diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000000..b26d4442ea1
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,19 @@
+# Top-most EditorConfig file
+root = true
+
+[*]
+# Unix-style newlines with a newline ending every file
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+
+# Four-space indentation
+indent_size = 4
+indent_style = space
+
+trim_trailing_whitespace = false
+
+[*.yml]
+# Two-space indentation
+indent_size = 2
+indent_style = space
diff --git a/.flake8 b/.flake8
new file mode 100644
index 00000000000..ec083d68034
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,5 @@
+[flake8]
+ignore = W293,E301,E271,E265,W291,E722,E302,C901,E225,E128,E122,E226,E231
+max-line-length = 160
+exclude = tests/*
+max-complexity = 10
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 00000000000..d5be139ad02
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,21 @@
+# When making commits that are strictly formatting/style changes, add the
+# commit hash here, so git blame can ignore the change. See docs for more
+# details:
+# https://git-scm.com/docs/git-config#Documentation/git-config.txt-blameignoreRevsFile
+#
+# 
+# You should be able to execute either
+# ./tools/configure-git-blame-ignore-revs.bat or
+# ./tools/configure-git-blame-ignore-revs.sh
+#
+# Example entries:
+#
+# <full commit hash>  # initial black-format 
+# <full commit hash>  # rename something internal
+6e748726282d1acb9a4f9f264ee679c474c4b8f5  # Apply pygrade --36plus on IPython/core/tests/test_inputtransformer.py.
+0233e65d8086d0ec34acb8685b7a5411633f0899 # apply pyupgrade to IPython/extensions/tests/test_autoreload.py
+a6a7e4dd7e51b892147895006d3a2a6c34b79ae6 # apply black to IPython/extensions/tests/test_autoreload.py
+c5ca5a8f25432dfd6b9eccbbe446a8348bf37cfa # apply pyupgrade to IPython/extensions/autoreload.py
+50624b84ccdece781750f5eb635a9efbf2fe30d6 # apply black to IPython/extensions/autoreload.py
+b7aaa47412b96379198705955004930c57f9d74a # apply pyupgrade to IPython/extensions/autoreload.py
+9c7476a88af3e567426b412f1b3c778401d8f6aa # apply black to IPython/extensions/autoreload.py
diff --git a/.gitattributes b/.gitattributes
index 8b5b26e3e96..56783b63081 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,2 +1,5 @@
 IPython/.git_commit_info.ini export-subst
 * text=auto
+*.py diff=python
+*.js diff=javascript
+*.html diff=html
diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
new file mode 100644
index 00000000000..2a6d4877c68
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE.md
@@ -0,0 +1,16 @@
+---
+name: Bug report / Question / Feature
+about: Anything related to IPython itsel
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!-- This is the repository for IPython command line, if you can try to make sure this question/bug/feature belong here and not on one of the Jupyter repositories. 
+
+If it's a generic Python/Jupyter question, try other forums or discourse.jupyter.org.
+
+If you are unsure, it's ok to post here, though, there are few maintainer so you might not get a fast response. 
+
+-->
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000000..d1fed9f3d5f
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,15 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    groups:
+      actions:
+        patterns:
+          - "*"
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 00000000000..a9ca3457f98
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,45 @@
+name: Build docs
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: 3.x
+        cache: pip
+        cache-dependency-path: |
+          docs/requirements.txt
+          pyproject.toml
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+    - name: Install Graphviz
+      run: |
+        sudo apt-get update
+        sudo apt-get install graphviz
+    - name: Install Python dependencies
+      run: |
+        uv pip install --system setuptools coverage rstvalidator
+        uv pip install --system -r docs/requirements.txt
+    - name: Build docs
+      run: |
+        python -m rstvalidator long_description.rst
+        python tools/fixup_whats_new_pr.py
+        make -C docs/ html SPHINXOPTS="-W" \
+          PYTHON="coverage run -a" \
+          SPHINXBUILD="coverage run -a -m sphinx.cmd.build"
+    - name: Generate coverage xml
+      run: |
+        coverage combine `find . -name .coverage\*` && coverage xml
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v5
+      with:
+        name: Docs
diff --git a/.github/workflows/downstream.yml b/.github/workflows/downstream.yml
new file mode 100644
index 00000000000..a8a03502917
--- /dev/null
+++ b/.github/workflows/downstream.yml
@@ -0,0 +1,99 @@
+name: Run Downstream tests
+
+on:
+  push:
+    paths-ignore:
+      - 'docs/**'
+      - '**.md'
+      - '**.rst'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**.md'
+      - '**.rst'
+  # Run weekly on Monday at 1:23 UTC
+  schedule:
+  - cron:  '23 1 * * 1'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    # Disable scheduled CI runs on forks
+    if: github.event_name != 'schedule' || github.repository_owner == 'ipython'
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ["3.13"]
+        include:
+          - os: macos-14
+            python-version: "3.13"
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Update Python installer
+      run: |
+        python -m pip install --upgrade pip setuptools wheel
+    - name: Install ipykernel
+      run: |
+        cd ..
+        git clone https://github.com/ipython/ipykernel
+        cd ipykernel
+        pip install -e .[test]
+        cd ..
+    - name: Install and update Python dependencies
+      run: |
+        python -m pip install --upgrade -e file://$PWD#egg=ipython[test]
+        # we must install IPython after ipykernel to get the right versions.
+        python -m pip install --upgrade --upgrade-strategy eager flaky ipyparallel
+    - name: pytest ipykernel
+      env:
+        COLUMNS: 120
+      run: |
+        cd ../ipykernel
+        pytest
+    - name: Install sagemath-repl
+      run: |
+        # Sept 2024, sage has been failing for a while, 
+        # Skipping.
+        # cd ..
+        # git clone --depth 1 https://github.com/sagemath/sage
+        # cd sage
+        # # We cloned it for the tests, but for simplicity we install the
+        # # wheels from PyPI.
+        # # (Avoid 10.3b6 because of https://github.com/sagemath/sage/pull/37178)
+        # pip install --pre sagemath-repl sagemath-environment
+        # # Install optionals that make more tests pass
+        # pip install pillow
+        # pip install --pre sagemath-categories
+        # cd ..
+    - name: Test sagemath-repl
+      run: |
+        # cd ../sage/
+        # # From https://github.com/sagemath/sage/blob/develop/pkgs/sagemath-repl/tox.ini
+        # sage-runtests -p --environment=sage.all__sagemath_repl --baseline-stats-path=pkgs/sagemath-repl/known-test-failures.json --initial --optional=sage src/sage/repl src/sage/doctest src/sage/misc/sage_input.py src/sage/misc/sage_eval.py
+    - name: Install pyflyby
+      run: |
+        cd ..
+        git clone https://github.com/deshaw/pyflyby
+        cd pyflyby
+        pip install meson-python meson ninja pybind11>=2.10.4 setuptools-scm
+        pip install setuptools wheel # needed for epydoc
+        pip install --no-build-isolation -ve .[test]
+        pip install 'pytest<=8'
+        cd ..
+    - name: Test pyflyby (IPython integration only)
+      run: |
+        cd ../pyflyby
+        pytest tests/test_interactive.py
diff --git a/.github/workflows/mypy.yml b/.github/workflows/mypy.yml
new file mode 100644
index 00000000000..ff7bc347974
--- /dev/null
+++ b/.github/workflows/mypy.yml
@@ -0,0 +1,40 @@
+name: Run MyPy
+
+on:
+  push:
+    branches: [ main, 7.x]
+  pull_request:
+    branches: [ main, 7.x]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.14"]
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: pip
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+    - name: Install dependencies
+      run: |
+        uv pip install --system mypy pyflakes flake8 types-decorator '.[all]'
+    - name: Lint with mypy
+      run: |
+        set -e
+        mypy IPython
+    - name: Lint with pyflakes
+      run: |
+        set -e
+        flake8  IPython/core/magics/script.py
+        flake8  IPython/core/magics/packaging.py
diff --git a/.github/workflows/nightly-wheel-build.yml b/.github/workflows/nightly-wheel-build.yml
new file mode 100644
index 00000000000..28e41ca2f9b
--- /dev/null
+++ b/.github/workflows/nightly-wheel-build.yml
@@ -0,0 +1,36 @@
+name: Nightly Wheel builder
+on:
+  workflow_dispatch:
+  schedule:
+    # this cron is ran every Sunday at midnight UTC
+    - cron: '0 0 * * 0'
+
+jobs:
+  upload_anaconda:
+    name: Upload to Anaconda
+    runs-on: ubuntu-latest
+    # The artifacts cannot be uploaded on PRs, also disable scheduled CI runs on forks
+    if: github.event_name != 'pull_request' && (github.event_name != 'schedule' || github.repository_owner == 'ipython')
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.14"
+          cache: pip
+          cache-dependency-path: |
+            pyproject.toml
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+      - name: Try building with Python build
+        if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
+        run: |
+          uv pip install --system build
+          python -m build
+
+      - name: Upload wheel
+        uses: scientific-python/upload-nightly-action@main
+        with:
+          artifacts_path: dist
+          anaconda_nightly_upload_token: ${{secrets.UPLOAD_TOKEN}}
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 00000000000..b8cd0ceafc5
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,79 @@
+name: Build and Publish IPython
+
+on:
+  push:
+    tags:
+      - '*'
+  workflow_dispatch:
+
+jobs:
+  build-and-publish:
+    name: Build and Publish to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/ipython
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.14"
+          cache: pip
+          cache-dependency-path: |
+            pyproject.toml
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build
+
+      - name: Build distribution
+        run: python -m build
+
+      - name: Verify built version matches tag
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          TAG_NAME=${GITHUB_REF#refs/tags/}
+          echo "Tag name: $TAG_NAME"
+
+          # Check dist folder filenames
+          echo "Built distribution files:"
+          ls -la dist/
+
+          # Install the built wheel
+          python -m pip install dist/*.whl
+
+          # Get IPython version
+          IPYTHON_VERSION=$(ipython --version)
+          echo "Installed IPython version: $IPYTHON_VERSION"
+
+          # Compare versions (allow only X.Y.Z)
+          if [[ "$TAG_NAME" != "$IPYTHON_VERSION" ]]; then
+            echo "Error: Tag ($TAG_NAME) does not match built IPython version ($IPYTHON_VERSION)"
+            exit 1
+          fi
+
+          echo "Version check passed! Tag matches built version."
+
+      - name: Publish distribution to PyPI
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: pypa/gh-action-pypi-publish@v1.13.0
+
+      - name: Send Zulip notification
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: zulip/github-actions-zulip/send-message@v1
+        with:
+          api-key: ${{ secrets.ZULIP_API_KEY }}
+          email: ${{ secrets.ZULIP_EMAIL }}
+          organization-url: ${{ vars.ZULIP_ORGANIZATION_URL }}
+          to: 'Releases'
+          type: 'stream'
+          topic: 'IPython'
+          content: |
+            IPython ${{ github.ref_name }} was just released on PyPI! 🎉
+            https://pypi.org/project/ipython/${{ github.ref_name }}/
diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
new file mode 100644
index 00000000000..9be2d870fb0
--- /dev/null
+++ b/.github/workflows/python-package.yml
@@ -0,0 +1,43 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Python package
+
+permissions:
+  contents: read
+
+on:
+  push:
+    branches: [ main, 7.x, 8.x ]
+  pull_request:
+    branches: [ main, 7.x, 8.x ]
+
+jobs:
+  formatting:
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+    - uses: actions/checkout@v6
+      with:
+        fetch-depth: 0
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: 3.x
+        cache: pip
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+    - name: Install dependencies
+      run: |
+        # when changing the versions please update CONTRIBUTING.md too
+        uv pip install --system darker==2.1.1 black==24.10.0
+    - name: Lint with darker
+      run: |
+        # disabling darker for now, I can't get it to format the same locally and on CI.
+        # darker -r 60625f241f298b5039cb2debc365db38aa7bb522 --check --diff . || (
+        # echo "Changes need auto-formatting. Run:"
+        # echo "    darker -r 60625f241f298b5039cb2debc365db38aa7bb522 ."
+        # echo "then commit and push changes to fix."
+        # exit 1
+        # )
diff --git a/.github/workflows/ruff.yml b/.github/workflows/ruff.yml
new file mode 100644
index 00000000000..efbc9dd7beb
--- /dev/null
+++ b/.github/workflows/ruff.yml
@@ -0,0 +1,35 @@
+name: Run Ruff
+
+on:
+  push:
+    branches: [ main, 7.x, 8.x]
+  pull_request:
+    branches: [ main, 7.x, 8.x]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.x"]
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: pip
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+    - name: Install dependencies
+      run: |
+        uv pip install --system ruff
+    - name: Lint with ruff
+      run: |
+        set -e
+        ruff check .
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 00000000000..6a3ef2f2e7a
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,143 @@
+name: Run tests
+
+on:
+  push:
+    branches:
+      - main
+      - '*.x'
+  pull_request:
+  # Run weekly on Monday at 1:23 UTC
+  schedule:
+  - cron:  '23 1 * * 1'
+  workflow_dispatch:
+
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+    # Disable scheduled CI runs on forks
+    if: github.event_name != 'schedule' || github.repository_owner == 'ipython'
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ["3.12", "3.13", "3.14"]
+        deps: [test_extra]
+        # Test all on ubuntu, test ends on macos
+        include:
+          - os: macos-latest
+            python-version: "3.12"
+            deps: test_extra
+          # free threaded, not with all dependencies
+          - os: ubuntu-latest
+            python-version: "3.14t"
+            deps: test
+          # Tests latest development Python version
+          - os: ubuntu-latest
+            python-version: "3.15-dev"
+            deps: test
+          - os: ubuntu-latest
+            python-version: "3.12"
+            deps: test_extra
+            want-latest-entry-point-code: true
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+        cache: pip
+        cache-dependency-path: |
+          pyproject.toml
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+    - name: Install latex
+      if: runner.os == 'Linux' && matrix.deps == 'test_extra'
+      run: echo "disable latex for now, issues in mirros" #sudo apt-get -yq -o Acquire::Retries=3 --no-install-suggests --no-install-recommends install texlive dvipng
+    - name: Install and update Python dependencies (binary only)
+      if: ${{ ! contains( matrix.python-version, 'dev' ) }}
+      run: |
+        uv pip install --system setuptools wheel build
+        uv pip install --system -e .[${{ matrix.deps }}]
+        uv pip install --system check-manifest pytest-cov pytest
+    - name: Install and update Python dependencies (dev?)
+      if: ${{ contains( matrix.python-version, 'dev' ) }}
+      run: |
+        uv pip install --system --prerelease=allow setuptools wheel build
+        uv pip install --system --prerelease=allow --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple -e .[${{ matrix.deps }}]
+        uv pip install --system --prerelease=allow --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple check-manifest pytest-cov
+    - name: Try building with Python build
+      if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
+      run: |
+        python -m build
+        shasum -a 256 dist/*
+    - name: Check manifest
+      if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
+      run: check-manifest
+
+    - name: Install entry point compatible code (TEMPORARY, April 2024)
+      if: matrix.want-latest-entry-point-code
+      run: |
+        uv pip list --system
+        # Not installing matplotlib's entry point code as building matplotlib from source is complex.
+        # Rely upon matplotlib to test all the latest entry point branches together.
+        uv pip install --system git+https://github.com/ipython/matplotlib-inline.git@main
+        uv pip list --system
+
+    - name: pytest
+      env:
+        COLUMNS: 120
+      run: |
+        pytest --color=yes -raXxs ${{ startsWith(matrix.python-version, 'pypy') && ' ' || '--cov --cov-report=xml' }} --maxfail=15
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v5
+      with:
+         token: ${{ secrets.CODECOV_TOKEN }}
+         name: Test
+         files: /home/runner/work/ipython/ipython/coverage.xml
+
+  oldest-deps:
+    # pro-actively check backward compatibility
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 15
+    # Disable scheduled CI runs on forks
+    if: github.event_name != 'schedule' || github.repository_owner == 'ipython'
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          # include windows because of platform-specific direct dependencies
+          - windows-latest
+
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up uv with Python 3.12
+      uses: astral-sh/setup-uv@v7
+      with:
+        python-version: '3.12'
+        enable-cache: true
+        activate-environment: true
+        prune-cache: false
+        cache-dependency-glob: |
+          pyproject.toml
+
+    - name: Install Python dependencies (oldest supported versions)
+      run: uv pip install --resolution=lowest-direct -e .[test]
+
+    - name: Try building with uv build
+      if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
+      run: |
+        uv build
+        shasum -a 256 dist/*
+
+    - name: Check manifest
+      if: runner.os != 'Windows'  # setup.py does not support sdist on Windows
+      run: uvx check-manifest
+
+    - name: pytest
+      env:
+        COLUMNS: 120
+      run: pytest --color=yes -raXxs
diff --git a/.github/workflows/zulip.yaml b/.github/workflows/zulip.yaml
new file mode 100644
index 00000000000..13097f5c2eb
--- /dev/null
+++ b/.github/workflows/zulip.yaml
@@ -0,0 +1,29 @@
+name: Post message to Zulip
+
+on:
+  workflow_dispatch:
+    inputs:
+      message:
+        description: 'Message to post to Zulip'
+        required: false
+        default: 'Test Auto release notification of IPython from GitHub action'
+        type: string
+
+jobs:
+  post-message:
+    name: Post Message to Zulip
+    runs-on: ubuntu-latest
+
+    steps:
+
+      - name: Send Zulip notification
+        uses: zulip/github-actions-zulip/send-message@v1
+        with:
+          api-key: ${{ secrets.ORG_ZULIP_API_KEY }}
+          email: ${{ secrets.ORG_ZULIP_EMAIL }}
+          organization-url: ${{ secrets.ORG_ZULIP_ORGANIZATION_URL }}
+          to: 'Releases'
+          type: 'stream'
+          topic: 'IPython'
+          content: |
+            ${{ inputs.message }}
diff --git a/.gitignore b/.gitignore
index 6221076cfb1..270eb98a3e7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,12 +1,41 @@
+MANIFEST
 build
-./dist
-docs/dist
-docs/build
-docs/_build
+dist
+_build
+docs/man/*.gz
 docs/source/api/generated
+docs/source/config/options
+docs/source/config/shortcuts/*.csv
+docs/source/config/shortcuts/table.tsv
+docs/source/savefig
+docs/source/interactive/magics-generated.txt
 docs/gh-pages
+jupyter_notebook/notebook/static/mathjax
+jupyter_notebook/static/style/*.map
 *.py[co]
-build
+__pycache__
 *.egg-info
 *~
 *.bak
+.ipynb_checkpoints
+.tox
+.DS_Store
+\#*#
+.#*
+.cache
+.coverage
+*.swp
+.pytest_cache
+.python-version
+.venv*/
+venv*/
+.mypy_cache/
+
+# jetbrains ide stuff
+*.iml
+.idea/
+
+# vscode ide stuff
+*.code-workspace
+.history
+.vscode
diff --git a/.mailmap b/.mailmap
new file mode 100644
index 00000000000..ab05ba24ba2
--- /dev/null
+++ b/.mailmap
@@ -0,0 +1,174 @@
+A. J. Holyoake <a.j.holyoake@gmail.com> ajholyoake <a.j.holyoake@gmail.com>
+Alok Singh <alokbeniwal@gmail.com> Alok Singh <8325708+alok@users.noreply.github.com>
+Aaron Culich <aculich@gmail.com> Aaron Culich <aculich@eecs.berkeley.edu>
+Aron Ahmadia <aron@ahmadia.net> ahmadia <aron@ahmadia.net>
+Arthur Svistunov <madbirddiary@gmail.com> <18216480+madbird1304@users.noreply.github.com>
+Arthur Svistunov <madbird1304@gmail.com> <18216480+madbird1304@users.noreply.github.com>
+Adam Hackbarth <fearchaos@gmail.com> <digitalvirtuoso@users.noreply.github.com>
+Benjamin Ragan-Kelley <benjaminrk@gmail.com> <minrk@Mercury.local>
+Benjamin Ragan-Kelley <benjaminrk@gmail.com> Min RK
+Benjamin Ragan-Kelley <benjaminrk@gmail.com> MinRK <benjaminrk@gmail.com>
+Barry Wark <barrywark@gmail.com> Barry Wark <barrywarkatgmaildotcom>
+Ben Edwards <bedwards@cs.unm.edu> Ben Edwards <bedwards@sausage.(none)>
+Bradley M. Froehle <brad.froehle@gmail.com> Bradley M. Froehle <bfroehle@math.berkeley.edu>
+Bradley M. Froehle <brad.froehle@gmail.com> Bradley Froehle <brad.froehle@gmail.com>
+Brandon Parsons <brandon@parsonstx.com> Brandon Parsons <brandon.parsons@hp.com>
+Brian E. Granger <ellisonbg@gmail.com> Brian Granger
+Brian E. Granger <ellisonbg@gmail.com> Brian Granger <>
+Brian E. Granger <ellisonbg@gmail.com> bgranger <>
+Brian E. Granger <ellisonbg@gmail.com> bgranger <bgranger@red>
+Blazej Michalik <code.mrmino@gmail.com> <6691643+MrMino@users.noreply.github.com>
+Blazej Michalik <code.mrmino@gmail.com> <blazej.michalik@nokia.com>
+Christoph Gohlke <cgohlke@uci.edu> cgohlke <cgohlke@uci.edu>
+Cyrille Rossant <cyrille.rossant@gmail.com> rossant <rossant@github>
+Damián Avila <damianavila82@yahoo.com.ar> damianavila <damianavila82@yahoo.com.ar>
+Damián Avila <damianavila82@yahoo.com.ar> damianavila <damianavila@gmail.com>
+Damon Allen <damontallen@gmail.com> damontallen <damontallen@gmail.com>
+Darren Dale <dsdale24@gmail.com> darren.dale <>
+Darren Dale <dsdale24@gmail.com> Darren Dale <>
+Dav Clark <davclark@berkeley.edu> Dav Clark <>
+Dav Clark <davclark@berkeley.edu> Dav Clark <davclark@gmail.com>
+David Hirschfeld <david.hirschfeld@gazprom-mt.com> dhirschfeld <david.hirschfeld@gazprom-mt.com>
+David P. Sanders <dpsanders@gmail.com> David P. Sanders <dpsanders@ciencias.unam.mx>
+David Warde-Farley <wardefar@iro.umontreal.ca> David Warde-Farley <>
+Dan Green-Leipciger <dangreen.tlv@gmail.com> <dangreen.tlv@gmail.com>
+Doug Blank <dblank@cs.brynmawr.edu> Doug Blank <doug.blank@gmail.com>
+Eugene Van den Bulke <eugene.van-den-bulke@gmail.com> Eugene Van den Bulke <eugene.vandenbulke@gmail.com> 
+Evan Patterson <epatters@enthought.com> <epatters@EPattersons-MacBook-Pro.local>
+Evan Patterson <epatters@enthought.com> <epatters@evan-laptop.localdomain>
+Evan Patterson <epatters@enthought.com> <epatters@caltech.edu>
+Evan Patterson <epatters@enthought.com> <ejpatters@gmail.com>
+Evan Patterson <epatters@enthought.com> epatters <ejpatters@gmail.com>
+Evan Patterson <epatters@enthought.com> epatters <epatters@enthought.com>
+Ernie French <ernestfrench@gmail.com> Ernie French <ernie@gqpbj.com>
+Ernie French <ernestfrench@gmail.com> ernie french <ernestfrench@gmail.com>
+Ernie French <ernestfrench@gmail.com> ernop <ernestfrench@gmail.com>
+Fernando Perez <Fernando.Perez@berkeley.edu> <fperez.net@gmail.com>
+Fernando Perez <Fernando.Perez@berkeley.edu> Fernando Perez <fernando.perez@berkeley.edu>
+Fernando Perez <Fernando.Perez@berkeley.edu> fperez <>
+Fernando Perez <Fernando.Perez@berkeley.edu> fptest <>
+Fernando Perez <Fernando.Perez@berkeley.edu> fptest1 <>
+Fernando Perez <Fernando.Perez@berkeley.edu> Fernando Perez <fernando.perez@berkeley.edu>
+Fernando Perez <fernando.perez@berkeley.edu> Fernando Perez <>
+Fernando Perez <fernando.perez@berkeley.edu> Fernando Perez <fperez@maqroll>
+Frank Murphy <fpmurphy@mtu.edu> Frank Murphy <fmurphy@arbor.net>
+Gabriel Becker <gmbecker@ucdavis.edu> gmbecker <gmbecker@ucdavis.edu>
+Gael Varoquaux <gael.varoquaux@normalesup.org> gael.varoquaux <>
+Gael Varoquaux <gael.varoquaux@normalesup.org> gvaroquaux <gvaroquaux@gvaroquaux-desktop>
+Gael Varoquaux <gael.varoquaux@normalesup.org> Gael Varoquaux <>
+Ingolf Becker <ingolf.becker@googlemail.com> watercrossing <ingolf.becker@googlemail.com>
+Jake Vanderplas <jakevdp@gmail.com> Jake Vanderplas <vanderplas@astro.washington.edu>
+Jakob Gager <jakob.gager@gmail.com> jakobgager <jakob.gager@gmail.com>
+Jakob Gager <jakob.gager@gmail.com> jakobgager <gager@ilsb.tuwien.ac.at>
+Jakob Gager <jakob.gager@gmail.com> jakobgager <jakobgager@hotmail.com>
+Jason Grout <jgrout6@bloomberg.net> <jason.grout@drake.edu>
+Jason Grout <jgrout6@bloomberg.net> <jason-github@creativetrax.com>
+Jason Gors <jason.gors.work@gmail.com> jason gors <jason.gors.work@gmail.com>
+Jason Gors <jason.gors.work@gmail.com> jgors <jason.gors.work@gmail.com>
+Jens Hedegaard Nielsen <jenshnielsen@gmail.com> Jens Hedegaard Nielsen <jhn@jhn-Znote.(none)>
+Jens Hedegaard Nielsen <jenshnielsen@gmail.com> Jens H Nielsen <jenshnielsen@gmail.com>
+Jens Hedegaard Nielsen <jenshnielsen@gmail.com> Jens H. Nielsen <jenshnielsen@gmail.com>
+Jez Ng <jezreel@gmail.com> Jez Ng <me@jezng.com>
+Jonathan Frederic <jdfreder@calpoly.edu> Jonathan Frederic <jonathan@LifebookMint.(none)>
+Jonathan Frederic <jdfreder@calpoly.edu> Jonathan Frederic <jon.freder@gmail.com>
+Jonathan Frederic <jdfreder@calpoly.edu> Jonathan Frederic <xh3xx.goose@gmail.com>
+Jonathan Frederic <jdfreder@calpoly.edu> jon <jon.freder@gmail.com>
+Jonathan Frederic <jdfreder@calpoly.edu> U-Jon-PC\Jon <Jon@Jon-PC.(none)>
+Jonathan March <jmarch@enthought.com> Jonathan March <JDM@MarchRay.net>
+Jean Cruypenynck <filaton@me.com> Jean Cruypenynck <jcruypenynck@flux.to>
+Jonathan March <jmarch@enthought.com> jdmarch <JDM@marchRay.net>
+Jörgen Stenarson <jorgen.stenarson@kroywen.se> Jörgen Stenarson <jorgen.stenarson@bostream.nu>
+Jörgen Stenarson <jorgen.stenarson@kroywen.se> Jorgen Stenarson <jorgen.stenarson@bostream.nu>
+Jörgen Stenarson <jorgen.stenarson@kroywen.se> Jorgen Stenarson <>
+Jörgen Stenarson <jorgen.stenarson@kroywen.se> jstenar <jorgen.stenarson@bostream.nu>
+Jörgen Stenarson <jorgen.stenarson@kroywen.se> jstenar <>
+Jörgen Stenarson <jorgen.stenarson@kroywen.se> Jörgen Stenarson <jorgen.stenarson@kroywen.se>
+Juergen Hasch <python@elbonia.de> juhasch <python@elbonia.de>
+Juergen Hasch <python@elbonia.de> juhasch <hasch@VMBOX.fritz.box>
+Julia Evans <julia@jvns.ca> Julia Evans <julia@stripe.com>
+Kester Tong <kestert@google.com> KesterTong <kestert@google.com>
+Kyle Kelley <rgbkrk@gmail.com> Kyle Kelley <kyle.kelley@rackspace.com>
+Kyle Kelley <rgbkrk@gmail.com> rgbkrk <rgbkrk@gmail.com>
+kd2718 <korydonati@gmail.com>
+Kory Donati <kd2718@outlook.com> kory donati <kd2718@outlook.com>
+Kory Donati <kd2718@outlook.com> Kory Donati <KoryDonati@clovisusd.k12.ca.us>
+Kory Donati <kd2718@outlook.com> koryd <korydonati@cusd.com>
+Laurent Dufréchou <laurent.dufrechou@gmail.com> <laurent.dufrechou@gmail.com>
+Laurent Dufréchou <laurent.dufrechou@gmail.com> <laurent@Pep>
+Laurent Dufréchou <laurent.dufrechou@gmail.com> laurent dufrechou <>
+Laurent Dufréchou <laurent.dufrechou@gmail.com> laurent.dufrechou <>
+Laurent Dufréchou <laurent.dufrechou@gmail.com> Laurent Dufrechou <>
+Laurent Dufréchou <laurent.dufrechou@gmail.com> laurent.dufrechou@gmail.com <>
+Laurent Dufréchou <laurent.dufrechou@gmail.com> ldufrechou <ldufrechou@PEP>
+Luciana da Costa Marques <lucianadacostamarques@gmail.com> luciana <lucianadacostamarques@gmail.com>
+Lorena Pantano <lorena.pantano@gmail.com> Lorena <lorena.pantano@gmail.com>
+Luis Pedro Coelho <luis@luispedro.org> Luis Pedro Coelho <lpc@cmu.edu>
+Marc Molla <marcmolla@gmail.com> marcmolla <marcmolla@gmail.com>
+Martín Gaitán <gaitan@gmail.com> Martín Gaitán <gaitan@phasety.com>
+Matthias Bussonnier <bussonniermatthias@gmail.com> Matthias BUSSONNIER <bussonniermatthias@gmail.com>
+Matthias Bussonnier <bussonniermatthias@gmail.com> Bussonnier Matthias <bussonniermatthias@gmail.com>
+Matthias Bussonnier <bussonniermatthias@gmail.com> Matthias BUSSONNIER <bussonniermatthias@umr168-curn-1-24x-6561.curie.fr>
+Matthias Bussonnier <bussonniermatthias@gmail.com> Matthias Bussonnier <carreau@Aspire.(none)>
+Matthias Bussonnier <bussonniermatthias@gmail.com> Matthias Bussonnier <mbussonnier@ucmerced.edu>
+Michael Droettboom <mdboom@gmail.com> Michael Droettboom <mdroe@stsci.edu>
+Nicholas Bollweg <nick.bollweg@gmail.com> Nicholas Bollweg (Nick) <nick.bollweg@gmail.com>
+Nicolas Rougier <Nicolas.Rougier@inria.fr> <Nicolas.rougier@inria.fr>
+Nikolay Koldunov <koldunovn@gmail.com> Nikolay Koldunov <nikolay.koldunov@zmaw.de>
+Omar Andrés Zapata Mesa <andresete.chaos@gmail.com> Omar Andres Zapata Mesa <andresete.chaos@gmail.com>
+Omar Andrés Zapata Mesa <andresete.chaos@gmail.com> Omar Andres Zapata Mesa <omazapa@tuxhome>
+Pankaj Pandey <pankaj86@gmail.com> Pankaj Pandey <pankaj@enthought.com>
+Pascal Schetelat <pascal.schetelat@gmail.com> pascal-schetelat <pascal.schetelat@gmail.com>
+Paul Ivanov <pi@berkeley.edu> Paul Ivanov <pivanov314@gmail.com>
+Paul Ivanov <pi@berkeley.edu> Paul Ivanov <pivanov5@bloomberg.net>
+Pauli Virtanen <pauli.virtanen@iki.fi> Pauli Virtanen <>
+Pauli Virtanen <pauli.virtanen@iki.fi> Pauli Virtanen <pav@iki.fi>
+Pierre Gerold <pierre.gerold@laposte.net> Pierre Gerold <gerold@crans.org>
+Pietro Berkes <pberkes@enthought.com> Pietro Berkes <pietro.berkes@googlemail.com>
+Piti Ongmongkolkul <piti118@gmail.com> piti118 <piti118@gmail.com>
+Prabhu Ramachandran <prabhu@enthought.com> Prabhu Ramachandran <>
+Puneeth Chaganti <punchagan@gmail.com> Puneeth Chaganti <punchagan@muse-amuse.in>
+Robert Kern <robert.kern@gmail.com> rkern <>
+Robert Kern <robert.kern@gmail.com> Robert Kern <rkern@enthought.com>
+Robert Kern <robert.kern@gmail.com> Robert Kern <rkern@Sacrilege.local>
+Robert Kern <robert.kern@gmail.com> Robert Kern <>
+Robert Marchman <bo.marchman@gmail.com> Robert Marchman <robert.l.marchman@dartmouth.edu>
+Satrajit Ghosh <satra@mit.edu> Satrajit Ghosh <satra@ba5.mit.edu>
+Satrajit Ghosh <satra@mit.edu> Satrajit Ghosh <satrajit.ghosh@gmail.com>
+Scott Sanderson <scoutoss@gmail.com> Scott Sanderson <ssanderson@quantopian.com>
+smithj1 <smithj1@LMC-022896.local> smithj1 <smithj1@LMC-022896.swisscom.com>
+smithj1 <smithj1@LMC-022896.local> smithj1 <smithj1@lmc-022896.local>
+Sang Min Park <sangmin.park@twosigma.com> Sang Min Park <sangmin.park@gmail.com>
+Steven Johnson <steven.johnson@drake.edu> stevenJohnson <steven.johnson@drake.edu>
+Steven Silvester <steven.silvester@ieee.org> blink1073 <steven.silvester@ieee.org>
+S. Weber <s8weber@c4.usr.sh> s8weber <s8weber@c5.usr.sh>
+Stefan van der Walt <stefan@sun.ac.za> Stefan van der Walt <bzr@mentat.za.net>
+Silvia Vinyes <silvia.vinyes@gmail.com> Silvia <silvia@silvia-U44SG.(none)>
+Silvia Vinyes <silvia.vinyes@gmail.com> silviav12 <silvia.vinyes@gmail.com>
+Srinivas Reddy Thatiparthy <thatiparthysreenivas@gmail.com> Srinivas Reddy Thatiparthy <srinivasreddy@users.noreply.github.com>
+Sylvain Corlay <scorlay@bloomberg.net> <sylvain.corlay@gmail.com>
+Sylvain Corlay <scorlay@bloomberg.net> sylvain.corlay <sylvain.corlay@gmail.com>
+Samuel Gaist <samuel.gaist@idiap.ch> <samuel.gaist@kde.org>
+Richard Shadrach <rhshadrach@gmail.com> <rhshadrach@gmail.com>
+Juan Luis Cano Rodríguez <juanlu@readthedocs.org> <hello@juanlu.space>
+Tamir Bahar <tamir@north-bit.com> Tamir Bahar <tmr232@users.noreply.github.com>
+Ted Drain <ted.drain@gmail.com> TD22057 <ted.drain@gmail.com>
+Théophile Studer <theo.studer@gmail.com> Théophile Studer <studer@users.noreply.github.com>
+Thomas A Caswell <tcaswell@gmail.com> Thomas A Caswell <tcaswell@bnl.gov> 
+Thomas Kluyver <thomas@kluyver.me.uk> Thomas <takowl@gmail.com>
+Thomas Kluyver <thomas@kluyver.me.uk> Thomas Kluyver <takowl@gmail.com>
+Thomas Spura <tomspur@fedoraproject.org> Thomas Spura <thomas.spura@gmail.com>
+Timo Paulssen <timonator@perpetuum-immobile.de> timo <timonator@perpetuum-immobile.de>
+vds <vds@VIVIAN> vds2212 <vds2212@VIVIAN>
+vds <vds@VIVIAN> vds <vds@vivian>
+Ville M. Vainio <vivainio@gmail.com> <vivainio2@WN-W0941>
+Ville M. Vainio <vivainio@gmail.com> ville <ville@VILLE-PC>
+Ville M. Vainio <vivainio@gmail.com> ville <ville@ville-desktop>
+Ville M. Vainio <vivainio@gmail.com> vivainio <>
+Ville M. Vainio <vivainio@gmail.com> Ville M. Vainio <vivainio@villev>
+Ville M. Vainio <vivainio@gmail.com> Ville M. Vainio <vivainio@ville_vmw>
+Walter Doerwald <walter@livinglogic.de> walter.doerwald <>
+Walter Doerwald <walter@livinglogic.de> Walter Doerwald <>
+Wieland Hoffmann <themineo@gmail.com> Wieland Hoffmann <mineo@users.noreply.github.com>
+W. Trevor King <wking@tremily.us> W. Trevor King <wking@drexel.edu>
+Yoval P. <yoval@gmx.com> y-p <yoval@gmx.com>
+
diff --git a/.meeseeksdev.yml b/.meeseeksdev.yml
new file mode 100644
index 00000000000..b52022dde07
--- /dev/null
+++ b/.meeseeksdev.yml
@@ -0,0 +1,22 @@
+users:
+    LucianaMarques:
+        can:
+            - tag
+special:
+  everyone:
+    can: 
+      - say
+      - tag
+      - untag
+      - close
+    config:
+      tag:
+        only:
+           - good first issue
+           - async/await
+           - backported
+           - help wanted
+           - documentation
+           - notebook
+           - tab-completion
+           - windows
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000000..61e986075d6
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,16 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+
+-   repo: https://github.com/akaihola/darker
+    rev: 1.7.2
+    hooks:
+    -   id: darker
+        additional_dependencies: [isort, mypy, flake8]
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 00000000000..4ab594e9d2a
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,18 @@
+version: 2
+
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.14"
+  apt_packages:
+    - graphviz
+
+sphinx:
+  configuration: docs/source/conf.py
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+   install:
+   - requirements: docs/requirements.txt
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000000..f51a821b07e
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,117 @@
+## Triaging Issues
+
+On the IPython repository,  we strive to trust users and give them responsibility.
+By using one of our bots, any user can close issues or add/remove
+labels by mentioning the bot and asking it to do things on your behalf.
+
+To close an issue (or PR), even if you did not create it, use the following:
+
+> @meeseeksdev close
+
+This command can be in the middle of another comment, but must start on its
+own line. 
+
+To add labels to an issue, ask the bot to `tag` with a comma-separated list of
+tags to add:
+
+> @meeseeksdev tag windows, documentation
+
+Only already pre-created tags can be added.  So far, the list is limited to:
+`async/await`, `backported`, `help wanted`, `documentation`, `notebook`,
+`tab-completion`, `windows`
+
+To remove a label, use the `untag` command:
+
+> @meeseeksdev untag windows, documentation
+
+We'll be adding additional capabilities for the bot and will share them here
+when they are ready to be used.
+
+## Opening an Issue
+
+When opening a new Issue, please take the following steps:
+
+1. Search GitHub and/or Google for your issue to avoid duplicate reports.
+   Keyword searches for your error messages are most helpful.
+2. If possible, try updating to main and reproducing your issue,
+   because we may have already fixed it.
+3. Try to include a minimal reproducible test case.
+4. Include relevant system information.  Start with the output of:
+
+        python -c "import IPython; print(IPython.sys_info())"
+
+   And include any relevant package versions, depending on the issue, such as
+   matplotlib, numpy, Qt, Qt bindings (PyQt/PySide), tornado, web browser, etc.
+
+## Pull Requests
+
+Some guidelines on contributing to IPython:
+
+* All work is submitted via Pull Requests.
+* Pull Requests can be submitted as soon as there is code worth discussing.
+  Pull Requests track the branch, so you can continue to work after the PR is submitted.
+  Review and discussion can begin well before the work is complete,
+  and the more discussion the better.
+  The worst case is that the PR is closed.
+* Pull Requests should generally be made against main
+* Pull Requests should be tested, if feasible:
+    - bugfixes should include regression tests.
+    - new behavior should at least get minimal exercise.
+* New features and backwards-incompatible changes should be documented by adding
+  a new file to the [pr](docs/source/whatsnew/pr) directory, see [the README.md
+  there](docs/source/whatsnew/pr/README.md) for details.
+* Don't make 'cleanup' pull requests just to change code style.
+  We don't follow any style guide strictly, and we consider formatting changes
+  unnecessary noise.
+  If you're making functional changes, you can clean up the specific pieces of
+  code you're working on.
+
+[GitHub Actions](https://github.com/ipython/ipython/actions/workflows/test.yml) does
+a pretty good job testing IPython and Pull Requests,
+but it may make sense to manually perform tests,
+particularly for PRs that affect `IPython.parallel` or Windows.
+
+For more detailed information, see our [GitHub Workflow](https://github.com/ipython/ipython/wiki/Dev:-GitHub-workflow).
+
+## Running Tests
+
+All the tests can be run by using
+```shell
+pytest
+```
+
+All the tests for a single module (for example **test_alias**) can be run by using the fully qualified path to the module.
+```shell
+pytest IPython/core/tests/test_alias.py
+```
+
+Only a single test (for example **test_alias_lifecycle**) within a single file can be run by adding the specific test after a `::` at the end:
+```shell
+pytest IPython/core/tests/test_alias.py::test_alias_lifecycle
+```
+
+## Code style
+
+* Before committing, run `darker -r 60625f241f298b5039cb2debc365db38aa7bb522 <file path>` to apply selective `black` formatting on modified regions using [darker](https://github.com/akaihola/darker)==1.5.1 and black==22.10.0
+* As described in the pull requests section, please avoid excessive formatting changes; if a formatting-only commit is necessary, consider adding its hash to [`.git-blame-ignore-revs`](https://github.com/ipython/ipython/blob/main/.git-blame-ignore-revs) file.
+
+## Documentation
+
+Sphinx documentation can be built locally using standard sphinx `make` commands. To build HTML documentation from the root of the project, execute:
+
+```shell
+pip install -r docs/requirements.txt   # only needed once
+make -C docs/ html SPHINXOPTS="-W"
+```
+
+To force update of the API documentation, precede the `make` command with:
+
+```shell
+python3 docs/autogen_api.py
+```
+
+Similarly, to force-update the configuration, run:
+
+```shell
+python3 docs/autogen_config.py
+```
diff --git a/COPYING.rst b/COPYING.rst
new file mode 100644
index 00000000000..e5c79ef38f0
--- /dev/null
+++ b/COPYING.rst
@@ -0,0 +1,41 @@
+=============================
+ The IPython licensing terms
+=============================
+
+IPython is licensed under the terms of the Modified BSD License (also known as
+New or Revised or 3-Clause BSD). See the LICENSE file.
+
+
+About the IPython Development Team
+----------------------------------
+
+Fernando Perez began IPython in 2001 based on code from Janko Hauser
+<jhauser@zscout.de> and Nathaniel Gray <n8gray@caltech.edu>.  Fernando is still
+the project lead.
+
+The IPython Development Team is the set of all contributors to the IPython
+project.  This includes all of the IPython subprojects. 
+
+The core team that coordinates development on GitHub can be found here:
+https://github.com/ipython/.
+
+Our Copyright Policy
+--------------------
+
+IPython uses a shared copyright model. Each contributor maintains copyright
+over their contributions to IPython. But, it is important to note that these
+contributions are typically only changes to the repositories. Thus, the IPython
+source code, in its entirety is not the copyright of any single person or
+institution.  Instead, it is the collective copyright of the entire IPython
+Development Team.  If individual contributors want to maintain a record of what
+changes/contributions they have specific copyright on, they should indicate
+their copyright in the commit message of the change, when they commit the
+change to one of the IPython repositories.
+
+With this in mind, the following banner should be used in any source code file 
+to indicate the copyright and license terms:
+
+::
+
+    # Copyright (c) IPython Development Team.
+    # Distributed under the terms of the Modified BSD License.
diff --git a/COPYING.txt b/COPYING.txt
deleted file mode 100644
index 64205fe4853..00000000000
--- a/COPYING.txt
+++ /dev/null
@@ -1,85 +0,0 @@
-=============================
- The IPython licensing terms
-=============================
-
-IPython is licensed under the terms of the Modified BSD License (also known as
-New or Revised BSD), as follows:
-
-Copyright (c) 2008-2010, IPython Development Team
-Copyright (c) 2001-2007, Fernando Perez. <fernando.perez@colorado.edu>
-Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
-Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.
-
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-Neither the name of the IPython Development Team nor the names of its
-contributors may be used to endorse or promote products derived from this
-software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-About the IPython Development Team
-----------------------------------
-
-Fernando Perez began IPython in 2001 based on code from Janko Hauser
-<jhauser@zscout.de> and Nathaniel Gray <n8gray@caltech.edu>.  Fernando is still
-the project lead.
-
-The IPython Development Team is the set of all contributors to the IPython
-project.  This includes all of the IPython subprojects. A full list with
-details is kept in the documentation directory, in the file
-``about/credits.txt``.
-
-The core team that coordinates development on GitHub can be found here:
-http://github.com/ipython.  As of late 2010, it consists of:
-
-* Brian E. Granger
-* Jonathan March
-* Evan Patterson
-* Fernando Perez
-* Min Ragan-Kelley
-* Robert Kern
-
-
-Our Copyright Policy
---------------------
-
-IPython uses a shared copyright model. Each contributor maintains copyright
-over their contributions to IPython. But, it is important to note that these
-contributions are typically only changes to the repositories. Thus, the IPython
-source code, in its entirety is not the copyright of any single person or
-institution.  Instead, it is the collective copyright of the entire IPython
-Development Team.  If individual contributors want to maintain a record of what
-changes/contributions they have specific copyright on, they should indicate
-their copyright in the commit message of the change, when they commit the
-change to one of the IPython repositories.
-
-With this in mind, the following banner should be used in any source code file
-to indicate the copyright and license terms:
-
-#-----------------------------------------------------------------------------
-# Copyright (c) 2010, IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
diff --git a/IPython/.git_commit_info.ini b/IPython/.git_commit_info.ini
deleted file mode 100644
index 19c2a55c94c..00000000000
--- a/IPython/.git_commit_info.ini
+++ /dev/null
@@ -1,9 +0,0 @@
-# This is an ini file that may contain information about the code state
-[commit hash]
-
-# The line below may contain a valid hash if it has been substituted during
-# 'git archive'
-archive_subst_hash=$Format:%h$
-
-# This line may be modified by the install process
-install_hash=
diff --git a/IPython/__init__.py b/IPython/__init__.py
index f49c9dd0760..d239b32280a 100644
--- a/IPython/__init__.py
+++ b/IPython/__init__.py
@@ -1,11 +1,11 @@
-# encoding: utf-8
+# PYTHON_ARGCOMPLETE_OK
 """
-IPython.
+IPython: tools for interactive and parallel computing in Python.
 
-IPython is a set of tools for interactive and exploratory computing in Python.
+https://ipython.org
 """
 #-----------------------------------------------------------------------------
-#  Copyright (c) 2008-2010, IPython Development Team.
+#  Copyright (c) 2008-2011, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <fernando.perez@colorado.edu>
 #  Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
 #  Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
@@ -18,41 +18,127 @@
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import absolute_import
 
-import os
 import sys
+import warnings
 
 #-----------------------------------------------------------------------------
 # Setup everything
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
-if sys.version[0:3] < '2.6':
-    raise ImportError('Python Version 2.6 or above is required for IPython.')
+if sys.version_info < (3, 12):
+    raise ImportError(
+        """
+IPython 9.x supports Python 3.12 and above, following SPEC0
+IPython 8.31+ supports Python 3.11 and above, following SPEC0
+IPython 8.19+ supports Python 3.10 and above, following SPEC0.
+IPython 8.13+ supports Python 3.9 and above, following NEP 29.
+When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
+Python 3.3 and 3.4 were supported up to IPython 6.x.
+Python 3.5 was supported with IPython 7.0 to 7.9.
+Python 3.6 was supported with IPython up to 7.16.
+Python 3.7 was still supported with the 7.x branch.
 
+See IPython `README.rst` file for more information:
 
-# Make it easy to import extensions - they are always directly on pythonpath.
-# Therefore, non-IPython modules can be added to extensions directory.
-# This should probably be in ipapp.py.
-sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
+    https://github.com/ipython/ipython/blob/main/README.rst
+
+"""
+    )
 
 #-----------------------------------------------------------------------------
 # Setup the top level names
 #-----------------------------------------------------------------------------
 
-from .config.loader import Config
+from .core.getipython import get_ipython
 from .core import release
 from .core.application import Application
-from .frontend.terminal.embed import embed
-from .core.error import TryNext
+from .terminal.embed import embed
+
 from .core.interactiveshell import InteractiveShell
-from .testing import test
 from .utils.sysinfo import sys_info
+from .utils.frame import extract_module_locals
+
+__all__ = ["start_ipython", "embed", "embed_kernel"]
 
 # Release data
-__author__ = ''
-for author, email in release.authors.itervalues():
-    __author__ += author + ' <' + email + '>\n'
+__author__ = '%s <%s>' % (release.author, release.author_email)
 __license__  = release.license
 __version__  = release.version
+version_info = release.version_info
+# list of CVEs that should have been patched in this release.
+# this is informational and should not be relied upon.
+__patched_cves__ = {"CVE-2022-21699", "CVE-2023-24816"}
+
+
+def embed_kernel(module=None, local_ns=None, **kwargs):
+    """Embed and start an IPython kernel in a given scope.
+
+    If you don't want the kernel to initialize the namespace
+    from the scope of the surrounding function,
+    and/or you want to load full IPython configuration,
+    you probably want `IPython.start_kernel()` instead.
+
+    This is a deprecated alias for `ipykernel.embed.embed_kernel()`,
+    to be removed in the future.
+    You should import directly from `ipykernel.embed`; this wrapper
+    fails anyway if you don't have `ipykernel` package installed.
+
+    Parameters
+    ----------
+    module : types.ModuleType, optional
+        The module to load into IPython globals (default: caller)
+    local_ns : dict, optional
+        The namespace to load into IPython user namespace (default: caller)
+    **kwargs : various, optional
+        Further keyword args are relayed to the IPKernelApp constructor,
+        such as `config`, a traitlets :class:`Config` object (see :ref:`configure_start_ipython`),
+        allowing configuration of the kernel.  Will only have an effect
+        on the first embed_kernel call for a given process.
+    """
+
+    warnings.warn(
+        "import embed_kernel from ipykernel.embed directly (since 2013)."
+        " Importing from IPython will be removed in the future",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+
+    (caller_module, caller_locals) = extract_module_locals(1)
+    if module is None:
+        module = caller_module
+    if local_ns is None:
+        local_ns = dict(**caller_locals)
+    
+    # Only import .zmq when we really need it
+    from ipykernel.embed import embed_kernel as real_embed_kernel
+    real_embed_kernel(module=module, local_ns=local_ns, **kwargs)
+
+def start_ipython(argv=None, **kwargs):
+    """Launch a normal IPython instance (as opposed to embedded)
+
+    `IPython.embed()` puts a shell in a particular calling scope,
+    such as a function or method for debugging purposes,
+    which is often not desirable.
+
+    `start_ipython()` does full, regular IPython initialization,
+    including loading startup files, configuration, etc.
+    much of which is skipped by `embed()`.
+
+    This is a public API method, and will survive implementation changes.
+
+    Parameters
+    ----------
+    argv : list or None, optional
+        If unspecified or None, IPython will parse command-line options from sys.argv.
+        To prevent any command-line parsing, pass an empty list: `argv=[]`.
+    user_ns : dict, optional
+        specify this dictionary to initialize the IPython user namespace with particular values.
+    **kwargs : various, optional
+        Any other kwargs will be passed to the Application constructor,
+        such as `config`, a traitlets :class:`Config` object (see :ref:`configure_start_ipython`),
+        allowing configuration of the instance (see :ref:`terminal_options`).
+    """
+    from IPython.terminal.ipapp import launch_new_instance
+    return launch_new_instance(argv=argv, **kwargs)
diff --git a/IPython/__main__.py b/IPython/__main__.py
new file mode 100644
index 00000000000..9eabd50e74a
--- /dev/null
+++ b/IPython/__main__.py
@@ -0,0 +1,14 @@
+# PYTHON_ARGCOMPLETE_OK
+# encoding: utf-8
+"""Terminal-based IPython entry point."""
+# -----------------------------------------------------------------------------
+#  Copyright (c) 2012, IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+from IPython import start_ipython
+
+start_ipython()
diff --git a/IPython/config/__init__.py b/IPython/config/__init__.py
deleted file mode 100644
index 876b4f330d0..00000000000
--- a/IPython/config/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/IPython/config/configurable.py b/IPython/config/configurable.py
deleted file mode 100755
index ed8fc2a921a..00000000000
--- a/IPython/config/configurable.py
+++ /dev/null
@@ -1,139 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A base class for objects that are configurable.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from copy import deepcopy
-import datetime
-from weakref import WeakValueDictionary
-
-from IPython.utils.importstring import import_item
-from loader import Config
-from IPython.utils.traitlets import HasTraits, Instance
-
-
-#-----------------------------------------------------------------------------
-# Helper classes for Configurables
-#-----------------------------------------------------------------------------
-
-
-class ConfigurableError(Exception):
-    pass
-
-
-#-----------------------------------------------------------------------------
-# Configurable implementation
-#-----------------------------------------------------------------------------
-
-
-class Configurable(HasTraits):
-
-    config = Instance(Config,(),{})
-    created = None
-
-    def __init__(self, **kwargs):
-        """Create a conigurable given a config config.
-
-        Parameters
-        ----------
-        config : Config
-            If this is empty, default values are used. If config is a 
-            :class:`Config` instance, it will be used to configure the
-            instance.
-        
-        Notes
-        -----
-        Subclasses of Configurable must call the :meth:`__init__` method of
-        :class:`Configurable` *before* doing anything else and using 
-        :func:`super`::
-        
-            class MyConfigurable(Configurable):
-                def __init__(self, config=None):
-                    super(MyConfigurable, self).__init__(config)
-                    # Then any other code you need to finish initialization.
-
-        This ensures that instances will be configured properly.
-        """
-        config = kwargs.pop('config', None)
-        if config is not None:
-            # We used to deepcopy, but for now we are trying to just save
-            # by reference.  This *could* have side effects as all components
-            # will share config. In fact, I did find such a side effect in
-            # _config_changed below. If a config attribute value was a mutable type
-            # all instances of a component were getting the same copy, effectively
-            # making that a class attribute.
-            # self.config = deepcopy(config)
-            self.config = config
-        # This should go second so individual keyword arguments override 
-        # the values in config.
-        super(Configurable, self).__init__(**kwargs)
-        self.created = datetime.datetime.now()
-
-    #-------------------------------------------------------------------------
-    # Static trait notifiations
-    #-------------------------------------------------------------------------
-
-    def _config_changed(self, name, old, new):
-        """Update all the class traits having ``config=True`` as metadata.
-
-        For any class trait with a ``config`` metadata attribute that is
-        ``True``, we update the trait with the value of the corresponding
-        config entry.
-        """
-        # Get all traits with a config metadata entry that is True
-        traits = self.traits(config=True)
-
-        # We auto-load config section for this class as well as any parent
-        # classes that are Configurable subclasses.  This starts with Configurable
-        # and works down the mro loading the config for each section.
-        section_names = [cls.__name__ for cls in \
-            reversed(self.__class__.__mro__) if 
-            issubclass(cls, Configurable) and issubclass(self.__class__, cls)]
-
-        for sname in section_names:
-            # Don't do a blind getattr as that would cause the config to 
-            # dynamically create the section with name self.__class__.__name__.
-            if new._has_section(sname):
-                my_config = new[sname]
-                for k, v in traits.iteritems():
-                    # Don't allow traitlets with config=True to start with
-                    # uppercase.  Otherwise, they are confused with Config
-                    # subsections.  But, developers shouldn't have uppercase
-                    # attributes anyways! (PEP 6)
-                    if k[0].upper()==k[0] and not k.startswith('_'):
-                        raise ConfigurableError('Configurable traitlets with '
-                        'config=True must start with a lowercase so they are '
-                        'not confused with Config subsections: %s.%s' % \
-                        (self.__class__.__name__, k))
-                    try:
-                        # Here we grab the value from the config
-                        # If k has the naming convention of a config
-                        # section, it will be auto created.
-                        config_value = my_config[k]
-                    except KeyError:
-                        pass
-                    else:
-                        # print "Setting %s.%s from %s.%s=%r" % \
-                        #     (self.__class__.__name__,k,sname,k,config_value)
-                        # We have to do a deepcopy here if we don't deepcopy the entire
-                        # config object. If we don't, a mutable config_value will be
-                        # shared by all instances, effectively making it a class attribute.
-                        setattr(self, k, deepcopy(config_value))
-
diff --git a/IPython/config/default/ipcluster_config.py b/IPython/config/default/ipcluster_config.py
deleted file mode 100644
index 5c2b43184ab..00000000000
--- a/IPython/config/default/ipcluster_config.py
+++ /dev/null
@@ -1,241 +0,0 @@
-import os
-
-c = get_config()
-
-#-----------------------------------------------------------------------------
-# Select which launchers to use
-#-----------------------------------------------------------------------------
-
-# This allows you to control what method is used to start the controller
-# and engines.  The following methods are currently supported:
-# - Start as a regular process on localhost.
-# - Start using mpiexec.
-# - Start using the Windows HPC Server 2008 scheduler
-# - Start using PBS/SGE
-# - Start using SSH
-
-
-# The selected launchers can be configured below.
-
-# Options are:
-# - LocalControllerLauncher
-# - MPIExecControllerLauncher
-# - PBSControllerLauncher
-# - SGEControllerLauncher
-# - WindowsHPCControllerLauncher
-# c.Global.controller_launcher = 'IPython.parallel.apps.launcher.LocalControllerLauncher'
-# c.Global.controller_launcher = 'IPython.parallel.apps.launcher.PBSControllerLauncher'
-
-# Options are:
-# - LocalEngineSetLauncher
-# - MPIExecEngineSetLauncher
-# - PBSEngineSetLauncher
-# - SGEEngineSetLauncher
-# - WindowsHPCEngineSetLauncher
-# c.Global.engine_launcher = 'IPython.parallel.apps.launcher.LocalEngineSetLauncher'
-
-#-----------------------------------------------------------------------------
-# Global configuration
-#-----------------------------------------------------------------------------
-
-# The default number of engines that will be started. This is overridden by
-# the -n command line option: "ipcluster start -n 4"
-# c.Global.n = 2
-
-# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
-# c.Global.log_to_file = False
-
-# Remove old logs from cluster_dir/log before starting.
-# c.Global.clean_logs = True
-
-# The working directory for the process. The application will use os.chdir
-# to change to this directory before starting.
-# c.Global.work_dir = os.getcwd()
-
-
-#-----------------------------------------------------------------------------
-# Local process launchers
-#-----------------------------------------------------------------------------
-
-# The command line arguments to call the controller with.
-# c.LocalControllerLauncher.controller_args = \
-#    ['--log-to-file','--log-level', '40']
-
-# The working directory for the controller
-# c.LocalEngineSetLauncher.work_dir = u''
-
-# Command line argument passed to the engines.
-# c.LocalEngineSetLauncher.engine_args = ['--log-to-file','--log-level', '40']
-
-#-----------------------------------------------------------------------------
-# MPIExec launchers
-#-----------------------------------------------------------------------------
-
-# The mpiexec/mpirun command to use in both the controller and engines.
-# c.MPIExecLauncher.mpi_cmd = ['mpiexec']
-
-# Additional arguments to pass to the actual mpiexec command.
-# c.MPIExecLauncher.mpi_args = []
-
-# The mpiexec/mpirun command and args can be overridden if they should be different
-# for controller and engines.
-# c.MPIExecControllerLauncher.mpi_cmd = ['mpiexec']
-# c.MPIExecControllerLauncher.mpi_args = []
-# c.MPIExecEngineSetLauncher.mpi_cmd = ['mpiexec']
-# c.MPIExecEngineSetLauncher.mpi_args = []
-
-# The command line argument to call the controller with.
-# c.MPIExecControllerLauncher.controller_args = \
-#     ['--log-to-file','--log-level', '40']
-
-# Command line argument passed to the engines.
-# c.MPIExecEngineSetLauncher.engine_args = ['--log-to-file','--log-level', '40']
-
-# The default number of engines to start if not given elsewhere.
-# c.MPIExecEngineSetLauncher.n = 1
-
-#-----------------------------------------------------------------------------
-# SSH launchers
-#-----------------------------------------------------------------------------
-
-# ipclusterz can be used to launch controller and engines remotely via ssh.
-# Note that currently ipclusterz does not do any file distribution, so if
-# machines are not on a shared filesystem, config and json files must be
-# distributed.  For this reason, the reuse_files defaults to True on an
-# ssh-launched Controller.  This flag can be overridded by the program_args
-# attribute of c.SSHControllerLauncher.
-
-# set the ssh cmd for launching remote commands. The default is ['ssh']
-# c.SSHLauncher.ssh_cmd = ['ssh']
-
-# set the ssh cmd for launching remote commands. The default is ['ssh']
-# c.SSHLauncher.ssh_args = ['tt']
-
-# Set the user and hostname for the controller
-# c.SSHControllerLauncher.hostname = 'controller.example.com'
-# c.SSHControllerLauncher.user = os.environ.get('USER','username')
-
-# Set the arguments to be passed to ipcontrollerz
-# note that remotely launched ipcontrollerz will not get the contents of 
-# the local ipcontrollerz_config.py unless it resides on the *remote host*
-# in the location specified by the --cluster_dir argument.
-# c.SSHControllerLauncher.program_args = ['-r', '-ip', '0.0.0.0', '--cluster_dir', '/path/to/cd']
-
-# Set the default args passed to ipenginez for SSH launched engines
-# c.SSHEngineSetLauncher.engine_args = ['--mpi', 'mpi4py']
-
-# SSH engines are launched as a dict of locations/n-engines.
-# if a value is a tuple instead of an int, it is assumed to be of the form
-# (n, [args]), setting the arguments to passed to ipenginez on `host`.
-# otherwise, c.SSHEngineSetLauncher.engine_args will be used as the default.
-
-# In this case, there will be 3 engines at my.example.com, and
-# 2 at you@ipython.scipy.org with a special json connector location.
-# c.SSHEngineSetLauncher.engines = {'my.example.com' : 3,
-#                                   'you@ipython.scipy.org' : (2, ['-f', '/path/to/ipcontroller-engine.json']}
-#                                  }
-
-#-----------------------------------------------------------------------------
-# Unix batch (PBS) schedulers launchers
-#-----------------------------------------------------------------------------
-
-# SGE and PBS are very similar. All configurables in this section called 'PBS*'
-# also exist as 'SGE*'.
-
-# The command line program to use to submit a PBS job.
-# c.PBSLauncher.submit_command = ['qsub']
-
-# The command line program to use to delete a PBS job.
-# c.PBSLauncher.delete_command = ['qdel']
-
-# The PBS queue in which the job should run
-# c.PBSLauncher.queue = 'myqueue'
-
-# A regular expression that takes the output of qsub and find the job id.
-# c.PBSLauncher.job_id_regexp = r'\d+'
-
-# If for some reason the Controller and Engines have different options above, they
-# can be set as c.PBSControllerLauncher.<option> etc.
-
-# PBS and SGE have default templates, but you can specify your own, either as strings
-# or from files, as described here:
-
-# The batch submission script used to start the controller. This is where
-# environment variables would be setup, etc. This string is interpreted using
-# the Itpl module in IPython.external. Basically, you can use ${n} for the
-# number of engine and ${cluster_dir} for the cluster_dir.
-# c.PBSControllerLauncher.batch_template = """
-# #PBS -N ipcontroller
-# #PBS -q $queue
-# 
-# ipcontrollerz --cluster-dir $cluster_dir
-# """
-
-# You can also load this template from a file
-# c.PBSControllerLauncher.batch_template_file = u"/path/to/my/template.sh"
-
-# The name of the instantiated batch script that will actually be used to
-# submit the job. This will be written to the cluster directory.
-# c.PBSControllerLauncher.batch_file_name = u'pbs_controller'
-
-# The batch submission script used to start the engines. This is where
-# environment variables would be setup, etc. This string is interpreted using
-# the Itpl module in IPython.external. Basically, you can use ${n} for the
-# number of engine and ${cluster_dir} for the cluster_dir.
-# c.PBSEngineSetLauncher.batch_template = """
-# #PBS -N ipcontroller
-# #PBS -l nprocs=$n
-# 
-# ipenginez --cluster-dir $cluster_dir$s
-# """
-
-# You can also load this template from a file
-# c.PBSControllerLauncher.batch_template_file = u"/path/to/my/template.sh"
-
-# The name of the instantiated batch script that will actually be used to
-# submit the job. This will be written to the cluster directory.
-# c.PBSEngineSetLauncher.batch_file_name = u'pbs_engines'
-
-
-
-#-----------------------------------------------------------------------------
-# Windows HPC Server 2008 launcher configuration
-#-----------------------------------------------------------------------------
-
-# c.IPControllerJob.job_name = 'IPController'
-# c.IPControllerJob.is_exclusive = False
-# c.IPControllerJob.username = r'USERDOMAIN\USERNAME'
-# c.IPControllerJob.priority = 'Highest'
-# c.IPControllerJob.requested_nodes = ''
-# c.IPControllerJob.project = 'MyProject'
-
-# c.IPControllerTask.task_name = 'IPController'
-# c.IPControllerTask.controller_cmd = [u'ipcontroller.exe']
-# c.IPControllerTask.controller_args = ['--log-to-file', '--log-level', '40']
-# c.IPControllerTask.environment_variables = {}
-
-# c.WindowsHPCControllerLauncher.scheduler = 'HEADNODE'
-# c.WindowsHPCControllerLauncher.job_file_name = u'ipcontroller_job.xml'
-
-
-# c.IPEngineSetJob.job_name = 'IPEngineSet'
-# c.IPEngineSetJob.is_exclusive = False
-# c.IPEngineSetJob.username = r'USERDOMAIN\USERNAME'
-# c.IPEngineSetJob.priority = 'Highest'
-# c.IPEngineSetJob.requested_nodes = ''
-# c.IPEngineSetJob.project = 'MyProject'
-
-# c.IPEngineTask.task_name = 'IPEngine'
-# c.IPEngineTask.engine_cmd = [u'ipengine.exe']
-# c.IPEngineTask.engine_args = ['--log-to-file', '--log-level', '40']
-# c.IPEngineTask.environment_variables = {}
-
-# c.WindowsHPCEngineSetLauncher.scheduler = 'HEADNODE'
-# c.WindowsHPCEngineSetLauncher.job_file_name = u'ipengineset_job.xml'
-
-
-
-
-
-
-
diff --git a/IPython/config/default/ipcontroller_config.py b/IPython/config/default/ipcontroller_config.py
deleted file mode 100644
index 347c922c8cd..00000000000
--- a/IPython/config/default/ipcontroller_config.py
+++ /dev/null
@@ -1,180 +0,0 @@
-from IPython.config.loader import Config
-
-c = get_config()
-
-#-----------------------------------------------------------------------------
-# Global configuration
-#-----------------------------------------------------------------------------
-
-# Basic Global config attributes
-
-# Start up messages are logged to stdout using the logging module.
-# These all happen before the twisted reactor is started and are
-# useful for debugging purposes. Can be (10=DEBUG,20=INFO,30=WARN,40=CRITICAL) 
-# and smaller is more verbose.
-# c.Global.log_level = 20
-
-# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
-# c.Global.log_to_file = False
-
-# Remove old logs from cluster_dir/log before starting.
-# c.Global.clean_logs = True
-
-# A list of Python statements that will be run before starting the 
-# controller. This is provided because occasionally certain things need to 
-# be imported in the controller for pickling to work.
-# c.Global.import_statements = ['import math']
-
-# Reuse the controller's JSON files. If False, JSON files are regenerated
-# each time the controller is run. If True, they will be reused, *but*, you
-# also must set the network ports by hand. If set, this will override the
-# values set for the client and engine connections below.
-# c.Global.reuse_files = True
-
-# Enable exec_key authentication on all messages. Default is True
-# c.Global.secure = True
-
-# The working directory for the process. The application will use os.chdir
-# to change to this directory before starting.
-# c.Global.work_dir = os.getcwd()
-
-# The log url for logging to an `iploggerz` application.  This will override
-# log-to-file.
-# c.Global.log_url = 'tcp://127.0.0.1:20202'
-
-# The specific external IP that is used to disambiguate multi-interface URLs.
-# The default behavior is to guess from external IPs gleaned from `socket`.
-# c.Global.location = '192.168.1.123'
-
-# The ssh server remote clients should use to connect to this controller.
-# It must be a machine that can see the interface specified in client_ip.
-# The default for client_ip is localhost, in which case the sshserver must
-# be an external IP of the controller machine.
-# c.Global.sshserver = 'controller.example.com'
-
-# the url to use for registration.  If set, this overrides engine-ip,
-# engine-transport client-ip,client-transport, and regport.
-# c.RegistrationFactory.url = 'tcp://*:12345'
-
-# the port to use for registration.  Clients and Engines both use this
-# port for registration.
-# c.RegistrationFactory.regport = 10101
-
-#-----------------------------------------------------------------------------
-# Configure the Task Scheduler
-#-----------------------------------------------------------------------------
-
-# The routing scheme. 'pure' will use the pure-ZMQ scheduler. Any other 
-# value will use a Python scheduler with various routing schemes.
-# python schemes are: lru, weighted, random, twobin. Default is 'weighted'.
-# Note that the pure ZMQ scheduler does not support many features, such as
-# dying engines, dependencies, or engine-subset load-balancing.
-# c.ControllerFactory.scheme = 'pure'
-
-# The Python scheduler can limit the number of outstanding tasks per engine
-# by using an HWM option.  This allows engines with long-running tasks
-# to not steal too many tasks from other engines. The default is 0, which
-# means agressively distribute messages, never waiting for them to finish.
-# c.TaskScheduler.hwm = 0
-
-# Whether to use Threads or Processes to start the Schedulers.  Threads will
-# use less resources, but potentially reduce throughput. Default is to 
-# use processes.  Note that the a Python scheduler will always be in a Process.
-# c.ControllerFactory.usethreads
-
-#-----------------------------------------------------------------------------
-# Configure the Hub
-#-----------------------------------------------------------------------------
-
-# Which class to use for the db backend.  Currently supported are DictDB (the
-# default), and MongoDB. Uncomment this line to enable MongoDB, which will
-# slow-down the Hub's responsiveness, but also reduce its memory footprint.
-# c.HubFactory.db_class = 'IPython.parallel.controller.mongodb.MongoDB'
-
-# The heartbeat ping frequency.  This is the frequency (in ms) at which the
-# Hub pings engines for heartbeats.  This determines how quickly the Hub
-# will react to engines coming and going.  A lower number means faster response
-# time, but more network activity.  The default is 100ms
-# c.HubFactory.ping = 100
-
-# HubFactory queue port pairs, to set by name: mux, iopub, control, task.  Set
-# each as a tuple of length 2 of ints.  The default is to find random
-# available ports
-# c.HubFactory.mux = (10102,10112)
-
-#-----------------------------------------------------------------------------
-# Configure the client connections
-#-----------------------------------------------------------------------------
-
-# Basic client connection config attributes
-
-# The network interface the controller will listen on for client connections.
-# This should be an IP address or interface on the controller. An asterisk
-# means listen on all interfaces. The transport can be any transport
-# supported by zeromq (tcp,epgm,pgm,ib,ipc):
-# c.HubFactory.client_ip = '*'
-# c.HubFactory.client_transport = 'tcp'
-
-# individual client ports to configure by name: query_port, notifier_port
-# c.HubFactory.query_port = 12345
-
-#-----------------------------------------------------------------------------
-# Configure the engine connections
-#-----------------------------------------------------------------------------
-
-# Basic config attributes for the engine connections.
-
-# The network interface the controller will listen on for engine connections.
-# This should be an IP address or interface on the controller. An asterisk
-# means listen on all interfaces. The transport can be any transport
-# supported by zeromq (tcp,epgm,pgm,ib,ipc):
-# c.HubFactory.engine_ip = '*'
-# c.HubFactory.engine_transport = 'tcp'
-
-# set the engine heartbeat ports to use:
-# c.HubFactory.hb = (10303,10313)
-
-#-----------------------------------------------------------------------------
-# Configure the TaskRecord database backend
-#-----------------------------------------------------------------------------
-
-# For memory/persistance reasons, tasks can be stored out-of-memory in a database.
-# Currently, only sqlite and mongodb are supported as backends, but the interface
-# is fairly simple, so advanced developers could write their own backend.
-
-# ----- in-memory configuration --------
-# this line restores the default behavior: in-memory storage of all results.
-# c.HubFactory.db_class = 'IPython.parallel.controller.dictdb.DictDB'
-
-# ----- sqlite configuration --------
-# use this line to activate sqlite:
-# c.HubFactory.db_class = 'IPython.parallel.controller.sqlitedb.SQLiteDB'
-
-# You can specify the name of the db-file.  By default, this will be located
-# in the active cluster_dir, e.g. ~/.ipython/clusterz_default/tasks.db
-# c.SQLiteDB.filename = 'tasks.db'
-
-# You can also specify the location of the db-file, if you want it to be somewhere
-# other than the cluster_dir.
-# c.SQLiteDB.location = '/scratch/'
-
-# This will specify the name of the table for the controller to use.  The default
-# behavior is to use the session ID of the SessionFactory object (a uuid). Overriding
-# this will result in results persisting for multiple sessions.
-# c.SQLiteDB.table = 'results'
-
-# ----- mongodb configuration --------
-# use this line to activate mongodb:
-# c.HubFactory.db_class = 'IPython.parallel.controller.mongodb.MongoDB'
-
-# You can specify the args and kwargs pymongo will use when creating the Connection.
-# For more information on what these options might be, see pymongo documentation.
-# c.MongoDB.connection_kwargs = {}
-# c.MongoDB.connection_args = []
-
-# This will specify the name of the mongo database for the controller to use.  The default
-# behavior is to use the session ID of the SessionFactory object (a uuid). Overriding
-# this will result in task results persisting through multiple sessions.
-# c.MongoDB.database = 'ipythondb'
-
-
diff --git a/IPython/config/default/ipengine_config.py b/IPython/config/default/ipengine_config.py
deleted file mode 100644
index 402f7fd1603..00000000000
--- a/IPython/config/default/ipengine_config.py
+++ /dev/null
@@ -1,85 +0,0 @@
-c = get_config()
-
-#-----------------------------------------------------------------------------
-# Global configuration
-#-----------------------------------------------------------------------------
-
-# Start up messages are logged to stdout using the logging module.
-# These all happen before the twisted reactor is started and are
-# useful for debugging purposes. Can be (10=DEBUG,20=INFO,30=WARN,40=CRITICAL) 
-# and smaller is more verbose.
-# c.Global.log_level = 20
-
-# Log to a file in cluster_dir/log, otherwise just log to sys.stdout.
-# c.Global.log_to_file = False
-
-# Remove old logs from cluster_dir/log before starting.
-# c.Global.clean_logs = True
-
-# A list of strings that will be executed in the users namespace on the engine
-# before it connects to the controller.
-# c.Global.exec_lines = ['import numpy']
-
-# The engine will try to connect to the controller multiple times, to allow
-# the controller time to startup and write its FURL file. These parameters 
-# control the number of retries (connect_max_tries) and the initial delay
-# (connect_delay) between attemps. The actual delay between attempts gets
-# longer each time by a factor of 1.5 (delay[i] = 1.5*delay[i-1])
-# those attemps.
-# c.Global.connect_delay = 0.1
-# c.Global.connect_max_tries = 15
-
-# By default, the engine will look for the controller's JSON file in its own
-# cluster directory. Sometimes, the JSON file will be elsewhere and this 
-# attribute can be set to the full path of the JSON file.
-# c.Global.url_file = u'/path/to/my/ipcontroller-engine.json'
-
-# The working directory for the process. The application will use os.chdir
-# to change to this directory before starting.
-# c.Global.work_dir = os.getcwd()
-
-#-----------------------------------------------------------------------------
-# MPI configuration
-#-----------------------------------------------------------------------------
-
-# Upon starting the engine can be configured to call MPI_Init. This section
-# configures that.
-
-# Select which MPI section to execute to setup MPI. The value of this 
-# attribute must match the name of another attribute in the MPI config 
-# section (mpi4py, pytrilinos, etc.). This can also be set by the --mpi
-# command line option.
-# c.MPI.use = ''
-
-# Initialize MPI using mpi4py. To use this, set c.MPI.use = 'mpi4py' to use
-# --mpi=mpi4py at the command line.
-# c.MPI.mpi4py = """from mpi4py import MPI as mpi
-# mpi.size = mpi.COMM_WORLD.Get_size()
-# mpi.rank = mpi.COMM_WORLD.Get_rank()
-# """
-
-# Initialize MPI using pytrilinos. To use this, set c.MPI.use = 'pytrilinos' 
-# to use --mpi=pytrilinos at the command line.
-# c.MPI.pytrilinos = """from PyTrilinos import Epetra
-# class SimpleStruct:
-# pass
-# mpi = SimpleStruct()
-# mpi.rank = 0
-# mpi.size = 0
-# """
-
-#-----------------------------------------------------------------------------
-# Developer level configuration attributes
-#-----------------------------------------------------------------------------
-
-# You shouldn't have to modify anything in this section. These attributes
-# are more for developers who want to change the behavior of the controller
-# at a fundamental level.
-
-# You should not have to change these attributes.
-
-# c.Global.url_file_name = u'ipcontroller-engine.furl'
-
-
-
-
diff --git a/IPython/config/default/ipython_config.py b/IPython/config/default/ipython_config.py
deleted file mode 100644
index e4130fe6f87..00000000000
--- a/IPython/config/default/ipython_config.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# Get the config being loaded so we can set attributes on it
-c = get_config()
-
-#-----------------------------------------------------------------------------
-# Global options
-#-----------------------------------------------------------------------------
-
-# c.Global.display_banner = True
-
-# c.Global.classic = False
-
-# c.Global.nosep = True
-
-# Set this to determine the detail of what is logged at startup.
-# The default is 30 and possible values are 0,10,20,30,40,50.
-# c.Global.log_level = 20
-
-# This should be a list of importable Python modules that have an
-# load_ipython_extension(ip) method.  This method gets called when the extension
-# is loaded.  You can put your extensions anywhere they can be imported
-# but we add the extensions subdir of the ipython directory to sys.path
-# during extension loading, so you can put them there as well.
-# c.Global.extensions = [
-#     'myextension'
-# ]
-
-# These lines are run in IPython in the user's namespace after extensions 
-# are loaded.  They can contain full IPython syntax with magics etc.
-# c.Global.exec_lines = [
-#     'import numpy',
-#     'a = 10; b = 20',
-#     '1/0'
-# ]
-
-# These files are run in IPython in the user's namespace.  Files with a .py
-# extension need to be pure Python.  Files with a .ipy extension can have
-# custom IPython syntax (like magics, etc.).  
-# These files need to be in the cwd, the ipython_dir or be absolute paths.
-# c.Global.exec_files = [
-#     'mycode.py',
-#     'fancy.ipy'
-# ]
-
-#-----------------------------------------------------------------------------
-# InteractiveShell options
-#-----------------------------------------------------------------------------
-
-# c.InteractiveShell.autocall = 1
-
-# c.TerminalInteractiveShell.autoedit_syntax = False
-
-# c.InteractiveShell.autoindent = True
-
-# c.InteractiveShell.automagic = False
-
-# c.TerminalTerminalInteractiveShell.banner1 = 'This if for overriding the default IPython banner'
- 
-# c.TerminalTerminalInteractiveShell.banner2 = "This is for extra banner text"
-
-# c.InteractiveShell.cache_size = 1000
-
-# c.InteractiveShell.colors = 'LightBG'
-
-# c.InteractiveShell.color_info = True
-
-# c.TerminalInteractiveShell.confirm_exit = True
-
-# c.InteractiveShell.deep_reload = False
-
-# c.TerminalInteractiveShell.editor = 'nano'
-
-# c.InteractiveShell.logstart = True
-
-# c.InteractiveShell.logfile = u'ipython_log.py'
-
-# c.InteractiveShell.logappend = u'mylog.py'
-
-# c.InteractiveShell.object_info_string_level = 0
-
-# c.TerminalInteractiveShell.pager = 'less'
-
-# c.InteractiveShell.pdb = False
-
-# c.InteractiveShell.prompt_in1 = 'In [\#]: '
-# c.InteractiveShell.prompt_in2 = '   .\D.: '
-# c.InteractiveShell.prompt_out = 'Out[\#]: '
-# c.InteractiveShell.prompts_pad_left = True
-
-# c.InteractiveShell.quiet = False
-
-# c.InteractiveShell.history_length = 10000
-
-# Readline 
-# c.InteractiveShell.readline_use = True
-
-# c.InteractiveShell.readline_parse_and_bind = [
-#     'tab: complete',
-#     '"\C-l": possible-completions',
-#     'set show-all-if-ambiguous on',
-#     '"\C-o": tab-insert',
-#     '"\M-i": "    "',
-#     '"\M-o": "\d\d\d\d"',
-#     '"\M-I": "\d\d\d\d"',
-#     '"\C-r": reverse-search-history',
-#     '"\C-s": forward-search-history',
-#     '"\C-p": history-search-backward',
-#     '"\C-n": history-search-forward',
-#     '"\e[A": history-search-backward',
-#     '"\e[B": history-search-forward',
-#     '"\C-k": kill-line',
-#     '"\C-u": unix-line-discard',
-# ]
-# c.InteractiveShell.readline_remove_delims = '-/~'
-# c.InteractiveShell.readline_merge_completions = True
-# c.InteractiveShell.readline_omit__names = 0
-
-# c.TerminalInteractiveShell.screen_length = 0
-
-# c.InteractiveShell.separate_in = '\n'
-# c.InteractiveShell.separate_out = ''
-# c.InteractiveShell.separate_out2 = ''
-
-# c.TerminalInteractiveShell.term_title = False
-
-# c.InteractiveShell.wildcards_case_sensitive = True
-
-# c.InteractiveShell.xmode = 'Context'
-
-#-----------------------------------------------------------------------------
-# Formatter and display options
-#-----------------------------------------------------------------------------
-
-# c.PlainTextFormatter.pprint = True
-
-#-----------------------------------------------------------------------------
-# PrefilterManager options
-#-----------------------------------------------------------------------------
-
-# c.PrefilterManager.multi_line_specials = True
-
-#-----------------------------------------------------------------------------
-# AliasManager options
-#-----------------------------------------------------------------------------
-
-# Do this to disable all defaults
-# c.AliasManager.default_aliases = []
-
-# c.AliasManager.user_aliases = [
-#     ('foo', 'echo Hi')
-# ]
-
-#-----------------------------------------------------------------------------
-# HistoryManager options
-#-----------------------------------------------------------------------------
-
-# Enable logging output as well as input to the database.
-# c.HistoryManager.db_log_output = False
-
-# Only write to the database every n commands - this can save disk
-# access (and hence power) over the default of writing on every command.
-# c.HistoryManager.db_cache_size = 0
diff --git a/IPython/config/loader.py b/IPython/config/loader.py
deleted file mode 100644
index 056ae6169b3..00000000000
--- a/IPython/config/loader.py
+++ /dev/null
@@ -1,389 +0,0 @@
-# -*- coding: utf-8 -*-
-# coding: utf-8
-"""A simple configuration system.
-
-Authors
--------
-* Brian Granger
-* Fernando Perez
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import __builtin__
-import os
-import sys
-
-from IPython.external import argparse
-from IPython.utils.path import filefind
-
-#-----------------------------------------------------------------------------
-# Exceptions
-#-----------------------------------------------------------------------------
-
-
-class ConfigError(Exception):
-    pass
-
-
-class ConfigLoaderError(ConfigError):
-    pass
-
-#-----------------------------------------------------------------------------
-# Argparse fix
-#-----------------------------------------------------------------------------
-
-# Unfortunately argparse by default prints help messages to stderr instead of
-# stdout.  This makes it annoying to capture long help screens at the command
-# line, since one must know how to pipe stderr, which many users don't know how
-# to do.  So we override the print_help method with one that defaults to
-# stdout and use our class instead.
-
-class ArgumentParser(argparse.ArgumentParser):
-    """Simple argparse subclass that prints help to stdout by default."""
-    
-    def print_help(self, file=None):
-        if file is None:
-            file = sys.stdout
-        return super(ArgumentParser, self).print_help(file)
-    
-    print_help.__doc__ = argparse.ArgumentParser.print_help.__doc__
-    
-#-----------------------------------------------------------------------------
-# Config class for holding config information
-#-----------------------------------------------------------------------------
-
-
-class Config(dict):
-    """An attribute based dict that can do smart merges."""
-
-    def __init__(self, *args, **kwds):
-        dict.__init__(self, *args, **kwds)
-        # This sets self.__dict__ = self, but it has to be done this way
-        # because we are also overriding __setattr__.
-        dict.__setattr__(self, '__dict__', self)
-
-    def _merge(self, other):
-        to_update = {}
-        for k, v in other.iteritems():
-            if not self.has_key(k):
-                to_update[k] = v
-            else: # I have this key
-                if isinstance(v, Config):
-                    # Recursively merge common sub Configs
-                    self[k]._merge(v)
-                else:
-                    # Plain updates for non-Configs
-                    to_update[k] = v
-
-        self.update(to_update)
-
-    def _is_section_key(self, key):
-        if key[0].upper()==key[0] and not key.startswith('_'):
-            return True
-        else:
-            return False
-
-    def __contains__(self, key):
-        if self._is_section_key(key):
-            return True
-        else:
-            return super(Config, self).__contains__(key)
-    # .has_key is deprecated for dictionaries.
-    has_key = __contains__
-
-    def _has_section(self, key):
-        if self._is_section_key(key):
-            if super(Config, self).__contains__(key):
-                return True
-        return False
-
-    def copy(self):
-        return type(self)(dict.copy(self))
-
-    def __copy__(self):
-        return self.copy()
-
-    def __deepcopy__(self, memo):
-        import copy
-        return type(self)(copy.deepcopy(self.items()))
-
-    def __getitem__(self, key):
-        # We cannot use directly self._is_section_key, because it triggers
-        # infinite recursion on top of PyPy. Instead, we manually fish the
-        # bound method.
-        is_section_key = self.__class__._is_section_key.__get__(self)
-        
-        # Because we use this for an exec namespace, we need to delegate
-        # the lookup of names in __builtin__ to itself.  This means
-        # that you can't have section or attribute names that are 
-        # builtins.
-        try:
-            return getattr(__builtin__, key)
-        except AttributeError:
-            pass
-        if is_section_key(key):
-            try:
-                return dict.__getitem__(self, key)
-            except KeyError:
-                c = Config()
-                dict.__setitem__(self, key, c)
-                return c
-        else:
-            return dict.__getitem__(self, key)
-
-    def __setitem__(self, key, value):
-        # Don't allow names in __builtin__ to be modified.
-        if hasattr(__builtin__, key):
-            raise ConfigError('Config variable names cannot have the same name '
-                              'as a Python builtin: %s' % key)
-        if self._is_section_key(key):
-            if not isinstance(value, Config):
-                raise ValueError('values whose keys begin with an uppercase '
-                                 'char must be Config instances: %r, %r' % (key, value))
-        else:
-            dict.__setitem__(self, key, value)
-
-    def __getattr__(self, key):
-        try:
-            return self.__getitem__(key)
-        except KeyError, e:
-            raise AttributeError(e)
-
-    def __setattr__(self, key, value):
-        try:
-            self.__setitem__(key, value)
-        except KeyError, e:
-            raise AttributeError(e)
-
-    def __delattr__(self, key):
-        try:
-            dict.__delitem__(self, key)
-        except KeyError, e:
-            raise AttributeError(e)
-
-
-#-----------------------------------------------------------------------------
-# Config loading classes
-#-----------------------------------------------------------------------------
-
-
-class ConfigLoader(object):
-    """A object for loading configurations from just about anywhere.
-    
-    The resulting configuration is packaged as a :class:`Struct`.
-    
-    Notes
-    -----
-    A :class:`ConfigLoader` does one thing: load a config from a source 
-    (file, command line arguments) and returns the data as a :class:`Struct`.
-    There are lots of things that :class:`ConfigLoader` does not do.  It does
-    not implement complex logic for finding config files.  It does not handle
-    default values or merge multiple configs.  These things need to be 
-    handled elsewhere.
-    """
-
-    def __init__(self):
-        """A base class for config loaders.
-        
-        Examples
-        --------
-        
-        >>> cl = ConfigLoader()
-        >>> config = cl.load_config()
-        >>> config
-        {}
-        """
-        self.clear()
-
-    def clear(self):
-        self.config = Config()
-
-    def load_config(self):
-        """Load a config from somewhere, return a :class:`Config` instance.
-        
-        Usually, this will cause self.config to be set and then returned.
-        However, in most cases, :meth:`ConfigLoader.clear` should be called
-        to erase any previous state.
-        """
-        self.clear()
-        return self.config
-
-
-class FileConfigLoader(ConfigLoader):
-    """A base class for file based configurations.
-
-    As we add more file based config loaders, the common logic should go
-    here.
-    """
-    pass
-
-
-class PyFileConfigLoader(FileConfigLoader):
-    """A config loader for pure python files.
-    
-    This calls execfile on a plain python file and looks for attributes
-    that are all caps.  These attribute are added to the config Struct.
-    """
-
-    def __init__(self, filename, path=None):
-        """Build a config loader for a filename and path.
-
-        Parameters
-        ----------
-        filename : str
-            The file name of the config file.
-        path : str, list, tuple
-            The path to search for the config file on, or a sequence of
-            paths to try in order.
-        """
-        super(PyFileConfigLoader, self).__init__()
-        self.filename = filename
-        self.path = path
-        self.full_filename = ''
-        self.data = None
-
-    def load_config(self):
-        """Load the config from a file and return it as a Struct."""
-        self.clear()
-        self._find_file()
-        self._read_file_as_dict()
-        self._convert_to_config()
-        return self.config
-
-    def _find_file(self):
-        """Try to find the file by searching the paths."""
-        self.full_filename = filefind(self.filename, self.path)
-
-    def _read_file_as_dict(self):
-        """Load the config file into self.config, with recursive loading."""
-        # This closure is made available in the namespace that is used
-        # to exec the config file.  This allows users to call
-        # load_subconfig('myconfig.py') to load config files recursively.
-        # It needs to be a closure because it has references to self.path
-        # and self.config.  The sub-config is loaded with the same path
-        # as the parent, but it uses an empty config which is then merged
-        # with the parents.
-        def load_subconfig(fname):
-            loader = PyFileConfigLoader(fname, self.path)
-            try:
-                sub_config = loader.load_config()
-            except IOError:
-                # Pass silently if the sub config is not there. This happens
-                # when a user us using a profile, but not the default config.
-                pass
-            else:
-                self.config._merge(sub_config)
-
-        # Again, this needs to be a closure and should be used in config
-        # files to get the config being loaded.
-        def get_config():
-            return self.config
-
-        namespace = dict(load_subconfig=load_subconfig, get_config=get_config)
-        fs_encoding = sys.getfilesystemencoding() or 'ascii'
-        conf_filename = self.full_filename.encode(fs_encoding)
-        execfile(conf_filename, namespace)
-
-    def _convert_to_config(self):
-        if self.data is None:
-            ConfigLoaderError('self.data does not exist')
-
-
-class CommandLineConfigLoader(ConfigLoader):
-    """A config loader for command line arguments.
-
-    As we add more command line based loaders, the common logic should go
-    here.
-    """
-
-
-class ArgParseConfigLoader(CommandLineConfigLoader):
-
-    def __init__(self, argv=None, *parser_args, **parser_kw):
-        """Create a config loader for use with argparse.
-
-        Parameters
-        ----------
-
-        argv : optional, list
-          If given, used to read command-line arguments from, otherwise
-          sys.argv[1:] is used.
-
-        parser_args : tuple
-          A tuple of positional arguments that will be passed to the
-          constructor of :class:`argparse.ArgumentParser`.
-
-        parser_kw : dict
-          A tuple of keyword arguments that will be passed to the
-          constructor of :class:`argparse.ArgumentParser`.
-        """
-        super(CommandLineConfigLoader, self).__init__()
-        if argv == None:
-            argv = sys.argv[1:]
-        self.argv = argv
-        self.parser_args = parser_args
-        self.version = parser_kw.pop("version", None)
-        kwargs = dict(argument_default=argparse.SUPPRESS)
-        kwargs.update(parser_kw)
-        self.parser_kw = kwargs
-
-    def load_config(self, args=None):
-        """Parse command line arguments and return as a Struct.
-
-        Parameters
-        ----------
-
-        args : optional, list
-          If given, a list with the structure of sys.argv[1:] to parse
-          arguments from. If not given, the instance's self.argv attribute
-          (given at construction time) is used."""
-        self.clear()
-        if args is None:
-            args = self.argv
-        self._create_parser()
-        self._parse_args(args)
-        self._convert_to_config()
-        return self.config
-
-    def get_extra_args(self):
-        if hasattr(self, 'extra_args'):
-            return self.extra_args
-        else:
-            return []
-
-    def _create_parser(self):
-        self.parser = ArgumentParser(*self.parser_args, **self.parser_kw)
-        self._add_arguments()
-
-    def _add_arguments(self):
-        raise NotImplementedError("subclasses must implement _add_arguments")
-
-    def _parse_args(self, args):
-        """self.parser->self.parsed_data"""
-        # decode sys.argv to support unicode command-line options
-        uargs = []
-        for a in args:
-            if isinstance(a, str):
-                # don't decode if we already got unicode
-                a = a.decode(sys.stdin.encoding or 
-                                            sys.getdefaultencoding())
-            uargs.append(a)
-        self.parsed_data, self.extra_args = self.parser.parse_known_args(uargs)
-
-    def _convert_to_config(self):
-        """self.parsed_data->self.config"""
-        for k, v in vars(self.parsed_data).iteritems():
-            exec_str = 'self.config.' + k + '= v'
-            exec exec_str in locals(), globals()
-
-
diff --git a/IPython/config/profile/ipython_config_cluster.py b/IPython/config/profile/ipython_config_cluster.py
deleted file mode 100644
index fd795a46b1b..00000000000
--- a/IPython/config/profile/ipython_config_cluster.py
+++ /dev/null
@@ -1,24 +0,0 @@
-c = get_config()
-
-# This can be used at any point in a config file to load a sub config
-# and merge it into the current one.
-load_subconfig('ipython_config.py')
-
-lines = """
-from IPython.kernel.client import *
-"""
-
-# You have to make sure that attributes that are containers already
-# exist before using them.  Simple assigning a new list will override
-# all previous values.
-if hasattr(c.Global, 'exec_lines'):
-    c.Global.exec_lines.append(lines)
-else:
-    c.Global.exec_lines = [lines]
-
-# Load the parallelmagic extension to enable %result, %px, %autopx magics.
-if hasattr(c.Global, 'extensions'):
-    c.Global.extensions.append('parallelmagic')
-else:
-    c.Global.extensions = ['parallelmagic']
-
diff --git a/IPython/config/profile/ipython_config_math.py b/IPython/config/profile/ipython_config_math.py
deleted file mode 100644
index 49a0933a525..00000000000
--- a/IPython/config/profile/ipython_config_math.py
+++ /dev/null
@@ -1,19 +0,0 @@
-c = get_config()
-
-# This can be used at any point in a config file to load a sub config
-# and merge it into the current one.
-load_subconfig('ipython_config.py')
-
-lines = """
-import cmath
-from math import *
-"""
-
-# You have to make sure that attributes that are containers already
-# exist before using them.  Simple assigning a new list will override
-# all previous values.
-if hasattr(c.Global, 'exec_lines'):
-    c.Global.exec_lines.append(lines)
-else:
-    c.Global.exec_lines = [lines]
-
diff --git a/IPython/config/profile/ipython_config_numeric.py b/IPython/config/profile/ipython_config_numeric.py
deleted file mode 100644
index 9f7afa80ecb..00000000000
--- a/IPython/config/profile/ipython_config_numeric.py
+++ /dev/null
@@ -1,20 +0,0 @@
-c = get_config()
-
-# This can be used at any point in a config file to load a sub config
-# and merge it into the current one.
-load_subconfig('ipython_config.py')
-
-lines = """
-import numpy
-import scipy
-import numpy as np
-import scipy as sp
-"""
-
-# You have to make sure that attributes that are containers already
-# exist before using them.  Simple assigning a new list will override
-# all previous values.
-if hasattr(c.Global, 'exec_lines'):
-    c.Global.exec_lines.append(lines)
-else:
-    c.Global.exec_lines = [lines]
\ No newline at end of file
diff --git a/IPython/config/profile/ipython_config_pylab.py b/IPython/config/profile/ipython_config_pylab.py
deleted file mode 100644
index 9885ac74974..00000000000
--- a/IPython/config/profile/ipython_config_pylab.py
+++ /dev/null
@@ -1,22 +0,0 @@
-c = get_config()
-
-# This can be used at any point in a config file to load a sub config
-# and merge it into the current one.
-load_subconfig('ipython_config.py')
-
-lines = """
-import matplotlib
-%gui -a wx
-matplotlib.use('wxagg')
-matplotlib.interactive(True)
-from matplotlib import pyplot as plt
-from matplotlib.pyplot import *
-"""
-
-# You have to make sure that attributes that are containers already
-# exist before using them.  Simple assigning a new list will override
-# all previous values.
-if hasattr(c.Global, 'exec_lines'):
-    c.Global.exec_lines.append(lines)
-else:
-    c.Global.exec_lines = [lines]
\ No newline at end of file
diff --git a/IPython/config/profile/ipython_config_pysh.py b/IPython/config/profile/ipython_config_pysh.py
deleted file mode 100644
index ba20354c368..00000000000
--- a/IPython/config/profile/ipython_config_pysh.py
+++ /dev/null
@@ -1,29 +0,0 @@
-c = get_config()
-
-# This can be used at any point in a config file to load a sub config
-# and merge it into the current one.
-load_subconfig('ipython_config.py')
-
-c.InteractiveShell.prompt_in1 = '\C_LightGreen\u@\h\C_LightBlue[\C_LightCyan\Y1\C_LightBlue]\C_Green|\#> '
-c.InteractiveShell.prompt_in2 = '\C_Green|\C_LightGreen\D\C_Green> '
-c.InteractiveShell.prompt_out = '<\#> '
-
-c.InteractiveShell.prompts_pad_left = True
-
-c.InteractiveShell.separate_in = ''
-c.InteractiveShell.separate_out = ''
-c.InteractiveShell.separate_out2 = ''
-
-c.PrefilterManager.multi_line_specials = True
-
-lines = """
-%rehashx
-"""
-
-# You have to make sure that attributes that are containers already
-# exist before using them.  Simple assigning a new list will override
-# all previous values.
-if hasattr(c.Global, 'exec_lines'):
-    c.Global.exec_lines.append(lines)
-else:
-    c.Global.exec_lines = [lines]
\ No newline at end of file
diff --git a/IPython/config/profile/ipython_config_sympy.py b/IPython/config/profile/ipython_config_sympy.py
deleted file mode 100644
index e01308ffebf..00000000000
--- a/IPython/config/profile/ipython_config_sympy.py
+++ /dev/null
@@ -1,29 +0,0 @@
-c = get_config()
-
-# This can be used at any point in a config file to load a sub config
-# and merge it into the current one.
-load_subconfig('ipython_config.py')
-
-lines = """
-from __future__ import division
-from sympy import *
-x, y, z = symbols('xyz')
-k, m, n = symbols('kmn', integer=True)
-f, g, h = map(Function, 'fgh')
-"""
-
-# You have to make sure that attributes that are containers already
-# exist before using them.  Simple assigning a new list will override
-# all previous values.
-
-if hasattr(c.Global, 'exec_lines'):
-    c.Global.exec_lines.append(lines)
-else:
-    c.Global.exec_lines = [lines]
-
-# Load the sympy_printing extension to enable nice printing of sympy expr's.
-if hasattr(c.Global, 'extensions'):
-    c.Global.extensions.append('sympy_printing')
-else:
-    c.Global.extensions = ['sympy_printing']
-
diff --git a/IPython/config/tests/test_configurable.py b/IPython/config/tests/test_configurable.py
deleted file mode 100644
index d57c36d995b..00000000000
--- a/IPython/config/tests/test_configurable.py
+++ /dev/null
@@ -1,124 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Tests for IPython.config.configurable
-
-Authors:
-
-* Brian Granger
-* Fernando Perez (design help)
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from unittest import TestCase
-
-from IPython.config.configurable import Configurable, ConfigurableError
-from IPython.utils.traitlets import (
-    TraitError, Int, Float, Str
-)
-from IPython.config.loader import Config
-
-
-#-----------------------------------------------------------------------------
-# Test cases
-#-----------------------------------------------------------------------------
-
-
-class MyConfigurable(Configurable):
-    a = Int(1, config=True)
-    b = Float(1.0, config=True)
-    c = Str('no config')
-
-
-class Foo(Configurable):
-    a = Int(0, config=True)
-    b = Str('nope', config=True)
-
-
-class Bar(Foo):
-    b = Str('gotit', config=False)
-    c = Float(config=True)
-
-
-class TestConfigurableConfig(TestCase):
-
-    def test_default(self):
-        c1 = Configurable()
-        c2 = Configurable(config=c1.config)
-        c3 = Configurable(config=c2.config)
-        self.assertEquals(c1.config, c2.config)
-        self.assertEquals(c2.config, c3.config)
-
-    def test_custom(self):
-        config = Config()
-        config.foo = 'foo'
-        config.bar = 'bar'
-        c1 = Configurable(config=config)
-        c2 = Configurable(config=c1.config)
-        c3 = Configurable(config=c2.config)
-        self.assertEquals(c1.config, config)
-        self.assertEquals(c2.config, config)
-        self.assertEquals(c3.config, config)
-        # Test that copies are not made
-        self.assert_(c1.config is config)
-        self.assert_(c2.config is config)
-        self.assert_(c3.config is config)
-        self.assert_(c1.config is c2.config)
-        self.assert_(c2.config is c3.config)
-        
-    def test_inheritance(self):
-        config = Config()
-        config.MyConfigurable.a = 2
-        config.MyConfigurable.b = 2.0
-        c1 = MyConfigurable(config=config)
-        c2 = MyConfigurable(config=c1.config)
-        self.assertEquals(c1.a, config.MyConfigurable.a)
-        self.assertEquals(c1.b, config.MyConfigurable.b)
-        self.assertEquals(c2.a, config.MyConfigurable.a)
-        self.assertEquals(c2.b, config.MyConfigurable.b)
-
-    def test_parent(self):
-        config = Config()
-        config.Foo.a = 10
-        config.Foo.b = "wow"
-        config.Bar.b = 'later'
-        config.Bar.c = 100.0
-        f = Foo(config=config)
-        b = Bar(config=f.config)
-        self.assertEquals(f.a, 10)
-        self.assertEquals(f.b, 'wow')
-        self.assertEquals(b.b, 'gotit')
-        self.assertEquals(b.c, 100.0)
-
-    def test_override1(self):
-        config = Config()
-        config.MyConfigurable.a = 2
-        config.MyConfigurable.b = 2.0
-        c = MyConfigurable(a=3, config=config)
-        self.assertEquals(c.a, 3)
-        self.assertEquals(c.b, config.MyConfigurable.b)
-        self.assertEquals(c.c, 'no config')
-
-    def test_override2(self):
-        config = Config()
-        config.Foo.a = 1
-        config.Bar.b = 'or'  # Up above b is config=False, so this won't do it.
-        config.Bar.c = 10.0
-        c = Bar(config=config)
-        self.assertEquals(c.a, config.Foo.a)
-        self.assertEquals(c.b, 'gotit')
-        self.assertEquals(c.c, config.Bar.c)
-        c = Bar(a=2, b='and', c=20.0, config=config)
-        self.assertEquals(c.a, 2)
-        self.assertEquals(c.b, 'and')
-        self.assertEquals(c.c, 20.0)
diff --git a/IPython/config/tests/test_loader.py b/IPython/config/tests/test_loader.py
deleted file mode 100755
index 390f1b4ae01..00000000000
--- a/IPython/config/tests/test_loader.py
+++ /dev/null
@@ -1,174 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Tests for IPython.config.loader
-
-Authors:
-
-* Brian Granger
-* Fernando Perez (design help)
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-from tempfile import mkstemp
-from unittest import TestCase
-
-from IPython.config.loader import (
-    Config,
-    PyFileConfigLoader, 
-    ArgParseConfigLoader,
-    ConfigError
-)
-
-#-----------------------------------------------------------------------------
-# Actual tests
-#-----------------------------------------------------------------------------
-
-
-pyfile = """
-c = get_config()
-c.a = 10
-c.b = 20
-c.Foo.Bar.value = 10
-c.Foo.Bam.value = range(10)
-c.D.C.value = 'hi there'
-"""
-
-class TestPyFileCL(TestCase):
-
-    def test_basic(self):
-        fd, fname = mkstemp('.py')
-        f = os.fdopen(fd, 'w')
-        f.write(pyfile)
-        f.close()
-        # Unlink the file
-        cl = PyFileConfigLoader(fname)
-        config = cl.load_config()
-        self.assertEquals(config.a, 10)
-        self.assertEquals(config.b, 20)
-        self.assertEquals(config.Foo.Bar.value, 10)
-        self.assertEquals(config.Foo.Bam.value, range(10))
-        self.assertEquals(config.D.C.value, 'hi there')
-
-class MyLoader1(ArgParseConfigLoader):
-    def _add_arguments(self):
-        p = self.parser
-        p.add_argument('-f', '--foo', dest='Global.foo', type=str)
-        p.add_argument('-b', dest='MyClass.bar', type=int)
-        p.add_argument('-n', dest='n', action='store_true')
-        p.add_argument('Global.bam', type=str)
-
-class MyLoader2(ArgParseConfigLoader):
-    def _add_arguments(self):
-        subparsers = self.parser.add_subparsers(dest='subparser_name')
-        subparser1 = subparsers.add_parser('1')
-        subparser1.add_argument('-x',dest='Global.x')
-        subparser2 = subparsers.add_parser('2')
-        subparser2.add_argument('y')
-
-class TestArgParseCL(TestCase):
-
-    def test_basic(self):
-        cl = MyLoader1()
-        config = cl.load_config('-f hi -b 10 -n wow'.split())
-        self.assertEquals(config.Global.foo, 'hi')
-        self.assertEquals(config.MyClass.bar, 10)
-        self.assertEquals(config.n, True)
-        self.assertEquals(config.Global.bam, 'wow')
-        config = cl.load_config(['wow'])
-        self.assertEquals(config.keys(), ['Global'])
-        self.assertEquals(config.Global.keys(), ['bam'])
-        self.assertEquals(config.Global.bam, 'wow')
-
-    def test_add_arguments(self):
-        cl = MyLoader2()
-        config = cl.load_config('2 frobble'.split())
-        self.assertEquals(config.subparser_name, '2')
-        self.assertEquals(config.y, 'frobble')
-        config = cl.load_config('1 -x frobble'.split())
-        self.assertEquals(config.subparser_name, '1')
-        self.assertEquals(config.Global.x, 'frobble')
-
-    def test_argv(self):
-        cl = MyLoader1(argv='-f hi -b 10 -n wow'.split())
-        config = cl.load_config()
-        self.assertEquals(config.Global.foo, 'hi')
-        self.assertEquals(config.MyClass.bar, 10)
-        self.assertEquals(config.n, True)
-        self.assertEquals(config.Global.bam, 'wow')
-
-
-class TestConfig(TestCase):
-
-    def test_setget(self):
-        c = Config()
-        c.a = 10
-        self.assertEquals(c.a, 10)
-        self.assertEquals(c.has_key('b'), False)
-
-    def test_auto_section(self):
-        c = Config()
-        self.assertEquals(c.has_key('A'), True)
-        self.assertEquals(c._has_section('A'), False)
-        A = c.A
-        A.foo = 'hi there'
-        self.assertEquals(c._has_section('A'), True)
-        self.assertEquals(c.A.foo, 'hi there')
-        del c.A
-        self.assertEquals(len(c.A.keys()),0)
-
-    def test_merge_doesnt_exist(self):
-        c1 = Config()
-        c2 = Config()
-        c2.bar = 10
-        c2.Foo.bar = 10
-        c1._merge(c2)
-        self.assertEquals(c1.Foo.bar, 10)
-        self.assertEquals(c1.bar, 10)
-        c2.Bar.bar = 10
-        c1._merge(c2)
-        self.assertEquals(c1.Bar.bar, 10)
-
-    def test_merge_exists(self):
-        c1 = Config()
-        c2 = Config()
-        c1.Foo.bar = 10
-        c1.Foo.bam = 30
-        c2.Foo.bar = 20
-        c2.Foo.wow = 40
-        c1._merge(c2)
-        self.assertEquals(c1.Foo.bam, 30)
-        self.assertEquals(c1.Foo.bar, 20)
-        self.assertEquals(c1.Foo.wow, 40)
-        c2.Foo.Bam.bam = 10
-        c1._merge(c2)
-        self.assertEquals(c1.Foo.Bam.bam, 10)
-
-    def test_deepcopy(self):
-        c1 = Config()
-        c1.Foo.bar = 10
-        c1.Foo.bam = 30
-        c1.a = 'asdf'
-        c1.b = range(10)
-        import copy
-        c2 = copy.deepcopy(c1)
-        self.assertEquals(c1, c2)
-        self.assert_(c1 is not c2)
-        self.assert_(c1.Foo is not c2.Foo)
-
-    def test_builtin(self):
-        c1 = Config()
-        exec 'foo = True' in c1
-        self.assertEquals(c1.foo, True)
-        self.assertRaises(ConfigError, setattr, c1, 'ValueError', 10)
diff --git a/IPython/core/alias.py b/IPython/core/alias.py
old mode 100755
new mode 100644
index 264c3b2ac71..1c4c88b1639
--- a/IPython/core/alias.py
+++ b/IPython/core/alias.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """
 System command aliases.
@@ -10,7 +9,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.
 #
@@ -21,27 +20,27 @@
 # Imports
 #-----------------------------------------------------------------------------
 
-import __builtin__
-import keyword
 import os
 import re
 import sys
 
-from IPython.config.configurable import Configurable
-from IPython.core.splitinput import split_user_input
+from traitlets.config.configurable import Configurable
+from .error import UsageError
+
+from traitlets import List, Instance
+from logging import error
+
+import typing as t
 
-from IPython.utils.traitlets import List, Instance
-from IPython.utils.autoattr import auto_attr
-from IPython.utils.warn import warn, error
 
 #-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
 
 # This is used as the pattern for calls to split_user_input.
-shell_line_split = re.compile(r'^(\s*)(\S*\s*)(.*$)')
+shell_line_split = re.compile(r'^(\s*)()(\S+)(.*$)')
 
-def default_aliases():
+def default_aliases() -> t.List[t.Tuple[str, str]]:
     """Return list of shell aliases to auto-define.
     """
     # Note: the aliases defined here should be safe to use on a kernel
@@ -50,10 +49,10 @@ def default_aliases():
     # their case.  For example, things like 'less' or 'clear' that manipulate
     # the terminal should NOT be declared here, as they will only work if the
     # kernel is running inside a true terminal, and not over the network.
-    
+
     if os.name == 'posix':
         default_aliases = [('mkdir', 'mkdir'), ('rmdir', 'rmdir'),
-                           ('mv', 'mv -i'), ('rm', 'rm -i'), ('cp', 'cp -i'),
+                           ('mv', 'mv'), ('rm', 'rm'), ('cp', 'cp'),
                            ('cat', 'cat'),
                            ]
         # Useful set of ls aliases.  The GNU and BSD options are a little
@@ -72,8 +71,9 @@ def default_aliases():
                           # things which are executable
                           ('lx', 'ls -F -o --color %l | grep ^-..x'),
                           ]
-        else:
-            # BSD, OSX, etc.
+        elif sys.platform.startswith('openbsd') or sys.platform.startswith('netbsd'):
+            # OpenBSD, NetBSD. The ls implementation on these platforms do not support
+            # the -G switch and lack the ability to use colorized output.
             ls_aliases = [('ls', 'ls -F'),
                           # long ls
                           ('ll', 'ls -F -l'),
@@ -86,6 +86,20 @@ def default_aliases():
                           # things which are executable
                           ('lx', 'ls -F -l %l | grep ^-..x'),
                           ]
+        else:
+            # BSD, OSX, etc.
+            ls_aliases = [('ls', 'ls -F -G'),
+                          # long ls
+                          ('ll', 'ls -F -l -G'),
+                          # ls normal files only
+                          ('lf', 'ls -F -l -G %l | grep ^-'),
+                          # ls symbolic links
+                          ('lk', 'ls -F -l -G %l | grep ^l'),
+                          # directories or links to directories,
+                          ('ldir', 'ls -F -G -l %l | grep /$'),
+                          # things which are executable
+                          ('lx', 'ls -F -l -G %l | grep ^-..x'),
+                          ]
         default_aliases = default_aliases + ls_aliases
     elif os.name in ['nt', 'dos']:
         default_aliases = [('ls', 'dir /on'),
@@ -95,7 +109,7 @@ def default_aliases():
                            ]
     else:
         default_aliases = []
-        
+
     return default_aliases
 
 
@@ -106,159 +120,149 @@ class AliasError(Exception):
 class InvalidAliasError(AliasError):
     pass
 
-#-----------------------------------------------------------------------------
-# Main AliasManager class
-#-----------------------------------------------------------------------------
-
-class AliasManager(Configurable):
-
-    default_aliases = List(default_aliases(), config=True)
-    user_aliases = List(default_value=[], config=True)
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
 
-    def __init__(self, shell=None, config=None):
-        super(AliasManager, self).__init__(shell=shell, config=config)
-        self.alias_table = {}
-        self.exclude_aliases()
-        self.init_aliases()
+class Alias:
+    """Callable object storing the details of one alias.
 
-    def __contains__(self, name):
-        return name in self.alias_table
-
-    @property
-    def aliases(self):
-        return [(item[0], item[1][1]) for item in self.alias_table.iteritems()]
-
-    def exclude_aliases(self):
-        # set of things NOT to alias (keywords, builtins and some magics)
-        no_alias = set(['cd','popd','pushd','dhist','alias','unalias'])
-        no_alias.update(set(keyword.kwlist))
-        no_alias.update(set(__builtin__.__dict__.keys()))
-        self.no_alias = no_alias
-
-    def init_aliases(self):
-        # Load default aliases
-        for name, cmd in self.default_aliases:
-            self.soft_define_alias(name, cmd)
+    Instances are registered as magic functions to allow use of aliases.
+    """
 
-        # Load user aliases
-        for name, cmd in self.user_aliases:
-            self.soft_define_alias(name, cmd)
+    # Prepare blacklist
+    blacklist = {'cd','popd','pushd','dhist','alias','unalias'}
 
-    def clear_aliases(self):
-        self.alias_table.clear()
+    def __init__(self, shell, name, cmd):
+        self.shell = shell
+        self.name = name
+        self.cmd = cmd
+        self.__doc__ = "Alias for `!{}`".format(cmd)
+        self.nargs = self.validate()
 
-    def soft_define_alias(self, name, cmd):
-        """Define an alias, but don't raise on an AliasError."""
+    def validate(self):
+        """Validate the alias, and return the number of arguments."""
+        if self.name in self.blacklist:
+            raise InvalidAliasError("The name %s can't be aliased "
+                                    "because it is a keyword or builtin." % self.name)
         try:
-            self.define_alias(name, cmd)
-        except AliasError, e:
-            error("Invalid alias: %s" % e)
-
-    def define_alias(self, name, cmd):
-        """Define a new alias after validating it.
-
-        This will raise an :exc:`AliasError` if there are validation
-        problems.
-        """
-        nargs = self.validate_alias(name, cmd)
-        self.alias_table[name] = (nargs, cmd)
-
-    def undefine_alias(self, name):
-        if self.alias_table.has_key(name):
-            del self.alias_table[name]
+            caller = self.shell.magics_manager.magics['line'][self.name]
+        except KeyError:
+            pass
+        else:
+            if not isinstance(caller, Alias):
+                raise InvalidAliasError("The name %s can't be aliased "
+                                        "because it is another magic command." % self.name)
 
-    def validate_alias(self, name, cmd):
-        """Validate an alias and return the its number of arguments."""
-        if name in self.no_alias:
-            raise InvalidAliasError("The name %s can't be aliased "
-                                    "because it is a keyword or builtin." % name)
-        if not (isinstance(cmd, basestring)):
+        if not (isinstance(self.cmd, str)):
             raise InvalidAliasError("An alias command must be a string, "
-                                    "got: %r" % name)
-        nargs = cmd.count('%s')
-        if nargs>0 and cmd.find('%l')>=0:
+                                    "got: %r" % self.cmd)
+
+        nargs = self.cmd.count('%s') - self.cmd.count('%%s')
+  
+        if (nargs > 0) and (self.cmd.find('%l') >= 0):
             raise InvalidAliasError('The %s and %l specifiers are mutually '
                                     'exclusive in alias definitions.')
-        return nargs
-
-    def call_alias(self, alias, rest=''):
-        """Call an alias given its name and the rest of the line."""
-        cmd = self.transform_alias(alias, rest)
-        try:
-            self.shell.system(cmd)
-        except:
-            self.shell.showtraceback()
 
-    def transform_alias(self, alias,rest=''):
-        """Transform alias to system command string."""
-        nargs, cmd = self.alias_table[alias]
+        return nargs
 
-        if ' ' in cmd and os.path.isfile(cmd):
-            cmd = '"%s"' % cmd
+    def __repr__(self):
+        return "<alias {} for {!r}>".format(self.name, self.cmd)
 
+    def __call__(self, rest=''):
+        cmd = self.cmd
+        nargs = self.nargs
         # Expand the %l special to be the user's input line
         if cmd.find('%l') >= 0:
             cmd = cmd.replace('%l', rest)
             rest = ''
+        
         if nargs==0:
+            if cmd.find('%%s') >= 1:
+                cmd = cmd.replace('%%s', '%s')
             # Simple, argument-less aliases
             cmd = '%s %s' % (cmd, rest)
         else:
             # Handle aliases with positional arguments
             args = rest.split(None, nargs)
             if len(args) < nargs:
-                raise AliasError('Alias <%s> requires %s arguments, %s given.' %
-                      (alias, nargs, len(args)))
+                raise UsageError('Alias <%s> requires %s arguments, %s given.' %
+                      (self.name, nargs, len(args)))
             cmd = '%s %s' % (cmd % tuple(args[:nargs]),' '.join(args[nargs:]))
-        return cmd
 
-    def expand_alias(self, line):
-        """ Expand an alias in the command line 
-        
-        Returns the provided command line, possibly with the first word 
-        (command) translated according to alias expansion rules.
-        
-        [ipython]|16> _ip.expand_aliases("np myfile.txt")
-                 <16> 'q:/opt/np/notepad++.exe myfile.txt'
-        """
-        
-        pre,fn,rest = split_user_input(line)
-        res = pre + self.expand_aliases(fn, rest)
-        return res
+        self.shell.system(cmd)
 
-    def expand_aliases(self, fn, rest):
-        """Expand multiple levels of aliases:
-        
-        if:
-        
-        alias foo bar /tmp
-        alias baz foo
-        
-        then:
-        
-        baz huhhahhei -> bar /tmp huhhahhei
+#-----------------------------------------------------------------------------
+# Main AliasManager class
+#-----------------------------------------------------------------------------
+
+class AliasManager(Configurable):
+    default_aliases: List = List(default_aliases()).tag(config=True)
+    user_aliases: List = List(default_value=[]).tag(config=True)
+    shell = Instance(
+        "IPython.core.interactiveshell.InteractiveShellABC", allow_none=True
+    )
+
+    def __init__(self, shell=None, **kwargs):
+        super(AliasManager, self).__init__(shell=shell, **kwargs)
+        # For convenient access
+        if self.shell is not None:
+            self.linemagics = self.shell.magics_manager.magics["line"]
+            self.init_aliases()
+
+    def init_aliases(self):
+        # Load default & user aliases
+        for name, cmd in self.default_aliases + self.user_aliases:
+            if (
+                cmd.startswith("ls ")
+                and self.shell is not None
+                and self.shell.colors == "nocolor"
+            ):
+                cmd = cmd.replace(" --color", "")
+            self.soft_define_alias(name, cmd)
+
+    @property
+    def aliases(self):
+        return [(n, func.cmd) for (n, func) in self.linemagics.items()
+                            if isinstance(func, Alias)]
+
+    def soft_define_alias(self, name, cmd):
+        """Define an alias, but don't raise on an AliasError."""
+        try:
+            self.define_alias(name, cmd)
+        except AliasError as e:
+            error("Invalid alias: %s" % e)
+
+    def define_alias(self, name, cmd):
+        """Define a new alias after validating it.
+
+        This will raise an :exc:`AliasError` if there are validation
+        problems.
         """
-        line = fn + " " + rest
-        
-        done = set()
-        while 1:
-            pre,fn,rest = split_user_input(line, shell_line_split)
-            if fn in self.alias_table:
-                if fn in done:
-                    warn("Cyclic alias definition, repeated '%s'" % fn)
-                    return ""
-                done.add(fn)
-
-                l2 = self.transform_alias(fn, rest)
-                if l2 == line:
-                    break
-                # ls -> ls -F should not recurse forever
-                if l2.split(None,1)[0] == line.split(None,1)[0]:
-                    line = l2
-                    break
-                line=l2
-            else:
-                break
-                
-        return line
+        caller = Alias(shell=self.shell, name=name, cmd=cmd)
+        self.shell.magics_manager.register_function(caller, magic_kind='line',
+                                                    magic_name=name)
+
+    def get_alias(self, name):
+        """Return an alias, or None if no alias by that name exists."""
+        aname = self.linemagics.get(name, None)
+        return aname if isinstance(aname, Alias) else None
+
+    def is_alias(self, name):
+        """Return whether or not a given name has been defined as an alias"""
+        return self.get_alias(name) is not None
+
+    def undefine_alias(self, name):
+        if self.is_alias(name):
+            del self.linemagics[name]
+        else:
+            raise ValueError('%s is not an alias' % name)
+
+    def clear_aliases(self):
+        for name, _ in self.aliases:
+            self.undefine_alias(name)
+
+    def retrieve_alias(self, name):
+        """Retrieve the command to which an alias expands."""
+        caller = self.get_alias(name)
+        if caller:
+            return caller.cmd
+        else:
+            raise ValueError('%s is not an alias' % name)
diff --git a/IPython/core/application.py b/IPython/core/application.py
index fc600d20a19..ba5f24f7eea 100644
--- a/IPython/core/application.py
+++ b/IPython/core/application.py
@@ -3,466 +3,490 @@
 An application for IPython.
 
 All top-level applications should use the classes in this module for
-handling configuration and creating componenets.
+handling configuration and creating configurables.
 
-The job of an :class:`Application` is to create the master configuration 
+The job of an :class:`Application` is to create the master configuration
 object and then create the configurable objects, passing the config to them.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
-
-Notes
------
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
+import atexit
+from copy import deepcopy
 import logging
 import os
+import shutil
 import sys
 
+from pathlib import Path
+
+from traitlets.config.application import Application, catch_config_error
+from traitlets.config.loader import ConfigFileNotFound, PyFileConfigLoader
 from IPython.core import release, crashhandler
-from IPython.utils.path import get_ipython_dir, get_ipython_package_dir
-from IPython.config.loader import (
-    PyFileConfigLoader,
-    ArgParseConfigLoader,
-    Config,
+from IPython.core.profiledir import ProfileDir, ProfileDirError
+from IPython.paths import get_ipython_dir, get_ipython_package_dir
+from IPython.utils.path import ensure_dir_exists
+from traitlets import (
+    List, Unicode, Type, Bool, Set, Instance, Undefined,
+    default, observe,
 )
 
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class ApplicationError(Exception):
-    pass
-
-
-class BaseAppConfigLoader(ArgParseConfigLoader):
-    """Default command line options for IPython based applications."""
-
-    def _add_ipython_dir(self, parser):
-        """Add the --ipython-dir option to the parser."""
-        paa = parser.add_argument
-        paa('--ipython-dir', 
-            dest='Global.ipython_dir',type=unicode,
-            help=
-            """Set to override default location of the IPython directory
-            IPYTHON_DIR, stored as Global.ipython_dir.  This can also be 
-            specified through the environment variable IPYTHON_DIR.""",
-            metavar='Global.ipython_dir')
-
-    def _add_log_level(self, parser):
-        """Add the --log-level option to the parser."""
-        paa = parser.add_argument
-        paa('--log-level',
-            dest="Global.log_level",type=int,
-            help='Set the log level (0,10,20,30,40,50).  Default is 30.',
-            metavar='Global.log_level')
-            
-    def _add_version(self, parser):
-        """Add the --version option to the parser."""
-        parser.add_argument('--version', action="version",
-                                                version=self.version)
-
-    def _add_arguments(self):
-        self._add_ipython_dir(self.parser)
-        self._add_log_level(self.parser)
-        try:  # Old versions of argparse don't have a version action
-            self._add_version(self.parser)
-        except Exception:
-            pass
+if os.name == "nt":
+    programdata = os.environ.get("PROGRAMDATA", None)
+    if programdata is not None:
+        SYSTEM_CONFIG_DIRS = [str(Path(programdata) / "ipython")]
+    else:  # PROGRAMDATA is not defined by default on XP.
+        SYSTEM_CONFIG_DIRS = []
+else:
+    SYSTEM_CONFIG_DIRS = [
+        "/usr/local/etc/ipython",
+        "/etc/ipython",
+    ]
+
+
+ENV_CONFIG_DIRS = []
+_env_config_dir = os.path.join(sys.prefix, 'etc', 'ipython')
+if _env_config_dir not in SYSTEM_CONFIG_DIRS:
+    # only add ENV_CONFIG if sys.prefix is not already included
+    ENV_CONFIG_DIRS.append(_env_config_dir)
+
+
+_envvar = os.environ.get('IPYTHON_SUPPRESS_CONFIG_ERRORS')
+if _envvar in {None, ''}:
+    IPYTHON_SUPPRESS_CONFIG_ERRORS = None
+else:
+    if _envvar.lower() in {'1','true'}:
+        IPYTHON_SUPPRESS_CONFIG_ERRORS = True
+    elif _envvar.lower() in {'0','false'} :
+        IPYTHON_SUPPRESS_CONFIG_ERRORS = False
+    else:
+        sys.exit("Unsupported value for environment variable: 'IPYTHON_SUPPRESS_CONFIG_ERRORS' is set to '%s' which is none of  {'0', '1', 'false', 'true', ''}."% _envvar )
+
+# aliases and flags
+
+base_aliases = {}
+if isinstance(Application.aliases, dict):
+    # traitlets 5
+    base_aliases.update(Application.aliases)
+base_aliases.update(
+    {
+        "profile-dir": "ProfileDir.location",
+        "profile": "BaseIPythonApplication.profile",
+        "ipython-dir": "BaseIPythonApplication.ipython_dir",
+        "log-level": "Application.log_level",
+        "config": "BaseIPythonApplication.extra_config_file",
+    }
+)
 
+base_flags = dict()
+if isinstance(Application.flags, dict):
+    # traitlets 5
+    base_flags.update(Application.flags)
+base_flags.update(
+    dict(
+        debug=(
+            {"Application": {"log_level": logging.DEBUG}},
+            "set log level to logging.DEBUG (maximize logging output)",
+        ),
+        quiet=(
+            {"Application": {"log_level": logging.CRITICAL}},
+            "set log level to logging.CRITICAL (minimize logging output)",
+        ),
+        init=(
+            {
+                "BaseIPythonApplication": {
+                    "copy_config_files": True,
+                    "auto_create": True,
+                }
+            },
+            """Initialize profile with default config files.  This is equivalent
+            to running `ipython profile create <profile>` prior to startup.
+            """,
+        ),
+    )
+)
 
-class Application(object):
-    """Load a config, construct configurables and set them running.
-
-    The configuration of an application can be done via three different Config
-    objects, which are loaded and ultimately merged into a single one used
-    from that point on by the app. These are:
-
-    1. default_config: internal defaults, implemented in code.
-    2. file_config: read from the filesystem.
-    3. command_line_config: read from the system's command line flags.
-
-    During initialization, 3 is actually read before 2, since at the
-    command-line one may override the location of the file to be read.  But the
-    above is the order in which the merge is made.
-    """
-
-    name = u'ipython'
-    description = 'IPython: an enhanced interactive Python shell.'
-    #: Usage message printed by argparse. If None, auto-generate
-    usage = None
-    #: The command line config loader.  Subclass of ArgParseConfigLoader.
-    command_line_loader = BaseAppConfigLoader
-    #: The name of the config file to load, determined at runtime
-    config_file_name = None
-    #: The name of the default config file. Track separately from the actual
-    #: name because some logic happens only if we aren't using the default.
-    default_config_file_name = u'ipython_config.py'
-    default_log_level = logging.WARN
-    #: Set by --profile option
-    profile_name = None
-    #: User's ipython directory, typically ~/.ipython or ~/.config/ipython/
-    ipython_dir = None
-    #: Internal defaults, implemented in code.
-    default_config = None
-    #: Read from the filesystem.
-    file_config = None
-    #: Read from the system's command line flags.
-    command_line_config = None
-    #: The final config that will be passed to the main object.
-    master_config = None
-    #: A reference to the argv to be used (typically ends up being sys.argv[1:])
-    argv = None
-    #: extra arguments computed by the command-line loader
-    extra_args = None
-    #: The class to use as the crash handler.
-    crash_handler_class = crashhandler.CrashHandler
-
-    # Private attributes
-    _exiting = False
-    _initialized = False
-
-    def __init__(self, argv=None):
-        self.argv = sys.argv[1:] if argv is None else argv
-        self.init_logger()
-
-    def init_logger(self):
-        self.log = logging.getLogger(self.__class__.__name__)
-        # This is used as the default until the command line arguments are read.
-        self.log.setLevel(self.default_log_level)
-        self._log_handler = logging.StreamHandler()
-        self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
-        self._log_handler.setFormatter(self._log_formatter)
-        self.log.addHandler(self._log_handler)
-
-    def _set_log_level(self, level):
-        self.log.setLevel(level)
-
-    def _get_log_level(self):
-        return self.log.level
-
-    log_level = property(_get_log_level, _set_log_level)
-
-    def initialize(self):
-        """Initialize the application.
-
-        Loads all configuration information and sets all application state, but
-        does not start any relevant processing (typically some kind of event
-        loop).
-
-        Once this method has been called, the application is flagged as
-        initialized and the method becomes a no-op."""
-        
-        if self._initialized:
-            return
 
-        # The first part is protected with an 'attempt' wrapper, that will log
-        # failures with the basic system traceback machinery.  Once our crash
-        # handler is in place, we can let any subsequent exception propagate,
-        # as our handler will log it with much better detail than the default.
-        self.attempt(self.create_crash_handler)
-
-        # Configuration phase
-        # Default config (internally hardwired in application code)
-        self.create_default_config()
-        self.log_default_config()
-        self.set_default_config_log_level()
-
-        # Command-line config
-        self.pre_load_command_line_config()
-        self.load_command_line_config()
-        self.set_command_line_config_log_level()
-        self.post_load_command_line_config()
-        self.log_command_line_config()
-
-        # Find resources needed for filesystem access, using information from
-        # the above two
-        self.find_ipython_dir()
-        self.find_resources()
-        self.find_config_file_name()
-        self.find_config_file_paths()
-
-        # File-based config
-        self.pre_load_file_config()
-        self.load_file_config()
-        self.set_file_config_log_level()
-        self.post_load_file_config()
-        self.log_file_config()
-
-        # Merge all config objects into a single one the app can then use
-        self.merge_configs()
-        self.log_master_config()
-
-        # Construction phase
-        self.pre_construct()
-        self.construct()
-        self.post_construct()
-
-        # Done, flag as such and
-        self._initialized = True
-
-    def start(self):
-        """Start the application."""
-        self.initialize()
-        self.start_app()
+class ProfileAwareConfigLoader(PyFileConfigLoader):
+    """A Python file config loader that is aware of IPython profiles."""
+    def load_subconfig(self, fname, path=None, profile=None):
+        if profile is not None:
+            try:
+                profile_dir = ProfileDir.find_profile_dir_by_name(
+                        get_ipython_dir(),
+                        profile,
+                )
+            except ProfileDirError:
+                return
+            path = profile_dir.location
+        return super(ProfileAwareConfigLoader, self).load_subconfig(fname, path=path)
+
+class BaseIPythonApplication(Application):
+    name = "ipython"
+    description = "IPython: an enhanced interactive Python shell."
+    version = Unicode(release.version)
+
+    aliases = base_aliases
+    flags = base_flags
+    classes = List([ProfileDir])
+    
+    # enable `load_subconfig('cfg.py', profile='name')`
+    python_config_loader_class = ProfileAwareConfigLoader
+
+    # Track whether the config_file has changed,
+    # because some logic happens only if we aren't using the default.
+    config_file_specified = Set()
+
+    config_file_name = Unicode()
+    @default('config_file_name')
+    def _config_file_name_default(self):
+        return self.name.replace('-','_') + u'_config.py'
+    @observe('config_file_name')
+    def _config_file_name_changed(self, change):
+        if change['new'] != change['old']:
+            self.config_file_specified.add(change['new'])
+
+    # The directory that contains IPython's builtin profiles.
+    builtin_profile_dir = Unicode(
+        os.path.join(get_ipython_package_dir(), u'config', u'profile', u'default')
+    )
+    
+    config_file_paths = List(Unicode())
+    @default('config_file_paths')
+    def _config_file_paths_default(self):
+        return []
+
+    extra_config_file = Unicode(
+    help="""Path to an extra config file to load.
+    
+    If specified, load this config file in addition to any other IPython config.
+    """).tag(config=True)
+    @observe('extra_config_file')
+    def _extra_config_file_changed(self, change):
+        old = change['old']
+        new = change['new']
+        try:
+            self.config_files.remove(old)
+        except ValueError:
+            pass
+        self.config_file_specified.add(new)
+        self.config_files.append(new)
+
+    profile = Unicode(u'default',
+        help="""The IPython profile to use."""
+    ).tag(config=True)
+    
+    @observe('profile')
+    def _profile_changed(self, change):
+        self.builtin_profile_dir = os.path.join(
+                get_ipython_package_dir(), u'config', u'profile', change['new']
+        )
+
+    add_ipython_dir_to_sys_path = Bool(
+        False,
+        """Should the IPython profile directory be added to sys path ?
+
+        This option was non-existing before IPython 8.0, and ipython_dir was added to
+        sys path to allow import of extensions present there. This was historical
+        baggage from when pip did not exist. This now default to false,
+        but can be set to true for legacy reasons.
+        """,
+    ).tag(config=True)
+
+    ipython_dir = Unicode(
+        help="""
+        The name of the IPython directory. This directory is used for logging
+        configuration (through profiles), history storage, etc. The default
+        is usually $HOME/.ipython. This option can also be specified through
+        the environment variable IPYTHONDIR.
+        """
+    ).tag(config=True)
+    @default('ipython_dir')
+    def _ipython_dir_default(self):
+        d = get_ipython_dir()
+        self._ipython_dir_changed({
+            'name': 'ipython_dir',
+            'old': d,
+            'new': d,
+        })
+        return d
+    
+    _in_init_profile_dir = False
+
+    profile_dir = Instance(ProfileDir, allow_none=True)
+
+    @default('profile_dir')
+    def _profile_dir_default(self):
+        # avoid recursion
+        if self._in_init_profile_dir:
+            return
+        # profile_dir requested early, force initialization
+        self.init_profile_dir()
+        return self.profile_dir
+
+    overwrite = Bool(False,
+        help="""Whether to overwrite existing config files when copying"""
+    ).tag(config=True)
+
+    auto_create = Bool(False,
+        help="""Whether to create profile dir if it doesn't exist"""
+    ).tag(config=True)
+
+    config_files = List(Unicode())
+
+    @default('config_files')
+    def _config_files_default(self):
+        return [self.config_file_name]
+
+    copy_config_files = Bool(False,
+        help="""Whether to install the default config files into the profile dir.
+        If a new profile is being created, and IPython contains config files for that
+        profile, then they will be staged into the new directory.  Otherwise,
+        default config files will be automatically generated.
+        """).tag(config=True)
+    
+    verbose_crash = Bool(False,
+        help="""Create a massive crash report when IPython encounters what may be an
+        internal error.  The default is to append a short message to the
+        usual traceback""").tag(config=True)
+
+    # The class to use as the crash handler.
+    crash_handler_class = Type(crashhandler.CrashHandler)
+
+    @catch_config_error
+    def __init__(self, **kwargs):
+        super(BaseIPythonApplication, self).__init__(**kwargs)
+        # ensure current working directory exists
+        try:
+            os.getcwd()
+        except:
+            # exit if cwd doesn't exist
+            self.log.error("Current working directory doesn't exist.")
+            self.exit(1)
 
     #-------------------------------------------------------------------------
     # Various stages of Application creation
     #-------------------------------------------------------------------------
-
-    def create_crash_handler(self):
+    
+    def init_crash_handler(self):
         """Create a crash handler, typically setting sys.excepthook to it."""
         self.crash_handler = self.crash_handler_class(self)
-        sys.excepthook = self.crash_handler
-
-    def create_default_config(self):
-        """Create defaults that can't be set elsewhere.
-
-        For the most part, we try to set default in the class attributes
-        of Configurables.  But, defaults the top-level Application (which is
-        not a HasTraits or Configurables) are not set in this way.  Instead
-        we set them here.  The Global section is for variables like this that
-        don't belong to a particular configurable.
+        sys.excepthook = self.excepthook
+        def unset_crashhandler():
+            sys.excepthook = sys.__excepthook__
+        atexit.register(unset_crashhandler)
+    
+    def excepthook(self, etype, evalue, tb):
+        """this is sys.excepthook after init_crashhandler
+
+        set self.verbose_crash=True to use our full crashhandler, instead of
+        a regular traceback with a short message (crash_handler_lite)
         """
-        c = Config()
-        c.Global.ipython_dir = get_ipython_dir()
-        c.Global.log_level = self.log_level
-        self.default_config = c
-
-    def log_default_config(self):
-        self.log.debug('Default config loaded:')
-        self.log.debug(repr(self.default_config))
-
-    def set_default_config_log_level(self):
-        try:
-            self.log_level = self.default_config.Global.log_level
-        except AttributeError:
-            # Fallback to the default_log_level class attribute
-            pass
-
-    def create_command_line_config(self):
-        """Create and return a command line config loader."""
-        return self.command_line_loader(
-            self.argv,
-            description=self.description, 
-            version=release.version,
-            usage=self.usage
-        )
-
-    def pre_load_command_line_config(self):
-        """Do actions just before loading the command line config."""
-        pass
-
-    def load_command_line_config(self):
-        """Load the command line config."""
-        loader = self.create_command_line_config()
-        self.command_line_config = loader.load_config()
-        self.extra_args = loader.get_extra_args()
-
-    def set_command_line_config_log_level(self):
-        try:
-            self.log_level = self.command_line_config.Global.log_level
-        except AttributeError:
-            pass
-
-    def post_load_command_line_config(self):
-        """Do actions just after loading the command line config."""
-        pass
+        
+        if self.verbose_crash:
+            return self.crash_handler(etype, evalue, tb)
+        else:
+            return crashhandler.crash_handler_lite(etype, evalue, tb)
+
+    @observe('ipython_dir')
+    def _ipython_dir_changed(self, change):
+        old = change['old']
+        new = change['new']
+        if old is not Undefined:
+            str_old = os.path.abspath(old)
+            if str_old in sys.path:
+                sys.path.remove(str_old)
+        if self.add_ipython_dir_to_sys_path:
+            str_path = os.path.abspath(new)
+            sys.path.append(str_path)
+            ensure_dir_exists(new)
+            readme = os.path.join(new, "README")
+            readme_src = os.path.join(
+                get_ipython_package_dir(), "config", "profile", "README"
+            )
+            if not os.path.exists(readme) and os.path.exists(readme_src):
+                shutil.copy(readme_src, readme)
+            for d in ("extensions", "nbextensions"):
+                path = os.path.join(new, d)
+                try:
+                    ensure_dir_exists(path)
+                except OSError as e:
+                    # this will not be EEXIST
+                    self.log.error("couldn't create path %s: %s", path, e)
+            self.log.debug("IPYTHONDIR set to: %s", new)
+
+    def load_config_file(self, suppress_errors=IPYTHON_SUPPRESS_CONFIG_ERRORS):
+        """Load the config file.
 
-    def log_command_line_config(self):
-        self.log.debug("Command line config loaded:")
-        self.log.debug(repr(self.command_line_config))
+        By default, errors in loading config are handled, and a warning
+        printed on screen. For testing, the suppress_errors option is set
+        to False, so errors will make tests fail.
 
-    def find_ipython_dir(self):
-        """Set the IPython directory.
+        `suppress_errors` default value is to be `None` in which case the
+        behavior default to the one of `traitlets.Application`.
 
-        This sets ``self.ipython_dir``, but the actual value that is passed to
-        the application is kept in either ``self.default_config`` or
-        ``self.command_line_config``.  This also adds ``self.ipython_dir`` to
-        ``sys.path`` so config files there can be referenced by other config
-        files.
-        """
+        The default value can be set :
+           - to `False` by setting 'IPYTHON_SUPPRESS_CONFIG_ERRORS' environment variable to '0', or 'false' (case insensitive).
+           - to `True` by setting 'IPYTHON_SUPPRESS_CONFIG_ERRORS' environment variable to '1' or 'true' (case insensitive).
+           - to `None` by setting 'IPYTHON_SUPPRESS_CONFIG_ERRORS' environment variable to '' (empty string) or leaving it unset.
 
-        try:
-            self.ipython_dir = self.command_line_config.Global.ipython_dir
-        except AttributeError:
-            self.ipython_dir = self.default_config.Global.ipython_dir
-        sys.path.append(os.path.abspath(self.ipython_dir))
-        if not os.path.isdir(self.ipython_dir):
-            os.makedirs(self.ipython_dir, mode=0777)
-        self.log.debug("IPYTHON_DIR set to: %s" % self.ipython_dir)
-
-    def find_resources(self):
-        """Find other resources that need to be in place.
-
-        Things like cluster directories need to be in place to find the
-        config file.  These happen right after the IPython directory has
-        been set.
+        Any other value are invalid, and will make IPython exit with a non-zero return code.
         """
-        pass
-
-    def find_config_file_name(self):
-        """Find the config file name for this application.
 
-        This must set ``self.config_file_name`` to the filename of the
-        config file to use (just the filename). The search paths for the
-        config file are set in :meth:`find_config_file_paths` and then passed
-        to the config file loader where they are resolved to an absolute path.
 
-        If a profile has been set at the command line, this will resolve it.
-        """
+        self.log.debug("Searching path %s for config files", self.config_file_paths)
+        base_config = 'ipython_config.py'
+        self.log.debug("Attempting to load config file: %s" %
+                       base_config)
         try:
-            self.config_file_name = self.command_line_config.Global.config_file
-        except AttributeError:
+            if suppress_errors is not None:
+                old_value = Application.raise_config_file_errors
+                Application.raise_config_file_errors = not suppress_errors
+            Application.load_config_file(
+                self,
+                base_config,
+                path=self.config_file_paths
+            )
+        except ConfigFileNotFound:
+            # ignore errors loading parent
+            self.log.debug("Config file %s not found", base_config)
             pass
-        else:
+        if suppress_errors is not None:
+            Application.raise_config_file_errors = old_value
+        
+        for config_file_name in self.config_files:
+            if not config_file_name or config_file_name == base_config:
+                continue
+            self.log.debug("Attempting to load config file: %s" %
+                           self.config_file_name)
+            try:
+                Application.load_config_file(
+                    self,
+                    config_file_name,
+                    path=self.config_file_paths
+                )
+            except ConfigFileNotFound:
+                # Only warn if the default config file was NOT being used.
+                if config_file_name in self.config_file_specified:
+                    msg = self.log.warning
+                else:
+                    msg = self.log.debug
+                msg("Config file not found, skipping: %s", config_file_name)
+            except Exception:
+                # For testing purposes.
+                if not suppress_errors:
+                    raise
+                self.log.warning("Error loading config file: %s" %
+                              self.config_file_name, exc_info=True)
+
+    def init_profile_dir(self):
+        """initialize the profile dir"""
+        self._in_init_profile_dir = True
+        if self.profile_dir is not None:
+            # already ran
             return
-
-        try:
-            self.profile_name = self.command_line_config.Global.profile
-        except AttributeError:
-            # Just use the default as there is no profile
-            self.config_file_name = self.default_config_file_name
+        if 'ProfileDir.location' not in self.config:
+            # location not specified, find by profile name
+            try:
+                p = ProfileDir.find_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
+            except ProfileDirError:
+                # not found, maybe create it (always create default profile)
+                if self.auto_create or self.profile == 'default':
+                    try:
+                        p = ProfileDir.create_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
+                    except ProfileDirError:
+                        self.log.fatal("Could not create profile: %r"%self.profile)
+                        self.exit(1)
+                    else:
+                        self.log.info("Created profile dir: %r"%p.location)
+                else:
+                    self.log.fatal("Profile %r not found."%self.profile)
+                    self.exit(1)
+            else:
+                self.log.debug("Using existing profile dir: %r", p.location)
         else:
-            # Use the default config file name and profile name if set
-            # to determine the used config file name.
-            name_parts = self.default_config_file_name.split('.')
-            name_parts.insert(1, u'_' + self.profile_name + u'.')
-            self.config_file_name = ''.join(name_parts)
-
-    def find_config_file_paths(self):
-        """Set the search paths for resolving the config file.
-
-        This must set ``self.config_file_paths`` to a sequence of search
-        paths to pass to the config file loader.
-        """
-        # Include our own profiles directory last, so that users can still find
-        # our shipped copies of builtin profiles even if they don't have them
-        # in their local ipython directory.
-        prof_dir = os.path.join(get_ipython_package_dir(), 'config', 'profile')
-        self.config_file_paths = (os.getcwdu(), self.ipython_dir, prof_dir)
-
-    def pre_load_file_config(self):
-        """Do actions before the config file is loaded."""
-        pass
-
-    def load_file_config(self, suppress_errors=True):
-        """Load the config file.
-        
-        This tries to load the config file from disk.  If successful, the
-        ``CONFIG_FILE`` config variable is set to the resolved config file
-        location.  If not successful, an empty config is used.
-        
-        By default, errors in loading config are handled, and a warning
-        printed on screen. For testing, the suppress_errors option is set
-        to False, so errors will make tests fail.
-        """
-        self.log.debug("Attempting to load config file: %s" %
-                       self.config_file_name)
-        loader = PyFileConfigLoader(self.config_file_name,
-                                    path=self.config_file_paths)
-        try:
-            self.file_config = loader.load_config()
-            self.file_config.Global.config_file = loader.full_filename
-        except IOError:
-            # Only warn if the default config file was NOT being used.
-            if not self.config_file_name==self.default_config_file_name:
-                self.log.warn("Config file not found, skipping: %s" %
-                               self.config_file_name, exc_info=True)
-            self.file_config = Config()
-        except:
-            if not suppress_errors:     # For testing purposes
-                raise
-            self.log.warn("Error loading config file: %s" %
-                          self.config_file_name, exc_info=True)
-            self.file_config = Config()
-
-    def set_file_config_log_level(self):
-        # We need to keeep self.log_level updated.  But we only use the value
-        # of the file_config if a value was not specified at the command
-        # line, because the command line overrides everything.
-        if not hasattr(self.command_line_config.Global, 'log_level'):
+            location = self.config.ProfileDir.location
+            # location is fully specified
             try:
-                self.log_level = self.file_config.Global.log_level
-            except AttributeError:
-                pass # Use existing value
-
-    def post_load_file_config(self):
-        """Do actions after the config file is loaded."""
-        pass
-
-    def log_file_config(self):
-        if hasattr(self.file_config.Global, 'config_file'):
-            self.log.debug("Config file loaded: %s" %
-                           self.file_config.Global.config_file)
-            self.log.debug(repr(self.file_config))
-
-    def merge_configs(self):
-        """Merge the default, command line and file config objects."""
-        config = Config()
-        config._merge(self.default_config)
-        config._merge(self.file_config)
-        config._merge(self.command_line_config)
-
-        # XXX fperez - propose to Brian we rename master_config to simply
-        # config, I think this is going to be heavily used in examples and
-        # application code and the name is shorter/easier to find/remember.
-        # For now, just alias it...
-        self.master_config = config
-        self.config = config
-
-    def log_master_config(self):
-        self.log.debug("Master config created:")
-        self.log.debug(repr(self.master_config))
-
-    def pre_construct(self):
-        """Do actions after the config has been built, but before construct."""
-        pass
-
-    def construct(self):
-        """Construct the main objects that make up this app."""
-        self.log.debug("Constructing main objects for application")
-
-    def post_construct(self):
-        """Do actions after construct, but before starting the app."""
-        pass
-
-    def start_app(self):
-        """Actually start the app."""
-        self.log.debug("Starting application")
-
-    #-------------------------------------------------------------------------
-    # Utility methods
-    #-------------------------------------------------------------------------
-
-    def exit(self, exit_status=0):
-        if self._exiting:
-            pass
+                p = ProfileDir.find_profile_dir(location, self.config)
+            except ProfileDirError:
+                # not found, maybe create it
+                if self.auto_create:
+                    try:
+                        p = ProfileDir.create_profile_dir(location, self.config)
+                    except ProfileDirError:
+                        self.log.fatal("Could not create profile directory: %r"%location)
+                        self.exit(1)
+                    else:
+                        self.log.debug("Creating new profile dir: %r"%location)
+                else:
+                    self.log.fatal("Profile directory %r not found."%location)
+                    self.exit(1)
+            else:
+                self.log.debug("Using existing profile dir: %r", p.location)
+            # if profile_dir is specified explicitly, set profile name
+            dir_name = os.path.basename(p.location)
+            if dir_name.startswith('profile_'):
+                self.profile = dir_name[8:]
+
+        self.profile_dir = p
+        self.config_file_paths.append(p.location)
+        self._in_init_profile_dir = False
+
+    def init_config_files(self):
+        """[optionally] copy default config files into profile dir."""
+        self.config_file_paths.extend(ENV_CONFIG_DIRS)
+        self.config_file_paths.extend(SYSTEM_CONFIG_DIRS)
+        # copy config files
+        path = Path(self.builtin_profile_dir)
+        if self.copy_config_files:
+            src = self.profile
+
+            cfg = self.config_file_name
+            if path and (path / cfg).exists():
+                self.log.warning(
+                    "Staging %r from %s into %r [overwrite=%s]"
+                    % (cfg, src, self.profile_dir.location, self.overwrite)
+                )
+                self.profile_dir.copy_config_file(cfg, path=path, overwrite=self.overwrite)
+            else:
+                self.stage_default_config_file()
         else:
-            self.log.debug("Exiting application: %s" % self.name)
-            self._exiting = True
-            sys.exit(exit_status)
-
-    def attempt(self, func):
-        try:
-            func()
-        except SystemExit:
-            raise
-        except:
-            self.log.critical("Aborting application: %s" % self.name,
-                              exc_info=True)
-            self.exit(0)
-
+            # Still stage *bundled* config files, but not generated ones
+            # This is necessary for `ipython profile=sympy` to load the profile
+            # on the first go
+            files = path.glob("*.py")
+            for fullpath in files:
+                cfg = fullpath.name
+                if self.profile_dir.copy_config_file(cfg, path=path, overwrite=False):
+                    # file was copied
+                    self.log.warning("Staging bundled %s from %s into %r"%(
+                            cfg, self.profile, self.profile_dir.location)
+                    )
+
+
+    def stage_default_config_file(self):
+        """auto generate default config file, and stage it into the profile."""
+        s = self.generate_config_file()
+        config_file = Path(self.profile_dir.location) / self.config_file_name
+        if self.overwrite or not config_file.exists():
+            self.log.warning("Generating default config file: %r", (config_file))
+            config_file.write_text(s, encoding="utf-8")
+
+    @catch_config_error
+    def initialize(self, argv=None):
+        # don't hook up crash handler before parsing command-line
+        self.parse_command_line(argv)
+        self.init_crash_handler()
+        if self.subapp is not None:
+            # stop here if subapp is taking over
+            return
+        # save a copy of CLI config to re-load after config files
+        # so that it has highest priority
+        cl_config = deepcopy(self.config)
+        self.init_profile_dir()
+        self.init_config_files()
+        self.load_config_file()
+        # enforce cl-opts override configfile opts:
+        self.update_config(cl_config)
diff --git a/IPython/core/async_helpers.py b/IPython/core/async_helpers.py
new file mode 100644
index 00000000000..1dd65d7f395
--- /dev/null
+++ b/IPython/core/async_helpers.py
@@ -0,0 +1,150 @@
+"""
+Async helper function that are invalid syntax on Python 3.5 and below.
+
+This code is best effort, and may have edge cases not behaving as expected. In
+particular it contain a number of heuristics to detect whether code is
+effectively async and need to run in an event loop or not.
+
+Some constructs (like top-level `return`, or `yield`) are taken care of
+explicitly to actually raise a SyntaxError and stay as close as possible to
+Python semantics.
+"""
+
+import ast
+import asyncio
+import inspect
+from functools import wraps
+
+_asyncio_event_loop = None
+
+
+def get_asyncio_loop():
+    """asyncio has deprecated get_event_loop
+
+    Replicate it here, with our desired semantics:
+
+    - always returns a valid, not-closed loop
+    - not thread-local like asyncio's,
+      because we only want one loop for IPython
+    - if called from inside a coroutine (e.g. in ipykernel),
+      return the running loop
+
+    .. versionadded:: 8.0
+    """
+    try:
+        return asyncio.get_running_loop()
+    except RuntimeError:
+        # not inside a coroutine,
+        # track our own global
+        pass
+
+    # not thread-local like asyncio's,
+    # because we only track one event loop to run for IPython itself,
+    # always in the main thread.
+    global _asyncio_event_loop
+    if _asyncio_event_loop is None or _asyncio_event_loop.is_closed():
+        _asyncio_event_loop = asyncio.new_event_loop()
+    return _asyncio_event_loop
+
+
+class _AsyncIORunner:
+    def __call__(self, coro):
+        """
+        Handler for asyncio autoawait
+        """
+        return get_asyncio_loop().run_until_complete(coro)
+
+    def __str__(self):
+        return "asyncio"
+
+
+_asyncio_runner = _AsyncIORunner()
+
+
+class _AsyncIOProxy:
+    """Proxy-object for an asyncio
+
+    Any coroutine methods will be wrapped in event_loop.run_
+    """
+
+    def __init__(self, obj, event_loop):
+        self._obj = obj
+        self._event_loop = event_loop
+
+    def __repr__(self):
+        return f"<_AsyncIOProxy({self._obj!r})>"
+
+    def __getattr__(self, key):
+        attr = getattr(self._obj, key)
+        if inspect.iscoroutinefunction(attr):
+            # if it's a coroutine method,
+            # return a threadsafe wrapper onto the _current_ asyncio loop
+            @wraps(attr)
+            def _wrapped(*args, **kwargs):
+                concurrent_future = asyncio.run_coroutine_threadsafe(
+                    attr(*args, **kwargs), self._event_loop
+                )
+                return asyncio.wrap_future(concurrent_future)
+
+            return _wrapped
+        else:
+            return attr
+
+    def __dir__(self):
+        return dir(self._obj)
+
+
+def _curio_runner(coroutine):
+    """
+    handler for curio autoawait
+    """
+    import curio
+
+    return curio.run(coroutine)
+
+
+def _trio_runner(async_fn):
+    import trio
+
+    async def loc(coro):
+        """
+        We need the dummy no-op async def to protect from
+        trio's internal. See https://github.com/python-trio/trio/issues/89
+        """
+        return await coro
+
+    return trio.run(loc, async_fn)
+
+
+def _pseudo_sync_runner(coro):
+    """
+    A runner that does not really allow async execution, and just advance the coroutine.
+
+    See discussion in https://github.com/python-trio/trio/issues/608,
+
+    Credit to Nathaniel Smith
+    """
+    try:
+        coro.send(None)
+    except StopIteration as exc:
+        return exc.value
+    else:
+        # TODO: do not raise but return an execution result with the right info.
+        raise RuntimeError(
+            "{coro_name!r} needs a real async loop".format(coro_name=coro.__name__)
+        )
+
+
+def _should_be_async(cell: str) -> bool:
+    """Detect if a block of code needs to be wrapped in an `async def`
+
+    If the code block has a top-level return statement or is otherwise
+    invalid, `False` will be returned.
+    """
+    try:
+        code = compile(
+            cell, "<>", "exec", flags=getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x0)
+        )
+        return inspect.CO_COROUTINE & code.co_flags == inspect.CO_COROUTINE
+    except (SyntaxError, ValueError, MemoryError):
+        return False
diff --git a/IPython/core/autocall.py b/IPython/core/autocall.py
index 11c3c562acf..d9ebac23ca8 100644
--- a/IPython/core/autocall.py
+++ b/IPython/core/autocall.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """
 Autocall capabilities for IPython.core.
@@ -14,7 +13,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -29,7 +28,7 @@
 # Code
 #-----------------------------------------------------------------------------
 
-class IPyAutocall(object):
+class IPyAutocall:
     """ Instances of this class are always autocalled
     
     This happens regardless of 'autocall' variable state. Use this to
@@ -41,10 +40,10 @@ def __init__(self, ip=None):
         self._ip = ip
     
     def set_ip(self, ip):
-        """ Will be used to set _ip point to current ipython instance b/f call
-        
+        """Will be used to set _ip point to current ipython instance b/f call
+
         Override this method if you don't want this to happen.
-        
+
         """
         self._ip = ip
 
diff --git a/IPython/core/builtin_trap.py b/IPython/core/builtin_trap.py
old mode 100755
new mode 100644
index 6eccc29118d..c1e24582913
--- a/IPython/core/builtin_trap.py
+++ b/IPython/core/builtin_trap.py
@@ -1,43 +1,33 @@
 """
-A context manager for managing things injected into :mod:`__builtin__`.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
+A context manager for managing things injected into :mod:`builtins`.
 """
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team.
-#
-#  Distributed under the terms of the BSD License.
-#
-#  Complete license in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+import builtins as builtin_mod
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+from traitlets.config.configurable import Configurable
 
-import __builtin__
+from traitlets import Instance
 
-from IPython.config.configurable import Configurable
 
-from IPython.utils.traitlets import Instance
+class __BuiltinUndefined:
+    pass
 
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
 
-class __BuiltinUndefined(object): pass
 BuiltinUndefined = __BuiltinUndefined()
 
-class __HideBuiltin(object): pass
+
+class __HideBuiltin:
+    pass
+
+
 HideBuiltin = __HideBuiltin()
 
 
 class BuiltinTrap(Configurable):
 
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
+                     allow_none=True)
 
     def __init__(self, shell=None):
         super(BuiltinTrap, self).__init__(shell=shell, config=None)
@@ -52,15 +42,6 @@ def __init__(self, shell=None):
                               'quit': HideBuiltin,
                               'get_ipython': self.shell.get_ipython,
                               }
-        # Recursive reload function
-        try:
-            from IPython.lib import deepreload
-            if self.shell.deep_reload:
-                self.auto_builtins['reload'] = deepreload.reload
-            else:
-                self.auto_builtins['dreload']= deepreload.reload
-        except ImportError:
-            pass
 
     def __enter__(self):
         if self._nested_level == 0:
@@ -78,7 +59,7 @@ def __exit__(self, type, value, traceback):
 
     def add_builtin(self, key, value):
         """Add a builtin and save the original."""
-        bdict = __builtin__.__dict__
+        bdict = builtin_mod.__dict__
         orig = bdict.get(key, BuiltinUndefined)
         if value is HideBuiltin:
             if orig is not BuiltinUndefined: #same as 'key in bdict'
@@ -88,41 +69,25 @@ def add_builtin(self, key, value):
             self._orig_builtins[key] = orig
             bdict[key] = value
 
-    def remove_builtin(self, key):
+    def remove_builtin(self, key, orig):
         """Remove an added builtin and re-set the original."""
-        try:
-            orig = self._orig_builtins.pop(key)
-        except KeyError:
-            pass
+        if orig is BuiltinUndefined:
+            del builtin_mod.__dict__[key]
         else:
-            if orig is BuiltinUndefined:
-                del __builtin__.__dict__[key]
-            else:
-                __builtin__.__dict__[key] = orig
+            builtin_mod.__dict__[key] = orig
 
     def activate(self):
         """Store ipython references in the __builtin__ namespace."""
 
         add_builtin = self.add_builtin
-        for name, func in self.auto_builtins.iteritems():
+        for name, func in self.auto_builtins.items():
             add_builtin(name, func)
 
-        # Keep in the builtins a flag for when IPython is active.  We set it
-        # with setdefault so that multiple nested IPythons don't clobber one
-        # another.
-        __builtin__.__dict__.setdefault('__IPYTHON__active', 0)
-
     def deactivate(self):
         """Remove any builtins which might have been added by add_builtins, or
         restore overwritten ones to their previous values."""
-        # Note: must iterate over a static keys() list because we'll be
-        # mutating the dict itself
         remove_builtin = self.remove_builtin
-        for key in self._orig_builtins.keys():
-            remove_builtin(key)
+        for key, val in self._orig_builtins.items():
+            remove_builtin(key, val)
         self._orig_builtins.clear()
         self._builtins_added = False
-        try:
-            del __builtin__.__dict__['__IPYTHON__active']
-        except KeyError:
-            pass
diff --git a/IPython/core/compilerop.py b/IPython/core/compilerop.py
index 585eba2e95b..baa9069e66d 100644
--- a/IPython/core/compilerop.py
+++ b/IPython/core/compilerop.py
@@ -15,7 +15,7 @@
 # weird problems (often with third-party tools).
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2010 The IPython Development Team.
+#  Copyright (C) 2010-2011 The IPython Development Team.
 #
 #  Distributed under the terms of the BSD License.
 #
@@ -25,13 +25,27 @@
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib imports
+import __future__
+from ast import PyCF_ONLY_AST
 import codeop
+import functools
 import hashlib
 import linecache
+import operator
 import time
+from contextlib import contextmanager
+
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
+
+# Roughly equal to PyCF_MASK | PyCF_MASK_OBSOLETE as defined in pythonrun.h,
+# this is used as a bitmask to extract future-related code flags.
+PyCF_MASK = functools.reduce(operator.or_,
+                             (getattr(__future__, fname).compiler_flag
+                              for fname in __future__.all_feature_names))
 
 #-----------------------------------------------------------------------------
 # Local utilities
@@ -39,10 +53,10 @@
 
 def code_name(code, number=0):
     """ Compute a (probably) unique name for code for caching.
-    
+
     This now expects code to be unicode.
     """
-    hash_digest = hashlib.md5(code.encode("utf-8")).hexdigest()
+    hash_digest = hashlib.sha1(code.encode("utf-8")).hexdigest()
     # Include the number and 12 characters of the hash in the name.  It's
     # pretty much impossible that in a single session we'll have collisions
     # even with truncated hashes, and the full one makes tracebacks too long
@@ -58,60 +72,121 @@ class CachingCompiler(codeop.Compile):
 
     def __init__(self):
         codeop.Compile.__init__(self)
-        
-        # This is ugly, but it must be done this way to allow multiple
-        # simultaneous ipython instances to coexist.  Since Python itself
-        # directly accesses the data structures in the linecache module, and
-        # the cache therein is global, we must work with that data structure.
-        # We must hold a reference to the original checkcache routine and call
-        # that in our own check_cache() below, but the special IPython cache
-        # must also be shared by all IPython instances.  If we were to hold
-        # separate caches (one in each CachingCompiler instance), any call made
-        # by Python itself to linecache.checkcache() would obliterate the
-        # cached data from the other IPython instances.
-        if not hasattr(linecache, '_ipython_cache'):
-            linecache._ipython_cache = {}
-        if not hasattr(linecache, '_checkcache_ori'):
-            linecache._checkcache_ori = linecache.checkcache
-        # Now, we must monkeypatch the linecache directly so that parts of the
-        # stdlib that call it outside our control go through our codepath
-        # (otherwise we'd lose our tracebacks).
-        linecache.checkcache = self.check_cache
+
+        # Caching a dictionary { filename: execution_count } for nicely
+        # rendered tracebacks. The filename corresponds to the filename
+        # argument used for the builtins.compile function.
+        self._filename_map = {}
+
+    def ast_parse(self, source, filename='<unknown>', symbol='exec'):
+        """Parse code to an AST with the current compiler flags active.
+
+        Arguments are exactly the same as ast.parse (in the standard library),
+        and are passed to the built-in compile function."""
+        return compile(source, filename, symbol, self.flags | PyCF_ONLY_AST, 1)
+
+    def reset_compiler_flags(self):
+        """Reset compiler flags to default state."""
+        # This value is copied from codeop.Compile.__init__, so if that ever
+        # changes, it will need to be updated.
+        self.flags = codeop.PyCF_DONT_IMPLY_DEDENT
 
     @property
     def compiler_flags(self):
         """Flags currently active in the compilation process.
         """
         return self.flags
-        
-    def cache(self, code, number=0):
+
+    def get_code_name(self, raw_code, transformed_code, number):
+        """Compute filename given the code, and the cell number.
+
+        Parameters
+        ----------
+        raw_code : str
+            The raw cell code.
+        transformed_code : str
+            The executable Python source code to cache and compile.
+        number : int
+            A number which forms part of the code's name. Used for the execution
+            counter.
+
+        Returns
+        -------
+        The computed filename.
+        """
+        return code_name(transformed_code, number)
+
+    def format_code_name(self, name):
+        """Return a user-friendly label and name for a code block.
+
+        Parameters
+        ----------
+        name : str
+            The name for the code block returned from get_code_name
+
+        Returns
+        -------
+        A (label, name) pair that can be used in tracebacks, or None if the default formatting should be used.
+        """
+        if name in self._filename_map:
+            return "Cell", "In[%s]" % self._filename_map[name]
+
+    def cache(self, transformed_code, number=0, raw_code=None):
         """Make a name for a block of code, and cache the code.
-        
+
         Parameters
         ----------
-        code : str
-          The Python source code to cache.
+        transformed_code : str
+            The executable Python source code to cache and compile.
         number : int
-          A number which forms part of the code's name. Used for the execution
-          counter.
-          
+            A number which forms part of the code's name. Used for the execution
+            counter.
+        raw_code : str
+            The raw code before transformation, if None, set to `transformed_code`.
+
         Returns
         -------
         The name of the cached code (as a string). Pass this as the filename
         argument to compilation, so that tracebacks are correctly hooked up.
         """
-        name = code_name(code, number)
-        entry = (len(code), time.time(),
-                 [line+'\n' for line in code.splitlines()], name)
+        if raw_code is None:
+            raw_code = transformed_code
+
+        name = self.get_code_name(raw_code, transformed_code, number)
+
+        # Save the execution count
+        self._filename_map[name] = number
+
+        # Since Python 2.5, setting mtime to `None` means the lines will
+        # never be removed by `linecache.checkcache`.  This means all the
+        # monkeypatching has *never* been necessary, since this code was
+        # only added in 2010, at which point IPython had already stopped
+        # supporting Python 2.4.
+        #
+        # Note that `linecache.clearcache` and `linecache.updatecache` may
+        # still remove our code from the cache, but those show explicit
+        # intent, and we should not try to interfere.  Normally the former
+        # is never called except when out of memory, and the latter is only
+        # called for lines *not* in the cache.
+        entry = (
+            len(transformed_code),
+            None,
+            [line + "\n" for line in transformed_code.splitlines()],
+            name,
+        )
         linecache.cache[name] = entry
-        linecache._ipython_cache[name] = entry
         return name
 
-    def check_cache(self, *args):
-        """Call linecache.checkcache() safely protecting our cached values.
-        """
-        # First call the orignal checkcache as intended
-        linecache._checkcache_ori(*args)
-        # Then, update back the cache with our data, so that tracebacks related
-        # to our compiled codes can be produced.
-        linecache.cache.update(linecache._ipython_cache)
+    @contextmanager
+    def extra_flags(self, flags):
+        ## bits that we'll set to 1
+        turn_on_bits = ~self.flags & flags
+
+
+        self.flags = self.flags | flags
+        try:
+            yield
+        finally:
+            # turn off only the bits we turned on so that something like
+            # __future__ that set flags stays.
+            self.flags &= ~turn_on_bits
diff --git a/IPython/core/completer.py b/IPython/core/completer.py
index 098d6de8d5d..1c65f1568a4 100644
--- a/IPython/core/completer.py
+++ b/IPython/core/completer.py
@@ -1,107 +1,338 @@
-"""Word completion for IPython.
+"""Completion for IPython.
 
-This module is a fork of the rlcompleter module in the Python standard
+This module started as fork of the rlcompleter module in the Python standard
 library.  The original enhancements made to rlcompleter have been sent
-upstream and were accepted as of Python 2.3, but we need a lot more
-functionality specific to IPython, so this module will continue to live as an
-IPython-specific utility.
+upstream and were accepted as of Python 2.3,
 
-Original rlcompleter documentation:
+This module now support a wide variety of completion mechanism both available
+for normal classic Python code, as well as completer for IPython specific
+Syntax like magics.
 
-This requires the latest extension to the readline module (the
-completes keywords, built-ins and globals in __main__; when completing
-NAME.NAME..., it evaluates (!) the expression up to the last dot and
-completes its attributes.
+Latex and Unicode completion
+============================
 
-It's very cool to do "import string" type "string.", hit the
-completion key (twice), and see the list of names defined by the
-string module!
+IPython and compatible frontends not only can complete your code, but can help
+you to input a wide range of characters. In particular we allow you to insert
+a unicode character using the tab completion mechanism.
 
-Tip: to use the tab key as the completion key, call
+Forward latex/unicode completion
+--------------------------------
 
-    readline.parse_and_bind("tab: complete")
+Forward completion allows you to easily type a unicode character using its latex
+name, or unicode long description. To do so type a backslash follow by the
+relevant name and press tab:
 
-Notes:
 
-- Exceptions raised by the completer function are *ignored* (and
-generally cause the completion to fail).  This is a feature -- since
-readline sets the tty device in raw (or cbreak) mode, printing a
-traceback wouldn't work well without some complicated hoopla to save,
-reset and restore the tty state.
+Using latex completion:
 
-- The evaluation of the NAME.NAME... form may cause arbitrary
-application defined code to be executed if an object with a
-__getattr__ hook is found.  Since it is the responsibility of the
-application (or the user) to enable this feature, I consider this an
-acceptable risk.  More complicated expressions (e.g. function calls or
-indexing operations) are *not* evaluated.
+.. code::
 
-- GNU readline is also used by the built-in functions input() and
-raw_input(), and thus these also benefit/suffer from the completer
-features.  Clearly an interactive application can benefit by
-specifying its own completer function and using raw_input() for all
-its input.
+    \\alpha<tab>
+    α
 
-- When the original stdin is not a tty device, GNU readline is never
-used, and this module (and the readline module) are silently inactive.
+or using unicode completion:
+
+
+.. code::
+
+    \\GREEK SMALL LETTER ALPHA<tab>
+    α
+
+
+Only valid Python identifiers will complete. Combining characters (like arrow or
+dots) are also available, unlike latex they need to be put after the their
+counterpart that is to say, ``F\\\\vec<tab>`` is correct, not ``\\\\vec<tab>F``.
+
+Some browsers are known to display combining characters incorrectly.
+
+Backward latex completion
+-------------------------
+
+It is sometime challenging to know how to type a character, if you are using
+IPython, or any compatible frontend you can prepend backslash to the character
+and press :kbd:`Tab` to expand it to its latex form.
+
+.. code::
+
+    \\α<tab>
+    \\alpha
+
+
+Both forward and backward completions can be deactivated by setting the
+:std:configtrait:`Completer.backslash_combining_completions` option to
+``False``.
+
+
+Experimental
+============
+
+Starting with IPython 6.0, this module can make use of the Jedi library to
+generate completions both using static analysis of the code, and dynamically
+inspecting multiple namespaces. Jedi is an autocompletion and static analysis
+for Python. The APIs attached to this new mechanism is unstable and will
+raise unless use in an :any:`provisionalcompleter` context manager.
+
+You will find that the following are experimental:
+
+    - :any:`provisionalcompleter`
+    - :any:`IPCompleter.completions`
+    - :any:`Completion`
+    - :any:`rectify_completions`
+
+.. note::
+
+    better name for :any:`rectify_completions` ?
+
+We welcome any feedback on these new API, and we also encourage you to try this
+module in debug mode (start IPython with ``--Completer.debug=True``) in order
+to have extra logging information if :mod:`jedi` is crashing, or if current
+IPython completer pending deprecations are returning results not yet handled
+by :mod:`jedi`
+
+Using Jedi for tab completion allow snippets like the following to work without
+having to execute any code:
+
+   >>> myvar = ['hello', 42]
+   ... myvar[1].bi<tab>
+
+Tab completion will be able to infer that ``myvar[1]`` is a real number without
+executing almost any code unlike the deprecated :any:`IPCompleter.greedy`
+option.
+
+Be sure to update :mod:`jedi` to the latest stable version or to try the
+current development version to get better completions.
+
+Matchers
+========
+
+All completions routines are implemented using unified *Matchers* API.
+The matchers API is provisional and subject to change without notice.
+
+The built-in matchers include:
+
+- :any:`IPCompleter.dict_key_matcher`:  dictionary key completions,
+- :any:`IPCompleter.magic_matcher`: completions for magics,
+- :any:`IPCompleter.unicode_name_matcher`,
+  :any:`IPCompleter.fwd_unicode_matcher`
+  and :any:`IPCompleter.latex_name_matcher`: see `Forward latex/unicode completion`_,
+- :any:`back_unicode_name_matcher` and :any:`back_latex_name_matcher`: see `Backward latex completion`_,
+- :any:`IPCompleter.file_matcher`: paths to files and directories,
+- :any:`IPCompleter.python_func_kw_matcher` - function keywords,
+- :any:`IPCompleter.python_matches` - globals and attributes (v1 API),
+- ``IPCompleter.jedi_matcher`` - static analysis with Jedi,
+- :any:`IPCompleter.custom_completer_matcher` - pluggable completer with a default
+  implementation in :any:`InteractiveShell` which uses IPython hooks system
+  (`complete_command`) with string dispatch (including regular expressions).
+  Differently to other matchers, ``custom_completer_matcher`` will not suppress
+  Jedi results to match behaviour in earlier IPython versions.
+
+Custom matchers can be added by appending to ``IPCompleter.custom_matchers`` list.
+
+Matcher API
+-----------
+
+Simplifying some details, the ``Matcher`` interface can described as
+
+.. code-block::
+
+    MatcherAPIv1 = Callable[[str], list[str]]
+    MatcherAPIv2 = Callable[[CompletionContext], SimpleMatcherResult]
+
+    Matcher = MatcherAPIv1 | MatcherAPIv2
+
+The ``MatcherAPIv1`` reflects the matcher API as available prior to IPython 8.6.0
+and remains supported as a simplest way for generating completions. This is also
+currently the only API supported by the IPython hooks system `complete_command`.
+
+To distinguish between matcher versions ``matcher_api_version`` attribute is used.
+More precisely, the API allows to omit ``matcher_api_version`` for v1 Matchers,
+and requires a literal ``2`` for v2 Matchers.
+
+Once the API stabilises future versions may relax the requirement for specifying
+``matcher_api_version`` by switching to :func:`functools.singledispatch`, therefore
+please do not rely on the presence of ``matcher_api_version`` for any purposes.
+
+Suppression of competing matchers
+---------------------------------
+
+By default results from all matchers are combined, in the order determined by
+their priority. Matchers can request to suppress results from subsequent
+matchers by setting ``suppress`` to ``True`` in the ``MatcherResult``.
+
+When multiple matchers simultaneously request suppression, the results from of
+the matcher with higher priority will be returned.
+
+Sometimes it is desirable to suppress most but not all other matchers;
+this can be achieved by adding a set of identifiers of matchers which
+should not be suppressed to ``MatcherResult`` under ``do_not_suppress`` key.
+
+The suppression behaviour can is user-configurable via
+:std:configtrait:`IPCompleter.suppress_competing_matchers`.
 """
 
-#*****************************************************************************
-#
-# Since this file is essentially a minimally modified copy of the rlcompleter
-# module which is part of the standard Python distribution, I assume that the
-# proper procedure is to maintain its copyright as belonging to the Python
-# Software Foundation (in addition to my own, for all new code).
-#
-#       Copyright (C) 2008-2010 IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
-#       Copyright (C) 2001 Python Software Foundation, www.python.org
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#
-#*****************************************************************************
-from __future__ import print_function
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+#
+# Some of this code originated from rlcompleter in the Python standard library
+# Copyright (C) 2001 Python Software Foundation, www.python.org
 
-import __builtin__
-import __main__
+from __future__ import annotations
+import builtins as builtin_mod
+import enum
 import glob
 import inspect
 import itertools
 import keyword
+import ast
 import os
 import re
-import shlex
+import string
 import sys
-
-from IPython.core.error import TryNext
-from IPython.core.prefilter import ESC_MAGIC
+import tokenize
+import time
+import unicodedata
+import uuid
+import warnings
+from ast import literal_eval
+from collections import defaultdict
+from contextlib import contextmanager
+from dataclasses import dataclass
+from functools import cached_property, partial
+from types import SimpleNamespace
+from typing import (
+    Union,
+    Any,
+    Optional,
+    TYPE_CHECKING,
+    TypeVar,
+    Literal,
+)
+from collections.abc import Iterable, Iterator, Sequence, Sized
+
+from IPython.core.guarded_eval import (
+    guarded_eval,
+    EvaluationContext,
+    _validate_policy_overrides,
+)
+from IPython.core.error import TryNext, UsageError
+from IPython.core.inputtransformer2 import ESC_MAGIC
+from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
+from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import generics
-from IPython.utils import io
-from IPython.utils.dir2 import dir2
+from IPython.utils.PyColorize import theme_table
+from IPython.utils.decorators import sphinx_options
+from IPython.utils.dir2 import dir2, get_real_method
+from IPython.utils.path import ensure_dir_exists
 from IPython.utils.process import arg_split
+from traitlets import (
+    Bool,
+    Enum,
+    Int,
+    List as ListTrait,
+    Unicode,
+    Dict as DictTrait,
+    DottedObjectName,
+    Union as UnionTrait,
+    observe,
+)
+from traitlets.config.configurable import Configurable
+from traitlets.utils.importstring import import_item
 
-#-----------------------------------------------------------------------------
+import __main__
+
+from typing import cast
+
+from typing import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
+
+
+# skip module docstests
+__skip_doctest__ = True
+
+
+try:
+    import jedi
+    jedi.settings.case_insensitive_completion = False
+    import jedi.api.helpers
+    import jedi.api.classes
+    JEDI_INSTALLED = True
+except ImportError:
+    JEDI_INSTALLED = False
+
+
+# -----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
+# ranges where we have most of the valid unicode names. We could be more finer
+# grained but is it worth it for performance  While unicode have character in the
+# range 0, 0x110000, we seem to have name for about 10% of those. (131808 as I
+# write this). With below range we cover them all, with a density of ~67%
+# biggest next gap we consider only adds up about 1% density and there are 600
+# gaps that would need hard coding.
+_UNICODE_RANGES = [(32, 0x3347A), (0xE0001, 0xE01F0)]
+
 # Public API
-__all__ = ['Completer','IPCompleter']
+__all__ = ["Completer", "IPCompleter"]
 
 if sys.platform == 'win32':
     PROTECTABLES = ' '
 else:
     PROTECTABLES = ' ()[]{}?=\\|;:\'#*"^&'
 
-#-----------------------------------------------------------------------------
-# Main functions and classes
-#-----------------------------------------------------------------------------
+# Protect against returning an enormous number of completions which the frontend
+# may have trouble processing.
+MATCHES_LIMIT = 500
 
-def has_open_quotes(s):
+# Completion type reported when no type can be inferred.
+_UNKNOWN_TYPE = "<unknown>"
+
+# sentinel value to signal lack of a match
+not_found = object()
+
+class ProvisionalCompleterWarning(FutureWarning):
+    """
+    Exception raise by an experimental feature in this module.
+
+    Wrap code in :any:`provisionalcompleter` context manager if you
+    are certain you want to use an unstable feature.
+    """
+    pass
+
+warnings.filterwarnings('error', category=ProvisionalCompleterWarning)
+
+
+@skip_doctest
+@contextmanager
+def provisionalcompleter(action='ignore'):
+    """
+    This context manager has to be used in any place where unstable completer
+    behavior and API may be called.
+
+    >>> with provisionalcompleter():
+    ...     completer.do_experimental_things() # works
+
+    >>> completer.do_experimental_things() # raises.
+
+    .. note::
+
+        Unstable
+
+        By using this context manager you agree that the API in use may change
+        without warning, and that you won't complain if they do so.
+
+        You also understand that, if the API is not to your liking, you should report
+        a bug to explain your use case upstream.
+
+        We'll be happy to get your feedback, feature requests, and improvements on
+        any of the unstable APIs!
+    """
+    with warnings.catch_warnings():
+        warnings.filterwarnings(action, category=ProvisionalCompleterWarning)
+        yield
+
+
+def has_open_quotes(s: str) -> Union[str, bool]:
     """Return whether a string has open quotes.
 
     This simply counts whether the number of quote characters of either type in
@@ -122,27 +353,19 @@ def has_open_quotes(s):
         return False
 
 
-def protect_filename(s):
+def protect_filename(s: str, protectables: str = PROTECTABLES) -> str:
     """Escape a string to protect certain characters."""
-    
-    return "".join([(ch in PROTECTABLES and '\\' + ch or ch)
-                    for ch in s])
-
-
-def mark_dirs(matches):
-    """Mark directories in input list by appending '/' to their names."""
-    out = []
-    isdir = os.path.isdir
-    for x in matches:
-        if isdir(x):
-            out.append(x+'/')
+    if set(s) & set(protectables):
+        if sys.platform == "win32":
+            return '"' + s + '"'
         else:
-            out.append(x)
-    return out
+            return "".join(("\\" + c if c in protectables else c) for c in s)
+    else:
+        return s
 
 
-def expand_user(path):
-    """Expand '~'-style usernames in strings.
+def expand_user(path: str) -> tuple[str, bool, str]:
+    """Expand ``~``-style usernames in strings.
 
     This is similar to :func:`os.path.expanduser`, but it computes and returns
     extra information that will be useful if the input was being used in
@@ -152,33 +375,36 @@ def expand_user(path):
     Parameters
     ----------
     path : str
-      String to be expanded.  If no ~ is present, the output is the same as the
-      input.
-      
+        String to be expanded.  If no ~ is present, the output is the same as the
+        input.
+
     Returns
     -------
     newpath : str
-      Result of ~ expansion in the input path.
+        Result of ~ expansion in the input path.
     tilde_expand : bool
-      Whether any expansion was performed or not.
+        Whether any expansion was performed or not.
     tilde_val : str
-      The value that ~ was replaced with.
+        The value that ~ was replaced with.
     """
     # Default values
     tilde_expand = False
     tilde_val = ''
     newpath = path
-    
+
     if path.startswith('~'):
         tilde_expand = True
-        rest = path[1:]
+        rest = len(path)-1
         newpath = os.path.expanduser(path)
-        tilde_val = newpath.replace(rest, '')
+        if rest:
+            tilde_val = newpath[:-rest]
+        else:
+            tilde_val = newpath
 
     return newpath, tilde_expand, tilde_val
 
 
-def compress_user(path, tilde_expand, tilde_val):
+def compress_user(path:str, tilde_expand:bool, tilde_val:str) -> str:
     """Does the opposite of expand_user, with its outputs.
     """
     if tilde_expand:
@@ -187,31 +413,493 @@ def compress_user(path, tilde_expand, tilde_val):
         return path
 
 
-def single_dir_expand(matches):
-    "Recursively expand match lists containing a single dir."
+def completions_sorting_key(word):
+    """key for sorting completions
 
-    if len(matches) == 1 and os.path.isdir(matches[0]):
-        # Takes care of links to directories also.  Use '/'
-        # explicitly, even under Windows, so that name completions
-        # don't end up escaped.
-        d = matches[0]
-        if d[-1] in ['/','\\']:
-            d = d[:-1]
+    This does several things:
 
-        subdirs = os.listdir(d)
-        if subdirs:
-            matches = [ (d + '/' + p) for p in subdirs]
-            return single_dir_expand(matches)
-        else:
-            return matches
-    else:
-        return matches
+    - Demote any completions starting with underscores to the end
+    - Insert any %magic and %%cellmagic completions in the alphabetical order
+      by their name
+    """
+    prio1, prio2 = 0, 0
+
+    if word.startswith('__'):
+        prio1 = 2
+    elif word.startswith('_'):
+        prio1 = 1
+
+    if word.endswith('='):
+        prio1 = -1
+
+    if word.startswith('%%'):
+        # If there's another % in there, this is something else, so leave it alone
+        if "%" not in word[2:]:
+            word = word[2:]
+            prio2 = 2
+    elif word.startswith('%'):
+        if "%" not in word[1:]:
+            word = word[1:]
+            prio2 = 1
+
+    return prio1, word, prio2
+
+
+class _FakeJediCompletion:
+    """
+    This is a workaround to communicate to the UI that Jedi has crashed and to
+    report a bug. Will be used only id :any:`IPCompleter.debug` is set to true.
+
+    Added in IPython 6.0 so should likely be removed for 7.0
+
+    """
+
+    def __init__(self, name):
+
+        self.name = name
+        self.complete = name
+        self.type = 'crashed'
+        self.name_with_symbols = name
+        self.signature = ""
+        self._origin = "fake"
+        self.text = "crashed"
+
+    def __repr__(self):
+        return '<Fake completion object jedi has crashed>'
+
+
+_JediCompletionLike = Union["jedi.api.Completion", _FakeJediCompletion]
+
+
+class Completion:
+    """
+    Completion object used and returned by IPython completers.
+
+    .. warning::
+
+        Unstable
+
+        This function is unstable, API may change without warning.
+        It will also raise unless use in proper context manager.
+
+    This act as a middle ground :any:`Completion` object between the
+    :class:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
+    object. While Jedi need a lot of information about evaluator and how the
+    code should be ran/inspected, PromptToolkit (and other frontend) mostly
+    need user facing information.
+
+    - Which range should be replaced replaced by what.
+    - Some metadata (like completion type), or meta information to displayed to
+      the use user.
+
+    For debugging purpose we can also store the origin of the completion (``jedi``,
+    ``IPython.python_matches``, ``IPython.magics_matches``...).
+    """
+
+    __slots__ = ['start', 'end', 'text', 'type', 'signature', '_origin']
+
+    def __init__(
+        self,
+        start: int,
+        end: int,
+        text: str,
+        *,
+        type: Optional[str] = None,
+        _origin="",
+        signature="",
+    ) -> None:
+        warnings.warn(
+            "``Completion`` is a provisional API (as of IPython 6.0). "
+            "It may change without warnings. "
+            "Use in corresponding context manager.",
+            category=ProvisionalCompleterWarning,
+            stacklevel=2,
+        )
+
+        self.start = start
+        self.end = end
+        self.text = text
+        self.type = type
+        self.signature = signature
+        self._origin = _origin
+
+    def __repr__(self):
+        return '<Completion start=%s end=%s text=%r type=%r, signature=%r,>' % \
+                (self.start, self.end, self.text, self.type or '?', self.signature or '?')
+
+    def __eq__(self, other) -> bool:
+        """
+        Equality and hash do not hash the type (as some completer may not be
+        able to infer the type), but are use to (partially) de-duplicate
+        completion.
+
+        Completely de-duplicating completion is a bit tricker that just
+        comparing as it depends on surrounding text, which Completions are not
+        aware of.
+        """
+        return self.start == other.start and \
+            self.end == other.end and \
+            self.text == other.text
+
+    def __hash__(self):
+        return hash((self.start, self.end, self.text))
+
+
+class SimpleCompletion:
+    """Completion item to be included in the dictionary returned by new-style Matcher (API v2).
+
+    .. warning::
+
+        Provisional
+
+        This class is used to describe the currently supported attributes of
+        simple completion items, and any additional implementation details
+        should not be relied on. Additional attributes may be included in
+        future versions, and meaning of text disambiguated from the current
+        dual meaning of "text to insert" and "text to used as a label".
+    """
 
+    __slots__ = ["text", "type"]
 
-class Bunch(object): pass
+    def __init__(self, text: str, *, type: Optional[str] = None):
+        self.text = text
+        self.type = type
 
+    def __repr__(self):
+        return f"<SimpleCompletion text={self.text!r} type={self.type!r}>"
 
-class CompletionSplitter(object):
+
+class _MatcherResultBase(TypedDict):
+    """Definition of dictionary to be returned by new-style Matcher (API v2)."""
+
+    #: Suffix of the provided ``CompletionContext.token``, if not given defaults to full token.
+    matched_fragment: NotRequired[str]
+
+    #: Whether to suppress results from all other matchers (True), some
+    #: matchers (set of identifiers) or none (False); default is False.
+    suppress: NotRequired[Union[bool, set[str]]]
+
+    #: Identifiers of matchers which should NOT be suppressed when this matcher
+    #: requests to suppress all other matchers; defaults to an empty set.
+    do_not_suppress: NotRequired[set[str]]
+
+    #: Are completions already ordered and should be left as-is? default is False.
+    ordered: NotRequired[bool]
+
+
+@sphinx_options(show_inherited_members=True, exclude_inherited_from=["dict"])
+class SimpleMatcherResult(_MatcherResultBase, TypedDict):
+    """Result of new-style completion matcher."""
+
+    # note: TypedDict is added again to the inheritance chain
+    # in order to get __orig_bases__ for documentation
+
+    #: List of candidate completions
+    completions: Sequence[SimpleCompletion] | Iterator[SimpleCompletion]
+
+
+class _JediMatcherResult(_MatcherResultBase):
+    """Matching result returned by Jedi (will be processed differently)"""
+
+    #: list of candidate completions
+    completions: Iterator[_JediCompletionLike]
+
+
+AnyMatcherCompletion = Union[_JediCompletionLike, SimpleCompletion]
+AnyCompletion = TypeVar("AnyCompletion", AnyMatcherCompletion, Completion)
+
+
+@dataclass
+class CompletionContext:
+    """Completion context provided as an argument to matchers in the Matcher API v2."""
+
+    # rationale: many legacy matchers relied on completer state (`self.text_until_cursor`)
+    # which was not explicitly visible as an argument of the matcher, making any refactor
+    # prone to errors; by explicitly passing `cursor_position` we can decouple the matchers
+    # from the completer, and make substituting them in sub-classes easier.
+
+    #: Relevant fragment of code directly preceding the cursor.
+    #: The extraction of token is implemented via splitter heuristic
+    #: (following readline behaviour for legacy reasons), which is user configurable
+    #: (by switching the greedy mode).
+    token: str
+
+    #: The full available content of the editor or buffer
+    full_text: str
+
+    #: Cursor position in the line (the same for ``full_text`` and ``text``).
+    cursor_position: int
+
+    #: Cursor line in ``full_text``.
+    cursor_line: int
+
+    #: The maximum number of completions that will be used downstream.
+    #: Matchers can use this information to abort early.
+    #: The built-in Jedi matcher is currently excepted from this limit.
+    # If not given, return all possible completions.
+    limit: Optional[int]
+
+    @cached_property
+    def text_until_cursor(self) -> str:
+        return self.line_with_cursor[: self.cursor_position]
+
+    @cached_property
+    def line_with_cursor(self) -> str:
+        return self.full_text.split("\n")[self.cursor_line]
+
+
+#: Matcher results for API v2.
+MatcherResult = Union[SimpleMatcherResult, _JediMatcherResult]
+
+
+class _MatcherAPIv1Base(Protocol):
+    def __call__(self, text: str) -> list[str]:
+        """Call signature."""
+        ...
+
+    #: Used to construct the default matcher identifier
+    __qualname__: str
+
+
+class _MatcherAPIv1Total(_MatcherAPIv1Base, Protocol):
+    #: API version
+    matcher_api_version: Optional[Literal[1]]
+
+    def __call__(self, text: str) -> list[str]:
+        """Call signature."""
+        ...
+
+
+#: Protocol describing Matcher API v1.
+MatcherAPIv1: TypeAlias = Union[_MatcherAPIv1Base, _MatcherAPIv1Total]
+
+
+class MatcherAPIv2(Protocol):
+    """Protocol describing Matcher API v2."""
+
+    #: API version
+    matcher_api_version: Literal[2] = 2
+
+    def __call__(self, context: CompletionContext) -> MatcherResult:
+        """Call signature."""
+        ...
+
+    #: Used to construct the default matcher identifier
+    __qualname__: str
+
+
+Matcher: TypeAlias = Union[MatcherAPIv1, MatcherAPIv2]
+
+
+def _is_matcher_v1(matcher: Matcher) -> TypeGuard[MatcherAPIv1]:
+    api_version = _get_matcher_api_version(matcher)
+    return api_version == 1
+
+
+def _is_matcher_v2(matcher: Matcher) -> TypeGuard[MatcherAPIv2]:
+    api_version = _get_matcher_api_version(matcher)
+    return api_version == 2
+
+
+def _is_sizable(value: Any) -> TypeGuard[Sized]:
+    """Determines whether objects is sizable"""
+    return hasattr(value, "__len__")
+
+
+def _is_iterator(value: Any) -> TypeGuard[Iterator]:
+    """Determines whether objects is sizable"""
+    return hasattr(value, "__next__")
+
+
+def has_any_completions(result: MatcherResult) -> bool:
+    """Check if any result includes any completions."""
+    completions = result["completions"]
+    if _is_sizable(completions):
+        return len(completions) != 0
+    if _is_iterator(completions):
+        try:
+            old_iterator = completions
+            first = next(old_iterator)
+            result["completions"] = cast(
+                Iterator[SimpleCompletion],
+                itertools.chain([first], old_iterator),
+            )
+            return True
+        except StopIteration:
+            return False
+    raise ValueError(
+        "Completions returned by matcher need to be an Iterator or a Sizable"
+    )
+
+
+def completion_matcher(
+    *,
+    priority: Optional[float] = None,
+    identifier: Optional[str] = None,
+    api_version: int = 1,
+) -> Callable[[Matcher], Matcher]:
+    """Adds attributes describing the matcher.
+
+    Parameters
+    ----------
+    priority : Optional[float]
+        The priority of the matcher, determines the order of execution of matchers.
+        Higher priority means that the matcher will be executed first. Defaults to 0.
+    identifier : Optional[str]
+        identifier of the matcher allowing users to modify the behaviour via traitlets,
+        and also used to for debugging (will be passed as ``origin`` with the completions).
+
+        Defaults to matcher function's ``__qualname__`` (for example,
+        ``IPCompleter.file_matcher`` for the built-in matched defined
+        as a ``file_matcher`` method of the ``IPCompleter`` class).
+    api_version: Optional[int]
+        version of the Matcher API used by this matcher.
+        Currently supported values are 1 and 2.
+        Defaults to 1.
+    """
+
+    def wrapper(func: Matcher):
+        func.matcher_priority = priority or 0  # type: ignore
+        func.matcher_identifier = identifier or func.__qualname__  # type: ignore
+        func.matcher_api_version = api_version  # type: ignore
+        if TYPE_CHECKING:
+            if api_version == 1:
+                func = cast(MatcherAPIv1, func)
+            elif api_version == 2:
+                func = cast(MatcherAPIv2, func)
+        return func
+
+    return wrapper
+
+
+def _get_matcher_priority(matcher: Matcher):
+    return getattr(matcher, "matcher_priority", 0)
+
+
+def _get_matcher_id(matcher: Matcher):
+    return getattr(matcher, "matcher_identifier", matcher.__qualname__)
+
+
+def _get_matcher_api_version(matcher):
+    return getattr(matcher, "matcher_api_version", 1)
+
+
+context_matcher = partial(completion_matcher, api_version=2)
+
+
+_IC = Iterable[Completion]
+
+
+def _deduplicate_completions(text: str, completions: _IC)-> _IC:
+    """
+    Deduplicate a set of completions.
+
+    .. warning::
+
+        Unstable
+
+        This function is unstable, API may change without warning.
+
+    Parameters
+    ----------
+    text : str
+        text that should be completed.
+    completions : Iterator[Completion]
+        iterator over the completions to deduplicate
+
+    Yields
+    ------
+    `Completions` objects
+    Completions coming from multiple sources, may be different but end up having
+    the same effect when applied to ``text``. If this is the case, this will
+    consider completions as equal and only emit the first encountered.
+    Not folded in `completions()` yet for debugging purpose, and to detect when
+    the IPython completer does return things that Jedi does not, but should be
+    at some point.
+    """
+    completions = list(completions)
+    if not completions:
+        return
+
+    new_start = min(c.start for c in completions)
+    new_end = max(c.end for c in completions)
+
+    seen = set()
+    for c in completions:
+        new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
+        if new_text not in seen:
+            yield c
+            seen.add(new_text)
+
+
+def rectify_completions(text: str, completions: _IC, *, _debug: bool = False) -> _IC:
+    """
+    Rectify a set of completions to all have the same ``start`` and ``end``
+
+    .. warning::
+
+        Unstable
+
+        This function is unstable, API may change without warning.
+        It will also raise unless use in proper context manager.
+
+    Parameters
+    ----------
+    text : str
+        text that should be completed.
+    completions : Iterator[Completion]
+        iterator over the completions to rectify
+    _debug : bool
+        Log failed completion
+
+    Notes
+    -----
+    :class:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
+    the Jupyter Protocol requires them to behave like so. This will readjust
+    the completion to have the same ``start`` and ``end`` by padding both
+    extremities with surrounding text.
+
+    During stabilisation should support a ``_debug`` option to log which
+    completion are return by the IPython completer and not found in Jedi in
+    order to make upstream bug report.
+    """
+    warnings.warn("`rectify_completions` is a provisional API (as of IPython 6.0). "
+                 "It may change without warnings. "
+                 "Use in corresponding context manager.",
+                  category=ProvisionalCompleterWarning, stacklevel=2)
+
+    completions = list(completions)
+    if not completions:
+        return
+    starts = (c.start for c in completions)
+    ends = (c.end for c in completions)
+
+    new_start = min(starts)
+    new_end = max(ends)
+
+    seen_jedi = set()
+    seen_python_matches = set()
+    for c in completions:
+        new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
+        if c._origin == 'jedi':
+            seen_jedi.add(new_text)
+        elif c._origin == "IPCompleter.python_matcher":
+            seen_python_matches.add(new_text)
+        yield Completion(new_start, new_end, new_text, type=c.type, _origin=c._origin, signature=c.signature)
+    diff = seen_python_matches.difference(seen_jedi)
+    if diff and _debug:
+        print('IPython.python matches have extras:', diff)
+
+
+if sys.platform == 'win32':
+    DELIMS = ' \t\n`!@#$^&*()=+[{]}|;\'",<>?'
+else:
+    DELIMS = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
+
+GREEDY_DELIMS = ' =\r\n'
+
+
+class CompletionSplitter:
     """An object to split an input line in a manner similar to readline.
 
     By having our own implementation, we can expose readline-like completion in
@@ -221,14 +909,14 @@ class CompletionSplitter(object):
     entire line.
 
     What characters are used as splitting delimiters can be controlled by
-    setting the `delims` attribute (this is a property that internally
-    automatically builds the necessary """
+    setting the ``delims`` attribute (this is a property that internally
+    automatically builds the necessary regular expression)"""
 
     # Private interface
-    
+
     # A string of delimiter characters.  The default value makes sense for
     # IPython's most typical usage patterns.
-    _delims = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
+    _delims = DELIMS
 
     # The expression (a normal string) to be compiled into a regular expression
     # for actual splitting.  We store it as an attribute mostly for ease of
@@ -240,31 +928,150 @@ class CompletionSplitter(object):
 
     def __init__(self, delims=None):
         delims = CompletionSplitter._delims if delims is None else delims
-        self.set_delims(delims)
+        self.delims = delims
+
+    @property
+    def delims(self):
+        """Return the string of delimiter characters."""
+        return self._delims
 
-    def set_delims(self, delims):
+    @delims.setter
+    def delims(self, delims):
         """Set the delimiters for line splitting."""
         expr = '[' + ''.join('\\'+ c for c in delims) + ']'
         self._delim_re = re.compile(expr)
         self._delims = delims
         self._delim_expr = expr
 
-    def get_delims(self):
-        """Return the string of delimiter characters."""
-        return self._delims
-
     def split_line(self, line, cursor_pos=None):
         """Split a line of text with a cursor at the given position.
         """
-        l = line if cursor_pos is None else line[:cursor_pos]
-        return self._delim_re.split(l)[-1]
-
-
-class Completer(object):
-    def __init__(self, namespace=None, global_namespace=None):
+        cut_line = line if cursor_pos is None else line[:cursor_pos]
+        return self._delim_re.split(cut_line)[-1]
+
+
+class Completer(Configurable):
+
+    greedy = Bool(
+        False,
+        help="""Activate greedy completion.
+
+        .. deprecated:: 8.8
+            Use :std:configtrait:`Completer.evaluation` and :std:configtrait:`Completer.auto_close_dict_keys` instead.
+
+        When enabled in IPython 8.8 or newer, changes configuration as follows:
+
+        - ``Completer.evaluation = 'unsafe'``
+        - ``Completer.auto_close_dict_keys = True``
+        """,
+    ).tag(config=True)
+
+    evaluation = Enum(
+        ("forbidden", "minimal", "limited", "unsafe", "dangerous"),
+        default_value="limited",
+        help="""Policy for code evaluation under completion.
+
+        Successive options allow to enable more eager evaluation for better
+        completion suggestions, including for nested dictionaries, nested lists,
+        or even results of function calls.
+        Setting ``unsafe`` or higher can lead to evaluation of arbitrary user
+        code on :kbd:`Tab` with potentially unwanted or dangerous side effects.
+
+        Allowed values are:
+
+        - ``forbidden``: no evaluation of code is permitted,
+        - ``minimal``: evaluation of literals and access to built-in namespace;
+          no item/attribute evaluation, no access to locals/globals,
+          no evaluation of any operations or comparisons.
+        - ``limited``: access to all namespaces, evaluation of hard-coded methods
+          (for example: :py:meth:`dict.keys`, :py:meth:`object.__getattr__`,
+          :py:meth:`object.__getitem__`) on allow-listed objects (for example:
+          :py:class:`dict`, :py:class:`list`, :py:class:`tuple`, ``pandas.Series``),
+        - ``unsafe``: evaluation of all methods and function calls but not of
+          syntax with side-effects like `del x`,
+        - ``dangerous``: completely arbitrary evaluation; does not support auto-import.
+
+        To override specific elements of the policy, you can use ``policy_overrides`` trait.
+        """,
+    ).tag(config=True)
+
+    use_jedi = Bool(default_value=JEDI_INSTALLED,
+                    help="Experimental: Use Jedi to generate autocompletions. "
+                    "Default to True if jedi is installed.").tag(config=True)
+
+    jedi_compute_type_timeout = Int(default_value=400,
+        help="""Experimental: restrict time (in milliseconds) during which Jedi can compute types.
+        Set to 0 to stop computing types. Non-zero value lower than 100ms may hurt
+        performance by preventing jedi to build its cache.
+        """).tag(config=True)
+
+    debug = Bool(default_value=False,
+                 help='Enable debug for the Completer. Mostly print extra '
+                      'information for experimental jedi integration.')\
+                      .tag(config=True)
+
+    backslash_combining_completions = Bool(True,
+        help="Enable unicode completions, e.g. \\alpha<tab> . "
+             "Includes completion of latex commands, unicode names, and expanding "
+             "unicode characters back to latex commands.").tag(config=True)
+
+    auto_close_dict_keys = Bool(
+        False,
+        help="""
+        Enable auto-closing dictionary keys.
+
+        When enabled string keys will be suffixed with a final quote
+        (matching the opening quote), tuple keys will also receive a
+        separating comma if needed, and keys which are final will
+        receive a closing bracket (``]``).
+        """,
+    ).tag(config=True)
+
+    policy_overrides = DictTrait(
+        default_value={},
+        key_trait=Unicode(),
+        help="""Overrides for policy evaluation.
+
+        For example, to enable auto-import on completion specify:
+
+        .. code-block::
+
+            ipython --Completer.policy_overrides='{"allow_auto_import": True}' --Completer.use_jedi=False
+
+        """,
+    ).tag(config=True)
+
+    @observe("evaluation")
+    def _evaluation_changed(self, _change):
+        _validate_policy_overrides(
+            policy_name=self.evaluation, policy_overrides=self.policy_overrides
+        )
+
+    @observe("policy_overrides")
+    def _policy_overrides_changed(self, _change):
+        _validate_policy_overrides(
+            policy_name=self.evaluation, policy_overrides=self.policy_overrides
+        )
+
+    auto_import_method = DottedObjectName(
+        default_value="importlib.import_module",
+        allow_none=True,
+        help="""\
+        Provisional:
+              This is a provisional API in IPython 9.3, it may change without warnings.
+
+        A fully qualified path to an auto-import method for use by completer.
+        The function should take a single string and return `ModuleType` and
+        can raise `ImportError` exception if module is not found.
+
+        The default auto-import implementation does not populate the user namespace with the imported module.
+        """,
+    ).tag(config=True)
+
+    def __init__(self, namespace=None, global_namespace=None, **kwargs):
         """Create a new completer for the command line.
 
-        Completer([namespace,global_namespace]) -> completer instance.
+        Completer(namespace=ns, global_namespace=ns2) -> completer instance.
 
         If unspecified, the default namespace where completions are performed
         is __main__ (technically, __main__.__dict__). Namespaces should be
@@ -273,20 +1080,15 @@ def __init__(self, namespace=None, global_namespace=None):
         An optional second namespace can be given.  This allows the completer
         to handle cases where both the local and global scopes need to be
         distinguished.
-
-        Completer instances should be used as the completion mechanism of
-        readline via the set_completer() call:
-
-        readline.set_completer(Completer(my_namespace).complete)
         """
 
         # Don't bind to namespace quite yet, but flag whether the user wants a
         # specific namespace or to use __main__.__dict__. This will allow us
         # to bind to __main__.__dict__ at completion time, not now.
         if namespace is None:
-            self.use_main_ns = 1
+            self.use_main_ns = True
         else:
-            self.use_main_ns = 0
+            self.use_main_ns = False
             self.namespace = namespace
 
         # The global namespace, if given, can be bound directly
@@ -295,6 +1097,10 @@ def __init__(self, namespace=None, global_namespace=None):
         else:
             self.global_namespace = global_namespace
 
+        self.custom_matchers = []
+
+        super(Completer, self).__init__(**kwargs)
+
     def complete(self, text, state):
         """Return the next possible completion for 'text'.
 
@@ -304,7 +1110,7 @@ def complete(self, text, state):
         """
         if self.use_main_ns:
             self.namespace = __main__.__dict__
-            
+
         if state == 0:
             if "." in text:
                 self.matches = self.attr_matches(text)
@@ -315,24 +1121,66 @@ def complete(self, text, state):
         except IndexError:
             return None
 
-    def global_matches(self, text):
+    def global_matches(self, text: str, context: Optional[CompletionContext] = None):
         """Compute matches when text is a simple name.
 
         Return a list of all keywords, built-in functions and names currently
         defined in self.namespace or self.global_namespace that match.
 
         """
-        #print 'Completer->global_matches, txt=%r' % text # dbg
         matches = []
         match_append = matches.append
         n = len(text)
-        for lst in [keyword.kwlist,
-                    __builtin__.__dict__.keys(),
-                    self.namespace.keys(),
-                    self.global_namespace.keys()]:
+
+        search_lists = [
+            keyword.kwlist,
+            builtin_mod.__dict__.keys(),
+            list(self.namespace.keys()),
+            list(self.global_namespace.keys()),
+        ]
+        if context and context.full_text.count("\n") > 1:
+            # try to evaluate on full buffer
+            previous_lines = "\n".join(
+                context.full_text.split("\n")[: context.cursor_line]
+            )
+            if previous_lines:
+                all_code_lines_before_cursor = (
+                    self._extract_code(previous_lines) + "\n" + text
+                )
+                context = EvaluationContext(
+                    globals=self.global_namespace,
+                    locals=self.namespace,
+                    evaluation=self.evaluation,
+                    auto_import=self._auto_import,
+                    policy_overrides=self.policy_overrides,
+                )
+                try:
+                    obj = guarded_eval(
+                        all_code_lines_before_cursor,
+                        context,
+                    )
+                except Exception as e:
+                    if self.debug:
+                        warnings.warn(f"Evaluation exception {e}")
+
+                search_lists.append(list(context.transient_locals.keys()))
+
+        for lst in search_lists:
             for word in lst:
                 if word[:n] == text and word != "__builtins__":
                     match_append(word)
+
+        snake_case_re = re.compile(r"[^_]+(_[^_]+)+?\Z")
+        for lst in [list(self.namespace.keys()), list(self.global_namespace.keys())]:
+            shortened = {
+                "_".join([sub[0] for sub in word.split("_")]): word
+                for word in lst
+                if snake_case_re.match(word)
+            }
+            for word in shortened.keys():
+                if word[:n] == text and word != "__builtins__":
+                    match_append(shortened[word])
+
         return matches
 
     def attr_matches(self, text):
@@ -341,97 +1189,906 @@ def attr_matches(self, text):
         Assuming the text is of the form NAME.NAME....[NAME], and is
         evaluatable in self.namespace or self.global_namespace, it will be
         evaluated and its attributes (as revealed by dir()) are used as
-        possible completions.  (For class instances, class members are are
+        possible completions.  (For class instances, class members are
         also considered.)
 
         WARNING: this can still invoke arbitrary C code, if an object
         with a __getattr__ hook is evaluated.
 
         """
+        return self._attr_matches(text)[0]
 
-        #print 'Completer->attr_matches, txt=%r' % text # dbg
-        # Another option, seems to work great. Catches things like ''.<tab>
-        m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
+    # we simple attribute matching with normal identifiers.
+    _ATTR_MATCH_RE = re.compile(r"(.+)\.(\w*)$")
 
-        if not m:
-            return []
-        
-        expr, attr = m.group(1, 3)
+    def _strip_code_before_operator(self, code: str) -> str:
+        o_parens = {"(", "[", "{"}
+        c_parens = {")", "]", "}"}
+
+        # Dry-run tokenize to catch errors
         try:
-            obj = eval(expr, self.namespace)
-        except:
+            _ = list(tokenize.generate_tokens(iter(code.splitlines()).__next__))
+        except tokenize.TokenError:
+            # Try trimming the expression and retrying
+            trimmed_code = self._trim_expr(code)
             try:
-                obj = eval(expr, self.global_namespace)
-            except:
-                return []
+                _ = list(
+                    tokenize.generate_tokens(iter(trimmed_code.splitlines()).__next__)
+                )
+                code = trimmed_code
+            except tokenize.TokenError:
+                return code
+
+        tokens = _parse_tokens(code)
+        encountered_operator = False
+        after_operator = []
+        nesting_level = 0
+
+        for t in tokens:
+            if t.type == tokenize.OP:
+                if t.string in o_parens:
+                    nesting_level += 1
+                elif t.string in c_parens:
+                    nesting_level -= 1
+                elif t.string != "." and nesting_level == 0:
+                    encountered_operator = True
+                    after_operator = []
+                    continue
+
+            if encountered_operator:
+                after_operator.append(t.string)
+
+        if encountered_operator:
+            return "".join(after_operator)
+        else:
+            return code
+
+    def _extract_code(self, line: str):
+        """No-op in Completer, but can be used in subclasses to customise behaviour"""
+        return line
+
+    def _attr_matches(
+        self,
+        text: str,
+        include_prefix: bool = True,
+        context: Optional[CompletionContext] = None,
+    ) -> tuple[Sequence[str], str]:
+        m2 = self._ATTR_MATCH_RE.match(text)
+        if not m2:
+            return [], ""
+        expr, attr = m2.group(1, 2)
+        try:
+            expr = self._strip_code_before_operator(expr)
+        except tokenize.TokenError:
+            pass
+
+        obj = self._evaluate_expr(expr)
+        if obj is not_found:
+            if context:
+                # try to evaluate on full buffer
+                previous_lines = "\n".join(
+                    context.full_text.split("\n")[: context.cursor_line]
+                )
+                if previous_lines:
+                    all_code_lines_before_cursor = (
+                        self._extract_code(previous_lines) + "\n" + expr
+                    )
+                    obj = self._evaluate_expr(all_code_lines_before_cursor)
+
+            if obj is not_found:
+                return [], ""
+
+        if self.limit_to__all__ and hasattr(obj, '__all__'):
+            words = get__all__entries(obj)
+        else:
+            words = dir2(obj)
 
-        words = dir2(obj)
-        
         try:
             words = generics.complete_object(obj, words)
         except TryNext:
             pass
+        except AssertionError:
+            raise
+        except Exception:
+            # Silence errors from completion function
+            pass
         # Build match list to return
         n = len(attr)
-        res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
-        return res
+
+        # Note: ideally we would just return words here and the prefix
+        # reconciliator would know that we intend to append to rather than
+        # replace the input text; this requires refactoring to return range
+        # which ought to be replaced (as does jedi).
+        if include_prefix:
+            tokens = _parse_tokens(expr)
+            rev_tokens = reversed(tokens)
+            skip_over = {tokenize.ENDMARKER, tokenize.NEWLINE}
+            name_turn = True
+
+            parts = []
+            for token in rev_tokens:
+                if token.type in skip_over:
+                    continue
+                if token.type == tokenize.NAME and name_turn:
+                    parts.append(token.string)
+                    name_turn = False
+                elif (
+                    token.type == tokenize.OP and token.string == "." and not name_turn
+                ):
+                    parts.append(token.string)
+                    name_turn = True
+                else:
+                    # short-circuit if not empty nor name token
+                    break
+
+            prefix_after_space = "".join(reversed(parts))
+        else:
+            prefix_after_space = ""
+
+        return (
+            ["%s.%s" % (prefix_after_space, w) for w in words if w[:n] == attr],
+            "." + attr,
+        )
+
+    def _trim_expr(self, code: str) -> str:
+        """
+        Trim the code until it is a valid expression and not a tuple;
+
+        return the trimmed expression for guarded_eval.
+        """
+        while code:
+            code = code[1:]
+            try:
+                res = ast.parse(code)
+            except SyntaxError:
+                continue
+
+            assert res is not None
+            if len(res.body) != 1:
+                continue
+            if not isinstance(res.body[0], ast.Expr):
+                continue
+            expr = res.body[0].value
+            if isinstance(expr, ast.Tuple) and not code[-1] == ")":
+                # we skip implicit tuple, like when trimming `fun(a,b`<completion>
+                # as `a,b` would be a tuple, and we actually expect to get only `b`
+                continue
+            return code
+        return ""
+
+    def _evaluate_expr(self, expr):
+        obj = not_found
+        done = False
+        while not done and expr:
+            try:
+                obj = guarded_eval(
+                    expr,
+                    EvaluationContext(
+                        globals=self.global_namespace,
+                        locals=self.namespace,
+                        evaluation=self.evaluation,
+                        auto_import=self._auto_import,
+                        policy_overrides=self.policy_overrides,
+                    ),
+                )
+                done = True
+            except (SyntaxError, TypeError) as e:
+                if self.debug:
+                    warnings.warn(f"Trimming because of {e}")
+                # TypeError can show up with something like `+ d`
+                # where `d` is a dictionary.
+
+                # trim the expression to remove any invalid prefix
+                # e.g. user starts `(d[`, so we get `expr = '(d'`,
+                # where parenthesis is not closed.
+                # TODO: make this faster by reusing parts of the computation?
+                expr = self._trim_expr(expr)
+            except Exception as e:
+                if self.debug:
+                    warnings.warn(f"Evaluation exception {e}")
+                done = True
+        if self.debug:
+            warnings.warn(f"Resolved to {obj}")
+        return obj
+
+    @property
+    def _auto_import(self):
+        if self.auto_import_method is None:
+            return None
+        if not hasattr(self, "_auto_import_func"):
+            self._auto_import_func = import_item(self.auto_import_method)
+        return self._auto_import_func
+
+
+def get__all__entries(obj):
+    """returns the strings in the __all__ attribute"""
+    try:
+        words = getattr(obj, '__all__')
+    except Exception:
+        return []
+
+    return [w for w in words if isinstance(w, str)]
+
+
+class _DictKeyState(enum.Flag):
+    """Represent state of the key match in context of other possible matches.
+
+    - given `d1 = {'a': 1}` completion on `d1['<tab>` will yield `{'a': END_OF_ITEM}` as there is no tuple.
+    - given `d2 = {('a', 'b'): 1}`: `d2['a', '<tab>` will yield `{'b': END_OF_TUPLE}` as there is no tuple members to add beyond `'b'`.
+    - given `d3 = {('a', 'b'): 1}`: `d3['<tab>` will yield `{'a': IN_TUPLE}` as `'a'` can be added.
+    - given `d4 = {'a': 1, ('a', 'b'): 2}`: `d4['<tab>` will yield `{'a': END_OF_ITEM & END_OF_TUPLE}`
+    """
+
+    BASELINE = 0
+    END_OF_ITEM = enum.auto()
+    END_OF_TUPLE = enum.auto()
+    IN_TUPLE = enum.auto()
+
+
+def _parse_tokens(c):
+    """Parse tokens even if there is an error."""
+    tokens = []
+    token_generator = tokenize.generate_tokens(iter(c.splitlines()).__next__)
+    while True:
+        try:
+            tokens.append(next(token_generator))
+        except tokenize.TokenError:
+            return tokens
+        except StopIteration:
+            return tokens
+
+
+def _match_number_in_dict_key_prefix(prefix: str) -> Union[str, None]:
+    """Match any valid Python numeric literal in a prefix of dictionary keys.
+
+    References:
+    - https://docs.python.org/3/reference/lexical_analysis.html#numeric-literals
+    - https://docs.python.org/3/library/tokenize.html
+    """
+    if prefix[-1].isspace():
+        # if user typed a space we do not have anything to complete
+        # even if there was a valid number token before
+        return None
+    tokens = _parse_tokens(prefix)
+    rev_tokens = reversed(tokens)
+    skip_over = {tokenize.ENDMARKER, tokenize.NEWLINE}
+    number = None
+    for token in rev_tokens:
+        if token.type in skip_over:
+            continue
+        if number is None:
+            if token.type == tokenize.NUMBER:
+                number = token.string
+                continue
+            else:
+                # we did not match a number
+                return None
+        if token.type == tokenize.OP:
+            if token.string == ",":
+                break
+            if token.string in {"+", "-"}:
+                number = token.string + number
+        else:
+            return None
+    return number
+
+
+_INT_FORMATS = {
+    "0b": bin,
+    "0o": oct,
+    "0x": hex,
+}
+
+
+def match_dict_keys(
+    keys: list[Union[str, bytes, tuple[Union[str, bytes], ...]]],
+    prefix: str,
+    delims: str,
+    extra_prefix: Optional[tuple[Union[str, bytes], ...]] = None,
+) -> tuple[str, int, dict[str, _DictKeyState]]:
+    """Used by dict_key_matches, matching the prefix to a list of keys
+
+    Parameters
+    ----------
+    keys
+        list of keys in dictionary currently being completed.
+    prefix
+        Part of the text already typed by the user. E.g. `mydict[b'fo`
+    delims
+        String of delimiters to consider when finding the current key.
+    extra_prefix : optional
+        Part of the text already typed in multi-key index cases. E.g. for
+        `mydict['foo', "bar", 'b`, this would be `('foo', 'bar')`.
+
+    Returns
+    -------
+    A tuple of three elements: ``quote``, ``token_start``, ``matched``, with
+    ``quote`` being the quote that need to be used to close current string.
+    ``token_start`` the position where the replacement should start occurring,
+    ``matches`` a dictionary of replacement/completion keys on keys and values
+        indicating whether the state.
+    """
+    prefix_tuple = extra_prefix if extra_prefix else ()
+
+    prefix_tuple_size = sum(
+        [
+            # for pandas, do not count slices as taking space
+            not isinstance(k, slice)
+            for k in prefix_tuple
+        ]
+    )
+    text_serializable_types = (str, bytes, int, float, slice)
+
+    def filter_prefix_tuple(key):
+        # Reject too short keys
+        if len(key) <= prefix_tuple_size:
+            return False
+        # Reject keys which cannot be serialised to text
+        for k in key:
+            if not isinstance(k, text_serializable_types):
+                return False
+        # Reject keys that do not match the prefix
+        for k, pt in zip(key, prefix_tuple):
+            if k != pt and not isinstance(pt, slice):
+                return False
+        # All checks passed!
+        return True
+
+    filtered_key_is_final: dict[
+        Union[str, bytes, int, float], _DictKeyState
+    ] = defaultdict(lambda: _DictKeyState.BASELINE)
+
+    for k in keys:
+        # If at least one of the matches is not final, mark as undetermined.
+        # This can happen with `d = {111: 'b', (111, 222): 'a'}` where
+        # `111` appears final on first match but is not final on the second.
+
+        if isinstance(k, tuple):
+            if filter_prefix_tuple(k):
+                key_fragment = k[prefix_tuple_size]
+                filtered_key_is_final[key_fragment] |= (
+                    _DictKeyState.END_OF_TUPLE
+                    if len(k) == prefix_tuple_size + 1
+                    else _DictKeyState.IN_TUPLE
+                )
+        elif prefix_tuple_size > 0:
+            # we are completing a tuple but this key is not a tuple,
+            # so we should ignore it
+            pass
+        else:
+            if isinstance(k, text_serializable_types):
+                filtered_key_is_final[k] |= _DictKeyState.END_OF_ITEM
+
+    filtered_keys = filtered_key_is_final.keys()
+
+    if not prefix:
+        return "", 0, {repr(k): v for k, v in filtered_key_is_final.items()}
+
+    quote_match = re.search("(?:\"|')", prefix)
+    is_user_prefix_numeric = False
+
+    if quote_match:
+        quote = quote_match.group()
+        valid_prefix = prefix + quote
+        try:
+            prefix_str = literal_eval(valid_prefix)
+        except Exception:
+            return "", 0, {}
+    else:
+        # If it does not look like a string, let's assume
+        # we are dealing with a number or variable.
+        number_match = _match_number_in_dict_key_prefix(prefix)
+
+        # We do not want the key matcher to suggest variable names so we yield:
+        if number_match is None:
+            # The alternative would be to assume that user forgort the quote
+            # and if the substring matches, suggest adding it at the start.
+            return "", 0, {}
+
+        prefix_str = number_match
+        is_user_prefix_numeric = True
+        quote = ""
+
+    pattern = '[^' + ''.join('\\' + c for c in delims) + ']*$'
+    token_match = re.search(pattern, prefix, re.UNICODE)
+    assert token_match is not None # silence mypy
+    token_start = token_match.start()
+    token_prefix = token_match.group()
+
+    matched: dict[str, _DictKeyState] = {}
+
+    str_key: Union[str, bytes]
+
+    for key in filtered_keys:
+        if isinstance(key, (int, float)):
+            # User typed a number but this key is not a number.
+            if not is_user_prefix_numeric:
+                continue
+            str_key = str(key)
+            if isinstance(key, int):
+                int_base = prefix_str[:2].lower()
+                # if user typed integer using binary/oct/hex notation:
+                if int_base in _INT_FORMATS:
+                    int_format = _INT_FORMATS[int_base]
+                    str_key = int_format(key)
+        else:
+            # User typed a string but this key is a number.
+            if is_user_prefix_numeric:
+                continue
+            str_key = key
+        try:
+            if not str_key.startswith(prefix_str):
+                continue
+        except (AttributeError, TypeError, UnicodeError):
+            # Python 3+ TypeError on b'a'.startswith('a') or vice-versa
+            continue
+
+        # reformat remainder of key to begin with prefix
+        rem = str_key[len(prefix_str) :]
+        # force repr wrapped in '
+        rem_repr = repr(rem + '"') if isinstance(rem, str) else repr(rem + b'"')
+        rem_repr = rem_repr[1 + rem_repr.index("'"):-2]
+        if quote == '"':
+            # The entered prefix is quoted with ",
+            # but the match is quoted with '.
+            # A contained " hence needs escaping for comparison:
+            rem_repr = rem_repr.replace('"', '\\"')
+
+        # then reinsert prefix from start of token
+        match = "%s%s" % (token_prefix, rem_repr)
+
+        matched[match] = filtered_key_is_final[key]
+    return quote, token_start, matched
+
+
+def cursor_to_position(text:str, line:int, column:int)->int:
+    """
+    Convert the (line,column) position of the cursor in text to an offset in a
+    string.
+
+    Parameters
+    ----------
+    text : str
+        The text in which to calculate the cursor offset
+    line : int
+        Line of the cursor; 0-indexed
+    column : int
+        Column of the cursor 0-indexed
+
+    Returns
+    -------
+    Position of the cursor in ``text``, 0-indexed.
+
+    See Also
+    --------
+    position_to_cursor : reciprocal of this function
+
+    """
+    lines = text.split('\n')
+    assert line <= len(lines), '{} <= {}'.format(str(line), str(len(lines)))
+
+    return sum(len(line) + 1 for line in lines[:line]) + column
+
+
+def position_to_cursor(text: str, offset: int) -> tuple[int, int]:
+    """
+    Convert the position of the cursor in text (0 indexed) to a line
+    number(0-indexed) and a column number (0-indexed) pair
+
+    Position should be a valid position in ``text``.
+
+    Parameters
+    ----------
+    text : str
+        The text in which to calculate the cursor offset
+    offset : int
+        Position of the cursor in ``text``, 0-indexed.
+
+    Returns
+    -------
+    (line, column) : (int, int)
+        Line of the cursor; 0-indexed, column of the cursor 0-indexed
+
+    See Also
+    --------
+    cursor_to_position : reciprocal of this function
+
+    """
+
+    assert 0 <= offset <= len(text) , "0 <= %s <= %s" % (offset , len(text))
+
+    before = text[:offset]
+    blines = before.split('\n')  # ! splitnes trim trailing \n
+    line = before.count('\n')
+    col = len(blines[-1])
+    return line, col
+
+
+def _safe_isinstance(obj, module, class_name, *attrs):
+    """Checks if obj is an instance of module.class_name if loaded
+    """
+    if module in sys.modules:
+        m = sys.modules[module]
+        for attr in [class_name, *attrs]:
+            m = getattr(m, attr)
+        return isinstance(obj, m)
+
+
+@context_matcher()
+def back_unicode_name_matcher(context: CompletionContext):
+    """Match Unicode characters back to Unicode name
+
+    Same as :any:`back_unicode_name_matches`, but adopted to new Matcher API.
+    """
+    fragment, matches = back_unicode_name_matches(context.text_until_cursor)
+    return _convert_matcher_v1_result_to_v2(
+        matches, type="unicode", fragment=fragment, suppress_if_matches=True
+    )
+
+
+def back_unicode_name_matches(text: str) -> tuple[str, Sequence[str]]:
+    """Match Unicode characters back to Unicode name
+
+    This does  ``☃`` -> ``\\snowman``
+
+    Note that snowman is not a valid python3 combining character but will be expanded.
+    Though it will not recombine back to the snowman character by the completion machinery.
+
+    This will not either back-complete standard sequences like \\n, \\b ...
+
+    .. deprecated:: 8.6
+        You can use :meth:`back_unicode_name_matcher` instead.
+
+    Returns
+    =======
+
+    Return a tuple with two elements:
+
+    - The Unicode character that was matched (preceded with a backslash), or
+        empty string,
+    - a sequence (of 1), name for the match Unicode character, preceded by
+        backslash, or empty if no match.
+    """
+    if len(text)<2:
+        return '', ()
+    maybe_slash = text[-2]
+    if maybe_slash != '\\':
+        return '', ()
+
+    char = text[-1]
+    # no expand on quote for completion in strings.
+    # nor backcomplete standard ascii keys
+    if char in string.ascii_letters or char in ('"',"'"):
+        return '', ()
+    try :
+        unic = unicodedata.name(char)
+        return '\\'+char,('\\'+unic,)
+    except KeyError:
+        pass
+    return '', ()
+
+
+@context_matcher()
+def back_latex_name_matcher(context: CompletionContext) -> SimpleMatcherResult:
+    """Match latex characters back to unicode name
+
+    This does ``\\ℵ`` -> ``\\aleph``
+    """
+
+    text = context.text_until_cursor
+    no_match = {
+        "completions": [],
+        "suppress": False,
+    }
+
+    if len(text)<2:
+        return no_match
+    maybe_slash = text[-2]
+    if maybe_slash != '\\':
+        return no_match
+
+    char = text[-1]
+    # no expand on quote for completion in strings.
+    # nor backcomplete standard ascii keys
+    if char in string.ascii_letters or char in ('"',"'"):
+        return no_match
+    try :
+        latex = reverse_latex_symbol[char]
+        # '\\' replace the \ as well
+        return {
+            "completions": [SimpleCompletion(text=latex, type="latex")],
+            "suppress": True,
+            "matched_fragment": "\\" + char,
+        }
+    except KeyError:
+        pass
+
+    return no_match
+
+def _formatparamchildren(parameter) -> str:
+    """
+    Get parameter name and value from Jedi Private API
+
+    Jedi does not expose a simple way to get `param=value` from its API.
+
+    Parameters
+    ----------
+    parameter
+        Jedi's function `Param`
+
+    Returns
+    -------
+    A string like 'a', 'b=1', '*args', '**kwargs'
+
+    """
+    description = parameter.description
+    if not description.startswith('param '):
+        raise ValueError('Jedi function parameter description have change format.'
+                         'Expected "param ...", found %r".' % description)
+    return description[6:]
+
+def _make_signature(completion)-> str:
+    """
+    Make the signature from a jedi completion
+
+    Parameters
+    ----------
+    completion : jedi.Completion
+        object does not complete a function type
+
+    Returns
+    -------
+    a string consisting of the function signature, with the parenthesis but
+    without the function name. example:
+    `(a, *args, b=1, **kwargs)`
+
+    """
+
+    # it looks like this might work on jedi 0.17
+    if hasattr(completion, 'get_signatures'):
+        signatures = completion.get_signatures()
+        if not signatures:
+            return  '(?)'
+
+        c0 = completion.get_signatures()[0]
+        return '('+c0.to_string().split('(', maxsplit=1)[1]
+
+    return '(%s)'% ', '.join([f for f in (_formatparamchildren(p) for signature in completion.get_signatures()
+                                          for p in signature.defined_names()) if f])
+
+
+_CompleteResult = dict[str, MatcherResult]
+
+
+DICT_MATCHER_REGEX = re.compile(
+    r"""(?x)
+(  # match dict-referring - or any get item object - expression
+    .+
+)
+\[   # open bracket
+\s*  # and optional whitespace
+# Capture any number of serializable objects (e.g. "a", "b", 'c')
+# and slices
+((?:(?:
+    (?: # closed string
+        [uUbB]?  # string prefix (r not handled)
+        (?:
+            '(?:[^']|(?<!\\)\\')*'
+        |
+            "(?:[^"]|(?<!\\)\\")*"
+        )
+    )
+    |
+        # capture integers and slices
+        (?:[-+]?\d+)?(?::(?:[-+]?\d+)?){0,2}
+    |
+        # integer in bin/hex/oct notation
+        0[bBxXoO]_?(?:\w|\d)+
+    )
+    \s*,\s*
+)*)
+((?:
+    (?: # unclosed string
+        [uUbB]?  # string prefix (r not handled)
+        (?:
+            '(?:[^']|(?<!\\)\\')*
+            |
+            "(?:[^"]|(?<!\\)\\")*
+        )
+    )
+    |
+        # unfinished integer
+        (?:[-+]?\d+)
+    |
+        # integer in bin/hex/oct notation
+        0[bBxXoO]_?(?:\w|\d)+
+    )
+)?
+$
+"""
+)
+
+
+def _convert_matcher_v1_result_to_v2_no_no(
+    matches: Sequence[str],
+    type: str,
+) -> SimpleMatcherResult:
+    """same as _convert_matcher_v1_result_to_v2 but fragment=None, and suppress_if_matches is False by construction"""
+    return SimpleMatcherResult(
+        completions=[SimpleCompletion(text=match, type=type) for match in matches],
+        suppress=False,
+    )
+
+
+def _convert_matcher_v1_result_to_v2(
+    matches: Sequence[str],
+    type: str,
+    fragment: Optional[str] = None,
+    suppress_if_matches: bool = False,
+) -> SimpleMatcherResult:
+    """Utility to help with transition"""
+    result = {
+        "completions": [SimpleCompletion(text=match, type=type) for match in matches],
+        "suppress": (True if matches else False) if suppress_if_matches else False,
+    }
+    if fragment is not None:
+        result["matched_fragment"] = fragment
+    return cast(SimpleMatcherResult, result)
 
 
 class IPCompleter(Completer):
     """Extension of the completer class with IPython-specific features"""
 
-    def __init__(self, shell, namespace=None, global_namespace=None,
-                 omit__names=True, alias_table=None, use_readline=True):
-        """IPCompleter() -> completer
+    @observe('greedy')
+    def _greedy_changed(self, change):
+        """update the splitter and readline delims when greedy is changed"""
+        if change["new"]:
+            self.evaluation = "unsafe"
+            self.auto_close_dict_keys = True
+            self.splitter.delims = GREEDY_DELIMS
+        else:
+            self.evaluation = "limited"
+            self.auto_close_dict_keys = False
+            self.splitter.delims = DELIMS
+
+    dict_keys_only = Bool(
+        False,
+        help="""
+        Whether to show dict key matches only.
+
+        (disables all matchers except for `IPCompleter.dict_key_matcher`).
+        """,
+    )
+
+    suppress_competing_matchers = UnionTrait(
+        [Bool(allow_none=True), DictTrait(Bool(None, allow_none=True))],
+        default_value=None,
+        help="""
+        Whether to suppress completions from other *Matchers*.
+
+        When set to ``None`` (default) the matchers will attempt to auto-detect
+        whether suppression of other matchers is desirable. For example, at
+        the beginning of a line followed by `%` we expect a magic completion
+        to be the only applicable option, and after ``my_dict['`` we usually
+        expect a completion with an existing dictionary key.
+
+        If you want to disable this heuristic and see completions from all matchers,
+        set ``IPCompleter.suppress_competing_matchers = False``.
+        To disable the heuristic for specific matchers provide a dictionary mapping:
+        ``IPCompleter.suppress_competing_matchers = {'IPCompleter.dict_key_matcher': False}``.
+
+        Set ``IPCompleter.suppress_competing_matchers = True`` to limit
+        completions to the set of matchers with the highest priority;
+        this is equivalent to ``IPCompleter.merge_completions`` and
+        can be beneficial for performance, but will sometimes omit relevant
+        candidates from matchers further down the priority list.
+        """,
+    ).tag(config=True)
+
+    merge_completions = Bool(
+        True,
+        help="""Whether to merge completion results into a single list
+
+        If False, only the completion results from the first non-empty
+        completer will be returned.
+
+        As of version 8.6.0, setting the value to ``False`` is an alias for:
+        ``IPCompleter.suppress_competing_matchers = True.``.
+        """,
+    ).tag(config=True)
+
+    disable_matchers = ListTrait(
+        Unicode(),
+        help="""List of matchers to disable.
+
+        The list should contain matcher identifiers (see :any:`completion_matcher`).
+        """,
+    ).tag(config=True)
+
+    omit__names = Enum(
+        (0, 1, 2),
+        default_value=2,
+        help="""Instruct the completer to omit private method names
+
+        Specifically, when completing on ``object.<tab>``.
+
+        When 2 [default]: all names that start with '_' will be excluded.
+
+        When 1: all 'magic' names (``__foo__``) will be excluded.
+
+        When 0: nothing will be excluded.
+        """
+    ).tag(config=True)
+    limit_to__all__ = Bool(False,
+        help="""
+        DEPRECATED as of version 5.0.
 
-        Return a completer object suitable for use by the readline library
-        via readline.set_completer().
+        Instruct the completer to use __all__ for the completion
 
-        Inputs:
+        Specifically, when completing on ``object.<tab>``.
 
-        - shell: a pointer to the ipython shell itself.  This is needed
-        because this completer knows about magic functions, and those can
-        only be accessed via the ipython instance.
+        When True: only those names in obj.__all__ will be included.
 
-        - namespace: an optional dict where completions are performed.
+        When False [default]: the __all__ attribute is ignored
+        """,
+    ).tag(config=True)
 
-        - global_namespace: secondary optional dict for completions, to
-        handle cases (such as IPython embedded inside functions) where
-        both Python scopes are visible.
+    profile_completions = Bool(
+        default_value=False,
+        help="If True, emit profiling data for completion subsystem using cProfile."
+    ).tag(config=True)
 
-        - The optional omit__names parameter sets the completer to omit the
-        'magic' names (__magicname__) for python objects unless the text
-        to be completed explicitly starts with one or more underscores.
+    profiler_output_dir = Unicode(
+        default_value=".completion_profiles",
+        help="Template for path at which to output profile data for completions."
+    ).tag(config=True)
 
-        - If alias_table is supplied, it should be a dictionary of aliases
-        to complete.
+    @observe('limit_to__all__')
+    def _limit_to_all_changed(self, change):
+        warnings.warn('`IPython.core.IPCompleter.limit_to__all__` configuration '
+            'value has been deprecated since IPython 5.0, will be made to have '
+            'no effects and then removed in future version of IPython.',
+            UserWarning)
 
-        use_readline : bool, optional
-          If true, use the readline library.  This completer can still function
-          without readline, though in that case callers must provide some extra
-          information on each call about the current line."""
+    def __init__(
+        self, shell=None, namespace=None, global_namespace=None, config=None, **kwargs
+    ):
+        """IPCompleter() -> completer
+
+        Return a completer object.
 
-        Completer.__init__(self, namespace, global_namespace)
+        Parameters
+        ----------
+        shell
+            a pointer to the ipython shell itself.  This is needed
+            because this completer knows about magic functions, and those can
+            only be accessed via the ipython instance.
+        namespace : dict, optional
+            an optional dict where completions are performed.
+        global_namespace : dict, optional
+            secondary optional dict for completions, to
+            handle cases (such as IPython embedded inside functions) where
+            both Python scopes are visible.
+        config : Config
+            traitlet's config object
+        **kwargs
+            passed to super class unmodified.
+        """
 
         self.magic_escape = ESC_MAGIC
         self.splitter = CompletionSplitter()
 
-        # Readline configuration, only used by the rlcompleter method.
-        if use_readline:
-            # We store the right version of readline so that later code 
-            import IPython.utils.rlineimpl as readline
-            self.readline = readline
-        else:
-            self.readline = None
+        # _greedy_changed() depends on splitter and readline being defined:
+        super().__init__(
+            namespace=namespace,
+            global_namespace=global_namespace,
+            config=config,
+            **kwargs,
+        )
 
         # List where completion matches will be stored
         self.matches = []
-        self.omit__names = omit__names
-        self.merge_completions = shell.readline_merge_completions
-        self.shell = shell.shell
-        if alias_table is None:
-            alias_table = {}
-        self.alias_table = alias_table
+        self.shell = shell
         # Regexp to split filenames with spaces in them
         self.space_name_re = re.compile(r'([^\\] )')
         # Hold a local ref. to glob.glob for speed
@@ -441,36 +2098,98 @@ def __init__(self, shell, namespace=None, global_namespace=None,
         # buffers, to avoid completion problems.
         term = os.environ.get('TERM','xterm')
         self.dumb_terminal = term in ['dumb','emacs']
-        
+
         # Special handling of backslashes needed in win32 platforms
         if sys.platform == "win32":
             self.clean_glob = self._clean_glob_win32
         else:
             self.clean_glob = self._clean_glob
 
-        # All active matcher routines for completion
-        self.matchers = [self.python_matches,
-                         self.file_matches,
-                         self.magic_matches,
-                         self.alias_matches,
-                         self.python_func_kw_matches,
-                         ]
-    
-    def all_completions(self, text):
+        #regexp to parse docstring for function signature
+        self.docstring_sig_re = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
+        self.docstring_kwd_re = re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
+        #use this if positional argument name is also needed
+        #= re.compile(r'[\s|\[]*(\w+)(?:\s*=?\s*.*)')
+
+        self.magic_arg_matchers = [
+            self.magic_config_matcher,
+            self.magic_color_matcher,
+        ]
+
+        # This is set externally by InteractiveShell
+        self.custom_completers = None
+
+        # This is a list of names of unicode characters that can be completed
+        # into their corresponding unicode value. The list is large, so we
+        # lazily initialize it on first use. Consuming code should access this
+        # attribute through the `@unicode_names` property.
+        self._unicode_names = None
+
+        self._backslash_combining_matchers = [
+            self.latex_name_matcher,
+            self.unicode_name_matcher,
+            back_latex_name_matcher,
+            back_unicode_name_matcher,
+            self.fwd_unicode_matcher,
+        ]
+
+        if not self.backslash_combining_completions:
+            for matcher in self._backslash_combining_matchers:
+                self.disable_matchers.append(_get_matcher_id(matcher))
+
+        if not self.merge_completions:
+            self.suppress_competing_matchers = True
+
+    @property
+    def matchers(self) -> list[Matcher]:
+        """All active matcher routines for completion"""
+        if self.dict_keys_only:
+            return [self.dict_key_matcher]
+
+        if self.use_jedi:
+            return [
+                *self.custom_matchers,
+                *self._backslash_combining_matchers,
+                *self.magic_arg_matchers,
+                self.custom_completer_matcher,
+                self.magic_matcher,
+                self._jedi_matcher,
+                self.dict_key_matcher,
+                self.file_matcher,
+            ]
+        else:
+            return [
+                *self.custom_matchers,
+                *self._backslash_combining_matchers,
+                *self.magic_arg_matchers,
+                self.custom_completer_matcher,
+                self.dict_key_matcher,
+                self.magic_matcher,
+                self.python_matcher,
+                self.file_matcher,
+                self.python_func_kw_matcher,
+            ]
+
+    def all_completions(self, text: str) -> list[str]:
         """
-        Wrapper around the complete method for the benefit of emacs
-        and pydb.
+        Wrapper around the completion methods for the benefit of emacs.
         """
+        prefix = text.rpartition('.')[0]
+        with provisionalcompleter():
+            return ['.'.join([prefix, c.text]) if prefix and self.use_jedi else c.text
+                    for c in self.completions(text, len(text))]
+
         return self.complete(text)[1]
 
-    def _clean_glob(self,text):
+    def _clean_glob(self, text:str):
         return self.glob("%s*" % text)
 
-    def _clean_glob_win32(self,text):
+    def _clean_glob_win32(self, text:str):
         return [f.replace("\\","/")
-                for f in self.glob("%s*" % text)]            
+                for f in self.glob("%s*" % text)]
 
-    def file_matches(self, text):
+    @context_matcher()
+    def file_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
         """Match filenames, expanding ~USER type strings.
 
         Most of the seemingly convoluted logic in this completer is an
@@ -482,9 +2201,23 @@ def file_matches(self, text):
         only the parts after what's already been typed (instead of the
         full completions, as is normally done).  I don't think with the
         current (as of Python 2.3) Python readline it's possible to do
-        better."""
-
-        #io.rprint('Completer->file_matches: <%r>' % text) # dbg
+        better.
+        """
+        # TODO: add a heuristic for suppressing (e.g. if it has OS-specific delimiter,
+        #  starts with `/home/`, `C:\`, etc)
+
+        text = context.token
+        code_until_cursor = self._extract_code(context.text_until_cursor)
+        completion_type = self._determine_completion_context(code_until_cursor)
+        in_cli_context = self._is_completing_in_cli_context(code_until_cursor)
+        if (
+            completion_type == self._CompletionContextType.ATTRIBUTE
+            and not in_cli_context
+        ):
+            return {
+                "completions": [],
+                "suppress": False,
+            }
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
@@ -492,9 +2225,9 @@ def file_matches(self, text):
         # when escaped with backslash
         if text.startswith('!'):
             text = text[1:]
-            text_prefix = '!'
+            text_prefix = u'!'
         else:
-            text_prefix = ''
+            text_prefix = u''
 
         text_until_cursor = self.text_until_cursor
         # track strings with open quotes
@@ -511,7 +2244,10 @@ def file_matches(self, text):
                 if open_quotes:
                     lsplit = text_until_cursor.split(open_quotes)[-1]
                 else:
-                    return []
+                    return {
+                        "completions": [],
+                        "suppress": False,
+                    }
             except IndexError:
                 # tab pressed on empty line
                 lsplit = ""
@@ -525,61 +2261,559 @@ def file_matches(self, text):
             text = os.path.expanduser(text)
 
         if text == "":
-            return [text_prefix + protect_filename(f) for f in self.glob("*")]
+            return {
+                "completions": [
+                    SimpleCompletion(
+                        text=text_prefix + protect_filename(f), type="path"
+                    )
+                    for f in self.glob("*")
+                ],
+                "suppress": False,
+            }
 
         # Compute the matches from the filesystem
-        m0 = self.clean_glob(text.replace('\\',''))
+        if sys.platform == 'win32':
+            m0 = self.clean_glob(text)
+        else:
+            m0 = self.clean_glob(text.replace('\\', ''))
 
         if has_protectables:
             # If we had protectables, we need to revert our changes to the
             # beginning of filename so that we don't double-write the part
             # of the filename we have so far
             len_lsplit = len(lsplit)
-            matches = [text_prefix + text0 + 
+            matches = [text_prefix + text0 +
                        protect_filename(f[len_lsplit:]) for f in m0]
         else:
             if open_quotes:
                 # if we have a string with an open quote, we don't need to
-                # protect the names at all (and we _shouldn't_, as it
-                # would cause bugs when the filesystem call is made).
-                matches = m0
+                # protect the names beyond the quote (and we _shouldn't_, as
+                # it would cause bugs when the filesystem call is made).
+                matches = m0 if sys.platform == "win32" else\
+                    [protect_filename(f, open_quotes) for f in m0]
             else:
-                matches = [text_prefix + 
+                matches = [text_prefix +
                            protect_filename(f) for f in m0]
 
-        #io.rprint('mm', matches)  # dbg
-        return mark_dirs(matches)
+        # Mark directories in input list by appending '/' to their names.
+        return {
+            "completions": [
+                SimpleCompletion(text=x + "/" if os.path.isdir(x) else x, type="path")
+                for x in matches
+            ],
+            "suppress": False,
+        }
+
+    def _extract_code(self, line: str) -> str:
+        """Extract code from magics if any."""
+
+        if not line:
+            return line
+        maybe_magic, *rest = line.split(maxsplit=1)
+        if not rest:
+            return line
+        args = rest[0]
+        known_magics = self.shell.magics_manager.lsmagic()
+        line_magics = known_magics["line"]
+        magic_name = maybe_magic.lstrip(self.magic_escape)
+        if magic_name not in line_magics:
+            return line
+
+        if not maybe_magic.startswith(self.magic_escape):
+            all_variables = [*self.namespace.keys(), *self.global_namespace.keys()]
+            if magic_name in all_variables:
+                # short circuit if we see a line starting with say `time`
+                # but time is defined as a variable (in addition to being
+                # a magic). In these cases users need to use explicit `%time`.
+                return line
+
+        magic_method = line_magics[magic_name]
+
+        try:
+            if magic_name == "timeit":
+                opts, stmt = magic_method.__self__.parse_options(
+                    args,
+                    "n:r:tcp:qov:",
+                    posix=False,
+                    strict=False,
+                    preserve_non_opts=True,
+                )
+                return stmt
+            elif magic_name == "prun":
+                opts, stmt = magic_method.__self__.parse_options(
+                    args, "D:l:rs:T:q", list_all=True, posix=False
+                )
+                return stmt
+            elif hasattr(magic_method, "parser") and getattr(
+                magic_method, "has_arguments", False
+            ):
+                # e.g. %debug, %time
+                args, extra = magic_method.parser.parse_argstring(args, partial=True)
+                return " ".join(extra)
+        except UsageError:
+            return line
+
+        return line
+
+    @context_matcher()
+    def magic_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match magics."""
 
-    def magic_matches(self, text):
-        """Match magics"""
-        #print 'Completer->magic_matches:',text,'lb',self.text_until_cursor # dbg
         # Get all shell magics now rather than statically, so magics loaded at
-        # runtime show up too
-        magics = self.shell.lsmagic()
+        # runtime show up too.
+        text = context.token
+        lsm = self.shell.magics_manager.lsmagic()
+        line_magics = lsm['line']
+        cell_magics = lsm['cell']
         pre = self.magic_escape
-        baretext = text.lstrip(pre)
-        return [ pre+m for m in magics if m.startswith(baretext)]
+        pre2 = pre + pre
+
+        explicit_magic = text.startswith(pre)
+
+        # Completion logic:
+        # - user gives %%: only do cell magics
+        # - user gives %: do both line and cell magics
+        # - no prefix: do both
+        # In other words, line magics are skipped if the user gives %% explicitly
+        #
+        # We also exclude magics that match any currently visible names:
+        # https://github.com/ipython/ipython/issues/4877, unless the user has
+        # typed a %:
+        # https://github.com/ipython/ipython/issues/10754
+        bare_text = text.lstrip(pre)
+        global_matches = self.global_matches(bare_text)
+        if not explicit_magic:
+            def matches(magic):
+                """
+                Filter magics, in particular remove magics that match
+                a name present in global namespace.
+                """
+                return ( magic.startswith(bare_text) and
+                         magic not in global_matches )
+        else:
+            def matches(magic):
+                return magic.startswith(bare_text)
+
+        completions = [pre2 + m for m in cell_magics if matches(m)]
+        if not text.startswith(pre2):
+            completions += [pre + m for m in line_magics if matches(m)]
+
+        is_magic_prefix = len(text) > 0 and text[0] == "%"
+
+        return {
+            "completions": [
+                SimpleCompletion(text=comp, type="magic") for comp in completions
+            ],
+            "suppress": is_magic_prefix and len(completions) > 0,
+        }
+
+    @context_matcher()
+    def magic_config_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match class names and attributes for %config magic."""
+        # NOTE: uses `line_buffer` equivalent for compatibility
+        matches = self.magic_config_matches(context.line_with_cursor)
+        return _convert_matcher_v1_result_to_v2_no_no(matches, type="param")
+
+    def magic_config_matches(self, text: str) -> list[str]:
+        """Match class names and attributes for %config magic.
+
+        .. deprecated:: 8.6
+            You can use :meth:`magic_config_matcher` instead.
+        """
+        texts = text.strip().split()
+
+        if len(texts) > 0 and (texts[0] == 'config' or texts[0] == '%config'):
+            # get all configuration classes
+            classes = sorted(set([ c for c in self.shell.configurables
+                                   if c.__class__.class_traits(config=True)
+                                   ]), key=lambda x: x.__class__.__name__)
+            classnames = [ c.__class__.__name__ for c in classes ]
+
+            # return all classnames if config or %config is given
+            if len(texts) == 1:
+                return classnames
+
+            # match classname
+            classname_texts = texts[1].split('.')
+            classname = classname_texts[0]
+            classname_matches = [ c for c in classnames
+                                  if c.startswith(classname) ]
+
+            # return matched classes or the matched class with attributes
+            if texts[1].find('.') < 0:
+                return classname_matches
+            elif len(classname_matches) == 1 and \
+                            classname_matches[0] == classname:
+                cls = classes[classnames.index(classname)].__class__
+                help = cls.class_get_help()
+                # strip leading '--' from cl-args:
+                help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
+                return [ attr.split('=')[0]
+                         for attr in help.strip().splitlines()
+                         if attr.startswith(texts[1]) ]
+        return []
 
-    def alias_matches(self, text):
-        """Match internal system aliases"""        
-        #print 'Completer->alias_matches:',text,'lb',self.text_until_cursor # dbg
+    @context_matcher()
+    def magic_color_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match color schemes for %colors magic."""
+        text = context.line_with_cursor
+        texts = text.split()
+        if text.endswith(' '):
+            # .split() strips off the trailing whitespace. Add '' back
+            # so that: '%colors ' -> ['%colors', '']
+            texts.append('')
+
+        if len(texts) == 2 and (texts[0] == 'colors' or texts[0] == '%colors'):
+            prefix = texts[1]
+            return SimpleMatcherResult(
+                completions=[
+                    SimpleCompletion(color, type="param")
+                    for color in theme_table.keys()
+                    if color.startswith(prefix)
+                ],
+                suppress=False,
+            )
+        return SimpleMatcherResult(
+            completions=[],
+            suppress=False,
+        )
+
+    @context_matcher(identifier="IPCompleter.jedi_matcher")
+    def _jedi_matcher(self, context: CompletionContext) -> _JediMatcherResult:
+        matches = self._jedi_matches(
+            cursor_column=context.cursor_position,
+            cursor_line=context.cursor_line,
+            text=context.full_text,
+        )
+        return {
+            "completions": matches,
+            # static analysis should not suppress other matcher
+            # NOTE: file_matcher is automatically suppressed on attribute completions
+            "suppress": False,
+        }
+
+    def _jedi_matches(
+        self, cursor_column: int, cursor_line: int, text: str
+    ) -> Iterator[_JediCompletionLike]:
+        """
+        Return a list of :any:`jedi.api.Completion`\\s object from a ``text`` and
+        cursor position.
 
-        # if we are not in the first 'item', alias matching
-        # doesn't make sense - unless we are starting with 'sudo' command.
-        main_text = self.text_until_cursor.lstrip()
-        if ' ' in main_text and not main_text.startswith('sudo'):
-            return []
-        text = os.path.expanduser(text)
-        aliases =  self.alias_table.keys()
-        if text == '':
-            return aliases
-        else:
-            return [a for a in aliases if a.startswith(text)]
+        Parameters
+        ----------
+        cursor_column : int
+            column position of the cursor in ``text``, 0-indexed.
+        cursor_line : int
+            line position of the cursor in ``text``, 0-indexed
+        text : str
+            text to complete
 
-    def python_matches(self,text):
-        """Match attributes or global python names"""
+        Notes
+        -----
+        If ``IPCompleter.debug`` is ``True`` may return a :any:`_FakeJediCompletion`
+        object containing a string with the Jedi debug information attached.
+
+        .. deprecated:: 8.6
+            You can use :meth:`_jedi_matcher` instead.
+        """
+        namespaces = [self.namespace]
+        if self.global_namespace is not None:
+            namespaces.append(self.global_namespace)
+
+        completion_filter = lambda x:x
+        offset = cursor_to_position(text, cursor_line, cursor_column)
+        # filter output if we are completing for object members
+        if offset:
+            pre = text[offset-1]
+            if pre == '.':
+                if self.omit__names == 2:
+                    completion_filter = lambda c:not c.name.startswith('_')
+                elif self.omit__names == 1:
+                    completion_filter = lambda c:not (c.name.startswith('__') and c.name.endswith('__'))
+                elif self.omit__names == 0:
+                    completion_filter = lambda x:x
+                else:
+                    raise ValueError("Don't understand self.omit__names == {}".format(self.omit__names))
 
-        #print 'Completer->python_matches, txt=%r' % text # dbg
+        interpreter = jedi.Interpreter(text[:offset], namespaces)
+        try_jedi = True
+
+        try:
+            # find the first token in the current tree -- if it is a ' or " then we are in a string
+            completing_string = False
+            try:
+                first_child = next(c for c in interpreter._get_module().tree_node.children if hasattr(c, 'value'))
+            except StopIteration:
+                pass
+            else:
+                # note the value may be ', ", or it may also be ''' or """, or
+                # in some cases, """what/you/typed..., but all of these are
+                # strings.
+                completing_string = len(first_child.value) > 0 and first_child.value[0] in {"'", '"'}
+
+            # if we are in a string jedi is likely not the right candidate for
+            # now. Skip it.
+            try_jedi = not completing_string
+        except Exception as e:
+            # many of things can go wrong, we are using private API just don't crash.
+            if self.debug:
+                print("Error detecting if completing a non-finished string :", e, '|')
+
+        if not try_jedi:
+            return iter([])
+        try:
+            return filter(completion_filter, interpreter.complete(column=cursor_column, line=cursor_line + 1))
+        except Exception as e:
+            if self.debug:
+                return iter(
+                    [
+                        _FakeJediCompletion(
+                            'Oops Jedi has crashed, please report a bug with the following:\n"""\n%s\ns"""'
+                            % (e)
+                        )
+                    ]
+                )
+            else:
+                return iter([])
+
+    class _CompletionContextType(enum.Enum):
+        ATTRIBUTE = "attribute"  # For attribute completion
+        GLOBAL = "global"  # For global completion
+
+    def _determine_completion_context(self, line):
+        """
+        Determine whether the cursor is in an attribute or global completion context.
+        """
+        # Cursor in string/comment → GLOBAL.
+        is_string, is_in_expression = self._is_in_string_or_comment(line)
+        if is_string and not is_in_expression:
+            return self._CompletionContextType.GLOBAL
+
+        # If we're in a template string expression, handle specially
+        if is_string and is_in_expression:
+            # Extract the expression part - look for the last { that isn't closed
+            expr_start = line.rfind("{")
+            if expr_start >= 0:
+                # We're looking at the expression inside a template string
+                expr = line[expr_start + 1 :]
+                # Recursively determine the context of the expression
+                return self._determine_completion_context(expr)
+
+        # Handle plain number literals - should be global context
+        # Ex: 3. -42.14 but not 3.1.
+        if re.search(r"(?<!\w)(?<!\d\.)([-+]?\d+\.(\d+)?)(?!\w)$", line):
+            return self._CompletionContextType.GLOBAL
+
+        # Handle all other attribute matches np.ran, d[0].k, (a,b).count, obj._private
+        chain_match = re.search(r".*(.+(?<!\s)\.(?:[a-zA-Z_]\w*)?)$", line)
+        if chain_match:
+            return self._CompletionContextType.ATTRIBUTE
+
+        return self._CompletionContextType.GLOBAL
+
+    def _is_completing_in_cli_context(self, text: str) -> bool:
+        """
+        Determine if we are completing in a CLI alias, line magic, or bang expression context.
+        """
+        stripped = text.lstrip()
+        if stripped.startswith("!") or stripped.startswith("%"):
+            return True
+        # Check for CLI aliases
+        try:
+            tokens = stripped.split(None, 1)
+            if not tokens:
+                return False
+            first_token = tokens[0]
+
+            # Must have arguments after the command for this to apply
+            if len(tokens) < 2:
+                return False
+
+            # Check if first token is a known alias
+            if not any(
+                alias[0] == first_token for alias in self.shell.alias_manager.aliases
+            ):
+                return False
+
+            try:
+                if first_token in self.shell.user_ns:
+                    # There's a variable defined, so the alias is overshadowed
+                    return False
+            except (AttributeError, KeyError):
+                pass
+
+            return True
+        except Exception:
+            return False
+
+    def _is_in_string_or_comment(self, text):
+        """
+        Determine if the cursor is inside a string or comment.
+        Returns (is_string, is_in_expression) tuple:
+        - is_string: True if in any kind of string
+        - is_in_expression: True if inside an f-string/t-string expression
+        """
+        in_single_quote = False
+        in_double_quote = False
+        in_triple_single = False
+        in_triple_double = False
+        in_template_string = False  # Covers both f-strings and t-strings
+        in_expression = False  # For expressions in f/t-strings
+        expression_depth = 0  # Track nested braces in expressions
+        i = 0
+
+        while i < len(text):
+            # Check for f-string or t-string start
+            if (
+                i + 1 < len(text)
+                and text[i] in ("f", "t")
+                and (text[i + 1] == '"' or text[i + 1] == "'")
+                and not (
+                    in_single_quote
+                    or in_double_quote
+                    or in_triple_single
+                    or in_triple_double
+                )
+            ):
+                in_template_string = True
+                i += 1  # Skip the 'f' or 't'
+
+            # Handle triple quotes
+            if i + 2 < len(text):
+                if (
+                    text[i : i + 3] == '"""'
+                    and not in_single_quote
+                    and not in_triple_single
+                ):
+                    in_triple_double = not in_triple_double
+                    if not in_triple_double:
+                        in_template_string = False
+                    i += 3
+                    continue
+                if (
+                    text[i : i + 3] == "'''"
+                    and not in_double_quote
+                    and not in_triple_double
+                ):
+                    in_triple_single = not in_triple_single
+                    if not in_triple_single:
+                        in_template_string = False
+                    i += 3
+                    continue
+
+            # Handle escapes
+            if text[i] == "\\" and i + 1 < len(text):
+                i += 2
+                continue
+
+            # Handle nested braces within f-strings
+            if in_template_string:
+                # Special handling for consecutive opening braces
+                if i + 1 < len(text) and text[i : i + 2] == "{{":
+                    i += 2
+                    continue
+
+                # Detect start of an expression
+                if text[i] == "{":
+                    # Only increment depth and mark as expression if not already in an expression
+                    # or if we're at a top-level nested brace
+                    if not in_expression or (in_expression and expression_depth == 0):
+                        in_expression = True
+                        expression_depth += 1
+                    i += 1
+                    continue
+
+                # Detect end of an expression
+                if text[i] == "}":
+                    expression_depth -= 1
+                    if expression_depth <= 0:
+                        in_expression = False
+                        expression_depth = 0
+                    i += 1
+                    continue
+
+            in_triple_quote = in_triple_single or in_triple_double
+
+            # Handle quotes - also reset template string when closing quotes are encountered
+            if text[i] == '"' and not in_single_quote and not in_triple_quote:
+                in_double_quote = not in_double_quote
+                if not in_double_quote and not in_triple_quote:
+                    in_template_string = False
+            elif text[i] == "'" and not in_double_quote and not in_triple_quote:
+                in_single_quote = not in_single_quote
+                if not in_single_quote and not in_triple_quote:
+                    in_template_string = False
+
+            # Check for comment
+            if text[i] == "#" and not (
+                in_single_quote or in_double_quote or in_triple_quote
+            ):
+                return True, False
+
+            i += 1
+
+        is_string = (
+            in_single_quote or in_double_quote or in_triple_single or in_triple_double
+        )
+
+        # Return tuple (is_string, is_in_expression)
+        return (
+            is_string or (in_template_string and not in_expression),
+            in_expression and expression_depth > 0,
+        )
+
+    @context_matcher()
+    def python_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match attributes or global python names"""
+        text = context.text_until_cursor
+        text = self._extract_code(text)
+        in_cli_context = self._is_completing_in_cli_context(text)
+        if in_cli_context:
+            completion_type = self._CompletionContextType.GLOBAL
+        else:
+            completion_type = self._determine_completion_context(text)
+        if completion_type == self._CompletionContextType.ATTRIBUTE:
+            try:
+                matches, fragment = self._attr_matches(
+                    text, include_prefix=False, context=context
+                )
+                if text.endswith(".") and self.omit__names:
+                    if self.omit__names == 1:
+                        # true if txt is _not_ a __ name, false otherwise:
+                        no__name = lambda txt: re.match(r".*\.__.*?__", txt) is None
+                    else:
+                        # true if txt is _not_ a _ name, false otherwise:
+                        no__name = (
+                            lambda txt: re.match(r"\._.*?", txt[txt.rindex(".") :])
+                            is None
+                        )
+                    matches = filter(no__name, matches)
+                matches = _convert_matcher_v1_result_to_v2(
+                    matches, type="attribute", fragment=fragment
+                )
+                return matches
+            except NameError:
+                # catches <undefined attributes>.<tab>
+                return SimpleMatcherResult(completions=[], suppress=False)
+        else:
+            try:
+                matches = self.global_matches(context.token, context=context)
+            except TypeError:
+                matches = self.global_matches(context.token)
+            # TODO: maybe distinguish between functions, modules and just "variables"
+            return SimpleMatcherResult(
+                completions=[
+                    SimpleCompletion(text=match, type="variable") for match in matches
+                ],
+                suppress=False,
+            )
+
+    @completion_matcher(api_version=1)
+    def python_matches(self, text: str) -> Iterable[str]:
+        """Match attributes or global python names.
+
+        .. deprecated:: 8.27
+            You can use :meth:`python_matcher` instead."""
         if "." in text:
             try:
                 matches = self.attr_matches(text)
@@ -591,54 +2825,105 @@ def python_matches(self,text):
                     else:
                         # true if txt is _not_ a _ name, false otherwise:
                         no__name = (lambda txt:
-                                    re.match(r'.*\._.*?',txt) is None)
+                                    re.match(r'\._.*?',txt[txt.rindex('.'):]) is None)
                     matches = filter(no__name, matches)
             except NameError:
                 # catches <undefined attributes>.<tab>
                 matches = []
         else:
             matches = self.global_matches(text)
-
         return matches
 
+    def _default_arguments_from_docstring(self, doc):
+        """Parse the first line of docstring for call signature.
+
+        Docstring should be of the form 'min(iterable[, key=func])\n'.
+        It can also parse cython docstring of the form
+        'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)'.
+        """
+        if doc is None:
+            return []
+
+        #care only the firstline
+        line = doc.lstrip().splitlines()[0]
+
+        #p = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
+        #'min(iterable[, key=func])\n' -> 'iterable[, key=func]'
+        sig = self.docstring_sig_re.search(line)
+        if sig is None:
+            return []
+        # iterable[, key=func]' -> ['iterable[' ,' key=func]']
+        sig = sig.groups()[0].split(',')
+        ret = []
+        for s in sig:
+            #re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
+            ret += self.docstring_kwd_re.findall(s)
+        return ret
+
     def _default_arguments(self, obj):
         """Return the list of default arguments of obj if it is callable,
         or empty list otherwise."""
-
-        if not (inspect.isfunction(obj) or inspect.ismethod(obj)):
-            # for classes, check for __init__,__new__
+        call_obj = obj
+        ret = []
+        if inspect.isbuiltin(obj):
+            pass
+        elif not (inspect.isfunction(obj) or inspect.ismethod(obj)):
             if inspect.isclass(obj):
-                obj = (getattr(obj,'__init__',None) or
-                       getattr(obj,'__new__',None))
+                #for cython embedsignature=True the constructor docstring
+                #belongs to the object itself not __init__
+                ret += self._default_arguments_from_docstring(
+                            getattr(obj, '__doc__', ''))
+                # for classes, check for __init__,__new__
+                call_obj = (getattr(obj, '__init__', None) or
+                       getattr(obj, '__new__', None))
             # for all others, check if they are __call__able
             elif hasattr(obj, '__call__'):
-                obj = obj.__call__
-            # XXX: is there a way to handle the builtins ?
+                call_obj = obj.__call__
+        ret += self._default_arguments_from_docstring(
+                 getattr(call_obj, '__doc__', ''))
+
+        _keeps = (inspect.Parameter.KEYWORD_ONLY,
+                  inspect.Parameter.POSITIONAL_OR_KEYWORD)
+
         try:
-            args,_,_1,defaults = inspect.getargspec(obj)
-            if defaults:
-                return args[-len(defaults):]
-        except TypeError: pass
-        return []
+            sig = inspect.signature(obj)
+            ret.extend(k for k, v in sig.parameters.items() if
+                       v.kind in _keeps)
+        except ValueError:
+            pass
+
+        return list(set(ret))
 
-    def python_func_kw_matches(self,text):
-        """Match named parameters (kwargs) of the last open function"""
+    @context_matcher()
+    def python_func_kw_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match named parameters (kwargs) of the last open function."""
+        matches = self.python_func_kw_matches(context.token)
+        return _convert_matcher_v1_result_to_v2_no_no(matches, type="param")
+
+    def python_func_kw_matches(self, text):
+        """Match named parameters (kwargs) of the last open function.
+
+        .. deprecated:: 8.6
+            You can use :meth:`python_func_kw_matcher` instead.
+        """
 
         if "." in text: # a parameter cannot be dotted
             return []
         try: regexp = self.__funcParamsRegex
         except AttributeError:
             regexp = self.__funcParamsRegex = re.compile(r'''
-                '.*?' |    # single quoted strings or
-                ".*?" |    # double quoted strings or
-                \w+   |    # identifier
-                \S         # other characters
+                '.*?(?<!\\)' |    # single quoted strings or
+                ".*?(?<!\\)" |    # double quoted strings or
+                \w+          |    # identifier
+                \S                # other characters
                 ''', re.VERBOSE | re.DOTALL)
         # 1. find the nearest identifier that comes before an unclosed
-        # parenthesis e.g. for "foo (1+bar(x), pa", the candidate is "foo"
-        tokens = regexp.findall(self.line_buffer)
-        tokens.reverse()
-        iterTokens = iter(tokens); openPar = 0
+        # parenthesis before the cursor
+        # e.g. for "foo (1+bar(x), pa<cursor>,a=1)", the candidate is "foo"
+        tokens = regexp.findall(self.text_until_cursor)
+        iterTokens = reversed(tokens)
+        openPar = 0
+
         for token in iterTokens:
             if token == ')':
                 openPar -= 1
@@ -652,61 +2937,313 @@ def python_func_kw_matches(self,text):
         # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
         ids = []
         isId = re.compile(r'\w+$').match
+
         while True:
             try:
-                ids.append(iterTokens.next())
+                ids.append(next(iterTokens))
                 if not isId(ids[-1]):
-                    ids.pop(); break
-                if not iterTokens.next() == '.':
+                    ids.pop()
+                    break
+                if not next(iterTokens) == '.':
                     break
             except StopIteration:
                 break
-        # lookup the candidate callable matches either using global_matches
-        # or attr_matches for dotted names
-        if len(ids) == 1:
-            callableMatches = self.global_matches(ids[0])
-        else:
-            callableMatches = self.attr_matches('.'.join(ids[::-1]))
-        argMatches = []
-        for callableMatch in callableMatches:
-            try:
-                namedArgs = self._default_arguments(eval(callableMatch,
-                                                         self.namespace))
-            except:
+
+        # Find all named arguments already assigned to, as to avoid suggesting
+        # them again
+        usedNamedArgs = set()
+        par_level = -1
+        for token, next_token in zip(tokens, tokens[1:]):
+            if token == '(':
+                par_level += 1
+            elif token == ')':
+                par_level -= 1
+
+            if par_level != 0:
+                continue
+
+            if next_token != '=':
                 continue
-            for namedArg in namedArgs:
+
+            usedNamedArgs.add(token)
+
+        argMatches = []
+        try:
+            callableObj = '.'.join(ids[::-1])
+            namedArgs = self._default_arguments(eval(callableObj,
+                                                    self.namespace))
+
+            # Remove used named arguments from the list, no need to show twice
+            for namedArg in set(namedArgs) - usedNamedArgs:
                 if namedArg.startswith(text):
                     argMatches.append("%s=" %namedArg)
+        except:
+            pass
+
         return argMatches
 
+    @staticmethod
+    def _get_keys(obj: Any) -> list[Any]:
+        # Objects can define their own completions by defining an
+        # _ipy_key_completions_() method.
+        method = get_real_method(obj, '_ipython_key_completions_')
+        if method is not None:
+            return method()
+
+        # Special case some common in-memory dict-like types
+        if isinstance(obj, dict) or _safe_isinstance(obj, "pandas", "DataFrame"):
+            try:
+                return list(obj.keys())
+            except Exception:
+                return []
+        elif _safe_isinstance(obj, "pandas", "core", "indexing", "_LocIndexer"):
+            try:
+                return list(obj.obj.keys())
+            except Exception:
+                return []
+        elif _safe_isinstance(obj, 'numpy', 'ndarray') or\
+             _safe_isinstance(obj, 'numpy', 'void'):
+            return obj.dtype.names or []
+        return []
+
+    @context_matcher()
+    def dict_key_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match string keys in a dictionary, after e.g. ``foo[``."""
+        matches = self.dict_key_matches(context.token)
+        return _convert_matcher_v1_result_to_v2(
+            matches, type="dict key", suppress_if_matches=True
+        )
+
+    def dict_key_matches(self, text: str) -> list[str]:
+        """Match string keys in a dictionary, after e.g. ``foo[``.
+
+        .. deprecated:: 8.6
+            You can use :meth:`dict_key_matcher` instead.
+        """
+
+        # Short-circuit on closed dictionary (regular expression would
+        # not match anyway, but would take quite a while).
+        if self.text_until_cursor.strip().endswith("]"):
+            return []
+
+        match = DICT_MATCHER_REGEX.search(self.text_until_cursor)
+
+        if match is None:
+            return []
+
+        expr, prior_tuple_keys, key_prefix = match.groups()
+
+        obj = self._evaluate_expr(expr)
+
+        if obj is not_found:
+            return []
+
+        keys = self._get_keys(obj)
+        if not keys:
+            return keys
+
+        tuple_prefix = guarded_eval(
+            prior_tuple_keys,
+            EvaluationContext(
+                globals=self.global_namespace,
+                locals=self.namespace,
+                evaluation=self.evaluation,  # type: ignore
+                in_subscript=True,
+                auto_import=self._auto_import,
+                policy_overrides=self.policy_overrides,
+            ),
+        )
+
+        closing_quote, token_offset, matches = match_dict_keys(
+            keys, key_prefix, self.splitter.delims, extra_prefix=tuple_prefix
+        )
+        if not matches:
+            return []
+
+        # get the cursor position of
+        # - the text being completed
+        # - the start of the key text
+        # - the start of the completion
+        text_start = len(self.text_until_cursor) - len(text)
+        if key_prefix:
+            key_start = match.start(3)
+            completion_start = key_start + token_offset
+        else:
+            key_start = completion_start = match.end()
+
+        # grab the leading prefix, to make sure all completions start with `text`
+        if text_start > key_start:
+            leading = ''
+        else:
+            leading = text[text_start:completion_start]
+
+        # append closing quote and bracket as appropriate
+        # this is *not* appropriate if the opening quote or bracket is outside
+        # the text given to this method, e.g. `d["""a\nt
+        can_close_quote = False
+        can_close_bracket = False
+
+        continuation = self.line_buffer[len(self.text_until_cursor) :].strip()
+
+        if continuation.startswith(closing_quote):
+            # do not close if already closed, e.g. `d['a<tab>'`
+            continuation = continuation[len(closing_quote) :]
+        else:
+            can_close_quote = True
+
+        continuation = continuation.strip()
+
+        # e.g. `pandas.DataFrame` has different tuple indexer behaviour,
+        # handling it is out of scope, so let's avoid appending suffixes.
+        has_known_tuple_handling = isinstance(obj, dict)
+
+        can_close_bracket = (
+            not continuation.startswith("]") and self.auto_close_dict_keys
+        )
+        can_close_tuple_item = (
+            not continuation.startswith(",")
+            and has_known_tuple_handling
+            and self.auto_close_dict_keys
+        )
+        can_close_quote = can_close_quote and self.auto_close_dict_keys
+
+        # fast path if closing quote should be appended but not suffix is allowed
+        if not can_close_quote and not can_close_bracket and closing_quote:
+            return [leading + k for k in matches]
+
+        results = []
+
+        end_of_tuple_or_item = _DictKeyState.END_OF_TUPLE | _DictKeyState.END_OF_ITEM
+
+        for k, state_flag in matches.items():
+            result = leading + k
+            if can_close_quote and closing_quote:
+                result += closing_quote
+
+            if state_flag == end_of_tuple_or_item:
+                # We do not know which suffix to add,
+                # e.g. both tuple item and string
+                # match this item.
+                pass
+
+            if state_flag in end_of_tuple_or_item and can_close_bracket:
+                result += "]"
+            if state_flag == _DictKeyState.IN_TUPLE and can_close_tuple_item:
+                result += ", "
+            results.append(result)
+        return results
+
+    @context_matcher()
+    def unicode_name_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
+        """Match Latex-like syntax for unicode characters base
+        on the name of the character.
+
+        This does  ``\\GREEK SMALL LETTER ETA`` -> ``η``
+
+        Works only on valid python 3 identifier, or on combining characters that
+        will combine to form a valid identifier.
+        """
+
+        text = context.text_until_cursor
+
+        slashpos = text.rfind('\\')
+        if slashpos > -1:
+            s = text[slashpos+1:]
+            try :
+                unic = unicodedata.lookup(s)
+                # allow combining chars
+                if ('a'+unic).isidentifier():
+                    return {
+                        "completions": [SimpleCompletion(text=unic, type="unicode")],
+                        "suppress": True,
+                        "matched_fragment": "\\" + s,
+                    }
+            except KeyError:
+                pass
+        return {
+            "completions": [],
+            "suppress": False,
+        }
+
+    @context_matcher()
+    def latex_name_matcher(self, context: CompletionContext):
+        """Match Latex syntax for unicode characters.
+
+        This does both ``\\alp`` -> ``\\alpha`` and ``\\alpha`` -> ``α``
+        """
+        fragment, matches = self.latex_matches(context.text_until_cursor)
+        return _convert_matcher_v1_result_to_v2(
+            matches, type="latex", fragment=fragment, suppress_if_matches=True
+        )
+
+    def latex_matches(self, text: str) -> tuple[str, Sequence[str]]:
+        """Match Latex syntax for unicode characters.
+
+        This does both ``\\alp`` -> ``\\alpha`` and ``\\alpha`` -> ``α``
+
+        .. deprecated:: 8.6
+            You can use :meth:`latex_name_matcher` instead.
+        """
+        slashpos = text.rfind('\\')
+        if slashpos > -1:
+            s = text[slashpos:]
+            if s in latex_symbols:
+                # Try to complete a full latex symbol to unicode
+                # \\alpha -> α
+                return s, [latex_symbols[s]]
+            else:
+                # If a user has partially typed a latex symbol, give them
+                # a full list of options \al -> [\aleph, \alpha]
+                matches = [k for k in latex_symbols if k.startswith(s)]
+                if matches:
+                    return s, matches
+        return '', ()
+
+    @context_matcher()
+    def custom_completer_matcher(self, context):
+        """Dispatch custom completer.
+
+        If a match is found, suppresses all other matchers except for Jedi.
+        """
+        matches = self.dispatch_custom_completer(context.token) or []
+        result = _convert_matcher_v1_result_to_v2(
+            matches, type=_UNKNOWN_TYPE, suppress_if_matches=True
+        )
+        result["ordered"] = True
+        result["do_not_suppress"] = {_get_matcher_id(self._jedi_matcher)}
+        return result
+
     def dispatch_custom_completer(self, text):
-        #print "Custom! '%s' %s" % (text, self.custom_completers) # dbg
-        line = self.line_buffer        
+        """
+        .. deprecated:: 8.6
+            You can use :meth:`custom_completer_matcher` instead.
+        """
+        if not self.custom_completers:
+            return
+
+        line = self.line_buffer
         if not line.strip():
             return None
-        
+
         # Create a little structure to pass all the relevant information about
         # the current completion to any custom completer.
-        event = Bunch()
+        event = SimpleNamespace()
         event.line = line
         event.symbol = text
         cmd = line.split(None,1)[0]
         event.command = cmd
         event.text_until_cursor = self.text_until_cursor
-        
-        #print "\ncustom:{%s]\n" % event # dbg
-        
+
         # for foo etc, try also to find completer for %foo
         if not cmd.startswith(self.magic_escape):
             try_magic = self.custom_completers.s_matches(
-                self.magic_escape + cmd)            
+                self.magic_escape + cmd)
         else:
-            try_magic = []        
-        
+            try_magic = []
+
         for c in itertools.chain(self.custom_completers.s_matches(cmd),
                  try_magic,
                  self.custom_completers.flat_matches(self.text_until_cursor)):
-            #print "try",c # dbg
             try:
                 res = c(event)
                 if res:
@@ -719,151 +3256,595 @@ def dispatch_custom_completer(self, text):
                     return [r for r in res if r.lower().startswith(text_low)]
             except TryNext:
                 pass
-            
+            except KeyboardInterrupt:
+                """
+                If custom completer take too long,
+                let keyboard interrupt abort and return nothing.
+                """
+                break
+
         return None
-               
-    def complete(self, text=None, line_buffer=None, cursor_pos=None):
-        """Find completions for the given text and line context.
 
-        This is called successively with state == 0, 1, 2, ... until it
-        returns None.  The completion should begin with 'text'.
+    def completions(self, text: str, offset: int)->Iterator[Completion]:
+        """
+        Returns an iterator over the possible completions
+
+        .. warning::
+
+            Unstable
+
+            This function is unstable, API may change without warning.
+            It will also raise unless use in proper context manager.
+
+        Parameters
+        ----------
+        text : str
+            Full text of the current input, multi line string.
+        offset : int
+            Integer representing the position of the cursor in ``text``. Offset
+            is 0-based indexed.
+
+        Yields
+        ------
+        Completion
+
+        Notes
+        -----
+        The cursor on a text can either be seen as being "in between"
+        characters or "On" a character depending on the interface visible to
+        the user. For consistency the cursor being on "in between" characters X
+        and Y is equivalent to the cursor being "on" character Y, that is to say
+        the character the cursor is on is considered as being after the cursor.
+
+        Combining characters may span more that one position in the
+        text.
+
+        .. note::
+
+            If ``IPCompleter.debug`` is :py:data:`True` will yield a ``--jedi/ipython--``
+            fake Completion token to distinguish completion returned by Jedi
+            and usual IPython completion.
+
+        .. note::
+
+            Completions are not completely deduplicated yet. If identical
+            completions are coming from different sources this function does not
+            ensure that each completion object will only be present once.
+        """
+        warnings.warn("_complete is a provisional API (as of IPython 6.0). "
+                      "It may change without warnings. "
+                      "Use in corresponding context manager.",
+                      category=ProvisionalCompleterWarning, stacklevel=2)
+
+        seen = set()
+        profiler:Optional[cProfile.Profile]
+        try:
+            if self.profile_completions:
+                import cProfile
+                profiler = cProfile.Profile()
+                profiler.enable()
+            else:
+                profiler = None
+
+            for c in self._completions(text, offset, _timeout=self.jedi_compute_type_timeout/1000):
+                if c and (c in seen):
+                    continue
+                yield c
+                seen.add(c)
+        except KeyboardInterrupt:
+            """if completions take too long and users send keyboard interrupt,
+            do not crash and return ASAP. """
+            pass
+        finally:
+            if profiler is not None:
+                profiler.disable()
+                ensure_dir_exists(self.profiler_output_dir)
+                output_path = os.path.join(self.profiler_output_dir, str(uuid.uuid4()))
+                print("Writing profiler output to", output_path)
+                profiler.dump_stats(output_path)
+
+    def _completions(self, full_text: str, offset: int, *, _timeout) -> Iterator[Completion]:
+        """
+        Core completion module.Same signature as :any:`completions`, with the
+        extra `timeout` parameter (in seconds).
+
+        Computing jedi's completion ``.type`` can be quite expensive (it is a
+        lazy property) and can require some warm-up, more warm up than just
+        computing the ``name`` of a completion. The warm-up can be :
+
+            - Long warm-up the first time a module is encountered after
+            install/update: actually build parse/inference tree.
+
+            - first time the module is encountered in a session: load tree from
+            disk.
+
+        We don't want to block completions for tens of seconds so we give the
+        completer a "budget" of ``_timeout`` seconds per invocation to compute
+        completions types, the completions that have not yet been computed will
+        be marked as "unknown" an will have a chance to be computed next round
+        are things get cached.
+
+        Keep in mind that Jedi is not the only thing treating the completion so
+        keep the timeout short-ish as if we take more than 0.3 second we still
+        have lots of processing to do.
+
+        """
+        deadline = time.monotonic() + _timeout
+
+        before = full_text[:offset]
+        cursor_line, cursor_column = position_to_cursor(full_text, offset)
+
+        jedi_matcher_id = _get_matcher_id(self._jedi_matcher)
+
+        def is_non_jedi_result(
+            result: MatcherResult, identifier: str
+        ) -> TypeGuard[SimpleMatcherResult]:
+            return identifier != jedi_matcher_id
+
+        results = self._complete(
+            full_text=full_text, cursor_line=cursor_line, cursor_pos=cursor_column
+        )
+
+        non_jedi_results: dict[str, SimpleMatcherResult] = {
+            identifier: result
+            for identifier, result in results.items()
+            if is_non_jedi_result(result, identifier)
+        }
+
+        jedi_matches = (
+            cast(_JediMatcherResult, results[jedi_matcher_id])["completions"]
+            if jedi_matcher_id in results
+            else ()
+        )
+
+        iter_jm = iter(jedi_matches)
+        if _timeout:
+            for jm in iter_jm:
+                try:
+                    type_ = jm.type
+                except Exception:
+                    if self.debug:
+                        print("Error in Jedi getting type of ", jm)
+                    type_ = None
+                delta = len(jm.name_with_symbols) - len(jm.complete)
+                if type_ == 'function':
+                    signature = _make_signature(jm)
+                else:
+                    signature = ''
+                yield Completion(start=offset - delta,
+                                 end=offset,
+                                 text=jm.name_with_symbols,
+                                 type=type_,
+                                 signature=signature,
+                                 _origin='jedi')
+
+                if time.monotonic() > deadline:
+                    break
+
+        for jm in iter_jm:
+            delta = len(jm.name_with_symbols) - len(jm.complete)
+            yield Completion(
+                start=offset - delta,
+                end=offset,
+                text=jm.name_with_symbols,
+                type=_UNKNOWN_TYPE,  # don't compute type for speed
+                _origin="jedi",
+                signature="",
+            )
+
+        # TODO:
+        # Suppress this, right now just for debug.
+        if jedi_matches and non_jedi_results and self.debug:
+            some_start_offset = before.rfind(
+                next(iter(non_jedi_results.values()))["matched_fragment"]
+            )
+            yield Completion(
+                start=some_start_offset,
+                end=offset,
+                text="--jedi/ipython--",
+                _origin="debug",
+                type="none",
+                signature="",
+            )
+
+        ordered: list[Completion] = []
+        sortable: list[Completion] = []
+
+        for origin, result in non_jedi_results.items():
+            matched_text = result["matched_fragment"]
+            start_offset = before.rfind(matched_text)
+            is_ordered = result.get("ordered", False)
+            container = ordered if is_ordered else sortable
+
+            # I'm unsure if this is always true, so let's assert and see if it
+            # crash
+            assert before.endswith(matched_text)
+
+            for simple_completion in result["completions"]:
+                completion = Completion(
+                    start=start_offset,
+                    end=offset,
+                    text=simple_completion.text,
+                    _origin=origin,
+                    signature="",
+                    type=simple_completion.type or _UNKNOWN_TYPE,
+                )
+                container.append(completion)
+
+        yield from list(self._deduplicate(ordered + self._sort(sortable)))[
+            :MATCHES_LIMIT
+        ]
+
+    def complete(
+        self, text=None, line_buffer=None, cursor_pos=None
+    ) -> tuple[str, Sequence[str]]:
+        """Find completions for the given text and line context.
 
         Note that both the text and the line_buffer are optional, but at least
         one of them must be given.
 
         Parameters
         ----------
-          text : string, optional
+        text : string, optional
             Text to perform the completion on.  If not given, the line buffer
             is split using the instance's CompletionSplitter object.
-
-          line_buffer : string, optional
+        line_buffer : string, optional
             If not given, the completer attempts to obtain the current line
             buffer via readline.  This keyword allows clients which are
             requesting for text completions in non-readline contexts to inform
             the completer of the entire text.
-
-          cursor_pos : int, optional
+        cursor_pos : int, optional
             Index of the cursor in the full line buffer.  Should be provided by
             remote frontends where kernel has no access to frontend state.
 
         Returns
         -------
+        Tuple of two items:
         text : str
-          Text that was actually used in the completion.
-          
+            Text that was actually used in the completion.
         matches : list
-          A list of completion matches.
+            A list of completion matches.
+
+        Notes
+        -----
+            This API is likely to be deprecated and replaced by
+            :any:`IPCompleter.completions` in the future.
+
+        """
+        warnings.warn('`Completer.complete` is pending deprecation since '
+                'IPython 6.0 and will be replaced by `Completer.completions`.',
+                      PendingDeprecationWarning)
+        # potential todo, FOLD the 3rd throw away argument of _complete
+        # into the first 2 one.
+        # TODO: Q: does the above refer to jedi completions (i.e. 0-indexed?)
+        # TODO: should we deprecate now, or does it stay?
+
+        results = self._complete(
+            line_buffer=line_buffer, cursor_pos=cursor_pos, text=text, cursor_line=0
+        )
+
+        jedi_matcher_id = _get_matcher_id(self._jedi_matcher)
+
+        return self._arrange_and_extract(
+            results,
+            # TODO: can we confirm that excluding Jedi here was a deliberate choice in previous version?
+            skip_matchers={jedi_matcher_id},
+            # this API does not support different start/end positions (fragments of token).
+            abort_if_offset_changes=True,
+        )
+
+    def _arrange_and_extract(
+        self,
+        results: dict[str, MatcherResult],
+        skip_matchers: set[str],
+        abort_if_offset_changes: bool,
+    ):
+        sortable: list[AnyMatcherCompletion] = []
+        ordered: list[AnyMatcherCompletion] = []
+        most_recent_fragment = None
+        for identifier, result in results.items():
+            if identifier in skip_matchers:
+                continue
+            if not result["completions"]:
+                continue
+            if not most_recent_fragment:
+                most_recent_fragment = result["matched_fragment"]
+            if (
+                abort_if_offset_changes
+                and result["matched_fragment"] != most_recent_fragment
+            ):
+                break
+            if result.get("ordered", False):
+                ordered.extend(result["completions"])
+            else:
+                sortable.extend(result["completions"])
+
+        if not most_recent_fragment:
+            most_recent_fragment = ""  # to satisfy typechecker (and just in case)
+
+        return most_recent_fragment, [
+            m.text for m in self._deduplicate(ordered + self._sort(sortable))
+        ]
+
+    def _complete(self, *, cursor_line, cursor_pos, line_buffer=None, text=None,
+                  full_text=None) -> _CompleteResult:
+        """
+        Like complete but can also returns raw jedi completions as well as the
+        origin of the completion text. This could (and should) be made much
+        cleaner but that will be simpler once we drop the old (and stateful)
+        :any:`complete` API.
+
+        With current provisional API, cursor_pos act both (depending on the
+        caller) as the offset in the ``text`` or ``line_buffer``, or as the
+        ``column`` when passing multiline strings this could/should be renamed
+        but would add extra noise.
+
+        Parameters
+        ----------
+        cursor_line
+            Index of the line the cursor is on. 0 indexed.
+        cursor_pos
+            Position of the cursor in the current line/line_buffer/text. 0
+            indexed.
+        line_buffer : optional, str
+            The current line the cursor is in, this is mostly due to legacy
+            reason that readline could only give a us the single current line.
+            Prefer `full_text`.
+        text : str
+            The current "token" the cursor is in, mostly also for historical
+            reasons. as the completer would trigger only after the current line
+            was parsed.
+        full_text : str
+            Full text of the current cell.
+
+        Returns
+        -------
+        An ordered dictionary where keys are identifiers of completion
+        matchers and values are ``MatcherResult``s.
         """
-        #io.rprint('\nCOMP1 %r %r %r' % (text, line_buffer, cursor_pos))  # dbg
 
         # if the cursor position isn't given, the only sane assumption we can
         # make is that it's at the end of the line (the common case)
         if cursor_pos is None:
             cursor_pos = len(line_buffer) if text is None else len(text)
 
+        if self.use_main_ns:
+            self.namespace = __main__.__dict__
+
         # if text is either None or an empty string, rely on the line buffer
-        if not text:
-            text = self.splitter.split_line(line_buffer, cursor_pos)
+        if (not line_buffer) and full_text:
+            line_buffer = full_text.split('\n')[cursor_line]
+        if not text:  # issue #11508: check line_buffer before calling split_line
+            text = (
+                self.splitter.split_line(line_buffer, cursor_pos) if line_buffer else ""
+            )
 
         # If no line buffer is given, assume the input text is all there was
         if line_buffer is None:
             line_buffer = text
-        
+
+        # deprecated - do not use `line_buffer` in new code.
         self.line_buffer = line_buffer
         self.text_until_cursor = self.line_buffer[:cursor_pos]
-        #io.rprint('\nCOMP2 %r %r %r' % (text, line_buffer, cursor_pos))  # dbg
+
+        if not full_text:
+            full_text = line_buffer
+
+        context = CompletionContext(
+            full_text=full_text,
+            cursor_position=cursor_pos,
+            cursor_line=cursor_line,
+            token=self._extract_code(text),
+            limit=MATCHES_LIMIT,
+        )
 
         # Start with a clean slate of completions
-        self.matches[:] = []
-        custom_res = self.dispatch_custom_completer(text)
-        if custom_res is not None:
-            # did custom completers produce something?
-            self.matches = custom_res
-        else:
-            # Extend the list of completions with the results of each
-            # matcher, so we return results to the user from all
-            # namespaces.
-            if self.merge_completions:
-                self.matches = []
-                for matcher in self.matchers:
-                    try:
-                        self.matches.extend(matcher(text))
-                    except:
-                        # Show the ugly traceback if the matcher causes an
-                        # exception, but do NOT crash the kernel!
-                        sys.excepthook(*sys.exc_info())
-            else:
-                for matcher in self.matchers:
-                    self.matches = matcher(text)
-                    if self.matches:
-                        break
-        # FIXME: we should extend our api to return a dict with completions for
-        # different types of objects.  The rlcomplete() method could then
-        # simply collapse the dict into a list for readline, but we'd have
-        # richer completion semantics in other evironments.
-        self.matches = sorted(set(self.matches))
-        #io.rprint('COMP TEXT, MATCHES: %r, %r' % (text, self.matches)) # dbg
-        return text, self.matches
-
-    def rlcomplete(self, text, state):
-        """Return the state-th possible completion for 'text'.
+        results: dict[str, MatcherResult] = {}
 
-        This is called successively with state == 0, 1, 2, ... until it
-        returns None.  The completion should begin with 'text'.
+        jedi_matcher_id = _get_matcher_id(self._jedi_matcher)
 
-        Parameters
-        ----------
-          text : string
-            Text to perform the completion on.
+        suppressed_matchers: set[str] = set()
 
-          state : int
-            Counter used by readline.
-        """
-        if state==0:
+        matchers = {
+            _get_matcher_id(matcher): matcher
+            for matcher in sorted(
+                self.matchers, key=_get_matcher_priority, reverse=True
+            )
+        }
 
-            self.line_buffer = line_buffer = self.readline.get_line_buffer()
-            cursor_pos = self.readline.get_endidx()
+        for matcher_id, matcher in matchers.items():
+            matcher_id = _get_matcher_id(matcher)
 
-            #io.rprint("\nRLCOMPLETE: %r %r %r" %
-            #          (text, line_buffer, cursor_pos) ) # dbg
+            if matcher_id in self.disable_matchers:
+                continue
 
-            # if there is only a tab on a line with only whitespace, instead of
-            # the mostly useless 'do you want to see all million completions'
-            # message, just do the right thing and give the user his tab!
-            # Incidentally, this enables pasting of tabbed text from an editor
-            # (as long as autoindent is off).
+            if matcher_id in results:
+                warnings.warn(f"Duplicate matcher ID: {matcher_id}.")
 
-            # It should be noted that at least pyreadline still shows file
-            # completions - is there a way around it?
+            if matcher_id in suppressed_matchers:
+                continue
 
-            # don't apply this on 'dumb' terminals, such as emacs buffers, so
-            # we don't interfere with their own tab-completion mechanism.
-            if not (self.dumb_terminal or line_buffer.strip()):
-                self.readline.insert_text('\t')
-                sys.stdout.flush()
-                return None
+            result: MatcherResult
+            try:
+                if _is_matcher_v1(matcher):
+                    result = _convert_matcher_v1_result_to_v2_no_no(
+                        matcher(text), type=_UNKNOWN_TYPE
+                    )
+                elif _is_matcher_v2(matcher):
+                    result = matcher(context)
+                else:
+                    api_version = _get_matcher_api_version(matcher)
+                    raise ValueError(f"Unsupported API version {api_version}")
+            except BaseException:
+                # Show the ugly traceback if the matcher causes an
+                # exception, but do NOT crash the kernel!
+                sys.excepthook(*sys.exc_info())
+                continue
+
+            # set default value for matched fragment if suffix was not selected.
+            result["matched_fragment"] = result.get("matched_fragment", context.token)
+
+            if not suppressed_matchers:
+                suppression_recommended: Union[bool, set[str]] = result.get(
+                    "suppress", False
+                )
+
+                suppression_config = (
+                    self.suppress_competing_matchers.get(matcher_id, None)
+                    if isinstance(self.suppress_competing_matchers, dict)
+                    else self.suppress_competing_matchers
+                )
+                should_suppress = (
+                    (suppression_config is True)
+                    or (suppression_recommended and (suppression_config is not False))
+                ) and has_any_completions(result)
+
+                if should_suppress:
+                    suppression_exceptions: set[str] = result.get(
+                        "do_not_suppress", set()
+                    )
+                    if isinstance(suppression_recommended, Iterable):
+                        to_suppress = set(suppression_recommended)
+                    else:
+                        to_suppress = set(matchers)
+                    suppressed_matchers = to_suppress - suppression_exceptions
+
+                    new_results = {}
+                    for previous_matcher_id, previous_result in results.items():
+                        if previous_matcher_id not in suppressed_matchers:
+                            new_results[previous_matcher_id] = previous_result
+                    results = new_results
+
+            results[matcher_id] = result
+
+        _, matches = self._arrange_and_extract(
+            results,
+            # TODO Jedi completions non included in legacy stateful API; was this deliberate or omission?
+            #  if it was omission, we can remove the filtering step, otherwise remove this comment.
+            skip_matchers={jedi_matcher_id},
+            abort_if_offset_changes=False,
+        )
+
+        # populate legacy stateful API
+        self.matches = matches
+
+        return results
+
+    @staticmethod
+    def _deduplicate(
+        matches: Sequence[AnyCompletion],
+    ) -> Iterable[AnyCompletion]:
+        filtered_matches: dict[str, AnyCompletion] = {}
+        for match in matches:
+            text = match.text
+            if (
+                text not in filtered_matches
+                or filtered_matches[text].type == _UNKNOWN_TYPE
+            ):
+                filtered_matches[text] = match
+
+        return filtered_matches.values()
+
+    @staticmethod
+    def _sort(matches: Sequence[AnyCompletion]):
+        return sorted(matches, key=lambda x: completions_sorting_key(x.text))
+
+    @context_matcher()
+    def fwd_unicode_matcher(self, context: CompletionContext):
+        """Same as :any:`fwd_unicode_match`, but adopted to new Matcher API."""
+        # TODO: use `context.limit` to terminate early once we matched the maximum
+        #  number that will be used downstream; can be added as an optional to
+        #  `fwd_unicode_match(text: str, limit: int = None)` or we could re-implement here.
+        fragment, matches = self.fwd_unicode_match(context.text_until_cursor)
+        return _convert_matcher_v1_result_to_v2(
+            matches, type="unicode", fragment=fragment, suppress_if_matches=True
+        )
+
+    def fwd_unicode_match(self, text: str) -> tuple[str, Sequence[str]]:
+        """
+        Forward match a string starting with a backslash with a list of
+        potential Unicode completions.
+
+        Will compute list of Unicode character names on first call and cache it.
+
+        .. deprecated:: 8.6
+            You can use :meth:`fwd_unicode_matcher` instead.
+
+        Returns
+        -------
+        At tuple with:
+            - matched text (empty if no matches)
+            - list of potential completions, empty tuple  otherwise)
+        """
+        # TODO: self.unicode_names is here a list we traverse each time with ~100k elements.
+        # We could do a faster match using a Trie.
+
+        # Using pygtrie the following seem to work:
+
+        #     s = PrefixSet()
+
+        #     for c in range(0,0x10FFFF + 1):
+        #         try:
+        #             s.add(unicodedata.name(chr(c)))
+        #         except ValueError:
+        #             pass
+        #     [''.join(k) for k in s.iter(prefix)]
+
+        # But need to be timed and adds an extra dependency.
+
+        slashpos = text.rfind('\\')
+        # if text starts with slash
+        if slashpos > -1:
+            # PERF: It's important that we don't access self._unicode_names
+            # until we're inside this if-block. _unicode_names is lazily
+            # initialized, and it takes a user-noticeable amount of time to
+            # initialize it, so we don't want to initialize it unless we're
+            # actually going to use it.
+            s = text[slashpos + 1 :]
+            sup = s.upper()
+            candidates = [x for x in self.unicode_names if x.startswith(sup)]
+            if candidates:
+                return s, candidates
+            candidates = [x for x in self.unicode_names if sup in x]
+            if candidates:
+                return s, candidates
+            splitsup = sup.split(" ")
+            candidates = [
+                x for x in self.unicode_names if all(u in x for u in splitsup)
+            ]
+            if candidates:
+                return s, candidates
+
+            return "", ()
+
+        # if text does not start with slash
+        else:
+            return '', ()
 
-            # Note: debugging exceptions that may occur in completion is very
-            # tricky, because readline unconditionally silences them.  So if
-            # during development you suspect a bug in the completion code, turn
-            # this flag on temporarily by uncommenting the second form (don't
-            # flip the value in the first line, as the '# dbg' marker can be
-            # automatically detected and is used elsewhere).
-            DEBUG = False
-            #DEBUG = True # dbg
-            if DEBUG:
+    @property
+    def unicode_names(self) -> list[str]:
+        """List of names of unicode code points that can be completed.
+
+        The list is lazily initialized on first access.
+        """
+        if self._unicode_names is None:
+            names = []
+            for c in range(0,0x10FFFF + 1):
                 try:
-                    self.complete(text, line_buffer, cursor_pos)
-                except:
-                    import traceback; traceback.print_exc()
-            else:
-                # The normal production version is here
-                
-                # This method computes the self.matches array
-                self.complete(text, line_buffer, cursor_pos)
+                    names.append(unicodedata.name(chr(c)))
+                except ValueError:
+                    pass
+            self._unicode_names = _unicode_name_compute(_UNICODE_RANGES)
 
-        try:
-            return self.matches[state]
-        except IndexError:
-            return None
+        return self._unicode_names
+
+
+def _unicode_name_compute(ranges: list[tuple[int, int]]) -> list[str]:
+    names = []
+    for start,stop in ranges:
+        for c in range(start, stop) :
+            try:
+                names.append(unicodedata.name(chr(c)))
+            except ValueError:
+                pass
+    return names
diff --git a/IPython/core/completerlib.py b/IPython/core/completerlib.py
index 95f0e4bce02..f15490f2a96 100644
--- a/IPython/core/completerlib.py
+++ b/IPython/core/completerlib.py
@@ -1,9 +1,10 @@
+# encoding: utf-8
 """Implementations for various useful completers.
 
 These are all loaded by default by IPython.
 """
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2010 The IPython Development Team.
+#  Copyright (C) 2010-2011 The IPython Development Team.
 #
 #  Distributed under the terms of the BSD License.
 #
@@ -13,30 +14,35 @@
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib imports
 import glob
 import inspect
 import os
 import re
-import shlex
 import sys
+from importlib import import_module
+from importlib.machinery import all_suffixes
+
 
 # Third-party imports
 from time import time
 from zipimport import zipimporter
 
 # Our own imports
-from IPython.core.completer import expand_user, compress_user
-from IPython.core.error import TryNext
+from .completer import expand_user, compress_user
+from .error import TryNext
+from ..utils._process_common import arg_split
 
 # FIXME: this should be pulled in with the right call via the component system
-from IPython.core.ipapi import get as get_ipython
+from IPython import get_ipython
+
+from typing import List
 
 #-----------------------------------------------------------------------------
 # Globals and constants
 #-----------------------------------------------------------------------------
+_suffixes = all_suffixes()
 
 # Time in seconds after which the rootmodules will be stored permanently in the
 # ipython ip.db database (kept in the user's .ipython dir).
@@ -46,140 +52,160 @@
 TIMEOUT_GIVEUP = 20
 
 # Regular expression for the python import statement
-import_re = re.compile(r'.*(\.so|\.py[cod]?)$')
+import_re = re.compile(r'(?P<name>[^\W\d]\w*?)'
+                       r'(?P<package>[/\\]__init__)?'
+                       r'(?P<suffix>%s)$' %
+                       r'|'.join(re.escape(s) for s in _suffixes))
 
 # RE for the ipython %run command (python + ipython scripts)
-magic_run_re = re.compile(r'.*(\.ipy|\.py[w]?)$')
+magic_run_re = re.compile(r'.*(\.ipy|\.ipynb|\.py[w]?)$')
 
 #-----------------------------------------------------------------------------
 # Local utilities
 #-----------------------------------------------------------------------------
 
-def shlex_split(x):
-    """Helper function to split lines into segments.
-    """
-    # shlex.split raises an exception if there is a syntax error in sh syntax
-    # for example if no closing " is found. This function keeps dropping the
-    # last character of the line until shlex.split does not raise
-    # an exception. It adds end of the line to the result of shlex.split
-    #
-    # Example:
-    # %run "c:/python -> ['%run','"c:/python']
-
-    # shlex.split has unicode bugs, so encode first to str
-    if isinstance(x, unicode):
-        x = x.encode(sys.stdin.encoding)
-
-    endofline = []
-    while x != '':
-        try:
-            comps = shlex.split(x)
-            if len(endofline) >= 1:
-                comps.append(''.join(endofline))
-            return comps
-        
-        except ValueError:
-            endofline = [x[-1:]]+endofline
-            x = x[:-1]
-
-    return [''.join(endofline)]
-
-def module_list(path):
+
+def module_list(path: str) -> List[str]:
     """
     Return the list containing the names of the modules available in the given
     folder.
     """
+    # sys.path has the cwd as an empty string, but isdir/listdir need it as '.'
+    if path == '':
+        path = '.'
+
+    # A few local constants to be used in loops below
+    pjoin = os.path.join
 
     if os.path.isdir(path):
-        folder_list = os.listdir(path)
-    elif path.endswith('.egg'):
-        try:
-            folder_list = [f for f in zipimporter(path)._files]
-        except:
-            folder_list = []
-    else:
-        folder_list = []
+        # Build a list of all files in the directory and all files
+        # in its subdirectories. For performance reasons, do not
+        # recurse more than one level into subdirectories.
+        files: List[str] = []
+        for root, dirs, nondirs in os.walk(path, followlinks=True):
+            subdir = root[len(path)+1:]
+            if subdir:
+                files.extend(pjoin(subdir, f) for f in nondirs)
+                dirs[:] = [] # Do not recurse into additional subdirectories.
+            else:
+                files.extend(nondirs)
 
-    if not folder_list:
-        return []
+    else:
+        try:
+            files = list(zipimporter(path)._files.keys())  # type: ignore
+        except Exception:
+            files = []
 
-    # A few local constants to be used in loops below
-    isfile = os.path.isfile
-    pjoin = os.path.join
-    basename = os.path.basename
-    
-    # Now find actual path matches for packages or modules
-    folder_list = [p for p in folder_list
-                   if isfile(pjoin(path, p,'__init__.py'))
-                   or import_re.match(p) ]
+    # Build a list of modules which match the import_re regex.
+    modules = []
+    for f in files:
+        m = import_re.match(f)
+        if m:
+            modules.append(m.group('name'))
+    return list(set(modules))
 
-    return [basename(p).split('.')[0] for p in folder_list]
 
 def get_root_modules():
     """
     Returns a list containing the names of all the modules available in the
     folders of the pythonpath.
+
+    ip.db['rootmodules_cache'] maps sys.path entries to list of modules.
     """
     ip = get_ipython()
+    if ip is None:
+        # No global shell instance to store cached list of modules.
+        # Don't try to scan for modules every time.
+        return list(sys.builtin_module_names)
 
-    if 'rootmodules' in ip.db:
-        return ip.db['rootmodules']
-    
-    t = time()
+    if getattr(ip.db, "_mock", False):
+        rootmodules_cache = {}
+    else:
+        rootmodules_cache = ip.db.get("rootmodules_cache", {})
+    rootmodules = list(sys.builtin_module_names)
+    start_time = time()
     store = False
-    modules = list(sys.builtin_module_names)
     for path in sys.path:
-        modules += module_list(path)        
-        if time() - t >= TIMEOUT_STORAGE and not store:
-            store = True
-            print("\nCaching the list of root modules, please wait!")
-            print("(This will only be done once - type '%rehashx' to "
-                  "reset cache!)\n")
-            sys.stdout.flush()
-        if time() - t > TIMEOUT_GIVEUP:
-            print("This is taking too long, we give up.\n")
-            ip.db['rootmodules'] = []
-            return []
-    
-    modules = set(modules)
-    if '__init__' in modules:
-        modules.remove('__init__')
-    modules = list(modules)
+        try:
+            modules = rootmodules_cache[path]
+        except KeyError:
+            modules = module_list(path)
+            try:
+                modules.remove('__init__')
+            except ValueError:
+                pass
+            if path not in ('', '.'): # cwd modules should not be cached
+                rootmodules_cache[path] = modules
+            if time() - start_time > TIMEOUT_STORAGE and not store:
+                store = True
+                print("\nCaching the list of root modules, please wait!")
+                print("(This will only be done once - type '%rehashx' to "
+                      "reset cache!)\n")
+                sys.stdout.flush()
+            if time() - start_time > TIMEOUT_GIVEUP:
+                print("This is taking too long, we give up.\n")
+                return []
+        rootmodules.extend(modules)
     if store:
-        ip.db['rootmodules'] = modules
-    return modules
+        ip.db['rootmodules_cache'] = rootmodules_cache
+    rootmodules = list(set(rootmodules))
+    return rootmodules
 
 
-def is_importable(module, attr, only_modules):
+def is_importable(module, attr: str, only_modules) -> bool:
     if only_modules:
-        return inspect.ismodule(getattr(module, attr))
+        try:
+            mod = getattr(module, attr)
+        except ModuleNotFoundError:
+            # See gh-14434
+            return False
+        return inspect.ismodule(mod)
     else:
         return not(attr[:2] == '__' and attr[-2:] == '__')
 
+def is_possible_submodule(module, attr):
+    try:
+        obj = getattr(module, attr)
+    except AttributeError:
+        # Is possibly an unimported submodule
+        return True
+    except TypeError:
+        # https://github.com/ipython/ipython/issues/9678
+        return False
+    return inspect.ismodule(obj)
+
 
-def try_import(mod, only_modules=False):
+def try_import(mod: str, only_modules=False) -> List[str]:
+    """
+    Try to import given module and return list of potential completions.
+    """
+    mod = mod.rstrip('.')
     try:
-        m = __import__(mod)
+        m = import_module(mod)
     except:
         return []
-    mods = mod.split('.')
-    for module in mods[1:]:
-        m = getattr(m, module)
 
-    m_is_init = hasattr(m, '__file__') and '__init__' in m.__file__
+    m_is_init = '__init__' in (getattr(m, '__file__', '') or '')
 
     completions = []
     if (not hasattr(m, '__file__')) or (not only_modules) or m_is_init:
         completions.extend( [attr for attr in dir(m) if
                              is_importable(m, attr, only_modules)])
-        
-    completions.extend(getattr(m, '__all__', []))
+
+    m_all = getattr(m, "__all__", [])
+    if only_modules:
+        completions.extend(attr for attr in m_all if is_possible_submodule(m, attr))
+    else:
+        completions.extend(m_all)
+
     if m_is_init:
-        completions.extend(module_list(os.path.dirname(m.__file__)))
-    completions = set(completions)
-    if '__init__' in completions:
-        completions.remove('__init__')
-    return list(completions)
+        file_ = m.__file__
+        file_path = os.path.dirname(file_)  # type: ignore
+        if file_path is not None:
+            completions.extend(module_list(file_path))
+    completions_set = {c for c in completions if isinstance(c, str)}
+    completions_set.discard('__init__')
+    return list(completions_set)
 
 
 #-----------------------------------------------------------------------------
@@ -187,28 +213,27 @@ def try_import(mod, only_modules=False):
 #-----------------------------------------------------------------------------
 
 def quick_completer(cmd, completions):
-    """ Easily create a trivial completer for a command.
+    r""" Easily create a trivial completer for a command.
 
     Takes either a list of completions, or all completions in string (that will
     be split on whitespace).
-    
+
     Example::
-    
+
         [d:\ipython]|1> import ipy_completers
         [d:\ipython]|2> ipy_completers.quick_completer('foo', ['bar','baz'])
         [d:\ipython]|3> foo b<TAB>
         bar baz
         [d:\ipython]|3> foo ba
     """
-    
-    if isinstance(completions, basestring):
+
+    if isinstance(completions, str):
         completions = completions.split()
 
     def do_complete(self, event):
         return completions
-    
-    get_ipython().set_hook('complete_command',do_complete, str_key = cmd)
 
+    get_ipython().set_hook('complete_command',do_complete, str_key = cmd)
 
 def module_completion(line):
     """
@@ -225,9 +250,9 @@ def module_completion(line):
     # from whatever <tab> -> 'import '
     if nwords == 3 and words[0] == 'from':
         return ['import ']
-    
+
     # 'from xy<tab>' or 'import xy<tab>'
-    if nwords < 3 and (words[0] in ['import','from']) :
+    if nwords < 3 and (words[0] in {'%aimport', 'import', 'from'}) :
         if nwords == 1:
             return get_root_modules()
         mod = words[1].split('.')
@@ -235,7 +260,7 @@ def module_completion(line):
             return get_root_modules()
         completion_list = try_import('.'.join(mod[:-1]), True)
         return ['.'.join(mod[:-1] + [el]) for el in completion_list]
-    
+
     # 'from xyz import abc<tab>'
     if nwords >= 3 and words[0] == 'from':
         mod = words[1]
@@ -262,10 +287,14 @@ def module_completer(self,event):
 # completers, that is currently reimplemented in each.
 
 def magic_run_completer(self, event):
-    """Complete files that end in .py or .ipy for the %run command.
+    """Complete files that end in .py or .ipy or .ipynb for the %run command.
     """
-    comps = shlex_split(event.line)
-    relpath = (len(comps) > 1 and comps[-1] or '').strip("'\"")
+    comps = arg_split(event.line, strict=False)
+    # relpath should be the current token that we need to complete.
+    if (len(comps) > 1) and (not event.line.endswith(' ')):
+        relpath = comps[-1].strip("'\"")
+    else:
+        relpath = ''
 
     #print("\nev=", event)  # dbg
     #print("rp=", relpath)  # dbg
@@ -274,21 +303,24 @@ def magic_run_completer(self, event):
     lglob = glob.glob
     isdir = os.path.isdir
     relpath, tilde_expand, tilde_val = expand_user(relpath)
-        
-    dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*') if isdir(f)]
 
     # Find if the user has already typed the first filename, after which we
     # should complete on all files, since after the first one other files may
     # be arguments to the input script.
 
-    if filter(magic_run_re.match, comps):
-        pys =  [f.replace('\\','/') for f in lglob('*')]
+    if any(magic_run_re.match(c) for c in comps):
+        matches =  [f.replace('\\','/') + ('/' if isdir(f) else '')
+                            for f in lglob(relpath+'*')]
     else:
+        dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*') if isdir(f)]
         pys =  [f.replace('\\','/')
                 for f in lglob(relpath+'*.py') + lglob(relpath+'*.ipy') +
-                lglob(relpath + '*.pyw')]
+                lglob(relpath+'*.ipynb') + lglob(relpath + '*.pyw')]
+
+        matches = dirs + pys
+
     #print('run comp:', dirs+pys) # dbg
-    return [compress_user(p, tilde_expand, tilde_val) for p in dirs+pys]
+    return [compress_user(p, tilde_expand, tilde_val) for p in matches]
 
 
 def cd_completer(self, event):
@@ -304,7 +336,7 @@ def cd_completer(self, event):
             return bkms.keys()
         else:
             return []
-    
+
     if event.symbol == '-':
         width_dh = str(len(str(len(ip.user_ns['_dh']) + 1)))
         # jump in directory history by number
@@ -328,7 +360,7 @@ def cd_completer(self, event):
             # we don't want to deal with any of that, complex code
             # for this is elsewhere
             raise TryNext
-        
+
         found.append(d)
 
     if not found:
@@ -336,11 +368,15 @@ def cd_completer(self, event):
             return [compress_user(relpath, tilde_expand, tilde_val)]
 
         # if no completions so far, try bookmarks
-        bks = self.db.get('bookmarks',{}).iterkeys()
+        bks = self.db.get('bookmarks',{})
         bkmatches = [s for s in bks if s.startswith(event.symbol)]
         if bkmatches:
             return bkmatches
-        
+
         raise TryNext
 
     return [compress_user(p, tilde_expand, tilde_val) for p in found]
+
+def reset_completer(self, event):
+    "A completer for %reset magic"
+    return '-f -s in out array dhist'.split()
diff --git a/IPython/core/crashhandler.py b/IPython/core/crashhandler.py
index 00f0a68543f..9887b8718a2 100644
--- a/IPython/core/crashhandler.py
+++ b/IPython/core/crashhandler.py
@@ -1,4 +1,3 @@
-# encoding: utf-8
 """sys.excepthook for IPython itself, leaves a detailed report on disk.
 
 Authors:
@@ -9,7 +8,7 @@
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
-#  Copyright (C) 2008-2010  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -19,44 +18,75 @@
 # Imports
 #-----------------------------------------------------------------------------
 
-import os
 import sys
+import traceback
 from pprint import pformat
+from pathlib import Path
+
+import builtins as builtin_mod
 
 from IPython.core import ultratb
-from IPython.external.Itpl import itpl
+from IPython.core.application import Application
+from IPython.core.release import author_email
 from IPython.utils.sysinfo import sys_info
 
+from IPython.core.release import __version__ as version
+
+from typing import Optional, Dict
+import types
+
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 # Template for the user message.
 _default_message_template = """\
-Oops, $self.app_name crashed. We do our best to make it stable, but...
+Oops, {app_name} crashed. We do our best to make it stable, but...
 
 A crash report was automatically generated with the following information:
   - A verbatim copy of the crash traceback.
   - A copy of your input history during this session.
-  - Data on your current $self.app_name configuration.
+  - Data on your current {app_name} configuration.
 
 It was left in the file named:
-\t'$self.crash_report_fname'
+\t'{crash_report_fname}'
 If you can email this file to the developers, the information in it will help
 them in understanding and correcting the problem.
 
-You can mail it to: $self.contact_name at $self.contact_email
-with the subject '$self.app_name Crash Report'.
+You can mail it to: {contact_name} at {contact_email}
+with the subject '{app_name} Crash Report'.
 
 If you want to do it now, the following command will work (under Unix):
-mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
+mail -s '{app_name} Crash Report' {contact_email} < {crash_report_fname}
+
+In your email, please also include information about:
+- The operating system under which the crash happened: Linux, macOS, Windows,
+  other, and which exact version (for example: Ubuntu 16.04.3, macOS 10.13.2,
+  Windows 10 Pro), and whether it is 32-bit or 64-bit;
+- How {app_name} was installed: using pip or conda, from GitHub, as part of
+  a Docker container, or other, providing more detail if possible;
+- How to reproduce the crash: what exact sequence of instructions can one
+  input to get the same crash? Ideally, find a minimal yet complete sequence
+  of instructions that yields the crash.
 
 To ensure accurate tracking of this issue, please file a report about it at:
-$self.bug_tracker
+{bug_tracker}
+"""
+
+_lite_message_template = """
+If you suspect this is an IPython {version} bug, please report it at:
+    https://github.com/ipython/ipython/issues
+or send an email to the mailing list at {email}
+
+You can print a more detailed traceback right now with "%tb", or use "%debug"
+to interactively debug it.
+
+Extra-detailed tracebacks for bug-reporting purposes can be enabled via:
+    {config}Application.verbose_crash=True
 """
 
 
-class CrashHandler(object):
+class CrashHandler:
     """Customizable crash handlers for IPython applications.
 
     Instances of this class provide a :meth:`__call__` method which can be
@@ -66,68 +96,86 @@ def __call__(self, etype, evalue, etb)
     """
 
     message_template = _default_message_template
-
-    def __init__(self, app, contact_name=None, contact_email=None, 
-                 bug_tracker=None, show_crash_traceback=True, call_pdb=False):
+    section_sep = '\n\n'+'*'*75+'\n\n'
+    info: Dict[str, Optional[str]]
+
+    def __init__(
+        self,
+        app: Application,
+        contact_name: Optional[str] = None,
+        contact_email: Optional[str] = None,
+        bug_tracker: Optional[str] = None,
+        show_crash_traceback: bool = True,
+        call_pdb: bool = False,
+    ):
         """Create a new crash handler
 
         Parameters
         ----------
-        app :  Application
-            A running :class:`Application` instance, which will be queried at 
+        app : Application
+            A running :class:`Application` instance, which will be queried at
             crash time for internal information.
-
         contact_name : str
             A string with the name of the person to contact.
-
         contact_email : str
             A string with the email address of the contact.
-
         bug_tracker : str
             A string with the URL for your project's bug tracker.
-
         show_crash_traceback : bool
             If false, don't print the crash traceback on stderr, only generate
             the on-disk report
+        call_pdb
+            Whether to call pdb on crash
 
-        Non-argument instance attributes:
-
+        Attributes
+        ----------
         These instances contain some non-argument attributes which allow for
         further customization of the crash handler's behavior. Please see the
         source for further details.
+
         """
+        self.crash_report_fname = "Crash_report_%s.txt" % app.name
         self.app = app
-        self.app_name = self.app.name
-        self.contact_name = contact_name
-        self.contact_email = contact_email
-        self.bug_tracker = bug_tracker
-        self.crash_report_fname = "Crash_report_%s.txt" % self.app_name
-        self.show_crash_traceback = show_crash_traceback
-        self.section_sep = '\n\n'+'*'*75+'\n\n'
         self.call_pdb = call_pdb
         #self.call_pdb = True # dbg
-
-    def __call__(self, etype, evalue, etb):
+        self.show_crash_traceback = show_crash_traceback
+        self.info = dict(app_name = app.name,
+                    contact_name = contact_name,
+                    contact_email = contact_email,
+                    bug_tracker = bug_tracker,
+                    crash_report_fname = self.crash_report_fname)
+
+    def __call__(
+        self,
+        etype: type[BaseException],
+        evalue: BaseException,
+        etb: types.TracebackType,
+    ) -> None:
         """Handle an exception, call for compatible with sys.excepthook"""
 
-        # Report tracebacks shouldn't use color in general (safer for users)
-        color_scheme = 'NoColor'
+        # do not allow the crash handler to be called twice without reinstalling it
+        # this prevents unlikely errors in the crash handling from entering an
+        # infinite loop.
+        sys.excepthook = sys.__excepthook__
+        
 
         # Use this ONLY for developer debugging (keep commented out for release)
-        #color_scheme = 'Linux'   # dbg
-        try:
-            rptdir = self.app.ipython_dir
-        except:
-            rptdir = os.getcwd()
-        if rptdir is None or not os.path.isdir(rptdir):
-            rptdir = os.getcwd()
-        report_name = os.path.join(rptdir,self.crash_report_fname)
+        ipython_dir = getattr(self.app, "ipython_dir", None)
+        if ipython_dir is not None:
+            assert isinstance(ipython_dir, str)
+            rptdir = Path(ipython_dir)
+        else:
+            rptdir = Path.cwd()
+        if not rptdir.is_dir():
+            rptdir = Path.cwd()
+        report_name = rptdir / self.crash_report_fname
         # write the report filename into the instance dict so it can get
         # properly expanded out in the user message template
-        self.crash_report_fname = report_name
+        self.crash_report_fname = str(report_name)
+        self.info["crash_report_fname"] = str(report_name)
         TBhandler = ultratb.VerboseTB(
-            color_scheme=color_scheme,
-            long_header=1,
+            theme_name="nocolor",
+            long_header=True,
             call_pdb=self.call_pdb,
         )
         if self.call_pdb:
@@ -138,38 +186,39 @@ def __call__(self, etype, evalue, etb):
 
         # print traceback to screen
         if self.show_crash_traceback:
-            print >> sys.stderr, traceback
+            print(traceback, file=sys.stderr)
 
         # and generate a complete report on disk
         try:
-            report = open(report_name,'w')
+            report = open(report_name, "w", encoding="utf-8")
         except:
-            print >> sys.stderr, 'Could not create crash report on disk.'
+            print('Could not create crash report on disk.', file=sys.stderr)
             return
 
-        # Inform user on stderr of what happened
-        msg = itpl('\n'+'*'*70+'\n'+self.message_template)
-        print >> sys.stderr, msg
+        with report:
+            # Inform user on stderr of what happened
+            print('\n'+'*'*70+'\n', file=sys.stderr)
+            print(self.message_template.format(**self.info), file=sys.stderr)
 
-        # Construct report on disk
-        report.write(self.make_report(traceback))
-        report.close()
-        raw_input("Hit <Enter> to quit this message (your terminal may close):")
+            # Construct report on disk
+            report.write(self.make_report(str(traceback)))
 
-    def make_report(self,traceback):
+        builtin_mod.input("Hit <Enter> to quit (your terminal may close):")
+
+    def make_report(self, traceback: str) -> str:
         """Return a string containing a crash report."""
-        
+
         sec_sep = self.section_sep
-        
+
         report = ['*'*75+'\n\n'+'IPython post-mortem report\n\n']
         rpt_add = report.append
         rpt_add(sys_info())
-        
+
         try:
             config = pformat(self.app.config)
             rpt_add(sec_sep)
-            rpt_add('Application name: %s\n\n' % self.app_name)
-            rpt_add('Current user configuration structure:\n\n')
+            rpt_add("Application name: %s\n\n" % self.app.name)
+            rpt_add("Current user configuration structure:\n\n")
             rpt_add(config)
         except:
             pass
@@ -177,3 +226,19 @@ def make_report(self,traceback):
 
         return ''.join(report)
 
+
+def crash_handler_lite(
+    etype: type[BaseException], evalue: BaseException, tb: types.TracebackType
+) -> None:
+    """a light excepthook, adding a small message to the usual traceback"""
+    traceback.print_exception(etype, evalue, tb)
+    
+    from IPython.core.interactiveshell import InteractiveShell
+    if InteractiveShell.initialized():
+        # we are in a Shell environment, give %magic example
+        config = "%config "
+    else:
+        # we are not in a shell, show generic config
+        config = "c."
+    print(_lite_message_template.format(email=author_email, config=config, version=version), file=sys.stderr)
+
diff --git a/IPython/core/debugger.py b/IPython/core/debugger.py
index 225e0824529..9b1c2bb45ae 100644
--- a/IPython/core/debugger.py
+++ b/IPython/core/debugger.py
@@ -1,7 +1,97 @@
-# -*- coding: utf-8 -*-
 """
 Pdb debugger class.
 
+
+This is an extension to PDB which adds a number of new features.
+Note that there is also the `IPython.terminal.debugger` class which provides UI
+improvements.
+
+We also strongly recommend to use this via the `ipdb` package, which provides
+extra configuration options.
+
+Among other things, this subclass of PDB:
+ - supports many IPython magics like pdef/psource
+ - hide frames in tracebacks based on `__tracebackhide__`
+ - allows to skip frames based on `__debuggerskip__`
+
+
+Global Configuration
+--------------------
+
+The IPython debugger will by read the global ``~/.pdbrc`` file.
+That is to say you can list all commands supported by ipdb in your `~/.pdbrc`
+configuration file, to globally configure pdb.
+
+Example::
+
+   # ~/.pdbrc
+   skip_predicates debuggerskip false
+   skip_hidden false
+   context 25
+
+Features
+--------
+
+The IPython debugger can hide and skip frames when printing or moving through
+the stack. This can have a performance impact, so can be configures.
+
+The skipping and hiding frames are configurable via the `skip_predicates`
+command.
+
+By default, frames from readonly files will be hidden, frames containing
+``__tracebackhide__ = True`` will be hidden.
+
+Frames containing ``__debuggerskip__`` will be stepped over, frames whose parent
+frames value of ``__debuggerskip__`` is ``True`` will also be skipped.
+
+    >>> def helpers_helper():
+    ...     pass
+    ...
+    ... def helper_1():
+    ...     print("don't step in me")
+    ...     helpers_helpers() # will be stepped over unless breakpoint set.
+    ...
+    ...
+    ... def helper_2():
+    ...     print("in me neither")
+    ...
+
+One can define a decorator that wraps a function between the two helpers:
+
+    >>> def pdb_skipped_decorator(function):
+    ...
+    ...
+    ...     def wrapped_fn(*args, **kwargs):
+    ...         __debuggerskip__ = True
+    ...         helper_1()
+    ...         __debuggerskip__ = False
+    ...         result = function(*args, **kwargs)
+    ...         __debuggerskip__ = True
+    ...         helper_2()
+    ...         # setting __debuggerskip__ to False again is not necessary
+    ...         return result
+    ...
+    ...     return wrapped_fn
+
+When decorating a function, ipdb will directly step into ``bar()`` by
+default:
+
+    >>> @foo_decorator
+    ... def bar(x, y):
+    ...     return x * y
+
+
+You can toggle the behavior with
+
+    ipdb> skip_predicates debuggerskip false
+
+or configure it in your ``.pdbrc``
+
+
+
+License
+-------
+
 Modified from the standard pdb.Pdb class to avoid including readline, so that
 the command line completion of other programs which include this isn't
 damaged.
@@ -9,13 +99,19 @@
 In the future, this class will be expanded with improvements over the standard
 pdb.
 
-The code in this file is mainly lifted out of cmd.py in Python 2.2, with minor
-changes. Licensing should therefore be under the standard Python terms.  For
-details on the PSF (Python Software Foundation) standard license, see:
+The original code in this file is mainly lifted out of cmd.py in Python 2.2,
+with minor changes. Licensing should therefore be under the standard Python
+terms.  For details on the PSF (Python Software Foundation) standard license,
+see:
+
+https://docs.python.org/2/license.html
 
-http://www.python.org/2.2.3/license.html"""
 
-#*****************************************************************************
+All the changes since then are under the same license as IPython.
+
+"""
+
+# *****************************************************************************
 #
 #       This file is licensed under the PSF license.
 #
@@ -23,410 +119,758 @@
 #       Copyright (C) 2005-2006 Fernando Perez. <fperez@colorado.edu>
 #
 #
-#*****************************************************************************
+# *****************************************************************************
+
+from __future__ import annotations
 
-import bdb
+import inspect
 import linecache
+import os
+import re
 import sys
+import warnings
+from contextlib import contextmanager
+from functools import lru_cache
 
+from IPython import get_ipython
+from IPython.core.debugger_backport import PdbClosureBackport
 from IPython.utils import PyColorize
-from IPython.core import ipapi
-from IPython.utils import coloransi, io
-from IPython.core.excolors import exception_colors
-
-# See if we can use pydb.
-has_pydb = False
-prompt = 'ipdb> '
-#We have to check this directly from sys.argv, config struct not yet available
-if '-pydb' in sys.argv:
-    try:        
-        import pydb
-        if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
-            # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
-            # better protect against it.
-            has_pydb = True
-    except ImportError:
-        print "Pydb (http://bashdb.sourceforge.net/pydb/) does not seem to be available"
-
-if has_pydb:
-    from pydb import Pdb as OldPdb
-    #print "Using pydb for %run -d and post-mortem" #dbg
-    prompt = 'ipydb> '
-else:
-    from pdb import Pdb as OldPdb
+from IPython.utils.PyColorize import TokenStream
 
-# Allow the set_trace code to operate outside of an ipython instance, even if
-# it does so with some limitations.  The rest of this support is implemented in
-# the Tracer constructor.
-def BdbQuit_excepthook(et,ev,tb):
-    if et==bdb.BdbQuit:
-        print 'Exiting Debugger.'
-    else:
-        BdbQuit_excepthook.excepthook_ori(et,ev,tb)
+from typing import TYPE_CHECKING
+from types import FrameType
 
-def BdbQuit_IPython_excepthook(self,et,ev,tb):
-    print 'Exiting Debugger.'
+# We have to check this directly from sys.argv, config struct not yet available
+from pdb import Pdb as _OldPdb
+from pygments.token import Token
 
 
-class Tracer(object):
-    """Class for local debugging, similar to pdb.set_trace.
+if sys.version_info < (3, 13):
 
-    Instances of this class, when called, behave like pdb.set_trace, but
-    providing IPython's enhanced capabilities.
+    class OldPdb(PdbClosureBackport, _OldPdb):
+        pass
 
-    This is implemented as a class which must be initialized in your own code
-    and not as a standalone function because we need to detect at runtime
-    whether IPython is already active or not.  That detection is done in the
-    constructor, ensuring that this code plays nicely with a running IPython,
-    while functioning acceptably (though with limitations) if outside of it.
-    """
+else:
+    OldPdb = _OldPdb
 
-    def __init__(self,colors=None):
-        """Create a local debugger instance.
+if TYPE_CHECKING:
+    # otherwise circular import
+    from IPython.core.interactiveshell import InteractiveShell
 
-        :Parameters:
+# skip module docstests
+__skip_doctest__ = True
 
-          - `colors` (None): a string containing the name of the color scheme to
-        use, it must be one of IPython's valid color schemes.  If not given, the
-        function will default to the current IPython scheme when running inside
-        IPython, and to 'NoColor' otherwise.
+prompt = "ipdb> "
 
-        Usage example:
 
-        from IPython.core.debugger import Tracer; debug_here = Tracer()
+# Allow the set_trace code to operate outside of an ipython instance, even if
+# it does so with some limitations.  The rest of this support is implemented in
+# the Tracer constructor.
 
-        ... later in your code
-        debug_here()  # -> will open up the debugger at that point.
+DEBUGGERSKIP = "__debuggerskip__"
 
-        Once the debugger activates, you can use all of its regular commands to
-        step through code, set breakpoints, etc.  See the pdb documentation
-        from the Python standard library for usage details.
-        """
 
-        try:
-            ip = ipapi.get()
-        except:
-            # Outside of ipython, we set our own exception hook manually
-            BdbQuit_excepthook.excepthook_ori = sys.excepthook
-            sys.excepthook = BdbQuit_excepthook
-            def_colors = 'NoColor'
-            try:
-                # Limited tab completion support
-                import readline
-                readline.parse_and_bind('tab: complete')
-            except ImportError:
-                pass
-        else:
-            # In ipython, we use its custom exception handler mechanism
-            def_colors = ip.colors
-            ip.set_custom_exc((bdb.BdbQuit,), BdbQuit_IPython_excepthook)
+# this has been implemented in Pdb in Python 3.13 (https://github.com/python/cpython/pull/106676
+# on lower python versions, we backported the feature.
+CHAIN_EXCEPTIONS = sys.version_info < (3, 13)
 
-        if colors is None:
-            colors = def_colors
-        self.debugger = Pdb(colors)
 
-    def __call__(self):
-        """Starts an interactive debugger at the point where called.
+def BdbQuit_excepthook(et, ev, tb, excepthook=None):
+    """Exception hook which handles `BdbQuit` exceptions.
 
-        This is similar to the pdb.set_trace() function from the std lib, but
-        using IPython's enhanced debugger."""
-        
-        self.debugger.set_trace(sys._getframe().f_back)
+    All other exceptions are processed using the `excepthook`
+    parameter.
+    """
+    raise ValueError(
+        "`BdbQuit_excepthook` is deprecated since version 5.1. It is still around only because it is still imported by ipdb.",
+    )
+
+
+RGX_EXTRA_INDENT = re.compile(r"(?<=\n)\s+")
+
+
+def strip_indentation(multiline_string):
+    return RGX_EXTRA_INDENT.sub("", multiline_string)
 
 
 def decorate_fn_with_doc(new_fn, old_fn, additional_text=""):
     """Make new_fn have old_fn's doc string. This is particularly useful
-    for the do_... commands that hook into the help system.
+    for the ``do_...`` commands that hook into the help system.
     Adapted from from a comp.lang.python posting
     by Duncan Booth."""
+
     def wrapper(*args, **kw):
         return new_fn(*args, **kw)
+
     if old_fn.__doc__:
-        wrapper.__doc__ = old_fn.__doc__ + additional_text
+        wrapper.__doc__ = strip_indentation(old_fn.__doc__) + additional_text
     return wrapper
 
 
-def _file_lines(fname):
-    """Return the contents of a named file as a list of lines.
-
-    This function never raises an IOError exception: if the file can't be
-    read, it simply returns an empty list."""
-
-    try:
-        outfile = open(fname)
-    except IOError:
-        return []
-    else:
-        out = outfile.readlines()
-        outfile.close()
-        return out
-
-
 class Pdb(OldPdb):
-    """Modified Pdb class, does not load readline."""
+    """Modified Pdb class, does not load readline.
 
-    def __init__(self,color_scheme='NoColor',completekey=None,
-                 stdin=None, stdout=None):
+    for a standalone version that uses prompt_toolkit, see
+    `IPython.terminal.debugger.TerminalPdb` and
+    `IPython.terminal.debugger.set_trace()`
 
-        # Parent constructor:
-        if has_pydb and completekey is None:
-            OldPdb.__init__(self,stdin=stdin,stdout=io.stdout)
-        else:
-            OldPdb.__init__(self,completekey,stdin,stdout)
-            
-        self.prompt = prompt # The default prompt is '(Pdb)'
-        
-        # IPython changes...
-        self.is_pydb = has_pydb
 
-        self.shell = ipapi.get()
+    This debugger can hide and skip frames that are tagged according to some predicates.
+    See the `skip_predicates` commands.
 
-        if self.is_pydb:
-
-            # interactiveshell.py's ipalias seems to want pdb's checkline
-            # which located in pydb.fn
-            import pydb.fns
-            self.checkline = lambda filename, lineno: \
-                             pydb.fns.checkline(self, filename, lineno)
+    """
 
+    shell: InteractiveShell
+    _theme_name: str
+    _context: int
+
+    _chained_exceptions: tuple[Exception, ...]
+    _chained_exception_index: int
+
+    if CHAIN_EXCEPTIONS:
+        MAX_CHAINED_EXCEPTION_DEPTH = 999
+
+    default_predicates = {
+        "tbhide": True,
+        "readonly": False,
+        "ipython_internal": True,
+        "debuggerskip": True,
+    }
+
+    def __init__(
+        self,
+        completekey=None,
+        stdin=None,
+        stdout=None,
+        context: int | None | str = 5,
+        **kwargs,
+    ):
+        """Create a new IPython debugger.
+
+        Parameters
+        ----------
+        completekey : default None
+            Passed to pdb.Pdb.
+        stdin : default None
+            Passed to pdb.Pdb.
+        stdout : default None
+            Passed to pdb.Pdb.
+        context : int
+            Number of lines of source code context to show when
+            displaying stacktrace information.
+        **kwargs
+            Passed to pdb.Pdb.
+
+        Notes
+        -----
+        The possibilities are python version dependent, see the python
+        docs for more info.
+        """
+        # ipdb issue, see https://github.com/ipython/ipython/issues/14811
+        if context is None:
+            context = 5
+        if isinstance(context, str):
+            context = int(context)
+        self.context = context
+
+        # `kwargs` ensures full compatibility with stdlib's `pdb.Pdb`.
+        OldPdb.__init__(self, completekey, stdin, stdout, **kwargs)
+        # Python 3.15+ should define this, so no need to initialize
+        # this avoids some getattr(self, 'curframe')
+        if sys.version_info < (3, 15):
             self.curframe = None
-            self.do_restart = self.new_do_restart
 
-            self.old_all_completions = self.shell.Completer.all_completions
-            self.shell.Completer.all_completions=self.all_completions
+        # IPython changes...
+        self.shell = get_ipython()
+
+        if self.shell is None:
+            save_main = sys.modules["__main__"]
+            # No IPython instance running, we must create one
+            from IPython.terminal.interactiveshell import TerminalInteractiveShell
 
-            self.do_list = decorate_fn_with_doc(self.list_command_pydb,
-                                                OldPdb.do_list)
-            self.do_l     = self.do_list
-            self.do_frame = decorate_fn_with_doc(self.new_do_frame,
-                                                 OldPdb.do_frame)
+            self.shell = TerminalInteractiveShell.instance()
+            # needed by any code which calls __import__("__main__") after
+            # the debugger was entered. See also #9941.
+            sys.modules["__main__"] = save_main
 
         self.aliases = {}
 
-        # Create color table: we copy the default one from the traceback
-        # module and add a few attributes needed for debugging
-        self.color_scheme_table = exception_colors()
+        theme_name = self.shell.colors
+        assert isinstance(theme_name, str)
+        assert theme_name.lower() == theme_name
 
-        # shorthands 
-        C = coloransi.TermColors
-        cst = self.color_scheme_table
+        # Add a python parser so we can syntax highlight source while
+        # debugging.
+        self.parser = PyColorize.Parser(theme_name=theme_name)
+        self.set_theme_name(theme_name)
+
+        # Set the prompt - the default prompt is '(Pdb)'
+        self.prompt = prompt
+        self.skip_hidden = True
+        self.report_skipped = True
+
+        # list of predicates we use to skip frames
+        self._predicates = self.default_predicates
+
+        if CHAIN_EXCEPTIONS:
+            self._chained_exceptions = tuple()
+            self._chained_exception_index = 0
+
+    @property
+    def context(self) -> int:
+        return self._context
+
+    @context.setter
+    def context(self, value: int | str) -> None:
+        # ipdb issue see https://github.com/ipython/ipython/issues/14811
+        if not isinstance(value, int):
+            value = int(value)
+        assert isinstance(value, int)
+        assert value >= 0
+        self._context = value
+
+    def set_theme_name(self, name):
+        assert name.lower() == name
+        assert isinstance(name, str)
+        self._theme_name = name
+        self.parser.theme_name = name
+
+    @property
+    def theme(self):
+        return PyColorize.theme_table[self._theme_name]
+
+    #
+    def set_colors(self, scheme):
+        """Shorthand access to the color table scheme selector method."""
+        warnings.warn(
+            "set_colors is deprecated since IPython 9.0, use set_theme_name instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        assert scheme == scheme.lower()
+        self._theme_name = scheme.lower()
+        self.parser.theme_name = scheme.lower()
+
+    def set_trace(self, frame=None):
+        if frame is None:
+            frame = sys._getframe().f_back
+        self.initial_frame = frame
+        return super().set_trace(frame)
+
+    def get_stack(self, *args, **kwargs):
+        stack, pos = super().get_stack(*args, **kwargs)
+        if len(stack) >= 0 and self._is_internal_frame(stack[0][0]):
+            stack.pop(0)
+            pos -= 1
+        return stack, pos
+
+    def _is_internal_frame(self, frame):
+        """Determine if this frame should be skipped as internal"""
+        filename = frame.f_code.co_filename
 
-        cst['NoColor'].colors.breakpoint_enabled = C.NoColor
-        cst['NoColor'].colors.breakpoint_disabled = C.NoColor
+        # Skip bdb.py runcall and internal operations
+        if filename.endswith("bdb.py"):
+            func_name = frame.f_code.co_name
+            # Skip internal bdb operations but allow breakpoint hits
+            if func_name in ("runcall", "run", "runeval"):
+                return True
 
-        cst['Linux'].colors.breakpoint_enabled = C.LightRed
-        cst['Linux'].colors.breakpoint_disabled = C.Red
+        return False
 
-        cst['LightBG'].colors.breakpoint_enabled = C.LightRed
-        cst['LightBG'].colors.breakpoint_disabled = C.Red
+    def _hidden_predicate(self, frame):
+        """
+        Given a frame return whether it it should be hidden or not by IPython.
+        """
 
-        self.set_colors(color_scheme)
+        if self._predicates["readonly"]:
+            fname = frame.f_code.co_filename
+            # we need to check for file existence and interactively define
+            # function would otherwise appear as RO.
+            if os.path.isfile(fname) and not os.access(fname, os.W_OK):
+                return True
+
+        if self._predicates["tbhide"]:
+            if frame in (self.curframe, getattr(self, "initial_frame", None)):
+                return False
+            frame_locals = self._get_frame_locals(frame)
+            if "__tracebackhide__" not in frame_locals:
+                return False
+            return frame_locals["__tracebackhide__"]
+        return False
+
+    def hidden_frames(self, stack):
+        """
+        Given an index in the stack return whether it should be skipped.
 
-        # Add a python parser so we can syntax highlight source while
-        # debugging.
-        self.parser = PyColorize.Parser()
+        This is used in up/down and where to skip frames.
+        """
+        # The f_locals dictionary is updated from the actual frame
+        # locals whenever the .f_locals accessor is called, so we
+        # avoid calling it here to preserve self.curframe_locals.
+        # Furthermore, there is no good reason to hide the current frame.
+        ip_hide = [self._hidden_predicate(s[0]) for s in stack]
+        ip_start = [i for i, s in enumerate(ip_hide) if s == "__ipython_bottom__"]
+        if ip_start and self._predicates["ipython_internal"]:
+            ip_hide = [h if i > ip_start[0] else True for (i, h) in enumerate(ip_hide)]
+        return ip_hide
+
+    if CHAIN_EXCEPTIONS:
+
+        def _get_tb_and_exceptions(self, tb_or_exc):
+            """
+            Given a tracecack or an exception, return a tuple of chained exceptions
+            and current traceback to inspect.
+            This will deal with selecting the right ``__cause__`` or ``__context__``
+            as well as handling cycles, and return a flattened list of exceptions we
+            can jump to with do_exceptions.
+            """
+            _exceptions = []
+            if isinstance(tb_or_exc, BaseException):
+                traceback, current = tb_or_exc.__traceback__, tb_or_exc
+
+                while current is not None:
+                    if current in _exceptions:
+                        break
+                    _exceptions.append(current)
+                    if current.__cause__ is not None:
+                        current = current.__cause__
+                    elif (
+                        current.__context__ is not None
+                        and not current.__suppress_context__
+                    ):
+                        current = current.__context__
+
+                    if len(_exceptions) >= self.MAX_CHAINED_EXCEPTION_DEPTH:
+                        self.message(
+                            f"More than {self.MAX_CHAINED_EXCEPTION_DEPTH}"
+                            " chained exceptions found, not all exceptions"
+                            "will be browsable with `exceptions`."
+                        )
+                        break
+            else:
+                traceback = tb_or_exc
+            return tuple(reversed(_exceptions)), traceback
+
+        @contextmanager
+        def _hold_exceptions(self, exceptions):
+            """
+            Context manager to ensure proper cleaning of exceptions references
+            When given a chained exception instead of a traceback,
+            pdb may hold references to many objects which may leak memory.
+            We use this context manager to make sure everything is properly cleaned
+            """
+            try:
+                self._chained_exceptions = exceptions
+                self._chained_exception_index = len(exceptions) - 1
+                yield
+            finally:
+                # we can't put those in forget as otherwise they would
+                # be cleared on exception change
+                self._chained_exceptions = tuple()
+                self._chained_exception_index = 0
+
+        def do_exceptions(self, arg):
+            """exceptions [number]
+            List or change current exception in an exception chain.
+            Without arguments, list all the current exception in the exception
+            chain. Exceptions will be numbered, with the current exception indicated
+            with an arrow.
+            If given an integer as argument, switch to the exception at that index.
+            """
+            if not self._chained_exceptions:
+                self.message(
+                    "Did not find chained exceptions. To move between"
+                    " exceptions, pdb/post_mortem must be given an exception"
+                    " object rather than a traceback."
+                )
+                return
+            if not arg:
+                for ix, exc in enumerate(self._chained_exceptions):
+                    prompt = ">" if ix == self._chained_exception_index else " "
+                    rep = repr(exc)
+                    if len(rep) > 80:
+                        rep = rep[:77] + "..."
+                    indicator = (
+                        "  -"
+                        if self._chained_exceptions[ix].__traceback__ is None
+                        else f"{ix:>3}"
+                    )
+                    self.message(f"{prompt} {indicator} {rep}")
+            else:
+                try:
+                    number = int(arg)
+                except ValueError:
+                    self.error("Argument must be an integer")
+                    return
+                if 0 <= number < len(self._chained_exceptions):
+                    if self._chained_exceptions[number].__traceback__ is None:
+                        self.error(
+                            "This exception does not have a traceback, cannot jump to it"
+                        )
+                        return
+
+                    self._chained_exception_index = number
+                    self.setup(None, self._chained_exceptions[number].__traceback__)
+                    self.print_stack_entry(self.stack[self.curindex])
+                else:
+                    self.error("No exception with that number")
 
-    def set_colors(self, scheme):
-        """Shorthand access to the color table scheme selector method."""
-        self.color_scheme_table.set_active_scheme(scheme)
+    def interaction(self, frame, tb_or_exc):
+        try:
+            if CHAIN_EXCEPTIONS:
+                # this context manager is part of interaction in 3.13
+                _chained_exceptions, tb = self._get_tb_and_exceptions(tb_or_exc)
+                if isinstance(tb_or_exc, BaseException):
+                    assert tb is not None, "main exception must have a traceback"
+                with self._hold_exceptions(_chained_exceptions):
+                    OldPdb.interaction(self, frame, tb)
+            else:
+                OldPdb.interaction(self, frame, tb_or_exc)
 
-    def interaction(self, frame, traceback):
-        self.shell.set_completer_frame(frame)
-        OldPdb.interaction(self, frame, traceback)
+        except KeyboardInterrupt:
+            self.stdout.write("\n" + self.shell.get_exception_only())
 
-    def new_do_up(self, arg):
-        OldPdb.do_up(self, arg)
-        self.shell.set_completer_frame(self.curframe)
-    do_u = do_up = decorate_fn_with_doc(new_do_up, OldPdb.do_up)
+    def precmd(self, line):
+        """Perform useful escapes on the command before it is executed."""
 
-    def new_do_down(self, arg):
-        OldPdb.do_down(self, arg)
-        self.shell.set_completer_frame(self.curframe)
+        if line.endswith("??"):
+            line = "pinfo2 " + line[:-2]
+        elif line.endswith("?"):
+            line = "pinfo " + line[:-1]
 
-    do_d = do_down = decorate_fn_with_doc(new_do_down, OldPdb.do_down)
+        line = super().precmd(line)
 
-    def new_do_frame(self, arg):
-        OldPdb.do_frame(self, arg)
-        self.shell.set_completer_frame(self.curframe)
+        return line
 
     def new_do_quit(self, arg):
-        
-        if hasattr(self, 'old_all_completions'):
-            self.shell.Completer.all_completions=self.old_all_completions
-        
-        
         return OldPdb.do_quit(self, arg)
 
     do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
 
-    def new_do_restart(self, arg):
-        """Restart command. In the context of ipython this is exactly the same
-        thing as 'quit'."""
-        self.msg("Restart doesn't make sense here. Using 'quit' instead.")
-        return self.do_quit(arg)
-
-    def postloop(self):
-        self.shell.set_completer_frame(None)
-
-    def print_stack_trace(self):
+    def print_stack_trace(self, context: int | None = None):
+        if context is None:
+            context = self.context
         try:
-            for frame_lineno in self.stack:
-                self.print_stack_entry(frame_lineno, context = 5)
+            skipped = 0
+            to_print = ""
+            for hidden, frame_lineno in zip(self.hidden_frames(self.stack), self.stack):
+                if hidden and self.skip_hidden:
+                    skipped += 1
+                    continue
+                if skipped:
+                    to_print += self.theme.format(
+                        [
+                            (
+                                Token.ExcName,
+                                f"    [... skipping {skipped} hidden frame(s)]",
+                            ),
+                            (Token, "\n"),
+                        ]
+                    )
+
+                    skipped = 0
+                to_print += self.format_stack_entry(frame_lineno)
+            if skipped:
+                to_print += self.theme.format(
+                    [
+                        (
+                            Token.ExcName,
+                            f"    [... skipping {skipped} hidden frame(s)]",
+                        ),
+                        (Token, "\n"),
+                    ]
+                )
+            print(to_print, file=self.stdout)
         except KeyboardInterrupt:
             pass
 
-    def print_stack_entry(self,frame_lineno,prompt_prefix='\n-> ',
-                          context = 3):
-        #frame, lineno = frame_lineno
-        print >>io.stdout, self.format_stack_entry(frame_lineno, '', context)
+    def print_stack_entry(
+        self, frame_lineno: tuple[FrameType, int], prompt_prefix: str = "\n-> "
+    ) -> None:
+        """
+        Overwrite print_stack_entry from superclass (PDB)
+        """
+        print(self.format_stack_entry(frame_lineno, ""), file=self.stdout)
 
-        # vds: >>
         frame, lineno = frame_lineno
         filename = frame.f_code.co_filename
         self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
-        # vds: <<
-
-    def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
-        import linecache, repr
-        
-        ret = []
-        
-        Colors = self.color_scheme_table.active_colors
-        ColorsNormal = Colors.Normal
-        tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
-        tpl_call = '%s%%s%s%%s%s' % (Colors.vName, Colors.valEm, ColorsNormal)
-        tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
-        tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
-                                            ColorsNormal)
-        
+
+    def _get_frame_locals(self, frame):
+        """ "
+        Accessing f_local of current frame reset the namespace, so we want to avoid
+        that or the following can happen
+
+        ipdb> foo
+        "old"
+        ipdb> foo = "new"
+        ipdb> foo
+        "new"
+        ipdb> where
+        ipdb> foo
+        "old"
+
+        So if frame is self.current_frame we instead return self.curframe_locals
+
+        """
+        if frame is self.curframe:
+            return self.curframe_locals
+        else:
+            return frame.f_locals
+
+    def format_stack_entry(
+        self,
+        frame_lineno: tuple[FrameType, int],  # type: ignore[override] # stubs are wrong
+        lprefix: str = ": ",
+    ) -> str:
+        """
+        overwrite from super class so must -> str
+        """
+        context = self.context
+        try:
+            context = int(context)
+            if context <= 0:
+                print("Context must be a positive integer", file=self.stdout)
+        except (TypeError, ValueError):
+            print("Context must be a positive integer", file=self.stdout)
+
+        import reprlib
+
+        ret_tok = []
+
         frame, lineno = frame_lineno
-        
-        return_value = ''
-        if '__return__' in frame.f_locals:
-            rv = frame.f_locals['__return__']
-            #return_value += '->'
-            return_value += repr.repr(rv) + '\n'
-        ret.append(return_value)
-
-        #s = filename + '(' + `lineno` + ')'
+
+        return_value = ""
+        loc_frame = self._get_frame_locals(frame)
+        if "__return__" in loc_frame:
+            rv = loc_frame["__return__"]
+            # return_value += '->'
+            return_value += reprlib.repr(rv) + "\n"
+            ret_tok.extend([(Token, return_value)])
+
+        # s = filename + '(' + `lineno` + ')'
         filename = self.canonic(frame.f_code.co_filename)
-        link = tpl_link % filename
-        
+        link_tok = (Token.FilenameEm, filename)
+
         if frame.f_code.co_name:
             func = frame.f_code.co_name
         else:
             func = "<lambda>"
-            
-        call = ''
-        if func != '?':         
-            if '__args__' in frame.f_locals:
-                args = repr.repr(frame.f_locals['__args__'])
+
+        call_toks = []
+        if func != "?":
+            if "__args__" in loc_frame:
+                args = reprlib.repr(loc_frame["__args__"])
             else:
-                args = '()'
-            call = tpl_call % (func, args)
+                args = "()"
+            call_toks = [(Token.VName, func), (Token.ValEm, args)]
 
         # The level info should be generated in the same format pdb uses, to
         # avoid breaking the pdbtrack functionality of python-mode in *emacs.
         if frame is self.curframe:
-            ret.append('> ')
+            ret_tok.append((Token.CurrentFrame, self.theme.make_arrow(2)))
         else:
-            ret.append('  ')
-        ret.append('%s(%s)%s\n' % (link,lineno,call))
-            
-        start = lineno - 1 - context//2
+            ret_tok.append((Token, "  "))
+
+        ret_tok.extend(
+            [
+                link_tok,
+                (Token, "("),
+                (Token.Lineno, str(lineno)),
+                (Token, ")"),
+                *call_toks,
+                (Token, "\n"),
+            ]
+        )
+
+        start = lineno - 1 - context // 2
         lines = linecache.getlines(filename)
-        start = max(start, 0)
         start = min(start, len(lines) - context)
+        start = max(start, 0)
         lines = lines[start : start + context]
-            
-        for i,line in enumerate(lines):
-            show_arrow = (start + 1 + i == lineno)
-            linetpl = (frame is self.curframe or show_arrow) \
-                      and tpl_line_em \
-                      or tpl_line
-            ret.append(self.__format_line(linetpl, filename,
-                                          start + 1 + i, line,
-                                          arrow = show_arrow) )
-
-        return ''.join(ret)
-
-    def __format_line(self, tpl_line, filename, lineno, line, arrow = False):
+
+        for i, line in enumerate(lines):
+            show_arrow = start + 1 + i == lineno
+
+            bp, num, colored_line = self.__line_content(
+                filename,
+                start + 1 + i,
+                line,
+                arrow=show_arrow,
+            )
+            if frame is self.curframe or show_arrow:
+                rlt = [
+                    bp,
+                    (Token.LinenoEm, num),
+                    (Token, " "),
+                    # TODO: investigate Toke.Line here, likely LineEm,
+                    # Token is problematic here as line is already colored, a
+                    # and this changes the full style of the colored line.
+                    # ideally, __line_content returns the token and we modify the style.
+                    (Token, colored_line),
+                ]
+            else:
+                rlt = [
+                    bp,
+                    (Token.Lineno, num),
+                    (Token, " "),
+                    # TODO: investigate Toke.Line here, likely Line
+                    # Token is problematic here as line is already colored, a
+                    # and this changes the full style of the colored line.
+                    # ideally, __line_content returns the token and we modify the style.
+                    (Token.Line, colored_line),
+                ]
+            ret_tok.extend(rlt)
+
+        return self.theme.format(ret_tok)
+
+    def __line_content(
+        self, filename: str, lineno: int, line: str, arrow: bool = False
+    ):
         bp_mark = ""
-        bp_mark_color = ""
+        BreakpointToken = Token.Breakpoint
 
-        scheme = self.color_scheme_table.active_scheme_name
-        new_line, err = self.parser.format2(line, 'str', scheme)
-        if not err: line = new_line
+        new_line, err = self.parser.format2(line, "str")
+        if not err:
+            assert new_line is not None
+            line = new_line
 
         bp = None
         if lineno in self.get_file_breaks(filename):
             bps = self.get_breaks(filename, lineno)
             bp = bps[-1]
-        
+
         if bp:
-            Colors = self.color_scheme_table.active_colors
             bp_mark = str(bp.number)
-            bp_mark_color = Colors.breakpoint_enabled
+            BreakpointToken = Token.Breakpoint.Enabled
             if not bp.enabled:
-                bp_mark_color = Colors.breakpoint_disabled
-
+                BreakpointToken = Token.Breakpoint.Disabled
         numbers_width = 7
         if arrow:
             # This is the line with the error
             pad = numbers_width - len(str(lineno)) - len(bp_mark)
-            if pad >= 3:
-                marker = '-'*(pad-3) + '-> '
-            elif pad == 2:
-                 marker = '> '
-            elif pad == 1:
-                 marker = '>'
-            else:
-                 marker = ''
-            num = '%s%s' % (marker, str(lineno))
-            line = tpl_line % (bp_mark_color + bp_mark, num, line)
+            num = "%s%s" % (self.theme.make_arrow(pad), str(lineno))
         else:
-            num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
-            line = tpl_line % (bp_mark_color + bp_mark, num, line)
-            
-        return line
+            num = "%*s" % (numbers_width - len(bp_mark), str(lineno))
+        bp_str = (BreakpointToken, bp_mark)
+        return (bp_str, num, line)
 
-    def list_command_pydb(self, arg):
-        """List command to use if we have a newer pydb installed"""
-        filename, first, last = OldPdb.parse_list_cmd(self, arg)
-        if filename is not None:
-            self.print_list_lines(filename, first, last)
-        
-    def print_list_lines(self, filename, first, last):
+    def print_list_lines(self, filename: str, first: int, last: int) -> None:
         """The printing (as opposed to the parsing part of a 'list'
         command."""
+        toks: TokenStream = []
         try:
-            Colors = self.color_scheme_table.active_colors
-            ColorsNormal = Colors.Normal
-            tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
-            tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line, ColorsNormal)
-            src = []
-            for lineno in range(first, last+1):
+            if filename == "<string>" and hasattr(self, "_exec_filename"):
+                filename = self._exec_filename
+
+            for lineno in range(first, last + 1):
                 line = linecache.getline(filename, lineno)
                 if not line:
                     break
 
+                assert self.curframe is not None
+
                 if lineno == self.curframe.f_lineno:
-                    line = self.__format_line(tpl_line_em, filename, lineno, line, arrow = True)
+                    bp, num, colored_line = self.__line_content(
+                        filename, lineno, line, arrow=True
+                    )
+                    toks.extend(
+                        [
+                            bp,
+                            (Token.LinenoEm, num),
+                            (Token, " "),
+                            # TODO: investigate Token.Line here
+                            (Token, colored_line),
+                        ]
+                    )
                 else:
-                    line = self.__format_line(tpl_line, filename, lineno, line, arrow = False)
+                    bp, num, colored_line = self.__line_content(
+                        filename, lineno, line, arrow=False
+                    )
+                    toks.extend(
+                        [
+                            bp,
+                            (Token.Lineno, num),
+                            (Token, " "),
+                            (Token, colored_line),
+                        ]
+                    )
 
-                src.append(line)
                 self.lineno = lineno
 
-            print >>io.stdout, ''.join(src)
+            print(self.theme.format(toks), file=self.stdout)
 
         except KeyboardInterrupt:
             pass
 
+    def do_skip_predicates(self, args):
+        """
+        Turn on/off individual predicates as to whether a frame should be hidden/skip.
+
+        The global option to skip (or not) hidden frames is set with skip_hidden
+
+        To change the value of a predicate
+
+            skip_predicates key [true|false]
+
+        Call without arguments to see the current values.
+
+        To permanently change the value of an option add the corresponding
+        command to your ``~/.pdbrc`` file. If you are programmatically using the
+        Pdb instance you can also change the ``default_predicates`` class
+        attribute.
+        """
+        if not args.strip():
+            print("current predicates:")
+            for p, v in self._predicates.items():
+                print("   ", p, ":", v)
+            return
+        type_value = args.strip().split(" ")
+        if len(type_value) != 2:
+            print(
+                f"Usage: skip_predicates <type> <value>, with <type> one of {set(self._predicates.keys())}"
+            )
+            return
+
+        type_, value = type_value
+        if type_ not in self._predicates:
+            print(f"{type_!r} not in {set(self._predicates.keys())}")
+            return
+        if value.lower() not in ("true", "yes", "1", "no", "false", "0"):
+            print(
+                f"{value!r} is invalid - use one of ('true', 'yes', '1', 'no', 'false', '0')"
+            )
+            return
+
+        self._predicates[type_] = value.lower() in ("true", "yes", "1")
+        if not any(self._predicates.values()):
+            print(
+                "Warning, all predicates set to False, skip_hidden may not have any effects."
+            )
+
+    def do_skip_hidden(self, arg):
+        """
+        Change whether or not we should skip frames with the
+        __tracebackhide__ attribute.
+        """
+        if not arg.strip():
+            print(
+                f"skip_hidden = {self.skip_hidden}, use 'yes','no', 'true', or 'false' to change."
+            )
+        elif arg.strip().lower() in ("true", "yes"):
+            self.skip_hidden = True
+        elif arg.strip().lower() in ("false", "no"):
+            self.skip_hidden = False
+        if not any(self._predicates.values()):
+            print(
+                "Warning, all predicates set to False, skip_hidden may not have any effects."
+            )
+
     def do_list(self, arg):
-        self.lastcmd = 'list'
+        """Print lines of code from the current stack frame"""
+        self.lastcmd = "list"
         last = None
-        if arg:
+        if arg and arg != ".":
             try:
                 x = eval(arg, {}, {})
                 if type(x) == type(()):
@@ -439,71 +883,494 @@ def do_list(self, arg):
                 else:
                     first = max(1, int(x) - 5)
             except:
-                print '*** Error in argument:', `arg`
+                print("*** Error in argument:", repr(arg), file=self.stdout)
                 return
-        elif self.lineno is None:
+        elif self.lineno is None or arg == ".":
+            assert self.curframe is not None
             first = max(1, self.curframe.f_lineno - 5)
         else:
             first = self.lineno + 1
         if last is None:
             last = first + 10
+        assert self.curframe is not None
         self.print_list_lines(self.curframe.f_code.co_filename, first, last)
 
-        # vds: >>
         lineno = first
         filename = self.curframe.f_code.co_filename
         self.shell.hooks.synchronize_with_editor(filename, lineno, 0)
-        # vds: <<
 
     do_l = do_list
 
+    def getsourcelines(self, obj):
+        lines, lineno = inspect.findsource(obj)
+        if inspect.isframe(obj) and obj.f_globals is self._get_frame_locals(obj):
+            # must be a module frame: do not try to cut a block out of it
+            return lines, 1
+        elif inspect.ismodule(obj):
+            return lines, 1
+        return inspect.getblock(lines[lineno:]), lineno + 1
+
+    def do_longlist(self, arg):
+        """Print lines of code from the current stack frame.
+
+        Shows more lines than 'list' does.
+        """
+        self.lastcmd = "longlist"
+        try:
+            lines, lineno = self.getsourcelines(self.curframe)
+        except OSError as err:
+            self.error(str(err))
+            return
+        last = lineno + len(lines)
+        assert self.curframe is not None
+        self.print_list_lines(self.curframe.f_code.co_filename, lineno, last)
+
+    do_ll = do_longlist
+
+    def do_debug(self, arg):
+        """debug code
+        Enter a recursive debugger that steps through the code
+        argument (which is an arbitrary expression or statement to be
+        executed in the current environment).
+        """
+        trace_function = sys.gettrace()
+        sys.settrace(None)
+        assert self.curframe is not None
+        globals = self.curframe.f_globals
+        locals = self.curframe_locals
+        p = self.__class__(
+            completekey=self.completekey, stdin=self.stdin, stdout=self.stdout
+        )
+        p.use_rawinput = self.use_rawinput
+        p.prompt = "(%s) " % self.prompt.strip()
+        self.message("ENTERING RECURSIVE DEBUGGER")
+        sys.call_tracing(p.run, (arg, globals, locals))
+        self.message("LEAVING RECURSIVE DEBUGGER")
+        sys.settrace(trace_function)
+        self.lastcmd = p.lastcmd
+
     def do_pdef(self, arg):
-        """The debugger interface to magic_pdef"""
-        namespaces = [('Locals', self.curframe.f_locals),
-                      ('Globals', self.curframe.f_globals)]
-        self.shell.magic_pdef(arg, namespaces=namespaces)
+        """Print the call signature for any callable object.
+
+        The debugger interface to %pdef"""
+        assert self.curframe is not None
+        namespaces = [
+            ("Locals", self.curframe_locals),
+            ("Globals", self.curframe.f_globals),
+        ]
+        self.shell.find_line_magic("pdef")(arg, namespaces=namespaces)
 
     def do_pdoc(self, arg):
-        """The debugger interface to magic_pdoc"""
-        namespaces = [('Locals', self.curframe.f_locals),
-                      ('Globals', self.curframe.f_globals)]
-        self.shell.magic_pdoc(arg, namespaces=namespaces)
+        """Print the docstring for an object.
+
+        The debugger interface to %pdoc."""
+        assert self.curframe is not None
+        namespaces = [
+            ("Locals", self.curframe_locals),
+            ("Globals", self.curframe.f_globals),
+        ]
+        self.shell.find_line_magic("pdoc")(arg, namespaces=namespaces)
+
+    def do_pfile(self, arg):
+        """Print (or run through pager) the file where an object is defined.
+
+        The debugger interface to %pfile.
+        """
+        assert self.curframe is not None
+        namespaces = [
+            ("Locals", self.curframe_locals),
+            ("Globals", self.curframe.f_globals),
+        ]
+        self.shell.find_line_magic("pfile")(arg, namespaces=namespaces)
 
     def do_pinfo(self, arg):
-        """The debugger equivalant of ?obj"""
-        namespaces = [('Locals', self.curframe.f_locals),
-                      ('Globals', self.curframe.f_globals)]
-        self.shell.magic_pinfo("pinfo %s" % arg, namespaces=namespaces)
+        """Provide detailed information about an object.
+
+        The debugger interface to %pinfo, i.e., obj?."""
+        assert self.curframe is not None
+        namespaces = [
+            ("Locals", self.curframe_locals),
+            ("Globals", self.curframe.f_globals),
+        ]
+        self.shell.find_line_magic("pinfo")(arg, namespaces=namespaces)
+
+    def do_pinfo2(self, arg):
+        """Provide extra detailed information about an object.
+
+        The debugger interface to %pinfo2, i.e., obj??."""
+        assert self.curframe is not None
+        namespaces = [
+            ("Locals", self.curframe_locals),
+            ("Globals", self.curframe.f_globals),
+        ]
+        self.shell.find_line_magic("pinfo2")(arg, namespaces=namespaces)
+
+    def do_psource(self, arg):
+        """Print (or run through pager) the source code for an object."""
+        assert self.curframe is not None
+        namespaces = [
+            ("Locals", self.curframe_locals),
+            ("Globals", self.curframe.f_globals),
+        ]
+        self.shell.find_line_magic("psource")(arg, namespaces=namespaces)
+
+    def do_where(self, arg: str):
+        """w(here)
+        Print a stack trace, with the most recent frame at the bottom.
+        An arrow indicates the "current frame", which determines the
+        context of most commands. 'bt' is an alias for this command.
+
+        Take a number as argument as an (optional) number of context line to
+        print"""
+        if arg:
+            try:
+                context = int(arg)
+            except ValueError as err:
+                self.error(str(err))
+                return
+            self.print_stack_trace(context)
+        else:
+            self.print_stack_trace()
+
+    do_w = do_where
+
+    def break_anywhere(self, frame):
+        """
+        _stop_in_decorator_internals is overly restrictive, as we may still want
+        to trace function calls, so we need to also update break_anywhere so
+        that is we don't `stop_here`, because of debugger skip, we may still
+        stop at any point inside the function
+
+        """
+
+        sup = super().break_anywhere(frame)
+        if sup:
+            return sup
+        if self._predicates["debuggerskip"]:
+            if DEBUGGERSKIP in frame.f_code.co_varnames:
+                return True
+            if frame.f_back and self._get_frame_locals(frame.f_back).get(DEBUGGERSKIP):
+                return True
+        return False
+
+    def _is_in_decorator_internal_and_should_skip(self, frame):
+        """
+        Utility to tell us whether we are in a decorator internal and should stop.
+
+        """
+        # if we are disabled don't skip
+        if not self._predicates["debuggerskip"]:
+            return False
+
+        return self._cachable_skip(frame)
+
+    @lru_cache(1024)
+    def _cached_one_parent_frame_debuggerskip(self, frame):
+        """
+        Cache looking up for DEBUGGERSKIP on parent frame.
+
+        This should speedup walking through deep frame when one of the highest
+        one does have a debugger skip.
+
+        This is likely to introduce fake positive though.
+        """
+        while getattr(frame, "f_back", None):
+            frame = frame.f_back
+            if self._get_frame_locals(frame).get(DEBUGGERSKIP):
+                return True
+        return None
+
+    @lru_cache(1024)
+    def _cachable_skip(self, frame):
+        # if frame is tagged, skip by default.
+        if DEBUGGERSKIP in frame.f_code.co_varnames:
+            return True
+
+        # if one of the parent frame value set to True skip as well.
+        if self._cached_one_parent_frame_debuggerskip(frame):
+            return True
+
+        return False
+
+    def stop_here(self, frame):
+        if self._is_in_decorator_internal_and_should_skip(frame) is True:
+            return False
+
+        hidden = False
+        if self.skip_hidden:
+            hidden = self._hidden_predicate(frame)
+        if hidden:
+            if self.report_skipped:
+                print(
+                    self.theme.format(
+                        [
+                            (
+                                Token.ExcName,
+                                "    [... skipped 1 hidden frame(s)]",
+                            ),
+                            (Token, "\n"),
+                        ]
+                    )
+                )
+        if self.skip and self.is_skipped_module(frame.f_globals.get("__name__", "")):
+            print(
+                self.theme.format(
+                    [
+                        (
+                            Token.ExcName,
+                            "    [... skipped 1 ignored module(s)]",
+                        ),
+                        (Token, "\n"),
+                    ]
+                )
+            )
+
+            return False
+
+        return super().stop_here(frame)
+
+    def do_up(self, arg):
+        """u(p) [count]
+        Move the current frame count (default one) levels up in the
+        stack trace (to an older frame).
+
+        Will skip hidden frames and ignored modules.
+        """
+        # modified version of upstream that skips
+        # frames with __tracebackhide__ and ignored modules
+        if self.curindex == 0:
+            self.error("Oldest frame")
+            return
+        try:
+            count = int(arg or 1)
+        except ValueError:
+            self.error("Invalid frame count (%s)" % arg)
+            return
+
+        hidden_skipped = 0
+        module_skipped = 0
+
+        if count < 0:
+            _newframe = 0
+        else:
+            counter = 0
+            hidden_frames = self.hidden_frames(self.stack)
+
+            for i in range(self.curindex - 1, -1, -1):
+                should_skip_hidden = hidden_frames[i] and self.skip_hidden
+                should_skip_module = self.skip and self.is_skipped_module(
+                    self.stack[i][0].f_globals.get("__name__", "")
+                )
+
+                if should_skip_hidden or should_skip_module:
+                    if should_skip_hidden:
+                        hidden_skipped += 1
+                    if should_skip_module:
+                        module_skipped += 1
+                    continue
+                counter += 1
+                if counter >= count:
+                    break
+            else:
+                # if no break occurred.
+                self.error(
+                    "all frames above skipped (hidden frames and ignored modules). Use `skip_hidden False` for hidden frames or unignore_module for ignored modules."
+                )
+                return
+
+            _newframe = i
+        self._select_frame(_newframe)
+
+        total_skipped = hidden_skipped + module_skipped
+        if total_skipped:
+            print(
+                self.theme.format(
+                    [
+                        (
+                            Token.ExcName,
+                            f"    [... skipped {total_skipped} frame(s): {hidden_skipped} hidden frames + {module_skipped} ignored modules]",
+                        ),
+                        (Token, "\n"),
+                    ]
+                )
+            )
+
+    def do_down(self, arg):
+        """d(own) [count]
+        Move the current frame count (default one) levels down in the
+        stack trace (to a newer frame).
+
+        Will skip hidden frames and ignored modules.
+        """
+        if self.curindex + 1 == len(self.stack):
+            self.error("Newest frame")
+            return
+        try:
+            count = int(arg or 1)
+        except ValueError:
+            self.error("Invalid frame count (%s)" % arg)
+            return
+        if count < 0:
+            _newframe = len(self.stack) - 1
+        else:
+            counter = 0
+            hidden_skipped = 0
+            module_skipped = 0
+            hidden_frames = self.hidden_frames(self.stack)
+
+            for i in range(self.curindex + 1, len(self.stack)):
+                should_skip_hidden = hidden_frames[i] and self.skip_hidden
+                should_skip_module = self.skip and self.is_skipped_module(
+                    self.stack[i][0].f_globals.get("__name__", "")
+                )
+
+                if should_skip_hidden or should_skip_module:
+                    if should_skip_hidden:
+                        hidden_skipped += 1
+                    if should_skip_module:
+                        module_skipped += 1
+                    continue
+                counter += 1
+                if counter >= count:
+                    break
+            else:
+                self.error(
+                    "all frames below skipped (hidden frames and ignored modules). Use `skip_hidden False` for hidden frames or unignore_module for ignored modules."
+                )
+                return
+
+            total_skipped = hidden_skipped + module_skipped
+            if total_skipped:
+                print(
+                    self.theme.format(
+                        [
+                            (
+                                Token.ExcName,
+                                f"    [... skipped {total_skipped} frame(s): {hidden_skipped} hidden frames + {module_skipped} ignored modules]",
+                            ),
+                            (Token, "\n"),
+                        ]
+                    )
+                )
+            _newframe = i
+
+        self._select_frame(_newframe)
+
+    do_d = do_down
+    do_u = do_up
+
+    def _show_ignored_modules(self):
+        """Display currently ignored modules."""
+        if self.skip:
+            print(f"Currently ignored modules: {sorted(self.skip)}")
+        else:
+            print("No modules are currently ignored.")
+
+    def do_ignore_module(self, arg):
+        """ignore_module <module_name>
 
-    def checkline(self, filename, lineno):
-        """Check whether specified line seems to be executable.
+        Add a module to the list of modules to skip when navigating frames.
+        When a module is ignored, the debugger will automatically skip over
+        frames from that module.
 
-        Return `lineno` if it is, 0 if not (e.g. a docstring, comment, blank
-        line or EOF). Warning: testing is not comprehensive.
+        Supports wildcard patterns using fnmatch syntax:
+
+        Usage:
+            ignore_module threading     # Skip threading module frames
+            ignore_module asyncio.\\*    # Skip all asyncio submodules
+            ignore_module \\*.tests      # Skip all test modules
+            ignore_module               # List currently ignored modules
         """
-        #######################################################################
-        # XXX Hack!  Use python-2.5 compatible code for this call, because with
-        # all of our changes, we've drifted from the pdb api in 2.6.  For now,
-        # changing:
-        #
-        #line = linecache.getline(filename, lineno, self.curframe.f_globals)
-        # to:
-        #
-        line = linecache.getline(filename, lineno)
-        #
-        # does the trick.  But in reality, we need to fix this by reconciling
-        # our updates with the new Pdb APIs in Python 2.6.
-        #
-        # End hack.  The rest of this method is copied verbatim from 2.6 pdb.py
-        #######################################################################
-        
-        if not line:
-            print >>self.stdout, 'End of file'
-            return 0
-        line = line.strip()
-        # Don't allow setting breakpoint at a blank line
-        if (not line or (line[0] == '#') or
-             (line[:3] == '"""') or line[:3] == "'''"):
-            print >>self.stdout, '*** Blank or comment'
-            return 0
-        return lineno
+
+        if self.skip is None:
+            self.skip = set()
+
+        module_name = arg.strip()
+
+        if not module_name:
+            self._show_ignored_modules()
+            return
+
+        self.skip.add(module_name)
+
+    def do_unignore_module(self, arg):
+        """unignore_module <module_name>
+
+        Remove a module from the list of modules to skip when navigating frames.
+        This will allow the debugger to step into frames from the specified module.
+
+        Usage:
+            unignore_module threading   # Stop ignoring threading module frames
+            unignore_module asyncio.\\*  # Remove asyncio.* pattern
+            unignore_module             # List currently ignored modules
+        """
+
+        if self.skip is None:
+            self.skip = set()
+
+        module_name = arg.strip()
+
+        if not module_name:
+            self._show_ignored_modules()
+            return
+
+        try:
+            self.skip.remove(module_name)
+        except KeyError:
+            print(f"Module {module_name} is not currently ignored")
+            self._show_ignored_modules()
+
+    def do_context(self, context: str):
+        """context number_of_lines
+        Set the number of lines of source code to show when displaying
+        stacktrace information.
+        """
+        try:
+            new_context = int(context)
+            if new_context <= 0:
+                raise ValueError()
+            self.context = new_context
+        except ValueError:
+            self.error(
+                f"The 'context' command requires a positive integer argument (current value {self.context})."
+            )
+
+
+class InterruptiblePdb(Pdb):
+    """Version of debugger where KeyboardInterrupt exits the debugger altogether."""
+
+    def cmdloop(self, intro=None):
+        """Wrap cmdloop() such that KeyboardInterrupt stops the debugger."""
+        try:
+            return OldPdb.cmdloop(self, intro=intro)
+        except KeyboardInterrupt:
+            self.stop_here = lambda frame: False  # type: ignore[method-assign]
+            self.do_quit("")
+            sys.settrace(None)
+            self.quitting = False
+            raise
+
+    def _cmdloop(self):
+        while True:
+            try:
+                # keyboard interrupts allow for an easy way to cancel
+                # the current command, so allow them during interactive input
+                self.allow_kbdint = True
+                self.cmdloop()
+                self.allow_kbdint = False
+                break
+            except KeyboardInterrupt:
+                self.message("--KeyboardInterrupt--")
+                raise
+
+
+def set_trace(frame=None, header=None):
+    """
+    Start debugging from `frame`.
+
+    If frame is not specified, debugging starts from caller's frame.
+    """
+    pdb = Pdb()
+    if header is not None:
+        pdb.message(header)
+    pdb.set_trace(frame or sys._getframe().f_back)
diff --git a/IPython/core/debugger_backport.py b/IPython/core/debugger_backport.py
new file mode 100644
index 00000000000..e8e957e899c
--- /dev/null
+++ b/IPython/core/debugger_backport.py
@@ -0,0 +1,206 @@
+"""
+The code in this module is a backport of cPython changes in Pdb
+that were introduced in Python 3.13 by gh-83151: Make closure work on pdb
+https://github.com/python/cpython/pull/111094.
+This file should be removed once IPython drops supports for Python 3.12.
+
+The only changes are:
+- reformatting by darker (black) formatter
+- addition of type-ignore comments to satisfy mypy
+
+Copyright (c) 2001 Python Software Foundation; All Rights Reserved
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001 Python Software Foundation; All Rights Reserved"
+are retained in Python alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+"""
+
+import sys
+import types
+import codeop
+import textwrap
+from types import CodeType
+
+
+class PdbClosureBackport:
+    def _exec_in_closure(self, source, globals, locals):  # type: ignore[no-untyped-def]
+        """Run source code in closure so code object created within source
+        can find variables in locals correctly
+        returns True if the source is executed, False otherwise
+        """
+
+        # Determine if the source should be executed in closure. Only when the
+        # source compiled to multiple code objects, we should use this feature.
+        # Otherwise, we can just raise an exception and normal exec will be used.
+
+        code = compile(source, "<string>", "exec")
+        if not any(isinstance(const, CodeType) for const in code.co_consts):
+            return False
+
+        # locals could be a proxy which does not support pop
+        # copy it first to avoid modifying the original locals
+        locals_copy = dict(locals)
+
+        locals_copy["__pdb_eval__"] = {"result": None, "write_back": {}}
+
+        # If the source is an expression, we need to print its value
+        try:
+            compile(source, "<string>", "eval")
+        except SyntaxError:
+            pass
+        else:
+            source = "__pdb_eval__['result'] = " + source
+
+        # Add write-back to update the locals
+        source = (
+            "try:\n"
+            + textwrap.indent(source, "  ")
+            + "\n"
+            + "finally:\n"
+            + "  __pdb_eval__['write_back'] = locals()"
+        )
+
+        # Build a closure source code with freevars from locals like:
+        # def __pdb_outer():
+        #   var = None
+        #   def __pdb_scope():  # This is the code object we want to execute
+        #     nonlocal var
+        #     <source>
+        #   return __pdb_scope.__code__
+        source_with_closure = (
+            "def __pdb_outer():\n"
+            + "\n".join(f"  {var} = None" for var in locals_copy)
+            + "\n"
+            + "  def __pdb_scope():\n"
+            + "\n".join(f"    nonlocal {var}" for var in locals_copy)
+            + "\n"
+            + textwrap.indent(source, "    ")
+            + "\n"
+            + "  return __pdb_scope.__code__"
+        )
+
+        # Get the code object of __pdb_scope()
+        # The exec fills locals_copy with the __pdb_outer() function and we can call
+        # that to get the code object of __pdb_scope()
+        ns = {}
+        try:
+            exec(source_with_closure, {}, ns)
+        except Exception:
+            return False
+        code = ns["__pdb_outer"]()
+
+        cells = tuple(types.CellType(locals_copy.get(var)) for var in code.co_freevars)
+
+        try:
+            exec(code, globals, locals_copy, closure=cells)
+        except Exception:
+            return False
+
+        # get the data we need from the statement
+        pdb_eval = locals_copy["__pdb_eval__"]
+
+        # __pdb_eval__ should not be updated back to locals
+        pdb_eval["write_back"].pop("__pdb_eval__")
+
+        # Write all local variables back to locals
+        locals.update(pdb_eval["write_back"])
+        eval_result = pdb_eval["result"]
+        if eval_result is not None:
+            print(repr(eval_result))
+
+        return True
+
+    def default(self, line):  # type: ignore[no-untyped-def]
+        if line[:1] == "!":
+            line = line[1:].strip()
+        locals = self.curframe_locals
+        globals = self.curframe.f_globals
+        try:
+            buffer = line
+            if (
+                code := codeop.compile_command(line + "\n", "<stdin>", "single")
+            ) is None:
+                # Multi-line mode
+                with self._disable_command_completion():
+                    buffer = line
+                    continue_prompt = "...   "
+                    while (
+                        code := codeop.compile_command(buffer, "<stdin>", "single")
+                    ) is None:
+                        if self.use_rawinput:
+                            try:
+                                line = input(continue_prompt)
+                            except (EOFError, KeyboardInterrupt):
+                                self.lastcmd = ""
+                                print("\n")
+                                return
+                        else:
+                            self.stdout.write(continue_prompt)
+                            self.stdout.flush()
+                            line = self.stdin.readline()
+                            if not len(line):
+                                self.lastcmd = ""
+                                self.stdout.write("\n")
+                                self.stdout.flush()
+                                return
+                            else:
+                                line = line.rstrip("\r\n")
+                        buffer += "\n" + line
+            save_stdout = sys.stdout
+            save_stdin = sys.stdin
+            save_displayhook = sys.displayhook
+            try:
+                sys.stdin = self.stdin
+                sys.stdout = self.stdout
+                sys.displayhook = self.displayhook
+                if not self._exec_in_closure(buffer, globals, locals):
+                    exec(code, globals, locals)
+            finally:
+                sys.stdout = save_stdout
+                sys.stdin = save_stdin
+                sys.displayhook = save_displayhook
+        except:
+            self._error_exc()
diff --git a/IPython/core/display.py b/IPython/core/display.py
index 57375c2cb47..ab4bc2c85a7 100644
--- a/IPython/core/display.py
+++ b/IPython/core/display.py
@@ -1,122 +1,1266 @@
-# -*- coding: utf-8 -*-
-"""Top-level display functions for displaying object in different formats.
+"""Top-level display functions for displaying object in different formats."""
 
-Authors:
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-* Brian Granger
-"""
 
-#-----------------------------------------------------------------------------
-#       Copyright (C) 2008-2010 The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+from binascii import b2a_base64, hexlify
+import html
+import json
+import mimetypes
+import os
+import struct
+import warnings
+from copy import deepcopy
+from os.path import splitext
+from pathlib import Path, PurePath
+
+from typing import Optional
+
+from IPython.testing.skipdoctest import skip_doctest
+from . import display_functions
+
+
+__all__ = [
+    "display_pretty",
+    "display_html",
+    "display_markdown",
+    "display_svg",
+    "display_png",
+    "display_jpeg",
+    "display_webp",
+    "display_latex",
+    "display_json",
+    "display_javascript",
+    "display_pdf",
+    "DisplayObject",
+    "TextDisplayObject",
+    "Pretty",
+    "HTML",
+    "Markdown",
+    "Math",
+    "Latex",
+    "SVG",
+    "ProgressBar",
+    "JSON",
+    "GeoJSON",
+    "Javascript",
+    "Image",
+    "Video",
+]
 
 #-----------------------------------------------------------------------------
-# Imports
+# utility functions
 #-----------------------------------------------------------------------------
 
+def _safe_exists(path):
+    """Check path, but don't let exceptions raise"""
+    try:
+        return os.path.exists(path)
+    except Exception:
+        return False
+
+
+def _display_mimetype(mimetype, objs, raw=False, metadata=None):
+    """internal implementation of all display_foo methods
+
+    Parameters
+    ----------
+    mimetype : str
+        The mimetype to be published (e.g. 'image/png')
+    *objs : object
+        The Python objects to display, or if raw=True raw text data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
+    if metadata:
+        metadata = {mimetype: metadata}
+    if raw:
+        # turn list of pngdata into list of { 'image/png': pngdata }
+        objs = [ {mimetype: obj} for obj in objs ]
+    display_functions.display(*objs, raw=raw, metadata=metadata, include=[mimetype])
+
 #-----------------------------------------------------------------------------
 # Main functions
 #-----------------------------------------------------------------------------
 
-def display(*objs, **kwargs):
-    """Display a Python object in all frontends.
 
-    By default all representations will be computed and sent to the frontends.
-    Frontends can decide which representation is used and how.
+def display_pretty(*objs, **kwargs):
+    """Display the pretty (default) representation of an object.
 
     Parameters
     ----------
-    objs : tuple of objects
-        The Python objects to display.
-    include : list or tuple, optional
-        A list of format type strings (MIME types) to include in the
-        format data dict. If this is set *only* the format types included
-        in this list will be computed.
-    exclude : list or tuple, optional
-        A list of format type string (MIME types) to exclue in the format
-        data dict. If this is set all format types will be computed,
-        except for those included in this argument.
-    """
-    include = kwargs.get('include')
-    exclude = kwargs.get('exclude')
-    
-    from IPython.core.interactiveshell import InteractiveShell
-    inst = InteractiveShell.instance()
-    format = inst.display_formatter.format
-    publish = inst.display_pub.publish
-
-    for obj in objs:
-        format_dict = format(obj, include=include, exclude=exclude)
-        publish('IPython.core.display.display', format_dict)
-
-
-def display_pretty(*objs):
-    """Display the pretty (default) representation of an object.
+    *objs : object
+        The Python objects to display, or if raw=True raw text data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
+    _display_mimetype('text/plain', objs, **kwargs)
+
+
+def display_html(*objs, **kwargs):
+    """Display the HTML representation of an object.
+
+    Note: If raw=False and the object does not have a HTML
+    representation, no HTML will be shown.
 
     Parameters
     ----------
-    objs : tuple of objects
-        The Python objects to display.
+    *objs : object
+        The Python objects to display, or if raw=True raw HTML data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
     """
-    display(*objs, include=['text/plain'])
+    _display_mimetype('text/html', objs, **kwargs)
 
 
-def display_html(*objs):
-    """Display the HTML representation of an object.
+def display_markdown(*objs, **kwargs):
+    """Displays the Markdown representation of an object.
 
     Parameters
     ----------
-    objs : tuple of objects
-        The Python objects to display.
-        """
-    display(*objs, include=['text/plain','text/html'])
+    *objs : object
+        The Python objects to display, or if raw=True raw markdown data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
 
+    _display_mimetype('text/markdown', objs, **kwargs)
 
-def display_svg(*objs):
+
+def display_svg(*objs, **kwargs):
     """Display the SVG representation of an object.
 
     Parameters
     ----------
-    objs : tuple of objects
-        The Python objects to display.
+    *objs : object
+        The Python objects to display, or if raw=True raw svg data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
     """
-    display(*objs, include=['text/plain','image/svg+xml'])
+    _display_mimetype('image/svg+xml', objs, **kwargs)
 
 
-def display_png(*objs):
+def display_png(*objs, **kwargs):
     """Display the PNG representation of an object.
 
     Parameters
     ----------
-    objs : tuple of objects
-        The Python objects to display.
+    *objs : object
+        The Python objects to display, or if raw=True raw png data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
+    _display_mimetype('image/png', objs, **kwargs)
+
+
+def display_jpeg(*objs, **kwargs):
+    """Display the JPEG representation of an object.
+
+    Parameters
+    ----------
+    *objs : object
+        The Python objects to display, or if raw=True raw JPEG data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
     """
-    display(*objs, include=['text/plain','image/png'])
+    _display_mimetype('image/jpeg', objs, **kwargs)
 
 
-def display_latex(*objs):
+def display_webp(*objs, **kwargs):
+    """Display the WEBP representation of an object.
+
+    Parameters
+    ----------
+    *objs : object
+        The Python objects to display, or if raw=True raw JPEG data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
+    _display_mimetype("image/webp", objs, **kwargs)
+
+
+def display_latex(*objs, **kwargs):
     """Display the LaTeX representation of an object.
 
     Parameters
     ----------
-    objs : tuple of objects
-        The Python objects to display.
+    *objs : object
+        The Python objects to display, or if raw=True raw latex data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
     """
-    display(*objs, include=['text/plain','text/latex'])
+    _display_mimetype('text/latex', objs, **kwargs)
 
 
-def display_json(*objs):
+def display_json(*objs, **kwargs):
     """Display the JSON representation of an object.
 
+    Note that not many frontends support displaying JSON.
+
+    Parameters
+    ----------
+    *objs : object
+        The Python objects to display, or if raw=True raw json data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
+    _display_mimetype('application/json', objs, **kwargs)
+
+
+def display_javascript(*objs, **kwargs):
+    """Display the Javascript representation of an object.
+
+    Parameters
+    ----------
+    *objs : object
+        The Python objects to display, or if raw=True raw javascript data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
+    _display_mimetype('application/javascript', objs, **kwargs)
+
+
+def display_pdf(*objs, **kwargs):
+    """Display the PDF representation of an object.
+
+    Parameters
+    ----------
+    *objs : object
+        The Python objects to display, or if raw=True raw javascript data to
+        display.
+    raw : bool
+        Are the data objects raw data or Python objects that need to be
+        formatted before display? [default: False]
+    metadata : dict (optional)
+        Metadata to be associated with the specific mimetype output.
+    """
+    _display_mimetype('application/pdf', objs, **kwargs)
+
+
+#-----------------------------------------------------------------------------
+# Smart classes
+#-----------------------------------------------------------------------------
+
+
+class DisplayObject:
+    """An object that wraps data to be displayed."""
+
+    _read_flags = 'r'
+    _show_mem_addr = False
+    metadata = None
+
+    def __init__(self, data=None, url=None, filename=None, metadata=None):
+        """Create a display object given raw data.
+
+        When this object is returned by an expression or passed to the
+        display function, it will result in the data being displayed
+        in the frontend. The MIME type of the data should match the
+        subclasses used, so the Png subclass should be used for 'image/png'
+        data. If the data is a URL, the data will first be downloaded
+        and then displayed.
+
+        Parameters
+        ----------
+        data : unicode, str or bytes
+            The raw data or a URL or file to load the data from
+        url : unicode
+            A URL to download the data from.
+        filename : unicode
+            Path to a local file to load the data from.
+        metadata : dict
+            Dict of metadata associated to be the object when displayed
+        """
+        if isinstance(data, (Path, PurePath)):
+            data = str(data)
+
+        if data is not None and isinstance(data, str):
+            if data.startswith('http') and url is None:
+                url = data
+                filename = None
+                data = None
+            elif _safe_exists(data) and filename is None:
+                url = None
+                filename = data
+                data = None
+
+        self.url = url
+        self.filename = filename
+        # because of @data.setter methods in
+        # subclasses ensure url and filename are set
+        # before assigning to self.data
+        self.data = data
+
+        if metadata is not None:
+            self.metadata = metadata
+        elif self.metadata is None:
+            self.metadata = {}
+
+        self.reload()
+        self._check_data()
+
+    def __repr__(self):
+        if not self._show_mem_addr:
+            cls = self.__class__
+            r = "<%s.%s object>" % (cls.__module__, cls.__name__)
+        else:
+            r = super(DisplayObject, self).__repr__()
+        return r
+
+    def _check_data(self):
+        """Override in subclasses if there's something to check."""
+        pass
+
+    def _data_and_metadata(self):
+        """shortcut for returning metadata with shape information, if defined"""
+        if self.metadata:
+            return self.data, deepcopy(self.metadata)
+        else:
+            return self.data
+
+    def reload(self):
+        """Reload the raw data from file or URL."""
+        if self.filename is not None:
+            encoding = None if "b" in self._read_flags else "utf-8"
+            with open(self.filename, self._read_flags, encoding=encoding) as f:
+                self.data = f.read()
+        elif self.url is not None:
+            # Deferred import
+            from urllib.request import urlopen
+            response = urlopen(self.url)
+            data = response.read()
+            # extract encoding from header, if there is one:
+            encoding = None
+            if 'content-type' in response.headers:
+                for sub in response.headers['content-type'].split(';'):
+                    sub = sub.strip()
+                    if sub.startswith('charset'):
+                        encoding = sub.split('=')[-1].strip()
+                        break
+            if 'content-encoding' in response.headers:
+                # TODO: do deflate?
+                if 'gzip' in response.headers['content-encoding']:
+                    import gzip
+                    from io import BytesIO
+
+                    # assume utf-8 if encoding is not specified
+                    with gzip.open(
+                        BytesIO(data), "rt", encoding=encoding or "utf-8"
+                    ) as fp:
+                        encoding = None
+                        data = fp.read()
+
+            # decode data, if an encoding was specified
+            # We only touch self.data once since
+            # subclasses such as SVG have @data.setter methods
+            # that transform self.data into ... well svg.
+            if encoding:
+                self.data = data.decode(encoding, 'replace')
+            else:
+                self.data = data
+
+
+class TextDisplayObject(DisplayObject):
+    """Create a text display object given raw data.
+
     Parameters
     ----------
-    objs : tuple of objects
-        The Python objects to display.
+    data : str or unicode
+        The raw data or a URL or file to load the data from.
+    url : unicode
+        A URL to download the data from.
+    filename : unicode
+        Path to a local file to load the data from.
+    metadata : dict
+        Dict of metadata associated to be the object when displayed
     """
-    display(*objs, include=['text/plain','application/json'])
+    def _check_data(self):
+        if self.data is not None and not isinstance(self.data, str):
+            raise TypeError("%s expects text, not %r" % (self.__class__.__name__, self.data))
+
+class Pretty(TextDisplayObject):
+
+    def _repr_pretty_(self, pp, cycle):
+        return pp.text(self.data)
+
+
+class HTML(TextDisplayObject):
+
+    def __init__(self, data=None, url=None, filename=None, metadata=None):
+        def warn():
+            if not data:
+                return False
+
+            #
+            # Avoid calling lower() on the entire data, because it could be a
+            # long string and we're only interested in its beginning and end.
+            #
+            prefix = data[:10].lower()
+            suffix = data[-10:].lower()
+            return prefix.startswith("<iframe ") and suffix.endswith("</iframe>")
+
+        if warn():
+            warnings.warn("Consider using IPython.display.IFrame instead")
+        super(HTML, self).__init__(data=data, url=url, filename=filename, metadata=metadata)
+
+    def _repr_html_(self):
+        return self._data_and_metadata()
+
+    def __html__(self):
+        """
+        This method exists to inform other HTML-using modules (e.g. Markupsafe,
+        htmltag, etc) that this object is HTML and does not need things like
+        special characters (<>&) escaped.
+        """
+        return self._repr_html_()
+
+
+class Markdown(TextDisplayObject):
+
+    def _repr_markdown_(self):
+        return self._data_and_metadata()
+
+
+class Math(TextDisplayObject):
+
+    def _repr_latex_(self):
+        s = r"$\displaystyle %s$" % self.data.strip('$')
+        if self.metadata:
+            return s, deepcopy(self.metadata)
+        else:
+            return s
+
+
+class Latex(TextDisplayObject):
+
+    def _repr_latex_(self):
+        return self._data_and_metadata()
+
+
+class SVG(DisplayObject):
+    """Embed an SVG into the display.
+
+    Note if you just want to view a svg image via a URL use `:class:Image` with
+    a url=URL keyword argument.
+    """
+
+    _read_flags = 'rb'
+    # wrap data in a property, which extracts the <svg> tag, discarding
+    # document headers
+    _data: Optional[str] = None
+
+    @property
+    def data(self):
+        return self._data
+
+    @data.setter
+    def data(self, svg):
+        if svg is None:
+            self._data = None
+            return
+        # parse into dom object
+        from xml.dom import minidom
+        x = minidom.parseString(svg)
+        # get svg tag (should be 1)
+        found_svg = x.getElementsByTagName('svg')
+        if found_svg:
+            svg = found_svg[0].toxml()
+        else:
+            # fallback on the input, trust the user
+            # but this is probably an error.
+            pass
+        if isinstance(svg, bytes):
+            self._data = svg.decode(errors="replace")
+        else:
+            self._data = svg
+
+    def _repr_svg_(self):
+        return self._data_and_metadata()
+
+class ProgressBar(DisplayObject):
+    """Progressbar supports displaying a progressbar like element
+    """
+    def __init__(self, total):
+        """Creates a new progressbar
+
+        Parameters
+        ----------
+        total : int
+            maximum size of the progressbar
+        """
+        self.total = total
+        self._progress = 0
+        self.html_width = '60ex'
+        self.text_width = 60
+        self._display_id = hexlify(os.urandom(8)).decode('ascii')
+
+    def __repr__(self):
+        fraction = self.progress / self.total
+        filled = '=' * int(fraction * self.text_width)
+        rest = ' ' * (self.text_width - len(filled))
+        return '[{}{}] {}/{}'.format(
+            filled, rest,
+            self.progress, self.total,
+        )
+
+    def _repr_html_(self):
+        return "<progress style='width:{}' max='{}' value='{}'></progress>".format(
+            self.html_width, self.total, self.progress)
+
+    def display(self):
+        display_functions.display(self, display_id=self._display_id)
+
+    def update(self):
+        display_functions.display(self, display_id=self._display_id, update=True)
+
+    @property
+    def progress(self):
+        return self._progress
+
+    @progress.setter
+    def progress(self, value):
+        self._progress = value
+        self.update()
+
+    def __iter__(self):
+        self.display()
+        self._progress = -1 # First iteration is 0
+        return self
+
+    def __next__(self):
+        """Returns current value and increments display by one."""
+        self.progress += 1
+        if self.progress < self.total:
+            return self.progress
+        else:
+            raise StopIteration()
+
+class JSON(DisplayObject):
+    """JSON expects a JSON-able dict or list
+
+    not an already-serialized JSON string.
+
+    Scalar types (None, number, string) are not allowed, only dict or list containers.
+    """
+    # wrap data in a property, which warns about passing already-serialized JSON
+    _data = None
+    def __init__(self, data=None, url=None, filename=None, expanded=False, metadata=None, root='root', **kwargs):
+        """Create a JSON display object given raw data.
+
+        Parameters
+        ----------
+        data : dict or list
+            JSON data to display. Not an already-serialized JSON string.
+            Scalar types (None, number, string) are not allowed, only dict
+            or list containers.
+        url : unicode
+            A URL to download the data from.
+        filename : unicode
+            Path to a local file to load the data from.
+        expanded : boolean
+            Metadata to control whether a JSON display component is expanded.
+        metadata : dict
+            Specify extra metadata to attach to the json display object.
+        root : str
+            The name of the root element of the JSON tree
+        """
+        self.metadata = {
+            'expanded': expanded,
+            'root': root,
+        }
+        if metadata:
+            self.metadata.update(metadata)
+        if kwargs:
+            self.metadata.update(kwargs)
+        super(JSON, self).__init__(data=data, url=url, filename=filename)
+
+    def _check_data(self):
+        if self.data is not None and not isinstance(self.data, (dict, list)):
+            raise TypeError("%s expects JSONable dict or list, not %r" % (self.__class__.__name__, self.data))
+
+    @property
+    def data(self):
+        return self._data
+
+    @data.setter
+    def data(self, data):
+        if isinstance(data, (Path, PurePath)):
+            data = str(data)
+
+        if isinstance(data, str):
+            if self.filename is None and self.url is None:
+                warnings.warn("JSON expects JSONable dict or list, not JSON strings")
+            data = json.loads(data)
+        self._data = data
+
+    def _data_and_metadata(self):
+        return self.data, self.metadata
+
+    def _repr_json_(self):
+        return self._data_and_metadata()
+
+
+_css_t = """var link = document.createElement("link");
+	link.rel = "stylesheet";
+	link.type = "text/css";
+	link.href = "%s";
+	document.head.appendChild(link);
+"""
+
+_lib_t1 = """new Promise(function(resolve, reject) {
+	var script = document.createElement("script");
+	script.onload = resolve;
+	script.onerror = reject;
+	script.src = "%s";
+	document.head.appendChild(script);
+}).then(() => {
+"""
+
+_lib_t2 = """
+});"""
+
+class GeoJSON(JSON):
+    """GeoJSON expects JSON-able dict
+
+    not an already-serialized JSON string.
+
+    Scalar types (None, number, string) are not allowed, only dict containers.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Create a GeoJSON display object given raw data.
+
+        Parameters
+        ----------
+        data : dict or list
+            VegaLite data. Not an already-serialized JSON string.
+            Scalar types (None, number, string) are not allowed, only dict
+            or list containers.
+        url_template : string
+            Leaflet TileLayer URL template: http://leafletjs.com/reference.html#url-template
+        layer_options : dict
+            Leaflet TileLayer options: http://leafletjs.com/reference.html#tilelayer-options
+        url : unicode
+            A URL to download the data from.
+        filename : unicode
+            Path to a local file to load the data from.
+        metadata : dict
+            Specify extra metadata to attach to the json display object.
+
+        Examples
+        --------
+        The following will display an interactive map of Mars with a point of
+        interest on frontend that do support GeoJSON display.
+
+            >>> from IPython.display import GeoJSON
+
+            >>> GeoJSON(data={
+            ...     "type": "Feature",
+            ...     "geometry": {
+            ...         "type": "Point",
+            ...         "coordinates": [-81.327, 296.038]
+            ...     }
+            ... },
+            ... url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
+            ... layer_options={
+            ...     "basemap_id": "celestia_mars-shaded-16k_global",
+            ...     "attribution" : "Celestia/praesepe",
+            ...     "minZoom" : 0,
+            ...     "maxZoom" : 18,
+            ... })
+            <IPython.core.display.GeoJSON object>
+
+        In the terminal IPython, you will only see the text representation of
+        the GeoJSON object.
+
+        """
+
+        super(GeoJSON, self).__init__(*args, **kwargs)
+
+
+    def _ipython_display_(self):
+        bundle = {
+            'application/geo+json': self.data,
+            'text/plain': '<IPython.display.GeoJSON object>'
+        }
+        metadata = {
+            'application/geo+json': self.metadata
+        }
+        display_functions.display(bundle, metadata=metadata, raw=True)
+
+class Javascript(TextDisplayObject):
+
+    def __init__(self, data=None, url=None, filename=None, lib=None, css=None):
+        """Create a Javascript display object given raw data.
+
+        When this object is returned by an expression or passed to the
+        display function, it will result in the data being displayed
+        in the frontend. If the data is a URL, the data will first be
+        downloaded and then displayed.
+
+        In the Notebook, the containing element will be available as `element`,
+        and jQuery will be available.  Content appended to `element` will be
+        visible in the output area.
+
+        Parameters
+        ----------
+        data : unicode, str or bytes
+            The Javascript source code or a URL to download it from.
+        url : unicode
+            A URL to download the data from.
+        filename : unicode
+            Path to a local file to load the data from.
+        lib : list or str
+            A sequence of Javascript library URLs to load asynchronously before
+            running the source code. The full URLs of the libraries should
+            be given. A single Javascript library URL can also be given as a
+            string.
+        css : list or str
+            A sequence of css files to load before running the source code.
+            The full URLs of the css files should be given. A single css URL
+            can also be given as a string.
+        """
+        if isinstance(lib, str):
+            lib = [lib]
+        elif lib is None:
+            lib = []
+        if isinstance(css, str):
+            css = [css]
+        elif css is None:
+            css = []
+        if not isinstance(lib, (list,tuple)):
+            raise TypeError('expected sequence, got: %r' % lib)
+        if not isinstance(css, (list,tuple)):
+            raise TypeError('expected sequence, got: %r' % css)
+        self.lib = lib
+        self.css = css
+        super(Javascript, self).__init__(data=data, url=url, filename=filename)
+
+    def _repr_javascript_(self):
+        r = ''
+        for c in self.css:
+            r += _css_t % c
+        for l in self.lib:
+            r += _lib_t1 % l
+        r += self.data
+        r += _lib_t2*len(self.lib)
+        return r
+
+
+# constants for identifying png/jpeg/gif/webp data
+_PNG = b"\x89PNG\r\n\x1a\n"
+_JPEG = b"\xff\xd8"
+_GIF1 = b"GIF87a"
+_GIF2 = b"GIF89a"
+_WEBP = b"WEBP"
+
+
+def _pngxy(data):
+    """read the (width, height) from a PNG header"""
+    ihdr = data.index(b'IHDR')
+    # next 8 bytes are width/height
+    return struct.unpack('>ii', data[ihdr+4:ihdr+12])
+
+
+def _jpegxy(data):
+    """read the (width, height) from a JPEG header"""
+    # adapted from http://www.64lines.com/jpeg-width-height
+
+    idx = 4
+    while True:
+        block_size = struct.unpack('>H', data[idx:idx+2])[0]
+        idx = idx + block_size
+        if data[idx:idx+2] == b'\xFF\xC0':
+            # found Start of Frame
+            iSOF = idx
+            break
+        else:
+            # read another block
+            idx += 2
+
+    h, w = struct.unpack('>HH', data[iSOF+5:iSOF+9])
+    return w, h
+
+
+def _gifxy(data):
+    """read the (width, height) from a GIF header"""
+    return struct.unpack('<HH', data[6:10])
+
+
+def _webpxy(data):
+    """read the (width, height) from a WEBP header"""
+    if data[12:16] == b"VP8 ":
+        width, height = struct.unpack("<HH", data[24:30])
+        width = width & 0x3FFF
+        height = height & 0x3FFF
+        return (width, height)
+    elif data[12:16] == b"VP8L":
+        size_info = struct.unpack("<I", data[21:25])[0]
+        width = 1 + ((size_info & 0x3F) << 8) | (size_info >> 24)
+        height = 1 + (
+            (((size_info >> 8) & 0xF) << 10)
+            | (((size_info >> 14) & 0x3FC) << 2)
+            | ((size_info >> 22) & 0x3)
+        )
+        return (width, height)
+    else:
+        raise ValueError("Not a valid WEBP header")
+
+
+class Image(DisplayObject):
+
+    _read_flags = "rb"
+    _FMT_JPEG = "jpeg"
+    _FMT_PNG = "png"
+    _FMT_GIF = "gif"
+    _FMT_WEBP = "webp"
+    _ACCEPTABLE_EMBEDDINGS = [_FMT_JPEG, _FMT_PNG, _FMT_GIF, _FMT_WEBP]
+    _MIMETYPES = {
+        _FMT_PNG: "image/png",
+        _FMT_JPEG: "image/jpeg",
+        _FMT_GIF: "image/gif",
+        _FMT_WEBP: "image/webp",
+    }
+
+    def __init__(
+        self,
+        data=None,
+        url=None,
+        filename=None,
+        format=None,
+        embed=None,
+        width=None,
+        height=None,
+        retina=False,
+        unconfined=False,
+        metadata=None,
+        alt=None,
+    ):
+        """Create a PNG/JPEG/GIF/WEBP image object given raw data.
+
+        When this object is returned by an input cell or passed to the
+        display function, it will result in the image being displayed
+        in the frontend.
+
+        Parameters
+        ----------
+        data : unicode, str or bytes
+            The raw image data or a URL or filename to load the data from.
+            This always results in embedded image data.
+
+        url : unicode
+            A URL to download the data from. If you specify `url=`,
+            the image data will not be embedded unless you also specify `embed=True`.
+
+        filename : unicode
+            Path to a local file to load the data from.
+            Images from a file are always embedded.
+
+        format : unicode
+            The format of the image data (png/jpeg/jpg/gif/webp). If a filename or URL is given
+            for format will be inferred from the filename extension.
+
+        embed : bool
+            Should the image data be embedded using a data URI (True) or be
+            loaded using an <img> tag. Set this to True if you want the image
+            to be viewable later with no internet connection in the notebook.
+
+            Default is `True`, unless the keyword argument `url` is set, then
+            default value is `False`.
+
+            Note that QtConsole is not able to display images if `embed` is set to `False`
+
+        width : int
+            Width in pixels to which to constrain the image in html
+
+        height : int
+            Height in pixels to which to constrain the image in html
+
+        retina : bool
+            Automatically set the width and height to half of the measured
+            width and height.
+            This only works for embedded images because it reads the width/height
+            from image data.
+            For non-embedded images, you can just set the desired display width
+            and height directly.
+
+        unconfined : bool
+            Set unconfined=True to disable max-width confinement of the image.
+
+        metadata : dict
+            Specify extra metadata to attach to the image.
+
+        alt : unicode
+            Alternative text for the image, for use by screen readers.
+
+        Examples
+        --------
+        embedded image data, works in qtconsole and notebook
+        when passed positionally, the first arg can be any of raw image data,
+        a URL, or a filename from which to load image data.
+        The result is always embedding image data for inline images.
+
+        >>> Image('https://www.google.fr/images/srpr/logo3w.png') # doctest: +SKIP
+        <IPython.core.display.Image object>
+
+        >>> Image('/path/to/image.jpg')
+        <IPython.core.display.Image object>
+
+        >>> Image(b'RAW_PNG_DATA...')
+        <IPython.core.display.Image object>
+
+        Specifying Image(url=...) does not embed the image data,
+        it only generates ``<img>`` tag with a link to the source.
+        This will not work in the qtconsole or offline.
+
+        >>> Image(url='https://www.google.fr/images/srpr/logo3w.png')
+        <IPython.core.display.Image object>
+
+        """
+        if isinstance(data, (Path, PurePath)):
+            data = str(data)
+
+        if filename is not None:
+            ext = self._find_ext(filename)
+        elif url is not None:
+            ext = self._find_ext(url)
+        elif data is None:
+            raise ValueError("No image data found. Expecting filename, url, or data.")
+        elif isinstance(data, str) and (
+            data.startswith('http') or _safe_exists(data)
+        ):
+            ext = self._find_ext(data)
+        else:
+            ext = None
+
+        if format is None:
+            if ext is not None:
+                if ext == u'jpg' or ext == u'jpeg':
+                    format = self._FMT_JPEG
+                elif ext == u'png':
+                    format = self._FMT_PNG
+                elif ext == u'gif':
+                    format = self._FMT_GIF
+                elif ext == "webp":
+                    format = self._FMT_WEBP
+                else:
+                    format = ext.lower()
+            elif isinstance(data, bytes):
+                # infer image type from image data header,
+                # only if format has not been specified.
+                if data[:2] == _JPEG:
+                    format = self._FMT_JPEG
+                elif data[:8] == _PNG:
+                    format = self._FMT_PNG
+                elif data[8:12] == _WEBP:
+                    format = self._FMT_WEBP
+                elif data[:6] == _GIF1 or data[:6] == _GIF2:
+                    format = self._FMT_GIF
+
+        # failed to detect format, default png
+        if format is None:
+            format = self._FMT_PNG
+
+        if format.lower() == 'jpg':
+            # jpg->jpeg
+            format = self._FMT_JPEG
+
+        self.format = format.lower()
+        self.embed = embed if embed is not None else (url is None)
+
+        if self.embed and self.format not in self._ACCEPTABLE_EMBEDDINGS:
+            raise ValueError("Cannot embed the '%s' image format" % (self.format))
+        if self.embed:
+            self._mimetype = self._MIMETYPES.get(self.format)
+
+        self.width = width
+        self.height = height
+        self.retina = retina
+        self.unconfined = unconfined
+        self.alt = alt
+        super(Image, self).__init__(data=data, url=url, filename=filename,
+                metadata=metadata)
+
+        if self.width is None and self.metadata.get('width', {}):
+            self.width = metadata['width']
+
+        if self.height is None and self.metadata.get('height', {}):
+            self.height = metadata['height']
+
+        if self.alt is None and self.metadata.get("alt", {}):
+            self.alt = metadata["alt"]
+
+        if retina:
+            self._retina_shape()
+
+
+    def _retina_shape(self):
+        """load pixel-doubled width and height from image data"""
+        if not self.embed:
+            return
+        if self.format == self._FMT_PNG:
+            w, h = _pngxy(self.data)
+        elif self.format == self._FMT_JPEG:
+            w, h = _jpegxy(self.data)
+        elif self.format == self._FMT_GIF:
+            w, h = _gifxy(self.data)
+        else:
+            # retina only supports png
+            return
+        self.width = w // 2
+        self.height = h // 2
+
+    def reload(self):
+        """Reload the raw data from file or URL."""
+        if self.embed:
+            super(Image,self).reload()
+            if self.retina:
+                self._retina_shape()
+
+    def _repr_html_(self):
+        if not self.embed:
+            width = height = klass = alt = ""
+            if self.width:
+                width = ' width="%d"' % self.width
+            if self.height:
+                height = ' height="%d"' % self.height
+            if self.unconfined:
+                klass = ' class="unconfined"'
+            if self.alt:
+                alt = ' alt="%s"' % html.escape(self.alt)
+            return '<img src="{url}"{width}{height}{klass}{alt}/>'.format(
+                url=self.url,
+                width=width,
+                height=height,
+                klass=klass,
+                alt=alt,
+            )
+
+    def _repr_mimebundle_(self, include=None, exclude=None):
+        """Return the image as a mimebundle
+
+        Any new mimetype support should be implemented here.
+        """
+        if self.embed:
+            mimetype = self._mimetype
+            data, metadata = self._data_and_metadata(always_both=True)
+            if metadata:
+                metadata = {mimetype: metadata}
+            return {mimetype: data}, metadata
+        else:
+            return {'text/html': self._repr_html_()}
+
+    def _data_and_metadata(self, always_both=False):
+        """shortcut for returning metadata with shape information, if defined"""
+        try:
+            b64_data = b2a_base64(self.data, newline=False).decode("ascii")
+        except TypeError as e:
+            raise FileNotFoundError(
+                "No such file or directory: '%s'" % (self.data)) from e
+        md = {}
+        if self.metadata:
+            md.update(self.metadata)
+        if self.width:
+            md['width'] = self.width
+        if self.height:
+            md['height'] = self.height
+        if self.unconfined:
+            md['unconfined'] = self.unconfined
+        if self.alt:
+            md["alt"] = self.alt
+        if md or always_both:
+            return b64_data, md
+        else:
+            return b64_data
+
+    def _repr_png_(self):
+        if self.embed and self.format == self._FMT_PNG:
+            return self._data_and_metadata()
+
+    def _repr_jpeg_(self):
+        if self.embed and self.format == self._FMT_JPEG:
+            return self._data_and_metadata()
+
+    def _find_ext(self, s):
+        base, ext = splitext(s)
+
+        if not ext:
+            return base
+
+        # `splitext` includes leading period, so we skip it
+        return ext[1:].lower()
+
+
+class Video(DisplayObject):
+
+    def __init__(self, data=None, url=None, filename=None, embed=False,
+                 mimetype=None, width=None, height=None, html_attributes="controls"):
+        """Create a video object given raw data or an URL.
+
+        When this object is returned by an input cell or passed to the
+        display function, it will result in the video being displayed
+        in the frontend.
+
+        Parameters
+        ----------
+        data : unicode, str or bytes
+            The raw video data or a URL or filename to load the data from.
+            Raw data will require passing ``embed=True``.
+
+        url : unicode
+            A URL for the video. If you specify ``url=``,
+            the image data will not be embedded.
+
+        filename : unicode
+            Path to a local file containing the video.
+            Will be interpreted as a local URL unless ``embed=True``.
+
+        embed : bool
+            Should the video be embedded using a data URI (True) or be
+            loaded using a <video> tag (False).
+
+            Since videos are large, embedding them should be avoided, if possible.
+            You must confirm embedding as your intention by passing ``embed=True``.
+
+            Local files can be displayed with URLs without embedding the content, via::
+
+                Video('./video.mp4')
+
+        mimetype : unicode
+            Specify the mimetype for embedded videos.
+            Default will be guessed from file extension, if available.
+
+        width : int
+            Width in pixels to which to constrain the video in HTML.
+            If not supplied, defaults to the width of the video.
+
+        height : int
+            Height in pixels to which to constrain the video in html.
+            If not supplied, defaults to the height of the video.
+
+        html_attributes : str
+            Attributes for the HTML ``<video>`` block.
+            Default: ``"controls"`` to get video controls.
+            Other examples: ``"controls muted"`` for muted video with controls,
+            ``"loop autoplay"`` for looping autoplaying video without controls.
+
+        Examples
+        --------
+        ::
+
+            Video('https://archive.org/download/Sita_Sings_the_Blues/Sita_Sings_the_Blues_small.mp4')
+            Video('path/to/video.mp4')
+            Video('path/to/video.mp4', embed=True)
+            Video('path/to/video.mp4', embed=True, html_attributes="controls muted autoplay")
+            Video(b'raw-videodata', embed=True)
+        """
+        if isinstance(data, (Path, PurePath)):
+            data = str(data)
+
+        if url is None and isinstance(data, str) and data.startswith(('http:', 'https:')):
+            url = data
+            data = None
+        elif data is not None and os.path.exists(data):
+            filename = data
+            data = None
+
+        if data and not embed:
+            msg = ''.join([
+                "To embed videos, you must pass embed=True ",
+                "(this may make your notebook files huge)\n",
+                "Consider passing Video(url='...')",
+            ])
+            raise ValueError(msg)
+
+        self.mimetype = mimetype
+        self.embed = embed
+        self.width = width
+        self.height = height
+        self.html_attributes = html_attributes
+        super(Video, self).__init__(data=data, url=url, filename=filename)
+
+    def _repr_html_(self):
+        width = height = ''
+        if self.width:
+            width = ' width="%d"' % self.width
+        if self.height:
+            height = ' height="%d"' % self.height
+
+        # External URLs and potentially local files are not embedded into the
+        # notebook output.
+        if not self.embed:
+            url = self.url if self.url is not None else self.filename
+            output = """<video src="{0}" {1} {2} {3}>
+      Your browser does not support the <code>video</code> element.
+    </video>""".format(url, self.html_attributes, width, height)
+            return output
+
+        # Embedded videos are base64-encoded.
+        mimetype = self.mimetype
+        if self.filename is not None:
+            if not mimetype:
+                mimetype, _ = mimetypes.guess_type(self.filename)
 
+            with open(self.filename, 'rb') as f:
+                video = f.read()
+        else:
+            video = self.data
+        if isinstance(video, str):
+            # unicode input is already b64-encoded
+            b64_video = video
+        else:
+            b64_video = b2a_base64(video, newline=False).decode("ascii").rstrip()
 
+        output = """<video {0} {1} {2}>
+ <source src="data:{3};base64,{4}" type="{3}">
+ Your browser does not support the video tag.
+ </video>""".format(self.html_attributes, width, height, mimetype, b64_video)
+        return output
 
+    def reload(self):
+        # TODO
+        pass
diff --git a/IPython/core/display_functions.py b/IPython/core/display_functions.py
new file mode 100644
index 00000000000..18825849368
--- /dev/null
+++ b/IPython/core/display_functions.py
@@ -0,0 +1,371 @@
+"""Top-level display functions for displaying object in different formats."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+from binascii import b2a_hex
+import os
+import sys
+import warnings
+
+__all__ = ['display', 'clear_output', 'publish_display_data', 'update_display', 'DisplayHandle']
+
+#-----------------------------------------------------------------------------
+# utility functions
+#-----------------------------------------------------------------------------
+
+
+def _merge(d1, d2):
+    """Like update, but merges sub-dicts instead of clobbering at the top level.
+
+    Updates d1 in-place
+    """
+
+    if not isinstance(d2, dict) or not isinstance(d1, dict):
+        return d2
+    for key, value in d2.items():
+        d1[key] = _merge(d1.get(key), value)
+    return d1
+
+
+#-----------------------------------------------------------------------------
+# Main functions
+#-----------------------------------------------------------------------------
+
+# use * to indicate transient is keyword-only
+def publish_display_data(data, metadata=None, *, transient=None, **kwargs):
+    """Publish data and metadata to all frontends.
+
+    See the ``display_data`` message in the messaging documentation for
+    more details about this message type.
+
+    Keys of data and metadata can be any mime-type.
+
+    Parameters
+    ----------
+    data : dict
+        A dictionary having keys that are valid MIME types (like
+        'text/plain' or 'image/svg+xml') and values that are the data for
+        that MIME type. The data itself must be a JSON'able data
+        structure. Minimally all data should have the 'text/plain' data,
+        which can be displayed by all frontends. If more than the plain
+        text is given, it is up to the frontend to decide which
+        representation to use.
+    metadata : dict
+        A dictionary for metadata related to the data. This can contain
+        arbitrary key, value pairs that frontends can use to interpret
+        the data. mime-type keys matching those in data can be used
+        to specify metadata about particular representations.
+    transient : dict, keyword-only
+        A dictionary of transient data, such as display_id.
+    """
+    from IPython.core.interactiveshell import InteractiveShell
+
+    display_pub = InteractiveShell.instance().display_pub
+
+    # only pass transient if supplied,
+    # to avoid errors with older ipykernel.
+    # TODO: We could check for ipykernel version and provide a detailed upgrade message.
+    if transient:
+        kwargs['transient'] = transient
+
+    display_pub.publish(
+        data=data,
+        metadata=metadata,
+        **kwargs
+    )
+
+
+def _new_id():
+    """Generate a new random text id with urandom"""
+    return b2a_hex(os.urandom(16)).decode('ascii')
+
+
+def display(
+    *objs,
+    include=None,
+    exclude=None,
+    metadata=None,
+    transient=None,
+    display_id=None,
+    raw=False,
+    clear=False,
+    **kwargs,
+):
+    """Display a Python object in all frontends.
+
+    By default all representations will be computed and sent to the frontends.
+    Frontends can decide which representation is used and how.
+
+    In terminal IPython this will be similar to using :func:`print`, for use in richer
+    frontends see Jupyter notebook examples with rich display logic.
+
+    Parameters
+    ----------
+    *objs : object
+        The Python objects to display.
+    raw : bool, optional
+        Are the objects to be displayed already mimetype-keyed dicts of raw display data,
+        or Python objects that need to be formatted before display? [default: False]
+    include : list, tuple or set, optional
+        A list of format type strings (MIME types) to include in the
+        format data dict. If this is set *only* the format types included
+        in this list will be computed.
+    exclude : list, tuple or set, optional
+        A list of format type strings (MIME types) to exclude in the format
+        data dict. If this is set all format types will be computed,
+        except for those included in this argument.
+    metadata : dict, optional
+        A dictionary of metadata to associate with the output.
+        mime-type keys in this dictionary will be associated with the individual
+        representation formats, if they exist.
+    transient : dict, optional
+        A dictionary of transient data to associate with the output.
+        Data in this dict should not be persisted to files (e.g. notebooks).
+    display_id : str, bool optional
+        Set an id for the display.
+        This id can be used for updating this display area later via update_display.
+        If given as `True`, generate a new `display_id`
+    clear : bool, optional
+        Should the output area be cleared before displaying anything? If True,
+        this will wait for additional output before clearing. [default: False]
+    **kwargs : additional keyword-args, optional
+        Additional keyword-arguments are passed through to the display publisher.
+
+    Returns
+    -------
+    handle: DisplayHandle
+        Returns a handle on updatable displays for use with :func:`update_display`,
+        if `display_id` is given. Returns :py:data:`None` if no `display_id` is given
+        (default).
+
+    Examples
+    --------
+    >>> class Json(object):
+    ...     def __init__(self, json):
+    ...         self.json = json
+    ...     def _repr_pretty_(self, pp, cycle):
+    ...         import json
+    ...         pp.text(json.dumps(self.json, indent=2))
+    ...     def __repr__(self):
+    ...         return str(self.json)
+    ...
+
+    >>> d = Json({1:2, 3: {4:5}})
+
+    >>> print(d)
+    {1: 2, 3: {4: 5}}
+
+    >>> display(d)
+    {
+      "1": 2,
+      "3": {
+        "4": 5
+      }
+    }
+
+    >>> def int_formatter(integer, pp, cycle):
+    ...     pp.text('I'*integer)
+
+    >>> plain = get_ipython().display_formatter.formatters['text/plain']
+    >>> plain.for_type(int, int_formatter)
+    <function _repr_pprint at 0x...>
+    >>> display(7-5)
+    II
+
+    >>> del plain.type_printers[int]
+    >>> display(7-5)
+    2
+
+    See Also
+    --------
+    :func:`update_display`
+
+    Notes
+    -----
+    In Python, objects can declare their textual representation using the
+    `__repr__` method. IPython expands on this idea and allows objects to declare
+    other, rich representations including:
+
+      - HTML
+      - JSON
+      - PNG
+      - JPEG
+      - SVG
+      - LaTeX
+
+    A single object can declare some or all of these representations; all are
+    handled by IPython's display system.
+
+    The main idea of the first approach is that you have to implement special
+    display methods when you define your class, one for each representation you
+    want to use. Here is a list of the names of the special methods and the
+    values they must return:
+
+      - `_repr_html_`: return raw HTML as a string, or a tuple (see below).
+      - `_repr_json_`: return a JSONable dict, or a tuple (see below).
+      - `_repr_jpeg_`: return raw JPEG data, or a tuple (see below).
+      - `_repr_png_`: return raw PNG data, or a tuple (see below).
+      - `_repr_svg_`: return raw SVG data as a string, or a tuple (see below).
+      - `_repr_latex_`: return LaTeX commands in a string surrounded by "$",
+                        or a tuple (see below).
+      - `_repr_mimebundle_`: return a full mimebundle containing the mapping
+                             from all mimetypes to data.
+                             Use this for any mime-type not listed above.
+
+    The above functions may also return the object's metadata alonside the
+    data.  If the metadata is available, the functions will return a tuple
+    containing the data and metadata, in that order.  If there is no metadata
+    available, then the functions will return the data only.
+
+    When you are directly writing your own classes, you can adapt them for
+    display in IPython by following the above approach. But in practice, you
+    often need to work with existing classes that you can't easily modify.
+
+    You can refer to the documentation on integrating with the display system in
+    order to register custom formatters for already existing types
+    (:ref:`integrating_rich_display`).
+
+    .. versionadded:: 5.4 display available without import
+    .. versionadded:: 6.1 display available without import
+
+    Since IPython 5.4 and 6.1 :func:`display` is automatically made available to
+    the user without import. If you are using display in a document that might
+    be used in a pure python context or with older version of IPython, use the
+    following import at the top of your file::
+
+        from IPython.display import display
+
+    """
+    from IPython.core.interactiveshell import InteractiveShell
+
+    if not InteractiveShell.initialized():
+        # Directly print objects.
+        print(*objs)
+        return
+
+    if transient is None:
+        transient = {}
+    if metadata is None:
+        metadata={}
+    if display_id:
+        if display_id is True:
+            display_id = _new_id()
+        transient['display_id'] = display_id
+    if kwargs.get('update') and 'display_id' not in transient:
+        raise TypeError('display_id required for update_display')
+    if transient:
+        kwargs['transient'] = transient
+
+    if not objs and display_id:
+        # if given no objects, but still a request for a display_id,
+        # we assume the user wants to insert an empty output that
+        # can be updated later
+        objs = [{}]
+        raw = True
+
+    if not raw:
+        format = InteractiveShell.instance().display_formatter.format
+
+    if clear:
+        clear_output(wait=True)
+
+    for obj in objs:
+        if raw:
+            publish_display_data(data=obj, metadata=metadata, **kwargs)
+        else:
+            format_dict, md_dict = format(obj, include=include, exclude=exclude)
+            if not format_dict:
+                # nothing to display (e.g. _ipython_display_ took over)
+                continue
+            if metadata:
+                # kwarg-specified metadata gets precedence
+                _merge(md_dict, metadata)
+            publish_display_data(data=format_dict, metadata=md_dict, **kwargs)
+    if display_id:
+        return DisplayHandle(display_id)
+
+
+# use * for keyword-only display_id arg
+def update_display(obj, *, display_id, **kwargs):
+    """Update an existing display by id
+
+    Parameters
+    ----------
+    obj
+        The object with which to update the display
+    display_id : keyword-only
+        The id of the display to update
+
+    See Also
+    --------
+    :func:`display`
+    """
+    kwargs['update'] = True
+    display(obj, display_id=display_id, **kwargs)
+
+
+class DisplayHandle:
+    """A handle on an updatable display
+
+    Call `.update(obj)` to display a new object.
+
+    Call `.display(obj`) to add a new instance of this display,
+    and update existing instances.
+
+    See Also
+    --------
+
+        :func:`display`, :func:`update_display`
+
+    """
+
+    def __init__(self, display_id=None):
+        if display_id is None:
+            display_id = _new_id()
+        self.display_id = display_id
+
+    def __repr__(self):
+        return "<%s display_id=%s>" % (self.__class__.__name__, self.display_id)
+
+    def display(self, obj, **kwargs):
+        """Make a new display with my id, updating existing instances.
+
+        Parameters
+        ----------
+        obj
+            object to display
+        **kwargs
+            additional keyword arguments passed to display
+        """
+        display(obj, display_id=self.display_id, **kwargs)
+
+    def update(self, obj, **kwargs):
+        """Update existing displays with my id
+
+        Parameters
+        ----------
+        obj
+            object to display
+        **kwargs
+            additional keyword arguments passed to update_display
+        """
+        update_display(obj, display_id=self.display_id, **kwargs)
+
+
+def clear_output(wait=False):
+    """Clear the output of the current cell receiving output.
+
+    Parameters
+    ----------
+    wait : bool [default: false]
+        Wait to clear the output until new output is available to replace it."""
+    from IPython.core.interactiveshell import InteractiveShell
+    if InteractiveShell.initialized():
+        InteractiveShell.instance().display_pub.clear_output(wait)
+    else:
+        print('\033[2K\r', end='')
+        sys.stdout.flush()
+        print('\033[2K\r', end='')
+        sys.stderr.flush()
diff --git a/IPython/core/display_trap.py b/IPython/core/display_trap.py
old mode 100755
new mode 100644
index d835b546a5e..a32d8759784
--- a/IPython/core/display_trap.py
+++ b/IPython/core/display_trap.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """
 A context manager for handling sys.displayhook.
@@ -10,7 +9,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -22,8 +21,8 @@
 
 import sys
 
-from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import Any
+from traitlets.config.configurable import Configurable
+from traitlets import Any
 
 #-----------------------------------------------------------------------------
 # Classes and functions
@@ -37,7 +36,7 @@ class DisplayTrap(Configurable):
     (no callbacks or formatters) until more of the core is refactored.
     """
 
-    hook = Any
+    hook = Any()
 
     def __init__(self, hook=None):
         super(DisplayTrap, self).__init__(hook=hook, config=None)
@@ -59,6 +58,10 @@ def __exit__(self, type, value, traceback):
         # Returning False will cause exceptions to propagate
         return False
 
+    @property
+    def is_active(self) -> bool:
+        return self._nested_level != 0
+
     def set(self):
         """Set the hook."""
         if sys.displayhook is not self.hook:
diff --git a/IPython/core/displayhook.py b/IPython/core/displayhook.py
index 4af17f36ae8..f3757237c28 100644
--- a/IPython/core/displayhook.py
+++ b/IPython/core/displayhook.py
@@ -2,66 +2,42 @@
 """Displayhook for IPython.
 
 This defines a callable class that IPython uses for `sys.displayhook`.
-
-Authors:
-
-* Fernando Perez
-* Brian Granger
-* Robert Kern
 """
 
-#-----------------------------------------------------------------------------
-#       Copyright (C) 2008-2010 The IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-import __builtin__
+import builtins as builtin_mod
+import sys
+import io as _io
+import tokenize
 
-from IPython.config.configurable import Configurable
-from IPython.core import prompts
-from IPython.utils import io
-from IPython.utils.traitlets import Instance, List
-from IPython.utils.warn import warn
+from traitlets.config.configurable import Configurable
+from traitlets import Instance, Float
+from warnings import warn
 
-#-----------------------------------------------------------------------------
-# Main displayhook class
-#-----------------------------------------------------------------------------
+from .history import HistoryOutput
 
-# TODO: The DisplayHook class should be split into two classes, one that
-# manages the prompts and their synchronization and another that just does the
-# displayhook logic and calls into the prompt manager.
-
-# TODO: Move the various attributes (cache_size, colors, input_sep,
-# output_sep, output_sep2, ps1, ps2, ps_out, pad_left). Some of these are also
-# attributes of InteractiveShell. They should be on ONE object only and the
-# other objects should ask that one object for their values.
+# TODO: Move the various attributes (cache_size, [others now moved]). Some
+# of these are also attributes of InteractiveShell. They should be on ONE object
+# only and the other objects should ask that one object for their values.
 
 class DisplayHook(Configurable):
     """The custom IPython displayhook to replace sys.displayhook.
 
     This class does many things, but the basic idea is that it is a callable
     that gets called anytime user code returns a value.
-
-    Currently this class does more than just the displayhook logic and that
-    extra logic should eventually be moved out of here.
     """
 
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-
-    def __init__(self, shell=None, cache_size=1000,
-                 colors='NoColor', input_sep='\n',
-                 output_sep='\n', output_sep2='',
-                 ps1 = None, ps2 = None, ps_out = None, pad_left=True,
-                 config=None):
-        super(DisplayHook, self).__init__(shell=shell, config=config)
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
+                     allow_none=True)
+    exec_result = Instance('IPython.core.interactiveshell.ExecutionResult',
+                           allow_none=True)
+    cull_fraction = Float(0.2)
 
+    def __init__(self, shell=None, cache_size=1000, **kwargs):
+        super(DisplayHook, self).__init__(shell=shell, **kwargs)
+        self._is_active = False
         cache_size_min = 3
         if cache_size <= 0:
             self.do_full_cache = 0
@@ -70,41 +46,15 @@ def __init__(self, shell=None, cache_size=1000,
             self.do_full_cache = 0
             cache_size = 0
             warn('caching was disabled (min value for cache size is %s).' %
-                 cache_size_min,level=3)
+                 cache_size_min,stacklevel=3)
         else:
             self.do_full_cache = 1
 
         self.cache_size = cache_size
-        self.input_sep = input_sep
 
         # we need a reference to the user-level namespace
         self.shell = shell
 
-        # Set input prompt strings and colors
-        if cache_size == 0:
-            if ps1.find('%n') > -1 or ps1.find(r'\#') > -1 \
-                   or ps1.find(r'\N') > -1:
-                ps1 = '>>> '
-            if ps2.find('%n') > -1 or ps2.find(r'\#') > -1 \
-                   or ps2.find(r'\N') > -1:
-                ps2 = '... '
-        self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
-        self.ps2_str = self._set_prompt_str(ps2,'   .\\D.: ','... ')
-        self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
-
-        self.color_table = prompts.PromptColors
-        self.prompt1 = prompts.Prompt1(self,sep=input_sep,prompt=self.ps1_str,
-                               pad_left=pad_left)
-        self.prompt2 = prompts.Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
-        self.prompt_out = prompts.PromptOut(self,sep='',prompt=self.ps_out_str,
-                                    pad_left=pad_left)
-        self.set_colors(colors)
-
-        # Store the last prompt string each time, we need it for aligning
-        # continuation and auto-rewrite prompts
-        self.last_prompt = ''
-        self.output_sep = output_sep
-        self.output_sep2 = output_sep2
         self._,self.__,self.___ = '','',''
 
         # these are deliberately global:
@@ -113,33 +63,7 @@ def __init__(self, shell=None, cache_size=1000,
 
     @property
     def prompt_count(self):
-        return self.shell.execution_count
-
-    def _set_prompt_str(self,p_str,cache_def,no_cache_def):
-        if p_str is None:
-            if self.do_full_cache:
-                return cache_def
-            else:
-                return no_cache_def
-        else:
-            return p_str
-                
-    def set_colors(self, colors):
-        """Set the active color scheme and configure colors for the three
-        prompt subsystems."""
-
-        # FIXME: This modifying of the global prompts.prompt_specials needs
-        # to be fixed. We need to refactor all of the prompts stuff to use
-        # proper configuration and traits notifications.
-        if colors.lower()=='nocolor':
-            prompts.prompt_specials = prompts.prompt_specials_nocolor
-        else:
-            prompts.prompt_specials = prompts.prompt_specials_color
-        
-        self.color_table.set_active_scheme(colors)
-        self.prompt1.set_colors()
-        self.prompt2.set_colors()
-        self.prompt_out.set_colors()
+        return self.shell.execution_count - 1
 
     #-------------------------------------------------------------------------
     # Methods used in __call__. Override these methods to modify the behavior
@@ -151,8 +75,11 @@ def check_for_underscore(self):
         # If something injected a '_' variable in __builtin__, delete
         # ipython's automatic one so we don't clobber that.  gettext() in
         # particular uses _, so we need to stay away from it.
-        if '_' in __builtin__.__dict__:
+        if '_' in builtin_mod.__dict__:
             try:
+                user_value = self.shell.user_ns['_']
+                if user_value is not self._:
+                    return
                 del self.shell.user_ns['_']
             except KeyError:
                 pass
@@ -160,30 +87,49 @@ def check_for_underscore(self):
     def quiet(self):
         """Should we silence the display hook because of ';'?"""
         # do not print output if input ends in ';'
+
         try:
-            cell = self.shell.history_manager.input_hist_parsed[self.prompt_count]
-            if cell.rstrip().endswith(';'):
-                return True
+            cell = self.shell.history_manager.input_hist_parsed[-1]
         except IndexError:
             # some uses of ipshellembed may fail here
-            pass
-        return False
+            return False
+
+        return self.semicolon_at_end_of_expression(cell)
+
+    @staticmethod
+    def semicolon_at_end_of_expression(expression):
+        """Parse Python expression and detects whether last token is ';'"""
+
+        sio = _io.StringIO(expression)
+        tokens = list(tokenize.generate_tokens(sio.readline))
+
+        for token in reversed(tokens):
+            if token[0] in (tokenize.ENDMARKER, tokenize.NL, tokenize.NEWLINE, tokenize.COMMENT):
+                continue
+            if (token[0] == tokenize.OP) and (token[1] == ';'):
+                return True
+            else:
+                return False
 
     def start_displayhook(self):
         """Start the displayhook, initializing resources."""
-        pass
+        self._is_active = True
+
+    @property
+    def is_active(self):
+        return self._is_active
 
     def write_output_prompt(self):
         """Write the output prompt.
 
         The default implementation simply writes the prompt to
-        ``io.stdout``.
+        ``sys.stdout``.
         """
         # Use write, not print which adds an extra space.
-        io.stdout.write(self.output_sep)
-        outprompt = str(self.prompt_out)
+        sys.stdout.write(self.shell.separate_out)
+        outprompt = 'Out[{}]: '.format(self.shell.execution_count - 1)
         if self.do_full_cache:
-            io.stdout.write(outprompt)
+            sys.stdout.write(outprompt)
 
     def compute_format_data(self, result):
         """Compute format data of the object to be displayed.
@@ -206,19 +152,25 @@ def compute_format_data(self, result):
 
         Returns
         -------
-        format_data : dict
-            A :class:`dict` whose keys are valid MIME types and values are
+        (format_dict, md_dict) : dict
+            format_dict is a :class:`dict` whose keys are valid MIME types and values are
             JSON'able raw data for that MIME type. It is recommended that
             all return values of this should always include the "text/plain"
             MIME type representation of the object.
+            md_dict is a :class:`dict` with the same MIME type keys
+            of metadata associated with each output.
+
         """
         return self.shell.display_formatter.format(result)
 
-    def write_format_data(self, format_dict):
+    # This can be set to True by the write_output_prompt method in a subclass
+    prompt_end_newline = False
+
+    def write_format_data(self, format_dict, md_dict=None) -> None:
         """Write the format data dict to the frontend.
 
         This default version of this method simply writes the plain text
-        representation of the object to ``io.stdout``. Subclasses should
+        representation of the object to ``sys.stdout``. Subclasses should
         override this method to send the entire `format_dict` to the
         frontends.
 
@@ -226,8 +178,13 @@ def write_format_data(self, format_dict):
         ----------
         format_dict : dict
             The format dict for the object passed to `sys.displayhook`.
+        md_dict : dict (optional)
+            The metadata dict to be associated with the display data.
         """
-        # We want to print because we want to always make sure we have a 
+        if 'text/plain' not in format_dict:
+            # nothing to do
+            return
+        # We want to print because we want to always make sure we have a
         # newline, even if all the prompt separators are ''. This is the
         # standard IPython behavior.
         result_repr = format_dict['text/plain']
@@ -235,50 +192,69 @@ def write_format_data(self, format_dict):
             # So that multi-line strings line up with the left column of
             # the screen, instead of having the output prompt mess up
             # their first line.
-            # We use the ps_out_str template instead of the expanded prompt
+            # We use the prompt template instead of the expanded prompt
             # because the expansion may add ANSI escapes that will interfere
             # with our ability to determine whether or not we should add
             # a newline.
-            if self.ps_out_str and not self.ps_out_str.endswith('\n'):
+            if not self.prompt_end_newline:
                 # But avoid extraneous empty lines.
                 result_repr = '\n' + result_repr
 
-        print >>io.stdout, result_repr
+        try:
+            print(result_repr)
+        except UnicodeEncodeError:
+            # If a character is not supported by the terminal encoding replace
+            # it with its \u or \x representation
+            print(result_repr.encode(sys.stdout.encoding,'backslashreplace').decode(sys.stdout.encoding))
 
     def update_user_ns(self, result):
         """Update user_ns with various things like _, __, _1, etc."""
 
         # Avoid recursive reference when displaying _oh/Out
-        if result is not self.shell.user_ns['_oh']:
+        if self.cache_size and result is not self.shell.user_ns['_oh']:
             if len(self.shell.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
-                warn('Output cache limit (currently '+
-                      `self.cache_size`+' entries) hit.\n'
-                     'Flushing cache and resetting history counter...\n'
-                     'The only history variables available will be _,__,___ and _1\n'
-                     'with the current result.')
-
-                self.flush()
-            # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
-            # we cause buggy behavior for things like gettext).
-
-            if '_' not in __builtin__.__dict__:
-                self.___ = self.__
-                self.__ = self._
-                self._ = result
-                self.shell.user_ns.update({'_':self._,
-                                           '__':self.__,
-                                           '___':self.___})
+                self.cull_cache()
+
+            # Don't overwrite '_' and friends if '_' is in __builtin__
+            # (otherwise we cause buggy behavior for things like gettext). and
+            # do not overwrite _, __ or ___ if one of these has been assigned
+            # by the user.
+            update_unders = True
+            for unders in ['_'*i for i in range(1,4)]:
+                if unders not in self.shell.user_ns:
+                    continue
+                if getattr(self, unders) is not self.shell.user_ns.get(unders):
+                    update_unders = False
+
+            self.___ = self.__
+            self.__ = self._
+            self._ = result
+
+            if ('_' not in builtin_mod.__dict__) and (update_unders):
+                self.shell.push({'_':self._,
+                                 '__':self.__,
+                                '___':self.___}, interactive=False)
 
             # hackish access to top-level  namespace to create _1,_2... dynamically
             to_main = {}
             if self.do_full_cache:
-                new_result = '_'+`self.prompt_count`
+                new_result = '_%s' % self.prompt_count
                 to_main[new_result] = result
-                self.shell.user_ns.update(to_main)
+                self.shell.push(to_main, interactive=False)
                 self.shell.user_ns['_oh'][self.prompt_count] = result
 
+    def fill_exec_result(self, result):
+        if self.exec_result is not None:
+            self.exec_result.result = result
+
     def log_output(self, format_dict):
         """Log the output."""
+        self.shell.history_manager.outputs[self.prompt_count].append(
+            HistoryOutput(output_type="execute_result", bundle=format_dict)
+        )
+        if "text/plain" not in format_dict:
+            # nothing to do
+            return
         if self.shell.logger.log_output:
             self.shell.logger.log_write(format_dict['text/plain'], 'output')
         self.shell.history_manager.output_hist_reprs[self.prompt_count] = \
@@ -286,44 +262,85 @@ def log_output(self, format_dict):
 
     def finish_displayhook(self):
         """Finish up all displayhook activities."""
-        io.stdout.write(self.output_sep2)
-        io.stdout.flush()
+        sys.stdout.write(self.shell.separate_out2)
+        sys.stdout.flush()
+        self._is_active = False
 
     def __call__(self, result=None):
         """Printing with history cache management.
-        
-        This is invoked everytime the interpreter needs to print, and is
+
+        This is invoked every time the interpreter needs to print, and is
         activated by setting the variable sys.displayhook to it.
         """
         self.check_for_underscore()
         if result is not None and not self.quiet():
             self.start_displayhook()
             self.write_output_prompt()
-            format_dict = self.compute_format_data(result)
-            self.write_format_data(format_dict)
+            format_dict, md_dict = self.compute_format_data(result)
             self.update_user_ns(result)
-            self.log_output(format_dict)
+            self.fill_exec_result(result)
+            if format_dict:
+                self.write_format_data(format_dict, md_dict)
+                self.log_output(format_dict)
             self.finish_displayhook()
 
+    def cull_cache(self):
+        """Output cache is full, cull the oldest entries"""
+        oh = self.shell.user_ns.get('_oh', {})
+        sz = len(oh)
+        cull_count = max(int(sz * self.cull_fraction), 2)
+        warn('Output cache limit (currently {sz} entries) hit.\n'
+             'Flushing oldest {cull_count} entries.'.format(sz=sz, cull_count=cull_count))
+
+        for i, n in enumerate(sorted(oh)):
+            if i >= cull_count:
+                break
+            self.shell.user_ns.pop('_%i' % n, None)
+            oh.pop(n, None)
+
     def flush(self):
         if not self.do_full_cache:
-            raise ValueError,"You shouldn't have reached the cache flush "\
-                  "if full caching is not enabled!"
+            raise ValueError("You shouldn't have reached the cache flush "
+                             "if full caching is not enabled!")
         # delete auto-generated vars from global namespace
-        
+
         for n in range(1,self.prompt_count + 1):
-            key = '_'+`n`
+            key = '_'+repr(n)
+            try:
+                del self.shell.user_ns_hidden[key]
+            except KeyError:
+                pass
             try:
                 del self.shell.user_ns[key]
-            except: pass
-        self.shell.user_ns['_oh'].clear()
-        
+            except KeyError:
+                pass
+        # In some embedded circumstances, the user_ns doesn't have the
+        # '_oh' key set up.
+        oh = self.shell.user_ns.get('_oh', None)
+        if oh is not None:
+            oh.clear()
+
         # Release our own references to objects:
         self._, self.__, self.___ = '', '', ''
-        
-        if '_' not in __builtin__.__dict__:
-            self.shell.user_ns.update({'_':None,'__':None, '___':None})
+
+        if '_' not in builtin_mod.__dict__:
+            self.shell.user_ns.update({'_':self._,'__':self.__,'___':self.___})
         import gc
         # TODO: Is this really needed?
-        gc.collect()
+        # IronPython blocks here forever
+        if sys.platform != "cli":
+            gc.collect()
+
 
+class CapturingDisplayHook:
+    def __init__(self, shell, outputs=None):
+        self.shell = shell
+        if outputs is None:
+            outputs = []
+        self.outputs = outputs
+
+    def __call__(self, result=None):
+        if result is None:
+            return
+        format_dict, md_dict = self.shell.display_formatter.format(result)
+        self.outputs.append({ 'data': format_dict, 'metadata': md_dict })
diff --git a/IPython/core/displaypub.py b/IPython/core/displaypub.py
index 704a99820b3..45afab854ba 100644
--- a/IPython/core/displaypub.py
+++ b/IPython/core/displaypub.py
@@ -3,37 +3,35 @@
 There are two components of the display system:
 
 * Display formatters, which take a Python object and compute the
-  representation of the object in various formats (text, HTML, SVg, etc.).
+  representation of the object in various formats (text, HTML, SVG, etc.).
 * The display publisher that is used to send the representation data to the
   various frontends.
 
 This module defines the logic display publishing. The display publisher uses
 the ``display_data`` message type that is defined in the IPython messaging
 spec.
-
-Authors:
-
-* Brian Granger
 """
 
-#-----------------------------------------------------------------------------
-#       Copyright (C) 2008-2010 The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import sys
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+from traitlets.config.configurable import Configurable
+from traitlets import List
 
-from __future__ import print_function
+# This used to be defined here - it is imported for backwards compatibility
+from .display_functions import publish_display_data
+from .history import HistoryOutput
 
-from IPython.config.configurable import Configurable
+import typing as t
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Main payload class
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
+_sentinel = object()
+
 
 class DisplayPublisher(Configurable):
     """A traited class that publishes display data to frontends.
@@ -42,29 +40,55 @@ class DisplayPublisher(Configurable):
     be accessed there.
     """
 
-    def _validate_data(self, source, data, metadata=None):
+    def __init__(self, shell=None, *args, **kwargs):
+        self.shell = shell
+        self._is_publishing = False
+        self._in_post_execute = False
+        if self.shell:
+            self._setup_execution_tracking()
+        super().__init__(*args, **kwargs)
+
+    def _validate_data(self, data, metadata=None):
         """Validate the display data.
 
         Parameters
         ----------
-        source : str
-            The fully dotted name of the callable that created the data, like
-            :func:`foo.bar.my_formatter`.
         data : dict
             The formata data dictionary.
         metadata : dict
             Any metadata for the data.
         """
 
-        if not isinstance(source, str):
-            raise TypeError('source must be a str, got: %r' % source)
         if not isinstance(data, dict):
-            raise TypeError('data must be a dict, got: %r' % data)
+            raise TypeError("data must be a dict, got: %r" % data)
         if metadata is not None:
             if not isinstance(metadata, dict):
-                raise TypeError('metadata must be a dict, got: %r' % data)
+                raise TypeError("metadata must be a dict, got: %r" % data)
 
-    def publish(self, source, data, metadata=None):
+    def _setup_execution_tracking(self):
+        """Set up hooks to track execution state"""
+        self.shell.events.register("post_execute", self._on_post_execute)
+        self.shell.events.register("pre_execute", self._on_pre_execute)
+
+    def _on_post_execute(self):
+        """Called at start of post_execute phase"""
+        self._in_post_execute = True
+
+    def _on_pre_execute(self):
+        """Called at start of pre_execute phase"""
+        self._in_post_execute = False
+
+    # use * to indicate transient, update are keyword-only
+    def publish(
+        self,
+        data,
+        metadata=None,
+        source=_sentinel,
+        *,
+        transient=None,
+        update=False,
+        **kwargs,
+    ) -> None:
         """Publish data and metadata to all frontends.
 
         See the ``display_data`` message in the messaging documentation for
@@ -74,18 +98,18 @@ def publish(self, source, data, metadata=None):
 
         * text/plain
         * text/html
+        * text/markdown
         * text/latex
         * application/json
+        * application/javascript
         * image/png
-        * immage/svg+xml
+        * image/jpeg
+        * image/svg+xml
 
         Parameters
         ----------
-        source : str
-            A string that give the function or method that created the data,
-            such as 'IPython.core.page'.
         data : dict
-            A dictionary having keys that are valid MIME types (like 
+            A dictionary having keys that are valid MIME types (like
             'text/plain' or 'image/svg+xml') and values that are the data for
             that MIME type. The data itself must be a JSON'able data
             structure. Minimally all data should have the 'text/plain' data,
@@ -95,51 +119,87 @@ def publish(self, source, data, metadata=None):
         metadata : dict
             A dictionary for metadata related to the data. This can contain
             arbitrary key, value pairs that frontends can use to interpret
-            the data.
+            the data.  Metadata specific to each mime-type can be specified
+            in the metadata dict with the same mime-type keys as
+            the data itself.
+        source : str, deprecated
+            Unused.
+        transient : dict, keyword-only
+            A dictionary for transient data.
+            Data in this dictionary should not be persisted as part of saving this output.
+            Examples include 'display_id'.
+        update : bool, keyword-only, default: False
+            If True, only update existing outputs with the same display_id,
+            rather than creating a new output.
         """
-        from IPython.utils import io
-        # The default is to simply write the plain text data using io.stdout.
-        if data.has_key('text/plain'):
-            print(data['text/plain'], file=io.stdout)
-
-
-def publish_display_data(self, source, data, metadata=None):
-    """Publish data and metadata to all frontends.
-
-    See the ``display_data`` message in the messaging documentation for
-    more details about this message type.
-
-    The following MIME types are currently implemented:
-
-    * text/plain
-    * text/html
-    * text/latex
-    * application/json
-    * image/png
-    * immage/svg+xml
-
-    Parameters
-    ----------
-    source : str
-        A string that give the function or method that created the data,
-        such as 'IPython.core.page'.
-    data : dict
-        A dictionary having keys that are valid MIME types (like 
-        'text/plain' or 'image/svg+xml') and values that are the data for
-        that MIME type. The data itself must be a JSON'able data
-        structure. Minimally all data should have the 'text/plain' data,
-        which can be displayed by all frontends. If more than the plain
-        text is given, it is up to the frontend to decide which
-        representation to use.
-    metadata : dict
-        A dictionary for metadata related to the data. This can contain
-        arbitrary key, value pairs that frontends can use to interpret
-        the data.
-    """
-    from IPython.core.interactiveshell import InteractiveShell
-    InteractiveShell.instance().display_pub.publish(
-        source,
-        data,
-        metadata
-    )
 
+        if source is not _sentinel:
+            import warnings
+
+            warnings.warn(
+                "The 'source' parameter is deprecated since IPython 3.0 and will be ignored "
+                "(this warning is present since 9.0). `source` parameter will be removed in the future.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        handlers: t.Dict = {}
+        if self.shell is not None:
+            handlers = getattr(self.shell, "mime_renderers", {})
+
+        outputs = self.shell.history_manager.outputs
+
+        target_execution_count = self.shell.execution_count - 1
+        if self._in_post_execute:
+            # We're in post_execute, so this is likely a matplotlib flush
+            # Use execution_count - 1 to associate with the cell that created the plot
+            target_execution_count = self.shell.execution_count - 1
+
+        outputs[target_execution_count].append(
+            HistoryOutput(output_type="display_data", bundle=data)
+        )
+
+        for mime, handler in handlers.items():
+            if mime in data:
+                handler(data[mime], metadata.get(mime, None))
+                return
+
+        self._is_publishing = True
+        if "text/plain" in data:
+            print(data["text/plain"])
+        self._is_publishing = False
+
+    @property
+    def is_publishing(self):
+        return self._is_publishing
+
+    def clear_output(self, wait=False):
+        """Clear the output of the cell receiving output."""
+        print("\033[2K\r", end="")
+        sys.stdout.flush()
+        print("\033[2K\r", end="")
+        sys.stderr.flush()
+
+
+class CapturingDisplayPublisher(DisplayPublisher):
+    """A DisplayPublisher that stores"""
+
+    outputs: List = List()
+
+    def publish(
+        self, data, metadata=None, source=None, *, transient=None, update=False
+    ):
+        self.outputs.append(
+            {
+                "data": data,
+                "metadata": metadata,
+                "transient": transient,
+                "update": update,
+            }
+        )
+
+    def clear_output(self, wait=False):
+        super(CapturingDisplayPublisher, self).clear_output(wait)
+
+        # empty the list, *do not* reassign a new list
+        self.outputs.clear()
diff --git a/IPython/core/doctb.py b/IPython/core/doctb.py
new file mode 100644
index 00000000000..a4839a7a5f2
--- /dev/null
+++ b/IPython/core/doctb.py
@@ -0,0 +1,445 @@
+import inspect
+import linecache
+import sys
+from collections.abc import Sequence
+from types import TracebackType
+from typing import Any, Optional
+from collections.abc import Callable
+
+import stack_data
+from pygments.formatters.terminal256 import Terminal256Formatter
+from pygments.token import Token
+
+from IPython.utils.PyColorize import Theme, TokenStream, theme_table
+from IPython.utils.terminal import get_terminal_size
+
+from .tbtools import (
+    FrameInfo,
+    TBTools,
+    _safe_string,
+    _tokens_filename,
+    eqrepr,
+    get_line_number_of_frame,
+    nullrepr,
+)
+
+INDENT_SIZE = 8
+
+
+def _format_traceback_lines(
+    lines: list[stack_data.Line],
+    theme: Theme,
+    has_colors: bool,
+    lvals_toks: list[TokenStream],
+) -> TokenStream:
+    """
+    Format tracebacks lines with pointing arrow, leading numbers,
+    this assumes the stack have been extracted using stackdata.
+
+
+    Parameters
+    ----------
+    lines : list[Line]
+    """
+    numbers_width = INDENT_SIZE - 1
+    tokens: TokenStream = [(Token, "\n")]
+
+    for stack_line in lines:
+        if stack_line is stack_data.LINE_GAP:
+            toks = [(Token.LinenoEm, "   (...)")]
+            tokens.extend(toks)
+            continue
+
+        lineno = stack_line.lineno
+        line = stack_line.render(pygmented=has_colors).rstrip("\n") + "\n"
+        if stack_line.is_current:
+            # This is the line with the error
+            pad = numbers_width - len(str(lineno))
+            toks = [
+                (Token.Prompt, theme.make_arrow(3)),
+                (Token, " "),
+                (Token, line),
+            ]
+        else:
+            # num = "%*s" % (numbers_width, lineno)
+            toks = [
+                # (Token.LinenoEm, str(num)),
+                (Token, "..."),
+                (Token, " "),
+                (Token, line),
+            ]
+
+        tokens.extend(toks)
+        if lvals_toks and stack_line.is_current:
+            for lv in lvals_toks:
+                tokens.append((Token, " " * INDENT_SIZE))
+                tokens.extend(lv)
+                tokens.append((Token, "\n"))
+            # strip the last newline
+            tokens = tokens[:-1]
+
+    return tokens
+
+
+class DocTB(TBTools):
+    """
+
+    A stripped down version of Verbose TB, simplified to not have too much information when
+    running doctests
+
+    """
+
+    tb_highlight = ""
+    tb_highlight_style = "default"
+    tb_offset: int
+    long_header: bool
+    include_vars: bool
+
+    _mode: str
+
+    def __init__(
+        self,
+        # TODO: no default ?
+        theme_name: str = "linux",
+        call_pdb: bool = False,
+        ostream: Any = None,
+        tb_offset: int = 0,
+        long_header: bool = False,
+        include_vars: bool = True,
+        check_cache: Callable[[], None] | None = None,
+        debugger_cls: type | None = None,
+    ):
+        """Specify traceback offset, headers and color scheme.
+
+        Define how many frames to drop from the tracebacks. Calling it with
+        tb_offset=1 allows use of this handler in interpreters which will have
+        their own code at the top of the traceback (VerboseTB will first
+        remove that frame before printing the traceback info)."""
+        assert isinstance(theme_name, str)
+        super().__init__(
+            theme_name=theme_name,
+            call_pdb=call_pdb,
+            ostream=ostream,
+            debugger_cls=debugger_cls,
+        )
+        self.tb_offset = tb_offset
+        self.long_header = long_header
+        self.include_vars = include_vars
+        # By default we use linecache.checkcache, but the user can provide a
+        # different check_cache implementation.  This was formerly used by the
+        # IPython kernel for interactive code, but is no longer necessary.
+        if check_cache is None:
+            check_cache = linecache.checkcache
+        self.check_cache = check_cache
+
+        self.skip_hidden = True
+
+    def format_record(self, frame_info: FrameInfo) -> str:
+        """Format a single stack frame"""
+        assert isinstance(frame_info, FrameInfo)
+
+        if isinstance(frame_info._sd, stack_data.RepeatedFrames):
+            return theme_table[self._theme_name].format(
+                [
+                    (Token, "    "),
+                    (
+                        Token.ExcName,
+                        "[... skipping similar frames: %s]" % frame_info.description,
+                    ),
+                    (Token, "\n"),
+                ]
+            )
+
+        indent: str = " " * INDENT_SIZE
+
+        assert isinstance(frame_info.lineno, int)
+        args, varargs, varkw, locals_ = inspect.getargvalues(frame_info.frame)
+        if frame_info.executing is not None:
+            func = frame_info.executing.code_qualname()
+        else:
+            func = "?"
+        if func == "<module>":
+            call = ""
+        else:
+            # Decide whether to include variable details or not
+            var_repr = eqrepr if self.include_vars else nullrepr
+            try:
+                scope = inspect.formatargvalues(
+                    args, varargs, varkw, locals_, formatvalue=var_repr
+                )
+                assert isinstance(scope, str)
+                call = theme_table[self._theme_name].format(
+                    [(Token, "in "), (Token.VName, func), (Token.ValEm, scope)]
+                )
+            except KeyError:
+                # This happens in situations like errors inside generator
+                # expressions, where local variables are listed in the
+                # line, but can't be extracted from the frame.  I'm not
+                # 100% sure this isn't actually a bug in inspect itself,
+                # but since there's no info for us to compute with, the
+                # best we can do is report the failure and move on.  Here
+                # we must *not* call any traceback construction again,
+                # because that would mess up use of %debug later on.  So we
+                # simply report the failure and move on.  The only
+                # limitation will be that this frame won't have locals
+                # listed in the call signature.  Quite subtle problem...
+                # I can't think of a good way to validate this in a unit
+                # test, but running a script consisting of:
+                #  dict( (k,v.strip()) for (k,v) in range(10) )
+                # will illustrate the error, if this exception catch is
+                # disabled.
+                call = theme_table[self._theme_name].format(
+                    [
+                        (Token, "in "),
+                        (Token.VName, func),
+                        (Token.ValEm, "(***failed resolving arguments***)"),
+                    ]
+                )
+
+        lvals_toks: list[TokenStream] = []
+        if self.include_vars:
+            try:
+                # we likely want to fix stackdata at some point, but
+                # still need a workaround.
+                fibp = frame_info.variables_in_executing_piece
+                for var in fibp:
+                    lvals_toks.append(
+                        [
+                            (Token, var.name),
+                            (Token, " "),
+                            (Token.ValEm, "= "),
+                            (Token.ValEm, repr(var.value)),
+                        ]
+                    )
+            except Exception:
+                lvals_toks.append(
+                    [
+                        (
+                            Token,
+                            "Exception trying to inspect frame. No more locals available.",
+                        ),
+                    ]
+                )
+
+        assert frame_info._sd is not None
+        result = theme_table[self._theme_name].format(
+            _tokens_filename(True, frame_info.filename, lineno=frame_info.lineno)
+        )
+        result += ", " if call else ""
+        result += f"{call}\n"
+        result += theme_table[self._theme_name].format(
+            _format_traceback_lines(
+                frame_info.lines,
+                theme_table[self._theme_name],
+                self.has_colors,
+                lvals_toks,
+            )
+        )
+        return result
+
+    def prepare_header(self, etype: str) -> str:
+        width = min(75, get_terminal_size()[0])
+        head = theme_table[self._theme_name].format(
+            [
+                (
+                    Token,
+                    "Traceback (most recent call last):",
+                ),
+                (Token, " "),
+            ]
+        )
+
+        return head
+
+    def format_exception(self, etype: Any, evalue: Any) -> Any:
+        # Get (safely) a string form of the exception info
+        try:
+            etype_str, evalue_str = map(str, (etype, evalue))
+        except:
+            # User exception is improperly defined.
+            etype, evalue = str, sys.exc_info()[:2]
+            etype_str, evalue_str = map(str, (etype, evalue))
+
+        # PEP-678 notes
+        notes = getattr(evalue, "__notes__", [])
+        if not isinstance(notes, Sequence) or isinstance(notes, (str, bytes)):
+            notes = [_safe_string(notes, "__notes__", func=repr)]
+
+        # ... and format it
+        return [
+            theme_table[self._theme_name].format(
+                [(Token.ExcName, etype_str), (Token, ": "), (Token, evalue_str)]
+            ),
+            *(
+                theme_table[self._theme_name].format([(Token, _safe_string(n, "note"))])
+                for n in notes
+            ),
+        ]
+
+    def format_exception_as_a_whole(
+        self,
+        etype: type,
+        evalue: Optional[BaseException],
+        etb: Optional[TracebackType],
+        context: int,
+        tb_offset: Optional[int],
+    ) -> list[list[str]]:
+        """Formats the header, traceback and exception message for a single exception.
+
+        This may be called multiple times by Python 3 exception chaining
+        (PEP 3134).
+        """
+        # some locals
+        orig_etype = etype
+        try:
+            etype = etype.__name__  # type: ignore[assignment]
+        except AttributeError:
+            pass
+
+        tb_offset = self.tb_offset if tb_offset is None else tb_offset
+        assert isinstance(tb_offset, int)
+        head = self.prepare_header(str(etype))
+        assert context == 1, context
+        records = self.get_records(etb, context, tb_offset) if etb else []
+
+        frames = []
+        skipped = 0
+        nskipped = len(records) - 1
+        frames.append(self.format_record(records[0]))
+        if nskipped:
+            frames.append(
+                theme_table[self._theme_name].format(
+                    [
+                        (Token, "\n"),
+                        (Token, "    "),
+                        (Token, "[... %s skipped frames]" % nskipped),
+                        (Token, "\n"),
+                        (Token, "\n"),
+                    ]
+                )
+            )
+
+        formatted_exception = self.format_exception(etype, evalue)
+        return [[head] + frames + formatted_exception]
+
+    def get_records(self, etb: TracebackType, context: int, tb_offset: int) -> Any:
+        assert context == 1, context
+        assert etb is not None
+        context = context - 1
+        after = context // 2
+        before = context - after
+        if self.has_colors:
+            base_style = theme_table[self._theme_name].as_pygments_style()
+            style = stack_data.style_with_executing_node(base_style, self.tb_highlight)
+            formatter = Terminal256Formatter(style=style)
+        else:
+            formatter = None
+        options = stack_data.Options(
+            before=before,
+            after=after,
+            pygments_formatter=formatter,
+        )
+
+        # Let's estimate the amount of code we will have to parse/highlight.
+        cf: Optional[TracebackType] = etb
+        max_len = 0
+        tbs = []
+        while cf is not None:
+            try:
+                mod = inspect.getmodule(cf.tb_frame)
+                if mod is not None:
+                    mod_name = mod.__name__
+                    root_name, *_ = mod_name.split(".")
+                    if root_name == "IPython":
+                        cf = cf.tb_next
+                        continue
+                max_len = get_line_number_of_frame(cf.tb_frame)
+
+            except OSError:
+                max_len = 0
+            max_len = max(max_len, max_len)
+            tbs.append(cf)
+            cf = getattr(cf, "tb_next", None)
+
+        res = list(stack_data.FrameInfo.stack_data(etb, options=options))[tb_offset:]
+        res2 = [FrameInfo._from_stack_data_FrameInfo(r) for r in res]
+        return res2
+
+    def structured_traceback(
+        self,
+        etype: type,
+        evalue: Optional[BaseException],
+        etb: Optional[TracebackType] = None,
+        tb_offset: Optional[int] = None,
+        context: int = 1,
+    ) -> list[str]:
+        """Return a nice text document describing the traceback."""
+        assert context > 0
+        assert context == 1, context
+        formatted_exceptions: list[list[str]] = self.format_exception_as_a_whole(
+            etype, evalue, etb, context, tb_offset
+        )
+
+        termsize = min(75, get_terminal_size()[0])
+        theme = theme_table[self._theme_name]
+        structured_traceback_parts: list[str] = []
+        chained_exceptions_tb_offset = 0
+        lines_of_context = 3
+        exception = self.get_parts_of_chained_exception(evalue)
+        if exception:
+            assert evalue is not None
+            formatted_exceptions += self.prepare_chained_exception_message(
+                evalue.__cause__
+            )
+            etype, evalue, etb = exception
+        else:
+            evalue = None
+        chained_exc_ids = set()
+        while evalue:
+            formatted_exceptions += self.format_exception_as_a_whole(
+                etype, evalue, etb, lines_of_context, chained_exceptions_tb_offset
+            )
+            exception = self.get_parts_of_chained_exception(evalue)
+
+            if exception and id(exception[1]) not in chained_exc_ids:
+                chained_exc_ids.add(
+                    id(exception[1])
+                )  # trace exception to avoid infinite 'cause' loop
+                formatted_exceptions += self.prepare_chained_exception_message(
+                    evalue.__cause__
+                )
+                etype, evalue, etb = exception
+            else:
+                evalue = None
+
+        # we want to see exceptions in a reversed order:
+        # the first exception should be on top
+        for fx in reversed(formatted_exceptions):
+            structured_traceback_parts += fx
+
+        return structured_traceback_parts
+
+    def debugger(self, force: bool = False) -> None:
+        raise RuntimeError("canot rundebugger in Docs mode")
+
+    def handler(self, info: tuple[Any, Any, Any] | None = None) -> None:
+        (etype, evalue, etb) = info or sys.exc_info()
+        self.tb = etb
+        ostream = self.ostream
+        ostream.flush()
+        ostream.write(self.text(etype, evalue, etb))  # type:ignore[arg-type]
+        ostream.write("\n")
+        ostream.flush()
+
+    # Changed so an instance can just be called as VerboseTB_inst() and print
+    # out the right info on its own.
+    def __call__(self, etype: Any = None, evalue: Any = None, etb: Any = None) -> None:
+        """This hook can replace sys.excepthook (for Python 2.1 or higher)."""
+        if etb is None:
+            self.handler()
+        else:
+            self.handler((etype, evalue, etb))
+        try:
+            self.debugger()
+        except KeyboardInterrupt:
+            print("\nKeyboardInterrupt")
diff --git a/IPython/core/error.py b/IPython/core/error.py
index 8d20ea85f8d..684cbc8da6a 100644
--- a/IPython/core/error.py
+++ b/IPython/core/error.py
@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """
 Global exception classes for IPython.core.
@@ -7,13 +6,14 @@
 
 * Brian Granger
 * Fernando Perez
+* Min Ragan-Kelley
 
 Notes
 -----
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -33,20 +33,28 @@ class IPythonCoreError(Exception):
 
 class TryNext(IPythonCoreError):
     """Try next hook exception.
-     
+
     Raise this in your hook function to indicate that the next hook handler
-    should be used to handle the operation.  If you pass arguments to the
-    constructor those arguments will be used by the next hook instead of the
-    original ones.
+    should be used to handle the operation.
     """
 
-    def __init__(self, *args, **kwargs):
-        self.args = args
-        self.kwargs = kwargs
-
 class UsageError(IPythonCoreError):
     """Error in magic function arguments, etc.
-    
+
     Something that probably won't warrant a full traceback, but should
-    nevertheless interrupt a macro / batch file.   
-    """
\ No newline at end of file
+    nevertheless interrupt a macro / batch file.
+    """
+
+class StdinNotImplementedError(IPythonCoreError, NotImplementedError):
+    """raw_input was requested in a context where it is not supported
+
+    For use in IPython kernels, where only some frontends may support
+    stdin requests.
+    """
+
+class InputRejected(Exception):
+    """Input rejected by ast transformer.
+
+    Raise this in your NodeTransformer to indicate that InteractiveShell should
+    not execute the supplied input.
+    """
diff --git a/IPython/core/events.py b/IPython/core/events.py
new file mode 100644
index 00000000000..b0590db7eda
--- /dev/null
+++ b/IPython/core/events.py
@@ -0,0 +1,179 @@
+"""Infrastructure for registering and firing callbacks on application events.
+
+Unlike :mod:`IPython.core.hooks`, which lets end users set single functions to
+be called at specific times, or a collection of alternative methods to try,
+callbacks are designed to be used by extension authors. A number of callbacks
+can be registered for the same event without needing to be aware of one another.
+
+The functions defined in this module are no-ops indicating the names of available
+events and the arguments which will be passed to them.
+
+.. note::
+
+   This API is experimental in IPython 2.0, and may be revised in future versions.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Iterable, TypeVar
+
+if TYPE_CHECKING:
+    from IPython.core.interactiveshell import (
+        ExecutionInfo,
+        ExecutionResult,
+        InteractiveShell,
+    )
+
+
+class EventManager:
+    """Manage a collection of events and a sequence of callbacks for each.
+    
+    This is attached to :class:`~IPython.core.interactiveshell.InteractiveShell`
+    instances as an ``events`` attribute.
+    
+    .. note::
+
+       This API is experimental in IPython 2.0, and may be revised in future versions.
+    """
+
+    def __init__(
+        self,
+        shell: InteractiveShell,
+        available_events: Iterable[str],
+        print_on_error: bool = True,
+    ) -> None:
+        """Initialise the :class:`CallbackManager`.
+
+        Parameters
+        ----------
+        shell
+            The :class:`~IPython.core.interactiveshell.InteractiveShell` instance
+        available_events
+            An iterable of names for callback events.
+        print_on_error:
+            A boolean flag to set whether the EventManager will print a warning which a event errors.
+        """
+        self.shell = shell
+        self.callbacks: dict[str, list[Callable[..., Any]]] = {
+            n: [] for n in available_events
+        }
+        self.print_on_error = print_on_error
+    
+    def register(self, event: str, function: Callable[..., Any]) -> None:
+        """Register a new event callback.
+
+        Parameters
+        ----------
+        event : str
+            The event for which to register this callback.
+        function : callable
+            A function to be called on the given event. It should take the same
+            parameters as the appropriate callback prototype.
+
+        Raises
+        ------
+        TypeError
+            If ``function`` is not callable.
+        KeyError
+            If ``event`` is not one of the known events.
+        """
+        if not callable(function):
+            raise TypeError('Need a callable, got %r' % function)
+        if function not in self.callbacks[event]:
+            self.callbacks[event].append(function)
+    
+    def unregister(self, event: str, function: Callable[..., Any]) -> None:
+        """Remove a callback from the given event."""
+        if function in self.callbacks[event]:
+            return self.callbacks[event].remove(function)
+
+        raise ValueError('Function {!r} is not registered as a {} callback'.format(function, event))
+
+    def trigger(self, event: str, *args: Any, **kwargs: Any) -> None:
+        """Call callbacks for ``event``.
+
+        Any additional arguments are passed to all callbacks registered for this
+        event. Exceptions raised by callbacks are caught, and a message printed.
+        """
+        for func in self.callbacks[event][:]:
+            try:
+                func(*args, **kwargs)
+            except (Exception, KeyboardInterrupt):
+                if self.print_on_error:
+                    print(
+                        "Error in callback {} (for {}), with arguments args {},kwargs {}:".format(
+                            func, event, args, kwargs
+                        )
+                    )
+                self.shell.showtraceback()
+
+# event_name -> prototype mapping
+available_events: dict[str, Callable[..., Any]] = {}
+
+_CallbackT = TypeVar("_CallbackT", bound=Callable[..., Any])
+
+def _define_event(callback_function: _CallbackT) -> _CallbackT:
+    """Decorator to register a function as an available event prototype."""
+    available_events[callback_function.__name__] = callback_function
+    return callback_function
+
+# ------------------------------------------------------------------------------
+# Callback prototypes
+#
+# No-op functions which describe the names of available events and the
+# signatures of callbacks for those events.
+# ------------------------------------------------------------------------------
+
+@_define_event
+def pre_execute() -> None:
+    """Fires before code is executed in response to user/frontend action.
+
+    This includes comm and widget messages and silent execution, as well as user
+    code cells.
+    """
+    pass
+
+@_define_event
+def pre_run_cell(info: ExecutionInfo) -> None:
+    """Fires before user-entered code runs.
+
+    Parameters
+    ----------
+    info : :class:`~IPython.core.interactiveshell.ExecutionInfo`
+        An object containing information used for the code execution.
+    """
+    pass
+
+@_define_event
+def post_execute() -> None:
+    """Fires after code is executed in response to user/frontend action.
+
+    This includes comm and widget messages and silent execution, as well as user
+    code cells.
+    """
+    pass
+
+@_define_event
+def post_run_cell(result: ExecutionResult) -> None:
+    """Fires after user-entered code runs.
+
+    Parameters
+    ----------
+    result : :class:`~IPython.core.interactiveshell.ExecutionResult`
+        The object which will be returned as the execution result.
+    """
+    pass
+
+@_define_event
+def shell_initialized(ip: InteractiveShell) -> None:
+    """Fires after initialisation of :class:`~IPython.core.interactiveshell.InteractiveShell`.
+
+    This is before extensions and startup scripts are loaded, so it can only be
+    set by subclassing.
+
+    Parameters
+    ----------
+    ip : :class:`~IPython.core.interactiveshell.InteractiveShell`
+        The newly initialised shell.
+    """
+    pass
diff --git a/IPython/core/excolors.py b/IPython/core/excolors.py
deleted file mode 100644
index 14451d5516d..00000000000
--- a/IPython/core/excolors.py
+++ /dev/null
@@ -1,135 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Color schemes for exception handling code in IPython.
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2005-2006 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from IPython.utils.coloransi import ColorSchemeTable, TermColors, ColorScheme
-
-def exception_colors():
-    """Return a color table with fields for exception reporting.
-
-    The table is an instance of ColorSchemeTable with schemes added for
-    'Linux', 'LightBG' and 'NoColor' and fields for exception handling filled
-    in.
-
-    Examples:
-
-    >>> ec = exception_colors()
-    >>> ec.active_scheme_name
-    ''
-    >>> print ec.active_colors
-    None
-
-    Now we activate a color scheme:    
-    >>> ec.set_active_scheme('NoColor')
-    >>> ec.active_scheme_name
-    'NoColor'
-    >>> ec.active_colors.keys()
-    ['em', 'filenameEm', 'excName', 'valEm', 'nameEm', 'line', 'topline', 
-    'name', 'caret', 'val', 'vName', 'Normal', 'filename', 'linenoEm', 
-    'lineno', 'normalEm']
-    """
-    
-    ex_colors = ColorSchemeTable()
-
-    # Populate it with color schemes
-    C = TermColors # shorthand and local lookup
-    ex_colors.add_scheme(ColorScheme(
-        'NoColor',
-        # The color to be used for the top line
-        topline = C.NoColor,
-
-        # The colors to be used in the traceback
-        filename = C.NoColor,
-        lineno = C.NoColor,
-        name = C.NoColor,
-        vName = C.NoColor,
-        val = C.NoColor,
-        em = C.NoColor,
-
-        # Emphasized colors for the last frame of the traceback
-        normalEm = C.NoColor,
-        filenameEm = C.NoColor,
-        linenoEm = C.NoColor,
-        nameEm = C.NoColor,
-        valEm = C.NoColor,
-
-        # Colors for printing the exception
-        excName = C.NoColor,
-        line = C.NoColor,
-        caret = C.NoColor,
-        Normal = C.NoColor
-        ))
-
-    # make some schemes as instances so we can copy them for modification easily
-    ex_colors.add_scheme(ColorScheme(
-        'Linux',
-        # The color to be used for the top line
-        topline = C.LightRed,
-
-        # The colors to be used in the traceback
-        filename = C.Green,
-        lineno = C.Green,
-        name = C.Purple,
-        vName = C.Cyan,
-        val = C.Green,
-        em = C.LightCyan,
-
-        # Emphasized colors for the last frame of the traceback
-        normalEm = C.LightCyan,
-        filenameEm = C.LightGreen,
-        linenoEm = C.LightGreen,
-        nameEm = C.LightPurple,
-        valEm = C.LightBlue,
-
-        # Colors for printing the exception
-        excName = C.LightRed,
-        line = C.Yellow,
-        caret = C.White,
-        Normal = C.Normal
-        ))
-
-    # For light backgrounds, swap dark/light colors
-    ex_colors.add_scheme(ColorScheme(
-        'LightBG',
-        # The color to be used for the top line
-        topline = C.Red,
-
-        # The colors to be used in the traceback
-        filename = C.LightGreen,
-        lineno = C.LightGreen,
-        name = C.LightPurple,
-        vName = C.Cyan,
-        val = C.LightGreen,
-        em = C.Cyan,
-
-        # Emphasized colors for the last frame of the traceback
-        normalEm = C.Cyan,
-        filenameEm = C.Green,
-        linenoEm = C.Green,
-        nameEm = C.Purple,
-        valEm = C.Blue,
-
-        # Colors for printing the exception
-        excName = C.Red,
-        #line = C.Brown,  # brown often is displayed as yellow
-        line = C.Red,
-        caret = C.Normal,
-        Normal = C.Normal,
-        ))
-
-    return ex_colors
-
-
-# For backwards compatibility, keep around a single global object.  Note that
-# this should NOT be used, the factory function should be used instead, since
-# these objects are stateful and it's very easy to get strange bugs if any code
-# modifies the module-level object's state.
-ExceptionColors = exception_colors()
diff --git a/IPython/core/extensions.py b/IPython/core/extensions.py
index a087b93ad5e..27c6a4116d4 100644
--- a/IPython/core/extensions.py
+++ b/IPython/core/extensions.py
@@ -1,32 +1,26 @@
 # encoding: utf-8
-"""A class for managing IPython extensions.
+"""A class for managing IPython extensions."""
 
-Authors:
-
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import os
+import os.path
 import sys
+from importlib import import_module, reload
+
+from traitlets.config.configurable import Configurable
+from IPython.utils.path import ensure_dir_exists
+from traitlets import Instance
 
-from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import Instance
 
 #-----------------------------------------------------------------------------
 # Main class
 #-----------------------------------------------------------------------------
 
+BUILTINS_EXTS = {"storemagic": False, "autoreload": False}
+
+
 class ExtensionManager(Configurable):
     """A class to manage IPython extensions.
 
@@ -36,69 +30,80 @@ class ExtensionManager(Configurable):
         def load_ipython_extension(ipython):
             # Do things with ipython
 
-    This function is called after your extension is imported and the 
+    This function is called after your extension is imported and the
     currently active :class:`InteractiveShell` instance is passed as
     the only argument.  You can do anything you want with IPython at
     that point, including defining new magic and aliases, adding new
     components, etc.
 
-    The :func:`load_ipython_extension` will be called again is you 
-    load or reload the extension again.  It is up to the extension
-    author to add code to manage that.
+    You can also optionally define an :func:`unload_ipython_extension(ipython)`
+    function, which will be called if the user unloads or reloads the extension.
+    The extension manager will only call :func:`load_ipython_extension` again
+    if the extension is reloaded.
 
     You can put your extension modules anywhere you want, as long as
-    they can be imported by Python's standard import mechanism.  However,
-    to make it easy to write extensions, you can also put your extensions
-    in ``os.path.join(self.ipython_dir, 'extensions')``.  This directory
-    is added to ``sys.path`` automatically.
+    they can be imported by Python's standard import mechanism.
     """
 
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-
-    def __init__(self, shell=None, config=None):
-        super(ExtensionManager, self).__init__(shell=shell, config=config)
-        self.shell.on_trait_change(
-            self._on_ipython_dir_changed, 'ipython_dir'
-        )
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
 
-    def __del__(self):
-        self.shell.on_trait_change(
-            self._on_ipython_dir_changed, 'ipython_dir', remove=True
-        )
+    def __init__(self, shell=None, **kwargs):
+        super(ExtensionManager, self).__init__(shell=shell, **kwargs)
+        self.loaded = set()
 
-    @property
-    def ipython_extension_dir(self):
-        return os.path.join(self.shell.ipython_dir, u'extensions')
-
-    def _on_ipython_dir_changed(self):
-        if not os.path.isdir(self.ipython_extension_dir):
-            os.makedirs(self.ipython_extension_dir, mode = 0777)
-
-    def load_extension(self, module_str):
+    def load_extension(self, module_str: str):
         """Load an IPython extension by its module name.
 
-        If :func:`load_ipython_extension` returns anything, this function
-        will return that object.
+        Returns the string "already loaded" if the extension is already loaded,
+        "no load function" if the module doesn't have a load_ipython_extension
+        function, or None if it succeeded.
         """
-        from IPython.utils.syspathcontext import prepended_to_syspath
-
-        if module_str not in sys.modules:
-            with prepended_to_syspath(self.ipython_extension_dir):
-                __import__(module_str)
-        mod = sys.modules[module_str]
-        return self._call_load_ipython_extension(mod)
+        try:
+            return self._load_extension(module_str)
+        except ModuleNotFoundError:
+            if module_str in BUILTINS_EXTS:
+                BUILTINS_EXTS[module_str] = True
+                return self._load_extension("IPython.extensions." + module_str)
+            raise
+
+    def _load_extension(self, module_str: str):
+        if module_str in self.loaded:
+            return "already loaded"
+
+        assert self.shell is not None
+
+        with self.shell.builtin_trap:
+            if module_str not in sys.modules:
+                mod = import_module(module_str)
+            mod = sys.modules[module_str]
+            if self._call_load_ipython_extension(mod):
+                self.loaded.add(module_str)
+            else:
+                return "no load function"
 
-    def unload_extension(self, module_str):
+    def unload_extension(self, module_str: str):
         """Unload an IPython extension by its module name.
 
         This function looks up the extension's name in ``sys.modules`` and
         simply calls ``mod.unload_ipython_extension(self)``.
+
+        Returns the string "no unload function" if the extension doesn't define
+        a function to unload itself, "not loaded" if the extension isn't loaded,
+        otherwise None.
         """
+        if BUILTINS_EXTS.get(module_str, False) is True:
+            module_str = "IPython.extensions." + module_str
+        if module_str not in self.loaded:
+            return "not loaded"
+
         if module_str in sys.modules:
             mod = sys.modules[module_str]
-            self._call_unload_ipython_extension(mod)
+            if self._call_unload_ipython_extension(mod):
+                self.loaded.discard(module_str)
+            else:
+                return "no unload function"
 
-    def reload_extension(self, module_str):
+    def reload_extension(self, module_str: str):
         """Reload an IPython extension by calling reload.
 
         If the module has not been loaded before,
@@ -106,20 +111,25 @@ def reload_extension(self, module_str):
         :func:`reload` is called and then the :func:`load_ipython_extension`
         function of the module, if it exists is called.
         """
-        from IPython.utils.syspathcontext import prepended_to_syspath
 
-        with prepended_to_syspath(self.ipython_extension_dir):
-            if module_str in sys.modules:
-                mod = sys.modules[module_str]
-                reload(mod)
-                self._call_load_ipython_extension(mod)
-            else:
-                self.load_extension(module_str)
+        if BUILTINS_EXTS.get(module_str, False) is True:
+            module_str = "IPython.extensions." + module_str
+
+        if (module_str in self.loaded) and (module_str in sys.modules):
+            self.unload_extension(module_str)
+            mod = sys.modules[module_str]
+            reload(mod)
+            if self._call_load_ipython_extension(mod):
+                self.loaded.add(module_str)
+        else:
+            self.load_extension(module_str)
 
     def _call_load_ipython_extension(self, mod):
         if hasattr(mod, 'load_ipython_extension'):
-            return mod.load_ipython_extension(self.shell)
+            mod.load_ipython_extension(self.shell)
+            return True
 
     def _call_unload_ipython_extension(self, mod):
         if hasattr(mod, 'unload_ipython_extension'):
-            return mod.unload_ipython_extension(self.shell)
+            mod.unload_ipython_extension(self.shell)
+            return True
diff --git a/IPython/core/fakemodule.py b/IPython/core/fakemodule.py
deleted file mode 100644
index 41029f52a2a..00000000000
--- a/IPython/core/fakemodule.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Class which mimics a module.
-
-Needed to allow pickle to correctly resolve namespaces during IPython
-sessions.
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2002-2004 Fernando Perez. <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-import types
-
-def init_fakemod_dict(fm,adict=None):
-    """Initialize a FakeModule instance __dict__.
-
-    Kept as a standalone function and not a method so the FakeModule API can
-    remain basically empty.
-
-    This should be considered for private IPython use, used in managing
-    namespaces for %run.
-
-    Parameters
-    ----------
-
-    fm : FakeModule instance
-
-    adict : dict, optional
-    """
-
-    dct = {}
-    # It seems pydoc (and perhaps others) needs any module instance to
-    # implement a __nonzero__ method, so we add it if missing:
-    dct.setdefault('__nonzero__',lambda : True)
-    dct.setdefault('__file__',__file__)
-
-    if adict is not None:
-        dct.update(adict)
-
-    # Hard assignment of the object's __dict__.  This is nasty but deliberate.
-    fm.__dict__.clear()
-    fm.__dict__.update(dct)
-
-
-class FakeModule(types.ModuleType):
-    """Simple class with attribute access to fake a module.
-
-    This is not meant to replace a module, but to allow inserting a fake
-    module in sys.modules so that systems which rely on run-time module
-    importing (like shelve and pickle) work correctly in interactive IPython
-    sessions.
-
-    Do NOT use this code for anything other than this IPython private hack."""
-
-    def __init__(self,adict=None):
-        
-        # tmp to force __dict__ instance creation, else self.__dict__ fails
-        self.__iptmp = None
-        # cleanup our temp trick
-        del self.__iptmp
-        # Now, initialize the actual data in the instance dict.
-        init_fakemod_dict(self,adict)
diff --git a/IPython/core/formatters.py b/IPython/core/formatters.py
index 40afd484599..82e700b5caf 100644
--- a/IPython/core/formatters.py
+++ b/IPython/core/formatters.py
@@ -1,62 +1,148 @@
 # -*- coding: utf-8 -*-
 """Display formatters.
 
+This module defines the base instances in order to implement custom
+formatters/mimetypes
+got objects:
 
-Authors:
+As we want to see internal IPython working we are going to use the following
+function to diaply objects instead of the normal print or display method:
 
-* Robert Kern
-* Brian Granger
+    >>> ip = get_ipython()
+    >>> ip.display_formatter.format(...)
+    ({'text/plain': 'Ellipsis'}, {})
+
+This return a tuple with the mimebumdle for the current object, and the
+associated metadata.
+
+
+We can now define our own formatter and register it:
+
+
+    >>> from IPython.core.formatters import BaseFormatter, FormatterABC
+
+
+    >>> class LLMFormatter(BaseFormatter):
+    ...
+    ...     format_type = 'x-vendor/llm'
+    ...     print_method = '_repr_llm_'
+    ...     _return_type = (dict, str)
+
+    >>> llm_formatter = LLMFormatter(parent=ip.display_formatter)
+
+    >>> ip.display_formatter.formatters[LLMFormatter.format_type] = llm_formatter
+
+Now any class that define `_repr_llm_` will return a x-vendor/llm as part of
+it's display data:
+
+    >>> class A:
+    ...
+    ...     def _repr_llm_(self, *kwargs):
+    ...         return 'This a A'
+    ...
+
+    >>> ip.display_formatter.format(A())
+    ({'text/plain': '<IPython.core.formatters.A at ...>', 'x-vendor/llm': 'This a A'}, {})
+
+As usual, you can register methods for third party types (see
+:ref:`third_party_formatting`)
+
+    >>> def llm_int(obj):
+    ...      return 'This is the integer %s, in between %s and %s'%(obj, obj-1, obj+1)
+
+    >>> llm_formatter.for_type(int, llm_int)
+
+    >>> ip.display_formatter.format(42)
+    ({'text/plain': '42', 'x-vendor/llm': 'This is the integer 42, in between 41 and 43'}, {})
+
+
+Inheritance diagram:
+
+.. inheritance-diagram:: IPython.core.formatters
+   :parts: 3
 """
-#-----------------------------------------------------------------------------
-# Copyright (c) 2010, IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-# Stdlib imports
 import abc
 import sys
-# We must use StringIO, as cStringIO doesn't handle unicode properly.
-from StringIO import StringIO
+import traceback
+import warnings
+from io import StringIO
 
-# Our own imports
-from IPython.config.configurable import Configurable
-from IPython.lib import pretty
-from IPython.utils.traitlets import Bool, Dict, Int, Str, CStr
+from decorator import decorator
 
+from traitlets.config.configurable import Configurable
+from .getipython import get_ipython
+from ..utils.sentinel import Sentinel
+from ..utils.dir2 import get_real_method
+from ..lib import pretty
+from traitlets import (
+    Bool, Dict, Integer, Unicode, CUnicode, ObjectName, List,
+    ForwardDeclaredInstance,
+    default, observe,
+)
 
-#-----------------------------------------------------------------------------
-# The main DisplayFormatter class
-#-----------------------------------------------------------------------------
+from typing import Any
 
 
 class DisplayFormatter(Configurable):
 
-    # When set to true only the default plain text formatter will be used.
-    plain_text_only = Bool(False, config=True)
+    active_types = List(Unicode(),
+        help="""List of currently active mime-types to display.
+        You can use this to set a white-list for formats to display.
+
+        Most users will not need to change this value.
+        """,
+    ).tag(config=True)
+
+    @default('active_types')
+    def _active_types_default(self):
+        return self.format_types
+
+    @observe('active_types')
+    def _active_types_changed(self, change):
+        for key, formatter in self.formatters.items():
+            if key in change['new']:
+                formatter.enabled = True
+            else:
+                formatter.enabled = False
+
+    ipython_display_formatter = ForwardDeclaredInstance("FormatterABC")  # type: ignore
+
+    @default("ipython_display_formatter")
+    def _default_formatter(self):
+        return IPythonDisplayFormatter(parent=self)
+
+    mimebundle_formatter = ForwardDeclaredInstance("FormatterABC")  # type: ignore
+
+    @default("mimebundle_formatter")
+    def _default_mime_formatter(self):
+        return MimeBundleFormatter(parent=self)
 
     # A dict of formatter whose keys are format types (MIME types) and whose
     # values are subclasses of BaseFormatter.
-    formatters = Dict(config=True)
+    formatters = Dict()
+
+    @default("formatters")
     def _formatters_default(self):
         """Activate the default formatters."""
         formatter_classes = [
             PlainTextFormatter,
             HTMLFormatter,
+            MarkdownFormatter,
             SVGFormatter,
             PNGFormatter,
+            PDFFormatter,
+            JPEGFormatter,
             LatexFormatter,
-            JSONFormatter
+            JSONFormatter,
+            JavascriptFormatter
         ]
         d = {}
         for cls in formatter_classes:
-            f = cls(config=self.config)
+            f = cls(parent=self)
             d[f.format_type] = f
         return d
 
@@ -65,71 +151,109 @@ def format(self, obj, include=None, exclude=None):
 
         By default all format types will be computed.
 
-        The following MIME types are currently implemented:
+        The following MIME types are usually implemented:
 
         * text/plain
         * text/html
+        * text/markdown
         * text/latex
         * application/json
+        * application/javascript
+        * application/pdf
         * image/png
-        * immage/svg+xml
+        * image/jpeg
+        * image/svg+xml
 
         Parameters
         ----------
         obj : object
             The Python object whose format data will be computed.
-        include : list or tuple, optional
+        include : list, tuple or set; optional
             A list of format type strings (MIME types) to include in the
             format data dict. If this is set *only* the format types included
             in this list will be computed.
-        exclude : list or tuple, optional
-            A list of format type string (MIME types) to exclue in the format
+        exclude : list, tuple or set; optional
+            A list of format type string (MIME types) to exclude in the format
             data dict. If this is set all format types will be computed,
             except for those included in this argument.
+            Mimetypes present in exclude will take precedence over the ones in include
 
         Returns
         -------
-        format_dict : dict
-            A dictionary of key/value pairs, one or each format that was
+        (format_dict, metadata_dict) : tuple of two dicts
+            format_dict is a dictionary of key/value pairs, one of each format that was
             generated for the object. The keys are the format types, which
             will usually be MIME type strings and the values and JSON'able
             data structure containing the raw data for the representation in
             that format.
+
+            metadata_dict is a dictionary of metadata about each mime-type output.
+            Its keys will be a strict subset of the keys in format_dict.
+
+        Notes
+        -----
+            If an object implement `_repr_mimebundle_` as well as various
+            `_repr_*_`, the data returned by `_repr_mimebundle_` will take
+            precedence and the corresponding `_repr_*_` for this mimetype will
+            not be called.
+
         """
         format_dict = {}
+        md_dict = {}
 
-        # If plain text only is active
-        if self.plain_text_only:
-            formatter = self.formatters['text/plain']
-            try:
-                data = formatter(obj)
-            except:
-                # FIXME: log the exception
-                raise
-            if data is not None:
-                format_dict['text/plain'] = data
-            return format_dict
+        if self.ipython_display_formatter(obj):
+            # object handled itself, don't proceed
+            return {}, {}
+
+        format_dict, md_dict = self.mimebundle_formatter(obj, include=include, exclude=exclude)
+
+        if format_dict or md_dict:
+            if include:
+                format_dict = {k:v for k,v in format_dict.items() if k in include}
+                md_dict = {k:v for k,v in md_dict.items() if k in include}
+            if exclude:
+                format_dict = {k:v for k,v in format_dict.items() if k not in exclude}
+                md_dict = {k:v for k,v in md_dict.items() if k not in exclude}
 
         for format_type, formatter in self.formatters.items():
-            if include is not None:
-                if format_type not in include:
-                    continue
-            if exclude is not None:
-                if format_type in exclude:
+            if format_type in format_dict:
+                # already got it from mimebundle, maybe don't render again.
+                # exception: manually registered per-mime renderer
+                # check priority:
+                # 1. user-registered per-mime formatter
+                # 2. mime-bundle (user-registered or repr method)
+                # 3. default per-mime formatter (e.g. repr method)
+                try:
+                    formatter.lookup(obj)
+                except KeyError:
+                    # no special formatter, use mime-bundle-provided value
                     continue
+            if include and format_type not in include:
+                continue
+            if exclude and format_type in exclude:
+                continue
+
+            md = None
             try:
                 data = formatter(obj)
             except:
                 # FIXME: log the exception
                 raise
+
+            # formatters can return raw data or (data, metadata)
+            if isinstance(data, tuple) and len(data) == 2:
+                data, md = data
+
             if data is not None:
                 format_dict[format_type] = data
-        return format_dict
+            if md is not None:
+                md_dict[format_type] = md
+        return format_dict, md_dict
 
     @property
     def format_types(self):
         """Return the format types (MIME types) of the active formatters."""
-        return self.formatters.keys()
+        return list(self.formatters.keys())
 
 
 #-----------------------------------------------------------------------------
@@ -137,7 +261,40 @@ def format_types(self):
 #-----------------------------------------------------------------------------
 
 
-class FormatterABC(object):
+def _safe_repr(obj):
+    """Try to return a repr of an object
+
+    always returns a string, at least.
+    """
+    try:
+        return repr(obj)
+    except Exception as e:
+        return "un-repr-able object (%r)" % e
+
+
+class FormatterWarning(UserWarning):
+    """Warning class for errors in formatters"""
+
+@decorator
+def catch_format_error(method, self, *args, **kwargs):
+    """show traceback on failed format call"""
+    try:
+        r = method(self, *args, **kwargs)
+    except NotImplementedError:
+        # don't warn on NotImplementedErrors
+        return self._check_return(None, args[0])
+    except Exception:
+        exc_info = sys.exc_info()
+        ip = get_ipython()
+        if ip is not None:
+            ip.showtraceback(exc_info)
+        else:
+            traceback.print_exception(*exc_info)
+        return self._check_return(None, args[0])
+    return self._check_return(r, args[0])
+
+
+class FormatterABC(metaclass=abc.ABCMeta):
     """ Abstract base class for Formatters.
 
     A formatter is a callable class that is responsible for computing the
@@ -145,7 +302,6 @@ class FormatterABC(object):
     an HTML formatter would have a format type of `text/html` and would return
     the HTML representation of the object when called.
     """
-    __metaclass__ = abc.ABCMeta
 
     # The format type of the data returned, usually a MIME type.
     format_type = 'text/plain'
@@ -157,12 +313,36 @@ class FormatterABC(object):
     def __call__(self, obj):
         """Return a JSON'able representation of the object.
 
-        If the object cannot be formatted by this formatter, then return None
+        If the object cannot be formatted by this formatter,
+        warn and return None.
         """
-        try:
-            return repr(obj)
-        except TypeError:
-            return None
+        return repr(obj)
+
+
+def _mod_name_key(typ):
+    """Return a (__module__, __name__) tuple for a type.
+
+    Used as key in Formatter.deferred_printers.
+    """
+    module = getattr(typ, '__module__', None)
+    name = getattr(typ, '__name__', None)
+    return (module, name)
+
+
+def _get_type(obj):
+    """Return the type of an instance (old and new-style)"""
+    return getattr(obj, '__class__', None) or type(obj)
+
+
+_raise_key_error = Sentinel(
+    "_raise_key_error",
+    __name__,
+    """
+Special value to raise a KeyError
+
+Raise KeyError in `BaseFormatter.pop` if passed as the default value to `pop`
+""",
+)
 
 
 class BaseFormatter(Configurable):
@@ -186,84 +366,170 @@ class BaseFormatter(Configurable):
     dictionaries is through the :meth:`for_type` and :meth:`for_type_by_name`
     methods.
 
-    If no function/callable is found to compute the format data, ``None`` is
+    If no function/callable is found to compute the format data, :py:data:`None` is
     returned and this format type is not used.
     """
 
-    format_type = Str('text/plain')
+    format_type = Unicode("text/plain")
+    _return_type: Any = str
 
-    enabled = Bool(True, config=True)
+    enabled = Bool(True).tag(config=True)
 
-    print_method = Str('__repr__')
+    print_method = ObjectName('__repr__')
 
     # The singleton printers.
     # Maps the IDs of the builtin singleton objects to the format functions.
-    singleton_printers = Dict(config=True)
-    def _singleton_printers_default(self):
-        return {}
+    singleton_printers = Dict().tag(config=True)
 
     # The type-specific printers.
     # Map type objects to the format functions.
-    type_printers = Dict(config=True)
-    def _type_printers_default(self):
-        return {}
+    type_printers = Dict().tag(config=True)
 
     # The deferred-import type-specific printers.
     # Map (modulename, classname) pairs to the format functions.
-    deferred_printers = Dict(config=True)
-    def _deferred_printers_default(self):
-        return {}
+    deferred_printers = Dict().tag(config=True)
 
+    @catch_format_error
     def __call__(self, obj):
         """Compute the format for an object."""
         if self.enabled:
-            obj_id = id(obj)
+            # lookup registered printer
             try:
-                obj_class = getattr(obj, '__class__', None) or type(obj)
-                if hasattr(obj_class, self.print_method):
-                    printer = getattr(obj_class, self.print_method)
-                    return printer(obj)
-                try:
-                    printer = self.singleton_printers[obj_id]
-                except (TypeError, KeyError):
-                    pass
-                else:
-                    return printer(obj)
-                for cls in pretty._get_mro(obj_class):
-                    if cls in self.type_printers:
-                        return self.type_printers[cls](obj)
-                    else:
-                        printer = self._in_deferred_types(cls)
-                        if printer is not None:
-                            return printer(obj)
-                return None
-            except Exception:
+                printer = self.lookup(obj)
+            except KeyError:
                 pass
+            else:
+                return printer(obj)
+            # Finally look for special method names
+            method = get_real_method(obj, self.print_method)
+            if method is not None:
+                return method()
+            return None
         else:
             return None
 
-    def for_type(self, typ, func):
+    def __contains__(self, typ):
+        """map in to lookup_by_type"""
+        try:
+            self.lookup_by_type(typ)
+        except KeyError:
+            return False
+        else:
+            return True
+
+    def _check_return(self, r, obj):
+        """Check that a return value is appropriate
+
+        Return the value if so, None otherwise, warning if invalid.
+        """
+        if r is None or isinstance(r, self._return_type) or \
+            (isinstance(r, tuple) and r and isinstance(r[0], self._return_type)):
+            return r
+        else:
+            warnings.warn(
+                "%s formatter returned invalid type %s (expected %s) for object: %s" % \
+                (self.format_type, type(r), self._return_type, _safe_repr(obj)),
+                FormatterWarning
+            )
+
+    def lookup(self, obj):
+        """Look up the formatter for a given instance.
+
+        Parameters
+        ----------
+        obj : object instance
+
+        Returns
+        -------
+        f : callable
+            The registered formatting callable for the type.
+
+        Raises
+        ------
+        KeyError if the type has not been registered.
+        """
+        # look for singleton first
+        obj_id = id(obj)
+        if obj_id in self.singleton_printers:
+            return self.singleton_printers[obj_id]
+        # then lookup by type
+        return self.lookup_by_type(_get_type(obj))
+
+    def lookup_by_type(self, typ):
+        """Look up the registered formatter for a type.
+
+        Parameters
+        ----------
+        typ : type or '__module__.__name__' string for a type
+
+        Returns
+        -------
+        f : callable
+            The registered formatting callable for the type.
+
+        Raises
+        ------
+        KeyError if the type has not been registered.
+        """
+        if isinstance(typ, str):
+            typ_key = tuple(typ.rsplit('.',1))
+            if typ_key not in self.deferred_printers:
+                # We may have it cached in the type map. We will have to
+                # iterate over all of the types to check.
+                for cls in self.type_printers:
+                    if _mod_name_key(cls) == typ_key:
+                        return self.type_printers[cls]
+            else:
+                return self.deferred_printers[typ_key]
+        else:
+            for cls in pretty._get_mro(typ):
+                if cls in self.type_printers or self._in_deferred_types(cls):
+                    return self.type_printers[cls]
+
+        # If we have reached here, the lookup failed.
+        raise KeyError("No registered printer for {0!r}".format(typ))
+
+    def for_type(self, typ, func=None):
         """Add a format function for a given type.
 
         Parameters
-        -----------
-        typ : class
+        ----------
+        typ : type or '__module__.__name__' string for a type
             The class of the object that will be formatted using `func`.
+
         func : callable
-            The callable that will be called to compute the format data. The
-            call signature of this function is simple, it must take the
-            object to be formatted and return the raw data for the given
-            format. Subclasses may use a different call signature for the
+            A callable for computing the format data.
+            `func` will be called with the object to be formatted,
+            and will return the raw data in this formatter's format.
+            Subclasses may use a different call signature for the
             `func` argument.
+
+            If `func` is None or not specified, there will be no change,
+            only returning the current value.
+
+        Returns
+        -------
+        oldfunc : callable
+            The currently registered callable.
+            If you are registering a new formatter,
+            this will be the previous value (to enable restoring later).
         """
-        oldfunc = self.type_printers.get(typ, None)
+        # if string given, interpret as 'pkg.module.class_name'
+        if isinstance(typ, str):
+            type_module, type_name = typ.rsplit('.', 1)
+            return self.for_type_by_name(type_module, type_name, func)
+
+        try:
+            oldfunc = self.lookup_by_type(typ)
+        except KeyError:
+            oldfunc = None
+
         if func is not None:
-            # To support easy restoration of old printers, we need to ignore
-            # Nones.
             self.type_printers[typ] = func
+
         return oldfunc
 
-    def for_type_by_name(self, type_module, type_name, func):
+    def for_type_by_name(self, type_module, type_name, func=None):
         """Add a format function for a type specified by the full dotted
         module and name of the type, rather than the type of the object.
 
@@ -272,48 +538,102 @@ def for_type_by_name(self, type_module, type_name, func):
         type_module : str
             The full dotted name of the module the type is defined in, like
             ``numpy``.
+
         type_name : str
             The name of the type (the class name), like ``dtype``
+
         func : callable
-            The callable that will be called to compute the format data. The
-            call signature of this function is simple, it must take the
-            object to be formatted and return the raw data for the given
-            format. Subclasses may use a different call signature for the
+            A callable for computing the format data.
+            `func` will be called with the object to be formatted,
+            and will return the raw data in this formatter's format.
+            Subclasses may use a different call signature for the
             `func` argument.
+
+            If `func` is None or unspecified, there will be no change,
+            only returning the current value.
+
+        Returns
+        -------
+        oldfunc : callable
+            The currently registered callable.
+            If you are registering a new formatter,
+            this will be the previous value (to enable restoring later).
         """
         key = (type_module, type_name)
-        oldfunc = self.deferred_printers.get(key, None)
+
+        try:
+            oldfunc = self.lookup_by_type("%s.%s" % key)
+        except KeyError:
+            oldfunc = None
+
         if func is not None:
-            # To support easy restoration of old printers, we need to ignore
-            # Nones.
             self.deferred_printers[key] = func
         return oldfunc
 
+    def pop(self, typ, default=_raise_key_error):
+        """Pop a formatter for the given type.
+
+        Parameters
+        ----------
+        typ : type or '__module__.__name__' string for a type
+        default : object
+            value to be returned if no formatter is registered for typ.
+
+        Returns
+        -------
+        obj : object
+            The last registered object for the type.
+
+        Raises
+        ------
+        KeyError if the type is not registered and default is not specified.
+        """
+
+        if isinstance(typ, str):
+            typ_key = tuple(typ.rsplit('.',1))
+            if typ_key not in self.deferred_printers:
+                # We may have it cached in the type map. We will have to
+                # iterate over all of the types to check.
+                for cls in self.type_printers:
+                    if _mod_name_key(cls) == typ_key:
+                        old = self.type_printers.pop(cls)
+                        break
+                else:
+                    old = default
+            else:
+                old = self.deferred_printers.pop(typ_key)
+        else:
+            if typ in self.type_printers:
+                old = self.type_printers.pop(typ)
+            else:
+                old = self.deferred_printers.pop(_mod_name_key(typ), default)
+        if old is _raise_key_error:
+            raise KeyError("No registered value for {0!r}".format(typ))
+        return old
+
     def _in_deferred_types(self, cls):
         """
         Check if the given class is specified in the deferred type registry.
 
-        Returns the printer from the registry if it exists, and None if the
-        class is not in the registry. Successful matches will be moved to the
-        regular type registry for future use.
+        Successful matches will be moved to the regular type registry for future use.
         """
         mod = getattr(cls, '__module__', None)
         name = getattr(cls, '__name__', None)
         key = (mod, name)
-        printer = None
         if key in self.deferred_printers:
             # Move the printer over to the regular registry.
             printer = self.deferred_printers.pop(key)
             self.type_printers[cls] = printer
-        return printer
+            return True
+        return False
 
 
 class PlainTextFormatter(BaseFormatter):
     """The default pretty-printer.
 
-    This uses :mod:`IPython.external.pretty` to compute the format data of
+    This uses :mod:`IPython.lib.pretty` to compute the format data of
     the object. If the object cannot be pretty printed, :func:`repr` is used.
-    See the documentation of :mod:`IPython.external.pretty` for details on
+    See the documentation of :mod:`IPython.lib.pretty` for details on
     how to write pretty printers.  Here is a simple example::
 
         def dtype_pprinter(obj, p, cycle):
@@ -333,63 +653,71 @@ def dtype_pprinter(obj, p, cycle):
     """
 
     # The format type of data returned.
-    format_type = Str('text/plain')
+    format_type = Unicode('text/plain')
 
     # This subclass ignores this attribute as it always need to return
     # something.
-    enabled = Bool(True, config=False)
+    enabled = Bool(True).tag(config=False)
+
+    max_seq_length = Integer(pretty.MAX_SEQ_LENGTH,
+        help="""Truncate large collections (lists, dicts, tuples, sets) to this size.
 
-    # Look for a __pretty__ methods to use for pretty printing.
-    print_method = Str('__pretty__')
+        Set to 0 to disable truncation.
+        """,
+    ).tag(config=True)
+
+    # Look for a _repr_pretty_ methods to use for pretty printing.
+    print_method = ObjectName('_repr_pretty_')
 
     # Whether to pretty-print or not.
-    pprint = Bool(True, config=True)
+    pprint = Bool(True).tag(config=True)
 
     # Whether to be verbose or not.
-    verbose = Bool(False, config=True)
+    verbose = Bool(False).tag(config=True)
 
     # The maximum width.
-    max_width = Int(79, config=True)
+    max_width = Integer(79).tag(config=True)
 
     # The newline character.
-    newline = Str('\n', config=True)
-    
+    newline = Unicode('\n').tag(config=True)
+
     # format-string for pprinting floats
-    float_format = Str('%r')
+    float_format = Unicode('%r')
     # setter for float precision, either int or direct format-string
-    float_precision = CStr('', config=True)
-    
-    def _float_precision_changed(self, name, old, new):
+    float_precision = CUnicode('').tag(config=True)
+
+    @observe('float_precision')
+    def _float_precision_changed(self, change):
         """float_precision changed, set float_format accordingly.
-        
+
         float_precision can be set by int or str.
         This will set float_format, after interpreting input.
         If numpy has been imported, numpy print precision will also be set.
-        
+
         integer `n` sets format to '%.nf', otherwise, format set directly.
-        
+
         An empty string returns to defaults (repr for float, 8 for numpy).
-        
+
         This parameter can be set via the '%precision' magic.
         """
-        
+        new = change['new']
         if '%' in new:
             # got explicit format string
             fmt = new
             try:
                 fmt%3.14159
-            except Exception:
-                raise ValueError("Precision must be int or format string, not %r"%new)
+            except Exception as e:
+                raise ValueError("Precision must be int or format string, not %r"%new) from e
         elif new:
             # otherwise, should be an int
             try:
                 i = int(new)
                 assert i >= 0
-            except ValueError:
-                raise ValueError("Precision must be int or format string, not %r"%new)
-            except AssertionError:
-                raise ValueError("int precision must be non-negative, not %r"%i)
-            
+            except ValueError as e:
+                raise ValueError("Precision must be int or format string, not %r"%new) from e
+            except AssertionError as e:
+                raise ValueError("int precision must be non-negative, not %r"%i) from e
+
             fmt = '%%.%if'%i
             if 'numpy' in sys.modules:
                 # set numpy precision if it has been imported
@@ -404,32 +732,38 @@ def _float_precision_changed(self, name, old, new):
                 numpy.set_printoptions(precision=8)
         self.float_format = fmt
 
-    # Use the default pretty printers from IPython.external.pretty.
+    # Use the default pretty printers from IPython.lib.pretty.
+    @default('singleton_printers')
     def _singleton_printers_default(self):
         return pretty._singleton_pprinters.copy()
 
+    @default('type_printers')
     def _type_printers_default(self):
         d = pretty._type_pprinters.copy()
         d[float] = lambda obj,p,cycle: p.text(self.float_format%obj)
+        # if NumPy is used, set precision for its float64 type
+        if "numpy" in sys.modules:
+            import numpy
+
+            d[numpy.float64] = lambda obj, p, cycle: p.text(self.float_format % obj)
         return d
 
+    @default('deferred_printers')
     def _deferred_printers_default(self):
         return pretty._deferred_type_pprinters.copy()
 
     #### FormatterABC interface ####
 
+    @catch_format_error
     def __call__(self, obj):
         """Compute the pretty representation of the object."""
         if not self.pprint:
-            try:
-                return repr(obj)
-            except TypeError:
-                return ''
+            return repr(obj)
         else:
-            # This uses use StringIO, as cStringIO doesn't handle unicode.
             stream = StringIO()
             printer = pretty.RepresentationPrinter(stream, self.verbose,
                 self.max_width, self.newline,
+                max_seq_length=self.max_seq_length,
                 singleton_pprinters=self.singleton_printers,
                 type_pprinters=self.type_printers,
                 deferred_pprinters=self.deferred_printers)
@@ -442,74 +776,282 @@ class HTMLFormatter(BaseFormatter):
     """An HTML formatter.
 
     To define the callables that compute the HTML representation of your
-    objects, define a :meth:`__html__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_html_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
+
+    The return value of this formatter should be a valid HTML snippet that
+    could be injected into an existing DOM. It should *not* include the
+    ```<html>`` or ```<body>`` tags.
     """
-    format_type = Str('text/html')
+    format_type = Unicode('text/html')
+
+    print_method = ObjectName('_repr_html_')
 
-    print_method = Str('__html__')
 
+class MarkdownFormatter(BaseFormatter):
+    """A Markdown formatter.
+
+    To define the callables that compute the Markdown representation of your
+    objects, define a :meth:`_repr_markdown_` method or use the :meth:`for_type`
+    or :meth:`for_type_by_name` methods to register functions that handle
+    this.
+
+    The return value of this formatter should be a valid Markdown.
+    """
+    format_type = Unicode('text/markdown')
+
+    print_method = ObjectName('_repr_markdown_')
 
 class SVGFormatter(BaseFormatter):
     """An SVG formatter.
 
     To define the callables that compute the SVG representation of your
-    objects, define a :meth:`__svg__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_svg_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
+
+    The return value of this formatter should be valid SVG enclosed in
+    ```<svg>``` tags, that could be injected into an existing DOM. It should
+    *not* include the ```<html>`` or ```<body>`` tags.
     """
-    format_type = Str('image/svg+xml')
+    format_type = Unicode('image/svg+xml')
 
-    print_method = Str('__svg__')
+    print_method = ObjectName('_repr_svg_')
 
 
 class PNGFormatter(BaseFormatter):
     """A PNG formatter.
 
     To define the callables that compute the PNG representation of your
-    objects, define a :meth:`__png__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_png_` method or use the :meth:`for_type`
+    or :meth:`for_type_by_name` methods to register functions that handle
+    this.
+
+    The return value of this formatter should be raw PNG data, *not*
+    base64 encoded.
+    """
+    format_type = Unicode('image/png')
+
+    print_method = ObjectName('_repr_png_')
+
+    _return_type = (bytes, str)
+
+
+class JPEGFormatter(BaseFormatter):
+    """A JPEG formatter.
+
+    To define the callables that compute the JPEG representation of your
+    objects, define a :meth:`_repr_jpeg_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
-    this. The raw data should be the base64 encoded raw png data.
+    this.
+
+    The return value of this formatter should be raw JPEG data, *not*
+    base64 encoded.
     """
-    format_type = Str('image/png')
+    format_type = Unicode('image/jpeg')
 
-    print_method = Str('__png__')
+    print_method = ObjectName('_repr_jpeg_')
+
+    _return_type = (bytes, str)
 
 
 class LatexFormatter(BaseFormatter):
     """A LaTeX formatter.
 
     To define the callables that compute the LaTeX representation of your
-    objects, define a :meth:`__latex__` method or use the :meth:`for_type`
+    objects, define a :meth:`_repr_latex_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
+
+    The return value of this formatter should be a valid LaTeX equation,
+    enclosed in either ```$```, ```$$``` or another LaTeX equation
+    environment.
     """
-    format_type = Str('text/latex')
+    format_type = Unicode('text/latex')
 
-    print_method = Str('__latex__')
+    print_method = ObjectName('_repr_latex_')
 
 
 class JSONFormatter(BaseFormatter):
     """A JSON string formatter.
 
-    To define the callables that compute the JSON string representation of
-    your objects, define a :meth:`__json__` method or use the :meth:`for_type`
+    To define the callables that compute the JSONable representation of
+    your objects, define a :meth:`_repr_json_` method or use the :meth:`for_type`
+    or :meth:`for_type_by_name` methods to register functions that handle
+    this.
+
+    The return value of this formatter should be a JSONable list or dict.
+    JSON scalars (None, number, string) are not allowed, only dict or list containers.
+    """
+    format_type = Unicode('application/json')
+    _return_type = (list, dict)
+
+    print_method = ObjectName('_repr_json_')
+
+    def _check_return(self, r, obj):
+        """Check that a return value is appropriate
+
+        Return the value if so, None otherwise, warning if invalid.
+        """
+        if r is None:
+            return
+        md = None
+        if isinstance(r, tuple):
+            # unpack data, metadata tuple for type checking on first element
+            r, md = r
+
+        assert not isinstance(
+            r, str
+        ), "JSON-as-string has been deprecated since IPython < 3"
+
+        if md is not None:
+            # put the tuple back together
+            r = (r, md)
+        return super(JSONFormatter, self)._check_return(r, obj)
+
+
+class JavascriptFormatter(BaseFormatter):
+    """A Javascript formatter.
+
+    To define the callables that compute the Javascript representation of
+    your objects, define a :meth:`_repr_javascript_` method or use the
+    :meth:`for_type` or :meth:`for_type_by_name` methods to register functions
+    that handle this.
+
+    The return value of this formatter should be valid Javascript code and
+    should *not* be enclosed in ```<script>``` tags.
+    """
+    format_type = Unicode('application/javascript')
+
+    print_method = ObjectName('_repr_javascript_')
+
+
+class PDFFormatter(BaseFormatter):
+    """A PDF formatter.
+
+    To define the callables that compute the PDF representation of your
+    objects, define a :meth:`_repr_pdf_` method or use the :meth:`for_type`
+    or :meth:`for_type_by_name` methods to register functions that handle
+    this.
+
+    The return value of this formatter should be raw PDF data, *not*
+    base64 encoded.
+    """
+    format_type = Unicode('application/pdf')
+
+    print_method = ObjectName('_repr_pdf_')
+
+    _return_type = (bytes, str)
+
+class IPythonDisplayFormatter(BaseFormatter):
+    """An escape-hatch Formatter for objects that know how to display themselves.
+
+    To define the callables that compute the representation of your
+    objects, define a :meth:`_ipython_display_` method or use the :meth:`for_type`
+    or :meth:`for_type_by_name` methods to register functions that handle
+    this. Unlike mime-type displays, this method should not return anything,
+    instead calling any appropriate display methods itself.
+
+    This display formatter has highest priority.
+    If it fires, no other display formatter will be called.
+
+    Prior to IPython 6.1, `_ipython_display_` was the only way to display custom mime-types
+    without registering a new Formatter.
+
+    IPython 6.1 introduces `_repr_mimebundle_` for displaying custom mime-types,
+    so `_ipython_display_` should only be used for objects that require unusual
+    display patterns, such as multiple display calls.
+    """
+    print_method = ObjectName('_ipython_display_')
+    _return_type = (type(None), bool)
+
+    @catch_format_error
+    def __call__(self, obj):
+        """Compute the format for an object."""
+        if self.enabled:
+            # lookup registered printer
+            try:
+                printer = self.lookup(obj)
+            except KeyError:
+                pass
+            else:
+                printer(obj)
+                return True
+            # Finally look for special method names
+            method = get_real_method(obj, self.print_method)
+            if method is not None:
+                method()
+                return True
+
+
+class MimeBundleFormatter(BaseFormatter):
+    """A Formatter for arbitrary mime-types.
+
+    Unlike other `_repr_<mimetype>_` methods,
+    `_repr_mimebundle_` should return mime-bundle data,
+    either the mime-keyed `data` dictionary or the tuple `(data, metadata)`.
+    Any mime-type is valid.
+
+    To define the callables that compute the mime-bundle representation of your
+    objects, define a :meth:`_repr_mimebundle_` method or use the :meth:`for_type`
     or :meth:`for_type_by_name` methods to register functions that handle
     this.
+
+    .. versionadded:: 6.1
     """
-    format_type = Str('application/json')
+    print_method = ObjectName('_repr_mimebundle_')
+    _return_type = dict
+
+    def _check_return(self, r, obj):
+        r = super(MimeBundleFormatter, self)._check_return(r, obj)
+        # always return (data, metadata):
+        if r is None:
+            return {}, {}
+        if not isinstance(r, tuple):
+            return r, {}
+        return r
+
+    @catch_format_error
+    def __call__(self, obj, include=None, exclude=None):
+        """Compute the format for an object.
+
+        Identical to parent's method but we pass extra parameters to the method.
+
+        Unlike other _repr_*_ `_repr_mimebundle_` should allow extra kwargs, in
+        particular `include` and `exclude`.
+        """
+        if self.enabled:
+            # lookup registered printer
+            try:
+                printer = self.lookup(obj)
+            except KeyError:
+                pass
+            else:
+                return printer(obj)
+            # Finally look for special method names
+            method = get_real_method(obj, self.print_method)
 
-    print_method = Str('__json__')
+            if method is not None:
+                return method(include=include, exclude=exclude)
+            return None
+        else:
+            return None
 
 
 FormatterABC.register(BaseFormatter)
 FormatterABC.register(PlainTextFormatter)
 FormatterABC.register(HTMLFormatter)
+FormatterABC.register(MarkdownFormatter)
 FormatterABC.register(SVGFormatter)
 FormatterABC.register(PNGFormatter)
+FormatterABC.register(PDFFormatter)
+FormatterABC.register(JPEGFormatter)
 FormatterABC.register(LatexFormatter)
 FormatterABC.register(JSONFormatter)
+FormatterABC.register(JavascriptFormatter)
+FormatterABC.register(IPythonDisplayFormatter)
+FormatterABC.register(MimeBundleFormatter)
 
 
 def format_display_data(obj, include=None, exclude=None):
@@ -517,15 +1059,6 @@ def format_display_data(obj, include=None, exclude=None):
 
     By default all format types will be computed.
 
-    The following MIME types are currently implemented:
-
-    * text/plain
-    * text/html
-    * text/latex
-    * application/json
-    * image/png
-    * immage/svg+xml
-
     Parameters
     ----------
     obj : object
@@ -544,13 +1077,13 @@ def format_display_data(obj, include=None, exclude=None):
         format data dict. If this is set *only* the format types included
         in this list will be computed.
     exclude : list or tuple, optional
-        A list of format type string (MIME types) to exclue in the format
+        A list of format type string (MIME types) to exclude in the format
         data dict. If this is set all format types will be computed,
         except for those included in this argument.
     """
-    from IPython.core.interactiveshell import InteractiveShell
+    from .interactiveshell import InteractiveShell
 
-    InteractiveShell.instance().display_formatter.format(
+    return InteractiveShell.instance().display_formatter.format(
         obj,
         include,
         exclude
diff --git a/IPython/core/getipython.py b/IPython/core/getipython.py
new file mode 100644
index 00000000000..c7e112ba9f0
--- /dev/null
+++ b/IPython/core/getipython.py
@@ -0,0 +1,23 @@
+"""Simple function to call to get the current InteractiveShell instance
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2013  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+def get_ipython():
+    """Get the global InteractiveShell instance.
+
+    Returns None if no InteractiveShell instance is registered.
+    """
+    from IPython.core.interactiveshell import InteractiveShell
+    if InteractiveShell.initialized():
+        return InteractiveShell.instance()
diff --git a/IPython/core/guarded_eval.py b/IPython/core/guarded_eval.py
new file mode 100644
index 00000000000..10136d41601
--- /dev/null
+++ b/IPython/core/guarded_eval.py
@@ -0,0 +1,1653 @@
+from copy import copy
+from inspect import isclass, signature, Signature, getmodule
+from typing import (
+    Annotated,
+    AnyStr,
+    Literal,
+    NamedTuple,
+    NewType,
+    Optional,
+    Protocol,
+    TypeGuard,
+    Union,
+    get_args,
+    get_origin,
+    is_typeddict,
+)
+from collections.abc import Callable, Sequence
+import ast
+import builtins
+import collections
+import dataclasses
+import operator
+import sys
+import typing
+import warnings
+from functools import cached_property
+from dataclasses import dataclass, field
+from types import MethodDescriptorType, ModuleType, MethodType
+
+from IPython.utils.decorators import undoc
+
+import types
+from typing import Self, LiteralString, get_type_hints
+
+from typing import TypeAliasType
+
+
+@undoc
+class HasGetItem(Protocol):
+    def __getitem__(self, key) -> None:
+        ...
+
+
+@undoc
+class InstancesHaveGetItem(Protocol):
+    def __call__(self, *args, **kwargs) -> HasGetItem:
+        ...
+
+
+@undoc
+class HasGetAttr(Protocol):
+    def __getattr__(self, key) -> None:
+        ...
+
+
+@undoc
+class DoesNotHaveGetAttr(Protocol):
+    pass
+
+
+# By default `__getattr__` is not explicitly implemented on most objects
+MayHaveGetattr = Union[HasGetAttr, DoesNotHaveGetAttr]
+
+
+def _unbind_method(func: Callable) -> Union[Callable, None]:
+    """Get unbound method for given bound method.
+
+    Returns None if cannot get unbound method, or method is already unbound.
+    """
+    owner = getattr(func, "__self__", None)
+    owner_class = type(owner)
+    name = getattr(func, "__name__", None)
+    instance_dict_overrides = getattr(owner, "__dict__", None)
+    if (
+        owner is not None
+        and name
+        and (
+            not instance_dict_overrides
+            or (instance_dict_overrides and name not in instance_dict_overrides)
+        )
+    ):
+        return getattr(owner_class, name)
+    return None
+
+
+@undoc
+@dataclass
+class EvaluationPolicy:
+    """Definition of evaluation policy."""
+
+    allow_locals_access: bool = False
+    allow_globals_access: bool = False
+    allow_item_access: bool = False
+    allow_attr_access: bool = False
+    allow_builtins_access: bool = False
+    allow_all_operations: bool = False
+    allow_any_calls: bool = False
+    allow_auto_import: bool = False
+    allowed_calls: set[Callable] = field(default_factory=set)
+
+    def can_get_item(self, value, item):
+        return self.allow_item_access
+
+    def can_get_attr(self, value, attr):
+        return self.allow_attr_access
+
+    def can_operate(self, dunders: tuple[str, ...], a, b=None):
+        if self.allow_all_operations:
+            return True
+
+    def can_call(self, func):
+        if self.allow_any_calls:
+            return True
+
+        if func in self.allowed_calls:
+            return True
+
+        owner_method = _unbind_method(func)
+
+        if owner_method and owner_method in self.allowed_calls:
+            return True
+
+
+def _get_external(module_name: str, access_path: Sequence[str]):
+    """Get value from external module given a dotted access path.
+
+    Only gets value if the module is already imported.
+
+    Raises:
+    * `KeyError` if module is removed not found, and
+    * `AttributeError` if access path does not match an exported object
+    """
+    try:
+        member_type = sys.modules[module_name]
+        # standard module
+        for attr in access_path:
+            member_type = getattr(member_type, attr)
+        return member_type
+    except (KeyError, AttributeError):
+        # handle modules in namespace packages
+        module_path = ".".join([module_name, *access_path])
+        if module_path in sys.modules:
+            return sys.modules[module_path]
+        raise
+
+
+def _has_original_dunder_external(
+    value,
+    module_name: str,
+    access_path: Sequence[str],
+    method_name: str,
+):
+    if module_name not in sys.modules:
+        full_module_path = ".".join([module_name, *access_path])
+        if full_module_path not in sys.modules:
+            # LBYLB as it is faster
+            return False
+    try:
+        member_type = _get_external(module_name, access_path)
+        value_type = type(value)
+        if type(value) == member_type:
+            return True
+        if isinstance(member_type, ModuleType):
+            value_module = getmodule(value_type)
+            if not value_module or not value_module.__name__:
+                return False
+            if (
+                value_module.__name__ == member_type.__name__
+                or value_module.__name__.startswith(member_type.__name__ + ".")
+            ):
+                return True
+        if method_name == "__getattribute__":
+            # we have to short-circuit here due to an unresolved issue in
+            # `isinstance` implementation: https://bugs.python.org/issue32683
+            return False
+        if not isinstance(member_type, ModuleType) and isinstance(value, member_type):
+            method = getattr(value_type, method_name, None)
+            member_method = getattr(member_type, method_name, None)
+            if member_method == method:
+                return True
+        if isinstance(member_type, ModuleType):
+            method = getattr(value_type, method_name, None)
+            for base_class in value_type.__mro__[1:]:
+                base_module = getmodule(base_class)
+                if base_module and (
+                    base_module.__name__ == member_type.__name__
+                    or base_module.__name__.startswith(member_type.__name__ + ".")
+                ):
+                    # Check if the method comes from this trusted base class
+                    base_method = getattr(base_class, method_name, None)
+                    if base_method is not None and base_method == method:
+                        return True
+    except (AttributeError, KeyError):
+        return False
+
+
+def _has_original_dunder(
+    value, allowed_types, allowed_methods, allowed_external, method_name
+):
+    # note: Python ignores `__getattr__`/`__getitem__` on instances,
+    # we only need to check at class level
+    value_type = type(value)
+
+    # strict type check passes → no need to check method
+    if value_type in allowed_types:
+        return True
+
+    method = getattr(value_type, method_name, None)
+
+    if method is None:
+        return None
+
+    if method in allowed_methods:
+        return True
+
+    for module_name, *access_path in allowed_external:
+        if _has_original_dunder_external(value, module_name, access_path, method_name):
+            return True
+
+    return False
+
+
+def _coerce_path_to_tuples(
+    allow_list: set[tuple[str, ...] | str],
+) -> set[tuple[str, ...]]:
+    """Replace dotted paths on the provided allow-list with tuples."""
+    return {
+        path if isinstance(path, tuple) else tuple(path.split("."))
+        for path in allow_list
+    }
+
+
+@undoc
+@dataclass
+class SelectivePolicy(EvaluationPolicy):
+    allowed_getitem: set[InstancesHaveGetItem] = field(default_factory=set)
+    allowed_getitem_external: set[tuple[str, ...] | str] = field(default_factory=set)
+
+    allowed_getattr: set[MayHaveGetattr] = field(default_factory=set)
+    allowed_getattr_external: set[tuple[str, ...] | str] = field(default_factory=set)
+
+    allowed_operations: set = field(default_factory=set)
+    allowed_operations_external: set[tuple[str, ...] | str] = field(default_factory=set)
+
+    allow_getitem_on_types: bool = field(default_factory=bool)
+
+    _operation_methods_cache: dict[str, set[Callable]] = field(
+        default_factory=dict, init=False
+    )
+
+    def can_get_attr(self, value, attr):
+        allowed_getattr_external = _coerce_path_to_tuples(self.allowed_getattr_external)
+
+        has_original_attribute = _has_original_dunder(
+            value,
+            allowed_types=self.allowed_getattr,
+            allowed_methods=self._getattribute_methods,
+            allowed_external=allowed_getattr_external,
+            method_name="__getattribute__",
+        )
+        has_original_attr = _has_original_dunder(
+            value,
+            allowed_types=self.allowed_getattr,
+            allowed_methods=self._getattr_methods,
+            allowed_external=allowed_getattr_external,
+            method_name="__getattr__",
+        )
+
+        accept = False
+
+        # Many objects do not have `__getattr__`, this is fine.
+        if has_original_attr is None and has_original_attribute:
+            accept = True
+        else:
+            # Accept objects without modifications to `__getattr__` and `__getattribute__`
+            accept = has_original_attr and has_original_attribute
+
+        if accept:
+            # We still need to check for overridden properties.
+
+            value_class = type(value)
+            if not hasattr(value_class, attr):
+                return True
+
+            class_attr_val = getattr(value_class, attr)
+            is_property = isinstance(class_attr_val, property)
+
+            if not is_property:
+                return True
+
+            # Properties in allowed types are ok (although we do not include any
+            # properties in our default allow list currently).
+            if type(value) in self.allowed_getattr:
+                return True  # pragma: no cover
+
+            # Properties in subclasses of allowed types may be ok if not changed
+            for module_name, *access_path in allowed_getattr_external:
+                try:
+                    external_class = _get_external(module_name, access_path)
+                    external_class_attr_val = getattr(external_class, attr)
+                except (KeyError, AttributeError):
+                    return False  # pragma: no cover
+                return class_attr_val == external_class_attr_val
+
+        return False
+
+    def can_get_item(self, value, item):
+        """Allow accessing `__getiitem__` of allow-listed instances unless it was not modified."""
+        allowed_getitem_external = _coerce_path_to_tuples(self.allowed_getitem_external)
+        if self.allow_getitem_on_types:
+            # e.g. Union[str, int] or Literal[True, 1]
+            if isinstance(value, (typing._SpecialForm, typing._BaseGenericAlias)):
+                return True
+            # PEP 560 e.g. list[str]
+            if isinstance(value, type) and hasattr(value, "__class_getitem__"):
+                return True
+        return _has_original_dunder(
+            value,
+            allowed_types=self.allowed_getitem,
+            allowed_methods=self._getitem_methods,
+            allowed_external=allowed_getitem_external,
+            method_name="__getitem__",
+        )
+
+    def can_operate(self, dunders: tuple[str, ...], a, b=None):
+        allowed_operations_external = _coerce_path_to_tuples(
+            self.allowed_operations_external
+        )
+        objects = [a]
+        if b is not None:
+            objects.append(b)
+        return all(
+            [
+                _has_original_dunder(
+                    obj,
+                    allowed_types=self.allowed_operations,
+                    allowed_methods=self._operator_dunder_methods(dunder),
+                    allowed_external=allowed_operations_external,
+                    method_name=dunder,
+                )
+                for dunder in dunders
+                for obj in objects
+            ]
+        )
+
+    def _operator_dunder_methods(self, dunder: str) -> set[Callable]:
+        if dunder not in self._operation_methods_cache:
+            self._operation_methods_cache[dunder] = self._safe_get_methods(
+                self.allowed_operations, dunder
+            )
+        return self._operation_methods_cache[dunder]
+
+    @cached_property
+    def _getitem_methods(self) -> set[Callable]:
+        return self._safe_get_methods(self.allowed_getitem, "__getitem__")
+
+    @cached_property
+    def _getattr_methods(self) -> set[Callable]:
+        return self._safe_get_methods(self.allowed_getattr, "__getattr__")
+
+    @cached_property
+    def _getattribute_methods(self) -> set[Callable]:
+        return self._safe_get_methods(self.allowed_getattr, "__getattribute__")
+
+    def _safe_get_methods(self, classes, name) -> set[Callable]:
+        return {
+            method
+            for class_ in classes
+            for method in [getattr(class_, name, None)]
+            if method
+        }
+
+
+class _DummyNamedTuple(NamedTuple):
+    """Used internally to retrieve methods of named tuple instance."""
+
+
+EvaluationPolicyName = Literal["forbidden", "minimal", "limited", "unsafe", "dangerous"]
+
+
+@dataclass
+class EvaluationContext:
+    #: Local namespace
+    locals: dict
+    #: Global namespace
+    globals: dict
+    #: Evaluation policy identifier
+    evaluation: EvaluationPolicyName = "forbidden"
+    #: Whether the evaluation of code takes place inside of a subscript.
+    #: Useful for evaluating ``:-1, 'col'`` in ``df[:-1, 'col']``.
+    in_subscript: bool = False
+    #: Auto import method
+    auto_import: Callable[[Sequence[str]], ModuleType] | None = None
+    #: Overrides for evaluation policy
+    policy_overrides: dict = field(default_factory=dict)
+    #: Transient local namespace used to store mocks
+    transient_locals: dict = field(default_factory=dict)
+    #: Transients of class level
+    class_transients: dict | None = None
+    #: Instance variable name used in the method definition
+    instance_arg_name: str | None = None
+    #: Currently associated value
+    #: Useful for adding items to _Duck on annotated assignment
+    current_value: ast.AST | None = None
+
+    def replace(self, /, **changes):
+        """Return a new copy of the context, with specified changes"""
+        return dataclasses.replace(self, **changes)
+
+
+class _IdentitySubscript:
+    """Returns the key itself when item is requested via subscript."""
+
+    def __getitem__(self, key):
+        return key
+
+
+IDENTITY_SUBSCRIPT = _IdentitySubscript()
+SUBSCRIPT_MARKER = "__SUBSCRIPT_SENTINEL__"
+UNKNOWN_SIGNATURE = Signature()
+NOT_EVALUATED = object()
+
+
+class GuardRejection(Exception):
+    """Exception raised when guard rejects evaluation attempt."""
+
+    pass
+
+
+def guarded_eval(code: str, context: EvaluationContext):
+    """Evaluate provided code in the evaluation context.
+
+    If evaluation policy given by context is set to ``forbidden``
+    no evaluation will be performed; if it is set to ``dangerous``
+    standard :func:`eval` will be used; finally, for any other,
+    policy :func:`eval_node` will be called on parsed AST.
+    """
+    locals_ = context.locals
+
+    if context.evaluation == "forbidden":
+        raise GuardRejection("Forbidden mode")
+
+    # note: not using `ast.literal_eval` as it does not implement
+    # getitem at all, for example it fails on simple `[0][1]`
+
+    if context.in_subscript:
+        # syntactic sugar for ellipsis (:) is only available in subscripts
+        # so we need to trick the ast parser into thinking that we have
+        # a subscript, but we need to be able to later recognise that we did
+        # it so we can ignore the actual __getitem__ operation
+        if not code:
+            return tuple()
+        locals_ = locals_.copy()
+        locals_[SUBSCRIPT_MARKER] = IDENTITY_SUBSCRIPT
+        code = SUBSCRIPT_MARKER + "[" + code + "]"
+        context = context.replace(locals=locals_)
+
+    if context.evaluation == "dangerous":
+        return eval(code, context.globals, context.locals)
+
+    node = ast.parse(code, mode="exec")
+
+    return eval_node(node, context)
+
+
+BINARY_OP_DUNDERS: dict[type[ast.operator], tuple[str]] = {
+    ast.Add: ("__add__",),
+    ast.Sub: ("__sub__",),
+    ast.Mult: ("__mul__",),
+    ast.Div: ("__truediv__",),
+    ast.FloorDiv: ("__floordiv__",),
+    ast.Mod: ("__mod__",),
+    ast.Pow: ("__pow__",),
+    ast.LShift: ("__lshift__",),
+    ast.RShift: ("__rshift__",),
+    ast.BitOr: ("__or__",),
+    ast.BitXor: ("__xor__",),
+    ast.BitAnd: ("__and__",),
+    ast.MatMult: ("__matmul__",),
+}
+
+COMP_OP_DUNDERS: dict[type[ast.cmpop], tuple[str, ...]] = {
+    ast.Eq: ("__eq__",),
+    ast.NotEq: ("__ne__", "__eq__"),
+    ast.Lt: ("__lt__", "__gt__"),
+    ast.LtE: ("__le__", "__ge__"),
+    ast.Gt: ("__gt__", "__lt__"),
+    ast.GtE: ("__ge__", "__le__"),
+    ast.In: ("__contains__",),
+    # Note: ast.Is, ast.IsNot, ast.NotIn are handled specially
+}
+
+UNARY_OP_DUNDERS: dict[type[ast.unaryop], tuple[str, ...]] = {
+    ast.USub: ("__neg__",),
+    ast.UAdd: ("__pos__",),
+    # we have to check both __inv__ and __invert__!
+    ast.Invert: ("__invert__", "__inv__"),
+    ast.Not: ("__not__",),
+}
+
+GENERIC_CONTAINER_TYPES = (dict, list, set, tuple, frozenset)
+
+
+class ImpersonatingDuck:
+    """A dummy class used to create objects of other classes without calling their ``__init__``"""
+
+    # no-op: override __class__ to impersonate
+
+
+class _Duck:
+    """A dummy class used to create objects pretending to have given attributes"""
+
+    def __init__(self, attributes: Optional[dict] = None, items: Optional[dict] = None):
+        self.attributes = attributes if attributes is not None else {}
+        self.items = items if items is not None else {}
+
+    def __getattr__(self, attr: str):
+        return self.attributes[attr]
+
+    def __hasattr__(self, attr: str):
+        return attr in self.attributes
+
+    def __dir__(self):
+        return [*dir(super), *self.attributes]
+
+    def __getitem__(self, key: str):
+        return self.items[key]
+
+    def __hasitem__(self, key: str):
+        return self.items[key]
+
+    def _ipython_key_completions_(self):
+        return self.items.keys()
+
+
+def _find_dunder(node_op, dunders) -> Union[tuple[str, ...], None]:
+    dunder = None
+    for op, candidate_dunder in dunders.items():
+        if isinstance(node_op, op):
+            dunder = candidate_dunder
+    return dunder
+
+
+def get_policy(context: EvaluationContext) -> EvaluationPolicy:
+    policy = copy(EVALUATION_POLICIES[context.evaluation])
+
+    for key, value in context.policy_overrides.items():
+        if hasattr(policy, key):
+            setattr(policy, key, value)
+    return policy
+
+
+def _validate_policy_overrides(
+    policy_name: EvaluationPolicyName, policy_overrides: dict
+) -> bool:
+    policy = EVALUATION_POLICIES[policy_name]
+
+    all_good = True
+    for key, value in policy_overrides.items():
+        if not hasattr(policy, key):
+            warnings.warn(
+                f"Override {key!r} is not valid with {policy_name!r} evaluation policy"
+            )
+            all_good = False
+    return all_good
+
+
+def _is_type_annotation(obj) -> bool:
+    """
+    Returns True if obj is a type annotation, False otherwise.
+    """
+    if isinstance(obj, type):
+        return True
+    if isinstance(obj, types.GenericAlias):
+        return True
+    if hasattr(types, "UnionType") and isinstance(obj, types.UnionType):
+        return True
+    if isinstance(obj, (typing._SpecialForm, typing._BaseGenericAlias)):
+        return True
+    if isinstance(obj, typing.TypeVar):
+        return True
+    # Types that support __class_getitem__
+    if isinstance(obj, type) and hasattr(obj, "__class_getitem__"):
+        return True
+    # Fallback: check if get_origin returns something
+    if hasattr(typing, "get_origin") and get_origin(obj) is not None:
+        return True
+
+    return False
+
+
+def _handle_assign(node: ast.Assign, context: EvaluationContext):
+    value = eval_node(node.value, context)
+    transient_locals = context.transient_locals
+    policy = get_policy(context)
+    class_transients = context.class_transients
+    for target in node.targets:
+        if isinstance(target, (ast.Tuple, ast.List)):
+            # Handle unpacking assignment
+            values = list(value)
+            targets = target.elts
+            starred = [i for i, t in enumerate(targets) if isinstance(t, ast.Starred)]
+
+            # Unified handling: treat no starred as starred at end
+            star_or_last_idx = starred[0] if starred else len(targets)
+
+            # Before starred
+            for i in range(star_or_last_idx):
+                # Check for self.x assignment
+                if _is_instance_attribute_assignment(targets[i], context):
+                    class_transients[targets[i].attr] = values[i]
+                else:
+                    transient_locals[targets[i].id] = values[i]
+
+            # Starred if exists
+            if starred:
+                end = len(values) - (len(targets) - star_or_last_idx - 1)
+                if _is_instance_attribute_assignment(
+                    targets[star_or_last_idx], context
+                ):
+                    class_transients[targets[star_or_last_idx].attr] = values[
+                        star_or_last_idx:end
+                    ]
+                else:
+                    transient_locals[targets[star_or_last_idx].value.id] = values[
+                        star_or_last_idx:end
+                    ]
+
+                # After starred
+                for i in range(star_or_last_idx + 1, len(targets)):
+                    if _is_instance_attribute_assignment(targets[i], context):
+                        class_transients[targets[i].attr] = values[
+                            len(values) - (len(targets) - i)
+                        ]
+                    else:
+                        transient_locals[targets[i].id] = values[
+                            len(values) - (len(targets) - i)
+                        ]
+        elif isinstance(target, ast.Subscript):
+            if isinstance(target.value, ast.Name):
+                name = target.value.id
+                container = transient_locals.get(name)
+                if container is None:
+                    container = context.locals.get(name)
+                if container is None:
+                    container = context.globals.get(name)
+                if container is None:
+                    raise NameError(
+                        f"{name} not found in locals, globals, nor builtins"
+                    )
+                storage_dict = transient_locals
+                storage_key = name
+            elif isinstance(
+                target.value, ast.Attribute
+            ) and _is_instance_attribute_assignment(target.value, context):
+                attr = target.value.attr
+                container = class_transients.get(attr, None)
+                if container is None:
+                    raise NameError(f"{attr} not found in class transients")
+                storage_dict = class_transients
+                storage_key = attr
+            else:
+                return
+
+            key = eval_node(target.slice, context)
+            attributes = (
+                dict.fromkeys(dir(container))
+                if policy.can_call(container.__dir__)
+                else {}
+            )
+            items = {}
+
+            if policy.can_get_item(container, None):
+                try:
+                    items = dict(container.items())
+                except Exception:
+                    pass
+
+            items[key] = value
+            duck_container = _Duck(attributes=attributes, items=items)
+            storage_dict[storage_key] = duck_container
+        elif _is_instance_attribute_assignment(target, context):
+            class_transients[target.attr] = value
+        else:
+            transient_locals[target.id] = value
+    return None
+
+
+def _handle_annassign(node, context):
+    context_with_value = context.replace(current_value=getattr(node, "value", None))
+    annotation_result = eval_node(node.annotation, context_with_value)
+    if _is_type_annotation(annotation_result):
+        annotation_value = _resolve_annotation(annotation_result, context)
+        # Use Value for generic types
+        use_value = (
+            isinstance(annotation_value, GENERIC_CONTAINER_TYPES) and node.value is not None
+        )
+    else:
+        annotation_value = annotation_result
+        use_value = False
+
+    # LOCAL VARIABLE
+    if getattr(node, "simple", False) and isinstance(node.target, ast.Name):
+        name = node.target.id
+        if use_value:
+            return _handle_assign(
+                ast.Assign(targets=[node.target], value=node.value), context
+            )
+        context.transient_locals[name] = annotation_value
+        return None
+
+    # INSTANCE ATTRIBUTE
+    if _is_instance_attribute_assignment(node.target, context):
+        attr = node.target.attr
+        if use_value:
+            return _handle_assign(
+                ast.Assign(targets=[node.target], value=node.value), context
+            )
+        context.class_transients[attr] = annotation_value
+        return None
+
+    return None
+
+def _extract_args_and_kwargs(node: ast.Call, context: EvaluationContext):
+    args = [eval_node(arg, context) for arg in node.args]
+    kwargs = {
+        k: v
+        for kw in node.keywords
+        for k, v in (
+            {kw.arg: eval_node(kw.value, context)}
+            if kw.arg
+            else eval_node(kw.value, context)
+        ).items()
+    }
+    return args, kwargs
+
+
+def _is_instance_attribute_assignment(
+    target: ast.AST, context: EvaluationContext
+) -> bool:
+    """Return True if target is an attribute access on the instance argument."""
+    return (
+        context.class_transients is not None
+        and context.instance_arg_name is not None
+        and isinstance(target, ast.Attribute)
+        and isinstance(getattr(target, "value", None), ast.Name)
+        and getattr(target.value, "id", None) == context.instance_arg_name
+    )
+
+
+def _get_coroutine_attributes() -> dict[str, Optional[object]]:
+    async def _dummy():
+        return None
+
+    coro = _dummy()
+    try:
+        return {attr: getattr(coro, attr, None) for attr in dir(coro)}
+    finally:
+        coro.close()
+
+
+def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
+    """Evaluate AST node in provided context.
+
+    Applies evaluation restrictions defined in the context. Currently does not support evaluation of functions with keyword arguments.
+
+    Does not evaluate actions that always have side effects:
+
+    - class definitions (``class sth: ...``)
+    - function definitions (``def sth: ...``)
+    - variable assignments (``x = 1``)
+    - augmented assignments (``x += 1``)
+    - deletions (``del x``)
+
+    Does not evaluate operations which do not return values:
+
+    - assertions (``assert x``)
+    - pass (``pass``)
+    - imports (``import x``)
+    - control flow:
+
+        - conditionals (``if x:``) except for ternary IfExp (``a if x else b``)
+        - loops (``for`` and ``while``)
+        - exception handling
+
+    The purpose of this function is to guard against unwanted side-effects;
+    it does not give guarantees on protection from malicious code execution.
+    """
+    policy = get_policy(context)
+
+    if node is None:
+        return None
+    if isinstance(node, (ast.Interactive, ast.Module)):
+        result = None
+        for child_node in node.body:
+            result = eval_node(child_node, context)
+        return result
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        is_async = isinstance(node, ast.AsyncFunctionDef)
+        func_locals = context.transient_locals.copy()
+        func_context = context.replace(transient_locals=func_locals)
+        is_property = False
+        is_static = False
+        is_classmethod = False
+        for decorator_node in node.decorator_list:
+            try:
+                decorator = eval_node(decorator_node, context)
+            except NameError:
+                # if the decorator is not yet defined this is fine
+                # especialy because we don't handle imports yet
+                continue
+            if decorator is property:
+                is_property = True
+            elif decorator is staticmethod:
+                is_static = True
+            elif decorator is classmethod:
+                is_classmethod = True
+
+        if func_context.class_transients is not None:
+            if not is_static and not is_classmethod:
+                func_context.instance_arg_name = (
+                    node.args.args[0].arg if node.args.args else None
+                )
+
+        return_type = eval_node(node.returns, context=context)
+
+        for child_node in node.body:
+            eval_node(child_node, func_context)
+
+        if is_property:
+            if return_type is not None:
+                if _is_type_annotation(return_type):
+                    context.transient_locals[node.name] = _resolve_annotation(
+                        return_type, context
+                    )
+                else:
+                    context.transient_locals[node.name] = return_type
+            else:
+                return_value = _infer_return_value(node, func_context)
+                context.transient_locals[node.name] = return_value
+
+            return None
+
+        def dummy_function(*args, **kwargs):
+            pass
+
+        if return_type is not None:
+            if _is_type_annotation(return_type):
+                dummy_function.__annotations__["return"] = return_type
+            else:
+                dummy_function.__inferred_return__ = return_type
+        else:
+            inferred_return = _infer_return_value(node, func_context)
+            if inferred_return is not None:
+                dummy_function.__inferred_return__ = inferred_return
+
+        dummy_function.__name__ = node.name
+        dummy_function.__node__ = node
+        dummy_function.__is_async__ = is_async
+        context.transient_locals[node.name] = dummy_function
+        return None
+    if isinstance(node, ast.Lambda):
+
+        def dummy_function(*args, **kwargs):
+            pass
+
+        dummy_function.__inferred_return__ = eval_node(node.body, context)
+        return dummy_function
+    if isinstance(node, ast.ClassDef):
+        # TODO support class decorators?
+        class_locals = {}
+        outer_locals = context.locals.copy()
+        outer_locals.update(context.transient_locals)
+        class_context = context.replace(
+            transient_locals=class_locals, locals=outer_locals
+        )
+        class_context.class_transients = class_locals
+        for child_node in node.body:
+            eval_node(child_node, class_context)
+        bases = tuple([eval_node(base, context) for base in node.bases])
+        dummy_class = type(node.name, bases, class_locals)
+        context.transient_locals[node.name] = dummy_class
+        return None
+    if isinstance(node, ast.Await):
+        value = eval_node(node.value, context)
+        if hasattr(value, "__awaited_type__"):
+            return value.__awaited_type__
+        return value
+    if isinstance(node, ast.While):
+        loop_locals = context.transient_locals.copy()
+        loop_context = context.replace(transient_locals=loop_locals)
+
+        result = None
+        for stmt in node.body:
+            result = eval_node(stmt, loop_context)
+
+        policy = get_policy(context)
+        merged_locals = _merge_dicts_by_key(
+            [loop_locals, context.transient_locals.copy()], policy
+        )
+        context.transient_locals.update(merged_locals)
+
+        return result
+    if isinstance(node, ast.For):
+        try:
+            iterable = eval_node(node.iter, context)
+        except Exception:
+            iterable = None
+
+        sample = None
+        if iterable is not None:
+            try:
+                if policy.can_call(getattr(iterable, "__iter__", None)):
+                    sample = next(iter(iterable))
+            except Exception:
+                sample = None
+
+        loop_locals = context.transient_locals.copy()
+        loop_context = context.replace(transient_locals=loop_locals)
+
+        if sample is not None:
+            try:
+                fake_assign = ast.Assign(
+                    targets=[node.target], value=ast.Constant(value=sample)
+                )
+                _handle_assign(fake_assign, loop_context)
+            except Exception:
+                pass
+
+        result = None
+        for stmt in node.body:
+            result = eval_node(stmt, loop_context)
+
+        policy = get_policy(context)
+        merged_locals = _merge_dicts_by_key(
+            [loop_locals, context.transient_locals.copy()], policy
+        )
+        context.transient_locals.update(merged_locals)
+
+        return result
+    if isinstance(node, ast.If):
+        branches = []
+        current = node
+        result = None
+        while True:
+            branch_locals = context.transient_locals.copy()
+            branch_context = context.replace(transient_locals=branch_locals)
+            for stmt in current.body:
+                result = eval_node(stmt, branch_context)
+            branches.append(branch_locals)
+            if not current.orelse:
+                break
+            elif len(current.orelse) == 1 and isinstance(current.orelse[0], ast.If):
+                # It's an elif - continue loop
+                current = current.orelse[0]
+            else:
+                # It's an else block - process and break
+                else_locals = context.transient_locals.copy()
+                else_context = context.replace(transient_locals=else_locals)
+                for stmt in current.orelse:
+                    result = eval_node(stmt, else_context)
+                branches.append(else_locals)
+                break
+        branches.append(context.transient_locals.copy())
+        policy = get_policy(context)
+        merged_locals = _merge_dicts_by_key(branches, policy)
+        context.transient_locals.update(merged_locals)
+        return result
+    if isinstance(node, ast.Assign):
+        return _handle_assign(node, context)
+    if isinstance(node, ast.AnnAssign):
+        return _handle_annassign(node, context)
+    if isinstance(node, ast.Expression):
+        return eval_node(node.body, context)
+    if isinstance(node, ast.Expr):
+        return eval_node(node.value, context)
+    if isinstance(node, ast.Pass):
+        return None
+    if isinstance(node, ast.Import):
+        # TODO: populate transient_locals
+        return None
+    if isinstance(node, (ast.AugAssign, ast.Delete)):
+        return None
+    if isinstance(node, (ast.Global, ast.Nonlocal)):
+        return None
+    if isinstance(node, ast.BinOp):
+        left = eval_node(node.left, context)
+        right = eval_node(node.right, context)
+        if (
+            isinstance(node.op, ast.BitOr)
+            and _is_type_annotation(left)
+            and _is_type_annotation(right)
+        ):
+            left_duck = (
+                _Duck(dict.fromkeys(dir(left)))
+                if policy.can_call(left.__dir__)
+                else _Duck()
+            )
+            right_duck = (
+                _Duck(dict.fromkeys(dir(right)))
+                if policy.can_call(right.__dir__)
+                else _Duck()
+            )
+            value_node = context.current_value
+            if value_node is not None and isinstance(value_node, ast.Dict):
+                if dict in [left, right]:
+                    return _merge_values(
+                        [left_duck, right_duck, ast.literal_eval(value_node)],
+                        policy=get_policy(context),
+                    )
+            return _merge_values([left_duck, right_duck], policy=get_policy(context))
+        dunders = _find_dunder(node.op, BINARY_OP_DUNDERS)
+        if dunders:
+            if policy.can_operate(dunders, left, right):
+                return getattr(left, dunders[0])(right)
+            else:
+                raise GuardRejection(
+                    f"Operation (`{dunders}`) for",
+                    type(left),
+                    f"not allowed in {context.evaluation} mode",
+                )
+    if isinstance(node, ast.Compare):
+        left = eval_node(node.left, context)
+        all_true = True
+        negate = False
+        for op, right in zip(node.ops, node.comparators):
+            right = eval_node(right, context)
+            dunder = None
+            dunders = _find_dunder(op, COMP_OP_DUNDERS)
+            if not dunders:
+                if isinstance(op, ast.NotIn):
+                    dunders = COMP_OP_DUNDERS[ast.In]
+                    negate = True
+                if isinstance(op, ast.Is):
+                    dunder = "is_"
+                if isinstance(op, ast.IsNot):
+                    dunder = "is_"
+                    negate = True
+            if not dunder and dunders:
+                dunder = dunders[0]
+            if dunder:
+                a, b = (right, left) if dunder == "__contains__" else (left, right)
+                if dunder == "is_" or dunders and policy.can_operate(dunders, a, b):
+                    result = getattr(operator, dunder)(a, b)
+                    if negate:
+                        result = not result
+                    if not result:
+                        all_true = False
+                    left = right
+                else:
+                    raise GuardRejection(
+                        f"Comparison (`{dunder}`) for",
+                        type(left),
+                        f"not allowed in {context.evaluation} mode",
+                    )
+            else:
+                raise ValueError(
+                    f"Comparison `{dunder}` not supported"
+                )  # pragma: no cover
+        return all_true
+    if isinstance(node, ast.Constant):
+        return node.value
+    if isinstance(node, ast.Tuple):
+        return tuple(eval_node(e, context) for e in node.elts)
+    if isinstance(node, ast.List):
+        return [eval_node(e, context) for e in node.elts]
+    if isinstance(node, ast.Set):
+        return {eval_node(e, context) for e in node.elts}
+    if isinstance(node, ast.Dict):
+        return dict(
+            zip(
+                [eval_node(k, context) for k in node.keys],
+                [eval_node(v, context) for v in node.values],
+            )
+        )
+    if isinstance(node, ast.Slice):
+        return slice(
+            eval_node(node.lower, context),
+            eval_node(node.upper, context),
+            eval_node(node.step, context),
+        )
+    if isinstance(node, ast.UnaryOp):
+        value = eval_node(node.operand, context)
+        dunders = _find_dunder(node.op, UNARY_OP_DUNDERS)
+        if dunders:
+            if policy.can_operate(dunders, value):
+                try:
+                    return getattr(value, dunders[0])()
+                except AttributeError:
+                    raise TypeError(
+                        f"bad operand type for unary {node.op}: {type(value)}"
+                    )
+            else:
+                raise GuardRejection(
+                    f"Operation (`{dunders}`) for",
+                    type(value),
+                    f"not allowed in {context.evaluation} mode",
+                )
+    if isinstance(node, ast.Subscript):
+        value = eval_node(node.value, context)
+        slice_ = eval_node(node.slice, context)
+        if policy.can_get_item(value, slice_):
+            return value[slice_]
+        raise GuardRejection(
+            "Subscript access (`__getitem__`) for",
+            type(value),  # not joined to avoid calling `repr`
+            f" not allowed in {context.evaluation} mode",
+        )
+    if isinstance(node, ast.Name):
+        return _eval_node_name(node.id, context)
+    if isinstance(node, ast.Attribute):
+        if (
+            context.class_transients is not None
+            and isinstance(node.value, ast.Name)
+            and node.value.id == context.instance_arg_name
+        ):
+            return context.class_transients.get(node.attr)
+        value = eval_node(node.value, context)
+        if policy.can_get_attr(value, node.attr):
+            return getattr(value, node.attr)
+        try:
+            cls = (
+                value if isinstance(value, type) else getattr(value, "__class__", None)
+            )
+            if cls is not None:
+                resolved_hints = get_type_hints(
+                    cls,
+                    globalns=(context.globals or {}),
+                    localns=(context.locals or {}),
+                )
+                if node.attr in resolved_hints:
+                    annotated = resolved_hints[node.attr]
+                    return _resolve_annotation(annotated, context)
+        except Exception:
+            # Fall through to the guard rejection
+            pass
+        raise GuardRejection(
+            "Attribute access (`__getattr__`) for",
+            type(value),  # not joined to avoid calling `repr`
+            f"not allowed in {context.evaluation} mode",
+        )
+    if isinstance(node, ast.IfExp):
+        test = eval_node(node.test, context)
+        if test:
+            return eval_node(node.body, context)
+        else:
+            return eval_node(node.orelse, context)
+    if isinstance(node, ast.Call):
+        func = eval_node(node.func, context)
+        if policy.can_call(func):
+            args, kwargs = _extract_args_and_kwargs(node, context)
+            return func(*args, **kwargs)
+        if isclass(func):
+            # this code path gets entered when calling class e.g. `MyClass()`
+            # or `my_instance.__class__()` - in both cases `func` is `MyClass`.
+            # Should return `MyClass` if `__new__` is not overridden,
+            # otherwise whatever `__new__` return type is.
+            overridden_return_type = _eval_return_type(func.__new__, node, context)
+            if overridden_return_type is not NOT_EVALUATED:
+                return overridden_return_type
+            return _create_duck_for_heap_type(func)
+        else:
+            inferred_return = getattr(func, "__inferred_return__", NOT_EVALUATED)
+            return_type = _eval_return_type(func, node, context)
+            if getattr(func, "__is_async__", False):
+                awaited_type = (
+                    inferred_return if inferred_return is not None else return_type
+                )
+                coroutine_duck = _Duck(attributes=_get_coroutine_attributes())
+                coroutine_duck.__awaited_type__ = awaited_type
+                return coroutine_duck
+            if inferred_return is not NOT_EVALUATED:
+                return inferred_return
+            if return_type is not NOT_EVALUATED:
+                return return_type
+        raise GuardRejection(
+            "Call for",
+            func,  # not joined to avoid calling `repr`
+            f"not allowed in {context.evaluation} mode",
+        )
+    if isinstance(node, ast.Assert):
+        # message is always the second item, so if it is defined user would be completing
+        # on the message, not on the assertion test
+        if node.msg:
+            return eval_node(node.msg, context)
+        return eval_node(node.test, context)
+    return None
+
+
+def _merge_dicts_by_key(dicts: list, policy: EvaluationPolicy):
+    """Merge multiple dictionaries, combining values for each key."""
+    if len(dicts) == 1:
+        return dicts[0]
+
+    all_keys = set()
+    for d in dicts:
+        all_keys.update(d.keys())
+
+    merged = {}
+    for key in all_keys:
+        values = [d[key] for d in dicts if key in d]
+        if values:
+            merged[key] = _merge_values(values, policy)
+
+    return merged
+
+
+def _merge_values(values, policy: EvaluationPolicy):
+    """Recursively merge multiple values, combining attributes and dict items."""
+    if len(values) == 1:
+        return values[0]
+
+    types = {type(v) for v in values}
+    merged_items = None
+    key_values = {}
+    attributes = set()
+    for v in values:
+        if policy.can_call(v.__dir__):
+            attributes.update(dir(v))
+        try:
+            if policy.can_call(v.items):
+                try:
+                    for k, val in v.items():
+                        key_values.setdefault(k, []).append(val)
+                except Exception as e:
+                    pass
+            elif policy.can_call(v.keys):
+                try:
+                    for k in v.keys():
+                        key_values.setdefault(k, []).append(None)
+                except Exception as e:
+                    pass
+        except Exception as e:
+            pass
+
+    if key_values:
+        merged_items = {
+            k: _merge_values(vals, policy) if vals[0] is not None else None
+            for k, vals in key_values.items()
+        }
+
+    if len(types) == 1:
+        t = next(iter(types))
+        if t not in (dict,) and not (
+            hasattr(next(iter(values)), "__getitem__")
+            and (
+                hasattr(next(iter(values)), "items")
+                or hasattr(next(iter(values)), "keys")
+            )
+        ):
+            if t in (list, set, tuple):
+                return t
+            return values[0]
+
+    return _Duck(attributes=dict.fromkeys(attributes), items=merged_items)
+
+
+def _infer_return_value(node: ast.FunctionDef, context: EvaluationContext):
+    """Infer the return value(s) of a function by evaluating all return statements."""
+    return_values = _collect_return_values(node.body, context)
+
+    if not return_values:
+        return None
+    if len(return_values) == 1:
+        return return_values[0]
+
+    policy = get_policy(context)
+    return _merge_values(return_values, policy)
+
+
+def _collect_return_values(body, context):
+    """Recursively collect return values from a list of AST statements."""
+    return_values = []
+    for stmt in body:
+        if isinstance(stmt, ast.Return):
+            if stmt.value is None:
+                continue
+            try:
+                value = eval_node(stmt.value, context)
+                if value is not None and value is not NOT_EVALUATED:
+                    return_values.append(value)
+            except Exception:
+                pass
+        if isinstance(
+            stmt, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)
+        ):
+            continue
+        elif hasattr(stmt, "body") and isinstance(stmt.body, list):
+            return_values.extend(_collect_return_values(stmt.body, context))
+        if isinstance(stmt, ast.Try):
+            for h in stmt.handlers:
+                if hasattr(h, "body"):
+                    return_values.extend(_collect_return_values(h.body, context))
+            if hasattr(stmt, "orelse"):
+                return_values.extend(_collect_return_values(stmt.orelse, context))
+            if hasattr(stmt, "finalbody"):
+                return_values.extend(_collect_return_values(stmt.finalbody, context))
+        if hasattr(stmt, "orelse") and isinstance(stmt.orelse, list):
+            return_values.extend(_collect_return_values(stmt.orelse, context))
+    return return_values
+
+
+def _eval_return_type(func: Callable, node: ast.Call, context: EvaluationContext):
+    """Evaluate return type of a given callable function.
+
+    Returns the built-in type, a duck or NOT_EVALUATED sentinel.
+    """
+    try:
+        sig = signature(func)
+    except ValueError:
+        sig = UNKNOWN_SIGNATURE
+    # if annotation was not stringized, or it was stringized
+    # but resolved by signature call we know the return type
+    not_empty = sig.return_annotation is not Signature.empty
+    if not_empty:
+        return _resolve_annotation(sig.return_annotation, context, sig, func, node)
+    return NOT_EVALUATED
+
+
+def _eval_annotation(
+    annotation: str,
+    context: EvaluationContext,
+):
+    return (
+        _eval_node_name(annotation, context)
+        if isinstance(annotation, str)
+        else annotation
+    )
+
+
+class _GetItemDuck(dict):
+    """A dict subclass that always returns the factory instance and claims to have any item."""
+
+    def __init__(self, factory, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._factory = factory
+
+    def __getitem__(self, key):
+        return self._factory()
+
+    def __contains__(self, key):
+        return True
+
+
+def _resolve_annotation(
+    annotation: object | str,
+    context: EvaluationContext,
+    sig: Signature | None = None,
+    func: Callable | None = None,
+    node: ast.Call | None = None,
+):
+    """Resolve annotation created by user with `typing` module and custom objects."""
+    if annotation is None:
+        return None
+    annotation = _eval_annotation(annotation, context)
+    origin = get_origin(annotation)
+    if annotation is Self and func and hasattr(func, "__self__"):
+        return func.__self__
+    elif origin is Literal:
+        type_args = get_args(annotation)
+        if len(type_args) == 1:
+            return type_args[0]
+    elif annotation is LiteralString:
+        return ""
+    elif annotation is AnyStr:
+        index = None
+        if func and hasattr(func, "__node__"):
+            def_node = func.__node__
+            for i, arg in enumerate(def_node.args.args):
+                if not arg.annotation:
+                    continue
+                annotation = _eval_annotation(arg.annotation.id, context)
+                if annotation is AnyStr:
+                    index = i
+                    break
+            is_bound_method = (
+                isinstance(func, MethodType) and getattr(func, "__self__") is not None
+            )
+            if index and is_bound_method:
+                index -= 1
+        elif sig:
+            for i, (key, value) in enumerate(sig.parameters.items()):
+                if value.annotation is AnyStr:
+                    index = i
+                    break
+        if index is None:
+            return None
+        if index < 0 or index >= len(node.args):
+            return None
+        return eval_node(node.args[index], context)
+    elif origin is TypeGuard:
+        return False
+    elif origin is set or origin is list:
+        # only one type argument allowed
+        attributes = [
+            attr
+            for attr in dir(
+                _resolve_annotation(get_args(annotation)[0], context, sig, func, node)
+            )
+        ]
+        duck = _Duck(attributes=dict.fromkeys(attributes))
+        return _Duck(
+            attributes=dict.fromkeys(dir(origin())),
+            # items are not strrictly needed for set
+            items=_GetItemDuck(lambda: duck),
+        )
+    elif origin is tuple:
+        # multiple type arguments
+        return tuple(
+            _resolve_annotation(arg, context, sig, func, node)
+            for arg in get_args(annotation)
+        )
+    elif origin is Union:
+        # multiple type arguments
+        attributes = [
+            attr
+            for type_arg in get_args(annotation)
+            for attr in dir(_resolve_annotation(type_arg, context, sig, func, node))
+        ]
+        return _Duck(attributes=dict.fromkeys(attributes))
+    elif is_typeddict(annotation):
+        return _Duck(
+            attributes=dict.fromkeys(dir(dict())),
+            items={
+                k: _resolve_annotation(v, context, sig, func, node)
+                for k, v in annotation.__annotations__.items()
+            },
+        )
+    elif hasattr(annotation, "_is_protocol"):
+        return _Duck(attributes=dict.fromkeys(dir(annotation)))
+    elif origin is Annotated:
+        type_arg = get_args(annotation)[0]
+        return _resolve_annotation(type_arg, context, sig, func, node)
+    elif isinstance(annotation, NewType):
+        return _eval_or_create_duck(annotation.__supertype__, context)
+    elif isinstance(annotation, TypeAliasType):
+        return _eval_or_create_duck(annotation.__value__, context)
+    else:
+        return _eval_or_create_duck(annotation, context)
+
+
+def _eval_node_name(node_id: str, context: EvaluationContext):
+    policy = get_policy(context)
+    if node_id in context.transient_locals:
+        return context.transient_locals[node_id]
+    if policy.allow_locals_access and node_id in context.locals:
+        return context.locals[node_id]
+    if policy.allow_globals_access and node_id in context.globals:
+        return context.globals[node_id]
+    if policy.allow_builtins_access and hasattr(builtins, node_id):
+        # note: do not use __builtins__, it is implementation detail of cPython
+        return getattr(builtins, node_id)
+    if policy.allow_auto_import and context.auto_import:
+        return context.auto_import(node_id)
+    if not policy.allow_globals_access and not policy.allow_locals_access:
+        raise GuardRejection(
+            f"Namespace access not allowed in {context.evaluation} mode"
+        )
+    else:
+        raise NameError(f"{node_id} not found in locals, globals, nor builtins")
+
+
+def _eval_or_create_duck(duck_type, context: EvaluationContext):
+    policy = get_policy(context)
+    # if allow-listed builtin is on type annotation, instantiate it
+    if policy.can_call(duck_type):
+        return duck_type()
+    # if custom class is in type annotation, mock it
+    return _create_duck_for_heap_type(duck_type)
+
+
+def _create_duck_for_heap_type(duck_type):
+    """Create an imitation of an object of a given type (a duck).
+
+    Returns the duck or NOT_EVALUATED sentinel if duck could not be created.
+    """
+    duck = ImpersonatingDuck()
+    try:
+        # this only works for heap types, not builtins
+        duck.__class__ = duck_type
+        return duck
+    except TypeError:
+        pass
+    return NOT_EVALUATED
+
+
+SUPPORTED_EXTERNAL_GETITEM = {
+    ("pandas", "core", "indexing", "_iLocIndexer"),
+    ("pandas", "core", "indexing", "_LocIndexer"),
+    ("pandas", "DataFrame"),
+    ("pandas", "Series"),
+    ("numpy", "ndarray"),
+    ("numpy", "void"),
+}
+
+
+BUILTIN_GETITEM: set[InstancesHaveGetItem] = {
+    dict,
+    str,  # type: ignore[arg-type]
+    bytes,  # type: ignore[arg-type]
+    list,
+    tuple,
+    type,  # for type annotations like list[str]
+    _Duck,
+    collections.defaultdict,
+    collections.deque,
+    collections.OrderedDict,
+    collections.ChainMap,
+    collections.UserDict,
+    collections.UserList,
+    collections.UserString,  # type: ignore[arg-type]
+    _DummyNamedTuple,
+    _IdentitySubscript,
+}
+
+
+def _list_methods(cls, source=None):
+    """For use on immutable objects or with methods returning a copy"""
+    return [getattr(cls, k) for k in (source if source else dir(cls))]
+
+
+dict_non_mutating_methods = ("copy", "keys", "values", "items")
+list_non_mutating_methods = ("copy", "index", "count")
+set_non_mutating_methods = set(dir(set)) & set(dir(frozenset))
+
+
+dict_keys: type[collections.abc.KeysView] = type({}.keys())
+dict_values: type = type({}.values())
+dict_items: type = type({}.items())
+
+NUMERICS = {int, float, complex}
+
+ALLOWED_CALLS = {
+    bytes,
+    *_list_methods(bytes),
+    bytes.__iter__,
+    dict,
+    *_list_methods(dict, dict_non_mutating_methods),
+    dict.__iter__,
+    dict_keys.__iter__,
+    dict_values.__iter__,
+    dict_items.__iter__,
+    dict_keys.isdisjoint,
+    list,
+    *_list_methods(list, list_non_mutating_methods),
+    list.__iter__,
+    set,
+    *_list_methods(set, set_non_mutating_methods),
+    set.__iter__,
+    frozenset,
+    *_list_methods(frozenset),
+    frozenset.__iter__,
+    range,
+    range.__iter__,
+    str,
+    *_list_methods(str),
+    str.__iter__,
+    tuple,
+    *_list_methods(tuple),
+    tuple.__iter__,
+    bool,
+    *_list_methods(bool),
+    *NUMERICS,
+    *[method for numeric_cls in NUMERICS for method in _list_methods(numeric_cls)],
+    collections.deque,
+    *_list_methods(collections.deque, list_non_mutating_methods),
+    collections.deque.__iter__,
+    collections.defaultdict,
+    *_list_methods(collections.defaultdict, dict_non_mutating_methods),
+    collections.defaultdict.__iter__,
+    collections.OrderedDict,
+    *_list_methods(collections.OrderedDict, dict_non_mutating_methods),
+    collections.OrderedDict.__iter__,
+    collections.UserDict,
+    *_list_methods(collections.UserDict, dict_non_mutating_methods),
+    collections.UserDict.__iter__,
+    collections.UserList,
+    *_list_methods(collections.UserList, list_non_mutating_methods),
+    collections.UserList.__iter__,
+    collections.UserString,
+    *_list_methods(collections.UserString, dir(str)),
+    collections.UserString.__iter__,
+    collections.Counter,
+    *_list_methods(collections.Counter, dict_non_mutating_methods),
+    collections.Counter.__iter__,
+    collections.Counter.elements,
+    collections.Counter.most_common,
+    object.__dir__,
+    type.__dir__,
+    _Duck.__dir__,
+}
+
+BUILTIN_GETATTR: set[MayHaveGetattr] = {
+    *BUILTIN_GETITEM,
+    set,
+    frozenset,
+    object,
+    type,  # `type` handles a lot of generic cases, e.g. numbers as in `int.real`.
+    *NUMERICS,
+    dict_keys,
+    MethodDescriptorType,
+    ModuleType,
+}
+
+
+BUILTIN_OPERATIONS = {*BUILTIN_GETATTR}
+
+EVALUATION_POLICIES = {
+    "minimal": EvaluationPolicy(
+        allow_builtins_access=True,
+        allow_locals_access=False,
+        allow_globals_access=False,
+        allow_item_access=False,
+        allow_attr_access=False,
+        allowed_calls=set(),
+        allow_any_calls=False,
+        allow_all_operations=False,
+    ),
+    "limited": SelectivePolicy(
+        allowed_getitem=BUILTIN_GETITEM,
+        allowed_getitem_external=SUPPORTED_EXTERNAL_GETITEM,
+        allowed_getattr=BUILTIN_GETATTR,
+        allowed_getattr_external={
+            # pandas Series/Frame implements custom `__getattr__`
+            ("pandas", "DataFrame"),
+            ("pandas", "Series"),
+        },
+        allowed_operations=BUILTIN_OPERATIONS,
+        allow_builtins_access=True,
+        allow_locals_access=True,
+        allow_globals_access=True,
+        allow_getitem_on_types=True,
+        allowed_calls=ALLOWED_CALLS,
+    ),
+    "unsafe": EvaluationPolicy(
+        allow_builtins_access=True,
+        allow_locals_access=True,
+        allow_globals_access=True,
+        allow_attr_access=True,
+        allow_item_access=True,
+        allow_any_calls=True,
+        allow_all_operations=True,
+    ),
+}
+
+
+__all__ = [
+    "guarded_eval",
+    "eval_node",
+    "GuardRejection",
+    "EvaluationContext",
+    "_unbind_method",
+]
diff --git a/IPython/core/history.py b/IPython/core/history.py
index 2c1e1babd06..b06111f8e93 100644
--- a/IPython/core/history.py
+++ b/IPython/core/history.py
@@ -1,53 +1,622 @@
-""" History related magics and functionality """
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010 The IPython Development Team.
-#
-#  Distributed under the terms of the BSD License.
-#
-#  The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Stdlib imports
+"""History related magics and functionality"""
+
+from __future__ import annotations
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
 import atexit
 import datetime
 import os
 import re
-import sqlite3
+
+
 import threading
+from pathlib import Path
+
+from collections import defaultdict
+from contextlib import contextmanager
+from dataclasses import dataclass
+from decorator import decorator
+from traitlets import (
+    Any,
+    Bool,
+    Dict,
+    Instance,
+    Integer,
+    List,
+    TraitError,
+    Unicode,
+    Union,
+    default,
+    observe,
+)
+from traitlets.config.configurable import LoggingConfigurable
+
+from IPython.paths import locate_profile
+from IPython.utils.decorators import undoc
+from typing import Tuple, Optional, TYPE_CHECKING
+from collections.abc import Iterable
+import typing
+import typing as t
+from typing import cast
+from warnings import warn
+from weakref import ref, WeakSet
+
+if TYPE_CHECKING:
+    from IPython.core.interactiveshell import InteractiveShell
+    from IPython.config.Configuration import Configuration
+
+try:
+    from sqlite3 import DatabaseError, OperationalError
+    import sqlite3
+
+    sqlite3.register_converter(
+        "timestamp", lambda val: datetime.datetime.fromisoformat(val.decode())
+    )
+
+    sqlite3_found = True
+except ModuleNotFoundError:
+    sqlite3_found = False
 
-# Our own packages
-from IPython.config.configurable import Configurable
+    class DatabaseError(Exception):  # type: ignore [no-redef]
+        pass
 
-from IPython.testing import decorators as testdec
-from IPython.utils import io
-from IPython.utils.traitlets import Bool, Dict, Instance, Int, List, Unicode
-from IPython.utils.warn import warn
+    class OperationalError(Exception):  # type: ignore [no-redef]
+        pass
 
-#-----------------------------------------------------------------------------
+
+InOrInOut = typing.Union[str, tuple[str, Optional[str]]]
+
+# -----------------------------------------------------------------------------
 # Classes and functions
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
+
+@undoc
+class DummyDB:
+    """Dummy DB that will act as a black hole for history.
+
+    Only used in the absence of sqlite"""
+
+    def execute(*args: typing.Any, **kwargs: typing.Any) -> list:
+        return []
+
+    def commit(self, *args, **kwargs):  # type: ignore [no-untyped-def]
+        pass
+
+    def __enter__(self, *args, **kwargs):  # type: ignore [no-untyped-def]
+        pass
+
+    def __exit__(self, *args, **kwargs):  # type: ignore [no-untyped-def]
+        pass
+
+
+@decorator
+def only_when_enabled(f, self, *a, **kw):  # type: ignore [no-untyped-def]
+    """Decorator: return an empty list in the absence of sqlite."""
+    if not self.enabled:
+        return []
+    else:
+        return f(self, *a, **kw)
 
-class HistoryManager(Configurable):
-    """A class to organize all history-related functionality in one place.
+
+# use 16kB as threshold for whether a corrupt history db should be saved
+# that should be at least 100 entries or so
+_SAVE_DB_SIZE = 16384
+
+
+@decorator
+def catch_corrupt_db(f, self, *a, **kw):  # type: ignore [no-untyped-def]
+    """A decorator which wraps HistoryAccessor method calls to catch errors from
+    a corrupt SQLite database, move the old database out of the way, and create
+    a new one.
+
+    We avoid clobbering larger databases because this may be triggered due to filesystem issues,
+    not just a corrupt file.
     """
+    try:
+        return f(self, *a, **kw)
+    except (DatabaseError, OperationalError) as e:
+        self._corrupt_db_counter += 1
+        self.log.error("Failed to open SQLite history %s (%s).", self.hist_file, e)
+        if self.hist_file != ":memory:":
+            if self._corrupt_db_counter > self._corrupt_db_limit:
+                self.hist_file = ":memory:"
+                self.log.error(
+                    "Failed to load history too many times, history will not be saved."
+                )
+            elif self.hist_file.is_file():
+                # move the file out of the way
+                base = str(self.hist_file.parent / self.hist_file.stem)
+                ext = self.hist_file.suffix
+                size = self.hist_file.stat().st_size
+                if size >= _SAVE_DB_SIZE:
+                    # if there's significant content, avoid clobbering
+                    now = (
+                        datetime.datetime.now(datetime.timezone.utc)
+                        .isoformat()
+                        .replace(":", ".")
+                    )
+                    newpath = base + "-corrupt-" + now + ext
+                    # don't clobber previous corrupt backups
+                    for i in range(100):
+                        if not Path(newpath).exists():
+                            break
+                        else:
+                            newpath = base + "-corrupt-" + now + ("-%i" % i) + ext
+                else:
+                    # not much content, possibly empty; don't worry about clobbering
+                    # maybe we should just delete it?
+                    newpath = base + "-corrupt" + ext
+                self.hist_file.rename(newpath)
+                self.log.error(
+                    "History file was moved to %s and a new file created.", newpath
+                )
+            self.init_db()
+            return []
+        else:
+            # Failed with :memory:, something serious is wrong
+            raise
+
+
+class HistoryAccessorBase(LoggingConfigurable):
+    """An abstract class for History Accessors"""
+
+    def get_tail(
+        self,
+        n: int = 10,
+        raw: bool = True,
+        output: bool = False,
+        include_latest: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        raise NotImplementedError
+
+    def search(
+        self,
+        pattern: str = "*",
+        raw: bool = True,
+        search_raw: bool = True,
+        output: bool = False,
+        n: Optional[int] = None,
+        unique: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        raise NotImplementedError
+
+    def get_range(
+        self,
+        session: int,
+        start: int = 1,
+        stop: Optional[int] = None,
+        raw: bool = True,
+        output: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        raise NotImplementedError
+
+    def get_range_by_str(
+        self, rangestr: str, raw: bool = True, output: bool = False
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        raise NotImplementedError
+
+
+class HistoryAccessor(HistoryAccessorBase):
+    """Access the history database without adding to it.
+
+    This is intended for use by standalone history tools. IPython shells use
+    HistoryManager, below, which is a subclass of this."""
+
+    # counter for init_db retries, so we don't keep trying over and over
+    _corrupt_db_counter = 0
+    # after two failures, fallback on :memory:
+    _corrupt_db_limit = 2
+
+    # String holding the path to the history file
+    hist_file = Union(
+        [Instance(Path), Unicode()],
+        help="""Path to file to use for SQLite history database.
+
+        By default, IPython will put the history database in the IPython
+        profile directory.  If you would rather share one history among
+        profiles, you can set this value in each, so that they are consistent.
+
+        Due to an issue with fcntl, SQLite is known to misbehave on some NFS
+        mounts.  If you see IPython hanging, try setting this to something on a
+        local disk, e.g::
+
+            ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite
+
+        you can also use the specific value `:memory:` (including the colon
+        at both end but not the back ticks), to avoid creating an history file.
+
+        """,
+    ).tag(config=True)
+
+    enabled = Bool(
+        sqlite3_found,
+        help="""enable the SQLite history
+
+        set enabled=False to disable the SQLite history,
+        in which case there will be no stored history, no SQLite connection,
+        and no background saving thread.  This may be necessary in some
+        threaded environments where IPython is embedded.
+        """,
+    ).tag(config=True)
+
+    connection_options = Dict(
+        help="""Options for configuring the SQLite connection
+
+        These options are passed as keyword args to sqlite3.connect
+        when establishing database connections.
+        """
+    ).tag(config=True)
+
+    @default("connection_options")
+    def _default_connection_options(self) -> dict[str, bool]:
+        return dict(check_same_thread=False)
+
+    # The SQLite database
+    db = Any()
+
+    @observe("db")
+    @only_when_enabled
+    def _db_changed(self, change):  # type: ignore [no-untyped-def]
+        """validate the db, since it can be an Instance of two different types"""
+        new = change["new"]
+        connection_types = (DummyDB, sqlite3.Connection)
+        if not isinstance(new, connection_types):
+            msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % (
+                self.__class__.__name__,
+                new,
+            )
+            raise TraitError(msg)
+
+    def __init__(
+        self, profile: str = "default", hist_file: str = "", **traits: typing.Any
+    ) -> None:
+        """Create a new history accessor.
+
+        Parameters
+        ----------
+        profile : str
+            The name of the profile from which to open history.
+        hist_file : str
+            Path to an SQLite history database stored by IPython. If specified,
+            hist_file overrides profile.
+        config : :class:`~traitlets.config.loader.Config`
+            Config object. hist_file can also be set through this.
+        """
+        super(HistoryAccessor, self).__init__(**traits)
+        # defer setting hist_file from kwarg until after init,
+        # otherwise the default kwarg value would clobber any value
+        # set by config
+        if hist_file:
+            self.hist_file = hist_file
+
+        try:
+            self.hist_file
+        except TraitError:
+            # No one has set the hist_file, yet.
+            self.hist_file = self._get_hist_file_name(profile)
+
+        self.init_db()
+
+    def _get_hist_file_name(self, profile: str = "default") -> Path:
+        """Find the history file for the given profile name.
+
+        This is overridden by the HistoryManager subclass, to use the shell's
+        active profile.
+
+        Parameters
+        ----------
+        profile : str
+            The name of a profile which has a history file.
+        """
+        return Path(locate_profile(profile)) / "history.sqlite"
+
+    @catch_corrupt_db
+    def init_db(self) -> None:
+        """Connect to the database, and create tables if necessary."""
+        if not self.enabled:
+            self.db = DummyDB()
+            return
+
+        # use detect_types so that timestamps return datetime objects
+        kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
+        kwargs.update(self.connection_options)
+        self.db = sqlite3.connect(str(self.hist_file), **kwargs)  # type: ignore [call-overload]
+        with self.db:
+            self.db.execute(
+                """CREATE TABLE IF NOT EXISTS sessions (session integer
+                            primary key autoincrement, start timestamp,
+                            end timestamp, num_cmds integer, remark text)"""
+            )
+            self.db.execute(
+                """CREATE TABLE IF NOT EXISTS history
+                    (session integer, line integer, source text, source_raw text,
+                    PRIMARY KEY (session, line))"""
+            )
+            # Output history is optional, but ensure the table's there so it can be
+            # enabled later.
+            self.db.execute(
+                """CREATE TABLE IF NOT EXISTS output_history
+                            (session integer, line integer, output text,
+                            PRIMARY KEY (session, line))"""
+            )
+        # success! reset corrupt db count
+        self._corrupt_db_counter = 0
+
+    def writeout_cache(self) -> None:
+        """Overridden by HistoryManager to dump the cache before certain
+        database lookups."""
+        pass
+
+    ## -------------------------------
+    ## Methods for retrieving history:
+    ## -------------------------------
+    def _run_sql(
+        self,
+        sql: str,
+        params: tuple,
+        raw: bool = True,
+        output: bool = False,
+        latest: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        """Prepares and runs an SQL query for the history database.
+
+        Parameters
+        ----------
+        sql : str
+            Any filtering expressions to go after SELECT ... FROM ...
+        params : tuple
+            Parameters passed to the SQL query (to replace "?")
+        raw, output : bool
+            See :meth:`get_range`
+        latest : bool
+            Select rows with max (session, line)
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        toget = "source_raw" if raw else "source"
+        sqlfrom = "history"
+        if output:
+            sqlfrom = "history LEFT JOIN output_history USING (session, line)"
+            toget = "history.%s, output_history.output" % toget
+        if latest:
+            toget += ", MAX(session * 128 * 1024 + line)"
+        this_querry = "SELECT session, line, %s FROM %s " % (toget, sqlfrom) + sql
+        cur = self.db.execute(this_querry, params)
+        if latest:
+            cur = (row[:-1] for row in cur)
+        if output:  # Regroup into 3-tuples, and parse JSON
+            return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)
+        return cur
+
+    @only_when_enabled
+    @catch_corrupt_db
+    def get_session_info(
+        self, session: int
+    ) -> tuple[int, datetime.datetime, Optional[datetime.datetime], Optional[int], str]:
+        """Get info about a session.
+
+        Parameters
+        ----------
+        session : int
+            Session number to retrieve.
+
+        Returns
+        -------
+        session_id : int
+            Session ID number
+        start : datetime
+            Timestamp for the start of the session.
+        end : datetime
+            Timestamp for the end of the session, or None if IPython crashed.
+        num_cmds : int
+            Number of commands run, or None if IPython crashed.
+        remark : str
+            A manually set description.
+        """
+        query = "SELECT * from sessions where session == ?"
+        return self.db.execute(query, (session,)).fetchone()
+
+    @catch_corrupt_db
+    def get_last_session_id(self) -> Optional[int]:
+        """Get the last session ID currently in the database.
+
+        Within IPython, this should be the same as the value stored in
+        :attr:`HistoryManager.session_number`.
+        """
+        for record in self.get_tail(n=1, include_latest=True):
+            return record[0]
+        return None
+
+    @catch_corrupt_db
+    def get_tail(
+        self,
+        n: int = 10,
+        raw: bool = True,
+        output: bool = False,
+        include_latest: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        """Get the last n lines from the history database.
+
+        Parameters
+        ----------
+        n : int
+            The number of lines to get
+        raw, output : bool
+            See :meth:`get_range`
+        include_latest : bool
+            If False (default), n+1 lines are fetched, and the latest one
+            is discarded. This is intended to be used where the function
+            is called by a user command, which it should not return.
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        self.writeout_cache()
+        if not include_latest:
+            n += 1
+        cur = self._run_sql(
+            "ORDER BY session DESC, line DESC LIMIT ?", (n,), raw=raw, output=output
+        )
+        if not include_latest:
+            return reversed(list(cur)[1:])
+        return reversed(list(cur))
+
+    @catch_corrupt_db
+    def search(
+        self,
+        pattern: str = "*",
+        raw: bool = True,
+        search_raw: bool = True,
+        output: bool = False,
+        n: Optional[int] = None,
+        unique: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        """Search the database using unix glob-style matching (wildcards
+        * and ?).
+
+        Parameters
+        ----------
+        pattern : str
+            The wildcarded pattern to match when searching
+        search_raw : bool
+            If True, search the raw input, otherwise, the parsed input
+        raw, output : bool
+            See :meth:`get_range`
+        n : None or int
+            If an integer is given, it defines the limit of
+            returned entries.
+        unique : bool
+            When it is true, return only unique entries.
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        tosearch = "source_raw" if search_raw else "source"
+        if output:
+            tosearch = "history." + tosearch
+        self.writeout_cache()
+        sqlform = "WHERE %s GLOB ?" % tosearch
+        params: tuple[typing.Any, ...] = (pattern,)
+        if unique:
+            sqlform += " GROUP BY {0}".format(tosearch)
+        if n is not None:
+            sqlform += " ORDER BY session DESC, line DESC LIMIT ?"
+            params += (n,)
+        elif unique:
+            sqlform += " ORDER BY session, line"
+        cur = self._run_sql(sqlform, params, raw=raw, output=output, latest=unique)
+        if n is not None:
+            return reversed(list(cur))
+        return cur
+
+    @catch_corrupt_db
+    def get_range(
+        self,
+        session: int,
+        start: int = 1,
+        stop: Optional[int] = None,
+        raw: bool = True,
+        output: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        """Retrieve input by session.
+
+        Parameters
+        ----------
+        session : int
+            Session number to retrieve.
+        start : int
+            First line to retrieve.
+        stop : int
+            End of line range (excluded from output itself). If None, retrieve
+            to the end of the session.
+        raw : bool
+            If True, return untranslated input
+        output : bool
+            If True, attempt to include output. This will be 'real' Python
+            objects for the current session, or text reprs from previous
+            sessions if db_log_output was enabled at the time. Where no output
+            is found, None is used.
+
+        Returns
+        -------
+        entries
+            An iterator over the desired lines. Each line is a 3-tuple, either
+            (session, line, input) if output is False, or
+            (session, line, (input, output)) if output is True.
+        """
+        params: tuple[typing.Any, ...]
+        if stop:
+            lineclause = "line >= ? AND line < ?"
+            params = (session, start, stop)
+        else:
+            lineclause = "line>=?"
+            params = (session, start)
+
+        return self._run_sql(
+            "WHERE session==? AND %s" % lineclause, params, raw=raw, output=output
+        )
+
+    def get_range_by_str(
+        self, rangestr: str, raw: bool = True, output: bool = False
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
+        """Get lines of history from a string of ranges, as used by magic
+        commands %hist, %save, %macro, etc.
+
+        Parameters
+        ----------
+        rangestr : str
+            A string specifying ranges, e.g. "5 ~2/1-4". If empty string is used,
+            this will return everything from current session's history.
+
+            See the documentation of :func:`%history` for the full details.
+
+        raw, output : bool
+            As :meth:`get_range`
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        for sess, s, e in extract_hist_ranges(rangestr):
+            yield from self.get_range(sess, s, e, raw=raw, output=output)
+
+
+@dataclass
+class HistoryOutput:
+    output_type: typing.Literal[
+        "out_stream", "err_stream", "display_data", "execute_result"
+    ]
+    bundle: typing.Dict[str, str | list[str]]
+
+
+class HistoryManager(HistoryAccessor):
+    """A class to organize all history-related functionality in one place."""
+
     # Public interface
 
     # An instance of the IPython shell we are attached to
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
+    shell = Instance(
+        "IPython.core.interactiveshell.InteractiveShellABC", allow_none=False
+    )
     # Lists to hold processed and raw history. These start with a blank entry
     # so that we can index them starting from 1
     input_hist_parsed = List([""])
     input_hist_raw = List([""])
     # A list of directories visited during session
-    dir_hist = List()
-    def _dir_hist_default(self):
+    dir_hist: List = List()
+
+    @default("dir_hist")
+    def _dir_hist_default(self) -> list[Path]:
         try:
-            return [os.getcwd()]
+            return [Path.cwd()]
         except OSError:
             return []
 
@@ -55,181 +624,237 @@ def _dir_hist_default(self):
     # execution count.
     output_hist = Dict()
     # The text/plain repr of outputs.
-    output_hist_reprs = Dict()
+    output_hist_reprs: typing.Dict[int, str] = Dict()  # type: ignore [assignment]
+    # Maps execution_count to MIME bundles
+    outputs: typing.Dict[int, typing.List[HistoryOutput]] = defaultdict(list)
+    # Maps execution_count to exception tracebacks
+    exceptions: typing.Dict[int, typing.Dict[str, Any]] = Dict()  # type: ignore [assignment]
 
-    # String holding the path to the history file
-    hist_file = Unicode(config=True)
-
-    # The SQLite database
-    db = Instance(sqlite3.Connection)
     # The number of the current session in the history database
-    session_number = Int()
-    # Should we log output to the database? (default no)
-    db_log_output = Bool(False, config=True)
-    # Write to database every x commands (higher values save disk access & power)
-    #  Values of 1 or less effectively disable caching. 
-    db_cache_size = Int(0, config=True)
+    session_number: int = Integer()  # type: ignore [assignment]
+
+    db_log_output = Bool(
+        False, help="Should the history database include output? (default: no)"
+    ).tag(config=True)
+    db_cache_size = Integer(
+        0,
+        help="Write to database every x commands (higher values save disk access & power).\n"
+        "Values of 1 or less effectively disable caching.",
+    ).tag(config=True)
     # The input and output caches
-    db_input_cache = List()
-    db_output_cache = List()
-    
+    db_input_cache: List[tuple[int, str, str]] = List()
+    db_output_cache: List[tuple[int, str]] = List()
+
     # History saving in separate thread
-    save_thread = Instance('IPython.core.history.HistorySavingThread')
-    # N.B. Event is a function returning an instance of _Event.
-    save_flag = Instance(threading._Event)
-    
+    save_thread = Instance("IPython.core.history.HistorySavingThread", allow_none=True)
+
+    @property
+    def save_flag(self) -> threading.Event | None:
+        if self.save_thread is not None:
+            return self.save_thread.save_flag
+        return None
+
     # Private interface
     # Variables used to store the three last inputs from the user.  On each new
     # history update, we populate the user's namespace with these, shifted as
     # necessary.
-    _i00 = Unicode(u'')
-    _i = Unicode(u'')
-    _ii = Unicode(u'')
-    _iii = Unicode(u'')
+    _i00 = Unicode("")
+    _i = Unicode("")
+    _ii = Unicode("")
+    _iii = Unicode("")
 
     # A regex matching all forms of the exit command, so that we don't store
     # them in the history (it's annoying to rewind the first entry and land on
     # an exit call).
     _exit_re = re.compile(r"(exit|quit)(\s*\(.*\))?$")
 
-    def __init__(self, shell, config=None, **traits):
-        """Create a new history manager associated with a shell instance.
-        """
-        # We need a pointer back to the shell for various tasks.
-        super(HistoryManager, self).__init__(shell=shell, config=config,
-            **traits)
+    _instances: WeakSet[HistoryManager] = WeakSet()
+    _max_inst: int | float = float("inf")
 
-        if self.hist_file == u'':
-            # No one has set the hist_file, yet.
-            if shell.profile:
-                histfname = 'history-%s' % shell.profile
-            else:
-                histfname = 'history'
-            self.hist_file = os.path.join(shell.ipython_dir, histfname + '.sqlite')
+    def __init__(
+        self,
+        shell: InteractiveShell,
+        config: Optional[Configuration] = None,
+        **traits: typing.Any,
+    ):
+        """Create a new history manager associated with a shell instance."""
+        super().__init__(shell=shell, config=config, **traits)
+        self.db_input_cache_lock = threading.Lock()
+        self.db_output_cache_lock = threading.Lock()
 
         try:
-            self.init_db()
-        except sqlite3.DatabaseError:
-            if os.path.isfile(self.hist_file):
-                # Try to move the file out of the way.
-                newpath = os.path.join(self.shell.ipython_dir, "hist-corrupt.sqlite")
-                os.rename(self.hist_file, newpath)
-                print("ERROR! History file wasn't a valid SQLite database.",
-                "It was moved to %s" % newpath, "and a new file created.")
-                self.init_db()
+            self.new_session()
+        except OperationalError:
+            self.log.error(
+                "Failed to create history session in %s. History will not be saved.",
+                self.hist_file,
+                exc_info=True,
+            )
+            self.hist_file = ":memory:"
+
+        self.using_thread = False
+        if self.enabled and self.hist_file != ":memory:":
+            self.save_thread = HistorySavingThread(self)
+            try:
+                self.save_thread.start()
+            except RuntimeError:
+                self.log.error(
+                    "Failed to start history saving thread. History will not be saved.",
+                    exc_info=True,
+                )
+                self.hist_file = ":memory:"
             else:
-                # The hist_file is probably :memory: or something else.
-                raise
-                
-        self.save_flag = threading.Event()
-        self.db_input_cache_lock = threading.Lock()
-        self.db_output_cache_lock = threading.Lock()
-        self.save_thread = HistorySavingThread(self)
-        self.save_thread.start()
+                self.using_thread = True
+        self._instances.add(self)
+        assert len(HistoryManager._instances) <= HistoryManager._max_inst, (
+            len(HistoryManager._instances),
+            HistoryManager._max_inst,
+        )
 
-        self.new_session()
+    def __del__(self) -> None:
+        if self.save_thread is not None:
+            self.save_thread.stop()
 
-        
-    def init_db(self):
-        """Connect to the database, and create tables if necessary."""
-        self.db = sqlite3.connect(self.hist_file)
-        self.db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer
-                        primary key autoincrement, start timestamp,
-                        end timestamp, num_cmds integer, remark text)""")
-        self.db.execute("""CREATE TABLE IF NOT EXISTS history 
-                (session integer, line integer, source text, source_raw text,
-                PRIMARY KEY (session, line))""")
-        # Output history is optional, but ensure the table's there so it can be
-        # enabled later.
-        self.db.execute("""CREATE TABLE IF NOT EXISTS output_history
-                        (session integer, line integer, output text,
-                        PRIMARY KEY (session, line))""")
-        self.db.commit()
-    
-    def new_session(self, conn=None):
+    @classmethod
+    def _stop_thread(cls) -> None:
+        # Used before forking so the thread isn't running at fork
+        for inst in cls._instances:
+            if inst.save_thread is not None:
+                inst.save_thread.stop()
+                inst.save_thread = None
+
+    def _restart_thread_if_stopped(self) -> None:
+        # Start the thread again after it was stopped for forking
+        if self.save_thread is None and self.using_thread:
+            self.save_thread = HistorySavingThread(self)
+            self.save_thread.start()
+
+    def _get_hist_file_name(self, profile: Optional[str] = None) -> Path:
+        """Get default history file name based on the Shell's profile.
+
+        The profile parameter is ignored, but must exist for compatibility with
+        the parent class."""
+        profile_dir = self.shell.profile_dir.location
+        return Path(profile_dir) / "history.sqlite"
+
+    @only_when_enabled
+    def new_session(self, conn: Optional[sqlite3.Connection] = None) -> None:
         """Get a new session number."""
         if conn is None:
             conn = self.db
-        
+
         with conn:
-            cur = conn.execute("""INSERT INTO sessions VALUES (NULL, ?, NULL,
-                            NULL, "") """, (datetime.datetime.now(),))
+            cur = conn.execute(
+                """INSERT INTO sessions VALUES (NULL, ?, NULL,
+                            NULL, '') """,
+                (datetime.datetime.now().isoformat(" "),),
+            )
+            assert isinstance(cur.lastrowid, int)
             self.session_number = cur.lastrowid
-            
-    def end_session(self):
+
+    def end_session(self) -> None:
         """Close the database session, filling in the end time and line count."""
         self.writeout_cache()
         with self.db:
-            self.db.execute("""UPDATE sessions SET end=?, num_cmds=? WHERE
-                            session==?""", (datetime.datetime.now(),
-                            len(self.input_hist_parsed)-1, self.session_number))
+            self.db.execute(
+                """UPDATE sessions SET end=?, num_cmds=? WHERE
+                            session==?""",
+                (
+                    datetime.datetime.now(datetime.timezone.utc).isoformat(" "),
+                    len(self.input_hist_parsed) - 1,
+                    self.session_number,
+                ),
+            )
         self.session_number = 0
-                            
-    def name_session(self, name):
+
+    def name_session(self, name: str) -> None:
         """Give the current session a name in the history database."""
+        warn(
+            "name_session is deprecated in IPython 9.0 and will be removed in future versions",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         with self.db:
-            self.db.execute("UPDATE sessions SET remark=? WHERE session==?",
-                            (name, self.session_number))
-                            
-    def reset(self, new_session=True):
+            self.db.execute(
+                "UPDATE sessions SET remark=? WHERE session==?",
+                (name, self.session_number),
+            )
+
+    def reset(self, new_session: bool = True) -> None:
         """Clear the session history, releasing all object references, and
         optionally open a new session."""
         self.output_hist.clear()
+        self.outputs.clear()
+        self.exceptions.clear()
+
         # The directory history can't be completely empty
-        self.dir_hist[:] = [os.getcwd()]
-        
+        self.dir_hist[:] = [Path.cwd()]
+
         if new_session:
             if self.session_number:
                 self.end_session()
             self.input_hist_parsed[:] = [""]
             self.input_hist_raw[:] = [""]
             self.new_session()
-    
-    ## -------------------------------
-    ## Methods for retrieving history:
-    ## -------------------------------
-    def _run_sql(self, sql, params, raw=True, output=False):
-        """Prepares and runs an SQL query for the history database.
-        
+
+    # ------------------------------
+    # Methods for retrieving history
+    # ------------------------------
+    def get_session_info(
+        self, session: int = 0
+    ) -> tuple[int, datetime.datetime, Optional[datetime.datetime], Optional[int], str]:
+        """Get info about a session.
+
         Parameters
         ----------
-        sql : str
-          Any filtering expressions to go after SELECT ... FROM ...
-        params : tuple
-          Parameters passed to the SQL query (to replace "?")
-        raw, output : bool
-          See :meth:`get_range`
-        
+        session : int
+            Session number to retrieve. The current session is 0, and negative
+            numbers count back from current session, so -1 is the previous session.
+
         Returns
         -------
-        Tuples as :meth:`get_range`
+        session_id : int
+            Session ID number
+        start : datetime
+            Timestamp for the start of the session.
+        end : datetime
+            Timestamp for the end of the session, or None if IPython crashed.
+        num_cmds : int
+            Number of commands run, or None if IPython crashed.
+        remark : str
+            A manually set description.
         """
-        toget = 'source_raw' if raw else 'source'
-        sqlfrom = "history"
-        if output:
-            sqlfrom = "history LEFT JOIN output_history USING (session, line)"
-            toget = "history.%s, output_history.output" % toget
-        cur = self.db.execute("SELECT session, line, %s FROM %s " %\
-                                (toget, sqlfrom) + sql, params)
-        if output:    # Regroup into 3-tuples, and parse JSON
-            return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)
-        return cur
-        
-    
-    def get_tail(self, n=10, raw=True, output=False, include_latest=False):
+        if session <= 0:
+            session += self.session_number
+
+        return super(HistoryManager, self).get_session_info(session=session)
+
+    @catch_corrupt_db
+    def get_tail(
+        self,
+        n: int = 10,
+        raw: bool = True,
+        output: bool = False,
+        include_latest: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
         """Get the last n lines from the history database.
-        
+
+        Most recent entry last.
+
+        Completion will be reordered so that that the last ones are when
+        possible from current session.
+
         Parameters
         ----------
         n : int
-          The number of lines to get
+            The number of lines to get
         raw, output : bool
-          See :meth:`get_range`
+            See :meth:`get_range`
         include_latest : bool
-          If False (default), n+1 lines are fetched, and the latest one
-          is discarded. This is intended to be used where the function
-          is called by a user command, which it should not return.
-        
+            If False (default), n+1 lines are fetched, and the latest one
+            is discarded. This is intended to be used where the function
+            is called by a user command, which it should not return.
+
         Returns
         -------
         Tuples as :meth:`get_range`
@@ -237,60 +862,68 @@ def get_tail(self, n=10, raw=True, output=False, include_latest=False):
         self.writeout_cache()
         if not include_latest:
             n += 1
-        cur = self._run_sql("ORDER BY session DESC, line DESC LIMIT ?",
-                                (n,), raw=raw, output=output)
+        # cursor/line/entry
+        this_cur = list(
+            self._run_sql(
+                "WHERE session == ? ORDER BY line DESC LIMIT ?  ",
+                (self.session_number, n),
+                raw=raw,
+                output=output,
+            )
+        )
+        other_cur = list(
+            self._run_sql(
+                "WHERE session != ? ORDER BY session DESC, line DESC LIMIT ?",
+                (self.session_number, n),
+                raw=raw,
+                output=output,
+            )
+        )
+
+        everything: list[tuple[int, int, InOrInOut]] = this_cur + other_cur
+
+        everything = everything[:n]
+
         if not include_latest:
-            return reversed(list(cur)[1:])
-        return reversed(list(cur))
-        
-    def search(self, pattern="*", raw=True, search_raw=True,
-                                                        output=False):
-        """Search the database using unix glob-style matching (wildcards
-        * and ?).
-        
-        Parameters
-        ----------
-        pattern : str
-          The wildcarded pattern to match when searching
-        search_raw : bool
-          If True, search the raw input, otherwise, the parsed input
-        raw, output : bool
-          See :meth:`get_range`
-        
-        Returns
-        -------
-        Tuples as :meth:`get_range`
-        """
-        tosearch = "source_raw" if search_raw else "source"
-        if output:
-            tosearch = "history." + tosearch
-        self.writeout_cache()
-        return self._run_sql("WHERE %s GLOB ?" % tosearch, (pattern,),
-                                    raw=raw, output=output)
-                                
-    def _get_range_session(self, start=1, stop=None, raw=True, output=False):
+            return list(everything)[:0:-1]
+        return list(everything)[::-1]
+
+    def _get_range_session(
+        self,
+        start: int = 1,
+        stop: Optional[int] = None,
+        raw: bool = True,
+        output: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
         """Get input and output history from the current session. Called by
         get_range, and takes similar parameters."""
         input_hist = self.input_hist_raw if raw else self.input_hist_parsed
-            
+
         n = len(input_hist)
         if start < 0:
             start += n
-        if not stop:
+        if not stop or (stop > n):
             stop = n
         elif stop < 0:
             stop += n
-        
+        line: InOrInOut
         for i in range(start, stop):
             if output:
                 line = (input_hist[i], self.output_hist_reprs.get(i))
             else:
                 line = input_hist[i]
             yield (0, i, line)
-            
-    def get_range(self, session=0, start=1, stop=None, raw=True,output=False):
+
+    def get_range(
+        self,
+        session: int = 0,
+        start: int = 1,
+        stop: Optional[int] = None,
+        raw: bool = True,
+        output: bool = False,
+    ) -> Iterable[tuple[int, int, InOrInOut]]:
         """Retrieve input by session.
-        
+
         Parameters
         ----------
         session : int
@@ -308,84 +941,59 @@ def get_range(self, session=0, start=1, stop=None, raw=True,output=False):
             objects for the current session, or text reprs from previous
             sessions if db_log_output was enabled at the time. Where no output
             is found, None is used.
-            
+
         Returns
         -------
-        An iterator over the desired lines. Each line is a 3-tuple, either
-        (session, line, input) if output is False, or
-        (session, line, (input, output)) if output is True.
+        entries
+            An iterator over the desired lines. Each line is a 3-tuple, either
+            (session, line, input) if output is False, or
+            (session, line, (input, output)) if output is True.
         """
-        if session == 0 or session==self.session_number:   # Current session
-            return self._get_range_session(start, stop, raw, output)
-        if session < 0:
+        if session <= 0:
             session += self.session_number
-            
-        if stop:
-            lineclause = "line >= ? AND line < ?"
-            params = (session, start, stop)
-        else:
-            lineclause = "line>=?"
-            params = (session, start)
-        
-        return self._run_sql("WHERE session==? AND %s""" % lineclause,
-                                    params, raw=raw, output=output)
-        
-    def get_range_by_str(self, rangestr, raw=True, output=False):
-        """Get lines of history from a string of ranges, as used by magic
-        commands %hist, %save, %macro, etc.
-        
-        Parameters
-        ----------
-        rangestr : str
-          A string specifying ranges, e.g. "5 ~2/1-4". See
-          :func:`magic_history` for full details.
-        raw, output : bool
-          As :meth:`get_range`
-          
-        Returns
-        -------
-        Tuples as :meth:`get_range`
-        """
-        for sess, s, e in extract_hist_ranges(rangestr):
-            for line in self.get_range(sess, s, e, raw=raw, output=output):
-                yield line
-    
+        if session == self.session_number:  # Current session
+            return self._get_range_session(start, stop, raw, output)
+        return super(HistoryManager, self).get_range(session, start, stop, raw, output)
+
     ## ----------------------------
     ## Methods for storing history:
     ## ----------------------------
-    def store_inputs(self, line_num, source, source_raw=None):
+    def store_inputs(
+        self, line_num: int, source: str, source_raw: Optional[str] = None
+    ) -> None:
         """Store source and raw input in history and create input cache
-        variables _i*.
-        
+        variables ``_i*``.
+
         Parameters
         ----------
         line_num : int
-          The prompt number of this input.
-        
+            The prompt number of this input.
         source : str
-          Python input.
-
+            Python input.
         source_raw : str, optional
-          If given, this is the raw input without any IPython transformations
-          applied to it.  If not given, ``source`` is used.
+            If given, this is the raw input without any IPython transformations
+            applied to it.  If not given, ``source`` is used.
         """
         if source_raw is None:
             source_raw = source
-        source = source.rstrip('\n')
-        source_raw = source_raw.rstrip('\n')
-            
+        source = source.rstrip("\n")
+        source_raw = source_raw.rstrip("\n")
+
         # do not store exit/quit commands
         if self._exit_re.match(source_raw.strip()):
             return
-        
+
         self.input_hist_parsed.append(source)
         self.input_hist_raw.append(source_raw)
-        
+
         with self.db_input_cache_lock:
             self.db_input_cache.append((line_num, source, source_raw))
             # Trigger to flush cache and write to DB.
             if len(self.db_input_cache) >= self.db_cache_size:
-                self.save_flag.set()
+                if self.using_thread:
+                    self._restart_thread_if_stopped()
+                    if self.save_flag is not None:
+                        self.save_flag.set()
 
         # update the auto _i variables
         self._iii = self._ii
@@ -394,58 +1002,69 @@ def store_inputs(self, line_num, source, source_raw=None):
         self._i00 = source_raw
 
         # hackish access to user namespace to create _i1,_i2... dynamically
-        new_i = '_i%s' % line_num
-        to_main = {'_i': self._i,
-                   '_ii': self._ii,
-                   '_iii': self._iii,
-                   new_i : self._i00 }
-        self.shell.user_ns.update(to_main)
-        
-    def store_output(self, line_num):
+        new_i = "_i%s" % line_num
+        to_main = {"_i": self._i, "_ii": self._ii, "_iii": self._iii, new_i: self._i00}
+
+        if self.shell is not None:
+            self.shell.push(to_main, interactive=False)
+
+    def store_output(self, line_num: int) -> None:
         """If database output logging is enabled, this saves all the
         outputs from the indicated prompt number to the database. It's
         called by run_cell after code has been executed.
-        
+
         Parameters
         ----------
         line_num : int
-          The line number from which to save outputs
+            The line number from which to save outputs
         """
         if (not self.db_log_output) or (line_num not in self.output_hist_reprs):
             return
+        lnum: int = line_num
         output = self.output_hist_reprs[line_num]
-        
+
         with self.db_output_cache_lock:
             self.db_output_cache.append((line_num, output))
-        if self.db_cache_size <= 1:
-            self.save_flag.set()
-    
-    def _writeout_input_cache(self, conn):
+        if self.db_cache_size <= 1 and self.using_thread:
+            self._restart_thread_if_stopped()
+            if self.save_flag is not None:
+                self.save_flag.set()
+
+    def _writeout_input_cache(self, conn: sqlite3.Connection) -> None:
         with conn:
             for line in self.db_input_cache:
-                conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
-                                (self.session_number,)+line)
-    
-    def _writeout_output_cache(self, conn):
+                conn.execute(
+                    "INSERT INTO history VALUES (?, ?, ?, ?)",
+                    (self.session_number,) + line,
+                )
+
+    def _writeout_output_cache(self, conn: sqlite3.Connection) -> None:
         with conn:
             for line in self.db_output_cache:
-                conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",
-                                (self.session_number,)+line)
-    
-    def writeout_cache(self, conn=None):
+                conn.execute(
+                    "INSERT INTO output_history VALUES (?, ?, ?)",
+                    (self.session_number,) + line,
+                )
+
+    @only_when_enabled
+    def writeout_cache(self, conn: Optional[sqlite3.Connection] = None) -> None:
         """Write any entries in the cache to the database."""
         if conn is None:
             conn = self.db
-            
+
         with self.db_input_cache_lock:
             try:
                 self._writeout_input_cache(conn)
             except sqlite3.IntegrityError:
                 self.new_session(conn)
-                print("ERROR! Session/line number was not unique in",
-                      "database. History logging moved to new session",
-                                                self.session_number)
-                try: # Try writing to the new session. If this fails, don't recurse
+                print(
+                    "ERROR! Session/line number was not unique in",
+                    "database. History logging moved to new session",
+                    self.session_number,
+                )
+                try:
+                    # Try writing to the new session. If this fails, don't
+                    # recurse
                     self._writeout_input_cache(conn)
                 except sqlite3.IntegrityError:
                     pass
@@ -456,347 +1075,183 @@ def writeout_cache(self, conn=None):
             try:
                 self._writeout_output_cache(conn)
             except sqlite3.IntegrityError:
-                print("!! Session/line number for output was not unique",
-                      "in database. Output will not be stored.")
+                print(
+                    "!! Session/line number for output was not unique",
+                    "in database. Output will not be stored.",
+                )
             finally:
                 self.db_output_cache = []
 
 
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(before=HistoryManager._stop_thread)
+
+
+from collections.abc import Callable, Iterator
+from weakref import ReferenceType
+
+
+@contextmanager
+def hold(ref: ReferenceType[HistoryManager]) -> Iterator[ReferenceType[HistoryManager]]:
+    """
+    Context manger that hold a reference to a weak ref to make sure it
+    is not GC'd during it's context.
+    """
+    r = ref()
+    yield ref
+    del r
+
+
 class HistorySavingThread(threading.Thread):
     """This thread takes care of writing history to the database, so that
     the UI isn't held up while that happens.
-    
+
     It waits for the HistoryManager's save_flag to be set, then writes out
     the history cache. The main thread is responsible for setting the flag when
     the cache size reaches a defined threshold."""
-    daemon = True
-    stop_now = False
-    def __init__(self, history_manager):
-        super(HistorySavingThread, self).__init__()
-        self.history_manager = history_manager
+
+    save_flag: threading.Event
+    daemon: bool = True
+    _stop_now: bool = False
+    enabled: bool = True
+    history_manager: ref[HistoryManager]
+    _stopped = False
+
+    def __init__(self, history_manager: HistoryManager) -> None:
+        super(HistorySavingThread, self).__init__(name="IPythonHistorySavingThread")
+        self.history_manager = ref(history_manager)
+        self.enabled = history_manager.enabled
+        self.save_flag = threading.Event()
+
+    @only_when_enabled
+    def run(self) -> None:
         atexit.register(self.stop)
-        
-    def run(self):
         # We need a separate db connection per thread:
         try:
-            self.db = sqlite3.connect(self.history_manager.hist_file)
+            hm: ReferenceType[HistoryManager]
+            with hold(self.history_manager) as hm:
+                if hm() is not None:
+                    self.db = sqlite3.connect(
+                        str(hm().hist_file),  # type: ignore [union-attr]
+                        **cast(dict[str, t.Any], hm().connection_options),  # type: ignore [union-attr]
+                    )
             while True:
-                self.history_manager.save_flag.wait()
-                if self.stop_now:
-                    return
-                self.history_manager.save_flag.clear()
-                self.history_manager.writeout_cache(self.db)
+                self.save_flag.wait()
+                with hold(self.history_manager) as hm:
+                    if hm() is None:
+                        self._stop_now = True
+                    if self._stop_now:
+                        self.db.close()
+                        return
+                    self.save_flag.clear()
+                    if hm() is not None:
+                        hm().writeout_cache(self.db)  # type: ignore [union-attr]
+
         except Exception as e:
-            print(("The history saving thread hit an unexpected error (%s)."
-                   "History will not be written to the database.") % repr(e))
-        
-    def stop(self):
+            print(
+                (
+                    "The history saving thread hit an unexpected error (%s)."
+                    "History will not be written to the database."
+                )
+                % repr(e)
+            )
+        finally:
+            atexit.unregister(self.stop)
+
+    def stop(self) -> None:
         """This can be called from the main thread to safely stop this thread.
-        
+
         Note that it does not attempt to write out remaining history before
         exiting. That should be done by calling the HistoryManager's
         end_session method."""
-        self.stop_now = True
-        self.history_manager.save_flag.set()
-        self.join()
-
-        
-# To match, e.g. ~5/8-~2/3
-range_re = re.compile(r"""
-((?P<startsess>~?\d+)/)?
-(?P<start>\d+)                    # Only the start line num is compulsory
+        if self._stopped:
+            return
+        self._stop_now = True
+
+        self.save_flag.set()
+        self._stopped = True
+        if self != threading.current_thread():
+            self.join()
+
+    def __del__(self) -> None:
+        self.stop()
+
+
+# To match, e.g. ~5/8-~2/3, or ~4 (without trailing slash for full session)
+# Session numbers: ~N or N/
+# Line numbers: N (just digits, no ~)
+# Range syntax: 4-6 (with end) or 4- (without end, means "onward")
+range_re = re.compile(
+    r"""
+((?P<startsess>(?:~?\d+/)))?
+(?P<start>\d+)?
 ((?P<sep>[\-:])
- ((?P<endsess>~?\d+)/)?
- (?P<end>\d+))?
-$""", re.VERBOSE)
+ ((?P<endsess>(?:~?\d+/)))?
+ (?P<end>\d*))?
+$""",
+    re.VERBOSE,
+)
+
 
-def extract_hist_ranges(ranges_str):
+def extract_hist_ranges(ranges_str: str) -> Iterable[tuple[int, int, Optional[int]]]:
     """Turn a string of history ranges into 3-tuples of (session, start, stop).
-    
+
+    Empty string results in a `[(0, 1, None)]`, i.e. "everything from current
+    session".
+
     Examples
     --------
-    list(extract_input_ranges("~8/5-~7/4 2"))
-    [(-8, 5, None), (-7, 1, 4), (0, 2, 3)]
+    >>> list(extract_hist_ranges("~8/5-~7/4 2"))
+    [(-8, 5, None), (-7, 1, 5), (0, 2, 3)]
+    >>> list(extract_hist_ranges("~4/"))
+    [(-4, 1, None)]
+    >>> list(extract_hist_ranges("4-"))
+    [(0, 4, None)]
+    >>> list(extract_hist_ranges("~4/4-"))
+    [(-4, 4, None)]
     """
+    if ranges_str == "":
+        yield (0, 1, None)  # Everything from current session
+        return
+
     for range_str in ranges_str.split():
         rmatch = range_re.match(range_str)
         if not rmatch:
             continue
-        start = int(rmatch.group("start"))
-        end = rmatch.group("end")
-        end = int(end) if end else start+1   # If no end specified, get (a, a+1)
-        if rmatch.group("sep") == "-":       # 1-3 == 1:4 --> [1, 2, 3]
-            end += 1
+        start = rmatch.group("start")
+        sep = rmatch.group("sep")
+        if start:
+            start = int(start)
+            end = rmatch.group("end")
+            if sep == "-":
+                end = (int(end) + 1) if end else None
+            else:
+                end = int(end) if end else start + 1
+        else:
+            if not rmatch.group("startsess"):
+                continue
+            start = 1
+            end = None
         startsess = rmatch.group("startsess") or "0"
         endsess = rmatch.group("endsess") or startsess
-        startsess = int(startsess.replace("~","-"))
-        endsess = int(endsess.replace("~","-"))
-        assert endsess >= startsess
+        startsess = startsess.rstrip("/")
+        endsess = endsess.rstrip("/")
+        startsess = int(startsess.replace("~", "-"))
+        endsess = int(endsess.replace("~", "-"))
+        assert endsess >= startsess, "start session must be earlier than end session"
 
         if endsess == startsess:
             yield (startsess, start, end)
             continue
         # Multiple sessions in one range:
         yield (startsess, start, None)
-        for sess in range(startsess+1, endsess):
+        for sess in range(startsess + 1, endsess):
             yield (sess, 1, None)
         yield (endsess, 1, end)
 
-def _format_lineno(session, line):
+
+def _format_lineno(session: int, line: int) -> str:
     """Helper function to format line numbers properly."""
     if session == 0:
         return str(line)
     return "%s#%s" % (session, line)
-
-@testdec.skip_doctest
-def magic_history(self, parameter_s = ''):
-    """Print input history (_i<n> variables), with most recent last.
-    
-    %history       -> print at most 40 inputs (some may be multi-line)\\
-    %history n     -> print at most n inputs\\
-    %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
-
-    By default, input history is printed without line numbers so it can be
-    directly pasted into an editor. Use -n to show them.
-
-    Ranges of history can be indicated using the syntax:
-    4      : Line 4, current session
-    4-6    : Lines 4-6, current session
-    243/1-5: Lines 1-5, session 243
-    ~2/7   : Line 7, session 2 before current
-    ~8/1-~6/5 : From the first line of 8 sessions ago, to the fifth line
-                of 6 sessions ago.
-    Multiple ranges can be entered, separated by spaces
-    
-    The same syntax is used by %macro, %save, %edit, %rerun
-
-    Options:
-
-      -n: print line numbers for each input.
-      This feature is only available if numbered prompts are in use.
-
-      -o: also print outputs for each input.
-
-      -p: print classic '>>>' python prompts before each input.  This is useful
-       for making documentation, and in conjunction with -o, for producing
-       doctest-ready output.
-
-      -r: (default) print the 'raw' history, i.e. the actual commands you typed.
-      
-      -t: print the 'translated' history, as IPython understands it.  IPython
-      filters your input and converts it all into valid Python source before
-      executing it (things like magics or aliases are turned into function
-      calls, for example). With this option, you'll see the native history
-      instead of the user-entered version: '%cd /' will be seen as
-      'get_ipython().magic("%cd /")' instead of '%cd /'.
-      
-      -g: treat the arg as a pattern to grep for in (full) history.
-      This includes the saved history (almost all commands ever written).
-      Use '%hist -g' to show full saved history (may be very long).
-      
-      -l: get the last n lines from all sessions. Specify n as a single arg, or
-      the default is the last 10 lines.
-
-      -f FILENAME: instead of printing the output to the screen, redirect it to
-       the given file.  The file is always overwritten, though IPython asks for
-       confirmation first if it already exists.
-       
-    Examples
-    --------
-    ::
-    
-      In [6]: %hist -n 4 6
-      4:a = 12
-      5:print a**2
-
-    """
-
-    if not self.shell.displayhook.do_full_cache:
-        print('This feature is only available if numbered prompts are in use.')
-        return
-    opts,args = self.parse_options(parameter_s,'noprtglf:',mode='string')
-    
-    # For brevity
-    history_manager = self.shell.history_manager
-    
-    def _format_lineno(session, line):
-        """Helper function to format line numbers properly."""
-        if session in (0, history_manager.session_number):
-            return str(line)
-        return "%s/%s" % (session, line)
-
-    # Check if output to specific file was requested.
-    try:
-        outfname = opts['f']
-    except KeyError:
-        outfile = io.stdout  # default
-        # We don't want to close stdout at the end!
-        close_at_end = False
-    else:
-        if os.path.exists(outfname):
-            if not io.ask_yes_no("File %r exists. Overwrite?" % outfname): 
-                print('Aborting.')
-                return
-
-        outfile = open(outfname,'w')
-        close_at_end = True
-    
-    print_nums = 'n' in opts
-    get_output = 'o' in opts
-    pyprompts = 'p' in opts
-    # Raw history is the default
-    raw = not('t' in opts)
-            
-    default_length = 40
-    pattern = None
-    
-    if 'g' in opts:         # Glob search
-        pattern = "*" + args + "*" if args else "*"
-        hist = history_manager.search(pattern, raw=raw, output=get_output)
-    elif 'l' in opts:       # Get 'tail'
-        try:
-            n = int(args)
-        except ValueError, IndexError:
-            n = 10
-        hist = history_manager.get_tail(n, raw=raw, output=get_output)
-    else:
-        if args:            # Get history by ranges
-            hist = history_manager.get_range_by_str(args, raw, get_output)
-        else:               # Just get history for the current session
-            hist = history_manager.get_range(raw=raw, output=get_output)
-    
-    # We could be displaying the entire history, so let's not try to pull it 
-    # into a list in memory. Anything that needs more space will just misalign.
-    width = 4
-        
-    for session, lineno, inline in hist:
-        # Print user history with tabs expanded to 4 spaces.  The GUI clients
-        # use hard tabs for easier usability in auto-indented code, but we want
-        # to produce PEP-8 compliant history for safe pasting into an editor.
-        if get_output:
-            inline, output = inline
-        inline = inline.expandtabs(4).rstrip()
-            
-        multiline = "\n" in inline
-        line_sep = '\n' if multiline else ' '
-        if print_nums:
-            print('%s:%s' % (_format_lineno(session, lineno).rjust(width),
-                    line_sep),  file=outfile, end='')
-        if pyprompts:
-            print(">>> ", end="", file=outfile)
-            if multiline:
-                inline = "\n... ".join(inline.splitlines()) + "\n..."
-        print(inline, file=outfile)
-        if get_output and output:
-            print(output, file=outfile)
-
-    if close_at_end:
-        outfile.close()
-
-
-def magic_rep(self, arg):
-    r""" Repeat a command, or get command to input line for editing
-
-    - %rep (no arguments):
-    
-    Place a string version of last computation result (stored in the special '_'
-    variable) to the next input prompt. Allows you to create elaborate command
-    lines without using copy-paste::
-    
-         In[1]: l = ["hei", "vaan"]
-         In[2]: "".join(l)
-        Out[2]: heivaan
-         In[3]: %rep
-         In[4]: heivaan_ <== cursor blinking
-    
-    %rep 45
-    
-    Place history line 45 on the next input prompt. Use %hist to find
-    out the number.
-    
-    %rep 1-4
-    
-    Combine the specified lines into one cell, and place it on the next
-    input prompt. See %history for the slice syntax.
-    
-    %rep foo+bar
-    
-    If foo+bar can be evaluated in the user namespace, the result is
-    placed at the next input prompt. Otherwise, the history is searched
-    for lines which contain that substring, and the most recent one is
-    placed at the next input prompt.
-    """
-    if not arg:                 # Last output
-        self.set_next_input(str(self.shell.user_ns["_"]))
-        return
-                                # Get history range
-    histlines = self.history_manager.get_range_by_str(arg)
-    cmd = "\n".join(x[2] for x in histlines)
-    if cmd:
-        self.set_next_input(cmd.rstrip())
-        return
-
-    try:                        # Variable in user namespace
-        cmd = str(eval(arg, self.shell.user_ns))
-    except Exception:           # Search for term in history
-        histlines = self.history_manager.search("*"+arg+"*")
-        for h in reversed([x[2] for x in histlines]):
-            if 'rep' in h:
-                continue
-            self.set_next_input(h.rstrip())
-            return
-    else:
-        self.set_next_input(cmd.rstrip())
-    print("Couldn't evaluate or find in history:", arg)
-        
-def magic_rerun(self, parameter_s=''):
-    """Re-run previous input
-    
-    By default, you can specify ranges of input history to be repeated
-    (as with %history). With no arguments, it will repeat the last line.
-    
-    Options:
-    
-      -l <n> : Repeat the last n lines of input, not including the
-      current command.
-      
-      -g foo : Repeat the most recent line which contains foo
-    """
-    opts, args = self.parse_options(parameter_s, 'l:g:', mode='string')
-    if "l" in opts:         # Last n lines
-        n = int(opts['l'])
-        hist = self.history_manager.get_tail(n)
-    elif "g" in opts:       # Search
-        p = "*"+opts['g']+"*"
-        hist = list(self.history_manager.search(p))
-        for l in reversed(hist):
-            if "rerun" not in l[2]:
-                hist = [l]     # The last match which isn't a %rerun
-                break
-        else:
-            hist = []          # No matches except %rerun
-    elif args:              # Specify history ranges
-        hist = self.history_manager.get_range_by_str(args)
-    else:                   # Last line
-        hist = self.history_manager.get_tail(1)
-    hist = [x[2] for x in hist]
-    if not hist:
-        print("No lines in history match specification")
-        return
-    histlines = "\n".join(hist)
-    print("=== Executing: ===")
-    print(histlines)
-    print("=== Output: ===")
-    self.run_cell("\n".join(hist), store_history=False)
-
-
-def init_ipython(ip):
-    ip.define_magic("rep", magic_rep) 
-    ip.define_magic("recall", magic_rep)
-    ip.define_magic("rerun", magic_rerun)
-    ip.define_magic("hist",magic_history)    # Alternative name
-    ip.define_magic("history",magic_history)
-
-    # XXX - ipy_completers are in quarantine, need to be updated to new apis
-    #import ipy_completers
-    #ipy_completers.quick_completer('%hist' ,'-g -t -r -n')
diff --git a/IPython/core/historyapp.py b/IPython/core/historyapp.py
new file mode 100644
index 00000000000..220ae9ad96e
--- /dev/null
+++ b/IPython/core/historyapp.py
@@ -0,0 +1,158 @@
+# encoding: utf-8
+"""
+An application for managing IPython history.
+
+To be invoked as the `ipython history` subcommand.
+"""
+
+import sqlite3
+from pathlib import Path
+
+from traitlets.config.application import Application
+from .application import BaseIPythonApplication
+from traitlets import Bool, Int, Dict
+from ..utils.io import ask_yes_no
+
+trim_hist_help = """Trim the IPython history database to the last 1000 entries.
+
+This actually copies the last 1000 entries to a new database, and then replaces
+the old file with the new. Use the `--keep=` argument to specify a number
+other than 1000.
+"""
+
+clear_hist_help = """Clear the IPython history database, deleting all entries.
+
+Because this is a destructive operation, IPython will prompt the user if they
+really want to do this. Passing a `-f` flag will force clearing without a
+prompt.
+
+This is an handy alias to `ipython history trim --keep=0`
+"""
+
+
+class HistoryTrim(BaseIPythonApplication):
+    description = trim_hist_help
+
+    backup = Bool(False, help="Keep the old history file as history.sqlite.<N>").tag(
+        config=True
+    )
+
+    keep = Int(1000, help="Number of recent lines to keep in the database.").tag(
+        config=True
+    )
+
+    flags = Dict(  # type: ignore
+        dict(backup=({"HistoryTrim": {"backup": True}}, backup.help))
+    )
+
+    aliases = Dict(dict(keep="HistoryTrim.keep"))  # type: ignore
+
+    def start(self):
+        profile_dir = Path(self.profile_dir.location)
+        hist_file = profile_dir / "history.sqlite"
+        con = sqlite3.connect(hist_file)
+
+        # Grab the recent history from the current database.
+        inputs = list(con.execute('SELECT session, line, source, source_raw FROM '
+                                'history ORDER BY session DESC, line DESC LIMIT ?', (self.keep+1,)))
+        if len(inputs) <= self.keep:
+            print("There are already at most %d entries in the history database." % self.keep)
+            print("Not doing anything. Use --keep= argument to keep fewer entries")
+            return
+
+        print("Trimming history to the most recent %d entries." % self.keep)
+
+        inputs.pop() # Remove the extra element we got to check the length.
+        inputs.reverse()
+        if inputs:
+            first_session = inputs[0][0]
+            outputs = list(con.execute('SELECT session, line, output FROM '
+                                       'output_history WHERE session >= ?', (first_session,)))
+            sessions = list(con.execute('SELECT session, start, end, num_cmds, remark FROM '
+                                        'sessions WHERE session >= ?', (first_session,)))
+        con.close()
+
+        # Create the new history database.
+        new_hist_file = profile_dir / "history.sqlite.new"
+        i = 0
+        while new_hist_file.exists():
+            # Make sure we don't interfere with an existing file.
+            i += 1
+            new_hist_file = profile_dir / ("history.sqlite.new" + str(i))
+        new_db = sqlite3.connect(new_hist_file)
+        new_db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer
+                            primary key autoincrement, start timestamp,
+                            end timestamp, num_cmds integer, remark text)""")
+        new_db.execute("""CREATE TABLE IF NOT EXISTS history
+                        (session integer, line integer, source text, source_raw text,
+                        PRIMARY KEY (session, line))""")
+        new_db.execute("""CREATE TABLE IF NOT EXISTS output_history
+                        (session integer, line integer, output text,
+                        PRIMARY KEY (session, line))""")
+        new_db.commit()
+
+
+        if inputs:
+            with new_db:
+                # Add the recent history into the new database.
+                new_db.executemany('insert into sessions values (?,?,?,?,?)', sessions)
+                new_db.executemany('insert into history values (?,?,?,?)', inputs)
+                new_db.executemany('insert into output_history values (?,?,?)', outputs)
+        new_db.close()
+
+        if self.backup:
+            i = 1
+            backup_hist_file = profile_dir / ("history.sqlite.old.%d" % i)
+            while backup_hist_file.exists():
+                i += 1
+                backup_hist_file = profile_dir / ("history.sqlite.old.%d" % i)
+            hist_file.rename(backup_hist_file)
+            print("Backed up longer history file to", backup_hist_file)
+        else:
+            hist_file.unlink()
+
+        new_hist_file.rename(hist_file)
+
+
+class HistoryClear(HistoryTrim):
+    description = clear_hist_help
+    keep = Int(0, help="Number of recent lines to keep in the database.")
+
+    force = Bool(False, help="Don't prompt user for confirmation").tag(config=True)
+
+    flags = Dict(  # type: ignore
+        dict(
+            force=({"HistoryClear": {"force": True}}, force.help),
+            f=({"HistoryTrim": {"force": True}}, force.help),
+        )
+    )
+    aliases = Dict()  # type: ignore
+
+    def start(self):
+        if self.force or ask_yes_no(
+            "Really delete all ipython history? ", default="no", interrupt="no"
+        ):
+            HistoryTrim.start(self)
+
+
+class HistoryApp(Application):
+    name = "ipython-history"
+    description = "Manage the IPython history database."
+
+    subcommands = Dict(dict(
+        trim = (HistoryTrim, HistoryTrim.description.splitlines()[0]),
+        clear = (HistoryClear, HistoryClear.description.splitlines()[0]),
+    ))
+
+    def start(self):
+        if self.subapp is None:
+            print(
+                "No subcommand specified. Must specify one of: "
+                + ", ".join(map(repr, self.subcommands))
+                + ".\n"
+            )
+            self.print_description()
+            self.print_subcommands()
+            self.exit(1)
+        else:
+            return self.subapp.start()
diff --git a/IPython/core/hooks.py b/IPython/core/hooks.py
index cd9e46c8885..938bd12c6da 100644
--- a/IPython/core/hooks.py
+++ b/IPython/core/hooks.py
@@ -1,37 +1,31 @@
-"""hooks for IPython.
+"""Hooks for IPython.
 
 In Python, it is possible to overwrite any method of any object if you really
-want to.  But IPython exposes a few 'hooks', methods which are _designed_ to
+want to.  But IPython exposes a few 'hooks', methods which are *designed* to
 be overwritten by users for customization purposes.  This module defines the
 default versions of all such hooks, which get used by IPython if not
 overridden by the user.
 
-hooks are simple functions, but they should be declared with 'self' as their
+Hooks are simple functions, but they should be declared with ``self`` as their
 first argument, because when activated they are registered into IPython as
-instance methods.  The self argument will be the IPython running instance
+instance methods. The self argument will be the IPython running instance
 itself, so hooks have full access to the entire IPython object.
 
-If you wish to define a new hook and activate it, you need to put the
-necessary code into a python file which can be either imported or execfile()'d
-from within your ipythonrc configuration.
+If you wish to define a new hook and activate it, you can make an :doc:`extension
+</config/extensions/index>` or a :ref:`startup script <startup_files>`. For
+example, you could use a startup file like this::
 
-For example, suppose that you have a module called 'myiphooks' in your
-PYTHONPATH, which contains the following definition:
+    import os
 
-import os
-from IPython.core import ipapi
-ip = ipapi.get()
-
-def calljed(self,filename, linenum):
-    "My editor hook calls the jed editor directly."
-    print "Calling my own editor, jed ..."
-    if os.system('jed +%d %s' % (linenum,filename)) != 0:
-        raise TryNext()
+    def calljed(self,filename, linenum):
+        "My editor hook calls the jed editor directly."
+        print("Calling my own editor, jed ...")
+        if os.system('jed +%d %s' % (linenum,filename)) != 0:
+            raise TryNext()
 
-ip.set_hook('editor', calljed)
+    def load_ipython_extension(ip):
+        ip.set_hook('editor', calljed)
 
-You can then enable the functionality by doing 'import myiphooks'
-somewhere in your configuration files or ipython command line.
 """
 
 #*****************************************************************************
@@ -41,20 +35,23 @@ def calljed(self,filename, linenum):
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-import os, bisect
+import os
+import subprocess
 import sys
 
-from IPython.core.error import TryNext
+from .error import TryNext
 
 # List here all the default hooks.  For now it's just the editor functions
 # but over time we'll move here all the public API for user-accessible things.
 
-__all__ = ['editor', 'fix_error_editor', 'synchronize_with_editor',
-           'input_prefilter', 'shutdown_hook', 'late_startup_hook',
-           'generate_prompt', 'show_in_pager','pre_prompt_hook',
-           'pre_run_code_hook', 'clipboard_get']
+__all__ = [
+    "editor",
+    "synchronize_with_editor",
+    "show_in_pager",
+    "clipboard_get",
+]
 
-def editor(self,filename, linenum=None):
+def editor(self, filename, linenum=None, wait=True):
     """Open the default editor at the given filename and linenumber.
 
     This is IPython's default editor hook, you can use it as an example to
@@ -64,45 +61,23 @@ def editor(self,filename, linenum=None):
     # IPython configures a default editor at startup by reading $EDITOR from
     # the environment, and falling back on vi (unix) or notepad (win32).
     editor = self.editor
-    
+
     # marker for at which line to open the file (for existing objects)
     if linenum is None or editor=='notepad':
         linemark = ''
     else:
         linemark = '+%d' % int(linenum)
-    
+
     # Enclose in quotes if necessary and legal
     if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
         editor = '"%s"' % editor
-        
+
     # Call the actual editor
-    if os.system('%s %s %s' % (editor,linemark,filename)) != 0:
+    proc = subprocess.Popen('%s %s %s' % (editor, linemark, filename),
+                            shell=True)
+    if wait and proc.wait() != 0:
         raise TryNext()
 
-import tempfile
-def fix_error_editor(self,filename,linenum,column,msg):
-    """Open the editor at the given filename, linenumber, column and 
-    show an error message. This is used for correcting syntax errors.
-    The current implementation only has special support for the VIM editor,
-    and falls back on the 'editor' hook if VIM is not used.
-
-    Call ip.set_hook('fix_error_editor',youfunc) to use your own function,
-    """
-    def vim_quickfix_file():
-        t = tempfile.NamedTemporaryFile()
-        t.write('%s:%d:%d:%s\n' % (filename,linenum,column,msg))
-        t.flush()
-        return t
-    if os.path.basename(self.editor) != 'vim':
-        self.hooks.editor(filename,linenum)
-        return
-    t = vim_quickfix_file()
-    try:
-        if os.system('vim --cmd "set errorformat=%f:%l:%c:%m" -q ' + t.name):
-            raise TryNext()
-    finally:
-        t.close()
-
 
 def synchronize_with_editor(self, filename, linenum, column):
         pass
@@ -110,124 +85,72 @@ def synchronize_with_editor(self, filename, linenum, column):
 
 class CommandChainDispatcher:
     """ Dispatch calls to a chain of commands until some func can handle it
-    
+
     Usage: instantiate, execute "add" to add commands (with optional
     priority), execute normally via f() calling mechanism.
-    
+
     """
     def __init__(self,commands=None):
         if commands is None:
             self.chain = []
         else:
             self.chain = commands
-            
-            
+
+
     def __call__(self,*args, **kw):
-        """ Command chain is called just like normal func. 
-        
-        This will call all funcs in chain with the same args as were given to this
-        function, and return the result of first func that didn't raise
-        TryNext """
-        
+        """ Command chain is called just like normal func.
+
+        This will call all funcs in chain with the same args as were given to
+        this function, and return the result of first func that didn't raise
+        TryNext"""
+        last_exc = TryNext()
         for prio,cmd in self.chain:
-            #print "prio",prio,"cmd",cmd #dbg
+            # print("prio",prio,"cmd",cmd)  # dbg
             try:
                 return cmd(*args, **kw)
-            except TryNext, exc:
-                if exc.args or exc.kwargs:
-                    args = exc.args
-                    kw = exc.kwargs
+            except TryNext as exc:
+                last_exc = exc
         # if no function will accept it, raise TryNext up to the caller
-        raise TryNext
-                
+        raise last_exc
+
     def __str__(self):
         return str(self.chain)
-    
+
     def add(self, func, priority=0):
         """ Add a func to the cmd chain with given priority """
-        bisect.insort(self.chain,(priority,func))
+        self.chain.append((priority, func))
+        self.chain.sort(key=lambda x: x[0])
 
     def __iter__(self):
         """ Return all objects in chain.
-        
+
         Handy if the objects are not callable.
         """
         return iter(self.chain)
 
 
-def input_prefilter(self,line):     
-    """ Default input prefilter
-    
-    This returns the line as unchanged, so that the interpreter
-    knows that nothing was done and proceeds with "classic" prefiltering
-    (%magics, !shell commands etc.). 
-    
-    Note that leading whitespace is not passed to this hook. Prefilter
-    can't alter indentation.
-    
-    """
-    #print "attempt to rewrite",line #dbg
-    return line
-
-
-def shutdown_hook(self):
-    """ default shutdown hook
-    
-    Typically, shotdown hooks should raise TryNext so all shutdown ops are done
-    """
-    
-    #print "default shutdown hook ok" # dbg
-    return
-
-
-def late_startup_hook(self):
-    """ Executed after ipython has been constructed and configured 
-    
-    """
-    #print "default startup hook ok" # dbg
-
-
-def generate_prompt(self, is_continuation):
-    """ calculate and return a string with the prompt to display """
-    if is_continuation:
-        return str(self.displayhook.prompt2)
-    return str(self.displayhook.prompt1)
-
-
-def show_in_pager(self,s):
+def show_in_pager(self, data, start, screen_lines):
     """ Run a string through pager """
     # raising TryNext here will use the default paging functionality
     raise TryNext
 
 
-def pre_prompt_hook(self):
-    """ Run before displaying the next prompt
-    
-    Use this e.g. to display output from asynchronous operations (in order 
-    to not mess up text entry)   
-    """
-    
-    return None
-
-
-def pre_run_code_hook(self):
-    """ Executed before running the (prefiltered) code in IPython """
-    return None
-
 
 def clipboard_get(self):
     """ Get text from the clipboard.
     """
-    from IPython.lib.clipboard import (
-        osx_clipboard_get, tkinter_clipboard_get, 
-        win32_clipboard_get
+    from ..lib.clipboard import (
+        osx_clipboard_get,
+        tkinter_clipboard_get,
+        win32_clipboard_get,
+        wayland_clipboard_get,
     )
     if sys.platform == 'win32':
         chain = [win32_clipboard_get, tkinter_clipboard_get]
     elif sys.platform == 'darwin':
         chain = [osx_clipboard_get, tkinter_clipboard_get]
     else:
-        chain = [tkinter_clipboard_get]
+        chain = [wayland_clipboard_get, tkinter_clipboard_get]
     dispatcher = CommandChainDispatcher()
     for func in chain:
         dispatcher.add(func)
diff --git a/IPython/core/inputsplitter.py b/IPython/core/inputsplitter.py
deleted file mode 100644
index 640465d432e..00000000000
--- a/IPython/core/inputsplitter.py
+++ /dev/null
@@ -1,865 +0,0 @@
-"""Analysis of text input into executable blocks.
-
-The main class in this module, :class:`InputSplitter`, is designed to break
-input from either interactive, line-by-line environments or block-based ones,
-into standalone blocks that can be executed by Python as 'single' statements
-(thus triggering sys.displayhook).
-
-A companion, :class:`IPythonInputSplitter`, provides the same functionality but
-with full support for the extended IPython syntax (magics, system calls, etc).
-
-For more details, see the class docstring below.
-
-Syntax Transformations
-----------------------
-
-One of the main jobs of the code in this file is to apply all syntax
-transformations that make up 'the IPython language', i.e. magics, shell
-escapes, etc.  All transformations should be implemented as *fully stateless*
-entities, that simply take one line as their input and return a line.
-Internally for implementation purposes they may be a normal function or a
-callable object, but the only input they receive will be a single line and they
-should only return a line, without holding any data-dependent state between
-calls.
-
-As an example, the EscapedTransformer is a class so we can more clearly group
-together the functionality of dispatching to individual functions based on the
-starting escape character, but the only method for public use is its call
-method.
-
-
-ToDo
-----
-
-- Should we make push() actually raise an exception once push_accepts_more()
-  returns False?
-
-- Naming cleanups.  The tr_* names aren't the most elegant, though now they are
-  at least just attributes of a class so not really very exposed.
-
-- Think about the best way to support dynamic things: automagic, autocall,
-  macros, etc.
-
-- Think of a better heuristic for the application of the transforms in
-  IPythonInputSplitter.push() than looking at the buffer ending in ':'.  Idea:
-  track indentation change events (indent, dedent, nothing) and apply them only
-  if the indentation went up, but not otherwise.
-
-- Think of the cleanest way for supporting user-specified transformations (the
-  user prefilters we had before).
-
-Authors
--------
-
-* Fernando Perez
-* Brian Granger
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-# stdlib
-import ast
-import codeop
-import re
-import sys
-
-# IPython modules
-from IPython.utils.text import make_quoted_expr
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# The escape sequences that define the syntax transformations IPython will
-# apply to user input.  These can NOT be just changed here: many regular
-# expressions and other parts of the code may use their hardcoded values, and
-# for all intents and purposes they constitute the 'IPython syntax', so they
-# should be considered fixed.
-
-ESC_SHELL  = '!'     # Send line to underlying system shell
-ESC_SH_CAP = '!!'    # Send line to system shell and capture output
-ESC_HELP   = '?'     # Find information about object
-ESC_HELP2  = '??'    # Find extra-detailed information about object
-ESC_MAGIC  = '%'     # Call magic function
-ESC_QUOTE  = ','     # Split args on whitespace, quote each as string and call
-ESC_QUOTE2 = ';'     # Quote all args as a single string, call
-ESC_PAREN  = '/'     # Call first argument with rest of line as arguments
-
-#-----------------------------------------------------------------------------
-# Utilities
-#-----------------------------------------------------------------------------
-
-# FIXME: These are general-purpose utilities that later can be moved to the
-# general ward.  Kept here for now because we're being very strict about test
-# coverage with this code, and this lets us ensure that we keep 100% coverage
-# while developing.
-
-# compiled regexps for autoindent management
-dedent_re = re.compile('|'.join([
-    r'^\s+raise(\s.*)?$', # raise statement (+ space + other stuff, maybe)
-    r'^\s+raise\([^\)]*\).*$', # wacky raise with immediate open paren
-    r'^\s+return(\s.*)?$', # normal return (+ space + other stuff, maybe)
-    r'^\s+return\([^\)]*\).*$', # wacky return with immediate open paren
-    r'^\s+pass\s*$' # pass (optionally followed by trailing spaces)
-]))
-ini_spaces_re = re.compile(r'^([ \t\r\f\v]+)')
-
-# regexp to match pure comment lines so we don't accidentally insert 'if 1:'
-# before pure comments
-comment_line_re = re.compile('^\s*\#')
-
-
-def num_ini_spaces(s):
-    """Return the number of initial spaces in a string.
-
-    Note that tabs are counted as a single space.  For now, we do *not* support
-    mixing of tabs and spaces in the user's input.
-
-    Parameters
-    ----------
-    s : string
-
-    Returns
-    -------
-    n : int
-    """
-
-    ini_spaces = ini_spaces_re.match(s)
-    if ini_spaces:
-        return ini_spaces.end()
-    else:
-        return 0
-
-
-def remove_comments(src):
-    """Remove all comments from input source.
-
-    Note: comments are NOT recognized inside of strings!
-
-    Parameters
-    ----------
-    src : string
-      A single or multiline input string.
-
-    Returns
-    -------
-    String with all Python comments removed.
-    """
-
-    return re.sub('#.*', '', src)
-
-
-def get_input_encoding():
-    """Return the default standard input encoding.
-
-    If sys.stdin has no encoding, 'ascii' is returned."""
-    # There are strange environments for which sys.stdin.encoding is None. We
-    # ensure that a valid encoding is returned.
-    encoding = getattr(sys.stdin, 'encoding', None)
-    if encoding is None:
-        encoding = 'ascii'
-    return encoding
-
-#-----------------------------------------------------------------------------
-# Classes and functions for normal Python syntax handling
-#-----------------------------------------------------------------------------
-
-class InputSplitter(object):
-    """An object that can split Python source input in executable blocks.
-
-    This object is designed to be used in one of two basic modes:
-
-    1. By feeding it python source line-by-line, using :meth:`push`.  In this
-       mode, it will return on each push whether the currently pushed code
-       could be executed already.  In addition, it provides a method called
-       :meth:`push_accepts_more` that can be used to query whether more input
-       can be pushed into a single interactive block.
-
-    2. By calling :meth:`split_blocks` with a single, multiline Python string,
-       that is then split into blocks each of which can be executed
-       interactively as a single statement.
-
-    This is a simple example of how an interactive terminal-based client can use
-    this tool::
-
-        isp = InputSplitter()
-        while isp.push_accepts_more():
-            indent = ' '*isp.indent_spaces
-            prompt = '>>> ' + indent
-            line = indent + raw_input(prompt)
-            isp.push(line)
-        print 'Input source was:\n', isp.source_reset(),
-    """
-    # Number of spaces of indentation computed from input that has been pushed
-    # so far.  This is the attributes callers should query to get the current
-    # indentation level, in order to provide auto-indent facilities.
-    indent_spaces = 0
-    # String, indicating the default input encoding.  It is computed by default
-    # at initialization time via get_input_encoding(), but it can be reset by a
-    # client with specific knowledge of the encoding.
-    encoding = ''
-    # String where the current full source input is stored, properly encoded.
-    # Reading this attribute is the normal way of querying the currently pushed
-    # source code, that has been properly encoded.
-    source = ''
-    # Code object corresponding to the current source.  It is automatically
-    # synced to the source, so it can be queried at any time to obtain the code
-    # object; it will be None if the source doesn't compile to valid Python.
-    code = None
-    # Input mode
-    input_mode = 'line'
-    
-    # Private attributes
-    
-    # List with lines of input accumulated so far
-    _buffer = None
-    # Command compiler
-    _compile = None
-    # Mark when input has changed indentation all the way back to flush-left
-    _full_dedent = False
-    # Boolean indicating whether the current block is complete
-    _is_complete = None
-    
-    def __init__(self, input_mode=None):
-        """Create a new InputSplitter instance.
-
-        Parameters
-        ----------
-        input_mode : str
-
-          One of ['line', 'cell']; default is 'line'.
-
-       The input_mode parameter controls how new inputs are used when fed via
-       the :meth:`push` method:
-
-       - 'line': meant for line-oriented clients, inputs are appended one at a
-         time to the internal buffer and the whole buffer is compiled.
-
-       - 'cell': meant for clients that can edit multi-line 'cells' of text at
-          a time.  A cell can contain one or more blocks that can be compile in
-          'single' mode by Python.  In this mode, each new input new input
-          completely replaces all prior inputs.  Cell mode is thus equivalent
-          to prepending a full reset() to every push() call.
-        """
-        self._buffer = []
-        self._compile = codeop.CommandCompiler()
-        self.encoding = get_input_encoding()
-        self.input_mode = InputSplitter.input_mode if input_mode is None \
-                          else input_mode
-
-    def reset(self):
-        """Reset the input buffer and associated state."""
-        self.indent_spaces = 0
-        self._buffer[:] = []
-        self.source = ''
-        self.code = None
-        self._is_complete = False
-        self._full_dedent = False
-
-    def source_reset(self):
-        """Return the input source and perform a full reset.
-        """
-        out = self.source
-        self.reset()
-        return out
-
-    def push(self, lines):
-        """Push one or more lines of input.
-
-        This stores the given lines and returns a status code indicating
-        whether the code forms a complete Python block or not.
-
-        Any exceptions generated in compilation are swallowed, but if an
-        exception was produced, the method returns True.
-
-        Parameters
-        ----------
-        lines : string
-          One or more lines of Python input.
-        
-        Returns
-        -------
-        is_complete : boolean
-          True if the current input source (the result of the current input
-        plus prior inputs) forms a complete Python execution block.  Note that
-        this value is also stored as a private attribute (_is_complete), so it
-        can be queried at any time.
-        """
-        if self.input_mode == 'cell':
-            self.reset()
-        
-        self._store(lines)
-        source = self.source
-
-        # Before calling _compile(), reset the code object to None so that if an
-        # exception is raised in compilation, we don't mislead by having
-        # inconsistent code/source attributes.
-        self.code, self._is_complete = None, None
-
-        # Honor termination lines properly
-        if source.rstrip().endswith('\\'):
-            return False
-
-        self._update_indent(lines)
-        try:
-            self.code = self._compile(source, symbol="exec")
-        # Invalid syntax can produce any of a number of different errors from
-        # inside the compiler, so we have to catch them all.  Syntax errors
-        # immediately produce a 'ready' block, so the invalid Python can be
-        # sent to the kernel for evaluation with possible ipython
-        # special-syntax conversion.
-        except (SyntaxError, OverflowError, ValueError, TypeError,
-                MemoryError):
-            self._is_complete = True
-        else:
-            # Compilation didn't produce any exceptions (though it may not have
-            # given a complete code object)
-            self._is_complete = self.code is not None
-
-        return self._is_complete
-
-    def push_accepts_more(self):
-        """Return whether a block of interactive input can accept more input.
-
-        This method is meant to be used by line-oriented frontends, who need to
-        guess whether a block is complete or not based solely on prior and
-        current input lines.  The InputSplitter considers it has a complete
-        interactive block and will not accept more input only when either a
-        SyntaxError is raised, or *all* of the following are true:
-
-        1. The input compiles to a complete statement.
-        
-        2. The indentation level is flush-left (because if we are indented,
-           like inside a function definition or for loop, we need to keep
-           reading new input).
-          
-        3. There is one extra line consisting only of whitespace.
-
-        Because of condition #3, this method should be used only by
-        *line-oriented* frontends, since it means that intermediate blank lines
-        are not allowed in function definitions (or any other indented block).
-
-        Block-oriented frontends that have a separate keyboard event to
-        indicate execution should use the :meth:`split_blocks` method instead.
-
-        If the current input produces a syntax error, this method immediately
-        returns False but does *not* raise the syntax error exception, as
-        typically clients will want to send invalid syntax to an execution
-        backend which might convert the invalid syntax into valid Python via
-        one of the dynamic IPython mechanisms.
-        """
-
-        # With incomplete input, unconditionally accept more
-        if not self._is_complete:
-            return True
-
-        # If we already have complete input and we're flush left, the answer
-        # depends.  In line mode, if there hasn't been any indentation,
-        # that's it. If we've come back from some indentation, we need
-        # the blank final line to finish.
-        # In cell mode, we need to check how many blocks the input so far
-        # compiles into, because if there's already more than one full
-        # independent block of input, then the client has entered full
-        # 'cell' mode and is feeding lines that each is complete.  In this
-        # case we should then keep accepting. The Qt terminal-like console
-        # does precisely this, to provide the convenience of terminal-like
-        # input of single expressions, but allowing the user (with a
-        # separate keystroke) to switch to 'cell' mode and type multiple
-        # expressions in one shot.
-        if self.indent_spaces==0:
-            if self.input_mode=='line':
-                if not self._full_dedent:
-                    return False
-            else:
-                try:
-                    code_ast = ast.parse(u''.join(self._buffer))
-                except Exception:
-                    return False
-                else:
-                    if len(code_ast.body) == 1:
-                        return False
-
-        # When input is complete, then termination is marked by an extra blank
-        # line at the end.
-        last_line = self.source.splitlines()[-1]
-        return bool(last_line and not last_line.isspace())
-
-    #------------------------------------------------------------------------
-    # Private interface
-    #------------------------------------------------------------------------
-
-    def _find_indent(self, line):
-        """Compute the new indentation level for a single line.
-
-        Parameters
-        ----------
-        line : str
-          A single new line of non-whitespace, non-comment Python input.
-          
-        Returns
-        -------
-        indent_spaces : int
-          New value for the indent level (it may be equal to self.indent_spaces
-        if indentation doesn't change.
-
-        full_dedent : boolean
-          Whether the new line causes a full flush-left dedent.
-        """
-        indent_spaces = self.indent_spaces
-        full_dedent = self._full_dedent
-        
-        inisp = num_ini_spaces(line)
-        if inisp < indent_spaces:
-            indent_spaces = inisp
-            if indent_spaces <= 0:
-                #print 'Full dedent in text',self.source # dbg
-                full_dedent = True
-
-        if line[-1] == ':':
-            indent_spaces += 4
-        elif dedent_re.match(line):
-            indent_spaces -= 4
-            if indent_spaces <= 0:
-                full_dedent = True
-
-        # Safety
-        if indent_spaces < 0:
-            indent_spaces = 0
-            #print 'safety' # dbg
-            
-        return indent_spaces, full_dedent
-    
-    def _update_indent(self, lines):
-        for line in remove_comments(lines).splitlines():
-            if line and not line.isspace():
-                self.indent_spaces, self._full_dedent = self._find_indent(line)
-
-    def _store(self, lines, buffer=None, store='source'):
-        """Store one or more lines of input.
-
-        If input lines are not newline-terminated, a newline is automatically
-        appended."""
-        
-        if buffer is None:
-            buffer = self._buffer
-            
-        if lines.endswith('\n'):
-            buffer.append(lines)
-        else:
-            buffer.append(lines+'\n')
-        setattr(self, store, self._set_source(buffer))
-
-    def _set_source(self, buffer):
-        return u''.join(buffer)
-
-
-#-----------------------------------------------------------------------------
-# Functions and classes for IPython-specific syntactic support
-#-----------------------------------------------------------------------------
-
-# RegExp for splitting line contents into pre-char//first word-method//rest.
-# For clarity, each group in on one line.
-
-line_split = re.compile("""
-             ^(\s*)              # any leading space
-             ([,;/%]|!!?|\?\??)  # escape character or characters
-             \s*(%?[\w\.\*]*)    # function/method, possibly with leading %
-                                 # to correctly treat things like '?%magic'
-             (\s+.*$|$)          # rest of line
-             """, re.VERBOSE)
-
-
-def split_user_input(line):
-    """Split user input into early whitespace, esc-char, function part and rest.
-
-    This is currently handles lines with '=' in them in a very inconsistent
-    manner.
-
-    Examples
-    ========
-    >>> split_user_input('x=1')
-    ('', '', 'x=1', '')
-    >>> split_user_input('?')
-    ('', '?', '', '')
-    >>> split_user_input('??')
-    ('', '??', '', '')
-    >>> split_user_input(' ?')
-    (' ', '?', '', '')
-    >>> split_user_input(' ??')
-    (' ', '??', '', '')
-    >>> split_user_input('??x')
-    ('', '??', 'x', '')
-    >>> split_user_input('?x=1')
-    ('', '', '?x=1', '')
-    >>> split_user_input('!ls')
-    ('', '!', 'ls', '')
-    >>> split_user_input('  !ls')
-    ('  ', '!', 'ls', '')
-    >>> split_user_input('!!ls')
-    ('', '!!', 'ls', '')
-    >>> split_user_input('  !!ls')
-    ('  ', '!!', 'ls', '')
-    >>> split_user_input(',ls')
-    ('', ',', 'ls', '')
-    >>> split_user_input(';ls')
-    ('', ';', 'ls', '')
-    >>> split_user_input('  ;ls')
-    ('  ', ';', 'ls', '')
-    >>> split_user_input('f.g(x)')
-    ('', '', 'f.g(x)', '')
-    >>> split_user_input('f.g (x)')
-    ('', '', 'f.g', '(x)')
-    >>> split_user_input('?%hist')
-    ('', '?', '%hist', '')
-    >>> split_user_input('?x*')
-    ('', '?', 'x*', '')
-    """
-    match = line_split.match(line)
-    if match:
-        lspace, esc, fpart, rest = match.groups()
-    else:
-        # print "match failed for line '%s'" % line
-        try:
-            fpart, rest = line.split(None, 1)
-        except ValueError:
-            # print "split failed for line '%s'" % line
-            fpart, rest = line,''
-        lspace = re.match('^(\s*)(.*)', line).groups()[0]
-        esc = ''
-
-    # fpart has to be a valid python identifier, so it better be only pure
-    # ascii, no unicode:
-    try:
-        fpart = fpart.encode('ascii')
-    except UnicodeEncodeError:
-        lspace = unicode(lspace)
-        rest = fpart + u' ' + rest
-        fpart = u''
-
-    #print 'line:<%s>' % line # dbg
-    #print 'esc <%s> fpart <%s> rest <%s>' % (esc,fpart.strip(),rest) # dbg
-    return lspace, esc, fpart.strip(), rest.lstrip()
-
-
-# The escaped translators ALL receive a line where their own escape has been
-# stripped.  Only '?' is valid at the end of the line, all others can only be
-# placed at the start.
-
-class LineInfo(object):
-    """A single line of input and associated info.
-
-    This is a utility class that mostly wraps the output of
-    :func:`split_user_input` into a convenient object to be passed around
-    during input transformations.
-
-    Includes the following as properties: 
-
-    line
-      The original, raw line
-
-    lspace
-      Any early whitespace before actual text starts.
-
-    esc
-      The initial esc character (or characters, for double-char escapes like
-      '??' or '!!').
-    
-    fpart
-      The 'function part', which is basically the maximal initial sequence
-      of valid python identifiers and the '.' character.  This is what is
-      checked for alias and magic transformations, used for auto-calling,
-      etc.
-    
-    rest
-      Everything else on the line.
-    """
-    def __init__(self, line):
-        self.line = line
-        self.lspace, self.esc, self.fpart, self.rest = \
-                             split_user_input(line)
-
-    def __str__(self):                                                         
-        return "LineInfo [%s|%s|%s|%s]" % (self.lspace, self.esc,
-                                           self.fpart, self.rest)
-
-
-# Transformations of the special syntaxes that don't rely on an explicit escape
-# character but instead on patterns on the input line
-
-# The core transformations are implemented as standalone functions that can be
-# tested and validated in isolation.  Each of these uses a regexp, we
-# pre-compile these and keep them close to each function definition for clarity
-
-_assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
-                               r'\s*=\s*!\s*(?P<cmd>.*)')
-
-def transform_assign_system(line):
-    """Handle the `files = !ls` syntax."""
-    m = _assign_system_re.match(line)
-    if m is not None:
-        cmd = m.group('cmd')
-        lhs = m.group('lhs')
-        expr = make_quoted_expr(cmd)
-        new_line = '%s = get_ipython().getoutput(%s)' % (lhs, expr)
-        return new_line
-    return line
-
-
-_assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
-                               r'\s*=\s*%\s*(?P<cmd>.*)')
-
-def transform_assign_magic(line):
-    """Handle the `a = %who` syntax."""
-    m = _assign_magic_re.match(line)
-    if m is not None:
-        cmd = m.group('cmd')
-        lhs = m.group('lhs')
-        expr = make_quoted_expr(cmd)
-        new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
-        return new_line
-    return line
-
-
-_classic_prompt_re = re.compile(r'^([ \t]*>>> |^[ \t]*\.\.\. )')
-
-def transform_classic_prompt(line):
-    """Handle inputs that start with '>>> ' syntax."""
-
-    if not line or line.isspace():
-        return line
-    m = _classic_prompt_re.match(line)
-    if m:
-        return line[len(m.group(0)):]
-    else:
-        return line
-
-
-_ipy_prompt_re = re.compile(r'^([ \t]*In \[\d+\]: |^[ \t]*\ \ \ \.\.\.+: )')
-
-def transform_ipy_prompt(line):
-    """Handle inputs that start classic IPython prompt syntax."""
-
-    if not line or line.isspace():
-        return line
-    #print 'LINE:  %r' % line # dbg
-    m = _ipy_prompt_re.match(line)
-    if m:
-        #print 'MATCH! %r -> %r' % (line, line[len(m.group(0)):]) # dbg
-        return line[len(m.group(0)):]
-    else:
-        return line
-
-
-class EscapedTransformer(object):
-    """Class to transform lines that are explicitly escaped out."""
-
-    def __init__(self):
-        tr = { ESC_SHELL  : self._tr_system,
-               ESC_SH_CAP : self._tr_system2,
-               ESC_HELP   : self._tr_help,
-               ESC_HELP2  : self._tr_help,
-               ESC_MAGIC  : self._tr_magic,
-               ESC_QUOTE  : self._tr_quote,
-               ESC_QUOTE2 : self._tr_quote2,
-               ESC_PAREN  : self._tr_paren }
-        self.tr = tr
-        
-    # Support for syntax transformations that use explicit escapes typed by the
-    # user at the beginning of a line
-    @staticmethod
-    def _tr_system(line_info):
-        "Translate lines escaped with: !"
-        cmd = line_info.line.lstrip().lstrip(ESC_SHELL)
-        return '%sget_ipython().system(%s)' % (line_info.lspace,
-                                               make_quoted_expr(cmd))
-
-    @staticmethod
-    def _tr_system2(line_info):
-        "Translate lines escaped with: !!"
-        cmd = line_info.line.lstrip()[2:]
-        return '%sget_ipython().getoutput(%s)' % (line_info.lspace,
-                                                  make_quoted_expr(cmd))
-
-    @staticmethod
-    def _tr_help(line_info):
-        "Translate lines escaped with: ?/??"
-        # A naked help line should just fire the intro help screen
-        if not line_info.line[1:]:
-            return 'get_ipython().show_usage()'
-
-        # There may be one or two '?' at the end, move them to the front so that
-        # the rest of the logic can assume escapes are at the start
-        l_ori = line_info
-        line = line_info.line
-        if line.endswith('?'):
-            line = line[-1] + line[:-1]
-        if line.endswith('?'):
-            line = line[-1] + line[:-1]
-        line_info = LineInfo(line)
-
-        # From here on, simply choose which level of detail to get, and
-        # special-case the psearch syntax
-        pinfo = 'pinfo' # default
-        if '*' in line_info.line:
-            pinfo = 'psearch'
-        elif line_info.esc == '??':
-            pinfo = 'pinfo2'
-
-        tpl = '%sget_ipython().magic(u"%s %s")'
-        return tpl % (line_info.lspace, pinfo,
-                      ' '.join([line_info.fpart, line_info.rest]).strip())
-
-    @staticmethod
-    def _tr_magic(line_info):
-        "Translate lines escaped with: %"
-        tpl = '%sget_ipython().magic(%s)'
-        cmd = make_quoted_expr(' '.join([line_info.fpart,
-                                         line_info.rest]).strip())
-        return tpl % (line_info.lspace, cmd)
-
-    @staticmethod
-    def _tr_quote(line_info):
-        "Translate lines escaped with: ,"
-        return '%s%s("%s")' % (line_info.lspace, line_info.fpart,
-                             '", "'.join(line_info.rest.split()) )
-
-    @staticmethod
-    def _tr_quote2(line_info):
-        "Translate lines escaped with: ;"
-        return '%s%s("%s")' % (line_info.lspace, line_info.fpart,
-                               line_info.rest)
-
-    @staticmethod
-    def _tr_paren(line_info):
-        "Translate lines escaped with: /"
-        return '%s%s(%s)' % (line_info.lspace, line_info.fpart,
-                             ", ".join(line_info.rest.split()))
-
-    def __call__(self, line):
-        """Class to transform lines that are explicitly escaped out.
-
-        This calls the above _tr_* static methods for the actual line
-        translations."""
-
-        # Empty lines just get returned unmodified
-        if not line or line.isspace():
-            return line
-
-        # Get line endpoints, where the escapes can be
-        line_info = LineInfo(line)
-
-        # If the escape is not at the start, only '?' needs to be special-cased.
-        # All other escapes are only valid at the start
-        if not line_info.esc in self.tr:
-            if line.endswith(ESC_HELP):
-                return self._tr_help(line_info)
-            else:
-                # If we don't recognize the escape, don't modify the line
-                return line
-
-        return self.tr[line_info.esc](line_info)
-
-
-# A function-looking object to be used by the rest of the code.  The purpose of
-# the class in this case is to organize related functionality, more than to
-# manage state.
-transform_escaped = EscapedTransformer()
-
-
-class IPythonInputSplitter(InputSplitter):
-    """An input splitter that recognizes all of IPython's special syntax."""
-
-    # String with raw, untransformed input.
-    source_raw = ''
-
-    # Private attributes
-    
-    # List with lines of raw input accumulated so far.
-    _buffer_raw = None
-
-    def __init__(self, input_mode=None):
-        InputSplitter.__init__(self, input_mode)
-        self._buffer_raw = []
-        
-    def reset(self):
-        """Reset the input buffer and associated state."""
-        InputSplitter.reset(self)
-        self._buffer_raw[:] = []
-        self.source_raw = ''
-
-    def source_raw_reset(self):
-        """Return input and raw source and perform a full reset.
-        """
-        out = self.source
-        out_r = self.source_raw
-        self.reset()
-        return out, out_r
-
-    def push(self, lines):
-        """Push one or more lines of IPython input.
-        """
-        if not lines:
-            return super(IPythonInputSplitter, self).push(lines)
-
-        # We must ensure all input is pure unicode
-        if type(lines)==str:
-            lines = lines.decode(self.encoding)
-
-        lines_list = lines.splitlines()
-
-        transforms = [transform_escaped, transform_assign_system,
-                      transform_assign_magic, transform_ipy_prompt,
-                      transform_classic_prompt]
-
-        # Transform logic
-        #
-        # We only apply the line transformers to the input if we have either no
-        # input yet, or complete input, or if the last line of the buffer ends
-        # with ':' (opening an indented block).  This prevents the accidental
-        # transformation of escapes inside multiline expressions like
-        # triple-quoted strings or parenthesized expressions.
-        #
-        # The last heuristic, while ugly, ensures that the first line of an
-        # indented block is correctly transformed.
-        #
-        # FIXME: try to find a cleaner approach for this last bit.
-
-        # If we were in 'block' mode, since we're going to pump the parent
-        # class by hand line by line, we need to temporarily switch out to
-        # 'line' mode, do a single manual reset and then feed the lines one
-        # by one.  Note that this only matters if the input has more than one
-        # line.
-        changed_input_mode = False
-
-        if self.input_mode == 'cell':
-            self.reset()
-            changed_input_mode = True
-            saved_input_mode = 'cell'
-            self.input_mode = 'line'
-
-        # Store raw source before applying any transformations to it.  Note
-        # that this must be done *after* the reset() call that would otherwise
-        # flush the buffer.
-        self._store(lines, self._buffer_raw, 'source_raw')
-        
-        try:
-            push = super(IPythonInputSplitter, self).push
-            for line in lines_list:
-                if self._is_complete or not self._buffer or \
-                   (self._buffer and self._buffer[-1].rstrip().endswith(':')):
-                    for f in transforms:
-                        line = f(line)
-
-                out = push(line)
-        finally:
-            if changed_input_mode:
-                self.input_mode = saved_input_mode
-        return out
diff --git a/IPython/core/inputtransformer2.py b/IPython/core/inputtransformer2.py
new file mode 100644
index 00000000000..416522abac4
--- /dev/null
+++ b/IPython/core/inputtransformer2.py
@@ -0,0 +1,875 @@
+"""Input transformer machinery to support IPython special syntax.
+
+This includes the machinery to recognise and transform ``%magic`` commands,
+``!system`` commands, ``help?`` querying, prompt stripping, and so forth.
+
+Added: IPython 7.0. Replaces inputsplitter and inputtransformer which were
+deprecated in 7.0 and removed in 9.0
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import ast
+from codeop import CommandCompiler, Compile
+import re
+import sys
+import tokenize
+from typing import List, Tuple, Optional, Any
+import warnings
+from textwrap import dedent
+
+from IPython.utils import tokenutil
+
+_indent_re = re.compile(r'^[ \t]+')
+
+def leading_empty_lines(lines):
+    """Remove leading empty lines
+
+    If the leading lines are empty or contain only whitespace, they will be
+    removed.
+    """
+    if not lines:
+        return lines
+    for i, line in enumerate(lines):
+        if line and not line.isspace():
+            return lines[i:]
+    return lines
+
+def leading_indent(lines):
+    """Remove leading indentation.
+
+    Removes the minimum common leading indentation from all lines.
+    """
+    if not lines:
+        return lines
+    return dedent("".join(lines)).splitlines(keepends=True)
+
+class PromptStripper:
+    """Remove matching input prompts from a block of input.
+
+    Parameters
+    ----------
+    prompt_re : regular expression
+        A regular expression matching any input prompt (including continuation,
+        e.g. ``...``)
+    initial_re : regular expression, optional
+        A regular expression matching only the initial prompt, but not continuation.
+        If no initial expression is given, prompt_re will be used everywhere.
+        Used mainly for plain Python prompts (``>>>``), where the continuation prompt
+        ``...`` is a valid Python expression in Python 3, so shouldn't be stripped.
+
+    Notes
+    -----
+
+    If initial_re and prompt_re differ,
+    only initial_re will be tested against the first line.
+    If any prompt is found on the first two lines,
+    prompts will be stripped from the rest of the block.
+    """
+    def __init__(self, prompt_re, initial_re=None, *, doctest=False):
+        self.prompt_re = prompt_re
+        self.initial_re = initial_re or prompt_re
+        self.doctest = doctest
+        if doctest:
+            # Doctest/xdoctest prompts may be indented (e.g. "    >>>").
+            # We only treat "..." as a continuation prompt when the same pasted
+            # block contains at least one ">>>" line, to avoid ambiguity with the
+            # Python Ellipsis literal.
+            self._doctest_initial_re = re.compile(r'^\s*>>>')
+            self._doctest_ps1_re = re.compile(r'^\s*>>>\s?')
+            self._doctest_ps2_re = re.compile(r'^\s*\.\.\.\s?')
+
+            # Very small state machine to detect triple-quoted strings in the
+            # *same* input block (e.g. user typed """ then pasted doctest).
+            # We preserve literal >>> / ... inside triple-quoted strings.
+            self._triple_quote_re = re.compile(r"(?<!\\)(\"\"\"|''')")
+
+
+    def _triple_quote_mask(self, lines: List[str]) -> List[bool]:
+        """
+        Return a boolean mask: True if the corresponding line is considered
+        inside a triple-quoted string literal.
+
+        This is intentionally heuristic (fast + good enough for paste handling).
+        """
+        mask: List[bool] = []
+        in_triple: str | None = None  # either ''' or """
+        for line in lines:
+            mask.append(in_triple is not None)
+            # Toggle state for each occurrence of """ or ''' in the line.
+            for m in self._triple_quote_re.finditer(line):
+                q = m.group(1)
+                if in_triple is None:
+                    in_triple = q
+                    mask[-1] = True  # current line is inside triple quotes
+                elif in_triple == q:
+                    in_triple = None
+                # else: ignore mismatched triple quote while inside
+        return mask
+
+
+    def _strip(self, lines):
+        return [self.prompt_re.sub('', l, count=1) for l in lines]
+
+    def __call__(self, lines):
+        if not lines:
+            return lines
+
+        if self.doctest:
+            triple_mask = self._triple_quote_mask(lines)
+
+            # Detect doctest prompts only outside triple-quoted strings.
+            has_doctest_outside = any(
+                (not in_triple) and self._doctest_initial_re.match(l)
+                for l, in_triple in zip(lines, triple_mask)
+            )
+            if not has_doctest_outside:
+                return lines
+
+            out_lines: List[str] = []
+            stripped_mask: List[bool] = []
+
+            for l, in_triple in zip(lines, triple_mask):
+                if in_triple:
+                    out_lines.append(l)
+                    stripped_mask.append(False)
+                    continue
+
+                if self._doctest_ps1_re.match(l):
+                    new_l = self._doctest_ps1_re.sub('', l, count=1)
+                elif self._doctest_ps2_re.match(l):
+                    new_l = self._doctest_ps2_re.sub('', l, count=1)
+                else:
+                    new_l = l
+                out_lines.append(new_l)
+                stripped_mask.append(new_l != l)
+
+            # Dedent only the non-triple-quoted segments where stripping occurred.
+            dedented: List[str] = []
+            i = 0
+            while i < len(out_lines):
+                j = i
+                in_triple = triple_mask[i]
+                while j < len(out_lines) and triple_mask[j] == in_triple:
+                    j += 1
+
+                segment = out_lines[i:j]
+                seg_stripped = any(stripped_mask[i:j])
+
+                if (not in_triple) and seg_stripped:
+                    dedented.extend(dedent(''.join(segment)).splitlines(keepends=True))
+                else:
+                    dedented.extend(segment)
+
+                i = j
+
+            return dedented
+
+        if self.initial_re.match(lines[0]) or \
+                (len(lines) > 1 and self.prompt_re.match(lines[1])):
+            return self._strip(lines)
+        return lines
+
+classic_prompt = PromptStripper(
+    prompt_re=re.compile(r'^(>>>|\.\.\.)( |$)'),
+    initial_re=re.compile(r'^>>>( |$)'),
+    doctest=True,
+)
+
+ipython_prompt = PromptStripper(
+    re.compile(
+        r"""
+        ^(                         # Match from the beginning of a line, either:
+
+                                   # 1. First-line prompt:
+        ((\[nav\]|\[ins\])?\ )?    # Vi editing mode prompt, if it's there
+        In\                        # The 'In' of the prompt, with a space
+        \[\d+\]:                   # Command index, as displayed in the prompt
+        \                          # With a mandatory trailing space
+
+        |                          # ... or ...
+
+                                   # 2. The three dots of the multiline prompt
+        \s*                        # All leading whitespace characters
+        \.{3,}:                    # The three (or more) dots
+        \ ?                        # With an optional trailing space
+
+        )
+        """,
+        re.VERBOSE,
+    )
+)
+
+
+def cell_magic(lines):
+    if not lines or not lines[0].startswith('%%'):
+        return lines
+    if re.match(r'%%\w+\?', lines[0]):
+        # This case will be handled by help_end
+        return lines
+    magic_name, _, first_line = lines[0][2:].rstrip().partition(' ')
+    body = ''.join(lines[1:])
+    return ['get_ipython().run_cell_magic(%r, %r, %r)\n'
+            % (magic_name, first_line, body)]
+
+
+def _find_assign_op(token_line) -> Optional[int]:
+    """Get the index of the first assignment in the line ('=' not inside brackets)
+
+    Note: We don't try to support multiple special assignment (a = b = %foo)
+    """
+    paren_level = 0
+    for i, ti in enumerate(token_line):
+        s = ti.string
+        if s == '=' and paren_level == 0:
+            return i
+        if s in {'(','[','{'}:
+            paren_level += 1
+        elif s in {')', ']', '}'}:
+            if paren_level > 0:
+                paren_level -= 1
+    return None
+
+def find_end_of_continued_line(lines, start_line: int):
+    """Find the last line of a line explicitly extended using backslashes.
+
+    Uses 0-indexed line numbers.
+    """
+    end_line = start_line
+    while lines[end_line].endswith('\\\n'):
+        end_line += 1
+        if end_line >= len(lines):
+            break
+    return end_line
+
+def assemble_continued_line(lines, start: Tuple[int, int], end_line: int):
+    r"""Assemble a single line from multiple continued line pieces
+
+    Continued lines are lines ending in ``\``, and the line following the last
+    ``\`` in the block.
+
+    For example, this code continues over multiple lines::
+
+        if (assign_ix is not None) \
+             and (len(line) >= assign_ix + 2) \
+             and (line[assign_ix+1].string == '%') \
+             and (line[assign_ix+2].type == tokenize.NAME):
+
+    This statement contains four continued line pieces.
+    Assembling these pieces into a single line would give::
+
+        if (assign_ix is not None) and (len(line) >= assign_ix + 2) and (line[...
+
+    This uses 0-indexed line numbers. *start* is (lineno, colno).
+
+    Used to allow ``%magic`` and ``!system`` commands to be continued over
+    multiple lines.
+    """
+    parts = [lines[start[0]][start[1]:]] + lines[start[0]+1:end_line+1]
+    return ' '.join([p.rstrip()[:-1] for p in parts[:-1]]  # Strip backslash+newline
+                    + [parts[-1].rstrip()])         # Strip newline from last line
+
+class TokenTransformBase:
+    """Base class for transformations which examine tokens.
+
+    Special syntax should not be transformed when it occurs inside strings or
+    comments. This is hard to reliably avoid with regexes. The solution is to
+    tokenise the code as Python, and recognise the special syntax in the tokens.
+
+    IPython's special syntax is not valid Python syntax, so tokenising may go
+    wrong after the special syntax starts. These classes therefore find and
+    transform *one* instance of special syntax at a time into regular Python
+    syntax. After each transformation, tokens are regenerated to find the next
+    piece of special syntax.
+
+    Subclasses need to implement one class method (find)
+    and one regular method (transform).
+
+    The priority attribute can select which transformation to apply if multiple
+    transformers match in the same place. Lower numbers have higher priority.
+    This allows "%magic?" to be turned into a help call rather than a magic call.
+    """
+    # Lower numbers -> higher priority (for matches in the same location)
+    priority = 10
+
+    def sortby(self):
+        return self.start_line, self.start_col, self.priority
+
+    def __init__(self, start):
+        self.start_line = start[0] - 1   # Shift from 1-index to 0-index
+        self.start_col = start[1]
+
+    @classmethod
+    def find(cls, tokens_by_line):
+        """Find one instance of special syntax in the provided tokens.
+
+        Tokens are grouped into logical lines for convenience,
+        so it is easy to e.g. look at the first token of each line.
+        *tokens_by_line* is a list of lists of tokenize.TokenInfo objects.
+
+        This should return an instance of its class, pointing to the start
+        position it has found, or None if it found no match.
+        """
+        raise NotImplementedError
+
+    def transform(self, lines: List[str]):
+        """Transform one instance of special syntax found by ``find()``
+
+        Takes a list of strings representing physical lines,
+        returns a similar list of transformed lines.
+        """
+        raise NotImplementedError
+
+class MagicAssign(TokenTransformBase):
+    """Transformer for assignments from magics (a = %foo)"""
+    @classmethod
+    def find(cls, tokens_by_line):
+        """Find the first magic assignment (a = %foo) in the cell.
+        """
+        for line in tokens_by_line:
+            assign_ix = _find_assign_op(line)
+            if (assign_ix is not None) \
+                    and (len(line) >= assign_ix + 2) \
+                    and (line[assign_ix+1].string == '%') \
+                    and (line[assign_ix+2].type == tokenize.NAME):
+                return cls(line[assign_ix+1].start)
+
+    def transform(self, lines: List[str]):
+        """Transform a magic assignment found by the ``find()`` classmethod.
+        """
+        start_line, start_col = self.start_line, self.start_col
+        lhs = lines[start_line][:start_col]
+        end_line = find_end_of_continued_line(lines, start_line)
+        rhs = assemble_continued_line(lines, (start_line, start_col), end_line)
+        assert rhs.startswith('%'), rhs
+        magic_name, _, args = rhs[1:].partition(' ')
+
+        lines_before = lines[:start_line]
+        call = "get_ipython().run_line_magic({!r}, {!r})".format(magic_name, args)
+        new_line = lhs + call + '\n'
+        lines_after = lines[end_line+1:]
+
+        return lines_before + [new_line] + lines_after
+
+
+class SystemAssign(TokenTransformBase):
+    """Transformer for assignments from system commands (a = !foo)"""
+    @classmethod
+    def find(cls, tokens_by_line):
+        """Find the first system assignment (a = !foo) in the cell."""
+        for line in tokens_by_line:
+            assign_ix = _find_assign_op(line)
+            if (
+                (assign_ix is not None)
+                and not line[assign_ix].line.strip().startswith("=")
+                and (len(line) >= assign_ix + 2)
+                and (line[assign_ix + 1].type == tokenize.OP)
+                and (line[assign_ix + 1].string == "!")
+            ):
+                return cls(line[assign_ix + 1].start)
+
+    def transform(self, lines: List[str]):
+        """Transform a system assignment found by the ``find()`` classmethod.
+        """
+        start_line, start_col = self.start_line, self.start_col
+
+        lhs = lines[start_line][:start_col]
+        end_line = find_end_of_continued_line(lines, start_line)
+        rhs = assemble_continued_line(lines, (start_line, start_col), end_line)
+        assert rhs.startswith('!'), rhs
+        cmd = rhs[1:]
+
+        lines_before = lines[:start_line]
+        call = "get_ipython().getoutput({!r})".format(cmd)
+        new_line = lhs + call + '\n'
+        lines_after = lines[end_line + 1:]
+
+        return lines_before + [new_line] + lines_after
+
+# The escape sequences that define the syntax transformations IPython will
+# apply to user input.  These can NOT be just changed here: many regular
+# expressions and other parts of the code may use their hardcoded values, and
+# for all intents and purposes they constitute the 'IPython syntax', so they
+# should be considered fixed.
+
+ESC_SHELL  = '!'     # Send line to underlying system shell
+ESC_SH_CAP = '!!'    # Send line to system shell and capture output
+ESC_HELP   = '?'     # Find information about object
+ESC_HELP2  = '??'    # Find extra-detailed information about object
+ESC_MAGIC  = '%'     # Call magic function
+ESC_MAGIC2 = '%%'    # Call cell-magic function
+ESC_QUOTE  = ','     # Split args on whitespace, quote each as string and call
+ESC_QUOTE2 = ';'     # Quote all args as a single string, call
+ESC_PAREN  = '/'     # Call first argument with rest of line as arguments
+
+ESCAPE_SINGLES = {'!', '?', '%', ',', ';', '/'}
+ESCAPE_DOUBLES = {'!!', '??'}  # %% (cell magic) is handled separately
+
+def _make_help_call(target, esc):
+    """Prepares a pinfo(2)/psearch call from a target name and the escape
+    (i.e. ? or ??)"""
+    method  = 'pinfo2' if esc == '??' \
+                else 'psearch' if '*' in target \
+                else 'pinfo'
+    arg = " ".join([method, target])
+    #Prepare arguments for get_ipython().run_line_magic(magic_name, magic_args)
+    t_magic_name, _, t_magic_arg_s = arg.partition(' ')
+    t_magic_name = t_magic_name.lstrip(ESC_MAGIC)
+    return "get_ipython().run_line_magic(%r, %r)" % (t_magic_name, t_magic_arg_s)
+
+
+def _tr_help(content):
+    """Translate lines escaped with: ?
+
+    A naked help line should fire the intro help screen (shell.show_usage())
+    """
+    if not content:
+        return 'get_ipython().show_usage()'
+
+    return _make_help_call(content, '?')
+
+def _tr_help2(content):
+    """Translate lines escaped with: ??
+
+    A naked help line should fire the intro help screen (shell.show_usage())
+    """
+    if not content:
+        return 'get_ipython().show_usage()'
+
+    return _make_help_call(content, '??')
+
+def _tr_magic(content):
+    "Translate lines escaped with a percent sign: %"
+    name, _, args = content.partition(' ')
+    return 'get_ipython().run_line_magic(%r, %r)' % (name, args)
+
+def _tr_quote(content):
+    "Translate lines escaped with a comma: ,"
+    name, _, args = content.partition(' ')
+    return '%s("%s")' % (name, '", "'.join(args.split()) )
+
+def _tr_quote2(content):
+    "Translate lines escaped with a semicolon: ;"
+    name, _, args = content.partition(' ')
+    return '%s("%s")' % (name, args)
+
+def _tr_paren(content):
+    "Translate lines escaped with a slash: /"
+    name, _, args = content.partition(" ")
+    if name == "":
+        raise SyntaxError(f'"{ESC_SHELL}" must be followed by a callable name')
+
+    return '%s(%s)' % (name, ", ".join(args.split()))
+
+tr = { ESC_SHELL  : 'get_ipython().system({!r})'.format,
+       ESC_SH_CAP : 'get_ipython().getoutput({!r})'.format,
+       ESC_HELP   : _tr_help,
+       ESC_HELP2  : _tr_help2,
+       ESC_MAGIC  : _tr_magic,
+       ESC_QUOTE  : _tr_quote,
+       ESC_QUOTE2 : _tr_quote2,
+       ESC_PAREN  : _tr_paren }
+
+class EscapedCommand(TokenTransformBase):
+    """Transformer for escaped commands like %foo, !foo, or /foo"""
+    @classmethod
+    def find(cls, tokens_by_line):
+        """Find the first escaped command (%foo, !foo, etc.) in the cell.
+        """
+        for line in tokens_by_line:
+            if not line:
+                continue
+            ix = 0
+            ll = len(line)
+            while ll > ix and line[ix].type in {tokenize.INDENT, tokenize.DEDENT}:
+                ix += 1
+            if ix >= ll:
+                continue
+            if line[ix].string in ESCAPE_SINGLES:
+                return cls(line[ix].start)
+
+    def transform(self, lines):
+        """Transform an escaped line found by the ``find()`` classmethod.
+        """
+        start_line, start_col = self.start_line, self.start_col
+
+        indent = lines[start_line][:start_col]
+        end_line = find_end_of_continued_line(lines, start_line)
+        line = assemble_continued_line(lines, (start_line, start_col), end_line)
+
+        if len(line) > 1 and line[:2] in ESCAPE_DOUBLES:
+            escape, content = line[:2], line[2:]
+        else:
+            escape, content = line[:1], line[1:]
+
+        if escape in tr:
+            call = tr[escape](content)
+        else:
+            call = ''
+
+        lines_before = lines[:start_line]
+        new_line = indent + call + '\n'
+        lines_after = lines[end_line + 1:]
+
+        return lines_before + [new_line] + lines_after
+
+
+_help_end_re = re.compile(
+    r"""(%{0,2}
+    (?!\d)[\w*]+            # Variable name
+    (\.(?!\d)[\w*]+|\[-?[0-9]+\])*       # .etc.etc or [0], we only support literal integers.
+    )
+    (\?\??)$                # ? or ??
+    """,
+    re.VERBOSE,
+)
+
+
+class HelpEnd(TokenTransformBase):
+    """Transformer for help syntax: obj? and obj??"""
+    # This needs to be higher priority (lower number) than EscapedCommand so
+    # that inspecting magics (%foo?) works.
+    priority = 5
+
+    def __init__(self, start, q_locn):
+        super().__init__(start)
+        self.q_line = q_locn[0] - 1  # Shift from 1-indexed to 0-indexed
+        self.q_col = q_locn[1]
+
+    @classmethod
+    def find(cls, tokens_by_line):
+        """Find the first help command (foo?) in the cell.
+        """
+        for line in tokens_by_line:
+            # Last token is NEWLINE; look at last but one
+            if len(line) > 2 and line[-2].string == '?':
+                # Find the first token that's not INDENT/DEDENT
+                ix = 0
+                while line[ix].type in {tokenize.INDENT, tokenize.DEDENT}:
+                    ix += 1
+                return cls(line[ix].start, line[-2].start)
+
+    def transform(self, lines):
+        """Transform a help command found by the ``find()`` classmethod.
+        """
+
+        piece = "".join(lines[self.start_line : self.q_line + 1])
+        indent, content = piece[: self.start_col], piece[self.start_col :]
+        lines_before = lines[: self.start_line]
+        lines_after = lines[self.q_line + 1 :]
+
+        m = _help_end_re.search(content)
+        if not m:
+            raise SyntaxError(content)
+        assert m is not None, content
+        target = m.group(1)
+        esc = m.group(3)
+
+
+        call = _make_help_call(target, esc)
+        new_line = indent + call + '\n'
+
+        return lines_before + [new_line] + lines_after
+
+def make_tokens_by_line(lines:List[str]):
+    """Tokenize a series of lines and group tokens by line.
+
+    The tokens for a multiline Python string or expression are grouped as one
+    line. All lines except the last lines should keep their line ending ('\\n',
+    '\\r\\n') for this to properly work. Use `.splitlines(keeplineending=True)`
+    for example when passing block of text to this function.
+
+    """
+    # NL tokens are used inside multiline expressions, but also after blank
+    # lines or comments. This is intentional - see https://bugs.python.org/issue17061
+    # We want to group the former case together but split the latter, so we
+    # track parentheses level, similar to the internals of tokenize.
+
+    #   reexported from token on 3.7+
+    NEWLINE, NL = tokenize.NEWLINE, tokenize.NL  # type: ignore
+    tokens_by_line: List[List[Any]] = [[]]
+    if len(lines) > 1 and not lines[0].endswith(("\n", "\r", "\r\n", "\x0b", "\x0c")):
+        warnings.warn(
+            "`make_tokens_by_line` received a list of lines which do not have lineending markers ('\\n', '\\r', '\\r\\n', '\\x0b', '\\x0c'), behavior will be unspecified",
+            stacklevel=2,
+        )
+    parenlev = 0
+    try:
+        for token in tokenutil.generate_tokens_catch_errors(
+            iter(lines).__next__, extra_errors_to_catch=["expected EOF"]
+        ):
+            tokens_by_line[-1].append(token)
+            if (token.type == NEWLINE) \
+                    or ((token.type == NL) and (parenlev <= 0)):
+                tokens_by_line.append([])
+            elif token.string in {'(', '[', '{'}:
+                parenlev += 1
+            elif token.string in {')', ']', '}'}:
+                if parenlev > 0:
+                    parenlev -= 1
+    except tokenize.TokenError:
+        # Input ended in a multiline string or expression. That's OK for us.
+        pass
+
+
+    if not tokens_by_line[-1]:
+        tokens_by_line.pop()
+
+
+    return tokens_by_line
+
+
+def has_sunken_brackets(tokens: List[tokenize.TokenInfo]):
+    """Check if the depth of brackets in the list of tokens drops below 0"""
+    parenlev = 0
+    for token in tokens:
+        if token.string in {"(", "[", "{"}:
+            parenlev += 1
+        elif token.string in {")", "]", "}"}:
+            parenlev -= 1
+            if parenlev < 0:
+                return True
+    return False
+
+# Arbitrary limit to prevent getting stuck in infinite loops
+TRANSFORM_LOOP_LIMIT = 500
+
+class TransformerManager:
+    """Applies various transformations to a cell or code block.
+
+    The key methods for external use are ``transform_cell()``
+    and ``check_complete()``.
+    """
+    def __init__(self):
+        self.cleanup_transforms = [
+            leading_empty_lines,
+            leading_indent,
+            classic_prompt,
+            ipython_prompt,
+        ]
+        self.line_transforms = [
+            cell_magic,
+        ]
+        self.token_transformers = [
+            MagicAssign,
+            SystemAssign,
+            EscapedCommand,
+            HelpEnd,
+        ]
+
+    def do_one_token_transform(self, lines):
+        """Find and run the transform earliest in the code.
+
+        Returns (changed, lines).
+
+        This method is called repeatedly until changed is False, indicating
+        that all available transformations are complete.
+
+        The tokens following IPython special syntax might not be valid, so
+        the transformed code is retokenised every time to identify the next
+        piece of special syntax. Hopefully long code cells are mostly valid
+        Python, not using lots of IPython special syntax, so this shouldn't be
+        a performance issue.
+        """
+        tokens_by_line = make_tokens_by_line(lines)
+        candidates = []
+        for transformer_cls in self.token_transformers:
+            transformer = transformer_cls.find(tokens_by_line)
+            if transformer:
+                candidates.append(transformer)
+
+        if not candidates:
+            # Nothing to transform
+            return False, lines
+        ordered_transformers = sorted(candidates, key=TokenTransformBase.sortby)
+        for transformer in ordered_transformers:
+            try:
+                return True, transformer.transform(lines)
+            except SyntaxError:
+                pass
+        return False, lines
+
+    def do_token_transforms(self, lines):
+        for _ in range(TRANSFORM_LOOP_LIMIT):
+            changed, lines = self.do_one_token_transform(lines)
+            if not changed:
+                return lines
+
+        raise RuntimeError("Input transformation still changing after "
+                           "%d iterations. Aborting." % TRANSFORM_LOOP_LIMIT)
+
+    def transform_cell(self, cell: str) -> str:
+        """Transforms a cell of input code"""
+        if not cell.endswith('\n'):
+            cell += '\n'  # Ensure the cell has a trailing newline
+        lines = cell.splitlines(keepends=True)
+        for transform in self.cleanup_transforms + self.line_transforms:
+            lines = transform(lines)
+
+        lines = self.do_token_transforms(lines)
+        return ''.join(lines)
+
+    def check_complete(self, cell: str):
+        """Return whether a block of code is ready to execute, or should be continued
+
+        Parameters
+        ----------
+        cell : string
+            Python input code, which can be multiline.
+
+        Returns
+        -------
+        status : str
+            One of 'complete', 'incomplete', or 'invalid' if source is not a
+            prefix of valid code.
+        indent_spaces : int or None
+            The number of spaces by which to indent the next line of code. If
+            status is not 'incomplete', this is None.
+        """
+        # Remember if the lines ends in a new line.
+        ends_with_newline = False
+        for character in reversed(cell):
+            if character == '\n':
+                ends_with_newline = True
+                break
+            elif character.strip():
+                break
+            else:
+                continue
+
+        if not ends_with_newline:
+            # Append an newline for consistent tokenization
+            # See https://bugs.python.org/issue33899
+            cell += '\n'
+
+        lines = cell.splitlines(keepends=True)
+
+        if not lines:
+            return 'complete', None
+
+        for line in reversed(lines):
+            if not line.strip():
+                continue
+            elif line.strip("\n").endswith("\\"):
+                return "incomplete", find_last_indent(lines)
+            else:
+                break
+
+        try:
+            for transform in self.cleanup_transforms:
+                if not getattr(transform, 'has_side_effects', False):
+                    lines = transform(lines)
+        except SyntaxError:
+            return 'invalid', None
+
+        if lines[0].startswith('%%'):
+            # Special case for cell magics - completion marked by blank line
+            if lines[-1].strip():
+                return 'incomplete', find_last_indent(lines)
+            else:
+                return 'complete', None
+
+        try:
+            for transform in self.line_transforms:
+                if not getattr(transform, 'has_side_effects', False):
+                    lines = transform(lines)
+            lines = self.do_token_transforms(lines)
+        except SyntaxError:
+            return 'invalid', None
+
+        tokens_by_line = make_tokens_by_line(lines)
+
+        # Bail if we got one line and there are more closing parentheses than
+        # the opening ones
+        if (
+            len(lines) == 1
+            and tokens_by_line
+            and has_sunken_brackets(tokens_by_line[0])
+        ):
+            return "invalid", None
+
+        if not tokens_by_line:
+            return 'incomplete', find_last_indent(lines)
+
+        if (
+            tokens_by_line[-1][-1].type != tokenize.ENDMARKER
+            and tokens_by_line[-1][-1].type != tokenize.ERRORTOKEN
+        ):
+            # We're in a multiline string or expression
+            return 'incomplete', find_last_indent(lines)
+
+        newline_types = {tokenize.NEWLINE, tokenize.COMMENT, tokenize.ENDMARKER} # type: ignore
+
+        # Pop the last line which only contains DEDENTs and ENDMARKER
+        last_token_line = None
+        if {t.type for t in tokens_by_line[-1]} in [
+            {tokenize.DEDENT, tokenize.ENDMARKER},
+            {tokenize.ENDMARKER}
+        ] and len(tokens_by_line) > 1:
+            last_token_line = tokens_by_line.pop()
+
+        while tokens_by_line[-1] and tokens_by_line[-1][-1].type in newline_types:
+            tokens_by_line[-1].pop()
+
+        if not tokens_by_line[-1]:
+            return 'incomplete', find_last_indent(lines)
+
+        if tokens_by_line[-1][-1].string == ':':
+            # The last line starts a block (e.g. 'if foo:')
+            ix = 0
+            while tokens_by_line[-1][ix].type in {tokenize.INDENT, tokenize.DEDENT}:
+                ix += 1
+
+            indent = tokens_by_line[-1][ix].start[1]
+            return 'incomplete', indent + 4
+
+        if tokens_by_line[-1][0].line.endswith('\\'):
+            return 'incomplete', None
+
+        # At this point, our checks think the code is complete (or invalid).
+        # We'll use codeop.compile_command to check this with the real parser
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter('error', SyntaxWarning)
+                res = compile_command(''.join(lines), symbol='exec')
+        except (SyntaxError, OverflowError, ValueError, TypeError,
+                MemoryError, SyntaxWarning):
+            return 'invalid', None
+        else:
+            if res is None:
+                return 'incomplete', find_last_indent(lines)
+
+        if last_token_line and last_token_line[0].type == tokenize.DEDENT:
+            if ends_with_newline:
+                return 'complete', None
+            return 'incomplete', find_last_indent(lines)
+
+        # If there's a blank line at the end, assume we're ready to execute
+        if not lines[-1].strip():
+            return 'complete', None
+
+        return 'complete', None
+
+
+def find_last_indent(lines):
+    m = _indent_re.match(lines[-1])
+    if not m:
+        return 0
+    return len(m.group(0).replace('\t', ' '*4))
+
+
+class MaybeAsyncCompile(Compile):
+    def __init__(self, extra_flags=0):
+        super().__init__()
+        self.flags |= extra_flags
+
+
+class MaybeAsyncCommandCompiler(CommandCompiler):
+    def __init__(self, extra_flags=0):
+        self.compiler = MaybeAsyncCompile(extra_flags=extra_flags)
+
+
+_extra_flags = ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
+
+compile_command = MaybeAsyncCommandCompiler(extra_flags=_extra_flags)
diff --git a/IPython/core/interactiveshell.py b/IPython/core/interactiveshell.py
index 3761dc85b44..fed7dc9be84 100644
--- a/IPython/core/interactiveshell.py
+++ b/IPython/core/interactiveshell.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """Main IPython class."""
 
 #-----------------------------------------------------------------------------
@@ -10,69 +9,138 @@
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 
-from __future__ import with_statement
-from __future__ import absolute_import
-
-import __builtin__
-import __future__
 import abc
 import ast
 import atexit
-import codeop
+import bdb
+import builtins as builtin_mod
+import functools
 import inspect
 import os
 import re
+import runpy
+import shutil
+import subprocess
 import sys
 import tempfile
+import traceback
 import types
-from contextlib import nested
-
-from IPython.config.configurable import Configurable
-from IPython.core import debugger, oinspect
-from IPython.core import history as ipcorehist
-from IPython.core import page
-from IPython.core import prefilter
-from IPython.core import shadowns
-from IPython.core import ultratb
-from IPython.core.alias import AliasManager
+import warnings
+from ast import stmt
+from contextlib import contextmanager
+from io import open as io_open
+from logging import error
+from pathlib import Path
+from collections.abc import Callable
+from typing import List as ListType, Any as AnyType
+from typing import Literal, Optional, Tuple
+from collections.abc import Sequence
+from warnings import warn
+
+from IPython.external.pickleshare import PickleShareDB
+
+from tempfile import TemporaryDirectory
+from traitlets import (
+    Any,
+    Bool,
+    CaselessStrEnum,
+    Dict,
+    Enum,
+    Instance,
+    Integer,
+    List,
+    Type,
+    Unicode,
+    default,
+    observe,
+    validate,
+)
+from traitlets.config.configurable import SingletonConfigurable
+from traitlets.utils.importstring import import_item
+
+import IPython.core.hooks
+from IPython.core import magic, oinspect, page, prefilter, ultratb
+from IPython.core.alias import Alias, AliasManager
 from IPython.core.autocall import ExitAutocall
 from IPython.core.builtin_trap import BuiltinTrap
 from IPython.core.compilerop import CachingCompiler
+from IPython.core.debugger import InterruptiblePdb
 from IPython.core.display_trap import DisplayTrap
 from IPython.core.displayhook import DisplayHook
 from IPython.core.displaypub import DisplayPublisher
-from IPython.core.error import TryNext, UsageError
+from IPython.core.error import InputRejected, UsageError
+from IPython.core.events import EventManager, available_events
 from IPython.core.extensions import ExtensionManager
-from IPython.core.fakemodule import FakeModule, init_fakemod_dict
 from IPython.core.formatters import DisplayFormatter
-from IPython.core.history import HistoryManager
-from IPython.core.inputsplitter import IPythonInputSplitter
+from IPython.core.history import HistoryManager, HistoryOutput
+from IPython.core.inputtransformer2 import ESC_MAGIC, ESC_MAGIC2
 from IPython.core.logger import Logger
 from IPython.core.macro import Macro
-from IPython.core.magic import Magic
 from IPython.core.payload import PayloadManager
-from IPython.core.plugin import PluginManager
-from IPython.core.prefilter import PrefilterManager, ESC_MAGIC
-from IPython.external.Itpl import ItplNS
-from IPython.utils import PyColorize
-from IPython.utils import io
-from IPython.utils.doctestreload import doctest_reload
-from IPython.utils.io import ask_yes_no, rprint
+from IPython.core.prefilter import PrefilterManager
+from IPython.core.profiledir import ProfileDir
+from IPython.core.tips import pick_tip
+from IPython.core.usage import default_banner
+from IPython.display import display
+from IPython.paths import get_ipython_dir
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils import PyColorize, io, openpy, py3compat
+from IPython.utils.decorators import undoc
+from IPython.utils.io import ask_yes_no
 from IPython.utils.ipstruct import Struct
-from IPython.utils.path import get_home_dir, get_ipython_dir, HomeDirError
-from IPython.utils.pickleshare import PickleShareDB
-from IPython.utils.process import system, getoutput
+from IPython.utils.path import ensure_dir_exists, get_home_dir, get_py_filename
+from IPython.utils.process import getoutput, system
 from IPython.utils.strdispatch import StrDispatch
 from IPython.utils.syspathcontext import prepended_to_syspath
-from IPython.utils.text import num_ini_spaces, format_screen, LSString, SList
-from IPython.utils.traitlets import (Int, Str, CBool, CaselessStrEnum, Enum,
-                                     List, Unicode, Instance, Type)
-from IPython.utils.warn import warn, error, fatal
-import IPython.core.hooks
+from IPython.utils.text import DollarFormatter, LSString, SList, format_screen
+from IPython.core.oinspect import OInfo
+
+
+sphinxify: Optional[Callable]
+
+try:
+    import docrepr.sphinxify as sphx
+
+    def sphinxify(oinfo):
+        wrapped_docstring = sphx.wrap_main_docstring(oinfo)
+
+        def sphinxify_docstring(docstring):
+            with TemporaryDirectory() as dirname:
+                return {
+                    "text/html": sphx.sphinxify(wrapped_docstring, dirname),
+                    "text/plain": docstring,
+                }
+
+        return sphinxify_docstring
+except ImportError:
+    sphinxify = None
+
+
+class ProvisionalWarning(DeprecationWarning):
+    """
+    Warning class for unstable features
+    """
+    pass
+
+from ast import Module
+
+_assign_nodes = (ast.AugAssign, ast.AnnAssign, ast.Assign)
+_single_targets_nodes = (ast.AugAssign, ast.AnnAssign)
+
+#-----------------------------------------------------------------------------
+# Await Helpers
+#-----------------------------------------------------------------------------
+
+# we still need to run things using the asyncio eventloop, but there is no
+# async integration
+from .async_helpers import (
+    _asyncio_runner,
+    _curio_runner,
+    _pseudo_sync_runner,
+    _should_be_async,
+    _trio_runner,
+)
 
 #-----------------------------------------------------------------------------
 # Globals
@@ -85,10 +153,20 @@
 # Utilities
 #-----------------------------------------------------------------------------
 
-# store the builtin raw_input globally, and use this always, in case user code
-# overwrites it (like wx.py.PyShell does)
-raw_input_original = raw_input
 
+def is_integer_string(s: str):
+    """
+    Variant of "str.isnumeric()" that allow negative values and other ints.
+    """
+    try:
+        int(s)
+        return True
+    except ValueError:
+        return False
+    raise ValueError("Unexpected error")
+
+
+@undoc
 def softspace(file, newvalue):
     """Copied from code.py, to remove the dependency"""
 
@@ -104,197 +182,451 @@ def softspace(file, newvalue):
         pass
     return oldvalue
 
+@undoc
+def no_op(*a, **kw):
+    pass
 
-def no_op(*a, **kw): pass
 
 class SpaceInInput(Exception): pass
 
-class Bunch: pass
-
-
-def get_default_colors():
-    if sys.platform=='darwin':
-        return "LightBG"
-    elif os.name=='nt':
-        return 'Linux'
-    else:
-        return 'Linux'
 
+class SeparateUnicode(Unicode):
+    r"""A Unicode subclass to validate separate_in, separate_out, etc.
 
-class SeparateStr(Str):
-    """A Str subclass to validate separate_in, separate_out, etc.
-
-    This is a Str based trait that converts '0'->'' and '\\n'->'\n'.
+    This is a Unicode based trait that converts '0'->'' and ``'\\n'->'\n'``.
     """
 
     def validate(self, obj, value):
         if value == '0': value = ''
         value = value.replace('\\n','\n')
-        return super(SeparateStr, self).validate(obj, value)
+        return super(SeparateUnicode, self).validate(obj, value)
 
-class MultipleInstanceError(Exception):
-    pass
-    
-class ReadlineNoRecord(object):
-    """Context manager to execute some code, then reload readline history
-    so that interactive input to the code doesn't appear when pressing up."""
-    def __init__(self, shell):
-        self.shell = shell
-        self._nested_level = 0
-        
-    def __enter__(self):
-        if self._nested_level == 0:
+
+class _IPythonMainModuleBase(types.ModuleType):
+    def __init__(self) -> None:
+        super().__init__(
+            "__main__",
+            doc="Automatically created module for the IPython interactive environment",
+        )
+
+
+def make_main_module_type(user_ns: dict[str, Any]) -> type[_IPythonMainModuleBase]:
+    @undoc
+    class IPythonMainModule(_IPythonMainModuleBase):
+        """
+        ModuleType that supports passing in a custom user namespace dictionary,
+        to be used for the module's __dict__. This is enabled by shadowing the
+        underlying __dict__ attribute of the module, and overriding getters and
+        setters to point to the custom user namespace dictionary.
+        The reason to do this is to allow the __main__ module to be an instance
+        of ModuleType, while still allowing the user namespace to be custom.
+        """
+
+        @property
+        def __dict__(self) -> dict[str, Any]:  # type: ignore[override]
+            return user_ns
+
+        def __setattr__(self, item: str, value: Any) -> None:
+            if item == "__dict__":
+                # Ignore this when IPython tries to set it, since we already provide it
+                return
+            user_ns[item] = value
+
+        def __getattr__(self, item: str) -> Any:
             try:
-                self.orig_length = self.current_length()
-                self.readline_tail = self.get_readline_tail()
-            except (AttributeError, IndexError):   # Can fail with pyreadline
-                self.orig_length, self.readline_tail = 999999, []
-        self._nested_level += 1
-        
-    def __exit__(self, type, value, traceback):
-        self._nested_level -= 1
-        if self._nested_level == 0:
-            # Try clipping the end if it's got longer
+                return user_ns[item]
+            except KeyError:
+                raise AttributeError(f"module {self.__name__} has no attribute {item}")
+
+        def __delattr__(self, item: str) -> None:
             try:
-                e = self.current_length() - self.orig_length
-                if e > 0:
-                    for _ in range(e):
-                        self.shell.readline.remove_history_item(self.orig_length)
-                
-                # If it still doesn't match, just reload readline history.
-                if self.current_length() != self.orig_length \
-                    or self.get_readline_tail() != self.readline_tail:
-                    self.shell.refill_readline_hist()
-            except (AttributeError, IndexError):
-                pass
-        # Returning False will cause exceptions to propagate
-        return False
-    
-    def current_length(self):
-        return self.shell.readline.get_current_history_length()
-    
-    def get_readline_tail(self, n=10):
-        """Get the last n items in readline history."""
-        end = self.shell.readline.get_current_history_length() + 1
-        start = max(end-n, 1)
-        ghi = self.shell.readline.get_history_item
-        return [ghi(x) for x in range(start, end)]
+                del user_ns[item]
+            except KeyError:
+                raise AttributeError(f"module {self.__name__} has no attribute {item}")
 
+    return IPythonMainModule
 
-#-----------------------------------------------------------------------------
-# Main IPython class
-#-----------------------------------------------------------------------------
 
-class InteractiveShell(Configurable, Magic):
+class ExecutionInfo:
+    """The arguments used for a call to :meth:`InteractiveShell.run_cell`
+
+    Stores information about what is going to happen.
+    """
+    raw_cell = None
+    transformed_cell = None
+    store_history = False
+    silent = False
+    shell_futures = True
+    cell_id = None
+
+    def __init__(
+        self,
+        raw_cell,
+        store_history,
+        silent,
+        shell_futures,
+        cell_id,
+        transformed_cell=None,
+    ):
+        self.raw_cell = raw_cell
+        self.transformed_cell = transformed_cell
+        self.store_history = store_history
+        self.silent = silent
+        self.shell_futures = shell_futures
+        self.cell_id = cell_id
+
+    def __repr__(self):
+        name = self.__class__.__qualname__
+        raw_cell = (
+            (self.raw_cell[:50] + "..") if len(self.raw_cell) > 50 else self.raw_cell
+        )
+        transformed_cell = (
+            (self.transformed_cell[:50] + "..")
+            if self.transformed_cell and len(self.transformed_cell) > 50
+            else self.transformed_cell
+        )
+        return (
+            '<%s object at %x, raw_cell="%s" transformed_cell="%s" store_history=%s silent=%s shell_futures=%s cell_id=%s>'
+            % (
+                name,
+                id(self),
+                raw_cell,
+                transformed_cell,
+                self.store_history,
+                self.silent,
+                self.shell_futures,
+                self.cell_id,
+            )
+        )
+
+
+class ExecutionResult:
+    """The result of a call to :meth:`InteractiveShell.run_cell`
+
+    Stores information about what took place.
+    """
+
+    execution_count: Optional[int] = None
+    error_before_exec: Optional[BaseException] = None
+    error_in_exec: Optional[BaseException] = None
+    info = None
+    result = None
+
+    def __init__(self, info):
+        self.info = info
+
+    @property
+    def success(self):
+        return (self.error_before_exec is None) and (self.error_in_exec is None)
+
+    def raise_error(self):
+        """Reraises error if `success` is `False`, otherwise does nothing"""
+        if self.error_before_exec is not None:
+            raise self.error_before_exec
+        if self.error_in_exec is not None:
+            raise self.error_in_exec
+
+    def __repr__(self):
+        name = self.__class__.__qualname__
+        return '<%s object at %x, execution_count=%s error_before_exec=%s error_in_exec=%s info=%s result=%s>' %\
+                (name, id(self), self.execution_count, self.error_before_exec, self.error_in_exec, repr(self.info), repr(self.result))
+
+
+@functools.wraps(io_open)
+def _modified_open(file, *args, **kwargs):
+    if file in {0, 1, 2}:
+        raise ValueError(
+            f"IPython won't let you open fd={file} by default "
+            "as it is likely to crash IPython. If you know what you are doing, "
+            "you can use builtins' open."
+        )
+
+    return io_open(file, *args, **kwargs)
+
+
+class InteractiveShell(SingletonConfigurable):
     """An enhanced, interactive shell for Python."""
 
     _instance = None
-    autocall = Enum((0,1,2), default_value=1, config=True)
-    # TODO: remove all autoindent logic and put into frontends.
-    # We can't do this yet because even runlines uses the autoindent.
-    autoindent = CBool(True, config=True)
-    automagic = CBool(True, config=True)
-    cache_size = Int(1000, config=True)
-    color_info = CBool(True, config=True)
-    colors = CaselessStrEnum(('NoColor','LightBG','Linux'), 
-                             default_value=get_default_colors(), config=True)
-    debug = CBool(False, config=True)
-    deep_reload = CBool(False, config=True)
-    display_formatter = Instance(DisplayFormatter)
+    _user_ns: dict
+    _sys_modules_keys: set[str]
+
+    inspector: oinspect.Inspector
+
+    ast_transformers: List[ast.NodeTransformer] = List(
+        [],
+        help="""
+        A list of ast.NodeTransformer subclass instances, which will be applied
+        to user input before code is run.
+        """,
+    ).tag(config=True)
+
+    autocall = Enum((0,1,2), default_value=0, help=
+        """
+        Make IPython automatically call any callable object even if you didn't
+        type explicit parentheses. For example, 'str 43' becomes 'str(43)'
+        automatically. The value can be '0' to disable the feature, '1' for
+        'smart' autocall, where it is not applied if there are no more
+        arguments on the line, and '2' for 'full' autocall, where all callable
+        objects are automatically called (even if no arguments are present).
+        """
+    ).tag(config=True)
+
+    autoindent = Bool(True, help=
+        """
+        Autoindent IPython code entered interactively.
+        """
+    ).tag(config=True)
+
+    autoawait = Bool(True, help=
+        """
+        Automatically run await statement in the top level repl.
+        """
+    ).tag(config=True)
+
+    loop_runner_map ={
+        'asyncio':(_asyncio_runner, True),
+        'curio':(_curio_runner, True),
+        'trio':(_trio_runner, True),
+        'sync': (_pseudo_sync_runner, False)
+    }
+
+    loop_runner = Any(default_value="IPython.core.interactiveshell._asyncio_runner",
+        allow_none=True,
+        help="""Select the loop runner that will be used to execute top-level asynchronous code"""
+    ).tag(config=True)
+
+    @default('loop_runner')
+    def _default_loop_runner(self):
+        return import_item("IPython.core.interactiveshell._asyncio_runner")
+
+    @validate('loop_runner')
+    def _import_runner(self, proposal):
+        if isinstance(proposal.value, str):
+            if proposal.value in self.loop_runner_map:
+                runner, autoawait = self.loop_runner_map[proposal.value]
+                self.autoawait = autoawait
+                return runner
+            runner = import_item(proposal.value)
+            if not callable(runner):
+                raise ValueError('loop_runner must be callable')
+            return runner
+        if not callable(proposal.value):
+            raise ValueError('loop_runner must be callable')
+        return proposal.value
+
+    automagic = Bool(True, help=
+        """
+        Enable magic commands to be called without the leading %.
+        """
+    ).tag(config=True)
+
+    enable_tip = Bool(
+        True,
+        help="""
+        Set to show a tip when IPython starts.""",
+    ).tag(config=True)
+
+    banner1 = Unicode(default_banner,
+        help="""The part of the banner to be printed before the profile"""
+    ).tag(config=True)
+    banner2 = Unicode('',
+        help="""The part of the banner to be printed after the profile"""
+    ).tag(config=True)
+
+    cache_size = Integer(
+        1000,
+        help="""
+        Set the size of the output cache.  The default is 1000, you can
+        change it permanently in your config file.  Setting it to 0 completely
+        disables the caching system, and the minimum value accepted is 3 (if
+        you provide a value less than 3, it is reset to 0 and a warning is
+        issued).  This limit is defined because otherwise you'll spend more
+        time re-flushing a too small cache than working
+        """,
+    ).tag(config=True)
+    debug = Bool(False).tag(config=True)
+    display_formatter = Instance(DisplayFormatter, allow_none=True)
     displayhook_class = Type(DisplayHook)
     display_pub_class = Type(DisplayPublisher)
+    compiler_class = Type(CachingCompiler)
+    inspector_class = Type(
+        oinspect.Inspector, help="Class to use to instantiate the shell inspector"
+    ).tag(config=True)
+
+    sphinxify_docstring = Bool(False, help=
+        """
+        Enables rich html representation of docstrings. (This requires the
+        docrepr module).
+        """).tag(config=True)
 
-    exit_now = CBool(False)
+    @observe("sphinxify_docstring")
+    def _sphinxify_docstring_changed(self, change):
+        if change['new']:
+            warn("`sphinxify_docstring` is provisional since IPython 5.0 and might change in future versions." , ProvisionalWarning)
+
+    enable_html_pager = Bool(False, help=
+        """
+        (Provisional API) enables html representation in mime bundles sent
+        to pagers.
+        """).tag(config=True)
+
+    @observe("enable_html_pager")
+    def _enable_html_pager_changed(self, change):
+        if change['new']:
+            warn("`enable_html_pager` is provisional since IPython 5.0 and might change in future versions.", ProvisionalWarning)
+
+    data_pub_class = None
+
+    exit_now = Bool(False)
     exiter = Instance(ExitAutocall)
+    @default('exiter')
     def _exiter_default(self):
         return ExitAutocall(self)
     # Monotonically increasing execution counter
-    execution_count = Int(1)
+    execution_count = Integer(1)
     filename = Unicode("<ipython console>")
-    ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
-
-    # Input splitter, to split entire cells of input into either individual
-    # interactive statements or whole blocks.
-    input_splitter = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
-                              (), {})
-    logstart = CBool(False, config=True)
-    logfile = Unicode('', config=True)
-    logappend = Unicode('', config=True)
+    ipython_dir = Unicode("").tag(config=True)  # Set to get_ipython_dir() in __init__
+
+    # Used to transform cells before running them, and check whether code is complete
+    input_transformer_manager = Instance('IPython.core.inputtransformer2.TransformerManager',
+                                         ())
+
+    @property
+    def input_transformers_cleanup(self):
+        return self.input_transformer_manager.cleanup_transforms
+
+    input_transformers_post: List = List(
+        [],
+        help="A list of string input transformers, to be applied after IPython's "
+             "own input transformations."
+    )
+
+    logstart = Bool(False, help=
+        """
+        Start logging to the default log file in overwrite mode.
+        Use `logappend` to specify a log file to **append** logs to.
+        """
+    ).tag(config=True)
+    logfile = Unicode('', help=
+        """
+        The name of the logfile to use.
+        """
+    ).tag(config=True)
+    logappend = Unicode('', help=
+        """
+        Start logging to the given file in append mode.
+        Use `logfile` to specify a log file to **overwrite** logs to.
+        """
+    ).tag(config=True)
     object_info_string_level = Enum((0,1,2), default_value=0,
-                                    config=True)
-    pdb = CBool(False, config=True)
-
-    profile = Unicode('', config=True)
-    prompt_in1 = Str('In [\\#]: ', config=True)
-    prompt_in2 = Str('   .\\D.: ', config=True)
-    prompt_out = Str('Out[\\#]: ', config=True)
-    prompts_pad_left = CBool(True, config=True)
-    quiet = CBool(False, config=True)
-
-    history_length = Int(10000, config=True)
-    
-    # The readline stuff will eventually be moved to the terminal subclass
-    # but for now, we can't do that as readline is welded in everywhere.
-    readline_use = CBool(True, config=True)
-    readline_merge_completions = CBool(True, config=True)
-    readline_omit__names = Enum((0,1,2), default_value=2, config=True)
-    readline_remove_delims = Str('-/~', config=True)
-    readline_parse_and_bind = List([
-            'tab: complete',
-            '"\C-l": clear-screen',
-            'set show-all-if-ambiguous on',
-            '"\C-o": tab-insert',
-            # See bug gh-58 - with \M-i enabled, chars 0x9000-0x9fff
-            # crash IPython.
-            '"\M-o": "\d\d\d\d"',
-            '"\M-I": "\d\d\d\d"',
-            '"\C-r": reverse-search-history',
-            '"\C-s": forward-search-history',
-            '"\C-p": history-search-backward',
-            '"\C-n": history-search-forward',
-            '"\e[A": history-search-backward',
-            '"\e[B": history-search-forward',
-            '"\C-k": kill-line',
-            '"\C-u": unix-line-discard',
-        ], allow_none=False, config=True)
+    ).tag(config=True)
+    pdb = Bool(False, help=
+        """
+        Automatically call the pdb debugger after every exception.
+        """
+    ).tag(config=True)
+    display_page = Bool(False,
+        help="""If True, anything that would be passed to the pager
+        will be displayed as regular output instead."""
+    ).tag(config=True)
+
+
+    show_rewritten_input = Bool(True,
+        help="Show rewritten input, e.g. for autocall."
+    ).tag(config=True)
+
+    quiet = Bool(False).tag(config=True)
+
+    history_length = Integer(10000,
+        help='Total length of command history'
+    ).tag(config=True)
+
+    history_load_length = Integer(1000, help=
+        """
+        The number of saved history entries to be loaded
+        into the history buffer at startup.
+        """
+    ).tag(config=True)
+
+    ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none', 'last_expr_or_assign'],
+                                  default_value='last_expr',
+                                  help="""
+        'all', 'last', 'last_expr' or 'none', 'last_expr_or_assign' specifying
+        which nodes should be run interactively (displaying output from expressions).
+        """
+    ).tag(config=True)
+
+    warn_venv = Bool(
+        True,
+        help="Warn if running in a virtual environment with no IPython installed (so IPython from the global environment is used).",
+    ).tag(config=True)
 
     # TODO: this part of prompt management should be moved to the frontends.
     # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
-    separate_in = SeparateStr('\n', config=True)
-    separate_out = SeparateStr('', config=True)
-    separate_out2 = SeparateStr('', config=True)
-    wildcards_case_sensitive = CBool(True, config=True)
-    xmode = CaselessStrEnum(('Context','Plain', 'Verbose'), 
-                            default_value='Context', config=True)
+    separate_in = SeparateUnicode('\n').tag(config=True)
+    separate_out = SeparateUnicode('').tag(config=True)
+    separate_out2 = SeparateUnicode('').tag(config=True)
+    wildcards_case_sensitive = Bool(True).tag(config=True)
+    xmode = CaselessStrEnum(
+        ("Context", "Plain", "Verbose", "Minimal", "Docs"),
+        default_value="Context",
+        help="Switch modes for the IPython exception handlers.",
+    ).tag(config=True)
 
     # Subcomponents of InteractiveShell
-    alias_manager = Instance('IPython.core.alias.AliasManager')
-    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
-    builtin_trap = Instance('IPython.core.builtin_trap.BuiltinTrap')
-    display_trap = Instance('IPython.core.display_trap.DisplayTrap')
-    extension_manager = Instance('IPython.core.extensions.ExtensionManager')
-    plugin_manager = Instance('IPython.core.plugin.PluginManager')
-    payload_manager = Instance('IPython.core.payload.PayloadManager')
-    history_manager = Instance('IPython.core.history.HistoryManager')
+    alias_manager = Instance("IPython.core.alias.AliasManager", allow_none=True)
+    prefilter_manager = Instance(
+        "IPython.core.prefilter.PrefilterManager", allow_none=True
+    )
+    builtin_trap = Instance("IPython.core.builtin_trap.BuiltinTrap")
+    display_trap = Instance("IPython.core.display_trap.DisplayTrap")
+    extension_manager = Instance(
+        "IPython.core.extensions.ExtensionManager", allow_none=True
+    )
+    payload_manager = Instance("IPython.core.payload.PayloadManager", allow_none=True)
+    history_manager = Instance(
+        "IPython.core.history.HistoryAccessorBase", allow_none=True
+    )
+    magics_manager = Instance("IPython.core.magic.MagicsManager")
+
+    profile_dir = Instance('IPython.core.application.ProfileDir', allow_none=True)
+    @property
+    def profile(self):
+        if self.profile_dir is not None:
+            name = os.path.basename(self.profile_dir.location)
+            return name.replace('profile_','')
+
 
     # Private interface
-    _post_execute = Instance(dict)
+    _post_execute = Dict()
 
-    def __init__(self, config=None, ipython_dir=None,
-                 user_ns=None, user_global_ns=None,
-                 custom_exceptions=((), None)):
+    # Tracks any GUI loop loaded for pylab
+    pylab_gui_select = None
 
+    last_execution_succeeded = Bool(True, help='Did last executed command succeeded')
+
+    last_execution_result = Instance('IPython.core.interactiveshell.ExecutionResult', help='Result of executing the last command', allow_none=True)
+
+    def __init__(self, ipython_dir=None, profile_dir=None,
+                 user_module=None, user_ns=None,
+                 custom_exceptions=((), None), **kwargs):
         # This is where traits with a config_key argument are updated
         # from the values on config.
-        super(InteractiveShell, self).__init__(config=config)
+        super(InteractiveShell, self).__init__(**kwargs)
+        self.configurables = [self]
 
         # These are relatively independent and stateless
         self.init_ipython_dir(ipython_dir)
+        self.init_profile_dir(profile_dir)
         self.init_instance_attrs()
         self.init_environment()
 
+        # Check if we're in a virtualenv, and set up sys.path.
+        self.init_virtualenv()
+
         # Create namespaces (user_ns, user_global_ns, etc.)
-        self.init_create_namespaces(user_ns, user_global_ns)
+        self.init_create_namespaces(user_module, user_ns)
         # This has to be done after init_create_namespaces because it uses
         # something in self.user_ns, but before init_sys_modules, which
         # is the first thing to modify sys.
@@ -303,42 +635,26 @@ def __init__(self, config=None, ipython_dir=None,
         # is what we want to do.
         self.save_sys_module_state()
         self.init_sys_modules()
-        
+
         # While we're trying to have each part of the code directly access what
         # it needs without keeping redundant references to objects, we have too
         # much legacy code that expects ip.db to exist.
-        self.db = PickleShareDB(os.path.join(self.ipython_dir, 'db'))
+        self.db = PickleShareDB(os.path.join(self.profile_dir.location, 'db'))
 
         self.init_history()
         self.init_encoding()
         self.init_prefilter()
 
-        Magic.__init__(self, self)
-
         self.init_syntax_highlighting()
         self.init_hooks()
+        self.init_events()
         self.init_pushd_popd_magic()
-        # self.init_traceback_handlers use to be here, but we moved it below
-        # because it and init_io have to come after init_readline.
         self.init_user_ns()
         self.init_logger()
-        self.init_alias()
         self.init_builtins()
 
-        # pre_config_initialization
-
-        # The next section should contain everything that was in ipmaker.
-        self.init_logstart()
-
         # The following was in post_config_initialization
-        self.init_inspector()
-        # init_readline() must come before init_io(), because init_io uses
-        # readline related things.
-        self.init_readline()
-        # init_completer must come after init_readline, because it needs to
-        # know whether readline is present or not system-wide to configure the
-        # completers, since the completion machinery can now operate
-        # independently of readline (e.g. over the network)
+        self.raw_input_original = input
         self.init_completer()
         # TODO: init_io() needs to happen before init_traceback handlers
         # because the traceback handlers hardcode the stdout/stderr streams.
@@ -348,40 +664,34 @@ def __init__(self, config=None, ipython_dir=None,
         self.init_prompts()
         self.init_display_formatter()
         self.init_display_pub()
+        self.init_data_pub()
         self.init_displayhook()
-        self.init_reload_doctest()
         self.init_magics()
+        self.init_alias()
+        self.init_logstart()
         self.init_pdb()
         self.init_extension_manager()
-        self.init_plugin_manager()
         self.init_payload()
-        self.hooks.late_startup_hook()
+        self.events.trigger('shell_initialized', self)
         atexit.register(self.atexit_operations)
 
-    @classmethod
-    def instance(cls, *args, **kwargs):
-        """Returns a global InteractiveShell instance."""
-        if cls._instance is None:
-            inst = cls(*args, **kwargs)
-            # Now make sure that the instance will also be returned by
-            # the subclasses instance attribute.
-            for subclass in cls.mro():
-                if issubclass(cls, subclass) and \
-                       issubclass(subclass, InteractiveShell):
-                    subclass._instance = inst
-                else:
-                    break
-        if isinstance(cls._instance, cls):
-            return cls._instance
-        else:
-            raise MultipleInstanceError(
-                'Multiple incompatible subclass instances of '
-                'InteractiveShell are being created.'
-            )
+        # The trio runner is used for running Trio in the foreground thread. It
+        # is different from `_trio_runner(async_fn)` in `async_helpers.py`
+        # which calls `trio.run()` for every cell. This runner runs all cells
+        # inside a single Trio event loop. If used, it is set from
+        # `ipykernel.kernelapp`.
+        self.trio_runner = None
+        self.showing_traceback = False
+
+    @property
+    def user_ns(self):
+        return self._user_ns
 
-    @classmethod
-    def initialized(cls):
-        return hasattr(cls, "_instance")
+    @user_ns.setter
+    def user_ns(self, ns: dict):
+        assert hasattr(ns, "clear")
+        assert isinstance(ns, dict)
+        self._user_ns = ns
 
     def get_ipython(self):
         """Return the currently running IPython instance."""
@@ -390,26 +700,22 @@ def get_ipython(self):
     #-------------------------------------------------------------------------
     # Trait changed handlers
     #-------------------------------------------------------------------------
-
-    def _ipython_dir_changed(self, name, new):
-        if not os.path.isdir(new):
-            os.makedirs(new, mode = 0777)
+    @observe('ipython_dir')
+    def _ipython_dir_changed(self, change):
+        ensure_dir_exists(change['new'])
 
     def set_autoindent(self,value=None):
-        """Set the autoindent flag, checking for readline support.
+        """Set the autoindent flag.
 
         If called with no arguments, it acts as a toggle."""
-
-        if not self.has_readline:
-            if os.name == 'posix':
-                warn("The auto-indent feature requires the readline library")
-            self.autoindent = 0
-            return
         if value is None:
             self.autoindent = not self.autoindent
         else:
             self.autoindent = value
 
+    def set_trio_runner(self, tr):
+        self.trio_runner = tr
+
     #-------------------------------------------------------------------------
     # init_* methods called by __init__
     #-------------------------------------------------------------------------
@@ -417,22 +723,23 @@ def set_autoindent(self,value=None):
     def init_ipython_dir(self, ipython_dir):
         if ipython_dir is not None:
             self.ipython_dir = ipython_dir
-            self.config.Global.ipython_dir = self.ipython_dir
             return
 
-        if hasattr(self.config.Global, 'ipython_dir'):
-            self.ipython_dir = self.config.Global.ipython_dir
-        else:
-            self.ipython_dir = get_ipython_dir()
+        self.ipython_dir = get_ipython_dir()
 
-        # All children can just read this
-        self.config.Global.ipython_dir = self.ipython_dir
+    def init_profile_dir(self, profile_dir):
+        if profile_dir is not None:
+            self.profile_dir = profile_dir
+            return
+        self.profile_dir = ProfileDir.create_profile_dir_by_name(
+            self.ipython_dir, "default"
+        )
 
     def init_instance_attrs(self):
         self.more = False
 
         # command compiler
-        self.compile = CachingCompiler()
+        self.compile = self.compiler_class()
 
         # Make an empty namespace, which extension writers can rely on both
         # existing and NEVER being used by ipython itself.  This gives them a
@@ -442,10 +749,9 @@ def init_instance_attrs(self):
         self.meta = Struct()
 
         # Temporary files used for various purposes.  Deleted at exit.
+        # The files here are stored with Path from Pathlib
         self.tempfiles = []
-
-        # Keep track of readline usage (later set by init_readline)
-        self.has_readline = False
+        self.tempdirs = []
 
         # keep track of where we started running (mainly for crash post-mortem)
         # This is not being used anywhere currently.
@@ -470,92 +776,210 @@ def init_encoding(self):
         except AttributeError:
             self.stdin_encoding = 'ascii'
 
-    def init_syntax_highlighting(self):
+    colors = Unicode(
+        "neutral", help="Set the color scheme (nocolor, neutral, linux, lightbg)."
+    ).tag(config=True)
+
+    @validate("colors")
+    def _check_colors(self, proposal):
+        new = proposal["value"]
+        if not new == new.lower():
+            warn(
+                f"`TerminalInteractiveShell.colors` is now lowercase: `{new.lower()}`,"
+                " non lowercase, may be invalid in the future.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        return new.lower()
+
+    @observe("colors")
+    def init_syntax_highlighting(self, changes=None):
         # Python source parser/formatter for syntax highlighting
-        pyformat = PyColorize.Parser().format
-        self.pycolorize = lambda src: pyformat(src,'str',self.colors)
+        pyformat = PyColorize.Parser(theme_name=self.colors).format
+        self.pycolorize = lambda src: pyformat(src, "str")
+        if not hasattr(self, "inspector"):
+            self.inspector = self.inspector_class(
+                theme_name=self.colors,
+                str_detail_level=self.object_info_string_level,
+                parent=self,
+            )
+
+        try:
+            # Deprecation in 9.0, colors should always be lower
+            self.inspector.set_theme_name(self.colors.lower())
+        except Exception:
+            warn(
+                "Error changing object inspector color schemes.\n%s"
+                % (sys.exc_info()[1]),
+                stacklevel=2,
+            )
+        if hasattr(self, "InteractiveTB"):
+            self.InteractiveTB.set_theme_name(self.colors)
+        if hasattr(self, "SyntaxTB"):
+            self.SyntaxTB.set_theme_name(self.colors)
+        self.refresh_style()
+
+    def refresh_style(self):
+        # No-op here, used in subclass
+        pass
 
     def init_pushd_popd_magic(self):
         # for pushd/popd management
-        try:
-            self.home_dir = get_home_dir()
-        except HomeDirError, msg:
-            fatal(msg)
+        self.home_dir = get_home_dir()
 
         self.dir_stack = []
 
-    def init_logger(self):
+    def init_logger(self) -> None:
         self.logger = Logger(self.home_dir, logfname='ipython_log.py',
                              logmode='rotate')
 
-    def init_logstart(self):
+    def init_logstart(self) -> None:
         """Initialize logging in case it was requested at the command line.
         """
         if self.logappend:
-            self.magic_logstart(self.logappend + ' append')
+            self.run_line_magic("logstart", f"{self.logappend} append")
         elif self.logfile:
-            self.magic_logstart(self.logfile)
+            self.run_line_magic("logstart", self.logfile)
         elif self.logstart:
-            self.magic_logstart()
+            self.run_line_magic("logstart", "")
 
     def init_builtins(self):
+        # A single, static flag that we set to True.  Its presence indicates
+        # that an IPython shell has been created, and we make no attempts at
+        # removing on exit or representing the existence of more than one
+        # IPython at a time.
+        builtin_mod.__dict__['__IPYTHON__'] = True
+        builtin_mod.__dict__['display'] = display
+
         self.builtin_trap = BuiltinTrap(shell=self)
 
-    def init_inspector(self):
-        # Object inspector
-        self.inspector = oinspect.Inspector(oinspect.InspectColors,
-                                            PyColorize.ANSICodeColors,
-                                            'NoColor',
-                                            self.object_info_string_level)
 
     def init_io(self):
-        # This will just use sys.stdout and sys.stderr. If you want to
-        # override sys.stdout and sys.stderr themselves, you need to do that
-        # *before* instantiating this class, because io holds onto 
-        # references to the underlying streams.
-        if sys.platform == 'win32' and self.has_readline:
-            io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
-        else:
-            io.stdout = io.IOStream(sys.stdout)
-            io.stderr = io.IOStream(sys.stderr)
+        # implemented in subclasses, TerminalInteractiveShell does call
+        # colorama.init().
+        pass
 
     def init_prompts(self):
-        # TODO: This is a pass for now because the prompts are managed inside
-        # the DisplayHook. Once there is a separate prompt manager, this 
-        # will initialize that object and all prompt related information.
-        pass
+        # Set system prompts, so that scripts can decide if they are running
+        # interactively.
+        sys.ps1 = 'In : '
+        sys.ps2 = '...: '
+        sys.ps3 = 'Out: '
 
     def init_display_formatter(self):
-        self.display_formatter = DisplayFormatter(config=self.config)
+        self.display_formatter = DisplayFormatter(parent=self)
+        self.configurables.append(self.display_formatter)
 
     def init_display_pub(self):
-        self.display_pub = self.display_pub_class(config=self.config)
+        self.display_pub = self.display_pub_class(parent=self, shell=self)
+        self.configurables.append(self.display_pub)
+
+    def init_data_pub(self):
+        if not self.data_pub_class:
+            self.data_pub = None
+            return
+        self.data_pub = self.data_pub_class(parent=self)
+        self.configurables.append(self.data_pub)
 
     def init_displayhook(self):
         # Initialize displayhook, set in/out prompts and printing system
         self.displayhook = self.displayhook_class(
-            config=self.config,
+            parent=self,
             shell=self,
             cache_size=self.cache_size,
-            input_sep = self.separate_in,
-            output_sep = self.separate_out,
-            output_sep2 = self.separate_out2,
-            ps1 = self.prompt_in1,
-            ps2 = self.prompt_in2,
-            ps_out = self.prompt_out,
-            pad_left = self.prompts_pad_left
         )
-        # This is a context manager that installs/revmoes the displayhook at
+        self.configurables.append(self.displayhook)
+        # This is a context manager that installs/removes the displayhook at
         # the appropriate time.
         self.display_trap = DisplayTrap(hook=self.displayhook)
 
-    def init_reload_doctest(self):
-        # Do a proper resetting of doctest, including the necessary displayhook
-        # monkeypatching
-        try:
-            doctest_reload()
-        except ImportError:
-            warn("doctest module does not exist.")
+    @staticmethod
+    def get_path_links(p: Path):
+        """Gets path links including all symlinks
+
+        Examples
+        --------
+        In [1]: from IPython.core.interactiveshell import InteractiveShell
+
+        In [2]: import sys, pathlib
+
+        In [3]: paths = InteractiveShell.get_path_links(pathlib.Path(sys.executable))
+
+        In [4]: len(paths) == len(set(paths))
+        Out[4]: True
+
+        In [5]: bool(paths)
+        Out[5]: True
+        """
+        paths = [p]
+        while p.is_symlink():
+            new_path = Path(os.readlink(p))
+            if not new_path.is_absolute():
+                new_path = p.parent / new_path
+            p = new_path
+            paths.append(p)
+        return paths
+
+    def init_virtualenv(self):
+        """Add the current virtualenv to sys.path so the user can import modules from it.
+        This isn't perfect: it doesn't use the Python interpreter with which the
+        virtualenv was built, and it ignores the --no-site-packages option. A
+        warning will appear suggesting the user installs IPython in the
+        virtualenv, but for many cases, it probably works well enough.
+
+        Adapted from code snippets online.
+
+        http://blog.ufsoft.org/2009/1/29/ipython-and-virtualenv
+        """
+        if 'VIRTUAL_ENV' not in os.environ:
+            # Not in a virtualenv
+            return
+        elif os.environ["VIRTUAL_ENV"] == "":
+            warn("Virtual env path set to '', please check if this is intended.")
+            return
+
+        p = Path(sys.executable)
+        p_venv = Path(os.environ["VIRTUAL_ENV"]).resolve()
+
+        # fallback venv detection:
+        # stdlib venv may symlink sys.executable, so we can't use realpath.
+        # but others can symlink *to* the venv Python, so we can't just use sys.executable.
+        # So we just check every item in the symlink tree (generally <= 3)
+        paths = self.get_path_links(p)
+
+        # In Cygwin paths like "c:\..." and '\cygdrive\c\...' are possible
+        if len(p_venv.parts) > 2 and p_venv.parts[1] == "cygdrive":
+            drive_name = p_venv.parts[2]
+            p_venv = (drive_name + ":/") / Path(*p_venv.parts[3:])
+
+        if any(p_venv == p.parents[1].resolve() for p in paths):
+            # Our exe is inside or has access to the virtualenv, don't need to do anything.
+            return
+
+        if sys.platform == "win32":
+            virtual_env = str(Path(os.environ["VIRTUAL_ENV"], "Lib", "site-packages"))
+        else:
+            virtual_env_path = Path(
+                os.environ["VIRTUAL_ENV"], "lib", "python{}.{}", "site-packages"
+            )
+            p_ver = sys.version_info[:2]
+
+            # Predict version from py[thon]-x.x in the $VIRTUAL_ENV
+            re_m = re.search(r"\bpy(?:thon)?([23])\.(\d+)\b", os.environ["VIRTUAL_ENV"])
+            if re_m:
+                predicted_path = Path(str(virtual_env_path).format(*re_m.groups()))
+                if predicted_path.exists():
+                    p_ver = re_m.groups()
+
+            virtual_env = str(virtual_env_path).format(*p_ver)
+        if self.warn_venv:
+            warn(
+                "Attempting to work in a virtualenv. If you encounter problems, "
+                "please install IPython inside the virtualenv."
+            )
+        import site
+        sys.path.insert(0, virtual_env)
+        site.addsitedir(virtual_env)
 
     #-------------------------------------------------------------------------
     # Things related to injections into the sys module
@@ -564,30 +988,45 @@ def init_reload_doctest(self):
     def save_sys_module_state(self):
         """Save the state of hooks in the sys module.
 
-        This has to be called after self.user_ns is created.
+        This has to be called after self.user_module is created.
         """
-        self._orig_sys_module_state = {}
-        self._orig_sys_module_state['stdin'] = sys.stdin
-        self._orig_sys_module_state['stdout'] = sys.stdout
-        self._orig_sys_module_state['stderr'] = sys.stderr
-        self._orig_sys_module_state['excepthook'] = sys.excepthook
-        try:
-            self._orig_sys_modules_main_name = self.user_ns['__name__']
-        except KeyError:
-            pass
+        self._orig_sys_module_state = {'stdin': sys.stdin,
+                                       'stdout': sys.stdout,
+                                       'stderr': sys.stderr,
+                                       'excepthook': sys.excepthook}
+        self._orig_sys_modules_main_name = self.user_module.__name__
+        self._orig_sys_modules_main_mod = sys.modules.get(self.user_module.__name__)
 
     def restore_sys_module_state(self):
         """Restore the state of the sys module."""
         try:
-            for k, v in self._orig_sys_module_state.iteritems():
+            for k, v in self._orig_sys_module_state.items():
                 setattr(sys, k, v)
         except AttributeError:
             pass
         # Reset what what done in self.init_sys_modules
-        try:
-            sys.modules[self.user_ns['__name__']] = self._orig_sys_modules_main_name
-        except (AttributeError, KeyError):
-            pass
+        if self._orig_sys_modules_main_mod is not None:
+            sys.modules[self._orig_sys_modules_main_name] = self._orig_sys_modules_main_mod
+
+    #-------------------------------------------------------------------------
+    # Things related to the banner
+    #-------------------------------------------------------------------------
+
+    @property
+    def banner(self):
+        banner = self.banner1
+        if self.profile and self.profile != 'default':
+            banner += '\nIPython profile: %s\n' % self.profile
+        if self.banner2:
+            banner += '\n' + self.banner2
+        elif self.enable_tip:
+            banner += "Tip: {tip}\n".format(tip=pick_tip())
+        return banner
+
+    def show_banner(self, banner=None):
+        if banner is None:
+            banner = self.banner
+        print(banner, end="")
 
     #-------------------------------------------------------------------------
     # Things related to hooks
@@ -604,19 +1043,22 @@ def init_hooks(self):
         for hook_name in hooks.__all__:
             # default hooks have priority 100, i.e. low; user hooks should have
             # 0-100 priority
-            self.set_hook(hook_name,getattr(hooks,hook_name), 100)
+            self.set_hook(hook_name, getattr(hooks, hook_name), 100)
+
+        if self.display_page:
+            self.set_hook('show_in_pager', page.as_hook(page.display_page), 90)
 
-    def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
+    def set_hook(self, name, hook, priority=50, str_key=None, re_key=None):
         """set_hook(name,hook) -> sets an internal IPython hook.
 
         IPython exposes some of its internal API as user-modifiable hooks.  By
-        adding your function to one of these hooks, you can modify IPython's 
+        adding your function to one of these hooks, you can modify IPython's
         behavior to call at runtime your own routines."""
 
         # At some point in the future, this should validate the hook before it
         # accepts it.  Probably at least check that the hook takes the number
         # of args it's supposed to.
-        
+
         f = types.MethodType(hook,self)
 
         # check if the hook is for strdispatcher first
@@ -630,14 +1072,15 @@ def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
             sdp.add_re(re.compile(re_key), f, priority )
             self.strdispatchers[name] = sdp
             return
-            
+
         dp = getattr(self.hooks, name, None)
         if name not in IPython.core.hooks.__all__:
-            print "Warning! Hook '%s' is not one of %s" % \
-                  (name, IPython.core.hooks.__all__ )
+            print("Warning! Hook '%s' is not one of %s" % \
+                  (name, IPython.core.hooks.__all__ ))
+
         if not dp:
             dp = IPython.core.hooks.CommandChainDispatcher()
-        
+
         try:
             dp.add(f,priority)
         except AttributeError:
@@ -646,64 +1089,63 @@ def set_hook(self,name,hook, priority = 50, str_key = None, re_key = None):
 
         setattr(self.hooks,name, dp)
 
-    def register_post_execute(self, func):
-        """Register a function for calling after code execution.
-        """
-        if not callable(func):
-            raise ValueError('argument %s must be callable' % func)
-        self._post_execute[func] = True
-
     #-------------------------------------------------------------------------
-    # Things related to the "main" module
+    # Things related to events
     #-------------------------------------------------------------------------
 
-    def new_main_mod(self,ns=None):
-        """Return a new 'main' module object for user code execution.
-        """
-        main_mod = self._user_main_module
-        init_fakemod_dict(main_mod,ns)
-        return main_mod
+    def init_events(self):
+        self.events = EventManager(self, available_events)
 
-    def cache_main_mod(self,ns,fname):
-        """Cache a main module's namespace.
+        self.events.register("pre_execute", self._clear_warning_registry)
 
-        When scripts are executed via %run, we must keep a reference to the
-        namespace of their __main__ module (a FakeModule instance) around so
-        that Python doesn't clear it, rendering objects defined therein
-        useless.
+    def _clear_warning_registry(self):
+        # clear the warning registry, so that different code blocks with
+        # overlapping line number ranges don't cause spurious suppression of
+        # warnings (see gh-6611 for details)
+        if "__warningregistry__" in self.user_global_ns:
+            del self.user_global_ns["__warningregistry__"]
 
-        This method keeps said reference in a private dict, keyed by the
-        absolute path of the module object (which corresponds to the script
-        path).  This way, for multiple executions of the same script we only
-        keep one copy of the namespace (the last one), thus preventing memory
-        leaks from old references while allowing the objects from the last
-        execution to be accessible.
-
-        Note: we can not allow the actual FakeModule instances to be deleted,
-        because of how Python tears down modules (it hard-sets all their
-        references to None without regard for reference counts).  This method
-        must therefore make a *copy* of the given namespace, to allow the
-        original module's __dict__ to be cleared and reused.
-
-        
-        Parameters
-        ----------
-          ns : a namespace (a dict, typically)
+    #-------------------------------------------------------------------------
+    # Things related to the "main" module
+    #-------------------------------------------------------------------------
 
-          fname : str
-            Filename associated with the namespace.
+    def new_main_mod(self, filename, modname):
+        """Return a new 'main' module object for user code execution.
 
-        Examples
-        --------
+        ``filename`` should be the path of the script which will be run in the
+        module. Requests with the same filename will get the same module, with
+        its namespace cleared.
 
-        In [10]: import IPython
+        ``modname`` should be the module name - normally either '__main__' or
+        the basename of the file without the extension.
 
-        In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
+        When scripts are executed via %run, we must keep a reference to their
+        __main__ module around so that Python doesn't
+        clear it, rendering references to module globals useless.
 
-        In [12]: IPython.__file__ in _ip._main_ns_cache
-        Out[12]: True
+        This method keeps said reference in a private dict, keyed by the
+        absolute path of the script. This way, for multiple executions of the
+        same script we only keep one copy of the namespace (the last one),
+        thus preventing memory leaks from old references while allowing the
+        objects from the last execution to be accessible.
         """
-        self._main_ns_cache[os.path.abspath(fname)] = ns.copy()
+        filename = os.path.abspath(filename)
+        try:
+            main_mod = self._main_mod_cache[filename]
+        except KeyError:
+            main_mod = self._main_mod_cache[filename] = types.ModuleType(
+                        modname,
+                        doc="Module created for script run in IPython")
+        else:
+            main_mod.__dict__.clear()
+            main_mod.__name__ = modname
+
+        main_mod.__file__ = filename
+        # It seems pydoc (and perhaps others) needs any module instance to
+        # implement a __nonzero__ method
+        main_mod.__nonzero__ = lambda : True
+
+        return main_mod
 
     def clear_main_mod_cache(self):
         """Clear the cache of main modules.
@@ -712,20 +1154,19 @@ def clear_main_mod_cache(self):
 
         Examples
         --------
-
         In [15]: import IPython
 
-        In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)
+        In [16]: m = _ip.new_main_mod(IPython.__file__, 'IPython')
 
-        In [17]: len(_ip._main_ns_cache) > 0
+        In [17]: len(_ip._main_mod_cache) > 0
         Out[17]: True
 
         In [18]: _ip.clear_main_mod_cache()
 
-        In [19]: len(_ip._main_ns_cache) == 0
+        In [19]: len(_ip._main_mod_cache) == 0
         Out[19]: True
         """
-        self._main_ns_cache.clear()
+        self._main_mod_cache.clear()
 
     #-------------------------------------------------------------------------
     # Things related to debugging
@@ -742,7 +1183,7 @@ def _get_call_pdb(self):
     def _set_call_pdb(self,val):
 
         if val not in (0,1,False,True):
-            raise ValueError,'new call_pdb value must be boolean'
+            raise ValueError('new call_pdb value must be boolean')
 
         # store value in instance
         self._call_pdb = val
@@ -754,14 +1195,14 @@ def _set_call_pdb(self,val):
                         'Control auto-activation of pdb at exceptions')
 
     def debugger(self,force=False):
-        """Call the pydb/pdb debugger.
+        """Call the pdb debugger.
 
         Keywords:
 
           - force(False): by default, this routine checks the instance call_pdb
-          flag and does not actually invoke the debugger if the flag is false.
-          The 'force' option forces the debugger to activate even if the flag
-          is false.
+            flag and does not actually invoke the debugger if the flag is false.
+            The 'force' option forces the debugger to activate even if the flag
+            is false.
         """
 
         if not (force or self.call_pdb):
@@ -771,21 +1212,14 @@ def debugger(self,force=False):
             error('No traceback has been produced, nothing to debug.')
             return
 
-        # use pydb if available
-        if debugger.has_pydb:
-            from pydb import pm
-        else:
-            # fallback to our internal debugger
-            pm = lambda : self.InteractiveTB.debugger(force=True)
-        
-        with self.readline_no_record:
-            pm()
+        self.InteractiveTB.debugger(force=True)
 
     #-------------------------------------------------------------------------
     # Things related to IPython's various namespaces
     #-------------------------------------------------------------------------
+    default_user_namespaces = True
 
-    def init_create_namespaces(self, user_ns=None, user_global_ns=None):
+    def init_create_namespaces(self, user_module=None, user_ns=None):
         # Create the namespace where the user will operate.  user_ns is
         # normally the only one used, and it is passed to the exec calls as
         # the locals argument.  But we do carry a user_global_ns namespace
@@ -819,31 +1253,21 @@ def init_create_namespaces(self, user_ns=None, user_global_ns=None):
         # should start with "import __builtin__" (note, no 's') which will
         # definitely give you a module. Yeah, it's somewhat confusing:-(.
 
-        # These routines return properly built dicts as needed by the rest of
-        # the code, and can also be used by extension writers to generate
-        # properly initialized namespaces.
-        user_ns, user_global_ns = self.make_user_namespaces(user_ns,
-                                                            user_global_ns)
-
-        # Assign namespaces
-        # This is the namespace where all normal user variables live
-        self.user_ns = user_ns
-        self.user_global_ns = user_global_ns
-
-        # An auxiliary namespace that checks what parts of the user_ns were
-        # loaded at startup, so we can list later only variables defined in
-        # actual interactive use.  Since it is always a subset of user_ns, it
-        # doesn't need to be separately tracked in the ns_table.
-        self.user_ns_hidden = {}
+        # These routines return a properly built module and dict as needed by
+        # the rest of the code, and can also be used by extension writers to
+        # generate properly initialized namespaces.
+        if (user_ns is not None) or (user_module is not None):
+            self.default_user_namespaces = False
+        self.user_module, self.user_ns = self.prepare_user_module(user_module, user_ns)
 
-        # A namespace to keep track of internal data structures to prevent
-        # them from cluttering user-visible stuff.  Will be updated later
-        self.internal_ns = {}
+        # A record of hidden variables we have added to the user namespace, so
+        # we can list later only variables defined in actual interactive use.
+        self.user_ns_hidden = {}
 
         # Now that FakeModule produces a real module, we've run into a nasty
         # problem: after script execution (via %run), the module where the user
         # code ran is deleted.  Now that this object is a true module (needed
-        # so docetst and other tools work correctly), the Python module
+        # so doctest and other tools work correctly), the Python module
         # teardown mechanism runs over it, and sets to None every variable
         # present in that module.  Top-level references to objects from the
         # script survive, because the user_ns is updated with them.  However,
@@ -851,7 +1275,7 @@ def init_create_namespaces(self, user_ns=None, user_global_ns=None):
         # the script will fail, because the function's closure had references
         # to the original objects, which are now all None.  So we must protect
         # these modules from deletion by keeping a cache.
-        # 
+        #
         # To avoid keeping stale modules around (we only need the one from the
         # last run), we use a dict keyed with the full path to the script, so
         # only the last version of the module is held in the cache.  Note,
@@ -859,90 +1283,65 @@ def init_create_namespaces(self, user_ns=None, user_global_ns=None):
         # __dict__).  Because if we try to cache the actual modules, old ones
         # (uncached) could be destroyed while still holding references (such as
         # those held by GUI objects that tend to be long-lived)>
-        # 
+        #
         # The %reset command will flush this cache.  See the cache_main_mod()
         # and clear_main_mod_cache() methods for details on use.
 
         # This is the cache used for 'main' namespaces
-        self._main_ns_cache = {}
-        # And this is the single instance of FakeModule whose __dict__ we keep
-        # copying and clearing for reuse on each %run
-        self._user_main_module = FakeModule()
+        self._main_mod_cache = {}
 
         # A table holding all the namespaces IPython deals with, so that
         # introspection facilities can search easily.
-        self.ns_table = {'user':user_ns,
-                         'user_global':user_global_ns,
-                         'internal':self.internal_ns,
-                         'builtin':__builtin__.__dict__
+        self.ns_table = {'user_global':self.user_module.__dict__,
+                         'user_local':self.user_ns,
+                         'builtin':builtin_mod.__dict__
                          }
 
-        # Similarly, track all namespaces where references can be held and that
-        # we can safely clear (so it can NOT include builtin).  This one can be
-        # a simple list.  Note that the main execution namespaces, user_ns and
-        # user_global_ns, can NOT be listed here, as clearing them blindly
-        # causes errors in object __del__ methods.  Instead, the reset() method
-        # clears them manually and carefully.
-        self.ns_refs_table = [ self.user_ns_hidden,
-                               self.internal_ns, self._main_ns_cache ]
-
-    def make_user_namespaces(self, user_ns=None, user_global_ns=None):
-        """Return a valid local and global user interactive namespaces.
-
-        This builds a dict with the minimal information needed to operate as a
-        valid IPython user namespace, which you can pass to the various
-        embedding classes in ipython. The default implementation returns the
-        same dict for both the locals and the globals to allow functions to
-        refer to variables in the namespace. Customized implementations can
-        return different dicts. The locals dictionary can actually be anything
-        following the basic mapping protocol of a dict, but the globals dict
-        must be a true dict, not even a subclass. It is recommended that any
-        custom object for the locals namespace synchronize with the globals
-        dict somehow.
-
-        Raises TypeError if the provided globals namespace is not a true dict.
+    @property
+    def user_global_ns(self):
+        return self.user_module.__dict__
+
+    def prepare_user_module(self, user_module=None, user_ns=None):
+        """Prepare the module and namespace in which user code will be run.
+
+        When IPython is started normally, both parameters are None: a new module
+        is created automatically, and its __dict__ used as the namespace.
+
+        If only user_module is provided, its __dict__ is used as the namespace.
+        If only user_ns is provided, a dummy module is created, and user_ns
+        becomes the global namespace. If both are provided (as they may be
+        when embedding), user_ns is the local namespace, and user_module
+        provides the global namespace.
 
         Parameters
         ----------
-        user_ns : dict-like, optional
-            The current user namespace. The items in this namespace should
-            be included in the output. If None, an appropriate blank
-            namespace should be created.
-        user_global_ns : dict, optional
-            The current user global namespace. The items in this namespace
-            should be included in the output. If None, an appropriate
-            blank namespace should be created.
+        user_module : module, optional
+            The current user module in which IPython is being run. If None,
+            a clean module will be created.
+        user_ns : dict, optional
+            A namespace in which to run interactive commands.
 
         Returns
         -------
-            A pair of dictionary-like object to be used as the local namespace
-            of the interpreter and a dict to be used as the global namespace.
+        A tuple of user_module and user_ns, each properly initialised.
         """
+        if user_module is None and user_ns is not None:
+            user_ns.setdefault("__name__", "__main__")
+            user_module = make_main_module_type(user_ns)()
 
+        if user_module is None:
+            user_module = types.ModuleType("__main__",
+                doc="Automatically created module for IPython interactive environment")
 
         # We must ensure that __builtin__ (without the final 's') is always
         # available and pointing to the __builtin__ *module*.  For more details:
         # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
+        user_module.__dict__.setdefault('__builtin__', builtin_mod)
+        user_module.__dict__.setdefault('__builtins__', builtin_mod)
 
         if user_ns is None:
-            # Set __name__ to __main__ to better match the behavior of the
-            # normal interpreter.
-            user_ns = {'__name__'     :'__main__',
-                       '__builtin__' : __builtin__,
-                       '__builtins__' : __builtin__,
-                      }
-        else:
-            user_ns.setdefault('__name__','__main__')
-            user_ns.setdefault('__builtin__',__builtin__)
-            user_ns.setdefault('__builtins__',__builtin__)
-
-        if user_global_ns is None:
-            user_global_ns = user_ns
-        if type(user_global_ns) is not dict:
-            raise TypeError("user_global_ns must be a true dict; got %r"
-                % type(user_global_ns))
-
-        return user_ns, user_global_ns
+            user_ns = user_module.__dict__
+        return user_module, user_ns
 
     def init_sys_modules(self):
         # We need to insert into sys.modules something that looks like a
@@ -961,13 +1360,8 @@ def init_sys_modules(self):
         # embedded in).
 
         # This is overridden in the InteractiveShellEmbed subclass to a no-op.
-
-        try:
-            main_name = self.user_ns['__name__']
-        except KeyError:
-            raise KeyError('user_ns dictionary MUST have a "__name__" key')
-        else:
-            sys.modules[main_name] = FakeModule(self.user_ns)
+        main_name = self.user_module.__name__
+        sys.modules[main_name] = self.user_module
 
     def init_user_ns(self):
         """Initialize all user-visible namespaces to their minimum defaults.
@@ -979,13 +1373,13 @@ def init_user_ns(self):
         -----
         All data structures here are only filled in, they are NOT reset by this
         method.  If they were not empty before, data will simply be added to
-        therm.
+        them.
         """
         # This function works in two parts: first we put a few things in
         # user_ns, and we sync that contents into user_ns_hidden so that these
         # initial variables aren't shown by %who.  After the sync, we add the
         # rest of what we *do* want the user to see with %who even on a new
-        # session (probably nothing, so theye really only see their own stuff)
+        # session (probably nothing, so they really only see their own stuff)
 
         # The user dict must *always* have a __builtin__ reference to the
         # Python standard __builtin__ namespace,  which must be imported.
@@ -995,35 +1389,28 @@ def init_user_ns(self):
         # module, and can even mutate at runtime, depending on the context
         # (Python makes no guarantees on it).  In contrast, __builtin__ is
         # always a module object, though it must be explicitly imported.
-        
+
         # For more details:
         # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
-        ns = dict(__builtin__ = __builtin__)
-        
-        # Put 'help' in the user namespace
-        try:
-            from site import _Helper
-            ns['help'] = _Helper()
-        except ImportError:
-            warn('help() not available - check site.py')
+        ns = {}
 
         # make global variables for user access to the histories
-        ns['_ih'] = self.history_manager.input_hist_parsed
-        ns['_oh'] = self.history_manager.output_hist
-        ns['_dh'] = self.history_manager.dir_hist
+        if self.history_manager is not None:
+            ns["_ih"] = self.history_manager.input_hist_parsed
+            ns["_oh"] = self.history_manager.output_hist
+            ns["_dh"] = self.history_manager.dir_hist
 
-        ns['_sh'] = shadowns
-
-        # user aliases to input and output histories.  These shouldn't show up
-        # in %who, as they can have very large reprs.
-        ns['In']  = self.history_manager.input_hist_parsed
-        ns['Out'] = self.history_manager.output_hist
+            # user aliases to input and output histories.  These shouldn't show up
+            # in %who, as they can have very large reprs.
+            ns["In"] = self.history_manager.input_hist_parsed
+            ns["Out"] = self.history_manager.output_hist
 
         # Store myself as the public api!!!
         ns['get_ipython'] = self.get_ipython
-        
+
         ns['exit'] = self.exiter
         ns['quit'] = self.exiter
+        ns["open"] = _modified_open
 
         # Sync what we've added so far to user_ns_hidden so these aren't seen
         # by %who
@@ -1032,53 +1419,129 @@ def init_user_ns(self):
         # Anything put into ns now would show up in %who.  Think twice before
         # putting anything here, as we really want %who to show the user their
         # stuff, not our variables.
-        
+
         # Finally, update the real user's namespace
         self.user_ns.update(ns)
 
-    def reset(self, new_session=True):
+    @property
+    def all_ns_refs(self):
+        """Get a list of references to all the namespace dictionaries in which
+        IPython might store a user-created object.
+
+        Note that this does not include the displayhook, which also caches
+        objects from the output."""
+        return [self.user_ns, self.user_global_ns, self.user_ns_hidden] + \
+               [m.__dict__ for m in self._main_mod_cache.values()]
+
+    def reset(self, new_session=True, aggressive=False):
         """Clear all internal namespaces, and attempt to release references to
         user objects.
-        
+
         If new_session is True, a new history session will be opened.
         """
         # Clear histories
-        self.history_manager.reset(new_session)
+        if self.history_manager is not None:
+            self.history_manager.reset(new_session)
         # Reset counter used to index all histories
         if new_session:
             self.execution_count = 1
-        
+
+        # Reset last execution result
+        self.last_execution_succeeded = True
+        self.last_execution_result = None
+
         # Flush cached output items
         if self.displayhook.do_full_cache:
             self.displayhook.flush()
-        
-        # Restore the user namespaces to minimal usability
-        for ns in self.ns_refs_table:
-            ns.clear()
 
         # The main execution namespaces must be cleared very carefully,
         # skipping the deletion of the builtin-related keys, because doing so
         # would cause errors in many object's __del__ methods.
-        for ns in [self.user_ns, self.user_global_ns]:
-            drop_keys = set(ns.keys())
-            drop_keys.discard('__builtin__')
-            drop_keys.discard('__builtins__')
-            for k in drop_keys:
-                del ns[k]
-                                        
+        if self.user_ns is not self.user_global_ns:
+            self.user_ns.clear()
+        ns = self.user_global_ns
+        drop_keys = set(ns.keys())
+        drop_keys.discard('__builtin__')
+        drop_keys.discard('__builtins__')
+        drop_keys.discard('__name__')
+        for k in drop_keys:
+            del ns[k]
+
+        self.user_ns_hidden.clear()
+
         # Restore the user namespaces to minimal usability
         self.init_user_ns()
+        if aggressive and not hasattr(self, "_sys_modules_keys"):
+            print("Cannot restore sys.module, no snapshot")
+        elif aggressive:
+            print("culling sys module...")
+            current_keys = set(sys.modules.keys())
+            for k in current_keys - self._sys_modules_keys:
+                if k.startswith("multiprocessing"):
+                    continue
+                del sys.modules[k]
 
         # Restore the default and user aliases
         self.alias_manager.clear_aliases()
         self.alias_manager.init_aliases()
-        
+
+        # Now define aliases that only make sense on the terminal, because they
+        # need direct access to the console in a way that we can't emulate in
+        # GUI or web frontend
+        if os.name == 'posix':
+            for cmd in ('clear', 'more', 'less', 'man'):
+                if cmd not in self.magics_manager.magics['line']:
+                    self.alias_manager.soft_define_alias(cmd, cmd)
+
         # Flush the private list of module references kept for script
         # execution protection
         self.clear_main_mod_cache()
-        
-        # Clear out the namespace from the last %run
-        self.new_main_mod()
+
+    def del_var(self, varname, by_name=False):
+        """Delete a variable from the various namespaces, so that, as
+        far as possible, we're not keeping any hidden references to it.
+
+        Parameters
+        ----------
+        varname : str
+            The name of the variable to delete.
+        by_name : bool
+            If True, delete variables with the given name in each
+            namespace. If False (default), find the variable in the user
+            namespace, and delete references to it.
+        """
+        if varname in ('__builtin__', '__builtins__'):
+            raise ValueError("Refusing to delete %s" % varname)
+
+        ns_refs = self.all_ns_refs
+
+        if by_name:                    # Delete by name
+            for ns in ns_refs:
+                try:
+                    del ns[varname]
+                except KeyError:
+                    pass
+        else:                         # Delete by object
+            try:
+                obj = self.user_ns[varname]
+            except KeyError as e:
+                raise NameError("name '%s' is not defined" % varname) from e
+            # Also check in output history
+            assert self.history_manager is not None
+            ns_refs.append(self.history_manager.output_hist)
+            for ns in ns_refs:
+                to_delete = [n for n, o in ns.items() if o is obj]
+                for name in to_delete:
+                    del ns[name]
+
+            # Ensure it is removed from the last execution result
+            if self.last_execution_result.result is obj:
+                self.last_execution_result = None
+
+            # displayhook keeps extra references, but not in a dictionary
+            for name in ('_', '__', '___'):
+                if getattr(self.displayhook, name) is obj:
+                    setattr(self.displayhook, name, None)
 
     def reset_selective(self, regex=None):
         """Clear selective variables from internal namespaces based on a
@@ -1093,15 +1556,15 @@ def reset_selective(self, regex=None):
         if regex is not None:
             try:
                 m = re.compile(regex)
-            except TypeError:
-                raise TypeError('regex must be a string or compiled pattern')
+            except TypeError as e:
+                raise TypeError('regex must be a string or compiled pattern') from e
             # Search for keys in each namespace that match the given regex
             # If a match is found, delete the key/value pair.
-            for ns in self.ns_refs_table:
+            for ns in self.all_ns_refs:
                 for var in ns:
                     if m.search(var):
-                        del ns[var]        
-        
+                        del ns[var]
+
     def push(self, variables, interactive=True):
         """Inject a group of variables into the IPython user namespace.
 
@@ -1123,82 +1586,155 @@ def push(self, variables, interactive=True):
         # We need a dict of name/value pairs to do namespace updates.
         if isinstance(variables, dict):
             vdict = variables
-        elif isinstance(variables, (basestring, list, tuple)):
-            if isinstance(variables, basestring):
+        elif isinstance(variables, (str, list, tuple)):
+            if isinstance(variables, str):
                 vlist = variables.split()
             else:
-                vlist = variables
+                vlist = list(variables)
             vdict = {}
             cf = sys._getframe(1)
             for name in vlist:
                 try:
                     vdict[name] = eval(name, cf.f_globals, cf.f_locals)
                 except:
-                    print ('Could not get variable %s from %s' %
+                    print('Could not get variable %s from %s' %
                            (name,cf.f_code.co_name))
         else:
             raise ValueError('variables must be a dict/str/list/tuple')
-            
+
         # Propagate variables to user namespace
         self.user_ns.update(vdict)
 
         # And configure interactive visibility
-        config_ns = self.user_ns_hidden
+        user_ns_hidden = self.user_ns_hidden
         if interactive:
-            for name, val in vdict.iteritems():
-                config_ns.pop(name, None)
+            for name in vdict:
+                user_ns_hidden.pop(name, None)
         else:
-            for name,val in vdict.iteritems():
-                config_ns[name] = val
+            user_ns_hidden.update(vdict)
+
+    def drop_by_id(self, variables):
+        """Remove a dict of variables from the user namespace, if they are the
+        same as the values in the dictionary.
+
+        This is intended for use by extensions: variables that they've added can
+        be taken back out if they are unloaded, without removing any that the
+        user has overwritten.
+
+        Parameters
+        ----------
+        variables : dict
+            A dictionary mapping object names (as strings) to the objects.
+        """
+        for name, obj in variables.items():
+            if name in self.user_ns and self.user_ns[name] is obj:
+                del self.user_ns[name]
+                self.user_ns_hidden.pop(name, None)
 
     #-------------------------------------------------------------------------
     # Things related to object introspection
     #-------------------------------------------------------------------------
+    @staticmethod
+    def _find_parts(oname: str) -> Tuple[bool, ListType[str]]:
+        """
+        Given an object name, return a list of parts of this object name.
 
-    def _ofind(self, oname, namespaces=None):
-        """Find an object in the available namespaces.
+        Basically split on docs when using attribute access,
+        and extract the value when using square bracket.
 
-        self._ofind(oname) -> dict with keys: found,obj,ospace,ismagic
 
-        Has special code to detect magic functions.
-        """
-        #oname = oname.strip()
-        #print '1- oname: <%r>' % oname  # dbg
-        try:
-            oname = oname.strip().encode('ascii')
-            #print '2- oname: <%r>' % oname  # dbg
-        except UnicodeEncodeError:
-            print 'Python identifiers can only contain ascii characters.'
-            return dict(found=False)
+        For example foo.bar[3].baz[x] -> foo, bar, 3, baz, x
 
-        alias_ns = None
-        if namespaces is None:
+
+        Returns
+        -------
+        parts_ok: bool
+            whether we were properly able to parse parts.
+        parts: list of str
+            extracted parts
+
+
+
+        """
+        raw_parts = oname.split(".")
+        parts = []
+        parts_ok = True
+        for p in raw_parts:
+            if p.endswith("]"):
+                var, *indices = p.split("[")
+                if not var.isidentifier():
+                    parts_ok = False
+                    break
+                parts.append(var)
+                for ind in indices:
+                    if ind[-1] != "]" and not is_integer_string(ind[:-1]):
+                        parts_ok = False
+                        break
+                    parts.append(ind[:-1])
+                continue
+
+            if not p.isidentifier():
+                parts_ok = False
+            parts.append(p)
+
+        return parts_ok, parts
+
+    def _ofind(
+        self, oname: str, namespaces: Optional[Sequence[Tuple[str, AnyType]]] = None
+    ) -> OInfo:
+        """Find an object in the available namespaces.
+
+
+        Returns
+        -------
+        OInfo with fields:
+          - ismagic
+          - isalias
+          - found
+          - obj
+          - namespac
+          - parent
+
+        Has special code to detect magic functions.
+        """
+        oname = oname.strip()
+        parts_ok, parts = self._find_parts(oname)
+
+        if (
+            not oname.startswith(ESC_MAGIC)
+            and not oname.startswith(ESC_MAGIC2)
+            and not parts_ok
+        ):
+            return OInfo(
+                ismagic=False,
+                isalias=False,
+                found=False,
+                obj=None,
+                namespace=None,
+                parent=None,
+            )
+
+        if namespaces is None:
             # Namespaces to search in:
             # Put them in a list. The order is important so that we
             # find things in the same order that Python finds them.
             namespaces = [ ('Interactive', self.user_ns),
-                           ('IPython internal', self.internal_ns),
-                           ('Python builtin', __builtin__.__dict__),
-                           ('Alias', self.alias_manager.alias_table),
+                           ('Interactive (global)', self.user_global_ns),
+                           ('Python builtin', builtin_mod.__dict__),
                            ]
-            alias_ns = self.alias_manager.alias_table
 
-        # initialize results to 'null'
-        found = False; obj = None;  ospace = None;  ds = None;
-        ismagic = False; isalias = False; parent = None
+        ismagic = False
+        isalias = False
+        found = False
+        ospace = None
+        parent = None
+        obj = None
 
-        # We need to special-case 'print', which as of python2.6 registers as a
-        # function but should only be treated as one if print_function was
-        # loaded with a future import.  In this case, just bail.
-        if (oname == 'print' and not (self.compile.compiler_flags &
-                                      __future__.CO_FUTURE_PRINT_FUNCTION)):
-            return {'found':found, 'obj':obj, 'namespace':ospace,
-                    'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
 
         # Look for the given name by splitting it in parts.  If the head is
         # found, then we look for all the remaining parts as members, and only
         # declare success if we can find them all.
-        oname_parts = oname.split('.')
+        oname_parts = parts
         oname_head, oname_rest = oname_parts[0],oname_parts[1:]
         for nsname,ns in namespaces:
             try:
@@ -1206,11 +1742,19 @@ def _ofind(self, oname, namespaces=None):
             except KeyError:
                 continue
             else:
-                #print 'oname_rest:', oname_rest  # dbg
-                for part in oname_rest:
+                for idx, part in enumerate(oname_rest):
                     try:
                         parent = obj
-                        obj = getattr(obj,part)
+                        # The last part is looked up in a special way to avoid
+                        # descriptor invocation as it may raise or have side
+                        # effects.
+                        if idx == len(oname_rest) - 1:
+                            obj = self._getattr_property(obj, part)
+                        else:
+                            if is_integer_string(part):
+                                obj = obj[int(part)]
+                            else:
+                                obj = getattr(obj, part)
                     except:
                         # Blanket except b/c some badly implemented objects
                         # allow __getattr__ to raise exceptions other than
@@ -1220,19 +1764,27 @@ def _ofind(self, oname, namespaces=None):
                     # If we finish the for loop (no break), we got all members
                     found = True
                     ospace = nsname
-                    if ns == alias_ns:
-                        isalias = True
                     break  # namespace loop
 
         # Try to see if it's magic
         if not found:
-            if oname.startswith(ESC_MAGIC):
-                oname = oname[1:]
-            obj = getattr(self,'magic_'+oname,None)
+            obj = None
+            if oname.startswith(ESC_MAGIC2):
+                oname = oname.lstrip(ESC_MAGIC2)
+                obj = self.find_cell_magic(oname)
+            elif oname.startswith(ESC_MAGIC):
+                oname = oname.lstrip(ESC_MAGIC)
+                obj = self.find_line_magic(oname)
+            else:
+                # search without prefix, so run? will find %run?
+                obj = self.find_line_magic(oname)
+                if obj is None:
+                    obj = self.find_cell_magic(oname)
             if obj is not None:
                 found = True
                 ospace = 'IPython internal'
                 ismagic = True
+                isalias = isinstance(obj, Alias)
 
         # Last try: special-case some literals like '', [], {}, etc:
         if not found and oname_head in ["''",'""','[]','{}','()']:
@@ -1240,86 +1792,164 @@ def _ofind(self, oname, namespaces=None):
             found = True
             ospace = 'Interactive'
 
-        return {'found':found, 'obj':obj, 'namespace':ospace,
-                'ismagic':ismagic, 'isalias':isalias, 'parent':parent}
+        return OInfo(
+            obj=obj,
+            found=found,
+            parent=parent,
+            ismagic=ismagic,
+            isalias=isalias,
+            namespace=ospace,
+        )
 
-    def _ofind_property(self, oname, info):
-        """Second part of object finding, to look for property details."""
-        if info.found:
-            # Get the docstring of the class property if it exists.
-            path = oname.split('.')
-            root = '.'.join(path[:-1])
-            if info.parent is not None:
-                try:
-                    target = getattr(info.parent, '__class__') 
-                    # The object belongs to a class instance. 
-                    try: 
-                        target = getattr(target, path[-1])
-                        # The class defines the object. 
-                        if isinstance(target, property):
-                            oname = root + '.__class__.' + path[-1]
-                            info = Struct(self._ofind(oname))
-                    except AttributeError: pass
-                except AttributeError: pass
-
-        # We return either the new info or the unmodified input if the object
-        # hadn't been found
-        return info
-
-    def _object_find(self, oname, namespaces=None):
+    @staticmethod
+    def _getattr_property(obj, attrname):
+        """Property-aware getattr to use in object finding.
+
+        If attrname represents a property, return it unevaluated (in case it has
+        side effects or raises an error.
+
+        """
+        if not isinstance(obj, type):
+            try:
+                # `getattr(type(obj), attrname)` is not guaranteed to return
+                # `obj`, but does so for property:
+                #
+                # property.__get__(self, None, cls) -> self
+                #
+                # The universal alternative is to traverse the mro manually
+                # searching for attrname in class dicts.
+                if is_integer_string(attrname):
+                    return obj[int(attrname)]
+                else:
+                    attr = getattr(type(obj), attrname)
+            except AttributeError:
+                pass
+            else:
+                # This relies on the fact that data descriptors (with both
+                # __get__ & __set__ magic methods) take precedence over
+                # instance-level attributes:
+                #
+                #    class A(object):
+                #        @property
+                #        def foobar(self): return 123
+                #    a = A()
+                #    a.__dict__['foobar'] = 345
+                #    a.foobar  # == 123
+                #
+                # So, a property may be returned right away.
+                if isinstance(attr, property):
+                    return attr
+
+        # Nothing helped, fall back.
+        return getattr(obj, attrname)
+
+    def _object_find(self, oname, namespaces=None) -> OInfo:
         """Find an object and return a struct with info about it."""
-        inf = Struct(self._ofind(oname, namespaces))
-        return Struct(self._ofind_property(oname, inf))
-        
-    def _inspect(self, meth, oname, namespaces=None, **kw):
+        return self._ofind(oname, namespaces)
+
+    def _inspect(self, meth, oname: str, namespaces=None, **kw):
         """Generic interface to the inspector system.
 
-        This function is meant to be called by pdef, pdoc & friends."""
-        info = self._object_find(oname)
-        if info.found:
+        This function is meant to be called by pdef, pdoc & friends.
+        """
+        info: OInfo = self._object_find(oname, namespaces)
+        if self.sphinxify_docstring:
+            if sphinxify is None:
+                raise ImportError("Module ``docrepr`` required but missing")
+            docformat = sphinxify(self.object_inspect(oname))
+        else:
+            docformat = None
+        if info.found or hasattr(info.parent, oinspect.HOOK_NAME):
             pmethod = getattr(self.inspector, meth)
-            formatter = format_screen if info.ismagic else None
+            # TODO: only apply format_screen to the plain/text repr of the mime
+            # bundle.
+            formatter = format_screen if info.ismagic else docformat
             if meth == 'pdoc':
                 pmethod(info.obj, oname, formatter)
             elif meth == 'pinfo':
-                pmethod(info.obj, oname, formatter, info, **kw)
+                pmethod(
+                    info.obj,
+                    oname,
+                    formatter,
+                    info,
+                    enable_html_pager=self.enable_html_pager,
+                    **kw,
+                )
             else:
                 pmethod(info.obj, oname)
         else:
-            print 'Object `%s` not found.' % oname
+            print('Object `%s` not found.' % oname)
             return 'not found'  # so callers can take other action
 
-    def object_inspect(self, oname):
+    def object_inspect(self, oname, detail_level=0):
+        """Get object info about oname"""
         with self.builtin_trap:
             info = self._object_find(oname)
             if info.found:
-                return self.inspector.info(info.obj, oname, info=info)
+                return self.inspector.info(info.obj, oname, info=info,
+                            detail_level=detail_level
+                )
             else:
                 return oinspect.object_info(name=oname, found=False)
 
+    def object_inspect_text(self, oname, detail_level=0):
+        """Get object info as formatted text"""
+        return self.object_inspect_mime(oname, detail_level)['text/plain']
+
+    def object_inspect_mime(self, oname, detail_level=0, omit_sections=()):
+        """Get object info as a mimebundle of formatted representations.
+
+        A mimebundle is a dictionary, keyed by mime-type.
+        It must always have the key `'text/plain'`.
+        """
+        with self.builtin_trap:
+            info = self._object_find(oname)
+            if info.found:
+                if self.sphinxify_docstring:
+                    if sphinxify is None:
+                        raise ImportError("Module ``docrepr`` required but missing")
+                    docformat = sphinxify(self.object_inspect(oname))
+                else:
+                    docformat = None
+                return self.inspector._get_info(
+                    info.obj,
+                    oname,
+                    info=info,
+                    detail_level=detail_level,
+                    formatter=docformat,
+                    omit_sections=omit_sections,
+                )
+            else:
+                raise KeyError(oname)
+
     #-------------------------------------------------------------------------
     # Things related to history management
     #-------------------------------------------------------------------------
 
     def init_history(self):
         """Sets up the command history, and starts regular autosaves."""
-        self.history_manager = HistoryManager(shell=self, config=self.config)
+        self.history_manager = HistoryManager(shell=self, parent=self)
+        self.configurables.append(self.history_manager)
 
     #-------------------------------------------------------------------------
     # Things related to exception handling and tracebacks (not debugging)
     #-------------------------------------------------------------------------
 
-    def init_traceback_handlers(self, custom_exceptions):
+    debugger_cls = InterruptiblePdb
+
+    def init_traceback_handlers(self, custom_exceptions) -> None:
         # Syntax error handler.
-        self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
-        
+        self.SyntaxTB = ultratb.SyntaxTB(theme_name=self.colors)
+
         # The interactive one is initialized with an offset, meaning we always
         # want to remove the topmost item in the traceback, which is our own
-        # internal code. Valid modes: ['Plain','Context','Verbose']
-        self.InteractiveTB = ultratb.AutoFormattedTB(mode = 'Plain',
-                                                     color_scheme='NoColor',
-                                                     tb_offset = 1,
-                                   check_cache=self.compile.check_cache)
+        # internal code. Valid modes: ['Plain','Context','Verbose','Minimal']
+        self.InteractiveTB = ultratb.AutoFormattedTB(
+            mode=self.xmode,
+            theme_name=self.colors,
+            tb_offset=1,
+            debugger_cls=self.debugger_cls,
+        )
 
         # The instance will store a pointer to the system-wide exception hook,
         # so that runtime code (such as magics) can access it.  This is because
@@ -1333,79 +1963,189 @@ def init_traceback_handlers(self, custom_exceptions):
         self.InteractiveTB.set_mode(mode=self.xmode)
 
     def set_custom_exc(self, exc_tuple, handler):
-        """set_custom_exc(exc_tuple,handler)
+        """set_custom_exc(exc_tuple, handler)
 
         Set a custom exception handler, which will be called if any of the
         exceptions in exc_tuple occur in the mainloop (specifically, in the
-        run_code() method.
+        run_code() method).
 
-        Inputs:
+        Parameters
+        ----------
+        exc_tuple : tuple of exception classes
+            A *tuple* of exception classes, for which to call the defined
+            handler.  It is very important that you use a tuple, and NOT A
+            LIST here, because of the way Python's except statement works.  If
+            you only want to trap a single exception, use a singleton tuple::
+
+                exc_tuple == (MyCustomException,)
 
-          - exc_tuple: a *tuple* of valid exceptions to call the defined
-          handler for.  It is very important that you use a tuple, and NOT A
-          LIST here, because of the way Python's except statement works.  If
-          you only want to trap a single exception, use a singleton tuple:
+        handler : callable
+            handler must have the following signature::
 
-            exc_tuple == (MyCustomException,)
+                def my_handler(self, etype, value, tb, tb_offset=None):
+                    ...
+                    return structured_traceback
 
-          - handler: this must be defined as a function with the following
-          basic interface::
+            Your handler must return a structured traceback (a list of strings),
+            or None.
 
-            def my_handler(self, etype, value, tb, tb_offset=None)
-                ...
-                # The return value must be
-                return structured_traceback
+            This will be made into an instance method (via types.MethodType)
+            of IPython itself, and it will be called if any of the exceptions
+            listed in the exc_tuple are caught. If the handler is None, an
+            internal basic one is used, which just prints basic info.
 
-          This will be made into an instance method (via types.MethodType)
-          of IPython itself, and it will be called if any of the exceptions
-          listed in the exc_tuple are caught.  If the handler is None, an
-          internal basic one is used, which just prints basic info.
+            To protect IPython from crashes, if your handler ever raises an
+            exception or returns an invalid result, it will be immediately
+            disabled.
 
+        Notes
+        -----
         WARNING: by putting in your own exception handler into IPython's main
         execution loop, you run a very good chance of nasty crashes.  This
-        facility should only be used if you really know what you are doing."""
-
-        assert type(exc_tuple)==type(()) , \
-               "The custom exceptions must be given AS A TUPLE."
-
-        def dummy_handler(self,etype,value,tb):
-            print '*** Simple custom exception handler ***'
-            print 'Exception type :',etype
-            print 'Exception value:',value
-            print 'Traceback      :',tb
-            #print 'Source code    :','\n'.join(self.buffer)
+        facility should only be used if you really know what you are doing.
+        """
 
-        if handler is None: handler = dummy_handler
+        if not isinstance(exc_tuple, tuple):
+            raise TypeError("The custom exceptions must be given as a tuple.")
+
+        def dummy_handler(self, etype, value, tb, tb_offset=None):
+            print('*** Simple custom exception handler ***')
+            print('Exception type :', etype)
+            print('Exception value:', value)
+            print('Traceback      :', tb)
+
+        def validate_stb(stb):
+            """validate structured traceback return type
+
+            return type of CustomTB *should* be a list of strings, but allow
+            single strings or None, which are harmless.
+
+            This function will *always* return a list of strings,
+            and will raise a TypeError if stb is inappropriate.
+            """
+            msg = "CustomTB must return list of strings, not %r" % stb
+            if stb is None:
+                return []
+            elif isinstance(stb, str):
+                return [stb]
+            elif not isinstance(stb, list):
+                raise TypeError(msg)
+            # it's a list
+            for line in stb:
+                # check every element
+                if not isinstance(line, str):
+                    raise TypeError(msg)
+            return stb
+
+        if handler is None:
+            wrapped = dummy_handler
+        else:
+            def wrapped(self,etype,value,tb,tb_offset=None):
+                """wrap CustomTB handler, to protect IPython from user code
 
-        self.CustomTB = types.MethodType(handler,self)
+                This makes it harder (but not impossible) for custom exception
+                handlers to crash IPython.
+                """
+                try:
+                    stb = handler(self,etype,value,tb,tb_offset=tb_offset)
+                    return validate_stb(stb)
+                except:
+                    # clear custom handler immediately
+                    self.set_custom_exc((), None)
+                    print("Custom TB Handler failed, unregistering", file=sys.stderr)
+                    # show the exception in handler first
+                    stb = self.InteractiveTB.structured_traceback(*sys.exc_info())
+                    print(self.InteractiveTB.stb2text(stb))
+                    print("The original exception:")
+                    stb = self.InteractiveTB.structured_traceback(
+                        etype, value, tb, tb_offset=tb_offset
+                    )
+                return stb
+
+        self.CustomTB = types.MethodType(wrapped,self)
         self.custom_exceptions = exc_tuple
 
     def excepthook(self, etype, value, tb):
-      """One more defense for GUI apps that call sys.excepthook.
-
-      GUI frameworks like wxPython trap exceptions and call
-      sys.excepthook themselves.  I guess this is a feature that
-      enables them to keep running after exceptions that would
-      otherwise kill their mainloop. This is a bother for IPython
-      which excepts to catch all of the program exceptions with a try:
-      except: statement.
-
-      Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
-      any app directly invokes sys.excepthook, it will look to the user like
-      IPython crashed.  In order to work around this, we can disable the
-      CrashHandler and replace it with this excepthook instead, which prints a
-      regular traceback using our InteractiveTB.  In this fashion, apps which
-      call sys.excepthook will generate a regular-looking exception from
-      IPython, and the CrashHandler will only be triggered by real IPython
-      crashes.
-
-      This hook should be used sparingly, only in places which are not likely
-      to be true IPython errors.
-      """
-      self.showtraceback((etype,value,tb),tb_offset=0)
-
-    def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
-                      exception_only=False):
+        """One more defense for GUI apps that call sys.excepthook.
+
+        GUI frameworks like wxPython trap exceptions and call
+        sys.excepthook themselves.  I guess this is a feature that
+        enables them to keep running after exceptions that would
+        otherwise kill their mainloop. This is a bother for IPython
+        which expects to catch all of the program exceptions with a try:
+        except: statement.
+
+        Normally, IPython sets sys.excepthook to a CrashHandler instance, so if
+        any app directly invokes sys.excepthook, it will look to the user like
+        IPython crashed.  In order to work around this, we can disable the
+        CrashHandler and replace it with this excepthook instead, which prints a
+        regular traceback using our InteractiveTB.  In this fashion, apps which
+        call sys.excepthook will generate a regular-looking exception from
+        IPython, and the CrashHandler will only be triggered by real IPython
+        crashes.
+
+        This hook should be used sparingly, only in places which are not likely
+        to be true IPython errors.
+        """
+        self.showtraceback((etype, value, tb), tb_offset=0)
+
+    def _get_exc_info(self, exc_tuple=None):
+        """get exc_info from a given tuple, sys.exc_info() or sys.last_type etc.
+
+        Ensures sys.last_type,value,traceback hold the exc_info we found,
+        from whichever source.
+
+        raises ValueError if none of these contain any information
+        """
+        if exc_tuple is None:
+            etype, value, tb = sys.exc_info()
+        else:
+            etype, value, tb = exc_tuple
+
+        if etype is None:
+            if hasattr(sys, 'last_type'):
+                etype, value, tb = sys.last_type, sys.last_value, \
+                                   sys.last_traceback
+
+        if etype is None:
+            raise ValueError("No exception to find")
+
+        # Now store the exception info in sys.last_type etc.
+        # WARNING: these variables are somewhat deprecated and not
+        # necessarily safe to use in a threaded environment, but tools
+        # like pdb depend on their existence, so let's set them.  If we
+        # find problems in the field, we'll need to revisit their use.
+        sys.last_type = etype
+        sys.last_value = value
+        sys.last_traceback = tb
+        sys.last_exc = value
+
+        return etype, value, tb
+
+    def show_usage_error(self, exc):
+        """Show a short message for UsageErrors
+
+        These are special exceptions that shouldn't show a traceback.
+        """
+        print("UsageError: %s" % exc, file=sys.stderr)
+
+    def get_exception_only(self, exc_tuple=None):
+        """
+        Return as a string (ending with a newline) the exception that
+        just occurred, without any traceback.
+        """
+        etype, value, tb = self._get_exc_info(exc_tuple)
+        msg = traceback.format_exception_only(etype, value)
+        return ''.join(msg)
+
+    def showtraceback(
+        self,
+        exc_tuple: tuple[type[BaseException], BaseException, AnyType] | None = None,
+        filename: str | None = None,
+        tb_offset: int | None = None,
+        exception_only: bool = False,
+        running_compiled_code: bool = False,
+    ) -> None:
         """Display the exception that just occurred.
 
         If nothing is known about the exception, this is the method which
@@ -1416,70 +2156,85 @@ def showtraceback(self,exc_tuple = None,filename=None,tb_offset=None,
         care of calling it if needed, so unless you are explicitly catching a
         SyntaxError exception, don't try to analyze the stack manually and
         simply call this method."""
-        
+
         try:
-            if exc_tuple is None:
-                etype, value, tb = sys.exc_info()
-            else:
-                etype, value, tb = exc_tuple
+            try:
+                etype, value, tb = self._get_exc_info(exc_tuple)
+            except ValueError:
+                print('No traceback available to show.', file=sys.stderr)
+                return
 
-            if etype is None:
-                if hasattr(sys, 'last_type'):
-                    etype, value, tb = sys.last_type, sys.last_value, \
-                                       sys.last_traceback
-                else:
-                    self.write_err('No traceback available to show.\n')
-                    return
-    
-            if etype is SyntaxError:
+            if issubclass(etype, SyntaxError):
                 # Though this won't be called by syntax errors in the input
-                # line, there may be SyntaxError cases whith imported code.
-                self.showsyntaxerror(filename)
+                # line, there may be SyntaxError cases with imported code.
+                self.showsyntaxerror(filename, running_compiled_code)
             elif etype is UsageError:
-                print "UsageError:", value
+                self.show_usage_error(value)
             else:
-                # WARNING: these variables are somewhat deprecated and not
-                # necessarily safe to use in a threaded environment, but tools
-                # like pdb depend on their existence, so let's set them.  If we
-                # find problems in the field, we'll need to revisit their use.
-                sys.last_type = etype
-                sys.last_value = value
-                sys.last_traceback = tb
-                if etype in self.custom_exceptions:
-                    # FIXME: Old custom traceback objects may just return a
-                    # string, in that case we just put it into a list
-                    stb = self.CustomTB(etype, value, tb, tb_offset)
-                    if isinstance(ctb, basestring):
-                        stb = [stb]
+                if exception_only:
+                    stb = ['An exception has occurred, use %tb to see '
+                           'the full traceback.\n']
+                    stb.extend(self.InteractiveTB.get_exception_only(etype,
+                                                                     value))
                 else:
-                    if exception_only:
-                        stb = ['An exception has occurred, use %tb to see '
-                               'the full traceback.\n']
-                        stb.extend(self.InteractiveTB.get_exception_only(etype,
-                                                                         value))
+
+                    def contains_exceptiongroup(val):
+                        if val is None:
+                            return False
+                        return isinstance(
+                            val, BaseExceptionGroup
+                        ) or contains_exceptiongroup(val.__context__)
+
+                    if contains_exceptiongroup(value):
+                        # fall back to native exception formatting until ultratb
+                        # supports exception groups
+                        traceback.print_exc()
                     else:
-                        stb = self.InteractiveTB.structured_traceback(etype,
-                                                value, tb, tb_offset=tb_offset)
-                        
-                        if self.call_pdb:
-                            # drop into debugger
-                            self.debugger(force=True)
+                        try:
+                            # Exception classes can customise their traceback - we
+                            # use this in IPython.parallel for exceptions occurring
+                            # in the engines. This should return a list of strings.
+                            if hasattr(value, "_render_traceback_"):
+                                stb = value._render_traceback_()
+                            else:
+                                stb = self.InteractiveTB.structured_traceback(
+                                    etype, value, tb, tb_offset=tb_offset
+                                )
+
+                        except Exception:
+                            print(
+                                "Unexpected exception formatting exception. Falling back to standard exception"
+                            )
+                            traceback.print_exc()
+                            return None
+
+                        self._showtraceback(etype, value, stb)
+                    if self.call_pdb:
+                        # drop into debugger
+                        self.debugger(force=True)
+                    return
 
                 # Actually show the traceback
                 self._showtraceback(etype, value, stb)
-                
+
         except KeyboardInterrupt:
-            self.write_err("\nKeyboardInterrupt\n")
+            print('\n' + self.get_exception_only(), file=sys.stderr)
 
-    def _showtraceback(self, etype, evalue, stb):
+    def _showtraceback(self, etype, evalue, stb: list[str]):
         """Actually show a traceback.
 
         Subclasses may override this method to put the traceback on a different
         place, like a side channel.
         """
-        print >> io.stdout, self.InteractiveTB.stb2text(stb)
+        val = self.InteractiveTB.stb2text(stb)
+        self.showing_traceback = True
+        try:
+            print(val)
+        except UnicodeEncodeError:
+            print(val.encode("utf-8", "backslashreplace").decode())
+        self.showing_traceback = False
 
-    def showsyntaxerror(self, filename=None):
+    def showsyntaxerror(self, filename=None, running_compiled_code=False):
         """Display the syntax error that just occurred.
 
         This doesn't display a stack trace because there isn't one.
@@ -1487,147 +2242,45 @@ def showsyntaxerror(self, filename=None):
         If a filename is given, it is stuffed in the exception instead
         of what was there before (because Python's parser always uses
         "<string>" when reading from a string).
+
+        If the syntax error occurred when running a compiled code (i.e. running_compile_code=True),
+        longer stack trace will be displayed.
         """
-        etype, value, last_traceback = sys.exc_info()
+        etype, value, last_traceback = self._get_exc_info()
 
-        # See note about these variables in showtraceback() above
-        sys.last_type = etype
-        sys.last_value = value
-        sys.last_traceback = last_traceback
-        
-        if filename and etype is SyntaxError:
-            # Work hard to stuff the correct filename in the exception
+        if filename and issubclass(etype, SyntaxError):
             try:
-                msg, (dummy_filename, lineno, offset, line) = value
+                value.filename = filename
             except:
                 # Not the format we expect; leave it alone
                 pass
-            else:
-                # Stuff in the right filename
-                try:
-                    # Assume SyntaxError is a class exception
-                    value = SyntaxError(msg, (filename, lineno, offset, line))
-                except:
-                    # If that failed, assume SyntaxError is a string
-                    value = msg, (filename, lineno, offset, line)
-        stb = self.SyntaxTB.structured_traceback(etype, value, [])
+
+        # If the error occurred when executing compiled code, we should provide full stacktrace.
+        elist = traceback.extract_tb(last_traceback) if running_compiled_code else []
+        stb = self.SyntaxTB.structured_traceback(etype, value, elist)
         self._showtraceback(etype, value, stb)
 
-    #-------------------------------------------------------------------------
-    # Things related to readline
-    #-------------------------------------------------------------------------
+    # This is overridden in TerminalInteractiveShell to show a message about
+    # the %paste magic.
+    def showindentationerror(self):
+        """Called by _run_cell when there's an IndentationError in code entered
+        at the prompt.
 
-    def init_readline(self):
-        """Command history completion/saving/reloading."""
+        This is overridden in TerminalInteractiveShell to show a message about
+        the %paste magic."""
+        self.showsyntaxerror()
 
-        if self.readline_use:
-            import IPython.utils.rlineimpl as readline
+    @skip_doctest
+    def set_next_input(self, s, replace=False):
+        """ Sets the 'default' input string for the next command line.
 
-        self.rl_next_input = None
-        self.rl_do_indent = False
+        Example::
 
-        if not self.readline_use or not readline.have_readline:
-            self.has_readline = False
-            self.readline = None
-            # Set a number of methods that depend on readline to be no-op
-            self.set_readline_completer = no_op
-            self.set_custom_completer = no_op
-            self.set_completer_frame = no_op
-            warn('Readline services not available or not loaded.')
-        else:
-            self.has_readline = True
-            self.readline = readline
-            sys.modules['readline'] = readline
-            
-            # Platform-specific configuration
-            if os.name == 'nt':
-                # FIXME - check with Frederick to see if we can harmonize
-                # naming conventions with pyreadline to avoid this
-                # platform-dependent check
-                self.readline_startup_hook = readline.set_pre_input_hook
-            else:
-                self.readline_startup_hook = readline.set_startup_hook
-
-            # Load user's initrc file (readline config)
-            # Or if libedit is used, load editrc.
-            inputrc_name = os.environ.get('INPUTRC')
-            if inputrc_name is None:
-                home_dir = get_home_dir()
-                if home_dir is not None:
-                    inputrc_name = '.inputrc'
-                    if readline.uses_libedit:
-                        inputrc_name = '.editrc'
-                    inputrc_name = os.path.join(home_dir, inputrc_name)
-            if os.path.isfile(inputrc_name):
-                try:
-                    readline.read_init_file(inputrc_name)
-                except:
-                    warn('Problems reading readline initialization file <%s>'
-                         % inputrc_name)
-            
-            # Configure readline according to user's prefs
-            # This is only done if GNU readline is being used.  If libedit
-            # is being used (as on Leopard) the readline config is
-            # not run as the syntax for libedit is different.
-            if not readline.uses_libedit:
-                for rlcommand in self.readline_parse_and_bind:
-                    #print "loading rl:",rlcommand  # dbg
-                    readline.parse_and_bind(rlcommand)
-
-            # Remove some chars from the delimiters list.  If we encounter
-            # unicode chars, discard them.
-            delims = readline.get_completer_delims().encode("ascii", "ignore")
-            delims = delims.translate(None, self.readline_remove_delims)
-            delims = delims.replace(ESC_MAGIC, '')
-            readline.set_completer_delims(delims)
-            # otherwise we end up with a monster history after a while:
-            readline.set_history_length(self.history_length)
-            
-            self.refill_readline_hist()
-            self.readline_no_record = ReadlineNoRecord(self)
-
-        # Configure auto-indent for all platforms
-        self.set_autoindent(self.autoindent)
-        
-    def refill_readline_hist(self):
-        # Load the last 1000 lines from history
-        self.readline.clear_history()
-        stdin_encoding = sys.stdin.encoding or "utf-8"
-        for _, _, cell in self.history_manager.get_tail(1000,
-                                                        include_latest=True):
-            if cell.strip(): # Ignore blank lines
-                for line in cell.splitlines():
-                    self.readline.add_history(line.encode(stdin_encoding, 'replace'))
-
-    def set_next_input(self, s):
-        """ Sets the 'default' input string for the next command line.
-        
-        Requires readline.
-        
-        Example:
-        
-        [D:\ipython]|1> _ip.set_next_input("Hello Word")
-        [D:\ipython]|2> Hello Word_  # cursor is here        
+            In [1]: _ip.set_next_input("Hello Word")
+            In [2]: Hello Word_  # cursor is here
         """
-
         self.rl_next_input = s
 
-    # Maybe move this to the terminal subclass?
-    def pre_readline(self):
-        """readline hook to be used at the start of each line.
-
-        Currently it handles auto-indent only."""
-
-        if self.rl_do_indent:
-            self.readline.insert_text(self._indent_current_str())
-        if self.rl_next_input is not None:
-            self.readline.insert_text(self.rl_next_input)
-            self.rl_next_input = None
-
-    def _indent_current_str(self):
-        """return the current level of indentation as a string"""
-        return self.input_splitter.indent_spaces * ' '
-
     #-------------------------------------------------------------------------
     # Things related to text completion
     #-------------------------------------------------------------------------
@@ -1637,20 +2290,24 @@ def init_completer(self):
 
         This creates completion machinery that can be used by client code,
         either interactively in-process (typically triggered by the readline
-        library), programatically (such as in test suites) or out-of-prcess
+        library), programmatically (such as in test suites) or out-of-process
         (typically over the network by remote frontends).
         """
         from IPython.core.completer import IPCompleter
-        from IPython.core.completerlib import (module_completer,
-                                               magic_run_completer, cd_completer)
-        
-        self.Completer = IPCompleter(self,
-                                     self.user_ns,
-                                     self.user_global_ns,
-                                     self.readline_omit__names,
-                                     self.alias_manager.alias_table,
-                                     self.has_readline)
-        
+        from IPython.core.completerlib import (
+            cd_completer,
+            magic_run_completer,
+            module_completer,
+            reset_completer,
+        )
+
+        self.Completer = IPCompleter(shell=self,
+                                     namespace=self.user_ns,
+                                     global_namespace=self.user_global_ns,
+                                     parent=self,
+                                     )
+        self.configurables.append(self.Completer)
+
         # Add custom completers to the basic ones built into IPCompleter
         sdisp = self.strdispatchers.get('complete_command', StrDispatch())
         self.strdispatchers['complete_command'] = sdisp
@@ -1658,50 +2315,45 @@ def init_completer(self):
 
         self.set_hook('complete_command', module_completer, str_key = 'import')
         self.set_hook('complete_command', module_completer, str_key = 'from')
+        self.set_hook('complete_command', module_completer, str_key = '%aimport')
         self.set_hook('complete_command', magic_run_completer, str_key = '%run')
         self.set_hook('complete_command', cd_completer, str_key = '%cd')
+        self.set_hook('complete_command', reset_completer, str_key = '%reset')
 
-        # Only configure readline if we truly are using readline.  IPython can
-        # do tab-completion over the network, in GUIs, etc, where readline
-        # itself may be absent
-        if self.has_readline:
-            self.set_readline_completer()
-
+    @skip_doctest
     def complete(self, text, line=None, cursor_pos=None):
         """Return the completed text and a list of completions.
 
         Parameters
         ----------
-
-           text : string
-             A string of text to be completed on.  It can be given as empty and
-             instead a line/position pair are given.  In this case, the
-             completer itself will split the line like readline does.
-
-           line : string, optional
-             The complete line that text is part of.
-
-           cursor_pos : int, optional
-             The position of the cursor on the input line.
+        text : string
+            A string of text to be completed on.  It can be given as empty and
+            instead a line/position pair are given.  In this case, the
+            completer itself will split the line like readline does.
+        line : string, optional
+            The complete line that text is part of.
+        cursor_pos : int, optional
+            The position of the cursor on the input line.
 
         Returns
         -------
-          text : string
+        text : string
             The actual text that was completed.
-
-          matches : list
+        matches : list
             A sorted list with all possible completions.
 
+        Notes
+        -----
         The optional arguments allow the completion to take more context into
         account, and are part of the low-level completion API.
-        
+
         This is a wrapper around the completion mechanism, similar to what
         readline does at the command line when the TAB key is hit.  By
         exposing it as a method, it can be used by other non-readline
         environments (such as GUIs) for text completion.
 
-        Simple usage example:
-
+        Examples
+        --------
         In [1]: x = 'hello'
 
         In [2]: _ip.complete('x.l')
@@ -1712,18 +2364,23 @@ def complete(self, text, line=None, cursor_pos=None):
         with self.builtin_trap:
             return self.Completer.complete(text, line, cursor_pos)
 
-    def set_custom_completer(self, completer, pos=0):
+    def set_custom_completer(self, completer, pos=0) -> None:
         """Adds a new custom completer function.
 
         The position argument (defaults to 0) is the index in the completers
-        list where you want the completer to be inserted."""
+        list where you want the completer to be inserted.
 
-        newcomp = types.MethodType(completer,self.Completer)
-        self.Completer.matchers.insert(pos,newcomp)
+        `completer` should have the following signature::
 
-    def set_readline_completer(self):
-        """Reset readline's completer to be our own."""
-        self.readline.set_completer(self.Completer.rlcomplete)
+            def completion(self: Completer, text: string) -> List[str]:
+                raise NotImplementedError
+
+        It will be bound to the current Completer instance and pass some text
+        and return a list with current completions to suggest to the user.
+        """
+
+        newcomp = types.MethodType(completer, self.Completer)
+        self.Completer.custom_matchers.insert(pos,newcomp)
 
     def set_completer_frame(self, frame=None):
         """Set the frame of the completer."""
@@ -1739,70 +2396,206 @@ def set_completer_frame(self, frame=None):
     #-------------------------------------------------------------------------
 
     def init_magics(self):
+        from IPython.core import magics as m
+        self.magics_manager = magic.MagicsManager(shell=self,
+                                   parent=self,
+                                   user_magics=m.UserMagics(self))
+        self.configurables.append(self.magics_manager)
+
+        # Expose as public API from the magics manager
+        self.register_magics = self.magics_manager.register
+
+        self.register_magics(m.AutoMagics, m.BasicMagics, m.CodeMagics,
+            m.ConfigMagics, m.DisplayMagics, m.ExecutionMagics,
+            m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
+            m.NamespaceMagics, m.OSMagics, m.PackagingMagics,
+            m.PylabMagics, m.ScriptMagics,
+        )
+        self.register_magics(m.AsyncMagics)
+
+        # Register Magic Aliases
+        mman = self.magics_manager
+        # FIXME: magic aliases should be defined by the Magics classes
+        # or in MagicsManager, not here
+        mman.register_alias('ed', 'edit')
+        mman.register_alias('hist', 'history')
+        mman.register_alias('rep', 'recall')
+        mman.register_alias('SVG', 'svg', 'cell')
+        mman.register_alias('HTML', 'html', 'cell')
+        mman.register_alias('file', 'writefile', 'cell')
+
         # FIXME: Move the color initialization to the DisplayHook, which
         # should be split into a prompt manager and displayhook. We probably
         # even need a centralize colors management object.
-        self.magic_colors(self.colors)
-        # History was moved to a separate module
-        from . import history
-        history.init_ipython(self)
+        self.run_line_magic('colors', self.colors)
 
-    def magic(self,arg_s):
-        """Call a magic function by name.
+    # Defined here so that it's included in the documentation
+    @functools.wraps(magic.MagicsManager.register_function)
+    def register_magic_function(self, func, magic_kind='line', magic_name=None):
+        self.magics_manager.register_function(
+            func, magic_kind=magic_kind, magic_name=magic_name
+        )
 
-        Input: a string containing the name of the magic function to call and
-        any additional arguments to be passed to the magic.
+    def _find_with_lazy_load(self, /, type_, magic_name: str):
+        """
+        Try to find a magic potentially lazy-loading it.
 
-        magic('name -opt foo bar') is equivalent to typing at the ipython
-        prompt:
+        Parameters
+        ----------
 
-        In[1]: %name -opt foo bar
+        type_: "line"|"cell"
+            the type of magics we are trying to find/lazy load.
+        magic_name: str
+            The name of the magic we are trying to find/lazy load
 
-        To call a magic without arguments, simply use magic('name').
 
-        This provides a proper Python function to call IPython's magics in any
-        valid Python code you can type at the interpreter, including loops and
-        compound statements.
+        Note that this may have any side effects
         """
-        args = arg_s.split(' ',1)
-        magic_name = args[0]
-        magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
-        
-        try:
-            magic_args = args[1]
-        except IndexError:
-            magic_args = ''
-        fn = getattr(self,'magic_'+magic_name,None)
+        finder = {"line": self.find_line_magic, "cell": self.find_cell_magic}[type_]
+        fn = finder(magic_name)
+        if fn is not None:
+            return fn
+        lazy = self.magics_manager.lazy_magics.get(magic_name)
+        if lazy is None:
+            return None
+
+        self.run_line_magic("load_ext", lazy)
+        res = finder(magic_name)
+        return res
+
+    def run_line_magic(self, magic_name: str, line: str, _stack_depth=1):
+        """Execute the given line magic.
+
+        Parameters
+        ----------
+        magic_name : str
+            Name of the desired magic function, without '%' prefix.
+        line : str
+            The rest of the input line as a single string.
+        _stack_depth : int
+            If run_line_magic() is called from magic() then _stack_depth=2.
+            This is added to ensure backward compatibility for use of 'get_ipython().magic()'
+        """
+        fn = self._find_with_lazy_load("line", magic_name)
         if fn is None:
-            error("Magic function `%s` not found." % magic_name)
+            lazy = self.magics_manager.lazy_magics.get(magic_name)
+            if lazy:
+                self.run_line_magic("load_ext", lazy)
+                fn = self.find_line_magic(magic_name)
+        if fn is None:
+            cm = self.find_cell_magic(magic_name)
+            etpl = "Line magic function `%%%s` not found%s."
+            extra = '' if cm is None else (' (But cell magic `%%%%%s` exists, '
+                                    'did you mean that instead?)' % magic_name )
+            raise UsageError(etpl % (magic_name, extra))
         else:
-            magic_args = self.var_expand(magic_args,1)
+            # Note: this is the distance in the stack to the user's frame.
+            # This will need to be updated if the internal calling logic gets
+            # refactored, or else we'll be expanding the wrong variables.
+
+            # Determine stack_depth depending on where run_line_magic() has been called
+            stack_depth = _stack_depth
+            if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
+                # magic has opted out of var_expand
+                magic_arg_s = line
+            else:
+                magic_arg_s = self.var_expand(line, stack_depth)
+            # Put magic args in a list so we can call with f(*a) syntax
+            args = [magic_arg_s]
+            kwargs = {}
             # Grab local namespace if we need it:
             if getattr(fn, "needs_local_scope", False):
-                self._magic_locals = sys._getframe(1).f_locals
+                kwargs['local_ns'] = self.get_local_scope(stack_depth)
             with self.builtin_trap:
-                result = fn(magic_args)
-            # Ensure we're not keeping object references around:
-            self._magic_locals = {}
+                result = fn(*args, **kwargs)
+
+            # The code below prevents the output from being displayed
+            # when using magics with decorator @output_can_be_silenced
+            # when the last Python token in the expression is a ';'.
+            if getattr(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, False):
+                if DisplayHook.semicolon_at_end_of_expression(magic_arg_s):
+                    return None
+
             return result
 
-    def define_magic(self, magicname, func):
-        """Expose own function as magic function for ipython 
-    
-        def foo_impl(self,parameter_s=''):
-            'My very own magic!. (Use docstrings, IPython reads them).'
-            print 'Magic function. Passed parameter is between < >:'
-            print '<%s>' % parameter_s
-            print 'The self object is:',self
-    
-        self.define_magic('foo',foo_impl)
-        """
-        
-        import new
-        im = types.MethodType(func,self)
-        old = getattr(self, "magic_" + magicname, None)
-        setattr(self, "magic_" + magicname, im)
-        return old
+    def get_local_scope(self, stack_depth):
+        """Get local scope at given stack depth.
+
+        Parameters
+        ----------
+        stack_depth : int
+            Depth relative to calling frame
+        """
+        return sys._getframe(stack_depth + 1).f_locals
+
+    def run_cell_magic(self, magic_name, line, cell):
+        """Execute the given cell magic.
+
+        Parameters
+        ----------
+        magic_name : str
+            Name of the desired magic function, without '%' prefix.
+        line : str
+            The rest of the first input line as a single string.
+        cell : str
+            The body of the cell as a (possibly multiline) string.
+        """
+        fn = self._find_with_lazy_load("cell", magic_name)
+        if fn is None:
+            lm = self.find_line_magic(magic_name)
+            etpl = "Cell magic `%%{0}` not found{1}."
+            extra = '' if lm is None else (' (But line magic `%{0}` exists, '
+                            'did you mean that instead?)'.format(magic_name))
+            raise UsageError(etpl.format(magic_name, extra))
+        elif cell == '':
+            message = '%%{0} is a cell magic, but the cell body is empty.'.format(magic_name)
+            if self.find_line_magic(magic_name) is not None:
+                message += ' Did you mean the line magic %{0} (single %)?'.format(magic_name)
+            raise UsageError(message)
+        else:
+            # Note: this is the distance in the stack to the user's frame.
+            # This will need to be updated if the internal calling logic gets
+            # refactored, or else we'll be expanding the wrong variables.
+            stack_depth = 2
+            if getattr(fn, magic.MAGIC_NO_VAR_EXPAND_ATTR, False):
+                # magic has opted out of var_expand
+                magic_arg_s = line
+            else:
+                magic_arg_s = self.var_expand(line, stack_depth)
+            kwargs = {}
+            if getattr(fn, "needs_local_scope", False):
+                kwargs['local_ns'] = self.user_ns
+
+            with self.builtin_trap:
+                args = (magic_arg_s, cell)
+                result = fn(*args, **kwargs)
+
+            # The code below prevents the output from being displayed
+            # when using magics with decorator @output_can_be_silenced
+            # when the last Python token in the expression is a ';'.
+            if getattr(fn, magic.MAGIC_OUTPUT_CAN_BE_SILENCED, False):
+                if DisplayHook.semicolon_at_end_of_expression(cell):
+                    return None
+
+            return result
+
+    def find_line_magic(self, magic_name):
+        """Find and return a line magic by name.
+
+        Returns None if the magic isn't found."""
+        return self.magics_manager.magics['line'].get(magic_name)
+
+    def find_cell_magic(self, magic_name):
+        """Find and return a cell magic by name.
+
+        Returns None if the magic isn't found."""
+        return self.magics_manager.magics['cell'].get(magic_name)
+
+    def find_magic(self, magic_name, magic_kind='line'):
+        """Find and return a magic of the given type by name.
+
+        Returns None if the magic isn't found."""
+        return self.magics_manager.magics[magic_kind].get(magic_name)
 
     #-------------------------------------------------------------------------
     # Things related to macros
@@ -1816,13 +2609,13 @@ def define_macro(self, name, themacro):
         name : str
             The name of the macro.
         themacro : str or Macro
-            The action to do upon invoking the macro.  If a string, a new 
+            The action to do upon invoking the macro.  If a string, a new
             Macro object is created by passing the string to it.
         """
-        
+
         from IPython.core import macro
 
-        if isinstance(themacro, basestring):
+        if isinstance(themacro, str):
             themacro = macro.Macro(themacro)
         if not isinstance(themacro, macro.Macro):
             raise ValueError('A macro must be a string or a Macro instance.')
@@ -1832,42 +2625,119 @@ def define_macro(self, name, themacro):
     # Things related to the running of system commands
     #-------------------------------------------------------------------------
 
-    def system(self, cmd):
-        """Call the given cmd in a subprocess.
+    def system_piped(self, cmd):
+        """Call the given cmd in a subprocess, piping stdout/err
 
         Parameters
         ----------
         cmd : str
-          Command to execute (can not end in '&', as bacground processes are
-          not supported.
+            Command to execute (can not end in '&', as background processes are
+            not supported.  Should not be a command that expects input
+            other than simple text.
         """
-        # We do not support backgrounding processes because we either use
-        # pexpect or pipes to read from.  Users can always just call
-        # os.system() if they really want a background process.
-        if cmd.endswith('&'):
+        if cmd.rstrip().endswith('&'):
+            # this is *far* from a rigorous test
+            # We do not support backgrounding processes because we either use
+            # pexpect or pipes to read from.  Users can always just call
+            # os.system() or use ip.system=ip.system_raw
+            # if they really want a background process.
             raise OSError("Background processes not supported.")
 
-        return system(self.var_expand(cmd, depth=2))
+        # we explicitly do NOT return the subprocess status code, because
+        # a non-None value would trigger :func:`sys.displayhook` calls.
+        # Instead, we store the exit_code in user_ns.
+        self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
+
+    def system_raw(self, cmd):
+        """Call the given cmd in a subprocess using os.system on Windows or
+        subprocess.call using the system shell on other platforms.
+
+        Parameters
+        ----------
+        cmd : str
+            Command to execute.
+        """
+        cmd = self.var_expand(cmd, depth=1)
+        # warn if there is an IPython magic alternative.
+        if cmd == "":
+            main_cmd = ""
+        else:
+            main_cmd = cmd.split()[0]
+        has_magic_alternatives = ("pip", "conda", "cd")
+
+        if main_cmd in has_magic_alternatives:
+            warnings.warn(
+                (
+                    "You executed the system command !{0} which may not work "
+                    "as expected. Try the IPython magic %{0} instead."
+                ).format(main_cmd)
+            )
 
-    def getoutput(self, cmd, split=True):
+        # protect os.system from UNC paths on Windows, which it can't handle:
+        if sys.platform == 'win32':
+            from IPython.utils._process_win32 import AvoidUNCPath
+            with AvoidUNCPath() as path:
+                if path is not None:
+                    cmd = '"pushd %s &&"%s' % (path, cmd)
+                try:
+                    ec = os.system(cmd)
+                except KeyboardInterrupt:
+                    print('\n' + self.get_exception_only(), file=sys.stderr)
+                    ec = -2
+        else:
+            # For posix the result of the subprocess.call() below is an exit
+            # code, which by convention is zero for success, positive for
+            # program failure.  Exit codes above 128 are reserved for signals,
+            # and the formula for converting a signal to an exit code is usually
+            # signal_number+128.  To more easily differentiate between exit
+            # codes and signals, ipython uses negative numbers.  For instance
+            # since control-c is signal 2 but exit code 130, ipython's
+            # _exit_code variable will read -2.  Note that some shells like
+            # csh and fish don't follow sh/bash conventions for exit codes.
+            executable = os.environ.get('SHELL', None)
+            try:
+                # Use env shell instead of default /bin/sh
+                ec = subprocess.call(cmd, shell=True, executable=executable)
+            except KeyboardInterrupt:
+                # intercept control-C; a long traceback is not useful here
+                print('\n' + self.get_exception_only(), file=sys.stderr)
+                ec = 130
+            if ec > 128:
+                ec = -(ec - 128)
+
+        # We explicitly do NOT return the subprocess status code, because
+        # a non-None value would trigger :func:`sys.displayhook` calls.
+        # Instead, we store the exit_code in user_ns.  Note the semantics
+        # of _exit_code: for control-c, _exit_code == -signal.SIGNIT,
+        # but raising SystemExit(_exit_code) will give status 254!
+        self.user_ns['_exit_code'] = ec
+
+    # use piped system by default, because it is better behaved
+    system = system_piped
+
+    def getoutput(self, cmd, split=True, depth=0):
         """Get output (possibly including stderr) from a subprocess.
 
         Parameters
         ----------
         cmd : str
-          Command to execute (can not end in '&', as background processes are
-          not supported.
+            Command to execute (can not end in '&', as background processes are
+            not supported.
         split : bool, optional
-        
-          If True, split the output into an IPython SList.  Otherwise, an
-          IPython LSString is returned.  These are objects similar to normal
-          lists and strings, with a few convenience attributes for easier
-          manipulation of line-based output.  You can use '?' on them for
-          details.
-          """
-        if cmd.endswith('&'):
+            If True, split the output into an IPython SList.  Otherwise, an
+            IPython LSString is returned.  These are objects similar to normal
+            lists and strings, with a few convenience attributes for easier
+            manipulation of line-based output.  You can use '?' on them for
+            details.
+        depth : int, optional
+            How many frames above the caller are the local variables which should
+            be expanded in the command string? The default (0) assumes that the
+            expansion variables are in the stack frame calling this function.
+        """
+        if cmd.rstrip().endswith('&'):
+            # this is *far* from a rigorous test
             raise OSError("Background processes not supported.")
-        out = getoutput(self.var_expand(cmd, depth=2))
+        out = getoutput(self.var_expand(cmd, depth=depth+1))
         if split:
             out = SList(out.splitlines())
         else:
@@ -1879,32 +2749,32 @@ def getoutput(self, cmd, split=True):
     #-------------------------------------------------------------------------
 
     def init_alias(self):
-        self.alias_manager = AliasManager(shell=self, config=self.config)
-        self.ns_table['alias'] = self.alias_manager.alias_table,
+        self.alias_manager = AliasManager(shell=self, parent=self)
+        self.configurables.append(self.alias_manager)
 
     #-------------------------------------------------------------------------
-    # Things related to extensions and plugins
+    # Things related to extensions
     #-------------------------------------------------------------------------
 
     def init_extension_manager(self):
-        self.extension_manager = ExtensionManager(shell=self, config=self.config)
-
-    def init_plugin_manager(self):
-        self.plugin_manager = PluginManager(config=self.config)
+        self.extension_manager = ExtensionManager(shell=self, parent=self)
+        self.configurables.append(self.extension_manager)
 
     #-------------------------------------------------------------------------
     # Things related to payloads
     #-------------------------------------------------------------------------
 
     def init_payload(self):
-        self.payload_manager = PayloadManager(config=self.config)
+        self.payload_manager = PayloadManager(parent=self)
+        self.configurables.append(self.payload_manager)
 
     #-------------------------------------------------------------------------
     # Things related to the prefilter
     #-------------------------------------------------------------------------
 
     def init_prefilter(self):
-        self.prefilter_manager = PrefilterManager(shell=self, config=self.config)
+        self.prefilter_manager = PrefilterManager(shell=self, parent=self)
+        self.configurables.append(self.prefilter_manager)
         # Ultimately this will be refactored in the new interpreter code, but
         # for now, we should expose the main prefilter method (there's legacy
         # code out there that may rely on this).
@@ -1921,73 +2791,76 @@ def auto_rewrite_input(self, cmd):
         into::
 
           ------> f(x)
-          
+
         after the user's input prompt.  This helps the user understand that the
         input line was transformed automatically by IPython.
         """
-        rw = self.displayhook.prompt1.auto_rewrite() + cmd
+        if not self.show_rewritten_input:
+            return
+
+        # This is overridden in TerminalInteractiveShell to use fancy prompts
+        print("------> " + cmd)
 
-        try:
-            # plain ascii works better w/ pyreadline, on some machines, so
-            # we use it and only print uncolored rewrite if we have unicode
-            rw = str(rw)
-            print >> io.stdout, rw
-        except UnicodeEncodeError:
-            print "------> " + cmd
-            
     #-------------------------------------------------------------------------
     # Things related to extracting values/expressions from kernel and user_ns
     #-------------------------------------------------------------------------
 
-    def _simple_error(self):
-        etype, value = sys.exc_info()[:2]
-        return u'[ERROR] {e.__name__}: {v}'.format(e=etype, v=value)
+    def _user_obj_error(self):
+        """return simple exception dict
 
-    def user_variables(self, names):
-        """Get a list of variable names from the user's namespace.
+        for use in user_expressions
+        """
 
-        Parameters
-        ----------
-        names : list of strings
-          A list of names of variables to be read from the user namespace.
+        etype, evalue, tb = self._get_exc_info()
+        stb = self.InteractiveTB.get_exception_only(etype, evalue)
 
-        Returns
-        -------
-        A dict, keyed by the input names and with the repr() of each value.
+        exc_info = {
+            "status": "error",
+            "traceback": stb,
+            "ename": etype.__name__,
+            "evalue": py3compat.safe_unicode(evalue),
+        }
+
+        return exc_info
+
+    def _format_user_obj(self, obj):
+        """format a user object to display dict
+
+        for use in user_expressions
         """
-        out = {}
-        user_ns = self.user_ns
-        for varname in names:
-            try:
-                value = repr(user_ns[varname])
-            except:
-                value = self._simple_error()
-            out[varname] = value
-        return out
-        
+
+        data, md = self.display_formatter.format(obj)
+        value = {
+            'status' : 'ok',
+            'data' : data,
+            'metadata' : md,
+        }
+        return value
+
     def user_expressions(self, expressions):
         """Evaluate a dict of expressions in the user's namespace.
 
         Parameters
         ----------
         expressions : dict
-          A dict with string keys and string values.  The expression values
-          should be valid Python expressions, each of which will be evaluated
-          in the user namespace.
-        
+            A dict with string keys and string values.  The expression values
+            should be valid Python expressions, each of which will be evaluated
+            in the user namespace.
+
         Returns
         -------
-        A dict, keyed like the input expressions dict, with the repr() of each
-        value.
+        A dict, keyed like the input expressions dict, with the rich mime-typed
+        display_data of each value.
         """
         out = {}
         user_ns = self.user_ns
         global_ns = self.user_global_ns
-        for key, expr in expressions.iteritems():
+
+        for key, expr in expressions.items():
             try:
-                value = repr(eval(expr, global_ns, user_ns))
+                value = self._format_user_obj(eval(expr, global_ns, user_ns))
             except:
-                value = self._simple_error()
+                value = self._user_obj_error()
             out[key] = value
         return out
 
@@ -1998,7 +2871,7 @@ def user_expressions(self, expressions):
     def ex(self, cmd):
         """Execute a normal python statement in user namespace."""
         with self.builtin_trap:
-            exec cmd in self.user_global_ns, self.user_ns
+            exec(cmd, self.user_global_ns, self.user_ns)
 
     def ev(self, expr):
         """Evaluate python expression expr in user namespace.
@@ -2008,7 +2881,7 @@ def ev(self, expr):
         with self.builtin_trap:
             return eval(expr, self.user_global_ns, self.user_ns)
 
-    def safe_execfile(self, fname, *where, **kw):
+    def safe_execfile(self, fname, *where, exit_ignore=False, raise_exceptions=False, shell_futures=False):
         """A safe version of the builtin execfile().
 
         This version will never throw an exception, but instead print
@@ -2019,23 +2892,26 @@ def safe_execfile(self, fname, *where, **kw):
         ----------
         fname : string
             The name of the file to be executed.
-        where : tuple
+        *where : tuple
             One or two namespaces, passed to execfile() as (globals,locals).
             If only one is given, it is passed as both.
         exit_ignore : bool (False)
             If True, then silence SystemExit for non-zero status (it is always
             silenced for zero status, as it is so common).
-        """
-        kw.setdefault('exit_ignore', False)
+        raise_exceptions : bool (False)
+            If True raise exceptions everywhere. Meant for testing.
+        shell_futures : bool (False)
+            If True, the code will share future statements with the interactive
+            shell. It will both be affected by previous __future__ imports, and
+            any __future__ imports in the code will affect the shell. If False,
+            __future__ imports are not shared in either direction.
 
-        fname = os.path.abspath(os.path.expanduser(fname))
-        # Make sure we have a .py file
-        if not fname.endswith('.py'):
-            warn('File must end with .py to be run using execfile: <%s>' % fname)
+        """
+        fname = Path(fname).expanduser().resolve()
 
         # Make sure we can open the file
         try:
-            with open(fname) as thefile:
+            with fname.open("rb"):
                 pass
         except:
             warn('Could not open file <%s> for safe execution.' % fname)
@@ -2044,17 +2920,15 @@ def safe_execfile(self, fname, *where, **kw):
         # Find things also in current directory.  This is needed to mimic the
         # behavior of running a script from the system command line, where
         # Python inserts the script's directory into sys.path
-        dname = os.path.dirname(fname)
-        
-        if isinstance(fname, unicode):
-            # execfile uses default encoding instead of filesystem encoding
-            # so unicode filenames will fail
-            fname = fname.encode(sys.getfilesystemencoding() or sys.getdefaultencoding())
+        dname = str(fname.parent)
 
-        with prepended_to_syspath(dname):
+        with prepended_to_syspath(dname), self.builtin_trap:
             try:
-                execfile(fname,*where)
-            except SystemExit, status:
+                glob, loc = (where + (None, ))[:2]
+                py3compat.execfile(
+                    fname, glob, loc,
+                    self.compile if shell_futures else None)
+            except SystemExit as status:
                 # If the call was made with 0 or None exit status (sys.exit(0)
                 # or sys.exit() ), don't bother showing a traceback, as both of
                 # these are considered normal by the OS:
@@ -2064,29 +2938,38 @@ def safe_execfile(self, fname, *where, **kw):
                 # 0
                 # For other exit status, we show the exception unless
                 # explicitly silenced, but only in short form.
-                if status.code not in (0, None) and not kw['exit_ignore']:
-                    self.showtraceback(exception_only=True)
+                if status.code:
+                    if raise_exceptions:
+                        raise
+                    if not exit_ignore:
+                        self.showtraceback(exception_only=True)
             except:
-                self.showtraceback()
+                if raise_exceptions:
+                    raise
+                # tb offset is 2 because we wrap execfile
+                self.showtraceback(tb_offset=2)
 
-    def safe_execfile_ipy(self, fname):
-        """Like safe_execfile, but for .ipy files with IPython syntax.
+    def safe_execfile_ipy(self, fname, shell_futures=False, raise_exceptions=False):
+        """Like safe_execfile, but for .ipy or .ipynb files with IPython syntax.
 
         Parameters
         ----------
         fname : str
             The name of the file to execute.  The filename must have a
-            .ipy extension.
+            .ipy or .ipynb extension.
+        shell_futures : bool (False)
+            If True, the code will share future statements with the interactive
+            shell. It will both be affected by previous __future__ imports, and
+            any __future__ imports in the code will affect the shell. If False,
+            __future__ imports are not shared in either direction.
+        raise_exceptions : bool (False)
+            If True raise exceptions everywhere.  Meant for testing.
         """
-        fname = os.path.abspath(os.path.expanduser(fname))
-
-        # Make sure we have a .py file
-        if not fname.endswith('.ipy'):
-            warn('File must end with .py to be run using execfile: <%s>' % fname)
+        fname = Path(fname).expanduser().resolve()
 
         # Make sure we can open the file
         try:
-            with open(fname) as thefile:
+            with fname.open("rb"):
                 pass
         except:
             warn('Could not open file <%s> for safe execution.' % fname)
@@ -2095,23 +2978,275 @@ def safe_execfile_ipy(self, fname):
         # Find things also in current directory.  This is needed to mimic the
         # behavior of running a script from the system command line, where
         # Python inserts the script's directory into sys.path
-        dname = os.path.dirname(fname)
+        dname = str(fname.parent)
+
+        def get_cells():
+            """generator for sequence of code blocks to run"""
+            if fname.suffix == ".ipynb":
+                from nbformat import read
+                nb = read(fname, as_version=4)
+                if not nb.cells:
+                    return
+                for cell in nb.cells:
+                    if cell.cell_type == 'code':
+                        yield cell.source
+            else:
+                yield fname.read_text(encoding="utf-8")
 
         with prepended_to_syspath(dname):
             try:
-                with open(fname) as thefile:
-                    # self.run_cell currently captures all exceptions
-                    # raised in user code.  It would be nice if there were
-                    # versions of runlines, execfile that did raise, so
-                    # we could catch the errors.
-                    self.run_cell(thefile.read(), store_history=False)
+                for cell in get_cells():
+                    result = self.run_cell(cell, silent=True, shell_futures=shell_futures)
+                    if raise_exceptions:
+                        result.raise_error()
+                    elif not result.success:
+                        break
             except:
+                if raise_exceptions:
+                    raise
                 self.showtraceback()
                 warn('Unknown failure executing file: <%s>' % fname)
-                
-    def run_cell(self, raw_cell, store_history=True):
+
+    def safe_run_module(self, mod_name, where):
+        """A safe version of runpy.run_module().
+
+        This version will never throw an exception, but instead print
+        helpful error messages to the screen.
+
+        `SystemExit` exceptions with status code 0 or None are ignored.
+
+        Parameters
+        ----------
+        mod_name : string
+            The name of the module to be executed.
+        where : dict
+            The globals namespace.
+        """
+        try:
+            try:
+                where.update(
+                    runpy.run_module(str(mod_name), run_name="__main__",
+                                     alter_sys=True)
+                            )
+            except SystemExit as status:
+                if status.code:
+                    raise
+        except:
+            self.showtraceback()
+            warn('Unknown failure executing module: <%s>' % mod_name)
+
+    @contextmanager
+    def _tee(self, channel: Literal["stdout", "stderr"]):
+        """Capture output of a given standard stream and store it in history.
+
+        Uses patching of write method for maximal compatibility,
+        because ipykernel checks for instances of the stream class,
+        and stream classes in ipykernel implement more complex logic.
+        """
+        stream = getattr(sys, channel)
+        original_write = stream.write
+        execution_count = self.execution_count
+
+        def write(data, *args, **kwargs):
+            """Write data to both the original destination and the capture dictionary."""
+            result = original_write(data, *args, **kwargs)
+            if any(
+                [
+                    self.display_pub.is_publishing,
+                    self.displayhook.is_active,
+                    self.showing_traceback,
+                ]
+            ):
+                return result
+            if not data:
+                return result
+            output_stream = None
+            outputs_by_counter = self.history_manager.outputs
+            output_type = "out_stream" if channel == "stdout" else "err_stream"
+            if execution_count in outputs_by_counter:
+                outputs = outputs_by_counter[execution_count]
+                if outputs[-1].output_type == output_type:
+                    output_stream = outputs[-1]
+            if output_stream is None:
+                output_stream = HistoryOutput(
+                    output_type=output_type, bundle={"stream": []}
+                )
+                outputs_by_counter[execution_count].append(output_stream)
+
+            output_stream.bundle["stream"].append(data)  # Append to existing stream
+            return result
+
+        stream.write = write
+        yield
+        stream.write = original_write
+
+    def run_cell(
+        self,
+        raw_cell,
+        store_history=False,
+        silent=False,
+        shell_futures=True,
+        cell_id=None,
+    ):
         """Run a complete IPython cell.
-        
+
+        Parameters
+        ----------
+        raw_cell : str
+            The code (including IPython code such as %magic functions) to run.
+        store_history : bool
+            If True, the raw and translated cell will be stored in IPython's
+            history. For user code calling back into IPython's machinery, this
+            should be set to False.
+        silent : bool
+            If True, avoid side-effects, such as implicit displayhooks and
+            and logging.  silent=True forces store_history=False.
+        shell_futures : bool
+            If True, the code will share future statements with the interactive
+            shell. It will both be affected by previous __future__ imports, and
+            any __future__ imports in the code will affect the shell. If False,
+            __future__ imports are not shared in either direction.
+        cell_id : str, optional
+            A unique identifier for the cell. This is used in the messaging system
+            to match output with execution requests and for tracking cell execution
+            history across kernel restarts. In notebook contexts, this is typically
+            a UUID generated by the frontend. If None, the kernel may generate an
+            internal identifier or proceed without cell tracking capabilities.
+        Returns
+        -------
+        result : :class:`ExecutionResult`
+        """
+        result = None
+        with self._tee(channel="stdout"), self._tee(channel="stderr"):
+            try:
+                result = self._run_cell(
+                    raw_cell, store_history, silent, shell_futures, cell_id
+                )
+            finally:
+                self.events.trigger("post_execute")
+                if not silent:
+                    self.events.trigger("post_run_cell", result)
+        return result
+
+    def _run_cell(
+        self,
+        raw_cell: str,
+        store_history: bool,
+        silent: bool,
+        shell_futures: bool,
+        cell_id: str,
+    ) -> ExecutionResult:
+        """Internal method to run a complete IPython cell."""
+
+        # we need to avoid calling self.transform_cell multiple time on the same thing
+        # so we need to store some results:
+        preprocessing_exc_tuple = None
+        try:
+            transformed_cell = self.transform_cell(raw_cell)
+        except Exception:
+            transformed_cell = raw_cell
+            preprocessing_exc_tuple = sys.exc_info()
+
+        assert transformed_cell is not None
+        coro = self.run_cell_async(
+            raw_cell,
+            store_history=store_history,
+            silent=silent,
+            shell_futures=shell_futures,
+            transformed_cell=transformed_cell,
+            preprocessing_exc_tuple=preprocessing_exc_tuple,
+            cell_id=cell_id,
+        )
+
+        # run_cell_async is async, but may not actually need an eventloop.
+        # when this is the case, we want to run it using the pseudo_sync_runner
+        # so that code can invoke eventloops (for example via the %run , and
+        # `%paste` magic.
+        if self.trio_runner:
+            runner = self.trio_runner
+        elif self.should_run_async(
+            raw_cell,
+            transformed_cell=transformed_cell,
+            preprocessing_exc_tuple=preprocessing_exc_tuple,
+        ):
+            runner = self.loop_runner
+        else:
+            runner = _pseudo_sync_runner
+
+        try:
+            result = runner(coro)
+        except BaseException as e:
+            try:
+                info = ExecutionInfo(
+                    raw_cell,
+                    store_history,
+                    silent,
+                    shell_futures,
+                    cell_id,
+                    transformed_cell=transformed_cell,
+                )
+                result = ExecutionResult(info)
+                result.error_in_exec = e
+                self.showtraceback(running_compiled_code=True)
+            except:
+                pass
+        return result
+
+    def should_run_async(
+        self, raw_cell: str, *, transformed_cell=None, preprocessing_exc_tuple=None
+    ) -> bool:
+        """Return whether a cell should be run asynchronously via a coroutine runner
+
+        Parameters
+        ----------
+        raw_cell : str
+            The code to be executed
+
+        Returns
+        -------
+        result: bool
+            Whether the code needs to be run with a coroutine runner or not
+        .. versionadded:: 7.0
+        """
+        if not self.autoawait:
+            return False
+        if preprocessing_exc_tuple is not None:
+            return False
+        assert preprocessing_exc_tuple is None
+        if transformed_cell is None:
+            warnings.warn(
+                "`should_run_async` will not call `transform_cell`"
+                " automatically in the future. Please pass the result to"
+                " `transformed_cell` argument and any exception that happen"
+                " during the"
+                "transform in `preprocessing_exc_tuple` in"
+                " IPython 7.17 and above.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            try:
+                cell = self.transform_cell(raw_cell)
+            except Exception:
+                # any exception during transform will be raised
+                # prior to execution
+                return False
+        else:
+            cell = transformed_cell
+        return _should_be_async(cell)
+
+    async def run_cell_async(
+        self,
+        raw_cell: str,
+        store_history=False,
+        silent=False,
+        shell_futures=True,
+        *,
+        transformed_cell: Optional[str] = None,
+        preprocessing_exc_tuple: Optional[AnyType] = None,
+        cell_id=None,
+    ) -> ExecutionResult:
+        """Run a complete IPython cell asynchronously.
+
         Parameters
         ----------
         raw_cell : str
@@ -2120,61 +3255,300 @@ def run_cell(self, raw_cell, store_history=True):
           If True, the raw and translated cell will be stored in IPython's
           history. For user code calling back into IPython's machinery, this
           should be set to False.
+        silent : bool
+          If True, avoid side-effects, such as implicit displayhooks and
+          and logging.  silent=True forces store_history=False.
+        shell_futures : bool
+          If True, the code will share future statements with the interactive
+          shell. It will both be affected by previous __future__ imports, and
+          any __future__ imports in the code will affect the shell. If False,
+          __future__ imports are not shared in either direction.
+        transformed_cell: str
+          cell that was passed through transformers
+        preprocessing_exc_tuple:
+          trace if the transformation failed.
+
+        Returns
+        -------
+        result : :class:`ExecutionResult`
+
+        .. versionadded:: 7.0
         """
+        info = ExecutionInfo(
+            raw_cell,
+            store_history,
+            silent,
+            shell_futures,
+            cell_id,
+            transformed_cell=transformed_cell,
+        )
+        result = ExecutionResult(info)
+
         if (not raw_cell) or raw_cell.isspace():
-            return
-        
-        for line in raw_cell.splitlines():
-            self.input_splitter.push(line)
-        cell = self.input_splitter.source_reset()
-        
-        with self.builtin_trap:
-            if len(cell.splitlines()) == 1:
-                cell = self.prefilter_manager.prefilter_lines(cell)
-            
-            # Store raw and processed history
+            self.last_execution_succeeded = True
+            self.last_execution_result = result
+            return result
+
+        if silent:
+            store_history = False
+
+        execution_count = result.execution_count = self.execution_count
+
+        if store_history:
+            self.execution_count += 1
+
+        def error_before_exec(value):
             if store_history:
-                self.history_manager.store_inputs(self.execution_count, 
-                                                  cell, raw_cell)
+                if self.history_manager:
+                    # Store formatted traceback and error details
+                    self.history_manager.exceptions[
+                        execution_count
+                    ] = self._format_exception_for_storage(value)
+            result.error_before_exec = value
+            self.last_execution_succeeded = False
+            self.last_execution_result = result
+            return result
+
+        self.events.trigger('pre_execute')
+        if not silent:
+            self.events.trigger('pre_run_cell', info)
+
+        if transformed_cell is None:
+            warnings.warn(
+                "`run_cell_async` will not call `transform_cell`"
+                " automatically in the future. Please pass the result to"
+                " `transformed_cell` argument and any exception that happen"
+                " during the"
+                "transform in `preprocessing_exc_tuple` in"
+                " IPython 7.17 and above.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            # If any of our input transformation (input_transformer_manager or
+            # prefilter_manager) raises an exception, we store it in this variable
+            # so that we can display the error after logging the input and storing
+            # it in the history.
+            try:
+                cell = self.transform_cell(raw_cell)
+            except Exception:
+                preprocessing_exc_tuple = sys.exc_info()
+                cell = raw_cell  # cell has to exist so it can be stored/logged
+            else:
+                preprocessing_exc_tuple = None
+        else:
+            if preprocessing_exc_tuple is None:
+                cell = transformed_cell
+            else:
+                cell = raw_cell
 
+        # Do NOT store paste/cpaste magic history
+        if "get_ipython().run_line_magic(" in cell and "paste" in cell:
+            store_history = False
+
+        # Store raw and processed history
+        if store_history:
+            assert self.history_manager is not None
+            self.history_manager.store_inputs(execution_count, cell, raw_cell)
+        if not silent:
             self.logger.log(cell, raw_cell)
-            
-            cell_name = self.compile.cache(cell, self.execution_count)
-            
+
+        # Display the exception if input processing failed.
+        if preprocessing_exc_tuple is not None:
+            self.showtraceback(preprocessing_exc_tuple)
+            return error_before_exec(preprocessing_exc_tuple[1])
+
+        # Our own compiler remembers the __future__ environment. If we want to
+        # run code with a separate __future__ environment, use the default
+        # compiler
+        compiler = self.compile if shell_futures else self.compiler_class()
+
+        with self.builtin_trap:
+            cell_name = compiler.cache(cell, execution_count, raw_code=raw_cell)
+
             with self.display_trap:
+                # Compile to bytecode
                 try:
-                    code_ast = ast.parse(cell, filename=cell_name)
+                    code_ast = compiler.ast_parse(cell, filename=cell_name)
+                except self.custom_exceptions as e:
+                    etype, value, tb = sys.exc_info()
+                    self.CustomTB(etype, value, tb)
+                    return error_before_exec(e)
+                except IndentationError as e:
+                    self.showindentationerror()
+                    return error_before_exec(e)
                 except (OverflowError, SyntaxError, ValueError, TypeError,
-                        MemoryError):
+                        MemoryError) as e:
                     self.showsyntaxerror()
-                    self.execution_count += 1
-                    return None
+                    return error_before_exec(e)
 
-                self.run_ast_nodes(code_ast.body, cell_name,
-                                                    interactivity="last_expr")
+                # Apply AST transformations
+                try:
+                    code_ast = self.transform_ast(code_ast)
+                except InputRejected as e:
+                    self.showtraceback()
+                    return error_before_exec(e)
+
+                # Give the displayhook a reference to our ExecutionResult so it
+                # can fill in the output value.
+                self.displayhook.exec_result = result
+
+                # Execute the user code
+                interactivity = "none" if silent else self.ast_node_interactivity
+
+
+                has_raised = await self.run_ast_nodes(code_ast.body, cell_name,
+                       interactivity=interactivity, compiler=compiler, result=result)
+
+                self.last_execution_succeeded = not has_raised
+                self.last_execution_result = result
+
+                # Reset this so later displayed values do not modify the
+                # ExecutionResult
+                self.displayhook.exec_result = None
 
-                # Execute any registered post-execution functions.
-                for func, status in self._post_execute.iteritems():
-                    if not status:
-                        continue
-                    try:
-                        func()
-                    except:
-                        self.showtraceback()
-                        # Deactivate failing function
-                        self._post_execute[func] = False
-                
         if store_history:
+            assert self.history_manager is not None
             # Write output to the database. Does nothing unless
             # history output logging is enabled.
-            self.history_manager.store_output(self.execution_count)
-            # Each cell is a *single* input, regardless of how many lines it has
-            self.execution_count += 1
-            
-    def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
+            self.history_manager.store_output(execution_count)
+            if result.error_in_exec:
+                # Store formatted traceback and error details
+                self.history_manager.exceptions[
+                    execution_count
+                ] = self._format_exception_for_storage(result.error_in_exec)
+
+        return result
+
+    def _format_exception_for_storage(
+        self, exception, filename=None, running_compiled_code=False
+    ):
+        """
+        Format an exception's traceback and details for storage, with special handling
+        for different types of errors.
+        """
+        etype = type(exception)
+        evalue = exception
+        tb = exception.__traceback__
+
+        # Handle SyntaxError and IndentationError with specific formatting
+        if issubclass(etype, (SyntaxError, IndentationError)):
+            if filename and isinstance(evalue, SyntaxError):
+                try:
+                    evalue.filename = filename
+                except:
+                    pass  # Keep the original filename if modification fails
+
+            # Extract traceback if the error happened during compiled code execution
+            elist = traceback.extract_tb(tb) if running_compiled_code else []
+            stb = self.SyntaxTB.structured_traceback(etype, evalue, elist)
+
+        # Handle UsageError with a simple message
+        elif etype is UsageError:
+            stb = [f"UsageError: {evalue}"]
+
+        else:
+            # Check if the exception (or its context) is an ExceptionGroup.
+            def contains_exceptiongroup(val):
+                if val is None:
+                    return False
+                return isinstance(val, BaseExceptionGroup) or contains_exceptiongroup(
+                    val.__context__
+                )
+
+            if contains_exceptiongroup(evalue):
+                # Fallback: use the standard library's formatting for exception groups.
+                stb = traceback.format_exception(etype, evalue, tb)
+            else:
+                try:
+                    # If the exception has a custom traceback renderer, use it.
+                    if hasattr(evalue, "_render_traceback_"):
+                        stb = evalue._render_traceback_()
+                    else:
+                        # Otherwise, use InteractiveTB to format the traceback.
+                        stb = self.InteractiveTB.structured_traceback(
+                            etype, evalue, tb, tb_offset=1
+                        )
+                except Exception:
+                    # In case formatting fails, fallback to Python's built-in formatting.
+                    stb = traceback.format_exception(etype, evalue, tb)
+
+        return {"ename": etype.__name__, "evalue": str(evalue), "traceback": stb}
+
+    def transform_cell(self, raw_cell):
+        """Transform an input cell before parsing it.
+
+        Static transformations, implemented in IPython.core.inputtransformer2,
+        deal with things like ``%magic`` and ``!system`` commands.
+        These run on all input.
+        Dynamic transformations, for things like unescaped magics and the exit
+        autocall, depend on the state of the interpreter.
+        These only apply to single line inputs.
+
+        These string-based transformations are followed by AST transformations;
+        see :meth:`transform_ast`.
+        """
+        # Static input transformations
+        cell = self.input_transformer_manager.transform_cell(raw_cell)
+
+        if len(cell.splitlines()) == 1:
+            # Dynamic transformations - only applied for single line commands
+            with self.builtin_trap:
+                # use prefilter_lines to handle trailing newlines
+                # restore trailing newline for ast.parse
+                cell = self.prefilter_manager.prefilter_lines(cell) + '\n'
+
+        lines = cell.splitlines(keepends=True)
+        for transform in self.input_transformers_post:
+            lines = transform(lines)
+        cell = ''.join(lines)
+
+        return cell
+
+    def transform_ast(self, node):
+        """Apply the AST transformations from self.ast_transformers
+
+        Parameters
+        ----------
+        node : ast.Node
+            The root node to be transformed. Typically called with the ast.Module
+            produced by parsing user input.
+
+        Returns
+        -------
+        An ast.Node corresponding to the node it was called with. Note that it
+        may also modify the passed object, so don't rely on references to the
+        original AST.
+        """
+        for transformer in self.ast_transformers:
+            try:
+                node = transformer.visit(node)
+            except InputRejected:
+                # User-supplied AST transformers can reject an input by raising
+                # an InputRejected.  Short-circuit in this case so that we
+                # don't unregister the transform.
+                raise
+            except Exception as e:
+                warn(
+                    "AST transformer %r threw an error. It will be unregistered. %s"
+                    % (transformer, e)
+                )
+                self.ast_transformers.remove(transformer)
+
+        if self.ast_transformers:
+            ast.fix_missing_locations(node)
+        return node
+
+    async def run_ast_nodes(
+        self,
+        nodelist: ListType[stmt],
+        cell_name: str,
+        interactivity="last_expr",
+        compiler=compile,
+        result=None,
+    ):
         """Run a sequence of AST nodes. The execution mode depends on the
         interactivity parameter.
-        
+
         Parameters
         ----------
         nodelist : list
@@ -2183,21 +3557,51 @@ def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
           Will be passed to the compiler as the filename of the cell. Typically
           the value returned by ip.compile.cache(cell).
         interactivity : str
-          'all', 'last', 'last_expr' or 'none', specifying which nodes should be
-          run interactively (displaying output from expressions). 'last_expr'
-          will run the last node interactively only if it is an expression (i.e.
-          expressions in loops or other blocks are not displayed. Other values
-          for this parameter will raise a ValueError.
+          'all', 'last', 'last_expr' , 'last_expr_or_assign' or 'none',
+          specifying which nodes should be run interactively (displaying output
+          from expressions). 'last_expr' will run the last node interactively
+          only if it is an expression (i.e. expressions in loops or other blocks
+          are not displayed) 'last_expr_or_assign' will run the last expression
+          or the last assignment. Other values for this parameter will raise a
+          ValueError.
+
+        compiler : callable
+          A function with the same interface as the built-in compile(), to turn
+          the AST nodes into code objects. Default is the built-in compile().
+        result : ExecutionResult, optional
+          An object to store exceptions that occur during execution.
+
+        Returns
+        -------
+        True if an exception occurred while running code, False if it finished
+        running.
         """
         if not nodelist:
             return
-        
+
+
+        if interactivity == 'last_expr_or_assign':
+            if isinstance(nodelist[-1], _assign_nodes):
+                asg = nodelist[-1]
+                if isinstance(asg, ast.Assign) and len(asg.targets) == 1:
+                    target = asg.targets[0]
+                elif isinstance(asg, _single_targets_nodes):
+                    target = asg.target
+                else:
+                    target = None
+                if isinstance(target, ast.Name):
+                    nnode = ast.Expr(ast.Name(target.id, ast.Load()))
+                    ast.fix_missing_locations(nnode)
+                    nodelist.append(nnode)
+            interactivity = 'last_expr'
+
+        _async = False
         if interactivity == 'last_expr':
             if isinstance(nodelist[-1], ast.Expr):
                 interactivity = "last"
             else:
                 interactivity = "none"
-        
+
         if interactivity == 'none':
             to_run_exec, to_run_interactive = nodelist, []
         elif interactivity == 'last':
@@ -2206,24 +3610,58 @@ def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
             to_run_exec, to_run_interactive = [], nodelist
         else:
             raise ValueError("Interactivity was %r" % interactivity)
-            
-        exec_count = self.execution_count
-        
-        for i, node in enumerate(to_run_exec):
-            mod = ast.Module([node])
-            code = self.compile(mod, cell_name, "exec")
-            if self.run_code(code):
-                return True
-
-        for i, node in enumerate(to_run_interactive):
-            mod = ast.Interactive([node])
-            code = self.compile(mod, cell_name, "single")
-            if self.run_code(code):
-                return True
+
+        try:
+
+            def compare(code):
+                is_async = inspect.CO_COROUTINE & code.co_flags == inspect.CO_COROUTINE
+                return is_async
+
+            # refactor that to just change the mod constructor.
+            to_run = []
+            for node in to_run_exec:
+                to_run.append((node, "exec"))
+
+            for node in to_run_interactive:
+                to_run.append((node, "single"))
+
+            for node, mode in to_run:
+                if mode == "exec":
+                    mod = Module([node], [])
+                elif mode == "single":
+                    mod = ast.Interactive([node])
+                with compiler.extra_flags(
+                    getattr(ast, "PyCF_ALLOW_TOP_LEVEL_AWAIT", 0x0)
+                    if self.autoawait
+                    else 0x0
+                ):
+                    code = compiler(mod, cell_name, mode)
+                    asy = compare(code)
+                if await self.run_code(code, result, async_=asy):
+                    return True
+
+            # Flush softspace
+            if softspace(sys.stdout, 0):
+                print()
+
+        except:
+            # It's possible to have exceptions raised here, typically by
+            # compilation of odd code (such as a naked 'return' outside a
+            # function) that did parse but isn't valid. Typically the exception
+            # is a SyntaxError, but it's safest just to catch anything and show
+            # the user a traceback.
+
+            # We do only one try/except outside the loop to minimize the impact
+            # on runtime, and also because if any node in the node list is
+            # broken, we should stop execution completely.
+            if result:
+                result.error_before_exec = sys.exc_info()[1]
+            self.showtraceback()
+            return True
 
         return False
-    
-    def run_code(self, code_obj):
+
+    async def run_code(self, code_obj, result=None, *, async_=False):
         """Execute a code object.
 
         When an exception occurs, self.showtraceback() is called to display a
@@ -2233,61 +3671,193 @@ def run_code(self, code_obj):
         ----------
         code_obj : code object
           A compiled code object, to be executed
-        post_execute : bool [default: True]
-          whether to call post_execute hooks after this particular execution.
+        result : ExecutionResult, optional
+          An object to store exceptions that occur during execution.
+        async_ :  Bool (Experimental)
+          Attempt to run top-level asynchronous code in a default loop.
 
         Returns
         -------
         False : successful execution.
         True : an error occurred.
         """
-
+        # special value to say that anything above is IPython and should be
+        # hidden.
+        __tracebackhide__ = "__ipython_bottom__"
         # Set our own excepthook in case the user code tries to call it
         # directly, so that the IPython crash handler doesn't get triggered
-        old_excepthook,sys.excepthook = sys.excepthook, self.excepthook
+        old_excepthook, sys.excepthook = sys.excepthook, self.excepthook
 
         # we save the original sys.excepthook in the instance, in case config
         # code (such as magics) needs access to it.
         self.sys_excepthook = old_excepthook
-        outflag = 1  # happens in more places, so it's easier as default
+        outflag = True  # happens in more places, so it's easier as default
         try:
             try:
-                self.hooks.pre_run_code_hook()
-                #rprint('Running code', repr(code_obj)) # dbg
-                exec code_obj in self.user_global_ns, self.user_ns
+                if async_:
+                    await eval(code_obj, self.user_global_ns, self.user_ns)
+                else:
+                    exec(code_obj, self.user_global_ns, self.user_ns)
             finally:
                 # Reset our crash handler in place
                 sys.excepthook = old_excepthook
-        except SystemExit:
+        except SystemExit as e:
+            if result is not None:
+                result.error_in_exec = e
             self.showtraceback(exception_only=True)
-            warn("To exit: use 'exit', 'quit', or Ctrl-D.", level=1)
+            warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)
+        except bdb.BdbQuit:
+            etype, value, tb = sys.exc_info()
+            if result is not None:
+                result.error_in_exec = value
+            # the BdbQuit stops here
         except self.custom_exceptions:
-            etype,value,tb = sys.exc_info()
-            self.CustomTB(etype,value,tb)
+            etype, value, tb = sys.exc_info()
+            if result is not None:
+                result.error_in_exec = value
+            self.CustomTB(etype, value, tb)
         except:
-            self.showtraceback()
+            if result is not None:
+                result.error_in_exec = sys.exc_info()[1]
+            self.showtraceback(running_compiled_code=True)
         else:
-            outflag = 0
-            if softspace(sys.stdout, 0):
-                print
-
+            outflag = False
         return outflag
-        
+
     # For backwards compatibility
     runcode = run_code
 
+    def check_complete(self, code: str) -> Tuple[str, str]:
+        """Return whether a block of code is ready to execute, or should be continued
+
+        Parameters
+        ----------
+        code : string
+            Python input code, which can be multiline.
+
+        Returns
+        -------
+        status : str
+            One of 'complete', 'incomplete', or 'invalid' if source is not a
+            prefix of valid code.
+        indent : str
+            When status is 'incomplete', this is some whitespace to insert on
+            the next line of the prompt.
+        """
+        status, nspaces = self.input_transformer_manager.check_complete(code)
+        return status, ' ' * (nspaces or 0)
+
     #-------------------------------------------------------------------------
     # Things related to GUI support and pylab
     #-------------------------------------------------------------------------
 
-    def enable_pylab(self, gui=None):
-        raise NotImplementedError('Implement enable_pylab in a subclass')
+    active_eventloop: Optional[str] = None
+
+    def enable_gui(self, gui=None):
+        raise NotImplementedError('Implement enable_gui in a subclass')
+
+    def enable_matplotlib(self, gui=None):
+        """Enable interactive matplotlib and inline figure support.
+
+        This takes the following steps:
+
+        1. select the appropriate eventloop and matplotlib backend
+        2. set up matplotlib for interactive use with that backend
+        3. configure formatters for inline figure display
+        4. enable the selected gui eventloop
+
+        Parameters
+        ----------
+        gui : optional, string
+            If given, dictates the choice of matplotlib GUI backend to use
+            (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
+            'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
+            matplotlib (as dictated by the matplotlib build-time options plus the
+            user's matplotlibrc configuration file).  Note that not all backends
+            make sense in all contexts, for example a terminal ipython can't
+            display figures inline.
+        """
+        from .pylabtools import _matplotlib_manages_backends
+
+        if not _matplotlib_manages_backends() and gui in (None, "auto"):
+            # Early import of backend_inline required for its side effect of
+            # calling _enable_matplotlib_integration()
+            import matplotlib_inline.backend_inline
+
+        from IPython.core import pylabtools as pt
+        gui, backend = pt.find_gui_and_backend(gui, self.pylab_gui_select)
+
+        if gui != None:
+            # If we have our first gui selection, store it
+            if self.pylab_gui_select is None:
+                self.pylab_gui_select = gui
+            # Otherwise if they are different
+            elif gui != self.pylab_gui_select:
+                print('Warning: Cannot change to a different GUI toolkit: %s.'
+                        ' Using %s instead.' % (gui, self.pylab_gui_select))
+                gui, backend = pt.find_gui_and_backend(self.pylab_gui_select)
+
+        pt.activate_matplotlib(backend)
+
+        from matplotlib_inline.backend_inline import configure_inline_support
+
+        configure_inline_support(self, backend)
+
+        # Now we must activate the gui pylab wants to use, and fix %run to take
+        # plot updates into account
+        self.enable_gui(gui)
+        self.magics_manager.registry['ExecutionMagics'].default_runner = \
+            pt.mpl_runner(self.safe_execfile)
+
+        return gui, backend
+
+    def enable_pylab(self, gui=None, import_all=True):
+        """Activate pylab support at runtime.
+
+        This turns on support for matplotlib, preloads into the interactive
+        namespace all of numpy and pylab, and configures IPython to correctly
+        interact with the GUI event loop.  The GUI backend to be used can be
+        optionally selected with the optional ``gui`` argument.
+
+        This method only adds preloading the namespace to InteractiveShell.enable_matplotlib.
+
+        Parameters
+        ----------
+        gui : optional, string
+            If given, dictates the choice of matplotlib GUI backend to use
+            (should be one of IPython's supported backends, 'qt', 'osx', 'tk',
+            'gtk', 'wx' or 'inline'), otherwise we use the default chosen by
+            matplotlib (as dictated by the matplotlib build-time options plus the
+            user's matplotlibrc configuration file).  Note that not all backends
+            make sense in all contexts, for example a terminal ipython can't
+            display figures inline.
+        import_all : optional, bool, default: True
+            Whether to do `from numpy import *` and `from pylab import *`
+            in addition to module imports.
+        """
+        from IPython.core.pylabtools import import_pylab
+
+        gui, backend = self.enable_matplotlib(gui)
+
+        # We want to prevent the loading of pylab to pollute the user's
+        # namespace as shown by the %who* magics, so we execute the activation
+        # code in an empty namespace, and we update *both* user_ns and
+        # user_ns_hidden with this information.
+        ns = {}
+        import_pylab(ns, import_all)
+        # warn about clobbered names
+        ignored = {"__builtins__"}
+        both = set(ns).intersection(self.user_ns).difference(ignored)
+        clobbered = [ name for name in both if self.user_ns[name] is not ns[name] ]
+        self.user_ns.update(ns)
+        self.user_ns_hidden.update(ns)
+        return gui, backend, clobbered
 
     #-------------------------------------------------------------------------
     # Utilities
     #-------------------------------------------------------------------------
 
-    def var_expand(self,cmd,depth=0):
+    def var_expand(self, cmd, depth=0, formatter=DollarFormatter()):
         """Expand python variables in a string.
 
         The depth argument indicates how many frames above the caller should
@@ -2296,93 +3866,197 @@ def var_expand(self,cmd,depth=0):
         The global namespace for expansion is always the user's interactive
         namespace.
         """
-        res = ItplNS(cmd, self.user_ns,  # globals
-                          # Skip our own frame in searching for locals:
-                          sys._getframe(depth+1).f_locals # locals
-                          )
-        return str(res).decode(res.codec)
+        ns = self.user_ns.copy()
+        try:
+            frame = sys._getframe(depth+1)
+        except ValueError:
+            # This is thrown if there aren't that many frames on the stack,
+            # e.g. if a script called run_line_magic() directly.
+            pass
+        else:
+            ns.update(frame.f_locals)
+
+        try:
+            # We have to use .vformat() here, because 'self' is a valid and common
+            # name, and expanding **ns for .format() would make it collide with
+            # the 'self' argument of the method.
+            cmd = formatter.vformat(cmd, args=[], kwargs=ns)
+        except Exception:
+            # if formatter couldn't format, just let it go untransformed
+            pass
+        return cmd
 
     def mktempfile(self, data=None, prefix='ipython_edit_'):
         """Make a new tempfile and return its filename.
 
-        This makes a call to tempfile.mktemp, but it registers the created
-        filename internally so ipython cleans it up at exit time.
+        This makes a call to tempfile.mkstemp (created in a tempfile.mkdtemp),
+        but it registers the created filename internally so ipython cleans it up
+        at exit time.
 
         Optional inputs:
 
           - data(None): if data is given, it gets written out to the temp file
-          immediately, and the file is closed again."""
+            immediately, and the file is closed again."""
 
-        filename = tempfile.mktemp('.py', prefix)
-        self.tempfiles.append(filename)
-        
-        if data:
-            tmp_file = open(filename,'w')
-            tmp_file.write(data)
-            tmp_file.close()
-        return filename
+        dir_path = Path(tempfile.mkdtemp(prefix=prefix))
+        self.tempdirs.append(dir_path)
 
-    # TODO:  This should be removed when Term is refactored.
-    def write(self,data):
-        """Write a string to the default output"""
-        io.stdout.write(data)
+        handle, filename = tempfile.mkstemp(".py", prefix, dir=str(dir_path))
+        os.close(handle)  # On Windows, there can only be one open handle on a file
 
-    # TODO:  This should be removed when Term is refactored.
-    def write_err(self,data):
-        """Write a string to the default error output"""
-        io.stderr.write(data)
+        file_path = Path(filename)
+        self.tempfiles.append(file_path)
 
-    def ask_yes_no(self,prompt,default=True):
+        if data:
+            file_path.write_text(data, encoding="utf-8")
+        return filename
+
+    def ask_yes_no(self, prompt, default=None, interrupt=None):
         if self.quiet:
             return True
-        return ask_yes_no(prompt,default)
-    
+        return ask_yes_no(prompt,default,interrupt)
+
     def show_usage(self):
         """Show a usage message"""
         page.page(IPython.core.usage.interactive_usage)
-        
-    def find_user_code(self, target, raw=True):
-        """Get a code string from history, file, or a string or macro.
-        
-        This is mainly used by magic functions. 
-        
+
+    def extract_input_lines(self, range_str, raw=False):
+        """Return as a string a set of input history slices.
+
+        Parameters
+        ----------
+        range_str : str
+            The set of slices is given as a string, like "~5/6-~4/2 4:8 9",
+            since this function is for use by magic functions which get their
+            arguments as strings. The number before the / is the session
+            number: ~n goes n back from the current session.
+
+            If empty string is given, returns history of current session
+            without the last input.
+
+        raw : bool, optional
+            By default, the processed input is used.  If this is true, the raw
+            input history is used instead.
+
+        Notes
+        -----
+        Slices can be described with two notations:
+
+        * ``N:M`` -> standard python form, means including items N...(M-1).
+        * ``N-M`` -> include items N..M (closed endpoint).
+        """
+        lines = self.history_manager.get_range_by_str(range_str, raw=raw)
+        text = "\n".join(x for _, _, x in lines)
+
+        # Skip the last line, as it's probably the magic that called this
+        if not range_str:
+            if "\n" not in text:
+                text = ""
+            else:
+                text = text[: text.rfind("\n")]
+
+        return text
+
+    def find_user_code(self, target, raw=True, py_only=False, skip_encoding_cookie=True, search_ns=False):
+        """Get a code string from history, file, url, or a string or macro.
+
+        This is mainly used by magic functions.
+
         Parameters
         ----------
         target : str
-          A string specifying code to retrieve. This will be tried respectively
-          as: ranges of input history (see %history for syntax), a filename, or
-          an expression evaluating to a string or Macro in the user namespace.
+            A string specifying code to retrieve. This will be tried respectively
+            as: ranges of input history (see %history for syntax), url,
+            corresponding .py file, filename, or an expression evaluating to a
+            string or Macro in the user namespace.
+
+            If empty string is given, returns complete history of current
+            session, without the last line.
+
         raw : bool
-          If true (default), retrieve raw history. Has no effect on the other
-          retrieval mechanisms.
-        
+            If true (default), retrieve raw history. Has no effect on the other
+            retrieval mechanisms.
+
+        py_only : bool (default False)
+            Only try to fetch python code, do not try alternative methods to decode file
+            if unicode fails.
+
         Returns
         -------
         A string of code.
-        
         ValueError is raised if nothing is found, and TypeError if it evaluates
         to an object of another type. In each case, .args[0] is a printable
         message.
         """
-        code = self.extract_input_lines(target, raw=raw)  # Grab history        
+        code = self.extract_input_lines(target, raw=raw)  # Grab history
         if code:
             return code
-        if os.path.isfile(target):                        # Read file
-            return open(target, "r").read()
-        
+        try:
+            if target.startswith(('http://', 'https://')):
+                return openpy.read_py_url(target, skip_encoding_cookie=skip_encoding_cookie)
+        except UnicodeDecodeError as e:
+            if not py_only :
+                # Deferred import
+                from urllib.request import urlopen
+                response = urlopen(target)
+                return response.read().decode('latin1')
+            raise ValueError(("'%s' seem to be unreadable.") % target) from e
+
+        potential_target = [target]
+        try :
+            potential_target.insert(0,get_py_filename(target))
+        except IOError:
+            pass
+
+        for tgt in potential_target :
+            if os.path.isfile(tgt):                        # Read file
+                try :
+                    return openpy.read_py_file(tgt, skip_encoding_cookie=skip_encoding_cookie)
+                except UnicodeDecodeError as e:
+                    if not py_only :
+                        with io_open(tgt,'r', encoding='latin1') as f :
+                            return f.read()
+                    raise ValueError(("'%s' seem to be unreadable.") % target) from e
+            elif os.path.isdir(os.path.expanduser(tgt)):
+                raise ValueError("'%s' is a directory, not a regular file." % target)
+
+        if search_ns:
+            # Inspect namespace to load object source
+            object_info = self.object_inspect(target, detail_level=1)
+            if object_info['found'] and object_info['source']:
+                return object_info['source']
+
         try:                                              # User namespace
             codeobj = eval(target, self.user_ns)
-        except Exception:
-            raise ValueError(("'%s' was not found in history, as a file, nor in"
-                                " the user namespace.") % target)
-        if isinstance(codeobj, basestring):
+        except Exception as e:
+            raise ValueError(("'%s' was not found in history, as a file, url, "
+                                "nor in the user namespace.") % target) from e
+
+        if isinstance(codeobj, str):
             return codeobj
         elif isinstance(codeobj, Macro):
             return codeobj.value
-            
+
         raise TypeError("%s is neither a string nor a macro." % target,
                         codeobj)
 
+    def _atexit_once(self):
+        """
+        At exist operation that need to be called at most once.
+        Second call to this function per instance will do nothing.
+        """
+
+        if not getattr(self, "_atexit_once_called", False):
+            self._atexit_once_called = True
+            # Clear all user namespaces to release all references cleanly.
+            self.reset(new_session=False)
+            # Close the history session (this stores the end time and line count)
+            # this must be *before* the tempfile cleanup, in case of temporary
+            # history db
+            if self.history_manager is not None:
+                self.history_manager.end_session()
+                self.history_manager = None
+
     #-------------------------------------------------------------------------
     # Things related to IPython exiting
     #-------------------------------------------------------------------------
@@ -2395,30 +4069,41 @@ def atexit_operations(self):
         For things that may depend on startup flags or platform specifics (such
         as having readline or not), register a separate atexit function in the
         code that has the appropriate information, rather than trying to
-        clutter 
+        clutter
         """
-        # Cleanup all tempfiles left around
+        self._atexit_once()
+
+        # Cleanup all tempfiles and folders left around
         for tfile in self.tempfiles:
             try:
-                os.unlink(tfile)
-            except OSError:
+                tfile.unlink()
+                self.tempfiles.remove(tfile)
+            except FileNotFoundError:
+                pass
+        del self.tempfiles
+        for tdir in self.tempdirs:
+            try:
+                shutil.rmtree(tdir)
+                self.tempdirs.remove(tdir)
+            except FileNotFoundError:
                 pass
-        
-        # Close the history session (this stores the end time and line count)
-        self.history_manager.end_session()
-        
-        # Clear all user namespaces to release all references cleanly.
-        self.reset(new_session=False)
+        del self.tempdirs
 
-        # Run user hooks
-        self.hooks.shutdown_hook()
+        # Restore user's cursor
+        if hasattr(self, "editing_mode") and self.editing_mode == "vi":
+            sys.stdout.write("\x1b[0 q")
+            sys.stdout.flush()
 
     def cleanup(self):
         self.restore_sys_module_state()
 
 
-class InteractiveShellABC(object):
+    # Overridden in terminal subclass to change prompts
+    def switch_doctest_mode(self, mode):
+        pass
+
+
+class InteractiveShellABC(metaclass=abc.ABCMeta):
     """An abstract base class for InteractiveShell."""
-    __metaclass__ = abc.ABCMeta
 
 InteractiveShellABC.register(InteractiveShell)
diff --git a/IPython/core/ipapi.py b/IPython/core/ipapi.py
deleted file mode 100644
index 0d79aa0b022..00000000000
--- a/IPython/core/ipapi.py
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-This module is *completely* deprecated and should no longer be used for
-any purpose.  Currently, we have a few parts of the core that have
-not been componentized and thus, still rely on this module.  When everything
-has been made into a component, this module will be sent to deathrow.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-
-def get():
-    """Get the global InteractiveShell instance."""
-    from IPython.core.interactiveshell import InteractiveShell
-    return InteractiveShell.instance()
-
diff --git a/IPython/core/latex_symbols.py b/IPython/core/latex_symbols.py
new file mode 100644
index 00000000000..e44921bcaff
--- /dev/null
+++ b/IPython/core/latex_symbols.py
@@ -0,0 +1,1306 @@
+# encoding: utf-8
+
+# DO NOT EDIT THIS FILE BY HAND.
+
+# To update this file, run the script /tools/gen_latex_symbols.py using Python 3
+
+# This file is autogenerated from the file:
+# https://raw.githubusercontent.com/JuliaLang/julia/master/stdlib/REPL/src/latex_symbols.jl
+# This original list is filtered to remove any unicode characters that are not valid
+# Python identifiers.
+
+latex_symbols = {
+    "\\euler": "ℯ",
+    "\\ohm": "Ω",
+    "\\^a": "ᵃ",
+    "\\^b": "ᵇ",
+    "\\^c": "ᶜ",
+    "\\^d": "ᵈ",
+    "\\^e": "ᵉ",
+    "\\^f": "ᶠ",
+    "\\^g": "�",
+    "\\^h": "Ê°",
+    "\\^i": "�",
+    "\\^j": "ʲ",
+    "\\^k": "�",
+    "\\^l": "Ë¡",
+    "\\^m": "�",
+    "\\^n": "�",
+    "\\^o": "áµ’",
+    "\\^p": "áµ–",
+    "\\^r": "ʳ",
+    "\\^s": "Ë¢",
+    "\\^t": "áµ—",
+    "\\^u": "ᵘ",
+    "\\^v": "áµ›",
+    "\\^w": "Ê·",
+    "\\^x": "Ë£",
+    "\\^y": "ʸ",
+    "\\^z": "ᶻ",
+    "\\^A": "á´¬",
+    "\\^B": "á´®",
+    "\\^D": "á´°",
+    "\\^E": "á´±",
+    "\\^G": "á´³",
+    "\\^H": "á´´",
+    "\\^I": "á´µ",
+    "\\^J": "á´¶",
+    "\\^K": "á´·",
+    "\\^L": "á´¸",
+    "\\^M": "á´¹",
+    "\\^N": "á´º",
+    "\\^O": "á´¼",
+    "\\^P": "á´¾",
+    "\\^R": "á´¿",
+    "\\^T": "áµ€",
+    "\\^U": "�",
+    "\\^V": "â±½",
+    "\\^W": "ᵂ",
+    "\\^alpha": "áµ…",
+    "\\^beta": "�",
+    "\\^gamma": "ᵞ",
+    "\\^delta": "ᵟ",
+    "\\^epsilon": "ᵋ",
+    "\\^theta": "ᶿ",
+    "\\^iota": "ᶥ",
+    "\\^phi": "áµ ",
+    "\\^chi": "ᵡ",
+    "\\^ltphi": "ᶲ",
+    "\\^uparrow": "ꜛ",
+    "\\^downarrow": "ꜜ",
+    "\\^!": "�",
+    "\\_a": "�",
+    "\\_e": "â‚‘",
+    "\\_h": "â‚•",
+    "\\_i": "áµ¢",
+    "\\_j": "â±¼",
+    "\\_k": "â‚–",
+    "\\_l": "â‚—",
+    "\\_m": "ₘ",
+    "\\_n": "â‚™",
+    "\\_o": "â‚’",
+    "\\_p": "â‚š",
+    "\\_r": "áµ£",
+    "\\_s": "â‚›",
+    "\\_t": "ₜ",
+    "\\_u": "ᵤ",
+    "\\_v": "áµ¥",
+    "\\_x": "â‚“",
+    "\\_schwa": "â‚”",
+    "\\_beta": "ᵦ",
+    "\\_gamma": "ᵧ",
+    "\\_rho": "ᵨ",
+    "\\_phi": "ᵩ",
+    "\\_chi": "ᵪ",
+    "\\hbar": "ħ",
+    "\\sout": "̶",
+    "\\ordfeminine": "ª",
+    "\\cdotp": "·",
+    "\\ordmasculine": "º",
+    "\\AA": "Ã…",
+    "\\AE": "Æ",
+    "\\DH": "�",
+    "\\O": "Ø",
+    "\\TH": "Þ",
+    "\\ss": "ß",
+    "\\aa": "Ã¥",
+    "\\ae": "æ",
+    "\\eth": "ð",
+    "\\dh": "ð",
+    "\\o": "ø",
+    "\\th": "þ",
+    "\\DJ": "�",
+    "\\dj": "Ä‘",
+    "\\imath": "ı",
+    "\\jmath": "È·",
+    "\\L": "�",
+    "\\l": "Å‚",
+    "\\NG": "ÅŠ",
+    "\\ng": "Å‹",
+    "\\OE": "Å’",
+    "\\oe": "Å“",
+    "\\hvlig": "Æ•",
+    "\\nrleg": "Æž",
+    "\\doublepipe": "Ç‚",
+    "\\trna": "�",
+    "\\trnsa": "É’",
+    "\\openo": "É”",
+    "\\rtld": "É–",
+    "\\schwa": "É™",
+    "\\varepsilon": "ε",
+    "\\pgamma": "É£",
+    "\\pbgam": "ɤ",
+    "\\trnh": "É¥",
+    "\\btdl": "ɬ",
+    "\\rtll": "É­",
+    "\\trnm": "ɯ",
+    "\\trnmlr": "É°",
+    "\\ltlmr": "ɱ",
+    "\\ltln": "ɲ",
+    "\\rtln": "ɳ",
+    "\\clomeg": "É·",
+    "\\ltphi": "ɸ",
+    "\\trnr": "ɹ",
+    "\\trnrl": "ɺ",
+    "\\rttrnr": "É»",
+    "\\rl": "ɼ",
+    "\\rtlr": "ɽ",
+    "\\fhr": "ɾ",
+    "\\rtls": "Ê‚",
+    "\\esh": "ʃ",
+    "\\trnt": "ʇ",
+    "\\rtlt": "ʈ",
+    "\\pupsil": "ÊŠ",
+    "\\pscrv": "Ê‹",
+    "\\invv": "ʌ",
+    "\\invw": "�",
+    "\\trny": "ÊŽ",
+    "\\rtlz": "�",
+    "\\yogh": "Ê’",
+    "\\glst": "Ê”",
+    "\\reglst": "Ê•",
+    "\\inglst": "Ê–",
+    "\\turnk": "Êž",
+    "\\dyogh": "ʤ",
+    "\\tesh": "ʧ",
+    "\\rasp": "ʼ",
+    "\\verts": "ˈ",
+    "\\verti": "ˌ",
+    "\\lmrk": "�",
+    "\\hlmrk": "Ë‘",
+    "\\grave": "Ì€",
+    "\\acute": "�",
+    "\\hat": "Ì‚",
+    "\\tilde": "̃",
+    "\\bar": "Ì„",
+    "\\breve": "̆",
+    "\\dot": "̇",
+    "\\ddot": "̈",
+    "\\ocirc": "ÌŠ",
+    "\\H": "Ì‹",
+    "\\check": "̌",
+    "\\palh": "Ì¡",
+    "\\rh": "Ì¢",
+    "\\c": "̧",
+    "\\k": "̨",
+    "\\sbbrg": "̪",
+    "\\strike": "̶",
+    "\\Alpha": "Α",
+    "\\Beta": "Î’",
+    "\\Gamma": "Γ",
+    "\\Delta": "Δ",
+    "\\Epsilon": "Ε",
+    "\\Zeta": "Ζ",
+    "\\Eta": "Η",
+    "\\Theta": "Θ",
+    "\\Iota": "Ι",
+    "\\Kappa": "Κ",
+    "\\Lambda": "Λ",
+    "\\Xi": "Ξ",
+    "\\Pi": "Π",
+    "\\Rho": "Ρ",
+    "\\Sigma": "Σ",
+    "\\Tau": "Τ",
+    "\\Upsilon": "Î¥",
+    "\\Phi": "Φ",
+    "\\Chi": "Χ",
+    "\\Psi": "Ψ",
+    "\\Omega": "Ω",
+    "\\alpha": "α",
+    "\\beta": "β",
+    "\\gamma": "γ",
+    "\\delta": "δ",
+    "\\zeta": "ζ",
+    "\\eta": "η",
+    "\\theta": "θ",
+    "\\iota": "ι",
+    "\\kappa": "κ",
+    "\\lambda": "λ",
+    "\\mu": "μ",
+    "\\nu": "ν",
+    "\\xi": "ξ",
+    "\\pi": "Ï€",
+    "\\rho": "�",
+    "\\varsigma": "Ï‚",
+    "\\sigma": "σ",
+    "\\tau": "Ï„",
+    "\\upsilon": "Ï…",
+    "\\varphi": "φ",
+    "\\chi": "χ",
+    "\\psi": "ψ",
+    "\\omega": "ω",
+    "\\vartheta": "Ï‘",
+    "\\phi": "Ï•",
+    "\\varpi": "Ï–",
+    "\\Stigma": "Ïš",
+    "\\Digamma": "Ϝ",
+    "\\digamma": "�",
+    "\\Koppa": "Ïž",
+    "\\Sampi": "Ï ",
+    "\\varkappa": "Ï°",
+    "\\varrho": "ϱ",
+    "\\varTheta": "Ï´",
+    "\\epsilon": "ϵ",
+    "\\dddot": "⃛",
+    "\\ddddot": "⃜",
+    "\\hslash": "�",
+    "\\Im": "â„‘",
+    "\\ell": "â„“",
+    "\\wp": "℘",
+    "\\Re": "ℜ",
+    "\\aleph": "ℵ",
+    "\\beth": "ℶ",
+    "\\gimel": "â„·",
+    "\\daleth": "ℸ",
+    "\\bbPi": "â„¿",
+    "\\Zbar": "Ƶ",
+    "\\overbar": "Ì…",
+    "\\ovhook": "̉",
+    "\\candra": "�",
+    "\\oturnedcomma": "Ì’",
+    "\\ocommatopright": "Ì•",
+    "\\droang": "Ìš",
+    "\\wideutilde": "Ì°",
+    "\\not": "̸",
+    "\\Mu": "Μ",
+    "\\Nu": "�",
+    "\\Omicron": "Ο",
+    "\\omicron": "ο",
+    "\\varbeta": "�",
+    "\\oldKoppa": "Ϙ",
+    "\\oldkoppa": "Ï™",
+    "\\stigma": "Ï›",
+    "\\koppa": "ÏŸ",
+    "\\sampi": "Ï¡",
+    "\\tieconcat": "�",
+    "\\leftharpoonaccent": "�",
+    "\\rightharpoonaccent": "⃑",
+    "\\vertoverlay": "⃒",
+    "\\overleftarrow": "⃖",
+    "\\vec": "⃗",
+    "\\overleftrightarrow": "⃡",
+    "\\annuity": "⃧",
+    "\\threeunderdot": "⃨",
+    "\\widebridgeabove": "⃩",
+    "\\bbC": "â„‚",
+    "\\eulermascheroni": "ℇ",
+    "\\scrg": "â„Š",
+    "\\scrH": "â„‹",
+    "\\frakH": "ℌ",
+    "\\bbH": "�",
+    "\\planck": "â„Ž",
+    "\\scrI": "�",
+    "\\scrL": "â„’",
+    "\\bbN": "â„•",
+    "\\bbP": "â„™",
+    "\\bbQ": "â„š",
+    "\\scrR": "â„›",
+    "\\bbR": "�",
+    "\\bbZ": "ℤ",
+    "\\frakZ": "ℨ",
+    "\\Angstrom": "â„«",
+    "\\scrB": "ℬ",
+    "\\frakC": "â„­",
+    "\\scre": "ℯ",
+    "\\scrE": "â„°",
+    "\\scrF": "ℱ",
+    "\\Finv": "Ⅎ",
+    "\\scrM": "ℳ",
+    "\\scro": "â„´",
+    "\\bbgamma": "ℽ",
+    "\\bbGamma": "ℾ",
+    "\\bbiD": "â……",
+    "\\bbid": "â…†",
+    "\\bbie": "â…‡",
+    "\\bbii": "â…ˆ",
+    "\\bbij": "â…‰",
+    "\\bfA": "�",
+    "\\bfB": "�",
+    "\\bfC": "�",
+    "\\bfD": "�",
+    "\\bfE": "�",
+    "\\bfF": "�",
+    "\\bfG": "�",
+    "\\bfH": "�",
+    "\\bfI": "�",
+    "\\bfJ": "�",
+    "\\bfK": "�",
+    "\\bfL": "�",
+    "\\bfM": "�",
+    "\\bfN": "�",
+    "\\bfO": "�",
+    "\\bfP": "�",
+    "\\bfQ": "�",
+    "\\bfR": "�",
+    "\\bfS": "�",
+    "\\bfT": "�",
+    "\\bfU": "�",
+    "\\bfV": "�",
+    "\\bfW": "�",
+    "\\bfX": "�",
+    "\\bfY": "�",
+    "\\bfZ": "�",
+    "\\bfa": "�",
+    "\\bfb": "�",
+    "\\bfc": "�",
+    "\\bfd": "�",
+    "\\bfe": "�",
+    "\\bff": "�",
+    "\\bfg": "�",
+    "\\bfh": "�",
+    "\\bfi": "�",
+    "\\bfj": "�",
+    "\\bfk": "�",
+    "\\bfl": "�",
+    "\\bfm": "�",
+    "\\bfn": "�",
+    "\\bfo": "�",
+    "\\bfp": "�",
+    "\\bfq": "�",
+    "\\bfr": "�",
+    "\\bfs": "�",
+    "\\bft": "�",
+    "\\bfu": "�",
+    "\\bfv": "�",
+    "\\bfw": "�",
+    "\\bfx": "�",
+    "\\bfy": "�",
+    "\\bfz": "�",
+    "\\itA": "�",
+    "\\itB": "�",
+    "\\itC": "�",
+    "\\itD": "�",
+    "\\itE": "�",
+    "\\itF": "�",
+    "\\itG": "�",
+    "\\itH": "�",
+    "\\itI": "�",
+    "\\itJ": "�",
+    "\\itK": "�",
+    "\\itL": "�",
+    "\\itM": "�",
+    "\\itN": "�",
+    "\\itO": "�",
+    "\\itP": "�",
+    "\\itQ": "�",
+    "\\itR": "�",
+    "\\itS": "�",
+    "\\itT": "�",
+    "\\itU": "�",
+    "\\itV": "�",
+    "\\itW": "�",
+    "\\itX": "�",
+    "\\itY": "�",
+    "\\itZ": "�",
+    "\\ita": "�",
+    "\\itb": "�",
+    "\\itc": "�",
+    "\\itd": "�",
+    "\\ite": "�",
+    "\\itf": "�",
+    "\\itg": "�",
+    "\\ith": "â„Ž",
+    "\\iti": "�",
+    "\\itj": "�",
+    "\\itk": "�",
+    "\\itl": "�",
+    "\\itm": "�",
+    "\\itn": "�",
+    "\\ito": "�",
+    "\\itp": "�",
+    "\\itq": "�",
+    "\\itr": "�",
+    "\\its": "�",
+    "\\itt": "�",
+    "\\itu": "�",
+    "\\itv": "�",
+    "\\itw": "�",
+    "\\itx": "�",
+    "\\ity": "�",
+    "\\itz": "�",
+    "\\biA": "�",
+    "\\biB": "�",
+    "\\biC": "�",
+    "\\biD": "�",
+    "\\biE": "�",
+    "\\biF": "�",
+    "\\biG": "�",
+    "\\biH": "�",
+    "\\biI": "�",
+    "\\biJ": "�",
+    "\\biK": "�",
+    "\\biL": "�",
+    "\\biM": "�",
+    "\\biN": "�",
+    "\\biO": "�",
+    "\\biP": "�",
+    "\\biQ": "�",
+    "\\biR": "�",
+    "\\biS": "�",
+    "\\biT": "�",
+    "\\biU": "�",
+    "\\biV": "�",
+    "\\biW": "�",
+    "\\biX": "�",
+    "\\biY": "�",
+    "\\biZ": "�",
+    "\\bia": "�",
+    "\\bib": "�",
+    "\\bic": "�",
+    "\\bid": "�",
+    "\\bie": "�",
+    "\\bif": "�",
+    "\\big": "�",
+    "\\bih": "�",
+    "\\bii": "�",
+    "\\bij": "�",
+    "\\bik": "�",
+    "\\bil": "�",
+    "\\bim": "�",
+    "\\bin": "�",
+    "\\bio": "�",
+    "\\bip": "�",
+    "\\biq": "�",
+    "\\bir": "�",
+    "\\bis": "�",
+    "\\bit": "�",
+    "\\biu": "�",
+    "\\biv": "�",
+    "\\biw": "�",
+    "\\bix": "�",
+    "\\biy": "�",
+    "\\biz": "�",
+    "\\scrA": "�",
+    "\\scrC": "�",
+    "\\scrD": "�",
+    "\\scrG": "�",
+    "\\scrJ": "�",
+    "\\scrK": "�",
+    "\\scrN": "�",
+    "\\scrO": "�",
+    "\\scrP": "�",
+    "\\scrQ": "�",
+    "\\scrS": "�",
+    "\\scrT": "�",
+    "\\scrU": "�",
+    "\\scrV": "�",
+    "\\scrW": "�",
+    "\\scrX": "�",
+    "\\scrY": "�",
+    "\\scrZ": "�",
+    "\\scra": "�",
+    "\\scrb": "�",
+    "\\scrc": "�",
+    "\\scrd": "�",
+    "\\scrf": "�",
+    "\\scrh": "�",
+    "\\scri": "�",
+    "\\scrj": "�",
+    "\\scrk": "�",
+    "\\scrm": "�",
+    "\\scrn": "�",
+    "\\scrp": "�",
+    "\\scrq": "�",
+    "\\scrr": "�",
+    "\\scrs": "�",
+    "\\scrt": "�",
+    "\\scru": "�",
+    "\\scrv": "�",
+    "\\scrw": "�",
+    "\\scrx": "�",
+    "\\scry": "�",
+    "\\scrz": "�",
+    "\\bscrA": "�",
+    "\\bscrB": "�",
+    "\\bscrC": "�",
+    "\\bscrD": "�",
+    "\\bscrE": "�",
+    "\\bscrF": "�",
+    "\\bscrG": "�",
+    "\\bscrH": "�",
+    "\\bscrI": "�",
+    "\\bscrJ": "�",
+    "\\bscrK": "�",
+    "\\bscrL": "�",
+    "\\bscrM": "�",
+    "\\bscrN": "�",
+    "\\bscrO": "�",
+    "\\bscrP": "�",
+    "\\bscrQ": "�",
+    "\\bscrR": "�",
+    "\\bscrS": "�",
+    "\\bscrT": "�",
+    "\\bscrU": "�",
+    "\\bscrV": "�",
+    "\\bscrW": "�",
+    "\\bscrX": "�",
+    "\\bscrY": "�",
+    "\\bscrZ": "�",
+    "\\bscra": "�",
+    "\\bscrb": "�",
+    "\\bscrc": "�",
+    "\\bscrd": "�",
+    "\\bscre": "�",
+    "\\bscrf": "�",
+    "\\bscrg": "�",
+    "\\bscrh": "�",
+    "\\bscri": "�",
+    "\\bscrj": "�",
+    "\\bscrk": "�",
+    "\\bscrl": "�",
+    "\\bscrm": "�",
+    "\\bscrn": "�",
+    "\\bscro": "�",
+    "\\bscrp": "�",
+    "\\bscrq": "�",
+    "\\bscrr": "�",
+    "\\bscrs": "�",
+    "\\bscrt": "�",
+    "\\bscru": "�",
+    "\\bscrv": "�",
+    "\\bscrw": "�",
+    "\\bscrx": "�",
+    "\\bscry": "�",
+    "\\bscrz": "�",
+    "\\frakA": "�",
+    "\\frakB": "�",
+    "\\frakD": "�",
+    "\\frakE": "�",
+    "\\frakF": "�",
+    "\\frakG": "�",
+    "\\frakI": "â„‘",
+    "\\frakJ": "�",
+    "\\frakK": "�",
+    "\\frakL": "�",
+    "\\frakM": "�",
+    "\\frakN": "�",
+    "\\frakO": "�",
+    "\\frakP": "�",
+    "\\frakQ": "�",
+    "\\frakR": "ℜ",
+    "\\frakS": "�",
+    "\\frakT": "�",
+    "\\frakU": "�",
+    "\\frakV": "�",
+    "\\frakW": "�",
+    "\\frakX": "�",
+    "\\frakY": "�",
+    "\\fraka": "�",
+    "\\frakb": "�",
+    "\\frakc": "�",
+    "\\frakd": "�",
+    "\\frake": "�",
+    "\\frakf": "�",
+    "\\frakg": "�",
+    "\\frakh": "�",
+    "\\fraki": "�",
+    "\\frakj": "�",
+    "\\frakk": "�",
+    "\\frakl": "�",
+    "\\frakm": "�",
+    "\\frakn": "�",
+    "\\frako": "�",
+    "\\frakp": "�",
+    "\\frakq": "�",
+    "\\frakr": "�",
+    "\\fraks": "�",
+    "\\frakt": "�",
+    "\\fraku": "�",
+    "\\frakv": "�",
+    "\\frakw": "�",
+    "\\frakx": "�",
+    "\\fraky": "�",
+    "\\frakz": "�",
+    "\\bbA": "�",
+    "\\bbB": "�",
+    "\\bbD": "�",
+    "\\bbE": "�",
+    "\\bbF": "�",
+    "\\bbG": "�",
+    "\\bbI": "�",
+    "\\bbJ": "�",
+    "\\bbK": "�",
+    "\\bbL": "�",
+    "\\bbM": "�",
+    "\\bbO": "�",
+    "\\bbS": "�",
+    "\\bbT": "�",
+    "\\bbU": "�",
+    "\\bbV": "�",
+    "\\bbW": "�",
+    "\\bbX": "�",
+    "\\bbY": "�",
+    "\\bba": "�",
+    "\\bbb": "�",
+    "\\bbc": "�",
+    "\\bbd": "�",
+    "\\bbe": "�",
+    "\\bbf": "�",
+    "\\bbg": "�",
+    "\\bbh": "�",
+    "\\bbi": "�",
+    "\\bbj": "�",
+    "\\bbk": "�",
+    "\\bbl": "�",
+    "\\bbm": "�",
+    "\\bbn": "�",
+    "\\bbo": "�",
+    "\\bbp": "�",
+    "\\bbq": "�",
+    "\\bbr": "�",
+    "\\bbs": "�",
+    "\\bbt": "�",
+    "\\bbu": "�",
+    "\\bbv": "�",
+    "\\bbw": "�",
+    "\\bbx": "�",
+    "\\bby": "�",
+    "\\bbz": "�",
+    "\\bfrakA": "�",
+    "\\bfrakB": "�",
+    "\\bfrakC": "�",
+    "\\bfrakD": "�",
+    "\\bfrakE": "�",
+    "\\bfrakF": "�",
+    "\\bfrakG": "�",
+    "\\bfrakH": "�",
+    "\\bfrakI": "�",
+    "\\bfrakJ": "�",
+    "\\bfrakK": "�",
+    "\\bfrakL": "�",
+    "\\bfrakM": "�",
+    "\\bfrakN": "�",
+    "\\bfrakO": "�",
+    "\\bfrakP": "�",
+    "\\bfrakQ": "�",
+    "\\bfrakR": "�",
+    "\\bfrakS": "�",
+    "\\bfrakT": "�",
+    "\\bfrakU": "�",
+    "\\bfrakV": "�",
+    "\\bfrakW": "�",
+    "\\bfrakX": "�",
+    "\\bfrakY": "�",
+    "\\bfrakZ": "�",
+    "\\bfraka": "�",
+    "\\bfrakb": "�",
+    "\\bfrakc": "�",
+    "\\bfrakd": "�",
+    "\\bfrake": "�",
+    "\\bfrakf": "�",
+    "\\bfrakg": "�",
+    "\\bfrakh": "�",
+    "\\bfraki": "�",
+    "\\bfrakj": "�",
+    "\\bfrakk": "�",
+    "\\bfrakl": "�",
+    "\\bfrakm": "�",
+    "\\bfrakn": "�",
+    "\\bfrako": "�",
+    "\\bfrakp": "�",
+    "\\bfrakq": "�",
+    "\\bfrakr": "�",
+    "\\bfraks": "�",
+    "\\bfrakt": "�",
+    "\\bfraku": "�",
+    "\\bfrakv": "�",
+    "\\bfrakw": "�",
+    "\\bfrakx": "�",
+    "\\bfraky": "�",
+    "\\bfrakz": "�",
+    "\\sansA": "�",
+    "\\sansB": "�",
+    "\\sansC": "�",
+    "\\sansD": "�",
+    "\\sansE": "�",
+    "\\sansF": "�",
+    "\\sansG": "�",
+    "\\sansH": "�",
+    "\\sansI": "�",
+    "\\sansJ": "�",
+    "\\sansK": "�",
+    "\\sansL": "�",
+    "\\sansM": "�",
+    "\\sansN": "�",
+    "\\sansO": "�",
+    "\\sansP": "�",
+    "\\sansQ": "�",
+    "\\sansR": "�",
+    "\\sansS": "�",
+    "\\sansT": "�",
+    "\\sansU": "�",
+    "\\sansV": "�",
+    "\\sansW": "�",
+    "\\sansX": "�",
+    "\\sansY": "�",
+    "\\sansZ": "�",
+    "\\sansa": "�",
+    "\\sansb": "�",
+    "\\sansc": "�",
+    "\\sansd": "�",
+    "\\sanse": "�",
+    "\\sansf": "�",
+    "\\sansg": "�",
+    "\\sansh": "�",
+    "\\sansi": "�",
+    "\\sansj": "�",
+    "\\sansk": "�",
+    "\\sansl": "�",
+    "\\sansm": "�",
+    "\\sansn": "�",
+    "\\sanso": "�",
+    "\\sansp": "�",
+    "\\sansq": "�",
+    "\\sansr": "�",
+    "\\sanss": "�",
+    "\\sanst": "�",
+    "\\sansu": "�",
+    "\\sansv": "�",
+    "\\sansw": "�",
+    "\\sansx": "�",
+    "\\sansy": "�",
+    "\\sansz": "�",
+    "\\bsansA": "�",
+    "\\bsansB": "�",
+    "\\bsansC": "�",
+    "\\bsansD": "�",
+    "\\bsansE": "�",
+    "\\bsansF": "�",
+    "\\bsansG": "�",
+    "\\bsansH": "�",
+    "\\bsansI": "�",
+    "\\bsansJ": "�",
+    "\\bsansK": "�",
+    "\\bsansL": "�",
+    "\\bsansM": "�",
+    "\\bsansN": "�",
+    "\\bsansO": "�",
+    "\\bsansP": "�",
+    "\\bsansQ": "�",
+    "\\bsansR": "�",
+    "\\bsansS": "�",
+    "\\bsansT": "�",
+    "\\bsansU": "�",
+    "\\bsansV": "�",
+    "\\bsansW": "�",
+    "\\bsansX": "�",
+    "\\bsansY": "�",
+    "\\bsansZ": "�",
+    "\\bsansa": "�",
+    "\\bsansb": "�",
+    "\\bsansc": "�",
+    "\\bsansd": "�",
+    "\\bsanse": "�",
+    "\\bsansf": "�",
+    "\\bsansg": "�",
+    "\\bsansh": "�",
+    "\\bsansi": "�",
+    "\\bsansj": "�",
+    "\\bsansk": "�",
+    "\\bsansl": "�",
+    "\\bsansm": "�",
+    "\\bsansn": "�",
+    "\\bsanso": "�",
+    "\\bsansp": "�",
+    "\\bsansq": "�",
+    "\\bsansr": "�",
+    "\\bsanss": "�",
+    "\\bsanst": "�",
+    "\\bsansu": "�",
+    "\\bsansv": "�",
+    "\\bsansw": "�",
+    "\\bsansx": "�",
+    "\\bsansy": "�",
+    "\\bsansz": "�",
+    "\\isansA": "�",
+    "\\isansB": "�",
+    "\\isansC": "�",
+    "\\isansD": "�",
+    "\\isansE": "�",
+    "\\isansF": "�",
+    "\\isansG": "�",
+    "\\isansH": "�",
+    "\\isansI": "�",
+    "\\isansJ": "�",
+    "\\isansK": "�",
+    "\\isansL": "�",
+    "\\isansM": "�",
+    "\\isansN": "�",
+    "\\isansO": "�",
+    "\\isansP": "�",
+    "\\isansQ": "�",
+    "\\isansR": "�",
+    "\\isansS": "�",
+    "\\isansT": "�",
+    "\\isansU": "�",
+    "\\isansV": "�",
+    "\\isansW": "�",
+    "\\isansX": "�",
+    "\\isansY": "�",
+    "\\isansZ": "�",
+    "\\isansa": "�",
+    "\\isansb": "�",
+    "\\isansc": "�",
+    "\\isansd": "�",
+    "\\isanse": "�",
+    "\\isansf": "�",
+    "\\isansg": "�",
+    "\\isansh": "�",
+    "\\isansi": "�",
+    "\\isansj": "�",
+    "\\isansk": "�",
+    "\\isansl": "�",
+    "\\isansm": "�",
+    "\\isansn": "�",
+    "\\isanso": "�",
+    "\\isansp": "�",
+    "\\isansq": "�",
+    "\\isansr": "�",
+    "\\isanss": "�",
+    "\\isanst": "�",
+    "\\isansu": "�",
+    "\\isansv": "�",
+    "\\isansw": "�",
+    "\\isansx": "�",
+    "\\isansy": "�",
+    "\\isansz": "�",
+    "\\bisansA": "�",
+    "\\bisansB": "�",
+    "\\bisansC": "�",
+    "\\bisansD": "�",
+    "\\bisansE": "�",
+    "\\bisansF": "�",
+    "\\bisansG": "�",
+    "\\bisansH": "�",
+    "\\bisansI": "�",
+    "\\bisansJ": "�",
+    "\\bisansK": "�",
+    "\\bisansL": "�",
+    "\\bisansM": "�",
+    "\\bisansN": "�",
+    "\\bisansO": "�",
+    "\\bisansP": "�",
+    "\\bisansQ": "�",
+    "\\bisansR": "�",
+    "\\bisansS": "�",
+    "\\bisansT": "�",
+    "\\bisansU": "�",
+    "\\bisansV": "�",
+    "\\bisansW": "�",
+    "\\bisansX": "�",
+    "\\bisansY": "�",
+    "\\bisansZ": "�",
+    "\\bisansa": "�",
+    "\\bisansb": "�",
+    "\\bisansc": "�",
+    "\\bisansd": "�",
+    "\\bisanse": "�",
+    "\\bisansf": "�",
+    "\\bisansg": "�",
+    "\\bisansh": "�",
+    "\\bisansi": "�",
+    "\\bisansj": "�",
+    "\\bisansk": "�",
+    "\\bisansl": "�",
+    "\\bisansm": "�",
+    "\\bisansn": "�",
+    "\\bisanso": "�",
+    "\\bisansp": "�",
+    "\\bisansq": "�",
+    "\\bisansr": "�",
+    "\\bisanss": "�",
+    "\\bisanst": "�",
+    "\\bisansu": "�",
+    "\\bisansv": "�",
+    "\\bisansw": "�",
+    "\\bisansx": "�",
+    "\\bisansy": "�",
+    "\\bisansz": "�",
+    "\\ttA": "�",
+    "\\ttB": "�",
+    "\\ttC": "�",
+    "\\ttD": "�",
+    "\\ttE": "�",
+    "\\ttF": "�",
+    "\\ttG": "�",
+    "\\ttH": "�",
+    "\\ttI": "�",
+    "\\ttJ": "�",
+    "\\ttK": "�",
+    "\\ttL": "�",
+    "\\ttM": "�",
+    "\\ttN": "�",
+    "\\ttO": "�",
+    "\\ttP": "�",
+    "\\ttQ": "�",
+    "\\ttR": "�",
+    "\\ttS": "�",
+    "\\ttT": "�",
+    "\\ttU": "�",
+    "\\ttV": "�",
+    "\\ttW": "�",
+    "\\ttX": "�",
+    "\\ttY": "�",
+    "\\ttZ": "�",
+    "\\tta": "�",
+    "\\ttb": "�",
+    "\\ttc": "�",
+    "\\ttd": "�",
+    "\\tte": "�",
+    "\\ttf": "�",
+    "\\ttg": "�",
+    "\\tth": "�",
+    "\\tti": "�",
+    "\\ttj": "�",
+    "\\ttk": "�",
+    "\\ttl": "�",
+    "\\ttm": "�",
+    "\\ttn": "�",
+    "\\tto": "�",
+    "\\ttp": "�",
+    "\\ttq": "�",
+    "\\ttr": "�",
+    "\\tts": "�",
+    "\\ttt": "�",
+    "\\ttu": "�",
+    "\\ttv": "�",
+    "\\ttw": "�",
+    "\\ttx": "�",
+    "\\tty": "�",
+    "\\ttz": "�",
+    "\\bfAlpha": "�",
+    "\\bfBeta": "�",
+    "\\bfGamma": "�",
+    "\\bfDelta": "�",
+    "\\bfEpsilon": "�",
+    "\\bfZeta": "�",
+    "\\bfEta": "�",
+    "\\bfTheta": "�",
+    "\\bfIota": "�",
+    "\\bfKappa": "�",
+    "\\bfLambda": "�",
+    "\\bfMu": "�",
+    "\\bfNu": "�",
+    "\\bfXi": "�",
+    "\\bfOmicron": "�",
+    "\\bfPi": "�",
+    "\\bfRho": "�",
+    "\\bfvarTheta": "�",
+    "\\bfSigma": "�",
+    "\\bfTau": "�",
+    "\\bfUpsilon": "�",
+    "\\bfPhi": "�",
+    "\\bfChi": "�",
+    "\\bfPsi": "�",
+    "\\bfOmega": "�",
+    "\\bfalpha": "�",
+    "\\bfbeta": "�",
+    "\\bfgamma": "�",
+    "\\bfdelta": "�",
+    "\\bfvarepsilon": "�",
+    "\\bfzeta": "�",
+    "\\bfeta": "�",
+    "\\bftheta": "�",
+    "\\bfiota": "�",
+    "\\bfkappa": "�",
+    "\\bflambda": "�",
+    "\\bfmu": "�",
+    "\\bfnu": "�",
+    "\\bfxi": "�",
+    "\\bfomicron": "�",
+    "\\bfpi": "�",
+    "\\bfrho": "�",
+    "\\bfvarsigma": "�",
+    "\\bfsigma": "�",
+    "\\bftau": "�",
+    "\\bfupsilon": "�",
+    "\\bfvarphi": "�",
+    "\\bfchi": "�",
+    "\\bfpsi": "�",
+    "\\bfomega": "�",
+    "\\bfepsilon": "�",
+    "\\bfvartheta": "�",
+    "\\bfvarkappa": "�",
+    "\\bfphi": "�",
+    "\\bfvarrho": "�",
+    "\\bfvarpi": "�",
+    "\\itAlpha": "�",
+    "\\itBeta": "�",
+    "\\itGamma": "�",
+    "\\itDelta": "�",
+    "\\itEpsilon": "�",
+    "\\itZeta": "�",
+    "\\itEta": "�",
+    "\\itTheta": "�",
+    "\\itIota": "�",
+    "\\itKappa": "�",
+    "\\itLambda": "�",
+    "\\itMu": "�",
+    "\\itNu": "�",
+    "\\itXi": "�",
+    "\\itOmicron": "�",
+    "\\itPi": "�",
+    "\\itRho": "�",
+    "\\itvarTheta": "�",
+    "\\itSigma": "�",
+    "\\itTau": "�",
+    "\\itUpsilon": "�",
+    "\\itPhi": "�",
+    "\\itChi": "�",
+    "\\itPsi": "�",
+    "\\itOmega": "�",
+    "\\italpha": "�",
+    "\\itbeta": "�",
+    "\\itgamma": "�",
+    "\\itdelta": "�",
+    "\\itvarepsilon": "�",
+    "\\itzeta": "�",
+    "\\iteta": "�",
+    "\\ittheta": "�",
+    "\\itiota": "�",
+    "\\itkappa": "�",
+    "\\itlambda": "�",
+    "\\itmu": "�",
+    "\\itnu": "�",
+    "\\itxi": "�",
+    "\\itomicron": "�",
+    "\\itpi": "�",
+    "\\itrho": "�",
+    "\\itvarsigma": "�",
+    "\\itsigma": "�",
+    "\\ittau": "�",
+    "\\itupsilon": "�",
+    "\\itvarphi": "�",
+    "\\itchi": "�",
+    "\\itpsi": "�",
+    "\\itomega": "�",
+    "\\itepsilon": "�",
+    "\\itvartheta": "�",
+    "\\itvarkappa": "�",
+    "\\itphi": "�",
+    "\\itvarrho": "�",
+    "\\itvarpi": "�",
+    "\\biAlpha": "�",
+    "\\biBeta": "�",
+    "\\biGamma": "�",
+    "\\biDelta": "�",
+    "\\biEpsilon": "�",
+    "\\biZeta": "�",
+    "\\biEta": "�",
+    "\\biTheta": "�",
+    "\\biIota": "�",
+    "\\biKappa": "�",
+    "\\biLambda": "�",
+    "\\biMu": "�",
+    "\\biNu": "�",
+    "\\biXi": "�",
+    "\\biOmicron": "�",
+    "\\biPi": "�",
+    "\\biRho": "�",
+    "\\bivarTheta": "�",
+    "\\biSigma": "�",
+    "\\biTau": "�",
+    "\\biUpsilon": "�",
+    "\\biPhi": "�",
+    "\\biChi": "�",
+    "\\biPsi": "�",
+    "\\biOmega": "�",
+    "\\bialpha": "�",
+    "\\bibeta": "�",
+    "\\bigamma": "�",
+    "\\bidelta": "�",
+    "\\bivarepsilon": "�",
+    "\\bizeta": "�",
+    "\\bieta": "�",
+    "\\bitheta": "�",
+    "\\biiota": "�",
+    "\\bikappa": "�",
+    "\\bilambda": "�",
+    "\\bimu": "�",
+    "\\binu": "�",
+    "\\bixi": "�",
+    "\\biomicron": "�",
+    "\\bipi": "�",
+    "\\birho": "�",
+    "\\bivarsigma": "�",
+    "\\bisigma": "�",
+    "\\bitau": "�",
+    "\\biupsilon": "�",
+    "\\bivarphi": "�",
+    "\\bichi": "�",
+    "\\bipsi": "�",
+    "\\biomega": "�",
+    "\\biepsilon": "�",
+    "\\bivartheta": "�",
+    "\\bivarkappa": "�",
+    "\\biphi": "�",
+    "\\bivarrho": "�",
+    "\\bivarpi": "�",
+    "\\bsansAlpha": "�",
+    "\\bsansBeta": "�",
+    "\\bsansGamma": "�",
+    "\\bsansDelta": "�",
+    "\\bsansEpsilon": "�",
+    "\\bsansZeta": "�",
+    "\\bsansEta": "�",
+    "\\bsansTheta": "�",
+    "\\bsansIota": "�",
+    "\\bsansKappa": "�",
+    "\\bsansLambda": "�",
+    "\\bsansMu": "�",
+    "\\bsansNu": "�",
+    "\\bsansXi": "�",
+    "\\bsansOmicron": "�",
+    "\\bsansPi": "�",
+    "\\bsansRho": "�",
+    "\\bsansvarTheta": "�",
+    "\\bsansSigma": "�",
+    "\\bsansTau": "�",
+    "\\bsansUpsilon": "�",
+    "\\bsansPhi": "�",
+    "\\bsansChi": "�",
+    "\\bsansPsi": "�",
+    "\\bsansOmega": "�",
+    "\\bsansalpha": "�",
+    "\\bsansbeta": "�",
+    "\\bsansgamma": "�",
+    "\\bsansdelta": "�",
+    "\\bsansvarepsilon": "�",
+    "\\bsanszeta": "�",
+    "\\bsanseta": "�",
+    "\\bsanstheta": "�",
+    "\\bsansiota": "�",
+    "\\bsanskappa": "�",
+    "\\bsanslambda": "�",
+    "\\bsansmu": "�",
+    "\\bsansnu": "�",
+    "\\bsansxi": "�",
+    "\\bsansomicron": "�",
+    "\\bsanspi": "�",
+    "\\bsansrho": "�",
+    "\\bsansvarsigma": "�",
+    "\\bsanssigma": "�",
+    "\\bsanstau": "�",
+    "\\bsansupsilon": "�",
+    "\\bsansvarphi": "�",
+    "\\bsanschi": "�",
+    "\\bsanspsi": "�",
+    "\\bsansomega": "�",
+    "\\bsansepsilon": "�",
+    "\\bsansvartheta": "�",
+    "\\bsansvarkappa": "�",
+    "\\bsansphi": "�",
+    "\\bsansvarrho": "�",
+    "\\bsansvarpi": "�",
+    "\\bisansAlpha": "�",
+    "\\bisansBeta": "�",
+    "\\bisansGamma": "�",
+    "\\bisansDelta": "�",
+    "\\bisansEpsilon": "�",
+    "\\bisansZeta": "�",
+    "\\bisansEta": "�",
+    "\\bisansTheta": "�",
+    "\\bisansIota": "�",
+    "\\bisansKappa": "�",
+    "\\bisansLambda": "�",
+    "\\bisansMu": "�",
+    "\\bisansNu": "�",
+    "\\bisansXi": "�",
+    "\\bisansOmicron": "�",
+    "\\bisansPi": "�",
+    "\\bisansRho": "�",
+    "\\bisansvarTheta": "�",
+    "\\bisansSigma": "�",
+    "\\bisansTau": "�",
+    "\\bisansUpsilon": "�",
+    "\\bisansPhi": "�",
+    "\\bisansChi": "�",
+    "\\bisansPsi": "�",
+    "\\bisansOmega": "�",
+    "\\bisansalpha": "�",
+    "\\bisansbeta": "�",
+    "\\bisansgamma": "�",
+    "\\bisansdelta": "�",
+    "\\bisansvarepsilon": "�",
+    "\\bisanszeta": "�",
+    "\\bisanseta": "�",
+    "\\bisanstheta": "�",
+    "\\bisansiota": "�",
+    "\\bisanskappa": "�",
+    "\\bisanslambda": "�",
+    "\\bisansmu": "�",
+    "\\bisansnu": "�",
+    "\\bisansxi": "�",
+    "\\bisansomicron": "�",
+    "\\bisanspi": "�",
+    "\\bisansrho": "�",
+    "\\bisansvarsigma": "�",
+    "\\bisanssigma": "�",
+    "\\bisanstau": "�",
+    "\\bisansupsilon": "�",
+    "\\bisansvarphi": "�",
+    "\\bisanschi": "�",
+    "\\bisanspsi": "�",
+    "\\bisansomega": "�",
+    "\\bisansepsilon": "�",
+    "\\bisansvartheta": "�",
+    "\\bisansvarkappa": "�",
+    "\\bisansphi": "�",
+    "\\bisansvarrho": "�",
+    "\\bisansvarpi": "�",
+    "\\bfzero": "�",
+    "\\bfone": "�",
+    "\\bftwo": "�",
+    "\\bfthree": "�",
+    "\\bffour": "�",
+    "\\bffive": "�",
+    "\\bfsix": "�",
+    "\\bfseven": "�",
+    "\\bfeight": "�",
+    "\\bfnine": "�",
+    "\\bbzero": "�",
+    "\\bbone": "�",
+    "\\bbtwo": "�",
+    "\\bbthree": "�",
+    "\\bbfour": "�",
+    "\\bbfive": "�",
+    "\\bbsix": "�",
+    "\\bbseven": "�",
+    "\\bbeight": "�",
+    "\\bbnine": "�",
+    "\\sanszero": "�",
+    "\\sansone": "�",
+    "\\sanstwo": "�",
+    "\\sansthree": "�",
+    "\\sansfour": "�",
+    "\\sansfive": "�",
+    "\\sanssix": "�",
+    "\\sansseven": "�",
+    "\\sanseight": "�",
+    "\\sansnine": "�",
+    "\\bsanszero": "�",
+    "\\bsansone": "�",
+    "\\bsanstwo": "�",
+    "\\bsansthree": "�",
+    "\\bsansfour": "�",
+    "\\bsansfive": "�",
+    "\\bsanssix": "�",
+    "\\bsansseven": "�",
+    "\\bsanseight": "�",
+    "\\bsansnine": "�",
+    "\\ttzero": "�",
+    "\\ttone": "�",
+    "\\tttwo": "�",
+    "\\ttthree": "�",
+    "\\ttfour": "�",
+    "\\ttfive": "�",
+    "\\ttsix": "�",
+    "\\ttseven": "�",
+    "\\tteight": "�",
+    "\\ttnine": "�",
+    "\\underbar": "̲",
+    "\\underleftrightarrow": "�",
+}
+
+
+reverse_latex_symbol = {v: k for k, v in latex_symbols.items()}
diff --git a/IPython/core/logger.py b/IPython/core/logger.py
index 39d829244b7..704bb995aa6 100644
--- a/IPython/core/logger.py
+++ b/IPython/core/logger.py
@@ -14,17 +14,23 @@
 
 # Python standard modules
 import glob
+import io
+import logging
 import os
 import time
 
+
+# prevent jedi/parso's debug messages pipe into interactiveshell
+logging.getLogger("parso").setLevel(logging.WARNING)
+
 #****************************************************************************
 # FIXME: This class isn't a mixin anymore, but it still needs attributes from
 # ipython and does input cache management.  Finish cleanup later...
 
-class Logger(object):
+class Logger:
     """A Logfile class with different policies for file creation"""
 
-    def __init__(self, home_dir, logfname='Logger.log', loghead='',
+    def __init__(self, home_dir, logfname='Logger.log', loghead=u'',
                  logmode='over'):
 
         # this is the full ipython instance, we need some attributes from it
@@ -51,16 +57,16 @@ def __init__(self, home_dir, logfname='Logger.log', loghead='',
     # logmode is a validated property
     def _set_mode(self,mode):
         if mode not in ['append','backup','global','over','rotate']:
-            raise ValueError,'invalid log mode %s given' % mode
+            raise ValueError('invalid log mode %s given' % mode)
         self._logmode = mode
 
     def _get_mode(self):
         return self._logmode
 
     logmode = property(_get_mode,_set_mode)
-    
-    def logstart(self,logfname=None,loghead=None,logmode=None,
-                 log_output=False,timestamp=False,log_raw_input=False):
+
+    def logstart(self, logfname=None, loghead=None, logmode=None,
+                 log_output=False, timestamp=False, log_raw_input=False):
         """Generate a new log-file with a default header.
 
         Raises RuntimeError if the log has already been started"""
@@ -68,8 +74,6 @@ def logstart(self,logfname=None,loghead=None,logmode=None,
         if self.logfile is not None:
             raise RuntimeError('Log file is already active: %s' %
                                self.logfname)
-        
-        self.log_active = True
 
         # The parameters can override constructor defaults
         if logfname is not None: self.logfname = logfname
@@ -80,13 +84,13 @@ def logstart(self,logfname=None,loghead=None,logmode=None,
         self.timestamp = timestamp
         self.log_output = log_output
         self.log_raw_input = log_raw_input
-        
+
         # init depending on the log mode requested
         isfile = os.path.isfile
         logmode = self.logmode
 
         if logmode == 'append':
-            self.logfile = open(self.logfname,'a')
+            self.logfile = io.open(self.logfname, 'a', encoding='utf-8')
 
         elif logmode == 'backup':
             if isfile(self.logfname):
@@ -96,72 +100,73 @@ def logstart(self,logfname=None,loghead=None,logmode=None,
                 if isfile(backup_logname):
                     os.remove(backup_logname)
                 os.rename(self.logfname,backup_logname)
-            self.logfile = open(self.logfname,'w')
+            self.logfile = io.open(self.logfname, 'w', encoding='utf-8')
 
         elif logmode == 'global':
             self.logfname = os.path.join(self.home_dir,self.logfname)
-            self.logfile = open(self.logfname, 'a')
+            self.logfile = io.open(self.logfname, 'a', encoding='utf-8')
 
         elif logmode == 'over':
             if isfile(self.logfname):
-                os.remove(self.logfname) 
-            self.logfile = open(self.logfname,'w')
+                os.remove(self.logfname)
+            self.logfile = io.open(self.logfname,'w', encoding='utf-8')
 
         elif logmode == 'rotate':
             if isfile(self.logfname):
-                if isfile(self.logfname+'.001~'): 
+                if isfile(self.logfname+'.001~'):
                     old = glob.glob(self.logfname+'.*~')
                     old.sort()
                     old.reverse()
                     for f in old:
                         root, ext = os.path.splitext(f)
                         num = int(ext[1:-1])+1
-                        os.rename(f, root+'.'+`num`.zfill(3)+'~')
+                        os.rename(f, root+'.'+repr(num).zfill(3)+'~')
                 os.rename(self.logfname, self.logfname+'.001~')
-            self.logfile = open(self.logfname,'w')
-            
+            self.logfile = io.open(self.logfname, 'w', encoding='utf-8')
+
         if logmode != 'append':
             self.logfile.write(self.loghead)
 
         self.logfile.flush()
+        self.log_active = True
 
     def switch_log(self,val):
         """Switch logging on/off. val should be ONLY a boolean."""
 
         if val not in [False,True,0,1]:
-            raise ValueError, \
-                  'Call switch_log ONLY with a boolean argument, not with:',val
-        
+            raise ValueError('Call switch_log ONLY with a boolean argument, '
+                             'not with: %s' % val)
+
         label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
 
         if self.logfile is None:
-            print """
+            print("""
 Logging hasn't been started yet (use logstart for that).
 
 %logon/%logoff are for temporarily starting and stopping logging for a logfile
 which already exists. But you must first start the logging process with
-%logstart (optionally giving a logfile name)."""
-            
+%logstart (optionally giving a logfile name).""")
+
         else:
             if self.log_active == val:
-                print 'Logging is already',label[val]
+                print('Logging is already',label[val])
             else:
-                print 'Switching logging',label[val]
+                print('Switching logging',label[val])
                 self.log_active = not self.log_active
                 self.log_active_out = self.log_active
 
     def logstate(self):
         """Print a status message about the logger."""
         if self.logfile is None:
-            print 'Logging has not been activated.'
+            print('Logging has not been activated.')
         else:
             state = self.log_active and 'active' or 'temporarily suspended'
-            print 'Filename       :',self.logfname
-            print 'Mode           :',self.logmode
-            print 'Output logging :',self.log_output
-            print 'Raw input log  :',self.log_raw_input
-            print 'Timestamping   :',self.timestamp
-            print 'State          :',state
+            print('Filename       :', self.logfname)
+            print('Mode           :', self.logmode)
+            print('Output logging :', self.log_output)
+            print('Raw input log  :', self.log_raw_input)
+            print('Timestamping   :', self.timestamp)
+            print('State          :', state)
 
     def log(self, line_mod, line_ori):
         """Write the sources to a log.
@@ -169,11 +174,11 @@ def log(self, line_mod, line_ori):
         Inputs:
 
         - line_mod: possibly modified input, such as the transformations made
-        by input prefilters or input handlers of various kinds.  This should
-        always be valid Python.
+          by input prefilters or input handlers of various kinds. This should
+          always be valid Python.
 
-        - line_ori: unmodified input line from the user.  This is not
-        necessarily valid Python.
+        - line_ori: unmodified input line from the user. This is not
+          necessarily valid Python.
         """
 
         # Write the log line, but decide which one according to the
@@ -186,19 +191,27 @@ def log(self, line_mod, line_ori):
     def log_write(self, data, kind='input'):
         """Write data to the log file, if active"""
 
-        #print 'data: %r' % data # dbg
+        # print('data: %r' % data)  # dbg
         if self.log_active and data:
             write = self.logfile.write
             if kind=='input':
                 if self.timestamp:
-                    write(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
-                                        time.localtime()))
+                    write(time.strftime('# %a, %d %b %Y %H:%M:%S\n', time.localtime()))
                 write(data)
             elif kind=='output' and self.log_output:
-                odata = '\n'.join(['#[Out]# %s' % s
+                odata = u'\n'.join([u'#[Out]# %s' % s
                                    for s in data.splitlines()])
-                write('%s\n' % odata)
-            self.logfile.flush()
+                write(u'%s\n' % odata)
+            try:
+                self.logfile.flush()
+            except OSError:
+                print("Failed to flush the log file.")
+                print(
+                    f"Please check that {self.logfname} exists and have the right permissions."
+                )
+                print(
+                    "Also consider turning off the log with `%logstop` to avoid this warning."
+                )
 
     def logstop(self):
         """Fully stop logging and close log file.
@@ -206,9 +219,12 @@ def logstop(self):
         In order to start logging again, a new logstart() call needs to be
         made, possibly (though not necessarily) with a new filename, mode and
         other options."""
-        
-        self.logfile.close()
-        self.logfile = None
+
+        if self.logfile is not None:
+            self.logfile.close()
+            self.logfile = None
+        else:
+            print("Logging hadn't been started.")
         self.log_active = False
 
     # For backwards compatibility, in case anyone was using this.
diff --git a/IPython/core/macro.py b/IPython/core/macro.py
index e87ea78624e..abab576e720 100644
--- a/IPython/core/macro.py
+++ b/IPython/core/macro.py
@@ -8,17 +8,16 @@
 #*****************************************************************************
 
 import re
-import sys
+
+from IPython.utils.encoding import DEFAULT_ENCODING
 
 coding_declaration = re.compile(r"#\s*coding[:=]\s*([-\w.]+)")
 
-class Macro(object):
+class Macro:
     """Simple class to store the value of macros as strings.
 
     Macro is just a callable that executes a string of IPython
     input when called.
-    
-    Args to macro are available in _margv list if you need them.
     """
 
     def __init__(self,code):
@@ -33,14 +32,10 @@ def __init__(self,code):
                 lines.append(line)
         code = "\n".join(lines)
         if isinstance(code, bytes):
-            code = code.decode(enc or sys.getdefaultencoding())
+            code = code.decode(enc or DEFAULT_ENCODING)
         self.value = code + '\n'
     
     def __str__(self):
-        enc = sys.stdin.encoding or sys.getdefaultencoding()
-        return self.value.encode(enc, "replace")
-    
-    def __unicode__(self):
         return self.value
 
     def __repr__(self):
@@ -53,6 +48,6 @@ def __getstate__(self):
     def __add__(self, other):
         if isinstance(other, Macro):
             return Macro(self.value + other.value)
-        elif isinstance(other, basestring):
+        elif isinstance(other, str):
             return Macro(self.value + other)
         raise TypeError
diff --git a/IPython/core/magic.py b/IPython/core/magic.py
index a298e36fa40..74c97c19003 100644
--- a/IPython/core/magic.py
+++ b/IPython/core/magic.py
@@ -1,3469 +1,827 @@
-# encoding: utf-8
-"""Magic functions for InteractiveShell.
-"""
+from __future__ import annotations
+
+"""Magic functions for InteractiveShell."""
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 #  Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
-#  Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2001 Fernando Perez <fperez@colorado.edu>
+#  Copyright (C) 2008 The IPython Development Team
 
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
-import __builtin__
-import __future__
-import bdb
-import inspect
 import os
-import sys
-import shutil
 import re
-import time
-import textwrap
-from cStringIO import StringIO
-from getopt import getopt,GetoptError
-from pprint import pformat
-from xmlrpclib import ServerProxy
-
-# cProfile was added in Python2.5
-try:
-    import cProfile as profile
-    import pstats
-except ImportError:
-    # profile isn't bundled by default in Debian for license reasons
-    try:
-        import profile,pstats
-    except ImportError:
-        profile = pstats = None
-
-import IPython
-from IPython.core import debugger, oinspect
-from IPython.core.error import TryNext
-from IPython.core.error import UsageError
-from IPython.core.fakemodule import FakeModule
-from IPython.core.macro import Macro
-from IPython.core import page
-from IPython.core.prefilter import ESC_MAGIC
-from IPython.lib.pylabtools import mpl_runner
-from IPython.external.Itpl import itpl, printpl
-from IPython.testing import decorators as testdec
-from IPython.utils.io import file_read, nlprint
-from IPython.utils.path import get_py_filename
-from IPython.utils.process import arg_split, abbrev_cwd
-from IPython.utils.terminal import set_term_title
-from IPython.utils.text import LSString, SList, format_screen
-from IPython.utils.timing import clock, clock2
-from IPython.utils.warn import warn, error
-from IPython.utils.ipstruct import Struct
-import IPython.utils.generics
-
-#-----------------------------------------------------------------------------
-# Utility functions
-#-----------------------------------------------------------------------------
-
-def on_off(tag):
-    """Return an ON/OFF string for a 1/0 input. Simple utility function."""
-    return ['OFF','ON'][tag]
-
-class Bunch: pass
-
-def compress_dhist(dh):
-    head, tail = dh[:-10], dh[-10:]
-
-    newhead = []
-    done = set()
-    for h in head:
-        if h in done:
-            continue
-        newhead.append(h)
-        done.add(h)
-
-    return newhead + tail        
-
-def needs_local_scope(func):
-    """Decorator to mark magic functions which need to local scope to run."""
-    func.needs_local_scope = True
-    return func
-
-#***************************************************************************
-# Main class implementing Magic functionality
-
-# XXX - for some odd reason, if Magic is made a new-style class, we get errors
-# on construction of the main InteractiveShell object.  Something odd is going
-# on with super() calls, Configurable and the MRO... For now leave it as-is, but
-# eventually this needs to be clarified.
-# BG: This is because InteractiveShell inherits from this, but is itself a 
-# Configurable. This messes up the MRO in some way. The fix is that we need to
-# make Magic a configurable that InteractiveShell does not subclass.
-
-class Magic:
-    """Magic functions for InteractiveShell.
-
-    Shell functions which can be reached as %function_name. All magic
-    functions should accept a string, which they can parse for their own
-    needs. This can make some functions easier to type, eg `%cd ../`
-    vs. `%cd("../")`
-
-    ALL definitions MUST begin with the prefix magic_. The user won't need it
-    at the command line, but it is is needed in the definition. """
-
-    # class globals
-    auto_status = ['Automagic is OFF, % prefix IS needed for magic functions.',
-                   'Automagic is ON, % prefix NOT needed for magic functions.']
-
-    #......................................................................
-    # some utility functions
-
-    def __init__(self,shell):
-        
-        self.options_table = {}
-        if profile is None:
-            self.magic_prun = self.profile_missing_notice
-        self.shell = shell
-
-        # namespace for holding state we may need
-        self._magic_state = Bunch()
-
-    def profile_missing_notice(self, *args, **kwargs):
-        error("""\
-The profile module could not be found. It has been removed from the standard
-python packages because of its non-free license. To use profiling, install the
-python-profiler package from non-free.""")
-
-    def default_option(self,fn,optstr):
-        """Make an entry in the options_table for fn, with value optstr"""
-
-        if fn not in self.lsmagic():
-            error("%s is not a magic function" % fn)
-        self.options_table[fn] = optstr
-
-    def lsmagic(self):
-        """Return a list of currently available magic functions.
-
-        Gives a list of the bare names after mangling (['ls','cd', ...], not
-        ['magic_ls','magic_cd',...]"""
-
-        # FIXME. This needs a cleanup, in the way the magics list is built.
-        
-        # magics in class definition
-        class_magic = lambda fn: fn.startswith('magic_') and \
-                      callable(Magic.__dict__[fn])
-        # in instance namespace (run-time user additions)
-        inst_magic =  lambda fn: fn.startswith('magic_') and \
-                     callable(self.__dict__[fn])
-        # and bound magics by user (so they can access self):
-        inst_bound_magic =  lambda fn: fn.startswith('magic_') and \
-                           callable(self.__class__.__dict__[fn])
-        magics = filter(class_magic,Magic.__dict__.keys()) + \
-                 filter(inst_magic,self.__dict__.keys()) + \
-                 filter(inst_bound_magic,self.__class__.__dict__.keys())
-        out = []
-        for fn in set(magics):
-            out.append(fn.replace('magic_','',1))
-        out.sort()
-        return out
-    
-    def extract_input_lines(self, range_str, raw=False):
-        """Return as a string a set of input history slices.
-
-        Inputs:
-
-          - range_str: the set of slices is given as a string, like 
-          "~5/6-~4/2 4:8 9", since this function is for use by magic functions
-          which get their arguments as strings. The number before the / is the
-          session number: ~n goes n back from the current session.
-
-        Optional inputs:
-
-          - raw(False): by default, the processed input is used.  If this is
-          true, the raw input history is used instead.
-
-        Note that slices can be called with two notations:
-
-        N:M -> standard python form, means including items N...(M-1).
-
-        N-M -> include items N..M (closed endpoint)."""
-        lines = self.shell.history_manager.\
-                                    get_range_by_str(range_str, raw=raw)
-        return "\n".join(x for _, _, x in lines)
-            
-    def arg_err(self,func):
-        """Print docstring if incorrect arguments were passed"""
-        print 'Error in arguments:'
-        print oinspect.getdoc(func)
-
-    def format_latex(self,strng):
-        """Format a string for latex inclusion."""
-
-        # Characters that need to be escaped for latex:
-        escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
-        # Magic command names as headers:
-        cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
-                                 re.MULTILINE)
-        # Magic commands 
-        cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
-                            re.MULTILINE)
-        # Paragraph continue
-        par_re = re.compile(r'\\$',re.MULTILINE)
-
-        # The "\n" symbol
-        newline_re = re.compile(r'\\n')
-
-        # Now build the string for output:
-        #strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
-        strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
-                                strng)
-        strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
-        strng = par_re.sub(r'\\\\',strng)
-        strng = escape_re.sub(r'\\\1',strng)
-        strng = newline_re.sub(r'\\textbackslash{}n',strng)
-        return strng
-
-    def parse_options(self,arg_str,opt_str,*long_opts,**kw):
-        """Parse options passed to an argument string.
+import sys
+from getopt import getopt, GetoptError
 
-        The interface is similar to that of getopt(), but it returns back a
-        Struct with the options as keys and the stripped argument string still
-        as a string.
+from traitlets.config.configurable import Configurable
+from . import oinspect
+from .error import UsageError
+from .inputtransformer2 import ESC_MAGIC, ESC_MAGIC2
+from ..utils.ipstruct import Struct
+from ..utils.process import arg_split
+from ..utils.text import dedent
+from traitlets import Bool, Dict, Instance, observe
+from logging import error
 
-        arg_str is quoted as a true sys.argv vector by using shlex.split.
-        This allows us to easily expand variables, glob files, quote
-        arguments, etc.
+import typing as t
+from typing import Any, Callable, Literal, TypeVar, overload
 
-        Options:
-          -mode: default 'string'. If given as 'list', the argument string is
-          returned as a list (split on whitespace) instead of a string.
+if t.TYPE_CHECKING:
+    from types import FrameType
 
-          -list_all: put all option values in lists. Normally only options
-          appearing more than once are put in a list.
+    from IPython.core.interactiveshell import InteractiveShell
 
-          -posix (True): whether to split the input line in POSIX mode or not,
-          as per the conventions outlined in the shlex module from the
-          standard library."""
- 
-        # inject default options at the beginning of the input line
-        caller = sys._getframe(1).f_code.co_name.replace('magic_','')
-        arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
-        
-        mode = kw.get('mode','string')
-        if mode not in ['string','list']:
-            raise ValueError,'incorrect mode given: %s' % mode
-        # Get options
-        list_all = kw.get('list_all',0)
-        posix = kw.get('posix', os.name == 'posix')
+_F = TypeVar("_F", bound=Callable[..., Any])
+_MagicKind = Literal["line", "cell"]
+_MagicSpec = Literal["line", "cell", "line_cell"]
 
-        # Check if we have more than one argument to warrant extra processing:
-        odict = {}  # Dictionary with options
-        args = arg_str.split()
-        if len(args) >= 1:
-            # If the list of inputs only has 0 or 1 thing in it, there's no
-            # need to look for options
-            argv = arg_split(arg_str,posix)
-            # Do regular option processing
-            try:
-                opts,args = getopt(argv,opt_str,*long_opts)
-            except GetoptError,e:
-                raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str, 
-                                        " ".join(long_opts)))
-            for o,a in opts:
-                if o.startswith('--'):
-                    o = o[2:]
-                else:
-                    o = o[1:]
-                try:
-                    odict[o].append(a)
-                except AttributeError:
-                    odict[o] = [odict[o],a]
-                except KeyError:
-                    if list_all:
-                        odict[o] = [a]
-                    else:
-                        odict[o] = a
 
-        # Prepare opts,args for return
-        opts = Struct(odict)
-        if mode == 'string':
-            args = ' '.join(args)
-
-        return opts,args
-    
-    #......................................................................
-    # And now the actual magic functions
-
-    # Functions for IPython shell work (vars,funcs, config, etc)
-    def magic_lsmagic(self, parameter_s = ''):
-        """List currently available magic functions."""
-        mesc = ESC_MAGIC
-        print 'Available magic functions:\n'+mesc+\
-              ('  '+mesc).join(self.lsmagic())
-        print '\n' + Magic.auto_status[self.shell.automagic]
-        return None
-        
-    def magic_magic(self, parameter_s = ''):
-        """Print information about the magic function system.
-        
-        Supported formats: -latex, -brief, -rest        
-        """
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
 
-        mode = ''
-        try:
-            if parameter_s.split()[0] == '-latex':
-                mode = 'latex'
-            if parameter_s.split()[0] == '-brief':
-                mode = 'brief'
-            if parameter_s.split()[0] == '-rest':
-                mode = 'rest'
-                rest_docs = []
-        except:
-            pass
-
-        magic_docs = []
-        for fname in self.lsmagic():
-            mname = 'magic_' + fname
-            for space in (Magic,self,self.__class__):
-                try:
-                    fn = space.__dict__[mname]
-                except KeyError:
-                    pass
-                else:
-                    break
-            if mode == 'brief':
-                # only first line
-                if fn.__doc__:                    
-                    fndoc = fn.__doc__.split('\n',1)[0]
-                else:
-                    fndoc = 'No documentation'
-            else:
-                if fn.__doc__:
-                    fndoc = fn.__doc__.rstrip()       
-                else:
-                    fndoc = 'No documentation'
-                
-                
-            if mode == 'rest':
-                rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
-                                                    fname,fndoc))
-                
-            else:
-                magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
-                                                    fname,fndoc))
-                
-        magic_docs = ''.join(magic_docs)
-
-        if mode == 'rest':
-            return "".join(rest_docs)
-        
-        if mode == 'latex':
-            print self.format_latex(magic_docs)
-            return
-        else:
-            magic_docs = format_screen(magic_docs)
-        if mode == 'brief':
-            return magic_docs
-        
-        outmsg = """
-IPython's 'magic' functions
-===========================
-
-The magic function system provides a series of functions which allow you to
-control the behavior of IPython itself, plus a lot of system-type
-features. All these functions are prefixed with a % character, but parameters
-are given without parentheses or quotes.
-
-NOTE: If you have 'automagic' enabled (via the command line option or with the
-%automagic function), you don't need to type in the % explicitly.  By default,
-IPython ships with automagic on, so you should only rarely need the % escape.
+# A dict we'll use for each class that has magics, used as temporary storage to
+# pass information between the @line/cell_magic method decorators and the
+# @magics_class class decorator, because the method decorators have no
+# access to the class when they run.  See for more details:
+# http://stackoverflow.com/questions/2366713/can-a-python-decorator-of-an-instance-method-access-the-class
 
-Example: typing '%cd mydir' (without the quotes) changes you working directory
-to 'mydir', if it exists.
+magics: dict[str, dict[str, str]] = dict(line={}, cell={})
 
-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).
+magic_kinds: tuple[_MagicKind, ...] = ("line", "cell")
+magic_spec: tuple[_MagicSpec, ...] = ("line", "cell", "line_cell")
+magic_escapes: dict[_MagicKind, str] = dict(line=ESC_MAGIC, cell=ESC_MAGIC2)
 
-You can also define your own aliased names for magic functions. In your
-ipythonrc file, placing a line like:
+# -----------------------------------------------------------------------------
+# Utility classes and functions
+# -----------------------------------------------------------------------------
 
-  execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile
 
-will define %pf as a new name for %profile.
+class Bunch:
+    pass
 
-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?'.
+def compress_dhist(dh: list[str]) -> list[str]:
+    """Compress a directory history into a new one with at most 20 entries.
 
-Currently the magic system has the following functions:\n"""
-
-        mesc = ESC_MAGIC
-        outmsg = ("%s\n%s\n\nSummary of magic functions (from %slsmagic):"
-                  "\n\n%s%s\n\n%s" % (outmsg,
-                                     magic_docs,mesc,mesc,
-                                     ('  '+mesc).join(self.lsmagic()),
-                                     Magic.auto_status[self.shell.automagic] ) )
-        page.page(outmsg)
-
-    def magic_automagic(self, parameter_s = ''):
-        """Make magic functions callable without having to type the initial %.
-
-        Without argumentsl toggles on/off (when off, you must call it as
-        %automagic, of course).  With arguments it sets the value, and you can
-        use any of (case insensitive):
+    Return a new list made from the first and last 10 elements of dhist after
+    removal of duplicates.
+    """
+    head, tail = dh[:-10], dh[-10:]
 
-         - on,1,True: to activate
+    newhead: list[str] = []
+    done: set[str] = set()
+    for h in head:
+        if h in done:
+            continue
+        newhead.append(h)
+        done.add(h)
 
-         - off,0,False: to deactivate.
+    return newhead + tail
 
-        Note that magic functions have lowest priority, so if there's a
-        variable whose name collides with that of a magic fn, automagic won't
-        work for that function (you get the variable instead). However, if you
-        delete the variable (del var), the previously shadowed magic function
-        becomes visible to automagic again."""
 
-        arg = parameter_s.lower()
-        if parameter_s in ('on','1','true'):
-            self.shell.automagic = True
-        elif parameter_s in ('off','0','false'):
-            self.shell.automagic = False
-        else:
-            self.shell.automagic = not self.shell.automagic
-        print '\n' + Magic.auto_status[self.shell.automagic]
+def needs_local_scope(func: _F) -> _F:
+    """Decorator to mark magic functions which need to local scope to run."""
+    func.needs_local_scope = True  # type: ignore[attr-defined]
+    return func
 
-    @testdec.skip_doctest
-    def magic_autocall(self, parameter_s = ''):
-        """Make functions callable without having to type parentheses.
 
-        Usage:
+# -----------------------------------------------------------------------------
+# Class and method decorators for registering magics
+# -----------------------------------------------------------------------------
 
-           %autocall [mode]
 
-        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
-        value is toggled on and off (remembering the previous state).
+_T = TypeVar("_T", bound=type["Magics"])
 
-        In more detail, these values mean:
 
-        0 -> fully disabled
+def magics_class(cls: _T) -> _T:
+    """Class decorator for all subclasses of the main Magics class.
 
-        1 -> active, but do not apply if there are no arguments on the line.
+    Any class that subclasses Magics *must* also apply this decorator, to
+    ensure that all the methods that have been decorated as line/cell magics
+    get correctly registered in the class instance.  This is necessary because
+    when method decorators run, the class does not exist yet, so they
+    temporarily store their information into a module global.  Application of
+    this class decorator copies that global data to the class instance and
+    clears the global.
 
-        In this mode, you get:
+    Obviously, this mechanism is not thread-safe, which means that the
+    *creation* of subclasses of Magic should only be done in a single-thread
+    context.  Instantiation of the classes has no restrictions.  Given that
+    these classes are typically created at IPython startup time and before user
+    application code becomes active, in practice this should not pose any
+    problems.
+    """
+    cls.registered = True
+    cls.magics = dict(line=magics["line"], cell=magics["cell"])
+    magics["line"] = {}
+    magics["cell"] = {}
+    return cls
 
-        In [1]: callable
-        Out[1]: <built-in function callable>
 
-        In [2]: callable 'hello'
-        ------> callable('hello')
-        Out[2]: False
+def record_magic(
+    dct: dict[str, dict[str, Any]],
+    magic_kind: _MagicSpec,
+    magic_name: str,
+    func: Any,
+) -> None:
+    """Utility function to store a function as a magic of a specific kind.
 
-        2 -> Active always.  Even if no arguments are present, the callable
-        object is called:
+    Parameters
+    ----------
+    dct : dict
+        A dictionary with 'line' and 'cell' subdicts.
+    magic_kind : str
+        Kind of magic to be stored.
+    magic_name : str
+        Key to store the magic as.
+    func : function
+        Callable object to store.
+    """
+    if magic_kind == "line_cell":
+        dct["line"][magic_name] = dct["cell"][magic_name] = func
+    else:
+        dct[magic_kind][magic_name] = func
 
-        In [2]: float
-        ------> float()
-        Out[2]: 0.0
 
-        Note that even with autocall off, you can still use '/' at the start of
-        a line to treat the first argument on the command line as a function
-        and add parentheses to it:
+def validate_type(magic_kind: str) -> None:
+    """Ensure that the given magic_kind is valid.
 
-        In [8]: /str 43
-        ------> str(43)
-        Out[8]: '43'
+    Check that the given magic_kind is one of the accepted spec types (stored
+    in the global `magic_spec`), raise ValueError otherwise.
+    """
+    if magic_kind not in magic_spec:
+        raise ValueError(
+            "magic_kind must be one of %s, %s given" % magic_kinds, magic_kind
+        )
 
-        # all-random (note for auto-testing)
-        """
 
-        if parameter_s:
-            arg = int(parameter_s)
-        else:
-            arg = 'toggle'
-
-        if not arg in (0,1,2,'toggle'):
-            error('Valid modes: (0->Off, 1->Smart, 2->Full')
-            return
-
-        if arg in (0,1,2):
-            self.shell.autocall = arg
-        else: # toggle
-            if self.shell.autocall:
-                self._magic_state.autocall_save = self.shell.autocall
-                self.shell.autocall = 0
-            else:
-                try:
-                    self.shell.autocall = self._magic_state.autocall_save
-                except AttributeError:
-                    self.shell.autocall = self._magic_state.autocall_save = 1
+# The docstrings for the decorator below will be fairly similar for the two
+# types (method and function), so we generate them here once and reuse the
+# templates below.
+_docstring_template = """Decorate the given {0} as {1} magic.
 
-        print "Automatic calling is:",['OFF','Smart','Full'][self.shell.autocall]
+The decorator can be used with or without arguments, as follows.
 
+i) without arguments: it will create a {1} magic named as the {0} being
+decorated::
 
-    def magic_page(self, parameter_s=''):
-        """Pretty print the object and display it through a pager.
-        
-        %page [options] OBJECT
+    @deco
+    def foo(...)
 
-        If no object is given, use _ (last output).
-        
-        Options:
+will create a {1} magic named `foo`.
 
-          -r: page str(object), don't pretty-print it."""
+ii) with one string argument: which will be used as the actual name of the
+resulting magic::
 
-        # After a function contributed by Olivier Aubert, slightly modified.
+    @deco('bar')
+    def foo(...)
 
-        # Process options/args
-        opts,args = self.parse_options(parameter_s,'r')
-        raw = 'r' in opts
+will create a {1} magic named `bar`.
 
-        oname = args and args or '_'
-        info = self._ofind(oname)
-        if info['found']:
-            txt = (raw and str or pformat)( info['obj'] )
-            page.page(txt)
-        else:
-            print 'Object `%s` not found' % oname
+To register a class magic use ``Interactiveshell.register_magic(class or instance)``.
+"""
 
-    def magic_profile(self, parameter_s=''):
-        """Print your currently active IPython profile."""
-        if self.shell.profile:
-            printpl('Current IPython profile: $self.shell.profile.')
-        else:
-            print 'No profile active.'
-
-    def magic_pinfo(self, parameter_s='', namespaces=None):
-        """Provide detailed information about an object.
-    
-        '%pinfo object' is just a synonym for object? or ?object."""
-    
-        #print 'pinfo par: <%s>' % parameter_s  # dbg
-    
-        
-        # detail_level: 0 -> obj? , 1 -> obj??
-        detail_level = 0
-        # We need to detect if we got called as 'pinfo pinfo foo', which can
-        # happen if the user types 'pinfo foo?' at the cmd line.
-        pinfo,qmark1,oname,qmark2 = \
-               re.match('(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
-        if pinfo or qmark1 or qmark2:
-            detail_level = 1
-        if "*" in oname:
-            self.magic_psearch(oname)
-        else:
-            self.shell._inspect('pinfo', oname, detail_level=detail_level,
-                                namespaces=namespaces)
-
-    def magic_pinfo2(self, parameter_s='', namespaces=None):
-        """Provide extra detailed information about an object.
-    
-        '%pinfo2 object' is just a synonym for object?? or ??object."""
-        self.shell._inspect('pinfo', parameter_s, detail_level=1,
-                            namespaces=namespaces)
-
-    @testdec.skip_doctest
-    def magic_pdef(self, parameter_s='', namespaces=None):
-        """Print the definition header for any callable object.
-
-        If the object is a class, print the constructor information.
-        
-        Examples
-        --------
-        ::
-        
-          In [3]: %pdef urllib.urlopen
-          urllib.urlopen(url, data=None, proxies=None)
+# These two are decorator factories.  While they are conceptually very similar,
+# there are enough differences in the details that it's simpler to have them
+# written as completely standalone functions rather than trying to share code
+# and make a single one with convoluted logic.
+
+
+def _method_magic_marker(
+    magic_kind: _MagicSpec,
+) -> Callable[[_F | str], _F | Callable[[_F], _F]]:
+    """Decorator factory for methods in Magics subclasses."""
+
+    validate_type(magic_kind)
+
+    # This is a closure to capture the magic_kind.  We could also use a class,
+    # but it's overkill for just that one bit of state.
+    def magic_deco(arg: _F | str) -> _F | Callable[[_F], _F]:
+        retval: _F | Callable[[_F], _F]
+        if callable(arg):
+            # "Naked" decorator call (just @foo, no args)
+            func = arg
+            name = func.__name__
+            retval = arg
+            record_magic(magics, magic_kind, name, name)
+        elif isinstance(arg, str):
+            # Decorator called with arguments (@foo('bar'))
+            name = arg
+
+            def mark(func: _F, *a: Any, **kw: Any) -> _F:
+                record_magic(magics, magic_kind, name, func.__name__)
+                return func
+
+            retval = mark
+        else:
+            raise TypeError("Decorator can only be called with string or function")
+        return retval
+
+    # Ensure the resulting decorator has a usable docstring
+    magic_deco.__doc__ = _docstring_template.format("method", magic_kind)
+    return magic_deco
+
+
+def _function_magic_marker(
+    magic_kind: _MagicSpec,
+) -> Callable[[_F | str], _F | Callable[[_F], _F]]:
+    """Decorator factory for standalone functions."""
+    validate_type(magic_kind)
+
+    # This is a closure to capture the magic_kind.  We could also use a class,
+    # but it's overkill for just that one bit of state.
+    def magic_deco(arg: _F | str) -> _F | Callable[[_F], _F]:
+        # Find get_ipython() in the caller's namespace
+        caller: FrameType = sys._getframe(1)
+        get_ipython: Callable[[], InteractiveShell] | None = None
+        for ns in ["f_locals", "f_globals", "f_builtins"]:
+            get_ipython = getattr(caller, ns).get("get_ipython")
+            if get_ipython is not None:
+                break
+        else:
+            raise NameError(
+                "Decorator can only run in context where `get_ipython` exists"
+            )
+
+        ip: InteractiveShell = get_ipython()
+
+        retval: _F | Callable[[_F], _F]
+        if callable(arg):
+            # "Naked" decorator call (just @foo, no args)
+            func = arg
+            name = func.__name__
+            ip.register_magic_function(func, magic_kind, name)  # type: ignore[arg-type]
+            retval = arg
+        elif isinstance(arg, str):
+            # Decorator called with arguments (@foo('bar'))
+            name = arg
+
+            def mark(func: _F, *a: Any, **kw: Any) -> _F:
+                ip.register_magic_function(func, magic_kind, name)  # type: ignore[arg-type]
+                return func
+
+            retval = mark
+        else:
+            raise TypeError("Decorator can only be called with string or function")
+        return retval
+
+    # Ensure the resulting decorator has a usable docstring
+    ds = _docstring_template.format("function", magic_kind)
+
+    ds += dedent(
         """
-        self._inspect('pdef',parameter_s, namespaces)
-
-    def magic_pdoc(self, parameter_s='', namespaces=None):
-        """Print the docstring for an object.
+    Note: this decorator can only be used in a context where IPython is already
+    active, so that the `get_ipython()` call succeeds.  You can therefore use
+    it in your startup files loaded after IPython initializes, but *not* in the
+    IPython configuration file itself, which is executed before IPython is
+    fully up and running.  Any file located in the `startup` subdirectory of
+    your configuration profile will be OK in this sense.
+    """
+    )
 
-        If the given object is a class, it will print both the class and the
-        constructor docstrings."""
-        self._inspect('pdoc',parameter_s, namespaces)
+    magic_deco.__doc__ = ds
+    return magic_deco
 
-    def magic_psource(self, parameter_s='', namespaces=None):
-        """Print (or run through pager) the source code for an object."""
-        self._inspect('psource',parameter_s, namespaces)
 
-    def magic_pfile(self, parameter_s=''):
-        """Print (or run through pager) the file where an object is defined.
+MAGIC_NO_VAR_EXPAND_ATTR = "_ipython_magic_no_var_expand"
+MAGIC_OUTPUT_CAN_BE_SILENCED = "_ipython_magic_output_can_be_silenced"
 
-        The file opens at the line where the object definition begins. IPython
-        will honor the environment variable PAGER if set, and otherwise will
-        do its best to print the file in a convenient form.
 
-        If the given argument is not an object currently defined, IPython will
-        try to interpret it as a filename (automatically adding a .py extension
-        if needed). You can thus use %pfile as a syntax highlighting code
-        viewer."""
-
-        # first interpret argument as an object name
-        out = self._inspect('pfile',parameter_s)
-        # if not, try the input as a filename
-        if out == 'not found':
-            try:
-                filename = get_py_filename(parameter_s)
-            except IOError,msg:
-                print msg
-                return
-            page.page(self.shell.inspector.format(file(filename).read()))
-
-    def magic_psearch(self, parameter_s=''):
-        """Search for object in namespaces by wildcard.
-
-        %psearch [options] PATTERN [OBJECT TYPE]
-
-        Note: ? can be used as a synonym for %psearch, at the beginning or at
-        the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
-        rest of the command line must be unchanged (options come first), so
-        for example the following forms are equivalent
-
-        %psearch -i a* function
-        -i a* function?
-        ?-i a* function
-
-        Arguments:
-        
-          PATTERN
-
-          where PATTERN is a string containing * as a wildcard similar to its
-          use in a shell.  The pattern is matched in all namespaces on the
-          search path. By default objects starting with a single _ are not
-          matched, many IPython generated objects have a single
-          underscore. The default is case insensitive matching. Matching is
-          also done on the attributes of objects and not only on the objects
-          in a module.
-
-          [OBJECT TYPE]
-
-          Is the name of a python type from the types module. The name is
-          given in lowercase without the ending type, ex. StringType is
-          written string. By adding a type here only objects matching the
-          given type are matched. Using all here makes the pattern match all
-          types (this is the default).
-
-        Options:
-
-          -a: makes the pattern match even objects whose names start with a
-          single underscore.  These names are normally ommitted from the
-          search.
-
-          -i/-c: make the pattern case insensitive/sensitive.  If neither of
-          these options is given, the default is read from your ipythonrc
-          file.  The option name which sets this value is
-          'wildcards_case_sensitive'.  If this option is not specified in your
-          ipythonrc file, IPython's internal default is to do a case sensitive
-          search.
-
-          -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
-          specifiy can be searched in any of the following namespaces:
-          'builtin', 'user', 'user_global','internal', 'alias', where
-          'builtin' and 'user' are the search defaults.  Note that you should
-          not use quotes when specifying namespaces.
-
-          'Builtin' contains the python module builtin, 'user' contains all
-          user data, 'alias' only contain the shell aliases and no python
-          objects, 'internal' contains objects used by IPython.  The
-          'user_global' namespace is only used by embedded IPython instances,
-          and it contains module-level globals.  You can add namespaces to the
-          search with -s or exclude them with -e (these options can be given
-          more than once).
-    
-        Examples:
-       
-        %psearch a*            -> objects beginning with an a
-        %psearch -e builtin a* -> objects NOT in the builtin space starting in a
-        %psearch a* function   -> all functions beginning with an a
-        %psearch re.e*         -> objects beginning with an e in module re
-        %psearch r*.e*         -> objects that start with e in modules starting in r
-        %psearch r*.* string   -> all strings in modules beginning with r
-
-        Case sensitve search:
-       
-        %psearch -c a*         list all object beginning with lower case a
-
-        Show objects beginning with a single _:
-       
-        %psearch -a _*         list objects beginning with a single underscore"""
-        try:
-            parameter_s = parameter_s.encode('ascii')
-        except UnicodeEncodeError:
-            print 'Python identifiers can only contain ascii characters.'
-            return
-
-        # default namespaces to be searched
-        def_search = ['user','builtin']
-
-        # Process options/args
-        opts,args = self.parse_options(parameter_s,'cias:e:',list_all=True)
-        opt = opts.get
-        shell = self.shell
-        psearch = shell.inspector.psearch
-
-        # select case options
-        if opts.has_key('i'):
-            ignore_case = True
-        elif opts.has_key('c'):
-            ignore_case = False
-        else:
-            ignore_case = not shell.wildcards_case_sensitive
-
-        # Build list of namespaces to search from user options
-        def_search.extend(opt('s',[]))
-        ns_exclude = ns_exclude=opt('e',[])
-        ns_search = [nm for nm in def_search if nm not in ns_exclude]
-        
-        # Call the actual search
-        try:
-            psearch(args,shell.ns_table,ns_search,
-                    show_all=opt('a'),ignore_case=ignore_case)
-        except:
-            shell.showtraceback()
-        
-    @testdec.skip_doctest
-    def magic_who_ls(self, parameter_s=''):
-        """Return a sorted list of all interactive variables.
+def no_var_expand(magic_func: _F) -> _F:
+    """Mark a magic function as not needing variable expansion
 
-        If arguments are given, only variables of types matching these
-        arguments are returned.
+    By default, IPython interprets `{a}` or `$a` in the line passed to magics
+    as variables that should be interpolated from the interactive namespace
+    before passing the line to the magic function.
+    This is not always desirable, e.g. when the magic executes Python code
+    (%timeit, %time, etc.).
+    Decorate magics with `@no_var_expand` to opt-out of variable expansion.
 
-        Examples
-        --------
+    .. versionadded:: 7.3
+    """
+    setattr(magic_func, MAGIC_NO_VAR_EXPAND_ATTR, True)
+    return magic_func
+
+
+def output_can_be_silenced(magic_func: _F) -> _F:
+    """Mark a magic function so its output may be silenced.
+
+    The output is silenced if the Python code used as a parameter of
+    the magic ends in a semicolon, not counting a Python comment that can
+    follow it.
+    """
+    setattr(magic_func, MAGIC_OUTPUT_CAN_BE_SILENCED, True)
+    return magic_func
+
+
+# Create the actual decorators for public use
+
+# These three are used to decorate methods in class definitions
+line_magic = _method_magic_marker("line")
+cell_magic = _method_magic_marker("cell")
+line_cell_magic = _method_magic_marker("line_cell")
+
+# These three decorate standalone functions and perform the decoration
+# immediately.  They can only run where get_ipython() works
+register_line_magic = _function_magic_marker("line")
+register_cell_magic = _function_magic_marker("cell")
+register_line_cell_magic = _function_magic_marker("line_cell")
+
+# -----------------------------------------------------------------------------
+# Core Magic classes
+# -----------------------------------------------------------------------------
+
+
+class MagicsManager(Configurable):
+    """Object that handles all magic-related functionality for IPython."""
+
+    # Non-configurable class attributes
+
+    # A two-level dict, first keyed by magic type, then by magic function, and
+    # holding the actual callable object as value.  This is the dict used for
+    # magic function dispatch
+    magics = Dict()
+    lazy_magics = Dict(
+        help="""
+    Mapping from magic names to modules to load.
+
+    This can be used in IPython/IPykernel configuration to declare lazy magics
+    that will only be imported/registered on first use.
+
+    For example::
+
+        c.MagicsManager.lazy_magics = {
+          "my_magic": "slow.to.import",
+          "my_other_magic": "also.slow",
+        }
+
+    On first invocation of `%my_magic`, `%%my_magic`, `%%my_other_magic` or
+    `%%my_other_magic`, the corresponding module will be loaded as an ipython
+    extensions as if you had previously done `%load_ext ipython`.
+
+    Magics names should be without percent(s) as magics can be both cell
+    and line magics.
+
+    Lazy loading happen relatively late in execution process, and
+    complex extensions that manipulate Python/IPython internal state or global state
+    might not support lazy loading.
+    """
+    ).tag(
+        config=True,
+    )
+
+    # A registry of the original objects that we've been given holding magics.
+    registry = Dict()
+
+    shell = Instance(
+        "IPython.core.interactiveshell.InteractiveShellABC", allow_none=True
+    )
 
-        Define two variables and list them with who_ls::
+    auto_magic = Bool(
+        True, help="Automatically call line magics without requiring explicit % prefix"
+    ).tag(config=True)
 
-          In [1]: alpha = 123
-
-          In [2]: beta = 'test'
-
-          In [3]: %who_ls
-          Out[3]: ['alpha', 'beta']
-
-          In [4]: %who_ls int
-          Out[4]: ['alpha']
-
-          In [5]: %who_ls str
-          Out[5]: ['beta']
+    @observe("auto_magic")
+    def _auto_magic_changed(self, change: dict[str, Any]) -> None:
+        assert self.shell is not None
+        self.shell.automagic = change["new"]
+
+    _auto_status = [
+        "Automagic is OFF, % prefix IS needed for line magics.",
+        "Automagic is ON, % prefix IS NOT needed for line magics.",
+    ]
+
+    user_magics = Instance("IPython.core.magics.UserMagics", allow_none=True)
+
+    def __init__(
+        self,
+        shell: InteractiveShell | None = None,
+        config: Any = None,
+        user_magics: Magics | None = None,
+        **traits: Any,
+    ) -> None:
+        super(MagicsManager, self).__init__(
+            shell=shell, config=config, user_magics=user_magics, **traits
+        )
+        self.magics = dict(line={}, cell={})
+        # Let's add the user_magics to the registry for uniformity, so *all*
+        # registered magic containers can be found there.
+        if user_magics is not None:
+            self.registry[user_magics.__class__.__name__] = user_magics
+
+    def auto_status(self) -> str:
+        """Return descriptive string with automagic status."""
+        return self._auto_status[self.auto_magic]
+
+    def lsmagic(self) -> dict[str, dict[str, Any]]:
+        """Return a dict of currently available magic functions.
+
+        The return dict has the keys 'line' and 'cell', corresponding to the
+        two types of magics we support.  Each value is a list of names.
         """
+        return self.magics
 
-        user_ns = self.shell.user_ns
-        internal_ns = self.shell.internal_ns
-        user_ns_hidden = self.shell.user_ns_hidden
-        out = [ i for i in user_ns
-                if not i.startswith('_') \
-                and not (i in internal_ns or i in user_ns_hidden) ]
-
-        typelist = parameter_s.split()
-        if typelist:
-            typeset = set(typelist)
-            out = [i for i in out if type(user_ns[i]).__name__ in typeset]
-
-        out.sort()
-        return out
-        
-    @testdec.skip_doctest
-    def magic_who(self, parameter_s=''):
-        """Print all interactive variables, with some minimal formatting.
-
-        If any arguments are given, only variables whose type matches one of
-        these are printed.  For example:
-
-          %who function str
-
-        will only list functions and strings, excluding all other types of
-        variables.  To find the proper type names, simply use type(var) at a
-        command line to see how python prints type names.  For example:
-
-          In [1]: type('hello')\\
-          Out[1]: <type 'str'>
-
-        indicates that the type name for strings is 'str'.
+    def lsmagic_docs(
+        self, brief: bool = False, missing: str = ""
+    ) -> dict[str, dict[str, str]]:
+        """Return dict of documentation of magic functions.
 
-        %who always excludes executed names loaded through your configuration
-        file and things which are internal to IPython.
+        The return dict has the keys 'line' and 'cell', corresponding to the
+        two types of magics we support. Each value is a dict keyed by magic
+        name whose value is the function docstring. If a docstring is
+        unavailable, the value of `missing` is used instead.
 
-        This is deliberate, as typically you may load many modules and the
-        purpose of %who is to show you only what you've manually defined.
-
-        Examples
-        --------
-
-        Define two variables and list them with who::
-
-          In [1]: alpha = 123
-
-          In [2]: beta = 'test'
-
-          In [3]: %who
-          alpha   beta
-
-          In [4]: %who int
-          alpha
-
-          In [5]: %who str
-          beta
+        If brief is True, only the first line of each docstring will be returned.
         """
+        docs: dict[str, dict[str, str]] = {}
+        for m_type in self.magics:
+            m_docs: dict[str, str] = {}
+            for m_name, m_func in self.magics[m_type].items():
+                if m_func.__doc__:
+                    if brief:
+                        m_docs[m_name] = m_func.__doc__.split("\n", 1)[0]
+                    else:
+                        m_docs[m_name] = m_func.__doc__.rstrip()
+                else:
+                    m_docs[m_name] = missing
+            docs[m_type] = m_docs
+        return docs
 
-        varlist = self.magic_who_ls(parameter_s)
-        if not varlist:
-            if parameter_s:
-                print 'No variables match your requested type.'
-            else:
-                print 'Interactive namespace is empty.'
-            return
-
-        # if we have variables, move on...
-        count = 0
-        for i in varlist:
-            print i+'\t',
-            count += 1
-            if count > 8:
-                count = 0
-                print
-        print
-
-    @testdec.skip_doctest
-    def magic_whos(self, parameter_s=''):
-        """Like %who, but gives some extra information about each variable.
-
-        The same type filtering of %who can be applied here.
-
-        For all variables, the type is printed. Additionally it prints:
-        
-          - For {},[],(): their length.
-
-          - For numpy arrays, a summary with shape, number of
-          elements, typecode and size in memory.
-
-          - Everything else: a string representation, snipping their middle if
-          too long.
-
-        Examples
-        --------
-
-        Define two variables and list them with whos::
-
-          In [1]: alpha = 123
-
-          In [2]: beta = 'test'
-
-          In [3]: %whos
-          Variable   Type        Data/Info
-          --------------------------------
-          alpha      int         123
-          beta       str         test
+    def register_lazy(self, name: str, fully_qualified_name: str) -> None:
         """
-        
-        varnames = self.magic_who_ls(parameter_s)
-        if not varnames:
-            if parameter_s:
-                print 'No variables match your requested type.'
-            else:
-                print 'Interactive namespace is empty.'
-            return
-
-        # if we have variables, move on...
-
-        # for these types, show len() instead of data:
-        seq_types = ['dict', 'list', 'tuple']
+        Lazily register a magic via an extension.
 
-        # for numpy/Numeric arrays, display summary info
-        try:
-            import numpy
-        except ImportError:
-            ndarray_type = None
-        else:
-            ndarray_type = numpy.ndarray.__name__
-        try:
-            import Numeric
-        except ImportError:
-            array_type = None
-        else:
-            array_type = Numeric.ArrayType.__name__
-
-        # Find all variable names and types so we can figure out column sizes
-        def get_vars(i):
-            return self.shell.user_ns[i]
-        
-        # some types are well known and can be shorter
-        abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
-        def type_name(v):
-            tn = type(v).__name__
-            return abbrevs.get(tn,tn)
-            
-        varlist = map(get_vars,varnames)
-
-        typelist = []
-        for vv in varlist:
-            tt = type_name(vv)
-
-            if tt=='instance':
-                typelist.append( abbrevs.get(str(vv.__class__),
-                                             str(vv.__class__)))
-            else:
-                typelist.append(tt)
-
-        # column labels and # of spaces as separator
-        varlabel = 'Variable'
-        typelabel = 'Type'
-        datalabel = 'Data/Info'
-        colsep = 3
-        # variable format strings
-        vformat    = "$vname.ljust(varwidth)$vtype.ljust(typewidth)"
-        vfmt_short = '$vstr[:25]<...>$vstr[-25:]'
-        aformat    = "%s: %s elems, type `%s`, %s bytes"
-        # find the size of the columns to format the output nicely
-        varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
-        typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
-        # table header
-        print varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
-              ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1)
-        # and the table itself
-        kb = 1024
-        Mb = 1048576  # kb**2
-        for vname,var,vtype in zip(varnames,varlist,typelist):
-            print itpl(vformat),
-            if vtype in seq_types:
-                print "n="+str(len(var))
-            elif vtype in [array_type,ndarray_type]:
-                vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
-                if vtype==ndarray_type:
-                    # numpy
-                    vsize  = var.size
-                    vbytes = vsize*var.itemsize
-                    vdtype = var.dtype
-                else:
-                    # Numeric
-                    vsize  = Numeric.size(var)
-                    vbytes = vsize*var.itemsize()
-                    vdtype = var.typecode()
-                    
-                if vbytes < 100000:
-                    print aformat % (vshape,vsize,vdtype,vbytes)
-                else:
-                    print aformat % (vshape,vsize,vdtype,vbytes),
-                    if vbytes < Mb:
-                        print '(%s kb)' % (vbytes/kb,)
-                    else:
-                        print '(%s Mb)' % (vbytes/Mb,)
-            else:
-                try:
-                    vstr = str(var)
-                except UnicodeEncodeError:
-                    vstr = unicode(var).encode(sys.getdefaultencoding(),
-                                               'backslashreplace')
-                vstr = vstr.replace('\n','\\n')
-                if len(vstr) < 50:
-                    print vstr
-                else:
-                    printpl(vfmt_short)
-                
-    def magic_reset(self, parameter_s=''):
-        """Resets the namespace by removing all names defined by the user.
 
         Parameters
         ----------
-          -f : force reset without asking for confirmation.
-          
-          -s : 'Soft' reset: Only clears your namespace, leaving history intact.
-          References to objects may be kept. By default (without this option),
-          we do a 'hard' reset, giving you a new session and removing all
-          references to objects from the current session.
-        
-        Examples
-        --------
-        In [6]: a = 1
-
-        In [7]: a
-        Out[7]: 1
-
-        In [8]: 'a' in _ip.user_ns
-        Out[8]: True
-
-        In [9]: %reset -f
-
-        In [1]: 'a' in _ip.user_ns
-        Out[1]: False
+        name : str
+            Name of the magic you wish to register.
+        fully_qualified_name :
+            Fully qualified name of the module/submodule that should be loaded
+            as an extensions when the magic is first called.
+            It is assumed that loading this extensions will register the given
+            magic.
         """
-        opts, args = self.parse_options(parameter_s,'sf')
-        if 'f' in opts:
-            ans = True
-        else:
-            ans = self.shell.ask_yes_no(
-                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
-        if not ans:
-            print 'Nothing done.'
-            return
-        
-        if 's' in opts:                     # Soft reset
-            user_ns = self.shell.user_ns
-            for i in self.magic_who_ls():
-                del(user_ns[i])
-            
-        else:                     # Hard reset
-            self.shell.reset(new_session = False)
-            
-        
-
-    def magic_reset_selective(self, parameter_s=''):
-        """Resets the namespace by removing names defined by the user.
-
-        Input/Output history are left around in case you need them.
-
-        %reset_selective [-f] regex
-
-        No action is taken if regex is not included
-        
-        Options
-          -f : force reset without asking for confirmation.
-
-        Examples
-        --------
-
-        We first fully reset the namespace so your output looks identical to
-        this example for pedagogical reasons; in practice you do not need a
-        full reset.
-        
-        In [1]: %reset -f
 
-        Now, with a clean namespace we can make a few variables and use
-        %reset_selective to only delete names that match our regexp:
+        self.lazy_magics[name] = fully_qualified_name
 
-        In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
+    def register(self, *magic_objects: type[Magics] | Magics) -> None:
+        """Register one or more instances of Magics.
 
-        In [3]: who_ls
-        Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
+        Take one or more classes or instances of classes that subclass the main
+        `core.Magic` class, and register them with IPython to use the magic
+        functions they provide.  The registration process will then ensure that
+        any methods that have decorated to provide line and/or cell magics will
+        be recognized with the `%x`/`%%x` syntax as a line/cell magic
+        respectively.
 
-        In [4]: %reset_selective -f b[2-3]m
+        If classes are given, they will be instantiated with the default
+        constructor.  If your classes need a custom constructor, you should
+        instanitate them first and pass the instance.
 
-        In [5]: who_ls
-        Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+        The provided arguments can be an arbitrary mix of classes and instances.
 
-        In [6]: %reset_selective -f d
-
-        In [7]: who_ls
-        Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
-
-        In [8]: %reset_selective -f c
-
-        In [9]: who_ls
-        Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
-
-        In [10]: %reset_selective -f b
-
-        In [11]: who_ls
-        Out[11]: ['a']
+        Parameters
+        ----------
+        *magic_objects : one or more classes or instances
         """
-        
-        opts, regex = self.parse_options(parameter_s,'f')
-        
-        if opts.has_key('f'):
-            ans = True
-        else:
-            ans = self.shell.ask_yes_no(
-                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ")
-        if not ans:
-            print 'Nothing done.'
-            return
-        user_ns = self.shell.user_ns
-        if not regex:
-            print 'No regex pattern specified. Nothing done.'
-            return
-        else:
-            try:
-                m = re.compile(regex)
-            except TypeError:
-                raise TypeError('regex must be a string or compiled pattern')
-            for i in self.magic_who_ls():
-                if m.search(i): 
-                    del(user_ns[i])        
-        
-    def magic_logstart(self,parameter_s=''):
-        """Start logging anywhere in a session.
-
-        %logstart [-o|-r|-t] [log_name [log_mode]]
-
-        If no name is given, it defaults to a file named 'ipython_log.py' in your
-        current directory, in 'rotate' mode (see below).
-
-        '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
-        history up to that point and then continues logging.
-
-        %logstart takes a second optional parameter: logging mode. This can be one
-        of (note that the modes are given unquoted):\\
-          append: well, that says it.\\
-          backup: rename (if exists) to name~ and start name.\\
-          global: single logfile in your home dir, appended to.\\
-          over  : overwrite existing log.\\
-          rotate: create rotating logs name.1~, name.2~, etc.
-
-        Options:
-
-          -o: log also IPython's output.  In this mode, all commands which
-          generate an Out[NN] prompt are recorded to the logfile, right after
-          their corresponding input line.  The output lines are always
-          prepended with a '#[Out]# ' marker, so that the log remains valid
-          Python code.
-
-          Since this marker is always the same, filtering only the output from
-          a log is very easy, using for example a simple awk call:
-
-            awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
-
-          -r: log 'raw' input.  Normally, IPython's logs contain the processed
-          input, so that user lines are logged in their final form, converted
-          into valid Python.  For example, %Exit is logged as
-          '_ip.magic("Exit").  If the -r flag is given, all input is logged
-          exactly as typed, with no transformations applied.
-
-          -t: put timestamps before each input line logged (these are put in
-          comments)."""
-        
-        opts,par = self.parse_options(parameter_s,'ort')
-        log_output = 'o' in opts
-        log_raw_input = 'r' in opts
-        timestamp = 't' in opts
-
-        logger = self.shell.logger
-
-        # if no args are given, the defaults set in the logger constructor by
-        # ipytohn remain valid
-        if par:
-            try:
-                logfname,logmode = par.split()
-            except:
-                logfname = par
-                logmode = 'backup'
-        else:
-            logfname = logger.logfname
-            logmode = logger.logmode
-        # put logfname into rc struct as if it had been called on the command
-        # line, so it ends up saved in the log header Save it in case we need
-        # to restore it...
-        old_logfile = self.shell.logfile
-        if logfname:
-            logfname = os.path.expanduser(logfname)
-        self.shell.logfile = logfname
-
-        loghead = '# IPython log file\n\n'
-        try:
-            started  = logger.logstart(logfname,loghead,logmode,
-                                       log_output,timestamp,log_raw_input)
-        except:
-            self.shell.logfile = old_logfile
-            warn("Couldn't start log: %s" % sys.exc_info()[1])
-        else:
-            # log input history up to this point, optionally interleaving
-            # output if requested
-
-            if timestamp:
-                # disable timestamping for the previous history, since we've
-                # lost those already (no time machine here).
-                logger.timestamp = False
-
-            if log_raw_input:
-                input_hist = self.shell.history_manager.input_hist_raw
-            else:
-                input_hist = self.shell.history_manager.input_hist_parsed
-                
-            if log_output:
-                log_write = logger.log_write
-                output_hist = self.shell.history_manager.output_hist
-                for n in range(1,len(input_hist)-1):
-                    log_write(input_hist[n].rstrip())
-                    if n in output_hist:
-                        log_write(repr(output_hist[n]),'output')
-            else:
-                logger.log_write(''.join(input_hist[1:]))
-            if timestamp:
-                # re-enable timestamping
-                logger.timestamp = True
-                
-            print ('Activating auto-logging. '
-                   'Current session state plus future input saved.')
-            logger.logstate()
-
-    def magic_logstop(self,parameter_s=''):
-        """Fully stop logging and close log file.
-
-        In order to start logging again, a new %logstart call needs to be made,
-        possibly (though not necessarily) with a new filename, mode and other
-        options."""
-        self.logger.logstop()
-
-    def magic_logoff(self,parameter_s=''):
-        """Temporarily stop logging.
-
-        You must have previously started logging."""
-        self.shell.logger.switch_log(0)
-        
-    def magic_logon(self,parameter_s=''):
-        """Restart logging.
-
-        This function is for restarting logging which you've temporarily
-        stopped with %logoff. For starting logging for the first time, you
-        must use the %logstart function, which allows you to specify an
-        optional log filename."""
-        
-        self.shell.logger.switch_log(1)
-    
-    def magic_logstate(self,parameter_s=''):
-        """Print the status of the logging system."""
-
-        self.shell.logger.logstate()
-        
-    def magic_pdb(self, parameter_s=''):
-        """Control the automatic calling of the pdb interactive debugger.
-
-        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
-        argument it works as a toggle.
-
-        When an exception is triggered, IPython can optionally call the
-        interactive pdb debugger after the traceback printout. %pdb toggles
-        this feature on and off.
-
-        The initial state of this feature is set in your ipythonrc
-        configuration file (the variable is called 'pdb').
-
-        If you want to just activate the debugger AFTER an exception has fired,
-        without having to type '%pdb on' and rerunning your code, you can use
-        the %debug magic."""
-
-        par = parameter_s.strip().lower()
-
-        if par:
-            try:
-                new_pdb = {'off':0,'0':0,'on':1,'1':1}[par]
-            except KeyError:
-                print ('Incorrect argument. Use on/1, off/0, '
-                       'or nothing for a toggle.')
-                return
-        else:
-            # toggle
-            new_pdb = not self.shell.call_pdb
-
-        # set on the shell
-        self.shell.call_pdb = new_pdb
-        print 'Automatic pdb calling has been turned',on_off(new_pdb)
+        # Start by validating them to ensure they have all had their magic
+        # methods registered at the instance level
+        for m in magic_objects:
+            if not m.registered:
+                raise ValueError(
+                    "Class of magics %r was constructed without "
+                    "the @register_magics class decorator"
+                )
+            if isinstance(m, type):
+                # If we're given an uninstantiated class
+                m = m(shell=self.shell)
+
+            # Now that we have an instance, we can register it and update the
+            # table of callables
+            self.registry[m.__class__.__name__] = m
+            for mtype in magic_kinds:
+                self.magics[mtype].update(m.magics[mtype])
+
+    def register_function(
+        self,
+        func: Callable[..., Any],
+        magic_kind: _MagicSpec = "line",
+        magic_name: str | None = None,
+    ) -> None:
+        """Expose a standalone function as magic function for IPython.
+
+        This will create an IPython magic (line, cell or both) from a
+        standalone function.  The functions should have the following
+        signatures:
+
+        * For line magics: `def f(line)`
+        * For cell magics: `def f(line, cell)`
+        * For a function that does both: `def f(line, cell=None)`
+
+        In the latter case, the function will be called with `cell==None` when
+        invoked as `%f`, and with cell as a string when invoked as `%%f`.
 
-    def magic_debug(self, parameter_s=''):
-        """Activate the interactive debugger in post-mortem mode.
+        Parameters
+        ----------
+        func : callable
+            Function to be registered as a magic.
+        magic_kind : str
+            Kind of magic, one of 'line', 'cell' or 'line_cell'
+        magic_name : optional str
+            If given, the name the magic will have in the IPython namespace. By
+            default, the name of the function itself is used.
+        """
 
-        If an exception has just occurred, this lets you inspect its stack
-        frames interactively.  Note that this will always work only on the last
-        traceback that occurred, so you must call this quickly after an
-        exception that you wish to inspect has fired, because if another one
-        occurs, it clobbers the previous one.
+        # Create the new method in the user_magics and register it in the
+        # global table
+        validate_type(magic_kind)
+        magic_name = func.__name__ if magic_name is None else magic_name
+        assert self.user_magics is not None
+        setattr(self.user_magics, magic_name, func)
+        record_magic(self.magics, magic_kind, magic_name, func)
+
+    def register_alias(
+        self,
+        alias_name: str,
+        magic_name: str,
+        magic_kind: _MagicKind = "line",
+        magic_params: str | None = None,
+    ) -> None:
+        """Register an alias to a magic function.
+
+        The alias is an instance of :class:`MagicAlias`, which holds the
+        name and kind of the magic it should call. Binding is done at
+        call time, so if the underlying magic function is changed the alias
+        will call the new function.
 
-        If you want IPython to automatically do this on every exception, see
-        the %pdb magic for more details.
-        """
-        self.shell.debugger(force=True)
-
-    @testdec.skip_doctest
-    def magic_prun(self, parameter_s ='',user_mode=1,
-                   opts=None,arg_lst=None,prog_ns=None):
-
-        """Run a statement through the python code profiler.
-
-        Usage:
-          %prun [options] statement
-
-        The given statement (which doesn't require quote marks) is run via the
-        python profiler in a manner similar to the profile.run() function.
-        Namespaces are internally managed to work correctly; profile.run
-        cannot be used in IPython because it makes certain assumptions about
-        namespaces which do not hold under IPython.
-
-        Options:
-
-        -l <limit>: you can place restrictions on what or how much of the
-        profile gets printed. The limit value can be:
-
-          * A string: only information for function names containing this string
-          is printed.
-
-          * An integer: only these many lines are printed.
-
-          * A float (between 0 and 1): this fraction of the report is printed
-          (for example, use a limit of 0.4 to see the topmost 40% only).
-
-        You can combine several limits with repeated use of the option. For
-        example, '-l __init__ -l 5' will print only the topmost 5 lines of
-        information about class constructors.
-
-        -r: return the pstats.Stats object generated by the profiling. This
-        object has all the information about the profile in it, and you can
-        later use it for further analysis or in other functions.
-
-       -s <key>: sort profile by given key. You can provide more than one key
-        by using the option several times: '-s key1 -s key2 -s key3...'. The
-        default sorting key is 'time'.
-
-        The following is copied verbatim from the profile documentation
-        referenced below:
-
-        When more than one key is provided, additional keys are used as
-        secondary criteria when the there is equality in all keys selected
-        before them.
-        
-        Abbreviations can be used for any key names, as long as the
-        abbreviation is unambiguous.  The following are the keys currently
-        defined:
-
-                Valid Arg       Meaning
-                  "calls"      call count
-                  "cumulative" cumulative time
-                  "file"       file name
-                  "module"     file name
-                  "pcalls"     primitive call count
-                  "line"       line number
-                  "name"       function name
-                  "nfl"        name/file/line
-                  "stdname"    standard name
-                  "time"       internal time
-
-        Note that all sorts on statistics are in descending order (placing
-        most time consuming items first), where as name, file, and line number
-        searches are in ascending order (i.e., alphabetical). The subtle
-        distinction between "nfl" and "stdname" is that the standard name is a
-        sort of the name as printed, which means that the embedded line
-        numbers get compared in an odd way.  For example, lines 3, 20, and 40
-        would (if the file names were the same) appear in the string order
-        "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
-        line numbers.  In fact, sort_stats("nfl") is the same as
-        sort_stats("name", "file", "line").
-
-        -T <filename>: save profile results as shown on screen to a text
-        file. The profile is still shown on screen.
-
-        -D <filename>: save (via dump_stats) profile statistics to given
-        filename. This data is in a format understod by the pstats module, and
-        is generated by a call to the dump_stats() method of profile
-        objects. The profile is still shown on screen.
-
-        If you want to run complete programs under the profiler's control, use
-        '%run -p [prof_opts] filename.py [args to program]' where prof_opts
-        contains profiler specific options as described here.
-        
-        You can read the complete documentation for the profile module with::
-        
-          In [1]: import profile; profile.help()
+        Parameters
+        ----------
+        alias_name : str
+            The name of the magic to be registered.
+        magic_name : str
+            The name of an existing magic.
+        magic_kind : str
+            Kind of magic, one of 'line' or 'cell'
         """
 
-        opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
-        # protect user quote marks
-        parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
-        
-        if user_mode:  # regular user call
-            opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
-                                              list_all=1)
-            namespace = self.shell.user_ns
-        else:  # called to run a program by %run -p
-            try:
-                filename = get_py_filename(arg_lst[0])
-            except IOError,msg:
-                error(msg)
-                return
+        # `validate_type` is too permissive, as it allows 'line_cell'
+        # which we do not handle.
+        if magic_kind not in magic_kinds:
+            raise ValueError(
+                "magic_kind must be one of %s, %s given" % magic_kinds, magic_kind
+            )
 
-            arg_str = 'execfile(filename,prog_ns)'
-            namespace = locals()
+        assert self.shell is not None
+        assert self.user_magics is not None
+        alias = MagicAlias(self.shell, magic_name, magic_kind, magic_params)
+        setattr(self.user_magics, alias_name, alias)
+        record_magic(self.magics, magic_kind, alias_name, alias)
 
-        opts.merge(opts_def)
-        
-        prof = profile.Profile()
-        try:
-            prof = prof.runctx(arg_str,namespace,namespace)
-            sys_exit = ''
-        except SystemExit:
-            sys_exit = """*** SystemExit exception caught in code being profiled."""
 
-        stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
+# Key base class that provides the central functionality for magics.
 
-        lims = opts.l
-        if lims:
-            lims = []  # rebuild lims with ints/floats/strings
-            for lim in opts.l:
-                try:
-                    lims.append(int(lim))
-                except ValueError:
-                    try:
-                        lims.append(float(lim))
-                    except ValueError:
-                        lims.append(lim)
-                    
-        # Trap output.
-        stdout_trap = StringIO()
-
-        if hasattr(stats,'stream'):
-            # In newer versions of python, the stats object has a 'stream'
-            # attribute to write into.
-            stats.stream = stdout_trap
-            stats.print_stats(*lims)
-        else:
-            # For older versions, we manually redirect stdout during printing
-            sys_stdout = sys.stdout
-            try:
-                sys.stdout = stdout_trap
-                stats.print_stats(*lims)
-            finally:
-                sys.stdout = sys_stdout
-                
-        output = stdout_trap.getvalue()
-        output = output.rstrip()
-
-        page.page(output)
-        print sys_exit,
-
-        dump_file = opts.D[0]
-        text_file = opts.T[0]
-        if dump_file:
-            prof.dump_stats(dump_file)
-            print '\n*** Profile stats marshalled to file',\
-                  `dump_file`+'.',sys_exit
-        if text_file:
-            pfile = file(text_file,'w')
-            pfile.write(output)
-            pfile.close()
-            print '\n*** Profile printout saved to text file',\
-                  `text_file`+'.',sys_exit
-
-        if opts.has_key('r'):
-            return stats
-        else:
-            return None
-
-    @testdec.skip_doctest
-    def magic_run(self, parameter_s ='',runner=None,
-                  file_finder=get_py_filename):
-        """Run the named file inside IPython as a program.
-
-        Usage:\\
-          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
-        
-        Parameters after the filename are passed as command-line arguments to
-        the program (put in sys.argv). Then, control returns to IPython's
-        prompt.
-
-        This is similar to running at a system prompt:\\
-          $ python file args\\
-        but with the advantage of giving you IPython's tracebacks, and of
-        loading all variables into your interactive namespace for further use
-        (unless -p is used, see below).
-
-        The file is executed in a namespace initially consisting only of
-        __name__=='__main__' and sys.argv constructed as indicated. It thus
-        sees its environment as if it were being run as a stand-alone program
-        (except for sharing global objects such as previously imported
-        modules). But after execution, the IPython interactive namespace gets
-        updated with all variables defined in the program (except for __name__
-        and sys.argv). This allows for very convenient loading of code for
-        interactive work, while giving each program a 'clean sheet' to run in.
-
-        Options:
-        
-        -n: __name__ is NOT set to '__main__', but to the running file's name
-        without extension (as python does under import).  This allows running
-        scripts and reloading the definitions in them without calling code
-        protected by an ' if __name__ == "__main__" ' clause.
-
-        -i: run the file in IPython's namespace instead of an empty one. This
-        is useful if you are experimenting with code written in a text editor
-        which depends on variables defined interactively.
-
-        -e: ignore sys.exit() calls or SystemExit exceptions in the script
-        being run.  This is particularly useful if IPython is being used to
-        run unittests, which always exit with a sys.exit() call.  In such
-        cases you are interested in the output of the test results, not in
-        seeing a traceback of the unittest module.
-
-        -t: print timing information at the end of the run.  IPython will give
-        you an estimated CPU time consumption for your script, which under
-        Unix uses the resource module to avoid the wraparound problems of
-        time.clock().  Under Unix, an estimate of time spent on system tasks
-        is also given (for Windows platforms this is reported as 0.0).
-
-        If -t is given, an additional -N<N> option can be given, where <N>
-        must be an integer indicating how many times you want the script to
-        run.  The final timing report will include total and per run results.
-
-        For example (testing the script uniq_stable.py):
-
-            In [1]: run -t uniq_stable
-
-            IPython CPU timings (estimated):\\
-              User  :    0.19597 s.\\
-              System:        0.0 s.\\
-
-            In [2]: run -t -N5 uniq_stable
-
-            IPython CPU timings (estimated):\\
-            Total runs performed: 5\\
-              Times :      Total       Per run\\
-              User  :   0.910862 s,  0.1821724 s.\\
-              System:        0.0 s,        0.0 s.
-
-        -d: run your program under the control of pdb, the Python debugger.
-        This allows you to execute your program step by step, watch variables,
-        etc.  Internally, what IPython does is similar to calling:
-        
-          pdb.run('execfile("YOURFILENAME")')
-
-        with a breakpoint set on line 1 of your file.  You can change the line
-        number for this automatic breakpoint to be <N> by using the -bN option
-        (where N must be an integer).  For example:
-
-          %run -d -b40 myscript
-
-        will set the first breakpoint at line 40 in myscript.py.  Note that
-        the first breakpoint must be set on a line which actually does
-        something (not a comment or docstring) for it to stop execution.
-
-        When the pdb debugger starts, you will see a (Pdb) prompt.  You must
-        first enter 'c' (without qoutes) to start execution up to the first
-        breakpoint.
-
-        Entering 'help' gives information about the use of the debugger.  You
-        can easily see pdb's full documentation with "import pdb;pdb.help()"
-        at a prompt.
-
-        -p: run program under the control of the Python profiler module (which
-        prints a detailed report of execution times, function calls, etc).
-
-        You can pass other options after -p which affect the behavior of the
-        profiler itself. See the docs for %prun for details.
-
-        In this mode, the program's variables do NOT propagate back to the
-        IPython interactive namespace (because they remain in the namespace
-        where the profiler executes them).
-
-        Internally this triggers a call to %prun, see its documentation for
-        details on the options available specifically for profiling.
-
-        There is one special usage for which the text above doesn't apply:
-        if the filename ends with .ipy, the file is run as ipython script,
-        just as if the commands were written on IPython prompt.
-        """
-
-        # get arguments and set sys.argv for program to be run.
-        opts,arg_lst = self.parse_options(parameter_s,'nidtN:b:pD:l:rs:T:e',
-                                          mode='list',list_all=1)
 
-        try:
-            filename = file_finder(arg_lst[0])
-        except IndexError:
-            warn('you must provide at least a filename.')
-            print '\n%run:\n',oinspect.getdoc(self.magic_run)
-            return
-        except IOError,msg:
-            error(msg)
-            return
-
-        if filename.lower().endswith('.ipy'):
-            self.shell.safe_execfile_ipy(filename)
-            return
-        
-        # Control the response to exit() calls made by the script being run
-        exit_ignore = opts.has_key('e')
-        
-        # Make sure that the running script gets a proper sys.argv as if it
-        # were run from a system shell.
-        save_argv = sys.argv # save it for later restoring
-        sys.argv = [filename]+ arg_lst[1:]  # put in the proper filename
-
-        if opts.has_key('i'):
-            # Run in user's interactive namespace
-            prog_ns = self.shell.user_ns
-            __name__save = self.shell.user_ns['__name__']
-            prog_ns['__name__'] = '__main__'
-            main_mod = self.shell.new_main_mod(prog_ns)
-        else:
-            # Run in a fresh, empty namespace
-            if opts.has_key('n'):
-                name = os.path.splitext(os.path.basename(filename))[0]
-            else:
-                name = '__main__'
+class Magics(Configurable):
+    """Base class for implementing magic functions.
 
-            main_mod = self.shell.new_main_mod()
-            prog_ns = main_mod.__dict__
-            prog_ns['__name__'] = name
-
-        # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
-        # set the __file__ global in the script's namespace
-        prog_ns['__file__'] = filename
-
-        # pickle fix.  See interactiveshell for an explanation.  But we need to make sure
-        # that, if we overwrite __main__, we replace it at the end
-        main_mod_name = prog_ns['__name__']
+    Shell functions which can be reached as %function_name. All magic
+    functions should accept a string, which they can parse for their own
+    needs. This can make some functions easier to type, eg `%cd ../`
+    vs. `%cd("../")`
 
-        if main_mod_name == '__main__':
-            restore_main = sys.modules['__main__']
-        else:
-            restore_main = False
+    Classes providing magic functions need to subclass this class, and they
+    MUST:
+
+    - Use the method decorators `@line_magic` and `@cell_magic` to decorate
+      individual methods as magic functions, AND
+
+    - Use the class decorator `@magics_class` to ensure that the magic
+      methods are properly registered at the instance level upon instance
+      initialization.
+
+    See :mod:`magic_functions` for examples of actual implementation classes.
+    """
+
+    # Dict holding all command-line options for each magic.
+    options_table: dict[str, t.Any] = {}
+    # Dict for the mapping of magic names to methods, set by class decorator
+    magics: dict[str, t.Any] = {}
+    # Flag to check that the class decorator was properly applied
+    registered: bool = False
+    # Instance of IPython shell
+    shell: None | InteractiveShell = None
+
+    def __init__(
+        self, shell: InteractiveShell | None = None, **kwargs: Any
+    ) -> None:
+        if not (self.__class__.registered):
+            raise ValueError(
+                "Magics subclass without registration - "
+                "did you forget to apply @magics_class?"
+            )
+        if shell is not None:
+            if hasattr(shell, "configurables"):
+                shell.configurables.append(self)  # type: ignore[arg-type]
+            if hasattr(shell, "config"):
+                kwargs.setdefault("parent", shell)
 
-        # This needs to be undone at the end to prevent holding references to
-        # every single object ever created.
-        sys.modules[main_mod_name] = main_mod
-        
-        try:
-            stats = None
-            with self.readline_no_record:
-                if opts.has_key('p'):
-                    stats = self.magic_prun('',0,opts,arg_lst,prog_ns)
-                else:
-                    if opts.has_key('d'):
-                        deb = debugger.Pdb(self.shell.colors)
-                        # reset Breakpoint state, which is moronically kept
-                        # in a class
-                        bdb.Breakpoint.next = 1
-                        bdb.Breakpoint.bplist = {}
-                        bdb.Breakpoint.bpbynumber = [None]
-                        # Set an initial breakpoint to stop execution
-                        maxtries = 10
-                        bp = int(opts.get('b',[1])[0])
-                        checkline = deb.checkline(filename,bp)
-                        if not checkline:
-                            for bp in range(bp+1,bp+maxtries+1):
-                                if deb.checkline(filename,bp):
-                                    break
-                            else:
-                                msg = ("\nI failed to find a valid line to set "
-                                       "a breakpoint\n"
-                                       "after trying up to line: %s.\n"
-                                       "Please set a valid breakpoint manually "
-                                       "with the -b option." % bp)
-                                error(msg)
-                                return
-                        # if we find a good linenumber, set the breakpoint
-                        deb.do_break('%s:%s' % (filename,bp))
-                        # Start file run
-                        print "NOTE: Enter 'c' at the",
-                        print "%s prompt to start your script." % deb.prompt
-                        try:
-                            deb.run('execfile("%s")' % filename,prog_ns)
-                            
-                        except:
-                            etype, value, tb = sys.exc_info()
-                            # Skip three frames in the traceback: the %run one,
-                            # one inside bdb.py, and the command-line typed by the
-                            # user (run by exec in pdb itself).
-                            self.shell.InteractiveTB(etype,value,tb,tb_offset=3)
-                    else:
-                        if runner is None:
-                            runner = self.shell.safe_execfile
-                        if opts.has_key('t'):
-                            # timed execution
-                            try:
-                                nruns = int(opts['N'][0])
-                                if nruns < 1:
-                                    error('Number of runs must be >=1')
-                                    return
-                            except (KeyError):
-                                nruns = 1
-                            if nruns == 1:
-                                t0 = clock2()
-                                runner(filename,prog_ns,prog_ns,
-                                       exit_ignore=exit_ignore)
-                                t1 = clock2()
-                                t_usr = t1[0]-t0[0]
-                                t_sys = t1[1]-t0[1]
-                                print "\nIPython CPU timings (estimated):"
-                                print "  User  : %10s s." % t_usr
-                                print "  System: %10s s." % t_sys
-                            else:
-                                runs = range(nruns)
-                                t0 = clock2()
-                                for nr in runs:
-                                    runner(filename,prog_ns,prog_ns,
-                                           exit_ignore=exit_ignore)
-                                t1 = clock2()
-                                t_usr = t1[0]-t0[0]
-                                t_sys = t1[1]-t0[1]
-                                print "\nIPython CPU timings (estimated):"
-                                print "Total runs performed:",nruns
-                                print "  Times : %10s    %10s" % ('Total','Per run')
-                                print "  User  : %10s s, %10s s." % (t_usr,t_usr/nruns)
-                                print "  System: %10s s, %10s s." % (t_sys,t_sys/nruns)
-                                
-                        else:
-                            # regular execution
-                            runner(filename,prog_ns,prog_ns,exit_ignore=exit_ignore)
-
-                if opts.has_key('i'):
-                    self.shell.user_ns['__name__'] = __name__save
+        self.shell = shell
+        self.options_table = {}
+        # The method decorators are run when the instance doesn't exist yet, so
+        # they can only record the names of the methods they are supposed to
+        # grab.  Only now, that the instance exists, can we create the proper
+        # mapping to bound methods.  So we read the info off the original names
+        # table and replace each method name by the actual bound method.
+        # But we mustn't clobber the *class* mapping, in case of multiple instances.
+        class_magics = self.magics
+        self.magics = {}
+        for mtype in magic_kinds:
+            self.magics[mtype] = {}
+            tab: dict[str, Any] = self.magics[mtype]
+            cls_tab: dict[str, Any] = class_magics[mtype]
+            for magic_name, meth_name in cls_tab.items():
+                if isinstance(meth_name, str):
+                    # it's a method name, grab it
+                    tab[magic_name] = getattr(self, meth_name)
                 else:
-                    # The shell MUST hold a reference to prog_ns so after %run
-                    # exits, the python deletion mechanism doesn't zero it out
-                    # (leaving dangling references).
-                    self.shell.cache_main_mod(prog_ns,filename)
-                    # update IPython interactive namespace
-
-                    # Some forms of read errors on the file may mean the
-                    # __name__ key was never set; using pop we don't have to
-                    # worry about a possible KeyError.
-                    prog_ns.pop('__name__', None)
-
-                    self.shell.user_ns.update(prog_ns)
-        finally:
-            # It's a bit of a mystery why, but __builtins__ can change from
-            # being a module to becoming a dict missing some key data after
-            # %run.  As best I can see, this is NOT something IPython is doing
-            # at all, and similar problems have been reported before:
-            # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
-            # Since this seems to be done by the interpreter itself, the best
-            # we can do is to at least restore __builtins__ for the user on
-            # exit.
-            self.shell.user_ns['__builtins__'] = __builtin__
-            
-            # Ensure key global structures are restored
-            sys.argv = save_argv
-            if restore_main:
-                sys.modules['__main__'] = restore_main
-            else:
-                # Remove from sys.modules the reference to main_mod we'd
-                # added.  Otherwise it will trap references to objects
-                # contained therein.
-                del sys.modules[main_mod_name]
-                
-        return stats
-
-    @testdec.skip_doctest
-    def magic_timeit(self, parameter_s =''):
-        """Time execution of a Python statement or expression
-
-        Usage:\\
-          %timeit [-n<N> -r<R> [-t|-c]] statement
-
-        Time execution of a Python statement or expression using the timeit
-        module.
-
-        Options:
-        -n<N>: execute the given statement <N> times in a loop. If this value
-        is not given, a fitting value is chosen. 
-        
-        -r<R>: repeat the loop iteration <R> times and take the best result.
-        Default: 3
-        
-        -t: use time.time to measure the time, which is the default on Unix.
-        This function measures wall time.
-        
-        -c: use time.clock to measure the time, which is the default on
-        Windows and measures wall time. On Unix, resource.getrusage is used
-        instead and returns the CPU user time.
-
-        -p<P>: use a precision of <P> digits to display the timing result.
-        Default: 3
-
-        
-        Examples:
-
-          In [1]: %timeit pass
-          10000000 loops, best of 3: 53.3 ns per loop
-
-          In [2]: u = None
-
-          In [3]: %timeit u is None
-          10000000 loops, best of 3: 184 ns per loop
-
-          In [4]: %timeit -r 4 u == None
-          1000000 loops, best of 4: 242 ns per loop
-
-          In [5]: import time
-
-          In [6]: %timeit -n1 time.sleep(2)
-          1 loops, best of 3: 2 s per loop
-          
-
-        The times reported by %timeit will be slightly higher than those
-        reported by the timeit.py script when variables are accessed. This is
-        due to the fact that %timeit executes the statement in the namespace
-        of the shell, compared with timeit.py, which uses a single setup
-        statement to import function or create variables. Generally, the bias
-        does not matter as long as results from timeit.py are not mixed with
-        those from %timeit."""
-
-        import timeit
-        import math
-
-        # XXX: Unfortunately the unicode 'micro' symbol can cause problems in
-        # certain terminals.  Until we figure out a robust way of
-        # auto-detecting if the terminal can deal with it, use plain 'us' for
-        # microseconds.  I am really NOT happy about disabling the proper
-        # 'micro' prefix, but crashing is worse... If anyone knows what the
-        # right solution for this is, I'm all ears...
-        #
-        # Note: using
-        #
-        # s = u'\xb5'
-        # s.encode(sys.getdefaultencoding())
-        #
-        # is not sufficient, as I've seen terminals where that fails but
-        # print s
-        #
-        # succeeds
-        #
-        # See bug: https://bugs.launchpad.net/ipython/+bug/348466
-        
-        #units = [u"s", u"ms",u'\xb5',"ns"]
-        units = [u"s", u"ms",u'us',"ns"]
-        
-        scaling = [1, 1e3, 1e6, 1e9]
-
-        opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
-                                        posix=False)
-        if stmt == "":
-            return
-        timefunc = timeit.default_timer
-        number = int(getattr(opts, "n", 0))
-        repeat = int(getattr(opts, "r", timeit.default_repeat))
-        precision = int(getattr(opts, "p", 3))
-        if hasattr(opts, "t"):
-            timefunc = time.time
-        if hasattr(opts, "c"):
-            timefunc = clock
-
-        timer = timeit.Timer(timer=timefunc)
-        # this code has tight coupling to the inner workings of timeit.Timer,
-        # but is there a better way to achieve that the code stmt has access
-        # to the shell namespace?
-
-        src = timeit.template % {'stmt': timeit.reindent(stmt, 8),
-                                 'setup': "pass"}
-        # Track compilation time so it can be reported if too long
-        # Minimum time above which compilation time will be reported
-        tc_min = 0.1
-        
-        t0 = clock()
-        code = compile(src, "<magic-timeit>", "exec")
-        tc = clock()-t0
-        
-        ns = {}
-        exec code in self.shell.user_ns, ns
-        timer.inner = ns["inner"]
-        
-        if number == 0:
-            # determine number so that 0.2 <= total time < 2.0
-            number = 1
-            for i in range(1, 10):
-                if timer.timeit(number) >= 0.2:
-                    break
-                number *= 10
-        
-        best = min(timer.repeat(repeat, number)) / number
-
-        if best > 0.0 and best < 1000.0:
-            order = min(-int(math.floor(math.log10(best)) // 3), 3)
-        elif best >= 1000.0:
-            order = 0
-        else:
-            order = 3
-        print u"%d loops, best of %d: %.*g %s per loop" % (number, repeat,
-                                                          precision,
-                                                          best * scaling[order],
-                                                          units[order])
-        if tc > tc_min:
-            print "Compiler time: %.2f s" % tc
-
-    @testdec.skip_doctest
-    @needs_local_scope
-    def magic_time(self,parameter_s = ''):
-        """Time execution of a Python statement or expression.
-
-        The CPU and wall clock times are printed, and the value of the
-        expression (if any) is returned.  Note that under Win32, system time
-        is always reported as 0, since it can not be measured.
-
-        This function provides very basic timing functionality.  In Python
-        2.3, the timeit module offers more control and sophistication, so this
-        could be rewritten to use it (patches welcome).
-        
-        Some examples:
-
-          In [1]: time 2**128
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00
-          Out[1]: 340282366920938463463374607431768211456L
-
-          In [2]: n = 1000000
-
-          In [3]: time sum(range(n))
-          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
-          Wall time: 1.37
-          Out[3]: 499999500000L
-
-          In [4]: time print 'hello world'
-          hello world
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00
-
-          Note that the time needed by Python to compile the given expression
-          will be reported if it is more than 0.1s.  In this example, the
-          actual exponentiation is done by Python at compilation time, so while
-          the expression can take a noticeable amount of time to compute, that
-          time is purely due to the compilation:
-
-          In [5]: time 3**9999;
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00 s
-
-          In [6]: time 3**999999;
-          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-          Wall time: 0.00 s
-          Compiler : 0.78 s
-          """
-        
-        # fail immediately if the given expression can't be compiled
-        
-        expr = self.shell.prefilter(parameter_s,False)
-
-        # Minimum time above which compilation time will be reported
-        tc_min = 0.1
-        
-        try:
-            mode = 'eval'
-            t0 = clock()
-            code = compile(expr,'<timed eval>',mode)
-            tc = clock()-t0
-        except SyntaxError:
-            mode = 'exec'
-            t0 = clock()
-            code = compile(expr,'<timed exec>',mode)
-            tc = clock()-t0
-        # skew measurement as little as possible
-        glob = self.shell.user_ns
-        locs = self._magic_locals
-        clk = clock2
-        wtime = time.time
-        # time execution
-        wall_st = wtime()
-        if mode=='eval':
-            st = clk()
-            out = eval(code, glob, locs)
-            end = clk()
-        else:
-            st = clk()
-            exec code in glob, locs
-            end = clk()
-            out = None
-        wall_end = wtime()
-        # Compute actual times and report
-        wall_time = wall_end-wall_st
-        cpu_user = end[0]-st[0]
-        cpu_sys = end[1]-st[1]
-        cpu_tot = cpu_user+cpu_sys
-        print "CPU times: user %.2f s, sys: %.2f s, total: %.2f s" % \
-              (cpu_user,cpu_sys,cpu_tot)
-        print "Wall time: %.2f s" % wall_time
-        if tc > tc_min:
-            print "Compiler : %.2f s" % tc
-        return out
-
-    @testdec.skip_doctest
-    def magic_macro(self,parameter_s = ''):
-        """Define a macro for future re-execution. It accepts ranges of history,
-        filenames or string objects.
-
-        Usage:\\
-          %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
-
-        Options:
-        
-          -r: use 'raw' input.  By default, the 'processed' history is used,
-          so that magics are loaded in their transformed version to valid
-          Python.  If this option is given, the raw input as typed as the
-          command line is used instead.
-
-        This will define a global variable called `name` which is a string
-        made of joining the slices and lines you specify (n1,n2,... numbers
-        above) from your input history into a single string. This variable
-        acts like an automatic function which re-executes those lines as if
-        you had typed them. You just type 'name' at the prompt and the code
-        executes.
-
-        The syntax for indicating input ranges is described in %history.
-
-        Note: as a 'hidden' feature, you can also use traditional python slice
-        notation, where N:M means numbers N through M-1.
-
-        For example, if your history contains (%hist prints it):
-        
-          44: x=1
-          45: y=3
-          46: z=x+y
-          47: print x
-          48: a=5
-          49: print 'x',x,'y',y
-
-        you can create a macro with lines 44 through 47 (included) and line 49
-        called my_macro with:
-
-          In [55]: %macro my_macro 44-47 49
-
-        Now, typing `my_macro` (without quotes) will re-execute all this code
-        in one pass.
-
-        You don't need to give the line-numbers in order, and any given line
-        number can appear multiple times. You can assemble macros with any
-        lines from your input history in any order.
-
-        The macro is a simple object which holds its value in an attribute,
-        but IPython's display system checks for macros and executes them as
-        code instead of printing them when you type their name.
-
-        You can view a macro's contents by explicitly printing it with:
-        
-          'print macro_name'.
-          
-        """
+                    # it's the real thing
+                    tab[magic_name] = meth_name
+        # Configurable **needs** to be initiated at the end or the config
+        # magics get screwed up.
+        super(Magics, self).__init__(**kwargs)
 
-        opts,args = self.parse_options(parameter_s,'r',mode='list')
-        if not args:   # List existing macros
-            return sorted(k for k,v in self.shell.user_ns.iteritems() if\
-                                                        isinstance(v, Macro))
-        if len(args) == 1:
-            raise UsageError(
-                "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
-        name, codefrom = args[0], " ".join(args[1:])
-        
-        #print 'rng',ranges  # dbg
-        try:
-            lines = self.shell.find_user_code(codefrom, 'r' in opts)
-        except (ValueError, TypeError) as e:
-            print e.args[0]
-            return
-        macro = Macro(lines)
-        self.shell.define_macro(name, macro)
-        print 'Macro `%s` created. To execute, type its name (without quotes).' % name
-        print '=== Macro contents: ==='
-        print macro,
-
-    def magic_save(self,parameter_s = ''):
-        """Save a set of lines or a macro to a given filename.
-
-        Usage:\\
-          %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
-
-        Options:
-        
-          -r: use 'raw' input.  By default, the 'processed' history is used,
-          so that magics are loaded in their transformed version to valid
-          Python.  If this option is given, the raw input as typed as the
-          command line is used instead.
-
-        This function uses the same syntax as %history for input ranges, 
-        then saves the lines to the filename you specify.
-
-        It adds a '.py' extension to the file if you don't do so yourself, and
-        it asks for confirmation before overwriting existing files."""
-
-        opts,args = self.parse_options(parameter_s,'r',mode='list')
-        fname, codefrom = args[0], " ".join(args[1:])
-        if not fname.endswith('.py'):
-            fname += '.py'
-        if os.path.isfile(fname):
-            ans = raw_input('File `%s` exists. Overwrite (y/[N])? ' % fname)
-            if ans.lower() not in ['y','yes']:
-                print 'Operation cancelled.'
-                return
-        try:
-            cmds = self.shell.find_user_code(codefrom, 'r' in opts)
-        except (TypeError, ValueError) as e:
-            print e.args[0]
-            return
-        if isinstance(cmds, unicode):
-            cmds = cmds.encode("utf-8")
-        with open(fname,'w') as f:
-            f.write("# coding: utf-8\n")
-            f.write(cmds)
-        print 'The following commands were written to file `%s`:' % fname
-        print cmds
-    
-    def magic_pastebin(self, parameter_s = ''):
-        """Upload code to the 'Lodge it' paste bin, returning the URL."""
-        try:
-            code = self.shell.find_user_code(parameter_s)
-        except (ValueError, TypeError) as e:
-            print e.args[0]
-            return
-        pbserver = ServerProxy('http://paste.pocoo.org/xmlrpc/')
-        id = pbserver.pastes.newPaste("python", code)
-        return "http://paste.pocoo.org/show/" + id
-
-    def _edit_macro(self,mname,macro):
-        """open an editor with the macro data in a file"""
-        filename = self.shell.mktempfile(macro.value)
-        self.shell.hooks.editor(filename)
-
-        # and make a new macro object, to replace the old one
-        mfile = open(filename)
-        mvalue = mfile.read()
-        mfile.close()
-        self.shell.user_ns[mname] = Macro(mvalue)
-
-    def magic_ed(self,parameter_s=''):
-        """Alias to %edit."""
-        return self.magic_edit(parameter_s)
-
-    @testdec.skip_doctest
-    def magic_edit(self,parameter_s='',last_call=['','']):
-        """Bring up an editor and execute the resulting code.
-
-        Usage:
-          %edit [options] [args]
-
-        %edit runs IPython's editor hook.  The default version of this hook is
-        set to call the __IPYTHON__.rc.editor command.  This is read from your
-        environment variable $EDITOR.  If this isn't found, it will default to
-        vi under Linux/Unix and to notepad under Windows.  See the end of this
-        docstring for how to change the editor hook.
-
-        You can also set the value of this editor via the command line option
-        '-editor' or in your ipythonrc file. This is useful if you wish to use
-        specifically for IPython an editor different from your typical default
-        (and for Windows users who typically don't set environment variables).
-
-        This command allows you to conveniently edit multi-line code right in
-        your IPython session.
-        
-        If called without arguments, %edit opens up an empty editor with a
-        temporary file and will execute the contents of this file when you
-        close it (don't forget to save it!).
-
-
-        Options:
-
-        -n <number>: open the editor at a specified line number.  By default,
-        the IPython editor hook uses the unix syntax 'editor +N filename', but
-        you can configure this by providing your own modified hook if your
-        favorite editor supports line-number specifications with a different
-        syntax.
-        
-        -p: this will call the editor with the same data as the previous time
-        it was used, regardless of how long ago (in your current session) it
-        was.
-
-        -r: use 'raw' input.  This option only applies to input taken from the
-        user's history.  By default, the 'processed' history is used, so that
-        magics are loaded in their transformed version to valid Python.  If
-        this option is given, the raw input as typed as the command line is
-        used instead.  When you exit the editor, it will be executed by
-        IPython's own processor.
-        
-        -x: do not execute the edited code immediately upon exit. This is
-        mainly useful if you are editing programs which need to be called with
-        command line arguments, which you can then do using %run.
-
-
-        Arguments:
-
-        If arguments are given, the following possibilites exist:
-        
-        - If the argument is a filename, IPython will load that into the
-        editor. It will execute its contents with execfile() when you exit,
-        loading any code in the file into your interactive namespace.
-
-        - The arguments are ranges of input history,  e.g. "7 ~1/4-6".
-        The syntax is the same as in the %history magic.
-
-        - If the argument is a string variable, its contents are loaded
-        into the editor. You can thus edit any string which contains
-        python code (including the result of previous edits).
-
-        - If the argument is the name of an object (other than a string),
-        IPython will try to locate the file where it was defined and open the
-        editor at the point where it is defined. You can use `%edit function`
-        to load an editor exactly at the point where 'function' is defined,
-        edit it and have the file be executed automatically.
-
-        If the object is a macro (see %macro for details), this opens up your
-        specified editor with a temporary file containing the macro's data.
-        Upon exit, the macro is reloaded with the contents of the file.
-
-        Note: opening at an exact line is only supported under Unix, and some
-        editors (like kedit and gedit up to Gnome 2.8) do not understand the
-        '+NUMBER' parameter necessary for this feature. Good editors like
-        (X)Emacs, vi, jed, pico and joe all do.
-
-        After executing your code, %edit will return as output the code you
-        typed in the editor (except when it was an existing file). This way
-        you can reload the code in further invocations of %edit as a variable,
-        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
-        the output.
-
-        Note that %edit is also available through the alias %ed.
-
-        This is an example of creating a simple function inside the editor and
-        then modifying it. First, start up the editor:
-
-        In [1]: ed
-        Editing... done. Executing edited code...
-        Out[1]: 'def foo():n    print "foo() was defined in an editing session"n'
-
-        We can then call the function foo():
-        
-        In [2]: foo()
-        foo() was defined in an editing session
-
-        Now we edit foo.  IPython automatically loads the editor with the
-        (temporary) file where foo() was previously defined:
-        
-        In [3]: ed foo
-        Editing... done. Executing edited code...
-
-        And if we call foo() again we get the modified version:
-        
-        In [4]: foo()
-        foo() has now been changed!
-
-        Here is an example of how to edit a code snippet successive
-        times. First we call the editor:
-
-        In [5]: ed
-        Editing... done. Executing edited code...
-        hello
-        Out[5]: "print 'hello'n"
-
-        Now we call it again with the previous output (stored in _):
-
-        In [6]: ed _
-        Editing... done. Executing edited code...
-        hello world
-        Out[6]: "print 'hello world'n"
-
-        Now we call it with the output #8 (stored in _8, also as Out[8]):
-
-        In [7]: ed _8
-        Editing... done. Executing edited code...
-        hello again
-        Out[7]: "print 'hello again'n"
-
-
-        Changing the default editor hook:
-
-        If you wish to write your own editor hook, you can put it in a
-        configuration file which you load at startup time.  The default hook
-        is defined in the IPython.core.hooks module, and you can use that as a
-        starting example for further modifications.  That file also has
-        general instructions on how to set a new hook for use once you've
-        defined it."""
-        
-        # FIXME: This function has become a convoluted mess.  It needs a
-        # ground-up rewrite with clean, simple logic.
+    def arg_err(self, func: Callable[..., Any]) -> None:
+        """Print docstring if incorrect arguments were passed"""
+        print("Error in arguments:")
+        print(oinspect.getdoc(func))
 
-        def make_filename(arg):
-            "Make a filename from the given args"
-            try:
-                filename = get_py_filename(arg)
-            except IOError:
-                if args.endswith('.py'):
-                    filename = arg
-                else:
-                    filename = None
-            return filename
-
-        # custom exceptions
-        class DataIsObject(Exception): pass
-
-        opts,args = self.parse_options(parameter_s,'prxn:')
-        # Set a few locals from the options for convenience:
-        opts_prev = 'p' in opts
-        opts_raw = 'r' in opts
-        
-        # Default line number value
-        lineno = opts.get('n',None)
-
-        if opts_prev:
-            args = '_%s' % last_call[0]
-            if not self.shell.user_ns.has_key(args):
-                args = last_call[1]
-            
-        # use last_call to remember the state of the previous call, but don't
-        # let it be clobbered by successive '-p' calls.
-        try:
-            last_call[0] = self.shell.displayhook.prompt_count
-            if not opts_prev:
-                last_call[1] = parameter_s
-        except:
-            pass
-
-        # by default this is done with temp files, except when the given
-        # arg is a filename
-        use_temp = True
-
-        data = ''
-        if args.endswith('.py'):
-            filename = make_filename(args)
-            use_temp = False
-        elif args:
-            # Mode where user specifies ranges of lines, like in %macro.
-            data = self.extract_input_lines(args, opts_raw)
-            if not data:
-                try:
-                    # Load the parameter given as a variable. If not a string,
-                    # process it as an object instead (below)
-
-                    #print '*** args',args,'type',type(args)  # dbg
-                    data = eval(args, self.shell.user_ns)
-                    if not isinstance(data, basestring):
-                        raise DataIsObject
-
-                except (NameError,SyntaxError):
-                    # given argument is not a variable, try as a filename
-                    filename = make_filename(args)
-                    if filename is None:
-                        warn("Argument given (%s) can't be found as a variable "
-                             "or as a filename." % args)
-                        return
-                    use_temp = False
-                
-                except DataIsObject:
-                    # macros have a special edit function
-                    if isinstance(data, Macro):
-                        self._edit_macro(args,data)
-                        return
-                                    
-                    # For objects, try to edit the file where they are defined
-                    try:
-                        filename = inspect.getabsfile(data)
-                        if 'fakemodule' in filename.lower() and inspect.isclass(data):                     
-                            # class created by %edit? Try to find source
-                            # by looking for method definitions instead, the
-                            # __module__ in those classes is FakeModule.
-                            attrs = [getattr(data, aname) for aname in dir(data)]
-                            for attr in attrs:
-                                if not inspect.ismethod(attr):
-                                    continue
-                                filename = inspect.getabsfile(attr)
-                                if filename and 'fakemodule' not in filename.lower():
-                                    # change the attribute to be the edit target instead
-                                    data = attr 
-                                    break
-                        
-                        datafile = 1
-                    except TypeError:
-                        filename = make_filename(args)
-                        datafile = 1
-                        warn('Could not find file where `%s` is defined.\n'
-                             'Opening a file named `%s`' % (args,filename))
-                    # Now, make sure we can actually read the source (if it was in
-                    # a temp file it's gone by now).
-                    if datafile:
-                        try:
-                            if lineno is None:
-                                lineno = inspect.getsourcelines(data)[1]
-                        except IOError:
-                            filename = make_filename(args)
-                            if filename is None:
-                                warn('The file `%s` where `%s` was defined cannot '
-                                     'be read.' % (filename,data))
-                                return
-                    use_temp = False
-
-        if use_temp:
-            filename = self.shell.mktempfile(data)
-            print 'IPython will make a temporary file named:',filename
-
-        # do actual editing here
-        print 'Editing...',
-        sys.stdout.flush()
-        try:
-            # Quote filenames that may have spaces in them
-            if ' ' in filename:
-                filename = "%s" % filename
-            self.shell.hooks.editor(filename,lineno)
-        except TryNext:
-            warn('Could not open editor')
-            return
-        
-        # XXX TODO: should this be generalized for all string vars?
-        # For now, this is special-cased to blocks created by cpaste
-        if args.strip() == 'pasted_block':
-            self.shell.user_ns['pasted_block'] = file_read(filename)
-        
-        if 'x' in opts:  # -x prevents actual execution
-            print
-        else:
-            print 'done. Executing edited code...'
-            if opts_raw:
-                self.shell.run_cell(file_read(filename),
-                                                    store_history=False)
-            else:
-                self.shell.safe_execfile(filename,self.shell.user_ns,
-                                         self.shell.user_ns)
-        
-                                                     
-        if use_temp:
-            try:
-                return open(filename).read()
-            except IOError,msg:
-                if msg.filename == filename:
-                    warn('File not found. Did you forget to save?')
-                    return
-                else:
-                    self.shell.showtraceback()
+    def format_latex(self, strng: str) -> str:
+        """Format a string for latex inclusion."""
 
-    def magic_xmode(self,parameter_s = ''):
-        """Switch modes for the exception handlers.
+        # Characters that need to be escaped for latex:
+        escape_re = re.compile(r"(%|_|\$|#|&)", re.MULTILINE)
+        # Magic command names as headers:
+        cmd_name_re = re.compile(r"^(%s.*?):" % ESC_MAGIC, re.MULTILINE)
+        # Magic commands
+        cmd_re = re.compile(r"(?P<cmd>%s.+?\b)(?!\}\}:)" % ESC_MAGIC, re.MULTILINE)
+        # Paragraph continue
+        par_re = re.compile(r"\\$", re.MULTILINE)
 
-        Valid modes: Plain, Context and Verbose.
+        # The "\n" symbol
+        newline_re = re.compile(r"\\n")
 
-        If called without arguments, acts as a toggle."""
+        # Now build the string for output:
+        # strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
+        strng = cmd_name_re.sub(r"\n\\bigskip\n\\texttt{\\textbf{ \1}}:", strng)
+        strng = cmd_re.sub(r"\\texttt{\g<cmd>}", strng)
+        strng = par_re.sub(r"\\\\", strng)
+        strng = escape_re.sub(r"\\\1", strng)
+        strng = newline_re.sub(r"\\textbackslash{}n", strng)
+        return strng
 
-        def xmode_switch_err(name):
-            warn('Error changing %s exception modes.\n%s' %
-                 (name,sys.exc_info()[1]))
+    def parse_options(
+        self, arg_str: str, opt_str: str, *long_opts: str, **kw: Any
+    ) -> tuple[Any, Any]:
+        """Parse options passed to an argument string.
 
-        shell = self.shell
-        new_mode = parameter_s.strip().capitalize()
-        try:
-            shell.InteractiveTB.set_mode(mode=new_mode)
-            print 'Exception reporting mode:',shell.InteractiveTB.mode
-        except:
-            xmode_switch_err('user')
-
-    def magic_colors(self,parameter_s = ''):
-        """Switch color scheme for prompts, info system and exception handlers.
-
-        Currently implemented schemes: NoColor, Linux, LightBG.
-
-        Color scheme names are not case-sensitive.
-        
-        Examples
-        --------
-        To get a plain black and white terminal::
-        
-          %colors nocolor
-        """
+        The interface is similar to that of :func:`getopt.getopt`, but it
+        returns a :class:`~IPython.utils.struct.Struct` with the options as keys
+        and the stripped argument string still as a string.
 
-        def color_switch_err(name):
-            warn('Error changing %s color schemes.\n%s' %
-                 (name,sys.exc_info()[1]))
-            
-        
-        new_scheme = parameter_s.strip()
-        if not new_scheme:
-            raise UsageError(
-                "%colors: you must specify a color scheme. See '%colors?'")
-            return
-        # local shortcut
-        shell = self.shell
-
-        import IPython.utils.rlineimpl as readline
-
-        if not readline.have_readline and sys.platform == "win32":
-            msg = """\
-Proper color support under MS Windows requires the pyreadline library.
-You can find it at:
-http://ipython.scipy.org/moin/PyReadline/Intro
-Gary's readline needs the ctypes module, from:
-http://starship.python.net/crew/theller/ctypes
-(Note that ctypes is already part of Python versions 2.5 and newer).
-
-Defaulting color scheme to 'NoColor'"""
-            new_scheme = 'NoColor'
-            warn(msg)
-        
-        # readline option is 0
-        if not shell.has_readline:
-            new_scheme = 'NoColor'
-            
-        # Set prompt colors
-        try:
-            shell.displayhook.set_colors(new_scheme)
-        except:
-            color_switch_err('prompt')
-        else:
-            shell.colors = \
-                       shell.displayhook.color_table.active_scheme_name
-        # Set exception colors
-        try:
-            shell.InteractiveTB.set_colors(scheme = new_scheme)
-            shell.SyntaxTB.set_colors(scheme = new_scheme)
-        except:
-            color_switch_err('exception')
+        arg_str is quoted as a true sys.argv vector by using shlex.split.
+        This allows us to easily expand variables, glob files, quote
+        arguments, etc.
 
-        # Set info (for 'object?') colors
-        if shell.color_info:
-            try:
-                shell.inspector.set_active_scheme(new_scheme)
-            except:
-                color_switch_err('object inspector')
-        else:
-            shell.inspector.set_active_scheme('NoColor')
-                
-    def magic_pprint(self, parameter_s=''):
-        """Toggle pretty printing on/off."""
-        ptformatter = self.shell.display_formatter.formatters['text/plain']
-        ptformatter.pprint = bool(1 - ptformatter.pprint)
-        print 'Pretty printing has been turned', \
-              ['OFF','ON'][ptformatter.pprint]
-
-    #......................................................................
-    # Functions to implement unix shell-type things
-
-    @testdec.skip_doctest
-    def magic_alias(self, parameter_s = ''):
-        """Define an alias for a system command.
-
-        '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
-
-        Then, typing 'alias_name params' will execute the system command 'cmd
-        params' (from your underlying operating system).
-
-        Aliases have lower precedence than magic functions and Python normal
-        variables, so if 'foo' is both a Python variable and an alias, the
-        alias can not be executed until 'del foo' removes the Python variable.
-
-        You can use the %l specifier in an alias definition to represent the
-        whole line when the alias is called.  For example:
-
-          In [2]: alias bracket echo "Input in brackets: <%l>"
-          In [3]: bracket hello world
-          Input in brackets: <hello world>
-
-        You can also define aliases with parameters using %s specifiers (one
-        per parameter):
-        
-          In [1]: alias parts echo first %s second %s
-          In [2]: %parts A B
-          first A second B
-          In [3]: %parts A
-          Incorrect number of arguments: 2 expected.
-          parts is an alias to: 'echo first %s second %s'
-
-        Note that %l and %s are mutually exclusive.  You can only use one or
-        the other in your aliases.
-
-        Aliases expand Python variables just like system calls using ! or !! 
-        do: all expressions prefixed with '$' get expanded.  For details of
-        the semantic rules, see PEP-215:
-        http://www.python.org/peps/pep-0215.html.  This is the library used by
-        IPython for variable expansion.  If you want to access a true shell
-        variable, an extra $ is necessary to prevent its expansion by IPython:
-
-        In [6]: alias show echo
-        In [7]: PATH='A Python string'
-        In [8]: show $PATH
-        A Python string
-        In [9]: show $$PATH
-        /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
-
-        You can use the alias facility to acess all of $PATH.  See the %rehash
-        and %rehashx functions, which automatically create aliases for the
-        contents of your $PATH.
-
-        If called with no parameters, %alias prints the current alias table."""
-
-        par = parameter_s.strip()
-        if not par:
-            stored = self.db.get('stored_aliases', {} )
-            aliases = sorted(self.shell.alias_manager.aliases)
-            # for k, v in stored:
-            #     atab.append(k, v[0])
-
-            print "Total number of aliases:", len(aliases)
-            sys.stdout.flush()
-            return aliases
-        
-        # Now try to define a new one
-        try:
-            alias,cmd = par.split(None, 1)
-        except:
-            print oinspect.getdoc(self.magic_alias)
-        else:
-            self.shell.alias_manager.soft_define_alias(alias, cmd)
-    # end magic_alias
-
-    def magic_unalias(self, parameter_s = ''):
-        """Remove an alias"""
-
-        aname = parameter_s.strip()
-        self.shell.alias_manager.undefine_alias(aname)
-        stored = self.db.get('stored_aliases', {} )
-        if aname in stored:
-            print "Removing %stored alias",aname
-            del stored[aname]
-            self.db['stored_aliases'] = stored
-
-    def magic_rehashx(self, parameter_s = ''):
-        """Update the alias table with all executable files in $PATH.
-
-        This version explicitly checks that every entry in $PATH is a file
-        with execute access (os.X_OK), so it is much slower than %rehash.
-
-        Under Windows, it checks executability as a match agains a
-        '|'-separated string of extensions, stored in the IPython config
-        variable win_exec_ext.  This defaults to 'exe|com|bat'.
-        
-        This function also resets the root module cache of module completer,
-        used on slow filesystems.
-        """
-        from IPython.core.alias import InvalidAliasError
-
-        # for the benefit of module completer in ipy_completers.py
-        del self.db['rootmodules']
-        
-        path = [os.path.abspath(os.path.expanduser(p)) for p in 
-            os.environ.get('PATH','').split(os.pathsep)]
-        path = filter(os.path.isdir,path)
-
-        syscmdlist = []
-        # Now define isexec in a cross platform manner.
-        if os.name == 'posix':
-            isexec = lambda fname:os.path.isfile(fname) and \
-                     os.access(fname,os.X_OK)
-        else:
-            try:
-                winext = os.environ['pathext'].replace(';','|').replace('.','')
-            except KeyError:
-                winext = 'exe|com|bat|py'
-            if 'py' not in winext:
-                winext += '|py'
-            execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
-            isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
-        savedir = os.getcwd()
-
-        # Now walk the paths looking for executables to alias.
-        try:
-            # write the whole loop for posix/Windows so we don't have an if in
-            # the innermost part
-            if os.name == 'posix':
-                for pdir in path:
-                    os.chdir(pdir)
-                    for ff in os.listdir(pdir):
-                        if isexec(ff):
-                            try:
-                                # Removes dots from the name since ipython
-                                # will assume names with dots to be python.
-                                self.shell.alias_manager.define_alias(
-                                    ff.replace('.',''), ff)
-                            except InvalidAliasError:
-                                pass
-                            else:
-                                syscmdlist.append(ff)
-            else:
-                no_alias = self.shell.alias_manager.no_alias
-                for pdir in path:
-                    os.chdir(pdir)
-                    for ff in os.listdir(pdir):
-                        base, ext = os.path.splitext(ff)
-                        if isexec(ff) and base.lower() not in no_alias:
-                            if ext.lower() == '.exe':
-                                ff = base
-                                try:
-                                    # Removes dots from the name since ipython
-                                    # will assume names with dots to be python.
-                                    self.shell.alias_manager.define_alias(
-                                        base.lower().replace('.',''), ff)
-                                except InvalidAliasError:
-                                    pass
-                                syscmdlist.append(ff)
-            db = self.db
-            db['syscmdlist'] = syscmdlist
-        finally:
-            os.chdir(savedir)
-    
-    @testdec.skip_doctest    
-    def magic_pwd(self, parameter_s = ''):
-        """Return the current working directory path.
-        
-        Examples
-        --------
-        ::
-        
-          In [9]: pwd
-          Out[9]: '/home/tsuser/sprint/ipython'
-        """
-        return os.getcwd()
-    
-    @testdec.skip_doctest
-    def magic_cd(self, parameter_s=''):
-        """Change the current working directory.
-
-        This command automatically maintains an internal list of directories
-        you visit during your IPython session, in the variable _dh. The
-        command %dhist shows this history nicely formatted. You can also
-        do 'cd -<tab>' to see directory history conveniently.
-
-        Usage:
-
-          cd 'dir': changes to directory 'dir'.
-
-          cd -: changes to the last visited directory.
-
-          cd -<n>: changes to the n-th directory in the directory history.
-
-          cd --foo: change to directory that matches 'foo' in history
-            
-          cd -b <bookmark_name>: jump to a bookmark set by %bookmark
-             (note: cd <bookmark_name> is enough if there is no
-              directory <bookmark_name>, but a bookmark with the name exists.)
-              'cd -b <tab>' allows you to tab-complete bookmark names. 
-
-        Options:
-
-        -q: quiet.  Do not print the working directory after the cd command is
-        executed.  By default IPython's cd command does print this directory,
-        since the default prompts do not display path information.
-        
-        Note that !cd doesn't work for this purpose because the shell where
-        !command runs is immediately discarded after executing 'command'.
-        
-        Examples
-        --------
-        ::
-        
-          In [10]: cd parent/child
-          /home/tsuser/parent/child
+        Parameters
+        ----------
+        arg_str : str
+            The arguments to parse.
+        opt_str : str
+            The options specification.
+        mode : str, default 'string'
+            If given as 'list', the argument string is returned as a list (split
+            on whitespace) instead of a string.
+        list_all : bool, default False
+            Put all option values in lists. Normally only options
+            appearing more than once are put in a list.
+        posix : bool, default True
+            Whether to split the input line in POSIX mode or not, as per the
+            conventions outlined in the :mod:`shlex` module from the standard
+            library.
         """
 
-        parameter_s = parameter_s.strip()
-        #bkms = self.shell.persist.get("bookmarks",{})
+        # inject default options at the beginning of the input line
+        caller = sys._getframe(1).f_code.co_name
+        arg_str = "%s %s" % (self.options_table.get(caller, ""), arg_str)
 
-        oldcwd = os.getcwd()
-        numcd = re.match(r'(-)(\d+)$',parameter_s)
-        # jump in directory history by number
-        if numcd:
-            nn = int(numcd.group(2))
-            try:
-                ps = self.shell.user_ns['_dh'][nn]
-            except IndexError:
-                print 'The requested directory does not exist in history.'
-                return
-            else:
-                opts = {}
-        elif parameter_s.startswith('--'):
-            ps = None
-            fallback = None
-            pat = parameter_s[2:]
-            dh = self.shell.user_ns['_dh']
-            # first search only by basename (last component)
-            for ent in reversed(dh):
-                if pat in os.path.basename(ent) and os.path.isdir(ent):
-                    ps = ent
-                    break
-            
-                if fallback is None and pat in ent and os.path.isdir(ent):
-                    fallback = ent
-                
-            # if we have no last part match, pick the first full path match
-            if ps is None:
-                ps = fallback
-            
-            if ps is None:
-                print "No matching entry in directory history"
-                return
-            else:
-                opts = {}
-                
-            
-        else:
-            #turn all non-space-escaping backslashes to slashes, 
-            # for c:\windows\directory\names\
-            parameter_s = re.sub(r'\\(?! )','/', parameter_s)            
-            opts,ps = self.parse_options(parameter_s,'qb',mode='string')
-        # jump to previous
-        if ps == '-':
-            try:
-                ps = self.shell.user_ns['_dh'][-2]
-            except IndexError:
-                raise UsageError('%cd -: No previous directory to change to.')
-        # jump to bookmark if needed
-        else:
-            if not os.path.isdir(ps) or opts.has_key('b'):
-                bkms = self.db.get('bookmarks', {})
-            
-                if bkms.has_key(ps):
-                    target = bkms[ps]
-                    print '(bookmark:%s) -> %s' % (ps,target)
-                    ps = target
-                else:
-                    if opts.has_key('b'):
-                        raise UsageError("Bookmark '%s' not found.  "
-                              "Use '%%bookmark -l' to see your bookmarks." % ps)
-            
-        # at this point ps should point to the target dir
-        if ps:
-            try:                
-                os.chdir(os.path.expanduser(ps))
-                if hasattr(self.shell, 'term_title') and self.shell.term_title:
-                    set_term_title('IPython: ' + abbrev_cwd())
-            except OSError:
-                print sys.exc_info()[1]
-            else:
-                cwd = os.getcwd()
-                dhist = self.shell.user_ns['_dh']
-                if oldcwd != cwd:
-                    dhist.append(cwd)
-                    self.db['dhist'] = compress_dhist(dhist)[-100:]
-                
-        else:
-            os.chdir(self.shell.home_dir)
-            if hasattr(self.shell, 'term_title') and self.shell.term_title:
-                set_term_title('IPython: ' + '~')
-            cwd = os.getcwd()
-            dhist = self.shell.user_ns['_dh']
-            
-            if oldcwd != cwd:
-                dhist.append(cwd)
-                self.db['dhist'] = compress_dhist(dhist)[-100:]
-        if not 'q' in opts and self.shell.user_ns['_dh']:
-            print self.shell.user_ns['_dh'][-1]
-
-
-    def magic_env(self, parameter_s=''):
-        """List environment variables."""
-        
-        return os.environ.data
-
-    def magic_pushd(self, parameter_s=''):
-        """Place the current dir on stack and change directory.
-        
-        Usage:\\
-          %pushd ['dirname']
-        """
-        
-        dir_s = self.shell.dir_stack
-        tgt = os.path.expanduser(parameter_s)
-        cwd = os.getcwd().replace(self.home_dir,'~')
-        if tgt:
-            self.magic_cd(parameter_s)
-        dir_s.insert(0,cwd)
-        return self.magic_dirs()
-
-    def magic_popd(self, parameter_s=''):
-        """Change to directory popped off the top of the stack.
-        """
-        if not self.shell.dir_stack:
-            raise UsageError("%popd on empty stack")
-        top = self.shell.dir_stack.pop(0)
-        self.magic_cd(top)
-        print "popd ->",top
-
-    def magic_dirs(self, parameter_s=''):
-        """Return the current directory stack."""
-
-        return self.shell.dir_stack
-
-    def magic_dhist(self, parameter_s=''):
-        """Print your history of visited directories.
-
-        %dhist       -> print full history\\
-        %dhist n     -> print last n entries only\\
-        %dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\\
-
-        This history is automatically maintained by the %cd command, and
-        always available as the global list variable _dh. You can use %cd -<n>
-        to go to directory number <n>.
-        
-        Note that most of time, you should view directory history by entering
-        cd -<TAB>.
-        
-        """
+        mode = kw.get("mode", "string")
+        if mode not in ["string", "list"]:
+            raise ValueError("incorrect mode given: %s" % mode)
+        # Get options
+        list_all = kw.get("list_all", 0)
+        posix = kw.get("posix", os.name == "posix")
+        strict = kw.get("strict", True)
 
-        dh = self.shell.user_ns['_dh']
-        if parameter_s:
-            try:
-                args = map(int,parameter_s.split())
-            except:
-                self.arg_err(Magic.magic_dhist)
-                return
-            if len(args) == 1:
-                ini,fin = max(len(dh)-(args[0]),0),len(dh)
-            elif len(args) == 2:
-                ini,fin = args
-            else:
-                self.arg_err(Magic.magic_dhist)
-                return
-        else:
-            ini,fin = 0,len(dh)
-        nlprint(dh,
-                header = 'Directory history (kept in _dh)',
-                start=ini,stop=fin)
-
-    @testdec.skip_doctest
-    def magic_sc(self, parameter_s=''):
-        """Shell capture - execute a shell command and capture its output.
-
-        DEPRECATED. Suboptimal, retained for backwards compatibility.
-        
-        You should use the form 'var = !command' instead. Example:
-         
-         "%sc -l myfiles = ls ~" should now be written as
-            
-         "myfiles = !ls ~"
-         
-        myfiles.s, myfiles.l and myfiles.n still apply as documented
-        below.
-
-        --
-        %sc [options] varname=command
-
-        IPython will run the given command using commands.getoutput(), and
-        will then update the user's interactive namespace with a variable
-        called varname, containing the value of the call.  Your command can
-        contain shell wildcards, pipes, etc.
-
-        The '=' sign in the syntax is mandatory, and the variable name you
-        supply must follow Python's standard conventions for valid names.
-        
-        (A special format without variable name exists for internal use)
-
-        Options:
-
-          -l: list output.  Split the output on newlines into a list before
-          assigning it to the given variable.  By default the output is stored
-          as a single string.
-
-          -v: verbose.  Print the contents of the variable.
-
-        In most cases you should not need to split as a list, because the
-        returned value is a special type of string which can automatically
-        provide its contents either as a list (split on newlines) or as a
-        space-separated string.  These are convenient, respectively, either
-        for sequential processing or to be passed to a shell command.
-
-        For example:
-
-        # all-random
-        
-            # Capture into variable a
-            In [1]: sc a=ls *py
-
-            # a is a string with embedded newlines
-            In [2]: a
-            Out[2]: 'setup.py\\nwin32_manual_post_install.py'
-
-            # which can be seen as a list:
-            In [3]: a.l
-            Out[3]: ['setup.py', 'win32_manual_post_install.py']
-
-            # or as a whitespace-separated string:
-            In [4]: a.s
-            Out[4]: 'setup.py win32_manual_post_install.py'
-
-            # a.s is useful to pass as a single command line:
-            In [5]: !wc -l $a.s
-              146 setup.py
-              130 win32_manual_post_install.py
-              276 total
-
-            # while the list form is useful to loop over:
-            In [6]: for f in a.l:
-              ...:      !wc -l $f
-              ...:
-            146 setup.py
-            130 win32_manual_post_install.py
-
-        Similiarly, the lists returned by the -l option are also special, in
-        the sense that you can equally invoke the .s attribute on them to
-        automatically get a whitespace-separated string from their contents:
-
-            In [7]: sc -l b=ls *py
-
-            In [8]: b
-            Out[8]: ['setup.py', 'win32_manual_post_install.py']
-
-            In [9]: b.s
-            Out[9]: 'setup.py win32_manual_post_install.py'
-
-        In summary, both the lists and strings used for ouptut capture have
-        the following special attributes:
-
-            .l (or .list) : value as list.
-            .n (or .nlstr): value as newline-separated string.
-            .s (or .spstr): value as space-separated string.
-        """
+        preserve_non_opts = kw.get("preserve_non_opts", False)
+        remainder_arg_str = arg_str
 
-        opts,args = self.parse_options(parameter_s,'lv')
-        # Try to get a variable name and command to run
-        try:
-            # the variable name must be obtained from the parse_options
-            # output, which uses shlex.split to strip options out.
-            var,_ = args.split('=',1)
-            var = var.strip()
-            # But the the command has to be extracted from the original input
-            # parameter_s, not on what parse_options returns, to avoid the
-            # quote stripping which shlex.split performs on it.
-            _,cmd = parameter_s.split('=',1)
-        except ValueError:
-            var,cmd = '',''
-        # If all looks ok, proceed
-        split = 'l' in opts
-        out = self.shell.getoutput(cmd, split=split)
-        if opts.has_key('v'):
-            print '%s ==\n%s' % (var,pformat(out))
-        if var:
-            self.shell.user_ns.update({var:out})
-        else:
-            return out
-
-    def magic_sx(self, parameter_s=''):
-        """Shell execute - run a shell command and capture its output.
-
-        %sx command
-
-        IPython will run the given command using commands.getoutput(), and
-        return the result formatted as a list (split on '\\n').  Since the
-        output is _returned_, it will be stored in ipython's regular output
-        cache Out[N] and in the '_N' automatic variables.
-
-        Notes:
-
-        1) If an input line begins with '!!', then %sx is automatically
-        invoked.  That is, while:
-          !ls
-        causes ipython to simply issue system('ls'), typing
-          !!ls
-        is a shorthand equivalent to:
-          %sx ls
-        
-        2) %sx differs from %sc in that %sx automatically splits into a list,
-        like '%sc -l'.  The reason for this is to make it as easy as possible
-        to process line-oriented shell output via further python commands.
-        %sc is meant to provide much finer control, but requires more
-        typing.
-
-        3) Just like %sc -l, this is a list with special attributes:
-
-          .l (or .list) : value as list.
-          .n (or .nlstr): value as newline-separated string.
-          .s (or .spstr): value as whitespace-separated string.
-
-        This is very useful when trying to use such lists as arguments to
-        system commands."""
-
-        if parameter_s:
-            return self.shell.getoutput(parameter_s)
-
-    
-    def magic_bookmark(self, parameter_s=''):
-        """Manage IPython's bookmark system.
-
-        %bookmark <name>       - set bookmark to current dir
-        %bookmark <name> <dir> - set bookmark to <dir>
-        %bookmark -l           - list all bookmarks
-        %bookmark -d <name>    - remove bookmark
-        %bookmark -r           - remove all bookmarks
-
-        You can later on access a bookmarked folder with:
-          %cd -b <name>
-        or simply '%cd <name>' if there is no directory called <name> AND
-        there is such a bookmark defined.
-
-        Your bookmarks persist through IPython sessions, but they are
-        associated with each profile."""
-
-        opts,args = self.parse_options(parameter_s,'drl',mode='list')
-        if len(args) > 2:
-            raise UsageError("%bookmark: too many arguments")
-
-        bkms = self.db.get('bookmarks',{})
-            
-        if opts.has_key('d'):
+        # Check if we have more than one argument to warrant extra processing:
+        odict: dict[str, t.Any] = {}  # Dictionary with options
+        args = arg_str.split()
+        if len(args) >= 1:
+            # If the list of inputs only has 0 or 1 thing in it, there's no
+            # need to look for options
+            argv = arg_split(arg_str, posix, strict)  # type: ignore[no-untyped-call]
+            # Do regular option processing
             try:
-                todel = args[0]
-            except IndexError:
+                opts, args = getopt(argv, opt_str, long_opts)
+            except GetoptError as e:
                 raise UsageError(
-                    "%bookmark -d: must provide a bookmark to delete")
-            else:
+                    '%s (allowed: "%s"%s)'
+                    % (e.msg, opt_str, " ".join(("",) + long_opts) if long_opts else "")
+                ) from e
+            for o, a in opts:
+                if mode == "string" and preserve_non_opts:
+                    # remove option-parts from the original args-string and preserve remaining-part.
+                    # This relies on the arg_split(...) and getopt(...)'s impl spec, that the parsed options are
+                    # returned in the original order.
+                    remainder_arg_str = remainder_arg_str.replace(o, "", 1).replace(
+                        a, "", 1
+                    )
+                if o.startswith("--"):
+                    o = o[2:]
+                else:
+                    o = o[1:]
                 try:
-                    del bkms[todel]
+                    odict[o].append(a)
+                except AttributeError:
+                    odict[o] = [odict[o], a]
                 except KeyError:
-                    raise UsageError(
-                        "%%bookmark -d: Can't delete bookmark '%s'" % todel)
-
-        elif opts.has_key('r'):
-            bkms = {}
-        elif opts.has_key('l'):
-            bks = bkms.keys()
-            bks.sort()
-            if bks:
-                size = max(map(len,bks))
-            else:
-                size = 0
-            fmt = '%-'+str(size)+'s -> %s'
-            print 'Current bookmarks:'
-            for bk in bks:
-                print fmt % (bk,bkms[bk])
-        else:
-            if not args:
-                raise UsageError("%bookmark: You must specify the bookmark name")
-            elif len(args)==1:
-                bkms[args[0]] = os.getcwd()
-            elif len(args)==2:
-                bkms[args[0]] = args[1]
-        self.db['bookmarks'] = bkms
-
-    def magic_pycat(self, parameter_s=''):
-        """Show a syntax-highlighted file through a pager.
-
-        This magic is similar to the cat utility, but it will assume the file
-        to be Python source and will show it with syntax highlighting. """
-        
-        try:
-            filename = get_py_filename(parameter_s)
-            cont = file_read(filename)
-        except IOError:
-            try:
-                cont = eval(parameter_s,self.user_ns)
-            except NameError:
-                cont = None
-        if cont is None:
-            print "Error: no such file or variable"
-            return
-
-        page.page(self.shell.pycolorize(cont))
+                    if list_all:
+                        odict[o] = [a]
+                    else:
+                        odict[o] = a
 
-    def _rerun_pasted(self):
-        """ Rerun a previously pasted command.
-        """
-        b = self.user_ns.get('pasted_block', None)
-        if b is None:
-            raise UsageError('No previous pasted block available')
-        print "Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b))
-        exec b in self.user_ns
-
-    def _get_pasted_lines(self, sentinel):
-        """ Yield pasted lines until the user enters the given sentinel value.
-        """
-        from IPython.core import interactiveshell
-        print "Pasting code; enter '%s' alone on the line to stop." % sentinel
-        while True:
-            l = interactiveshell.raw_input_original(':')
-            if l == sentinel:
-                return
+        # Prepare opts,args for return
+        opts = Struct(odict)  # type: ignore[assignment, no-untyped-call]
+        if mode == "string":
+            if preserve_non_opts:
+                args = remainder_arg_str.lstrip()  # type: ignore[assignment]
             else:
-                yield l
-
-    def _strip_pasted_lines_for_code(self, raw_lines):
-        """ Strip non-code parts of a sequence of lines to return a block of
-        code.
-        """
-        # Regular expressions that declare text we strip from the input:
-        strip_re =  [r'^\s*In \[\d+\]:', # IPython input prompt
-                     r'^\s*(\s?>)+', # Python input prompt
-                     r'^\s*\.{3,}', # Continuation prompts
-                     r'^\++',
-                     ]
-
-        strip_from_start = map(re.compile,strip_re)
-        
-        lines = []
-        for l in raw_lines:
-            for pat in strip_from_start: 
-                l = pat.sub('',l)
-            lines.append(l)
-                         
-        block = "\n".join(lines) + '\n'
-        #print "block:\n",block
-        return block
-
-    def _execute_block(self, block, par):
-        """ Execute a block, or store it in a variable, per the user's request.
-        """
-        if not par:
-            b = textwrap.dedent(block)
-            self.user_ns['pasted_block'] = b
-            exec b in self.user_ns
-        else:
-            self.user_ns[par] = SList(block.splitlines())
-            print "Block assigned to '%s'" % par
-
-    def magic_quickref(self,arg):
-        """ Show a quick reference sheet """
-        import IPython.core.usage
-        qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
-        
-        page.page(qr)
-
-    def magic_doctest_mode(self,parameter_s=''):
-        """Toggle doctest mode on and off.
-
-        This mode is intended to make IPython behave as much as possible like a
-        plain Python shell, from the perspective of how its prompts, exceptions
-        and output look.  This makes it easy to copy and paste parts of a
-        session into doctests.  It does so by:
-
-        - Changing the prompts to the classic ``>>>`` ones.
-        - Changing the exception reporting mode to 'Plain'.
-        - Disabling pretty-printing of output.
-
-        Note that IPython also supports the pasting of code snippets that have
-        leading '>>>' and '...' prompts in them.  This means that you can paste
-        doctests from files or docstrings (even if they have leading
-        whitespace), and the code will execute correctly.  You can then use
-        '%history -t' to see the translated history; this will give you the
-        input after removal of all the leading prompts and whitespace, which
-        can be pasted back into an editor.
-
-        With these features, you can switch into this mode easily whenever you
-        need to do testing and changes to doctests, without having to leave
-        your existing IPython session.
-        """
-
-        from IPython.utils.ipstruct import Struct
-
-        # Shorthands
-        shell = self.shell
-        oc = shell.displayhook
-        meta = shell.meta
-        disp_formatter = self.shell.display_formatter
-        ptformatter = disp_formatter.formatters['text/plain']
-        # dstore is a data store kept in the instance metadata bag to track any
-        # changes we make, so we can undo them later.
-        dstore = meta.setdefault('doctest_mode',Struct())
-        save_dstore = dstore.setdefault
-
-        # save a few values we'll need to recover later
-        mode = save_dstore('mode',False)
-        save_dstore('rc_pprint',ptformatter.pprint)
-        save_dstore('xmode',shell.InteractiveTB.mode)
-        save_dstore('rc_separate_out',shell.separate_out)
-        save_dstore('rc_separate_out2',shell.separate_out2)
-        save_dstore('rc_prompts_pad_left',shell.prompts_pad_left)
-        save_dstore('rc_separate_in',shell.separate_in)
-        save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
-
-        if mode == False:
-            # turn on
-            oc.prompt1.p_template = '>>> '
-            oc.prompt2.p_template = '... '
-            oc.prompt_out.p_template = ''
-
-            # Prompt separators like plain python
-            oc.input_sep = oc.prompt1.sep = ''
-            oc.output_sep = ''
-            oc.output_sep2 = ''
-
-            oc.prompt1.pad_left = oc.prompt2.pad_left = \
-                                  oc.prompt_out.pad_left = False
-
-            ptformatter.pprint = False
-            disp_formatter.plain_text_only = True
-            
-            shell.magic_xmode('Plain')
-        else:
-            # turn off
-            oc.prompt1.p_template = shell.prompt_in1
-            oc.prompt2.p_template = shell.prompt_in2
-            oc.prompt_out.p_template = shell.prompt_out
-
-            oc.input_sep = oc.prompt1.sep = dstore.rc_separate_in
-
-            oc.output_sep = dstore.rc_separate_out
-            oc.output_sep2 = dstore.rc_separate_out2
-
-            oc.prompt1.pad_left = oc.prompt2.pad_left = \
-                         oc.prompt_out.pad_left = dstore.rc_prompts_pad_left
-
-            ptformatter.pprint = dstore.rc_pprint
-            disp_formatter.plain_text_only = dstore.rc_plain_text_only
-
-            shell.magic_xmode(dstore.xmode)
-
-        # Store new mode and inform
-        dstore.mode = bool(1-int(mode))
-        mode_label = ['OFF','ON'][dstore.mode]
-        print 'Doctest mode is:', mode_label
-
-    def magic_gui(self, parameter_s=''):
-        """Enable or disable IPython GUI event loop integration.
-
-        %gui [GUINAME]
-
-        This magic replaces IPython's threaded shells that were activated
-        using the (pylab/wthread/etc.) command line flags.  GUI toolkits
-        can now be enabled, disabled and swtiched at runtime and keyboard
-        interrupts should work without any problems.  The following toolkits
-        are supported:  wxPython, PyQt4, PyGTK, and Tk::
+                args = " ".join(args)  # type: ignore[assignment]
 
-            %gui wx      # enable wxPython event loop integration
-            %gui qt4|qt  # enable PyQt4 event loop integration
-            %gui gtk     # enable PyGTK event loop integration
-            %gui tk      # enable Tk event loop integration
-            %gui         # disable all event loop integration
+        return opts, args
 
-        WARNING:  after any of these has been called you can simply create
-        an application object, but DO NOT start the event loop yourself, as
-        we have already handled that.
-        """
-        from IPython.lib.inputhook import enable_gui
-        opts, arg = self.parse_options(parameter_s, '')
-        if arg=='': arg = None
-        return enable_gui(arg)
-
-    def magic_load_ext(self, module_str):
-        """Load an IPython extension by its module name."""
-        return self.extension_manager.load_extension(module_str)
-
-    def magic_unload_ext(self, module_str):
-        """Unload an IPython extension by its module name."""
-        self.extension_manager.unload_extension(module_str)
-
-    def magic_reload_ext(self, module_str):
-        """Reload an IPython extension by its module name."""
-        self.extension_manager.reload_extension(module_str)
-
-    @testdec.skip_doctest
-    def magic_install_profiles(self, s):
-        """Install the default IPython profiles into the .ipython dir.
-
-        If the default profiles have already been installed, they will not
-        be overwritten. You can force overwriting them by using the ``-o``
-        option::
-
-            In [1]: %install_profiles -o
-        """
-        if '-o' in s:
-            overwrite = True
-        else:
-            overwrite = False
-        from IPython.config import profile
-        profile_dir = os.path.split(profile.__file__)[0]
-        ipython_dir = self.ipython_dir
-        files = os.listdir(profile_dir)
-
-        to_install = []
-        for f in files:
-            if f.startswith('ipython_config'):
-                src = os.path.join(profile_dir, f)
-                dst = os.path.join(ipython_dir, f)
-                if (not os.path.isfile(dst)) or overwrite:
-                    to_install.append((f, src, dst))
-        if len(to_install)>0:
-            print "Installing profiles to: ", ipython_dir
-            for (f, src, dst) in to_install:
-                shutil.copy(src, dst)
-                print "    %s" % f
-
-    def magic_install_default_config(self, s):
-        """Install IPython's default config file into the .ipython dir.
-
-        If the default config file (:file:`ipython_config.py`) is already
-        installed, it will not be overwritten. You can force overwriting
-        by using the ``-o`` option::
-
-            In [1]: %install_default_config
-        """
-        if '-o' in s:
-            overwrite = True
-        else:
-            overwrite = False
-        from IPython.config import default
-        config_dir = os.path.split(default.__file__)[0]
-        ipython_dir = self.ipython_dir
-        default_config_file_name = 'ipython_config.py'
-        src = os.path.join(config_dir, default_config_file_name)
-        dst = os.path.join(ipython_dir, default_config_file_name)
-        if (not os.path.isfile(dst)) or overwrite:
-            shutil.copy(src, dst)
-            print "Installing default config file: %s" % dst
+class MagicAlias:
+    """An alias to another magic function.
 
-    # Pylab support: simple wrappers that activate pylab, load gui input
-    # handling and modify slightly %run
+    An alias is determined by its magic name and magic kind. Lookup
+    is done at call time, so if the underlying magic changes the alias
+    will call the new function.
 
-    @testdec.skip_doctest
-    def _pylab_magic_run(self, parameter_s=''):
-        Magic.magic_run(self, parameter_s,
-                        runner=mpl_runner(self.shell.safe_execfile))
+    Use the :meth:`MagicsManager.register_alias` method or the
+    `%alias_magic` magic function to create and register a new alias.
+    """
 
-    _pylab_magic_run.__doc__ = magic_run.__doc__
-
-    @testdec.skip_doctest
-    def magic_pylab(self, s):
-        """Load numpy and matplotlib to work interactively.
-
-        %pylab [GUINAME]
+    def __init__(
+        self,
+        shell: InteractiveShell,
+        magic_name: str,
+        magic_kind: _MagicKind,
+        magic_params: str | None = None,
+    ) -> None:
+        self.shell = shell
+        self.magic_name = magic_name
+        self.magic_params = magic_params
+        self.magic_kind = magic_kind
 
-        This function lets you activate pylab (matplotlib, numpy and
-        interactive support) at any point during an IPython session.
+        self.pretty_target = "%s%s" % (magic_escapes[self.magic_kind], self.magic_name)
+        self.__doc__ = "Alias for `%s`." % self.pretty_target
 
-        It will import at the top level numpy as np, pyplot as plt, matplotlib,
-        pylab and mlab, as well as all names from numpy and pylab.
+        self._in_call = False
 
-        Parameters
-        ----------
-        guiname : optional
-          One of the valid arguments to the %gui magic ('qt', 'wx', 'gtk', 'osx' or
-          'tk').  If given, the corresponding Matplotlib backend is used,
-          otherwise matplotlib's default (which you can override in your
-          matplotlib config file) is used.
-
-        Examples
-        --------
-        In this case, where the MPL default is TkAgg:
-        In [2]: %pylab
-
-        Welcome to pylab, a matplotlib-based Python environment.
-        Backend in use: TkAgg
-        For more information, type 'help(pylab)'.
-
-        But you can explicitly request a different backend:
-        In [3]: %pylab qt
-
-        Welcome to pylab, a matplotlib-based Python environment.
-        Backend in use: Qt4Agg
-        For more information, type 'help(pylab)'.
-        """
-        self.shell.enable_pylab(s)
-
-    def magic_tb(self, s):
-        """Print the last traceback with the currently active exception mode.
-
-        See %xmode for changing exception reporting modes."""
-        self.shell.showtraceback()
-    
-    @testdec.skip_doctest
-    def magic_precision(self, s=''):
-        """Set floating point precision for pretty printing.
-        
-        Can set either integer precision or a format string.
-        
-        If numpy has been imported and precision is an int,
-        numpy display precision will also be set, via ``numpy.set_printoptions``.
-        
-        If no argument is given, defaults will be restored.
-        
-        Examples
-        --------
-        ::
-        
-            In [1]: from math import pi
-        
-            In [2]: %precision 3
-            Out[2]: '%.3f'
-        
-            In [3]: pi
-            Out[3]: 3.142
-        
-            In [4]: %precision %i
-            Out[4]: '%i'
-        
-            In [5]: pi
-            Out[5]: 3
-        
-            In [6]: %precision %e
-            Out[6]: '%e'
-        
-            In [7]: pi**10
-            Out[7]: 9.364805e+04
-        
-            In [8]: %precision
-            Out[8]: '%r'
-        
-            In [9]: pi**10
-            Out[9]: 93648.047476082982
-        
-        """
-        
-        ptformatter = self.shell.display_formatter.formatters['text/plain']
-        ptformatter.float_precision = s
-        return ptformatter.float_format
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Call the magic alias."""
+        fn = self.shell.find_magic(self.magic_name, self.magic_kind)  # type: ignore[no-untyped-call]
+        if fn is None:
+            raise UsageError("Magic `%s` not found." % self.pretty_target)
 
-# end Magic
+        # Protect against infinite recursion.
+        if self._in_call:
+            raise UsageError(
+                "Infinite recursion detected; magic aliases cannot call themselves."
+            )
+        self._in_call = True
+        try:
+            if self.magic_params:
+                args_list = list(args)
+                args_list[0] = self.magic_params + " " + args[0]
+                args = tuple(args_list)
+            return fn(*args, **kwargs)
+        finally:
+            self._in_call = False
diff --git a/IPython/core/magic_arguments.py b/IPython/core/magic_arguments.py
index e2a5450ce8b..4871f56d3dd 100644
--- a/IPython/core/magic_arguments.py
+++ b/IPython/core/magic_arguments.py
@@ -1,4 +1,4 @@
-''' A decorator-based method of constructing IPython magics with `argparse`
+'''A decorator-based method of constructing IPython magics with `argparse`
 option handling.
 
 New magic functions can be defined like so::
@@ -27,30 +27,112 @@ def magic_cool(self, arg):
 
     In[1]: %cool?
         %cool [-o OPTION] arg
-        
+
         A really cool magic command.
-        
+
         positional arguments:
           arg                   An integer positional argument.
-        
+
         optional arguments:
           -o OPTION, --option OPTION
                                 An optional argument.
 
+Here is an elaborated example that uses default parameters in `argument` and calls the `args` in the cell magic::
+
+    from IPython.core.magic import register_cell_magic
+    from IPython.core.magic_arguments import (argument, magic_arguments,
+                                            parse_argstring)
+
+
+    @magic_arguments()
+    @argument(
+        "--option",
+        "-o",
+        help=("Add an option here"),
+    )
+    @argument(
+        "--style",
+        "-s",
+        default="foo",
+        help=("Add some style arguments"),
+    )
+    @register_cell_magic
+    def my_cell_magic(line, cell):
+        args = parse_argstring(my_cell_magic, line)
+        print(f"{args.option=}")
+        print(f"{args.style=}")
+        print(f"{cell=}")
+
+In a jupyter notebook, this cell magic can be executed like this::
+
+    %%my_cell_magic -o Hello
+    print("bar")
+    i = 42
+
+Inheritance diagram:
+
+.. inheritance-diagram:: IPython.core.magic_arguments
+   :parts: 3
+
 '''
 #-----------------------------------------------------------------------------
-# Copyright (c) 2010, IPython Development Team.
+# Copyright (C) 2010-2011, IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
+import argparse
+import re
 
 # Our own imports
-from IPython.external import argparse
 from IPython.core.error import UsageError
+from IPython.utils.decorators import undoc
 from IPython.utils.process import arg_split
+from IPython.utils.text import dedent
 
+NAME_RE = re.compile(r"[a-zA-Z][a-zA-Z0-9_-]*$")
+
+@undoc
+class MagicHelpFormatter(argparse.RawDescriptionHelpFormatter):
+    """A HelpFormatter with a couple of changes to meet our needs.
+    """
+    # Modified to dedent text.
+    def _fill_text(self, text, width, indent):
+        return argparse.RawDescriptionHelpFormatter._fill_text(self, dedent(text), width, indent)
+
+    # Modified to wrap argument placeholders in <> where necessary.
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+
+        else:
+            parts = []
+
+            # if the Optional doesn't take a value, format is:
+            #    -s, --long
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+
+            # if the Optional takes a value, format is:
+            #    -s ARGS, --long ARGS
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                # IPYTHON MODIFICATION: If args_string is not a plain name, wrap
+                # it in <> so it's valid RST.
+                if not NAME_RE.match(args_string):
+                    args_string = "<%s>" % args_string
+                for option_string in action.option_strings:
+                    parts.append('%s %s' % (option_string, args_string))
+
+            return ', '.join(parts)
+
+    # Override the default prefix ('usage') to our % magic escape,
+    # in a code block.
+    def add_usage(self, usage, actions, groups, prefix="::\n\n  %"):
+        super(MagicHelpFormatter, self).add_usage(usage, actions, groups, prefix)
 
 class MagicArgumentParser(argparse.ArgumentParser):
     """ An ArgumentParser tweaked for use by IPython magics.
@@ -60,9 +142,8 @@ def __init__(self,
                  usage=None,
                  description=None,
                  epilog=None,
-                 version=None,
                  parents=None,
-                 formatter_class=argparse.HelpFormatter,
+                 formatter_class=MagicHelpFormatter,
                  prefix_chars='-',
                  argument_default=None,
                  conflict_handler='error',
@@ -70,7 +151,7 @@ def __init__(self,
         if parents is None:
             parents = []
         super(MagicArgumentParser, self).__init__(prog=prog, usage=usage,
-            description=description, epilog=epilog, version=version,
+            description=description, epilog=epilog,
             parents=parents, formatter_class=formatter_class,
             prefix_chars=prefix_chars, argument_default=argument_default,
             conflict_handler=conflict_handler, add_help=add_help)
@@ -80,10 +161,12 @@ def error(self, message):
         """
         raise UsageError(message)
 
-    def parse_argstring(self, argstring):
+    def parse_argstring(self, argstring, *, partial=False):
         """ Split a string into an argument list and parse that argument list.
         """
-        argv = arg_split(argstring)
+        argv = arg_split(argstring, strict=not partial)
+        if partial:
+            return self.parse_known_args(argv)
         return self.parse_args(argv)
 
 
@@ -103,23 +186,16 @@ def construct_parser(magic_func):
         if result is not None:
             group = result
 
-    # Replace the starting 'usage: ' with IPython's %.
-    help_text = parser.format_help()
-    if help_text.startswith('usage: '):
-        help_text = help_text.replace('usage: ', '%', 1)
-    else:
-        help_text = '%' + help_text
-
     # Replace the magic function's docstring with the full help text.
-    magic_func.__doc__ = help_text
+    magic_func.__doc__ = parser.format_help()
 
     return parser
 
 
-def parse_argstring(magic_func, argstring):
+def parse_argstring(magic_func, argstring, *, partial=False):
     """ Parse the string of arguments for the given magic function.
     """
-    return magic_func.parser.parse_argstring(argstring)
+    return magic_func.parser.parse_argstring(argstring, partial=partial)
 
 
 def real_name(magic_func):
@@ -131,7 +207,7 @@ def real_name(magic_func):
     return getattr(magic_func, 'argcmd_name', magic_name)
 
 
-class ArgDecorator(object):
+class ArgDecorator:
     """ Base class for decorators to add ArgumentParser information to a method.
     """
 
@@ -168,11 +244,17 @@ def __call__(self, func):
         return func
 
 
-class argument(ArgDecorator):
-    """ Store arguments and keywords to pass to add_argument().
+class ArgMethodWrapper(ArgDecorator):
+
+    """
+    Base class to define a wrapper for ArgumentParser method.
+
+    Child class must define either `_method_name` or `add_to_parser`.
 
-    Instances also serve to decorate command methods.
     """
+
+    _method_name: str
+
     def __init__(self, *args, **kwds):
         self.args = args
         self.kwds = kwds
@@ -182,18 +264,31 @@ def add_to_parser(self, parser, group):
         """
         if group is not None:
             parser = group
-        parser.add_argument(*self.args, **self.kwds)
+        getattr(parser, self._method_name)(*self.args, **self.kwds)
         return None
 
 
-class argument_group(ArgDecorator):
+class argument(ArgMethodWrapper):
+    """ Store arguments and keywords to pass to add_argument().
+
+    Instances also serve to decorate command methods.
+    """
+    _method_name = 'add_argument'
+
+
+class defaults(ArgMethodWrapper):
+    """ Store arguments and keywords to pass to set_defaults().
+
+    Instances also serve to decorate command methods.
+    """
+    _method_name = 'set_defaults'
+
+
+class argument_group(ArgMethodWrapper):
     """ Store arguments and keywords to pass to add_argument_group().
 
     Instances also serve to decorate command methods.
     """
-    def __init__(self, *args, **kwds):
-        self.args = args
-        self.kwds = kwds
 
     def add_to_parser(self, parser, group):
         """ Add this object's information to the parser.
diff --git a/IPython/core/magics/__init__.py b/IPython/core/magics/__init__.py
new file mode 100644
index 00000000000..a6c5f474c15
--- /dev/null
+++ b/IPython/core/magics/__init__.py
@@ -0,0 +1,42 @@
+"""Implementation of all the magic functions built into IPython.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+from ..magic import Magics, magics_class
+from .auto import AutoMagics
+from .basic import BasicMagics, AsyncMagics
+from .code import CodeMagics, MacroToEdit
+from .config import ConfigMagics
+from .display import DisplayMagics
+from .execution import ExecutionMagics
+from .extension import ExtensionMagics
+from .history import HistoryMagics
+from .logging import LoggingMagics
+from .namespace import NamespaceMagics
+from .osm import OSMagics
+from .packaging import PackagingMagics
+from .pylab import PylabMagics
+from .script import ScriptMagics
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class UserMagics(Magics):
+    """Placeholder for user-defined magics to be added at runtime.
+
+    All magics are eventually merged into a single namespace at runtime, but we
+    use this class to isolate the magics defined dynamically by the user into
+    their own class.
+    """
diff --git a/IPython/core/magics/ast_mod.py b/IPython/core/magics/ast_mod.py
new file mode 100644
index 00000000000..dc3c5bc7683
--- /dev/null
+++ b/IPython/core/magics/ast_mod.py
@@ -0,0 +1,330 @@
+"""
+This module contains utility function and classes to inject simple ast
+transformations based on code strings into IPython. While it is already possible
+with ast-transformers it is not easy to directly manipulate ast.
+
+
+IPython has pre-code and post-code hooks, but are ran from within the IPython
+machinery so may be inappropriate, for example for performance measurement.
+
+This module give you tools to simplify this, and expose 2 classes:
+
+- `ReplaceCodeTransformer` which is a simple ast transformer based on code
+  template,
+
+and for advance case:
+
+- `Mangler` which is a simple ast transformer that mangle names in the ast.
+
+
+Example, let's try to make a simple version of the ``timeit`` magic, that run a
+code snippet 10 times and print the average time taken.
+
+Basically we want to run :
+
+.. code-block:: python
+
+    from time import perf_counter
+    now = perf_counter()
+    for i in range(10):
+        __code__ # our code
+    print(f"Time taken: {(perf_counter() - now)/10}")
+    __ret__ # the result of the last statement
+
+Where ``__code__`` is the code snippet we want to run, and ``__ret__`` is the
+result, so that if we for example run `dataframe.head()` IPython still display
+the head of dataframe instead of nothing.
+
+Here is a complete example of a file `timit2.py` that define such a magic:
+
+.. code-block:: python
+
+    from IPython.core.magic import (
+        Magics,
+        magics_class,
+        line_cell_magic,
+    )
+    from IPython.core.magics.ast_mod import ReplaceCodeTransformer
+    from textwrap import dedent
+    import ast
+
+    template = template = dedent('''
+        from time import perf_counter
+        now = perf_counter()
+        for i in range(10):
+            __code__
+        print(f"Time taken: {(perf_counter() - now)/10}")
+        __ret__
+    '''
+    )
+
+
+    @magics_class
+    class AstM(Magics):
+        @line_cell_magic
+        def t2(self, line, cell):
+            transformer = ReplaceCodeTransformer.from_string(template)
+            transformer.debug = True
+            transformer.mangler.debug = True
+            new_code = transformer.visit(ast.parse(cell))
+            return exec(compile(new_code, "<ast>", "exec"))
+
+
+    def load_ipython_extension(ip):
+        ip.register_magics(AstM)
+
+
+
+.. code-block:: python
+
+    In [1]: %load_ext timit2
+
+    In [2]: %%t2
+       ...: import time
+       ...: time.sleep(0.05)
+       ...:
+       ...:
+    Time taken: 0.05435649999999441
+
+
+If you wish to ran all the code enter in IPython in an ast transformer, you can
+do so as well:
+
+.. code-block:: python
+
+    In [1]: from IPython.core.magics.ast_mod import ReplaceCodeTransformer
+       ...:
+       ...: template = '''
+       ...: from time import perf_counter
+       ...: now = perf_counter()
+       ...: __code__
+       ...: print(f"Code ran in {perf_counter()-now}")
+       ...: __ret__'''
+       ...:
+       ...: get_ipython().ast_transformers.append(ReplaceCodeTransformer.from_string(template))
+
+    In [2]: 1+1
+    Code ran in 3.40410006174352e-05
+    Out[2]: 2
+
+
+
+Hygiene and Mangling
+--------------------
+
+The ast transformer above is not hygienic, it may not work if the user code use
+the same variable names as the ones used in the template. For example.
+
+To help with this by default the `ReplaceCodeTransformer` will mangle all names
+staring with 3 underscores. This is a simple heuristic that should work in most
+case, but can be cumbersome in some case. We provide a `Mangler` class that can
+be overridden to change the mangling heuristic, or simply use the `mangle_all`
+utility function. It will _try_ to mangle all names (except `__ret__` and
+`__code__`), but this include builtins (``print``, ``range``, ``type``) and
+replace those by invalid identifiers py prepending ``mangle-``:
+``mangle-print``, ``mangle-range``, ``mangle-type`` etc. This is not a problem
+as currently Python AST support invalid identifiers, but it may not be the case
+in the future.
+
+You can set `ReplaceCodeTransformer.debug=True` and
+`ReplaceCodeTransformer.mangler.debug=True` to see the code after mangling and
+transforming:
+
+.. code-block:: python
+
+
+    In [1]: from IPython.core.magics.ast_mod import ReplaceCodeTransformer, mangle_all
+       ...:
+       ...: template = '''
+       ...: from builtins import type, print
+       ...: from time import perf_counter
+       ...: now = perf_counter()
+       ...: __code__
+       ...: print(f"Code ran in {perf_counter()-now}")
+       ...: __ret__'''
+       ...:
+       ...: transformer = ReplaceCodeTransformer.from_string(template, mangling_predicate=mangle_all)
+
+
+    In [2]: transformer.debug = True
+       ...: transformer.mangler.debug = True
+       ...: get_ipython().ast_transformers.append(transformer)
+
+    In [3]: 1+1
+    Mangling Alias mangle-type
+    Mangling Alias mangle-print
+    Mangling Alias mangle-perf_counter
+    Mangling now
+    Mangling perf_counter
+    Not mangling __code__
+    Mangling print
+    Mangling perf_counter
+    Mangling now
+    Not mangling __ret__
+    ---- Transformed code ----
+    from builtins import type as mangle-type, print as mangle-print
+    from time import perf_counter as mangle-perf_counter
+    mangle-now = mangle-perf_counter()
+    ret-tmp = 1 + 1
+    mangle-print(f'Code ran in {mangle-perf_counter() - mangle-now}')
+    ret-tmp
+    ---- ---------------- ----
+    Code ran in 0.00013654199938173406
+    Out[3]: 2
+
+
+"""
+
+__skip_doctest__ = True
+
+
+from ast import (
+    NodeTransformer,
+    Store,
+    Load,
+    Name,
+    Expr,
+    Assign,
+    Module,
+    Import,
+    ImportFrom,
+)
+import ast
+import copy
+
+from typing import Dict, Optional, Union
+
+
+mangle_all = lambda name: False if name in ("__ret__", "__code__") else True
+
+
+class Mangler(NodeTransformer):
+    """
+    Mangle given names in and ast tree to make sure they do not conflict with
+    user code.
+    """
+
+    enabled: bool = True
+    debug: bool = False
+
+    def log(self, *args, **kwargs):
+        if self.debug:
+            print(*args, **kwargs)
+
+    def __init__(self, predicate=None):
+        if predicate is None:
+            predicate = lambda name: name.startswith("___")
+        self.predicate = predicate
+
+    def visit_Name(self, node):
+        if self.predicate(node.id):
+            self.log("Mangling", node.id)
+            # Once in the ast we do not need
+            # names to be valid identifiers.
+            node.id = "mangle-" + node.id
+        else:
+            self.log("Not mangling", node.id)
+        return node
+
+    def visit_FunctionDef(self, node):
+        if self.predicate(node.name):
+            self.log("Mangling", node.name)
+            node.name = "mangle-" + node.name
+        else:
+            self.log("Not mangling", node.name)
+
+        for arg in node.args.args:
+            if self.predicate(arg.arg):
+                self.log("Mangling function arg", arg.arg)
+                arg.arg = "mangle-" + arg.arg
+            else:
+                self.log("Not mangling function arg", arg.arg)
+        return self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ImportFrom):
+        return self._visit_Import_and_ImportFrom(node)
+
+    def visit_Import(self, node: Import):
+        return self._visit_Import_and_ImportFrom(node)
+
+    def _visit_Import_and_ImportFrom(self, node: Union[Import, ImportFrom]):
+        for alias in node.names:
+            asname = alias.name if alias.asname is None else alias.asname
+            if self.predicate(asname):
+                new_name: str = "mangle-" + asname
+                self.log("Mangling Alias", new_name)
+                alias.asname = new_name
+            else:
+                self.log("Not mangling Alias", alias.asname)
+        return node
+
+
+class ReplaceCodeTransformer(NodeTransformer):
+    enabled: bool = True
+    debug: bool = False
+    mangler: Mangler
+
+    def __init__(
+        self, template: Module, mapping: Optional[Dict] = None, mangling_predicate=None
+    ):
+        assert isinstance(mapping, (dict, type(None)))
+        assert isinstance(mangling_predicate, (type(None), type(lambda: None)))
+        assert isinstance(template, ast.Module)
+        self.template = template
+        self.mangler = Mangler(predicate=mangling_predicate)
+        if mapping is None:
+            mapping = {}
+        self.mapping = mapping
+
+    @classmethod
+    def from_string(
+        cls, template: str, mapping: Optional[Dict] = None, mangling_predicate=None
+    ):
+        return cls(
+            ast.parse(template), mapping=mapping, mangling_predicate=mangling_predicate
+        )
+
+    def visit_Module(self, code):
+        if not self.enabled:
+            return code
+        # if not isinstance(code, ast.Module):
+        # recursively called...
+        #    return generic_visit(self, code)
+        last = code.body[-1]
+        if isinstance(last, Expr):
+            code.body.pop()
+            code.body.append(Assign([Name("ret-tmp", ctx=Store())], value=last.value))
+            ast.fix_missing_locations(code)
+            ret = Expr(value=Name("ret-tmp", ctx=Load()))
+            ret = ast.fix_missing_locations(ret)
+            self.mapping["__ret__"] = ret
+        else:
+            self.mapping["__ret__"] = ast.parse("None").body[0]
+        self.mapping["__code__"] = code.body
+        tpl = ast.fix_missing_locations(self.template)
+
+        tx = copy.deepcopy(tpl)
+        tx = self.mangler.visit(tx)
+        node = self.generic_visit(tx)
+        node_2 = ast.fix_missing_locations(node)
+        if self.debug:
+            print("---- Transformed code ----")
+            print(ast.unparse(node_2))
+            print("---- ---------------- ----")
+        return node_2
+
+    # this does not work as the name might be in a list and one might want to extend the list.
+    # def visit_Name(self, name):
+    #     if name.id in self.mapping and name.id == "__ret__":
+    #         print(name, "in mapping")
+    #         if isinstance(name.ctx, ast.Store):
+    #             return Name("tmp", ctx=Store())
+    #         else:
+    #             return copy.deepcopy(self.mapping[name.id])
+    #     return name
+
+    def visit_Expr(self, expr):
+        if isinstance(expr.value, Name) and expr.value.id in self.mapping:
+            if self.mapping[expr.value.id] is not None:
+                return copy.deepcopy(self.mapping[expr.value.id])
+        return self.generic_visit(expr)
diff --git a/IPython/core/magics/auto.py b/IPython/core/magics/auto.py
new file mode 100644
index 00000000000..329e7acdbe5
--- /dev/null
+++ b/IPython/core/magics/auto.py
@@ -0,0 +1,144 @@
+"""Implementation of magic functions that control various automatic behaviors.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Our own packages
+from IPython.core.magic import Bunch, Magics, magics_class, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from logging import error
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class AutoMagics(Magics):
+    """Magics that control various autoX behaviors."""
+
+    def __init__(self, shell):
+        super(AutoMagics, self).__init__(shell)
+        # namespace for holding state we may need
+        self._magic_state = Bunch()
+
+    @line_magic
+    def automagic(self, parameter_s=''):
+        """Make magic functions callable without having to type the initial %.
+
+        Without arguments toggles on/off (when off, you must call it as
+        %automagic, of course).  With arguments it sets the value, and you can
+        use any of (case insensitive):
+
+         - on, 1, True: to activate
+
+         - off, 0, False: to deactivate.
+
+        Note that magic functions have lowest priority, so if there's a
+        variable whose name collides with that of a magic fn, automagic won't
+        work for that function (you get the variable instead). However, if you
+        delete the variable (del var), the previously shadowed magic function
+        becomes visible to automagic again."""
+
+        arg = parameter_s.lower()
+        mman = self.shell.magics_manager
+        if arg in ('on', '1', 'true'):
+            val = True
+        elif arg in ('off', '0', 'false'):
+            val = False
+        else:
+            val = not mman.auto_magic
+        mman.auto_magic = val
+        print('\n' + self.shell.magics_manager.auto_status())
+
+    @skip_doctest
+    @line_magic
+    def autocall(self, parameter_s=''):
+        """Make functions callable without having to type parentheses.
+
+        Usage:
+
+           %autocall [mode]
+
+        The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
+        value is toggled on and off (remembering the previous state).
+
+        In more detail, these values mean:
+
+        0 -> fully disabled
+
+        1 -> active, but do not apply if there are no arguments on the line.
+
+        In this mode, you get::
+
+          In [1]: callable
+          Out[1]: <built-in function callable>
+
+          In [2]: callable 'hello'
+          ------> callable('hello')
+          Out[2]: False
+
+        2 -> Active always.  Even if no arguments are present, the callable
+        object is called::
+
+          In [2]: float
+          ------> float()
+          Out[2]: 0.0
+
+        Note that even with autocall off, you can still use '/' at the start of
+        a line to treat the first argument on the command line as a function
+        and add parentheses to it::
+
+          In [8]: /str 43
+          ------> str(43)
+          Out[8]: '43'
+
+        # all-random (note for auto-testing)
+        """
+
+        valid_modes = {
+            0: "Off",
+            1: "Smart",
+            2: "Full",
+        }
+
+        def errorMessage() -> str:
+            error = "Valid modes: "
+            for k, v in valid_modes.items():
+                error += str(k) + "->" + v + ", "
+            error = error[:-2]  # remove tailing `, ` after last element
+            return error
+
+        if parameter_s:
+            if parameter_s not in map(str, valid_modes.keys()):
+                error(errorMessage())
+                return
+            arg = int(parameter_s)
+        else:
+            arg = 'toggle'
+
+        if arg not in (*list(valid_modes.keys()), "toggle"):
+            error(errorMessage())
+            return
+
+        if arg in (valid_modes.keys()):
+            self.shell.autocall = arg
+        else: # toggle
+            if self.shell.autocall:
+                self._magic_state.autocall_save = self.shell.autocall
+                self.shell.autocall = 0
+            else:
+                try:
+                    self.shell.autocall = self._magic_state.autocall_save
+                except AttributeError:
+                    self.shell.autocall = self._magic_state.autocall_save = 1
+
+        print("Automatic calling is:", list(valid_modes.values())[self.shell.autocall])
diff --git a/IPython/core/magics/basic.py b/IPython/core/magics/basic.py
new file mode 100644
index 00000000000..7dd65f83230
--- /dev/null
+++ b/IPython/core/magics/basic.py
@@ -0,0 +1,739 @@
+"""Implementation of basic magic functions."""
+
+
+from logging import error
+import io
+import os
+import platform
+from pprint import pformat
+import sys
+from warnings import warn
+
+from traitlets.utils.importstring import import_item
+from IPython.core import magic_arguments, page
+from IPython.core.error import UsageError
+from IPython.core.magic import Magics, magics_class, line_magic, magic_escapes
+from IPython.utils.text import format_screen, dedent, indent
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.ipstruct import Struct
+
+
+class MagicsDisplay:
+    def __init__(self, magics_manager, ignore=None):
+        self.ignore = ignore if ignore else []
+        self.magics_manager = magics_manager
+
+    def _lsmagic(self):
+        """The main implementation of the %lsmagic"""
+        mesc = magic_escapes['line']
+        cesc = magic_escapes['cell']
+        mman = self.magics_manager
+        magics = mman.lsmagic()
+        out = ['Available line magics:',
+               mesc + ('  '+mesc).join(sorted([m for m,v in magics['line'].items() if (v not in self.ignore)])),
+               '',
+               'Available cell magics:',
+               cesc + ('  '+cesc).join(sorted([m for m,v in magics['cell'].items() if (v not in self.ignore)])),
+               '',
+               mman.auto_status()]
+        return '\n'.join(out)
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(self._lsmagic())
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __str__(self):
+        return self._lsmagic()
+
+    def _jsonable(self):
+        """turn magics dict into jsonable dict of the same structure
+
+        replaces object instances with their class names as strings
+        """
+        magic_dict = {}
+        mman = self.magics_manager
+        magics = mman.lsmagic()
+        for key, subdict in magics.items():
+            d = {}
+            magic_dict[key] = d
+            for name, obj in subdict.items():
+                try:
+                    classname = obj.__self__.__class__.__name__
+                except AttributeError:
+                    classname = 'Other'
+
+                d[name] = classname
+        return magic_dict
+
+    def _repr_json_(self):
+        return self._jsonable()
+
+
+@magics_class
+class BasicMagics(Magics):
+    """Magics that provide central IPython functionality.
+
+    These are various magics that don't fit into specific categories but that
+    are all part of the base 'IPython experience'."""
+
+    @skip_doctest
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '-l', '--line', action='store_true',
+        help="""Create a line magic alias."""
+    )
+    @magic_arguments.argument(
+        '-c', '--cell', action='store_true',
+        help="""Create a cell magic alias."""
+    )
+    @magic_arguments.argument(
+        'name',
+        help="""Name of the magic to be created."""
+    )
+    @magic_arguments.argument(
+        'target',
+        help="""Name of the existing line or cell magic."""
+    )
+    @magic_arguments.argument(
+        '-p', '--params', default=None,
+        help="""Parameters passed to the magic function."""
+    )
+    @line_magic
+    def alias_magic(self, line=''):
+        """Create an alias for an existing line or cell magic.
+
+        Examples
+        --------
+        ::
+
+          In [1]: %alias_magic t timeit
+          Created `%t` as an alias for `%timeit`.
+          Created `%%t` as an alias for `%%timeit`.
+
+          In [2]: %t -n1 pass
+          107 ns ± 43.6 ns per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+          In [3]: %%t -n1
+             ...: pass
+             ...:
+          107 ns ± 58.3 ns per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+          In [4]: %alias_magic --cell whereami pwd
+          UsageError: Cell magic function `%%pwd` not found.
+          In [5]: %alias_magic --line whereami pwd
+          Created `%whereami` as an alias for `%pwd`.
+
+          In [6]: %whereami
+          Out[6]: '/home/testuser'
+
+          In [7]: %alias_magic h history -p "-l 30" --line
+          Created `%h` as an alias for `%history -l 30`.
+        """
+
+        args = magic_arguments.parse_argstring(self.alias_magic, line)
+        shell = self.shell
+        mman = self.shell.magics_manager
+        escs = ''.join(magic_escapes.values())
+
+        target = args.target.lstrip(escs)
+        name = args.name.lstrip(escs)
+
+        params = args.params
+        if (params and
+                ((params.startswith('"') and params.endswith('"'))
+                or (params.startswith("'") and params.endswith("'")))):
+            params = params[1:-1]
+
+        # Find the requested magics.
+        m_line = shell.find_magic(target, 'line')
+        m_cell = shell.find_magic(target, 'cell')
+        if args.line and m_line is None:
+            raise UsageError('Line magic function `%s%s` not found.' %
+                             (magic_escapes['line'], target))
+        if args.cell and m_cell is None:
+            raise UsageError('Cell magic function `%s%s` not found.' %
+                             (magic_escapes['cell'], target))
+
+        # If --line and --cell are not specified, default to the ones
+        # that are available.
+        if not args.line and not args.cell:
+            if not m_line and not m_cell:
+                raise UsageError(
+                    'No line or cell magic with name `%s` found.' % target
+                )
+            args.line = bool(m_line)
+            args.cell = bool(m_cell)
+
+        params_str = "" if params is None else " " + params
+
+        if args.line:
+            mman.register_alias(name, target, 'line', params)
+            print('Created `%s%s` as an alias for `%s%s%s`.' % (
+                magic_escapes['line'], name,
+                magic_escapes['line'], target, params_str))
+
+        if args.cell:
+            mman.register_alias(name, target, 'cell', params)
+            print('Created `%s%s` as an alias for `%s%s%s`.' % (
+                magic_escapes['cell'], name,
+                magic_escapes['cell'], target, params_str))
+
+    @line_magic
+    def lsmagic(self, parameter_s=''):
+        """List currently available magic functions."""
+        return MagicsDisplay(self.shell.magics_manager, ignore=[])
+
+    def _magic_docs(self, brief=False, rest=False):
+        """Return docstrings from magic functions."""
+        mman = self.shell.magics_manager
+        docs = mman.lsmagic_docs(brief, missing='No documentation')
+
+        if rest:
+            format_string = '**%s%s**::\n\n%s\n\n'
+        else:
+            format_string = '%s%s:\n%s\n'
+
+        return ''.join(
+            [format_string % (magic_escapes['line'], fname,
+                              indent(dedent(fndoc)))
+             for fname, fndoc in sorted(docs['line'].items())]
+            +
+            [format_string % (magic_escapes['cell'], fname,
+                              indent(dedent(fndoc)))
+             for fname, fndoc in sorted(docs['cell'].items())]
+        )
+
+    @line_magic
+    def magic(self, parameter_s=''):
+        """Print information about the magic function system.
+
+        Supported formats: -latex, -brief, -rest
+        """
+
+        mode = ''
+        try:
+            mode = parameter_s.split()[0][1:]
+        except IndexError:
+            pass
+
+        brief = (mode == 'brief')
+        rest = (mode == 'rest')
+        magic_docs = self._magic_docs(brief, rest)
+
+        if mode == 'latex':
+            print(self.format_latex(magic_docs))
+            return
+        else:
+            magic_docs = format_screen(magic_docs)
+
+        out = ["""
+IPython's 'magic' functions
+===========================
+
+The magic function system provides a series of functions which allow you to
+control the behavior of IPython itself, plus a lot of system-type
+features. There are two kinds of magics, line-oriented and cell-oriented.
+
+Line magics are prefixed with the % character and work much like OS
+command-line calls: they get as an argument the rest of the line, where
+arguments are passed without parentheses or quotes.  For example, this will
+time the given statement::
+
+        %timeit range(1000)
+
+Cell magics are prefixed with a double %%, and they are functions that get as
+an argument not only the rest of the line, but also the lines below it in a
+separate argument.  These magics are called with two arguments: the rest of the
+call line and the body of the cell, consisting of the lines below the first.
+For example::
+
+        %%timeit x = numpy.random.randn((100, 100))
+        numpy.linalg.svd(x)
+
+will time the execution of the numpy svd routine, running the assignment of x
+as part of the setup phase, which is not timed.
+
+In a line-oriented client (the terminal or Qt console IPython), starting a new
+input with %% will automatically enter cell mode, and IPython will continue
+reading input until a blank line is given.  In the notebook, simply type the
+whole cell as one entity, but keep in mind that the %% escape can only be at
+the very start of the cell.
+
+NOTE: If you have 'automagic' enabled (via the command line option or with the
+%automagic function), you don't need to type in the % explicitly for line
+magics; cell magics always require an explicit '%%' escape.  By default,
+IPython ships with automagic on, so you should only rarely need the % escape.
+
+Example: typing '%cd mydir' (without the quotes) changes your working directory
+to 'mydir', if it exists.
+
+For a list of the available magic functions, use %lsmagic. For a description
+of any of them, type %magic_name?, e.g. '%cd?'.
+
+Currently the magic system has the following functions:""",
+       magic_docs,
+       "Summary of magic functions (from %slsmagic):" % magic_escapes['line'],
+       str(self.lsmagic()),
+       ]
+        page.page('\n'.join(out))
+
+
+    @line_magic
+    def page(self, parameter_s=''):
+        """Pretty print the object and display it through a pager.
+
+        %page [options] OBJECT
+
+        If no object is given, use _ (last output).
+
+        Options:
+
+          -r: page str(object), don't pretty-print it."""
+
+        # After a function contributed by Olivier Aubert, slightly modified.
+
+        # Process options/args
+        opts, args = self.parse_options(parameter_s, 'r')
+        raw = 'r' in opts
+
+        oname = args and args or '_'
+        info = self.shell._ofind(oname)
+        if info.found:
+            if raw:
+                txt = str(info.obj)
+            else:
+                txt = pformat(info.obj)
+            page.page(txt)
+        else:
+            print('Object `%s` not found' % oname)
+
+    @line_magic
+    def pprint(self, parameter_s=''):
+        """Toggle pretty printing on/off."""
+        ptformatter = self.shell.display_formatter.formatters['text/plain']
+        ptformatter.pprint = bool(1 - ptformatter.pprint)
+        print('Pretty printing has been turned',
+              ['OFF','ON'][ptformatter.pprint])
+
+    @line_magic
+    def colors(self, parameter_s=''):
+        """Switch color scheme/theme globally for IPython
+
+        Examples
+        --------
+        To get a plain black and white terminal::
+
+          %colors nocolor
+        """
+
+
+        new_theme = parameter_s.strip()
+        if not new_theme:
+            from IPython.utils.PyColorize import theme_table
+
+            raise UsageError(
+                "%colors: you must specify a color theme. See '%colors?'."
+                f" Available themes: {list(theme_table.keys())}"
+            )
+
+        self.shell.colors = new_theme
+
+    @line_magic
+    def xmode(self, parameter_s=''):
+        """Switch modes for the exception handlers.
+
+        Valid modes: Plain, Context, Verbose, and Minimal.
+
+        If called without arguments, acts as a toggle.
+
+        When in verbose mode the value `--show` (and `--hide`)
+        will respectively show (or hide) frames with ``__tracebackhide__ =
+        True`` value set.
+        """
+
+        def xmode_switch_err(name):
+            warn('Error changing %s exception modes.\n%s' %
+                 (name,sys.exc_info()[1]))
+
+        shell = self.shell
+        if parameter_s.strip() == "--show":
+            shell.InteractiveTB.skip_hidden = False
+            return
+        if parameter_s.strip() == "--hide":
+            shell.InteractiveTB.skip_hidden = True
+            return
+
+        new_mode = parameter_s.strip().capitalize()
+        try:
+            shell.InteractiveTB.set_mode(mode=new_mode)
+            print('Exception reporting mode:',shell.InteractiveTB.mode)
+        except:
+            raise
+            xmode_switch_err('user')
+
+    @line_magic
+    def quickref(self, arg):
+        """ Show a quick reference sheet """
+        from IPython.core.usage import quick_reference
+        qr = quick_reference + self._magic_docs(brief=True)
+        page.page(qr)
+
+    @line_magic
+    def doctest_mode(self, parameter_s=''):
+        """Toggle doctest mode on and off.
+
+        This mode is intended to make IPython behave as much as possible like a
+        plain Python shell, from the perspective of how its prompts, exceptions
+        and output look.  This makes it easy to copy and paste parts of a
+        session into doctests.  It does so by:
+
+        - Changing the prompts to the classic ``>>>`` ones.
+        - Changing the exception reporting mode to 'Plain'.
+        - Disabling pretty-printing of output.
+
+        Note that IPython also supports the pasting of code snippets that have
+        leading '>>>' and '...' prompts in them.  This means that you can paste
+        doctests from files or docstrings (even if they have leading
+        whitespace), and the code will execute correctly.  You can then use
+        '%history -t' to see the translated history; this will give you the
+        input after removal of all the leading prompts and whitespace, which
+        can be pasted back into an editor.
+
+        With these features, you can switch into this mode easily whenever you
+        need to do testing and changes to doctests, without having to leave
+        your existing IPython session.
+        """
+
+        # Shorthands
+        shell = self.shell
+        meta = shell.meta
+        disp_formatter = self.shell.display_formatter
+        ptformatter = disp_formatter.formatters['text/plain']
+        # dstore is a data store kept in the instance metadata bag to track any
+        # changes we make, so we can undo them later.
+        dstore = meta.setdefault('doctest_mode',Struct())
+        save_dstore = dstore.setdefault
+
+        # save a few values we'll need to recover later
+        mode = save_dstore('mode',False)
+        save_dstore('rc_pprint',ptformatter.pprint)
+        save_dstore('xmode',shell.InteractiveTB.mode)
+        save_dstore('rc_separate_out',shell.separate_out)
+        save_dstore('rc_separate_out2',shell.separate_out2)
+        save_dstore('rc_separate_in',shell.separate_in)
+        save_dstore('rc_active_types',disp_formatter.active_types)
+
+        if not mode:
+            # turn on
+
+            # Prompt separators like plain python
+            shell.separate_in = ''
+            shell.separate_out = ''
+            shell.separate_out2 = ''
+
+
+            ptformatter.pprint = False
+            disp_formatter.active_types = ['text/plain']
+
+            shell.run_line_magic("xmode", "Plain")
+        else:
+            # turn off
+            shell.separate_in = dstore.rc_separate_in
+
+            shell.separate_out = dstore.rc_separate_out
+            shell.separate_out2 = dstore.rc_separate_out2
+
+            ptformatter.pprint = dstore.rc_pprint
+            disp_formatter.active_types = dstore.rc_active_types
+
+            shell.run_line_magic("xmode", dstore.xmode)
+
+        # mode here is the state before we switch; switch_doctest_mode takes
+        # the mode we're switching to.
+        shell.switch_doctest_mode(not mode)
+
+        # Store new mode and inform
+        dstore.mode = bool(not mode)
+        mode_label = ['OFF','ON'][dstore.mode]
+        print('Doctest mode is:', mode_label)
+
+    @line_magic
+    def gui(self, parameter_s=''):
+        """Enable or disable IPython GUI event loop integration.
+
+        %gui [GUINAME]
+
+        This magic replaces IPython's threaded shells that were activated
+        using the (pylab/wthread/etc.) command line flags.  GUI toolkits
+        can now be enabled at runtime and keyboard
+        interrupts should work without any problems.  The following toolkits
+        are supported:  wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
+
+            %gui wx      # enable wxPython event loop integration
+            %gui qt      # enable PyQt/PySide event loop integration
+                         # with the latest version available.
+            %gui qt6     # enable PyQt6/PySide6 event loop integration
+            %gui qt5     # enable PyQt5/PySide2 event loop integration
+            %gui gtk     # enable PyGTK event loop integration
+            %gui gtk3    # enable Gtk3 event loop integration
+            %gui gtk4    # enable Gtk4 event loop integration
+            %gui tk      # enable Tk event loop integration
+            %gui osx     # enable Cocoa event loop integration
+                         # (requires %matplotlib 1.1)
+            %gui         # disable all event loop integration
+
+        WARNING:  after any of these has been called you can simply create
+        an application object, but DO NOT start the event loop yourself, as
+        we have already handled that.
+        """
+        opts, arg = self.parse_options(parameter_s, '')
+        if arg=='': arg = None
+        try:
+            return self.shell.enable_gui(arg)
+        except Exception as e:
+            # print simple error message, rather than traceback if we can't
+            # hook up the GUI
+            error(str(e))
+
+    @skip_doctest
+    @line_magic
+    def precision(self, s=''):
+        """Set floating point precision for pretty printing.
+
+        Can set either integer precision or a format string.
+
+        If numpy has been imported and precision is an int,
+        numpy display precision will also be set, via ``numpy.set_printoptions``.
+
+        If no argument is given, defaults will be restored.
+
+        Examples
+        --------
+        ::
+
+            In [1]: from math import pi
+
+            In [2]: %precision 3
+            Out[2]: '%.3f'
+
+            In [3]: pi
+            Out[3]: 3.142
+
+            In [4]: %precision %i
+            Out[4]: '%i'
+
+            In [5]: pi
+            Out[5]: 3
+
+            In [6]: %precision %e
+            Out[6]: '%e'
+
+            In [7]: pi**10
+            Out[7]: 9.364805e+04
+
+            In [8]: %precision
+            Out[8]: '%r'
+
+            In [9]: pi**10
+            Out[9]: 93648.047476082982
+        """
+        ptformatter = self.shell.display_formatter.formatters['text/plain']
+        ptformatter.float_precision = s
+        return ptformatter.float_format
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        'filename', type=str,
+        help='Notebook name or filename'
+    )
+    @line_magic
+    def notebook(self, s):
+        """Export and convert IPython notebooks.
+
+        This function can export the current IPython history to a notebook file.
+        For example, to export the history to "foo.ipynb" do "%notebook foo.ipynb".
+        """
+        args = magic_arguments.parse_argstring(self.notebook, s)
+        outfname = os.path.expanduser(args.filename)
+
+        from nbformat import write, v4
+        from nbformat.sign import NotebookNotary
+
+        cells = []
+        hist = list(self.shell.history_manager.get_range())
+        outputs = self.shell.history_manager.outputs
+        exceptions = self.shell.history_manager.exceptions
+
+        if(len(hist)<=1):
+            raise ValueError('History is empty, cannot export')
+
+        for session, execution_count, source in hist[:-1]:
+            cell = v4.new_code_cell(execution_count=execution_count, source=source)
+
+            for output in outputs[execution_count]:
+                if output.output_type in {"out_stream", "err_stream"}:
+                    text_data = []
+                    for mime_type, data in output.bundle.items():
+                        if isinstance(data, list):
+                            text_data.extend(data)
+                        else:
+                            text_data.append(data)
+                    full_text = "".join(text_data)
+                    # Replace literal \n with actual newlines
+                    full_text = full_text.replace("\\n", "\n")
+                    normalized_text = []
+                    lines = full_text.split("\n")
+                    for i, line in enumerate(lines):
+                        if i < len(lines) - 1:
+                            normalized_text.append(line + "\n")
+                        elif line:  # Last line only if it's not empty
+                            normalized_text.append(line + "\n")
+                    stream_output = v4.new_output("stream", text=normalized_text)
+                    if output.output_type == "err_stream":
+                        stream_output.name = "stderr"
+                    cell.outputs.append(stream_output)
+
+                elif output.output_type == "execute_result":
+                    data_dict = {}
+                    for mime_type, data in output.bundle.items():
+                        data_dict[mime_type] = data
+                    cell.outputs.append(
+                        v4.new_output(
+                            "execute_result",
+                            data=data_dict,
+                            execution_count=execution_count,
+                        )
+                    )
+
+                elif output.output_type == "display_data":
+                    # Collect all MIME types for this display_data into a single output
+                    data_dict = {}
+                    for mime_type, data in output.bundle.items():
+                        data_dict[mime_type] = data
+                    cell.outputs.append(
+                        v4.new_output(
+                            "display_data",
+                            data=data_dict,
+                        )
+                    )
+                else:
+                    raise ValueError(f"Unknown output type: {output.output_type}")
+
+            # Check if this execution_count is in exceptions (current session)
+            if execution_count in exceptions:
+                cell.outputs.append(
+                    v4.new_output("error", **exceptions[execution_count])
+                )
+            cells.append(cell)
+
+        kernel_language_info = self._get_kernel_language_info()
+
+        nb = v4.new_notebook(
+            cells=cells,
+            metadata={
+                "kernelspec": {
+                    "display_name": "Python 3 (ipykernel)",
+                    "language": "python",
+                    "name": "python3",
+                },
+                "language_info": kernel_language_info
+                or {
+                    "codemirror_mode": {
+                        "name": "ipython",
+                        "version": sys.version_info[0],
+                    },
+                    "file_extension": ".py",
+                    "mimetype": "text/x-python",
+                    "name": "python",
+                    "nbconvert_exporter": "python",
+                    "pygments_lexer": "ipython3",
+                    "version": platform.python_version(),
+                },
+            },
+        )
+        # Sign the notebook to make it trusted
+        notary = NotebookNotary()
+        notary.update_config(self.shell.config)
+        notary.sign(nb)
+        with io.open(outfname, "w", encoding="utf-8") as f:
+            write(nb, f, version=4)
+
+    def _get_kernel_language_info(self) -> dict | None:
+        """Get language info from kernel, useful when used in Jupyter Console where kernels exist."""
+        if not hasattr(self.shell, "kernel"):
+            return
+        if not hasattr(self.shell.kernel, "language_info"):
+            return
+        if not isinstance(self.shell.kernel.language_info, dict):
+            return
+        return self.shell.kernel.language_info
+
+@magics_class
+class AsyncMagics(BasicMagics):
+
+    @line_magic
+    def autoawait(self, parameter_s):
+        """
+        Allow to change the status of the autoawait option.
+
+        This allow you to set a specific asynchronous code runner.
+
+        If no value is passed, print the currently used asynchronous integration
+        and whether it is activated.
+
+        It can take a number of value evaluated in the following order:
+
+        - False/false/off deactivate autoawait integration
+        - True/true/on activate autoawait integration using configured default
+          loop
+        - asyncio/curio/trio activate autoawait integration and use integration
+          with said library.
+
+        - `sync` turn on the pseudo-sync integration (mostly used for
+          `IPython.embed()` which does not run IPython with a real eventloop and
+          deactivate running asynchronous code. Turning on Asynchronous code with
+          the pseudo sync loop is undefined behavior and may lead IPython to crash.
+
+        If the passed parameter does not match any of the above and is a python
+        identifier, get said object from user namespace and set it as the
+        runner, and activate autoawait.
+
+        If the object is a fully qualified object name, attempt to import it and
+        set it as the runner, and activate autoawait.
+
+        The exact behavior of autoawait is experimental and subject to change
+        across version of IPython and Python.
+        """
+
+        param = parameter_s.strip()
+        d = {True: "on", False: "off"}
+
+        if not param:
+            print("IPython autoawait is `{}`, and set to use `{}`".format(
+                d[self.shell.autoawait],
+                self.shell.loop_runner
+            ))
+            return None
+
+        if param.lower() in ('false', 'off'):
+            self.shell.autoawait = False
+            return None
+        if param.lower() in ('true', 'on'):
+            self.shell.autoawait = True
+            return None
+
+        if param in self.shell.loop_runner_map:
+            self.shell.loop_runner, self.shell.autoawait = self.shell.loop_runner_map[param]
+            return None
+
+        if param in self.shell.user_ns :
+            self.shell.loop_runner = self.shell.user_ns[param]
+            self.shell.autoawait = True
+            return None
+
+        runner = import_item(param)
+
+        self.shell.loop_runner = runner
+        self.shell.autoawait = True
diff --git a/IPython/core/magics/code.py b/IPython/core/magics/code.py
new file mode 100644
index 00000000000..191e55ab6e5
--- /dev/null
+++ b/IPython/core/magics/code.py
@@ -0,0 +1,757 @@
+"""Implementation of code management magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import inspect
+import io
+import os
+import re
+import sys
+import ast
+from itertools import chain
+from urllib.request import Request, urlopen
+from urllib.parse import urlencode
+from pathlib import Path
+
+# Our own packages
+from IPython.core.error import TryNext, StdinNotImplementedError, UsageError
+from IPython.core.macro import Macro
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.core.oinspect import find_file, find_source_lines
+from IPython.core.release import version
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.contexts import preserve_keys
+from IPython.utils.path import get_py_filename
+from warnings import warn
+from logging import error
+from IPython.utils.text import get_text_list
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+# Used for exception handling in magic_edit
+class MacroToEdit(ValueError): pass
+
+ipython_input_pat = re.compile(r"<ipython\-input\-(\d+)-[a-z\d]+>$")
+
+# To match, e.g. 8-10 1:5 :10 3-
+range_re = re.compile(r"""
+(?P<start>\d+)?
+((?P<sep>[\-:])
+ (?P<end>\d+)?)?
+$""", re.VERBOSE)
+
+
+def extract_code_ranges(ranges_str):
+    """Turn a string of range for %%load into 2-tuples of (start, stop)
+    ready to use as a slice of the content split by lines.
+
+    Examples
+    --------
+    list(extract_input_ranges("5-10 2"))
+    [(4, 10), (1, 2)]
+    """
+    for range_str in ranges_str.split():
+        rmatch = range_re.match(range_str)
+        if not rmatch:
+            continue
+        sep = rmatch.group("sep")
+        start = rmatch.group("start")
+        end = rmatch.group("end")
+
+        if sep == '-':
+            start = int(start) - 1 if start else None
+            end = int(end) if end else None
+        elif sep == ':':
+            start = int(start) - 1 if start else None
+            end = int(end) - 1 if end else None
+        else:
+            end = int(start)
+            start = int(start) - 1
+        yield (start, end)
+
+
+def extract_symbols(code, symbols):
+    """
+    Return a tuple  (blocks, not_found)
+    where ``blocks`` is a list of code fragments
+    for each symbol parsed from code, and ``not_found`` are
+    symbols not found in the code.
+
+    For example::
+
+        In [1]: code = '''a = 10
+           ...: def b(): return 42
+           ...: class A: pass'''
+
+        In [2]: extract_symbols(code, 'A,b,z')
+        Out[2]: (['class A: pass\\n', 'def b(): return 42\\n'], ['z'])
+    """
+    symbols = symbols.split(',')
+
+    # this will raise SyntaxError if code isn't valid Python
+    py_code = ast.parse(code)
+
+    marks = [(getattr(s, 'name', None), s.lineno) for s in py_code.body]
+    code = code.split('\n')
+
+    symbols_lines = {}
+    
+    # we already know the start_lineno of each symbol (marks). 
+    # To find each end_lineno, we traverse in reverse order until each 
+    # non-blank line
+    end = len(code)  
+    for name, start in reversed(marks):
+        while not code[end - 1].strip():
+            end -= 1
+        if name:
+            symbols_lines[name] = (start - 1, end)
+        end = start - 1
+
+    # Now symbols_lines is a map
+    # {'symbol_name': (start_lineno, end_lineno), ...}
+    
+    # fill a list with chunks of codes for each requested symbol
+    blocks = []
+    not_found = []
+    for symbol in symbols:
+        if symbol in symbols_lines:
+            start, end = symbols_lines[symbol]
+            blocks.append('\n'.join(code[start:end]) + '\n')
+        else:
+            not_found.append(symbol)
+
+    return blocks, not_found
+
+def strip_initial_indent(lines):
+    """For %load, strip indent from lines until finding an unindented line.
+
+    https://github.com/ipython/ipython/issues/9775
+    """
+    indent_re = re.compile(r'\s+')
+
+    it = iter(lines)
+    first_line = next(it)
+    indent_match = indent_re.match(first_line)
+
+    if indent_match:
+        # First line was indented
+        indent = indent_match.group()
+        yield first_line[len(indent):]
+
+        for line in it:
+            if line.startswith(indent):
+                yield line[len(indent) :]
+            elif line in ("\n", "\r\n") or len(line) == 0:
+                yield line
+            else:
+                # Less indented than the first line - stop dedenting
+                yield line
+                break
+    else:
+        yield first_line
+
+    # Pass the remaining lines through without dedenting
+    for line in it:
+        yield line
+
+
+class InteractivelyDefined(Exception):
+    """Exception for interactively defined variable in magic_edit"""
+    def __init__(self, index):
+        self.index = index
+
+
+@magics_class
+class CodeMagics(Magics):
+    """Magics related to code management (loading, saving, editing, ...)."""
+
+    def __init__(self, *args, **kwargs):
+        self._knowntemps = set()
+        super(CodeMagics, self).__init__(*args, **kwargs)
+
+    @line_magic
+    def save(self, parameter_s=''):
+        """Save a set of lines or a macro to a given filename.
+
+        Usage:\\
+          %save [options] filename [history]
+
+        Options:
+
+          -r: use 'raw' input.  By default, the 'processed' history is used,
+          so that magics are loaded in their transformed version to valid
+          Python.  If this option is given, the raw input as typed at the
+          command line is used instead.
+          
+          -f: force overwrite.  If file exists, %save will prompt for overwrite
+          unless -f is given.
+
+          -a: append to the file instead of overwriting it.
+
+        The history argument uses the same syntax as %history for input ranges,
+        then saves the lines to the filename you specify.
+
+        If no ranges are specified, saves history of the current session up to
+        this point.
+
+        It adds a '.py' extension to the file if you don't do so yourself, and
+        it asks for confirmation before overwriting existing files.
+
+        If `-r` option is used, the default extension is `.ipy`.
+        """
+
+        opts,args = self.parse_options(parameter_s,'fra',mode='list')
+        if not args:
+            raise UsageError('Missing filename.')
+        raw = 'r' in opts
+        force = 'f' in opts
+        append = 'a' in opts
+        mode = 'a' if append else 'w'
+        ext = '.ipy' if raw else '.py'
+        fname, codefrom = args[0], " ".join(args[1:])
+        if not fname.endswith(('.py','.ipy')):
+            fname += ext
+        fname = os.path.expanduser(fname)
+        file_exists = os.path.isfile(fname)
+        if file_exists and not force and not append:
+            try:
+                overwrite = self.shell.ask_yes_no('File `%s` exists. Overwrite (y/[N])? ' % fname, default='n')
+            except StdinNotImplementedError:
+                print("File `%s` exists. Use `%%save -f %s` to force overwrite" % (fname, parameter_s))
+                return
+            if not overwrite :
+                print('Operation cancelled.')
+                return
+        try:
+            cmds = self.shell.find_user_code(codefrom,raw)
+        except (TypeError, ValueError) as e:
+            print(e.args[0])
+            return
+        with io.open(fname, mode, encoding="utf-8") as f:
+            if not file_exists or not append:
+                f.write("# coding: utf-8\n")
+            f.write(cmds)
+            # make sure we end on a newline
+            if not cmds.endswith('\n'):
+                f.write('\n')
+        print('The following commands were written to file `%s`:' % fname)
+        print(cmds)
+
+    @line_magic
+    def pastebin(self, parameter_s=''):
+        """Upload code to dpaste.com, returning the URL.
+
+        Usage:\\
+          %pastebin [-d "Custom description"][-e 24] 1-7
+
+        The argument can be an input history range, a filename, or the name of a
+        string or macro.
+
+        If no arguments are given, uploads the history of this session up to
+        this point.
+
+        Options:
+
+          -d: Pass a custom description. The default will say
+              "Pasted from IPython".
+          -e: Pass number of days for the link to be expired.
+              The default will be 7 days.
+        """
+        opts, args = self.parse_options(parameter_s, "d:e:")
+
+        try:
+            code = self.shell.find_user_code(args)
+        except (ValueError, TypeError) as e:
+            print(e.args[0])
+            return
+
+        expiry_days = 7
+        try:
+            expiry_days = int(opts.get("e", 7))
+        except ValueError as e:
+            print(e.args[0].capitalize())
+            return
+        if expiry_days < 1 or expiry_days > 365:
+            print("Expiry days should be in range of 1 to 365")
+            return
+
+        post_data = urlencode(
+            {
+                "title": opts.get("d", "Pasted from IPython"),
+                "syntax": "python",
+                "content": code,
+                "expiry_days": expiry_days,
+            }
+        ).encode("utf-8")
+
+        request = Request(
+            "https://dpaste.com/api/v2/",
+            headers={"User-Agent": "IPython v{}".format(version)},
+        )
+        response = urlopen(request, post_data)
+        return response.headers.get('Location')
+
+    @line_magic
+    def loadpy(self, arg_s):
+        """Alias of `%load`
+
+        `%loadpy` has gained some flexibility and dropped the requirement of a `.py`
+        extension. So it has been renamed simply into %load. You can look at
+        `%load`'s docstring for more info.
+        """
+        self.load(arg_s)
+
+    @line_magic
+    def load(self, arg_s):
+        """Load code into the current frontend.
+
+        Usage:\\
+          %load [options] source
+
+          where source can be a filename, URL, input history range, macro, or
+          element in the user namespace
+
+        If no arguments are given, loads the history of this session up to this
+        point.
+
+        Options:
+
+          -r <lines>: Specify lines or ranges of lines to load from the source.
+          Ranges could be specified as x-y (x..y) or in python-style x:y 
+          (x..(y-1)). Both limits x and y can be left blank (meaning the 
+          beginning and end of the file, respectively).
+
+          -s <symbols>: Specify function or classes to load from python source. 
+
+          -y : Don't ask confirmation for loading source above 200 000 characters.
+
+          -n : Include the user's namespace when searching for source code.
+
+        This magic command can either take a local filename, a URL, an history
+        range (see %history) or a macro as argument, it will prompt for
+        confirmation before loading source with more than 200 000 characters, unless
+        -y flag is passed or if the frontend does not support raw_input::
+
+        %load
+        %load myscript.py
+        %load 7-27
+        %load myMacro
+        %load http://www.example.com/myscript.py
+        %load -r 5-10 myscript.py
+        %load -r 10-20,30,40: foo.py
+        %load -s MyClass,wonder_function myscript.py
+        %load -n MyClass
+        %load -n my_module.wonder_function
+        """
+        opts,args = self.parse_options(arg_s,'yns:r:')
+        search_ns = 'n' in opts
+        contents = self.shell.find_user_code(args, search_ns=search_ns)
+
+        if 's' in opts:
+            try:
+                blocks, not_found = extract_symbols(contents, opts['s'])
+            except SyntaxError:
+                # non python code
+                error("Unable to parse the input as valid Python code")
+                return
+
+            if len(not_found) == 1:
+                warn('The symbol `%s` was not found' % not_found[0])
+            elif len(not_found) > 1:
+                warn('The symbols %s were not found' % get_text_list(not_found,
+                                                                     wrap_item_with='`')
+                )
+
+            contents = '\n'.join(blocks)
+
+        if 'r' in opts:
+            ranges = opts['r'].replace(',', ' ')
+            lines = contents.split('\n')
+            slices = extract_code_ranges(ranges)
+            contents = [lines[slice(*slc)] for slc in slices]
+            contents = '\n'.join(strip_initial_indent(chain.from_iterable(contents)))
+
+        l = len(contents)
+
+        # 200 000 is ~ 2500 full 80 character lines
+        # so in average, more than 5000 lines
+        if l > 200000 and 'y' not in opts:
+            try:
+                ans = self.shell.ask_yes_no(("The text you're trying to load seems pretty big"\
+                " (%d characters). Continue (y/[N]) ?" % l), default='n' )
+            except StdinNotImplementedError:
+                #assume yes if raw input not implemented
+                ans = True
+
+            if ans is False :
+                print('Operation cancelled.')
+                return
+
+        contents = "# %load {}\n".format(arg_s) + contents
+
+        self.shell.set_next_input(contents, replace=True)
+
+    @staticmethod
+    def _find_edit_target(shell, args, opts, last_call):
+        """Utility method used by magic_edit to find what to edit."""
+
+        def make_filename(arg):
+            "Make a filename from the given args"
+            try:
+                filename = get_py_filename(arg)
+            except IOError:
+                # If it ends with .py but doesn't already exist, assume we want
+                # a new file.
+                if arg.endswith('.py'):
+                    filename = arg
+                else:
+                    filename = None
+            return filename
+
+        # Set a few locals from the options for convenience:
+        opts_prev = 'p' in opts
+        opts_raw = 'r' in opts
+
+        # custom exceptions
+        class DataIsObject(Exception): pass
+
+        # Default line number value
+        lineno = opts.get('n',None)
+
+        if opts_prev:
+            args = '_%s' % last_call[0]
+            if args not in shell.user_ns:
+                args = last_call[1]
+
+        # by default this is done with temp files, except when the given
+        # arg is a filename
+        use_temp = True
+
+        data = ''
+
+        # First, see if the arguments should be a filename.
+        filename = make_filename(args)
+        if filename:
+            use_temp = False
+        elif args:
+            # Mode where user specifies ranges of lines, like in %macro.
+            data = shell.extract_input_lines(args, opts_raw)
+            if not data:
+                try:
+                    # Load the parameter given as a variable. If not a string,
+                    # process it as an object instead (below)
+
+                    # print('*** args',args,'type',type(args))  # dbg
+                    data = eval(args, shell.user_ns)
+                    if not isinstance(data, str):
+                        raise DataIsObject
+
+                except (NameError,SyntaxError):
+                    # given argument is not a variable, try as a filename
+                    filename = make_filename(args)
+                    if filename is None:
+                        warn("Argument given (%s) can't be found as a variable "
+                             "or as a filename." % args)
+                        return (None, None, None)
+                    use_temp = False
+
+                except DataIsObject as e:
+                    # macros have a special edit function
+                    if isinstance(data, Macro):
+                        raise MacroToEdit(data) from e
+
+                    # For objects, try to edit the file where they are defined
+                    filename = find_file(data)
+                    if filename:
+                        if 'fakemodule' in filename.lower() and \
+                            inspect.isclass(data):
+                            # class created by %edit? Try to find source
+                            # by looking for method definitions instead, the
+                            # __module__ in those classes is FakeModule.
+                            attrs = [getattr(data, aname) for aname in dir(data)]
+                            for attr in attrs:
+                                if not inspect.ismethod(attr):
+                                    continue
+                                filename = find_file(attr)
+                                if filename and \
+                                  'fakemodule' not in filename.lower():
+                                    # change the attribute to be the edit
+                                    # target instead
+                                    data = attr
+                                    break
+                        
+                        m = ipython_input_pat.match(os.path.basename(filename))
+                        if m:
+                            raise InteractivelyDefined(int(m.groups()[0])) from e
+
+                        datafile = 1
+                    if filename is None:
+                        filename = make_filename(args)
+                        datafile = 1
+                        if filename is not None:
+                            # only warn about this if we get a real name
+                            warn('Could not find file where `%s` is defined.\n'
+                             'Opening a file named `%s`' % (args, filename))
+                    # Now, make sure we can actually read the source (if it was
+                    # in a temp file it's gone by now).
+                    if datafile:
+                        if lineno is None:
+                            lineno = find_source_lines(data)
+                        if lineno is None:
+                            filename = make_filename(args)
+                            if filename is None:
+                                warn('The file where `%s` was defined '
+                                     'cannot be read or found.' % data)
+                                return (None, None, None)
+                    use_temp = False
+
+        if use_temp:
+            filename = shell.mktempfile(data)
+            print('IPython will make a temporary file named:',filename)
+
+        # use last_call to remember the state of the previous call, but don't
+        # let it be clobbered by successive '-p' calls.
+        try:
+            last_call[0] = shell.displayhook.prompt_count
+            if not opts_prev:
+                last_call[1] = args
+        except:
+            pass
+
+
+        return filename, lineno, use_temp
+
+    def _edit_macro(self,mname,macro):
+        """open an editor with the macro data in a file"""
+        filename = self.shell.mktempfile(macro.value)
+        self.shell.hooks.editor(filename)
+
+        # and make a new macro object, to replace the old one
+        mvalue = Path(filename).read_text(encoding="utf-8")
+        self.shell.user_ns[mname] = Macro(mvalue)
+
+    @skip_doctest
+    @line_magic
+    def edit(self, parameter_s='',last_call=['','']):
+        """Bring up an editor and execute the resulting code.
+
+        Usage:
+          %edit [options] [args]
+
+        %edit runs IPython's editor hook. The default version of this hook is
+        set to call the editor specified by your $EDITOR environment variable.
+        If this isn't found, it will default to vi under Linux/Unix and to
+        notepad under Windows. See the end of this docstring for how to change
+        the editor hook.
+
+        You can also set the value of this editor via the
+        ``TerminalInteractiveShell.editor`` option in your configuration file.
+        This is useful if you wish to use a different editor from your typical
+        default with IPython (and for Windows users who typically don't set
+        environment variables).
+
+        This command allows you to conveniently edit multi-line code right in
+        your IPython session.
+
+        If called without arguments, %edit opens up an empty editor with a
+        temporary file and will execute the contents of this file when you
+        close it (don't forget to save it!).
+
+
+        Options:
+
+        -n <number>: open the editor at a specified line number.  By default,
+        the IPython editor hook uses the unix syntax 'editor +N filename', but
+        you can configure this by providing your own modified hook if your
+        favorite editor supports line-number specifications with a different
+        syntax.
+
+        -p: this will call the editor with the same data as the previous time
+        it was used, regardless of how long ago (in your current session) it
+        was.
+
+        -r: use 'raw' input.  This option only applies to input taken from the
+        user's history.  By default, the 'processed' history is used, so that
+        magics are loaded in their transformed version to valid Python.  If
+        this option is given, the raw input as typed as the command line is
+        used instead.  When you exit the editor, it will be executed by
+        IPython's own processor.
+
+        -x: do not execute the edited code immediately upon exit. This is
+        mainly useful if you are editing programs which need to be called with
+        command line arguments, which you can then do using %run.
+
+
+        Arguments:
+
+        If arguments are given, the following possibilities exist:
+
+        - If the argument is a filename, IPython will load that into the
+          editor. It will execute its contents with execfile() when you exit,
+          loading any code in the file into your interactive namespace.
+
+        - The arguments are ranges of input history,  e.g. "7 ~1/4-6".
+          The syntax is the same as in the %history magic.
+
+        - If the argument is a string variable, its contents are loaded
+          into the editor. You can thus edit any string which contains
+          python code (including the result of previous edits).
+
+        - If the argument is the name of an object (other than a string),
+          IPython will try to locate the file where it was defined and open the
+          editor at the point where it is defined. You can use `%edit function`
+          to load an editor exactly at the point where 'function' is defined,
+          edit it and have the file be executed automatically.
+
+        - If the object is a macro (see %macro for details), this opens up your
+          specified editor with a temporary file containing the macro's data.
+          Upon exit, the macro is reloaded with the contents of the file.
+
+        Note: opening at an exact line is only supported under Unix, and some
+        editors (like kedit and gedit up to Gnome 2.8) do not understand the
+        '+NUMBER' parameter necessary for this feature. Good editors like
+        (X)Emacs, vi, jed, pico and joe all do.
+
+        After executing your code, %edit will return as output the code you
+        typed in the editor (except when it was an existing file). This way
+        you can reload the code in further invocations of %edit as a variable,
+        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
+        the output.
+
+        Note that %edit is also available through the alias %ed.
+
+        This is an example of creating a simple function inside the editor and
+        then modifying it. First, start up the editor::
+
+          In [1]: edit
+          Editing... done. Executing edited code...
+          Out[1]: 'def foo():\\n    print("foo() was defined in an editing
+          session")\\n'
+
+        We can then call the function foo()::
+
+          In [2]: foo()
+          foo() was defined in an editing session
+
+        Now we edit foo.  IPython automatically loads the editor with the
+        (temporary) file where foo() was previously defined::
+
+          In [3]: edit foo
+          Editing... done. Executing edited code...
+
+        And if we call foo() again we get the modified version::
+
+          In [4]: foo()
+          foo() has now been changed!
+
+        Here is an example of how to edit a code snippet successive
+        times. First we call the editor::
+
+          In [5]: edit
+          Editing... done. Executing edited code...
+          hello
+          Out[5]: "print('hello')\\n"
+
+        Now we call it again with the previous output (stored in _)::
+
+          In [6]: edit _
+          Editing... done. Executing edited code...
+          hello world
+          Out[6]: "print('hello world')\\n"
+
+        Now we call it with the output #8 (stored in _8, also as Out[8])::
+
+          In [7]: edit _8
+          Editing... done. Executing edited code...
+          hello again
+          Out[7]: "print('hello again')\\n"
+
+
+        Changing the default editor hook:
+
+        If you wish to write your own editor hook, you can put it in a
+        configuration file which you load at startup time.  The default hook
+        is defined in the IPython.core.hooks module, and you can use that as a
+        starting example for further modifications.  That file also has
+        general instructions on how to set a new hook for use once you've
+        defined it."""
+        opts,args = self.parse_options(parameter_s,'prxn:')
+
+        try:
+            filename, lineno, is_temp = self._find_edit_target(self.shell, 
+                                                       args, opts, last_call)
+        except MacroToEdit as e:
+            self._edit_macro(args, e.args[0])
+            return
+        except InteractivelyDefined as e:
+            print("Editing In[%i]" % e.index)
+            args = str(e.index)
+            filename, lineno, is_temp = self._find_edit_target(self.shell, 
+                                                       args, opts, last_call)
+        if filename is None:
+            # nothing was found, warnings have already been issued,
+            # just give up.
+            return
+
+        if is_temp:
+            self._knowntemps.add(filename)
+        elif (filename in self._knowntemps):
+            is_temp = True
+
+
+        # do actual editing here
+        print('Editing...', end=' ')
+        sys.stdout.flush()
+        filepath = Path(filename)
+        try:
+            # Quote filenames that may have spaces in them when opening
+            # the editor
+            quoted = filename = str(filepath.absolute())
+            if " " in quoted:
+                quoted = "'%s'" % quoted
+            self.shell.hooks.editor(quoted, lineno)
+        except TryNext:
+            warn('Could not open editor')
+            return
+
+        # XXX TODO: should this be generalized for all string vars?
+        # For now, this is special-cased to blocks created by cpaste
+        if args.strip() == "pasted_block":
+            self.shell.user_ns["pasted_block"] = filepath.read_text(encoding="utf-8")
+
+        if 'x' in opts:  # -x prevents actual execution
+            print()
+        else:
+            print('done. Executing edited code...')
+            with preserve_keys(self.shell.user_ns, '__file__'):
+                if not is_temp:
+                    self.shell.user_ns["__file__"] = filename
+                if "r" in opts:  # Untranslated IPython code
+                    source = filepath.read_text(encoding="utf-8")
+                    self.shell.run_cell(source, store_history=False)
+                else:
+                    self.shell.safe_execfile(filename, self.shell.user_ns,
+                                             self.shell.user_ns)
+
+        if is_temp:
+            try:
+                return filepath.read_text(encoding="utf-8")
+            except IOError as msg:
+                if Path(msg.filename) == filepath:
+                    warn('File not found. Did you forget to save?')
+                    return
+                else:
+                    self.shell.showtraceback()
diff --git a/IPython/core/magics/config.py b/IPython/core/magics/config.py
new file mode 100644
index 00000000000..9e1cb38c254
--- /dev/null
+++ b/IPython/core/magics/config.py
@@ -0,0 +1,140 @@
+"""Implementation of configuration-related magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import re
+
+# Our own packages
+from IPython.core.error import UsageError
+from IPython.core.magic import Magics, magics_class, line_magic
+from logging import error
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+reg = re.compile(r'^\w+\.\w+$')
+@magics_class
+class ConfigMagics(Magics):
+
+    def __init__(self, shell):
+        super(ConfigMagics, self).__init__(shell)
+        self.configurables = []
+
+    @line_magic
+    def config(self, s):
+        """configure IPython
+
+            %config Class[.trait=value]
+
+        This magic exposes most of the IPython config system. Any
+        Configurable class should be able to be configured with the simple
+        line::
+
+            %config Class.trait=value
+
+        Where `value` will be resolved in the user's namespace, if it is an
+        expression or variable name.
+
+        Examples
+        --------
+
+        To see what classes are available for config, pass no arguments::
+
+            In [1]: %config
+            Available objects for config:
+                AliasManager
+                DisplayFormatter
+                HistoryManager
+                IPCompleter
+                LoggingMagics
+                MagicsManager
+                OSMagics
+                PrefilterManager
+                ScriptMagics
+                TerminalInteractiveShell
+
+        To view what is configurable on a given class, just pass the class
+        name::
+
+            In [2]: %config LoggingMagics
+            LoggingMagics(Magics) options
+            ---------------------------
+            LoggingMagics.quiet=<Bool>
+                Suppress output of log state when logging is enabled
+                Current: False
+
+        but the real use is in setting values::
+
+            In [3]: %config LoggingMagics.quiet = True
+
+        and these values are read from the user_ns if they are variables::
+
+            In [4]: feeling_quiet=False
+
+            In [5]: %config LoggingMagics.quiet = feeling_quiet
+
+        """
+        from traitlets.config.loader import Config
+        # some IPython objects are Configurable, but do not yet have
+        # any configurable traits.  Exclude them from the effects of
+        # this magic, as their presence is just noise:
+        configurables = sorted(set([ c for c in self.shell.configurables
+                                     if c.__class__.class_traits(config=True)
+                                     ]), key=lambda x: x.__class__.__name__)
+        classnames = [ c.__class__.__name__ for c in configurables ]
+
+        line = s.strip()
+        if not line:
+            # print available configurable names
+            print("Available objects for config:")
+            for name in classnames:
+                print("   ", name)
+            return
+        elif line in classnames:
+            # `%config TerminalInteractiveShell` will print trait info for
+            # TerminalInteractiveShell
+            c = configurables[classnames.index(line)]
+            cls = c.__class__
+            help = cls.class_get_help(c)
+            # strip leading '--' from cl-args:
+            help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
+            print(help)
+            return
+        elif reg.match(line):
+            cls, attr = line.split('.')
+            return getattr(configurables[classnames.index(cls)],attr)
+        elif '=' not in line:
+            msg = "Invalid config statement: %r, "\
+                  "should be `Class.trait = value`."
+            
+            ll = line.lower()
+            for classname in classnames:
+                if ll == classname.lower():
+                    msg = msg + '\nDid you mean %s (note the case)?' % classname
+                    break
+
+            raise UsageError( msg % line)
+
+        # otherwise, assume we are setting configurables.
+        # leave quotes on args when splitting, because we want
+        # unquoted args to eval in user_ns
+        cfg = Config()
+        exec("cfg."+line, self.shell.user_ns, locals())
+
+        for configurable in configurables:
+            try:
+                configurable.update_config(cfg)
+            except Exception as e:
+                error(e)
diff --git a/IPython/core/magics/display.py b/IPython/core/magics/display.py
new file mode 100644
index 00000000000..6c0eff6884f
--- /dev/null
+++ b/IPython/core/magics/display.py
@@ -0,0 +1,93 @@
+"""Simple magics for display formats"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Our own packages
+from IPython.display import display, Javascript, Latex, SVG, HTML, Markdown
+from IPython.core.magic import  (
+    Magics, magics_class, cell_magic
+)
+from IPython.core import magic_arguments
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+
+@magics_class
+class DisplayMagics(Magics):
+    """Magics for displaying various output types with literals
+
+    Defines javascript/latex/svg/html cell magics for writing
+    blocks in those languages, to be rendered in the frontend.
+    """
+
+    @cell_magic
+    def js(self, line, cell):
+        """Run the cell block of Javascript code
+
+        Alias of `%%javascript`
+
+        Starting with IPython 8.0 %%javascript is pending deprecation to be replaced
+        by a more flexible system
+
+        Please See https://github.com/ipython/ipython/issues/13376
+        """
+        self.javascript(line, cell)
+
+    @cell_magic
+    def javascript(self, line, cell):
+        """Run the cell block of Javascript code
+
+        Starting with IPython 8.0 %%javascript is pending deprecation to be replaced
+        by a more flexible system
+
+        Please See https://github.com/ipython/ipython/issues/13376
+        """
+        display(Javascript(cell))
+
+
+    @cell_magic
+    def latex(self, line, cell):
+        """Render the cell as a block of LaTeX
+
+        The subset of LaTeX which is supported depends on the implementation in
+        the client.  In the Jupyter Notebook, this magic only renders the subset
+        of LaTeX defined by MathJax
+        [here](https://docs.mathjax.org/en/v2.5-latest/tex.html)."""
+        display(Latex(cell))
+
+    @cell_magic
+    def svg(self, line, cell):
+        """Render the cell as an SVG literal"""
+        display(SVG(cell))
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '--isolated', action='store_true', default=False,
+        help="""Annotate the cell as 'isolated'.
+Isolated cells are rendered inside their own <iframe> tag"""
+    )
+    @cell_magic
+    def html(self, line, cell):
+        """Render the cell as a block of HTML"""
+        args = magic_arguments.parse_argstring(self.html, line)
+        html = HTML(cell)
+        if args.isolated:
+            display(html, metadata={'text/html':{'isolated':True}})
+        else:
+            display(html)
+
+    @cell_magic
+    def markdown(self, line, cell):
+        """Render the cell as Markdown text block"""
+        display(Markdown(cell))
diff --git a/IPython/core/magics/execution.py b/IPython/core/magics/execution.py
new file mode 100644
index 00000000000..fb4897806e3
--- /dev/null
+++ b/IPython/core/magics/execution.py
@@ -0,0 +1,1708 @@
+# -*- coding: utf-8 -*-
+"""Implementation of execution-related magic functions."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import ast
+import bdb
+import builtins as builtin_mod
+import copy
+import cProfile as profile
+import gc
+import itertools
+import math
+import os
+import pstats
+import re
+import shlex
+import sys
+import time
+import timeit
+import signal
+from typing import Dict, Any
+from ast import (
+    Assign,
+    Call,
+    Expr,
+    Load,
+    Module,
+    Name,
+    NodeTransformer,
+    Store,
+    parse,
+    unparse,
+)
+from io import StringIO
+from logging import error
+from pathlib import Path
+from pdb import Restart
+from textwrap import dedent, indent
+from warnings import warn
+
+from IPython.core import magic_arguments, oinspect, page
+from IPython.core.displayhook import DisplayHook
+from IPython.core.error import UsageError
+from IPython.core.macro import Macro
+from IPython.core.magic import (
+    Magics,
+    cell_magic,
+    line_cell_magic,
+    line_magic,
+    magics_class,
+    needs_local_scope,
+    no_var_expand,
+    output_can_be_silenced,
+)
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.capture import capture_output
+from IPython.utils.contexts import preserve_keys
+from IPython.utils.ipstruct import Struct
+from IPython.utils.module_paths import find_mod
+from IPython.utils.path import get_py_filename, shellglob
+from IPython.utils.timing import clock, clock2
+from IPython.core.magics.ast_mod import ReplaceCodeTransformer
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+
+class TimeitResult:
+    """
+    Object returned by the timeit magic with info about the run.
+
+    Contains the following attributes:
+
+    loops: int
+      number of loops done per measurement
+
+    repeat: int
+      number of times the measurement was repeated
+
+    best: float
+      best execution time / number
+
+    all_runs : list[float]
+      execution time of each run (in s)
+
+    compile_time: float
+      time of statement compilation (s)
+
+    """
+    def __init__(self, loops, repeat, best, worst, all_runs, compile_time, precision):
+        self.loops = loops
+        self.repeat = repeat
+        self.best = best
+        self.worst = worst
+        self.all_runs = all_runs
+        self.compile_time = compile_time
+        self._precision = precision
+        self.timings = [dt / self.loops for dt in all_runs]
+
+    @property
+    def average(self):
+        return math.fsum(self.timings) / len(self.timings)
+
+    @property
+    def stdev(self):
+        mean = self.average
+        return (math.fsum([(x - mean) ** 2 for x in self.timings]) / len(self.timings)) ** 0.5
+
+    def __str__(self):
+        pm = '+-'
+        if hasattr(sys.stdout, 'encoding') and sys.stdout.encoding:
+            try:
+                "\xb1".encode(sys.stdout.encoding)
+                pm = "\xb1"
+            except:
+                pass
+        return "{mean} {pm} {std} per loop (mean {pm} std. dev. of {runs} run{run_plural}, {loops:,} loop{loop_plural} each)".format(
+            pm=pm,
+            runs=self.repeat,
+            loops=self.loops,
+            loop_plural="" if self.loops == 1 else "s",
+            run_plural="" if self.repeat == 1 else "s",
+            mean=_format_time(self.average, self._precision),
+            std=_format_time(self.stdev, self._precision),
+        )
+
+    def _repr_pretty_(self, p , cycle):
+        unic = self.__str__()
+        p.text("<TimeitResult : " + unic + ">")
+
+
+class TimeitTemplateFiller(ast.NodeTransformer):
+    """Fill in the AST template for timing execution.
+
+    This is quite closely tied to the template definition, which is in
+    :meth:`ExecutionMagics.timeit`.
+    """
+    def __init__(self, ast_setup, ast_stmt):
+        self.ast_setup = ast_setup
+        self.ast_stmt = ast_stmt
+
+    def visit_FunctionDef(self, node):
+        "Fill in the setup statement"
+        self.generic_visit(node)
+        if node.name == "inner":
+            node.body[:1] = self.ast_setup.body
+
+        return node
+
+    def visit_For(self, node):
+        "Fill in the statement to be timed"
+        if getattr(getattr(node.body[0], 'value', None), 'id', None) == 'stmt':
+            node.body = self.ast_stmt.body
+        return node
+
+
+class Timer(timeit.Timer):
+    """Timer class that explicitly uses self.inner
+
+    which is an undocumented implementation detail of CPython,
+    not shared by PyPy.
+    """
+
+    # Timer.timeit copied from CPython 3.4.2
+    def timeit(self, number=timeit.default_number):
+        """Time 'number' executions of the main statement.
+
+        To be precise, this executes the setup statement once, and
+        then returns the time it takes to execute the main statement
+        a number of times, as a float measured in seconds.  The
+        argument is the number of times through the loop, defaulting
+        to one million.  The main statement, the setup statement and
+        the timer function to be used are passed to the constructor.
+        """
+        it = itertools.repeat(None, number)
+        gcold = gc.isenabled()
+        gc.disable()
+        try:
+            timing = self.inner(it, self.timer)
+        finally:
+            if gcold:
+                gc.enable()
+        return timing
+
+
+@magics_class
+class ExecutionMagics(Magics):
+    """Magics related to code execution, debugging, profiling, etc."""
+
+    _transformers: Dict[str, Any] = {}
+
+    def __init__(self, shell):
+        super(ExecutionMagics, self).__init__(shell)
+        # Default execution function used to actually run user code.
+        self.default_runner = None
+
+    @skip_doctest
+    @no_var_expand
+    @line_cell_magic
+    def prun(self, parameter_s='', cell=None):
+        """Run a statement through the python code profiler.
+
+        **Usage, in line mode**::
+
+          %prun [options] statement
+
+        **Usage, in cell mode**::
+
+          %%prun [options] [statement]
+          code...
+          code...
+
+        In cell mode, the additional code lines are appended to the (possibly
+        empty) statement in the first line.  Cell mode allows you to easily
+        profile multiline blocks without having to put them in a separate
+        function.
+
+        The given statement (which doesn't require quote marks) is run via the
+        python profiler in a manner similar to the profile.run() function.
+        Namespaces are internally managed to work correctly; profile.run
+        cannot be used in IPython because it makes certain assumptions about
+        namespaces which do not hold under IPython.
+
+        Options:
+
+        -l <limit>
+          you can place restrictions on what or how much of the
+          profile gets printed. The limit value can be:
+
+             * A string: only information for function names containing this string
+               is printed.
+
+             * An integer: only these many lines are printed.
+
+             * A float (between 0 and 1): this fraction of the report is printed
+               (for example, use a limit of 0.4 to see the topmost 40% only).
+
+          You can combine several limits with repeated use of the option. For
+          example, ``-l __init__ -l 5`` will print only the topmost 5 lines of
+          information about class constructors.
+
+        -r
+          return the pstats.Stats object generated by the profiling. This
+          object has all the information about the profile in it, and you can
+          later use it for further analysis or in other functions.
+
+        -s <key>
+          sort profile by given key. You can provide more than one key
+          by using the option several times: '-s key1 -s key2 -s key3...'. The
+          default sorting key is 'time'.
+
+          The following is copied verbatim from the profile documentation
+          referenced below:
+
+          When more than one key is provided, additional keys are used as
+          secondary criteria when the there is equality in all keys selected
+          before them.
+
+          Abbreviations can be used for any key names, as long as the
+          abbreviation is unambiguous.  The following are the keys currently
+          defined:
+
+          ============  =====================
+          Valid Arg     Meaning
+          ============  =====================
+          "calls"       call count
+          "cumulative"  cumulative time
+          "file"        file name
+          "module"      file name
+          "pcalls"      primitive call count
+          "line"        line number
+          "name"        function name
+          "nfl"         name/file/line
+          "stdname"     standard name
+          "time"        internal time
+          ============  =====================
+
+          Note that all sorts on statistics are in descending order (placing
+          most time consuming items first), where as name, file, and line number
+          searches are in ascending order (i.e., alphabetical). The subtle
+          distinction between "nfl" and "stdname" is that the standard name is a
+          sort of the name as printed, which means that the embedded line
+          numbers get compared in an odd way.  For example, lines 3, 20, and 40
+          would (if the file names were the same) appear in the string order
+          "20" "3" and "40".  In contrast, "nfl" does a numeric compare of the
+          line numbers.  In fact, sort_stats("nfl") is the same as
+          sort_stats("name", "file", "line").
+
+        -T <filename>
+          save profile results as shown on screen to a text
+          file. The profile is still shown on screen.
+
+        -D <filename>
+          save (via dump_stats) profile statistics to given
+          filename. This data is in a format understood by the pstats module, and
+          is generated by a call to the dump_stats() method of profile
+          objects. The profile is still shown on screen.
+
+        -q
+          suppress output to the pager.  Best used with -T and/or -D above.
+
+        If you want to run complete programs under the profiler's control, use
+        ``%run -p [prof_opts] filename.py [args to program]`` where prof_opts
+        contains profiler specific options as described here.
+
+        You can read the complete documentation for the profile module with::
+
+          In [1]: import profile; profile.help()
+
+        .. versionchanged:: 7.3
+            User variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        """
+        # TODO: port to magic_arguments as currently this is duplicated in IPCompleter._extract_code
+        opts, arg_str = self.parse_options(parameter_s, 'D:l:rs:T:q',
+                                           list_all=True, posix=False)
+        if cell is not None:
+            arg_str += '\n' + cell
+        arg_str = self.shell.transform_cell(arg_str)
+        return self._run_with_profiler(arg_str, opts, self.shell.user_ns)
+
+    def _run_with_profiler(self, code, opts, namespace):
+        """
+        Run `code` with profiler.  Used by ``%prun`` and ``%run -p``.
+
+        Parameters
+        ----------
+        code : str
+            Code to be executed.
+        opts : Struct
+            Options parsed by `self.parse_options`.
+        namespace : dict
+            A dictionary for Python namespace (e.g., `self.shell.user_ns`).
+
+        """
+
+        # Fill default values for unspecified options:
+        opts.merge(Struct(D=[''], l=[], s=['time'], T=['']))
+
+        prof = profile.Profile()
+        try:
+            prof = prof.runctx(code, namespace, namespace)
+            sys_exit = ''
+        except SystemExit:
+            sys_exit = """*** SystemExit exception caught in code being profiled."""
+
+        stats = pstats.Stats(prof).strip_dirs().sort_stats(*opts.s)
+
+        lims = opts.l
+        if lims:
+            lims = []  # rebuild lims with ints/floats/strings
+            for lim in opts.l:
+                try:
+                    lims.append(int(lim))
+                except ValueError:
+                    try:
+                        lims.append(float(lim))
+                    except ValueError:
+                        lims.append(lim)
+
+        # Trap output.
+        stdout_trap = StringIO()
+        stats_stream = stats.stream
+        try:
+            stats.stream = stdout_trap
+            stats.print_stats(*lims)
+        finally:
+            stats.stream = stats_stream
+
+        output = stdout_trap.getvalue()
+        output = output.rstrip()
+
+        if 'q' not in opts:
+            page.page(output)
+        print(sys_exit, end=' ')
+
+        dump_file = opts.D[0]
+        text_file = opts.T[0]
+        if dump_file:
+            prof.dump_stats(dump_file)
+            print(
+                f"\n*** Profile stats marshalled to file {repr(dump_file)}.{sys_exit}"
+            )
+        if text_file:
+            pfile = Path(text_file)
+            pfile.touch(exist_ok=True)
+            pfile.write_text(output, encoding="utf-8")
+
+            print(
+                f"\n*** Profile printout saved to text file {repr(text_file)}.{sys_exit}"
+            )
+
+        if 'r' in opts:
+            return stats
+
+        return None
+
+    @line_magic
+    def pdb(self, parameter_s=''):
+        """Control the automatic calling of the pdb interactive debugger.
+
+        Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
+        argument it works as a toggle.
+
+        When an exception is triggered, IPython can optionally call the
+        interactive pdb debugger after the traceback printout. %pdb toggles
+        this feature on and off.
+
+        The initial state of this feature is set in your configuration
+        file (the option is ``InteractiveShell.pdb``).
+
+        If you want to just activate the debugger AFTER an exception has fired,
+        without having to type '%pdb on' and rerunning your code, you can use
+        the %debug magic."""
+
+        par = parameter_s.strip().lower()
+
+        new_pdb: bool
+
+        if par:
+            try:
+                new_pdb = {"off": False, "0": False, "on": True, "1": True}[par]
+            except KeyError:
+                print ('Incorrect argument. Use on/1, off/0, '
+                       'or nothing for a toggle.')
+                return
+        else:
+            # toggle
+            new_pdb = not self.shell.call_pdb
+
+        # set on the shell
+        self.shell.call_pdb = new_pdb
+        print("Automatic pdb calling has been turned", "ON" if new_pdb else "OFF")
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument('--breakpoint', '-b', metavar='FILE:LINE',
+        help="""
+        Set break point at LINE in FILE.
+        """
+    )
+    @magic_arguments.kwds(
+        epilog="""
+      Any remaining arguments will be treated as code to run in the debugger.
+    """
+    )
+    @no_var_expand
+    @line_cell_magic
+    @needs_local_scope
+    def debug(self, line="", cell=None, local_ns=None):
+        """Activate the interactive debugger.
+
+        This magic command support two ways of activating debugger.
+        One is to activate debugger before executing code. This way, you
+        can set a break point, to step through the code from the point.
+        You can use this mode by giving statements to execute and optionally
+        a breakpoint.
+
+        The other one is to activate debugger in post-mortem mode. You can
+        activate this mode simply running %debug without any argument.
+        If an exception has just occurred, this lets you inspect its stack
+        frames interactively.  Note that this will always work only on the last
+        traceback that occurred, so you must call this quickly after an
+        exception that you wish to inspect has fired, because if another one
+        occurs, it clobbers the previous one.
+
+        If you want IPython to automatically do this on every exception, see
+        the %pdb magic for more details.
+
+        .. versionchanged:: 7.3
+            When running code, user variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        """
+        args, extra = magic_arguments.parse_argstring(self.debug, line, partial=True)
+
+        if not (args.breakpoint or extra or cell):
+            self._debug_post_mortem()
+        elif not (args.breakpoint or cell):
+            # If there is no breakpoints, the line is just code to execute
+            self._debug_exec(line, None, local_ns)
+        else:
+            # Here we try to reconstruct the code from the output of
+            # parse_argstring. This might not work if the code has spaces
+            # For example this fails for `print("a b")`
+            code = " ".join(extra)
+            if cell:
+                code += "\n" + cell
+            self._debug_exec(code, args.breakpoint, local_ns)
+
+    def _debug_post_mortem(self):
+        self.shell.debugger(force=True)
+
+    def _debug_exec(self, code, breakpoint, local_ns=None):
+        if breakpoint:
+            (filename, bp_line) = breakpoint.rsplit(':', 1)
+            bp_line = int(bp_line)
+        else:
+            (filename, bp_line) = (None, None)
+        self._run_with_debugger(
+            code, self.shell.user_ns, filename, bp_line, local_ns=local_ns
+        )
+
+    @line_magic
+    def tb(self, s):
+        """Print the last traceback.
+
+        Optionally, specify an exception reporting mode, tuning the
+        verbosity of the traceback. By default the currently-active exception
+        mode is used. See %xmode for changing exception reporting modes.
+
+        Valid modes: Plain, Context, Verbose, and Minimal.
+        """
+        interactive_tb = self.shell.InteractiveTB
+        if s:
+            # Switch exception reporting mode for this one call.
+            # Ensure it is switched back.
+            def xmode_switch_err(name):
+                warn('Error changing %s exception modes.\n%s' %
+                    (name,sys.exc_info()[1]))
+
+            new_mode = s.strip().capitalize()
+            original_mode = interactive_tb.mode
+            try:
+                try:
+                    interactive_tb.set_mode(mode=new_mode)
+                except Exception:
+                    xmode_switch_err('user')
+                else:
+                    self.shell.showtraceback()
+            finally:
+                interactive_tb.set_mode(mode=original_mode)
+        else:
+            self.shell.showtraceback()
+
+    @skip_doctest
+    @line_magic
+    def run(self, parameter_s='', runner=None,
+                  file_finder=get_py_filename):
+        """Run the named file inside IPython as a program.
+
+        Usage::
+
+          %run [-n -i -e -G]
+               [( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]
+               ( -m mod | filename ) [args]
+
+        The filename argument should be either a pure Python script (with
+        extension ``.py``), or a file with custom IPython syntax (such as
+        magics). If the latter, the file can be either a script with ``.ipy``
+        extension, or a Jupyter notebook with ``.ipynb`` extension. When running
+        a Jupyter notebook, the output from print statements and other
+        displayed objects will appear in the terminal (even matplotlib figures
+        will open, if a terminal-compliant backend is being used). Note that,
+        at the system command line, the ``jupyter run`` command offers similar
+        functionality for executing notebooks (albeit currently with some
+        differences in supported options).
+
+        Parameters after the filename are passed as command-line arguments to
+        the program (put in sys.argv). Then, control returns to IPython's
+        prompt.
+
+        This is similar to running at a system prompt ``python file args``,
+        but with the advantage of giving you IPython's tracebacks, and of
+        loading all variables into your interactive namespace for further use
+        (unless -p is used, see below).
+
+        The file is executed in a namespace initially consisting only of
+        ``__name__=='__main__'`` and sys.argv constructed as indicated. It thus
+        sees its environment as if it were being run as a stand-alone program
+        (except for sharing global objects such as previously imported
+        modules). But after execution, the IPython interactive namespace gets
+        updated with all variables defined in the program (except for ``__name__``
+        and ``sys.argv``). This allows for very convenient loading of code for
+        interactive work, while giving each program a 'clean sheet' to run in.
+
+        Arguments are expanded using shell-like glob match.  Patterns
+        '*', '?', '[seq]' and '[!seq]' can be used.  Additionally,
+        tilde '~' will be expanded into user's home directory.  Unlike
+        real shells, quotation does not suppress expansions.  Use
+        *two* back slashes (e.g. ``\\\\*``) to suppress expansions.
+        To completely disable these expansions, you can use -G flag.
+
+        On Windows systems, the use of single quotes `'` when specifying
+        a file is not supported. Use double quotes `"`.
+
+        Options:
+
+        -n
+          __name__ is NOT set to '__main__', but to the running file's name
+          without extension (as python does under import).  This allows running
+          scripts and reloading the definitions in them without calling code
+          protected by an ``if __name__ == "__main__"`` clause.
+
+        -i
+          run the file in IPython's namespace instead of an empty one. This
+          is useful if you are experimenting with code written in a text editor
+          which depends on variables defined interactively.
+
+        -e
+          ignore sys.exit() calls or SystemExit exceptions in the script
+          being run.  This is particularly useful if IPython is being used to
+          run unittests, which always exit with a sys.exit() call.  In such
+          cases you are interested in the output of the test results, not in
+          seeing a traceback of the unittest module.
+
+        -t
+          print timing information at the end of the run.  IPython will give
+          you an estimated CPU time consumption for your script, which under
+          Unix uses the resource module to avoid the wraparound problems of
+          time.clock().  Under Unix, an estimate of time spent on system tasks
+          is also given (for Windows platforms this is reported as 0.0).
+
+          If -t is given, an additional ``-N<N>`` option can be given, where <N>
+          must be an integer indicating how many times you want the script to
+          run.  The final timing report will include total and per run results.
+
+          For example (testing the script myscript.py)::
+
+              In [1]: run -t myscript
+
+              IPython CPU timings (estimated):
+                User  :    0.19597 s.
+                System:        0.0 s.
+
+              In [2]: run -t -N5 myscript
+
+              IPython CPU timings (estimated):
+              Total runs performed: 5
+                Times :      Total       Per run
+                User  :   0.910862 s,  0.1821724 s.
+                System:        0.0 s,        0.0 s.
+
+        -d
+          run your program under the control of pdb, the Python debugger.
+          This allows you to execute your program step by step, watch variables,
+          etc.  Internally, what IPython does is similar to calling::
+
+              pdb.run('execfile("YOURFILENAME")')
+
+          with a breakpoint set on line 1 of your file.  You can change the line
+          number for this automatic breakpoint to be <N> by using the -bN option
+          (where N must be an integer). For example::
+
+              %run -d -b40 myscript
+
+          will set the first breakpoint at line 40 in myscript.py.  Note that
+          the first breakpoint must be set on a line which actually does
+          something (not a comment or docstring) for it to stop execution.
+
+          Or you can specify a breakpoint in a different file::
+
+              %run -d -b myotherfile.py:20 myscript
+
+          When the pdb debugger starts, you will see a (Pdb) prompt.  You must
+          first enter 'c' (without quotes) to start execution up to the first
+          breakpoint.
+
+          Entering 'help' gives information about the use of the debugger.  You
+          can easily see pdb's full documentation with "import pdb;pdb.help()"
+          at a prompt.
+
+        -p
+          run program under the control of the Python profiler module (which
+          prints a detailed report of execution times, function calls, etc).
+
+          You can pass other options after -p which affect the behavior of the
+          profiler itself. See the docs for %prun for details.
+
+          In this mode, the program's variables do NOT propagate back to the
+          IPython interactive namespace (because they remain in the namespace
+          where the profiler executes them).
+
+          Internally this triggers a call to %prun, see its documentation for
+          details on the options available specifically for profiling.
+
+        There is one special usage for which the text above doesn't apply:
+        if the filename ends with .ipy[nb], the file is run as ipython script,
+        just as if the commands were written on IPython prompt.
+
+        -m
+          specify module name to load instead of script path. Similar to
+          the -m option for the python interpreter. Use this option last if you
+          want to combine with other %run options. Unlike the python interpreter
+          only source modules are allowed no .pyc or .pyo files.
+          For example::
+
+              %run -m example
+
+          will run the example module.
+
+        -G
+          disable shell-like glob expansion of arguments.
+
+        """
+
+        # Logic to handle issue #3664
+        # Add '--' after '-m <module_name>' to ignore additional args passed to a module.
+        if '-m' in parameter_s and '--' not in parameter_s:
+            argv = shlex.split(parameter_s, posix=(os.name == 'posix'))
+            for idx, arg in enumerate(argv):
+                if arg and arg.startswith('-') and arg != '-':
+                    if arg == '-m':
+                        argv.insert(idx + 2, '--')
+                        break
+                else:
+                    # Positional arg, break
+                    break
+            parameter_s = ' '.join(shlex.quote(arg) for arg in argv)
+
+        # get arguments and set sys.argv for program to be run.
+        opts, arg_lst = self.parse_options(parameter_s,
+                                           'nidtN:b:pD:l:rs:T:em:G',
+                                           mode='list', list_all=1)
+        if "m" in opts:
+            modulename = opts["m"][0]
+            modpath = find_mod(modulename)
+            if modpath is None:
+                msg = '%r is not a valid modulename on sys.path'%modulename
+                raise Exception(msg)
+            arg_lst = [modpath] + arg_lst
+        try:
+            fpath = None # initialize to make sure fpath is in scope later
+            fpath = arg_lst[0]
+            filename = file_finder(fpath)
+        except IndexError as e:
+            msg = 'you must provide at least a filename.'
+            raise Exception(msg) from e
+        except IOError as e:
+            try:
+                msg = str(e)
+            except UnicodeError:
+                msg = e.message
+            if os.name == 'nt' and re.match(r"^'.*'$",fpath):
+                warn('For Windows, use double quotes to wrap a filename: %run "mypath\\myfile.py"')
+            raise Exception(msg) from e
+        except TypeError:
+            if fpath in sys.meta_path:
+                filename = ""
+            else:
+                raise
+
+        if filename.lower().endswith(('.ipy', '.ipynb')):
+            with preserve_keys(self.shell.user_ns, '__file__'):
+                self.shell.user_ns['__file__'] = filename
+                self.shell.safe_execfile_ipy(filename, raise_exceptions=True)
+            return
+
+        # Control the response to exit() calls made by the script being run
+        exit_ignore = 'e' in opts
+
+        # Make sure that the running script gets a proper sys.argv as if it
+        # were run from a system shell.
+        save_argv = sys.argv # save it for later restoring
+
+        if 'G' in opts:
+            args = arg_lst[1:]
+        else:
+            # tilde and glob expansion
+            args = shellglob(map(os.path.expanduser,  arg_lst[1:]))
+
+        sys.argv = [filename] + args  # put in the proper filename
+
+        if 'n' in opts:
+            name = Path(filename).stem
+        else:
+            name = '__main__'
+
+        if 'i' in opts:
+            # Run in user's interactive namespace
+            prog_ns = self.shell.user_ns
+            __name__save = self.shell.user_ns['__name__']
+            prog_ns['__name__'] = name
+            main_mod = self.shell.user_module
+
+            # Since '%run foo' emulates 'python foo.py' at the cmd line, we must
+            # set the __file__ global in the script's namespace
+            # TK: Is this necessary in interactive mode?
+            prog_ns['__file__'] = filename
+        else:
+            # Run in a fresh, empty namespace
+
+            # The shell MUST hold a reference to prog_ns so after %run
+            # exits, the python deletion mechanism doesn't zero it out
+            # (leaving dangling references). See interactiveshell for details
+            main_mod = self.shell.new_main_mod(filename, name)
+            prog_ns = main_mod.__dict__
+
+        # pickle fix.  See interactiveshell for an explanation.  But we need to
+        # make sure that, if we overwrite __main__, we replace it at the end
+        main_mod_name = prog_ns['__name__']
+
+        if main_mod_name == '__main__':
+            restore_main = sys.modules['__main__']
+        else:
+            restore_main = False
+
+        # This needs to be undone at the end to prevent holding references to
+        # every single object ever created.
+        sys.modules[main_mod_name] = main_mod
+
+        if 'p' in opts or 'd' in opts:
+            if 'm' in opts:
+                code = 'run_module(modulename, prog_ns)'
+                code_ns = {
+                    'run_module': self.shell.safe_run_module,
+                    'prog_ns': prog_ns,
+                    'modulename': modulename,
+                }
+            else:
+                if 'd' in opts:
+                    # allow exceptions to raise in debug mode
+                    code = 'execfile(filename, prog_ns, raise_exceptions=True)'
+                else:
+                    code = 'execfile(filename, prog_ns)'
+                code_ns = {
+                    'execfile': self.shell.safe_execfile,
+                    'prog_ns': prog_ns,
+                    'filename': get_py_filename(filename),
+                }
+
+        try:
+            stats = None
+            if 'p' in opts:
+                stats = self._run_with_profiler(code, opts, code_ns)
+            else:
+                if 'd' in opts:
+                    bp_file, bp_line = parse_breakpoint(
+                        opts.get('b', ['1'])[0], filename)
+                    self._run_with_debugger(
+                        code, code_ns, filename, bp_line, bp_file)
+                else:
+                    if 'm' in opts:
+                        def run():
+                            self.shell.safe_run_module(modulename, prog_ns)
+                    else:
+                        if runner is None:
+                            runner = self.default_runner
+                        if runner is None:
+                            runner = self.shell.safe_execfile
+
+                        def run():
+                            runner(filename, prog_ns, prog_ns,
+                                    exit_ignore=exit_ignore)
+
+                    if 't' in opts:
+                        # timed execution
+                        try:
+                            nruns = int(opts['N'][0])
+                            if nruns < 1:
+                                error('Number of runs must be >=1')
+                                return
+                        except (KeyError):
+                            nruns = 1
+                        self._run_with_timing(run, nruns)
+                    else:
+                        # regular execution
+                        run()
+
+            if 'i' in opts:
+                self.shell.user_ns['__name__'] = __name__save
+            else:
+                # update IPython interactive namespace
+
+                # Some forms of read errors on the file may mean the
+                # __name__ key was never set; using pop we don't have to
+                # worry about a possible KeyError.
+                prog_ns.pop('__name__', None)
+
+                with preserve_keys(self.shell.user_ns, '__file__'):
+                    self.shell.user_ns.update(prog_ns)
+        finally:
+            # It's a bit of a mystery why, but __builtins__ can change from
+            # being a module to becoming a dict missing some key data after
+            # %run.  As best I can see, this is NOT something IPython is doing
+            # at all, and similar problems have been reported before:
+            # http://coding.derkeiler.com/Archive/Python/comp.lang.python/2004-10/0188.html
+            # Since this seems to be done by the interpreter itself, the best
+            # we can do is to at least restore __builtins__ for the user on
+            # exit.
+            self.shell.user_ns['__builtins__'] = builtin_mod
+
+            # Ensure key global structures are restored
+            sys.argv = save_argv
+            if restore_main:
+                sys.modules['__main__'] = restore_main
+                if '__mp_main__' in sys.modules:
+                    sys.modules['__mp_main__'] = restore_main
+            else:
+                # Remove from sys.modules the reference to main_mod we'd
+                # added.  Otherwise it will trap references to objects
+                # contained therein.
+                del sys.modules[main_mod_name]
+
+        return stats
+
+    def _run_with_debugger(
+        self, code, code_ns, filename=None, bp_line=None, bp_file=None, local_ns=None
+    ):
+        """
+        Run `code` in debugger with a break point.
+
+        Parameters
+        ----------
+        code : str
+            Code to execute.
+        code_ns : dict
+            A namespace in which `code` is executed.
+        filename : str
+            `code` is ran as if it is in `filename`.
+        bp_line : int, optional
+            Line number of the break point.
+        bp_file : str, optional
+            Path to the file in which break point is specified.
+            `filename` is used if not given.
+        local_ns : dict, optional
+            A local namespace in which `code` is executed.
+
+        Raises
+        ------
+        UsageError
+            If the break point given by `bp_line` is not valid.
+
+        """
+        deb = self.shell.InteractiveTB.pdb
+        if not deb:
+            self.shell.InteractiveTB.pdb = self.shell.InteractiveTB.debugger_cls()
+            deb = self.shell.InteractiveTB.pdb
+
+        # reset Breakpoint state, which is moronically kept
+        # in a class
+        bdb.Breakpoint.next = 1
+        bdb.Breakpoint.bplist = {}
+        bdb.Breakpoint.bpbynumber = [None]
+        deb.clear_all_breaks()
+        if bp_line is not None:
+            # Set an initial breakpoint to stop execution
+            maxtries = 10
+            bp_file = bp_file or filename
+            checkline = deb.checkline(bp_file, bp_line)
+            if not checkline:
+                for bp in range(bp_line + 1, bp_line + maxtries + 1):
+                    if deb.checkline(bp_file, bp):
+                        break
+                else:
+                    msg = ("\nI failed to find a valid line to set "
+                           "a breakpoint\n"
+                           "after trying up to line: %s.\n"
+                           "Please set a valid breakpoint manually "
+                           "with the -b option." % bp)
+                    raise UsageError(msg)
+            # if we find a good linenumber, set the breakpoint
+            deb.do_break('%s:%s' % (bp_file, bp_line))
+
+        if filename:
+            # Mimic Pdb._runscript(...)
+            deb._wait_for_mainpyfile = True
+            deb.mainpyfile = deb.canonic(filename)
+
+        # Start file run
+        print("NOTE: Enter 'c' at the %s prompt to continue execution." % deb.prompt)
+        try:
+            if filename:
+                # save filename so it can be used by methods on the deb object
+                deb._exec_filename = filename
+            while True:
+                try:
+                    trace = sys.gettrace()
+                    deb.run(code, code_ns, local_ns)
+                except Restart:
+                    print("Restarting")
+                    if filename:
+                        deb._wait_for_mainpyfile = True
+                        deb.mainpyfile = deb.canonic(filename)
+                    continue
+                else:
+                    break
+                finally:
+                    sys.settrace(trace)
+
+            # Perform proper cleanup of the session in case if
+            # it exited with "continue" and not "quit" command
+            if hasattr(deb, "rcLines"):
+                # Run this code defensively in case if custom debugger
+                # class does not implement rcLines, which although public
+                # is an implementation detail of `pdb.Pdb` and not part of
+                # the more generic basic debugger framework (`bdb.Bdb`).
+                deb.set_quit()
+                deb.rcLines.extend(["q"])
+                try:
+                    deb.run("", code_ns, local_ns)
+                except StopIteration:
+                    # Stop iteration is raised on quit command
+                    pass
+
+        except Exception:
+            etype, value, tb = sys.exc_info()
+            # Skip three frames in the traceback: the %run one,
+            # one inside bdb.py, and the command-line typed by the
+            # user (run by exec in pdb itself).
+            self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
+
+    @staticmethod
+    def _run_with_timing(run, nruns):
+        """
+        Run function `run` and print timing information.
+
+        Parameters
+        ----------
+        run : callable
+            Any callable object which takes no argument.
+        nruns : int
+            Number of times to execute `run`.
+
+        """
+        twall0 = time.perf_counter()
+        if nruns == 1:
+            t0 = clock2()
+            run()
+            t1 = clock2()
+            t_usr = t1[0] - t0[0]
+            t_sys = t1[1] - t0[1]
+            print("\nIPython CPU timings (estimated):")
+            print("  User   : %10.2f s." % t_usr)
+            print("  System : %10.2f s." % t_sys)
+        else:
+            runs = range(nruns)
+            t0 = clock2()
+            for nr in runs:
+                run()
+            t1 = clock2()
+            t_usr = t1[0] - t0[0]
+            t_sys = t1[1] - t0[1]
+            print("\nIPython CPU timings (estimated):")
+            print("Total runs performed:", nruns)
+            print("  Times  : %10s   %10s" % ('Total', 'Per run'))
+            print("  User   : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns))
+            print("  System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns))
+        twall1 = time.perf_counter()
+        print("Wall time: %10.2f s." % (twall1 - twall0))
+
+    @skip_doctest
+    @no_var_expand
+    @line_cell_magic
+    @needs_local_scope
+    def timeit(self, line='', cell=None, local_ns=None):
+        """Time execution of a Python statement or expression
+
+        **Usage, in line mode**::
+
+          %timeit [-n<N> -r<R> [-t|-c] -q -p<P> [-o|-v <V>]] statement
+
+        **or in cell mode**::
+
+          %%timeit [-n<N> -r<R> [-t|-c] -q -p<P> [-o|-v <V>]] setup_code
+          code
+          code...
+
+        Time execution of a Python statement or expression using the timeit
+        module.  This function can be used both as a line and cell magic:
+
+        - In line mode you can time a single-line statement (though multiple
+          ones can be chained with using semicolons).
+
+        - In cell mode, the statement in the first line is used as setup code
+          (executed but not timed) and the body of the cell is timed.  The cell
+          body has access to any variables created in the setup code.
+
+        Options:
+
+        -n<N>
+          Execute the given statement N times in a loop. If N is not
+          provided, N is determined so as to get sufficient accuracy.
+
+        -r<R>
+          Number of repeats R, each consisting of N loops, and take the
+          average result.
+          Default: 7
+
+        -t
+          Use ``time.time`` to measure the time, which is the default on Unix.
+          This function measures wall time.
+
+        -c
+          Use ``time.clock`` to measure the time, which is the default on
+          Windows and measures wall time. On Unix, ``resource.getrusage`` is used
+          instead and returns the CPU user time.
+
+        -p<P>
+          Use a precision of P digits to display the timing result.
+          Default: 3
+
+        -q
+          Quiet, do not print result.
+
+        -o
+          Return a ``TimeitResult`` that can be stored in a variable to inspect
+          the result in more details.
+
+        -v <V>
+          Like ``-o``, but save the ``TimeitResult`` directly to variable <V>.
+
+        .. versionchanged:: 7.3
+            User variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        Examples
+        --------
+        ::
+
+          In [1]: %timeit pass
+          8.26 ns ± 0.12 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
+
+          In [2]: u = None
+
+          In [3]: %timeit u is None
+          29.9 ns ± 0.643 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+          In [4]: %timeit -r 4 u == None
+
+          In [5]: import time
+
+          In [6]: %timeit -n1 time.sleep(2)
+
+        The times reported by ``%timeit`` will be slightly higher than those
+        reported by the timeit.py script when variables are accessed. This is
+        due to the fact that ``%timeit`` executes the statement in the namespace
+        of the shell, compared with timeit.py, which uses a single setup
+        statement to import function or create variables. Generally, the bias
+        does not matter as long as results from timeit.py are not mixed with
+        those from ``%timeit``."""
+
+        # TODO: port to magic_arguments as currently this is duplicated in IPCompleter._extract_code
+        opts, stmt = self.parse_options(
+            line, "n:r:tcp:qov:", posix=False, strict=False, preserve_non_opts=True
+        )
+        if stmt == "" and cell is None:
+            return
+
+        timefunc = timeit.default_timer
+        number = int(getattr(opts, "n", 0))
+        default_repeat = 7 if timeit.default_repeat < 7 else timeit.default_repeat
+        repeat = int(getattr(opts, "r", default_repeat))
+        precision = int(getattr(opts, "p", 3))
+        quiet = "q" in opts
+        return_result = "o" in opts
+        save_result = "v" in opts
+        if hasattr(opts, "t"):
+            timefunc = time.time
+        if hasattr(opts, "c"):
+            timefunc = clock
+
+        timer = Timer(timer=timefunc)
+        # this code has tight coupling to the inner workings of timeit.Timer,
+        # but is there a better way to achieve that the code stmt has access
+        # to the shell namespace?
+        transform  = self.shell.transform_cell
+
+        if cell is None:
+            # called as line magic
+            ast_setup = self.shell.compile.ast_parse("pass")
+            ast_stmt = self.shell.compile.ast_parse(transform(stmt))
+        else:
+            ast_setup = self.shell.compile.ast_parse(transform(stmt))
+            ast_stmt = self.shell.compile.ast_parse(transform(cell))
+
+        ast_setup = self.shell.transform_ast(ast_setup)
+        ast_stmt = self.shell.transform_ast(ast_stmt)
+
+        # Check that these compile to valid Python code *outside* the timer func
+        # Invalid code may become valid when put inside the function & loop,
+        # which messes up error messages.
+        # https://github.com/ipython/ipython/issues/10636
+        self.shell.compile(ast_setup, "<magic-timeit-setup>", "exec")
+        self.shell.compile(ast_stmt, "<magic-timeit-stmt>", "exec")
+
+        # This codestring is taken from timeit.template - we fill it in as an
+        # AST, so that we can apply our AST transformations to the user code
+        # without affecting the timing code.
+        timeit_ast_template = ast.parse('def inner(_it, _timer):\n'
+                                        '    setup\n'
+                                        '    _t0 = _timer()\n'
+                                        '    for _i in _it:\n'
+                                        '        stmt\n'
+                                        '    _t1 = _timer()\n'
+                                        '    return _t1 - _t0\n')
+
+        timeit_ast = TimeitTemplateFiller(ast_setup, ast_stmt).visit(timeit_ast_template)
+        timeit_ast = ast.fix_missing_locations(timeit_ast)
+
+        # Track compilation time so it can be reported if too long
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
+
+        t0 = clock()
+        code = self.shell.compile(timeit_ast, "<magic-timeit>", "exec")
+        tc = clock()-t0
+
+        ns = {}
+        glob = self.shell.user_ns
+        # handles global vars with same name as local vars. We store them in conflict_globs.
+        conflict_globs = {}
+        if local_ns and cell is None:
+            for var_name, var_val in glob.items():
+                if var_name in local_ns:
+                    conflict_globs[var_name] = var_val
+            glob.update(local_ns)
+
+        exec(code, glob, ns)
+        timer.inner = ns["inner"]
+
+        # This is used to check if there is a huge difference between the
+        # best and worst timings.
+        # Issue: https://github.com/ipython/ipython/issues/6471
+        if number == 0:
+            # determine number so that 0.2 <= total time < 2.0
+            for index in range(0, 10):
+                number = 10 ** index
+                time_number = timer.timeit(number)
+                if time_number >= 0.2:
+                    break
+
+        all_runs = timer.repeat(repeat, number)
+        best = min(all_runs) / number
+        worst = max(all_runs) / number
+        timeit_result = TimeitResult(number, repeat, best, worst, all_runs, tc, precision)
+
+        # Restore global vars from conflict_globs
+        if conflict_globs:
+            glob.update(conflict_globs)
+
+        if not quiet:
+            # Check best timing is greater than zero to avoid a
+            # ZeroDivisionError.
+            # In cases where the slowest timing is lesser than a microsecond
+            # we assume that it does not really matter if the fastest
+            # timing is 4 times faster than the slowest timing or not.
+            if worst > 4 * best and best > 0 and worst > 1e-6:
+                print("The slowest run took %0.2f times longer than the "
+                      "fastest. This could mean that an intermediate result "
+                      "is being cached." % (worst / best))
+
+            print( timeit_result )
+
+            if tc > tc_min:
+                print("Compiler time: %.2f s" % tc)
+
+        if save_result:
+            self.shell.user_ns[opts.v] = timeit_result
+
+        if return_result:
+            return timeit_result
+
+    @no_var_expand
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        "--no-raise-error",
+        action="store_true",
+        dest="no_raise_error",
+        help="If given, don't re-raise exceptions",
+    )
+    @magic_arguments.kwds(
+        epilog="""
+      Any remaining arguments will be treated as code to run.
+    """
+    )
+    @skip_doctest
+    @needs_local_scope
+    @line_cell_magic
+    @output_can_be_silenced
+    def time(self, line="", cell=None, local_ns=None):
+        """Time execution of a Python statement or expression.
+
+        The CPU and wall clock times are printed, and the value of the
+        expression (if any) is returned.  Note that under Win32, system time
+        is always reported as 0, since it can not be measured.
+
+        This function can be used both as a line and cell magic:
+
+        - In line mode you can time a single-line statement (though multiple
+          ones can be chained with using semicolons).
+
+        - In cell mode, you can time the cell body (a directly
+          following statement raises an error).
+
+        This function provides very basic timing functionality. Use the timeit
+        magic for more control over the measurement.
+
+        .. versionchanged:: 7.3
+            User variables are no longer expanded,
+            the magic line is always left unmodified.
+
+        .. versionchanged:: 8.3
+            The time magic now correctly propagates system-exiting exceptions
+            (such as ``KeyboardInterrupt`` invoked when interrupting execution)
+            rather than just printing out the exception traceback.
+            The non-system-exception will still be caught as before.
+
+        Examples
+        --------
+        ::
+
+          In [1]: %time 2**128
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+          Out[1]: 340282366920938463463374607431768211456L
+
+          In [2]: n = 1000000
+
+          In [3]: %time sum(range(n))
+          CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
+          Wall time: 1.37
+          Out[3]: 499999500000L
+
+          In [4]: %time print('hello world')
+          hello world
+          CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+          Wall time: 0.00
+
+        .. note::
+            The time needed by Python to compile the given expression will be
+            reported if it is more than 0.1s.
+
+            In the example below, the actual exponentiation is done by Python
+            at compilation time, so while the expression can take a noticeable
+            amount of time to compute, that time is purely due to the
+            compilation::
+
+                In [5]: %time 3**9999;
+                CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+                Wall time: 0.00 s
+
+                In [6]: %time 3**999999;
+                CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
+                Wall time: 0.00 s
+                Compiler : 0.78 s
+        """
+        args, extra = magic_arguments.parse_argstring(self.time, line, partial=True)
+        line = " ".join(extra)
+
+        if line and cell:
+            raise UsageError("Can't use statement directly after '%%time'!")
+
+        if cell:
+            expr = self.shell.transform_cell(cell)
+        else:
+            expr = self.shell.transform_cell(line)
+
+        # Minimum time above which parse time will be reported
+        tp_min = 0.1
+
+        t0 = clock()
+        expr_ast = self.shell.compile.ast_parse(expr)
+        tp = clock() - t0
+
+        # Apply AST transformations
+        expr_ast = self.shell.transform_ast(expr_ast)
+
+        # Minimum time above which compilation time will be reported
+        tc_min = 0.1
+
+        expr_val = None
+        if len(expr_ast.body) == 1 and isinstance(expr_ast.body[0], ast.Expr):
+            mode = 'eval'
+            source = '<timed eval>'
+            expr_ast = ast.Expression(expr_ast.body[0].value)
+        else:
+            mode = 'exec'
+            source = '<timed exec>'
+            # multi-line %%time case
+            if len(expr_ast.body) > 1 and isinstance(expr_ast.body[-1], ast.Expr):
+                expr_val = expr_ast.body[-1]
+                expr_ast = expr_ast.body[:-1]
+                expr_ast = Module(expr_ast, [])
+                expr_val = ast.Expression(expr_val.value)
+
+        t0 = clock()
+        code = self.shell.compile(expr_ast, source, mode)
+        tc = clock() - t0
+
+        # skew measurement as little as possible
+        glob = self.shell.user_ns
+        wtime = time.time
+        # time execution
+        wall_st = wtime()
+        # Track whether to propagate exceptions or exit
+        exit_on_interrupt = False
+        interrupt_occured = False
+        captured_exception = None
+
+        if mode == "eval":
+            st = clock2()
+            try:
+                out = eval(code, glob, local_ns)
+            except KeyboardInterrupt as e:
+                captured_exception = e
+                interrupt_occured = True
+                exit_on_interrupt = True
+            except Exception as e:
+                captured_exception = e
+                interrupt_occured = True
+                if not args.no_raise_error:
+                    exit_on_interrupt = True
+            end = clock2()
+        else:
+            st = clock2()
+            try:
+                exec(code, glob, local_ns)
+                out = None
+                # multi-line %%time case
+                if expr_val is not None:
+                    code_2 = self.shell.compile(expr_val, source, 'eval')
+                    out = eval(code_2, glob, local_ns)
+            except KeyboardInterrupt as e:
+                captured_exception = e
+                interrupt_occured = True
+                exit_on_interrupt = True
+            except Exception as e:
+                captured_exception = e
+                interrupt_occured = True
+                if not args.no_raise_error:
+                    exit_on_interrupt = True
+            end = clock2()
+        wall_end = wtime()
+        # Compute actual times and report
+        wall_time = wall_end - wall_st
+        cpu_user = end[0] - st[0]
+        cpu_sys = end[1] - st[1]
+        cpu_tot = cpu_user + cpu_sys
+        # On windows cpu_sys is always zero, so only total is displayed
+        if sys.platform != "win32":
+            print(
+                f"CPU times: user {_format_time(cpu_user)}, sys: {_format_time(cpu_sys)}, total: {_format_time(cpu_tot)}"
+            )
+        else:
+            print(f"CPU times: total: {_format_time(cpu_tot)}")
+        print(f"Wall time: {_format_time(wall_time)}")
+        if tc > tc_min:
+            print(f"Compiler : {_format_time(tc)}")
+        if tp > tp_min:
+            print(f"Parser   : {_format_time(tp)}")
+        if interrupt_occured:
+            if exit_on_interrupt and captured_exception:
+                raise captured_exception
+            return
+        return out
+
+    @skip_doctest
+    @line_magic
+    def macro(self, parameter_s=''):
+        """Define a macro for future re-execution. It accepts ranges of history,
+        filenames or string objects.
+
+        Usage::
+
+          %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
+
+        Options:
+
+        -r
+          Use 'raw' input.  By default, the 'processed' history is used,
+          so that magics are loaded in their transformed version to valid
+          Python.  If this option is given, the raw input as typed at the
+          command line is used instead.
+
+        -q
+          Quiet macro definition.  By default, a tag line is printed
+          to indicate the macro has been created, and then the contents of
+          the macro are printed.  If this option is given, then no printout
+          is produced once the macro is created.
+
+        This will define a global variable called `name` which is a string
+        made of joining the slices and lines you specify (n1,n2,... numbers
+        above) from your input history into a single string. This variable
+        acts like an automatic function which re-executes those lines as if
+        you had typed them. You just type 'name' at the prompt and the code
+        executes.
+
+        The syntax for indicating input ranges is described in %history.
+
+        Note: as a 'hidden' feature, you can also use traditional python slice
+        notation, where N:M means numbers N through M-1.
+
+        For example, if your history contains (print using %hist -n )::
+
+          44: x=1
+          45: y=3
+          46: z=x+y
+          47: print(x)
+          48: a=5
+          49: print('x',x,'y',y)
+
+        you can create a macro with lines 44 through 47 (included) and line 49
+        called my_macro with::
+
+          In [55]: %macro my_macro 44-47 49
+
+        Now, typing `my_macro` (without quotes) will re-execute all this code
+        in one pass.
+
+        You don't need to give the line-numbers in order, and any given line
+        number can appear multiple times. You can assemble macros with any
+        lines from your input history in any order.
+
+        The macro is a simple object which holds its value in an attribute,
+        but IPython's display system checks for macros and executes them as
+        code instead of printing them when you type their name.
+
+        You can view a macro's contents by explicitly printing it with::
+
+          print(macro_name)
+
+        """
+        opts,args = self.parse_options(parameter_s,'rq',mode='list')
+        if not args:   # List existing macros
+            return sorted(k for k,v in self.shell.user_ns.items() if isinstance(v, Macro))
+        if len(args) == 1:
+            raise UsageError(
+                "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
+        name, codefrom = args[0], " ".join(args[1:])
+
+        # print('rng',ranges)  # dbg
+        try:
+            lines = self.shell.find_user_code(codefrom, 'r' in opts)
+        except (ValueError, TypeError) as e:
+            print(e.args[0])
+            return
+        macro = Macro(lines)
+        self.shell.define_macro(name, macro)
+        if "q" not in opts:
+            print(
+                "Macro `%s` created. To execute, type its name (without quotes)." % name
+            )
+            print("=== Macro contents: ===")
+            print(macro, end=" ")
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        "output",
+        type=str,
+        default="",
+        nargs="?",
+        help="""
+
+        The name of the variable in which to store output.
+        This is a ``utils.io.CapturedIO`` object with stdout/err attributes
+        for the text of the captured output.
+
+        CapturedOutput also has a ``show()`` method for displaying the output,
+        and ``__call__`` as well, so you can use that to quickly display the
+        output.
+
+        If unspecified, captured output is discarded.
+        """,
+    )
+    @magic_arguments.argument(
+        "--no-stderr", action="store_true", help="""Don't capture stderr."""
+    )
+    @magic_arguments.argument(
+        "--no-stdout", action="store_true", help="""Don't capture stdout."""
+    )
+    @magic_arguments.argument(
+        "--no-display",
+        action="store_true",
+        help="""Don't capture IPython's rich display."""
+    )
+    @cell_magic
+    def capture(self, line, cell):
+        """run the cell, capturing stdout, stderr, and IPython's rich display() calls."""
+        args = magic_arguments.parse_argstring(self.capture, line)
+        out = not args.no_stdout
+        err = not args.no_stderr
+        disp = not args.no_display
+        with capture_output(out, err, disp) as io:
+            self.shell.run_cell(cell)
+        if DisplayHook.semicolon_at_end_of_expression(cell):
+            if args.output in self.shell.user_ns:
+                del self.shell.user_ns[args.output]
+        elif args.output:
+            self.shell.user_ns[args.output] = io
+
+    @skip_doctest
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument("name", type=str, default="default", nargs="?")
+    @magic_arguments.argument(
+        "--remove", action="store_true", help="remove the current transformer"
+    )
+    @magic_arguments.argument(
+        "--list", action="store_true", help="list existing transformers name"
+    )
+    @magic_arguments.argument(
+        "--list-all",
+        action="store_true",
+        help="list existing transformers name and code template",
+    )
+    @line_cell_magic
+    def code_wrap(self, line, cell=None):
+        """
+        Simple magic to quickly define a code transformer for all IPython's future input.
+
+        ``__code__`` and ``__ret__`` are special variable that represent the code to run
+        and the value of the last expression of ``__code__`` respectively.
+
+        Examples
+        --------
+
+        .. ipython::
+
+            In [1]: %%code_wrap before_after
+               ...: print('before')
+               ...: __code__
+               ...: print('after')
+               ...: __ret__
+
+
+            In [2]: 1
+            before
+            after
+            Out[2]: 1
+
+            In [3]: %code_wrap --list
+            before_after
+
+            In [4]: %code_wrap --list-all
+            before_after :
+                print('before')
+                __code__
+                print('after')
+                __ret__
+
+            In [5]: %code_wrap --remove before_after
+
+        """
+        args = magic_arguments.parse_argstring(self.code_wrap, line)
+
+        if args.list:
+            for name in self._transformers.keys():
+                print(name)
+            return
+        if args.list_all:
+            for name, _t in self._transformers.items():
+                print(name, ":")
+                print(indent(ast.unparse(_t.template), "    "))
+            print()
+            return
+
+        to_remove = self._transformers.pop(args.name, None)
+        if to_remove in self.shell.ast_transformers:
+            self.shell.ast_transformers.remove(to_remove)
+        if cell is None or args.remove:
+            return
+
+        _trs = ReplaceCodeTransformer(ast.parse(cell))
+
+        self._transformers[args.name] = _trs
+        self.shell.ast_transformers.append(_trs)
+
+
+def parse_breakpoint(text, current_file):
+    '''Returns (file, line) for file:line and (current_file, line) for line'''
+    colon = text.find(':')
+    if colon == -1:
+        return current_file, int(text)
+    else:
+        return text[:colon], int(text[colon+1:])
+
+
+def _format_time(timespan, precision=3):
+    """Formats the timespan in a human readable form"""
+
+    if timespan >= 60.0:
+        # we have more than a minute, format that in a human readable form
+        # Idea from http://snipplr.com/view/5713/
+        parts = [("d", 60 * 60 * 24), ("h", 60 * 60), ("min", 60), ("s", 1)]
+        time = []
+        leftover = timespan
+        for suffix, length in parts:
+            value = int(leftover / length)
+            if value > 0:
+                leftover = leftover % length
+                time.append("%s%s" % (str(value), suffix))
+            if leftover < 1:
+                break
+        return " ".join(time)
+
+    # Unfortunately characters outside of range(128) can cause problems in
+    # certain terminals.
+    # See bug: https://bugs.launchpad.net/ipython/+bug/348466
+    # Try to prevent crashes by being more secure than it needs to
+    # E.g. eclipse is able to print a µ, but has no sys.stdout.encoding set.
+    units = ["s", "ms", "us", "ns"]  # the safe value
+    if hasattr(sys.stdout, "encoding") and sys.stdout.encoding:
+        try:
+            "μ".encode(sys.stdout.encoding)
+            units = ["s", "ms", "μs", "ns"]
+        except:
+            pass
+    scaling = [1, 1e3, 1e6, 1e9]
+
+    if timespan > 0.0:
+        order = min(-int(math.floor(math.log10(timespan)) // 3), 3)
+    else:
+        order = 3
+    return "%.*g %s" % (precision, timespan * scaling[order], units[order])
diff --git a/IPython/core/magics/extension.py b/IPython/core/magics/extension.py
new file mode 100644
index 00000000000..2bc76b2d552
--- /dev/null
+++ b/IPython/core/magics/extension.py
@@ -0,0 +1,63 @@
+"""Implementation of magic functions for the extension machinery.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+
+# Our own packages
+from IPython.core.error import UsageError
+from IPython.core.magic import Magics, magics_class, line_magic
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class ExtensionMagics(Magics):
+    """Magics to manage the IPython extensions system."""
+
+    @line_magic
+    def load_ext(self, module_str):
+        """Load an IPython extension by its module name."""
+        if not module_str:
+            raise UsageError('Missing module name.')
+        res = self.shell.extension_manager.load_extension(module_str)
+        
+        if res == 'already loaded':
+            print("The %s extension is already loaded. To reload it, use:" % module_str)
+            print("  %reload_ext", module_str)
+        elif res == 'no load function':
+            print("The %s module is not an IPython extension." % module_str)
+
+    @line_magic
+    def unload_ext(self, module_str):
+        """Unload an IPython extension by its module name.
+
+        Not all extensions can be unloaded, only those which define an
+        ``unload_ipython_extension`` function.
+        """
+        if not module_str:
+            raise UsageError('Missing module name.')
+        
+        res = self.shell.extension_manager.unload_extension(module_str)
+        
+        if res == 'no unload function':
+            print("The %s extension doesn't define how to unload it." % module_str)
+        elif res == "not loaded":
+            print("The %s extension is not loaded." % module_str)
+
+    @line_magic
+    def reload_ext(self, module_str):
+        """Reload an IPython extension by its module name."""
+        if not module_str:
+            raise UsageError('Missing module name.')
+        self.shell.extension_manager.reload_extension(module_str)
diff --git a/IPython/core/magics/history.py b/IPython/core/magics/history.py
new file mode 100644
index 00000000000..54b19ce3696
--- /dev/null
+++ b/IPython/core/magics/history.py
@@ -0,0 +1,361 @@
+"""Implementation of magic functions related to History.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012, IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import os
+import sys
+from io import open as io_open
+import fnmatch
+
+# Our own packages
+from IPython.core.error import StdinNotImplementedError
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.core.magic_arguments import (argument, magic_arguments,
+                                          parse_argstring)
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils import io
+
+#-----------------------------------------------------------------------------
+# Magics class implementation
+#-----------------------------------------------------------------------------
+
+
+_unspecified = object()
+
+
+@magics_class
+class HistoryMagics(Magics):
+
+    @magic_arguments()
+    @argument(
+        '-n', dest='print_nums', action='store_true', default=False,
+        help="""
+        print line numbers for each input.
+        This feature is only available if numbered prompts are in use.
+        """)
+    @argument(
+        '-o', dest='get_output', action='store_true', default=False,
+        help="also print outputs for each input.")
+    @argument(
+        '-p', dest='pyprompts', action='store_true', default=False,
+        help="""
+        print classic '>>>' python prompts before each input.
+        This is useful for making documentation, and in conjunction
+        with -o, for producing doctest-ready output.
+        """)
+    @argument(
+        '-t', dest='raw', action='store_false', default=True,
+        help="""
+        print the 'translated' history, as IPython understands it.
+        IPython filters your input and converts it all into valid Python
+        source before executing it (things like magics or aliases are turned
+        into function calls, for example). With this option, you'll see the
+        native history instead of the user-entered version: '%%cd /' will be
+        seen as 'get_ipython().run_line_magic("cd", "/")' instead of '%%cd /'.
+        """)
+    @argument(
+        '-f', dest='filename',
+        help="""
+        FILENAME: instead of printing the output to the screen, redirect
+        it to the given file.  The file is always overwritten, though *when
+        it can*, IPython asks for confirmation first. In particular, running
+        the command 'history -f FILENAME' from the IPython Notebook
+        interface will replace FILENAME even if it already exists *without*
+        confirmation.
+        """,
+    )
+    @argument(
+        "-y",
+        dest="overwrite",
+        help="yes, overwrite filename even if exists",
+        action="store_true",
+        default=None,
+    )
+    @argument(
+        "-g",
+        dest="pattern",
+        nargs="*",
+        default=None,
+        help="""
+        treat the arg as a glob pattern to search for in (full) history.
+        This includes the saved history (almost all commands ever written).
+        The pattern may contain '?' to match one unknown character and '*'
+        to match any number of unknown characters. Use '%%hist -g' to show
+        full saved history (may be very long).
+        """)
+    @argument(
+        '-l', dest='limit', type=int, nargs='?', default=_unspecified,
+        help="""
+        get the last n lines from all sessions. Specify n as a single
+        arg, or the default is the last 10 lines.
+        """)
+    @argument(
+        '-u', dest='unique', action='store_true',
+        help="""
+        when searching history using `-g`, show only unique history.
+        """)
+    @argument('range', nargs='*')
+    @skip_doctest
+    @line_magic
+    def history(self, parameter_s = ''):
+        """Print input history (_i<n> variables), with most recent last.
+
+        By default, input history is printed without line numbers so it can be
+        directly pasted into an editor. Use -n to show them.
+
+        By default, all input history from the current session is displayed.
+        Ranges of history can be indicated using the syntax:
+
+        ``4``
+            Line 4, current session
+        ``4-6``
+            Lines 4-6, current session
+        ``4-``
+            Lines 4 onward (to end), current session
+        ``243/1-5``
+            Lines 1-5, session 243
+        ``~2/``
+            All lines of session 2 before current
+        ``~4/4-``
+            Lines 4 onward (to end), session 4 before current
+        ``~2/7``
+            Line 7, session 2 before current
+        ``~8/1-~6/5``
+            From the first line of 8 sessions ago, to the fifth line of 6
+            sessions ago.
+
+        Multiple ranges can be entered, separated by spaces
+
+        The same syntax is used by %macro, %save, %edit, %rerun
+
+        Examples
+        --------
+        ::
+
+          In [6]: %history -n 4-6
+          4:a = 12
+          5:print(a**2)
+          6:%history -n 4-6
+
+        """
+
+        args = parse_argstring(self.history, parameter_s)
+
+        # For brevity
+        history_manager = self.shell.history_manager
+
+        def _format_lineno(session, line):
+            """Helper function to format line numbers properly."""
+            if session in (0, history_manager.session_number):
+                return str(line)
+            return "%s/%s" % (session, line)
+
+        # Check if output to specific file was requested.
+        outfname = args.filename
+        if not outfname:
+            outfile = sys.stdout  # default
+            # We don't want to close stdout at the end!
+            close_at_end = False
+        else:
+            outfname = os.path.expanduser(outfname)
+            if args.overwrite is True:
+                ans = True
+            elif os.path.exists(outfname):
+                ans = True
+                if sys.stdin.isatty():
+                    ans = io.ask_yes_no("File %r exists. Overwrite?" % outfname)
+                else:
+                    try:
+                        ans = io.ask_yes_no("File %r exists. Overwrite?" % outfname)
+                    except StdinNotImplementedError:
+                        ans = True
+                if not ans:
+                    print("Aborting.")
+                    return
+                print("Overwriting file.")
+            outfile = io_open(outfname, 'w', encoding='utf-8')
+            close_at_end = True
+
+        print_nums = args.print_nums
+        get_output = args.get_output
+        pyprompts = args.pyprompts
+        raw = args.raw
+
+        pattern = None
+        limit = None if args.limit is _unspecified else args.limit
+
+        range_pattern = False
+        if args.pattern is not None and not args.range:
+            if args.pattern:
+                pattern = "*" + " ".join(args.pattern) + "*"
+            else:
+                pattern = "*"
+            hist = history_manager.search(pattern, raw=raw, output=get_output,
+                                          n=limit, unique=args.unique)
+            print_nums = True
+        elif args.limit is not _unspecified:
+            n = 10 if limit is None else limit
+            hist = history_manager.get_tail(n, raw=raw, output=get_output)
+        else:
+            if args.pattern:
+                range_pattern = "*" + " ".join(args.pattern) + "*"
+                print_nums = True
+            hist = history_manager.get_range_by_str(
+                " ".join(args.range), raw, get_output
+            )
+
+        # We could be displaying the entire history, so let's not try to pull
+        # it into a list in memory. Anything that needs more space will just
+        # misalign.
+        width = 4
+
+        for session, lineno, inline in hist:
+            # Print user history with tabs expanded to 4 spaces.  The GUI
+            # clients use hard tabs for easier usability in auto-indented code,
+            # but we want to produce PEP-8 compliant history for safe pasting
+            # into an editor.
+            if get_output:
+                inline, output = inline
+            if range_pattern:
+                if not fnmatch.fnmatch(inline, range_pattern):
+                    continue
+            inline = inline.expandtabs(4).rstrip()
+
+            multiline = "\n" in inline
+            line_sep = '\n' if multiline else ' '
+            if print_nums:
+                print(u'%s:%s' % (_format_lineno(session, lineno).rjust(width),
+                        line_sep),  file=outfile, end=u'')
+            if pyprompts:
+                print(u">>> ", end=u"", file=outfile)
+                if multiline:
+                    inline = "\n... ".join(inline.splitlines()) + "\n..."
+            print(inline, file=outfile)
+            if get_output and output:
+                print(output, file=outfile)
+
+        if close_at_end:
+            outfile.close()
+
+    @line_magic
+    def recall(self, arg):
+        r"""Repeat a command, or get command to input line for editing.
+
+        %recall and %rep are equivalent.
+
+        - %recall (no arguments):
+
+        Place a string version of last computation result (stored in the
+        special '_' variable) to the next input prompt. Allows you to create
+        elaborate command lines without using copy-paste::
+
+             In[1]: l = ["hei", "vaan"]
+             In[2]: "".join(l)
+            Out[2]: heivaan
+             In[3]: %recall
+             In[4]: heivaan_ <== cursor blinking
+
+        %recall 45
+
+        Place history line 45 on the next input prompt. Use %hist to find
+        out the number.
+
+        %recall 1-4
+
+        Combine the specified lines into one cell, and place it on the next
+        input prompt. See %history for the slice syntax.
+
+        %recall foo+bar
+
+        If foo+bar can be evaluated in the user namespace, the result is
+        placed at the next input prompt. Otherwise, the history is searched
+        for lines which contain that substring, and the most recent one is
+        placed at the next input prompt.
+        """
+        if not arg:                 # Last output
+            self.shell.set_next_input(str(self.shell.user_ns["_"]))
+            return
+                                    # Get history range
+        histlines = self.shell.history_manager.get_range_by_str(arg)
+        cmd = "\n".join(x[2] for x in histlines)
+        if cmd:
+            self.shell.set_next_input(cmd.rstrip())
+            return
+
+        try:                        # Variable in user namespace
+            cmd = str(eval(arg, self.shell.user_ns))
+        except Exception:           # Search for term in history
+            histlines = self.shell.history_manager.search("*"+arg+"*")
+            for h in reversed([x[2] for x in histlines]):
+                if 'recall' in h or 'rep' in h:
+                    continue
+                self.shell.set_next_input(h.rstrip())
+                return
+        else:
+            self.shell.set_next_input(cmd.rstrip())
+            return
+        print("Couldn't evaluate or find in history:", arg)
+
+    @line_magic
+    def rerun(self, parameter_s=''):
+        """Re-run previous input
+
+        By default, you can specify ranges of input history to be repeated
+        (as with %history). With no arguments, it will repeat the last line.
+
+        Options:
+
+          -l <n> : Repeat the last n lines of input, not including the
+          current command.
+
+          -g foo : Repeat the most recent line which contains foo
+        """
+        opts, args = self.parse_options(parameter_s, 'l:g:', mode='string')
+        if "l" in opts:         # Last n lines
+            try:
+                n = int(opts["l"])
+            except ValueError:
+                print("Number of lines must be an integer")
+                return
+
+            if n == 0:
+                print("Requested 0 last lines - nothing to run")
+                return
+            elif n < 0:
+                print("Number of lines to rerun cannot be negative")
+                return
+
+            hist = self.shell.history_manager.get_tail(n)
+        elif "g" in opts:       # Search
+            p = "*"+opts['g']+"*"
+            hist = list(self.shell.history_manager.search(p))
+            for l in reversed(hist):
+                if "rerun" not in l[2]:
+                    hist = [l]     # The last match which isn't a %rerun
+                    break
+            else:
+                hist = []          # No matches except %rerun
+        elif args:              # Specify history ranges
+            hist = self.shell.history_manager.get_range_by_str(args)
+        else:                   # Last line
+            hist = self.shell.history_manager.get_tail(1)
+        hist = [x[2] for x in hist]
+        if not hist:
+            print("No lines in history match specification")
+            return
+        histlines = "\n".join(hist)
+        print("=== Executing: ===")
+        print(histlines)
+        print("=== Output: ===")
+        self.shell.run_cell("\n".join(hist), store_history=False)
diff --git a/IPython/core/magics/logging.py b/IPython/core/magics/logging.py
new file mode 100644
index 00000000000..81b167545c4
--- /dev/null
+++ b/IPython/core/magics/logging.py
@@ -0,0 +1,195 @@
+"""Implementation of magic functions for IPython's own logging.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import os
+import sys
+
+# Our own packages
+from IPython.core.magic import Magics, magics_class, line_magic
+from warnings import warn
+from traitlets import Bool
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class LoggingMagics(Magics):
+    """Magics related to all logging machinery."""
+
+    quiet = Bool(False, help=
+        """
+        Suppress output of log state when logging is enabled
+        """
+    ).tag(config=True)
+
+    @line_magic
+    def logstart(self, parameter_s=''):
+        """Start logging anywhere in a session.
+
+        %logstart [-o|-r|-t|-q] [log_name [log_mode]]
+
+        If no name is given, it defaults to a file named 'ipython_log.py' in your
+        current directory, in 'rotate' mode (see below).
+
+        '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
+        history up to that point and then continues logging.
+
+        %logstart takes a second optional parameter: logging mode. This can be one
+        of (note that the modes are given unquoted):
+
+        append
+            Keep logging at the end of any existing file.
+
+        backup
+            Rename any existing file to name~ and start name.
+
+        global
+            Append to  a single logfile in your home directory.
+
+        over
+            Overwrite any existing log.
+
+        rotate
+            Create rotating logs: name.1~, name.2~, etc.
+
+        Options:
+
+          -o
+            log also IPython's output. In this mode, all commands which
+            generate an Out[NN] prompt are recorded to the logfile, right after
+            their corresponding input line. The output lines are always
+            prepended with a '#[Out]# ' marker, so that the log remains valid
+            Python code.
+
+          Since this marker is always the same, filtering only the output from
+          a log is very easy, using for example a simple awk call::
+
+            awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
+
+          -r
+            log 'raw' input.  Normally, IPython's logs contain the processed
+            input, so that user lines are logged in their final form, converted
+            into valid Python.  For example, %Exit is logged as
+            _ip.run_line_magic("Exit").  If the -r flag is given, all input is logged
+            exactly as typed, with no transformations applied.
+
+          -t
+            put timestamps before each input line logged (these are put in
+            comments).
+
+          -q
+            suppress output of logstate message when logging is invoked
+        """
+
+        opts,par = self.parse_options(parameter_s,'ortq')
+        log_output = 'o' in opts
+        log_raw_input = 'r' in opts
+        timestamp = 't' in opts
+        quiet = 'q' in opts
+
+        logger = self.shell.logger
+
+        # if no args are given, the defaults set in the logger constructor by
+        # ipython remain valid
+        if par:
+            try:
+                logfname,logmode = par.split()
+            except:
+                logfname = par
+                logmode = 'backup'
+        else:
+            logfname = logger.logfname
+            logmode = logger.logmode
+        # put logfname into rc struct as if it had been called on the command
+        # line, so it ends up saved in the log header Save it in case we need
+        # to restore it...
+        old_logfile = self.shell.logfile
+        if logfname:
+            logfname = os.path.expanduser(logfname)
+        self.shell.logfile = logfname
+
+        loghead = u'# IPython log file\n\n'
+        try:
+            logger.logstart(logfname, loghead, logmode, log_output, timestamp,
+                            log_raw_input)
+        except:
+            self.shell.logfile = old_logfile
+            warn("Couldn't start log: %s" % sys.exc_info()[1])
+        else:
+            # log input history up to this point, optionally interleaving
+            # output if requested
+
+            if timestamp:
+                # disable timestamping for the previous history, since we've
+                # lost those already (no time machine here).
+                logger.timestamp = False
+
+            if log_raw_input:
+                input_hist = self.shell.history_manager.input_hist_raw
+            else:
+                input_hist = self.shell.history_manager.input_hist_parsed
+
+            if log_output:
+                log_write = logger.log_write
+                output_hist = self.shell.history_manager.output_hist
+                for n in range(1,len(input_hist)-1):
+                    log_write(input_hist[n].rstrip() + u'\n')
+                    if n in output_hist:
+                        log_write(repr(output_hist[n]),'output')
+            else:
+                logger.log_write(u'\n'.join(input_hist[1:]))
+                logger.log_write(u'\n')
+            if timestamp:
+                # re-enable timestamping
+                logger.timestamp = True
+
+            if not (self.quiet or quiet):
+                print ('Activating auto-logging. '
+                       'Current session state plus future input saved.')
+                logger.logstate()
+
+    @line_magic
+    def logstop(self, parameter_s=''):
+        """Fully stop logging and close log file.
+
+        In order to start logging again, a new %logstart call needs to be made,
+        possibly (though not necessarily) with a new filename, mode and other
+        options."""
+        self.shell.logger.logstop()
+
+    @line_magic
+    def logoff(self, parameter_s=''):
+        """Temporarily stop logging.
+
+        You must have previously started logging."""
+        self.shell.logger.switch_log(0)
+
+    @line_magic
+    def logon(self, parameter_s=''):
+        """Restart logging.
+
+        This function is for restarting logging which you've temporarily
+        stopped with %logoff. For starting logging for the first time, you
+        must use the %logstart function, which allows you to specify an
+        optional log filename."""
+
+        self.shell.logger.switch_log(1)
+
+    @line_magic
+    def logstate(self, parameter_s=''):
+        """Print the status of the logging system."""
+
+        self.shell.logger.logstate()
diff --git a/IPython/core/magics/namespace.py b/IPython/core/magics/namespace.py
new file mode 100644
index 00000000000..82cc181fec0
--- /dev/null
+++ b/IPython/core/magics/namespace.py
@@ -0,0 +1,723 @@
+"""Implementation of namespace-related magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import gc
+import re
+import sys
+
+# Our own packages
+from IPython.core import page
+from IPython.core.error import StdinNotImplementedError, UsageError
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.encoding import DEFAULT_ENCODING
+from IPython.utils.openpy import read_py_file
+from IPython.utils.path import get_py_filename
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+@magics_class
+class NamespaceMagics(Magics):
+    """Magics to manage various aspects of the user's namespace.
+
+    These include listing variables, introspecting into them, etc.
+    """
+
+    @line_magic
+    def pinfo(self, parameter_s='', namespaces=None):
+        """Provide detailed information about an object.
+
+        '%pinfo object' is just a synonym for object? or ?object."""
+
+        # print('pinfo par: <%s>' % parameter_s)  # dbg
+        # detail_level: 0 -> obj? , 1 -> obj??
+        detail_level = 0
+        # We need to detect if we got called as 'pinfo pinfo foo', which can
+        # happen if the user types 'pinfo foo?' at the cmd line.
+        pinfo,qmark1,oname,qmark2 = \
+               re.match(r'(pinfo )?(\?*)(.*?)(\??$)',parameter_s).groups()
+        if pinfo or qmark1 or qmark2:
+            detail_level = 1
+        if "*" in oname:
+            self.psearch(oname)
+        else:
+            self.shell._inspect('pinfo', oname, detail_level=detail_level,
+                                namespaces=namespaces)
+
+    @line_magic
+    def pinfo2(self, parameter_s='', namespaces=None):
+        """Provide extra detailed information about an object.
+
+        '%pinfo2 object' is just a synonym for object?? or ??object."""
+        self.shell._inspect('pinfo', parameter_s, detail_level=1,
+                            namespaces=namespaces)
+
+    @skip_doctest
+    @line_magic
+    def pdef(self, parameter_s='', namespaces=None):
+        """Print the call signature for any callable object.
+
+        If the object is a class, print the constructor information.
+
+        Examples
+        --------
+        ::
+
+          In [3]: %pdef urllib.urlopen
+          urllib.urlopen(url, data=None, proxies=None)
+        """
+        self.shell._inspect('pdef',parameter_s, namespaces)
+
+    @line_magic
+    def pdoc(self, parameter_s='', namespaces=None):
+        """Print the docstring for an object.
+
+        If the given object is a class, it will print both the class and the
+        constructor docstrings."""
+        self.shell._inspect('pdoc',parameter_s, namespaces)
+
+    @line_magic
+    def psource(self, parameter_s='', namespaces=None):
+        """Print (or run through pager) the source code for an object."""
+        if not parameter_s:
+            raise UsageError('Missing object name.')
+        self.shell._inspect('psource',parameter_s, namespaces)
+
+    @line_magic
+    def pfile(self, parameter_s='', namespaces=None):
+        """Print (or run through pager) the file where an object is defined.
+
+        The file opens at the line where the object definition begins. IPython
+        will honor the environment variable PAGER if set, and otherwise will
+        do its best to print the file in a convenient form.
+
+        If the given argument is not an object currently defined, IPython will
+        try to interpret it as a filename (automatically adding a .py extension
+        if needed). You can thus use %pfile as a syntax highlighting code
+        viewer."""
+
+        # first interpret argument as an object name
+        out = self.shell._inspect('pfile',parameter_s, namespaces)
+        # if not, try the input as a filename
+        if out == 'not found':
+            try:
+                filename = get_py_filename(parameter_s)
+            except IOError as msg:
+                print(msg)
+                return
+            page.page(self.shell.pycolorize(read_py_file(filename, skip_encoding_cookie=False)))
+
+    @line_magic
+    def psearch(self, parameter_s=''):
+        """Search for object in namespaces by wildcard.
+
+        %psearch [options] PATTERN [OBJECT TYPE]
+
+        Note: ? can be used as a synonym for %psearch, at the beginning or at
+        the end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, the
+        rest of the command line must be unchanged (options come first), so
+        for example the following forms are equivalent
+
+        %psearch -i a* function
+        -i a* function?
+        ?-i a* function
+
+        Arguments:
+
+          PATTERN
+
+          where PATTERN is a string containing * as a wildcard similar to its
+          use in a shell.  The pattern is matched in all namespaces on the
+          search path. By default objects starting with a single _ are not
+          matched, many IPython generated objects have a single
+          underscore. The default is case insensitive matching. Matching is
+          also done on the attributes of objects and not only on the objects
+          in a module.
+
+          [OBJECT TYPE]
+
+          Is the name of a python type from the types module. The name is
+          given in lowercase without the ending type, ex. StringType is
+          written string. By adding a type here only objects matching the
+          given type are matched. Using all here makes the pattern match all
+          types (this is the default).
+
+        Options:
+
+          -a: makes the pattern match even objects whose names start with a
+          single underscore.  These names are normally omitted from the
+          search.
+
+          -i/-c: make the pattern case insensitive/sensitive.  If neither of
+          these options are given, the default is read from your configuration
+          file, with the option ``InteractiveShell.wildcards_case_sensitive``.
+          If this option is not specified in your configuration file, IPython's
+          internal default is to do a case sensitive search.
+
+          -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
+          specify can be searched in any of the following namespaces:
+          'builtin', 'user', 'user_global','internal', 'alias', where
+          'builtin' and 'user' are the search defaults.  Note that you should
+          not use quotes when specifying namespaces.
+
+          -l: List all available object types for object matching. This function
+          can be used without arguments.
+
+          'Builtin' contains the python module builtin, 'user' contains all
+          user data, 'alias' only contain the shell aliases and no python
+          objects, 'internal' contains objects used by IPython.  The
+          'user_global' namespace is only used by embedded IPython instances,
+          and it contains module-level globals.  You can add namespaces to the
+          search with -s or exclude them with -e (these options can be given
+          more than once).
+
+        Examples
+        --------
+        ::
+
+          %psearch a*            -> objects beginning with an a
+          %psearch -e builtin a* -> objects NOT in the builtin space starting in a
+          %psearch a* function   -> all functions beginning with an a
+          %psearch re.e*         -> objects beginning with an e in module re
+          %psearch r*.e*         -> objects that start with e in modules starting in r
+          %psearch r*.* string   -> all strings in modules beginning with r
+
+        Case sensitive search::
+
+          %psearch -c a*         list all object beginning with lower case a
+
+        Show objects beginning with a single _::
+
+          %psearch -a _*         list objects beginning with a single underscore
+
+        List available objects::
+
+          %psearch -l            list all available object types
+        """
+        # default namespaces to be searched
+        def_search = ['user_local', 'user_global', 'builtin']
+
+        # Process options/args
+        opts,args = self.parse_options(parameter_s,'cias:e:l',list_all=True)
+        opt = opts.get
+        shell = self.shell
+        psearch = shell.inspector.psearch
+        
+        # select list object types
+        list_types = False
+        if 'l' in opts:
+            list_types = True
+
+        # select case options
+        if 'i' in opts:
+            ignore_case = True
+        elif 'c' in opts:
+            ignore_case = False
+        else:
+            ignore_case = not shell.wildcards_case_sensitive
+
+        # Build list of namespaces to search from user options
+        def_search.extend(opt('s',[]))
+        ns_exclude = ns_exclude=opt('e',[])
+        ns_search = [nm for nm in def_search if nm not in ns_exclude]
+
+        # Call the actual search
+        try:
+            psearch(args,shell.ns_table,ns_search,
+                    show_all=opt('a'),ignore_case=ignore_case, list_types=list_types)
+        except:
+            shell.showtraceback()
+
+    @skip_doctest
+    @line_magic
+    def who_ls(self, parameter_s=''):
+        """Return a sorted list of all interactive variables.
+
+        If arguments are given, only variables of types matching these
+        arguments are returned.
+
+        Examples
+        --------
+        Define two variables and list them with who_ls::
+
+          In [1]: alpha = 123
+
+          In [2]: beta = 'test'
+
+          In [3]: %who_ls
+          Out[3]: ['alpha', 'beta']
+
+          In [4]: %who_ls int
+          Out[4]: ['alpha']
+
+          In [5]: %who_ls str
+          Out[5]: ['beta']
+        """
+
+        user_ns = self.shell.user_ns
+        user_ns_hidden = self.shell.user_ns_hidden
+        nonmatching = object()  # This can never be in user_ns
+        out = [ i for i in user_ns
+                if not i.startswith('_') \
+                and (user_ns[i] is not user_ns_hidden.get(i, nonmatching)) ]
+
+        typelist = parameter_s.split()
+        if typelist:
+            typeset = set(typelist)
+            out = [i for i in out if type(user_ns[i]).__name__ in typeset]
+
+        out.sort()
+        return out
+
+    @skip_doctest
+    @line_magic
+    def who(self, parameter_s=''):
+        """Print all interactive variables, with some minimal formatting.
+
+        If any arguments are given, only variables whose type matches one of
+        these are printed.  For example::
+
+          %who function str
+
+        will only list functions and strings, excluding all other types of
+        variables.  To find the proper type names, simply use type(var) at a
+        command line to see how python prints type names.  For example:
+
+        ::
+
+          In [1]: type('hello')\\
+          Out[1]: <type 'str'>
+
+        indicates that the type name for strings is 'str'.
+
+        ``%who`` always excludes executed names loaded through your configuration
+        file and things which are internal to IPython.
+
+        This is deliberate, as typically you may load many modules and the
+        purpose of %who is to show you only what you've manually defined.
+
+        Examples
+        --------
+
+        Define two variables and list them with who::
+
+          In [1]: alpha = 123
+
+          In [2]: beta = 'test'
+
+          In [3]: %who
+          alpha   beta
+
+          In [4]: %who int
+          alpha
+
+          In [5]: %who str
+          beta
+        """
+
+        varlist = self.who_ls(parameter_s)
+        if not varlist:
+            if parameter_s:
+                print('No variables match your requested type.')
+            else:
+                print('Interactive namespace is empty.')
+            return
+
+        # if we have variables, move on...
+        count = 0
+        for i in varlist:
+            print(i+'\t', end=' ')
+            count += 1
+            if count > 8:
+                count = 0
+                print()
+        print()
+
+    @skip_doctest
+    @line_magic
+    def whos(self, parameter_s=''):
+        """Like %who, but gives some extra information about each variable.
+
+        The same type filtering of %who can be applied here.
+
+        For all variables, the type is printed. Additionally it prints:
+
+          - For {},[],(): their length.
+
+          - For numpy arrays, a summary with shape, number of
+            elements, typecode and size in memory.
+
+          - For DataFrame and Series types: their shape.
+
+          - Everything else: a string representation, snipping their middle if
+            too long.
+
+        Examples
+        --------
+        Define two variables and list them with whos::
+
+          In [1]: alpha = 123
+
+          In [2]: beta = 'test'
+
+          In [3]: df = pd.DataFrame({"a": range(10), "b": range(10,20)})
+
+          In [4]: s = df["a"]
+
+          In [5]: %whos
+          Variable   Type        Data/Info
+          --------------------------------
+          alpha      int         123
+          beta       str         test
+          df         DataFrame   Shape: (10, 2)
+          s          Series      Shape: (10, )
+        """
+
+        varnames = self.who_ls(parameter_s)
+        if not varnames:
+            if parameter_s:
+                print('No variables match your requested type.')
+            else:
+                print('Interactive namespace is empty.')
+            return
+
+        # if we have variables, move on...
+
+        # for these types, show len() instead of data:
+        seq_types = ['dict', 'list', 'tuple']
+
+        # for numpy arrays, display summary info
+        ndarray_type = None
+        if 'numpy' in sys.modules:
+            try:
+                from numpy import ndarray
+            except ImportError:
+                pass
+            else:
+                ndarray_type = ndarray.__name__
+
+        # Find all variable names and types so we can figure out column sizes
+
+        # some types are well known and can be shorter
+        abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
+        def type_name(v):
+            tn = type(v).__name__
+            return abbrevs.get(tn,tn)
+
+        varlist = [self.shell.user_ns[n] for n in varnames]
+
+        typelist = []
+        for vv in varlist:
+            tt = type_name(vv)
+
+            if tt=='instance':
+                typelist.append( abbrevs.get(str(vv.__class__),
+                                             str(vv.__class__)))
+            else:
+                typelist.append(tt)
+
+        # column labels and # of spaces as separator
+        varlabel = 'Variable'
+        typelabel = 'Type'
+        datalabel = 'Data/Info'
+        colsep = 3
+        # variable format strings
+        vformat    = "{0:<{varwidth}}{1:<{typewidth}}"
+        aformat    = "%s: %s elems, type `%s`, %s bytes"
+        # find the size of the columns to format the output nicely
+        varwidth = max(max(map(len,varnames)), len(varlabel)) + colsep
+        typewidth = max(max(map(len,typelist)), len(typelabel)) + colsep
+        # table header
+        print(varlabel.ljust(varwidth) + typelabel.ljust(typewidth) + \
+              ' '+datalabel+'\n' + '-'*(varwidth+typewidth+len(datalabel)+1))
+        # and the table itself
+        kb = 1024
+        Mb = 1048576  # kb**2
+        for vname,var,vtype in zip(varnames,varlist,typelist):
+            print(vformat.format(vname, vtype, varwidth=varwidth, typewidth=typewidth), end=' ')
+            if vtype in seq_types:
+                print("n="+str(len(var)))
+            elif vtype == ndarray_type:
+                vshape = str(var.shape).replace(',','').replace(' ','x')[1:-1]
+                if vtype==ndarray_type:
+                    # numpy
+                    vsize  = var.size
+                    vbytes = vsize*var.itemsize
+                    vdtype = var.dtype
+
+                if vbytes < 100000:
+                    print(aformat % (vshape, vsize, vdtype, vbytes))
+                else:
+                    print(aformat % (vshape, vsize, vdtype, vbytes), end=' ')
+                    if vbytes < Mb:
+                        print("(%s kb)" % (vbytes / kb,))
+                    else:
+                        print("(%s Mb)" % (vbytes / Mb,))
+            elif vtype in ["DataFrame", "Series"]:
+                # Useful for DataFrames and Series
+                # Ought to work for both pandas and polars
+                print(f"Shape: {var.shape}")
+            else:
+                try:
+                    vstr = str(var)
+                except UnicodeEncodeError:
+                    vstr = var.encode(DEFAULT_ENCODING,
+                                      'backslashreplace')
+                except:
+                    vstr = "<object with id %d (str() failed)>" % id(var)
+                vstr = vstr.replace('\n', '\\n')
+                if len(vstr) < 50:
+                    print(vstr)
+                else:
+                    print(vstr[:25] + "<...>" + vstr[-25:])
+
+    @line_magic
+    def reset(self, parameter_s=''):
+        """Resets the namespace by removing all names defined by the user, if
+        called without arguments, or by removing some types of objects, such
+        as everything currently in IPython's In[] and Out[] containers (see
+        the parameters for details).
+
+        Parameters
+        ----------
+        -f
+            force reset without asking for confirmation.
+        -s
+            'Soft' reset: Only clears your namespace, leaving history intact.
+            References to objects may be kept. By default (without this option),
+            we do a 'hard' reset, giving you a new session and removing all
+            references to objects from the current session.
+        --aggressive
+            Try to aggressively remove modules from sys.modules ; this
+            may allow you to reimport Python modules that have been updated and
+            pick up changes, but can have unintended consequences.
+
+        in
+            reset input history
+        out
+            reset output history
+        dhist
+            reset directory history
+        array
+            reset only variables that are NumPy arrays
+
+        See Also
+        --------
+        reset_selective : invoked as ``%reset_selective``
+
+        Examples
+        --------
+        ::
+
+          In [6]: a = 1
+
+          In [7]: a
+          Out[7]: 1
+
+          In [8]: 'a' in get_ipython().user_ns
+          Out[8]: True
+
+          In [9]: %reset -f
+
+          In [1]: 'a' in get_ipython().user_ns
+          Out[1]: False
+
+          In [2]: %reset -f in
+          Flushing input history
+
+          In [3]: %reset -f dhist in
+          Flushing directory history
+          Flushing input history
+
+        Notes
+        -----
+        Calling this magic from clients that do not implement standard input,
+        such as the ipython notebook interface, will reset the namespace
+        without confirmation.
+        """
+        opts, args = self.parse_options(parameter_s, "sf", "aggressive", mode="list")
+        if "f" in opts:
+            ans = True
+        else:
+            try:
+                ans = self.shell.ask_yes_no(
+                "Once deleted, variables cannot be recovered. Proceed (y/[n])?",
+                default='n')
+            except StdinNotImplementedError:
+                ans = True
+        if not ans:
+            print('Nothing done.')
+            return
+
+        if 's' in opts:                     # Soft reset
+            user_ns = self.shell.user_ns
+            for i in self.who_ls():
+                del(user_ns[i])
+        elif len(args) == 0:                # Hard reset
+            self.shell.reset(new_session=False, aggressive=("aggressive" in opts))
+
+        # reset in/out/dhist/array: previously extensinions/clearcmd.py
+        ip = self.shell
+        user_ns = self.shell.user_ns  # local lookup, heavily used
+
+        for target in args:
+            target = target.lower() # make matches case insensitive
+            if target == 'out':
+                print("Flushing output cache (%d entries)" % len(user_ns['_oh']))
+                self.shell.displayhook.flush()
+
+            elif target == 'in':
+                print("Flushing input history")
+                pc = self.shell.displayhook.prompt_count + 1
+                for n in range(1, pc):
+                    key = '_i'+repr(n)
+                    user_ns.pop(key,None)
+                user_ns.update(dict(_i=u'',_ii=u'',_iii=u''))
+                hm = ip.history_manager
+                # don't delete these, as %save and %macro depending on the
+                # length of these lists to be preserved
+                hm.input_hist_parsed[:] = [''] * pc
+                hm.input_hist_raw[:] = [''] * pc
+                # hm has internal machinery for _i,_ii,_iii, clear it out
+                hm._i = hm._ii = hm._iii = hm._i00 =  u''
+
+            elif target == 'array':
+                # Support cleaning up numpy arrays
+                try:
+                    from numpy import ndarray
+                    # This must be done with items and not iteritems because
+                    # we're going to modify the dict in-place.
+                    for x,val in list(user_ns.items()):
+                        if isinstance(val,ndarray):
+                            del user_ns[x]
+                except ImportError:
+                    print("reset array only works if Numpy is available.")
+
+            elif target == 'dhist':
+                print("Flushing directory history")
+                del user_ns['_dh'][:]
+
+            else:
+                print("Don't know how to reset ", end=' ')
+                print(target + ", please run `%reset?` for details")
+
+        gc.collect()
+
+    @line_magic
+    def reset_selective(self, parameter_s=''):
+        """Resets the namespace by removing names defined by the user.
+
+        Input/Output history are left around in case you need them.
+
+        %reset_selective [-f] regex
+
+        No action is taken if regex is not included
+
+        Options
+          -f : force reset without asking for confirmation.
+
+        See Also
+        --------
+        reset : invoked as ``%reset``
+
+        Examples
+        --------
+        We first fully reset the namespace so your output looks identical to
+        this example for pedagogical reasons; in practice you do not need a
+        full reset::
+
+          In [1]: %reset -f
+
+        Now, with a clean namespace we can make a few variables and use
+        ``%reset_selective`` to only delete names that match our regexp::
+
+          In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8
+
+          In [3]: who_ls
+          Out[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']
+
+          In [4]: %reset_selective -f b[2-3]m
+
+          In [5]: who_ls
+          Out[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+
+          In [6]: %reset_selective -f d
+
+          In [7]: who_ls
+          Out[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']
+
+          In [8]: %reset_selective -f c
+
+          In [9]: who_ls
+          Out[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']
+
+          In [10]: %reset_selective -f b
+
+          In [11]: who_ls
+          Out[11]: ['a']
+
+        Notes
+        -----
+        Calling this magic from clients that do not implement standard input,
+        such as the ipython notebook interface, will reset the namespace
+        without confirmation.
+        """
+
+        opts, regex = self.parse_options(parameter_s,'f')
+
+        if 'f' in opts:
+            ans = True
+        else:
+            try:
+                ans = self.shell.ask_yes_no(
+                "Once deleted, variables cannot be recovered. Proceed (y/[n])? ",
+                default='n')
+            except StdinNotImplementedError:
+                ans = True
+        if not ans:
+            print('Nothing done.')
+            return
+        user_ns = self.shell.user_ns
+        if not regex:
+            print('No regex pattern specified. Nothing done.')
+            return
+        else:
+            try:
+                m = re.compile(regex)
+            except TypeError as e:
+                raise TypeError('regex must be a string or compiled pattern') from e
+            for i in self.who_ls():
+                if m.search(i):
+                    del(user_ns[i])
+
+    @line_magic
+    def xdel(self, parameter_s=''):
+        """Delete a variable, trying to clear it from anywhere that
+        IPython's machinery has references to it. By default, this uses
+        the identity of the named object in the user namespace to remove
+        references held under other names. The object is also removed
+        from the output history.
+
+        Options
+          -n : Delete the specified name from all namespaces, without
+          checking their identity.
+        """
+        opts, varname = self.parse_options(parameter_s,'n')
+        try:
+            self.shell.del_var(varname, ('n' in opts))
+        except (NameError, ValueError) as e:
+            print(type(e).__name__ +": "+ str(e))
diff --git a/IPython/core/magics/osm.py b/IPython/core/magics/osm.py
new file mode 100644
index 00000000000..ac265978daf
--- /dev/null
+++ b/IPython/core/magics/osm.py
@@ -0,0 +1,855 @@
+"""Implementation of magic functions for interaction with the OS.
+
+Note: this module is named 'osm' instead of 'os' to avoid a collision with the
+builtin.
+"""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import io
+import os
+import pathlib
+import re
+import sys
+from pprint import pformat
+
+from IPython.core import magic_arguments
+from IPython.core import oinspect
+from IPython.core import page
+from IPython.core.alias import AliasError, Alias
+from IPython.core.error import UsageError
+from IPython.core.magic import  (
+    Magics, compress_dhist, magics_class, line_magic, cell_magic, line_cell_magic
+)
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.openpy import source_to_unicode
+from IPython.utils.process import abbrev_cwd
+from IPython.utils.terminal import set_term_title
+from traitlets import Bool
+from warnings import warn
+
+
+@magics_class
+class OSMagics(Magics):
+    """Magics to interact with the underlying OS (shell-type functionality).
+    """
+
+    cd_force_quiet = Bool(False,
+        help="Force %cd magic to be quiet even if -q is not passed."
+    ).tag(config=True)
+
+    def __init__(self, shell=None, **kwargs):
+
+        # Now define isexec in a cross platform manner.
+        self.is_posix = False
+        self.execre = None
+        if os.name == 'posix':
+            self.is_posix = True
+        else:
+            try:
+                winext = os.environ['pathext'].replace(';','|').replace('.','')
+            except KeyError:
+                winext = 'exe|com|bat|py'
+            try:
+                self.execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
+            except re.error:
+                warn("Seems like your pathext environmental "
+                     "variable is malformed. Please check it to "
+                     "enable a proper handle of file extensions "
+                     "managed for your system")
+                winext = 'exe|com|bat|py'
+                self.execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
+
+        # call up the chain
+        super().__init__(shell=shell, **kwargs)
+
+
+    def _isexec_POSIX(self, file):
+        """
+        Test for executable on a POSIX system
+        """
+        if os.access(file.path, os.X_OK):
+            # will fail on maxOS if access is not X_OK
+            return file.is_file()
+        return False
+
+
+
+    def _isexec_WIN(self, file):
+        """
+        Test for executable file on non POSIX system
+        """
+        return file.is_file() and self.execre.match(file.name) is not None
+
+    def isexec(self, file):
+        """
+        Test for executable file on non POSIX system
+        """
+        if self.is_posix:
+            return self._isexec_POSIX(file)
+        else:
+            return self._isexec_WIN(file)
+
+
+    @skip_doctest
+    @line_magic
+    def alias(self, parameter_s=''):
+        """Define an alias for a system command.
+
+        '%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
+
+        Then, typing 'alias_name params' will execute the system command 'cmd
+        params' (from your underlying operating system).
+
+        Aliases have lower precedence than magic functions and Python normal
+        variables, so if 'foo' is both a Python variable and an alias, the
+        alias can not be executed until 'del foo' removes the Python variable.
+
+        You can use the %l specifier in an alias definition to represent the
+        whole line when the alias is called.  For example::
+
+          In [2]: alias bracket echo "Input in brackets: <%l>"
+          In [3]: bracket hello world
+          Input in brackets: <hello world>
+
+        You can also define aliases with parameters using %s specifiers (one
+        per parameter)::
+
+          In [1]: alias parts echo first %s second %s
+          In [2]: %parts A B
+          first A second B
+          In [3]: %parts A
+          Incorrect number of arguments: 2 expected.
+          parts is an alias to: 'echo first %s second %s'
+
+        Note that %l and %s are mutually exclusive.  You can only use one or
+        the other in your aliases.
+
+        Aliases expand Python variables just like system calls using ! or !!
+        do: all expressions prefixed with '$' get expanded.  For details of
+        the semantic rules, see PEP-215:
+        https://peps.python.org/pep-0215/.  This is the library used by
+        IPython for variable expansion.  If you want to access a true shell
+        variable, an extra $ is necessary to prevent its expansion by
+        IPython::
+
+          In [6]: alias show echo
+          In [7]: PATH='A Python string'
+          In [8]: show $PATH
+          A Python string
+          In [9]: show $$PATH
+          /usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
+
+        You can use the alias facility to access all of $PATH.  See the %rehashx
+        function, which automatically creates aliases for the contents of your
+        $PATH.
+
+        If called with no parameters, %alias prints the current alias table
+        for your system.  For posix systems, the default aliases are 'cat',
+        'cp', 'mv', 'rm', 'rmdir', and 'mkdir', and other platform-specific
+        aliases are added.  For windows-based systems, the default aliases are
+        'copy', 'ddir', 'echo', 'ls', 'ldir', 'mkdir', 'ren', and 'rmdir'.
+
+        You can see the definition of alias by adding a question mark in the
+        end::
+
+          In [1]: cat?
+          Repr: <alias cat for 'cat'>"""
+
+        par = parameter_s.strip()
+        if not par:
+            aliases = sorted(self.shell.alias_manager.aliases)
+            # stored = self.shell.db.get('stored_aliases', {} )
+            # for k, v in stored:
+            #     atab.append(k, v[0])
+
+            print("Total number of aliases:", len(aliases))
+            sys.stdout.flush()
+            return aliases
+
+        # Now try to define a new one
+        try:
+            alias,cmd = par.split(None, 1)
+        except TypeError:
+            print(oinspect.getdoc(self.alias))
+            return
+        
+        try:
+            self.shell.alias_manager.define_alias(alias, cmd)
+        except AliasError as e:
+            print(e)
+    # end magic_alias
+
+    @line_magic
+    def unalias(self, parameter_s=''):
+        """Remove an alias"""
+
+        aname = parameter_s.strip()
+        try:
+            self.shell.alias_manager.undefine_alias(aname)
+        except ValueError as e:
+            print(e)
+            return
+        
+        stored = self.shell.db.get('stored_aliases', {} )
+        if aname in stored:
+            print("Removing %stored alias",aname)
+            del stored[aname]
+            self.shell.db['stored_aliases'] = stored
+
+    @line_magic
+    def rehashx(self, parameter_s=''):
+        """Update the alias table with all executable files in $PATH.
+
+        rehashx explicitly checks that every entry in $PATH is a file
+        with execute access (os.X_OK).
+
+        Under Windows, it checks executability as a match against a
+        '|'-separated string of extensions, stored in the IPython config
+        variable win_exec_ext.  This defaults to 'exe|com|bat'.
+
+        This function also resets the root module cache of module completer,
+        used on slow filesystems.
+        """
+        from IPython.core.alias import InvalidAliasError
+
+        # for the benefit of module completer in ipy_completers.py
+        del self.shell.db['rootmodules_cache']
+
+        path = [os.path.abspath(os.path.expanduser(p)) for p in
+            os.environ.get('PATH','').split(os.pathsep)]
+
+        syscmdlist = []
+        savedir = os.getcwd()
+
+        # Now walk the paths looking for executables to alias.
+        try:
+            # write the whole loop for posix/Windows so we don't have an if in
+            # the innermost part
+            if self.is_posix:
+                for pdir in path:
+                    try:
+                        os.chdir(pdir)
+                    except OSError:
+                        continue
+
+                    # for python 3.6+ rewrite to: with os.scandir(pdir) as dirlist:
+                    dirlist = os.scandir(path=pdir)
+                    for ff in dirlist:
+                        if self.isexec(ff):
+                            fname = ff.name
+                            try:
+                                # Removes dots from the name since ipython
+                                # will assume names with dots to be python.
+                                if not self.shell.alias_manager.is_alias(fname):
+                                    self.shell.alias_manager.define_alias(
+                                        fname.replace('.',''), fname)
+                            except InvalidAliasError:
+                                pass
+                            else:
+                                syscmdlist.append(fname)
+            else:
+                no_alias = Alias.blacklist
+                for pdir in path:
+                    try:
+                        os.chdir(pdir)
+                    except OSError:
+                        continue
+
+                    # for python 3.6+ rewrite to: with os.scandir(pdir) as dirlist:
+                    dirlist = os.scandir(pdir)
+                    for ff in dirlist:
+                        fname = ff.name
+                        base, ext = os.path.splitext(fname)
+                        if self.isexec(ff) and base.lower() not in no_alias:
+                            if ext.lower() == '.exe':
+                                fname = base
+                                try:
+                                    # Removes dots from the name since ipython
+                                    # will assume names with dots to be python.
+                                    self.shell.alias_manager.define_alias(
+                                        base.lower().replace('.',''), fname)
+                                except InvalidAliasError:
+                                    pass
+                                syscmdlist.append(fname)
+
+            self.shell.db['syscmdlist'] = syscmdlist
+        finally:
+            os.chdir(savedir)
+
+    @skip_doctest
+    @line_magic
+    def pwd(self, parameter_s=''):
+        """Return the current working directory path.
+
+        Examples
+        --------
+        ::
+
+          In [9]: pwd
+          Out[9]: '/home/tsuser/sprint/ipython'
+        """
+        try:
+            return os.getcwd()
+        except FileNotFoundError as e:
+            raise UsageError("CWD no longer exists - please use %cd to change directory.") from e
+
+    @skip_doctest
+    @line_magic
+    def cd(self, parameter_s=''):
+        """Change the current working directory.
+
+        This command automatically maintains an internal list of directories
+        you visit during your IPython session, in the variable ``_dh``. The
+        command :magic:`%dhist` shows this history nicely formatted. You can
+        also do ``cd -<tab>`` to see directory history conveniently.
+        Usage:
+
+          - ``cd 'dir'``: changes to directory 'dir'.
+          - ``cd -``: changes to the last visited directory.
+          - ``cd -<n>``: changes to the n-th directory in the directory history.
+          - ``cd --foo``: change to directory that matches 'foo' in history
+          - ``cd -b <bookmark_name>``: jump to a bookmark set by %bookmark
+          - Hitting a tab key after ``cd -b`` allows you to tab-complete
+            bookmark names.
+
+          .. note::
+            ``cd <bookmark_name>`` is enough if there is no directory
+            ``<bookmark_name>``, but a bookmark with the name exists.
+
+        Options:
+
+        -q               Be quiet. Do not print the working directory after the
+                          cd command is executed. By default IPython's cd
+                          command does print this directory, since the default
+                          prompts do not display path information.
+
+        .. note::
+           Note that ``!cd`` doesn't work for this purpose because the shell
+           where ``!command`` runs is immediately discarded after executing
+           'command'.
+
+        Examples
+        --------
+        ::
+
+          In [10]: cd parent/child
+          /home/tsuser/parent/child
+        """
+
+        try:
+            oldcwd = os.getcwd()
+        except FileNotFoundError:
+            # Happens if the CWD has been deleted.
+            oldcwd = None
+
+        numcd = re.match(r'(-)(\d+)$',parameter_s)
+        # jump in directory history by number
+        if numcd:
+            nn = int(numcd.group(2))
+            try:
+                ps = self.shell.user_ns['_dh'][nn]
+            except IndexError:
+                print('The requested directory does not exist in history.')
+                return
+            else:
+                opts = {}
+        elif parameter_s.startswith('--'):
+            ps = None
+            fallback = None
+            pat = parameter_s[2:]
+            dh = self.shell.user_ns['_dh']
+            # first search only by basename (last component)
+            for ent in reversed(dh):
+                if pat in os.path.basename(ent) and os.path.isdir(ent):
+                    ps = ent
+                    break
+
+                if fallback is None and pat in ent and os.path.isdir(ent):
+                    fallback = ent
+
+            # if we have no last part match, pick the first full path match
+            if ps is None:
+                ps = fallback
+
+            if ps is None:
+                print("No matching entry in directory history")
+                return
+            else:
+                opts = {}
+
+
+        else:
+            opts, ps = self.parse_options(parameter_s, 'qb', mode='string')
+        # jump to previous
+        if ps == '-':
+            try:
+                ps = self.shell.user_ns['_dh'][-2]
+            except IndexError as e:
+                raise UsageError('%cd -: No previous directory to change to.') from e
+        # jump to bookmark if needed
+        else:
+            if not os.path.isdir(ps) or 'b' in opts:
+                bkms = self.shell.db.get('bookmarks', {})
+
+                if ps in bkms:
+                    target = bkms[ps]
+                    print('(bookmark:%s) -> %s' % (ps, target))
+                    ps = target
+                else:
+                    if 'b' in opts:
+                        raise UsageError("Bookmark '%s' not found.  "
+                              "Use '%%bookmark -l' to see your bookmarks." % ps)
+
+        # at this point ps should point to the target dir
+        if ps:
+            try:
+                os.chdir(os.path.expanduser(ps))
+                if hasattr(self.shell, 'term_title') and self.shell.term_title:
+                    set_term_title(self.shell.term_title_format.format(cwd=abbrev_cwd()))
+            except OSError:
+                print(sys.exc_info()[1])
+            else:
+                cwd = pathlib.Path.cwd()
+                dhist = self.shell.user_ns['_dh']
+                if oldcwd != cwd:
+                    dhist.append(cwd)
+                    self.shell.db['dhist'] = compress_dhist(dhist)[-100:]
+
+        else:
+            os.chdir(self.shell.home_dir)
+            if hasattr(self.shell, 'term_title') and self.shell.term_title:
+                set_term_title(self.shell.term_title_format.format(cwd="~"))
+            cwd = pathlib.Path.cwd()
+            dhist = self.shell.user_ns['_dh']
+
+            if oldcwd != cwd:
+                dhist.append(cwd)
+                self.shell.db["dhist"] = compress_dhist(dhist)[-100:]
+        if "q" not in opts and not self.cd_force_quiet and self.shell.user_ns["_dh"]:
+            print(self.shell.user_ns["_dh"][-1])
+
+    @line_magic
+    def env(self, parameter_s=''):
+        """Get, set, or list environment variables.
+
+        Usage:\\
+
+          :``%env``: lists all environment variables/values
+          :``%env var``: get value for var
+          :``%env var val``: set value for var
+          :``%env var=val``: set value for var
+          :``%env var=$val``: set value for var, using python expansion if possible
+        """
+        if parameter_s.strip():
+            split = '=' if '=' in parameter_s else ' '
+            bits = parameter_s.split(split)
+            if len(bits) == 1:
+                key = parameter_s.strip()
+                if key in os.environ:
+                    return os.environ[key]
+                else:
+                    err = "Environment does not have key: {0}".format(key)
+                    raise UsageError(err)
+            if len(bits) > 1:
+                return self.set_env(parameter_s)
+        env = dict(os.environ)
+        # hide likely secrets when printing the whole environment
+        for key in list(env):
+            if any(s in key.lower() for s in ('key', 'token', 'secret')):
+                env[key] = '<hidden>'
+
+        return env
+
+    @line_magic
+    def set_env(self, parameter_s):
+        """Set environment variables.  Assumptions are that either "val" is a
+        name in the user namespace, or val is something that evaluates to a
+        string.
+
+        Usage:\\
+          :``%set_env var val``: set value for var
+          :``%set_env var=val``: set value for var
+          :``%set_env var=$val``: set value for var, using python expansion if possible
+        """
+        split = '=' if '=' in parameter_s else ' '
+        bits = parameter_s.split(split, 1)
+        if not parameter_s.strip() or len(bits)<2:
+            raise UsageError("usage is 'set_env var=val'")
+        var = bits[0].strip()
+        val = bits[1].strip()
+        if re.match(r'.*\s.*', var):
+            # an environment variable with whitespace is almost certainly
+            # not what the user intended.  what's more likely is the wrong
+            # split was chosen, ie for "set_env cmd_args A=B", we chose
+            # '=' for the split and should have chosen ' '.  to get around
+            # this, users should just assign directly to os.environ or use
+            # standard magic {var} expansion.
+            err = "refusing to set env var with whitespace: '{0}'"
+            err = err.format(val)
+            raise UsageError(err)
+        os.environ[var] = val
+        print('env: {0}={1}'.format(var,val))
+
+    @line_magic
+    def pushd(self, parameter_s=''):
+        """Place the current dir on stack and change directory.
+
+        Usage:\\
+          %pushd ['dirname']
+        """
+
+        dir_s = self.shell.dir_stack
+        tgt = os.path.expanduser(parameter_s)
+        cwd = os.getcwd().replace(self.shell.home_dir,'~')
+        if tgt:
+            self.cd(parameter_s)
+        dir_s.insert(0,cwd)
+        return self.shell.run_line_magic('dirs', '')
+
+    @line_magic
+    def popd(self, parameter_s=''):
+        """Change to directory popped off the top of the stack.
+        """
+        if not self.shell.dir_stack:
+            raise UsageError("%popd on empty stack")
+        top = self.shell.dir_stack.pop(0)
+        self.cd(top)
+        print("popd ->",top)
+
+    @line_magic
+    def dirs(self, parameter_s=''):
+        """Return the current directory stack."""
+
+        return self.shell.dir_stack
+
+    @line_magic
+    def dhist(self, parameter_s=''):
+        """Print your history of visited directories.
+
+        %dhist       -> print full history\\
+        %dhist n     -> print last n entries only\\
+        %dhist n1 n2 -> print entries between n1 and n2 (n2 not included)\\
+
+        This history is automatically maintained by the %cd command, and
+        always available as the global list variable _dh. You can use %cd -<n>
+        to go to directory number <n>.
+
+        Note that most of time, you should view directory history by entering
+        cd -<TAB>.
+
+        """
+
+        dh = self.shell.user_ns['_dh']
+        if parameter_s:
+            try:
+                args = map(int,parameter_s.split())
+            except:
+                self.arg_err(self.dhist)
+                return
+            if len(args) == 1:
+                ini,fin = max(len(dh)-(args[0]),0),len(dh)
+            elif len(args) == 2:
+                ini,fin = args
+                fin = min(fin, len(dh))
+            else:
+                self.arg_err(self.dhist)
+                return
+        else:
+            ini,fin = 0,len(dh)
+        print('Directory history (kept in _dh)')
+        for i in range(ini, fin):
+            print("%d: %s" % (i, dh[i]))
+
+    @skip_doctest
+    @line_magic
+    def sc(self, parameter_s=''):
+        """Shell capture - run shell command and capture output (DEPRECATED use !).
+
+        DEPRECATED. Suboptimal, retained for backwards compatibility.
+
+        You should use the form 'var = !command' instead. Example:
+
+         "%sc -l myfiles = ls ~" should now be written as
+
+         "myfiles = !ls ~"
+
+        myfiles.s, myfiles.l and myfiles.n still apply as documented
+        below.
+
+        --
+        %sc [options] varname=command
+
+        IPython will run the given command using commands.getoutput(), and
+        will then update the user's interactive namespace with a variable
+        called varname, containing the value of the call.  Your command can
+        contain shell wildcards, pipes, etc.
+
+        The '=' sign in the syntax is mandatory, and the variable name you
+        supply must follow Python's standard conventions for valid names.
+
+        (A special format without variable name exists for internal use)
+
+        Options:
+
+          -l: list output.  Split the output on newlines into a list before
+          assigning it to the given variable.  By default the output is stored
+          as a single string.
+
+          -v: verbose.  Print the contents of the variable.
+
+        In most cases you should not need to split as a list, because the
+        returned value is a special type of string which can automatically
+        provide its contents either as a list (split on newlines) or as a
+        space-separated string.  These are convenient, respectively, either
+        for sequential processing or to be passed to a shell command.
+
+        For example::
+
+            # Capture into variable a
+            In [1]: sc a=ls *py
+
+            # a is a string with embedded newlines
+            In [2]: a
+            Out[2]: 'setup.py\\nwin32_manual_post_install.py'
+
+            # which can be seen as a list:
+            In [3]: a.l
+            Out[3]: ['setup.py', 'win32_manual_post_install.py']
+
+            # or as a whitespace-separated string:
+            In [4]: a.s
+            Out[4]: 'setup.py win32_manual_post_install.py'
+
+            # a.s is useful to pass as a single command line:
+            In [5]: !wc -l $a.s
+              146 setup.py
+              130 win32_manual_post_install.py
+              276 total
+
+            # while the list form is useful to loop over:
+            In [6]: for f in a.l:
+               ...:      !wc -l $f
+               ...:
+            146 setup.py
+            130 win32_manual_post_install.py
+
+        Similarly, the lists returned by the -l option are also special, in
+        the sense that you can equally invoke the .s attribute on them to
+        automatically get a whitespace-separated string from their contents::
+
+            In [7]: sc -l b=ls *py
+
+            In [8]: b
+            Out[8]: ['setup.py', 'win32_manual_post_install.py']
+
+            In [9]: b.s
+            Out[9]: 'setup.py win32_manual_post_install.py'
+
+        In summary, both the lists and strings used for output capture have
+        the following special attributes::
+
+            .l (or .list) : value as list.
+            .n (or .nlstr): value as newline-separated string.
+            .s (or .spstr): value as space-separated string.
+        """
+
+        opts,args = self.parse_options(parameter_s, 'lv')
+        # Try to get a variable name and command to run
+        try:
+            # the variable name must be obtained from the parse_options
+            # output, which uses shlex.split to strip options out.
+            var,_ = args.split('=', 1)
+            var = var.strip()
+            # But the command has to be extracted from the original input
+            # parameter_s, not on what parse_options returns, to avoid the
+            # quote stripping which shlex.split performs on it.
+            _,cmd = parameter_s.split('=', 1)
+        except ValueError:
+            var,cmd = '',''
+        # If all looks ok, proceed
+        split = 'l' in opts
+        out = self.shell.getoutput(cmd, split=split)
+        if 'v' in opts:
+            print('%s ==\n%s' % (var, pformat(out)))
+        if var:
+            self.shell.user_ns.update({var:out})
+        else:
+            return out
+
+    @line_cell_magic
+    def sx(self, line='', cell=None):
+        """Shell execute - run shell command and capture output (!! is short-hand).
+
+        %sx command
+
+        IPython will run the given command using commands.getoutput(), and
+        return the result formatted as a list (split on '\\n').  Since the
+        output is _returned_, it will be stored in ipython's regular output
+        cache Out[N] and in the '_N' automatic variables.
+
+        Notes:
+
+        1) If an input line begins with '!!', then %sx is automatically
+        invoked.  That is, while::
+
+          !ls
+
+        causes ipython to simply issue system('ls'), typing::
+
+          !!ls
+
+        is a shorthand equivalent to::
+
+          %sx ls
+
+        2) %sx differs from %sc in that %sx automatically splits into a list,
+        like '%sc -l'.  The reason for this is to make it as easy as possible
+        to process line-oriented shell output via further python commands.
+        %sc is meant to provide much finer control, but requires more
+        typing.
+
+        3) Just like %sc -l, this is a list with special attributes:
+        ::
+
+          .l (or .list) : value as list.
+          .n (or .nlstr): value as newline-separated string.
+          .s (or .spstr): value as whitespace-separated string.
+
+        This is very useful when trying to use such lists as arguments to
+        system commands."""
+        
+        if cell is None:
+            # line magic
+            return self.shell.getoutput(line)
+        else:
+            opts,args = self.parse_options(line, '', 'out=')
+            output = self.shell.getoutput(cell)
+            out_name = opts.get('out', opts.get('o'))
+            if out_name:
+                self.shell.user_ns[out_name] = output
+            else:
+                return output
+
+    system = line_cell_magic('system')(sx)
+    bang = cell_magic('!')(sx)
+
+    @line_magic
+    def bookmark(self, parameter_s=''):
+        """Manage IPython's bookmark system.
+
+        %bookmark <name>       - set bookmark to current dir
+        %bookmark <name> <dir> - set bookmark to <dir>
+        %bookmark -l           - list all bookmarks
+        %bookmark -d <name>    - remove bookmark
+        %bookmark -r           - remove all bookmarks
+
+        You can later on access a bookmarked folder with::
+
+          %cd -b <name>
+
+        or simply '%cd <name>' if there is no directory called <name> AND
+        there is such a bookmark defined.
+
+        Your bookmarks persist through IPython sessions, but they are
+        associated with each profile."""
+
+        opts,args = self.parse_options(parameter_s,'drl',mode='list')
+        if len(args) > 2:
+            raise UsageError("%bookmark: too many arguments")
+
+        bkms = self.shell.db.get('bookmarks',{})
+
+        if 'd' in opts:
+            try:
+                todel = args[0]
+            except IndexError as e:
+                raise UsageError(
+                    "%bookmark -d: must provide a bookmark to delete") from e
+            else:
+                try:
+                    del bkms[todel]
+                except KeyError as e:
+                    raise UsageError(
+                        "%%bookmark -d: Can't delete bookmark '%s'" % todel) from e
+
+        elif 'r' in opts:
+            bkms = {}
+        elif 'l' in opts:
+            bks = sorted(bkms)
+            if bks:
+                size = max(map(len, bks))
+            else:
+                size = 0
+            fmt = '%-'+str(size)+'s -> %s'
+            print('Current bookmarks:')
+            for bk in bks:
+                print(fmt % (bk, bkms[bk]))
+        else:
+            if not args:
+                raise UsageError("%bookmark: You must specify the bookmark name")
+            elif len(args)==1:
+                bkms[args[0]] = os.getcwd()
+            elif len(args)==2:
+                bkms[args[0]] = args[1]
+        self.shell.db['bookmarks'] = bkms
+
+    @line_magic
+    def pycat(self, parameter_s=''):
+        """Show a syntax-highlighted file through a pager.
+
+        This magic is similar to the cat utility, but it will assume the file
+        to be Python source and will show it with syntax highlighting.
+
+        This magic command can either take a local filename, an url,
+        an history range (see %history) or a macro as argument.
+
+        If no parameter is given, prints out history of current session up to
+        this point. ::
+
+        %pycat myscript.py
+        %pycat 7-27
+        %pycat myMacro
+        %pycat http://www.example.com/myscript.py
+        """
+        try:
+            cont = self.shell.find_user_code(parameter_s, skip_encoding_cookie=False)
+        except (ValueError, IOError):
+            print("Error: no such file, variable, URL, history range or macro")
+            return
+
+        page.page(self.shell.pycolorize(source_to_unicode(cont)))
+
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '-a', '--append', action='store_true', default=False,
+        help='Append contents of the cell to an existing file. '
+             'The file will be created if it does not exist.'
+    )
+    @magic_arguments.argument(
+        'filename', type=str,
+        help='file to write'
+    )
+    @cell_magic
+    def writefile(self, line, cell):
+        """Write the contents of the cell to a file.
+
+        The file will be overwritten unless the -a (--append) flag is specified.
+        """
+        args = magic_arguments.parse_argstring(self.writefile, line)
+        if re.match(r'^(\'.*\')|(".*")$', args.filename):
+            filename = os.path.expanduser(args.filename[1:-1])
+        else:
+            filename = os.path.expanduser(args.filename)
+            
+        if os.path.exists(filename):
+            if args.append:
+                print("Appending to %s" % filename)
+            else:
+                print("Overwriting %s" % filename)
+        else:
+            print("Writing %s" % filename)
+        
+        mode = 'a' if args.append else 'w'
+        with io.open(filename, mode, encoding='utf-8') as f:
+            f.write(cell)
diff --git a/IPython/core/magics/packaging.py b/IPython/core/magics/packaging.py
new file mode 100644
index 00000000000..ed1c1274f3d
--- /dev/null
+++ b/IPython/core/magics/packaging.py
@@ -0,0 +1,181 @@
+"""Implementation of packaging-related magic functions.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2018 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+import functools
+import os
+import re
+import shlex
+import sys
+from pathlib import Path
+
+from IPython.core.magic import Magics, magics_class, line_magic
+
+
+def is_conda_environment(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        """Return True if the current Python executable is in a conda env"""
+        # TODO: does this need to change on windows?
+        if not Path(sys.prefix, "conda-meta", "history").exists():
+            raise ValueError(
+                "The python kernel does not appear to be a conda environment.  "
+                "Please use ``%pip install`` instead."
+            )
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def _get_conda_like_executable(command):
+    """Find the path to the given executable
+
+    Parameters
+    ----------
+
+    executable: string
+        Value should be: conda, mamba or micromamba
+    """
+    # Check for a environment variable bound to the base executable, both conda and mamba
+    # set these when activating an environment.
+    base_executable = "CONDA_EXE"
+    if "mamba" in command.lower():
+        base_executable = "MAMBA_EXE"
+    if base_executable in os.environ:
+        executable = Path(os.environ[base_executable])
+        if executable.is_file():
+            return str(executable.resolve())
+
+    # Check if there is a conda executable in the same directory as the Python executable.
+    # This is the case within conda's root environment.
+    executable = Path(sys.executable).parent / command
+    if executable.is_file():
+        return str(executable)
+
+    # Otherwise, attempt to extract the executable from conda history.
+    # This applies in any conda environment. Parsing this way is error prone because
+    # different versions of conda and mamba include differing cmd values such as
+    # `conda`, `conda-script.py`, or `path/to/conda`, here use the raw command provided.
+    history = Path(sys.prefix, "conda-meta", "history").read_text(encoding="utf-8")
+    match = re.search(
+        rf"^#\s*cmd:\s*(?P<command>.*{command})\s[create|install]",
+        history,
+        flags=re.MULTILINE,
+    )
+    if match:
+        return match.groupdict()["command"]
+
+    # Fallback: assume the executable is available on the system path.
+    return command
+
+
+CONDA_COMMANDS_REQUIRING_PREFIX = {
+    'install', 'list', 'remove', 'uninstall', 'update', 'upgrade',
+}
+CONDA_COMMANDS_REQUIRING_YES = {
+    'install', 'remove', 'uninstall', 'update', 'upgrade',
+}
+CONDA_ENV_FLAGS = {'-p', '--prefix', '-n', '--name'}
+CONDA_YES_FLAGS = {'-y', '--y'}
+
+
+@magics_class
+class PackagingMagics(Magics):
+    """Magics related to packaging & installation"""
+
+    @line_magic
+    def pip(self, line):
+        """Run the pip package manager within the current kernel.
+
+        Usage:
+          %pip install [pkgs]
+        """
+        python = sys.executable
+        if sys.platform == "win32":
+            python = '"' + python + '"'
+        else:
+            python = shlex.quote(python)
+
+        self.shell.system(" ".join([python, "-m", "pip", line]))
+
+        print("Note: you may need to restart the kernel to use updated packages.")
+
+    def _run_command(self, cmd, line):
+        args = shlex.split(line)
+        command = args[0] if len(args) > 0 else ""
+        args = args[1:] if len(args) > 1 else [""]
+
+        extra_args = []
+
+        # When the subprocess does not allow us to respond "yes" during the installation,
+        # we need to insert --yes in the argument list for some commands
+        stdin_disabled = getattr(self.shell, 'kernel', None) is not None
+        needs_yes = command in CONDA_COMMANDS_REQUIRING_YES
+        has_yes = set(args).intersection(CONDA_YES_FLAGS)
+        if stdin_disabled and needs_yes and not has_yes:
+            extra_args.append("--yes")
+
+        # Add --prefix to point conda installation to the current environment
+        needs_prefix = command in CONDA_COMMANDS_REQUIRING_PREFIX
+        has_prefix = set(args).intersection(CONDA_ENV_FLAGS)
+        if needs_prefix and not has_prefix:
+            extra_args.extend(["--prefix", sys.prefix])
+
+        self.shell.system(" ".join([cmd, command] + extra_args + args))
+        print("\nNote: you may need to restart the kernel to use updated packages.")
+
+    @line_magic
+    @is_conda_environment
+    def conda(self, line):
+        """Run the conda package manager within the current kernel.
+
+        Usage:
+          %conda install [pkgs]
+        """
+        conda = _get_conda_like_executable("conda")
+        self._run_command(conda, line)
+
+    @line_magic
+    @is_conda_environment
+    def mamba(self, line):
+        """Run the mamba package manager within the current kernel.
+
+        Usage:
+          %mamba install [pkgs]
+        """
+        mamba = _get_conda_like_executable("mamba")
+        self._run_command(mamba, line)
+
+    @line_magic
+    @is_conda_environment
+    def micromamba(self, line):
+        """Run the conda package manager within the current kernel.
+
+        Usage:
+          %micromamba install [pkgs]
+        """
+        micromamba = _get_conda_like_executable("micromamba")
+        self._run_command(micromamba, line)
+
+    @line_magic
+    def uv(self, line):
+        """Run the uv package manager within the current kernel.
+
+        Usage:
+          %uv pip install [pkgs]
+        """
+        python = sys.executable
+        if sys.platform == "win32":
+            python = '"' + python + '"'
+        else:
+            python = shlex.quote(python)
+
+        self.shell.system(" ".join([python, "-m", "uv", line]))
+
+        print("Note: you may need to restart the kernel to use updated packages.")
diff --git a/IPython/core/magics/pylab.py b/IPython/core/magics/pylab.py
new file mode 100644
index 00000000000..423498d404c
--- /dev/null
+++ b/IPython/core/magics/pylab.py
@@ -0,0 +1,173 @@
+"""Implementation of magic functions for matplotlib/pylab support.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (c) 2012 The IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Our own packages
+from traitlets.config.application import Application
+from IPython.core import magic_arguments
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from warnings import warn
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+magic_gui_arg = magic_arguments.argument(
+    "gui",
+    nargs="?",
+    help="""Name of the matplotlib backend to use such as 'qt' or 'widget'.
+        If given, the corresponding matplotlib backend is used,
+        otherwise it will be matplotlib's default
+        (which you can set in your matplotlib config file).
+        """,
+)
+
+
+@magics_class
+class PylabMagics(Magics):
+    """Magics related to matplotlib's pylab support"""
+
+    @skip_doctest
+    @line_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument('-l', '--list', action='store_true',
+                              help='Show available matplotlib backends')
+    @magic_gui_arg
+    def matplotlib(self, line=''):
+        """Set up matplotlib to work interactively.
+
+        This function lets you activate matplotlib interactive support
+        at any point during an IPython session. It does not import anything
+        into the interactive namespace.
+
+        If you are using the inline matplotlib backend in the IPython Notebook
+        you can set which figure formats are enabled using the following::
+
+            In [1]: from matplotlib_inline.backend_inline import set_matplotlib_formats
+
+            In [2]: set_matplotlib_formats('pdf', 'svg')
+
+        The default for inline figures sets `bbox_inches` to 'tight'. This can
+        cause discrepancies between the displayed image and the identical
+        image created using `savefig`. This behavior can be disabled using the
+        `%config` magic::
+
+            In [3]: %config InlineBackend.print_figure_kwargs = {'bbox_inches':None}
+
+        In addition, see the docstrings of
+        `matplotlib_inline.backend_inline.set_matplotlib_formats` and
+        `matplotlib_inline.backend_inline.set_matplotlib_close` for more information on
+        changing additional behaviors of the inline backend.
+
+        Examples
+        --------
+        To enable the inline backend for usage with the IPython Notebook::
+
+            In [1]: %matplotlib inline
+
+        In this case, where the matplotlib default is TkAgg::
+
+            In [2]: %matplotlib
+            Using matplotlib backend: TkAgg
+
+        But you can explicitly request a different GUI backend::
+
+            In [3]: %matplotlib qt
+
+        You can list the available backends using the -l/--list option::
+
+           In [4]: %matplotlib --list
+           Available matplotlib backends: ['osx', 'qt4', 'qt5', 'gtk3', 'gtk4', 'notebook', 'wx', 'qt', 'nbagg',
+           'gtk', 'tk', 'inline']
+        """
+        args = magic_arguments.parse_argstring(self.matplotlib, line)
+        if args.list:
+            from IPython.core.pylabtools import _list_matplotlib_backends_and_gui_loops
+
+            print(
+                "Available matplotlib backends: %s"
+                % _list_matplotlib_backends_and_gui_loops()
+            )
+        else:
+            gui, backend = self.shell.enable_matplotlib(args.gui)
+            self._show_matplotlib_backend(args.gui, backend)
+
+    @skip_doctest
+    @line_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        '--no-import-all', action='store_true', default=None,
+        help="""Prevent IPython from performing ``import *`` into the interactive namespace.
+
+        You can govern the default behavior of this flag with the
+        InteractiveShellApp.pylab_import_all configurable.
+        """
+    )
+    @magic_gui_arg
+    def pylab(self, line=''):
+        """Load numpy and matplotlib to work interactively.
+
+        This function lets you activate pylab (matplotlib, numpy and
+        interactive support) at any point during an IPython session.
+
+        %pylab makes the following imports::
+
+            import numpy
+            import matplotlib
+            from matplotlib import pylab, mlab, pyplot
+            np = numpy
+            plt = pyplot
+
+            from IPython.display import display
+            from IPython.core.pylabtools import figsize, getfigs
+
+            from pylab import *
+            from numpy import *
+
+        If you pass `--no-import-all`, the last two `*` imports will be excluded.
+
+        See the %matplotlib magic for more details about activating matplotlib
+        without affecting the interactive namespace.
+        """
+        args = magic_arguments.parse_argstring(self.pylab, line)
+        if args.no_import_all is None:
+            # get default from Application
+            if Application.initialized():
+                app = Application.instance()
+                try:
+                    import_all = app.pylab_import_all
+                except AttributeError:
+                    import_all = True
+            else:
+                # nothing specified, no app - default True
+                import_all = True
+        else:
+            # invert no-import flag
+            import_all = not args.no_import_all
+
+        gui, backend, clobbered = self.shell.enable_pylab(args.gui, import_all=import_all)
+        self._show_matplotlib_backend(args.gui, backend)
+        print(
+            "%pylab is deprecated, use %matplotlib inline and import the required libraries."
+        )
+        print("Populating the interactive namespace from numpy and matplotlib")
+        if clobbered:
+            warn("pylab import has clobbered these variables: %s"  % clobbered +
+            "\n`%matplotlib` prevents importing * from pylab and numpy"
+            )
+
+    def _show_matplotlib_backend(self, gui, backend):
+        """show matplotlib message backend message"""
+        if not gui or gui == 'auto':
+            print("Using matplotlib backend: %s" % backend)
diff --git a/IPython/core/magics/script.py b/IPython/core/magics/script.py
new file mode 100644
index 00000000000..1f7e6b3cb68
--- /dev/null
+++ b/IPython/core/magics/script.py
@@ -0,0 +1,405 @@
+"""Magic functions for running cells in various scripts."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import asyncio
+import asyncio.exceptions
+import atexit
+import errno
+import os
+import signal
+import sys
+import time
+from codecs import getincrementaldecoder
+from subprocess import CalledProcessError
+from threading import Thread
+
+from traitlets import Any, Dict, List, default
+
+from IPython.core import magic_arguments
+from IPython.core.async_helpers import _AsyncIOProxy
+from IPython.core.magic import Magics, cell_magic, line_magic, magics_class
+from IPython.utils.process import arg_split
+
+#-----------------------------------------------------------------------------
+# Magic implementation classes
+#-----------------------------------------------------------------------------
+
+def script_args(f):
+    """single decorator for adding script args"""
+    args = [
+        magic_arguments.argument(
+            '--out', type=str,
+            help="""The variable in which to store stdout from the script.
+            If the script is backgrounded, this will be the stdout *pipe*,
+            instead of the stderr text itself and will not be auto closed.
+            """
+        ),
+        magic_arguments.argument(
+            '--err', type=str,
+            help="""The variable in which to store stderr from the script.
+            If the script is backgrounded, this will be the stderr *pipe*,
+            instead of the stderr text itself and will not be autoclosed.
+            """
+        ),
+        magic_arguments.argument(
+            '--bg', action="store_true",
+            help="""Whether to run the script in the background.
+            If given, the only way to see the output of the command is
+            with --out/err.
+            """
+        ),
+        magic_arguments.argument(
+            '--proc', type=str,
+            help="""The variable in which to store Popen instance.
+            This is used only when --bg option is given.
+            """
+        ),
+        magic_arguments.argument(
+            '--no-raise-error', action="store_false", dest='raise_error',
+            help="""Whether you should raise an error message in addition to
+            a stream on stderr if you get a nonzero exit code.
+            """,
+        ),
+    ]
+    for arg in args:
+        f = arg(f)
+    return f
+
+
+class RaiseAfterInterrupt(Exception):
+    pass
+
+
+@magics_class
+class ScriptMagics(Magics):
+    """Magics for talking to scripts
+    
+    This defines a base `%%script` cell magic for running a cell
+    with a program in a subprocess, and registers a few top-level
+    magics that call %%script with common interpreters.
+    """
+
+    event_loop = Any(
+        help="""
+        The event loop on which to run subprocesses
+
+        Not the main event loop,
+        because we want to be able to make blocking calls
+        and have certain requirements we don't want to impose on the main loop.
+        """
+    )
+
+    script_magics: List = List(
+        help="""Extra script cell magics to define
+        
+        This generates simple wrappers of `%%script foo` as `%%foo`.
+        
+        If you want to add script magics that aren't on your path,
+        specify them in script_paths
+        """,
+    ).tag(config=True)
+
+    @default('script_magics')
+    def _script_magics_default(self):
+        """default to a common list of programs"""
+        
+        defaults = [
+            'sh',
+            'bash',
+            'perl',
+            'ruby',
+            'python',
+            'python2',
+            'python3',
+            'pypy',
+        ]
+        if os.name == 'nt':
+            defaults.extend([
+                'cmd',
+            ])
+        
+        return defaults
+    
+    script_paths = Dict(
+        help="""Dict mapping short 'ruby' names to full paths, such as '/opt/secret/bin/ruby'
+        
+        Only necessary for items in script_magics where the default path will not
+        find the right interpreter.
+        """
+    ).tag(config=True)
+    
+    def __init__(self, shell=None):
+        super(ScriptMagics, self).__init__(shell=shell)
+        self._generate_script_magics()
+        self.bg_processes = []
+        atexit.register(self.kill_bg_processes)
+
+    def __del__(self):
+        self.kill_bg_processes()
+    
+    def _generate_script_magics(self):
+        cell_magics = self.magics['cell']
+        for name in self.script_magics:
+            cell_magics[name] = self._make_script_magic(name)
+    
+    def _make_script_magic(self, name):
+        """make a named magic, that calls %%script with a particular program"""
+        # expand to explicit path if necessary:
+        script = self.script_paths.get(name, name)
+        
+        @magic_arguments.magic_arguments()
+        @script_args
+        def named_script_magic(line, cell):
+            # if line, add it as cl-flags
+            if line:
+                line = "%s %s" % (script, line)
+            else:
+                line = script
+            return self.shebang(line, cell)
+        
+        # write a basic docstring:
+        named_script_magic.__doc__ = \
+        """%%{name} script magic
+        
+        Run cells with {script} in a subprocess.
+        
+        This is a shortcut for `%%script {script}`
+        """.format(**locals())
+        
+        return named_script_magic
+    
+    @magic_arguments.magic_arguments()
+    @script_args
+    @cell_magic("script")
+    def shebang(self, line, cell):
+        """Run a cell via a shell command
+
+        The `%%script` line is like the #! line of script,
+        specifying a program (bash, perl, ruby, etc.) with which to run.
+
+        The rest of the cell is run by that program.
+
+        .. versionchanged:: 9.0
+          Interrupting the script executed without `--bg` will end in
+          raising an exception (unless `--no-raise-error` is passed).
+
+        Examples
+        --------
+        ::
+
+            In [1]: %%script bash
+               ...: for i in 1 2 3; do
+               ...:   echo $i
+               ...: done
+            1
+            2
+            3
+        """
+
+        # Create the event loop in which to run script magics
+        # this operates on a background thread
+        if self.event_loop is None:
+            if sys.platform == "win32":
+                # don't override the current policy,
+                # just create an event loop
+                event_loop = asyncio.WindowsProactorEventLoopPolicy().new_event_loop()
+            else:
+                event_loop = asyncio.new_event_loop()
+            self.event_loop = event_loop
+
+            # start the loop in a background thread
+            asyncio_thread = Thread(target=event_loop.run_forever, daemon=True)
+            asyncio_thread.start()
+        else:
+            event_loop = self.event_loop
+
+        def in_thread(coro):
+            """Call a coroutine on the asyncio thread"""
+            return asyncio.run_coroutine_threadsafe(coro, event_loop).result()
+
+        async def _readchunk(stream):
+            try:
+                return await stream.read(100)
+            except asyncio.exceptions.IncompleteReadError as e:
+                return e.partial
+            except asyncio.exceptions.LimitOverrunError as e:
+                return await stream.read(e.consumed)
+
+        async def _handle_stream(stream, stream_arg, file_object):
+            should_break = False
+            decoder = getincrementaldecoder("utf-8")(errors="replace")
+            while True:
+                chunk = decoder.decode(await _readchunk(stream))
+                if not chunk:
+                    break
+                    chunk = decoder.decode("", final=True)
+                    should_break = True
+                if stream_arg:
+                    self.shell.user_ns[stream_arg] += chunk
+                else:
+                    file_object.write(chunk)
+                    file_object.flush()
+                if should_break:
+                    break
+
+        async def _stream_communicate(process, cell):
+            process.stdin.write(cell)
+            process.stdin.close()
+            stdout_task = asyncio.create_task(
+                _handle_stream(process.stdout, args.out, sys.stdout)
+            )
+            stderr_task = asyncio.create_task(
+                _handle_stream(process.stderr, args.err, sys.stderr)
+            )
+            await asyncio.wait([stdout_task, stderr_task])
+            await process.wait()
+
+        argv = arg_split(line, posix=not sys.platform.startswith("win"))
+        args, cmd = self.shebang.parser.parse_known_args(argv)
+
+        if args.out:
+            self.shell.user_ns[args.out] = ""
+        if args.err:
+            self.shell.user_ns[args.err] = ""
+
+        try:
+            p = in_thread(
+                asyncio.create_subprocess_exec(
+                    *cmd,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                    stdin=asyncio.subprocess.PIPE,
+                )
+            )
+        except OSError as e:
+            if e.errno == errno.ENOENT:
+                print("Couldn't find program: %r" % cmd[0])
+                return
+            else:
+                raise
+
+        if not cell.endswith('\n'):
+            cell += '\n'
+        cell = cell.encode('utf8', 'replace')
+        if args.bg:
+            self.bg_processes.append(p)
+            self._gc_bg_processes()
+            to_close = []
+            if args.out:
+                self.shell.user_ns[args.out] = _AsyncIOProxy(p.stdout, event_loop)
+            else:
+                to_close.append(p.stdout)
+            if args.err:
+                self.shell.user_ns[args.err] = _AsyncIOProxy(p.stderr, event_loop)
+            else:
+                to_close.append(p.stderr)
+            event_loop.call_soon_threadsafe(
+                lambda: asyncio.Task(self._run_script(p, cell, to_close))
+            )
+            if args.proc:
+                proc_proxy = _AsyncIOProxy(p, event_loop)
+                proc_proxy.stdout = _AsyncIOProxy(p.stdout, event_loop)
+                proc_proxy.stderr = _AsyncIOProxy(p.stderr, event_loop)
+                self.shell.user_ns[args.proc] = proc_proxy
+            return
+
+        try:
+            in_thread(_stream_communicate(p, cell))
+        except KeyboardInterrupt:
+            try:
+                p.send_signal(signal.SIGINT)
+                in_thread(asyncio.wait_for(p.wait(), timeout=0.1))
+                if p.returncode is not None:
+                    print("Process was interrupted.")
+                    if args.raise_error:
+                        raise RaiseAfterInterrupt()
+                    else:
+                        return
+                p.terminate()
+                in_thread(asyncio.wait_for(p.wait(), timeout=0.1))
+                if p.returncode is not None:
+                    print("Process was terminated.")
+                    if args.raise_error:
+                        raise RaiseAfterInterrupt()
+                    else:
+                        return
+                p.kill()
+                print("Process was killed.")
+                if args.raise_error:
+                    raise RaiseAfterInterrupt()
+            except RaiseAfterInterrupt:
+                pass
+            except OSError:
+                pass
+            except Exception as e:
+                print("Error while terminating subprocess (pid=%i): %s" % (p.pid, e))
+            if args.raise_error:
+                raise CalledProcessError(p.returncode, cell) from None
+            else:
+                return
+
+        if args.raise_error and p.returncode != 0:
+            # If we get here and p.returncode is still None, we must have
+            # killed it but not yet seen its return code. We don't wait for it,
+            # in case it's stuck in uninterruptible sleep. -9 = SIGKILL
+            rc = p.returncode or -9
+            raise CalledProcessError(rc, cell)
+
+    shebang.__skip_doctest__ = os.name != "posix"
+
+    async def _run_script(self, p, cell, to_close):
+        """callback for running the script in the background"""
+
+        p.stdin.write(cell)
+        await p.stdin.drain()
+        p.stdin.close()
+        await p.stdin.wait_closed()
+        await p.wait()
+        # asyncio read pipes have no close
+        # but we should drain the data anyway
+        for s in to_close:
+            await s.read()
+        self._gc_bg_processes()
+
+    @line_magic("killbgscripts")
+    def killbgscripts(self, _nouse_=''):
+        """Kill all BG processes started by %%script and its family."""
+        self.kill_bg_processes()
+        print("All background processes were killed.")
+
+    def kill_bg_processes(self):
+        """Kill all BG processes which are still running."""
+        if not self.bg_processes:
+            return
+        for p in self.bg_processes:
+            if p.returncode is None:
+                try:
+                    p.send_signal(signal.SIGINT)
+                except:
+                    pass
+        time.sleep(0.1)
+        self._gc_bg_processes()
+        if not self.bg_processes:
+            return
+        for p in self.bg_processes:
+            if p.returncode is None:
+                try:
+                    p.terminate()
+                except:
+                    pass
+        time.sleep(0.1)
+        self._gc_bg_processes()
+        if not self.bg_processes:
+            return
+        for p in self.bg_processes:
+            if p.returncode is None:
+                try:
+                    p.kill()
+                except:
+                    pass
+        self._gc_bg_processes()
+
+    def _gc_bg_processes(self):
+        self.bg_processes = [p for p in self.bg_processes if p.returncode is None]
diff --git a/IPython/core/oinspect.py b/IPython/core/oinspect.py
index 1ee9f2e8f71..0fc27940d23 100644
--- a/IPython/core/oinspect.py
+++ b/IPython/core/oinspect.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """Tools for inspecting Python objects.
 
 Uses syntax highlighting for presenting the various information elements.
@@ -7,622 +6,874 @@
 reference the name under which an object is being read.
 """
 
-#*****************************************************************************
-#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-__all__ = ['Inspector','InspectColors']
+__all__ = ["Inspector"]
 
 # stdlib modules
-import __builtin__
-import StringIO
+from dataclasses import dataclass
+from inspect import signature
+from textwrap import dedent
+import ast
+import html
 import inspect
+import io as stdlib_io
 import linecache
 import os
-import sys
 import types
-from collections import namedtuple
-from itertools import izip_longest
+import warnings
+from pygments.token import Token
+
+
+from typing import (
+    cast,
+    Any,
+    Optional,
+    Dict,
+    Union,
+    List,
+    TypedDict,
+    TypeAlias,
+    Tuple,
+)
+
+import traitlets
+from traitlets.config import Configurable
 
 # IPython's own
 from IPython.core import page
-from IPython.external.Itpl import itpl
-from IPython.utils import PyColorize
-from IPython.utils import io
+from IPython.lib.pretty import pretty
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils import PyColorize, openpy
+from IPython.utils.dir2 import safe_hasattr
+from IPython.utils.path import compress_user
 from IPython.utils.text import indent
-from IPython.utils.wildcard import list_namespace
-from IPython.utils.coloransi import *
+from IPython.utils.wildcard import list_namespace, typestr2type
+from IPython.utils.decorators import undoc
 
-#****************************************************************************
-# Builtin color schemes
+from pygments import highlight
+from pygments.lexers import PythonLexer
+from pygments.formatters import HtmlFormatter
 
-Colors = TermColors  # just a shorthand
+HOOK_NAME = "__custom_documentations__"
 
-# Build a few color schemes
-NoColor = ColorScheme(
-    'NoColor',{
-    'header' : Colors.NoColor,
-    'normal' : Colors.NoColor  # color off (usu. Colors.Normal)
-    }  )
 
-LinuxColors = ColorScheme(
-    'Linux',{
-    'header' : Colors.LightRed,
-    'normal' : Colors.Normal  # color off (usu. Colors.Normal)
-    } )
+UnformattedBundle: TypeAlias = Dict[str, List[Tuple[str, str]]]  # List of (title, body)
+Bundle: TypeAlias = Dict[str, str]
 
-LightBGColors = ColorScheme(
-    'LightBG',{
-    'header' : Colors.Red,
-    'normal' : Colors.Normal  # color off (usu. Colors.Normal)
-    }  )
 
-# Build table of color schemes (needed by the parser)
-InspectColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
-                                 'Linux')
+@dataclass
+class OInfo:
+    ismagic: bool
+    isalias: bool
+    found: bool
+    namespace: Optional[str]
+    parent: Any
+    obj: Any
 
+    def get(self, field):
+        """Get a field from the object for backward compatibility with before 8.12
+
+        see https://github.com/h5py/h5py/issues/2253
+        """
+        # We need to deprecate this at some point, but the warning will show in completion.
+        # Let's comment this for now and uncomment end of 2023 ish
+        # Jan 2025: decomenting for IPython 9.0
+        warnings.warn(
+            f"OInfo dataclass with fields access since IPython 8.12 please use OInfo.{field} instead."
+            "OInfo used to be a dict but a dataclass provide static fields verification with mypy."
+            "This warning and backward compatibility `get()` method were added in 8.13.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return getattr(self, field)
+
+
+def pylight(code):
+    return highlight(code, PythonLexer(), HtmlFormatter(noclasses=True))
+
+# builtin docstrings to ignore
+_func_call_docstring = types.FunctionType.__call__.__doc__
+_object_init_docstring = object.__init__.__doc__
+_builtin_type_docstrings = {
+    inspect.getdoc(t) for t in (types.ModuleType, types.MethodType,
+                                types.FunctionType, property)
+}
+
+_builtin_func_type = type(all)
+_builtin_meth_type = type(str.upper)  # Bound methods have the same type as builtin functions
 #****************************************************************************
-# Auxiliary functions and objects
+# Builtin color schemes
 
-# See the messaging spec for the definition of all these fields.  This list
-# effectively defines the order of display
-info_fields = ['type_name', 'base_class', 'string_form', 'namespace',
-               'length', 'file', 'definition', 'docstring', 'source',
-               'init_definition', 'class_docstring', 'init_docstring',
-               'call_def', 'call_docstring',
-               # These won't be printed but will be used to determine how to
-               # format the object
-               'ismagic', 'isalias', 'argspec', 'found', 'name',
-               ]
 
+#****************************************************************************
+# Auxiliary functions and objects
 
-def object_info(**kw):
+
+class InfoDict(TypedDict):
+    type_name: Optional[str]
+    base_class: Optional[str]
+    string_form: Optional[str]
+    namespace: Optional[str]
+    length: Optional[str]
+    file: Optional[str]
+    definition: Optional[str]
+    docstring: Optional[str]
+    source: Optional[str]
+    init_definition: Optional[str]
+    class_docstring: Optional[str]
+    init_docstring: Optional[str]
+    call_def: Optional[str]
+    call_docstring: Optional[str]
+    subclasses: Optional[str]
+    # These won't be printed but will be used to determine how to
+    # format the object
+    ismagic: bool
+    isalias: bool
+    isclass: bool
+    found: bool
+    name: str
+
+
+_info_fields = list(InfoDict.__annotations__.keys())
+
+
+def __getattr__(name):
+    if name == "info_fields":
+        warnings.warn(
+            "IPython.core.oinspect's `info_fields` is considered for deprecation and may be removed in the Future. ",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _info_fields
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+@dataclass
+class InspectorHookData:
+    """Data passed to the mime hook"""
+
+    obj: Any
+    info: Optional[OInfo]
+    info_dict: InfoDict
+    detail_level: int
+    omit_sections: list[str]
+
+
+@undoc
+def object_info(
+    *,
+    name: str,
+    found: bool,
+    isclass: bool = False,
+    isalias: bool = False,
+    ismagic: bool = False,
+    **kw,
+) -> InfoDict:
     """Make an object info dict with all fields present."""
-    infodict = dict(izip_longest(info_fields, [None]))
-    infodict.update(kw)
-    return infodict
+    infodict = dict(kw)
+    infodict.update({k: None for k in _info_fields if k not in infodict})
+    infodict["name"] = name  # type: ignore
+    infodict["found"] = found  # type: ignore
+    infodict["isclass"] = isclass  # type: ignore
+    infodict["isalias"] = isalias  # type: ignore
+    infodict["ismagic"] = ismagic  # type: ignore
+
+    return InfoDict(**infodict)  # type:ignore
 
 
-def getdoc(obj):
+def get_encoding(obj):
+    """Get encoding for python source file defining obj
+
+    Returns None if obj is not defined in a sourcefile.
+    """
+    ofile = find_file(obj)
+    # run contents of file through pager starting at line where the object
+    # is defined, as long as the file isn't binary and is actually on the
+    # filesystem.
+    if ofile is None:
+        return None
+    elif ofile.endswith(('.so', '.dll', '.pyd')):
+        return None
+    elif not os.path.isfile(ofile):
+        return None
+    else:
+        # Print only text files, not extension binaries.  Note that
+        # getsourcelines returns lineno with 1-offset and page() uses
+        # 0-offset, so we must adjust.
+        with stdlib_io.open(ofile, 'rb') as buffer:   # Tweaked to use io.open for Python 2
+            encoding, _lines = openpy.detect_encoding(buffer.readline)
+        return encoding
+
+
+def getdoc(obj) -> Union[str, None]:
     """Stable wrapper around inspect.getdoc.
 
     This can't crash because of attribute problems.
 
     It also attempts to call a getdoc() method on the given object.  This
     allows objects which provide their docstrings via non-standard mechanisms
-    (like Pyro proxies) to still be inspected by ipython's ? system."""
-
-    ds = None  # default return value
-    try:
-        ds = inspect.getdoc(obj)
-    except:
-        # Harden against an inspect failure, which can occur with
-        # SWIG-wrapped extensions.
-        pass
+    (like Pyro proxies) to still be inspected by ipython's ? system.
+    """
     # Allow objects to offer customized documentation via a getdoc method:
     try:
-        ds2 = obj.getdoc()
-    except:
+        ds = obj.getdoc()
+    except Exception:
         pass
     else:
-        # if we get extra info, we add it to the normal docstring.
-        if ds is None:
-            ds = ds2
-        else:
-            ds = '%s\n%s' % (ds,ds2)
-    return ds
+        if isinstance(ds, str):
+            return inspect.cleandoc(ds)
+    docstr = inspect.getdoc(obj)
+    return docstr
 
 
-def getsource(obj,is_binary=False):
+def getsource(obj, oname='') -> Union[str,None]:
     """Wrapper around inspect.getsource.
 
     This can be modified by other projects to provide customized source
     extraction.
 
-    Inputs:
+    Parameters
+    ----------
+    obj : object
+        an object whose source code we will attempt to extract
+    oname : str
+        (optional) a name under which the object is known
 
-    - obj: an object whose source code we will attempt to extract.
+    Returns
+    -------
+    src : unicode or None
 
-    Optional inputs:
+    """
+
+    if isinstance(obj, property):
+        sources = []
+        for attrname in ['fget', 'fset', 'fdel']:
+            fn = getattr(obj, attrname)
+            if fn is not None:
+                oname_prefix = ('%s.' % oname) if oname else ''
+                sources.append(''.join(('# ', oname_prefix, attrname)))
+                if inspect.isfunction(fn):
+                    _src = getsource(fn)
+                    if _src:
+                        # assert _src is not None, "please mypy"
+                        sources.append(dedent(_src))
+                else:
+                    # Default str/repr only prints function name,
+                    # pretty.pretty prints module name too.
+                    sources.append(
+                        '%s%s = %s\n' % (oname_prefix, attrname, pretty(fn))
+                    )
+        if sources:
+            return '\n'.join(sources)
+        else:
+            return None
 
-    - is_binary: whether the object is known to come from a binary source.
-    This implementation will skip returning any output for binary objects, but
-    custom extractors may know how to meaningfully process them."""
-    
-    if is_binary:
-        return None
     else:
+        # Get source for non-property objects.
+
+        obj = _get_wrapped(obj)
+
         try:
             src = inspect.getsource(obj)
         except TypeError:
-            if hasattr(obj,'__class__'):
+            # The object itself provided no meaningful source, try looking for
+            # its class definition instead.
+            try:
                 src = inspect.getsource(obj.__class__)
-        return src
-
-def getargspec(obj):
-    """Get the names and default values of a function's arguments.
-
-    A tuple of four things is returned: (args, varargs, varkw, defaults).
-    'args' is a list of the argument names (it may contain nested lists).
-    'varargs' and 'varkw' are the names of the * and ** arguments or None.
-    'defaults' is an n-tuple of the default values of the last n arguments.
+            except (OSError, TypeError):
+                return None
+        except OSError:
+            return None
 
-    Modified version of inspect.getargspec from the Python Standard
-    Library."""
+        return src
 
-    if inspect.isfunction(obj):
-        func_obj = obj
-    elif inspect.ismethod(obj):
-        func_obj = obj.im_func
-    elif hasattr(obj, '__call__'):
-        func_obj = obj.__call__
-    else:
-        raise TypeError('arg is not a Python function')
-    args, varargs, varkw = inspect.getargs(func_obj.func_code)
-    return args, varargs, varkw, func_obj.func_defaults
 
+def is_simple_callable(obj):
+    """True if obj is a function ()"""
+    return (inspect.isfunction(obj) or inspect.ismethod(obj) or \
+            isinstance(obj, _builtin_func_type) or isinstance(obj, _builtin_meth_type))
 
-def format_argspec(argspec):
-    """Format argspect, convenience wrapper around inspect's.
+def _get_wrapped(obj):
+    """Get the original object if wrapped in one or more @decorators
 
-    This takes a dict instead of ordered arguments and calls
-    inspect.format_argspec with the arguments in the necessary order.
+    Some objects automatically construct similar objects on any unrecognised
+    attribute access (e.g. unittest.mock.call). To protect against infinite loops,
+    this will arbitrarily cut off after 100 levels of obj.__wrapped__
+    attribute access. --TK, Jan 2016
     """
-    return inspect.formatargspec(argspec['args'], argspec['varargs'],
-                                 argspec['varkw'], argspec['defaults'])
+    orig_obj = obj
+    i = 0
+    while safe_hasattr(obj, '__wrapped__'):
+        obj = obj.__wrapped__
+        i += 1
+        if i > 100:
+            # __wrapped__ is probably a lie, so return the thing we started with
+            return orig_obj
+    return obj
+
+def find_file(obj) -> Optional[str]:
+    """Find the absolute path to the file where an object was defined.
 
+    This is essentially a robust wrapper around `inspect.getabsfile`.
 
-def call_tip(oinfo, format_call=True):
-    """Extract call tip data from an oinfo dict.
+    Returns None if no file can be found.
 
     Parameters
     ----------
-    oinfo : dict
-
-    format_call : bool, optional
-      If True, the call line is formatted and returned as a string.  If not, a
-      tuple of (name, argspec) is returned.
+    obj : any Python object
 
     Returns
     -------
-    call_info : None, str or (str, dict) tuple.
-      When format_call is True, the whole call information is formattted as a
-      single string.  Otherwise, the object's name and its argspec dict are
-      returned.  If no call information is available, None is returned.
-      
-    docstring : str or None
-      The most relevant docstring for calling purposes is returned, if
-      available.  The priority is: call docstring for callable instances, then
-      constructor docstring for classes, then main object's docstring otherwise
-      (regular functions).
+    fname : str
+        The absolute path to the file where the object was defined.
     """
-    # Get call definition
-    argspec = oinfo['argspec']
-    if argspec is None:
-        call_line = None
-    else:
-        # Callable objects will have 'self' as their first argument, prune
-        # it out if it's there for clarity (since users do *not* pass an
-        # extra first argument explicitly).
+    obj = _get_wrapped(obj)
+
+    fname: Optional[str] = None
+    try:
+        fname = inspect.getabsfile(obj)
+    except TypeError:
+        # For an instance, the file that matters is where its class was
+        # declared.
         try:
-            has_self = argspec['args'][0] == 'self'
-        except (KeyError, IndexError):
+            fname = inspect.getabsfile(obj.__class__)
+        except (OSError, TypeError):
+            # Can happen for builtins
             pass
-        else:
-            if has_self:
-                argspec['args'] = argspec['args'][1:]
-                
-        call_line = oinfo['name']+format_argspec(argspec)
+    except OSError:
+        pass
 
-    # Now get docstring.
-    # The priority is: call docstring, constructor docstring, main one.
-    doc = oinfo['call_docstring']
-    if doc is None:
-        doc = oinfo['init_docstring']
-    if doc is None:
-        doc = oinfo['docstring']
+    return fname
 
-    return call_line, doc
 
-#****************************************************************************
-# Class definitions
-
-class myStringIO(StringIO.StringIO):
-    """Adds a writeln method to normal StringIO."""
-    def writeln(self,*arg,**kw):
-        """Does a write() and then a write('\n')"""
-        self.write(*arg,**kw)
-        self.write('\n')
-
-
-class Inspector:
-    def __init__(self, color_table=InspectColors,
-                 code_color_table=PyColorize.ANSICodeColors,
-                 scheme='NoColor',
-                 str_detail_level=0):
-        self.color_table = color_table
-        self.parser = PyColorize.Parser(code_color_table,out='str')
-        self.format = self.parser.format
+def find_source_lines(obj):
+    """Find the line number in a file where an object was defined.
+
+    This is essentially a robust wrapper around `inspect.getsourcelines`.
+
+    Returns None if no file can be found.
+
+    Parameters
+    ----------
+    obj : any Python object
+
+    Returns
+    -------
+    lineno : int
+        The line number where the object definition starts.
+    """
+    obj = _get_wrapped(obj)
+
+    try:
+        lineno = inspect.getsourcelines(obj)[1]
+    except TypeError:
+        # For instances, try the class object like getsource() does
+        try:
+            lineno = inspect.getsourcelines(obj.__class__)[1]
+        except (OSError, TypeError):
+            return None
+    except OSError:
+        return None
+
+    return lineno
+
+
+_sentinel = object()
+
+
+class Inspector(Configurable):
+    mime_hooks = traitlets.Dict(
+        config=True,
+        help="dictionary of mime to callable to add information into help mimebundle dict",
+    ).tag(config=True)
+
+    _theme_name: str
+
+    def __init__(
+        self,
+        *,
+        theme_name: str,
+        str_detail_level=0,
+        parent=None,
+        config=None,
+    ):
+        if theme_name in ["Linux", "LightBG", "Neutral", "NoColor"]:
+            warnings.warn(
+                f"Theme names and color schemes are lowercase in IPython 9.0 use {theme_name.lower()} instead",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            theme_name = theme_name.lower()
+        self._theme_name = theme_name
+        super(Inspector, self).__init__(parent=parent, config=config)
+        self.parser = PyColorize.Parser(out="str", theme_name=theme_name)
         self.str_detail_level = str_detail_level
-        self.set_active_scheme(scheme)
+        self.set_theme_name(theme_name)
+
+    def format(self, *args, **kwargs):
+        return self.parser.format(*args, **kwargs)
 
-    def _getdef(self,obj,oname=''):
-        """Return the definition header for any callable object.
+    def _getdef(self,obj,oname='') -> Union[str,None]:
+        """Return the call signature for any callable object.
 
         If any exception is generated, None is returned instead and the
         exception is suppressed."""
-        
+        if not callable(obj):
+            return None
         try:
-            # We need a plain string here, NOT unicode!
-            hdef = oname + inspect.formatargspec(*getargspec(obj))
-            return hdef.encode('ascii')
+            return _render_signature(signature(obj), oname)
         except:
             return None
- 
-    def __head(self,h):
+
+    def __head(self, h: str) -> str:
         """Return a header string with proper colors."""
-        return '%s%s%s' % (self.color_table.active_colors.header,h,
-                           self.color_table.active_colors.normal)
-
-    def set_active_scheme(self,scheme):
-        self.color_table.set_active_scheme(scheme)
-        self.parser.color_table.set_active_scheme(scheme)
-    
-    def noinfo(self,msg,oname):
+        return PyColorize.theme_table[self._theme_name].format([(Token.Header, h)])
+
+    def set_theme_name(self, name: str):
+        assert name == name.lower()
+        assert name in PyColorize.theme_table.keys()
+        self._theme_name = name
+        self.parser.theme_name = name
+
+    def set_active_scheme(self, scheme: str):
+        warnings.warn(
+            "set_active_scheme is deprecated and replaced by set_theme_name as of IPython 9.0",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        assert scheme == scheme.lower()
+        if scheme is not None and self._theme_name != scheme:
+            self._theme_name = scheme
+            self.parser.theme_name = scheme
+
+    def noinfo(self, msg, oname):
         """Generic message when no information is found."""
-        print 'No %s found' % msg,
+        print('No %s found' % msg, end=' ')
         if oname:
-            print 'for %s' % oname
+            print('for %s' % oname)
         else:
-            print
-            
-    def pdef(self,obj,oname=''):
-        """Print the definition header for any callable object.
+            print()
+
+    def pdef(self, obj, oname=''):
+        """Print the call signature for any callable object.
 
         If the object is a class, print the constructor information."""
 
         if not callable(obj):
-            print 'Object is not callable.'
+            print('Object is not callable.')
             return
 
         header = ''
 
         if inspect.isclass(obj):
             header = self.__head('Class constructor information:\n')
-            obj = obj.__init__
-        elif type(obj) is types.InstanceType:
-            obj = obj.__call__
+
 
         output = self._getdef(obj,oname)
         if output is None:
             self.noinfo('definition header',oname)
         else:
-            print >>io.stdout, header,self.format(output),
+            print(header,self.format(output), end=' ')
 
-    def pdoc(self,obj,oname='',formatter = None):
+    # In Python 3, all classes are new-style, so they all have __init__.
+    @skip_doctest
+    def pdoc(self, obj, oname='', formatter=None):
         """Print the docstring for any object.
 
         Optional:
         -formatter: a function to run the docstring through for specially
-        formatted docstrings."""
+        formatted docstrings.
+
+        Examples
+        --------
+        In [1]: class NoInit:
+           ...:     pass
+
+        In [2]: class NoDoc:
+           ...:     def __init__(self):
+           ...:         pass
+
+        In [3]: %pdoc NoDoc
+        No documentation found for NoDoc
+
+        In [4]: %pdoc NoInit
+        No documentation found for NoInit
+
+        In [5]: obj = NoInit()
+
+        In [6]: %pdoc obj
+        No documentation found for obj
+
+        In [5]: obj2 = NoDoc()
+
+        In [6]: %pdoc obj2
+        No documentation found for obj2
+        """
 
-        head = self.__head  # so that itpl can find it even if private
+        lines = []
         ds = getdoc(obj)
         if formatter:
-            ds = formatter(ds)
-        if inspect.isclass(obj):
+            ds = formatter(ds).get('plain/text', ds)
+        if ds:
+            lines.append(self.__head("Class docstring:"))
+            lines.append(indent(ds))
+        if inspect.isclass(obj) and hasattr(obj, '__init__'):
             init_ds = getdoc(obj.__init__)
-            output = itpl('$head("Class Docstring:")\n'
-                          '$indent(ds)\n'
-                          '$head("Constructor Docstring"):\n'
-                          '$indent(init_ds)')
-        elif (type(obj) is types.InstanceType or isinstance(obj,object)) \
-                 and hasattr(obj,'__call__'):
+            if init_ds is not None:
+                lines.append(self.__head("Init docstring:"))
+                lines.append(indent(init_ds))
+        elif hasattr(obj,'__call__'):
             call_ds = getdoc(obj.__call__)
             if call_ds:
-                output = itpl('$head("Class Docstring:")\n$indent(ds)\n'
-                              '$head("Calling Docstring:")\n$indent(call_ds)')
-            else:
-                output = ds
-        else:
-            output = ds
-        if output is None:
+                lines.append(self.__head("Call docstring:"))
+                lines.append(indent(call_ds))
+
+        if not lines:
             self.noinfo('documentation',oname)
-            return
-        page.page(output)
-    
-    def psource(self,obj,oname=''):
+        else:
+            page.page('\n'.join(lines))
+
+    def psource(self, obj, oname=''):
         """Print the source code for an object."""
 
         # Flush the source cache because inspect can return out-of-date source
         linecache.checkcache()
         try:
-            src = getsource(obj) 
-        except:
-            self.noinfo('source',oname)
+            src = getsource(obj, oname=oname)
+        except Exception:
+            src = None
+
+        if src is None:
+            self.noinfo('source', oname)
         else:
             page.page(self.format(src))
 
-    def pfile(self,obj,oname=''):
+    def pfile(self, obj, oname=''):
         """Show the whole file where an object was defined."""
 
-        try:
-            try:
-                lineno = inspect.getsourcelines(obj)[1]
-            except TypeError:
-                # For instances, try the class object like getsource() does
-                if hasattr(obj,'__class__'):
-                    lineno = inspect.getsourcelines(obj.__class__)[1]
-                    # Adjust the inspected object so getabsfile() below works
-                    obj = obj.__class__
-        except:
-            self.noinfo('file',oname)
+        lineno = find_source_lines(obj)
+        if lineno is None:
+            self.noinfo('file', oname)
             return
 
-        # We only reach this point if object was successfully queried
-        
-        # run contents of file through pager starting at line
-        # where the object is defined
-        ofile = inspect.getabsfile(obj)
-
-        if (ofile.endswith('.so') or ofile.endswith('.dll')):
-            print 'File %r is binary, not printing.' % ofile
+        ofile = find_file(obj)
+        # run contents of file through pager starting at line where the object
+        # is defined, as long as the file isn't binary and is actually on the
+        # filesystem.
+        if ofile is None:
+            print("Could not find file for object")
+        elif ofile.endswith((".so", ".dll", ".pyd")):
+            print("File %r is binary, not printing." % ofile)
         elif not os.path.isfile(ofile):
-            print 'File %r does not exist, not printing.' % ofile
+            print('File %r does not exist, not printing.' % ofile)
         else:
             # Print only text files, not extension binaries.  Note that
             # getsourcelines returns lineno with 1-offset and page() uses
             # 0-offset, so we must adjust.
-            page.page(self.format(open(ofile).read()),lineno-1)
-
-    def pinfo(self,obj,oname='',formatter=None,info=None,detail_level=0):
-        """Show detailed information about an object.
+            page.page(self.format(openpy.read_py_file(ofile, skip_encoding_cookie=False)), lineno - 1)
 
-        Optional arguments:
-        
-        - oname: name of the variable pointing to the object.
 
-        - formatter: special formatter for docstrings (see pdoc)
+    def _mime_format(self, text:str, formatter=None) -> dict:
+        """Return a mime bundle representation of the input text.
 
-        - info: a structure with some information fields which may have been
-        precomputed already.
+        - if `formatter` is None, the returned mime bundle has
+           a ``text/plain`` field, with the input text.
+           a ``text/html`` field with a ``<pre>`` tag containing the input text.
 
-        - detail_level: if set to 1, more information is given.
-        """
+        - if ``formatter`` is not None, it must be a callable transforming the
+          input text into a mime bundle. Default values for ``text/plain`` and
+          ``text/html`` representations are the ones described above.
 
-        obj_type = type(obj)
+        Note:
 
-        header = self.__head
-        if info is None:
-            ismagic = 0
-            isalias = 0
-            ospace = ''
-        else:
-            ismagic = info.ismagic
-            isalias = info.isalias
-            ospace = info.namespace
-        # Get docstring, special-casing aliases:
-        if isalias:
-            if not callable(obj):
-                try:
-                    ds = "Alias to the system command:\n  %s" % obj[1]
-                except:
-                    ds = "Alias: " + str(obj)
-            else:
-                ds = "Alias to " + str(obj)
-                if obj.__doc__:
-                    ds += "\nDocstring:\n" + obj.__doc__
-        else:
-            ds = getdoc(obj)
-            if ds is None:
-                ds = '<no docstring>'
-        if formatter is not None:
-            ds = formatter(ds)
+        Formatters returning strings are supported but this behavior is deprecated.
 
-        # store output in a list which gets joined with \n at the end.
-        out = myStringIO()
-        
-        string_max = 200 # max size of strings to show (snipped if longer)
-        shalf = int((string_max -5)/2)
+        """
+        defaults = {
+            "text/plain": text,
+            "text/html": f"<pre>{html.escape(text)}</pre>",
+        }
 
-        if ismagic:
-            obj_type_name = 'Magic function'
-        elif isalias:
-            obj_type_name = 'System alias'
+        if formatter is None:
+            return defaults
         else:
-            obj_type_name = obj_type.__name__
-        out.writeln(header('Type:\t\t')+obj_type_name)
-
-        try:
-            bclass = obj.__class__
-            out.writeln(header('Base Class:\t')+str(bclass))
-        except: pass
-
-        # String form, but snip if too long in ? form (full in ??)
-        if detail_level >= self.str_detail_level:
-            try:
-                ostr = str(obj)
-                str_head = 'String Form:'
-                if not detail_level and len(ostr)>string_max:
-                    ostr = ostr[:shalf] + ' <...> ' + ostr[-shalf:]
-                    ostr = ("\n" + " " * len(str_head.expandtabs())).\
-                            join(q.strip() for q in ostr.split("\n"))
-                if ostr.find('\n') > -1:
-                    # Print multi-line strings starting at the next line.
-                    str_sep = '\n'
-                else:
-                    str_sep = '\t'
-                out.writeln("%s%s%s" % (header(str_head),str_sep,ostr))
-            except:
-                pass
+            formatted = formatter(text)
 
-        if ospace:
-            out.writeln(header('Namespace:\t')+ospace)
+            if not isinstance(formatted, dict):
+                # Handle the deprecated behavior of a formatter returning
+                # a string instead of a mime bundle.
+                return {"text/plain": formatted, "text/html": f"<pre>{formatted}</pre>"}
 
-        # Length (for strings and lists)
-        try:
-            length = str(len(obj))
-            out.writeln(header('Length:\t\t')+length)
-        except: pass
-
-        # Filename where object was defined
-        binary_file = False
-        try:
-            try:
-                fname = inspect.getabsfile(obj)
-            except TypeError:
-                # For an instance, the file that matters is where its class was
-                # declared.
-                if hasattr(obj,'__class__'):
-                    fname = inspect.getabsfile(obj.__class__)
-            if fname.endswith('<string>'):
-                fname = 'Dynamically generated function. No source code available.'
-            if (fname.endswith('.so') or fname.endswith('.dll')):
-                binary_file = True
-            out.writeln(header('File:\t\t')+fname)
-        except:
-            # if anything goes wrong, we don't want to show source, so it's as
-            # if the file was binary
-            binary_file = True
+            else:
+                return dict(defaults, **formatted)
+
+    def format_mime(self, bundle: UnformattedBundle) -> Bundle:
+        """Format a mimebundle being created by _make_info_unformatted into a real mimebundle"""
+        # Format text/plain mimetype
+        assert isinstance(bundle["text/plain"], list)
+        for item in bundle["text/plain"]:
+            assert isinstance(item, tuple)
+
+        new_b: Bundle = {}
+        lines = []
+        _len = max(len(h) for h, _ in bundle["text/plain"])
+
+        for head, body in bundle["text/plain"]:
+            body = body.strip("\n")
+            delim = "\n" if "\n" in body else " "
+            lines.append(
+                f"{self.__head(head+':')}{(_len - len(head))*' '}{delim}{body}"
+            )
+
+        new_b["text/plain"] = "\n".join(lines)
+
+        if "text/html" in bundle:
+            assert isinstance(bundle["text/html"], list)
+            for item in bundle["text/html"]:
+                assert isinstance(item, tuple)
+            # Format the text/html mimetype
+            if isinstance(bundle["text/html"], (list, tuple)):
+                # bundle['text/html'] is a list of (head, formatted body) pairs
+                new_b["text/html"] = "\n".join(
+                    f"<h1>{head}</h1>\n{body}" for (head, body) in bundle["text/html"]
+                )
+
+        for k in bundle.keys():
+            if k in ("text/html", "text/plain"):
+                continue
+            else:
+                new_b[k] = bundle[k]  # type:ignore
+        return new_b
+
+    def _append_info_field(
+        self,
+        bundle: UnformattedBundle,
+        title: str,
+        key: str,
+        info,
+        omit_sections: List[str],
+        formatter,
+    ):
+        """Append an info value to the unformatted mimebundle being constructed by _make_info_unformatted"""
+        if title in omit_sections or key in omit_sections:
+            return
+        field = info[key]
+        if field is not None:
+            formatted_field = self._mime_format(field, formatter)
+            bundle["text/plain"].append((title, formatted_field["text/plain"]))
+            bundle["text/html"].append((title, formatted_field["text/html"]))
+
+    def _make_info_unformatted(
+        self, obj, info, formatter, detail_level, omit_sections
+    ) -> UnformattedBundle:
+        """Assemble the mimebundle as unformatted lists of information"""
+        bundle: UnformattedBundle = {
+            "text/plain": [],
+            "text/html": [],
+        }
+
+        # A convenience function to simplify calls below
+        def append_field(
+            bundle: UnformattedBundle, title: str, key: str, formatter=None
+        ):
+            self._append_info_field(
+                bundle,
+                title=title,
+                key=key,
+                info=info,
+                omit_sections=omit_sections,
+                formatter=formatter,
+            )
+
+        def code_formatter(text) -> Bundle:
+            return {
+                'text/plain': self.format(text),
+                'text/html': pylight(text)
+            }
+
+        if info["isalias"]:
+            append_field(bundle, "Repr", "string_form")
+
+        elif info['ismagic']:
+            if detail_level > 0:
+                append_field(bundle, "Source", "source", code_formatter)
+            else:
+                append_field(bundle, "Docstring", "docstring", formatter)
+            append_field(bundle, "File", "file")
+
+        elif info['isclass'] or is_simple_callable(obj):
+            # Functions, methods, classes
+            append_field(bundle, "Signature", "definition", code_formatter)
+            append_field(bundle, "Init signature", "init_definition", code_formatter)
+            append_field(bundle, "Docstring", "docstring", formatter)
+            if detail_level > 0 and info["source"]:
+                append_field(bundle, "Source", "source", code_formatter)
+            else:
+                append_field(bundle, "Init docstring", "init_docstring", formatter)
 
-        # reconstruct the function definition and print it:
-        defln = self._getdef(obj,oname)
-        if defln:
-            out.write(header('Definition:\t')+self.format(defln))
- 
-        # Docstrings only in detail 0 mode, since source contains them (we
-        # avoid repetitions).  If source fails, we add them back, see below.
-        if ds and detail_level == 0:
-                out.writeln(header('Docstring:\n') + indent(ds))
-                
-        # Original source code for any callable
-        if detail_level:
-            # Flush the source cache because inspect can return out-of-date
-            # source
-            linecache.checkcache()
-            source_success = False
-            try:
-                try:
-                    src = getsource(obj,binary_file)
-                except TypeError:
-                    if hasattr(obj,'__class__'):
-                        src = getsource(obj.__class__,binary_file)
-                if src is not None:
-                    source = self.format(src)
-                    out.write(header('Source:\n')+source.rstrip()+'\n')
-                    source_success = True
-            except Exception, msg:
-                pass
-            
-            if ds and not source_success:
-                out.writeln(header('Docstring [source file open failed]:\n')
-                            + indent(ds))
+            append_field(bundle, "File", "file")
+            append_field(bundle, "Type", "type_name")
+            append_field(bundle, "Subclasses", "subclasses")
 
-        # Constructor docstring for classes
-        if inspect.isclass(obj):
-            # reconstruct the function definition and print it:
-            try:
-                obj_init =  obj.__init__
-            except AttributeError:
-                init_def = init_ds = None
+        else:
+            # General Python objects
+            append_field(bundle, "Signature", "definition", code_formatter)
+            append_field(bundle, "Call signature", "call_def", code_formatter)
+            append_field(bundle, "Type", "type_name")
+            append_field(bundle, "String form", "string_form")
+
+            # Namespace
+            if info["namespace"] != "Interactive":
+                append_field(bundle, "Namespace", "namespace")
+
+            append_field(bundle, "Length", "length")
+            append_field(bundle, "File", "file")
+
+            # Source or docstring, depending on detail level and whether
+            # source found.
+            if detail_level > 0 and info["source"]:
+                append_field(bundle, "Source", "source", code_formatter)
             else:
-                init_def = self._getdef(obj_init,oname)
-                init_ds  = getdoc(obj_init)
-                # Skip Python's auto-generated docstrings
-                if init_ds and \
-                       init_ds.startswith('x.__init__(...) initializes'):
-                    init_ds = None
-
-            if init_def or init_ds:
-                out.writeln(header('Constructor information:'))
-                if init_def:
-                    out.write(header('Definition:\t')+ self.format(init_def))
-                if init_ds:
-                    out.writeln(header('Docstring:\n') + indent(init_ds))
-        # and class docstring for instances:
-        elif obj_type is types.InstanceType or \
-                 isinstance(obj,object):
+                append_field(bundle, "Docstring", "docstring", formatter)
+
+            append_field(bundle, "Class docstring", "class_docstring", formatter)
+            append_field(bundle, "Init docstring", "init_docstring", formatter)
+            append_field(bundle, "Call docstring", "call_docstring", formatter)
+        return bundle
+
+
+    def _get_info(
+        self,
+        obj: Any,
+        oname: str = "",
+        formatter=None,
+        info: Optional[OInfo] = None,
+        detail_level: int = 0,
+        omit_sections: Union[List[str], Tuple[()]] = (),
+    ) -> Bundle:
+        """Retrieve an info dict and format it.
+
+        Parameters
+        ----------
+        obj : any
+            Object to inspect and return info from
+        oname : str (default: ''):
+            Name of the variable pointing to `obj`.
+        formatter : callable
+        info
+            already computed information
+        detail_level : integer
+            Granularity of detail level, if set to 1, give more information.
+        omit_sections : list[str]
+            Titles or keys to omit from output (can be set, tuple, etc., anything supporting `in`)
+        """
 
-            # First, check whether the instance docstring is identical to the
-            # class one, and print it separately if they don't coincide.  In
-            # most cases they will, but it's nice to print all the info for
-            # objects which use instance-customized docstrings.
-            if ds:
-                try:
-                    cls = getattr(obj,'__class__')
-                except:
-                    class_ds = None
+        info_dict = self.info(obj, oname=oname, info=info, detail_level=detail_level)
+        omit_sections = list(omit_sections)
+
+        bundle = self._make_info_unformatted(
+            obj,
+            info_dict,
+            formatter,
+            detail_level=detail_level,
+            omit_sections=omit_sections,
+        )
+        if self.mime_hooks:
+            hook_data = InspectorHookData(
+                obj=obj,
+                info=info,
+                info_dict=info_dict,
+                detail_level=detail_level,
+                omit_sections=omit_sections,
+            )
+            for key, hook in self.mime_hooks.items():  # type:ignore
+                required_parameters = [
+                    parameter
+                    for parameter in inspect.signature(hook).parameters.values()
+                    if parameter.default != inspect.Parameter.default
+                ]
+                if len(required_parameters) == 1:
+                    res = hook(hook_data)
                 else:
-                    class_ds = getdoc(cls)
-                # Skip Python's auto-generated docstrings
-                if class_ds and \
-                       (class_ds.startswith('function(code, globals[,') or \
-                   class_ds.startswith('instancemethod(function, instance,') or \
-                   class_ds.startswith('module(name[,') ):
-                    class_ds = None
-                if class_ds and ds != class_ds:
-                    out.writeln(header('Class Docstring:\n') +
-                                indent(class_ds))
-
-            # Next, try to show constructor docstrings
-            try:
-                init_ds = getdoc(obj.__init__)
-                # Skip Python's auto-generated docstrings
-                if init_ds and \
-                       init_ds.startswith('x.__init__(...) initializes'):
-                    init_ds = None
-            except AttributeError:
-                init_ds = None
-            if init_ds:
-                out.writeln(header('Constructor Docstring:\n') +
-                            indent(init_ds))
+                    warnings.warn(
+                        "MIME hook format changed in IPython 8.22; hooks should now accept"
+                        " a single parameter (InspectorHookData); support for hooks requiring"
+                        " two-parameters (obj and info) will be removed in a future version",
+                        DeprecationWarning,
+                        stacklevel=2,
+                    )
+                    res = hook(obj, info)
+                if res is not None:
+                    bundle[key] = res
+        return self.format_mime(bundle)
+
+    def pinfo(
+        self,
+        obj,
+        oname="",
+        formatter=None,
+        info: Optional[OInfo] = None,
+        detail_level=0,
+        enable_html_pager=True,
+        omit_sections=(),
+    ):
+        """Show detailed information about an object.
 
-            # Call form docstring for callable instances
-            if hasattr(obj,'__call__'):
-                #out.writeln(header('Callable:\t')+'Yes')
-                call_def = self._getdef(obj.__call__,oname)
-                #if call_def is None:
-                #    out.writeln(header('Call def:\t')+
-                #              'Calling definition not available.')
-                if call_def is not None:
-                    out.writeln(header('Call def:\t')+self.format(call_def))
-                call_ds = getdoc(obj.__call__)
-                # Skip Python's auto-generated docstrings
-                if call_ds and call_ds.startswith('x.__call__(...) <==> x(...)'):
-                    call_ds = None
-                if call_ds:
-                    out.writeln(header('Call docstring:\n') + indent(call_ds))
+        Optional arguments:
 
-        # Finally send to printer/pager
-        output = out.getvalue()
-        if output:
-            page.page(output)
-        # end pinfo
+        - oname: name of the variable pointing to the object.
 
-    def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
-        """Compute a dict with detailed information about an object.
+        - formatter: callable (optional)
+              A special formatter for docstrings.
 
-        Optional arguments:
-        
-        - oname: name of the variable pointing to the object.
+              The formatter is a callable that takes a string as an input
+              and returns either a formatted string or a mime type bundle
+              in the form of a dictionary.
 
-        - formatter: special formatter for docstrings (see pdoc)
+              Although the support of custom formatter returning a string
+              instead of a mime type bundle is deprecated.
 
         - info: a structure with some information fields which may have been
-        precomputed already.
+          precomputed already.
 
         - detail_level: if set to 1, more information is given.
+
+        - omit_sections: set of section keys and titles to omit
         """
+        assert info is not None
+        info_b: Bundle = self._get_info(
+            obj, oname, formatter, info, detail_level, omit_sections=omit_sections
+        )
+        if not enable_html_pager:
+            del info_b["text/html"]
+        page.page(info_b)
+
+    def info(self, obj, oname="", info=None, detail_level=0) -> InfoDict:
+        """Compute a dict with detailed information about an object.
 
-        obj_type = type(obj)
+        Parameters
+        ----------
+        obj : any
+            An object to find information about
+        oname : str (default: '')
+            Name of the variable pointing to `obj`.
+        info : (default: None)
+            A struct (dict like with attr access) with some information fields
+            which may have been precomputed already.
+        detail_level : int (default:0)
+            If set to 1, more information is given.
+
+        Returns
+        -------
+        An object info dict with known fields from `info_fields` (see `InfoDict`).
+        """
 
-        header = self.__head
         if info is None:
-            ismagic = 0
-            isalias = 0
+            ismagic = False
+            isalias = False
             ospace = ''
         else:
             ismagic = info.ismagic
@@ -630,7 +881,29 @@ def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
             ospace = info.namespace
 
         # Get docstring, special-casing aliases:
-        if isalias:
+        att_name = oname.split(".")[-1]
+        parents_docs = None
+        prelude = ""
+        if info and info.parent is not None and hasattr(info.parent, HOOK_NAME):
+            parents_docs_dict = getattr(info.parent, HOOK_NAME)
+            parents_docs = parents_docs_dict.get(att_name, None)
+        out: InfoDict = cast(
+            InfoDict,
+            {
+                **{field: None for field in _info_fields},
+                **{
+                    "name": oname,
+                    "found": True,
+                    "isalias": isalias,
+                    "ismagic": ismagic,
+                    "subclasses": None,
+                },
+            },
+        )
+
+        if parents_docs:
+            ds = parents_docs
+        elif isalias:
             if not callable(obj):
                 try:
                     ds = "Alias to the system command:\n  %s" % obj[1]
@@ -641,46 +914,44 @@ def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
                 if obj.__doc__:
                     ds += "\nDocstring:\n" + obj.__doc__
         else:
-            ds = getdoc(obj)
-            if ds is None:
+            ds_or_None = getdoc(obj)
+            if ds_or_None is None:
                 ds = '<no docstring>'
-        if formatter is not None:
-            ds = formatter(ds)
+            else:
+                ds = ds_or_None
+
+        ds = prelude + ds
 
         # store output in a dict, we initialize it here and fill it as we go
-        out = dict(name=oname, found=True, isalias=isalias, ismagic=ismagic)
-        
+
         string_max = 200 # max size of strings to show (snipped if longer)
-        shalf = int((string_max -5)/2)
+        shalf = int((string_max - 5) / 2)
 
         if ismagic:
-            obj_type_name = 'Magic function'
+            out['type_name'] = 'Magic function'
         elif isalias:
-            obj_type_name = 'System alias'
+            out['type_name'] = 'System alias'
         else:
-            obj_type_name = obj_type.__name__
-        out['type_name'] = obj_type_name
+            out['type_name'] = type(obj).__name__
 
         try:
             bclass = obj.__class__
             out['base_class'] = str(bclass)
-        except: pass
+        except:
+            pass
 
         # String form, but snip if too long in ? form (full in ??)
         if detail_level >= self.str_detail_level:
             try:
                 ostr = str(obj)
-                str_head = 'string_form'
-                if not detail_level and len(ostr)>string_max:
+                if not detail_level and len(ostr) > string_max:
                     ostr = ostr[:shalf] + ' <...> ' + ostr[-shalf:]
-                    ostr = ("\n" + " " * len(str_head.expandtabs())).\
-                            join(q.strip() for q in ostr.split("\n"))
-                if ostr.find('\n') > -1:
-                    # Print multi-line strings starting at the next line.
-                    str_sep = '\n'
-                else:
-                    str_sep = '\t'
-                out[str_head] = ostr
+                    # TODO: `'string_form'.expandtabs()` seems wrong, but
+                    # it was (nearly) like this since the first commit ever.
+                    ostr = ("\n" + " " * len("string_form".expandtabs())).join(
+                        q.strip() for q in ostr.split("\n")
+                    )
+                out["string_form"] = ostr
             except:
                 pass
 
@@ -690,81 +961,89 @@ def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
         # Length (for strings and lists)
         try:
             out['length'] = str(len(obj))
-        except: pass
+        except Exception:
+            pass
 
         # Filename where object was defined
         binary_file = False
-        try:
-            try:
-                fname = inspect.getabsfile(obj)
-            except TypeError:
-                # For an instance, the file that matters is where its class was
-                # declared.
-                if hasattr(obj,'__class__'):
-                    fname = inspect.getabsfile(obj.__class__)
-            if fname.endswith('<string>'):
-                fname = 'Dynamically generated function. No source code available.'
-            if (fname.endswith('.so') or fname.endswith('.dll')):
-                binary_file = True
-            out['file'] = fname
-        except:
+        fname = find_file(obj)
+        if fname is None:
             # if anything goes wrong, we don't want to show source, so it's as
             # if the file was binary
             binary_file = True
+        else:
+            if fname.endswith(('.so', '.dll', '.pyd')):
+                binary_file = True
+            elif fname.endswith('<string>'):
+                fname = 'Dynamically generated function. No source code available.'
+            out['file'] = compress_user(fname)
 
-        # reconstruct the function definition and print it:
-        defln = self._getdef(obj, oname)
-        if defln:
-            out['definition'] = self.format(defln)
-
-        # Docstrings only in detail 0 mode, since source contains them (we
-        # avoid repetitions).  If source fails, we add them back, see below.
-        if ds and detail_level == 0:
-                out['docstring'] = ds
-                
-        # Original source code for any callable
+        # Original source code for a callable, class or property.
         if detail_level:
             # Flush the source cache because inspect can return out-of-date
             # source
             linecache.checkcache()
-            source_success = False
             try:
-                try:
-                    src = getsource(obj,binary_file)
-                except TypeError:
-                    if hasattr(obj,'__class__'):
-                        src = getsource(obj.__class__,binary_file)
-                if src is not None:
-                    source = self.format(src)
-                    out['source'] = source.rstrip()
-                    source_success = True
-            except Exception, msg:
+                if isinstance(obj, property) or not binary_file:
+                    src = getsource(obj, oname)
+                    if src is not None:
+                        src = src.rstrip()
+                    out['source'] = src
+
+            except Exception:
                 pass
 
+        # Add docstring only if no source is to be shown (avoid repetitions).
+        if ds and not self._source_contains_docstring(out.get('source'), ds):
+            out['docstring'] = ds
+
         # Constructor docstring for classes
         if inspect.isclass(obj):
-            # reconstruct the function definition and print it:
+            out['isclass'] = True
+
+            # get the init signature:
             try:
-                obj_init =  obj.__init__
+                init_def = self._getdef(obj, oname)
             except AttributeError:
-                init_def = init_ds = None
+                init_def = None
+
+            # get the __init__ docstring
+            try:
+                obj_init = obj.__init__
+            except AttributeError:
+                init_ds = None
             else:
-                init_def = self._getdef(obj_init,oname)
-                init_ds  = getdoc(obj_init)
+                if init_def is None:
+                    # Get signature from init if top-level sig failed.
+                    # Can happen for built-in types (list, etc.).
+                    try:
+                        init_def = self._getdef(obj_init, oname)
+                    except AttributeError:
+                        pass
+                init_ds = getdoc(obj_init)
                 # Skip Python's auto-generated docstrings
-                if init_ds and \
-                       init_ds.startswith('x.__init__(...) initializes'):
+                if init_ds == _object_init_docstring:
                     init_ds = None
 
-            if init_def or init_ds:
-                if init_def:
-                    out['init_definition'] = self.format(init_def)
-                if init_ds:
-                    out['init_docstring'] = init_ds
+            if init_def:
+                out['init_definition'] = init_def
 
+            if init_ds:
+                out['init_docstring'] = init_ds
+
+            names = [sub.__name__ for sub in type.__subclasses__(obj)]
+            if len(names) < 10:
+                all_names = ', '.join(names)
+            else:
+                all_names = ', '.join(names[:10]+['...'])
+            out['subclasses'] = all_names
         # and class docstring for instances:
-        elif obj_type is types.InstanceType or \
-                 isinstance(obj, object):
+        else:
+            # reconstruct the function definition and print it:
+            defln = self._getdef(obj, oname)
+            if defln:
+                out['definition'] = defln
+
             # First, check whether the instance docstring is identical to the
             # class one, and print it separately if they don't coincide.  In
             # most cases they will, but it's nice to print all the info for
@@ -777,10 +1056,7 @@ def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
                 else:
                     class_ds = getdoc(cls)
                 # Skip Python's auto-generated docstrings
-                if class_ds and \
-                       (class_ds.startswith('function(code, globals[,') or \
-                   class_ds.startswith('instancemethod(function, instance,') or \
-                   class_ds.startswith('module(name[,') ):
+                if class_ds in _builtin_type_docstrings:
                     class_ds = None
                 if class_ds and ds != class_ds:
                     out['class_docstring'] = class_ds
@@ -789,8 +1065,7 @@ def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
             try:
                 init_ds = getdoc(obj.__init__)
                 # Skip Python's auto-generated docstrings
-                if init_ds and \
-                       init_ds.startswith('x.__init__(...) initializes'):
+                if init_ds == _object_init_docstring:
                     init_ds = None
             except AttributeError:
                 init_ds = None
@@ -798,68 +1073,72 @@ def info(self, obj, oname='', formatter=None, info=None, detail_level=0):
                 out['init_docstring'] = init_ds
 
             # Call form docstring for callable instances
-            if hasattr(obj, '__call__'):
+            if safe_hasattr(obj, '__call__') and not is_simple_callable(obj):
                 call_def = self._getdef(obj.__call__, oname)
-                if call_def is not None:
-                    out['call_def'] = self.format(call_def)
+                if call_def and (call_def != out.get('definition')):
+                    # it may never be the case that call def and definition differ,
+                    # but don't include the same signature twice
+                    out['call_def'] = call_def
                 call_ds = getdoc(obj.__call__)
                 # Skip Python's auto-generated docstrings
-                if call_ds and call_ds.startswith('x.__call__(...) <==> x(...)'):
+                if call_ds == _func_call_docstring:
                     call_ds = None
                 if call_ds:
                     out['call_docstring'] = call_ds
 
-        # Compute the object's argspec as a callable.  The key is to decide
-        # whether to pull it from the object itself, from its __init__ or
-        # from its __call__ method.
-        
-        if inspect.isclass(obj):
-            callable_obj = obj.__init__
-        elif callable(obj):
-            callable_obj = obj
-        else:
-            callable_obj = None
+        return out
 
-        if callable_obj:
-            try:
-                args,  varargs, varkw, defaults = getargspec(callable_obj)
-            except (TypeError, AttributeError):
-                # For extensions/builtins we can't retrieve the argspec
-                pass
-            else:
-                out['argspec'] = dict(args=args, varargs=varargs,
-                                      varkw=varkw, defaults=defaults)
-
-        return object_info(**out)
+    @staticmethod
+    def _source_contains_docstring(src, doc):
+        """
+        Check whether the source *src* contains the docstring *doc*.
 
+        This is is helper function to skip displaying the docstring if the
+        source already contains it, avoiding repetition of information.
+        """
+        try:
+            (def_node,) = ast.parse(dedent(src)).body
+            return ast.get_docstring(def_node) == doc  # type: ignore[arg-type]
+        except Exception:
+            # The source can become invalid or even non-existent (because it
+            # is re-fetched from the source file) so the above code fail in
+            # arbitrary ways.
+            return False
 
     def psearch(self,pattern,ns_table,ns_search=[],
-                ignore_case=False,show_all=False):
+                ignore_case=False,show_all=False, *, list_types=False):
         """Search namespaces with wildcards for objects.
 
         Arguments:
 
         - pattern: string containing shell-like wildcards to use in namespace
-        searches and optionally a type specification to narrow the search to
-        objects of that type.
+          searches and optionally a type specification to narrow the search to
+          objects of that type.
 
         - ns_table: dict of name->namespaces for search.
 
         Optional arguments:
-        
+
           - ns_search: list of namespace names to include in search.
 
           - ignore_case(False): make the search case-insensitive.
 
           - show_all(False): show all names, including those starting with
-          underscores.
+            underscores.
+
+          - list_types(False): list all available object types for object matching.
         """
-        #print 'ps pattern:<%r>' % pattern # dbg
-        
+        # print('ps pattern:<%r>' % pattern)  # dbg
+
         # defaults
         type_pattern = 'all'
         filter = ''
 
+        # list all object types
+        if list_types:
+            page.page('\n'.join(sorted(typestr2type)))
+            return
+
         cmds = pattern.split()
         len_cmds  =  len(cmds)
         if len_cmds == 1:
@@ -878,14 +1157,59 @@ def psearch(self,pattern,ns_table,ns_search=[],
                 raise ValueError('invalid namespace <%s>. Valid names: %s' %
                                  (name,ns_table.keys()))
 
-        #print 'type_pattern:',type_pattern # dbg
-        search_result = []
+        # print('type_pattern:',type_pattern)  # dbg
+        search_result, namespaces_seen = set(), set()
         for ns_name in ns_search:
             ns = ns_table[ns_name]
-            tmp_res = list(list_namespace(ns,type_pattern,filter,
-                                          ignore_case=ignore_case,
-                                          show_all=show_all))
-            search_result.extend(tmp_res)
-        search_result.sort()
+            # Normally, locals and globals are the same, so we just check one.
+            if id(ns) in namespaces_seen:
+                continue
+            namespaces_seen.add(id(ns))
+            tmp_res = list_namespace(ns, type_pattern, filter,
+                                    ignore_case=ignore_case, show_all=show_all)
+            search_result.update(tmp_res)
+
+        page.page('\n'.join(sorted(search_result)))
+
+
+def _render_signature(obj_signature, obj_name) -> str:
+    """
+    This was mostly taken from inspect.Signature.__str__.
+    Look there for the comments.
+    The only change is to add linebreaks when this gets too long.
+    """
+    result = []
+    pos_only = False
+    kw_only = True
+    for param in obj_signature.parameters.values():
+        if param.kind == inspect.Parameter.POSITIONAL_ONLY:
+            pos_only = True
+        elif pos_only:
+            result.append('/')
+            pos_only = False
+
+        if param.kind == inspect.Parameter.VAR_POSITIONAL:
+            kw_only = False
+        elif param.kind == inspect.Parameter.KEYWORD_ONLY and kw_only:
+            result.append('*')
+            kw_only = False
+
+        result.append(str(param))
+
+    if pos_only:
+        result.append('/')
+
+    # add up name, parameters, braces (2), and commas
+    if len(obj_name) + sum(len(r) + 2 for r in result) > 75:
+        # This doesn’t fit behind “Signature: � in an inspect window.
+        rendered = '{}(\n{})'.format(obj_name, ''.join(
+            '    {},\n'.format(r) for r in result)
+        )
+    else:
+        rendered = '{}({})'.format(obj_name, ', '.join(result))
+
+    if obj_signature.return_annotation is not inspect._empty:
+        anno = inspect.formatannotation(obj_signature.return_annotation)
+        rendered += ' -> {}'.format(anno)
 
-        page.page('\n'.join(search_result))
+    return rendered
diff --git a/IPython/core/page.py b/IPython/core/page.py
old mode 100755
new mode 100644
index a140d6236dc..2eb6c399b36
--- a/IPython/core/page.py
+++ b/IPython/core/page.py
@@ -1,49 +1,56 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """
 Paging capabilities for IPython.core
 
-Authors:
-
-* Brian Granger
-* Fernando Perez
-
 Notes
 -----
 
-For now this uses ipapi, so it can't be in IPython.utils.  If we can get
+For now this uses IPython hooks, so it can't be in IPython.utils.  If we can get
 rid of that dependency, we could move it there.
 -----
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 
 import os
+import io
 import re
 import sys
 import tempfile
+import subprocess
 
-from IPython.core import ipapi
+from io import UnsupportedOperation
+from pathlib import Path
+
+from IPython import get_ipython
+from IPython.display import display
 from IPython.core.error import TryNext
-from IPython.utils.cursesimport import use_curses
 from IPython.utils.data import chop
-from IPython.utils import io
 from IPython.utils.process import system
 from IPython.utils.terminal import get_terminal_size
+from IPython.utils import py3compat
+
+
+def display_page(strng, start=0, screen_lines=25):
+    """Just display, no paging. screen_lines is ignored."""
+    if isinstance(strng, dict):
+        data = strng
+    else:
+        if start:
+            strng = u'\n'.join(strng.splitlines()[start:])
+        data = { 'text/plain': strng }
+    display(data, raw=True)
 
 
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
+def as_hook(page_func):
+    """Wrap a pager func to strip the `self` arg
+
+    so it can be called as a hook.
+    """
+    return lambda self, *args, **kwargs: page_func(*args, **kwargs)
+
 
 esc_re = re.compile(r"(\x1b[^m]+m)")
 
@@ -51,27 +58,78 @@ def page_dumb(strng, start=0, screen_lines=25):
     """Very dumb 'pager' in Python, for when nothing else works.
 
     Only moves forward, same interface as page(), except for pager_cmd and
-    mode."""
-
+    mode.
+    """
+    if isinstance(strng, dict):
+        strng = strng.get('text/plain', '')
     out_ln  = strng.splitlines()[start:]
     screens = chop(out_ln,screen_lines-1)
     if len(screens) == 1:
-        print >>io.stdout, os.linesep.join(screens[0])
+        print(os.linesep.join(screens[0]))
     else:
         last_escape = ""
         for scr in screens[0:-1]:
             hunk = os.linesep.join(scr)
-            print >>io.stdout, last_escape + hunk
+            print(last_escape + hunk)
             if not page_more():
                 return
             esc_list = esc_re.findall(hunk)
             if len(esc_list) > 0:
                 last_escape = esc_list[-1]
-        print >>io.stdout, last_escape + os.linesep.join(screens[-1])
+        print(last_escape + os.linesep.join(screens[-1]))
+
+def _detect_screen_size(screen_lines_def):
+    """Attempt to work out the number of lines on the screen.
 
+    This is called by page(). It can raise an error (e.g. when run in the
+    test suite), so it's separated out so it can easily be called in a try block.
+    """
+    TERM = os.environ.get('TERM',None)
+    if not((TERM=='xterm' or TERM=='xterm-color') and sys.platform != 'sunos5'):
+        # curses causes problems on many terminals other than xterm, and
+        # some termios calls lock up on Sun OS5.
+        return screen_lines_def
+    
+    try:
+        import termios
+        import curses
+    except ImportError:
+        return screen_lines_def
+    
+    # There is a bug in curses, where *sometimes* it fails to properly
+    # initialize, and then after the endwin() call is made, the
+    # terminal is left in an unusable state.  Rather than trying to
+    # check every time for this (by requesting and comparing termios
+    # flags each time), we just save the initial terminal state and
+    # unconditionally reset it every time.  It's cheaper than making
+    # the checks.
+    try:
+        term_flags = termios.tcgetattr(sys.stdout)
+    except termios.error as err:
+        # can fail on Linux 2.6, pager_page will catch the TypeError
+        raise TypeError('termios error: {0}'.format(err)) from err
 
-def page(strng, start=0, screen_lines=0, pager_cmd=None):
-    """Print a string, piping through a pager after a certain length.
+    try:
+        scr = curses.initscr()
+    except AttributeError:
+        # Curses on Solaris may not be complete, so we can't use it there
+        return screen_lines_def
+    
+    screen_lines_real,screen_cols = scr.getmaxyx()
+    curses.endwin()
+
+    # Restore terminal state in case endwin() didn't.
+    termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
+    # Now we have what we needed: the screen size in rows/columns
+    return screen_lines_real
+    # print('***Screen size:',screen_lines_real,'lines x',
+    #       screen_cols,'columns.')  # dbg
+
+def pager_page(strng, start=0, screen_lines=0, pager_cmd=None) -> None:
+    """Display a string, piping through a pager after a certain length.
+
+    strng can be a mime-bundle dict, supplying multiple representations,
+    keyed by mime-type.
 
     The screen_lines parameter specifies the number of *usable* lines of your
     terminal screen (total lines minus lines you need to reserve to show other
@@ -90,24 +148,15 @@ def page(strng, start=0, screen_lines=0, pager_cmd=None):
     If no system pager works, the string is sent through a 'dumb pager'
     written in python, very simplistic.
     """
-
-    # Some routines may auto-compute start offsets incorrectly and pass a
-    # negative value.  Offset to 0 for robustness.
-    start = max(0, start)
-
-    # first, try the hook
-    ip = ipapi.get()
-    if ip:
-        try:
-            ip.hooks.show_in_pager(strng)
-            return
-        except TryNext:
-            pass
+    
+    # for compatibility with mime-bundle form:
+    if isinstance(strng, dict):
+        strng = strng['text/plain']
 
     # Ugly kludge, but calling curses.initscr() flat out crashes in emacs
     TERM = os.environ.get('TERM','dumb')
     if TERM in ['dumb','emacs'] and os.name != 'nt':
-        print strng
+        print(strng)
         return
     # chop off the topmost part of the string we don't want to see
     str_lines = strng.splitlines()[start:]
@@ -124,59 +173,16 @@ def page(strng, start=0, screen_lines=0, pager_cmd=None):
 
     # auto-determine screen size
     if screen_lines <= 0:
-        if (TERM=='xterm' or TERM=='xterm-color') and sys.platform != 'sunos5':
-            local_use_curses = use_curses
-        else:
-            # curses causes problems on many terminals other than xterm, and
-            # some termios calls lock up on Sun OS5.
-            local_use_curses = False
-        if local_use_curses:
-            import termios
-            import curses
-            # There is a bug in curses, where *sometimes* it fails to properly
-            # initialize, and then after the endwin() call is made, the
-            # terminal is left in an unusable state.  Rather than trying to
-            # check everytime for this (by requesting and comparing termios
-            # flags each time), we just save the initial terminal state and
-            # unconditionally reset it every time.  It's cheaper than making
-            # the checks.
-            term_flags = termios.tcgetattr(sys.stdout)
-
-            # Curses modifies the stdout buffer size by default, which messes
-            # up Python's normal stdout buffering.  This would manifest itself
-            # to IPython users as delayed printing on stdout after having used
-            # the pager.
-            #
-            # We can prevent this by manually setting the NCURSES_NO_SETBUF
-            # environment variable.  For more details, see:
-            # http://bugs.python.org/issue10144
-            NCURSES_NO_SETBUF = os.environ.get('NCURSES_NO_SETBUF', None)
-            os.environ['NCURSES_NO_SETBUF'] = ''
-            
-            # Proceed with curses initialization
-            scr = curses.initscr()
-            screen_lines_real,screen_cols = scr.getmaxyx()
-            curses.endwin()
-
-            # Restore environment
-            if NCURSES_NO_SETBUF is None:
-                del os.environ['NCURSES_NO_SETBUF']
-            else:
-                os.environ['NCURSES_NO_SETBUF'] = NCURSES_NO_SETBUF
-                
-            # Restore terminal state in case endwin() didn't.
-            termios.tcsetattr(sys.stdout,termios.TCSANOW,term_flags)
-            # Now we have what we needed: the screen size in rows/columns
-            screen_lines += screen_lines_real
-            #print '***Screen size:',screen_lines_real,'lines x',\
-            #screen_cols,'columns.' # dbg
-        else:
-            screen_lines += screen_lines_def
+        try:
+            screen_lines += _detect_screen_size(screen_lines_def)
+        except (TypeError, UnsupportedOperation):
+            print(str_toprint)
+            return
 
-    #print 'numlines',numlines,'screenlines',screen_lines  # dbg
+    # print('numlines',numlines,'screenlines',screen_lines)  # dbg
     if numlines <= screen_lines :
-        #print '*** normal print'  # dbg
-        print >>io.stdout, str_toprint
+        # print('*** normal print')  # dbg
+        print(str_toprint)
     else:
         # Try to open pager and default to internal one if that fails.
         # All failure modes are tagged as 'retval=1', to match the return
@@ -189,27 +195,40 @@ def page(strng, start=0, screen_lines=0, pager_cmd=None):
                 # The default WinXP 'type' command is failing on complex strings.
                 retval = 1
             else:
-                tmpname = tempfile.mktemp('.txt')
-                tmpfile = file(tmpname,'wt')
-                tmpfile.write(strng)
-                tmpfile.close()
-                cmd = "%s < %s" % (pager_cmd,tmpname)
-                if os.system(cmd):
-                  retval = 1
-                else:
-                  retval = None
-                os.remove(tmpname)
+                fd, tmpname = tempfile.mkstemp('.txt')
+                tmppath = Path(tmpname)
+                try:
+                    os.close(fd)
+                    with tmppath.open("wt", encoding="utf-8") as tmpfile:
+                        tmpfile.write(strng)
+                        cmd = "%s < %s" % (pager_cmd, tmppath)
+                    # tmpfile needs to be closed for windows
+                    if os.system(cmd):
+                        retval = 1
+                    else:
+                        retval = None
+                finally:
+                    Path.unlink(tmppath)
         else:
             try:
                 retval = None
-                # if I use popen4, things hang. No idea why.
-                #pager,shell_out = os.popen4(pager_cmd)
-                pager = os.popen(pager_cmd,'w')
-                pager.write(strng)
-                pager.close()
-                retval = pager.close()  # success returns None
-            except IOError,msg:  # broken pipe when user quits
-                if msg.args == (32,'Broken pipe'):
+                # Emulate os.popen, but redirect stderr
+                proc = subprocess.Popen(
+                    pager_cmd,
+                    shell=True,
+                    stdin=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                )
+                pager = os._wrap_close(
+                    io.TextIOWrapper(proc.stdin, encoding="utf-8"), proc
+                )
+                try:
+                    pager_encoding = pager.encoding or sys.stdout.encoding
+                    pager.write(strng)
+                finally:
+                    retval = pager.close()
+            except IOError as msg:  # broken pipe when user quits
+                if msg.args == (32, 'Broken pipe'):
                     retval = None
                 else:
                     retval = 1
@@ -220,6 +239,32 @@ def page(strng, start=0, screen_lines=0, pager_cmd=None):
             page_dumb(strng,screen_lines=screen_lines)
 
 
+def page(data, start: int = 0, screen_lines: int = 0, pager_cmd=None):
+    """Display content in a pager, piping through a pager after a certain length.
+
+    data can be a mime-bundle dict, supplying multiple representations,
+    keyed by mime-type, or text.
+
+    Pager is dispatched via the `show_in_pager` IPython hook.
+    If no hook is registered, `pager_page` will be used.
+    """
+    # Some routines may auto-compute start offsets incorrectly and pass a
+    # negative value.  Offset to 0 for robustness.
+    start = max(0, start)
+
+    # first, try the hook
+    ip = get_ipython()
+    if ip:
+        try:
+            ip.hooks.show_in_pager(data, start=start, screen_lines=screen_lines)
+            return
+        except TryNext:
+            pass
+    
+    # fallback on default pager
+    return pager_page(data, start, screen_lines, pager_cmd)
+
+
 def page_file(fname, start=0, pager_cmd=None):
     """Page a file, using an optional pager command and starting line.
     """
@@ -235,9 +280,9 @@ def page_file(fname, start=0, pager_cmd=None):
         try:
             if start > 0:
                 start -= 1
-            page(open(fname).read(),start)
+            page(open(fname, encoding="utf-8").read(), start)
         except:
-            print 'Unable to show file',`fname`
+            print('Unable to show file',repr(fname))
 
 
 def get_pager_cmd(pager_cmd=None):
@@ -246,7 +291,7 @@ def get_pager_cmd(pager_cmd=None):
     Makes some attempts at finding an OS-correct one.
     """
     if os.name == 'posix':
-        default_pager_cmd = 'less -r'  # -r for color control sequences
+        default_pager_cmd = 'less -R'  # -R for color control sequences
     elif os.name in ['nt','dos']:
         default_pager_cmd = 'type'
 
@@ -255,6 +300,10 @@ def get_pager_cmd(pager_cmd=None):
             pager_cmd = os.environ['PAGER']
         except:
             pager_cmd = default_pager_cmd
+    
+    if pager_cmd == 'less' and '-r' not in os.environ.get('LESS', '').lower():
+        pager_cmd += ' -R'
+    
     return pager_cmd
 
 
@@ -282,46 +331,18 @@ def page_more():
 
         @return:    True if need print more lines, False if quit
         """
-        io.stdout.write('---Return to continue, q to quit--- ')
-        ans = msvcrt.getch()
+        sys.stdout.write('---Return to continue, q to quit--- ')
+        ans = msvcrt.getwch()
         if ans in ("q", "Q"):
             result = False
         else:
             result = True
-        io.stdout.write("\b"*37 + " "*37 + "\b"*37)
+        sys.stdout.write("\b"*37 + " "*37 + "\b"*37)
         return result
 else:
     def page_more():
-        ans = raw_input('---Return to continue, q to quit--- ')
+        ans = py3compat.input('---Return to continue, q to quit--- ')
         if ans.lower().startswith('q'):
             return False
         else:
             return True
-
-
-def snip_print(str,width = 75,print_full = 0,header = ''):
-    """Print a string snipping the midsection to fit in width.
-
-    print_full: mode control:
-      - 0: only snip long strings
-      - 1: send to page() directly.
-      - 2: snip long strings and ask for full length viewing with page()
-    Return 1 if snipping was necessary, 0 otherwise."""
-
-    if print_full == 1:
-        page(header+str)
-        return 0
-
-    print header,
-    if len(str) < width:
-        print str
-        snip = 0
-    else:
-        whalf = int((width -5)/2)
-        print str[:whalf] + ' <...> ' + str[-whalf:]
-        snip = 1
-    if snip and print_full == 2:
-        if raw_input(header+' Snipped. View (y/n)? [N]').lower() == 'y':
-            page(str)
-    return snip
-
diff --git a/IPython/core/payload.py b/IPython/core/payload.py
index 9fd90f983fb..28eb7c80d31 100644
--- a/IPython/core/payload.py
+++ b/IPython/core/payload.py
@@ -8,7 +8,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#       Copyright (C) 2008-2010 The IPython Development Team
+#       Copyright (C) 2008-2011 The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -18,20 +18,33 @@
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import List
+from traitlets.config.configurable import Configurable
+from traitlets import List
 
 #-----------------------------------------------------------------------------
 # Main payload class
 #-----------------------------------------------------------------------------
 
 class PayloadManager(Configurable):
+    _payload: List = List([])
 
-    _payload = List([])
+    def write_payload(self, data, single=True):
+        """Include or update the specified `data` payload in the PayloadManager.
+
+        If a previous payload with the same source exists and `single` is True,
+        it will be overwritten with the new one.
+        """
 
-    def write_payload(self, data):
         if not isinstance(data, dict):
             raise TypeError('Each payload write must be a dict, got: %r' % data)
+
+        if single and 'source' in data:
+            source = data['source']
+            for i, pl in enumerate(self._payload):
+                if 'source' in pl and pl['source'] == source:
+                    self._payload[i] = data
+                    return
+
         self._payload.append(data)
 
     def read_payload(self):
diff --git a/IPython/core/payloadpage.py b/IPython/core/payloadpage.py
old mode 100755
new mode 100644
index 363eddb24fc..9ba4157cec8
--- a/IPython/core/payloadpage.py
+++ b/IPython/core/payloadpage.py
@@ -1,42 +1,16 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A payload based version of page.
+"""A payload based version of page."""
 
-Authors:
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-* Brian Granger
-* Fernando Perez
-"""
+import warnings
+from IPython.core.getipython import get_ipython
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# see https://github.com/ipython/ipykernel/issues/1304
+# this should be moved to ipykernel and removed in the long run.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
 
-# Third-party
-try:
-    from docutils.core import publish_string
-except ImportError:
-    # html paging won't be available, but we don't raise any errors.  It's a
-    # purely optional feature.
-    pass
-
-# Our own
-from IPython.core.interactiveshell import InteractiveShell
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-def page(strng, start=0, screen_lines=0, pager_cmd=None,
-         html=None, auto_html=False):
+def page(strng, start=0, screen_lines=0, pager_cmd=None):
     """Print a string, piping through a pager.
 
     This version ignores the screen_lines and pager_cmd arguments and uses
@@ -44,54 +18,24 @@ def page(strng, start=0, screen_lines=0, pager_cmd=None,
 
     Parameters
     ----------
-    strng : str
-      Text to page.
-
+    strng : str or mime-dict
+        Text to page, or a mime-type keyed dict of already formatted data.
     start : int
-      Starting line at which to place the display.
-    
-    html : str, optional
-      If given, an html string to send as well.
-
-    auto_html : bool, optional
-      If true, the input string is assumed to be valid reStructuredText and is
-      converted to HTML with docutils.  Note that if docutils is not found,
-      this option is silently ignored.
-
-    Note
-    ----
-
-    Only one of the ``html`` and ``auto_html`` options can be given, not
-    both.
+        Starting line at which to place the display.
     """
 
     # Some routines may auto-compute start offsets incorrectly and pass a
     # negative value.  Offset to 0 for robustness.
     start = max(0, start)
-    shell = InteractiveShell.instance()
+    shell = get_ipython()
 
-    if auto_html:
-        try:
-            # These defaults ensure user configuration variables for docutils
-            # are not loaded, only our config is used here.
-            defaults = {'file_insertion_enabled': 0,
-                        'raw_enabled': 0,
-                        '_disable_config': 1}
-            html = publish_string(strng, writer_name='html',
-                                  settings_overrides=defaults)
-        except:
-            pass
-        
+    if isinstance(strng, dict):
+        data = strng
+    else:
+        data = {"text/plain": strng}
     payload = dict(
-        source='IPython.zmq.page.page',
-        text=strng,
-        html=html,
-        start_line_number=start
-        )
+        source="page",
+        data=data,
+        start=start,
+    )
     shell.payload_manager.write_payload(payload)
-
-
-def install_payload_page():
-    """Install this version of page as IPython.core.page.page."""
-    from IPython.core import page as corepage
-    corepage.page = page
diff --git a/IPython/core/plugin.py b/IPython/core/plugin.py
deleted file mode 100644
index ee12abe7a39..00000000000
--- a/IPython/core/plugin.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# encoding: utf-8
-"""IPython plugins.
-
-Authors:
-
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import Dict
-
-#-----------------------------------------------------------------------------
-# Main class
-#-----------------------------------------------------------------------------
-
-class PluginManager(Configurable):
-    """A manager for IPython plugins."""
-
-    plugins = Dict({})
-
-    def __init__(self, config=None):
-        super(PluginManager, self).__init__(config=config)
-
-    def register_plugin(self, name, plugin):
-        if not isinstance(plugin, Plugin):
-            raise TypeError('Expected Plugin, got: %r' % plugin)
-        if self.plugins.has_key(name):
-            raise KeyError('Plugin with name already exists: %r' % name)
-        self.plugins[name] = plugin
-
-    def unregister_plugin(self, name):
-        del self.plugins[name]
-
-    def get_plugin(self, name, default=None):
-        return self.plugins.get(name, default)
-
-
-class Plugin(Configurable):
-    """Base class for IPython plugins."""
-    pass
diff --git a/IPython/core/prefilter.py b/IPython/core/prefilter.py
old mode 100755
new mode 100644
index 859ccca6cb0..36aa376ad35
--- a/IPython/core/prefilter.py
+++ b/IPython/core/prefilter.py
@@ -1,72 +1,49 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """
 Prefiltering components.
 
 Prefilters transform user input before it is exec'd by Python.  These
 transforms are used to implement additional syntax such as !ls and %magic.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
-* Dan Milstein
-* Ville Vainio
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import __builtin__
-import codeop
+from keyword import iskeyword
 import re
 
-from IPython.core.alias import AliasManager
-from IPython.core.autocall import IPyAutocall
-from IPython.config.configurable import Configurable
-from IPython.core.macro import Macro
-from IPython.core.splitinput import split_user_input
-from IPython.core import page
-
-from IPython.utils.traitlets import List, Int, Any, Str, CBool, Bool, Instance
-from IPython.utils.text import make_quoted_expr
-from IPython.utils.autoattr import auto_attr
+from .autocall import IPyAutocall
+from traitlets.config.configurable import Configurable
+from .inputtransformer2 import (
+    ESC_MAGIC,
+    ESC_QUOTE,
+    ESC_QUOTE2,
+    ESC_PAREN,
+)
+from .macro import Macro
+from .splitinput import LineInfo
+
+from traitlets import (
+    List, Integer, Unicode, Bool, Instance, CRegExp
+)
 
 #-----------------------------------------------------------------------------
 # Global utilities, errors and constants
 #-----------------------------------------------------------------------------
 
-# Warning, these cannot be changed unless various regular expressions
-# are updated in a number of places.  Not great, but at least we told you.
-ESC_SHELL  = '!'
-ESC_SH_CAP = '!!'
-ESC_HELP   = '?'
-ESC_MAGIC  = '%'
-ESC_QUOTE  = ','
-ESC_QUOTE2 = ';'
-ESC_PAREN  = '/'
-
 
 class PrefilterError(Exception):
     pass
 
 
 # RegExp to identify potential function names
-re_fun_name = re.compile(r'[a-zA-Z_]([a-zA-Z0-9_.]*) *$')
+re_fun_name = re.compile(r'[^\W\d]([\w.]*) *$')
 
 # RegExp to exclude strings with this start from autocalling.  In
 # particular, all binary operators should be excluded, so that if foo is
 # callable, foo OP bar doesn't become foo(OP bar), which is invalid.  The
 # characters '!=()' don't need to be checked for, as the checkPythonChars
-# routine explicitely does so, to catch direct calls and rebindings of
+# routine explicitly does so, to catch direct calls and rebindings of
 # existing names.
 
 # Warning: the '-' HAS TO BE AT THE END of the first group, otherwise
@@ -88,80 +65,9 @@ def is_shadowed(identifier, ip):
     than ifun, because it can not contain a '.' character."""
     # This is much safer than calling ofind, which can change state
     return (identifier in ip.user_ns \
-            or identifier in ip.internal_ns \
-            or identifier in ip.ns_table['builtin'])
-
-
-#-----------------------------------------------------------------------------
-# The LineInfo class used throughout
-#-----------------------------------------------------------------------------
-
-
-class LineInfo(object):
-    """A single line of input and associated info.
-
-    Includes the following as properties: 
-
-    line
-      The original, raw line
-    
-    continue_prompt
-      Is this line a continuation in a sequence of multiline input?
-    
-    pre
-      The initial esc character or whitespace.
-    
-    pre_char
-      The escape character(s) in pre or the empty string if there isn't one.
-      Note that '!!' is a possible value for pre_char.  Otherwise it will
-      always be a single character.
-    
-    pre_whitespace
-      The leading whitespace from pre if it exists.  If there is a pre_char,
-      this is just ''.
-    
-    ifun
-      The 'function part', which is basically the maximal initial sequence
-      of valid python identifiers and the '.' character.  This is what is
-      checked for alias and magic transformations, used for auto-calling,
-      etc.
-    
-    the_rest
-      Everything else on the line.
-    """
-    def __init__(self, line, continue_prompt):
-        self.line            = line
-        self.continue_prompt = continue_prompt
-        self.pre, self.ifun, self.the_rest = split_user_input(line)
-
-        self.pre_char       = self.pre.strip()
-        if self.pre_char:
-            self.pre_whitespace = '' # No whitespace allowd before esc chars
-        else: 
-            self.pre_whitespace = self.pre
-
-        self._oinfo = None
-
-    def ofind(self, ip):
-        """Do a full, attribute-walking lookup of the ifun in the various
-        namespaces for the given IPython InteractiveShell instance.
-
-        Return a dict with keys: found,obj,ospace,ismagic
-
-        Note: can cause state changes because of calling getattr, but should
-        only be run if autocall is on and if the line hasn't matched any
-        other, less dangerous handlers.
-
-        Does cache the results of the call, so can be called multiple times
-        without worrying about *further* damaging state.
-        """
-        if not self._oinfo:
-            # ip.shell._ofind is actually on the Magic class!
-            self._oinfo = ip.shell._ofind(self.ifun)
-        return self._oinfo
-
-    def __str__(self):                                                         
-        return "Lineinfo [%s|%s|%s]" %(self.pre, self.ifun, self.the_rest) 
+            or identifier in ip.user_global_ns \
+            or identifier in ip.ns_table['builtin']\
+            or iskeyword(identifier))
 
 
 #-----------------------------------------------------------------------------
@@ -173,10 +79,10 @@ class PrefilterManager(Configurable):
     """Main prefilter component.
 
     The IPython prefilter is run on all user input before it is run.  The
-    prefilter consumes lines of input and produces transformed lines of 
+    prefilter consumes lines of input and produces transformed lines of
     input.
 
-    The iplementation consists of two phases:
+    The implementation consists of two phases:
 
     1. Transformers
     2. Checkers and handlers
@@ -187,17 +93,16 @@ class PrefilterManager(Configurable):
     The transformers are instances of :class:`PrefilterTransformer` and have
     a single method :meth:`transform` that takes a line and returns a
     transformed line.  The transformation can be accomplished using any
-    tool, but our current ones use regular expressions for speed.  We also
-    ship :mod:`pyparsing` in :mod:`IPython.external` for use in transformers.
+    tool, but our current ones use regular expressions for speed.
 
     After all the transformers have been run, the line is fed to the checkers,
     which are instances of :class:`PrefilterChecker`.  The line is passed to
-    the :meth:`check` method, which either returns `None` or a 
+    the :meth:`check` method, which either returns `None` or a
     :class:`PrefilterHandler` instance.  If `None` is returned, the other
     checkers are tried.  If an :class:`PrefilterHandler` instance is returned,
     the line is passed to the :meth:`handle` method of the returned
     handler and no further checkers are tried.
-    
+
     Both transformers and checkers have a `priority` attribute, that determines
     the order in which they are called.  Smaller priorities are tried first.
 
@@ -209,13 +114,13 @@ class PrefilterManager(Configurable):
     or :meth:`sort_transformers` method after changing the priority.
     """
 
-    multi_line_specials = CBool(True, config=True)
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
+    multi_line_specials = Bool(True).tag(config=True)
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
 
-    def __init__(self, shell=None, config=None):
-        super(PrefilterManager, self).__init__(shell=shell, config=config)
+    def __init__(self, shell=None, **kwargs):
+        super(PrefilterManager, self).__init__(shell=shell, **kwargs)
         self.shell = shell
-        self.init_transformers()
+        self._transformers = []
         self.init_handlers()
         self.init_checkers()
 
@@ -223,14 +128,6 @@ def __init__(self, shell=None, config=None):
     # API for managing transformers
     #-------------------------------------------------------------------------
 
-    def init_transformers(self):
-        """Create the default transformers."""
-        self._transformers = []
-        for transformer_cls in _default_transformers:
-            transformer_cls(
-                shell=self.shell, prefilter_manager=self, config=self.config
-            )
-
     def sort_transformers(self):
         """Sort the transformers by priority.
 
@@ -264,7 +161,7 @@ def init_checkers(self):
         self._checkers = []
         for checker in _default_checkers:
             checker(
-                shell=self.shell, prefilter_manager=self, config=self.config
+                shell=self.shell, prefilter_manager=self, parent=self
             )
 
     def sort_checkers(self):
@@ -292,7 +189,7 @@ def unregister_checker(self, checker):
             self._checkers.remove(checker)
 
     #-------------------------------------------------------------------------
-    # API for managing checkers
+    # API for managing handlers
     #-------------------------------------------------------------------------
 
     def init_handlers(self):
@@ -301,7 +198,7 @@ def init_handlers(self):
         self._esc_handlers = {}
         for handler in _default_handlers:
             handler(
-                shell=self.shell, prefilter_manager=self, config=self.config
+                shell=self.shell, prefilter_manager=self, parent=self
             )
 
     @property
@@ -343,7 +240,7 @@ def prefilter_line_info(self, line_info):
 
         This implements the checker/handler part of the prefilter pipe.
         """
-        # print "prefilter_line_info: ", line_info
+        # print("prefilter_line_info: ", line_info)
         handler = self.find_handler(line_info)
         return handler.handle(line_info)
 
@@ -370,7 +267,7 @@ def prefilter_line(self, line, continue_prompt=False):
         transformers and then the checkers/handlers.
         """
 
-        # print "prefilter_line: ", line, continue_prompt
+        # print("prefilter_line: ", line, continue_prompt)
         # All handlers *must* return a value, even if it's blank ('').
 
         # save the line away in case we crash, so the post-mortem handler can
@@ -390,15 +287,12 @@ def prefilter_line(self, line, continue_prompt=False):
 
         # Now we compute line_info for the checkers and handlers
         line_info = LineInfo(line, continue_prompt)
-        
+
         # the input history needs to track even empty lines
         stripped = line.strip()
 
         normal_handler = self.get_handler_by_name('normal')
         if not stripped:
-            if not continue_prompt:
-                self.shell.displayhook.prompt_count -= 1
-
             return normal_handler.handle(line_info)
 
         # special handlers are only allowed for single line statements
@@ -406,7 +300,7 @@ def prefilter_line(self, line, continue_prompt=False):
             return normal_handler.handle(line_info)
 
         prefiltered = self.prefilter_line_info(line_info)
-        # print "prefiltered line: %r" % prefiltered
+        # print("prefiltered line: %r" % prefiltered)
         return prefiltered
 
     def prefilter_lines(self, lines, continue_prompt=False):
@@ -431,7 +325,7 @@ def prefilter_lines(self, lines, continue_prompt=False):
                              for lnum, line in enumerate(llines) ])
         else:
             out = self.prefilter_line(llines[0], continue_prompt)
-            
+
         return out
 
 #-----------------------------------------------------------------------------
@@ -442,16 +336,16 @@ def prefilter_lines(self, lines, continue_prompt=False):
 class PrefilterTransformer(Configurable):
     """Transform a line of user input."""
 
-    priority = Int(100, config=True)
+    priority = Integer(100).tag(config=True)
     # Transformers don't currently use shell or prefilter_manager, but as we
     # move away from checkers and handlers, they will need them.
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
-    enabled = Bool(True, config=True)
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
+    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)
+    enabled = Bool(True).tag(config=True)
 
-    def __init__(self, shell=None, prefilter_manager=None, config=None):
+    def __init__(self, shell=None, prefilter_manager=None, **kwargs):
         super(PrefilterTransformer, self).__init__(
-            shell=shell, prefilter_manager=prefilter_manager, config=config
+            shell=shell, prefilter_manager=prefilter_manager, **kwargs
         )
         self.prefilter_manager.register_transformer(self)
 
@@ -464,86 +358,6 @@ def __repr__(self):
             self.__class__.__name__, self.priority, self.enabled)
 
 
-_assign_system_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
-                               r'\s*=\s*!(?P<cmd>.*)')
-
-
-class AssignSystemTransformer(PrefilterTransformer):
-    """Handle the `files = !ls` syntax."""
-
-    priority = Int(100, config=True)
-
-    def transform(self, line, continue_prompt):
-        m = _assign_system_re.match(line)
-        if m is not None:
-            cmd = m.group('cmd')
-            lhs = m.group('lhs')
-            expr = make_quoted_expr("sc =%s" % cmd)
-            new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
-            return new_line
-        return line
-
-
-_assign_magic_re = re.compile(r'(?P<lhs>(\s*)([\w\.]+)((\s*,\s*[\w\.]+)*))'
-                               r'\s*=\s*%(?P<cmd>.*)')
-
-class AssignMagicTransformer(PrefilterTransformer):
-    """Handle the `a = %who` syntax."""
-
-    priority = Int(200, config=True)
-
-    def transform(self, line, continue_prompt):
-        m = _assign_magic_re.match(line)
-        if m is not None:
-            cmd = m.group('cmd')
-            lhs = m.group('lhs')
-            expr = make_quoted_expr(cmd)
-            new_line = '%s = get_ipython().magic(%s)' % (lhs, expr)
-            return new_line
-        return line
-
-
-_classic_prompt_re = re.compile(r'(^[ \t]*>>> |^[ \t]*\.\.\. )')
-
-class PyPromptTransformer(PrefilterTransformer):
-    """Handle inputs that start with '>>> ' syntax."""
-
-    priority = Int(50, config=True)
-
-    def transform(self, line, continue_prompt):
-
-        if not line or line.isspace() or line.strip() == '...':
-            # This allows us to recognize multiple input prompts separated by
-            # blank lines and pasted in a single chunk, very common when
-            # pasting doctests or long tutorial passages.
-            return ''
-        m = _classic_prompt_re.match(line)
-        if m:
-            return line[len(m.group(0)):]
-        else:
-            return line
-
-
-_ipy_prompt_re = re.compile(r'(^[ \t]*In \[\d+\]: |^[ \t]*\ \ \ \.\.\.+: )')
-
-class IPyPromptTransformer(PrefilterTransformer):
-    """Handle inputs that start classic IPython prompt syntax."""
-
-    priority = Int(50, config=True)
-
-    def transform(self, line, continue_prompt):
-
-        if not line or line.isspace() or line.strip() == '...':
-            # This allows us to recognize multiple input prompts separated by
-            # blank lines and pasted in a single chunk, very common when
-            # pasting doctests or long tutorial passages.
-            return ''
-        m = _ipy_prompt_re.match(line)
-        if m:
-            return line[len(m.group(0)):]
-        else:
-            return line
-
 #-----------------------------------------------------------------------------
 # Prefilter checkers
 #-----------------------------------------------------------------------------
@@ -552,14 +366,14 @@ def transform(self, line, continue_prompt):
 class PrefilterChecker(Configurable):
     """Inspect an input line and return a handler for that line."""
 
-    priority = Int(100, config=True)
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
-    enabled = Bool(True, config=True)
+    priority = Integer(100).tag(config=True)
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
+    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager', allow_none=True)
+    enabled = Bool(True).tag(config=True)
 
-    def __init__(self, shell=None, prefilter_manager=None, config=None):
+    def __init__(self, shell=None, prefilter_manager=None, **kwargs):
         super(PrefilterChecker, self).__init__(
-            shell=shell, prefilter_manager=prefilter_manager, config=config
+            shell=shell, prefilter_manager=prefilter_manager, **kwargs
         )
         self.prefilter_manager.register_checker(self)
 
@@ -574,8 +388,8 @@ def __repr__(self):
 
 class EmacsChecker(PrefilterChecker):
 
-    priority = Int(100, config=True)
-    enabled = Bool(False, config=True)
+    priority = Integer(100).tag(config=True)
+    enabled = Bool(False).tag(config=True)
 
     def check(self, line_info):
         "Emacs ipython-mode tags certain input lines."
@@ -585,19 +399,10 @@ def check(self, line_info):
             return None
 
 
-class ShellEscapeChecker(PrefilterChecker):
-
-    priority = Int(200, config=True)
-
-    def check(self, line_info):
-        if line_info.line.lstrip().startswith(ESC_SHELL):
-            return self.prefilter_manager.get_handler_by_name('shell')
+class MacroChecker(PrefilterChecker):
 
+    priority = Integer(250).tag(config=True)
 
-class MacroChecker(PrefilterChecker):
-    
-    priority = Int(250, config=True)
-    
     def check(self, line_info):
         obj = self.shell.user_ns.get(line_info.ifun)
         if isinstance(obj, Macro):
@@ -608,7 +413,7 @@ def check(self, line_info):
 
 class IPyAutocallChecker(PrefilterChecker):
 
-    priority = Int(300, config=True)
+    priority = Integer(300).tag(config=True)
 
     def check(self, line_info):
         "Instances of IPyAutocall in user_ns get autocalled immediately"
@@ -620,49 +425,14 @@ def check(self, line_info):
             return None
 
 
-class MultiLineMagicChecker(PrefilterChecker):
-
-    priority = Int(400, config=True)
-
-    def check(self, line_info):
-        "Allow ! and !! in multi-line statements if multi_line_specials is on"
-        # Note that this one of the only places we check the first character of
-        # ifun and *not* the pre_char.  Also note that the below test matches
-        # both ! and !!.    
-        if line_info.continue_prompt \
-            and self.prefilter_manager.multi_line_specials:
-                if line_info.ifun.startswith(ESC_MAGIC):
-                    return self.prefilter_manager.get_handler_by_name('magic')
-        else:
-            return None
-
-
-class EscCharsChecker(PrefilterChecker):
-
-    priority = Int(500, config=True)
-
-    def check(self, line_info):
-        """Check for escape character and return either a handler to handle it,
-        or None if there is no escape char."""
-        if line_info.line[-1] == ESC_HELP \
-               and line_info.pre_char != ESC_SHELL \
-               and line_info.pre_char != ESC_SH_CAP:
-            # the ? can be at the end, but *not* for either kind of shell escape,
-            # because a ? can be a vaild final char in a shell cmd
-            return self.prefilter_manager.get_handler_by_name('help')
-        else:
-            # This returns None like it should if no handler exists
-            return self.prefilter_manager.get_handler_by_esc(line_info.pre_char)
-
-
 class AssignmentChecker(PrefilterChecker):
 
-    priority = Int(600, config=True)
+    priority = Integer(600).tag(config=True)
 
     def check(self, line_info):
         """Check to see if user is assigning to a var for the first time, in
         which case we want to avoid any sort of automagic / autocall games.
-    
+
         This allows users to assign to either alias or magic names true python
         variables (the magic/alias systems always take second seat to true
         python code).  E.g. ls='hi', or ls,that=1,2"""
@@ -675,7 +445,7 @@ def check(self, line_info):
 
 class AutoMagicChecker(PrefilterChecker):
 
-    priority = Int(700, config=True)
+    priority = Integer(700).tag(config=True)
 
     def check(self, line_info):
         """If the ifun is magic, and automagic is on, run it.  Note: normal,
@@ -683,7 +453,7 @@ def check(self, line_info):
         check_esc_chars. This just checks for automagic.  Also, before
         triggering the magic handler, make sure that there is nothing in the
         user namespace which could shadow it."""
-        if not self.shell.automagic or not hasattr(self.shell,'magic_'+line_info.ifun):
+        if not self.shell.automagic or not self.shell.find_magic(line_info.ifun):
             return None
 
         # We have a likely magic method.  Make sure we should actually call it.
@@ -697,54 +467,57 @@ def check(self, line_info):
         return self.prefilter_manager.get_handler_by_name('magic')
 
 
-class AliasChecker(PrefilterChecker):
-
-    priority = Int(800, config=True)
-
-    def check(self, line_info):
-        "Check if the initital identifier on the line is an alias."
-        # Note: aliases can not contain '.'
-        head = line_info.ifun.split('.',1)[0]
-        if line_info.ifun not in self.shell.alias_manager \
-               or head not in self.shell.alias_manager \
-               or is_shadowed(head, self.shell):
-            return None
-
-        return self.prefilter_manager.get_handler_by_name('alias')
-
-
 class PythonOpsChecker(PrefilterChecker):
 
-    priority = Int(900, config=True)
+    priority = Integer(900).tag(config=True)
 
     def check(self, line_info):
         """If the 'rest' of the line begins with a function call or pretty much
         any python operator, we should simply execute the line (regardless of
         whether or not there's a possible autocall expansion).  This avoids
         spurious (and very confusing) geattr() accesses."""
-        if line_info.the_rest and line_info.the_rest[0] in '!=()<>,+*/%^&|':
-            return self.prefilter_manager.get_handler_by_name('normal')
+        if line_info.the_rest and line_info.the_rest[0] in "!=()<>,+*/%^&|":
+            return self.prefilter_manager.get_handler_by_name("normal")
         else:
             return None
 
 
 class AutocallChecker(PrefilterChecker):
 
-    priority = Int(1000, config=True)
+    priority = Integer(1000).tag(config=True)
+
+    function_name_regexp = CRegExp(re_fun_name,
+        help="RegExp to identify potential function names."
+        ).tag(config=True)
+    exclude_regexp = CRegExp(re_exclude_auto,
+        help="RegExp to exclude strings with this start from autocalling."
+        ).tag(config=True)
 
     def check(self, line_info):
         "Check if the initial word/function is callable and autocall is on."
         if not self.shell.autocall:
             return None
 
-        oinfo = line_info.ofind(self.shell) # This can mutate state via getattr
-        if not oinfo['found']:
+        oinfo = self.shell._ofind(line_info.ifun)  # This can mutate state via getattr
+        if not oinfo.found:
             return None
-        
-        if callable(oinfo['obj']) \
-               and (not re_exclude_auto.match(line_info.the_rest)) \
-               and re_fun_name.match(line_info.ifun):
-            return self.prefilter_manager.get_handler_by_name('auto')
+
+        ignored_funs = ['b', 'f', 'r', 'u', 'br', 'rb', 'fr', 'rf']
+        ifun = line_info.ifun
+        line = line_info.line
+        if ifun.lower() in ignored_funs and (line.startswith(ifun + "'") or line.startswith(ifun + '"')):
+            return None
+
+        if (
+            callable(oinfo.obj)
+            and (not self.exclude_regexp.match(line_info.the_rest))
+            and self.function_name_regexp.match(line_info.ifun)
+            and (
+                line_info.raw_the_rest.startswith(" ")
+                or not line_info.raw_the_rest.strip()
+            )
+        ):
+            return self.prefilter_manager.get_handler_by_name("auto")
         else:
             return None
 
@@ -755,15 +528,18 @@ def check(self, line_info):
 
 
 class PrefilterHandler(Configurable):
-
-    handler_name = Str('normal')
-    esc_strings = List([])
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-    prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
-
-    def __init__(self, shell=None, prefilter_manager=None, config=None):
+    handler_name = Unicode("normal")
+    esc_strings: List = List([])
+    shell = Instance(
+        "IPython.core.interactiveshell.InteractiveShellABC", allow_none=True
+    )
+    prefilter_manager = Instance(
+        "IPython.core.prefilter.PrefilterManager", allow_none=True
+    )
+
+    def __init__(self, shell=None, prefilter_manager=None, **kwargs):
         super(PrefilterHandler, self).__init__(
-            shell=shell, prefilter_manager=prefilter_manager, config=config
+            shell=shell, prefilter_manager=prefilter_manager, **kwargs
         )
         self.prefilter_manager.register_handler(
             self.handler_name,
@@ -772,7 +548,7 @@ def __init__(self, shell=None, prefilter_manager=None, config=None):
         )
 
     def handle(self, line_info):
-        # print "normal: ", line_info
+        # print("normal: ", line_info)
         """Handle normal input lines. Use as a template for handlers."""
 
         # With autoindent on, we need some way to exit the input loop, and I
@@ -795,52 +571,9 @@ def __str__(self):
         return "<%s(name=%s)>" % (self.__class__.__name__, self.handler_name)
 
 
-class AliasHandler(PrefilterHandler):
-
-    handler_name = Str('alias')
-
-    def handle(self, line_info):
-        """Handle alias input lines. """
-        transformed = self.shell.alias_manager.expand_aliases(line_info.ifun,line_info.the_rest)
-        # pre is needed, because it carries the leading whitespace.  Otherwise
-        # aliases won't work in indented sections.
-        line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
-                                         make_quoted_expr(transformed))
-        
-        return line_out
-
-
-class ShellEscapeHandler(PrefilterHandler):
-
-    handler_name = Str('shell')
-    esc_strings = List([ESC_SHELL, ESC_SH_CAP])
-
-    def handle(self, line_info):
-        """Execute the line in a shell, empty return value"""
-        magic_handler = self.prefilter_manager.get_handler_by_name('magic')
-
-        line = line_info.line
-        if line.lstrip().startswith(ESC_SH_CAP):
-            # rewrite LineInfo's line, ifun and the_rest to properly hold the
-            # call to %sx and the actual command to be executed, so
-            # handle_magic can work correctly.  Note that this works even if
-            # the line is indented, so it handles multi_line_specials
-            # properly.
-            new_rest = line.lstrip()[2:]
-            line_info.line = '%ssx %s' % (ESC_MAGIC, new_rest)
-            line_info.ifun = 'sx'
-            line_info.the_rest = new_rest
-            return magic_handler.handle(line_info)
-        else:
-            cmd = line.lstrip().lstrip(ESC_SHELL)
-            line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
-                                             make_quoted_expr(cmd))
-        return line_out
-
-
 class MacroHandler(PrefilterHandler):
-    handler_name = Str("macro")
-    
+    handler_name = Unicode("macro")
+
     def handle(self, line_info):
         obj = self.shell.user_ns.get(line_info.ifun)
         pre_space = line_info.pre_whitespace
@@ -850,21 +583,24 @@ def handle(self, line_info):
 
 class MagicHandler(PrefilterHandler):
 
-    handler_name = Str('magic')
+    handler_name = Unicode('magic')
     esc_strings = List([ESC_MAGIC])
 
     def handle(self, line_info):
         """Execute magic functions."""
         ifun    = line_info.ifun
         the_rest = line_info.the_rest
-        cmd = '%sget_ipython().magic(%s)' % (line_info.pre_whitespace,
-                                   make_quoted_expr(ifun + " " + the_rest))
+        #Prepare arguments for get_ipython().run_line_magic(magic_name, magic_args)
+        t_arg_s = ifun + " " + the_rest
+        t_magic_name, _, t_magic_arg_s = t_arg_s.partition(' ')
+        t_magic_name = t_magic_name.lstrip(ESC_MAGIC)
+        cmd = '%sget_ipython().run_line_magic(%r, %r)' % (line_info.pre_whitespace, t_magic_name, t_magic_arg_s)
         return cmd
 
 
 class AutoHandler(PrefilterHandler):
 
-    handler_name = Str('auto')
+    handler_name = Unicode('auto')
     esc_strings = List([ESC_PAREN, ESC_QUOTE, ESC_QUOTE2])
 
     def handle(self, line_info):
@@ -872,97 +608,69 @@ def handle(self, line_info):
         line    = line_info.line
         ifun    = line_info.ifun
         the_rest = line_info.the_rest
-        pre     = line_info.pre
+        esc     = line_info.esc
         continue_prompt = line_info.continue_prompt
-        obj = line_info.ofind(self)['obj']
-        #print 'pre <%s> ifun <%s> rest <%s>' % (pre,ifun,the_rest)  # dbg
+        obj = self.shell._ofind(line_info.ifun).obj
 
         # This should only be active for single-line input!
         if continue_prompt:
             return line
 
         force_auto = isinstance(obj, IPyAutocall)
-        auto_rewrite = getattr(obj, 'rewrite', True)
-        
-        if pre == ESC_QUOTE:
+
+        # User objects sometimes raise exceptions on attribute access other
+        # than AttributeError (we've seen it in the past), so it's safest to be
+        # ultra-conservative here and catch all.
+        try:
+            auto_rewrite = obj.rewrite
+        except Exception:
+            auto_rewrite = True
+
+        if esc == ESC_QUOTE:
             # Auto-quote splitting on whitespace
             newcmd = '%s("%s")' % (ifun,'", "'.join(the_rest.split()) )
-        elif pre == ESC_QUOTE2:
+        elif esc == ESC_QUOTE2:
             # Auto-quote whole string
             newcmd = '%s("%s")' % (ifun,the_rest)
-        elif pre == ESC_PAREN:
+        elif esc == ESC_PAREN:
             newcmd = '%s(%s)' % (ifun,",".join(the_rest.split()))
         else:
             # Auto-paren.
-            # We only apply it to argument-less calls if the autocall
-            # parameter is set to 2.  We only need to check that autocall is <
-            # 2, since this function isn't called unless it's at least 1.
-            if not the_rest and (self.shell.autocall < 2) and not force_auto:
-                newcmd = '%s %s' % (ifun,the_rest)
-                auto_rewrite = False
+            if force_auto:
+                # Don't rewrite if it is already a call.
+                do_rewrite = not the_rest.startswith('(')
             else:
-                if not force_auto and the_rest.startswith('['):
-                    if hasattr(obj,'__getitem__'):
-                        # Don't autocall in this case: item access for an object
-                        # which is BOTH callable and implements __getitem__.
-                        newcmd = '%s %s' % (ifun,the_rest)
-                        auto_rewrite = False
-                    else:
-                        # if the object doesn't support [] access, go ahead and
-                        # autocall
-                        newcmd = '%s(%s)' % (ifun.rstrip(),the_rest)
-                elif the_rest.endswith(';'):
+                if not the_rest:
+                    # We only apply it to argument-less calls if the autocall
+                    # parameter is set to 2.
+                    do_rewrite = (self.shell.autocall >= 2)
+                elif the_rest.startswith('[') and hasattr(obj, '__getitem__'):
+                    # Don't autocall in this case: item access for an object
+                    # which is BOTH callable and implements __getitem__.
+                    do_rewrite = False
+                else:
+                    do_rewrite = True
+
+            # Figure out the rewritten command
+            if do_rewrite:
+                if the_rest.endswith(';'):
                     newcmd = '%s(%s);' % (ifun.rstrip(),the_rest[:-1])
                 else:
                     newcmd = '%s(%s)' % (ifun.rstrip(), the_rest)
+            else:
+                normal_handler = self.prefilter_manager.get_handler_by_name('normal')
+                return normal_handler.handle(line_info)
 
+        # Display the rewritten call
         if auto_rewrite:
             self.shell.auto_rewrite_input(newcmd)
-            
-        return newcmd
-
-
-class HelpHandler(PrefilterHandler):
-
-    handler_name = Str('help')
-    esc_strings = List([ESC_HELP])
 
-    def handle(self, line_info):
-        """Try to get some help for the object.
-
-        obj? or ?obj   -> basic information.
-        obj?? or ??obj -> more details.
-        """
-        normal_handler = self.prefilter_manager.get_handler_by_name('normal')
-        line = line_info.line
-        # We need to make sure that we don't process lines which would be
-        # otherwise valid python, such as "x=1 # what?"
-        try:
-            codeop.compile_command(line)
-        except SyntaxError:
-            # We should only handle as help stuff which is NOT valid syntax
-            if line[0]==ESC_HELP:
-                line = line[1:]
-            elif line[-1]==ESC_HELP:
-                line = line[:-1]
-            if line:
-                #print 'line:<%r>' % line  # dbg
-                self.shell.magic_pinfo(line)
-            else:
-                self.shell.show_usage()
-            return '' # Empty string is needed here!
-        except:
-            raise
-            # Pass any other exceptions through to the normal handler
-            return normal_handler.handle(line_info)
-        else:
-            # If the code compiles ok, we should handle it normally
-            return normal_handler.handle(line_info)
+        return newcmd
 
 
 class EmacsHandler(PrefilterHandler):
 
-    handler_name = Str('emacs')
+    handler_name = Unicode('emacs')
     esc_strings = List([])
 
     def handle(self, line_info):
@@ -980,34 +688,20 @@ def handle(self, line_info):
 #-----------------------------------------------------------------------------
 
 
-_default_transformers = [
-    AssignSystemTransformer,
-    AssignMagicTransformer,
-    PyPromptTransformer,
-    IPyPromptTransformer,
-]
-
 _default_checkers = [
     EmacsChecker,
-    ShellEscapeChecker,
     MacroChecker,
     IPyAutocallChecker,
-    MultiLineMagicChecker,
-    EscCharsChecker,
     AssignmentChecker,
     AutoMagicChecker,
-    AliasChecker,
     PythonOpsChecker,
     AutocallChecker
 ]
 
 _default_handlers = [
     PrefilterHandler,
-    AliasHandler,
-    ShellEscapeHandler,
     MacroHandler,
     MagicHandler,
     AutoHandler,
-    HelpHandler,
     EmacsHandler
 ]
diff --git a/IPython/core/profile/README_STARTUP b/IPython/core/profile/README_STARTUP
new file mode 100644
index 00000000000..61d47000421
--- /dev/null
+++ b/IPython/core/profile/README_STARTUP
@@ -0,0 +1,11 @@
+This is the IPython startup directory
+
+.py and .ipy files in this directory will be run *prior* to any code or files specified
+via the exec_lines or exec_files configurables whenever you load this profile.
+
+Files will be run in lexicographical order, so you can control the execution order of files
+with a prefix, e.g.::
+
+    00-first.py
+    50-middle.py
+    99-last.ipy
diff --git a/IPython/core/profileapp.py b/IPython/core/profileapp.py
new file mode 100644
index 00000000000..e7538ff201a
--- /dev/null
+++ b/IPython/core/profileapp.py
@@ -0,0 +1,315 @@
+# encoding: utf-8
+"""
+An application for managing IPython profiles.
+
+To be invoked as the `ipython profile` subcommand.
+
+Authors:
+
+* Min RK
+
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import os
+
+from traitlets.config.application import Application
+from IPython.core.application import (
+    BaseIPythonApplication, base_flags
+)
+from IPython.core.profiledir import ProfileDir
+from IPython.utils.importstring import import_item
+from IPython.paths import get_ipython_dir, get_ipython_package_dir
+from traitlets import Unicode, Bool, Dict, observe
+
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
+
+create_help = """Create an IPython profile by name
+
+Create an ipython profile directory by its name or
+profile directory path. Profile directories contain
+configuration, log and security related files and are named
+using the convention 'profile_<name>'. By default they are
+located in your ipython directory. Once created, you will
+can edit the configuration files in the profile
+directory to configure IPython. Most users will create a
+profile directory by name,
+`ipython profile create myprofile`, which will put the directory
+in `<ipython_dir>/profile_myprofile`.
+"""
+list_help = """List available IPython profiles
+
+List all available profiles, by profile location, that can
+be found in the current working directly or in the ipython
+directory. Profile directories are named using the convention
+'profile_<profile>'.
+"""
+profile_help = """Manage IPython profiles
+
+Profile directories contain
+configuration, log and security related files and are named
+using the convention 'profile_<name>'. By default they are
+located in your ipython directory.  You can create profiles
+with `ipython profile create <name>`, or see the profiles you
+already have with `ipython profile list`
+
+To get started configuring IPython, simply do:
+
+$> ipython profile create
+
+and IPython will create the default profile in <ipython_dir>/profile_default,
+where you can edit ipython_config.py to start configuring IPython.
+
+"""
+
+_list_examples = "ipython profile list  # list all profiles"
+
+_create_examples = """
+ipython profile create foo         # create profile foo w/ default config files
+ipython profile create foo --reset # restage default config files over current
+ipython profile create foo --parallel # also stage parallel config files
+"""
+
+_main_examples = """
+ipython profile create -h  # show the help string for the create subcommand
+ipython profile list -h    # show the help string for the list subcommand
+
+ipython locate profile foo # print the path to the directory for profile 'foo'
+"""
+
+#-----------------------------------------------------------------------------
+# Profile Application Class (for `ipython profile` subcommand)
+#-----------------------------------------------------------------------------
+
+
+def list_profiles_in(path):
+    """list profiles in a given root directory"""
+    profiles = []
+
+    # for python 3.6+ rewrite to: with os.scandir(path) as dirlist:
+    files = os.scandir(path)
+    for f in files:
+        if f.is_dir() and f.name.startswith('profile_'):
+            profiles.append(f.name.split('_', 1)[-1])
+    return profiles
+
+
+def list_bundled_profiles():
+    """list profiles that are bundled with IPython."""
+    path = os.path.join(get_ipython_package_dir(), u'core', u'profile')
+    profiles = []
+
+    # for python 3.6+ rewrite to: with os.scandir(path) as dirlist:
+    files =  os.scandir(path)
+    for profile in files:
+        if profile.is_dir() and profile.name != "__pycache__":
+            profiles.append(profile.name)
+    return profiles
+
+
+class ProfileLocate(BaseIPythonApplication):
+    description = """print the path to an IPython profile dir"""
+    
+    def parse_command_line(self, argv=None):
+        super(ProfileLocate, self).parse_command_line(argv)
+        if self.extra_args:
+            self.profile = self.extra_args[0]
+    
+    def start(self):
+        print(self.profile_dir.location)
+
+
+class ProfileList(Application):
+    name = u'ipython-profile'
+    description = list_help
+    examples = _list_examples
+
+    aliases = Dict({
+        'ipython-dir' : 'ProfileList.ipython_dir',
+        'log-level' : 'Application.log_level',
+    })
+    flags = Dict(dict(
+        debug = ({'Application' : {'log_level' : 0}},
+            "Set Application.log_level to 0, maximizing log output."
+        )
+    ))
+
+    ipython_dir = Unicode(get_ipython_dir(),
+        help="""
+        The name of the IPython directory. This directory is used for logging
+        configuration (through profiles), history storage, etc. The default
+        is usually $HOME/.ipython. This options can also be specified through
+        the environment variable IPYTHONDIR.
+        """
+    ).tag(config=True)
+
+
+    def _print_profiles(self, profiles):
+        """print list of profiles, indented."""
+        for profile in profiles:
+            print('    %s' % profile)
+
+    def list_profile_dirs(self):
+        profiles = list_bundled_profiles()
+        if profiles:
+            print()
+            print("Available profiles in IPython:")
+            self._print_profiles(profiles)
+            print()
+            print("    The first request for a bundled profile will copy it")
+            print("    into your IPython directory (%s)," % self.ipython_dir)
+            print("    where you can customize it.")
+        
+        profiles = list_profiles_in(self.ipython_dir)
+        if profiles:
+            print()
+            print("Available profiles in %s:" % self.ipython_dir)
+            self._print_profiles(profiles)
+        
+        profiles = list_profiles_in(os.getcwd())
+        if profiles:
+            print()
+            print(
+                "Profiles from CWD have been removed for security reason, see CVE-2022-21699:"
+            )
+
+        print()
+        print("To use any of the above profiles, start IPython with:")
+        print("    ipython --profile=<name>")
+        print()
+
+    def start(self):
+        self.list_profile_dirs()
+
+
+create_flags = {}
+create_flags.update(base_flags)
+# don't include '--init' flag, which implies running profile create in other apps
+create_flags.pop('init')
+create_flags['reset'] = ({'ProfileCreate': {'overwrite' : True}},
+                        "reset config files in this profile to the defaults.")
+create_flags['parallel'] = ({'ProfileCreate': {'parallel' : True}},
+                        "Include the config files for parallel "
+                        "computing apps (ipengine, ipcontroller, etc.)")
+
+
+class ProfileCreate(BaseIPythonApplication):
+    name = u'ipython-profile'
+    description = create_help
+    examples = _create_examples
+    auto_create = Bool(True).tag(config=True)
+    def _log_format_default(self):
+        return "[%(name)s] %(message)s"
+
+    def _copy_config_files_default(self):
+        return True
+
+    parallel = Bool(False,
+        help="whether to include parallel computing config files"
+    ).tag(config=True)
+
+    @observe('parallel')
+    def _parallel_changed(self, change):
+        parallel_files = [   'ipcontroller_config.py',
+                            'ipengine_config.py',
+                            'ipcluster_config.py'
+                        ]
+        if change['new']:
+            for cf in parallel_files:
+                self.config_files.append(cf)
+        else:
+            for cf in parallel_files:
+                if cf in self.config_files:
+                    self.config_files.remove(cf)
+
+    def parse_command_line(self, argv):
+        super(ProfileCreate, self).parse_command_line(argv)
+        # accept positional arg as profile name
+        if self.extra_args:
+            self.profile = self.extra_args[0]
+
+    flags = Dict(create_flags)
+
+    classes = [ProfileDir]
+    
+    def _import_app(self, app_path):
+        """import an app class"""
+        app = None
+        name = app_path.rsplit('.', 1)[-1]
+        try:
+            app = import_item(app_path)
+        except ImportError:
+            self.log.info("Couldn't import %s, config file will be excluded", name)
+        except Exception:
+            self.log.warning('Unexpected error importing %s', name, exc_info=True)
+        return app
+
+    def init_config_files(self):
+        super(ProfileCreate, self).init_config_files()
+        # use local imports, since these classes may import from here
+        from IPython.terminal.ipapp import TerminalIPythonApp
+        apps = [TerminalIPythonApp]
+        for app_path in (
+            'ipykernel.kernelapp.IPKernelApp',
+        ):
+            app = self._import_app(app_path)
+            if app is not None:
+                apps.append(app)
+        if self.parallel:
+            from ipyparallel.apps.ipcontrollerapp import IPControllerApp
+            from ipyparallel.apps.ipengineapp import IPEngineApp
+            from ipyparallel.apps.ipclusterapp import IPClusterStart
+            apps.extend([
+                IPControllerApp,
+                IPEngineApp,
+                IPClusterStart,
+            ])
+        for App in apps:
+            app = App()
+            app.config.update(self.config)
+            app.log = self.log
+            app.overwrite = self.overwrite
+            app.copy_config_files=True
+            app.ipython_dir=self.ipython_dir
+            app.profile_dir=self.profile_dir
+            app.init_config_files()
+
+    def stage_default_config_file(self):
+        pass
+
+
+class ProfileApp(Application):
+    name = u'ipython profile'
+    description = profile_help
+    examples = _main_examples
+
+    subcommands = Dict(dict(
+        create = (ProfileCreate, ProfileCreate.description.splitlines()[0]),
+        list = (ProfileList, ProfileList.description.splitlines()[0]),
+        locate = (ProfileLocate, ProfileLocate.description.splitlines()[0]),
+    ))
+
+    def start(self):
+        if self.subapp is None:
+            print(
+                "No subcommand specified. Must specify one of: "
+                + ", ".join(map(repr, self.subcommands))
+                + ".\n"
+            )
+            self.print_description()
+            self.print_subcommands()
+            self.exit(1)
+        else:
+            return self.subapp.start()
diff --git a/IPython/core/profiledir.py b/IPython/core/profiledir.py
new file mode 100644
index 00000000000..a1b94f2da33
--- /dev/null
+++ b/IPython/core/profiledir.py
@@ -0,0 +1,244 @@
+# encoding: utf-8
+"""An object for managing IPython profile directories."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import shutil
+import errno
+from pathlib import Path
+
+from traitlets.config.configurable import LoggingConfigurable
+from ..paths import get_ipython_package_dir
+from ..utils.path import expand_path, ensure_dir_exists
+from traitlets import Unicode, Bool, observe
+
+from typing import Optional
+
+#-----------------------------------------------------------------------------
+# Module errors
+#-----------------------------------------------------------------------------
+
+class ProfileDirError(Exception):
+    pass
+
+
+#-----------------------------------------------------------------------------
+# Class for managing profile directories
+#-----------------------------------------------------------------------------
+
+class ProfileDir(LoggingConfigurable):
+    """An object to manage the profile directory and its resources.
+
+    The profile directory is used by all IPython applications, to manage
+    configuration, logging and security.
+
+    This object knows how to find, create and manage these directories. This
+    should be used by any code that wants to handle profiles.
+    """
+
+    security_dir_name = Unicode('security')
+    log_dir_name = Unicode('log')
+    startup_dir_name = Unicode('startup')
+    pid_dir_name = Unicode('pid')
+    static_dir_name = Unicode('static')
+    security_dir = Unicode(u'')
+    log_dir = Unicode(u'')
+    startup_dir = Unicode(u'')
+    pid_dir = Unicode(u'')
+    static_dir = Unicode(u'')
+
+    location = Unicode(u'',
+        help="""Set the profile location directly. This overrides the logic used by the
+        `profile` option.""",
+        ).tag(config=True)
+
+    _location_isset = Bool(False) # flag for detecting multiply set location
+    @observe('location')
+    def _location_changed(self, change):
+        if self._location_isset:
+            raise RuntimeError("Cannot set profile location more than once.")
+        self._location_isset = True
+        new = change['new']
+        ensure_dir_exists(new)
+
+        # ensure config files exist:
+        self.security_dir = os.path.join(new, self.security_dir_name)
+        self.log_dir = os.path.join(new, self.log_dir_name)
+        self.startup_dir = os.path.join(new, self.startup_dir_name)
+        self.pid_dir = os.path.join(new, self.pid_dir_name)
+        self.static_dir = os.path.join(new, self.static_dir_name)
+        self.check_dirs()
+
+    def _mkdir(self, path: str, mode: Optional[int] = None) -> bool:
+        """ensure a directory exists at a given path
+
+        This is a version of os.mkdir, with the following differences:
+
+        - returns whether the directory has been created or not.
+        - ignores EEXIST, protecting against race conditions where
+          the dir may have been created in between the check and
+          the creation
+        - sets permissions if requested and the dir already exists
+
+        Parameters
+        ----------
+        path: str
+            path of the dir to create
+        mode: int
+            see `mode` of `os.mkdir`
+
+        Returns
+        -------
+        bool:
+            returns True if it created the directory, False otherwise
+        """
+
+        if os.path.exists(path):
+            if mode and os.stat(path).st_mode != mode:
+                try:
+                    os.chmod(path, mode)
+                except OSError:
+                    self.log.warning(
+                        "Could not set permissions on %s",
+                        path
+                    )
+            return False
+        try:
+            if mode:
+                os.mkdir(path, mode)
+            else:
+                os.mkdir(path)
+        except OSError as e:
+            if e.errno == errno.EEXIST:
+                return False
+            else:
+                raise
+
+        return True
+    
+    @observe('log_dir')
+    def check_log_dir(self, change=None):
+        self._mkdir(self.log_dir)
+    
+    @observe('startup_dir')
+    def check_startup_dir(self, change=None):
+        if self._mkdir(self.startup_dir):
+            readme = os.path.join(self.startup_dir, "README")
+            src = os.path.join(
+                get_ipython_package_dir(), "core", "profile", "README_STARTUP"
+            )
+
+            if os.path.exists(src):
+                if not os.path.exists(readme):
+                    shutil.copy(src, readme)
+            else:
+                self.log.warning(
+                    "Could not copy README_STARTUP to startup dir. Source file %s does not exist.",
+                    src,
+                )
+
+    @observe('security_dir')
+    def check_security_dir(self, change=None):
+        self._mkdir(self.security_dir, 0o40700)
+
+    @observe('pid_dir')
+    def check_pid_dir(self, change=None):
+        self._mkdir(self.pid_dir, 0o40700)
+
+    def check_dirs(self):
+        self.check_security_dir()
+        self.check_log_dir()
+        self.check_pid_dir()
+        self.check_startup_dir()
+
+    def copy_config_file(self, config_file: str, path: Path, overwrite=False) -> bool:
+        """Copy a default config file into the active profile directory.
+
+        Default configuration files are kept in :mod:`IPython.core.profile`.
+        This function moves these from that location to the working profile
+        directory.
+        """
+        dst = Path(os.path.join(self.location, config_file))
+        if dst.exists() and not overwrite:
+            return False
+        if path is None:
+            path = os.path.join(get_ipython_package_dir(), u'core', u'profile', u'default')
+        assert isinstance(path, Path)
+        src = path / config_file
+        shutil.copy(src, dst)
+        return True
+
+    @classmethod
+    def create_profile_dir(cls, profile_dir, config=None):
+        """Create a new profile directory given a full path.
+
+        Parameters
+        ----------
+        profile_dir : str
+            The full path to the profile directory.  If it does exist, it will
+            be used.  If not, it will be created.
+        """
+        return cls(location=profile_dir, config=config)
+
+    @classmethod
+    def create_profile_dir_by_name(cls, path, name=u'default', config=None):
+        """Create a profile dir by profile name and path.
+
+        Parameters
+        ----------
+        path : unicode
+            The path (directory) to put the profile directory in.
+        name : unicode
+            The name of the profile.  The name of the profile directory will
+            be "profile_<profile>".
+        """
+        if not os.path.isdir(path):
+            raise ProfileDirError('Directory not found: %s' % path)
+        profile_dir = os.path.join(path, u'profile_' + name)
+        return cls(location=profile_dir, config=config)
+
+    @classmethod
+    def find_profile_dir_by_name(cls, ipython_dir, name=u'default', config=None):
+        """Find an existing profile dir by profile name, return its ProfileDir.
+
+        This searches through a sequence of paths for a profile dir.  If it
+        is not found, a :class:`ProfileDirError` exception will be raised.
+
+        The search path algorithm is:
+        1. ``os.getcwd()`` # removed for security reason.
+        2. ``ipython_dir``
+
+        Parameters
+        ----------
+        ipython_dir : unicode or str
+            The IPython directory to use.
+        name : unicode or str
+            The name of the profile.  The name of the profile directory
+            will be "profile_<profile>".
+        """
+        dirname = u'profile_' + name
+        paths = [ipython_dir]
+        for p in paths:
+            profile_dir = os.path.join(p, dirname)
+            if os.path.isdir(profile_dir):
+                return cls(location=profile_dir, config=config)
+        else:
+            raise ProfileDirError('Profile directory not found in paths: %s' % dirname)
+
+    @classmethod
+    def find_profile_dir(cls, profile_dir, config=None):
+        """Find/create a profile dir and return its ProfileDir.
+
+        This will create the profile directory if it doesn't exist.
+
+        Parameters
+        ----------
+        profile_dir : unicode or str
+            The path of the profile directory.
+        """
+        profile_dir = expand_path(profile_dir)
+        if not os.path.isdir(profile_dir):
+            raise ProfileDirError('Profile directory not found: %s' % profile_dir)
+        return cls(location=profile_dir, config=config)
diff --git a/IPython/core/prompts.py b/IPython/core/prompts.py
deleted file mode 100644
index 2964320d62e..00000000000
--- a/IPython/core/prompts.py
+++ /dev/null
@@ -1,436 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Classes for handling input/output prompts.
-
-Authors:
-
-* Fernando Perez
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#       Copyright (C) 2008-2010 The IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import re
-import socket
-import sys
-
-from IPython.core import release
-from IPython.external.Itpl import ItplNS
-from IPython.utils import coloransi
-
-#-----------------------------------------------------------------------------
-# Color schemes for prompts
-#-----------------------------------------------------------------------------
-
-PromptColors = coloransi.ColorSchemeTable()
-InputColors = coloransi.InputTermColors  # just a shorthand
-Colors = coloransi.TermColors  # just a shorthand
-
-PromptColors.add_scheme(coloransi.ColorScheme(
-    'NoColor',
-    in_prompt  = InputColors.NoColor,  # Input prompt
-    in_number  = InputColors.NoColor,  # Input prompt number
-    in_prompt2 = InputColors.NoColor, # Continuation prompt
-    in_normal  = InputColors.NoColor,  # color off (usu. Colors.Normal)
-    
-    out_prompt = Colors.NoColor, # Output prompt
-    out_number = Colors.NoColor, # Output prompt number
-
-    normal = Colors.NoColor  # color off (usu. Colors.Normal)
-    ))
-
-# make some schemes as instances so we can copy them for modification easily:
-__PColLinux =  coloransi.ColorScheme(
-    'Linux',
-    in_prompt  = InputColors.Green,
-    in_number  = InputColors.LightGreen,
-    in_prompt2 = InputColors.Green,
-    in_normal  = InputColors.Normal,  # color off (usu. Colors.Normal)
-
-    out_prompt = Colors.Red,
-    out_number = Colors.LightRed,
-
-    normal = Colors.Normal
-    )
-# Don't forget to enter it into the table!
-PromptColors.add_scheme(__PColLinux)
-
-# Slightly modified Linux for light backgrounds
-__PColLightBG  = __PColLinux.copy('LightBG')
-
-__PColLightBG.colors.update(
-    in_prompt  = InputColors.Blue,
-    in_number  = InputColors.LightBlue,
-    in_prompt2 = InputColors.Blue
-)
-PromptColors.add_scheme(__PColLightBG)
-
-del Colors,InputColors
-
-#-----------------------------------------------------------------------------
-# Utilities
-#-----------------------------------------------------------------------------
-
-def multiple_replace(dict, text):
-    """ Replace in 'text' all occurences of any key in the given
-    dictionary by its corresponding value.  Returns the new string."""
-
-    # Function by Xavier Defrang, originally found at:
-    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
-
-    # Create a regular expression  from the dictionary keys
-    regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
-    # For each match, look-up corresponding value in dictionary
-    return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
-
-#-----------------------------------------------------------------------------
-# Special characters that can be used in prompt templates, mainly bash-like
-#-----------------------------------------------------------------------------
-
-# If $HOME isn't defined (Windows), make it an absurd string so that it can
-# never be expanded out into '~'.  Basically anything which can never be a
-# reasonable directory name will do, we just want the $HOME -> '~' operation
-# to become a no-op.  We pre-compute $HOME here so it's not done on every
-# prompt call.
-
-# FIXME:
-
-# - This should be turned into a class which does proper namespace management,
-# since the prompt specials need to be evaluated in a certain namespace.
-# Currently it's just globals, which need to be managed manually by code
-# below.
-
-# - I also need to split up the color schemes from the prompt specials
-# somehow.  I don't have a clean design for that quite yet.
-
-HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
-
-# We precompute a few more strings here for the prompt_specials, which are
-# fixed once ipython starts.  This reduces the runtime overhead of computing
-# prompt strings.
-USER           = os.environ.get("USER")
-HOSTNAME       = socket.gethostname()
-HOSTNAME_SHORT = HOSTNAME.split(".")[0]
-ROOT_SYMBOL    = "$#"[os.name=='nt' or os.getuid()==0]
-
-prompt_specials_color = {
-    # Prompt/history count
-    '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
-    r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
-    # Just the prompt counter number, WITHOUT any coloring wrappers, so users
-    # can get numbers displayed in whatever color they want.
-    r'\N': '${self.cache.prompt_count}',
-
-    # Prompt/history count, with the actual digits replaced by dots.  Used
-    # mainly in continuation prompts (prompt_in2)
-    #r'\D': '${"."*len(str(self.cache.prompt_count))}',
-
-    # More robust form of the above expression, that uses the __builtin__
-    # module.  Note that we can NOT use __builtins__ (note the 's'), because
-    # that can either be a dict or a module, and can even mutate at runtime,
-    # depending on the context (Python makes no guarantees on it).  In
-    # contrast, __builtin__ is always a module object, though it must be
-    # explicitly imported.
-    r'\D': '${"."*__builtin__.len(__builtin__.str(self.cache.prompt_count))}',
-
-    # Current working directory
-    r'\w': '${os.getcwd()}',
-    # Current time
-    r'\t' : '${time.strftime("%H:%M:%S")}',
-    # Basename of current working directory.
-    # (use os.sep to make this portable across OSes)
-    r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
-    # These X<N> are an extension to the normal bash prompts.  They return
-    # N terms of the path, after replacing $HOME with '~'
-    r'\X0': '${os.getcwd().replace("%s","~")}' % HOME,
-    r'\X1': '${self.cwd_filt(1)}',
-    r'\X2': '${self.cwd_filt(2)}',
-    r'\X3': '${self.cwd_filt(3)}',
-    r'\X4': '${self.cwd_filt(4)}',
-    r'\X5': '${self.cwd_filt(5)}',
-    # Y<N> are similar to X<N>, but they show '~' if it's the directory
-    # N+1 in the list.  Somewhat like %cN in tcsh.
-    r'\Y0': '${self.cwd_filt2(0)}',
-    r'\Y1': '${self.cwd_filt2(1)}',
-    r'\Y2': '${self.cwd_filt2(2)}',
-    r'\Y3': '${self.cwd_filt2(3)}',
-    r'\Y4': '${self.cwd_filt2(4)}',
-    r'\Y5': '${self.cwd_filt2(5)}',
-    # Hostname up to first .
-    r'\h': HOSTNAME_SHORT,
-    # Full hostname
-    r'\H': HOSTNAME,
-    # Username of current user
-    r'\u': USER,
-    # Escaped '\'
-    '\\\\': '\\',
-    # Newline
-    r'\n': '\n',
-    # Carriage return
-    r'\r': '\r',
-    # Release version
-    r'\v': release.version,
-    # Root symbol ($ or #)
-    r'\$': ROOT_SYMBOL,
-    }
-
-# A copy of the prompt_specials dictionary but with all color escapes removed,
-# so we can correctly compute the prompt length for the auto_rewrite method.
-prompt_specials_nocolor = prompt_specials_color.copy()
-prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
-prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}'
-
-# Add in all the InputTermColors color escapes as valid prompt characters.
-# They all get added as \\C_COLORNAME, so that we don't have any conflicts
-# with a color name which may begin with a letter used by any other of the
-# allowed specials.  This of course means that \\C will never be allowed for
-# anything else.
-input_colors = coloransi.InputTermColors
-for _color in dir(input_colors):
-    if _color[0] != '_':
-        c_name = r'\C_'+_color
-        prompt_specials_color[c_name] = getattr(input_colors,_color)
-        prompt_specials_nocolor[c_name] = ''
-
-# we default to no color for safety.  Note that prompt_specials is a global
-# variable used by all prompt objects.
-prompt_specials = prompt_specials_nocolor
-
-#-----------------------------------------------------------------------------
-# More utilities
-#-----------------------------------------------------------------------------
-
-def str_safe(arg):
-    """Convert to a string, without ever raising an exception.
-
-    If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
-    error message."""
-
-    try:
-        out = str(arg)
-    except UnicodeError:
-        try:
-            out = arg.encode('utf_8','replace')
-        except Exception,msg:
-            # let's keep this little duplication here, so that the most common
-            # case doesn't suffer from a double try wrapping.
-            out = '<ERROR: %s>' % msg
-    except Exception,msg:
-        out = '<ERROR: %s>' % msg
-        #raise  # dbg
-    return out
-
-#-----------------------------------------------------------------------------
-# Prompt classes
-#-----------------------------------------------------------------------------
-
-class BasePrompt(object):
-    """Interactive prompt similar to Mathematica's."""
-
-    def _get_p_template(self):
-        return self._p_template
-
-    def _set_p_template(self,val):
-        self._p_template = val
-        self.set_p_str()
-
-    p_template = property(_get_p_template,_set_p_template,
-                          doc='Template for prompt string creation')
-
-    def __init__(self, cache, sep, prompt, pad_left=False):
-
-        # Hack: we access information about the primary prompt through the
-        # cache argument.  We need this, because we want the secondary prompt
-        # to be aligned with the primary one.  Color table info is also shared
-        # by all prompt classes through the cache.  Nice OO spaghetti code!
-        self.cache = cache
-        self.sep = sep
-        
-        # regexp to count the number of spaces at the end of a prompt
-        # expression, useful for prompt auto-rewriting
-        self.rspace = re.compile(r'(\s*)$')
-        # Flag to left-pad prompt strings to match the length of the primary
-        # prompt
-        self.pad_left = pad_left
-
-        # Set template to create each actual prompt (where numbers change).
-        # Use a property
-        self.p_template = prompt
-        self.set_p_str()
-
-    def set_p_str(self):
-        """ Set the interpolating prompt strings.
-
-        This must be called every time the color settings change, because the
-        prompt_specials global may have changed."""
-
-        import os,time  # needed in locals for prompt string handling
-        loc = locals()
-        try:
-            self.p_str = ItplNS('%s%s%s' %
-                                ('${self.sep}${self.col_p}',
-                                 multiple_replace(prompt_specials, self.p_template),
-                                 '${self.col_norm}'),self.cache.shell.user_ns,loc)
-    
-            self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
-                                                         self.p_template),
-                                        self.cache.shell.user_ns,loc)
-        except:
-            print "Illegal prompt template (check $ usage!):",self.p_template
-            self.p_str = self.p_template
-            self.p_str_nocolor = self.p_template
-
-    def write(self, msg):
-        sys.stdout.write(msg)
-        return ''
-
-    def __str__(self):
-        """Return a string form of the prompt.
-
-        This for is useful for continuation and output prompts, since it is
-        left-padded to match lengths with the primary one (if the
-        self.pad_left attribute is set)."""
-
-        out_str = str_safe(self.p_str)
-        if self.pad_left:
-            # We must find the amount of padding required to match lengths,
-            # taking the color escapes (which are invisible on-screen) into
-            # account.
-            esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
-            format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
-            return format % out_str
-        else:
-            return out_str
-
-    # these path filters are put in as methods so that we can control the
-    # namespace where the prompt strings get evaluated
-    def cwd_filt(self, depth):
-        """Return the last depth elements of the current working directory.
-
-        $HOME is always replaced with '~'.
-        If depth==0, the full path is returned."""
-
-        cwd = os.getcwd().replace(HOME,"~")
-        out = os.sep.join(cwd.split(os.sep)[-depth:])
-        if out:
-            return out
-        else:
-            return os.sep
-
-    def cwd_filt2(self, depth):
-        """Return the last depth elements of the current working directory.
-
-        $HOME is always replaced with '~'.
-        If depth==0, the full path is returned."""
-
-        full_cwd = os.getcwd()
-        cwd = full_cwd.replace(HOME,"~").split(os.sep)
-        if '~' in cwd and len(cwd) == depth+1:
-            depth += 1
-        drivepart = ''
-        if sys.platform == 'win32' and len(cwd) > depth:
-            drivepart = os.path.splitdrive(full_cwd)[0]
-        out = drivepart + '/'.join(cwd[-depth:])
-
-        if out:
-            return out
-        else:
-            return os.sep
-
-    def __nonzero__(self):
-        """Implement boolean behavior.
-
-        Checks whether the p_str attribute is non-empty"""
-
-        return bool(self.p_template)
-
-
-class Prompt1(BasePrompt):
-    """Input interactive prompt similar to Mathematica's."""
-
-    def __init__(self, cache, sep='\n', prompt='In [\\#]: ', pad_left=True):
-        BasePrompt.__init__(self, cache, sep, prompt, pad_left)
-
-    def set_colors(self):
-        self.set_p_str()
-        Colors = self.cache.color_table.active_colors # shorthand
-        self.col_p = Colors.in_prompt
-        self.col_num = Colors.in_number
-        self.col_norm = Colors.in_normal
-        # We need a non-input version of these escapes for the '--->'
-        # auto-call prompts used in the auto_rewrite() method.
-        self.col_p_ni = self.col_p.replace('\001','').replace('\002','') 
-        self.col_norm_ni = Colors.normal        
-
-    def __str__(self):
-        self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
-        return str_safe(self.p_str)
-
-    def auto_rewrite(self):
-        """Return a string of the form '--->' which lines up with the previous
-        input string. Useful for systems which re-write the user input when
-        handling automatically special syntaxes."""
-
-        curr = str(self.cache.last_prompt)
-        nrspaces = len(self.rspace.search(curr).group())
-        return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
-                              ' '*nrspaces,self.col_norm_ni)
-
-
-class PromptOut(BasePrompt):
-    """Output interactive prompt similar to Mathematica's."""
-
-    def __init__(self, cache, sep='', prompt='Out[\\#]: ', pad_left=True):
-        BasePrompt.__init__(self, cache, sep, prompt, pad_left)
-        if not self.p_template:
-            self.__str__ = lambda: ''
-
-    def set_colors(self):
-        self.set_p_str()
-        Colors = self.cache.color_table.active_colors # shorthand
-        self.col_p = Colors.out_prompt
-        self.col_num = Colors.out_number
-        self.col_norm = Colors.normal
-
-
-class Prompt2(BasePrompt):
-    """Interactive continuation prompt."""
-    
-    def __init__(self, cache, prompt='   .\\D.: ', pad_left=True):
-        self.cache = cache
-        self.p_template = prompt
-        self.pad_left = pad_left
-        self.set_p_str()
-
-    def set_p_str(self):
-        import os,time  # needed in locals for prompt string handling
-        loc = locals()
-        self.p_str = ItplNS('%s%s%s' %
-                            ('${self.col_p2}',
-                             multiple_replace(prompt_specials, self.p_template),
-                             '$self.col_norm'),
-                            self.cache.shell.user_ns,loc)
-        self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
-                                                     self.p_template),
-                                    self.cache.shell.user_ns,loc)
-
-    def set_colors(self):
-        self.set_p_str()
-        Colors = self.cache.color_table.active_colors
-        self.col_p2 = Colors.in_prompt2
-        self.col_norm = Colors.in_normal
-        # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
-        # updated their prompt_in2 definitions.  Remove eventually.
-        self.col_p = Colors.out_prompt
-        self.col_num = Colors.out_number
-
diff --git a/IPython/core/pylabtools.py b/IPython/core/pylabtools.py
new file mode 100644
index 00000000000..a7ce578afd3
--- /dev/null
+++ b/IPython/core/pylabtools.py
@@ -0,0 +1,514 @@
+# -*- coding: utf-8 -*-
+"""Pylab (matplotlib) support utilities."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from io import BytesIO
+from binascii import b2a_base64
+from functools import partial
+import warnings
+
+from IPython.core.display import _pngxy
+from IPython.utils.decorators import flag_calls
+
+
+# Matplotlib backend resolution functionality moved from IPython to Matplotlib
+# in IPython 8.24 and Matplotlib 3.9.0. Need to keep `backends` and `backend2gui`
+# here for earlier Matplotlib and for external backend libraries such as
+# mplcairo that might rely upon it.
+_deprecated_backends = {
+    "tk": "TkAgg",
+    "gtk": "GTKAgg",
+    "gtk3": "GTK3Agg",
+    "gtk4": "GTK4Agg",
+    "wx": "WXAgg",
+    "qt4": "Qt4Agg",
+    "qt5": "Qt5Agg",
+    "qt6": "QtAgg",
+    "qt": "QtAgg",
+    "osx": "MacOSX",
+    "nbagg": "nbAgg",
+    "webagg": "WebAgg",
+    "notebook": "nbAgg",
+    "agg": "agg",
+    "svg": "svg",
+    "pdf": "pdf",
+    "ps": "ps",
+    "inline": "module://matplotlib_inline.backend_inline",
+    "ipympl": "module://ipympl.backend_nbagg",
+    "widget": "module://ipympl.backend_nbagg",
+}
+
+# We also need a reverse backends2guis mapping that will properly choose which
+# GUI support to activate based on the desired matplotlib backend.  For the
+# most part it's just a reverse of the above dict, but we also need to add a
+# few others that map to the same GUI manually:
+_deprecated_backend2gui = dict(
+    zip(_deprecated_backends.values(), _deprecated_backends.keys())
+)
+# In the reverse mapping, there are a few extra valid matplotlib backends that
+# map to the same GUI support
+_deprecated_backend2gui["GTK"] = _deprecated_backend2gui["GTKCairo"] = "gtk"
+_deprecated_backend2gui["GTK3Cairo"] = "gtk3"
+_deprecated_backend2gui["GTK4Cairo"] = "gtk4"
+_deprecated_backend2gui["WX"] = "wx"
+_deprecated_backend2gui["CocoaAgg"] = "osx"
+# There needs to be a hysteresis here as the new QtAgg Matplotlib backend
+# supports either Qt5 or Qt6 and the IPython qt event loop support Qt4, Qt5,
+# and Qt6.
+_deprecated_backend2gui["QtAgg"] = "qt"
+_deprecated_backend2gui["Qt4Agg"] = "qt4"
+_deprecated_backend2gui["Qt5Agg"] = "qt5"
+
+# And some backends that don't need GUI integration
+del _deprecated_backend2gui["nbAgg"]
+del _deprecated_backend2gui["agg"]
+del _deprecated_backend2gui["svg"]
+del _deprecated_backend2gui["pdf"]
+del _deprecated_backend2gui["ps"]
+del _deprecated_backend2gui["module://matplotlib_inline.backend_inline"]
+del _deprecated_backend2gui["module://ipympl.backend_nbagg"]
+
+
+# Deprecated attributes backends and backend2gui mostly following PEP 562.
+def __getattr__(name):
+    if name in ("backends", "backend2gui"):
+        warnings.warn(
+            f"{name} is deprecated since IPython 8.24, backends are managed "
+            "in matplotlib and can be externally registered.",
+            DeprecationWarning,
+        )
+        return globals()[f"_deprecated_{name}"]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+#-----------------------------------------------------------------------------
+# Matplotlib utilities
+#-----------------------------------------------------------------------------
+
+
+def getfigs(*fig_nums):
+    """Get a list of matplotlib figures by figure numbers.
+
+    If no arguments are given, all available figures are returned.  If the
+    argument list contains references to invalid figures, a warning is printed
+    but the function continues pasting further figures.
+
+    Parameters
+    ----------
+    figs : tuple
+        A tuple of ints giving the figure numbers of the figures to return.
+    """
+    from matplotlib._pylab_helpers import Gcf
+    if not fig_nums:
+        fig_managers = Gcf.get_all_fig_managers()
+        return [fm.canvas.figure for fm in fig_managers]
+    else:
+        figs = []
+        for num in fig_nums:
+            f = Gcf.figs.get(num)
+            if f is None:
+                print('Warning: figure %s not available.' % num)
+            else:
+                figs.append(f.canvas.figure)
+        return figs
+
+
+def figsize(sizex, sizey):
+    """Set the default figure size to be [sizex, sizey].
+
+    This is just an easy to remember, convenience wrapper that sets::
+
+      matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
+    """
+    import matplotlib
+    matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
+
+
+def print_figure(fig, fmt="png", bbox_inches="tight", base64=False, **kwargs):
+    """Print a figure to an image, and return the resulting file data
+
+    Returned data will be bytes unless ``fmt='svg'``,
+    in which case it will be unicode.
+
+    Any keyword args are passed to fig.canvas.print_figure,
+    such as ``quality`` or ``bbox_inches``.
+
+    If `base64` is True, return base64-encoded str instead of raw bytes
+    for binary-encoded image formats
+
+    .. versionadded:: 7.29
+        base64 argument
+    """
+    # When there's an empty figure, we shouldn't return anything, otherwise we
+    # get big blank areas in the qt console.
+    if not fig.axes and not fig.lines:
+        return
+
+    dpi = fig.dpi
+    if fmt == 'retina':
+        dpi = dpi * 2
+        fmt = 'png'
+
+    # build keyword args
+    kw = {
+        "format":fmt,
+        "facecolor":fig.get_facecolor(),
+        "edgecolor":fig.get_edgecolor(),
+        "dpi":dpi,
+        "bbox_inches":bbox_inches,
+    }
+    # **kwargs get higher priority
+    kw.update(kwargs)
+
+    bytes_io = BytesIO()
+    if fig.canvas is None:
+        from matplotlib.backend_bases import FigureCanvasBase
+        FigureCanvasBase(fig)
+
+    fig.canvas.print_figure(bytes_io, **kw)
+    data = bytes_io.getvalue()
+    if fmt == 'svg':
+        data = data.decode('utf-8')
+    elif base64:
+        data = b2a_base64(data, newline=False).decode("ascii")
+    return data
+
+def retina_figure(fig, base64=False, **kwargs):
+    """format a figure as a pixel-doubled (retina) PNG
+
+    If `base64` is True, return base64-encoded str instead of raw bytes
+    for binary-encoded image formats
+
+    .. versionadded:: 7.29
+        base64 argument
+    """
+    pngdata = print_figure(fig, fmt="retina", base64=False, **kwargs)
+    # Make sure that retina_figure acts just like print_figure and returns
+    # None when the figure is empty.
+    if pngdata is None:
+        return
+    w, h = _pngxy(pngdata)
+    metadata = {"width": w//2, "height":h//2}
+    if base64:
+        pngdata = b2a_base64(pngdata, newline=False).decode("ascii")
+    return pngdata, metadata
+
+
+# We need a little factory function here to create the closure where
+# safe_execfile can live.
+def mpl_runner(safe_execfile):
+    """Factory to return a matplotlib-enabled runner for %run.
+
+    Parameters
+    ----------
+    safe_execfile : function
+        This must be a function with the same interface as the
+        :meth:`safe_execfile` method of IPython.
+
+    Returns
+    -------
+    A function suitable for use as the ``runner`` argument of the %run magic
+    function.
+    """
+
+    def mpl_execfile(fname,*where,**kw):
+        """matplotlib-aware wrapper around safe_execfile.
+
+        Its interface is identical to that of the :func:`execfile` builtin.
+
+        This is ultimately a call to execfile(), but wrapped in safeties to
+        properly handle interactive rendering."""
+
+        import matplotlib
+        import matplotlib.pyplot as plt
+
+        # print('*** Matplotlib runner ***')  # dbg
+        # turn off rendering until end of script
+        with matplotlib.rc_context({"interactive": False}):
+            safe_execfile(fname, *where, **kw)
+
+        if matplotlib.is_interactive():
+            plt.show()
+
+        # make rendering call now, if the user tried to do it
+        if plt.draw_if_interactive.called:
+            plt.draw()
+            plt.draw_if_interactive.called = False
+
+        # re-draw everything that is stale
+        try:
+            da = plt.draw_all
+        except AttributeError:
+            pass
+        else:
+            da()
+
+    return mpl_execfile
+
+
+def _reshow_nbagg_figure(fig):
+    """reshow an nbagg figure"""
+    try:
+        reshow = fig.canvas.manager.reshow
+    except AttributeError as e:
+        raise NotImplementedError() from e
+    else:
+        reshow()
+
+
+def select_figure_formats(shell, formats, **kwargs):
+    """Select figure formats for the inline backend.
+
+    Parameters
+    ----------
+    shell : InteractiveShell
+        The main IPython instance.
+    formats : str or set
+        One or a set of figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'.
+    **kwargs : any
+        Extra keyword arguments to be passed to fig.canvas.print_figure.
+    """
+    import matplotlib
+    from matplotlib.figure import Figure
+
+    svg_formatter = shell.display_formatter.formatters['image/svg+xml']
+    png_formatter = shell.display_formatter.formatters['image/png']
+    jpg_formatter = shell.display_formatter.formatters['image/jpeg']
+    pdf_formatter = shell.display_formatter.formatters['application/pdf']
+
+    if isinstance(formats, str):
+        formats = {formats}
+    # cast in case of list / tuple
+    formats = set(formats)
+
+    [ f.pop(Figure, None) for f in shell.display_formatter.formatters.values() ]
+    mplbackend = matplotlib.get_backend().lower()
+    if mplbackend in ("nbagg", "ipympl", "widget", "module://ipympl.backend_nbagg"):
+        formatter = shell.display_formatter.ipython_display_formatter
+        formatter.for_type(Figure, _reshow_nbagg_figure)
+
+    supported = {'png', 'png2x', 'retina', 'jpg', 'jpeg', 'svg', 'pdf'}
+    bad = formats.difference(supported)
+    if bad:
+        bs = "%s" % ','.join([repr(f) for f in bad])
+        gs = "%s" % ','.join([repr(f) for f in supported])
+        raise ValueError("supported formats are: %s not %s" % (gs, bs))
+
+    if "png" in formats:
+        png_formatter.for_type(
+            Figure, partial(print_figure, fmt="png", base64=True, **kwargs)
+        )
+    if "retina" in formats or "png2x" in formats:
+        png_formatter.for_type(Figure, partial(retina_figure, base64=True, **kwargs))
+    if "jpg" in formats or "jpeg" in formats:
+        jpg_formatter.for_type(
+            Figure, partial(print_figure, fmt="jpg", base64=True, **kwargs)
+        )
+    if "svg" in formats:
+        svg_formatter.for_type(Figure, partial(print_figure, fmt="svg", **kwargs))
+    if "pdf" in formats:
+        pdf_formatter.for_type(
+            Figure, partial(print_figure, fmt="pdf", base64=True, **kwargs)
+        )
+
+#-----------------------------------------------------------------------------
+# Code for initializing matplotlib and importing pylab
+#-----------------------------------------------------------------------------
+
+
+def find_gui_and_backend(gui=None, gui_select=None):
+    """Given a gui string return the gui and mpl backend.
+
+    Parameters
+    ----------
+    gui : str
+        Can be one of ('tk','gtk','wx','qt','qt4','inline','agg').
+    gui_select : str
+        Can be one of ('tk','gtk','wx','qt','qt4','inline').
+        This is any gui already selected by the shell.
+
+    Returns
+    -------
+    A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
+    'WXAgg','Qt4Agg','module://matplotlib_inline.backend_inline','agg').
+    """
+
+    import matplotlib
+
+    if _matplotlib_manages_backends():
+        backend_registry = matplotlib.backends.registry.backend_registry
+
+        # gui argument may be a gui event loop or may be a backend name.
+        if gui in ("auto", None):
+            backend = matplotlib.rcParamsOrig["backend"]
+            backend, gui = backend_registry.resolve_backend(backend)
+        else:
+            gui = _convert_gui_to_matplotlib(gui)
+            backend, gui = backend_registry.resolve_gui_or_backend(gui)
+
+        gui = _convert_gui_from_matplotlib(gui)
+        return gui, backend
+
+    # Fallback to previous behaviour (Matplotlib < 3.9)
+    mpl_version_info = getattr(matplotlib, "__version_info__", (0, 0))
+    has_unified_qt_backend = mpl_version_info >= (3, 5)
+
+
+    backends_ = dict(_deprecated_backends)
+    if not has_unified_qt_backend:
+        backends_["qt"] = "qt5agg"
+
+    if gui and gui != 'auto':
+        # select backend based on requested gui
+        backend = backends_[gui]
+        if gui == 'agg':
+            gui = None
+    else:
+        # We need to read the backend from the original data structure, *not*
+        # from mpl.rcParams, since a prior invocation of %matplotlib may have
+        # overwritten that.
+        # WARNING: this assumes matplotlib 1.1 or newer!!
+        backend = matplotlib.rcParamsOrig['backend']
+
+        # In this case, we need to find what the appropriate gui selection call
+        # should be for IPython, so we can activate inputhook accordingly
+        gui = _deprecated_backend2gui.get(backend, None)
+
+        # If we have already had a gui active, we need it and inline are the
+        # ones allowed.
+        if gui_select and gui != gui_select:
+            gui = gui_select
+            backend = backends_[gui]
+
+    # Matplotlib before _matplotlib_manages_backends() can return "inline" for
+    # no gui event loop rather than the None that IPython >= 8.24.0 expects.
+    if gui == "inline":
+        gui = None
+
+    return gui, backend
+
+
+def activate_matplotlib(backend):
+    """Activate the given backend and set interactive to True."""
+
+    import matplotlib
+    matplotlib.interactive(True)
+
+    # Matplotlib had a bug where even switch_backend could not force
+    # the rcParam to update. This needs to be set *before* the module
+    # magic of switch_backend().
+    matplotlib.rcParams['backend'] = backend
+
+    # Due to circular imports, pyplot may be only partially initialised
+    # when this function runs.
+    # So avoid needing matplotlib attribute-lookup to access pyplot.
+    from matplotlib import pyplot as plt
+
+    plt.switch_backend(backend)
+
+    plt.show._needmain = False
+    # We need to detect at runtime whether show() is called by the user.
+    # For this, we wrap it into a decorator which adds a 'called' flag.
+    plt.draw_if_interactive = flag_calls(plt.draw_if_interactive)
+
+
+def import_pylab(user_ns, import_all=True):
+    """Populate the namespace with pylab-related values.
+
+    Imports matplotlib, pylab, numpy, and everything from pylab and numpy.
+
+    Also imports a few names from IPython (figsize, display, getfigs)
+
+    """
+
+    # Import numpy as np/pyplot as plt are conventions we're trying to
+    # somewhat standardize on.  Making them available to users by default
+    # will greatly help this.
+    s = ("import numpy\n"
+          "import matplotlib\n"
+          "from matplotlib import pylab, mlab, pyplot\n"
+          "np = numpy\n"
+          "plt = pyplot\n"
+          )
+    exec(s, user_ns)
+
+    if import_all:
+        s = ("from matplotlib.pylab import *\n"
+             "from numpy import *\n")
+        exec(s, user_ns)
+
+    # IPython symbols to add
+    user_ns['figsize'] = figsize
+    from IPython.display import display
+    # Add display and getfigs to the user's namespace
+    user_ns['display'] = display
+    user_ns['getfigs'] = getfigs
+
+
+# Determine if Matplotlib manages backends only if needed, and cache result.
+# Do not read this directly, instead use _matplotlib_manages_backends().
+_matplotlib_manages_backends_value: bool | None = None
+
+
+def _matplotlib_manages_backends() -> bool:
+    """Return True if Matplotlib manages backends, False otherwise.
+
+    If it returns True, the caller can be sure that
+    matplotlib.backends.registry.backend_registry is available along with
+    member functions resolve_gui_or_backend, resolve_backend, list_all, and
+    list_gui_frameworks.
+
+    This function can be removed as it will always return True when Python
+    3.12, the latest version supported by Matplotlib < 3.9, reaches
+    end-of-life in late 2028.
+    """
+    global _matplotlib_manages_backends_value
+    if _matplotlib_manages_backends_value is None:
+        try:
+            from matplotlib.backends.registry import backend_registry
+
+            _matplotlib_manages_backends_value = hasattr(
+                backend_registry, "resolve_gui_or_backend"
+            )
+        except ImportError:
+            _matplotlib_manages_backends_value = False
+
+    return _matplotlib_manages_backends_value
+
+
+def _list_matplotlib_backends_and_gui_loops() -> list[str]:
+    """Return list of all Matplotlib backends and GUI event loops.
+
+    This is the list returned by
+        %matplotlib --list
+    """
+    if _matplotlib_manages_backends():
+        from matplotlib.backends.registry import backend_registry
+
+        ret = backend_registry.list_all() + [
+            _convert_gui_from_matplotlib(gui)
+            for gui in backend_registry.list_gui_frameworks()
+        ]
+    else:
+        from IPython.core import pylabtools
+
+        ret = list(pylabtools.backends.keys())
+
+    return sorted(["auto"] + ret)
+
+
+# Matplotlib and IPython do not always use the same gui framework name.
+# Always use the appropriate one of these conversion functions when passing a
+# gui framework name to/from Matplotlib.
+def _convert_gui_to_matplotlib(gui: str | None) -> str | None:
+    if gui and gui.lower() == "osx":
+        return "macosx"
+    return gui
+
+
+def _convert_gui_from_matplotlib(gui: str | None) -> str | None:
+    if gui and gui.lower() == "macosx":
+        return "osx"
+    return gui
diff --git a/IPython/core/release.py b/IPython/core/release.py
index 0f7d4227334..1c0c0d068dd 100644
--- a/IPython/core/release.py
+++ b/IPython/core/release.py
@@ -2,8 +2,8 @@
 """Release data for the IPython project."""
 
 #-----------------------------------------------------------------------------
-#  Copyright (c) 2008-2010, IPython Development Team.
-#  Copyright (c) 2001-2007, Fernando Perez <fernando.perez@colorado.edu>
+#  Copyright (c) 2008, IPython Development Team.
+#  Copyright (c) 2001, Fernando Perez <fernando.perez@colorado.edu>
 #  Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
 #  Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
 #
@@ -12,112 +12,34 @@
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
-# Name of the package for release purposes.  This is the name which labels
-# the tarballs and RPMs made by distutils, so it's best to lowercase it.
-name = 'ipython'
-
 # IPython version information.  An empty _version_extra corresponds to a full
 # release.  'dev' as a _version_extra string means this is a development
 # version
-_version_major = 0
+_version_major = 9
 _version_minor = 11
-_version_micro = ''  # use '' for first of series, number for 1 and above
-_version_extra = 'dev'
-#_version_extra = ''  # Uncomment this for full releases
+_version_patch = 0
+_version_extra = ".dev"
+# _version_extra = "b2"
+# _version_extra = ""  # Uncomment this for full releases
 
 # Construct full version string from these.
-_ver = [_version_major, _version_minor]
-if _version_micro:
-    _ver.append(_version_micro)
-if _version_extra:
-    _ver.append(_version_extra)
+_ver = [_version_major, _version_minor, _version_patch]
 
 __version__ = '.'.join(map(str, _ver))
+if _version_extra:
+    __version__ = __version__  + _version_extra
 
 version = __version__  # backwards compatibility name
+version_info = (_version_major, _version_minor, _version_patch, _version_extra)
 
-description = "An interactive computing environment for Python"
-
-long_description = \
-"""
-The goal of IPython is to create a comprehensive environment for
-interactive and exploratory computing.  To support this goal, IPython
-has two main components:
-
-* An enhanced interactive Python shell.
-
-* An architecture for interactive parallel computing.
-
-The enhanced interactive Python shell has the following main features:
-
-* Comprehensive object introspection.
-
-* Input history, persistent across sessions.
-
-* Caching of output results during a session with automatically generated
-  references.
-
-* Readline based name completion.
-
-* Extensible system of 'magic' commands for controlling the environment and
-  performing many tasks related either to IPython or the operating system.
-
-* Configuration system with easy switching between different setups (simpler
-  than changing $PYTHONSTARTUP environment variables every time).
-
-* Session logging and reloading.
-
-* Extensible syntax processing for special purpose situations.
-
-* Access to the system shell with user-extensible alias system.
 
-* Easily embeddable in other Python programs and wxPython GUIs.
+license = "BSD-3-Clause"
 
-* Integrated access to the pdb debugger and the Python profiler. 
-
-The parallel computing architecture has the following main features:
-
-* Quickly parallelize Python code from an interactive Python/IPython session.
-
-* A flexible and dynamic process model that be deployed on anything from 
-  multicore workstations to supercomputers.
-
-* An architecture that supports many different styles of parallelism, from
-  message passing to task farming.
-
-* Both blocking and fully asynchronous interfaces.
-
-* High level APIs that enable many things to be parallelized in a few lines
-  of code.
-
-* Share live parallel jobs with other users securely.  
-
-* Dynamically load balanced task farming system.
-
-* Robust error handling in parallel code.
-
-The latest development version is always available from IPython's `GitHub
-site <http://github.com/ipython>`_.
-"""
-
-license = 'BSD'
-
-authors = {'Fernando' : ('Fernando Perez','fperez.net@gmail.com'),
-           'Janko'    : ('Janko Hauser','jhauser@zscout.de'),
-           'Nathan'   : ('Nathaniel Gray','n8gray@caltech.edu'),
-           'Ville'    : ('Ville Vainio','vivainio@gmail.com'),
-           'Brian'    : ('Brian E Granger', 'ellisonbg@gmail.com'),
-           'Min'      : ('Min Ragan-Kelley', 'benjaminrk@gmail.com')
-           }
+authors = {
+    "Fernando": ("Fernando Perez", "fperez.net@gmail.com"),
+    "M": ("M Bussonnier", "mbussonnier@gmail.com"),
+}
 
 author = 'The IPython Development Team'
 
-author_email = 'ipython-dev@scipy.org'
-
-url = 'http://ipython.scipy.org'
-
-download_url = 'http://ipython.scipy.org/dist'
-
-platforms = ['Linux','Mac OSX','Windows XP/2000/NT','Windows 95/98/ME']
-
-keywords = ['Interactive','Interpreter','Shell','Parallel','Distributed']
+author_email = 'ipython-dev@python.org'
diff --git a/IPython/core/shadowns.py b/IPython/core/shadowns.py
deleted file mode 100644
index d2d93b61bd8..00000000000
--- a/IPython/core/shadowns.py
+++ /dev/null
@@ -1 +0,0 @@
-""" Shadow namespace """
\ No newline at end of file
diff --git a/IPython/core/shellapp.py b/IPython/core/shellapp.py
new file mode 100644
index 00000000000..f5199ff7a18
--- /dev/null
+++ b/IPython/core/shellapp.py
@@ -0,0 +1,500 @@
+# encoding: utf-8
+"""
+A mixin for :class:`~IPython.core.application.Application` classes that
+launch InteractiveShell instances, load extensions, etc.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import glob
+from itertools import chain
+import os
+import sys
+import typing as t
+
+from traitlets.config.application import boolean_flag
+from traitlets.config.configurable import Configurable
+from traitlets.config.loader import Config
+from IPython.core.application import SYSTEM_CONFIG_DIRS, ENV_CONFIG_DIRS
+from IPython.utils.contexts import preserve_keys
+from IPython.utils.path import filefind
+from traitlets import (
+    Unicode,
+    Instance,
+    List,
+    Bool,
+    CaselessStrEnum,
+    observe,
+    DottedObjectName,
+    Undefined,
+)
+from IPython.terminal import pt_inputhooks
+
+# -----------------------------------------------------------------------------
+# Aliases and Flags
+# -----------------------------------------------------------------------------
+
+gui_keys = tuple(sorted(pt_inputhooks.backends) + sorted(pt_inputhooks.aliases))
+
+shell_flags = {}
+
+addflag = lambda *args: shell_flags.update(boolean_flag(*args))
+addflag(
+    "autoindent",
+    "InteractiveShell.autoindent",
+    "Turn on autoindenting.",
+    "Turn off autoindenting.",
+)
+addflag(
+    "automagic",
+    "InteractiveShell.automagic",
+    """Turn on the auto calling of magic commands. Type %%magic at the
+        IPython  prompt  for  more information.""",
+        'Turn off the auto calling of magic commands.'
+)
+addflag('pdb', 'InteractiveShell.pdb',
+    "Enable auto calling the pdb debugger after every exception.",
+    "Disable auto calling the pdb debugger after every exception."
+)
+addflag('pprint', 'PlainTextFormatter.pprint',
+    "Enable auto pretty printing of results.",
+    "Disable auto pretty printing of results."
+)
+addflag('color-info', 'InteractiveShell.color_info',
+    """IPython can display information about objects via a set of functions,
+    and optionally can use colors for this, syntax highlighting
+    source code and various other elements. This is on by default, but can cause
+    problems with some pagers. If you see such problems, you can disable the
+    colours.""",
+    "Disable using colors for info related things."
+)
+addflag('ignore-cwd', 'InteractiveShellApp.ignore_cwd',
+        "Exclude the current working directory from sys.path",
+        "Include the current working directory in sys.path",
+)
+nosep_config = Config()
+nosep_config.InteractiveShell.separate_in = ''
+nosep_config.InteractiveShell.separate_out = ''
+nosep_config.InteractiveShell.separate_out2 = ''
+
+shell_flags['nosep']=(nosep_config, "Eliminate all spacing between prompts.")
+shell_flags['pylab'] = (
+    {'InteractiveShellApp' : {'pylab' : 'auto'}},
+    """Pre-load matplotlib and numpy for interactive use with
+    the default matplotlib backend. The exact options available
+    depend on what Matplotlib provides at runtime.""",
+)
+shell_flags['matplotlib'] = (
+    {'InteractiveShellApp' : {'matplotlib' : 'auto'}},
+    """Configure matplotlib for interactive use with
+    the default matplotlib backend. The exact options available
+    depend on what Matplotlib provides at runtime.""",
+)
+
+# it's possible we don't want short aliases for *all* of these:
+shell_aliases = dict(
+    autocall="InteractiveShell.autocall",
+    colors="InteractiveShell.colors",
+    theme="InteractiveShell.colors",
+    logfile="InteractiveShell.logfile",
+    logappend="InteractiveShell.logappend",
+    c="InteractiveShellApp.code_to_run",
+    m="InteractiveShellApp.module_to_run",
+    ext="InteractiveShellApp.extra_extensions",
+    gui='InteractiveShellApp.gui',
+    pylab='InteractiveShellApp.pylab',
+    matplotlib='InteractiveShellApp.matplotlib',
+)
+shell_aliases['cache-size'] = 'InteractiveShell.cache_size'
+
+
+# -----------------------------------------------------------------------------
+# Traitlets
+# -----------------------------------------------------------------------------
+
+
+class MatplotlibBackendCaselessStrEnum(CaselessStrEnum):
+    """An enum of Matplotlib backend strings where the case should be ignored.
+
+    Prior to Matplotlib 3.9.0 the list of valid backends is hardcoded in
+    pylabtools.backends. After that, Matplotlib manages backends.
+
+    The list of valid backends is determined when it is first needed to avoid
+    wasting unnecessary initialisation time.
+    """
+
+    def __init__(
+        self: CaselessStrEnum[t.Any],
+        default_value: t.Any = Undefined,
+        **kwargs: t.Any,
+    ) -> None:
+        super().__init__(None, default_value=default_value, **kwargs)
+
+    def __getattribute__(self, name):
+        if name == "values" and object.__getattribute__(self, name) is None:
+            from IPython.core.pylabtools import _list_matplotlib_backends_and_gui_loops
+
+            self.values = _list_matplotlib_backends_and_gui_loops()
+        return object.__getattribute__(self, name)
+
+
+#-----------------------------------------------------------------------------
+# Main classes and functions
+#-----------------------------------------------------------------------------
+
+class InteractiveShellApp(Configurable):
+    """A Mixin for applications that start InteractiveShell instances.
+
+    Provides configurables for loading extensions and executing files
+    as part of configuring a Shell environment.
+
+    The following methods should be called by the :meth:`initialize` method
+    of the subclass:
+
+      - :meth:`init_path`
+      - :meth:`init_shell` (to be implemented by the subclass)
+      - :meth:`init_gui_pylab`
+      - :meth:`init_extensions`
+      - :meth:`init_code`
+    """
+    extensions = List(Unicode(),
+        help="A list of dotted module names of IPython extensions to load."
+    ).tag(config=True)
+
+    extra_extensions = List(
+        DottedObjectName(),
+        help="""
+        Dotted module name(s) of one or more IPython extensions to load.
+
+        For specifying extra extensions to load on the command-line.
+
+        .. versionadded:: 7.10
+        """,
+    ).tag(config=True)
+
+    reraise_ipython_extension_failures = Bool(False,
+        help="Reraise exceptions encountered loading IPython extensions?",
+    ).tag(config=True)
+
+    # Extensions that are always loaded (not configurable)
+    default_extensions = List(Unicode(), [u'storemagic']).tag(config=False)
+
+    hide_initial_ns = Bool(True,
+        help="""Should variables loaded at startup (by startup files, exec_lines, etc.)
+        be hidden from tools like %who?"""
+    ).tag(config=True)
+
+    exec_files = List(Unicode(),
+        help="""List of files to run at IPython startup."""
+    ).tag(config=True)
+    exec_PYTHONSTARTUP = Bool(True,
+        help="""Run the file referenced by the PYTHONSTARTUP environment
+        variable at IPython startup."""
+    ).tag(config=True)
+    file_to_run = Unicode('',
+        help="""A file to be run""").tag(config=True)
+
+    exec_lines = List(Unicode(),
+        help="""lines of code to run at IPython startup."""
+    ).tag(config=True)
+    code_to_run = Unicode("", help="Execute the given command string.").tag(config=True)
+    module_to_run = Unicode("", help="Run the module as a script.").tag(config=True)
+    gui = CaselessStrEnum(
+        gui_keys,
+        allow_none=True,
+        help="Enable GUI event loop integration with any of {0}.".format(gui_keys),
+    ).tag(config=True)
+    matplotlib = MatplotlibBackendCaselessStrEnum(
+        allow_none=True,
+        help="""Configure matplotlib for interactive use with
+        the default matplotlib backend. The exact options available
+        depend on what Matplotlib provides at runtime.""",
+    ).tag(config=True)
+    pylab = MatplotlibBackendCaselessStrEnum(
+        allow_none=True,
+        help="""Pre-load matplotlib and numpy for interactive use,
+        selecting a particular matplotlib backend and loop integration.
+        The exact options available depend on what Matplotlib provides at runtime.
+        """,
+    ).tag(config=True)
+    pylab_import_all = Bool(
+        True,
+        help="""If true, IPython will populate the user namespace with numpy, pylab, etc.
+        and an ``import *`` is done from numpy and pylab, when using pylab mode.
+
+        When False, pylab mode should not import any names into the user namespace.
+        """,
+    ).tag(config=True)
+    ignore_cwd = Bool(
+        False,
+        help="""If True, IPython will not add the current working directory to sys.path.
+        When False, the current working directory is added to sys.path, allowing imports
+        of modules defined in the current directory."""
+    ).tag(config=True)
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
+                     allow_none=True)
+    # whether interact-loop should start
+    interact = Bool(True)
+
+    user_ns = Instance(dict, args=None, allow_none=True)
+    @observe('user_ns')
+    def _user_ns_changed(self, change):
+        if self.shell is not None:
+            self.shell.user_ns = change['new']
+            self.shell.init_user_ns()
+
+    def init_path(self):
+        """Add current working directory, '', to sys.path
+
+        Unless disabled by ignore_cwd config or sys.flags.safe_path.
+
+        Unlike Python's default, we insert before the first `site-packages`
+        or `dist-packages` directory,
+        so that it is after the standard library.
+
+        .. versionchanged:: 7.2
+            Try to insert after the standard library, instead of first.
+        .. versionchanged:: 8.0
+            Allow optionally not including the current directory in sys.path
+        .. versionchanged:: 9.7
+            Respect sys.flags.safe_path (PYTHONSAFEPATH and -P flag)
+        """
+        if "" in sys.path or self.ignore_cwd or sys.flags.safe_path:
+            return
+        for idx, path in enumerate(sys.path):
+            parent, last_part = os.path.split(path)
+            if last_part in {'site-packages', 'dist-packages'}:
+                break
+        else:
+            # no site-packages or dist-packages found (?!)
+            # back to original behavior of inserting at the front
+            idx = 0
+        sys.path.insert(idx, '')
+
+    def init_shell(self):
+        raise NotImplementedError("Override in subclasses")
+
+    def init_gui_pylab(self):
+        """Enable GUI event loop integration, taking pylab into account."""
+        enable = False
+        shell = self.shell
+        if self.pylab:
+            enable = lambda key: shell.enable_pylab(key, import_all=self.pylab_import_all)
+            key = self.pylab
+        elif self.matplotlib:
+            enable = shell.enable_matplotlib
+            key = self.matplotlib
+        elif self.gui:
+            enable = shell.enable_gui
+            key = self.gui
+
+        if not enable:
+            return
+
+        try:
+            r = enable(key)
+        except ImportError:
+            self.log.warning("Eventloop or matplotlib integration failed. Is matplotlib installed?")
+            self.shell.showtraceback()
+            return
+        except Exception:
+            self.log.warning("GUI event loop or pylab initialization failed")
+            self.shell.showtraceback()
+            return
+
+        if isinstance(r, tuple):
+            gui, backend = r[:2]
+            self.log.info("Enabling GUI event loop integration, "
+                      "eventloop=%s, matplotlib=%s", gui, backend)
+            if key == "auto":
+                print("Using matplotlib backend: %s" % backend)
+        else:
+            gui = r
+            self.log.info("Enabling GUI event loop integration, "
+                      "eventloop=%s", gui)
+
+    def init_extensions(self):
+        """Load all IPython extensions in IPythonApp.extensions.
+
+        This uses the :meth:`ExtensionManager.load_extensions` to load all
+        the extensions listed in ``self.extensions``.
+        """
+        try:
+            self.log.debug("Loading IPython extensions...")
+            extensions = (
+                self.default_extensions + self.extensions + self.extra_extensions
+            )
+            for ext in extensions:
+                try:
+                    self.log.info("Loading IPython extension: %s", ext)
+                    self.shell.extension_manager.load_extension(ext)
+                except:
+                    if self.reraise_ipython_extension_failures:
+                        raise
+                    msg = ("Error in loading extension: {ext}\n"
+                           "Check your config files in {location}".format(
+                               ext=ext,
+                               location=self.profile_dir.location
+                           ))
+                    self.log.warning(msg, exc_info=True)
+        except:
+            if self.reraise_ipython_extension_failures:
+                raise
+            self.log.warning("Unknown error in loading extensions:", exc_info=True)
+
+    def init_code(self):
+        """run the pre-flight code, specified via exec_lines"""
+        self._run_startup_files()
+        self._run_exec_lines()
+        self._run_exec_files()
+
+        # Hide variables defined here from %who etc.
+        if self.hide_initial_ns:
+            self.shell.user_ns_hidden.update(self.shell.user_ns)
+
+        # command-line execution (ipython -i script.py, ipython -m module)
+        # should *not* be excluded from %whos
+        self._run_cmd_line_code()
+        self._run_module()
+
+        # flush output, so itwon't be attached to the first cell
+        sys.stdout.flush()
+        sys.stderr.flush()
+        self.shell._sys_modules_keys = set(sys.modules.keys())
+
+    def _run_exec_lines(self):
+        """Run lines of code in IPythonApp.exec_lines in the user's namespace."""
+        if not self.exec_lines:
+            return
+        try:
+            self.log.debug("Running code from IPythonApp.exec_lines...")
+            for line in self.exec_lines:
+                try:
+                    self.log.info("Running code in user namespace: %s" %
+                                  line)
+                    self.shell.run_cell(line, store_history=False)
+                except:
+                    self.log.warning("Error in executing line in user "
+                                  "namespace: %s" % line)
+                    self.shell.showtraceback()
+        except:
+            self.log.warning("Unknown error in handling IPythonApp.exec_lines:")
+            self.shell.showtraceback()
+
+    def _exec_file(self, fname, shell_futures=False):
+        try:
+            full_filename = filefind(fname, [u'.', self.ipython_dir])
+        except IOError:
+            self.log.warning("File not found: %r"%fname)
+            return
+        # Make sure that the running script gets a proper sys.argv as if it
+        # were run from a system shell.
+        save_argv = sys.argv
+        sys.argv = [full_filename] + self.extra_args[1:]
+        try:
+            if os.path.isfile(full_filename):
+                self.log.info("Running file in user namespace: %s" %
+                              full_filename)
+                # Ensure that __file__ is always defined to match Python
+                # behavior.
+                with preserve_keys(self.shell.user_ns, '__file__'):
+                    self.shell.user_ns['__file__'] = fname
+                    if full_filename.endswith('.ipy') or full_filename.endswith('.ipynb'):
+                        self.shell.safe_execfile_ipy(full_filename,
+                                                     shell_futures=shell_futures)
+                    else:
+                        # default to python, even without extension
+                        self.shell.safe_execfile(full_filename,
+                                                 self.shell.user_ns,
+                                                 shell_futures=shell_futures,
+                                                 raise_exceptions=True)
+        finally:
+            sys.argv = save_argv
+
+    def _run_startup_files(self):
+        """Run files from profile startup directory"""
+        startup_dirs = [self.profile_dir.startup_dir] + [
+            os.path.join(p, 'startup') for p in chain(ENV_CONFIG_DIRS, SYSTEM_CONFIG_DIRS)
+        ]
+        startup_files = []
+
+        if self.exec_PYTHONSTARTUP and os.environ.get('PYTHONSTARTUP', False) and \
+                not (self.file_to_run or self.code_to_run or self.module_to_run):
+            python_startup = os.environ['PYTHONSTARTUP']
+            self.log.debug("Running PYTHONSTARTUP file %s...", python_startup)
+            try:
+                self._exec_file(python_startup)
+            except:
+                self.log.warning("Unknown error in handling PYTHONSTARTUP file %s:", python_startup)
+                self.shell.showtraceback()
+        for startup_dir in startup_dirs[::-1]:
+            startup_files += glob.glob(os.path.join(startup_dir, '*.py'))
+            startup_files += glob.glob(os.path.join(startup_dir, '*.ipy'))
+        if not startup_files:
+            return
+
+        self.log.debug("Running startup files from %s...", startup_dir)
+        try:
+            for fname in sorted(startup_files):
+                self._exec_file(fname)
+        except:
+            self.log.warning("Unknown error in handling startup files:")
+            self.shell.showtraceback()
+
+    def _run_exec_files(self):
+        """Run files from IPythonApp.exec_files"""
+        if not self.exec_files:
+            return
+
+        self.log.debug("Running files in IPythonApp.exec_files...")
+        try:
+            for fname in self.exec_files:
+                self._exec_file(fname)
+        except:
+            self.log.warning("Unknown error in handling IPythonApp.exec_files:")
+            self.shell.showtraceback()
+
+    def _run_cmd_line_code(self):
+        """Run code or file specified at the command-line"""
+        if self.code_to_run:
+            line = self.code_to_run
+            try:
+                self.log.info("Running code given at command line (c=): %s" %
+                              line)
+                self.shell.run_cell(line, store_history=False)
+            except:
+                self.log.warning("Error in executing line in user namespace: %s" %
+                              line)
+                self.shell.showtraceback()
+                if not self.interact:
+                    self.exit(1)
+
+        # Like Python itself, ignore the second if the first of these is present
+        elif self.file_to_run:
+            fname = self.file_to_run
+            if os.path.isdir(fname):
+                fname = os.path.join(fname, "__main__.py")
+            if not os.path.exists(fname):
+                self.log.warning("File '%s' doesn't exist", fname)
+                if not self.interact:
+                    self.exit(2)
+            try:
+                self._exec_file(fname, shell_futures=True)
+            except:
+                self.shell.showtraceback(tb_offset=4)
+                if not self.interact:
+                    self.exit(1)
+
+    def _run_module(self):
+        """Run module specified at the command-line."""
+        if self.module_to_run:
+            # Make sure that the module gets a proper sys.argv as if it were
+            # run using `python -m`.
+            save_argv = sys.argv
+            sys.argv = [sys.executable] + self.extra_args
+            try:
+                self.shell.safe_run_module(self.module_to_run,
+                                           self.shell.user_ns)
+            finally:
+                sys.argv = save_argv
diff --git a/IPython/core/splitinput.py b/IPython/core/splitinput.py
old mode 100755
new mode 100644
index 880e18318e9..6acbb0c7d43
--- a/IPython/core/splitinput.py
+++ b/IPython/core/splitinput.py
@@ -1,91 +1,155 @@
-#!/usr/bin/env python
-# encoding: utf-8
 """
-Simple utility for splitting user input.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
+Simple utility for splitting user input. This is used by both inputsplitter and
+prefilter.
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Imports
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 import re
 import sys
+import warnings
 
-#-----------------------------------------------------------------------------
-# Main function
-#-----------------------------------------------------------------------------
+from IPython.core.oinspect import OInfo
 
+# -----------------------------------------------------------------------------
+# Main function
+# -----------------------------------------------------------------------------
 
 # RegExp for splitting line contents into pre-char//first word-method//rest.
 # For clarity, each group in on one line.
 
-# WARNING: update the regexp if the escapes in interactiveshell are changed, as they
-# are hardwired in.
+# WARNING: update the regexp if the escapes in interactiveshell are changed, as
+# they are hardwired in.
 
 # Although it's not solely driven by the regex, note that:
 # ,;/% only trigger if they are the first character on the line
-# ! and !! trigger if they are first char(s) *or* follow an indent 
+# ! and !! trigger if they are first char(s) *or* follow an indent
 # ? triggers as first or last char.
 
-# The three parts of the regex are:
-#  1) pre:     pre_char *or* initial whitespace 
-#  2) ifun:    first word/method (mix of \w and '.')
-#  3) the_rest: rest of line (separated from ifun by space if non-empty)
-line_split = re.compile(r'^([,;/%?]|!!?|\s*)'
-                        r'\s*([\w\.]+)'
-                        r'(\s+.*$|$)')
-
-# r'[\w\.]+'
-# r'\s*=\s*%.*'
-
-def split_user_input(line, pattern=None):
-    """Split user input into pre-char/whitespace, function part and rest.
-
-    This is currently handles lines with '=' in them in a very inconsistent
-    manner.
+line_split = re.compile(
+    r"""
+             ^(\s*)               # any leading space
+             ([,;/%]|!!?|\?\??)?  # escape character or characters
+             \s*(%{0,2}[\w\.\*]*)     # function/method, possibly with leading %
+                                  # to correctly treat things like '?%magic'
+             (.*?$|$)             # rest of line
+             """,
+    re.VERBOSE,
+)
+
+
+def split_user_input(
+    line: str, pattern: re.Pattern[str] | None = None
+) -> tuple[str, str, str, str]:
+    """Split user input into initial whitespace, escape character, function part
+    and the rest.
     """
-    # We need to ensure that the rest of this routine deals only with unicode
-    if type(line)==str:
-        codec = sys.stdin.encoding
-        if codec is None:
-            codec = 'utf-8'
-        line = line.decode(codec)
-        
+    assert isinstance(line, str)
+
     if pattern is None:
         pattern = line_split
     match = pattern.match(line)
     if not match:
-        # print "match failed for line '%s'" % line
+        # print("match failed for line '%s'" % line)
         try:
-            ifun, the_rest = line.split(None,1)
+            ifun, the_rest = line.split(None, 1)
         except ValueError:
-            # print "split failed for line '%s'" % line
-            ifun, the_rest = line, u''
-        pre = re.match('^(\s*)(.*)',line).groups()[0]
+            # print("split failed for line '%s'" % line)
+            ifun, the_rest = line, ""
+        pre = re.match(r"^(\s*)(.*)", line).groups()[0]
+        esc = ""
     else:
-        pre,ifun,the_rest = match.groups()
-
-    # ifun has to be a valid python identifier, so it better encode into
-    # ascii.  We do still make it a unicode string so that we consistently
-    # return unicode, but it will be one that is guaranteed to be pure ascii
-    try:
-        ifun = unicode(ifun.encode('ascii'))
-    except UnicodeEncodeError:
-        the_rest = ifun + u' ' + the_rest
-        ifun = u''
-
-    #print 'line:<%s>' % line # dbg
-    #print 'pre <%s> ifun <%s> rest <%s>' % (pre,ifun.strip(),the_rest) # dbg
-    return pre, ifun.strip(), the_rest.lstrip()
+        pre, esc, ifun, the_rest = match.groups()
+
+    # print('line:<%s>' % line)  # dbg
+    # print('pre <%s> ifun <%s> rest <%s>' % (pre,ifun.strip(),the_rest))  # dbg
+    return pre, esc or "", ifun.strip(), the_rest
+
+
+class LineInfo:
+    """A single line of input and associated info.
+
+    Includes the following as properties:
+
+    line
+      The original, raw line
+
+    continue_prompt
+      Is this line a continuation in a sequence of multiline input?
+
+    pre
+      Any leading whitespace.
+
+    esc
+      The escape character(s) in pre or the empty string if there isn't one.
+      Note that '!!' and '??' are possible values for esc. Otherwise it will
+      always be a single character.
+
+    ifun
+      The 'function part', which is basically the maximal initial sequence
+      of valid python identifiers and the '.' character. This is what is
+      checked for alias and magic transformations, used for auto-calling,
+      etc. In contrast to Python identifiers, it may start with "%" and contain
+      "*".
+
+    the_rest
+      Everything else on the line.
+
+    raw_the_rest
+      the_rest without whitespace stripped.
+    """
+
+    line: str
+    continue_prompt: bool
+    pre: str
+    esc: str
+    ifun: str
+    raw_the_rest: str
+    the_rest: str
+    pre_char: str
+    pre_whitespace: str
+
+    def __init__(self, line: str, continue_prompt: bool = False) -> None:
+        assert isinstance(line, str)
+        self.line = line
+        self.continue_prompt = continue_prompt
+        self.pre, self.esc, self.ifun, self.raw_the_rest = split_user_input(line)
+        self.the_rest = self.raw_the_rest.lstrip()
+
+        self.pre_char = self.pre.strip()
+        if self.pre_char:
+            self.pre_whitespace = ""  # No whitespace allowed before esc chars
+        else:
+            self.pre_whitespace = self.pre
+
+    def ofind(self, ip) -> OInfo:
+        """Do a full, attribute-walking lookup of the ifun in the various
+        namespaces for the given IPython InteractiveShell instance.
+
+        Return a dict with keys: {found, obj, ospace, ismagic}
+
+        Note: can cause state changes because of calling getattr, but should
+        only be run if autocall is on and if the line hasn't matched any
+        other, less dangerous handlers.
+
+        Does cache the results of the call, so can be called multiple times
+        without worrying about *further* damaging state.
+
+        .. deprecated:: 9.8
+            Use ``shell._ofind(line_info.ifun)`` directly instead.
+        """
+        warnings.warn(
+            "LineInfo.ofind() is deprecated since IPython 9.9. "
+            "Use shell._ofind(line_info.ifun) directly instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return ip._ofind(self.ifun)
+
+    def __str__(self) -> str:
+        return "LineInfo [%s|%s|%s|%s]" % (self.pre, self.esc, self.ifun, self.the_rest)
+
+    def __repr__(self) -> str:
+        return "<" + str(self) + ">"
diff --git a/IPython/core/tbtools.py b/IPython/core/tbtools.py
new file mode 100644
index 00000000000..dc21e71923c
--- /dev/null
+++ b/IPython/core/tbtools.py
@@ -0,0 +1,555 @@
+import functools
+import inspect
+import pydoc
+import sys
+import types
+import warnings
+from types import TracebackType
+from typing import Any, Optional, Tuple
+from collections.abc import Callable
+
+import stack_data
+from pygments.token import Token
+
+from IPython import get_ipython
+from IPython.core import debugger
+from IPython.utils import path as util_path
+from IPython.utils import py3compat
+from IPython.utils.PyColorize import Theme, TokenStream, theme_table
+
+_sentinel = object()
+INDENT_SIZE = 8
+
+
+@functools.lru_cache
+def count_lines_in_py_file(filename: str) -> int:
+    """
+    Given a filename, returns the number of lines in the file
+    if it ends with the extension ".py". Otherwise, returns 0.
+    """
+    if not filename.endswith(".py"):
+        return 0
+    else:
+        try:
+            with open(filename, "r") as file:
+                s = sum(1 for line in file)
+        except UnicodeError:
+            return 0
+    return s
+
+
+def get_line_number_of_frame(frame: types.FrameType) -> int:
+    """
+    Given a frame object, returns the total number of lines in the file
+    containing the frame's code object, or the number of lines in the
+    frame's source code if the file is not available.
+
+    Parameters
+    ----------
+    frame : FrameType
+        The frame object whose line number is to be determined.
+
+    Returns
+    -------
+    int
+        The total number of lines in the file containing the frame's
+        code object, or the number of lines in the frame's source code
+        if the file is not available.
+    """
+    filename = frame.f_code.co_filename
+    if filename is None:
+        print("No file....")
+        lines, first = inspect.getsourcelines(frame)
+        return first + len(lines)
+    return count_lines_in_py_file(filename)
+
+
+def _safe_string(value: Any, what: Any, func: Any = str) -> str:
+    # Copied from cpython/Lib/traceback.py
+    try:
+        return func(value)
+    except:
+        return f"<{what} {func.__name__}() failed>"
+
+
+def _format_traceback_lines(
+    lines: list[stack_data.Line],
+    theme: Theme,
+    has_colors: bool,
+    lvals_toks: list[TokenStream],
+) -> TokenStream:
+    """
+    Format tracebacks lines with pointing arrow, leading numbers,
+    this assumes the stack have been extracted using stackdata.
+
+
+    Parameters
+    ----------
+    lines : list[Line]
+    """
+    numbers_width = INDENT_SIZE - 1
+    tokens: TokenStream = []
+
+    for stack_line in lines:
+        if stack_line is stack_data.LINE_GAP:
+            toks = [(Token.LinenoEm, "   (...)")]
+            tokens.extend(toks)
+            continue
+
+        lineno = stack_line.lineno
+        line = stack_line.render(pygmented=has_colors).rstrip("\n") + "\n"
+        if stack_line.is_current:
+            # This is the line with the error
+            pad = numbers_width - len(str(lineno))
+            toks = [
+                (Token.LinenoEm, theme.make_arrow(pad)),
+                (Token.LinenoEm, str(lineno)),
+                (Token, " "),
+                (Token, line),
+            ]
+        else:
+            num = "%*s" % (numbers_width, lineno)
+            toks = [
+                (Token.LinenoEm, str(num)),
+                (Token, " "),
+                (Token, line),
+            ]
+
+        tokens.extend(toks)
+        if lvals_toks and stack_line.is_current:
+            for lv in lvals_toks:
+                tokens.append((Token, " " * INDENT_SIZE))
+                tokens.extend(lv)
+                tokens.append((Token, "\n"))
+            # strip the last newline
+            tokens = tokens[:-1]
+
+    return tokens
+
+
+# some internal-use functions
+def text_repr(value: Any) -> str:
+    """Hopefully pretty robust repr equivalent."""
+    # this is pretty horrible but should always return *something*
+    try:
+        return pydoc.text.repr(value)  # type: ignore[call-arg]
+    except KeyboardInterrupt:
+        raise
+    except:
+        try:
+            return repr(value)
+        except KeyboardInterrupt:
+            raise
+        except:
+            try:
+                # all still in an except block so we catch
+                # getattr raising
+                name = getattr(value, "__name__", None)
+                if name:
+                    # ick, recursion
+                    return text_repr(name)
+                klass = getattr(value, "__class__", None)
+                if klass:
+                    return "%s instance" % text_repr(klass)
+                return "UNRECOVERABLE REPR FAILURE"
+            except KeyboardInterrupt:
+                raise
+            except:
+                return "UNRECOVERABLE REPR FAILURE"
+
+
+def eqrepr(value: Any, repr: Callable[[Any], str] = text_repr) -> str:
+    return "=%s" % repr(value)
+
+
+def nullrepr(value: Any, repr: Callable[[Any], str] = text_repr) -> str:
+    return ""
+
+
+def _tokens_filename(
+    em: bool,
+    file: str | None,
+    *,
+    lineno: int | None = None,
+) -> TokenStream:
+    """
+    Format filename lines with custom formatting from caching compiler or `File *.py` by default
+
+    Parameters
+    ----------
+    em: wether bold or not
+    file : str
+    """
+    Normal = Token.NormalEm if em else Token.Normal
+    Filename = Token.FilenameEm if em else Token.Filename
+    ipinst = get_ipython()
+    if (
+        ipinst is not None
+        and (data := ipinst.compile.format_code_name(file)) is not None
+    ):
+        label, name = data
+        if lineno is None:
+            return [
+                (Normal, label),
+                (Normal, " "),
+                (Filename, name),
+            ]
+        else:
+            return [
+                (Normal, label),
+                (Normal, " "),
+                (Filename, name),
+                (Filename, f", line {lineno}"),
+            ]
+    else:
+        name = util_path.compress_user(
+            py3compat.cast_unicode(file, util_path.fs_encoding)
+        )
+        if lineno is None:
+            return [
+                (Normal, "File "),
+                (Filename, name),
+            ]
+        else:
+            return [
+                (Normal, "File "),
+                (Filename, f"{name}:{lineno}"),
+            ]
+
+
+def _simple_format_traceback_lines(
+    lnum: int,
+    index: int,
+    lines: list[tuple[str, tuple[str, bool]]],
+    lvals_toks: list[TokenStream],
+    theme: Theme,
+) -> TokenStream:
+    """
+    Format tracebacks lines with pointing arrow, leading numbers
+
+    This should be equivalent to _format_traceback_lines, but does not rely on stackdata
+    to format the lines
+
+    This is due to the fact that stackdata may be slow on super long and complex files.
+
+    Parameters
+    ==========
+
+    lnum: int
+        number of the target line of code.
+    index: int
+        which line in the list should be highlighted.
+    lines: list[string]
+    lvals_toks: pairs of token type and str
+        Values of local variables, already colored, to inject just after the error line.
+    """
+    for item in lvals_toks:
+        assert isinstance(item, list)
+        for subit in item:
+            assert isinstance(subit[1], str)
+
+    numbers_width = INDENT_SIZE - 1
+    res_toks: TokenStream = []
+    for i, (line, (new_line, err)) in enumerate(lines, lnum - index):
+        if not err:
+            line = new_line
+
+        colored_line = line
+        if i == lnum:
+            # This is the line with the error
+            pad = numbers_width - len(str(i))
+            line_toks = [
+                (Token.LinenoEm, theme.make_arrow(pad)),
+                (Token.LinenoEm, str(lnum)),
+                (Token, " "),
+                (Token, colored_line),
+            ]
+        else:
+            padding_num = "%*s" % (numbers_width, i)
+
+            line_toks = [
+                (Token.LinenoEm, padding_num),
+                (Token, " "),
+                (Token, colored_line),
+            ]
+        res_toks.extend(line_toks)
+
+        if lvals_toks and i == lnum:
+            for lv in lvals_toks:
+                res_toks.extend(lv)
+            # res_toks.extend(lvals_toks)
+    return res_toks
+
+
+class FrameInfo:
+    """
+    Mirror of stack data's FrameInfo, but so that we can bypass highlighting on
+    really long frames.
+    """
+
+    description: Optional[str]
+    filename: Optional[str]
+    lineno: int
+    # number of context lines to use
+    context: Optional[int]
+    raw_lines: list[str]
+    _sd: stack_data.core.FrameInfo
+    frame: Any
+
+    @classmethod
+    def _from_stack_data_FrameInfo(
+        cls, frame_info: stack_data.core.FrameInfo | stack_data.core.RepeatedFrames
+    ) -> "FrameInfo":
+        return cls(
+            getattr(frame_info, "description", None),
+            getattr(frame_info, "filename", None),  # type: ignore[arg-type]
+            getattr(frame_info, "lineno", None),  # type: ignore[arg-type]
+            getattr(frame_info, "frame", None),
+            getattr(frame_info, "code", None),
+            sd=frame_info,
+            context=None,
+        )
+
+    def __init__(
+        self,
+        description: Optional[str],
+        filename: str,
+        lineno: int,
+        frame: Any,
+        code: Optional[types.CodeType],
+        *,
+        sd: Any = None,
+        context: int | None = None,
+    ):
+        assert isinstance(lineno, (int, type(None))), lineno
+        self.description = description
+        self.filename = filename
+        self.lineno = lineno
+        self.frame = frame
+        self.code = code
+        self._sd = sd
+        self.context = context
+
+        # self.lines = []
+        if sd is None:
+            try:
+                # return a list of source lines and a starting line number
+                self.raw_lines = inspect.getsourcelines(frame)[0]
+            except OSError:
+                self.raw_lines = [
+                    "'Could not get source, probably due dynamically evaluated source code.'"
+                ]
+
+    @property
+    def variables_in_executing_piece(self) -> list[Any]:
+        if self._sd is not None:
+            return self._sd.variables_in_executing_piece  # type:ignore[misc]
+        else:
+            return []
+
+    @property
+    def lines(self) -> list[Any]:
+        from executing.executing import NotOneValueFound
+
+        assert self._sd is not None
+        try:
+            return self._sd.lines  # type: ignore[misc]
+        except NotOneValueFound:
+
+            class Dummy:
+                lineno = 0
+                is_current = False
+
+                def render(self, *, pygmented: bool) -> str:
+                    return "<Error retrieving source code with stack_data see ipython/ipython#13598>"
+
+            return [Dummy()]
+
+    @property
+    def executing(self) -> Any:
+        if self._sd is not None:
+            return self._sd.executing
+        else:
+            return None
+
+
+class TBTools:
+    """Basic tools used by all traceback printer classes."""
+
+    # Number of frames to skip when reporting tracebacks
+    tb_offset = 0
+    _theme_name: str
+    _old_theme_name: str
+    call_pdb: bool
+    ostream: Any
+    debugger_cls: Any
+    pdb: Any
+
+    def __init__(
+        self,
+        color_scheme: Any = _sentinel,
+        call_pdb: bool = False,
+        ostream: Any = None,
+        *,
+        debugger_cls: type | None = None,
+        theme_name: str = "nocolor",
+    ):
+        if color_scheme is not _sentinel:
+            assert isinstance(color_scheme, str), color_scheme
+            warnings.warn(
+                "color_scheme is deprecated since IPython 9.0, use theme_name instead, all lowercase",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            theme_name = color_scheme
+        if theme_name in ["Linux", "LightBG", "Neutral", "NoColor"]:
+            warnings.warn(
+                f"Theme names and color schemes are lowercase in IPython 9.0 use {theme_name.lower()} instead",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            theme_name = theme_name.lower()
+        # Whether to call the interactive pdb debugger after printing
+        # tracebacks or not
+        super().__init__()
+        self.call_pdb = call_pdb
+
+        # Output stream to write to.  Note that we store the original value in
+        # a private attribute and then make the public ostream a property, so
+        # that we can delay accessing sys.stdout until runtime.  The way
+        # things are written now, the sys.stdout object is dynamically managed
+        # so a reference to it should NEVER be stored statically.  This
+        # property approach confines this detail to a single location, and all
+        # subclasses can simply access self.ostream for writing.
+        self._ostream = ostream
+
+        # Create color table
+        self.set_theme_name(theme_name)
+        self.debugger_cls = debugger_cls or debugger.Pdb
+
+        if call_pdb:
+            self.pdb = self.debugger_cls()
+        else:
+            self.pdb = None
+
+    def _get_ostream(self) -> Any:
+        """Output stream that exceptions are written to.
+
+        Valid values are:
+
+        - None: the default, which means that IPython will dynamically resolve
+          to sys.stdout.  This ensures compatibility with most tools, including
+          Windows (where plain stdout doesn't recognize ANSI escapes).
+
+        - Any object with 'write' and 'flush' attributes.
+        """
+        return sys.stdout if self._ostream is None else self._ostream
+
+    def _set_ostream(self, val) -> None:  # type:ignore[no-untyped-def]
+        assert val is None or (hasattr(val, "write") and hasattr(val, "flush"))
+        self._ostream = val
+
+    ostream = property(_get_ostream, _set_ostream)
+
+    @staticmethod
+    def _get_chained_exception(exception_value: Any) -> Any:
+        cause = getattr(exception_value, "__cause__", None)
+        if cause:
+            return cause
+        if getattr(exception_value, "__suppress_context__", False):
+            return None
+        return getattr(exception_value, "__context__", None)
+
+    def get_parts_of_chained_exception(
+        self, evalue: BaseException | None
+    ) -> Optional[Tuple[type, BaseException, TracebackType]]:
+        chained_evalue = self._get_chained_exception(evalue)
+
+        if chained_evalue:
+            return (
+                chained_evalue.__class__,
+                chained_evalue,
+                chained_evalue.__traceback__,
+            )
+        return None
+
+    def prepare_chained_exception_message(
+        self, cause: BaseException | None
+    ) -> list[list[str]]:
+        direct_cause = (
+            "\nThe above exception was the direct cause of the following exception:\n"
+        )
+        exception_during_handling = (
+            "\nDuring handling of the above exception, another exception occurred:\n"
+        )
+
+        if cause:
+            message = [[direct_cause]]
+        else:
+            message = [[exception_during_handling]]
+        return message
+
+    @property
+    def has_colors(self) -> bool:
+        assert self._theme_name == self._theme_name.lower()
+        return self._theme_name != "nocolor"
+
+    def set_theme_name(self, name: str) -> None:
+        assert name in theme_table
+        assert name.lower() == name
+        self._theme_name = name
+        # Also set colors of debugger
+        if hasattr(self, "pdb") and self.pdb is not None:
+            self.pdb.set_theme_name(name)
+
+    def set_colors(self, name: str) -> None:
+        """Shorthand access to the color table scheme selector method."""
+
+        # todo emit deprecation
+        warnings.warn(
+            "set_colors is deprecated since IPython 9.0, use set_theme_name instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.set_theme_name(name)
+
+    def color_toggle(self) -> None:
+        """Toggle between the currently active color scheme and nocolor."""
+        if self._theme_name == "nocolor":
+            self._theme_name = self._old_theme_name
+        else:
+            self._old_theme_name = self._theme_name
+            self._theme_name = "nocolor"
+
+    def stb2text(self, stb: list[str]) -> str:
+        """Convert a structured traceback (a list) to a string."""
+        return "\n".join(stb)
+
+    def text(
+        self,
+        etype: type,
+        value: BaseException | None,
+        tb: TracebackType | None,
+        tb_offset: Optional[int] = None,
+        context: int = 5,
+    ) -> str:
+        """Return formatted traceback.
+
+        Subclasses may override this if they add extra arguments.
+        """
+        tb_list = self.structured_traceback(etype, value, tb, tb_offset, context)
+        return self.stb2text(tb_list)
+
+    def structured_traceback(
+        self,
+        etype: type,
+        evalue: BaseException | None,
+        etb: Optional[TracebackType] = None,
+        tb_offset: Optional[int] = None,
+        context: int = 5,
+    ) -> list[str]:
+        """Return a list of traceback frames.
+
+        Must be implemented by each class.
+        """
+        raise NotImplementedError()
diff --git a/IPython/core/tests/refbug.py b/IPython/core/tests/refbug.py
deleted file mode 100644
index b049777f8ac..00000000000
--- a/IPython/core/tests/refbug.py
+++ /dev/null
@@ -1,47 +0,0 @@
-"""Minimal script to reproduce our nasty reference counting bug.
-
-The problem is related to https://bugs.launchpad.net/ipython/+bug/269966
-
-The original fix for that appeared to work, but John D. Hunter found a
-matplotlib example which, when run twice in a row, would break.  The problem
-were references held by open figures to internals of Tkinter.
-
-This code reproduces the problem that John saw, without matplotlib.
-
-This script is meant to be called by other parts of the test suite that call it
-via %run as if it were executed interactively by the user.  As of 2009-04-13,
-test_magic.py calls it.
-"""
-
-#-----------------------------------------------------------------------------
-# Module imports
-#-----------------------------------------------------------------------------
-import sys
-
-from IPython.core import ipapi
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# This needs to be here because nose and other test runners will import
-# this module. Importing this module has potential side effects that we
-# want to prevent.
-if __name__ == '__main__':
-
-    ip = ipapi.get()
-
-    if not '_refbug_cache' in ip.user_ns:
-        ip.user_ns['_refbug_cache'] = []
-
-
-    aglobal = 'Hello'
-    def f():
-        return aglobal
-
-    cache = ip.user_ns['_refbug_cache']
-    cache.append(f)
-
-    def call_f():
-        for func in cache:
-            print 'lowercased:',func().lower()
diff --git a/IPython/core/tests/simpleerr.py b/IPython/core/tests/simpleerr.py
deleted file mode 100644
index 34e697029db..00000000000
--- a/IPython/core/tests/simpleerr.py
+++ /dev/null
@@ -1,32 +0,0 @@
-"""Error script. DO NOT EDIT FURTHER! It will break exception doctests!!!"""
-import sys
-
-def div0():
-    "foo"
-    x = 1
-    y = 0
-    x/y
-
-def sysexit(stat, mode):
-    raise SystemExit(stat, 'Mode = %s' % mode)
-
-def bar(mode):
-    "bar"
-    if mode=='div':
-        div0()
-    elif mode=='exit':
-        try:
-            stat = int(sys.argv[2])
-        except:
-            stat = 1
-        sysexit(stat, mode)
-    else:
-        raise ValueError('Unknown mode')
-
-if __name__ == '__main__':
-    try:
-        mode = sys.argv[1]
-    except IndexError:
-        mode = 'div'
-
-    bar(mode)
diff --git a/IPython/core/tests/test_application.py b/IPython/core/tests/test_application.py
deleted file mode 100644
index 24e0f61f519..00000000000
--- a/IPython/core/tests/test_application.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# coding: utf-8
-"""Tests for IPython.core.application"""
-
-import os
-import tempfile
-
-from IPython.core.application import Application
-
-def test_unicode_cwd():
-    """Check that IPython starts with non-ascii characters in the path."""
-    wd = tempfile.mkdtemp(suffix=u"€")
-    
-    old_wd = os.getcwdu()
-    os.chdir(wd)
-    #raise Exception(repr(os.getcwd()))
-    try:
-        app = Application()
-        # The lines below are copied from Application.initialize()
-        app.create_default_config()
-        app.log_default_config()
-        app.set_default_config_log_level()
-
-        # Find resources needed for filesystem access, using information from
-        # the above two
-        app.find_ipython_dir()
-        app.find_resources()
-        app.find_config_file_name()
-        app.find_config_file_paths()
-
-        # File-based config
-        app.pre_load_file_config()
-        app.load_file_config(suppress_errors=False)
-    finally:
-        os.chdir(old_wd)
-        
-def test_unicode_ipdir():
-    """Check that IPython starts with non-ascii characters in the IP dir."""
-    ipdir = tempfile.mkdtemp(suffix=u"€")
-    
-    # Create the config file, so it tries to load it.
-    with open(os.path.join(ipdir, 'ipython_config.py'), "w") as f:
-        pass
-    
-    old_ipdir1 = os.environ.pop("IPYTHONDIR", None)
-    old_ipdir2 = os.environ.pop("IPYTHON_DIR", None)
-    os.environ["IPYTHONDIR"] = ipdir.encode("utf-8")
-    try:
-        app = Application()
-        # The lines below are copied from Application.initialize()
-        app.create_default_config()
-        app.log_default_config()
-        app.set_default_config_log_level()
-
-        # Find resources needed for filesystem access, using information from
-        # the above two
-        app.find_ipython_dir()
-        app.find_resources()
-        app.find_config_file_name()
-        app.find_config_file_paths()
-
-        # File-based config
-        app.pre_load_file_config()
-        app.load_file_config(suppress_errors=False)
-    finally:
-        if old_ipdir1:
-            os.environ["IPYTHONDIR"] = old_ipdir1
-        if old_ipdir2:
-            os.environ["IPYTHONDIR"] = old_ipdir2
diff --git a/IPython/core/tests/test_autocall.py b/IPython/core/tests/test_autocall.py
deleted file mode 100644
index 8db5b491e20..00000000000
--- a/IPython/core/tests/test_autocall.py
+++ /dev/null
@@ -1,43 +0,0 @@
-"""These kinds of tests are less than ideal, but at least they run.
-
-This was an old test that was being run interactively in the top-level tests/
-directory, which we are removing.  For now putting this here ensures at least
-we do run the test, though ultimately this functionality should all be tested
-with better-isolated tests that don't rely on the global instance in iptest.
-"""
-
-def doctest_autocall():
-    """
-    In [1]: def f1(a,b,c):
-       ...:     return a+b+c
-       ...: 
-
-    In [2]: def f2(a):
-       ...:     return a + a
-       ...:   
-
-    In [3]: ;f2 a b c
-    Out[3]: 'a b ca b c'
-
-    In [4]: assert _ == "a b ca b c"
-
-    In [5]: ,f1 a b c
-    Out[5]: 'abc'
-
-    In [6]: assert _ == 'abc'
-
-    In [7]: print _
-    abc
-
-    In [8]: /f1 1,2,3
-    Out[8]: 6
-
-    In [9]: assert _ == 6
-
-    In [10]: /f2 4
-    Out[10]: 8
-
-    In [11]: assert _ == 8
-
-    In [11]: del f1, f2
-    """
diff --git a/IPython/core/tests/test_compilerop.py b/IPython/core/tests/test_compilerop.py
deleted file mode 100644
index e9989db17ba..00000000000
--- a/IPython/core/tests/test_compilerop.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# coding: utf-8
-"""Tests for the compilerop module.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010 The IPython Development Team.
-#
-#  Distributed under the terms of the BSD License.
-#
-#  The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Stdlib imports
-import linecache
-import sys
-
-# Third-party imports
-import nose.tools as nt
-
-# Our own imports
-from IPython.core import compilerop
-
-#-----------------------------------------------------------------------------
-# Test functions
-#-----------------------------------------------------------------------------
-
-def test_code_name():
-    code = 'x=1'
-    name = compilerop.code_name(code)
-    nt.assert_true(name.startswith('<ipython-input-0'))
-
-
-def test_code_name2():
-    code = 'x=1'
-    name = compilerop.code_name(code, 9)
-    nt.assert_true(name.startswith('<ipython-input-9'))
-
-
-def test_cache():
-    """Test the compiler correctly compiles and caches inputs
-    """
-    cp = compilerop.CachingCompiler()
-    ncache = len(linecache.cache)
-    cp.cache('x=1')
-    nt.assert_true(len(linecache.cache) > ncache)
-
-def setUp():
-    # Check we're in a proper Python 2 environment (some imports, such
-    # as GTK, can change the default encoding, which can hide bugs.)
-    nt.assert_equal(sys.getdefaultencoding(), "ascii")
-
-def test_cache_unicode():
-    cp = compilerop.CachingCompiler()
-    ncache = len(linecache.cache)
-    cp.cache(u"t = 'žć�šđ'")
-    nt.assert_true(len(linecache.cache) > ncache)
-
-def test_compiler_check_cache():
-    """Test the compiler properly manages the cache.
-    """
-    # Rather simple-minded tests that just exercise the API
-    cp = compilerop.CachingCompiler()
-    cp.cache('x=1', 99)
-    # Ensure now that after clearing the cache, our entries survive
-    cp.check_cache()
-    for k in linecache.cache:
-        if k.startswith('<ipython-input-99'):
-            break
-    else:
-        raise AssertionError('Entry for input-99 missing from linecache')
diff --git a/IPython/core/tests/test_completer.py b/IPython/core/tests/test_completer.py
deleted file mode 100644
index e3ae238eecf..00000000000
--- a/IPython/core/tests/test_completer.py
+++ /dev/null
@@ -1,158 +0,0 @@
-"""Tests for the IPython tab-completion machinery.
-"""
-#-----------------------------------------------------------------------------
-# Module imports
-#-----------------------------------------------------------------------------
-
-# stdlib
-import os
-import sys
-import unittest
-
-# third party
-import nose.tools as nt
-
-# our own packages
-from IPython.core import completer
-from IPython.utils.tempdir import TemporaryDirectory
-
-#-----------------------------------------------------------------------------
-# Test functions
-#-----------------------------------------------------------------------------
-def test_protect_filename():
-    pairs = [ ('abc','abc'),
-              (' abc',r'\ abc'),
-              ('a bc',r'a\ bc'),
-              ('a  bc',r'a\ \ bc'),
-              ('  bc',r'\ \ bc'),
-              ]
-    # On posix, we also protect parens and other special characters
-    if sys.platform != 'win32':
-        pairs.extend( [('a(bc',r'a\(bc'),
-                       ('a)bc',r'a\)bc'),
-                       ('a( )bc',r'a\(\ \)bc'),
-                       ('a[1]bc', r'a\[1\]bc'),
-                       ('a{1}bc', r'a\{1\}bc'),
-                       ('a#bc', r'a\#bc'),
-                       ('a?bc', r'a\?bc'),
-                       ('a=bc', r'a\=bc'),
-                       ('a\\bc', r'a\\bc'),
-                       ('a|bc', r'a\|bc'),
-                       ('a;bc', r'a\;bc'),
-                       ('a:bc', r'a\:bc'),
-                       ("a'bc", r"a\'bc"),
-                       ('a*bc', r'a\*bc'),
-                       ('a"bc', r'a\"bc'),
-                       ('a^bc', r'a\^bc'),
-                       ('a&bc', r'a\&bc'),
-                       ] )
-    # run the actual tests
-    for s1, s2 in pairs:
-        s1p = completer.protect_filename(s1)
-        nt.assert_equals(s1p, s2)
-
-
-def check_line_split(splitter, test_specs):
-    for part1, part2, split in test_specs:
-        cursor_pos = len(part1)
-        line = part1+part2
-        out = splitter.split_line(line, cursor_pos)
-        nt.assert_equal(out, split)
-
-
-def test_line_split():
-    """Basice line splitter test with default specs."""
-    sp = completer.CompletionSplitter()
-    # The format of the test specs is: part1, part2, expected answer.  Parts 1
-    # and 2 are joined into the 'line' sent to the splitter, as if the cursor
-    # was at the end of part1.  So an empty part2 represents someone hitting
-    # tab at the end of the line, the most common case.
-    t = [('run some/scrip', '', 'some/scrip'),
-         ('run scripts/er', 'ror.py foo', 'scripts/er'),
-         ('echo $HOM', '', 'HOM'),
-         ('print sys.pa', '', 'sys.pa'),
-         ('print(sys.pa', '', 'sys.pa'),
-         ("execfile('scripts/er", '', 'scripts/er'),
-         ('a[x.', '', 'x.'),
-         ('a[x.', 'y', 'x.'),
-         ('cd "some_file/', '', 'some_file/'),
-         ]
-    check_line_split(sp, t)
-    # Ensure splitting works OK with unicode by re-running the tests with
-    # all inputs turned into unicode
-    check_line_split(sp, [ map(unicode, p) for p in t] )
-
-
-def test_unicode_completions():
-    ip = get_ipython()
-    # Some strings that trigger different types of completion.  Check them both
-    # in str and unicode forms
-    s = ['ru', '%ru', 'cd /', 'floa', 'float(x)/']
-    for t in s + map(unicode, s):
-        # We don't need to check exact completion values (they may change
-        # depending on the state of the namespace, but at least no exceptions
-        # should be thrown and the return value should be a pair of text, list
-        # values.
-        text, matches = ip.complete(t)
-        nt.assert_true(isinstance(text, basestring))
-        nt.assert_true(isinstance(matches, list))
-
-
-class CompletionSplitterTestCase(unittest.TestCase):
-    def setUp(self):
-        self.sp = completer.CompletionSplitter()
-
-    def test_delim_setting(self):
-        self.sp.set_delims(' ')
-        nt.assert_equal(self.sp.get_delims(), ' ')
-        nt.assert_equal(self.sp._delim_expr, '[\ ]')
-
-    def test_spaces(self):
-        """Test with only spaces as split chars."""
-        self.sp.delims = ' '
-        t = [('foo', '', 'foo'),
-             ('run foo', '', 'foo'),
-             ('run foo', 'bar', 'foo'),
-             ]
-        check_line_split(self.sp, t)
-
-
-def test_has_open_quotes1():
-    for s in ["'", "'''", "'hi' '"]:
-        nt.assert_equal(completer.has_open_quotes(s), "'")
-
-
-def test_has_open_quotes2():
-    for s in ['"', '"""', '"hi" "']:
-        nt.assert_equal(completer.has_open_quotes(s), '"')
-
-
-def test_has_open_quotes3():
-    for s in ["''", "''' '''", "'hi' 'ipython'"]:
-        nt.assert_false(completer.has_open_quotes(s))
-
-
-def test_has_open_quotes4():
-    for s in ['""', '""" """', '"hi" "ipython"']:
-        nt.assert_false(completer.has_open_quotes(s))
-
-
-def test_file_completions():
-
-    ip = get_ipython()
-    with TemporaryDirectory() as tmpdir:
-        prefix = os.path.join(tmpdir, 'foo')
-        suffixes = map(str, [1,2])
-        names = [prefix+s for s in suffixes]
-        for n in names:
-            open(n, 'w').close()
-
-        # Check simple completion
-        c = ip.complete(prefix)[1]
-        nt.assert_equal(c, names)
-
-        # Now check with a function call
-        cmd = 'a = f("%s' % prefix
-        c = ip.complete(prefix, cmd)[1]
-        comp = [prefix+s for s in suffixes]
-        nt.assert_equal(c, comp)
diff --git a/IPython/core/tests/test_fakemodule.py b/IPython/core/tests/test_fakemodule.py
deleted file mode 100644
index c8f0b3de2e0..00000000000
--- a/IPython/core/tests/test_fakemodule.py
+++ /dev/null
@@ -1,17 +0,0 @@
-"""Tests for the FakeModule objects.
-"""
-
-import nose.tools as nt
-
-from IPython.core.fakemodule import FakeModule, init_fakemod_dict
-
-# Make a fakemod and check a few properties
-def test_mk_fakemod():
-    fm = FakeModule()
-    yield nt.assert_true,fm
-    yield nt.assert_true,lambda : hasattr(fm,'__file__')
-
-def test_mk_fakemod_fromdict():
-    """Test making a FakeModule object with initial data"""
-    fm = FakeModule(dict(hello=True))
-    nt.assert_true(fm.hello)
diff --git a/IPython/core/tests/test_formatters.py b/IPython/core/tests/test_formatters.py
deleted file mode 100644
index ea1b83463fa..00000000000
--- a/IPython/core/tests/test_formatters.py
+++ /dev/null
@@ -1,74 +0,0 @@
-"""Tests for the Formatters.
-"""
-
-from math import pi
-
-try:
-    import numpy
-except:
-    numpy = None
-import nose.tools as nt
-
-from IPython.core.formatters import FormatterABC, PlainTextFormatter
-
-class A(object):
-    def __repr__(self):
-        return 'A()'
-
-class B(A):
-    def __repr__(self):
-        return 'B()'
-
-def foo_printer(obj, pp, cycle):
-    pp.text('foo')
-
-def test_pretty():
-    f = PlainTextFormatter()
-    f.for_type(A, foo_printer)
-    nt.assert_equals(f(A()), 'foo')
-    nt.assert_equals(f(B()), 'foo')
-    f.pprint = False
-    nt.assert_equals(f(A()), 'A()')
-    nt.assert_equals(f(B()), 'B()')
-
-def test_deferred():
-    f = PlainTextFormatter()
-
-def test_precision():
-    """test various values for float_precision."""
-    f = PlainTextFormatter()
-    nt.assert_equals(f(pi), repr(pi))
-    f.float_precision = 0
-    if numpy:
-        po = numpy.get_printoptions()
-        nt.assert_equals(po['precision'], 0)
-    nt.assert_equals(f(pi), '3')
-    f.float_precision = 2
-    if numpy:
-        po = numpy.get_printoptions()
-        nt.assert_equals(po['precision'], 2)
-    nt.assert_equals(f(pi), '3.14')
-    f.float_precision = '%g'
-    if numpy:
-        po = numpy.get_printoptions()
-        nt.assert_equals(po['precision'], 2)
-    nt.assert_equals(f(pi), '3.14159')
-    f.float_precision = '%e'
-    nt.assert_equals(f(pi), '3.141593e+00')
-    f.float_precision = ''
-    if numpy:
-        po = numpy.get_printoptions()
-        nt.assert_equals(po['precision'], 8)
-    nt.assert_equals(f(pi), repr(pi))
-
-def test_bad_precision():
-    """test various invalid values for float_precision."""
-    f = PlainTextFormatter()
-    def set_fp(p):
-        f.float_precision=p
-    nt.assert_raises(ValueError, set_fp, '%')
-    nt.assert_raises(ValueError, set_fp, '%.3f%i')
-    nt.assert_raises(ValueError, set_fp, 'foo')
-    nt.assert_raises(ValueError, set_fp, -1)
-
-
diff --git a/IPython/core/tests/test_handlers.py b/IPython/core/tests/test_handlers.py
deleted file mode 100644
index 483a8d7dfae..00000000000
--- a/IPython/core/tests/test_handlers.py
+++ /dev/null
@@ -1,172 +0,0 @@
-"""Tests for input handlers.
-"""
-#-----------------------------------------------------------------------------
-# Module imports
-#-----------------------------------------------------------------------------
-
-# third party
-import nose.tools as nt
-
-# our own packages
-from IPython.core import autocall
-from IPython.testing import decorators as dec
-from IPython.testing.globalipapp import get_ipython
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# Get the public instance of IPython
-ip = get_ipython()
-
-failures = []
-num_tests = 0
-
-#-----------------------------------------------------------------------------
-# Test functions
-#-----------------------------------------------------------------------------
-
-class CallableIndexable(object):
-    def __getitem__(self, idx): return True
-    def __call__(self, *args, **kws): return True
-
-
-class Autocallable(autocall.IPyAutocall):
-    def __call__(self):
-        return "called"
-
-
-def run(tests):
-    """Loop through a list of (pre, post) inputs, where pre is the string
-    handed to ipython, and post is how that string looks after it's been
-    transformed (i.e. ipython's notion of _i)"""
-    for pre, post in tests:
-        global num_tests
-        num_tests += 1        
-        actual = ip.prefilter_manager.prefilter_lines(pre)
-        if actual != None:
-            actual = actual.rstrip('\n')
-        if actual != post:
-            failures.append('Expected %r to become %r, found %r' % (
-                pre, post, actual))
-
-
-def test_handlers():
-    # alias expansion
-
-    # We're using 'true' as our syscall of choice because it doesn't
-    # write anything to stdout.
-
-    # Turn off actual execution of aliases, because it's noisy
-    old_system_cmd = ip.system
-    ip.system = lambda cmd: None
-
-
-    ip.alias_manager.alias_table['an_alias'] = (0, 'true')
-    # These are useful for checking a particular recursive alias issue
-    ip.alias_manager.alias_table['top'] = (0, 'd:/cygwin/top')
-    ip.alias_manager.alias_table['d'] =   (0, 'true')
-    run([("an_alias",    'get_ipython().system(u"true ")'),     # alias
-         # Below: recursive aliases should expand whitespace-surrounded
-         # chars, *not* initial chars which happen to be aliases:
-         ("top",         'get_ipython().system(u"d:/cygwin/top ")'),
-         ])
-    ip.system = old_system_cmd
-
-    call_idx = CallableIndexable()
-    ip.user_ns['call_idx'] = call_idx
-
-    # For many of the below, we're also checking that leading whitespace
-    # turns off the esc char, which it should unless there is a continuation
-    # line.
-    run([('"no change"', '"no change"'),             # normal
-         ("!true",       'get_ipython().system(u"true")'),      # shell_escapes
-         ("!! true",     'get_ipython().magic(u"sx  true")'),   # shell_escapes + magic
-         ("!!true",      'get_ipython().magic(u"sx true")'),    # shell_escapes + magic
-         ("%lsmagic",    'get_ipython().magic(u"lsmagic ")'),   # magic
-         ("lsmagic",     'get_ipython().magic(u"lsmagic ")'),   # magic
-         #("a = b # PYTHON-MODE", '_i'),          # emacs -- avoids _in cache
-
-         # post-esc-char whitespace goes inside
-         ("! true",   'get_ipython().system(u" true")'),  
-
-         # handle_help
-
-         # These are weak tests -- just looking at what the help handlers
-         # logs, which is not how it really does its work.  But it still
-         # lets us check the key paths through the handler.
-
-         ("x=1 # what?", "x=1 # what?"), # no help if valid python
-         ])
-
-    # multi_line_specials
-    ip.prefilter_manager.multi_line_specials = False
-    # W/ multi_line_specials off, leading ws kills esc chars/autoexpansion
-    run([
-        ('if 1:\n    !true',    'if 1:\n    !true'),
-        ('if 1:\n    lsmagic',  'if 1:\n    lsmagic'),
-        ('if 1:\n    an_alias', 'if 1:\n    an_alias'),
-        ])
-
-    ip.prefilter_manager.multi_line_specials = True
-    # initial indents must be preserved.
-    run([
-         ('if 1:\n    !true',    'if 1:\n    get_ipython().system(u"true")'),
-         ('if 2:\n    lsmagic',  'if 2:\n    get_ipython().magic(u"lsmagic ")'),
-         ('if 1:\n    an_alias', 'if 1:\n    get_ipython().system(u"true ")'),
-         # Weird one
-         ('if 1:\n    !!true',   'if 1:\n    get_ipython().magic(u"sx true")'),
-
-         # Even with m_l_s on, autocall is off even with special chars
-         ('if 1:\n    /fun 1 2', 'if 1:\n    /fun 1 2'), 
-         ('if 1:\n    ;fun 1 2', 'if 1:\n    ;fun 1 2'),
-         ('if 1:\n    ,fun 1 2', 'if 1:\n    ,fun 1 2'),
-         ('if 1:\n    ?fun 1 2', 'if 1:\n    ?fun 1 2'),
-         # What about !!  
-         ])
-
-    # Objects which are instances of IPyAutocall are *always* autocalled
-    autocallable = Autocallable()
-    ip.user_ns['autocallable'] = autocallable
-
-    # auto 
-    ip.magic('autocall 0')
-    # Only explicit escapes or instances of IPyAutocallable should get
-    # expanded
-    run([
-        ('len "abc"',       'len "abc"'),        
-        ('autocallable',    'autocallable()'),     
-        (",list 1 2 3",     'list("1", "2", "3")'),
-        (";list 1 2 3",     'list("1 2 3")'),      
-        ("/len range(1,4)", 'len(range(1,4))'),
-        ])
-    ip.magic('autocall 1')
-    run([
-        (",list 1 2 3", 'list("1", "2", "3")'),
-        (";list 1 2 3", 'list("1 2 3")'),      
-        ("/len range(1,4)", 'len(range(1,4))'),
-        ('len "abc"', 'len("abc")'),
-        ('len "abc";', 'len("abc");'),  # ; is special -- moves out of parens
-        # Autocall is turned off if first arg is [] and the object
-        # is both callable and indexable.  Like so:
-        ('len [1,2]', 'len([1,2])'),      # len doesn't support __getitem__...
-        ('call_idx [1]', 'call_idx [1]'), # call_idx *does*..
-        ('call_idx 1', 'call_idx(1)'),
-        ('len', 'len '), # only at 2 does it auto-call on single args
-        ])
-    ip.magic('autocall 2')
-    run([
-        (",list 1 2 3", 'list("1", "2", "3")'),
-        (";list 1 2 3", 'list("1 2 3")'),      
-        ("/len range(1,4)", 'len(range(1,4))'),
-        ('len "abc"', 'len("abc")'),
-        ('len "abc";', 'len("abc");'),
-        ('len [1,2]', 'len([1,2])'),   
-        ('call_idx [1]', 'call_idx [1]'),
-        ('call_idx 1', 'call_idx(1)'),
-        # This is what's different:
-        ('len', 'len()'), # only at 2 does it auto-call on single args
-        ])
-    ip.magic('autocall 1')
-
-    nt.assert_equals(failures, [])
diff --git a/IPython/core/tests/test_history.py b/IPython/core/tests/test_history.py
deleted file mode 100644
index 9a74a4ec3f9..00000000000
--- a/IPython/core/tests/test_history.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# coding: utf-8
-"""Tests for the IPython tab-completion machinery.
-"""
-#-----------------------------------------------------------------------------
-# Module imports
-#-----------------------------------------------------------------------------
-
-# stdlib
-import os
-import sys
-import unittest
-
-# third party
-import nose.tools as nt
-
-# our own packages
-from IPython.utils.tempdir import TemporaryDirectory
-from IPython.core.history import HistoryManager, extract_hist_ranges
-
-def setUp():
-    nt.assert_equal(sys.getdefaultencoding(), "ascii")
-
-def test_history():
-    ip = get_ipython()
-    with TemporaryDirectory() as tmpdir:
-        hist_manager_ori = ip.history_manager
-        hist_file = os.path.join(tmpdir, 'history.sqlite')
-        try:
-            ip.history_manager = HistoryManager(shell=ip, hist_file=hist_file)
-            hist = ['a=1', 'def f():\n    test = 1\n    return test', u"b='€Æ¾÷ß'"]
-            for i, h in enumerate(hist, start=1):
-                ip.history_manager.store_inputs(i, h)
-            
-            ip.history_manager.db_log_output = True
-            # Doesn't match the input, but we'll just check it's stored.
-            ip.history_manager.output_hist_reprs[3] = "spam"
-            ip.history_manager.store_output(3)
-            
-            nt.assert_equal(ip.history_manager.input_hist_raw, [''] + hist)
-            
-            
-            # New session
-            ip.history_manager.reset()
-            newcmds = ["z=5","class X(object):\n    pass", "k='p'"]
-            for i, cmd in enumerate(newcmds, start=1):
-                ip.history_manager.store_inputs(i, cmd)
-            gothist = ip.history_manager.get_range(start=1, stop=4)
-            nt.assert_equal(list(gothist), zip([0,0,0],[1,2,3], newcmds))
-            # Previous session:
-            gothist = ip.history_manager.get_range(-1, 1, 4)
-            nt.assert_equal(list(gothist), zip([1,1,1],[1,2,3], hist))
-            
-            # Check get_hist_tail
-            gothist = ip.history_manager.get_tail(4, output=True,
-                                                    include_latest=True)
-            expected = [(1, 3, (hist[-1], "spam")),
-                        (2, 1, (newcmds[0], None)),
-                        (2, 2, (newcmds[1], None)),
-                        (2, 3, (newcmds[2], None)),]
-            nt.assert_equal(list(gothist), expected)
-            
-            gothist = ip.history_manager.get_tail(2)
-            expected = [(2, 1, newcmds[0]),
-                        (2, 2, newcmds[1])]
-            nt.assert_equal(list(gothist), expected)
-            
-            # Check get_hist_search
-            gothist = ip.history_manager.search("*test*")
-            nt.assert_equal(list(gothist), [(1,2,hist[1])] )
-            gothist = ip.history_manager.search("b*", output=True)
-            nt.assert_equal(list(gothist), [(1,3,(hist[2],"spam"))] )
-            
-            # Cross testing: check that magic %save can get previous session.
-            testfilename = os.path.realpath(os.path.join(tmpdir, "test.py"))
-            ip.magic_save(testfilename + " ~1/1-3")
-            testfile = open(testfilename, "r")
-            nt.assert_equal(testfile.read().decode("utf-8"),
-                    "# coding: utf-8\n" + "\n".join(hist))
-            
-            # Duplicate line numbers - check that it doesn't crash, and
-            # gets a new session
-            ip.history_manager.store_inputs(1, "rogue")
-            ip.history_manager.writeout_cache()
-            nt.assert_equal(ip.history_manager.session_number, 3)
-        finally:
-            # Restore history manager
-            ip.history_manager = hist_manager_ori
-
-
-def test_extract_hist_ranges():
-    instr = "1 2/3 ~4/5-6 ~4/7-~4/9 ~9/2-~7/5"
-    expected = [(0, 1, 2),  # 0 == current session
-                (2, 3, 4),
-                (-4, 5, 7),
-                (-4, 7, 10),
-                (-9, 2, None),  # None == to end
-                (-8, 1, None),
-                (-7, 1, 6)]
-    actual = list(extract_hist_ranges(instr))
-    nt.assert_equal(actual, expected)
-    
-def test_magic_rerun():
-    """Simple test for %rerun (no args -> rerun last line)"""
-    ip = get_ipython()
-    ip.run_cell("a = 10")
-    ip.run_cell("a += 1")
-    nt.assert_equal(ip.user_ns["a"], 11)
-    ip.run_cell("%rerun")
-    nt.assert_equal(ip.user_ns["a"], 12)
diff --git a/IPython/core/tests/test_imports.py b/IPython/core/tests/test_imports.py
deleted file mode 100644
index 7f72a1b18e4..00000000000
--- a/IPython/core/tests/test_imports.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-def test_import_completer():
-    from IPython.core import completer
-
-def test_import_crashhandler():
-    from IPython.core import crashhandler
-
-def test_import_debugger():
-    from IPython.core import debugger
-
-def test_import_fakemodule():
-    from IPython.core import fakemodule
-
-def test_import_excolors():
-    from IPython.core import excolors
-
-def test_import_history():
-    from IPython.core import history
-
-def test_import_hooks():
-    from IPython.core import hooks
-
-def test_import_ipapi():
-    from IPython.core import ipapi
-
-def test_import_interactiveshell():
-    from IPython.core import interactiveshell
-
-def test_import_logger():
-    from IPython.core import logger
-
-def test_import_macro():
-    from IPython.core import macro
-
-def test_import_magic():
-    from IPython.core import magic
-
-def test_import_oinspect():
-    from IPython.core import oinspect
-
-def test_import_prefilter():
-    from IPython.core import prefilter
-
-def test_import_prompts():
-    from IPython.core import prompts
-
-def test_import_release():
-    from IPython.core import release
-
-def test_import_shadowns():
-    from IPython.core import shadowns
-
-def test_import_ultratb():
-    from IPython.core import ultratb
-
-def test_import_usage():
-    from IPython.core import usage
diff --git a/IPython/core/tests/test_inputsplitter.py b/IPython/core/tests/test_inputsplitter.py
deleted file mode 100644
index 95ebc203fd2..00000000000
--- a/IPython/core/tests/test_inputsplitter.py
+++ /dev/null
@@ -1,653 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Tests for the inputsplitter module.
-
-Authors
--------
-* Fernando Perez
-* Robert Kern
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-# stdlib
-import unittest
-import sys
-
-# Third party
-import nose.tools as nt
-
-# Our own
-from IPython.core import inputsplitter as isp
-
-#-----------------------------------------------------------------------------
-# Semi-complete examples (also used as tests)
-#-----------------------------------------------------------------------------
-
-# Note: at the bottom, there's a slightly more complete version of this that
-# can be useful during development of code here.
-
-def mini_interactive_loop(input_func):
-    """Minimal example of the logic of an interactive interpreter loop.
-
-    This serves as an example, and it is used by the test system with a fake
-    raw_input that simulates interactive input."""
-
-    from IPython.core.inputsplitter import InputSplitter
-    
-    isp = InputSplitter()
-    # In practice, this input loop would be wrapped in an outside loop to read
-    # input indefinitely, until some exit/quit command was issued.  Here we
-    # only illustrate the basic inner loop.
-    while isp.push_accepts_more():
-        indent = ' '*isp.indent_spaces
-        prompt = '>>> ' + indent
-        line = indent + input_func(prompt)
-        isp.push(line)
-
-    # Here we just return input so we can use it in a test suite, but a real
-    # interpreter would instead send it for execution somewhere.
-    src = isp.source_reset()
-    #print 'Input source was:\n', src  # dbg
-    return src
-
-#-----------------------------------------------------------------------------
-# Test utilities, just for local use
-#-----------------------------------------------------------------------------
-
-def assemble(block):
-    """Assemble a block into multi-line sub-blocks."""
-    return ['\n'.join(sub_block)+'\n' for sub_block in block]
-
-
-def pseudo_input(lines):
-    """Return a function that acts like raw_input but feeds the input list."""
-    ilines = iter(lines)
-    def raw_in(prompt):
-        try:
-            return next(ilines)
-        except StopIteration:
-            return ''
-    return raw_in
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-def test_spaces():
-    tests = [('', 0),
-             (' ', 1),
-             ('\n', 0),
-             (' \n', 1),
-             ('x', 0),
-             (' x', 1),
-             ('  x',2),
-             ('    x',4),
-             # Note: tabs are counted as a single whitespace!
-             ('\tx', 1),
-             ('\t x', 2),
-             ]
-    
-    for s, nsp in tests:
-        nt.assert_equal(isp.num_ini_spaces(s), nsp)
-
-
-def test_remove_comments():
-    tests = [('text', 'text'),
-             ('text # comment', 'text '),
-             ('text # comment\n', 'text \n'),
-             ('text # comment \n', 'text \n'),
-             ('line # c \nline\n','line \nline\n'),
-             ('line # c \nline#c2  \nline\nline #c\n\n',
-              'line \nline\nline\nline \n\n'),
-             ]
-
-    for inp, out in tests:
-        nt.assert_equal(isp.remove_comments(inp), out)
-
-
-def test_get_input_encoding():
-    encoding = isp.get_input_encoding()
-    nt.assert_true(isinstance(encoding, basestring))
-    # simple-minded check that at least encoding a simple string works with the
-    # encoding we got.
-    nt.assert_equal('test'.encode(encoding), 'test')
-
-
-class NoInputEncodingTestCase(unittest.TestCase):
-    def setUp(self):
-        self.old_stdin = sys.stdin
-        class X: pass
-        fake_stdin = X()
-        sys.stdin = fake_stdin
-        
-    def test(self):
-        # Verify that if sys.stdin has no 'encoding' attribute we do the right
-        # thing
-        enc = isp.get_input_encoding()
-        self.assertEqual(enc, 'ascii')
-        
-    def tearDown(self):
-        sys.stdin = self.old_stdin
-
-
-class InputSplitterTestCase(unittest.TestCase):
-    def setUp(self):
-        self.isp = isp.InputSplitter()
-
-    def test_reset(self):
-        isp = self.isp
-        isp.push('x=1')
-        isp.reset()
-        self.assertEqual(isp._buffer, [])
-        self.assertEqual(isp.indent_spaces, 0)
-        self.assertEqual(isp.source, '')
-        self.assertEqual(isp.code, None)
-        self.assertEqual(isp._is_complete, False)
-
-    def test_source(self):
-        self.isp._store('1')
-        self.isp._store('2')
-        self.assertEqual(self.isp.source, '1\n2\n')
-        self.assertTrue(len(self.isp._buffer)>0)
-        self.assertEqual(self.isp.source_reset(), '1\n2\n')
-        self.assertEqual(self.isp._buffer, [])
-        self.assertEqual(self.isp.source, '')
-        
-    def test_indent(self):
-        isp = self.isp # shorthand
-        isp.push('x=1')
-        self.assertEqual(isp.indent_spaces, 0)
-        isp.push('if 1:\n    x=1')
-        self.assertEqual(isp.indent_spaces, 4)
-        isp.push('y=2\n')
-        self.assertEqual(isp.indent_spaces, 0)
-
-    def test_indent2(self):
-        # In cell mode, inputs must be fed in whole blocks, so skip this test
-        if self.isp.input_mode == 'cell': return
-
-        isp = self.isp
-        isp.push('if 1:')
-        self.assertEqual(isp.indent_spaces, 4)
-        isp.push('    x=1')
-        self.assertEqual(isp.indent_spaces, 4)
-        # Blank lines shouldn't change the indent level
-        isp.push(' '*2)
-        self.assertEqual(isp.indent_spaces, 4)
-
-    def test_indent3(self):
-        # In cell mode, inputs must be fed in whole blocks, so skip this test
-        if self.isp.input_mode == 'cell': return
-
-        isp = self.isp
-        # When a multiline statement contains parens or multiline strings, we
-        # shouldn't get confused.
-        isp.push("if 1:")
-        isp.push("    x = (1+\n    2)")
-        self.assertEqual(isp.indent_spaces, 4)
-
-    def test_dedent_pass(self):
-        isp = self.isp # shorthand
-        # should NOT cause dedent
-        isp.push('if 1:\n    passes = 5')
-        self.assertEqual(isp.indent_spaces, 4)
-        isp.push('if 1:\n     pass')
-        self.assertEqual(isp.indent_spaces, 0)
-        isp.push('if 1:\n     pass   ')
-        self.assertEqual(isp.indent_spaces, 0)
-
-    def test_dedent_raise(self):
-        isp = self.isp # shorthand
-        # should NOT cause dedent
-        isp.push('if 1:\n    raised = 4')
-        self.assertEqual(isp.indent_spaces, 4)
-        isp.push('if 1:\n     raise TypeError()')
-        self.assertEqual(isp.indent_spaces, 0)
-        isp.push('if 1:\n     raise')
-        self.assertEqual(isp.indent_spaces, 0)
-        isp.push('if 1:\n     raise      ')
-        self.assertEqual(isp.indent_spaces, 0)
-
-    def test_dedent_return(self):
-        isp = self.isp # shorthand
-        # should NOT cause dedent
-        isp.push('if 1:\n    returning = 4')
-        self.assertEqual(isp.indent_spaces, 4)
-        isp.push('if 1:\n     return 5 + 493')
-        self.assertEqual(isp.indent_spaces, 0)
-        isp.push('if 1:\n     return')
-        self.assertEqual(isp.indent_spaces, 0)
-        isp.push('if 1:\n     return      ')
-        self.assertEqual(isp.indent_spaces, 0)
-        isp.push('if 1:\n     return(0)')
-        self.assertEqual(isp.indent_spaces, 0)
-
-    def test_push(self):
-        isp = self.isp
-        self.assertTrue(isp.push('x=1'))
-
-    def test_push2(self):
-        isp = self.isp
-        self.assertFalse(isp.push('if 1:'))
-        for line in ['  x=1', '# a comment', '  y=2']:
-            self.assertTrue(isp.push(line))
-            
-    def test_push3(self):
-        isp = self.isp
-        isp.push('if True:')
-        isp.push('  a = 1')
-        self.assertFalse(isp.push('b = [1,'))
-            
-    def test_replace_mode(self):
-        isp = self.isp
-        isp.input_mode = 'cell'
-        isp.push('x=1')
-        self.assertEqual(isp.source, 'x=1\n')
-        isp.push('x=2')
-        self.assertEqual(isp.source, 'x=2\n')
-
-    def test_push_accepts_more(self):
-        isp = self.isp
-        isp.push('x=1')
-        self.assertFalse(isp.push_accepts_more())
-
-    def test_push_accepts_more2(self):
-        # In cell mode, inputs must be fed in whole blocks, so skip this test
-        if self.isp.input_mode == 'cell': return
-
-        isp = self.isp
-        isp.push('if 1:')
-        self.assertTrue(isp.push_accepts_more())
-        isp.push('  x=1')
-        self.assertTrue(isp.push_accepts_more())
-        isp.push('')
-        self.assertFalse(isp.push_accepts_more())
-        
-    def test_push_accepts_more3(self):
-        isp = self.isp
-        isp.push("x = (2+\n3)")
-        self.assertFalse(isp.push_accepts_more())
-
-    def test_push_accepts_more4(self):
-        # In cell mode, inputs must be fed in whole blocks, so skip this test
-        if self.isp.input_mode == 'cell': return
-
-        isp = self.isp
-        # When a multiline statement contains parens or multiline strings, we
-        # shouldn't get confused.
-        # FIXME: we should be able to better handle de-dents in statements like
-        # multiline strings and multiline expressions (continued with \ or
-        # parens).  Right now we aren't handling the indentation tracking quite
-        # correctly with this, though in practice it may not be too much of a
-        # problem.  We'll need to see.
-        isp.push("if 1:")
-        isp.push("    x = (2+")
-        isp.push("    3)")
-        self.assertTrue(isp.push_accepts_more())
-        isp.push("    y = 3")
-        self.assertTrue(isp.push_accepts_more())
-        isp.push('')
-        self.assertFalse(isp.push_accepts_more())
-        
-    def test_push_accepts_more5(self):
-        # In cell mode, inputs must be fed in whole blocks, so skip this test
-        if self.isp.input_mode == 'cell': return
-
-        isp = self.isp
-        isp.push('try:')
-        isp.push('    a = 5')
-        isp.push('except:')
-        isp.push('    raise')
-        self.assertTrue(isp.push_accepts_more())
-
-    def test_continuation(self):
-        isp = self.isp
-        isp.push("import os, \\")
-        self.assertTrue(isp.push_accepts_more())
-        isp.push("sys")
-        self.assertFalse(isp.push_accepts_more())
-
-    def test_syntax_error(self):
-        isp = self.isp
-        # Syntax errors immediately produce a 'ready' block, so the invalid
-        # Python can be sent to the kernel for evaluation with possible ipython
-        # special-syntax conversion.
-        isp.push('run foo')
-        self.assertFalse(isp.push_accepts_more())
-
-    def test_unicode(self):
-        self.isp.push(u"Pérez")
-        self.isp.push(u'\xc3\xa9')
-        self.isp.push(u"u'\xc3\xa9'")
-
-class InteractiveLoopTestCase(unittest.TestCase):
-    """Tests for an interactive loop like a python shell.
-    """
-    def check_ns(self, lines, ns):
-        """Validate that the given input lines produce the resulting namespace.
-
-        Note: the input lines are given exactly as they would be typed in an
-        auto-indenting environment, as mini_interactive_loop above already does
-        auto-indenting and prepends spaces to the input.
-        """
-        src = mini_interactive_loop(pseudo_input(lines))
-        test_ns = {}
-        exec src in test_ns
-        # We can't check that the provided ns is identical to the test_ns,
-        # because Python fills test_ns with extra keys (copyright, etc).  But
-        # we can check that the given dict is *contained* in test_ns
-        for k,v in ns.iteritems():
-            self.assertEqual(test_ns[k], v)
-        
-    def test_simple(self):
-        self.check_ns(['x=1'], dict(x=1))
-
-    def test_simple2(self):
-        self.check_ns(['if 1:', 'x=2'], dict(x=2))
-
-    def test_xy(self):
-        self.check_ns(['x=1; y=2'], dict(x=1, y=2))
-
-    def test_abc(self):
-        self.check_ns(['if 1:','a=1','b=2','c=3'], dict(a=1, b=2, c=3))
-    
-    def test_multi(self):
-        self.check_ns(['x =(1+','1+','2)'], dict(x=4))
-    
-
-def test_LineInfo():
-    """Simple test for LineInfo construction and str()"""
-    linfo = isp.LineInfo('  %cd /home')
-    nt.assert_equals(str(linfo), 'LineInfo [  |%|cd|/home]')
-
-
-def test_split_user_input():
-    """Unicode test - split_user_input already has good doctests"""
-    line = u"Pérez Fernando"
-    parts = isp.split_user_input(line)
-    parts_expected = (u'', u'', u'', line)
-    nt.assert_equal(parts, parts_expected)
-
-
-# Transformer tests
-def transform_checker(tests, func):
-    """Utility to loop over test inputs"""
-    for inp, tr in tests:
-        nt.assert_equals(func(inp), tr)
-
-# Data for all the syntax tests in the form of lists of pairs of
-# raw/transformed input.  We store it here as a global dict so that we can use
-# it both within single-function tests and also to validate the behavior of the
-# larger objects
-
-syntax = \
-  dict(assign_system =
-       [('a =! ls', 'a = get_ipython().getoutput(u"ls")'),
-        ('b = !ls', 'b = get_ipython().getoutput(u"ls")'),
-        ('x=1', 'x=1'), # normal input is unmodified
-        ('    ','    '),  # blank lines are kept intact
-        ],
-
-       assign_magic =
-       [('a =% who', 'a = get_ipython().magic(u"who")'),
-        ('b = %who', 'b = get_ipython().magic(u"who")'),
-        ('x=1', 'x=1'), # normal input is unmodified
-        ('    ','    '),  # blank lines are kept intact
-        ],
-
-       classic_prompt =
-       [('>>> x=1', 'x=1'),
-        ('x=1', 'x=1'), # normal input is unmodified
-        ('    ', '    '),  # blank lines are kept intact
-        ('... ', ''), # continuation prompts
-        ],
-
-       ipy_prompt =
-       [('In [1]: x=1', 'x=1'),
-        ('x=1', 'x=1'), # normal input is unmodified
-        ('    ','    '),  # blank lines are kept intact
-        ('   ....: ', ''), # continuation prompts
-        ],
-
-       # Tests for the escape transformer to leave normal code alone
-       escaped_noesc =
-       [ ('    ', '    '),
-         ('x=1', 'x=1'),
-         ],
-
-       # System calls
-       escaped_shell =
-       [ ('!ls', 'get_ipython().system(u"ls")'),
-         # Double-escape shell, this means to capture the output of the
-         # subprocess and return it
-         ('!!ls', 'get_ipython().getoutput(u"ls")'),
-         ],
-
-       # Help/object info
-       escaped_help =
-       [ ('?', 'get_ipython().show_usage()'),
-         ('?x1', 'get_ipython().magic(u"pinfo x1")'),
-         ('??x2', 'get_ipython().magic(u"pinfo2 x2")'),
-         ('x3?', 'get_ipython().magic(u"pinfo x3")'),
-         ('x4??', 'get_ipython().magic(u"pinfo2 x4")'),
-         ('%hist?', 'get_ipython().magic(u"pinfo %hist")'),
-         ('f*?', 'get_ipython().magic(u"psearch f*")'),
-         ('ax.*aspe*?', 'get_ipython().magic(u"psearch ax.*aspe*")'),
-         ],
-
-       # Explicit magic calls
-       escaped_magic =
-       [ ('%cd', 'get_ipython().magic(u"cd")'),
-         ('%cd /home', 'get_ipython().magic(u"cd /home")'),
-         ('    %magic', '    get_ipython().magic(u"magic")'),
-         ],
-       
-       # Quoting with separate arguments
-       escaped_quote =
-       [ (',f', 'f("")'),
-         (',f x', 'f("x")'),
-         ('  ,f y', '  f("y")'),
-         (',f a b', 'f("a", "b")'),
-         ],
-       
-       # Quoting with single argument
-       escaped_quote2 = 
-       [ (';f', 'f("")'),
-         (';f x', 'f("x")'),
-         ('  ;f y', '  f("y")'),
-         (';f a b', 'f("a b")'),
-         ],
-       
-       # Simply apply parens
-       escaped_paren = 
-       [ ('/f', 'f()'),
-         ('/f x', 'f(x)'),
-         ('  /f y', '  f(y)'),
-         ('/f a b', 'f(a, b)'),
-         ],
-
-       )
-
-# multiline syntax examples.  Each of these should be a list of lists, with
-# each entry itself having pairs of raw/transformed input.  The union (with
-# '\n'.join() of the transformed inputs is what the splitter should produce
-# when fed the raw lines one at a time via push.
-syntax_ml = \
-  dict(classic_prompt =
-       [ [('>>> for i in range(10):','for i in range(10):'),
-          ('...     print i','    print i'),
-          ('... ', ''),
-          ],
-        ],
-
-       ipy_prompt =
-       [ [('In [24]: for i in range(10):','for i in range(10):'),
-          ('   ....:     print i','    print i'),
-          ('   ....: ', ''),
-          ],
-         ],
-       )
-
-
-def test_assign_system():
-    transform_checker(syntax['assign_system'], isp.transform_assign_system)
-
-    
-def test_assign_magic():
-    transform_checker(syntax['assign_magic'], isp.transform_assign_magic)
-
-
-def test_classic_prompt():
-    transform_checker(syntax['classic_prompt'], isp.transform_classic_prompt)
-    for example in syntax_ml['classic_prompt']:
-        transform_checker(example, isp.transform_classic_prompt)
-    
-
-def test_ipy_prompt():
-    transform_checker(syntax['ipy_prompt'], isp.transform_ipy_prompt)
-    for example in syntax_ml['ipy_prompt']:
-        transform_checker(example, isp.transform_ipy_prompt)
-    
-
-def test_escaped_noesc():
-    transform_checker(syntax['escaped_noesc'], isp.transform_escaped)
-
-
-def test_escaped_shell():
-    transform_checker(syntax['escaped_shell'], isp.transform_escaped)
-
-
-def test_escaped_help():
-    transform_checker(syntax['escaped_help'], isp.transform_escaped)
-
-
-def test_escaped_magic():
-    transform_checker(syntax['escaped_magic'], isp.transform_escaped)
-
-
-def test_escaped_quote():
-    transform_checker(syntax['escaped_quote'], isp.transform_escaped)
-
-
-def test_escaped_quote2():
-    transform_checker(syntax['escaped_quote2'], isp.transform_escaped)
-
-
-def test_escaped_paren():
-    transform_checker(syntax['escaped_paren'], isp.transform_escaped)
-
-
-class IPythonInputTestCase(InputSplitterTestCase):
-    """By just creating a new class whose .isp is a different instance, we
-    re-run the same test battery on the new input splitter.
-
-    In addition, this runs the tests over the syntax and syntax_ml dicts that
-    were tested by individual functions, as part of the OO interface.
-
-    It also makes some checks on the raw buffer storage.
-    """
-
-    def setUp(self):
-        self.isp = isp.IPythonInputSplitter(input_mode='line')
-
-    def test_syntax(self):
-        """Call all single-line syntax tests from the main object"""
-        isp = self.isp
-        for example in syntax.itervalues():
-            for raw, out_t in example:
-                if raw.startswith(' '):
-                    continue
-                
-                isp.push(raw)
-                out, out_raw = isp.source_raw_reset()
-                self.assertEqual(out.rstrip(), out_t)
-                self.assertEqual(out_raw.rstrip(), raw.rstrip())
-
-    def test_syntax_multiline(self):
-        isp = self.isp
-        for example in syntax_ml.itervalues():
-            out_t_parts = []
-            raw_parts = []
-            for line_pairs in example:
-                for lraw, out_t_part in line_pairs:
-                    isp.push(lraw)
-                    out_t_parts.append(out_t_part)
-                    raw_parts.append(lraw)
-
-                out, out_raw = isp.source_raw_reset()
-                out_t = '\n'.join(out_t_parts).rstrip()
-                raw = '\n'.join(raw_parts).rstrip()
-                self.assertEqual(out.rstrip(), out_t)
-                self.assertEqual(out_raw.rstrip(), raw)
-                
-
-class BlockIPythonInputTestCase(IPythonInputTestCase):
-
-    # Deactivate tests that don't make sense for the block mode
-    test_push3 = test_split = lambda s: None
-    
-    def setUp(self):
-        self.isp = isp.IPythonInputSplitter(input_mode='cell')
-
-    def test_syntax_multiline(self):
-        isp = self.isp
-        for example in syntax_ml.itervalues():
-            raw_parts = []
-            out_t_parts = []
-            for line_pairs in example:
-                for raw, out_t_part in line_pairs:
-                    raw_parts.append(raw)
-                    out_t_parts.append(out_t_part)
-
-                raw = '\n'.join(raw_parts)
-                out_t = '\n'.join(out_t_parts)
-
-                isp.push(raw)
-                out, out_raw = isp.source_raw_reset()
-                # Match ignoring trailing whitespace
-                self.assertEqual(out.rstrip(), out_t.rstrip())
-                self.assertEqual(out_raw.rstrip(), raw.rstrip())
-    
-
-#-----------------------------------------------------------------------------
-# Main - use as a script, mostly for developer experiments
-#-----------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    # A simple demo for interactive experimentation.  This code will not get
-    # picked up by any test suite.
-    from IPython.core.inputsplitter import InputSplitter, IPythonInputSplitter
-
-    # configure here the syntax to use, prompt and whether to autoindent
-    #isp, start_prompt = InputSplitter(), '>>> '
-    isp, start_prompt = IPythonInputSplitter(), 'In> '
-
-    autoindent = True
-    #autoindent = False
-    
-    try:
-        while True:
-            prompt = start_prompt
-            while isp.push_accepts_more():
-                indent = ' '*isp.indent_spaces
-                if autoindent:
-                    line = indent + raw_input(prompt+indent)
-                else:
-                    line = raw_input(prompt)
-                isp.push(line)
-                prompt = '... '
-
-            # Here we just return input so we can use it in a test suite, but a
-            # real interpreter would instead send it for execution somewhere.
-            #src = isp.source; raise EOFError # dbg
-            src, raw = isp.source_raw_reset()
-            print 'Input source was:\n', src
-            print 'Raw source was:\n', raw
-    except EOFError:
-        print 'Bye'
diff --git a/IPython/core/tests/test_interactiveshell.py b/IPython/core/tests/test_interactiveshell.py
deleted file mode 100644
index 3e930b7edad..00000000000
--- a/IPython/core/tests/test_interactiveshell.py
+++ /dev/null
@@ -1,93 +0,0 @@
-"""Tests for the key interactiveshell module.
-
-Historically the main classes in interactiveshell have been under-tested.  This
-module should grow as many single-method tests as possible to trap many of the
-recurring bugs we seem to encounter with high-level interaction.
-
-Authors
--------
-* Fernando Perez
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-# stdlib
-import unittest
-from IPython.testing import decorators as dec
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-class InteractiveShellTestCase(unittest.TestCase):
-    def test_naked_string_cells(self):
-        """Test that cells with only naked strings are fully executed"""
-        ip = get_ipython()
-        # First, single-line inputs
-        ip.run_cell('"a"\n')
-        self.assertEquals(ip.user_ns['_'], 'a')
-        # And also multi-line cells
-        ip.run_cell('"""a\nb"""\n')
-        self.assertEquals(ip.user_ns['_'], 'a\nb')
-
-    def test_run_empty_cell(self):
-        """Just make sure we don't get a horrible error with a blank
-        cell of input. Yes, I did overlook that."""
-        ip = get_ipython()
-        old_xc = ip.execution_count
-        ip.run_cell('')
-        self.assertEquals(ip.execution_count, old_xc)
-
-    def test_run_cell_multiline(self):
-        """Multi-block, multi-line cells must execute correctly.
-        """
-        ip = get_ipython()
-        src = '\n'.join(["x=1",
-                         "y=2",
-                         "if 1:",
-                         "    x += 1",
-                         "    y += 1",])
-        ip.run_cell(src)
-        self.assertEquals(ip.user_ns['x'], 2)
-        self.assertEquals(ip.user_ns['y'], 3)
-
-    def test_multiline_string_cells(self):
-        "Code sprinkled with multiline strings should execute (GH-306)"
-        ip = get_ipython()
-        ip.run_cell('tmp=0')
-        self.assertEquals(ip.user_ns['tmp'], 0)
-        ip.run_cell('tmp=1;"""a\nb"""\n')
-        self.assertEquals(ip.user_ns['tmp'], 1)
-
-    def test_dont_cache_with_semicolon(self):
-        "Ending a line with semicolon should not cache the returned object (GH-307)"
-        ip = get_ipython()
-        oldlen = len(ip.user_ns['Out'])
-        a = ip.run_cell('1;')
-        newlen = len(ip.user_ns['Out'])
-        self.assertEquals(oldlen, newlen)
-        #also test the default caching behavior
-        ip.run_cell('1')
-        newlen = len(ip.user_ns['Out'])
-        self.assertEquals(oldlen+1, newlen)
-
-    def test_In_variable(self):
-        "Verify that In variable grows with user input (GH-284)"
-        ip = get_ipython()
-        oldlen = len(ip.user_ns['In'])
-        ip.run_cell('1;')
-        newlen = len(ip.user_ns['In'])
-        self.assertEquals(oldlen+1, newlen)
-        self.assertEquals(ip.user_ns['In'][-1],'1;')
-        
-    def test_magic_names_in_string(self):
-        ip = get_ipython()
-        ip.run_cell('a = """\n%exit\n"""')
-        self.assertEquals(ip.user_ns['a'], '\n%exit\n')
diff --git a/IPython/core/tests/test_iplib.py b/IPython/core/tests/test_iplib.py
deleted file mode 100644
index cb91ab2cbcf..00000000000
--- a/IPython/core/tests/test_iplib.py
+++ /dev/null
@@ -1,271 +0,0 @@
-"""Tests for the key interactiveshell module, where the main ipython class is defined.
-"""
-#-----------------------------------------------------------------------------
-# Module imports
-#-----------------------------------------------------------------------------
-
-# stdlib
-import os
-import shutil
-import tempfile
-
-# third party
-import nose.tools as nt
-
-# our own packages
-from IPython.testing import decorators as dec
-from IPython.testing.globalipapp import get_ipython
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# Get the public instance of IPython
-ip = get_ipython()
-
-#-----------------------------------------------------------------------------
-# Test functions
-#-----------------------------------------------------------------------------
-
-@dec.parametric
-def test_reset():
-    """reset must clear most namespaces."""
-    # The number of variables in the private user_ns_hidden is not zero, but it
-    # should be constant regardless of what we do
-    nvars_config_ns = len(ip.user_ns_hidden)
-
-    # Check that reset runs without error
-    ip.reset()
-
-    # Once we've reset it (to clear of any junk that might have been there from
-    # other tests, we can count how many variables are in the user's namespace
-    nvars_user_ns = len(ip.user_ns)
-
-    # Now add a few variables to user_ns, and check that reset clears them
-    ip.user_ns['x'] = 1
-    ip.user_ns['y'] = 1
-    ip.reset()
-    
-    # Finally, check that all namespaces have only as many variables as we
-    # expect to find in them:
-    for ns in ip.ns_refs_table:
-        if ns is ip.user_ns:
-            nvars_expected = nvars_user_ns
-        elif ns is ip.user_ns_hidden:
-            nvars_expected = nvars_config_ns
-        else:
-            nvars_expected = 0
-            
-        yield nt.assert_equals(len(ns), nvars_expected)
-
-
-# Tests for reporting of exceptions in various modes, handling of SystemExit,
-# and %tb functionality.  This is really a mix of testing ultraTB and interactiveshell.
-
-def doctest_tb_plain():
-    """
-In [18]: xmode plain
-Exception reporting mode: Plain
-
-In [19]: run simpleerr.py
-Traceback (most recent call last):
-  ...line 32, in <module>
-    bar(mode)
-  ...line 16, in bar
-    div0()
-  ...line 8, in div0
-    x/y
-ZeroDivisionError: integer division or modulo by zero
-    """
-
-
-def doctest_tb_context():
-    """
-In [3]: xmode context
-Exception reporting mode: Context
-
-In [4]: run simpleerr.py
----------------------------------------------------------------------------
-ZeroDivisionError                         Traceback (most recent call last)
-<BLANKLINE>
-... in <module>()
-     30         mode = 'div'
-     31 
----> 32     bar(mode)
-<BLANKLINE>
-... in bar(mode)
-     14     "bar"
-     15     if mode=='div':
----> 16         div0()
-     17     elif mode=='exit':
-     18         try:
-<BLANKLINE>
-... in div0()
-      6     x = 1
-      7     y = 0
-----> 8     x/y
-      9 
-     10 def sysexit(stat, mode):
-<BLANKLINE>
-ZeroDivisionError: integer division or modulo by zero
-"""
-
-
-def doctest_tb_verbose():
-    """
-In [5]: xmode verbose
-Exception reporting mode: Verbose
-
-In [6]: run simpleerr.py
----------------------------------------------------------------------------
-ZeroDivisionError                         Traceback (most recent call last)
-<BLANKLINE>
-... in <module>()
-     30         mode = 'div'
-     31 
----> 32     bar(mode)
-        global bar = <function bar at ...>
-        global mode = 'div'
-<BLANKLINE>
-... in bar(mode='div')
-     14     "bar"
-     15     if mode=='div':
----> 16         div0()
-        global div0 = <function div0 at ...>
-     17     elif mode=='exit':
-     18         try:
-<BLANKLINE>
-... in div0()
-      6     x = 1
-      7     y = 0
-----> 8     x/y
-        x = 1
-        y = 0
-      9 
-     10 def sysexit(stat, mode):
-<BLANKLINE>
-ZeroDivisionError: integer division or modulo by zero
-      """
-
-
-def doctest_tb_sysexit():
-    """
-In [17]: %xmode plain
-Exception reporting mode: Plain
-
-In [18]: %run simpleerr.py exit
-An exception has occurred, use %tb to see the full traceback.
-SystemExit: (1, u'Mode = exit')
-
-In [19]: %run simpleerr.py exit 2
-An exception has occurred, use %tb to see the full traceback.
-SystemExit: (2, u'Mode = exit')
-
-In [20]: %tb
-Traceback (most recent call last):
-  File ... in <module>
-    bar(mode)
-  File ... line 22, in bar
-    sysexit(stat, mode)
-  File ... line 11, in sysexit
-    raise SystemExit(stat, 'Mode = %s' % mode)
-SystemExit: (2, u'Mode = exit')
-
-In [21]: %xmode context
-Exception reporting mode: Context
-
-In [22]: %tb
----------------------------------------------------------------------------
-SystemExit                                Traceback (most recent call last)
-<BLANKLINE>
-...<module>()
-     30         mode = 'div'
-     31 
----> 32     bar(mode)
-<BLANKLINE>
-...bar(mode)
-     20         except:
-     21             stat = 1
----> 22         sysexit(stat, mode)
-     23     else:
-     24         raise ValueError('Unknown mode')
-<BLANKLINE>
-...sysexit(stat, mode)
-      9 
-     10 def sysexit(stat, mode):
----> 11     raise SystemExit(stat, 'Mode = %s' % mode)
-     12 
-     13 def bar(mode):
-<BLANKLINE>
-SystemExit: (2, u'Mode = exit')
-
-In [23]: %xmode verbose
-Exception reporting mode: Verbose
-
-In [24]: %tb
----------------------------------------------------------------------------
-SystemExit                                Traceback (most recent call last)
-<BLANKLINE>
-... in <module>()
-     30         mode = 'div'
-     31 
----> 32     bar(mode)
-        global bar = <function bar at ...>
-        global mode = u'exit'
-<BLANKLINE>
-... in bar(mode=u'exit')
-     20         except:
-     21             stat = 1
----> 22         sysexit(stat, mode)
-        global sysexit = <function sysexit at ...>
-        stat = 2
-        mode = u'exit'
-     23     else:
-     24         raise ValueError('Unknown mode')
-<BLANKLINE>
-... in sysexit(stat=2, mode=u'exit')
-      9 
-     10 def sysexit(stat, mode):
----> 11     raise SystemExit(stat, 'Mode = %s' % mode)
-        global SystemExit = undefined
-        stat = 2
-        mode = u'exit'
-     12 
-     13 def bar(mode):
-<BLANKLINE>
-SystemExit: (2, u'Mode = exit')
-    """
-
-
-def test_run_cell():
-    import textwrap
-    ip.run_cell('a = 10\na+=1')
-    ip.run_cell('assert a == 11\nassert 1')
-
-    nt.assert_equals(ip.user_ns['a'], 11)
-    complex = textwrap.dedent("""
-    if 1:
-        print "hello"
-        if 1:
-            print "world"
-        
-    if 2:
-        print "foo"
-
-    if 3:
-        print "bar"
-
-    if 4:
-        print "bar"
-    
-    """)
-    # Simply verifies that this kind of input is run
-    ip.run_cell(complex)
-    
-
-def test_db():
-    """Test the internal database used for variable persistence."""
-    ip.db['__unittest_'] = 12
-    nt.assert_equals(ip.db['__unittest_'], 12)
-    del ip.db['__unittest_']
-    assert '__unittest_' not in ip.db
diff --git a/IPython/core/tests/test_magic.py b/IPython/core/tests/test_magic.py
deleted file mode 100644
index 671d7ea87ac..00000000000
--- a/IPython/core/tests/test_magic.py
+++ /dev/null
@@ -1,440 +0,0 @@
-"""Tests for various magic functions.
-
-Needs to be run by nose (to make ipython session available).
-"""
-from __future__ import absolute_import
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import sys
-import tempfile
-import types
-from cStringIO import StringIO
-
-import nose.tools as nt
-
-from IPython.utils.path import get_long_path_name
-from IPython.testing import decorators as dec
-from IPython.testing import tools as tt
-
-#-----------------------------------------------------------------------------
-# Test functions begin
-#-----------------------------------------------------------------------------
-def test_rehashx():
-    # clear up everything
-    _ip = get_ipython()
-    _ip.alias_manager.alias_table.clear()
-    del _ip.db['syscmdlist']
-    
-    _ip.magic('rehashx')
-    # Practically ALL ipython development systems will have more than 10 aliases
-
-    yield (nt.assert_true, len(_ip.alias_manager.alias_table) > 10)
-    for key, val in _ip.alias_manager.alias_table.iteritems():
-        # we must strip dots from alias names
-        nt.assert_true('.' not in key)
-
-    # rehashx must fill up syscmdlist
-    scoms = _ip.db['syscmdlist']
-    yield (nt.assert_true, len(scoms) > 10)
-
-
-def test_magic_parse_options():
-    """Test that we don't mangle paths when parsing magic options."""
-    ip = get_ipython()
-    path = 'c:\\x'
-    opts = ip.parse_options('-f %s' % path,'f:')[0]
-    # argv splitting is os-dependent
-    if os.name == 'posix':
-        expected = 'c:x'
-    else:
-        expected = path
-    nt.assert_equals(opts['f'], expected)
-
-    
-def doctest_hist_f():
-    """Test %hist -f with temporary filename.
-
-    In [9]: import tempfile
-
-    In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
-
-    In [11]: %hist -nl -f $tfile 3
-
-    In [13]: import os; os.unlink(tfile)
-    """
-
-
-def doctest_hist_r():
-    """Test %hist -r
-
-    XXX - This test is not recording the output correctly.  For some reason, in
-    testing mode the raw history isn't getting populated.  No idea why.
-    Disabling the output checking for now, though at least we do run it.
-
-    In [1]: 'hist' in _ip.lsmagic()
-    Out[1]: True
-
-    In [2]: x=1
-
-    In [3]: %hist -rl 2
-    x=1 # random
-    %hist -r 2
-    """
-
-def doctest_hist_op():
-    """Test %hist -op
-
-    In [1]: class b:
-       ...:         pass
-       ...: 
-
-    In [2]: class s(b):
-       ...:         def __str__(self):
-       ...:             return 's'
-       ...: 
-
-    In [3]: 
-
-    In [4]: class r(b):
-       ...:         def __repr__(self):
-       ...:             return 'r'
-       ...: 
-
-    In [5]: class sr(s,r): pass
-       ...: 
-
-    In [6]: 
-
-    In [7]: bb=b()
-
-    In [8]: ss=s()
-
-    In [9]: rr=r()
-
-    In [10]: ssrr=sr()
-
-    In [11]: bb
-    Out[11]: <...b instance at ...>
-
-    In [12]: ss
-    Out[12]: <...s instance at ...>
-
-    In [13]: 
-
-    In [14]: %hist -op
-    >>> class b:
-    ...     pass
-    ... 
-    >>> class s(b):
-    ...     def __str__(self):
-    ...         return 's'
-    ... 
-    >>> 
-    >>> class r(b):
-    ...     def __repr__(self):
-    ...         return 'r'
-    ... 
-    >>> class sr(s,r): pass
-    >>> 
-    >>> bb=b()
-    >>> ss=s()
-    >>> rr=r()
-    >>> ssrr=sr()
-    >>> bb
-    <...b instance at ...>
-    >>> ss
-    <...s instance at ...>
-    >>> 
-    """
-  
-def test_macro():
-    ip = get_ipython()
-    ip.history_manager.reset()   # Clear any existing history.
-    cmds = ["a=1", "def b():\n  return a**2", "print(a,b())"]
-    for i, cmd in enumerate(cmds, start=1):
-        ip.history_manager.store_inputs(i, cmd)
-    ip.magic("macro test 1-3")
-    nt.assert_equal(ip.user_ns["test"].value, "\n".join(cmds)+"\n")
-    
-    # List macros.
-    assert "test" in ip.magic("macro")
-
-def test_macro_run():
-    """Test that we can run a multi-line macro successfully."""
-    ip = get_ipython()
-    ip.history_manager.reset()
-    cmds = ["a=10", "a+=1", "print a", "%macro test 2-3"]
-    for cmd in cmds:
-        ip.run_cell(cmd)
-    nt.assert_equal(ip.user_ns["test"].value, "a+=1\nprint a\n")
-    original_stdout = sys.stdout
-    new_stdout = StringIO()
-    sys.stdout = new_stdout
-    try:
-        ip.run_cell("test")
-        nt.assert_true("12" in new_stdout.getvalue())
-        ip.run_cell("test")
-        nt.assert_true("13" in new_stdout.getvalue())
-    finally:
-        sys.stdout = original_stdout
-        new_stdout.close()
-
-    
-# XXX failing for now, until we get clearcmd out of quarantine.  But we should
-# fix this and revert the skip to happen only if numpy is not around.
-#@dec.skipif_not_numpy
-@dec.skip_known_failure
-def test_numpy_clear_array_undec():
-    from IPython.extensions import clearcmd
-
-    _ip.ex('import numpy as np')
-    _ip.ex('a = np.empty(2)')
-    yield (nt.assert_true, 'a' in _ip.user_ns)
-    _ip.magic('clear array')
-    yield (nt.assert_false, 'a' in _ip.user_ns)
-    
-
-# Multiple tests for clipboard pasting
-@dec.parametric
-def test_paste():
-    _ip = get_ipython()
-    def paste(txt, flags='-q'):
-        """Paste input text, by default in quiet mode"""
-        hooks.clipboard_get = lambda : txt
-        _ip.magic('paste '+flags)
-
-    # Inject fake clipboard hook but save original so we can restore it later
-    hooks = _ip.hooks
-    user_ns = _ip.user_ns
-    original_clip = hooks.clipboard_get
-
-    try:
-        # This try/except with an emtpy except clause is here only because
-        # try/yield/finally is invalid syntax in Python 2.4.  This will be
-        # removed when we drop 2.4-compatibility, and the emtpy except below
-        # will be changed to a finally.
-
-        # Run tests with fake clipboard function
-        user_ns.pop('x', None)
-        paste('x=1')
-        yield nt.assert_equal(user_ns['x'], 1)
-
-        user_ns.pop('x', None)
-        paste('>>> x=2')
-        yield nt.assert_equal(user_ns['x'], 2)
-
-        paste("""
-        >>> x = [1,2,3]
-        >>> y = []
-        >>> for i in x:
-        ...     y.append(i**2)
-        ...
-        """)
-        yield nt.assert_equal(user_ns['x'], [1,2,3])
-        yield nt.assert_equal(user_ns['y'], [1,4,9])
-
-        # Now, test that paste -r works
-        user_ns.pop('x', None)
-        yield nt.assert_false('x' in user_ns)
-        _ip.magic('paste -r')
-        yield nt.assert_equal(user_ns['x'], [1,2,3])
-
-        # Also test paste echoing, by temporarily faking the writer
-        w = StringIO()
-        writer = _ip.write
-        _ip.write = w.write
-        code = """
-        a = 100
-        b = 200"""
-        try:
-            paste(code,'')
-            out = w.getvalue()
-        finally:
-            _ip.write = writer
-        yield nt.assert_equal(user_ns['a'], 100)
-        yield nt.assert_equal(user_ns['b'], 200)
-        yield nt.assert_equal(out, code+"\n## -- End pasted text --\n")
-        
-    finally:
-        # This should be in a finally clause, instead of the bare except above.
-        # Restore original hook
-        hooks.clipboard_get = original_clip
-
-
-def test_time():
-    _ip.magic('time None')
-
-
-def doctest_time():
-    """
-    In [10]: %time None
-    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-    Wall time: 0.00 s
-    
-    In [11]: def f(kmjy):
-       ....:    %time print 2*kmjy
-       
-    In [12]: f(3)
-    6
-    CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-    Wall time: 0.00 s
-    """
-
-
-def test_doctest_mode():
-    "Toggle doctest_mode twice, it should be a no-op and run without error"
-    _ip.magic('doctest_mode')
-    _ip.magic('doctest_mode')
-
-
-def test_parse_options():
-    """Tests for basic options parsing in magics."""
-    # These are only the most minimal of tests, more should be added later.  At
-    # the very least we check that basic text/unicode calls work OK.
-    nt.assert_equal(_ip.parse_options('foo', '')[1], 'foo')
-    nt.assert_equal(_ip.parse_options(u'foo', '')[1], u'foo')
-
-    
-def test_dirops():
-    """Test various directory handling operations."""
-    curpath = lambda :os.path.splitdrive(os.getcwdu())[1].replace('\\','/')
-
-    startdir = os.getcwdu()
-    ipdir = _ip.ipython_dir
-    try:
-        _ip.magic('cd "%s"' % ipdir)
-        nt.assert_equal(curpath(), ipdir)
-        _ip.magic('cd -')
-        nt.assert_equal(curpath(), startdir)
-        _ip.magic('pushd "%s"' % ipdir)
-        nt.assert_equal(curpath(), ipdir)
-        _ip.magic('popd')
-        nt.assert_equal(curpath(), startdir)
-    finally:
-        os.chdir(startdir)
-
-
-def check_cpaste(code, should_fail=False):
-    """Execute code via 'cpaste' and ensure it was executed, unless
-    should_fail is set.
-    """
-    _ip.user_ns['code_ran'] = False
-
-    src = StringIO()
-    src.write('\n')
-    src.write(code)
-    src.write('\n--\n')
-    src.seek(0)
-
-    stdin_save = sys.stdin
-    sys.stdin = src
-    
-    try:
-        _ip.magic('cpaste')
-    except:
-        if not should_fail:
-            raise AssertionError("Failure not expected : '%s'" %
-                                 code)
-    else:
-        assert _ip.user_ns['code_ran']
-        if should_fail:
-            raise AssertionError("Failure expected : '%s'" % code)
-    finally:
-        sys.stdin = stdin_save
-
-
-def test_cpaste():
-    """Test cpaste magic"""
-
-    def run():
-        """Marker function: sets a flag when executed.
-        """
-        _ip.user_ns['code_ran'] = True
-        return 'run' # return string so '+ run()' doesn't result in success
-
-    tests = {'pass': ["> > > run()",
-                      ">>> > run()",
-                      "+++ run()",
-                      "++ run()",
-                      "  >>> run()"],
-
-             'fail': ["+ + run()",
-                      " ++ run()"]}
-
-    _ip.user_ns['run'] = run
-
-    for code in tests['pass']:
-        check_cpaste(code)
-
-    for code in tests['fail']:
-        check_cpaste(code, should_fail=True)
-
-def test_xmode():
-    # Calling xmode three times should be a no-op
-    xmode = _ip.InteractiveTB.mode
-    for i in range(3):
-        _ip.magic("xmode")
-    nt.assert_equal(_ip.InteractiveTB.mode, xmode)
-    
-def test_reset_hard():
-    monitor = []
-    class A(object):
-        def __del__(self):
-            monitor.append(1)
-        def __repr__(self):
-            return "<A instance>"
-            
-    _ip.user_ns["a"] = A()
-    _ip.run_cell("a")
-    
-    nt.assert_equal(monitor, [])
-    _ip.magic_reset("-f")
-    nt.assert_equal(monitor, [1])
-
-def doctest_who():
-    """doctest for %who
-    
-    In [1]: %reset -f
-    
-    In [2]: alpha = 123
-    
-    In [3]: beta = 'beta'
-    
-    In [4]: %who int
-    alpha
-    
-    In [5]: %who str
-    beta
-    
-    In [6]: %whos
-    Variable   Type    Data/Info
-    ----------------------------
-    alpha      int     123
-    beta       str     beta
-    
-    In [7]: %who_ls
-    Out[7]: ['alpha', 'beta']
-    """
-
-def doctest_precision():
-    """doctest for %precision
-    
-    In [1]: f = get_ipython().shell.display_formatter.formatters['text/plain']
-    
-    In [2]: %precision 5
-    Out[2]: '%.5f'
-    
-    In [3]: f.float_format
-    Out[3]: '%.5f'
-    
-    In [4]: %precision %e
-    Out[4]: '%e'
-    
-    In [5]: f(3.1415927)
-    Out[5]: '3.141593e+00'
-    """
-
diff --git a/IPython/core/tests/test_magic_arguments.py b/IPython/core/tests/test_magic_arguments.py
deleted file mode 100644
index 3e38f477581..00000000000
--- a/IPython/core/tests/test_magic_arguments.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#-----------------------------------------------------------------------------
-# Copyright (c) 2010, IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-from nose.tools import assert_equal, assert_true
-
-from IPython.external import argparse
-from IPython.core.magic_arguments import (argument, argument_group, kwds,
-    magic_arguments, parse_argstring, real_name)
-from IPython.testing.decorators import parametric
-
-
-@magic_arguments()
-@argument('-f', '--foo', help="an argument")
-def magic_foo1(self, args):
-    """ A docstring.
-    """
-    return parse_argstring(magic_foo1, args)
-
-
-@magic_arguments()
-def magic_foo2(self, args):
-    """ A docstring.
-    """
-    return parse_argstring(magic_foo2, args)
-
-
-@magic_arguments()
-@argument('-f', '--foo', help="an argument")
-@argument_group('Group')
-@argument('-b', '--bar', help="a grouped argument")
-@argument_group('Second Group')
-@argument('-z', '--baz', help="another grouped argument")
-def magic_foo3(self, args):
-    """ A docstring.
-    """
-    return parse_argstring(magic_foo3, args)
-
-
-@magic_arguments()
-@kwds(argument_default=argparse.SUPPRESS)
-@argument('-f', '--foo', help="an argument")
-def magic_foo4(self, args):
-    """ A docstring.
-    """
-    return parse_argstring(magic_foo4, args)
-
-
-@magic_arguments('frobnicate')
-@argument('-f', '--foo', help="an argument")
-def magic_foo5(self, args):
-    """ A docstring.
-    """
-    return parse_argstring(magic_foo5, args)
-
-
-@magic_arguments()
-@argument('-f', '--foo', help="an argument")
-def magic_magic_foo(self, args):
-    """ A docstring.
-    """
-    return parse_argstring(magic_magic_foo, args)
-
-
-@magic_arguments()
-@argument('-f', '--foo', help="an argument")
-def foo(self, args):
-    """ A docstring.
-    """
-    return parse_argstring(foo, args)
-
-
-@parametric
-def test_magic_arguments():
-    # Ideally, these would be doctests, but I could not get it to work.
-    yield assert_equal(magic_foo1.__doc__, '%foo1 [-f FOO]\n\nA docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_foo1, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo1), 'foo1')
-    yield assert_equal(magic_foo1(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(magic_foo1, 'has_arguments'))
-
-    yield assert_equal(magic_foo2.__doc__, '%foo2\n\nA docstring.\n')
-    yield assert_equal(getattr(magic_foo2, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo2), 'foo2')
-    yield assert_equal(magic_foo2(None, ''), argparse.Namespace())
-    yield assert_true(hasattr(magic_foo2, 'has_arguments'))
-
-    yield assert_equal(magic_foo3.__doc__, '%foo3 [-f FOO] [-b BAR] [-z BAZ]\n\nA docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n\nGroup:\n  -b BAR, --bar BAR  a grouped argument\n\nSecond Group:\n  -z BAZ, --baz BAZ  another grouped argument\n')
-    yield assert_equal(getattr(magic_foo3, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo3), 'foo3')
-    yield assert_equal(magic_foo3(None, ''),
-                       argparse.Namespace(bar=None, baz=None, foo=None))
-    yield assert_true(hasattr(magic_foo3, 'has_arguments'))
-
-    yield assert_equal(magic_foo4.__doc__, '%foo4 [-f FOO]\n\nA docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_foo4, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_foo4), 'foo4')
-    yield assert_equal(magic_foo4(None, ''), argparse.Namespace())
-    yield assert_true(hasattr(magic_foo4, 'has_arguments'))
-
-    yield assert_equal(magic_foo5.__doc__, '%frobnicate [-f FOO]\n\nA docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_foo5, 'argcmd_name', None), 'frobnicate')
-    yield assert_equal(real_name(magic_foo5), 'frobnicate')
-    yield assert_equal(magic_foo5(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(magic_foo5, 'has_arguments'))
-
-    yield assert_equal(magic_magic_foo.__doc__, '%magic_foo [-f FOO]\n\nA docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(magic_magic_foo, 'argcmd_name', None), None)
-    yield assert_equal(real_name(magic_magic_foo), 'magic_foo')
-    yield assert_equal(magic_magic_foo(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(magic_magic_foo, 'has_arguments'))
-
-    yield assert_equal(foo.__doc__, '%foo [-f FOO]\n\nA docstring.\n\noptional arguments:\n  -f FOO, --foo FOO  an argument\n')
-    yield assert_equal(getattr(foo, 'argcmd_name', None), None)
-    yield assert_equal(real_name(foo), 'foo')
-    yield assert_equal(foo(None, ''), argparse.Namespace(foo=None))
-    yield assert_true(hasattr(foo, 'has_arguments'))
diff --git a/IPython/core/tests/test_oinspect.py b/IPython/core/tests/test_oinspect.py
deleted file mode 100644
index d31d4423259..00000000000
--- a/IPython/core/tests/test_oinspect.py
+++ /dev/null
@@ -1,89 +0,0 @@
-"""Tests for the object inspection functionality.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010 The IPython Development Team.
-#
-#  Distributed under the terms of the BSD License.
-#
-#  The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Stdlib imports
-
-# Third-party imports
-import nose.tools as nt
-
-# Our own imports
-from .. import oinspect
-
-#-----------------------------------------------------------------------------
-# Globals and constants
-#-----------------------------------------------------------------------------
-
-inspector = oinspect.Inspector()
-
-#-----------------------------------------------------------------------------
-# Local utilities
-#-----------------------------------------------------------------------------
-
-# A few generic objects we can then inspect in the tests below
-
-class Call(object):
-    """This is the class docstring."""
-
-    def __init__(self, x, y=1):
-        """This is the constructor docstring."""
-
-    def __call__(self, *a, **kw):
-        """This is the call docstring."""
-
-    def method(self, x, z=2):
-        """Some method's docstring"""
-
-def f(x, y=2, *a, **kw):
-    """A simple function."""
-
-def g(y, z=3, *a, **kw):
-    pass  # no docstring
-
-
-def check_calltip(obj, name, call, docstring):
-    """Generic check pattern all calltip tests will use"""
-    info = inspector.info(obj, name)
-    call_line, ds = oinspect.call_tip(info)
-    nt.assert_equal(call_line, call)
-    nt.assert_equal(ds, docstring)    
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-def test_calltip_class():
-    check_calltip(Call, 'Call', 'Call(x, y=1)', Call.__init__.__doc__)
-
-
-def test_calltip_instance():
-    c = Call(1)
-    check_calltip(c, 'c', 'c(*a, **kw)', c.__call__.__doc__)
-
-
-def test_calltip_method():
-    c = Call(1)
-    check_calltip(c.method, 'c.method', 'c.method(x, z=2)', c.method.__doc__)
-
-
-def test_calltip_function():
-    check_calltip(f, 'f', 'f(x, y=2, *a, **kw)', f.__doc__)
-
-
-def test_calltip_function2():
-    check_calltip(g, 'g', 'g(y, z=3, *a, **kw)', '<no docstring>')
-
-
-def test_calltip_builtin():
-    check_calltip(sum, 'sum', None, sum.__doc__)
diff --git a/IPython/core/tests/test_plugin.py b/IPython/core/tests/test_plugin.py
deleted file mode 100644
index 92ff22b2b75..00000000000
--- a/IPython/core/tests/test_plugin.py
+++ /dev/null
@@ -1,46 +0,0 @@
-"""Tests for plugin.py"""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from unittest import TestCase
-
-from IPython.core.plugin import Plugin, PluginManager
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-class FooPlugin(Plugin):
-    pass
-
-
-class BarPlugin(Plugin):
-    pass
-
-
-class BadPlugin(object):
-    pass
-
-
-class PluginTest(TestCase):
-
-    def setUp(self):
-        self.manager = PluginManager()
-
-    def test_register_get(self):
-        self.assertEquals(None, self.manager.get_plugin('foo'))
-        foo = FooPlugin()
-        self.manager.register_plugin('foo', foo)
-        self.assertEquals(foo, self.manager.get_plugin('foo'))
-        bar = BarPlugin()
-        self.assertRaises(KeyError, self.manager.register_plugin, 'foo', bar)
-        bad = BadPlugin()
-        self.assertRaises(TypeError, self.manager.register_plugin, 'bad')
-
-    def test_unregister(self):
-        foo = FooPlugin()
-        self.manager.register_plugin('foo', foo)
-        self.manager.unregister_plugin('foo')
-        self.assertEquals(None, self.manager.get_plugin('foo'))
diff --git a/IPython/core/tests/test_prefilter.py b/IPython/core/tests/test_prefilter.py
deleted file mode 100644
index 3575a98a115..00000000000
--- a/IPython/core/tests/test_prefilter.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""Tests for input manipulation machinery."""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-import nose.tools as nt
-
-from IPython.testing import tools as tt, decorators as dec
-from IPython.testing.globalipapp import get_ipython
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-ip = get_ipython()
-
-@dec.parametric
-def test_prefilter():
-    """Test user input conversions"""
-
-    # pairs of (raw, expected correct) input
-    pairs = [ ('2+2','2+2'),
-              ('>>> 2+2','2+2'),
-              ('>>> # This is a comment\n'
-               '... 2+2',
-               '# This is a comment\n'
-               '2+2'),
-              # Some IPython input
-              ('In [1]: 1', '1'),
-              ('In [2]: for i in range(5):\n'
-               '   ...:     print i,',
-               'for i in range(5):\n'
-               '    print i,'),
-             ]
-
-    for raw, correct in pairs:
-        yield nt.assert_equals(ip.prefilter(raw), correct)
-
-@dec.parametric
-def test_autocall_binops():
-    """See https://bugs.launchpad.net/ipython/+bug/315706"""
-    ip.magic('autocall 2')
-    f = lambda x: x
-    ip.user_ns['f'] = f
-    try:
-        yield nt.assert_equals(ip.prefilter('f 1'),'f(1)')
-        for t in ['f +1', 'f -1']:
-            yield nt.assert_equals(ip.prefilter(t), t)
-    finally:
-        ip.magic('autocall 0')
-        del ip.user_ns['f']
-
-@dec.parametric
-def test_issue114():
-    """Check that multiline string literals don't expand as magic
-    see http://github.com/ipython/ipython/issues/#issue/114"""
-
-    template = '"""\n%s\n"""'
-    # Store the current value of multi_line_specials and turn it off before
-    # running test, since it could be true (case in which the test doesn't make
-    # sense, as multiline string literals *will* expand as magic in that case).
-    msp = ip.prefilter_manager.multi_line_specials
-    ip.prefilter_manager.multi_line_specials = False
-    try:
-        for mgk in ip.lsmagic():
-            raw = template % mgk
-            yield nt.assert_equals(ip.prefilter(raw), raw)
-    finally:
-        ip.prefilter_manager.multi_line_specials = msp
diff --git a/IPython/core/tests/test_run.py b/IPython/core/tests/test_run.py
deleted file mode 100644
index 4004979bae1..00000000000
--- a/IPython/core/tests/test_run.py
+++ /dev/null
@@ -1,210 +0,0 @@
-"""Tests for code execution (%run and related), which is particularly tricky.
-
-Because of how %run manages namespaces, and the fact that we are trying here to
-verify subtle object deletion and reference counting issues, the %run tests
-will be kept in this separate file.  This makes it easier to aggregate in one
-place the tricks needed to handle it; most other magics are much easier to test
-and we do so in a common test_magic file.
-"""
-from __future__ import absolute_import
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import sys
-import tempfile
-
-import nose.tools as nt
-
-from IPython.testing import decorators as dec
-from IPython.testing import tools as tt
-
-#-----------------------------------------------------------------------------
-# Test functions begin
-#-----------------------------------------------------------------------------
-
-def doctest_refbug():
-    """Very nasty problem with references held by multiple runs of a script.
-    See: https://bugs.launchpad.net/ipython/+bug/269966
-
-    In [1]: _ip.clear_main_mod_cache()
-    # random
-    
-    In [2]: %run refbug
-
-    In [3]: call_f()
-    lowercased: hello
-
-    In [4]: %run refbug
-
-    In [5]: call_f()
-    lowercased: hello
-    lowercased: hello
-    """
-
-
-def doctest_run_builtins():
-    r"""Check that %run doesn't damage __builtins__.
-
-    In [1]: import tempfile
-
-    In [2]: bid1 = id(__builtins__)
-
-    In [3]: fname = tempfile.mkstemp('.py')[1]
-
-    In [3]: f = open(fname,'w')
-
-    In [4]: f.write('pass\n')
-
-    In [5]: f.flush()
-
-    In [6]: t1 = type(__builtins__)
-
-    In [7]: %run $fname
-
-    In [7]: f.close()
-
-    In [8]: bid2 = id(__builtins__)
-
-    In [9]: t2 = type(__builtins__)
-
-    In [10]: t1 == t2
-    Out[10]: True
-
-    In [10]: bid1 == bid2
-    Out[10]: True
-
-    In [12]: try:
-       ....:     os.unlink(fname)
-       ....: except:
-       ....:     pass
-       ....: 
-    """
-
-def doctest_reset_del():
-    """Test that resetting doesn't cause errors in __del__ methods.
-
-    In [2]: class A(object):
-       ...:     def __del__(self):
-       ...:         print str("Hi")
-       ...: 
-
-    In [3]: a = A()
-
-    In [4]: get_ipython().reset()
-    Hi
-
-    In [5]: 1+1
-    Out[5]: 2
-    """
-
-# For some tests, it will be handy to organize them in a class with a common
-# setup that makes a temp file
-
-class TestMagicRunPass(tt.TempFileMixin):
-
-    def setup(self):
-        """Make a valid python temp file."""
-        self.mktmp('pass\n')
-
-    def run_tmpfile(self):
-        _ip = get_ipython()
-        # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
-        # See below and ticket https://bugs.launchpad.net/bugs/366353
-        _ip.magic('run %s' % self.fname)
-
-    def test_builtins_id(self):
-        """Check that %run doesn't damage __builtins__ """
-        _ip = get_ipython()
-        # Test that the id of __builtins__ is not modified by %run
-        bid1 = id(_ip.user_ns['__builtins__'])
-        self.run_tmpfile()
-        bid2 = id(_ip.user_ns['__builtins__'])
-        tt.assert_equals(bid1, bid2)
-
-    def test_builtins_type(self):
-        """Check that the type of __builtins__ doesn't change with %run.
-        
-        However, the above could pass if __builtins__ was already modified to
-        be a dict (it should be a module) by a previous use of %run.  So we
-        also check explicitly that it really is a module:
-        """
-        _ip = get_ipython()
-        self.run_tmpfile()
-        tt.assert_equals(type(_ip.user_ns['__builtins__']),type(sys))
-
-    def test_prompts(self):
-        """Test that prompts correctly generate after %run"""
-        self.run_tmpfile()
-        _ip = get_ipython()
-        p2 = str(_ip.displayhook.prompt2).strip()
-        nt.assert_equals(p2[:3], '...')
-
-
-class TestMagicRunSimple(tt.TempFileMixin):
-
-    def test_simpledef(self):
-        """Test that simple class definitions work."""
-        src = ("class foo: pass\n"
-               "def f(): return foo()")
-        self.mktmp(src)
-        _ip.magic('run %s' % self.fname)
-        _ip.run_cell('t = isinstance(f(), foo)')
-        nt.assert_true(_ip.user_ns['t'])
-
-    # We have to skip these in win32 because getoutputerr() crashes,
-    # due to the fact that subprocess does not support close_fds when
-    # redirecting stdout/err.  So unless someone who knows more tells us how to
-    # implement getoutputerr() in win32, we're stuck avoiding these.
-    @dec.skip_win32
-    def test_obj_del(self):
-        """Test that object's __del__ methods are called on exit."""
-        
-        # This test is known to fail on win32.
-        # See ticket https://bugs.launchpad.net/bugs/366334
-        src = ("class A(object):\n"
-               "    def __del__(self):\n"
-               "        print 'object A deleted'\n"
-               "a = A()\n")
-        self.mktmp(src)
-        tt.ipexec_validate(self.fname, 'object A deleted')
-    
-    @dec.skip_known_failure 
-    def test_aggressive_namespace_cleanup(self):
-        """Test that namespace cleanup is not too aggressive GH-238
-
-        Returning from another run magic deletes the namespace"""
-        # see ticket https://github.com/ipython/ipython/issues/238
-        class secondtmp(tt.TempFileMixin): pass
-        empty = secondtmp()
-        empty.mktmp('')
-        src = ("ip = get_ipython()\n"
-               "for i in range(5):\n"
-               "   try:\n"
-               "       ip.magic('run %s')\n"
-               "   except NameError, e:\n"
-               "       print i;break\n" % empty.fname)
-        self.mktmp(src)
-        _ip.magic('run %s' % self.fname)
-        _ip.run_cell('ip == get_ipython()')
-        tt.assert_equals(_ip.user_ns['i'], 5)
-
-    @dec.skip_win32
-    def test_tclass(self):
-        mydir = os.path.dirname(__file__)
-        tc = os.path.join(mydir, 'tclass')
-        src = ("%%run '%s' C-first\n"
-               "%%run '%s' C-second\n"
-               "%%run '%s' C-third\n") % (tc, tc, tc)
-        self.mktmp(src, '.ipy')
-        out = """\
-ARGV 1-: [u'C-first']
-ARGV 1-: [u'C-second']
-tclass.py: deleting object: C-first
-ARGV 1-: [u'C-third']
-tclass.py: deleting object: C-second
-tclass.py: deleting object: C-third
-"""
-        tt.ipexec_validate(self.fname, out)
diff --git a/IPython/core/tips.py b/IPython/core/tips.py
new file mode 100644
index 00000000000..7e2f8b61365
--- /dev/null
+++ b/IPython/core/tips.py
@@ -0,0 +1,128 @@
+from datetime import datetime
+import os
+from random import choice
+from typing import Any
+
+_tips: Any = {
+    # (month, day)
+    "every_year": {
+        (1, 1): "Happy new year!",
+        # European time:
+        # [2/8/25, 23:28:24] Fernando Perez: Hi! Yes, this was my first public
+        # announcement:
+        # [2/8/25, 23:28:25] Fernando Perez:
+        # https://mail.python.org/pipermail/python-list/2001-December/093408.html
+        # [2/8/25, 23:28:55] Fernando Perez: All that started two months earlier
+        # - in October 2001 I read this article:
+        # [2/8/25, 23:28:55] Fernando Perez:
+        # https://web.archive.org/web/20011202000624/http://www.onlamp.com/pub/a/python/2001/10/11/pythonnews.html
+        # [2/8/25, 23:29:05] Fernando Perez: Which is also archived here:
+        # [2/8/25, 23:29:05] Fernando Perez:
+        # https://docstore.mik.ua/orelly/weblinux2/orn/interactive_python.html
+        # [2/8/25, 23:29:48] Fernando Perez: That article put me on the trail of
+        # LazyPython, and I also found out (can’t remember where) about IPP
+        # (Interactive Python Prompt), another similar projecd by Janko Hauser.
+        # [2/8/25, 23:30:20] Fernando Perez: A also read an article around that
+        # time, about new features in Python 2.0, which spoke of how
+        # sys.displayhook could be programmed to call any object you wanted.
+        # [2/8/25, 23:31:01] Fernando Perez: Those things together gave me the
+        # idea of implementing a stateful object, the “IPython Prompt�, that
+        # could store a  cache of old results, Mathematica-style, and that could
+        # have all kinds of other useful tricks up its sleeve.
+        # [2/8/25, 23:31:17] Fernando Perez: I can’t remember if I did the
+        # prompt stuff first and then read about LazyPython/IPP.
+        # [2/8/25, 23:31:41] Fernando Perez: I do know that, implementation
+        # wise, at first I just did the tiny IPython 0.0.1 that I posted much
+        # later on github as a gist:
+        # [2/8/25, 23:31:55] Fernando Perez:
+        # https://gist.github.com/fperez/1579699
+        # [2/8/25, 23:32:03] Fernando Perez: But I only shared that publicly
+        # much later.
+        # [2/8/25, 23:33:19] Fernando Perez: I did find out about IPP/LazyPython
+        # sometime in October, contacted Janko and Nathan who told me to use
+        # their code at will but said they were busy with other things, and got
+        # cranking for a few mad weeks on what became the IPython 0.2.0 that I
+        # posted about in that comp.lang.python thread of December 2001.
+        # [2/8/25, 23:33:52] Fernando Perez: That period from Oct 11 to Dec 9
+        # 2001 was maniacal coding, with very little sleep 🙂
+        (
+            10,
+            11,
+        ): "IPython's first line of code was written {} years ago by Fernando Pérez".format(
+            datetime.now().year - 2001
+        ),
+        (
+            12,
+            9,
+        ): "IPython 0.0.2 was announced {} years ago: https://mail.python.org/pipermail/python-list/2001-December/093408.html".format(
+            datetime.now().year - 2001
+        ),
+        (
+            3,
+            8,
+        ): "Today is International Women's Day: https://www.internationalwomensday.com/",
+        (
+            3,
+            31,
+        ): "Happy International Transgender Day of Visibility! You are valid. You matter. https://en.wikipedia.org/wiki/International_Transgender_Day_of_Visibility",
+    },
+    "random": [
+        "Use `F2` or %edit with no arguments to open an empty editor with a temporary file.",
+        "Run your doctests from within IPython for development and debugging. The special %doctest_mode command toggles a mode where the prompt, output and exceptions display matches as closely as possible that of the default Python interpreter.",
+        "You can use `files = !ls *.png`",
+        "Use the IPython.lib.demo.Demo class to load any Python script as an interactive demo.",
+        "Put a ';' at the end of a line to suppress the printing of output.",
+        "You can use Ctrl-O to force a new line in terminal IPython",
+        "Use `object?` to see the help on `object`, `object??` to view its source",
+        "`?` alone on a line will brings up IPython's help",
+        "You can use `%hist` to view history, see the options with `%history?`",
+        "You can change the editing mode of IPython to behave more like vi, or emacs.",
+        "IPython 9.0+ has hooks to integrate AI/LLM completions.",
+        "Use `%timeit` or `%%timeit`, and the  `-r`, `-n`, and `-o` options to easily profile your code.",
+        "Use `ipython --help-all | less` to view all the IPython configuration options.",
+        "Use `--theme`, or the `%colors` magic to change IPython's themes and colors.",
+        "The `%timeit` magic has a `-o` flag, which returns the results, making it easy to plot. See `%timeit?`.",
+    ],
+}
+
+if os.name == "nt":
+    _tips["random"].extend(
+        [
+            "We can't show you all tips on Windows as sometimes Unicode characters crash the Windows console, please help us debug it."
+        ]
+    )
+    # unicode may crash windows console, so we filter out tips with non-ASCII characters.
+    _tips["every_year"] = {
+        k: v
+        for k, v in _tips["every_year"].items()
+        if all(ord(char) < 128 for char in v)
+    }
+else:
+    _tips["random"].extend(
+        [
+            "You can use LaTeX or Unicode completion, `\\alpha<tab>` will insert the α symbol.",
+            "You can find how to type a LaTeX symbol by back-completing it, eg `\\θ<tab>` will expand to `\\theta`.",
+            "You can find how to type a Unicode symbol by back-completing it, eg `\\â…§<tab>` will expand to `\\ROMAN NUMERAL EIGHT`.",
+            "IPython supports combining unicode identifiers, eg F\\vec<tab> will become F⃗, useful for physics equations. Play with \\dot \\ddot and others.",
+        ]
+    )
+
+# Check if argcomplete is installed and add tip
+try:
+    import argcomplete
+
+    _tips["random"].append(
+        "Run `activate-global-python-argcomplete` from your shell to enable CLI completion for IPython"
+    )
+except ModuleNotFoundError:
+    pass
+
+
+def pick_tip() -> str:
+    current_date = datetime.now()
+    month, day = current_date.month, current_date.day
+
+    if (month, day) in _tips["every_year"]:
+        return _tips["every_year"][(month, day)]
+
+    return choice(_tips["random"])
diff --git a/IPython/core/ultratb.py b/IPython/core/ultratb.py
index 22928da3cb1..16c95cdd2f3 100644
--- a/IPython/core/ultratb.py
+++ b/IPython/core/ultratb.py
@@ -1,18 +1,20 @@
-# -*- coding: utf-8 -*-
 """
-ultratb.py -- Spice up your tracebacks!
+Verbose and colourful traceback formatting.
+
+**ColorTB**
 
-* ColorTB
 I've always found it a bit hard to visually parse tracebacks in Python.  The
 ColorTB class is a solution to that problem.  It colors the different parts of a
 traceback in a manner similar to what you would expect from a syntax-highlighting
 text editor.
 
-Installation instructions for ColorTB:
+Installation instructions for ColorTB::
+
     import sys,ultratb
     sys.excepthook = ultratb.ColorTB()
 
-* VerboseTB  
+**VerboseTB**
+
 I've also included a port of Ka-Ping Yee's "cgitb.py" that produces all kinds
 of useful info when a traceback occurs.  Ping originally had it spit out HTML
 and intended it for CGI programmers, but why should they have all the fun?  I
@@ -21,7 +23,7 @@
 are bug-free.  If a crash *does* occur in that type of program you want details.
 Give it a shot--you'll love it or you'll hate it.
 
-Note:
+.. note::
 
   The Verbose mode prints the variables currently visible where the exception
   happened (shortening their strings if too long). This can potentially be
@@ -34,385 +36,89 @@
   Verbose_novars mode instead of the regular Verbose, which avoids formatting
   variables (but otherwise includes the information and context given by
   Verbose).
-  
 
-Installation instructions for ColorTB:
+.. note::
+
+  The verbose mode print all variables in the stack, which means it can
+  potentially leak sensitive information like access keys, or unencrypted
+  password.
+
+Installation instructions for VerboseTB::
+
     import sys,ultratb
     sys.excepthook = ultratb.VerboseTB()
 
 Note:  Much of the code in this module was lifted verbatim from the standard
 library module 'traceback.py' and Ka-Ping Yee's 'cgitb.py'.
 
-* Color schemes
-The colors are defined in the class TBTools through the use of the
-ColorSchemeTable class. Currently the following exist:
-
-  - NoColor: allows all of this module to be used in any terminal (the color
-  escapes are just dummy blank strings).
-
-  - Linux: is meant to look good in a terminal like the Linux console (black
-  or very dark background).
 
-  - LightBG: similar to Linux but swaps dark/light colors to be more readable
-  in light background terminals.
+Inheritance diagram:
 
-You can implement other color schemes easily, the syntax is fairly
-self-explanatory. Please send back new schemes you develop to the author for
-possible inclusion in future releases.
+.. inheritance-diagram:: IPython.core.ultratb
+   :parts: 3
 """
 
-#*****************************************************************************
-#       Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu>
-#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
+# *****************************************************************************
+# Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu>
+# Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
 #
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from __future__ import with_statement
+# Distributed under the terms of the BSD License.  The full license is in
+# the file COPYING, distributed as part of this software.
+# *****************************************************************************
 
+import functools
 import inspect
-import keyword
 import linecache
-import os
-import pydoc
-import re
 import sys
 import time
-import tokenize
 import traceback
 import types
-
-# For purposes of monkeypatching inspect to fix a bug in it.
-from inspect import getsourcefile, getfile, getmodule,\
-     ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode
-
-# IPython's own modules
-# Modified pdb which doesn't damage IPython's readline handling
-from IPython.core import debugger, ipapi
-from IPython.core.display_trap import DisplayTrap
-from IPython.core.excolors import exception_colors
-from IPython.utils import PyColorize
-from IPython.utils import io
-from IPython.utils.data import uniq_stable
-from IPython.utils.warn import info, error
+import warnings
+from collections.abc import Sequence
+from types import TracebackType
+from typing import Any, List, Optional, Tuple
+from collections.abc import Callable
+
+import stack_data
+from pygments.formatters.terminal256 import Terminal256Formatter
+from pygments.token import Token
+
+from IPython import get_ipython
+from IPython.utils import path as util_path
+from IPython.utils import py3compat
+from IPython.utils.PyColorize import Parser, Theme, TokenStream, theme_table
+from IPython.utils.terminal import get_terminal_size
+
+from .display_trap import DisplayTrap
+from .doctb import DocTB
+from .tbtools import (
+    FrameInfo,
+    TBTools,
+    _format_traceback_lines,
+    _safe_string,
+    _simple_format_traceback_lines,
+    _tokens_filename,
+    eqrepr,
+    get_line_number_of_frame,
+    nullrepr,
+    text_repr,
+)
 
 # Globals
 # amount of space to put line numbers before verbose tracebacks
 INDENT_SIZE = 8
 
-# Default color scheme.  This is used, for example, by the traceback
-# formatter.  When running in an actual IPython instance, the user's rc.colors
-# value is used, but havinga module global makes this functionality available
-# to users of ultratb who are NOT running inside ipython.
-DEFAULT_SCHEME = 'NoColor'
-
-#---------------------------------------------------------------------------
-# Code begins
-
-# Utility functions
-def inspect_error():
-    """Print a message about internal inspect errors.
-
-    These are unfortunately quite common."""
-    
-    error('Internal Python error in the inspect module.\n'
-          'Below is the traceback from this internal error.\n')
-
-
-def findsource(object):
-    """Return the entire source file and starting line number for an object.
-
-    The argument may be a module, class, method, function, traceback, frame,
-    or code object.  The source code is returned as a list of all the lines
-    in the file and the line number indexes a line in that list.  An IOError
-    is raised if the source code cannot be retrieved.
-
-    FIXED version with which we monkeypatch the stdlib to work around a bug."""
-
-    file = getsourcefile(object) or getfile(object)
-    # If the object is a frame, then trying to get the globals dict from its
-    # module won't work. Instead, the frame object itself has the globals
-    # dictionary.
-    globals_dict = None
-    if inspect.isframe(object):
-        # XXX: can this ever be false?
-        globals_dict = object.f_globals
-    else:
-        module = getmodule(object, file)
-        if module:
-            globals_dict = module.__dict__
-    lines = linecache.getlines(file, globals_dict)
-    if not lines:
-        raise IOError('could not get source code')
-
-    if ismodule(object):
-        return lines, 0
-
-    if isclass(object):
-        name = object.__name__
-        pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
-        # make some effort to find the best matching class definition:
-        # use the one with the least indentation, which is the one
-        # that's most probably not inside a function definition.
-        candidates = []
-        for i in range(len(lines)):
-            match = pat.match(lines[i])
-            if match:
-                # if it's at toplevel, it's already the best one
-                if lines[i][0] == 'c':
-                    return lines, i
-                # else add whitespace to candidate list
-                candidates.append((match.group(1), i))
-        if candidates:
-            # this will sort by whitespace, and by line number,
-            # less whitespace first
-            candidates.sort()
-            return lines, candidates[0][1]
-        else:
-            raise IOError('could not find class definition')
-
-    if ismethod(object):
-        object = object.im_func
-    if isfunction(object):
-        object = object.func_code
-    if istraceback(object):
-        object = object.tb_frame
-    if isframe(object):
-        object = object.f_code
-    if iscode(object):
-        if not hasattr(object, 'co_firstlineno'):
-            raise IOError('could not find function definition')
-        pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
-        pmatch = pat.match
-        # fperez - fix: sometimes, co_firstlineno can give a number larger than
-        # the length of lines, which causes an error.  Safeguard against that.
-        lnum = min(object.co_firstlineno,len(lines))-1
-        while lnum > 0:
-            if pmatch(lines[lnum]): break
-            lnum -= 1
- 
-        return lines, lnum
-    raise IOError('could not find code object')
-
-# Monkeypatch inspect to apply our bugfix.  This code only works with py25
-if sys.version_info[:2] >= (2,5):
-    inspect.findsource = findsource
-
-def fix_frame_records_filenames(records):
-    """Try to fix the filenames in each record from inspect.getinnerframes().
-
-    Particularly, modules loaded from within zip files have useless filenames
-    attached to their code object, and inspect.getinnerframes() just uses it.
-    """
-    fixed_records = []
-    for frame, filename, line_no, func_name, lines, index in records:
-        # Look inside the frame's globals dictionary for __file__, which should
-        # be better.
-        better_fn = frame.f_globals.get('__file__', None)
-        if isinstance(better_fn, str):
-            # Check the type just in case someone did something weird with
-            # __file__. It might also be None if the error occurred during
-            # import.
-            filename = better_fn
-        fixed_records.append((frame, filename, line_no, func_name, lines, index))
-    return fixed_records
-
-
-def _fixed_getinnerframes(etb, context=1,tb_offset=0):
-    import linecache
-    LNUM_POS, LINES_POS, INDEX_POS =  2, 4, 5
-
-    records  = fix_frame_records_filenames(inspect.getinnerframes(etb, context))
-
-    # If the error is at the console, don't build any context, since it would
-    # otherwise produce 5 blank lines printed out (there is no file at the
-    # console)
-    rec_check = records[tb_offset:]
-    try:
-        rname = rec_check[0][1]
-        if rname == '<ipython console>' or rname.endswith('<string>'):
-            return rec_check
-    except IndexError:
-        pass
-
-    aux = traceback.extract_tb(etb)
-    assert len(records) == len(aux)
-    for i, (file, lnum, _, _) in zip(range(len(records)), aux):
-        maybeStart = lnum-1 - context//2
-        start =  max(maybeStart, 0)
-        end   = start + context
-        lines = linecache.getlines(file)[start:end]
-        buf = list(records[i])
-        buf[LNUM_POS] = lnum
-        buf[INDEX_POS] = lnum - 1 - start
-        buf[LINES_POS] = lines
-        records[i] = tuple(buf)
-    return records[tb_offset:]
-
-# Helper function -- largely belongs to VerboseTB, but we need the same
-# functionality to produce a pseudo verbose TB for SyntaxErrors, so that they
-# can be recognized properly by ipython.el's py-traceback-line-re
-# (SyntaxErrors have to be treated specially because they have no traceback)
-
-_parser = PyColorize.Parser()
-    
-def _format_traceback_lines(lnum, index, lines, Colors, lvals=None,scheme=None):
-    numbers_width = INDENT_SIZE - 1
-    res = []
-    i = lnum - index
-
-    # This lets us get fully syntax-highlighted tracebacks.
-    if scheme is None:
-        ipinst = ipapi.get()
-        if ipinst is not None:
-            scheme = ipinst.colors
-        else:
-            scheme = DEFAULT_SCHEME
-
-    _line_format = _parser.format2
-
-    for line in lines:
-        # FIXME: we need to ensure the source is a pure string at this point,
-        # else the coloring code makes a  royal mess.  This is in need of a
-        # serious refactoring, so that all of the ultratb and PyColorize code
-        # is unicode-safe.  So for now this is rather an ugly hack, but
-        # necessary to at least have readable tracebacks. Improvements welcome!
-        if type(line)==unicode:
-            line = line.encode('utf-8', 'replace')
-            
-        new_line, err = _line_format(line, 'str', scheme)
-        if not err: line = new_line
-        
-        if i == lnum:
-            # This is the line with the error
-            pad = numbers_width - len(str(i))
-            if pad >= 3:
-                marker = '-'*(pad-3) + '-> '
-            elif pad == 2:
-                marker = '> '
-            elif pad == 1:
-                marker = '>'
-            else:
-                marker = ''
-            num = marker + str(i)
-            line = '%s%s%s %s%s' %(Colors.linenoEm, num, 
-                                   Colors.line, line, Colors.Normal)
-        else:
-            num = '%*s' % (numbers_width,i)
-            line = '%s%s%s %s' %(Colors.lineno, num, 
-                                 Colors.Normal, line)
-
-        res.append(line)
-        if lvals and i == lnum:
-            res.append(lvals + '\n')
-        i = i + 1
-    return res
-
-
-#---------------------------------------------------------------------------
-# Module classes
-class TBTools(object):
-    """Basic tools used by all traceback printer classes."""
-
-    # Number of frames to skip when reporting tracebacks
-    tb_offset = 0
-
-    def __init__(self, color_scheme='NoColor', call_pdb=False, ostream=None):
-        # Whether to call the interactive pdb debugger after printing
-        # tracebacks or not
-        self.call_pdb = call_pdb
-
-        # Output stream to write to.  Note that we store the original value in
-        # a private attribute and then make the public ostream a property, so
-        # that we can delay accessing io.stdout until runtime.  The way
-        # things are written now, the io.stdout object is dynamically managed
-        # so a reference to it should NEVER be stored statically.  This
-        # property approach confines this detail to a single location, and all
-        # subclasses can simply access self.ostream for writing.
-        self._ostream = ostream
-
-        # Create color table
-        self.color_scheme_table = exception_colors()
-
-        self.set_colors(color_scheme)
-        self.old_scheme = color_scheme  # save initial value for toggles
-
-        if call_pdb:
-            self.pdb = debugger.Pdb(self.color_scheme_table.active_scheme_name)
-        else:
-            self.pdb = None
-
-    def _get_ostream(self):
-        """Output stream that exceptions are written to.
+# When files are too long do not use stackdata to get frames.
+# it is too long.
+FAST_THRESHOLD = 10_000
 
-        Valid values are:
-        
-        - None: the default, which means that IPython will dynamically resolve
-        to io.stdout.  This ensures compatibility with most tools, including
-        Windows (where plain stdout doesn't recognize ANSI escapes).
-
-        - Any object with 'write' and 'flush' attributes.
-        """
-        return io.stdout if self._ostream is None else self._ostream
-
-    def _set_ostream(self, val):
-        assert val is None or (hasattr(val, 'write') and hasattr(val, 'flush'))
-        self._ostream = val
-        
-    ostream = property(_get_ostream, _set_ostream)
-
-    def set_colors(self,*args,**kw):
-        """Shorthand access to the color table scheme selector method."""
-
-        # Set own color table
-        self.color_scheme_table.set_active_scheme(*args,**kw)
-        # for convenience, set Colors to the active scheme
-        self.Colors = self.color_scheme_table.active_colors
-        # Also set colors of debugger
-        if hasattr(self,'pdb') and self.pdb is not None:
-            self.pdb.set_colors(*args,**kw)
-
-    def color_toggle(self):
-        """Toggle between the currently active color scheme and NoColor."""
-        
-        if self.color_scheme_table.active_scheme_name == 'NoColor':
-            self.color_scheme_table.set_active_scheme(self.old_scheme)
-            self.Colors = self.color_scheme_table.active_colors
-        else:
-            self.old_scheme = self.color_scheme_table.active_scheme_name
-            self.color_scheme_table.set_active_scheme('NoColor')
-            self.Colors = self.color_scheme_table.active_colors
-
-    def stb2text(self, stb):
-        """Convert a structured traceback (a list) to a string."""
-        return '\n'.join(stb)
-
-    def text(self, etype, value, tb, tb_offset=None, context=5):
-        """Return formatted traceback.
-
-        Subclasses may override this if they add extra arguments.
-        """
-        tb_list = self.structured_traceback(etype, value, tb,
-                                            tb_offset, context)
-        return self.stb2text(tb_list)
-
-    def structured_traceback(self, etype, evalue, tb, tb_offset=None,
-                             context=5, mode=None):
-        """Return a list of traceback frames.
-
-        Must be implemented by each class.
-        """
-        raise NotImplementedError()
-
-
-#---------------------------------------------------------------------------
+# ---------------------------------------------------------------------------
 class ListTB(TBTools):
     """Print traceback information from a traceback list, with optional color.
-        
-    Calling: requires 3 arguments:
-      (etype, evalue, elist)
-    as would be obtained by:
+
+    Calling requires 3 arguments: (etype, evalue, elist)
+    as would be obtained by::
+
       etype, evalue, tb = sys.exc_info()
       if tb:
         elist = traceback.extract_tb(tb)
@@ -426,69 +132,115 @@ class ListTB(TBTools):
     Because they are meant to be called without a full traceback (only a
     list), instances of this class can't call the interactive pdb debugger."""
 
-    def __init__(self,color_scheme = 'NoColor', call_pdb=False, ostream=None):
-        TBTools.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
-                         ostream=ostream)
-        
-    def __call__(self, etype, value, elist):
+    def __call__(
+        self,
+        etype: type[BaseException],
+        evalue: BaseException | None,
+        etb: TracebackType | None,
+    ) -> None:
         self.ostream.flush()
-        self.ostream.write(self.text(etype, value, elist))
-        self.ostream.write('\n')
+        self.ostream.write(self.text(etype, evalue, etb))
+        self.ostream.write("\n")
+
+    def _extract_tb(self, tb: TracebackType | None) -> traceback.StackSummary | None:
+        if tb:
+            return traceback.extract_tb(tb)
+        else:
+            return None
 
-    def structured_traceback(self, etype, value, elist, tb_offset=None,
-                             context=5):
+    def structured_traceback(
+        self,
+        etype: type,
+        evalue: Optional[BaseException],
+        etb: Optional[TracebackType] = None,
+        tb_offset: Optional[int] = None,
+        context: int = 5,
+    ) -> list[str]:
         """Return a color formatted string with the traceback info.
 
         Parameters
         ----------
         etype : exception type
-          Type of the exception raised.
-
-        value : object
-          Data stored in the exception
-
-        elist : list
-          List of frames, see class docstring for details.
-
+            Type of the exception raised.
+        evalue : object
+            Data stored in the exception
+        etb : list | TracebackType | None
+            If list: List of frames, see class docstring for details.
+            If Traceback: Traceback of the exception.
         tb_offset : int, optional
-          Number of frames in the traceback to skip.  If not given, the
-          instance value is used (set in constructor).
-          
+            Number of frames in the traceback to skip.  If not given, the
+            instance evalue is used (set in constructor).
         context : int, optional
-          Number of lines of context information to print.
+            Number of lines of context information to print.
 
         Returns
         -------
         String with formatted exception.
         """
+        # This is a workaround to get chained_exc_ids in recursive calls
+        # etb should not be a tuple if structured_traceback is not recursive
+        if isinstance(etb, tuple):
+            etb, chained_exc_ids = etb
+        else:
+            chained_exc_ids = set()
+        elist: list[Any]
+        if isinstance(etb, list):
+            elist = etb
+        elif etb is not None:
+            elist = self._extract_tb(etb)  # type: ignore[assignment]
+        else:
+            elist = []
         tb_offset = self.tb_offset if tb_offset is None else tb_offset
-        Colors = self.Colors
-        out_list = []
+        assert isinstance(tb_offset, int)
+        out_list: list[str] = []
         if elist:
-
             if tb_offset and len(elist) > tb_offset:
                 elist = elist[tb_offset:]
-            
-            out_list.append('Traceback %s(most recent call last)%s:' %
-                                (Colors.normalEm, Colors.Normal) + '\n')
+
+            out_list.append(
+                theme_table[self._theme_name].format(
+                    [
+                        (Token, "Traceback"),
+                        (Token, " "),
+                        (Token.NormalEm, "(most recent call last)"),
+                        (Token, ":"),
+                        (Token, "\n"),
+                    ]
+                ),
+            )
             out_list.extend(self._format_list(elist))
         # The exception info should be a single entry in the list.
-        lines = ''.join(self._format_exception_only(etype, value))
+        lines = "".join(self._format_exception_only(etype, evalue))
         out_list.append(lines)
 
-        # Note: this code originally read:
-        
-        ## for line in lines[:-1]:
-        ##     out_list.append(" "+line)
-        ## out_list.append(lines[-1])
+        # Find chained exceptions if we have a traceback (not for exception-only mode)
+        if etb is not None:
+            exception = self.get_parts_of_chained_exception(evalue)
+
+            if exception and (id(exception[1]) not in chained_exc_ids):
+                chained_exception_message: list[str] = (
+                    self.prepare_chained_exception_message(evalue.__cause__)[0]
+                    if evalue is not None
+                    else [""]
+                )
+                etype, evalue, etb = exception
+                # Trace exception to avoid infinite 'cause' loop
+                chained_exc_ids.add(id(exception[1]))
+                chained_exceptions_tb_offset = 0
+                ol1 = self.structured_traceback(
+                    etype,
+                    evalue,
+                    (etb, chained_exc_ids),  # type: ignore[arg-type]
+                    chained_exceptions_tb_offset,
+                    context,
+                )
+                ol2 = chained_exception_message
+
+                out_list = ol1 + ol2 + out_list
 
-        # This means it was indenting everything but the last line by a little
-        # bit.  I've disabled this for now, but if we see ugliness somewhre we
-        # can restore it.
-        
         return out_list
 
-    def _format_list(self, extracted_list):
+    def _format_list(self, extracted_list: list[Any]) -> list[str]:
         """Format a list of traceback entry tuples for printing.
 
         Given a list of tuples as returned by extract_tb() or
@@ -497,36 +249,47 @@ def _format_list(self, extracted_list):
         same index in the argument list.  Each string ends in a newline;
         the strings may contain internal newlines as well, for those items
         whose source text line is not None.
-        
+
         Lifted almost verbatim from traceback.py
         """
 
-        Colors = self.Colors
-        list = []
-        for filename, lineno, name, line in extracted_list[:-1]:
-            item = '  File %s"%s"%s, line %s%d%s, in %s%s%s\n' % \
-                    (Colors.filename, filename, Colors.Normal, 
-                     Colors.lineno, lineno, Colors.Normal,
-                     Colors.name, name, Colors.Normal)
+        output_list = []
+        for ind, (filename, lineno, name, line) in enumerate(extracted_list):
+            # Will emphasize the last entry
+            em = True if ind == len(extracted_list) - 1 else False
+
+            item = theme_table[self._theme_name].format(
+                [(Token.NormalEm if em else Token.Normal, "  ")]
+                + _tokens_filename(em, filename, lineno=lineno)
+            )
+
+            # This seem to be only in xmode plain (%run sinpleer), investigate why not share with verbose.
+            # look at _tokens_filename in forma_record.
+            if name != "<module>":
+                item += theme_table[self._theme_name].format(
+                    [
+                        (Token.NormalEm if em else Token.Normal, " in "),
+                        (Token.TB.NameEm if em else Token.TB.Name, name),
+                    ]
+                )
+            item += theme_table[self._theme_name].format(
+                [(Token.NormalEm if em else Token, "\n")]
+            )
             if line:
-                item = item + '    %s\n' % line.strip()
-            list.append(item)
-        # Emphasize the last entry
-        filename, lineno, name, line = extracted_list[-1]
-        item = '%s  File %s"%s"%s, line %s%d%s, in %s%s%s%s\n' % \
-                (Colors.normalEm,
-                 Colors.filenameEm, filename, Colors.normalEm,
-                 Colors.linenoEm, lineno, Colors.normalEm,
-                 Colors.nameEm, name, Colors.normalEm,
-                 Colors.Normal)
-        if line:
-            item = item + '%s    %s%s\n' % (Colors.line, line.strip(),
-                                            Colors.Normal)
-        list.append(item)
-        #from pprint import pformat; print 'LISTTB', pformat(list) # dbg
-        return list
-        
-    def _format_exception_only(self, etype, value):
+                item += theme_table[self._theme_name].format(
+                    [
+                        (Token.Line if em else Token, "    "),
+                        (Token.Line if em else Token, line.strip()),
+                        (Token, "\n"),
+                    ]
+                )
+            output_list.append(item)
+
+        return output_list
+
+    def _format_exception_only(
+        self, etype: type[BaseException], value: BaseException | None
+    ) -> list[str]:
         """Format the exception part of a traceback.
 
         The arguments are the exception type and value such as given by
@@ -536,99 +299,149 @@ def _format_exception_only(self, etype, value):
         printed) display detailed information about where the syntax error
         occurred.  The message indicating which exception occurred is the
         always last string in the list.
-        
+
         Also lifted nearly verbatim from traceback.py
         """
-
         have_filedata = False
-        Colors = self.Colors
-        list = []
-        try:
-            stype = Colors.excName + etype.__name__ + Colors.Normal
-        except AttributeError:
-            stype = etype  # String exceptions don't get special coloring
+        output_list = []
+        stype_tokens = [(Token.ExcName, etype.__name__)]
+        stype: str = theme_table[self._theme_name].format(stype_tokens)
         if value is None:
-            list.append( str(stype) + '\n')
+            # Not sure if this can still happen in Python 2.6 and above
+            output_list.append(stype + "\n")
         else:
-            if etype is SyntaxError:
-                try:
-                    msg, (filename, lineno, offset, line) = value
-                except:
-                    have_filedata = False
+            if issubclass(etype, SyntaxError):
+                assert hasattr(value, "filename")
+                assert hasattr(value, "lineno")
+                assert hasattr(value, "text")
+                assert hasattr(value, "offset")
+                assert hasattr(value, "msg")
+                have_filedata = True
+                if not value.filename:
+                    value.filename = "<string>"
+                if value.lineno:
+                    lineno = value.lineno
+                    textline = linecache.getline(value.filename, value.lineno)
                 else:
-                    have_filedata = True
-                    #print 'filename is',filename  # dbg
-                    if not filename: filename = "<string>"
-                    list.append('%s  File %s"%s"%s, line %s%d%s\n' % \
-                            (Colors.normalEm,
-                             Colors.filenameEm, filename, Colors.normalEm,
-                             Colors.linenoEm, lineno, Colors.Normal  ))
-                    if line is not None:
-                        i = 0
-                        while i < len(line) and line[i].isspace():
-                            i = i+1
-                        list.append('%s    %s%s\n' % (Colors.line,
-                                                      line.strip(), 
-                                                      Colors.Normal))
-                        if offset is not None:
-                            s = '    '
-                            for c in line[i:offset-1]:
-                                if c.isspace():
-                                    s = s + c
-                                else:
-                                    s = s + ' '
-                            list.append('%s%s^%s\n' % (Colors.caret, s,
-                                                       Colors.Normal) )
-                        value = msg
-            s = self._some_str(value)
+                    lineno = "unknown"
+                    textline = ""
+                output_list.append(
+                    theme_table[self._theme_name].format(
+                        [(Token, "  ")]
+                        + _tokens_filename(
+                            True,
+                            value.filename,
+                            lineno=(None if lineno == "unknown" else lineno),
+                        )
+                        + [(Token, "\n")]
+                    )
+                )
+                if textline == "":
+                    # sep 2025:
+                    # textline = py3compat.cast_unicode(value.text, "utf-8")
+                    if value.text is None:
+                        textline = ""
+                    else:
+                        assert isinstance(value.text, str)
+                        textline = value.text
+
+                if textline is not None:
+                    i = 0
+                    while i < len(textline) and textline[i].isspace():
+                        i += 1
+                    output_list.append(
+                        theme_table[self._theme_name].format(
+                            [
+                                (Token.Line, "    "),
+                                (Token.Line, textline.strip()),
+                                (Token, "\n"),
+                            ]
+                        )
+                    )
+                    if value.offset is not None:
+                        s = "    "
+                        for c in textline[i : value.offset - 1]:
+                            if c.isspace():
+                                s += c
+                            else:
+                                s += " "
+                        output_list.append(
+                            theme_table[self._theme_name].format(
+                                [(Token.Caret, s + "^"), (Token, "\n")]
+                            )
+                        )
+                s = value.msg
+            else:
+                s = self._some_str(value)
             if s:
-                list.append('%s%s:%s %s\n' % (str(stype), Colors.excName,
-                                              Colors.Normal, s))
+                output_list.append(
+                    theme_table[self._theme_name].format(
+                        stype_tokens
+                        + [
+                            (Token.ExcName, ":"),
+                            (Token, " "),
+                            (Token, s),
+                            (Token, "\n"),
+                        ]
+                    )
+                )
             else:
-                list.append('%s\n' % str(stype))
+                output_list.append("%s\n" % stype)
+
+            # PEP-678 notes
+            output_list.extend(f"{x}\n" for x in getattr(value, "__notes__", []))
 
         # sync with user hooks
         if have_filedata:
-            ipinst = ipapi.get()
+            ipinst = get_ipython()
             if ipinst is not None:
-                ipinst.hooks.synchronize_with_editor(filename, lineno, 0)
+                assert value is not None
+                assert hasattr(value, "lineno")
+                assert hasattr(value, "filename")
+                ipinst.hooks.synchronize_with_editor(value.filename, value.lineno, 0)
 
-        return list
+        return output_list
 
     def get_exception_only(self, etype, value):
         """Only print the exception type and message, without a traceback.
-        
+
         Parameters
         ----------
         etype : exception type
         value : exception value
         """
-        return ListTB.structured_traceback(self, etype, value, [])
-
+        return ListTB.structured_traceback(self, etype, value)
 
-    def show_exception_only(self, etype, evalue):
+    def show_exception_only(
+        self, etype: BaseException | None, evalue: TracebackType | None
+    ) -> None:
         """Only print the exception type and message, without a traceback.
-        
+
         Parameters
         ----------
         etype : exception type
-        value : exception value
+        evalue : exception value
         """
         # This method needs to use __call__ from *this* class, not the one from
         # a subclass whose signature or behavior may be different
         ostream = self.ostream
         ostream.flush()
-        ostream.write('\n'.join(self.get_exception_only(etype, evalue)))
+        ostream.write("\n".join(self.get_exception_only(etype, evalue)))
         ostream.flush()
 
-    def _some_str(self, value):
+    def _some_str(self, value: Any) -> str:
         # Lifted from traceback.py
         try:
             return str(value)
         except:
-            return '<unprintable %s object>' % type(value).__name__
+            return "<unprintable %s object>" % type(value).__name__
 
-#----------------------------------------------------------------------------
+
+_sentinel = object()
+_default = "default"
+
+
+# ----------------------------------------------------------------------------
 class VerboseTB(TBTools):
     """A port of Ka-Ping Yee's cgitb.py module that outputs color text instead
     of HTML.  Requires inspect and pydoc.  Crazy, man.
@@ -637,343 +450,486 @@ class VerboseTB(TBTools):
     traceback, to be used with alternate interpreters (because their own code
     would appear in the traceback)."""
 
-    def __init__(self,color_scheme = 'Linux', call_pdb=False, ostream=None,
-                 tb_offset=0, long_header=False, include_vars=True,
-                 check_cache=None):
+    tb_highlight = "bg:ansiyellow"
+    tb_highlight_style = "default"
+
+    _mode: str
+
+    def __init__(
+        self,
+        # TODO: no default ?
+        theme_name: str = _default,
+        call_pdb: bool = False,
+        ostream: Any = None,
+        tb_offset: int = 0,
+        long_header: bool = False,
+        include_vars: bool = True,
+        check_cache: Callable[[], None] | None = None,
+        debugger_cls: type | None = None,
+        *,
+        color_scheme: Any = _sentinel,
+    ):
         """Specify traceback offset, headers and color scheme.
 
         Define how many frames to drop from the tracebacks. Calling it with
         tb_offset=1 allows use of this handler in interpreters which will have
         their own code at the top of the traceback (VerboseTB will first
         remove that frame before printing the traceback info)."""
-        TBTools.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
-                         ostream=ostream)
+        if color_scheme is not _sentinel:
+            assert isinstance(color_scheme, str)
+            theme_name = color_scheme.lower()
+
+            warnings.warn(
+                "color_scheme is deprecated as of IPython 9.0 and replaced by "
+                "theme_name (which should be lowercase). As you passed a "
+                "color_scheme value I will try to see if I have corresponding "
+                "theme.",
+                stacklevel=2,
+                category=DeprecationWarning,
+            )
+
+            if theme_name != _default:
+                warnings.warn(
+                    "You passed both `theme_name` and `color_scheme` "
+                    "(deprecated) to VerboseTB constructor. `theme_name` will "
+                    "be ignored for the time being.",
+                    stacklevel=2,
+                    category=DeprecationWarning,
+                )
+
+        if theme_name == _default:
+            theme_name = "linux"
+
+        assert isinstance(theme_name, str)
+        super().__init__(
+            theme_name=theme_name,
+            call_pdb=call_pdb,
+            ostream=ostream,
+            debugger_cls=debugger_cls,
+        )
         self.tb_offset = tb_offset
         self.long_header = long_header
         self.include_vars = include_vars
         # By default we use linecache.checkcache, but the user can provide a
-        # different check_cache implementation.  This is used by the IPython
-        # kernel to provide tracebacks for interactive code that is cached,
-        # by a compiler instance that flushes the linecache but preserves its
-        # own code cache.
+        # different check_cache implementation.  This was formerly used by the
+        # IPython kernel for interactive code, but is no longer necessary.
         if check_cache is None:
             check_cache = linecache.checkcache
         self.check_cache = check_cache
 
-    def structured_traceback(self, etype, evalue, etb, tb_offset=None,
-                             context=5):
-        """Return a nice text document describing the traceback."""
+        self.skip_hidden = True
+
+    def format_record(self, frame_info: FrameInfo) -> str:
+        """Format a single stack frame"""
+        assert isinstance(frame_info, FrameInfo)
+
+        if isinstance(frame_info._sd, stack_data.RepeatedFrames):
+            return theme_table[self._theme_name].format(
+                [
+                    (Token, "    "),
+                    (
+                        Token.ExcName,
+                        "[... skipping similar frames: %s]" % frame_info.description,
+                    ),
+                    (Token, "\n"),
+                ]
+            )
 
-        tb_offset = self.tb_offset if tb_offset is None else tb_offset
+        indent: str = " " * INDENT_SIZE
 
-        # some locals
-        try:
-            etype = etype.__name__
-        except AttributeError:
-            pass
-        Colors        = self.Colors   # just a shorthand + quicker name lookup
-        ColorsNormal  = Colors.Normal  # used a lot
-        col_scheme    = self.color_scheme_table.active_scheme_name
-        indent        = ' '*INDENT_SIZE
-        em_normal     = '%s\n%s%s' % (Colors.valEm, indent,ColorsNormal)
-        undefined     = '%sundefined%s' % (Colors.em, ColorsNormal)
-        exc = '%s%s%s' % (Colors.excName,etype,ColorsNormal)
-
-        # some internal-use functions
-        def text_repr(value):
-            """Hopefully pretty robust repr equivalent."""
-            # this is pretty horrible but should always return *something*
+        assert isinstance(frame_info.lineno, int)
+        args, varargs, varkw, locals_ = inspect.getargvalues(frame_info.frame)
+        if frame_info.executing is not None:
+            func = frame_info.executing.code_qualname()
+        else:
+            func = "?"
+        if func == "<module>":
+            call = ""
+        else:
+            # Decide whether to include variable details or not
+            var_repr = eqrepr if self.include_vars else nullrepr
             try:
-                return pydoc.text.repr(value)
-            except KeyboardInterrupt:
-                raise
-            except:
-                try:
-                    return repr(value)
-                except KeyboardInterrupt:
-                    raise
-                except:
-                    try:
-                        # all still in an except block so we catch
-                        # getattr raising
-                        name = getattr(value, '__name__', None)
-                        if name:
-                            # ick, recursion
-                            return text_repr(name)
-                        klass = getattr(value, '__class__', None)
-                        if klass:
-                            return '%s instance' % text_repr(klass)
-                    except KeyboardInterrupt:
-                        raise
-                    except:
-                        return 'UNRECOVERABLE REPR FAILURE'
-        def eqrepr(value, repr=text_repr): return '=%s' % repr(value)
-        def nullrepr(value, repr=text_repr): return ''
-
-        # meat of the code begins
-        try:
-            etype = etype.__name__
-        except AttributeError:
-            pass
+                scope = inspect.formatargvalues(
+                    args, varargs, varkw, locals_, formatvalue=var_repr
+                )
+                assert isinstance(scope, str)
+                call = theme_table[self._theme_name].format(
+                    [(Token, "in "), (Token.VName, func), (Token.ValEm, scope)]
+                )
+            except KeyError:
+                # This happens in situations like errors inside generator
+                # expressions, where local variables are listed in the
+                # line, but can't be extracted from the frame.  I'm not
+                # 100% sure this isn't actually a bug in inspect itself,
+                # but since there's no info for us to compute with, the
+                # best we can do is report the failure and move on.  Here
+                # we must *not* call any traceback construction again,
+                # because that would mess up use of %debug later on.  So we
+                # simply report the failure and move on.  The only
+                # limitation will be that this frame won't have locals
+                # listed in the call signature.  Quite subtle problem...
+                # I can't think of a good way to validate this in a unit
+                # test, but running a script consisting of:
+                #  dict( (k,v.strip()) for (k,v) in range(10) )
+                # will illustrate the error, if this exception catch is
+                # disabled.
+                call = theme_table[self._theme_name].format(
+                    [
+                        (Token, "in "),
+                        (Token.VName, func),
+                        (Token.ValEm, "(***failed resolving arguments***)"),
+                    ]
+                )
+
+        lvals_toks: list[TokenStream] = []
+        if self.include_vars:
+            try:
+                # we likely want to fix stackdata at some point, but
+                # still need a workaround.
+                fibp = frame_info.variables_in_executing_piece
+                for var in fibp:
+                    lvals_toks.append(
+                        [
+                            (Token, var.name),
+                            (Token, " "),
+                            (Token.ValEm, "= "),
+                            (Token.ValEm, repr(var.value)),
+                        ]
+                    )
+            except Exception:
+                lvals_toks.append(
+                    [
+                        (
+                            Token,
+                            "Exception trying to inspect frame. No more locals available.",
+                        ),
+                    ]
+                )
+
+        if frame_info._sd is None:
+            # fast fallback if file is too long
+            assert frame_info.filename is not None
+            level_tokens = [
+                (Token.FilenameEm, util_path.compress_user(frame_info.filename)),
+                (Token, " "),
+                (Token, call),
+                (Token, "\n"),
+            ]
+
+            _line_format = Parser(theme_name=self._theme_name).format2
+            assert isinstance(frame_info.code, types.CodeType)
+            first_line: int = frame_info.code.co_firstlineno
+            current_line: int = frame_info.lineno
+            raw_lines: list[str] = frame_info.raw_lines
+            index: int = current_line - first_line
+            assert frame_info.context is not None
+            if index >= frame_info.context:
+                start = max(index - frame_info.context, 0)
+                stop = index + frame_info.context
+                index = frame_info.context
+            else:
+                start = 0
+                stop = index + frame_info.context
+            raw_lines = raw_lines[start:stop]
+
+            # Jan 2025: may need _line_format(py3ompat.cast_unicode(s))
+            raw_color_err = []
+            for s in raw_lines:
+                formatted, is_error = _line_format(s, "str")
+                assert formatted is not None, "format2 should return str when out='str'"
+                raw_color_err.append((s, (formatted, is_error)))
+
+            tb_tokens = _simple_format_traceback_lines(
+                current_line,
+                index,
+                raw_color_err,
+                lvals_toks,
+                theme=theme_table[self._theme_name],
+            )
+            _tb_lines: str = theme_table[self._theme_name].format(tb_tokens)
+
+            return theme_table[self._theme_name].format(level_tokens + tb_tokens)
+        else:
+            result = theme_table[self._theme_name].format(
+                _tokens_filename(True, frame_info.filename, lineno=frame_info.lineno)
+            )
+            result += ", " if call else ""
+            result += f"{call}\n"
+            result += theme_table[self._theme_name].format(
+                _format_traceback_lines(
+                    frame_info.lines,
+                    theme_table[self._theme_name],
+                    self.has_colors,
+                    lvals_toks,
+                )
+            )
+            return result
 
-        if self.long_header:
+    def prepare_header(self, etype: str, long_version: bool = False) -> str:
+        width = min(75, get_terminal_size()[0])
+        if long_version:
             # Header with the exception type, python version, and date
-            pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable
+            pyver = "Python " + sys.version.split()[0] + ": " + sys.executable
             date = time.ctime(time.time())
-            
-            head = '%s%s%s\n%s%s%s\n%s' % (Colors.topline, '-'*75, ColorsNormal,
-                                           exc, ' '*(75-len(str(etype))-len(pyver)),
-                                           pyver, date.rjust(75) )
-            head += "\nA problem occured executing Python code.  Here is the sequence of function"\
-                    "\ncalls leading up to the error, with the most recent (innermost) call last."
+            theme = theme_table[self._theme_name]
+            head = theme.format(
+                [
+                    (Token.Topline, theme.symbols["top_line"] * width),
+                    (Token, "\n"),
+                    (Token.ExcName, etype),
+                    (Token, " " * (width - len(etype) - len(pyver))),
+                    (Token, pyver),
+                    (Token, "\n"),
+                    (Token, date.rjust(width)),
+                ]
+            )
+            head += (
+                "\nA problem occurred executing Python code.  Here is the sequence of function"
+                "\ncalls leading up to the error, with the most recent (innermost) call last."
+            )
         else:
             # Simplified header
-            head = '%s%s%s\n%s%s' % (Colors.topline, '-'*75, ColorsNormal,exc,
-                                     'Traceback (most recent call last)'.\
-                                                  rjust(75 - len(str(etype)) ) )
-        frames = []
-        # Flush cache before calling inspect.  This helps alleviate some of the
-        # problems with python 2.3's inspect.py.
-        ##self.check_cache()
-        # Drop topmost frames if requested
+            head = theme_table[self._theme_name].format(
+                [
+                    (Token.ExcName, etype),
+                    (
+                        Token,
+                        "Traceback (most recent call last)".rjust(width - len(etype)),
+                    ),
+                ]
+            )
+
+        return head
+
+    def format_exception(self, etype, evalue):
+        # Get (safely) a string form of the exception info
         try:
-            # Try the default getinnerframes and Alex's: Alex's fixes some
-            # problems, but it generates empty tracebacks for console errors
-            # (5 blanks lines) where none should be returned.
-            #records = inspect.getinnerframes(etb, context)[tb_offset:]
-            #print 'python records:', records # dbg
-            records = _fixed_getinnerframes(etb, context, tb_offset)
-            #print 'alex   records:', records # dbg
+            etype_str, evalue_str = map(str, (etype, evalue))
         except:
+            # User exception is improperly defined.
+            etype, evalue = str, sys.exc_info()[:2]
+            etype_str, evalue_str = map(str, (etype, evalue))
+
+        # PEP-678 notes
+        notes = getattr(evalue, "__notes__", [])
+        if not isinstance(notes, Sequence) or isinstance(notes, (str, bytes)):
+            notes = [_safe_string(notes, "__notes__", func=repr)]
+
+        for note in notes:
+            assert isinstance(note, str)
 
-            # FIXME: I've been getting many crash reports from python 2.3
-            # users, traceable to inspect.py.  If I can find a small test-case
-            # to reproduce this, I should either write a better workaround or
-            # file a bug report against inspect (if that's the real problem).
-            # So far, I haven't been able to find an isolated example to
-            # reproduce the problem.
-            inspect_error()
-            traceback.print_exc(file=self.ostream)
-            info('\nUnfortunately, your original traceback can not be constructed.\n')
-            return ''
-
-        # build some color string templates outside these nested loops
-        tpl_link       = '%s%%s%s' % (Colors.filenameEm,ColorsNormal)
-        tpl_call       = 'in %s%%s%s%%s%s' % (Colors.vName, Colors.valEm,
-                                              ColorsNormal)
-        tpl_call_fail  = 'in %s%%s%s(***failed resolving arguments***)%s' % \
-                         (Colors.vName, Colors.valEm, ColorsNormal)
-        tpl_local_var  = '%s%%s%s' % (Colors.vName, ColorsNormal)
-        tpl_global_var = '%sglobal%s %s%%s%s' % (Colors.em, ColorsNormal,
-                                                 Colors.vName, ColorsNormal)
-        tpl_name_val   = '%%s %s= %%s%s' % (Colors.valEm, ColorsNormal)
-        tpl_line       = '%s%%s%s %%s' % (Colors.lineno, ColorsNormal)
-        tpl_line_em    = '%s%%s%s %%s%s' % (Colors.linenoEm,Colors.line,
-                                            ColorsNormal)
-
-        # now, loop over all records printing context and info
-        abspath = os.path.abspath
-        for frame, file, lnum, func, lines, index in records:
-            #print '*** record:',file,lnum,func,lines,index  # dbg
+        str_notes: Sequence[str] = notes
+
+        # ... and format it
+        return [
+            theme_table[self._theme_name].format(
+                [(Token.ExcName, etype_str), (Token, ": "), (Token, evalue_str)]
+            ),
+            *(
+                theme_table[self._theme_name].format([(Token, note)])
+                for note in str_notes
+            ),
+        ]
+
+    def format_exception_as_a_whole(
+        self,
+        etype: type,
+        evalue: Optional[BaseException],
+        etb: Optional[TracebackType],
+        context: int,
+        tb_offset: Optional[int],
+    ) -> list[list[str]]:
+        """Formats the header, traceback and exception message for a single exception.
+
+        This may be called multiple times by Python 3 exception chaining
+        (PEP 3134).
+        """
+        # some locals
+        orig_etype = etype
+        try:
+            etype = etype.__name__  # type: ignore[assignment]
+        except AttributeError:
+            pass
+
+        tb_offset = self.tb_offset if tb_offset is None else tb_offset
+        assert isinstance(tb_offset, int)
+        head = self.prepare_header(str(etype), self.long_header)
+        records = self.get_records(etb, context, tb_offset) if etb else []
+
+        frames = []
+        skipped = 0
+        lastrecord = len(records) - 1
+        for i, record in enumerate(records):
+            if (
+                not isinstance(record._sd, stack_data.RepeatedFrames)
+                and self.skip_hidden
+            ):
+                if (
+                    record.frame.f_locals.get("__tracebackhide__", 0)
+                    and i != lastrecord
+                ):
+                    skipped += 1
+                    continue
+            if skipped:
+                frames.append(
+                    theme_table[self._theme_name].format(
+                        [
+                            (Token, "    "),
+                            (Token.ExcName, "[... skipping hidden %s frame]" % skipped),
+                            (Token, "\n"),
+                        ]
+                    )
+                )
+                skipped = 0
+            frames.append(self.format_record(record))
+        if skipped:
+            frames.append(
+                theme_table[self._theme_name].format(
+                    [
+                        (Token, "    "),
+                        (Token.ExcName, "[... skipping hidden %s frame]" % skipped),
+                        (Token, "\n"),
+                    ]
+                )
+            )
+
+        formatted_exception = self.format_exception(etype, evalue)
+        if records:
+            frame_info = records[-1]
+            ipinst = get_ipython()
+            if ipinst is not None:
+                ipinst.hooks.synchronize_with_editor(
+                    frame_info.filename, frame_info.lineno, 0
+                )
+
+        return [[head] + frames + formatted_exception]
+
+    def get_records(self, etb: TracebackType, context: int, tb_offset: int) -> Any:
+        assert etb is not None
+        context = context - 1
+        after = context // 2
+        before = context - after
+        if self.has_colors:
+            base_style = theme_table[self._theme_name].as_pygments_style()
+            style = stack_data.style_with_executing_node(base_style, self.tb_highlight)
+            formatter = Terminal256Formatter(style=style)
+        else:
+            formatter = None
+        options = stack_data.Options(
+            before=before,
+            after=after,
+            pygments_formatter=formatter,
+        )
+
+        # Let's estimate the amount of code we will have to parse/highlight.
+        cf: Optional[TracebackType] = etb
+        max_len = 0
+        tbs = []
+        while cf is not None:
             try:
-                file = file and abspath(file) or '?'
+                mod = inspect.getmodule(cf.tb_frame)
+                if mod is not None:
+                    mod_name = mod.__name__
+                    root_name, *_ = mod_name.split(".")
+                    if root_name == "IPython":
+                        cf = cf.tb_next
+                        continue
+                max_len = get_line_number_of_frame(cf.tb_frame)
+
             except OSError:
-                # if file is '<console>' or something not in the filesystem,
-                # the abspath call will throw an OSError.  Just ignore it and
-                # keep the original file string.
-                pass
-            link = tpl_link % file
-            try:
-                args, varargs, varkw, locals = inspect.getargvalues(frame)
-            except:
-                # This can happen due to a bug in python2.3.  We should be
-                # able to remove this try/except when 2.4 becomes a
-                # requirement.  Bug details at http://python.org/sf/1005466
-                inspect_error()
-                traceback.print_exc(file=self.ostream)
-                info("\nIPython's exception reporting continues...\n")
-                
-            if func == '?':
-                call = ''
-            else:
-                # Decide whether to include variable details or not
-                var_repr = self.include_vars and eqrepr or nullrepr
-                try:
-                    call = tpl_call % (func,inspect.formatargvalues(args,
-                                                varargs, varkw,
-                                                locals,formatvalue=var_repr))
-                except KeyError:
-                    # This happens in situations like errors inside generator
-                    # expressions, where local variables are listed in the
-                    # line, but can't be extracted from the frame.  I'm not
-                    # 100% sure this isn't actually a bug in inspect itself,
-                    # but since there's no info for us to compute with, the
-                    # best we can do is report the failure and move on.  Here
-                    # we must *not* call any traceback construction again,
-                    # because that would mess up use of %debug later on.  So we
-                    # simply report the failure and move on.  The only
-                    # limitation will be that this frame won't have locals
-                    # listed in the call signature.  Quite subtle problem...
-                    # I can't think of a good way to validate this in a unit
-                    # test, but running a script consisting of:
-                    #  dict( (k,v.strip()) for (k,v) in range(10) )
-                    # will illustrate the error, if this exception catch is
-                    # disabled.
-                    call = tpl_call_fail % func
-
-            # Initialize a list of names on the current line, which the
-            # tokenizer below will populate.
-            names = []
-
-            def tokeneater(token_type, token, start, end, line):
-                """Stateful tokeneater which builds dotted names.
-
-                The list of names it appends to (from the enclosing scope) can
-                contain repeated composite names.  This is unavoidable, since
-                there is no way to disambguate partial dotted structures until
-                the full list is known.  The caller is responsible for pruning
-                the final list of duplicates before using it."""
-                
-                # build composite names
-                if token == '.':
-                    try:
-                        names[-1] += '.'
-                        # store state so the next token is added for x.y.z names
-                        tokeneater.name_cont = True
-                        return
-                    except IndexError:
-                        pass
-                if token_type == tokenize.NAME and token not in keyword.kwlist:
-                    if tokeneater.name_cont:
-                        # Dotted names
-                        names[-1] += token
-                        tokeneater.name_cont = False
-                    else:
-                        # Regular new names.  We append everything, the caller
-                        # will be responsible for pruning the list later.  It's
-                        # very tricky to try to prune as we go, b/c composite
-                        # names can fool us.  The pruning at the end is easy
-                        # to do (or the caller can print a list with repeated
-                        # names if so desired.
-                        names.append(token)
-                elif token_type == tokenize.NEWLINE:
-                    raise IndexError
-            # we need to store a bit of state in the tokenizer to build
-            # dotted names
-            tokeneater.name_cont = False
-
-            def linereader(file=file, lnum=[lnum], getline=linecache.getline):
-                line = getline(file, lnum[0])
-                lnum[0] += 1
-                return line
-
-            # Build the list of names on this line of code where the exception
-            # occurred.
-            try:
-                # This builds the names list in-place by capturing it from the
-                # enclosing scope.
-                tokenize.tokenize(linereader, tokeneater)
-            except IndexError:
-                # signals exit of tokenizer
-                pass
-            except tokenize.TokenError,msg:
-                _m = ("An unexpected error occurred while tokenizing input\n"
-                      "The following traceback may be corrupted or invalid\n"
-                      "The error message is: %s\n" % msg)
-                error(_m)
-            
-            # prune names list of duplicates, but keep the right order
-            unique_names = uniq_stable(names)
-
-            # Start loop over vars
-            lvals = []
-            if self.include_vars:
-                for name_full in unique_names:
-                    name_base = name_full.split('.',1)[0]
-                    if name_base in frame.f_code.co_varnames:
-                        if locals.has_key(name_base):
-                            try:
-                                value = repr(eval(name_full,locals))
-                            except:
-                                value = undefined
-                        else:
-                            value = undefined
-                        name = tpl_local_var % name_full
-                    else:
-                        if frame.f_globals.has_key(name_base):
-                            try:
-                                value = repr(eval(name_full,frame.f_globals))
-                            except:
-                                value = undefined
-                        else:
-                            value = undefined
-                        name = tpl_global_var % name_full
-                    lvals.append(tpl_name_val % (name,value))
-            if lvals:
-                lvals = '%s%s' % (indent,em_normal.join(lvals))
+                max_len = 0
+            max_len = max(max_len, max_len)
+            tbs.append(cf)
+            cf = getattr(cf, "tb_next", None)
+
+        if max_len > FAST_THRESHOLD:
+            FIs: list[FrameInfo] = []
+            for tb in tbs:
+                frame = tb.tb_frame  # type: ignore[union-attr]
+                lineno = frame.f_lineno
+                code = frame.f_code
+                filename = code.co_filename
+                # TODO: Here we need to use before/after/
+                FIs.append(
+                    FrameInfo(
+                        "Raw frame", filename, lineno, frame, code, context=context
+                    )
+                )
+            return FIs
+        res = list(stack_data.FrameInfo.stack_data(etb, options=options))[tb_offset:]
+        res2 = [FrameInfo._from_stack_data_FrameInfo(r) for r in res]
+        return res2
+
+    def structured_traceback(
+        self,
+        etype: type,
+        evalue: Optional[BaseException],
+        etb: Optional[TracebackType] = None,
+        tb_offset: Optional[int] = None,
+        context: int = 5,
+    ) -> list[str]:
+        """Return a nice text document describing the traceback."""
+        formatted_exceptions: list[list[str]] = self.format_exception_as_a_whole(
+            etype, evalue, etb, context, tb_offset
+        )
+
+        termsize = min(75, get_terminal_size()[0])
+        theme = theme_table[self._theme_name]
+        head: str = theme.format(
+            [
+                (
+                    Token.Topline,
+                    theme.symbols["top_line"] * termsize,
+                ),
+            ]
+        )
+        structured_traceback_parts: list[str] = [head]
+        chained_exceptions_tb_offset = 0
+        lines_of_context = 3
+        exception = self.get_parts_of_chained_exception(evalue)
+        if exception:
+            assert evalue is not None
+            formatted_exceptions += self.prepare_chained_exception_message(
+                evalue.__cause__
+            )
+            etype, evalue, etb = exception
+        else:
+            evalue = None
+        chained_exc_ids = set()
+        while evalue:
+            formatted_exceptions += self.format_exception_as_a_whole(
+                etype, evalue, etb, lines_of_context, chained_exceptions_tb_offset
+            )
+            exception = self.get_parts_of_chained_exception(evalue)
+
+            if exception and id(exception[1]) not in chained_exc_ids:
+                chained_exc_ids.add(
+                    id(exception[1])
+                )  # trace exception to avoid infinite 'cause' loop
+                formatted_exceptions += self.prepare_chained_exception_message(
+                    evalue.__cause__
+                )
+                etype, evalue, etb = exception
             else:
-                lvals = ''
+                evalue = None
 
-            level = '%s %s\n' % (link,call)
+        # we want to see exceptions in a reversed order:
+        # the first exception should be on top
+        for fx in reversed(formatted_exceptions):
+            structured_traceback_parts += fx
 
-            if index is None:
-                frames.append(level)
-            else:
-                frames.append('%s%s' % (level,''.join(
-                    _format_traceback_lines(lnum,index,lines,Colors,lvals,
-                                            col_scheme))))
+        return structured_traceback_parts
 
-        # Get (safely) a string form of the exception info
-        try:
-            etype_str,evalue_str = map(str,(etype,evalue))
-        except:
-            # User exception is improperly defined.
-            etype,evalue = str,sys.exc_info()[:2]
-            etype_str,evalue_str = map(str,(etype,evalue))
-        # ... and format it
-        exception = ['%s%s%s: %s' % (Colors.excName, etype_str,
-                                     ColorsNormal, evalue_str)]
-        if type(evalue) is types.InstanceType:
-            try:
-                names = [w for w in dir(evalue) if isinstance(w, basestring)]
-            except:
-                # Every now and then, an object with funny inernals blows up
-                # when dir() is called on it.  We do the best we can to report
-                # the problem and continue
-                _m = '%sException reporting error (object with broken dir())%s:'
-                exception.append(_m % (Colors.excName,ColorsNormal))
-                etype_str,evalue_str = map(str,sys.exc_info()[:2])
-                exception.append('%s%s%s: %s' % (Colors.excName,etype_str,
-                                     ColorsNormal, evalue_str))
-                names = []
-            for name in names:
-                value = text_repr(getattr(evalue, name))
-                exception.append('\n%s%s = %s' % (indent, name, value))
-
-        # vds: >>
-        if records:
-             filepath, lnum = records[-1][1:3]
-             #print "file:", str(file), "linenb", str(lnum) # dbg
-             filepath = os.path.abspath(filepath)
-             ipinst = ipapi.get()
-             if ipinst is not None:
-                 ipinst.hooks.synchronize_with_editor(filepath, lnum, 0)
-        # vds: <<
-                
-        # return all our info assembled as a single string
-        # return '%s\n\n%s\n%s' % (head,'\n'.join(frames),''.join(exception[0]) )
-        return [head] + frames + [''.join(exception[0])]
-    
-    def debugger(self,force=False):
+    def debugger(self, force: bool = False) -> None:
         """Call up the pdb debugger if desired, always clean up the tb
         reference.
 
         Keywords:
 
           - force(False): by default, this routine checks the instance call_pdb
-          flag and does not actually invoke the debugger if the flag is false.
-          The 'force' option forces the debugger to activate even if the flag
-          is false.
+            flag and does not actually invoke the debugger if the flag is false.
+            The 'force' option forces the debugger to activate even if the flag
+            is false.
 
         If the call_pdb flag is set, the pdb interactive debugger is
         invoked. In all cases, the self.tb reference to the current traceback
@@ -986,26 +942,32 @@ def debugger(self,force=False):
 
         if force or self.call_pdb:
             if self.pdb is None:
-                self.pdb = debugger.Pdb(
-                    self.color_scheme_table.active_scheme_name)
+                self.pdb = self.debugger_cls()
             # the system displayhook may have changed, restore the original
             # for pdb
             display_trap = DisplayTrap(hook=sys.__displayhook__)
             with display_trap:
                 self.pdb.reset()
                 # Find the right frame so we don't pop up inside ipython itself
-                if hasattr(self,'tb') and self.tb is not None:
-                    etb = self.tb
+                if hasattr(self, "tb") and self.tb is not None:  # type: ignore[has-type]
+                    etb = self.tb  # type: ignore[has-type]
                 else:
                     etb = self.tb = sys.last_traceback
                 while self.tb is not None and self.tb.tb_next is not None:
+                    assert self.tb.tb_next is not None
                     self.tb = self.tb.tb_next
                 if etb and etb.tb_next:
                     etb = etb.tb_next
                 self.pdb.botframe = etb.tb_frame
-                self.pdb.interaction(self.tb.tb_frame, self.tb)
+                # last_value should be deprecated, but last-exc sometimme not set
+                # please check why later and remove the getattr.
+                exc = getattr(sys, "last_exc", sys.last_value)
+                if exc:
+                    self.pdb.interaction(None, exc)
+                else:
+                    self.pdb.interaction(None, etb)
 
-        if hasattr(self,'tb'):
+        if hasattr(self, "tb"):
             del self.tb
 
     def handler(self, info=None):
@@ -1013,8 +975,8 @@ def handler(self, info=None):
         self.tb = etb
         ostream = self.ostream
         ostream.flush()
-        ostream.write(self.text(etype, evalue, etb))
-        ostream.write('\n')
+        ostream.write(self.text(etype, evalue, etb))  # type:ignore[arg-type]
+        ostream.write("\n")
         ostream.flush()
 
     # Changed so an instance can just be called as VerboseTB_inst() and print
@@ -1028,9 +990,10 @@ def __call__(self, etype=None, evalue=None, etb=None):
         try:
             self.debugger()
         except KeyboardInterrupt:
-            print "\nKeyboardInterrupt"
+            print("\nKeyboardInterrupt")
+
 
-#----------------------------------------------------------------------------
+# ----------------------------------------------------------------------------
 class FormattedTB(VerboseTB, ListTB):
     """Subclass ListTB but allow calling with a traceback.
 
@@ -1041,103 +1004,150 @@ class FormattedTB(VerboseTB, ListTB):
     Allows a tb_offset to be specified. This is useful for situations where
     one needs to remove a number of topmost frames from the traceback (such as
     occurs with python programs that themselves execute other python code,
-    like Python shells).  """
-    
-    def __init__(self, mode='Plain', color_scheme='Linux', call_pdb=False,
-                 ostream=None, 
-                 tb_offset=0, long_header=False, include_vars=False,
-                 check_cache=None):
-
+    like Python shells)."""
+
+    mode: str
+
+    def __init__(
+        self,
+        mode="Plain",
+        # TODO: no default
+        theme_name="linux",
+        call_pdb=False,
+        ostream=None,
+        tb_offset=0,
+        long_header=False,
+        include_vars=False,
+        check_cache=None,
+        debugger_cls=None,
+    ):
         # NEVER change the order of this list. Put new modes at the end:
-        self.valid_modes = ['Plain','Context','Verbose']
+        self.valid_modes = ["Plain", "Context", "Verbose", "Minimal", "Docs"]
         self.verbose_modes = self.valid_modes[1:3]
 
-        VerboseTB.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
-                           ostream=ostream, tb_offset=tb_offset,
-                           long_header=long_header, include_vars=include_vars,
-                           check_cache=check_cache)
+        VerboseTB.__init__(
+            self,
+            theme_name=theme_name,
+            call_pdb=call_pdb,
+            ostream=ostream,
+            tb_offset=tb_offset,
+            long_header=long_header,
+            include_vars=include_vars,
+            check_cache=check_cache,
+            debugger_cls=debugger_cls,
+        )
 
         # Different types of tracebacks are joined with different separators to
         # form a single string.  They are taken from this dict
-        self._join_chars = dict(Plain='', Context='\n', Verbose='\n')
+        self._join_chars = dict(
+            Plain="", Context="\n", Verbose="\n", Minimal="", Docs=""
+        )
         # set_mode also sets the tb_join_char attribute
         self.set_mode(mode)
-        
-    def _extract_tb(self,tb):
-        if tb:
-            return traceback.extract_tb(tb)
-        else:
-            return None
 
-    def structured_traceback(self, etype, value, tb, tb_offset=None, context=5):
+    def structured_traceback(
+        self,
+        etype: type,
+        evalue: BaseException | None,
+        etb: TracebackType | None = None,
+        tb_offset: int | None = None,
+        context: int = 5,
+    ) -> list[str]:
         tb_offset = self.tb_offset if tb_offset is None else tb_offset
         mode = self.mode
         if mode in self.verbose_modes:
             # Verbose modes need a full traceback
             return VerboseTB.structured_traceback(
-                self, etype, value, tb, tb_offset, context
+                self, etype, evalue, etb, tb_offset, context
             )
+        elif mode == "Docs":
+            # return DocTB
+            return DocTB(
+                theme_name=self._theme_name,
+                call_pdb=self.call_pdb,
+                ostream=self.ostream,
+                tb_offset=tb_offset,
+                long_header=self.long_header,
+                include_vars=self.include_vars,
+                check_cache=self.check_cache,
+                debugger_cls=self.debugger_cls,
+            ).structured_traceback(
+                etype, evalue, etb, tb_offset, 1
+            )  # type: ignore[arg-type]
+
+        elif mode == "Minimal":
+            return ListTB.get_exception_only(self, etype, evalue)
         else:
             # We must check the source cache because otherwise we can print
             # out-of-date source code.
             self.check_cache()
             # Now we can extract and format the exception
-            elist = self._extract_tb(tb)
             return ListTB.structured_traceback(
-                self, etype, value, elist, tb_offset, context
+                self, etype, evalue, etb, tb_offset, context
             )
 
-    def stb2text(self, stb):
+    def stb2text(self, stb: list[str]) -> str:
         """Convert a structured traceback (a list) to a string."""
         return self.tb_join_char.join(stb)
-        
 
-    def set_mode(self,mode=None):
+    def set_mode(self, mode: Optional[str] = None) -> None:
         """Switch to the desired mode.
 
         If mode is not specified, cycles through the available modes."""
 
         if not mode:
-            new_idx = ( self.valid_modes.index(self.mode) + 1 ) % \
-                      len(self.valid_modes)
+            new_idx = (self.valid_modes.index(self.mode) + 1) % len(self.valid_modes)
             self.mode = self.valid_modes[new_idx]
         elif mode not in self.valid_modes:
-            raise ValueError, 'Unrecognized mode in FormattedTB: <'+mode+'>\n'\
-                  'Valid modes: '+str(self.valid_modes)
+            raise ValueError(
+                "Unrecognized mode in FormattedTB: <" + mode + ">\n"
+                "Valid modes: " + str(self.valid_modes)
+            )
         else:
+            assert isinstance(mode, str)
             self.mode = mode
         # include variable details only in 'Verbose' mode
-        self.include_vars = (self.mode == self.valid_modes[2])
+        self.include_vars = self.mode == self.valid_modes[2]
         # Set the join character for generating text tracebacks
         self.tb_join_char = self._join_chars[self.mode]
 
-    # some convenient shorcuts
-    def plain(self):
+    # some convenient shortcuts
+    def plain(self) -> None:
         self.set_mode(self.valid_modes[0])
 
-    def context(self):
+    def context(self) -> None:
         self.set_mode(self.valid_modes[1])
 
-    def verbose(self):
+    def verbose(self) -> None:
         self.set_mode(self.valid_modes[2])
 
-#----------------------------------------------------------------------------
+    def minimal(self) -> None:
+        self.set_mode(self.valid_modes[3])
+
+
+# ----------------------------------------------------------------------------
 class AutoFormattedTB(FormattedTB):
     """A traceback printer which can be called on the fly.
 
     It will find out about exceptions by itself.
 
-    A brief example:
-    
-    AutoTB = AutoFormattedTB(mode = 'Verbose',color_scheme='Linux')
-    try:
-      ...
-    except:
-      AutoTB()  # or AutoTB(out=logfile) where logfile is an open file object
+    A brief example::
+
+        AutoTB = AutoFormattedTB(mode = 'Verbose', theme_name='linux')
+        try:
+          ...
+        except:
+          AutoTB()  # or AutoTB(out=logfile) where logfile is an open file object
     """
-    
-    def __call__(self,etype=None,evalue=None,etb=None,
-                 out=None,tb_offset=None):
+
+    def __call__(
+        self,
+        etype: type | None = None,
+        evalue: BaseException | None = None,
+        etb: TracebackType | None = None,
+        out: Any = None,
+        tb_offset: int | None = None,
+    ) -> None:
         """Print out a formatted exception traceback.
 
         Optional arguments:
@@ -1145,99 +1155,105 @@ def __call__(self,etype=None,evalue=None,etb=None,
 
           - tb_offset: the number of frames to skip over in the stack, on a
           per-call basis (this overrides temporarily the instance's tb_offset
-          given at initialization time.  """
+          given at initialization time."""
 
-        
         if out is None:
             out = self.ostream
         out.flush()
-        out.write(self.text(etype, evalue, etb, tb_offset))
-        out.write('\n')
+        out.write(self.text(etype, evalue, etb, tb_offset))  # type:ignore[arg-type]
+        out.write("\n")
         out.flush()
         # FIXME: we should remove the auto pdb behavior from here and leave
         # that to the clients.
         try:
             self.debugger()
         except KeyboardInterrupt:
-            print "\nKeyboardInterrupt"
-
-    def structured_traceback(self, etype=None, value=None, tb=None,
-                             tb_offset=None, context=5):
+            print("\nKeyboardInterrupt")
+
+    def structured_traceback(
+        self,
+        etype: type,
+        evalue: Optional[BaseException],
+        etb: Optional[TracebackType] = None,
+        tb_offset: Optional[int] = None,
+        context: int = 5,
+    ) -> list[str]:
+        # tb: TracebackType or tupleof tb types ?
         if etype is None:
-            etype,value,tb = sys.exc_info()
-        self.tb = tb
+            etype, evalue, etb = sys.exc_info()
+        if isinstance(etb, tuple):
+            # tb is a tuple if this is a chained exception.
+            self.tb = etb[0]
+        else:
+            self.tb = etb
         return FormattedTB.structured_traceback(
-            self, etype, value, tb, tb_offset, context)
+            self, etype, evalue, etb, tb_offset, context
+        )
+
+
+# ---------------------------------------------------------------------------
 
-#---------------------------------------------------------------------------
 
 # A simple class to preserve Nathan's original functionality.
 class ColorTB(FormattedTB):
-    """Shorthand to initialize a FormattedTB in Linux colors mode."""
-    def __init__(self,color_scheme='Linux',call_pdb=0):
-        FormattedTB.__init__(self,color_scheme=color_scheme,
-                             call_pdb=call_pdb)
+    """Deprecated since IPython 9.0."""
+
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            "Deprecated since IPython 9.0 use FormattedTB directly ColorTB is just an alias",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        super().__init__(*args, **kwargs)
 
 
 class SyntaxTB(ListTB):
     """Extension which holds some state: the last exception value"""
 
-    def __init__(self,color_scheme = 'NoColor'):
-        ListTB.__init__(self,color_scheme)
+    last_syntax_error: BaseException | None
+
+    def __init__(self, *, theme_name):
+        super().__init__(theme_name=theme_name)
         self.last_syntax_error = None
 
     def __call__(self, etype, value, elist):
         self.last_syntax_error = value
-        ListTB.__call__(self,etype,value,elist)
 
-    def clear_err_state(self):
+        super().__call__(etype, value, elist)
+
+    def structured_traceback(
+        self,
+        etype: type,
+        evalue: BaseException | None,
+        etb: TracebackType | None = None,
+        tb_offset: int | None = None,
+        context: int = 5,
+    ) -> list[str]:
+        value = evalue
+        # If the source file has been edited, the line in the syntax error can
+        # be wrong (retrieved from an outdated cache). This replaces it with
+        # the current value.
+        if (
+            isinstance(value, SyntaxError)
+            and isinstance(value.filename, str)
+            and isinstance(value.lineno, int)
+        ):
+            linecache.checkcache(value.filename)
+            newtext = linecache.getline(value.filename, value.lineno)
+            if newtext:
+                value.text = newtext
+        self.last_syntax_error = value
+        return super(SyntaxTB, self).structured_traceback(
+            etype, value, etb, tb_offset=tb_offset, context=context
+        )
+
+    def clear_err_state(self) -> Any | None:
         """Return the current error state and clear it"""
         e = self.last_syntax_error
         self.last_syntax_error = None
         return e
 
-    def stb2text(self, stb):
+    def stb2text(self, stb: list[str]) -> str:
         """Convert a structured traceback (a list) to a string."""
-        return ''.join(stb)
-
-
-#----------------------------------------------------------------------------
-# module testing (minimal)
-if __name__ == "__main__":
-    def spam(c, (d, e)):
-        x = c + d
-        y = c * d
-        foo(x, y)
-
-    def foo(a, b, bar=1):
-        eggs(a, b + bar)
-
-    def eggs(f, g, z=globals()):
-        h = f + g
-        i = f - g
-        return h / i
-
-    print ''
-    print '*** Before ***'
-    try:
-        print spam(1, (2, 3))
-    except:
-        traceback.print_exc()
-    print ''
-    
-    handler = ColorTB()
-    print '*** ColorTB ***'
-    try:
-        print spam(1, (2, 3))
-    except:
-        apply(handler, sys.exc_info() )
-    print ''
-    
-    handler = VerboseTB()
-    print '*** VerboseTB ***'
-    try:
-        print spam(1, (2, 3))
-    except:
-        apply(handler, sys.exc_info() )
-    print ''
-    
+        return "".join(stb)
diff --git a/IPython/core/usage.py b/IPython/core/usage.py
index 01eff9e3a42..53219bceb25 100644
--- a/IPython/core/usage.py
+++ b/IPython/core/usage.py
@@ -2,7 +2,7 @@
 """Usage information for the main IPython applications.
 """
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #  Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
@@ -13,72 +13,99 @@
 from IPython.core import release
 
 cl_usage = """\
-ipython [options] [files]
+=========
+ IPython
+=========
 
-IPython: an enhanced interactive Python shell.
+Tools for Interactive Computing in Python
+=========================================
 
     A Python shell with automatic history (input and output), dynamic object
     introspection, easier configuration, command completion, access to the
     system shell and more.  IPython can also be embedded in running programs.
 
-    If invoked with no options, it executes all the files listed in sequence
-    and exits, use -i to enter interactive mode after running the files.  Files
-    ending in .py will be treated as normal Python, but files ending in .ipy
-    can contain special IPython syntax (magic commands, shell expansions, etc.)
 
-    Please note that some of the configuration options are not available at the
-    command line, simply because they are not practical here. Look into your
-    ipython_config.py configuration file for details on those.
+Usage
+
+    ipython [subcommand] [options] [-c cmd | -m mod | file] [--] [arg] ...
+
+    If invoked with no options, it executes the file and exits, passing the
+    remaining arguments to the script, just as if you had specified the same
+    command with python. You may need to specify `--` before args to be passed
+    to the script, to prevent IPython from attempting to parse them. If you
+    specify the option `-i` before the filename, it will enter an interactive
+    IPython session after running the script, rather than exiting. Files ending
+    in .py will be treated as normal Python, but files ending in .ipy can
+    contain special IPython syntax (magic commands, shell expansions, etc.).
+
+    Almost all configuration in IPython is available via the command-line. Do
+    `ipython --help-all` to see all available options.  For persistent
+    configuration, look into your `ipython_config.py` configuration file for
+    details.
+
+    This file is typically installed in the `IPYTHONDIR` directory, and there
+    is a separate configuration directory for each profile. The default profile
+    directory will be located in $IPYTHONDIR/profile_default. IPYTHONDIR
+    defaults to to `$HOME/.ipython`.  For Windows users, $HOME resolves to
+    C:\\Users\\YourUserName in most instances.
+
+    To initialize a profile with the default configuration file, do::
 
-    This file is typically installed in the IPYTHON_DIR directory. For Linux
-    users, this will be $HOME/.config/ipython, and for other users it will be
-    $HOME/.ipython.  For Windows users, $HOME resolves to C:\\Documents and
-    Settings\\YourUserName in most instances.
+      $> ipython profile create
 
-    In IPython's documentation, we will refer to this directory as IPYTHON_DIR,
-    you can change its default location by setting any path you want in this
-    environment variable.
+    and start editing `IPYTHONDIR/profile_default/ipython_config.py`
+
+    In IPython's documentation, we will refer to this directory as
+    `IPYTHONDIR`, you can change its default location by creating an
+    environment variable with this name and setting it to the desired path.
 
     For more information, see the manual available in HTML and PDF in your
-    installation, or online at http://ipython.scipy.org.
+    installation, or online at https://ipython.org/documentation.html.
 """
 
 interactive_usage = """
 IPython -- An enhanced Interactive Python
 =========================================
 
-IPython offers a combination of convenient shell features, special commands
-and a history mechanism for both input (command history) and output (results
-caching, similar to Mathematica). It is intended to be a fully compatible
-replacement for the standard Python interpreter, while offering vastly
-improved functionality and flexibility.
+IPython offers a fully compatible replacement for the standard Python
+interpreter, with convenient shell features, special commands, command
+history mechanism and output results caching.
 
-At your system command line, type 'ipython -help' to see the command line
+At your system command line, type 'ipython -h' to see the command line
 options available. This document only describes interactive features.
 
-Warning: IPython relies on the existence of a global variable called __IP which
-controls the shell itself. If you redefine __IP to anything, bizarre behavior
-will quickly occur.
+GETTING HELP
+------------
+
+Within IPython you have various way to access help:
+
+  ?         -> Introduction and overview of IPython's features (this screen).
+  object?   -> Details about 'object'.
+  object??  -> More detailed, verbose information about 'object'.
+  %quickref -> Quick reference of all IPython specific syntax and magics.
+  help      -> Access Python's own help system.
+
+If you are in terminal IPython you can quit this screen by pressing `q`.
+
 
 MAIN FEATURES
+-------------
 
-* Access to the standard Python help. As of Python 2.1, a help system is
-  available with access to object docstrings and the Python manuals. Simply
-  type 'help' (no quotes) to access it.
+* Access to the standard Python help with object docstrings and the Python
+  manuals. Simply type 'help' (no quotes) to invoke it.
 
 * Magic commands: type %magic for information on the magic subsystem.
 
-* System command aliases, via the %alias command or the ipythonrc config file.
+* System command aliases, via the %alias command or the configuration file(s).
 
 * 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.
+  Typing ?word or word? prints detailed information about an object. Certain
+  long strings (code, etc.) get snipped in the center for brevity.
 
   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, printed otherwise.
+  snipping long strings. Strings that are longer than the screen are printed
+  through the less pager.
 
   The ?/?? system gives access to the full source code for any object (if
   available), shows function prototypes and other useful information.
@@ -86,36 +113,28 @@
   If you just want to see an object's docstring, type '%pdoc object' (without
   quotes, and without % if you have automagic on).
 
-  Both %pdoc and ?/?? give you access to documentation even on things which are
-  not explicitely defined. Try for example typing {}.get? or after import os,
-  type os.path.abspath??. The magic functions %pdef, %source and %file operate
-  similarly.
-
-* Completion in the local namespace, by typing TAB at the prompt.
+* Tab completion in the local namespace:
 
   At any time, hitting tab will complete any available python commands or
   variable names, and show you a list of the possible completions if there's
   no unambiguous one. It will also complete filenames in the current directory.
 
-  This feature requires the readline and rlcomplete modules, so it won't work
-  if your Python lacks readline support (such as under Windows).
-
-* Search previous command history in two ways (also requires readline):
+* Search previous command history in multiple ways:
 
-  - Start typing, and then use Ctrl-p (previous,up) and Ctrl-n (next,down) to
-  search through only the history items that match what you've typed so
-  far. If you use Ctrl-p/Ctrl-n at a blank prompt, they just behave like
-  normal arrow keys.
+  - Start typing, and then use arrow keys up/down or (Ctrl-p/Ctrl-n) to search
+    through the history items that match what you've typed so far.
 
   - Hit Ctrl-r: opens a search prompt. Begin typing and the system searches
-  your history for lines that match what you've typed so far, completing as
-  much as it can.
+    your history for lines that match what you've typed so far, completing as
+    much as it can.
+
+  - %hist: search history by index.
 
-* Persistent command history across sessions (readline required).
+* Persistent command history across sessions.
 
 * Logging of input with the ability to save and restore a working session.
-  
-* System escape with !. Typing !ls will run 'ls' in the current directory.
+
+* System shell with !. Typing !ls will run 'ls' in the current directory.
 
 * The reload command does a 'deep' reload of a module: changes made to the
   module since you imported will actually be available without having to exit.
@@ -174,53 +193,73 @@
 
 * Auto-parentheses and auto-quotes (adapted from Nathan Gray's LazyPython)
 
-    1. Auto-parentheses
-        Callable objects (i.e. functions, methods, etc) can be invoked like
-        this (notice the commas between the arguments):
-            >>> callable_ob arg1, arg2, arg3
-        and the input will be translated to this:
-            --> callable_ob(arg1, arg2, arg3)
-        You can force auto-parentheses by using '/' as the first character
-        of a line.  For example:
-            >>> /globals             # becomes 'globals()'
-        Note that the '/' MUST be the first character on the line!  This
-        won't work:
-            >>> print /globals    # syntax error
-            
-        In most cases the automatic algorithm should work, so you should
-        rarely need to explicitly invoke /. One notable exception is if you
-        are trying to call a function with a list of tuples as arguments (the
-        parenthesis will confuse IPython):
-            In [1]: zip (1,2,3),(4,5,6)  # won't work
-        but this will work:
-            In [2]: /zip (1,2,3),(4,5,6)
-            ------> zip ((1,2,3),(4,5,6))
-            Out[2]= [(1, 4), (2, 5), (3, 6)]        
-
-        IPython tells you that it has altered your command line by
-        displaying the new command line preceded by -->.  e.g.:
-            In [18]: callable list
-            -------> callable (list) 
-
-    2. Auto-Quoting
-        You can force auto-quoting of a function's arguments by using ',' as
-        the first character of a line.  For example:
-            >>> ,my_function /home/me   # becomes my_function("/home/me")
-
-        If you use ';' instead, the whole argument is quoted as a single
-        string (while ',' splits on whitespace):
-            >>> ,my_function a b c   # becomes my_function("a","b","c")
-            >>> ;my_function a b c   # becomes my_function("a b c")
-
-        Note that the ',' MUST be the first character on the line!  This
-        won't work:
-            >>> x = ,my_function /home/me    # syntax error
+  1. Auto-parentheses
+        
+     Callable objects (i.e. functions, methods, etc) can be invoked like
+     this (notice the commas between the arguments)::
+       
+         In [1]: callable_ob arg1, arg2, arg3
+       
+     and the input will be translated to this::
+       
+         callable_ob(arg1, arg2, arg3)
+       
+     This feature is off by default (in rare cases it can produce
+     undesirable side-effects), but you can activate it at the command-line
+     by starting IPython with `--autocall 1`, set it permanently in your
+     configuration file, or turn on at runtime with `%autocall 1`.
+
+     You can force auto-parentheses by using '/' as the first character
+     of a line.  For example::
+       
+          In [1]: /globals             # becomes 'globals()'
+       
+     Note that the '/' MUST be the first character on the line!  This
+     won't work::
+       
+          In [2]: print /globals    # syntax error
+
+     In most cases the automatic algorithm should work, so you should
+     rarely need to explicitly invoke /. One notable exception is if you
+     are trying to call a function with a list of tuples as arguments (the
+     parenthesis will confuse IPython)::
+       
+          In [1]: zip (1,2,3),(4,5,6)  # won't work
+       
+     but this will work::
+       
+          In [2]: /zip (1,2,3),(4,5,6)
+          ------> zip ((1,2,3),(4,5,6))
+          Out[2]= [(1, 4), (2, 5), (3, 6)]
+
+     IPython tells you that it has altered your command line by
+     displaying the new command line preceded by -->.  e.g.::
+       
+          In [18]: callable list
+          -------> callable (list)
+
+  2. Auto-Quoting
+    
+     You can force auto-quoting of a function's arguments by using ',' as
+     the first character of a line.  For example::
+       
+          In [1]: ,my_function /home/me   # becomes my_function("/home/me")
+
+     If you use ';' instead, the whole argument is quoted as a single
+     string (while ',' splits on whitespace)::
+       
+          In [2]: ,my_function a b c   # becomes my_function("a","b","c")
+          In [3]: ;my_function a b c   # becomes my_function("a b c")
+
+     Note that the ',' MUST be the first character on the line!  This
+     won't work::
+       
+          In [4]: x = ,my_function /home/me    # syntax error
 """
 
 interactive_usage_min =  """\
 An enhanced console for Python.
 Some of its features are:
-- Readline support if the readline library is present.
 - Tab completion in the local namespace.
 - Logging of input, see command-line options.
 - System shell escape via ! , eg !ls.
@@ -238,9 +277,10 @@
 ?foo.*abc*       : List names in 'foo' containing 'abc' in them.
 %magic           : Information about IPython's 'magic' % functions.
 
-Magic functions are prefixed by %, and typically take their arguments without
-parentheses, quotes or even commas for convenience.
- 
+Magic functions are prefixed by % or %%, and typically take their arguments
+without parentheses, quotes or even commas for convenience.  Line magics take a
+single % and cell magics are prefixed with two %%.
+
 Example magic function calls:
 
 %alias d ls -F   : 'd' is now an alias for 'ls -F'
@@ -248,29 +288,40 @@
 alist = %alias   : Get list of aliases to 'alist'
 cd /usr/share    : Obvious. cd -<tab> to choose from visited dirs.
 %cd??            : See help AND source for magic %cd
+%timeit x=10     : time the 'x=10' statement with high precision.
+%%timeit x=2**100
+x**100           : time 'x**100' with a setup of 'x=2**100'; setup code is not
+                   counted.  This is an example of a cell magic.
 
 System commands:
-    
+
 !cp a.txt b/     : System command escape, calls os.system()
 cp a.txt b/      : after %rehashx, most system commands work without !
 cp ${f}.txt $bar : Variable expansion in magics and system commands
-files = !ls /usr : Capture sytem command output
+files = !ls /usr : Capture system command output
 files.s, files.l, files.n: "a b c", ['a','b','c'], 'a\nb\nc'
 
 History:
 
 _i, _ii, _iii    : Previous, next previous, next next previous input
 _i4, _ih[2:5]    : Input history line 4, lines 2-4
-exec _i81        : Execute input history line #81 again
-%rep 81          : Edit input history line #81        
+exec(_i81)       : Execute input history line #81 again
+%rep 81          : Edit input history line #81
 _, __, ___       : previous, next previous, next next previous output
 _dh              : Directory history
 _oh              : Output history
-%hist            : Command history. '%hist -g foo' search history for 'foo'
+%hist            : Command history of current session.
+%hist -g foo     : Search command history of (almost) all sessions for 'foo'.
+%hist -g         : Command history of (almost) all sessions.
+%hist 1/2-8      : Command history containing lines 2-8 of session 1.
+%hist 1/ ~2/     : Command history of session 1 and 2 sessions before current.
+%hist ~8/1-~6/5  : Command history from line 1 of 8 sessions ago to
+                   line 5 of 6 sessions ago.
+%edit 0/         : Open editor to execute code with history of current session.
 
 Autocall:
 
-f 1,2            : f(1,2)
+f 1,2            : f(1,2)  # Off by default, enable with %autocall magic.
 /f 1,2           : f(1,2) (forced autoparen)
 ,f 1 2           : f("1","2")
 ;f 1 2           : f("1 2")
@@ -282,228 +333,9 @@
 
 """
 
-gui_reference = """\
-===============================
- The graphical IPython console
-===============================
-
-This console is designed to emulate the look, feel and workflow of a terminal
-environment, while adding a number of enhancements that are simply not possible
-in a real terminal, such as inline syntax highlighting, true multiline editing,
-inline graphics and much more.
-
-This quick reference document contains the basic information you'll need to
-know to make the most efficient use of it.  For the various command line
-options available at startup, type ``--help`` at the command line.
-
-
-Multiline editing
-=================
-
-The graphical console is capable of true multiline editing, but it also tries
-to behave intuitively like a terminal when possible.  If you are used to
-IPyhton's old terminal behavior, you should find the transition painless, and
-once you learn a few basic keybindings it will be a much more efficient
-environment.
-
-For single expressions or indented blocks, the console behaves almost like the
-terminal IPython: single expressions are immediately evaluated, and indented
-blocks are evaluated once a single blank line is entered::
-
-    In [1]: print "Hello IPython!"  # Enter was pressed at the end of the line
-    Hello IPython!
-    
-    In [2]: for i in range(10):
-       ...: 	print i,
-       ...: 	
-    0 1 2 3 4 5 6 7 8 9
-
-If you want to enter more than one expression in a single input block
-(something not possible in the terminal), you can use ``Control-Enter`` at the
-end of your first line instead of ``Enter``.  At that point the console goes
-into 'cell mode' and even if your inputs are not indented, it will continue
-accepting arbitrarily many lines until either you enter an extra blank line or
-you hit ``Shift-Enter`` (the key binding that forces execution).  When a
-multiline cell is entered, IPython analyzes it and executes its code producing
-an ``Out[n]`` prompt only for the last expression in it, while the rest of the
-cell is executed as if it was a script.  An example should clarify this::
-
-    In [3]: x=1  # Hit C-Enter here
-       ...: y=2  # from now on, regular Enter is sufficient
-       ...: z=3
-       ...: x**2  # This does *not* produce an Out[] value
-       ...: x+y+z  # Only the last expression does
-       ...: 
-    Out[3]: 6
-
-The behavior where an extra blank line forces execution is only active if you
-are actually typing at the keyboard each line, and is meant to make it mimic
-the IPython terminal behavior.  If you paste a long chunk of input (for example
-a long script copied form an editor or web browser), it can contain arbitrarily
-many intermediate blank lines and they won't cause any problems.  As always,
-you can then make it execute by appending a blank line *at the end* or hitting
-``Shift-Enter`` anywhere within the cell.
-
-With the up arrow key, you can retrieve previous blocks of input that contain
-multiple lines.  You can move inside of a multiline cell like you would in any
-text editor.  When you want it executed, the simplest thing to do is to hit the
-force execution key, ``Shift-Enter`` (though you can also navigate to the end
-and append a blank line by using ``Enter`` twice).
-
-If you've edited a multiline cell and accidentally navigate out of it with the
-up or down arrow keys, IPython will clear the cell and replace it with the
-contents of the one above or below that you navigated to.  If this was an
-accident and you want to retrieve the cell you were editing, use the Undo
-keybinding, ``Control-z``.
-
-
-Key bindings
-============
-
-The IPython console supports most of the basic Emacs line-oriented keybindings,
-in addition to some of its own.
-
-The keybinding prefixes mean:
-
-- ``C``: Control
-- ``S``: Shift
-- ``M``: Meta (typically the Alt key)
-
-The keybindings themselves are:
-
-- ``Enter``: insert new line (may cause execution, see above).
-- ``C-Enter``: force new line, *never* causes execution.
-- ``S-Enter``: *force* execution regardless of where cursor is, no newline added.
-- ``C-c``: copy highlighted text to clipboard (prompts are automatically stripped).
-- ``C-S-c``: copy highlighted text to clipboard (prompts are not stripped).
-- ``C-v``: paste text from clipboard.
-- ``C-z``: undo (retrieves lost text if you move out of a cell with the arrows).
-- ``C-S-z``: redo.
-- ``C-o``: move to 'other' area, between pager and terminal.
-- ``C-l``: clear terminal.
-- ``C-a``: go to beginning of line.
-- ``C-e``: go to end of line.
-- ``C-k``: kill from cursor to the end of the line.
-- ``C-y``: yank (paste)
-- ``C-p``: previous line (like up arrow)
-- ``C-n``: next line (like down arrow)
-- ``C-f``: forward (like right arrow)
-- ``C-b``: back (like left arrow)
-- ``C-d``: delete next character.
-- ``M-<``: move to the beginning of the input region.
-- ``M->``: move to the end of the input region.
-- ``M-d``: delete next word.
-- ``M-Backspace``: delete previous word.
-- ``C-.``: force a kernel restart (a confirmation dialog appears).
-- ``C-+``: increase font size.
-- ``C--``: decrease font size.
-
-The IPython pager
-=================
-
-IPython will show long blocks of text from many sources using a builtin pager.
-You can control where this pager appears with the ``--paging`` command-line
-flag:
-
-- ``inside`` [default]: the pager is overlaid on top of the main terminal. You
-  must quit the pager to get back to the terminal (similar to how a pager such
-  as ``less`` or ``more`` works).
-
-- ``vsplit``: the console is made double-tall, and the pager appears on the
-  bottom area when needed.  You can view its contents while using the terminal.
-
-- ``hsplit``: the console is made double-wide, and the pager appears on the
-  right area when needed.  You can view its contents while using the terminal.
-
-- ``none``: the console never pages output.
-
-If you use the vertical or horizontal paging modes, you can navigate between
-terminal and pager as follows:
-
-- Tab key: goes from pager to terminal (but not the other way around).
-- Control-o: goes from one to another always.
-- Mouse: click on either.
-
-In all cases, the ``q`` or ``Escape`` keys quit the pager (when used with the
-focus on the pager area).
-
-Running subprocesses
-====================
-
-The graphical IPython console uses the ``pexpect`` module to run subprocesses
-when you type ``!command``.  This has a number of advantages (true asynchronous
-output from subprocesses as well as very robust termination of rogue
-subprocesses with ``Control-C``), as well as some limitations.  The main
-limitation is that you can *not* interact back with the subprocess, so anything
-that invokes a pager or expects you to type input into it will block and hang
-(you can kill it with ``Control-C``).
-
-We have provided as magics ``%less`` to page files (aliased to ``%more``),
-``%clear`` to clear the terminal, and ``%man`` on Linux/OSX.  These cover the
-most common commands you'd want to call in your subshell and that would cause
-problems if invoked via ``!cmd``, but you need to be aware of this limitation.
-
-Display
-=======
-
-The IPython console can now display objects in a variety of formats, including
-HTML, PNG and SVG. This is accomplished using the display functions in
-``IPython.core.display``::
-
-    In [4]: from IPython.core.display import display, display_html
-
-    In [5]: from IPython.core.display import display_png, display_svg
-
-Python objects can simply be passed to these functions and the appropriate
-representations will be displayed in the console as long as the objects know
-how to compute those representations. The easiest way of teaching objects how
-to format themselves in various representations is to define special methods
-such as: ``__html``, ``__svg__`` and ``__png__``. IPython's display formatters
-can also be given custom formatter functions for various types::
-
-    In [6]: ip = get_ipython()
-
-    In [7]: html_formatter = ip.display_formatter.formatters['text/html']
-
-    In [8]: html_formatter.for_type(Foo, foo_to_html)
-
-For further details, see ``IPython.core.formatters``.
-
-Inline matplotlib graphics
-==========================
-
-The IPython console is capable of displaying matplotlib figures inline, in SVG
-format.  If started with the ``--pylab inline`` flag, then all figures are
-rendered inline automatically.  If started with ``--pylab`` or ``--pylab <your
-backend>``, then a GUI backend will be used, but IPython's ``display()`` and
-``getfigs()`` functions can be used to view plots inline::
-
-    In [9]: display(*getfigs())    # display all figures inline
-
-    In[10]: display(*getfigs(1,2)) # display figures 1 and 2 inline
-"""
-
-
-quick_guide = """\
-?         -> Introduction and overview of IPython's features.
-%quickref -> Quick reference.
-help      -> Python's own help system.
-object?   -> Details about 'object', use 'object??' for extra details.
-"""
-
-gui_note = """\
-%guiref   -> A brief reference about the graphical user interface.
-"""
-
-default_banner_parts = [
-    'Python %s\n' % (sys.version.split('\n')[0],),
-    'Type "copyright", "credits" or "license" for more information.\n\n',
-    'IPython %s -- An enhanced Interactive Python.\n' % (release.version,),
-    quick_guide
+default_banner_parts = ["Python %s\n"%sys.version.split("\n")[0],
+    "Type 'copyright', 'credits' or 'license' for more information\n" ,
+    "IPython {version} -- An enhanced Interactive Python. Type '?' for help.\n".format(version=release.version),
 ]
 
-default_gui_banner_parts = default_banner_parts + [gui_note]
-
 default_banner = ''.join(default_banner_parts)
-
-default_gui_banner = ''.join(default_gui_banner_parts)
diff --git a/IPython/deathrow/Gnuplot2.py b/IPython/deathrow/Gnuplot2.py
deleted file mode 100644
index e085cccb9f7..00000000000
--- a/IPython/deathrow/Gnuplot2.py
+++ /dev/null
@@ -1,665 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Improved replacement for the Gnuplot.Gnuplot class.
-
-This module imports Gnuplot and replaces some of its functionality with
-improved versions. They add better handling of arrays for plotting and more
-convenient PostScript generation, plus some fixes for hardcopy().
-
-It also adds a convenient plot2 method for plotting dictionaries and
-lists/tuples of arrays.
-
-This module is meant to be used as a drop-in replacement to the original
-Gnuplot, so it should be safe to do:
-
-import IPython.Gnuplot2 as Gnuplot
-"""
-
-import cStringIO
-import os
-import string
-import sys
-import tempfile
-import time
-import types
-
-import Gnuplot as Gnuplot_ori
-import Numeric
-
-from IPython.utils.genutils import popkey,xsys
-
-# needed by hardcopy():
-gp = Gnuplot_ori.gp
-
-# Patch for Gnuplot.py 1.6 compatibility.
-# Thanks to Hayden Callow <h.callow@elec.canterbury.ac.nz>
-try:
-    OptionException = Gnuplot_ori.PlotItems.OptionException
-except AttributeError:
-    OptionException = Gnuplot_ori.Errors.OptionError
-
-# exhibit a similar interface to Gnuplot so it can be somewhat drop-in
-Data      = Gnuplot_ori.Data
-Func      = Gnuplot_ori.Func
-GridData  = Gnuplot_ori.GridData
-PlotItem  = Gnuplot_ori.PlotItem
-PlotItems = Gnuplot_ori.PlotItems
-
-# Modify some of Gnuplot's functions with improved versions (or bugfixed, in
-# hardcopy's case). In order to preserve the docstrings at runtime, I've
-# copied them from the original code.
-
-# After some significant changes in v 1.7 of Gnuplot.py, we need to do a bit
-# of version checking.
-
-if Gnuplot_ori.__version__ <= '1.6':
-    _BaseFileItem = PlotItems.File
-    _BaseTempFileItem = PlotItems.TempFile
-
-    # Fix the File class to add the 'index' option for Gnuplot versions < 1.7
-    class File(_BaseFileItem):
-
-        _option_list = _BaseFileItem._option_list.copy()
-        _option_list.update({
-            'index' : lambda self, index: self.set_option_index(index),
-            })
-
-        # A new initializer is needed b/c we want to add a modified
-        # _option_sequence list which includes 'index' in the right place.
-        def __init__(self,*args,**kw):
-            self._option_sequence = ['binary', 'index', 'using', 'smooth', 'axes',
-                         'title', 'with']
-
-            _BaseFileItem.__init__(self,*args,**kw)
-
-        # Let's fix the constructor docstring
-        __newdoc = \
-            """Additional Keyword arguments added by IPython:
-
-             'index=<int>' -- similar to the `index` keyword in Gnuplot.
-                 This allows only some of the datasets in a file to be
-                 plotted. Datasets within a file are assumed to be separated
-                 by _pairs_ of blank lines, and the first one is numbered as
-                 0 (similar to C/Python usage)."""
-        __init__.__doc__ = PlotItems.File.__init__.__doc__ + __newdoc
-
-        def set_option_index(self, index):
-            if index is None:
-                self.clear_option('index')
-            elif type(index) in [type(''), type(1)]:
-                self._options['index'] = (index, 'index %s' % index)
-            elif type(index) is type(()):
-                self._options['index'] = (index,'index %s' %
-                                          string.join(map(repr, index), ':'))
-            else:
-                raise OptionException('index=%s' % (index,))
-
-    # We need a FileClass with a different name from 'File', which is a
-    # factory function in 1.7, so that our String class can subclass FileClass
-    # in any version.
-    _FileClass = File
-
-elif Gnuplot_ori.__version__ =='1.7':
-    _FileClass = _BaseFileItem = PlotItems._FileItem
-    _BaseTempFileItem = PlotItems._TempFileItem
-    File = PlotItems.File
-
-else:  # changes in the newer version (svn as of March'06)
-     _FileClass = _BaseFileItem = PlotItems._FileItem
-     _BaseTempFileItem = PlotItems._NewFileItem
-     File = PlotItems.File
-
-
-# Now, we can add our generic code which is version independent
-
-# First some useful utilities
-def eps_fix_bbox(fname):
-    """Fix the bounding box of an eps file by running ps2eps on it.
-
-    If its name ends in .eps, the original file is removed.
-
-    This is particularly useful for plots made by Gnuplot with square aspect
-    ratio: there is a bug in Gnuplot which makes it generate a bounding box
-    which is far wider than the actual plot.
-
-    This function assumes that ps2eps is installed in your system."""
-
-    # note: ps2ps and eps2eps do NOT work, ONLY ps2eps works correctly. The
-    # others make output with bitmapped fonts, which looks horrible.
-    print 'Fixing eps file: <%s>' % fname
-    xsys('ps2eps -f -q -l %s' % fname)
-    if fname.endswith('.eps'):
-        os.rename(fname+'.eps',fname)
-
-def is_list1d(x,containers = [types.ListType,types.TupleType]):
-    """Returns true if x appears to be a 1d list/tuple/array.
-
-    The heuristics are: identify Numeric arrays, or lists/tuples whose first
-    element is not itself a list/tuple. This way zipped lists should work like
-    the original Gnuplot. There's no inexpensive way to know if a list doesn't
-    have a composite object after its first element, so that kind of input
-    will produce an error. But it should work well in most cases.
-    """
-    x_type = type(x)
-
-    return x_type == Numeric.ArrayType and len(x.shape)==1 or \
-           (x_type in containers and
-            type(x[0]) not in containers + [Numeric.ArrayType])
-
-def zip_items(items,titles=None):
-    """zip together neighboring 1-d arrays, and zip standalone ones
-    with their index. Leave other plot items alone."""
-
-    class StandaloneItem(Exception): pass
-    
-    def get_titles(titles):
-        """Return the next title and the input titles array.
-
-        The input array may be changed to None when no titles are left to
-        prevent extra unnecessary calls to this function."""
-        
-        try:
-            title = titles[tit_ct[0]]  # tit_ct[0] is in zip_items'scope
-        except IndexError:
-            titles = None # so we don't enter again
-            title = None
-        else:
-            tit_ct[0] += 1
-        return title,titles
-
-    new_items = []
-
-    if titles:
-        # Initialize counter. It was put in a list as a hack to allow the
-        # nested get_titles to modify it without raising a NameError.
-        tit_ct = [0]
-
-    n = 0  # this loop needs to be done by hand
-    while n < len(items):
-        item = items[n]
-        try:
-            if is_list1d(item):
-                if n==len(items)-1: # last in list
-                    raise StandaloneItem
-                else: # check the next item and zip together if needed
-                    next_item = items[n+1]
-                    if next_item is None:
-                        n += 1
-                        raise StandaloneItem
-                    elif is_list1d(next_item):
-                        # this would be best done with an iterator
-                        if titles:
-                            title,titles = get_titles(titles)
-                        else:
-                            title = None
-                        new_items.append(Data(zip(item,next_item),
-                                              title=title))
-                        n += 1  # avoid double-inclusion of next item
-                    else: # can't zip with next, zip with own index list
-                        raise StandaloneItem
-            else:  # not 1-d array
-                new_items.append(item)
-        except StandaloneItem:
-            if titles:
-                title,titles = get_titles(titles)
-            else:
-                title = None
-            new_items.append(Data(zip(range(len(item)),item),title=title))
-        except AttributeError:
-            new_items.append(item)
-        n+=1
-
-    return new_items
-
-# And some classes with enhanced functionality.
-class String(_FileClass):
-    """Make a PlotItem from data in a string with the same format as a File.
-
-    This allows writing data directly inside python scripts using the exact
-    same format and manipulation options which would be used for external
-    files."""
-
-    def __init__(self, data_str, **keyw):
-        """Construct a String object.
-
-        <data_str> is a string formatted exactly like a valid Gnuplot data
-        file would be. All options from the File constructor are valid here.
-
-        Warning: when used for interactive plotting in scripts which exit
-        immediately, you may get an error because the temporary file used to
-        hold the string data was deleted before Gnuplot had a chance to see
-        it. You can work around this problem by putting a raw_input() call at
-        the end of the script.
-
-        This problem does not appear when generating PostScript output, only
-        with Gnuplot windows."""
-
-        self.tmpfile = _BaseTempFileItem()
-        tmpfile = file(self.tmpfile.filename,'w')
-        tmpfile.write(data_str)
-        _BaseFileItem.__init__(self,self.tmpfile,**keyw)
-
-
-class Gnuplot(Gnuplot_ori.Gnuplot):
-    """Improved Gnuplot class.
-
-    Enhancements: better plot,replot and hardcopy methods. New methods for
-    quick range setting.
-    """
-
-    def xrange(self,min='*',max='*'):
-        """Set xrange. If min/max is omitted, it is set to '*' (auto).
-
-        Note that this is different from the regular Gnuplot behavior, where
-        an unspecified limit means no change. Here any unspecified limit is
-        set to autoscaling, allowing these functions to be used for full
-        autoscaling when called with no arguments.
-
-        To preserve one limit's current value while changing the other, an
-        explicit '' argument must be given as the limit to be kept.
-
-        Similar functions exist for [y{2}z{2}rtuv]range."""
-        
-        self('set xrange [%s:%s]' % (min,max))
-             
-    def yrange(self,min='*',max='*'):
-        self('set yrange [%s:%s]' % (min,max))
-             
-    def zrange(self,min='*',max='*'):
-        self('set zrange [%s:%s]' % (min,max))
-             
-    def x2range(self,min='*',max='*'):
-        self('set xrange [%s:%s]' % (min,max))
-             
-    def y2range(self,min='*',max='*'):
-        self('set yrange [%s:%s]' % (min,max))
-             
-    def z2range(self,min='*',max='*'):
-        self('set zrange [%s:%s]' % (min,max))
-             
-    def rrange(self,min='*',max='*'):
-        self('set rrange [%s:%s]' % (min,max))
-             
-    def trange(self,min='*',max='*'):
-        self('set trange [%s:%s]' % (min,max))
-             
-    def urange(self,min='*',max='*'):
-        self('set urange [%s:%s]' % (min,max))
-             
-    def vrange(self,min='*',max='*'):
-        self('set vrange [%s:%s]' % (min,max))
-
-    def set_ps(self,option):
-        """Set an option for the PostScript terminal and reset default term."""
-
-        self('set terminal postscript %s ' % option)
-        self('set terminal %s' % gp.GnuplotOpts.default_term)
-
-    def __plot_ps(self, plot_method,*items, **keyw):
-        """Wrapper for plot/splot/replot, with processing of hardcopy options.
-
-        For internal use only."""
-
-        # Filter out PostScript options which will crash the normal plot/replot
-        psargs = {'filename':None,
-                  'mode':None,
-                  'eps':None,
-                  'enhanced':None,
-                  'color':None,
-                  'solid':None,
-                  'duplexing':None,
-                  'fontname':None,
-                  'fontsize':None,
-                  'debug':0 }
-
-        for k in psargs.keys():
-            if keyw.has_key(k):
-                psargs[k] = keyw[k]
-                del keyw[k]
-
-        # Filter out other options the original plot doesn't know
-        hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
-        titles = popkey(keyw,'titles',0)
-        
-        # the filename keyword should control hardcopy generation, this is an
-        # override switch only which needs to be explicitly set to zero
-        if hardcopy:
-            if psargs['filename'] is None:
-                raise ValueError, \
-                      'If you request hardcopy, you must give a filename.'
-
-            # set null output so nothing goes to screen. hardcopy() restores output
-            self('set term dumb')
-            # I don't know how to prevent screen output in Windows
-            if os.name == 'posix':
-                self('set output "/dev/null"')
-
-        new_items = zip_items(items,titles)
-        # plot_method is either plot or replot from the original Gnuplot class:
-        plot_method(self,*new_items,**keyw)
-
-        # Do hardcopy if requested
-        if hardcopy:
-            if psargs['filename'].endswith('.eps'):
-                psargs['eps'] = 1
-            self.hardcopy(**psargs)
-
-    def plot(self, *items, **keyw):
-        """Draw a new plot.
-
-        Clear the current plot and create a new 2-d plot containing
-        the specified items.  Each arguments should be of the
-        following types:
-
-        'PlotItem' (e.g., 'Data', 'File', 'Func') -- This is the most
-            flexible way to call plot because the PlotItems can
-            contain suboptions.  Moreover, PlotItems can be saved to
-            variables so that their lifetime is longer than one plot
-            command; thus they can be replotted with minimal overhead.
-
-        'string' (e.g., 'sin(x)') -- The string is interpreted as
-            'Func(string)' (a function that is computed by gnuplot).
-
-        Anything else -- The object, which should be convertible to an
-            array, is passed to the 'Data' constructor, and thus
-            plotted as data.  If the conversion fails, an exception is
-            raised.
-
-
-        This is a modified version of plot(). Compared to the original in
-        Gnuplot.py, this version has several enhancements, listed below.
-
-
-        Modifications to the input arguments
-        ------------------------------------
-
-        (1-d array means Numeric array, list or tuple):
-
-        (i) Any 1-d array which is NOT followed by another 1-d array, is
-        automatically zipped with range(len(array_1d)). Typing g.plot(y) will
-        plot y against its indices.
-
-        (ii) If two 1-d arrays are contiguous in the argument list, they are
-        automatically zipped together. So g.plot(x,y) plots y vs. x, and
-        g.plot(x1,y1,x2,y2) plots y1 vs. x1 and y2 vs. x2.
-
-        (iii) Any 1-d array which is followed by None is automatically zipped
-        with range(len(array_1d)). In this form, typing g.plot(y1,None,y2)
-        will plot both y1 and y2 against their respective indices (and NOT
-        versus one another). The None prevents zipping y1 and y2 together, and
-        since y2 is unpaired it is automatically zipped to its indices by (i)
-
-        (iv) Any other arguments which don't match these cases are left alone and
-        passed to the code below.
-
-        For lists or tuples, the heuristics used to determine whether they are
-        in fact 1-d is fairly simplistic: their first element is checked, and
-        if it is not a list or tuple itself, it is assumed that the whole
-        object is one-dimensional.
-
-        An additional optional keyword 'titles' has been added: it must be a
-        list of strings to be used as labels for the individual plots which
-        are NOT PlotItem objects (since those objects carry their own labels
-        within).
-
-
-        PostScript generation
-        ---------------------
-
-        This version of plot() also handles automatically the production of
-        PostScript output. The main options are (given as keyword arguments):
-
-        - filename: a string, typically ending in .eps. If given, the plot is
-        sent to this file in PostScript format.
-        
-        - hardcopy: this can be set to 0 to override 'filename'. It does not
-        need to be given to produce PostScript, its purpose is to allow
-        switching PostScript output off globally in scripts without having to
-        manually change 'filename' values in multiple calls.
-
-        All other keywords accepted by Gnuplot.hardcopy() are transparently
-        passed, and safely ignored if output is sent to the screen instead of
-        PostScript.
-
-        For example:
-        
-        In [1]: x=frange(0,2*pi,npts=100)
-
-        Generate a plot in file 'sin.eps':
-
-        In [2]: plot(x,sin(x),filename = 'sin.eps')
-
-        Plot to screen instead, without having to change the filename:
-
-        In [3]: plot(x,sin(x),filename = 'sin.eps',hardcopy=0)
-
-        Pass the 'color=0' option to hardcopy for monochrome output:
-
-        In [4]: plot(x,sin(x),filename = 'sin.eps',color=0)
-
-        PostScript generation through plot() is useful mainly for scripting
-        uses where you are not interested in interactive plotting. For
-        interactive use, the hardcopy() function is typically more convenient:
-        
-        In [5]: plot(x,sin(x))
-
-        In [6]: hardcopy('sin.eps')  """
-        
-        self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
-        
-    def plot2(self,arg,**kw):
-        """Plot the entries of a dictionary or a list/tuple of arrays.        
-        
-        This simple utility calls plot() with a list of Gnuplot.Data objects
-        constructed either from the values of the input dictionary, or the entries
-        in it if it is a tuple or list.  Each item gets labeled with the key/index
-        in the Gnuplot legend.
-
-        Each item is plotted by zipping it with a list of its indices.
-
-        Any keywords are passed directly to plot()."""
-
-        if hasattr(arg,'keys'):
-            keys = arg.keys()
-            keys.sort()
-        else:
-            keys = range(len(arg))
-
-        pitems = [Data(zip(range(len(arg[k])),arg[k]),title=`k`) for k in keys]
-        self.plot(*pitems,**kw)
-
-    def splot(self, *items, **keyw):
-        """Draw a new three-dimensional plot.
-
-        Clear the current plot and create a new 3-d plot containing
-        the specified items.  Arguments can be of the following types:
-
-        'PlotItem' (e.g., 'Data', 'File', 'Func', 'GridData' ) -- This
-            is the most flexible way to call plot because the
-            PlotItems can contain suboptions.  Moreover, PlotItems can
-            be saved to variables so that their lifetime is longer
-            than one plot command--thus they can be replotted with
-            minimal overhead.
-
-        'string' (e.g., 'sin(x*y)') -- The string is interpreted as a
-            'Func()' (a function that is computed by gnuplot).
-
-        Anything else -- The object is converted to a Data() item, and
-            thus plotted as data.  Note that each data point should
-            normally have at least three values associated with it
-            (i.e., x, y, and z).  If the conversion fails, an
-            exception is raised.
-
-        This is a modified version of splot(). Compared to the original in
-        Gnuplot.py, this version has several enhancements, listed in the
-        plot() documentation.
-        """
-        
-        self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
-
-    def replot(self, *items, **keyw):
-        """Replot the data, possibly adding new 'PlotItem's.
-
-        Replot the existing graph, using the items in the current
-        itemlist.  If arguments are specified, they are interpreted as
-        additional items to be plotted alongside the existing items on
-        the same graph.  See 'plot' for details.
-
-        If you want to replot to a postscript file, you MUST give the
-        'filename' keyword argument in each call to replot. The Gnuplot python
-        interface has no way of knowing that your previous call to
-        Gnuplot.plot() was meant for PostScript output."""
-        
-        self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
-
-    # The original hardcopy has a bug. See fix at the end. The rest of the code
-    # was lifted verbatim from the original, so that people using IPython get the
-    # benefits without having to manually patch Gnuplot.py
-    def hardcopy(self, filename=None,
-                 mode=None,
-                 eps=None,
-                 enhanced=None,
-                 color=None,
-                 solid=None,
-                 duplexing=None,
-                 fontname=None,
-                 fontsize=None,
-                 debug = 0,
-                 ):
-        """Create a hardcopy of the current plot.
-
-        Create a postscript hardcopy of the current plot to the
-        default printer (if configured) or to the specified filename.
-
-        Note that gnuplot remembers the postscript suboptions across
-        terminal changes.  Therefore if you set, for example, color=1
-        for one hardcopy then the next hardcopy will also be color
-        unless you explicitly choose color=0.  Alternately you can
-        force all of the options to their defaults by setting
-        mode='default'.  I consider this to be a bug in gnuplot.
-
-        Keyword arguments:
-
-          'filename=<string>' -- if a filename is specified, save the
-              output in that file; otherwise print it immediately
-              using the 'default_lpr' configuration option.  If the
-              filename ends in '.eps', EPS mode is automatically
-              selected (like manually specifying eps=1 or mode='eps').
-
-          'mode=<string>' -- set the postscript submode ('landscape',
-              'portrait', 'eps', or 'default').  The default is
-              to leave this option unspecified.
-
-          'eps=<bool>' -- shorthand for 'mode="eps"'; asks gnuplot to
-              generate encapsulated postscript.
-
-          'enhanced=<bool>' -- if set (the default), then generate
-              enhanced postscript, which allows extra features like
-              font-switching, superscripts, and subscripts in axis
-              labels.  (Some old gnuplot versions do not support
-              enhanced postscript; if this is the case set
-              gp.GnuplotOpts.prefer_enhanced_postscript=None.)
-
-          'color=<bool>' -- if set, create a plot with color.  Default
-              is to leave this option unchanged.
-
-          'solid=<bool>' -- if set, force lines to be solid (i.e., not
-              dashed).
-
-          'duplexing=<string>' -- set duplexing option ('defaultplex',
-              'simplex', or 'duplex').  Only request double-sided
-              printing if your printer can handle it.  Actually this
-              option is probably meaningless since hardcopy() can only
-              print a single plot at a time.
-
-          'fontname=<string>' -- set the default font to <string>,
-              which must be a valid postscript font.  The default is
-              to leave this option unspecified.
-
-          'fontsize=<double>' -- set the default font size, in
-              postscript points.
-
-          'debug=<bool>' -- print extra debugging information (useful if
-              your PostScript files are misteriously not being created).
-        """
-
-        if filename is None:
-            assert gp.GnuplotOpts.default_lpr is not None, \
-                   OptionException('default_lpr is not set, so you can only '
-                                   'print to a file.')
-            filename = gp.GnuplotOpts.default_lpr
-            lpr_output = 1
-        else:
-            if filename.endswith('.eps'):
-                eps = 1
-            lpr_output = 0
-
-        # Be careful processing the options.  If the user didn't
-        # request an option explicitly, do not specify it on the 'set
-        # terminal' line (don't even specify the default value for the
-        # option).  This is to avoid confusing older versions of
-        # gnuplot that do not support all of these options.  The
-        # exception is 'enhanced', which is just too useful to have to
-        # specify each time!
-
-        setterm = ['set', 'terminal', 'postscript']
-        if eps:
-            assert mode is None or mode=='eps', \
-                   OptionException('eps option and mode are incompatible')
-            setterm.append('eps')
-        else:
-            if mode is not None:
-                assert mode in ['landscape', 'portrait', 'eps', 'default'], \
-                       OptionException('illegal mode "%s"' % mode)
-                setterm.append(mode)
-        if enhanced is None:
-            enhanced = gp.GnuplotOpts.prefer_enhanced_postscript
-        if enhanced is not None:
-            if enhanced: setterm.append('enhanced')
-            else: setterm.append('noenhanced')
-        if color is not None:
-            if color: setterm.append('color')
-            else: setterm.append('monochrome')
-        if solid is not None:
-            if solid: setterm.append('solid')
-            else: setterm.append('dashed')
-        if duplexing is not None:
-            assert duplexing in ['defaultplex', 'simplex', 'duplex'], \
-                   OptionException('illegal duplexing mode "%s"' % duplexing)
-            setterm.append(duplexing)
-        if fontname is not None:
-            setterm.append('"%s"' % fontname)
-        if fontsize is not None:
-            setterm.append('%s' % fontsize)
-
-        self(string.join(setterm))
-        self.set_string('output', filename)
-        # replot the current figure (to the printer):
-        self.refresh()
-
-        # fperez. Ugly kludge: often for some reason the file is NOT created
-        # and we must reissue the creation commands. I have no idea why!
-        if not lpr_output:
-            #print 'Hardcopy <%s>' % filename  # dbg
-            maxtries = 20
-            delay = 0.1  # delay (in seconds) between print attempts
-            for i in range(maxtries):
-                time.sleep(0.05)  # safety, very small delay
-                if os.path.isfile(filename):
-                    if debug:
-                        print 'Hardcopy to file <%s> success at attempt #%s.' \
-                        % (filename,i+1)
-                    break
-                time.sleep(delay)
-                # try again, issue all commands just in case
-                self(string.join(setterm))
-                self.set_string('output', filename)
-                self.refresh()
-            if not os.path.isfile(filename):
-                print >> sys.stderr,'ERROR: Tried %s times and failed to '\
-                'create hardcopy file `%s`' % (maxtries,filename)
-
-        # reset the terminal to its `default' setting:
-        self('set terminal %s' % gp.GnuplotOpts.default_term)
-        self.set_string('output')
-
-#********************** End of file <Gnuplot2.py> ************************
diff --git a/IPython/deathrow/GnuplotInteractive.py b/IPython/deathrow/GnuplotInteractive.py
deleted file mode 100644
index b528428a1ee..00000000000
--- a/IPython/deathrow/GnuplotInteractive.py
+++ /dev/null
@@ -1,148 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Interactive functions and magic functions for Gnuplot usage.
-
-This requires the Gnuplot.py module for interfacing python with Gnuplot, which
-can be downloaded from:
-
-http://gnuplot-py.sourceforge.net/
-
-See gphelp() below for details on the services offered by this module.
-
-Inspired by a suggestion/request from Arnd Baecker.
-"""
-
-__all__ = ['Gnuplot','gp','gp_new','plot','plot2','splot','replot',
-           'hardcopy','gpdata','gpfile','gpstring','gpfunc','gpgrid',
-           'gphelp']
-
-import IPython.GnuplotRuntime as GRun
-from IPython.utils.genutils import warn
-from IPython.core import page
-
-# Set global names for interactive use
-Gnuplot  = GRun.Gnuplot
-gp_new   = GRun.gp_new
-gp       = GRun.gp
-plot     = gp.plot
-plot2    = gp.plot2
-splot    = gp.splot
-replot   = gp.replot
-hardcopy = gp.hardcopy
-
-# Accessors for the main plot object constructors:
-gpdata   = Gnuplot.Data
-gpfile   = Gnuplot.File
-gpstring = Gnuplot.String
-gpfunc   = Gnuplot.Func
-gpgrid   = Gnuplot.GridData
-
-def gphelp():
-    """Print information about the Gnuplot facilities in IPython."""
-
-    page("""
-IPython provides an interface to access the Gnuplot scientific plotting
-system, in an environment similar to that of Mathematica or Matlab.
-
-New top-level global objects
-----------------------------
-
-Please see their respective docstrings for further details.
-
-- gp: a running Gnuplot instance. You can access its methods as
-gp.<method>. gp(`a string`) will execute the given string as if it had been
-typed in an interactive gnuplot window.
-
-- plot, splot, replot and hardcopy: aliases to the methods of the same name in
-the global running Gnuplot instance gp. These allow you to simply type:
-
-In [1]: plot(x,sin(x),title='Sin(x)')  # assuming x is a Numeric array
-
-and obtain a plot of sin(x) vs x with the title 'Sin(x)'.
-
-- gp_new: a function which returns a new Gnuplot instance. This can be used to
-have multiple Gnuplot instances running in your session to compare different
-plots, each in a separate window.
-
-- Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
-the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
-functions with improved versions (Gnuplot2 comes with IPython).
-
-- gpdata, gpfile, gpstring, gpfunc, gpgrid: aliases to Gnuplot.Data,
-Gnuplot.File, Gnuplot.String, Gnuplot.Func and Gnuplot.GridData
-respectively. These functions create objects which can then be passed to the
-plotting commands. See the Gnuplot.py documentation for details.
-
-Keep in mind that all commands passed to a Gnuplot instance are executed in
-the Gnuplot namespace, where no Python variables exist. For example, for
-plotting sin(x) vs x as above, typing
-
-In [2]: gp('plot x,sin(x)')
-
-would not work. Instead, you would get the plot of BOTH the functions 'x' and
-'sin(x)', since Gnuplot doesn't know about the 'x' Python array. The plot()
-method lives in python and does know about these variables.
-
-
-New magic functions
--------------------
-
-%gpc: pass one command to Gnuplot and execute it or open a Gnuplot shell where
-each line of input is executed.
-
-%gp_set_default: reset the value of IPython's global Gnuplot instance.""")
-    
-# Code below is all for IPython use
-# Define the magic functions for communicating with the above gnuplot instance.
-def magic_gpc(self,parameter_s=''):
-    """Execute a gnuplot command or open a gnuplot shell.
-
-    Usage (omit the % if automagic is on). There are two ways to use it:
-
-      1) %gpc 'command' -> passes 'command' directly to the gnuplot instance.
-
-      2) %gpc -> will open up a prompt (gnuplot>>>) which takes input like the
-      standard gnuplot interactive prompt. If you need to type a multi-line
-      command, use \\ at the end of each intermediate line.
-
-      Upon exiting of the gnuplot sub-shell, you return to your IPython
-      session (the gnuplot sub-shell can be invoked as many times as needed).
-      """
-
-    if parameter_s.strip():
-        self.shell.gnuplot(parameter_s)
-    else:
-        self.shell.gnuplot.interact()
-
-def magic_gp_set_default(self,parameter_s=''):
-    """Set the default gnuplot instance accessed by the %gp magic function.
-
-    %gp_set_default name
-
-    Call with the name of the new instance at the command line. If you want to
-    set this instance in your own code (using an embedded IPython, for
-    example), simply set the variable __IPYTHON__.gnuplot to your own gnuplot
-    instance object."""
-
-    gname = parameter_s.strip()
-    G = eval(gname,self.shell.user_ns)
-    self.shell.gnuplot = G
-    self.shell.user_ns.update({'plot':G.plot,'splot':G.splot,'plot2':G.plot2,
-                               'replot':G.replot,'hardcopy':G.hardcopy})
-
-try:
-    __IPYTHON__
-except NameError:
-    pass
-else:
-    # make the global Gnuplot instance known to IPython
-    __IPYTHON__.gnuplot = GRun.gp
-    __IPYTHON__.gnuplot.shell_first_time = 1
-
-    print """*** Type `gphelp` for help on the Gnuplot integration features."""
-
-    # Add the new magic functions to the class dict
-    from IPython.core.iplib import InteractiveShell
-    InteractiveShell.magic_gpc = magic_gpc
-    InteractiveShell.magic_gp_set_default = magic_gp_set_default
-
-#********************** End of file <GnuplotInteractive.py> *******************
diff --git a/IPython/deathrow/GnuplotRuntime.py b/IPython/deathrow/GnuplotRuntime.py
deleted file mode 100644
index 8d524e3ce5a..00000000000
--- a/IPython/deathrow/GnuplotRuntime.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Basic Gnuplot functionality for inclusion in other code.
-
-This module creates a running Gnuplot instance called 'gp' and builds other
-convenient globals for quick use in running scripts. It is intended to allow
-you to script plotting tasks in Python with a minimum of effort. A typical
-usage would be:
-
-import IPython.GnuplotRuntime as GP  # or some other short name
-GP.gp.plot(GP.File('your_data.dat'))
-
-
-This module exposes the following objects:
-
-- gp: a running Gnuplot instance. You can access its methods as
-gp.<method>. gp(`a string`) will execute the given string as if it had been
-typed in an interactive gnuplot window.
-
-- gp_new: a function which returns a new Gnuplot instance. This can be used to
-have multiple Gnuplot instances running in your session to compare different
-plots.
-
-- Gnuplot: alias to the Gnuplot2 module, an improved drop-in replacement for
-the original Gnuplot.py. Gnuplot2 needs Gnuplot but redefines several of its
-functions with improved versions (Gnuplot2 comes with IPython).
-
-- Data: alias to Gnuplot.Data, makes a PlotItem from array data.
-
-- File: alias to Gnuplot.File, makes a PlotItem from a file.
-
-- String: alias to Gnuplot.String, makes a PlotItem from a string formatted
-exactly like a file for Gnuplot.File would be.
-
-- Func: alias to Gnuplot.Func, makes a PlotItem from a function string.
-
-- GridData: alias to Gnuplot.GridData, makes a PlotItem from grid data.
-
-- pm3d_config: a string with Gnuplot commands to set up the pm3d mode for
-surface plotting. You can activate it simply by calling gp(pm3d_config).
-
-- eps_fix_bbox: A Unix-only function to fix eps files with bad bounding boxes
-(which Gnuplot generates when the plot size is set to square).
-
-This requires the Gnuplot.py module for interfacing Python with Gnuplot, which
-can be downloaded from:
-
-http://gnuplot-py.sourceforge.net/
-
-Inspired by a suggestion/request from Arnd Baecker.
-"""
-
-__all__ = ['Gnuplot','gp','gp_new','Data','File','Func','GridData',
-           'pm3d_config','eps_fix_bbox']
-
-import os,tempfile,sys
-from IPython.utils.process import getoutput
-
-#---------------------------------------------------------------------------
-# Notes on mouse support for Gnuplot.py
-
-# If you do not have a mouse-enabled gnuplot, set gnuplot_mouse to 0. If you
-# use gnuplot, you should really grab a recent, mouse enabled copy. It is an
-# extremely useful feature.  Mouse support is official as of gnuplot 4.0,
-# released in April 2004.
-
-# For the mouse features to work correctly, you MUST set your Gnuplot.py
-# module to use temporary files instead of 'inline data' for data
-# communication. Note that this is the default, so unless you've manually
-# fiddled with it you should be ok. If you need to make changes, in the
-# Gnuplot module directory, loook for the gp_unix.py file and make sure the
-# prefer_inline_data variable is set to 0. If you set it to 1 Gnuplot.py will
-# try to pass the data to gnuplot via standard input, which completely
-# confuses the mouse control system (even though it may be a bit faster than
-# using temp files).
-
-# As of Gnuplot.py v1.7, a new option was added to use FIFOs (pipes).  This
-# mechanism, while fast, also breaks the mouse system.  You must therefore set
-# the variable prefer_fifo_data to 0 in gp_unix.py.
-
-tmpname = tempfile.mktemp()
-open(tmpname,'w').write('set mouse')
-gnu_out = getoutput('gnuplot '+ tmpname)
-os.unlink(tmpname)
-if gnu_out:  # Gnuplot won't print anything if it has mouse support
-    print "*** Your version of Gnuplot appears not to have mouse support."
-    gnuplot_mouse = 0
-else:
-    gnuplot_mouse = 1
-del tmpname,gnu_out
-
-# Default state for persistence of new gnuplot instances
-if os.name in ['nt','dos'] or sys.platform == 'cygwin':
-    gnuplot_persist = 0
-else:
-    gnuplot_persist = 1
-
-import IPython.Gnuplot2 as Gnuplot
-
-class NotGiven: pass
-
-def gp_new(mouse=NotGiven,persist=NotGiven):
-    """Return a new Gnuplot instance.
-
-    The instance returned uses the improved methods defined in Gnuplot2.
-
-    Options (boolean):
-
-    - mouse: if unspecified, the module global gnuplot_mouse is used.
-
-    - persist: if unspecified, the module global gnuplot_persist is used."""
-    
-    if mouse is NotGiven:
-        mouse = gnuplot_mouse
-    if persist is NotGiven:
-        persist = gnuplot_persist
-    g = Gnuplot.Gnuplot(persist=persist)
-    if mouse:
-        g('set mouse')
-    return g
-
-# Global-level names.
-
-# A global Gnuplot instance for interactive use:
-gp = gp_new()
-
-# Accessors for the main plot object constructors:
-Data = Gnuplot.Data
-File = Gnuplot.File
-Func = Gnuplot.Func
-String = Gnuplot.String
-GridData = Gnuplot.GridData
-
-# A Unix-only function to fix eps files with bad bounding boxes (which Gnuplot
-# generates when the plot size is set to square):
-eps_fix_bbox = Gnuplot.eps_fix_bbox
-
-# String for configuring pm3d. Simply call g(pm3d_config) to execute it.  pm3d
-# is a very nice mode for plotting colormaps on surfaces. Modify the defaults
-# below to suit your taste.
-pm3d_config = """
-set pm3d solid
-set hidden3d
-unset surface
-set isosamples 50
-"""
-#******************** End of file <GnuplotRuntime.py> ******************
diff --git a/IPython/deathrow/Itpl.py b/IPython/deathrow/Itpl.py
deleted file mode 100644
index 7deba81c929..00000000000
--- a/IPython/deathrow/Itpl.py
+++ /dev/null
@@ -1,290 +0,0 @@
-# -*- coding: utf-8 -*-
-"""String interpolation for Python (by Ka-Ping Yee, 14 Feb 2000).
-
-This module lets you quickly and conveniently interpolate values into
-strings (in the flavour of Perl or Tcl, but with less extraneous
-punctuation).  You get a bit more power than in the other languages,
-because this module allows subscripting, slicing, function calls,
-attribute lookup, or arbitrary expressions.  Variables and expressions
-are evaluated in the namespace of the caller.
-
-The itpl() function returns the result of interpolating a string, and
-printpl() prints out an interpolated string.  Here are some examples:
-
-    from Itpl import printpl
-    printpl("Here is a $string.")
-    printpl("Here is a $module.member.")
-    printpl("Here is an $object.member.")
-    printpl("Here is a $functioncall(with, arguments).")
-    printpl("Here is an ${arbitrary + expression}.")
-    printpl("Here is an $array[3] member.")
-    printpl("Here is a $dictionary['member'].")
-
-The filter() function filters a file object so that output through it
-is interpolated.  This lets you produce the illusion that Python knows
-how to do interpolation:
-
-    import Itpl
-    sys.stdout = Itpl.filter()
-    f = "fancy"
-    print "Is this not $f?"
-    print "Standard output has been replaced with a $sys.stdout object."
-    sys.stdout = Itpl.unfilter()
-    print "Okay, back $to $normal."
-
-Under the hood, the Itpl class represents a string that knows how to
-interpolate values.  An instance of the class parses the string once
-upon initialization; the evaluation and substitution can then be done
-each time the instance is evaluated with str(instance).  For example:
-
-    from Itpl import Itpl
-    s = Itpl("Here is $foo.")
-    foo = 5
-    print str(s)
-    foo = "bar"
-    print str(s)
-"""
-
-#*****************************************************************************
-#
-# Copyright (c) 2001 Ka-Ping Yee <ping@lfw.org>
-#
-#
-# Published under the terms of the MIT license, hereby reproduced:
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-#*****************************************************************************
-
-__author__  = 'Ka-Ping Yee <ping@lfw.org>'
-__license__ = 'MIT'
-
-import string
-import sys
-from tokenize import tokenprog
-from types import StringType
-
-class ItplError(ValueError):
-    def __init__(self, text, pos):
-        self.text = text
-        self.pos = pos
-    def __str__(self):
-        return "unfinished expression in %s at char %d" % (
-            repr(self.text), self.pos)
-
-def matchorfail(text, pos):
-    match = tokenprog.match(text, pos)
-    if match is None:
-        raise ItplError(text, pos)
-
-    return match, match.end()
-
-try:
-    itpl_encoding = sys.stdin.encoding or 'ascii'
-except AttributeError:
-    itpl_encoding = 'ascii'
-
-    
-
-class Itpl:
-    """Class representing a string with interpolation abilities.
-    
-    Upon creation, an instance works out what parts of the format
-    string are literal and what parts need to be evaluated.  The
-    evaluation and substitution happens in the namespace of the
-    caller when str(instance) is called."""
-
-    def __init__(self, format,codec=itpl_encoding,encoding_errors='backslashreplace'):
-        """The single mandatory argument to this constructor is a format
-        string.
-
-        The format string is parsed according to the following rules:
-
-        1.  A dollar sign and a name, possibly followed by any of: 
-              - an open-paren, and anything up to the matching paren 
-              - an open-bracket, and anything up to the matching bracket 
-              - a period and a name 
-            any number of times, is evaluated as a Python expression.
-
-        2.  A dollar sign immediately followed by an open-brace, and
-            anything up to the matching close-brace, is evaluated as
-            a Python expression.
-
-        3.  Outside of the expressions described in the above two rules,
-            two dollar signs in a row give you one literal dollar sign.
-
-        Optional arguments:
-
-        - codec('utf_8'): a string containing the name of a valid Python
-        codec.
-
-        - encoding_errors('backslashreplace'): a string with a valid error handling
-        policy.  See the codecs module documentation for details.
-
-        These are used to encode the format string if a call to str() fails on
-        the expanded result."""
-
-        if not isinstance(format,basestring):
-            raise TypeError, "needs string initializer"
-        self.format = format
-        self.codec = codec
-        self.encoding_errors = encoding_errors
-        
-        namechars = "abcdefghijklmnopqrstuvwxyz" \
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
-        chunks = []
-        pos = 0
-
-        while 1:
-            dollar = string.find(format, "$", pos)
-            if dollar < 0: break
-            nextchar = format[dollar+1]
-
-            if nextchar == "{":
-                chunks.append((0, format[pos:dollar]))
-                pos, level = dollar+2, 1
-                while level:
-                    match, pos = matchorfail(format, pos)
-                    tstart, tend = match.regs[3]
-                    token = format[tstart:tend]
-                    if token == "{": level = level+1
-                    elif token == "}": level = level-1
-                chunks.append((1, format[dollar+2:pos-1]))
-
-            elif nextchar in namechars:
-                chunks.append((0, format[pos:dollar]))
-                match, pos = matchorfail(format, dollar+1)
-                while pos < len(format):
-                    if format[pos] == "." and \
-                        pos+1 < len(format) and format[pos+1] in namechars:
-                        match, pos = matchorfail(format, pos+1)
-                    elif format[pos] in "([":
-                        pos, level = pos+1, 1
-                        while level:
-                            match, pos = matchorfail(format, pos)
-                            tstart, tend = match.regs[3]
-                            token = format[tstart:tend]
-                            if token[0] in "([": level = level+1
-                            elif token[0] in ")]": level = level-1
-                    else: break
-                chunks.append((1, format[dollar+1:pos]))
-
-            else:
-                chunks.append((0, format[pos:dollar+1]))
-                pos = dollar + 1 + (nextchar == "$")
-
-        if pos < len(format): chunks.append((0, format[pos:]))
-        self.chunks = chunks
-
-    def __repr__(self):
-        return "<Itpl %s >" % repr(self.format)
-
-    def _str(self,glob,loc):
-        """Evaluate to a string in the given globals/locals.
-
-        The final output is built by calling str(), but if this fails, the
-        result is encoded with the instance's codec and error handling policy,
-        via a call to out.encode(self.codec,self.encoding_errors)"""
-        result = []
-        app = result.append
-        for live, chunk in self.chunks:
-            if live:
-                val = eval(chunk,glob,loc)
-                try:
-                    app(str(val))
-                except UnicodeEncodeError:
-                    app(unicode(val))
-                
-            else: app(chunk)
-        out = ''.join(result)
-        try:
-            return str(out)
-        except UnicodeError:
-            return out.encode(self.codec,self.encoding_errors)
-
-    def __str__(self):
-        """Evaluate and substitute the appropriate parts of the string."""
-
-        # We need to skip enough frames to get to the actual caller outside of
-        # Itpl.
-        frame = sys._getframe(1)
-        while frame.f_globals["__name__"] == __name__: frame = frame.f_back
-        loc, glob = frame.f_locals, frame.f_globals
-
-        return self._str(glob,loc)
-    
-class ItplNS(Itpl):
-    """Class representing a string with interpolation abilities.
-
-    This inherits from Itpl, but at creation time a namespace is provided
-    where the evaluation will occur.  The interpolation becomes a bit more
-    efficient, as no traceback needs to be extracte.  It also allows the
-    caller to supply a different namespace for the interpolation to occur than
-    its own."""
-    
-    def __init__(self, format,globals,locals=None,
-                 codec='utf_8',encoding_errors='backslashreplace'):
-        """ItplNS(format,globals[,locals]) -> interpolating string instance.
-
-        This constructor, besides a format string, takes a globals dictionary
-        and optionally a locals (which defaults to globals if not provided).
-
-        For further details, see the Itpl constructor."""
-
-        if locals is None:
-            locals = globals
-        self.globals = globals
-        self.locals = locals
-        Itpl.__init__(self,format,codec,encoding_errors)
-        
-    def __str__(self):
-        """Evaluate and substitute the appropriate parts of the string."""
-        return self._str(self.globals,self.locals)
-
-    def __repr__(self):
-        return "<ItplNS %s >" % repr(self.format)
-
-# utilities for fast printing
-def itpl(text): return str(Itpl(text))
-def printpl(text): print itpl(text)
-# versions with namespace
-def itplns(text,globals,locals=None): return str(ItplNS(text,globals,locals))
-def printplns(text,globals,locals=None): print itplns(text,globals,locals)
-
-class ItplFile:
-    """A file object that filters each write() through an interpolator."""
-    def __init__(self, file): self.file = file
-    def __repr__(self): return "<interpolated " + repr(self.file) + ">"
-    def __getattr__(self, attr): return getattr(self.file, attr)
-    def write(self, text): self.file.write(str(Itpl(text)))
-
-def filter(file=sys.stdout):
-    """Return an ItplFile that filters writes to the given file object.
-    
-    'file = filter(file)' replaces 'file' with a filtered object that
-    has a write() method.  When called with no argument, this creates
-    a filter to sys.stdout."""
-    return ItplFile(file)
-
-def unfilter(ifile=None):
-    """Return the original file that corresponds to the given ItplFile.
-    
-    'file = unfilter(file)' undoes the effect of 'file = filter(file)'.
-    'sys.stdout = unfilter()' undoes the effect of 'sys.stdout = filter()'."""
-    return ifile and ifile.file or sys.stdout.file
diff --git a/IPython/deathrow/PhysicalQInput.py b/IPython/deathrow/PhysicalQInput.py
deleted file mode 100644
index fd53e8a540f..00000000000
--- a/IPython/deathrow/PhysicalQInput.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Modified input prompt for entering quantities with units.
-
-Modify the behavior of the interactive interpreter to allow direct input of
-quantities with units without having to make a function call.
-
-Now the following forms are accepted:
-
-x = 4 m
-y = -.45e3 m/s
-g = 9.8 m/s**2
-a = 2.3 m/s^2   # ^ -> ** automatically
-
-All other input is processed normally.
-
-Authors
--------
-- Fernando Perez <Fernando.Perez@berkeley.edu>
-"""
-#*****************************************************************************
-#       Copyright (C) 2008-2009 The IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-# This file is an example of how to modify IPython's line-processing behavior
-# without touching the internal code. We'll define an alternate pre-processing
-# stage which allows a special form of input (which is invalid Python syntax)
-# for certain quantities, rewrites a line of proper Python in those cases, and
-# then passes it off to IPython's normal processor for further work.
-
-# With this kind of customization, IPython can be adapted for many
-# special-purpose scenarios providing alternate input syntaxes.
-
-# This file can be imported like a regular module.
-
-# IPython has a prefilter() function that analyzes each input line. We redefine
-# it here to first pre-process certain forms of input
-
-# The prototype of any alternate prefilter must be like this one (the name
-# doesn't matter):
-# - line is a string containing the user input line.
-# - continuation is a parameter which tells us if we are processing a first line of
-#   user input or the second or higher of a multi-line statement.
-
-def prefilter_PQ(self,line,continuation):
-    """Alternate prefilter for input of PhysicalQuantityInteractive objects.
-
-    This assumes that the function PhysicalQuantityInteractive() has been
-    imported."""
-
-    from re import match
-    from IPython.core.iplib import InteractiveShell
-
-    # This regexp is what does the real work
-    unit_split = match(r'\s*(\w+)\s*=\s*(-?\d*\.?\d*[eE]?-?\d*)\s+([a-zA-Z].*)',
-                       line)
-
-    # If special input was ecnountered, process it:
-    if unit_split:
-        var,val,units = unit_split.groups()
-        if var and val and units:
-            units = units.replace('^','**')
-            # Now a valid line needs to be constructed for IPython to process:
-            line = var +" = PhysicalQuantityInteractive(" + val + ", '" + \
-                   units + "')"
-            #print 'New line:',line   # dbg
-            
-    # In the end, always call the default IPython _prefilter() function.  Note
-    # that self must be passed explicitly, b/c we're calling the unbound class
-    # method (since this method will overwrite the instance prefilter())
-    return InteractiveShell._prefilter(self,line,continuation)
-
-# Rebind this to be the new IPython prefilter:
-from IPython.core.iplib import InteractiveShell
-InteractiveShell.prefilter = prefilter_PQ
-
-# Clean up the namespace.
-del InteractiveShell,prefilter_PQ
-
-# Just a heads up at the console
-print '*** Simplified input for physical quantities enabled.'
diff --git a/IPython/deathrow/PhysicalQInteractive.py b/IPython/deathrow/PhysicalQInteractive.py
deleted file mode 100644
index 45817bc5b8b..00000000000
--- a/IPython/deathrow/PhysicalQInteractive.py
+++ /dev/null
@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Modify the PhysicalQuantities class for more convenient interactive use.
-
-Also redefine some math functions to operate on PhysQties with no need for
-special method syntax. This just means moving them out to the global
-namespace.
-
-This module should always be loaded *after* math or Numeric, so it can
-overwrite math functions with the versions that handle units.
-
-Authors
--------
-- Fernando Perez <Fernando.Perez@berkeley.edu>
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2008-2009 The IPython Development Team
-#       Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-from Scientific.Physics.PhysicalQuantities import PhysicalQuantity
-
-# This code can be set up to work with Numeric or with math for providing the
-# mathematical functions. Uncomment the one you prefer to use below.
-
-# If you use math, sin(x) won't work for x an array, only float or PhysQty
-import math
-
-# If you use Numeric, sin(x) works for x a float, PhysQty an array.
-#import Numeric as math
-
-class PhysicalQuantityFunction:
-    """Generic function wrapper for PhysicalQuantity instances.
-
-    Calls functions from either the math library or the instance's methods as
-    required.  Allows using sin(theta) or sqrt(v**2) syntax irrespective of
-    whether theta is a pure number or a PhysicalQuantity.
-
-    This is *slow*. It's meant for convenient interactive use, not for
-    speed."""
-
-    def __init__(self,name):
-        self.name = name
-        
-    def __call__(self,x):
-        if isinstance(x,PhysicalQuantity):
-            return PhysicalQuantity.__dict__[self.name](x)
-        else:
-            return math.__dict__[self.name](x)
-
-class PhysicalQuantityInteractive(PhysicalQuantity):
-    """Physical quantity with units - modified for Interactive use.
-
-    Basically, the __str__ and __repr__ methods have been swapped for more
-    convenient interactive use. Powers are shown as ^ instead of ** and only 4
-    significant figures are shown.
-
-    Also adds the following aliases for commonly used methods:
-      b = PhysicalQuantity.inBaseUnits
-      u = PhysicalQuantity.inUnitsOf
-      
-    These are useful when doing a lot of interactive calculations.
-    """
-    
-    # shorthands for the most useful unit conversions
-    b = PhysicalQuantity.inBaseUnits  # so you can just type x.b to get base units
-    u = PhysicalQuantity.inUnitsOf
-
-    # This can be done, but it can get dangerous when coupled with IPython's
-    # auto-calling. Everything ends up shown in baseunits and things like x*2
-    # get automatically converted to k(*2), which doesn't work.
-    # Probably not a good idea in general...
-    #__call__ = b
-    
-    def __str__(self):
-        return PhysicalQuantity.__repr__(self)
- 
-    def __repr__(self):
-        value = '%.4G' % self.value
-        units = self.unit.name().replace('**','^')
-        return value + ' ' + units
-
-# implement the methods defined in PhysicalQuantity as PhysicalQuantityFunctions
-sin = PhysicalQuantityFunction('sin')
-cos = PhysicalQuantityFunction('cos')
-tan = PhysicalQuantityFunction('tan')
-sqrt = PhysicalQuantityFunction('sqrt')
diff --git a/IPython/deathrow/Shell.py b/IPython/deathrow/Shell.py
deleted file mode 100644
index 7600f17b3bb..00000000000
--- a/IPython/deathrow/Shell.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A backwards compatibility layer for IPython.Shell.
-
-Previously, IPython had an IPython.Shell module.  IPython.Shell has been moved
-to IPython.core.shell and is being refactored.  This new module is provided
-for backwards compatability.  We strongly encourage everyone to start using
-the new code in IPython.core.shell.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from warnings import warn
-
-msg = """
-This module (IPython.Shell) is deprecated.  The classes that were in this
-module have been replaced by:
-
-IPShell->IPython.core.iplib.InteractiveShell
-IPShellEmbed->IPython.core.embed.InteractiveShellEmbed
-
-Please migrate your code to use these classes instead.
-"""
-
-warn(msg, category=DeprecationWarning, stacklevel=1)
-
-from IPython.core.iplib import InteractiveShell as IPShell
-from IPython.core.embed import InteractiveShellEmbed as IPShellEmbed
-
-def start(user_ns=None, embedded=False):
-    """Return an instance of :class:`InteractiveShell`."""
-    if embedded:
-        return IPShellEmbed(user_ns=user_ns)
-    else:
-        return IPShell(user_ns=user_ns)
-
diff --git a/IPython/deathrow/astyle.py b/IPython/deathrow/astyle.py
deleted file mode 100644
index 9821d58fd21..00000000000
--- a/IPython/deathrow/astyle.py
+++ /dev/null
@@ -1,400 +0,0 @@
-"""
-``astyle`` provides classes for adding style (foreground and background color;
-bold; blink; etc.) to terminal and curses output.
-"""
-
-
-import sys, os
-
-try:
-    import curses
-except ImportError:
-    curses = None
-
-
-COLOR_BLACK   = 0
-COLOR_RED     = 1
-COLOR_GREEN   = 2
-COLOR_YELLOW  = 3
-COLOR_BLUE    = 4
-COLOR_MAGENTA = 5
-COLOR_CYAN    = 6
-COLOR_WHITE   = 7
-
-A_BLINK     = 1<<0 # Blinking text
-A_BOLD      = 1<<1 # Extra bright or bold text
-A_DIM       = 1<<2 # Half bright text
-A_REVERSE   = 1<<3 # Reverse-video text
-A_STANDOUT  = 1<<4 # The best highlighting mode available
-A_UNDERLINE = 1<<5 # Underlined text
-
-
-class Style(object):
-    """
-    Store foreground color, background color and attribute (bold, underlined
-    etc.).
-    """
-    __slots__ = ("fg", "bg", "attrs")
-
-    COLORNAMES = {
-        "black": COLOR_BLACK,
-        "red": COLOR_RED,
-        "green": COLOR_GREEN,
-        "yellow": COLOR_YELLOW,
-        "blue": COLOR_BLUE,
-        "magenta": COLOR_MAGENTA,
-        "cyan": COLOR_CYAN,
-        "white": COLOR_WHITE,
-    }
-    ATTRNAMES = {
-        "blink": A_BLINK,
-        "bold": A_BOLD,
-        "dim": A_DIM,
-        "reverse": A_REVERSE,
-        "standout": A_STANDOUT,
-        "underline": A_UNDERLINE,
-    }
-
-    def __init__(self, fg, bg, attrs=0):
-        """
-        Create a ``Style`` object with ``fg`` as the foreground color,
-        ``bg`` as the background color and ``attrs`` as the attributes.
-
-        Examples:
-        >>> Style(COLOR_RED, COLOR_BLACK)
-        <Style fg=red bg=black attrs=0>
-
-        >>> Style(COLOR_YELLOW, COLOR_BLUE, A_BOLD|A_UNDERLINE)
-        <Style fg=yellow bg=blue attrs=bold|underline>
-        """
-        self.fg = fg
-        self.bg = bg
-        self.attrs = attrs
-
-    def __call__(self, *args):
-        text = Text()
-        for arg in args:
-            if isinstance(arg, Text):
-                text.extend(arg)
-            else:
-                text.append((self, arg))
-        return text
-
-    def __eq__(self, other):
-        return self.fg == other.fg and self.bg == other.bg and self.attrs == other.attrs
-
-    def __neq__(self, other):
-        return self.fg != other.fg or self.bg != other.bg or self.attrs != other.attrs
-
-    def __repr__(self):
-        color2name = ("black", "red", "green", "yellow", "blue", "magenta", "cyan", "white")
-        attrs2name = ("blink", "bold", "dim", "reverse", "standout", "underline")
-
-        return "<%s fg=%s bg=%s attrs=%s>" % (
-            self.__class__.__name__, color2name[self.fg], color2name[self.bg],
-            "|".join([attrs2name[b] for b in xrange(6) if self.attrs&(1<<b)]) or 0)
-
-    def fromstr(cls, value):
-        """
-        Create a ``Style`` object from a string. The format looks like this:
-        ``"red:black:bold|blink"``.
-        """
-        # defaults
-        fg = COLOR_WHITE
-        bg = COLOR_BLACK
-        attrs = 0
-
-        parts = value.split(":")
-        if len(parts) > 0:
-            fg = cls.COLORNAMES[parts[0].lower()]
-            if len(parts) > 1:
-                bg = cls.COLORNAMES[parts[1].lower()]
-                if len(parts) > 2:
-                    for strattr in parts[2].split("|"):
-                        attrs |= cls.ATTRNAMES[strattr.lower()]
-        return cls(fg, bg, attrs)
-    fromstr = classmethod(fromstr)
-
-    def fromenv(cls, name, default):
-        """
-        Create a ``Style`` from an environment variable named ``name``
-        (using ``default`` if the environment variable doesn't exist).
-        """
-        return cls.fromstr(os.environ.get(name, default))
-    fromenv = classmethod(fromenv)
-
-
-def switchstyle(s1, s2):
-    """
-    Return the ANSI escape sequence needed to switch from style ``s1`` to
-    style ``s2``.
-    """
-    attrmask = (A_BLINK|A_BOLD|A_UNDERLINE|A_REVERSE)
-    a1 = s1.attrs & attrmask
-    a2 = s2.attrs & attrmask
-
-    args = []
-    if s1 != s2:
-        # do we have to get rid of the bold/underline/blink bit?
-        # (can only be done by a reset)
-        # use reset when our target color is the default color
-        # (this is shorter than 37;40)
-        if (a1 & ~a2 or s2==style_default):
-            args.append("0")
-            s1 = style_default
-            a1 = 0
-
-        # now we know that old and new color have the same boldness,
-        # or the new color is bold and the old isn't,
-        # i.e. we only might have to switch bold on, not off
-        if not (a1 & A_BOLD) and (a2 & A_BOLD):
-            args.append("1")
-
-        # Fix underline
-        if not (a1 & A_UNDERLINE) and (a2 & A_UNDERLINE):
-            args.append("4")
-
-        # Fix blink
-        if not (a1 & A_BLINK) and (a2 & A_BLINK):
-            args.append("5")
-
-        # Fix reverse
-        if not (a1 & A_REVERSE) and (a2 & A_REVERSE):
-            args.append("7")
-
-        # Fix foreground color
-        if s1.fg != s2.fg:
-            args.append("3%d" % s2.fg)
-
-        # Finally fix the background color
-        if s1.bg != s2.bg:
-            args.append("4%d" % s2.bg)
-
-        if args:
-            return "\033[%sm" % ";".join(args)
-    return ""
-
-
-class Text(list):
-    """
-    A colored string. A ``Text`` object is a sequence, the sequence
-    items will be ``(style, string)`` tuples.
-    """
-
-    def __init__(self, *args):
-        list.__init__(self)
-        self.append(*args)
-
-    def __repr__(self):
-        return "%s.%s(%s)" % (
-            self.__class__.__module__, self.__class__.__name__,
-            list.__repr__(self)[1:-1])
-
-    def append(self, *args):
-        for arg in args:
-            if isinstance(arg, Text):
-                self.extend(arg)
-            elif isinstance(arg, tuple): # must be (style, string)
-                list.append(self, arg)
-            elif isinstance(arg, unicode):
-                list.append(self, (style_default, arg))
-            else:
-                list.append(self, (style_default, str(arg)))
-
-    def insert(self, index, *args):
-        self[index:index] = Text(*args)
-
-    def __add__(self, other):
-        new = Text()
-        new.append(self)
-        new.append(other)
-        return new
-
-    def __iadd__(self, other):
-        self.append(other)
-        return self
-
-    def format(self, styled=True):
-        """
-        This generator yields the strings that will make up the final
-        colorized string.
-        """
-        if styled:
-            oldstyle = style_default
-            for (style, string) in self:
-                if not isinstance(style, (int, long)):
-                    switch = switchstyle(oldstyle, style)
-                    if switch:
-                        yield switch
-                    if string:
-                        yield string
-                    oldstyle = style
-            switch = switchstyle(oldstyle, style_default)
-            if switch:
-                yield switch
-        else:
-            for (style, string) in self:
-                if not isinstance(style, (int, long)):
-                    yield string
-
-    def string(self, styled=True):
-        """
-        Return the resulting string (with escape sequences, if ``styled``
-        is true).
-        """
-        return "".join(self.format(styled))
-
-    def __str__(self):
-        """
-        Return ``self`` as a string (without ANSI escape sequences).
-        """
-        return self.string(False)
-
-    def write(self, stream, styled=True):
-        """
-        Write ``self`` to the output stream ``stream`` (with escape sequences,
-        if ``styled`` is true).
-        """
-        for part in self.format(styled):
-            stream.write(part)
-
-
-try:
-    import ipipe
-except ImportError:
-    pass
-else:
-    def xrepr_astyle_text(self, mode="default"):
-        yield (-1, True)
-        for info in self:
-            yield info
-    ipipe.xrepr.when_type(Text)(xrepr_astyle_text)
-
-
-def streamstyle(stream, styled=None):
-    """
-    If ``styled`` is ``None``, return whether ``stream`` refers to a terminal.
-    If this can't be determined (either because ``stream`` doesn't refer to a
-    real OS file, or because you're on Windows) return ``False``. If ``styled``
-    is not ``None`` ``styled`` will be returned unchanged.
-    """
-    if styled is None:
-        try:
-            styled = os.isatty(stream.fileno())
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except Exception:
-            styled = False
-    return styled
-
-
-def write(stream, styled, *texts):
-    """
-    Write ``texts`` to ``stream``.
-    """
-    text = Text(*texts)
-    text.write(stream, streamstyle(stream, styled))
-
-
-def writeln(stream, styled, *texts):
-    """
-    Write ``texts`` to ``stream`` and finish with a line feed.
-    """
-    write(stream, styled, *texts)
-    stream.write("\n")
-
-
-class Stream(object):
-    """
-    Stream wrapper that adds color output.
-    """
-    def __init__(self, stream, styled=None):
-        self.stream = stream
-        self.styled = streamstyle(stream, styled)
-
-    def write(self, *texts):
-        write(self.stream, self.styled, *texts)
-
-    def writeln(self, *texts):
-        writeln(self.stream, self.styled, *texts)
-
-    def __getattr__(self, name):
-        return getattr(self.stream, name)
-
-
-class stdout(object):
-    """
-    Stream wrapper for ``sys.stdout`` that adds color output.
-    """
-    def write(self, *texts):
-        write(sys.stdout, None, *texts)
-
-    def writeln(self, *texts):
-        writeln(sys.stdout, None, *texts)
-
-    def __getattr__(self, name):
-        return getattr(sys.stdout, name)
-stdout = stdout()
-
-
-class stderr(object):
-    """
-    Stream wrapper for ``sys.stderr`` that adds color output.
-    """
-    def write(self, *texts):
-        write(sys.stderr, None, *texts)
-
-    def writeln(self, *texts):
-        writeln(sys.stderr, None, *texts)
-
-    def __getattr__(self, name):
-        return getattr(sys.stdout, name)
-stderr = stderr()
-
-
-if curses is not None:
-    # This is probably just range(8)
-    COLOR2CURSES = [
-        COLOR_BLACK,
-        COLOR_RED,
-        COLOR_GREEN,
-        COLOR_YELLOW,
-        COLOR_BLUE,
-        COLOR_MAGENTA,
-        COLOR_CYAN,
-        COLOR_WHITE,
-    ]
-
-    A2CURSES = {
-        A_BLINK: curses.A_BLINK,
-        A_BOLD: curses.A_BOLD,
-        A_DIM: curses.A_DIM,
-        A_REVERSE: curses.A_REVERSE,
-        A_STANDOUT: curses.A_STANDOUT,
-        A_UNDERLINE: curses.A_UNDERLINE,
-    }
-
-
-# default style
-style_default = Style.fromstr("white:black")
-
-# Styles for datatypes
-style_type_none = Style.fromstr("magenta:black")
-style_type_bool = Style.fromstr("magenta:black")
-style_type_number = Style.fromstr("yellow:black")
-style_type_datetime = Style.fromstr("magenta:black")
-style_type_type = Style.fromstr("cyan:black")
-
-# Style for URLs and file/directory names
-style_url = Style.fromstr("green:black")
-style_dir = Style.fromstr("cyan:black")
-style_file = Style.fromstr("green:black")
-
-# Style for ellipsis (when an output has been shortened
-style_ellisis = Style.fromstr("red:black")
-
-# Style for displaying exceptions
-style_error = Style.fromstr("red:black")
-
-# Style for displaying non-existing attributes
-style_nodata = Style.fromstr("red:black")
diff --git a/IPython/deathrow/dtutils.py b/IPython/deathrow/dtutils.py
deleted file mode 100644
index 41e377f81ed..00000000000
--- a/IPython/deathrow/dtutils.py
+++ /dev/null
@@ -1,137 +0,0 @@
-"""Doctest-related utilities for IPython.
-
-For most common uses, all you should need to run is::
-
-  from IPython.dtutils import idoctest
-
-See the idoctest docstring below for usage details.
-"""
-
-import doctest
-import sys
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-def rundoctest(text,ns=None,eraise=False):
-    """Run a the input source as a doctest, in the caller's namespace.
-
-    :Parameters:
-      text : str
-        Source to execute.
-
-    :Keywords:
-      ns : dict (None)
-        Namespace where the code should be executed.  If not given, the
-        caller's locals and globals are used.
-      eraise : bool (False)
-        If true, immediately raise any exceptions instead of reporting them at
-        the end.  This allows you to then do interactive debugging via
-        IPython's facilities (use %debug after the fact, or with %pdb for
-        automatic activation).
-    """
-
-    name = 'interactive doctest'
-    filename = '<IPython console>'
-
-    if eraise:
-        runner = doctest.DebugRunner()
-    else:
-        runner = doctest.DocTestRunner()
-        
-    parser = doctest.DocTestParser()
-    if ns is None:
-        f = sys._getframe(1)
-        ns = f.f_globals.copy()
-        ns.update(f.f_locals)
-        
-    test = parser.get_doctest(text,ns,name,filename,0)
-    runner.run(test)
-    runner.summarize(True)
-
-       
-def idoctest(ns=None,eraise=False):
-    """Interactively prompt for input and run it as a doctest.
-
-    To finish entering input, enter two blank lines or Ctrl-D (EOF).  If you
-    use Ctrl-C, the example is aborted and all input discarded.
-
-    :Keywords:
-      ns : dict (None)
-        Namespace where the code should be executed.  If not given, the IPython
-        interactive namespace is used.
-      eraise : bool (False)
-        If true, immediately raise any exceptions instead of reporting them at
-        the end.  This allows you to then do interactive debugging via
-        IPython's facilities (use %debug after the fact, or with %pdb for
-        automatic activation).
-      end_mark : str ('--')
-        String to explicitly indicate the end of input.
-
-    """
-    
-    inlines = []
-    empty_lines = 0  # count consecutive empty lines
-    run_test = True
-
-    if ns is None:
-        ns = ip.user_ns
-
-    ip.savehist()
-    try:
-        while True:
-            line = raw_input()
-            if not line or line.isspace():
-                empty_lines += 1
-            else:
-                empty_lines = 0
-
-            if empty_lines>=2:
-                break
-
-            inlines.append(line)
-    except EOFError:
-        pass
-    except KeyboardInterrupt:
-        print "KeyboardInterrupt - Discarding input."
-        run_test = False
-    
-    ip.reloadhist()
-
-    if run_test:
-        # Extra blank line at the end to ensure that the final docstring has a
-        # closing newline
-        inlines.append('')
-        rundoctest('\n'.join(inlines),ns,eraise)
-
-
-# For debugging of this module itself.
-if __name__ == "__main__":
-    t = """
-    >>> for i in range(10):
-    ...     print i,
-    ...
-    0 1 2 3 4 5 6 7 8 9
-    """
-
-    t2 = """
-        A simple example::
-
-          >>> for i in range(10):
-          ...     print i,
-          ...
-          0 1 2 3 4 5 6 7 8 9
-
-        Some more details::
-
-          >>> print "hello"
-          hello
-    """
-
-    t3 = """
-        A failing example::
-
-          >>> x=1
-          >>> x+1
-          3
-    """
diff --git a/IPython/deathrow/gui/__init__.py b/IPython/deathrow/gui/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/deathrow/gui/wx/__init__.py b/IPython/deathrow/gui/wx/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/deathrow/gui/wx/ipshell_nonblocking.py b/IPython/deathrow/gui/wx/ipshell_nonblocking.py
deleted file mode 100755
index 8644ade4df3..00000000000
--- a/IPython/deathrow/gui/wx/ipshell_nonblocking.py
+++ /dev/null
@@ -1,518 +0,0 @@
-#!/usr/bin/python
-# -*- coding: iso-8859-15 -*-
-'''
-Provides IPython remote instance.
-
-@author: Laurent Dufrechou
-laurent.dufrechou _at_ gmail.com
-@license: BSD
-
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the BSD which accompanies this distribution, and
-is available at U{http://www.opensource.org/licenses/bsd-license.php}
-'''
-
-__version__ = 0.9
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-
-import re
-import sys
-import os
-import locale
-from thread_ex import ThreadEx
-
-from IPython.core import iplib
-import IPython.utils.io
-
-##############################################################################
-class _Helper(object):
-    """Redefine the built-in 'help'.
-    This is a wrapper around pydoc.help (with a twist).
-    """
-
-    def __init__(self, pager):
-        self._pager = pager
-
-    def __repr__(self):
-        return "Type help() for interactive help, " \
-               "or help(object) for help about object."
-    
-    def __call__(self, *args, **kwds):
-        class DummyWriter(object):
-            '''Dumy class to handle help output'''      
-            def __init__(self, pager):
-                self._pager = pager
-                
-            def write(self, data):
-                '''hook to fill self._pager'''
-                self._pager(data)
-
-        import pydoc
-        pydoc.help.output = DummyWriter(self._pager)
-        pydoc.help.interact = lambda :1
-        
-        return pydoc.help(*args, **kwds)
-
-  
-##############################################################################
-class _CodeExecutor(ThreadEx):
-    ''' Thread that execute ipython code '''
-    def __init__(self, instance):
-        ThreadEx.__init__(self)
-        self.instance = instance
-        
-    def run(self):
-        '''Thread main loop'''
-        try:
-            self.instance._doc_text = None
-            self.instance._help_text = None
-            self.instance._execute()
-            # used for uper class to generate event after execution
-            self.instance._after_execute() 
-            
-        except KeyboardInterrupt:
-            pass
- 
-
-##############################################################################
-class NonBlockingIPShell(object):
-    '''
-    Create an IPython instance, running the commands in a separate,
-    non-blocking thread. 
-    This allows embedding in any GUI without blockage.
-
-    Note: The ThreadEx class supports asynchroneous function call
-          via raise_exc()
-    '''
-
-    def __init__(self, user_ns={}, user_global_ns=None,
-                 cin=None, cout=None, cerr=None,
-                 ask_exit_handler=None):
-        '''
-        @param user_ns: User namespace.
-        @type user_ns: dictionary
-        @param user_global_ns: User global namespace.
-        @type user_global_ns: dictionary.
-        @param cin: Console standard input.
-        @type cin: IO stream
-        @param cout: Console standard output.
-        @type cout: IO stream
-        @param cerr: Console standard error.
-        @type cerr: IO stream
-        @param exit_handler: Replacement for builtin exit() function
-        @type exit_handler: function
-        @param time_loop: Define the sleep time between two thread's loop
-        @type int
-        '''
-        #ipython0 initialisation
-        self._IP = None
-        self.init_ipython0(user_ns, user_global_ns,
-                           cin, cout, cerr,
-                           ask_exit_handler)
-        
-        #vars used by _execute
-        self._iter_more = 0
-        self._history_level = 0
-        self._complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
-        self._prompt = str(self._IP.outputcache.prompt1).strip()
-
-        #thread working vars
-        self._line_to_execute = ''
-        self._threading = True
-        
-        #vars that will be checked by GUI loop to handle thread states...
-        #will be replaced later by PostEvent GUI funtions...
-        self._doc_text = None
-        self._help_text = None
-        self._add_button = None
-
-    def init_ipython0(self, user_ns={}, user_global_ns=None,
-                     cin=None, cout=None, cerr=None,
-                     ask_exit_handler=None):
-        ''' Initialize an ipython0 instance '''
-        
-        #first we redefine in/out/error functions of IPython
-        #BUG: we've got a limitation form ipython0 there
-        #only one instance can be instanciated else tehre will be
-        #cin/cout/cerr clash...
-        if cin:
-            Term.cin = cin
-        if cout:
-            Term.cout = cout
-        if cerr:
-            Term.cerr = cerr
-        
-        excepthook = sys.excepthook
-
-        #Hack to save sys.displayhook, because ipython seems to overwrite it...
-        self.sys_displayhook_ori = sys.displayhook
-        ipython0 = iplib.InteractiveShell(
-            parent=None, config=None,
-            user_ns=user_ns,
-            user_global_ns=user_global_ns
-        )
-        self._IP = ipython0
-
-        #we save ipython0 displayhook and we restore sys.displayhook
-        self.displayhook = sys.displayhook
-        sys.displayhook = self.sys_displayhook_ori
-
-        #we replace IPython default encoding by wx locale encoding
-        loc = locale.getpreferredencoding()
-        if loc:
-            self._IP.stdin_encoding = loc
-        #we replace the ipython default pager by our pager
-        self._IP.set_hook('show_in_pager', self._pager)
-        
-        #we replace the ipython default shell command caller 
-        #by our shell handler
-        self._IP.set_hook('shell_hook', self._shell)
-        
-        #we replace the ipython default input command caller by our method
-        iplib.raw_input_original = self._raw_input_original
-        #we replace the ipython default exit command by our method
-        self._IP.exit = ask_exit_handler
-        #we replace the help command
-        self._IP.user_ns['help'] = _Helper(self._pager_help)
-
-        #we disable cpaste magic... until we found a way to use it properly.
-        def bypass_magic(self, arg):
-            print '%this magic is currently disabled.'
-        ipython0.define_magic('cpaste', bypass_magic)
-
-        import __builtin__
-        __builtin__.raw_input = self._raw_input
-        
-        sys.excepthook = excepthook
-
-    #----------------------- Thread management section ----------------------   
-    def do_execute(self, line):
-        """
-        Tell the thread to process the 'line' command
-        """
-
-        self._line_to_execute = line
-
-        if self._threading:
-            #we launch the ipython line execution in a thread to make it 
-            #interruptible with include it in self namespace to be able 
-            #to call  ce.raise_exc(KeyboardInterrupt)
-            self.ce = _CodeExecutor(self)
-            self.ce.start()
-        else:
-            try:
-                self._doc_text = None
-                self._help_text = None
-                self._execute()
-                # used for uper class to generate event after execution
-                self._after_execute() 
-            
-            except KeyboardInterrupt:
-                pass
-
-    #----------------------- IPython management section ----------------------
-    def get_threading(self):
-        """
-        Returns threading status, is set to True, then each command sent to
-        the interpreter will be executed in a separated thread allowing,
-        for example, breaking a long running commands.
-        Disallowing it, permits better compatibilty with instance that is embedding
-        IPython instance.
-
-        @return: Execution method
-        @rtype: bool
-        """
-        return self._threading
-    
-    def set_threading(self, state):
-        """
-        Sets threading state, if set to True, then each command sent to
-        the interpreter will be executed in a separated thread allowing,
-        for example, breaking a long running commands.
-        Disallowing it, permits better compatibilty with instance that is embedding
-        IPython instance.
-
-        @param state: Sets threading state
-        @type bool
-        """
-        self._threading = state
-
-    def get_doc_text(self):
-        """
-        Returns the output of the processing that need to be paged (if any)
-
-        @return: The std output string.
-        @rtype: string
-        """
-        return self._doc_text
-        
-    def get_help_text(self):
-        """
-        Returns the output of the processing that need to be paged via help pager(if any)
-
-        @return: The std output string.
-        @rtype: string
-        """
-        return self._help_text
-
-    def get_banner(self):
-        """
-        Returns the IPython banner for useful info on IPython instance
-
-        @return: The banner string.
-        @rtype: string
-        """
-        return self._IP.banner
-    
-    def get_prompt_count(self):
-        """
-        Returns the prompt number.
-        Each time a user execute a line in the IPython shell the prompt count is increased
-
-        @return: The prompt number
-        @rtype: int
-        """
-        return self._IP.outputcache.prompt_count
-
-    def get_prompt(self):
-        """
-        Returns current prompt inside IPython instance
-        (Can be In [...]: ot ...:)
-
-        @return: The current prompt.
-        @rtype: string
-        """
-        return self._prompt
-
-    def get_indentation(self):
-        """
-        Returns the current indentation level
-        Usefull to put the caret at the good start position if we want to do autoindentation.
-
-        @return: The indentation level.
-        @rtype: int
-        """
-        return self._IP.indent_current_nsp
-        
-    def update_namespace(self, ns_dict):
-        '''
-        Add the current dictionary to the shell namespace.
-
-        @param ns_dict: A dictionary of symbol-values.
-        @type ns_dict: dictionary
-        '''
-        self._IP.user_ns.update(ns_dict)
-
-    def complete(self, line):
-        '''
-        Returns an auto completed line and/or posibilities for completion.
-
-        @param line: Given line so far.
-        @type line: string
-
-        @return: Line completed as for as possible,
-        and possible further completions.
-        @rtype: tuple
-        '''
-        split_line = self._complete_sep.split(line)
-        possibilities = self._IP.complete(split_line[-1])
-        if possibilities:
-
-            def _common_prefix(str1, str2):
-                '''
-                Reduction function. returns common prefix of two given strings.
-
-                @param str1: First string.
-                @type str1: string
-                @param str2: Second string
-                @type str2: string
-
-                @return: Common prefix to both strings.
-                @rtype: string
-                '''
-                for i in range(len(str1)):
-                    if not str2.startswith(str1[:i+1]):
-                        return str1[:i]
-                return str1
-            common_prefix = reduce(_common_prefix, possibilities)
-            completed = line[:-len(split_line[-1])]+common_prefix
-        else:
-            completed = line
-        return completed, possibilities
-
-    def history_back(self):
-        '''
-        Provides one history command back.
-
-        @return: The command string.
-        @rtype: string
-        '''
-        history = ''
-        #the below while loop is used to suppress empty history lines
-        while((history == '' or history == '\n') and self._history_level >0):
-            if self._history_level >= 1:
-                self._history_level -= 1
-            history = self._get_history()            
-        return history
-
-    def history_forward(self):
-        '''
-        Provides one history command forward.
-
-        @return: The command string.
-        @rtype: string
-        '''
-        history = ''
-        #the below while loop is used to suppress empty history lines
-        while((history == '' or history == '\n') \
-        and self._history_level <= self._get_history_max_index()):
-            if self._history_level < self._get_history_max_index():
-                self._history_level += 1
-                history = self._get_history()
-            else:
-                if self._history_level == self._get_history_max_index():
-                    history = self._get_history()
-                    self._history_level += 1
-                else:
-                    history = ''
-        return history
-
-    def init_history_index(self):
-        '''
-        set history to last command entered
-        '''
-        self._history_level = self._get_history_max_index()+1
-
-    #----------------------- IPython PRIVATE management section --------------
-    def _after_execute(self):
-        '''
-        Can be redefined to generate post event after excution is done
-        '''
-        pass
-
-    def _ask_exit(self):
-        '''
-        Can be redefined to generate post event to exit the Ipython shell
-        '''
-        pass
-
-    def _get_history_max_index(self):
-        '''
-        returns the max length of the history buffer
-
-        @return: history length
-        @rtype: int
-        '''
-        return len(self._IP.input_hist_raw)-1
-        
-    def _get_history(self):
-        '''
-        Get's the command string of the current history level.
-
-        @return: Historic command stri
-        @rtype: string
-        '''
-        rv = self._IP.input_hist_raw[self._history_level].strip('\n')
-        return rv
-
-    def _pager_help(self, text):
-        '''
-        This function is used as a callback replacment to IPython help pager function
-
-        It puts the 'text' value inside the self._help_text string that can be retrived via
-        get_help_text function.
-        '''
-        if self._help_text == None:
-            self._help_text = text
-        else:
-            self._help_text += text
-    
-    def _pager(self, IP, text):
-        '''
-        This function is used as a callback replacment to IPython pager function
-
-        It puts the 'text' value inside the self._doc_text string that can be retrived via
-        get_doc_text function.
-        '''
-        self._doc_text = text
-    
-    def _raw_input_original(self, prompt=''):
-        '''
-        Custom raw_input() replacement. Get's current line from console buffer.
-
-        @param prompt: Prompt to print. Here for compatability as replacement.
-        @type prompt: string
-
-        @return: The current command line text.
-        @rtype: string
-        '''
-        return self._line_to_execute
-
-    def _raw_input(self, prompt=''):
-        """ A replacement from python's raw_input.
-        """
-        raise NotImplementedError
-    
-    def _execute(self):
-        '''
-        Executes the current line provided by the shell object.
-        '''
-
-        orig_stdout = sys.stdout
-        sys.stdout = Term.cout
-        #self.sys_displayhook_ori = sys.displayhook
-        #sys.displayhook = self.displayhook
-        
-        try:
-            line = self._IP.raw_input(None, self._iter_more)
-            if self._IP.autoindent:
-                self._IP.readline_startup_hook(None)
-
-        except KeyboardInterrupt:
-            self._IP.write('\nKeyboardInterrupt\n')
-            self._IP.resetbuffer()
-            # keep cache in sync with the prompt counter:
-            self._IP.outputcache.prompt_count -= 1
-
-            if self._IP.autoindent:
-                self._IP.indent_current_nsp = 0
-            self._iter_more = 0
-        except:
-            self._IP.showtraceback()
-        else:
-            self._IP.write(str(self._IP.outputcache.prompt_out).strip())
-            self._iter_more = self._IP.push_line(line)
-            if (self._IP.SyntaxTB.last_syntax_error and \
-                                                            self._IP.autoedit_syntax):
-                self._IP.edit_syntax_error()
-        if self._iter_more:
-            self._prompt = str(self._IP.outputcache.prompt2).strip()
-            if self._IP.autoindent:
-                self._IP.readline_startup_hook(self._IP.pre_readline)
-        else:
-            self._prompt = str(self._IP.outputcache.prompt1).strip()
-            self._IP.indent_current_nsp = 0 #we set indentation to 0
-
-        sys.stdout = orig_stdout
-        #sys.displayhook = self.sys_displayhook_ori
-                
-    def _shell(self, ip, cmd):
-        '''
-        Replacement method to allow shell commands without them blocking.
-
-        @param ip: Ipython instance, same as self._IP
-        @type cmd: Ipython instance
-        @param cmd: Shell command to execute.
-        @type cmd: string
-        '''
-        stdin, stdout = os.popen4(cmd)
-        result = stdout.read().decode('cp437').\
-                                            encode(locale.getpreferredencoding())
-        #we use print command because the shell command is called
-        #inside IPython instance and thus is redirected to thread cout
-        #"\x01\x1b[1;36m\x02" <-- add colour to the text...
-        print "\x01\x1b[1;36m\x02"+result
-        stdout.close()
-        stdin.close()
diff --git a/IPython/deathrow/gui/wx/ipython_history.py b/IPython/deathrow/gui/wx/ipython_history.py
deleted file mode 100644
index 2e88ef0a0d2..00000000000
--- a/IPython/deathrow/gui/wx/ipython_history.py
+++ /dev/null
@@ -1,510 +0,0 @@
-#!/usr/bin/python
-# -*- coding: iso-8859-15 -*-
-import wx
-import wx.stc  as  stc
-import keyword
-
-#-----------------------------------------
-# History widget for IPython
-__version__ = 0.5
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-#-----------------------------------------
-
-class IPythonHistoryPanel(wx.Panel):
-
-    def __init__(self, parent,flt_empty=True,
-                 flt_doc=True,flt_cmd=True,flt_magic=True):
-        
-        wx.Panel.__init__(self,parent,-1)
-        #text_ctrl = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE)
-        text_ctrl = PythonSTC(self, -1)
-        
-        
-        st_filt = wx.StaticText(self, -1, " Filter:")
-
-        self.filter_empty = wx.CheckBox(self, -1, "Empty commands")
-        self.filter_doc   = wx.CheckBox(self, -1, "?: Doc commands")
-        self.filter_cmd   = wx.CheckBox(self, -1, "!: Sys commands")
-        self.filter_magic = wx.CheckBox(self, -1, "%: Magic keys")
-
-        self.options={'filter_empty':{'value':'True',
-                                'checkbox':self.filter_empty, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                      'filter_doc':{'value':'True',
-                                'checkbox':self.filter_doc, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                      'filter_cmd':{'value':'True',
-                                'checkbox':self.filter_cmd, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                      'filter_magic':{'value':'True',
-                                'checkbox':self.filter_magic, \
-                                                'True':True,'False':False,
-                                'setfunc':lambda x:None},
-                     }
-        self.reloadOptions(self.options)
-
-        self.filter_empty.Bind(wx.EVT_CHECKBOX, self.evtCheckEmptyFilter)
-        self.filter_doc.Bind(wx.EVT_CHECKBOX, self.evtCheckDocFilter)
-        self.filter_cmd.Bind(wx.EVT_CHECKBOX, self.evtCheckCmdFilter)
-        self.filter_magic.Bind(wx.EVT_CHECKBOX, self.evtCheckMagicFilter)
-        
-        #self.filter_empty.SetValue(flt_empty)
-        #self.filter_doc.SetValue(flt_doc)
-        #self.filter_cmd.SetValue(flt_cmd)
-        #self.filter_magic.SetValue(flt_magic)
-        
-        sizer = wx.BoxSizer(wx.VERTICAL)
-
-        sizer.Add(text_ctrl, 1, wx.EXPAND)
-        sizer.AddMany( [(5,5),
-                        st_filt,
-                        (10,10),
-                        self.filter_empty,
-                        self.filter_doc,
-                        self.filter_cmd,
-                        self.filter_magic,
-                        (10,10),
-                        ])
-        self.SetAutoLayout(True)
-        sizer.Fit(self)
-        sizer.SetSizeHints(self)
-        self.SetSizer(sizer)
-        self.text_ctrl=text_ctrl
-        #text_ctrl.SetText(demoText + open('Main.py').read())
-        text_ctrl.EmptyUndoBuffer()
-        text_ctrl.Colourise(0, -1)
-
-        # line numbers in the margin
-        text_ctrl.SetMarginType(1, stc.STC_MARGIN_NUMBER)
-        text_ctrl.SetMarginWidth(1, 15)
-
-        
-    def write(self,history_line):
-        add = True
-        if self.filter_empty.GetValue() == True and history_line == '':
-            add = False
-        if len(history_line)>0:
-            if self.filter_doc.GetValue() == True and history_line[-1:] == '?':
-                add = False
-            if self.filter_cmd.GetValue() == True and history_line[0] == '!':
-                add = False
-            if self.filter_magic.GetValue() == True and history_line[0] == '%':
-                add = False
-        if add:
-                self.text_ctrl.AppendText(history_line+'\n')
-
-#------------------------ Option Section -----------------------------------
-    def processOptionCheckedEvt(self, event, name):
-        if event.IsChecked():
-            self.options[name]['value']='True'
-        else:
-            self.options[name]['value']='False'
-        self.updateOptionTracker(name,
-                                 self.options[name]['value'])
-        
-    def evtCheckEmptyFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_empty')
-        
-    def evtCheckDocFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_doc')
-
-    def evtCheckCmdFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_cmd')
-
-    def evtCheckMagicFilter(self, event):
-        self.processOptionCheckedEvt(event, 'filter_magic')
-        
-    def getOptions(self):
-        return self.options
-    
-    def reloadOptions(self,options):
-        self.options = options
-        for key in self.options.keys():
-            value = self.options[key]['value']
-            self.options[key]['checkbox'].SetValue(self.options[key][value])
-            self.options[key]['setfunc'](value)
-
-#------------------------ Hook Section -----------------------------------
-    def updateOptionTracker(self,name,value):
-        '''
-        Default history tracker (does nothing)
-        '''
-        pass
-    
-    def setOptionTrackerHook(self,func):
-        '''
-        Define a new history tracker
-        '''
-        self.updateOptionTracker = func
-
-            
-#----------------------------------------------------------------------
-# Font definition for Styled Text Control
-
-if wx.Platform == '__WXMSW__':
-    faces = { 'times': 'Times New Roman',
-              'mono' : 'Courier New',
-              'helv' : 'Arial',
-              'other': 'Comic Sans MS',
-              'size' : 8,
-              'size2': 6,
-             }
-elif wx.Platform == '__WXMAC__':
-    faces = { 'times': 'Times New Roman',
-              'mono' : 'Monaco',
-              'helv' : 'Arial',
-              'other': 'Comic Sans MS',
-              'size' : 8,
-              'size2': 6,
-             }
-else:
-    faces = { 'times': 'Times',
-              'mono' : 'Courier',
-              'helv' : 'Helvetica',
-              'other': 'new century schoolbook',
-              'size' : 8,
-              'size2': 6,
-             }
-
-
-#----------------------------------------------------------------------
-
-class PythonSTC(stc.StyledTextCtrl):
-
-    fold_symbols = 3
-    
-    def __init__(self, parent, ID,
-                 pos=wx.DefaultPosition, size=wx.DefaultSize,
-                 style=0):
-        stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
-        #self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
-        #self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
-
-        self.SetLexer(stc.STC_LEX_PYTHON)
-        self.SetKeyWords(0, " ".join(keyword.kwlist))
-
-        #self.SetProperty("fold", "1")
-        #self.SetProperty("tab.timmy.whinge.level", "1")
-        #self.SetMargins(0,0)
-
-        #self.SetViewWhiteSpace(False)
-        #self.SetBufferedDraw(False)
-        #self.SetViewEOL(True)
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        #self.SetUseAntiAliasing(True)
-        
-        self.SetEdgeMode(stc.STC_EDGE_LINE)
-        self.SetEdgeColumn(80)
-        self.SetEdgeColour(wx.LIGHT_GREY)
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-
-        # Setup a margin to hold fold markers
-        #self.SetFoldFlags(16)  
-        ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?
-        self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
-        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
-        self.SetMarginSensitive(2, True)
-        self.SetMarginWidth(2, 12)
-
-        if self.fold_symbols == 0:
-            # Arrow pointing right for contracted folders, 
-            # arrow pointing down for expanded
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
-                                        stc.STC_MARK_ARROWDOWN, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
-                                        stc.STC_MARK_ARROW, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_EMPTY, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_EMPTY, "black", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
-                                        stc.STC_MARK_EMPTY,     "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_EMPTY,     "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_EMPTY,     "white", "black")
-            
-        elif self.fold_symbols == 1:
-            # Plus for contracted folders, minus for expanded
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
-                                        stc.STC_MARK_MINUS, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
-                                        stc.STC_MARK_PLUS,  "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_EMPTY, "white", "black")
-
-        elif self.fold_symbols == 2:
-            # Like a flattened tree control using circular headers and curved joins
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,  \
-                                        stc.STC_MARK_CIRCLEMINUS, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER, \
-                                        stc.STC_MARK_CIRCLEPLUS, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_VLINE, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_LCORNERCURVE, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, \
-                                        stc.STC_MARK_CIRCLEPLUSCONNECTED, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_TCORNERCURVE, "white", "#404040")
-
-        elif self.fold_symbols == 3:
-            # Like a flattened tree control using square headers
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
-                                        stc.STC_MARK_BOXMINUS, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDER,  \
-                                        stc.STC_MARK_BOXPLUS, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, \
-                                        stc.STC_MARK_VLINE, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, \
-                                        stc.STC_MARK_LCORNER, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,  \
-                                        stc.STC_MARK_BOXPLUSCONNECTED, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, \
-                                        stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
-            self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
-                                        stc.STC_MARK_TCORNER,           "white", "#808080")
-
-
-        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
-        self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)
-        self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)
-
-        # Make some styles,  The lexer defines what each style is used for, we
-        # just have to define what each style looks like.  This set is adapted from
-        # Scintilla sample property files.
-
-        # Global default styles for all languages
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
-        self.StyleClearAll()  # Reset all to be like the default
-
-        # Global default styles for all languages
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,     "face:%(helv)s,size:%(size)d" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,  "back:#C0C0C0,face:%(helv)s,size:%(size2)d" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, "face:%(other)s" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  "fore:#FFFFFF,back:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")
-
-        # Python styles
-        # Default 
-        self.StyleSetSpec(stc.STC_P_DEFAULT, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
-        # Comments
-        self.StyleSetSpec(stc.STC_P_COMMENTLINE, "fore:#007F00,face:%(other)s,size:%(size)d" % faces)
-        # Number
-        self.StyleSetSpec(stc.STC_P_NUMBER, "fore:#007F7F,size:%(size)d" % faces)
-        # String
-        self.StyleSetSpec(stc.STC_P_STRING, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
-        # Single quoted string
-        self.StyleSetSpec(stc.STC_P_CHARACTER, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
-        # Keyword
-        self.StyleSetSpec(stc.STC_P_WORD, "fore:#00007F,bold,size:%(size)d" % faces)
-        # Triple quotes
-        self.StyleSetSpec(stc.STC_P_TRIPLE, "fore:#7F0000,size:%(size)d" % faces)
-        # Triple double quotes
-        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, "fore:#7F0000,size:%(size)d" % faces)
-        # Class name definition
-        self.StyleSetSpec(stc.STC_P_CLASSNAME, "fore:#0000FF,bold,underline,size:%(size)d" % faces)
-        # Function or method name definition
-        self.StyleSetSpec(stc.STC_P_DEFNAME, "fore:#007F7F,bold,size:%(size)d" % faces)
-        # Operators
-        self.StyleSetSpec(stc.STC_P_OPERATOR, "bold,size:%(size)d" % faces)
-        # Identifiers
-        self.StyleSetSpec(stc.STC_P_IDENTIFIER, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
-        # Comment-blocks
-        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, "fore:#7F7F7F,size:%(size)d" % faces)
-        # End of line where string is not closed
-        self.StyleSetSpec(stc.STC_P_STRINGEOL, "fore:#000000,face:%(mono)s,back:#E0C0E0,eol,size:%(size)d" % faces)
-
-        self.SetCaretForeground("BLUE")
-
-
-        # register some images for use in the AutoComplete box.
-        #self.RegisterImage(1, images.getSmilesBitmap())
-        #self.RegisterImage(2, 
-        #    wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))
-        #self.RegisterImage(3, 
-        #    wx.ArtProvider.GetBitmap(wx.ART_COPY, size=(16,16)))
-
-
-    def OnKeyPressed(self, event):
-        if self.CallTipActive():
-            self.CallTipCancel()
-        key = event.GetKeyCode()
-
-        if key == 32 and event.ControlDown():
-            pos = self.GetCurrentPos()
-
-            # Tips
-            if event.ShiftDown():
-                self.CallTipSetBackground("yellow")
-                self.CallTipShow(pos, 'lots of of text: blah, blah, blah\n\n'
-                                 'show some suff, maybe parameters..\n\n'
-                                 'fubar(param1, param2)')
-            # Code completion
-            else:
-                #lst = []
-                #for x in range(50000):
-                #    lst.append('%05d' % x)
-                #st = " ".join(lst)
-                #print len(st)
-                #self.AutoCompShow(0, st)
-
-                kw = keyword.kwlist[:]
-                
-                kw.sort()  # Python sorts are case sensitive
-                self.AutoCompSetIgnoreCase(False)  # so this needs to match
-
-                # Images are specified with a appended "?type"
-                for i in range(len(kw)):
-                    if kw[i] in keyword.kwlist:
-                        kw[i] = kw[i]# + "?1"
-
-                self.AutoCompShow(0, " ".join(kw))
-        else:
-            event.Skip()
-
-
-    def OnUpdateUI(self, evt):
-        # check for matching braces
-        braceAtCaret = -1
-        braceOpposite = -1
-        charBefore = None
-        caretPos = self.GetCurrentPos()
-
-        if caretPos > 0:
-            charBefore = self.GetCharAt(caretPos - 1)
-            styleBefore = self.GetStyleAt(caretPos - 1)
-
-        # check before
-        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
-            braceAtCaret = caretPos - 1
-
-        # check after
-        if braceAtCaret < 0:
-            charAfter = self.GetCharAt(caretPos)
-            styleAfter = self.GetStyleAt(caretPos)
-            
-            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
-                braceAtCaret = caretPos
-
-        if braceAtCaret >= 0:
-            braceOpposite = self.BraceMatch(braceAtCaret)
-
-        if braceAtCaret != -1  and braceOpposite == -1:
-            self.BraceBadLight(braceAtCaret)
-        else:
-            self.BraceHighlight(braceAtCaret, braceOpposite)
-            #pt = self.PointFromPosition(braceOpposite)
-            #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
-            #print pt
-            #self.Refresh(False)
-
-
-    def OnMarginClick(self, evt):
-        # fold and unfold as needed
-        if evt.GetMargin() == 2:
-            if evt.GetShift() and evt.GetControl():
-                self.FoldAll()
-            else:
-                lineClicked = self.LineFromPosition(evt.GetPosition())
-
-                if self.GetFoldLevel(lineClicked) & stc.STC_FOLDLEVELHEADERFLAG:
-                    if evt.GetShift():
-                        self.SetFoldExpanded(lineClicked, True)
-                        self.Expand(lineClicked, True, True, 1)
-                    elif evt.GetControl():
-                        if self.GetFoldExpanded(lineClicked):
-                            self.SetFoldExpanded(lineClicked, False)
-                            self.Expand(lineClicked, False, True, 0)
-                        else:
-                            self.SetFoldExpanded(lineClicked, True)
-                            self.Expand(lineClicked, True, True, 100)
-                    else:
-                        self.ToggleFold(lineClicked)
-
-
-    def FoldAll(self):
-        lineCount = self.GetLineCount()
-        expanding = True
-
-        # find out if we are folding or unfolding
-        for lineNum in range(lineCount):
-            if self.GetFoldLevel(lineNum) & stc.STC_FOLDLEVELHEADERFLAG:
-                expanding = not self.GetFoldExpanded(lineNum)
-                break
-
-        lineNum = 0
-
-        while lineNum < lineCount:
-            level = self.GetFoldLevel(lineNum)
-            if level & stc.STC_FOLDLEVELHEADERFLAG and \
-               (level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:
-
-                if expanding:
-                    self.SetFoldExpanded(lineNum, True)
-                    lineNum = self.Expand(lineNum, True)
-                    lineNum = lineNum - 1
-                else:
-                    lastChild = self.GetLastChild(lineNum, -1)
-                    self.SetFoldExpanded(lineNum, False)
-
-                    if lastChild > lineNum:
-                        self.HideLines(lineNum+1, lastChild)
-
-            lineNum = lineNum + 1
-
-
-
-    def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):
-        lastChild = self.GetLastChild(line, level)
-        line = line + 1
-
-        while line <= lastChild:
-            if force:
-                if visLevels > 0:
-                    self.ShowLines(line, line)
-                else:
-                    self.HideLines(line, line)
-            else:
-                if doExpand:
-                    self.ShowLines(line, line)
-
-            if level == -1:
-                level = self.GetFoldLevel(line)
-
-            if level & stc.STC_FOLDLEVELHEADERFLAG:
-                if force:
-                    if visLevels > 1:
-                        self.SetFoldExpanded(line, True)
-                    else:
-                        self.SetFoldExpanded(line, False)
-
-                    line = self.Expand(line, doExpand, force, visLevels-1)
-
-                else:
-                    if doExpand and self.GetFoldExpanded(line):
-                        line = self.Expand(line, True, force, visLevels-1)
-                    else:
-                        line = self.Expand(line, False, force, visLevels-1)
-            else:
-                line = line + 1
-
-        return line
-
-
-#----------------------------------------------------------------------
diff --git a/IPython/deathrow/gui/wx/ipython_view.py b/IPython/deathrow/gui/wx/ipython_view.py
deleted file mode 100644
index 2fc44c308c7..00000000000
--- a/IPython/deathrow/gui/wx/ipython_view.py
+++ /dev/null
@@ -1,942 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-'''
-Provides IPython WX console widgets.
-
-@author: Laurent Dufrechou
-laurent.dufrechou _at_ gmail.com
-This WX widget is based on the original work of Eitan Isaacson
-that provided the console for the GTK toolkit.
-
-Original work from:
-@author: Eitan Isaacson
-@organization: IBM Corporation
-@copyright: Copyright (c) 2007 IBM Corporation
-@license: BSD
-
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the BSD which accompanies this distribution, and
-is available at U{http://www.opensource.org/licenses/bsd-license.php}
-'''
-
-__version__ = 0.9
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-
-import wx
-import wx.stc  as  stc
-
-import re
-from StringIO import StringIO
-
-import sys
-import codecs
-import locale
-import time
-
-for enc in (locale.getpreferredencoding(),
-            sys.getfilesystemencoding(),
-            sys.getdefaultencoding()):
-    try:
-        codecs.lookup(enc)
-        ENCODING = enc
-        break
-    except LookupError:
-        pass
-else:
-    ENCODING = 'utf-8'
-
-from ipshell_nonblocking import NonBlockingIPShell
-
-class WxNonBlockingIPShell(NonBlockingIPShell):
-    '''
-    An NonBlockingIPShell Thread that is WX dependent.
-    '''
-    def __init__(self, parent, 
-                 argv=[],user_ns={},user_global_ns=None,
-                 cin=None, cout=None, cerr=None,
-                 ask_exit_handler=None):
-        
-        NonBlockingIPShell.__init__(self, argv, user_ns, user_global_ns,
-                                    cin, cout, cerr,
-                                    ask_exit_handler)
-
-        self.parent = parent
-
-        self.ask_exit_callback = ask_exit_handler
-        self._IP.exit = self._ask_exit
-
-    def addGUIShortcut(self, text, func):
-        wx.CallAfter(self.parent.add_button_handler, 
-                button_info={   'text':text, 
-                                'func':self.parent.doExecuteLine(func)})
-
-    def _raw_input(self, prompt=''):
-        """ A replacement from python's raw_input.
-        """
-        self.answer = None
-        if(self._threading == True):                    
-                        wx.CallAfter(self._yesNoBox,  prompt)
-                        while self.answer is None:
-                                time.sleep(.1)
-        else:
-                        self._yesNoBox(prompt)
-        return self.answer
-        
-    def _yesNoBox(self, prompt):
-        """ yes/no box managed with wx.CallAfter jsut in case caler is executed in a thread"""
-        dlg = wx.TextEntryDialog(
-                self.parent, prompt,
-                'Input requested', 'Python')
-        dlg.SetValue("")
-
-        answer = ''
-        if dlg.ShowModal() == wx.ID_OK:
-            answer = dlg.GetValue()
-        
-        dlg.Destroy()
-        self.answer = answer
-        
-    def _ask_exit(self):
-        wx.CallAfter(self.ask_exit_callback, ())
-
-    def _after_execute(self):
-        wx.CallAfter(self.parent.evtStateExecuteDone, ())
-
-                
-class WxConsoleView(stc.StyledTextCtrl):
-    '''
-    Specialized styled text control view for console-like workflow.
-    We use here a scintilla frontend thus it can be reused in any GUI that 
-    supports scintilla with less work.
-
-    @cvar ANSI_COLORS_BLACK: Mapping of terminal colors to X11 names.
-                    (with Black background)
-    @type ANSI_COLORS_BLACK: dictionary
-
-    @cvar ANSI_COLORS_WHITE: Mapping of terminal colors to X11 names.
-                    (with White background)
-    @type ANSI_COLORS_WHITE: dictionary
-
-    @ivar color_pat: Regex of terminal color pattern
-    @type color_pat: _sre.SRE_Pattern
-    '''
-    ANSI_STYLES_BLACK = {'0;30': [0, 'WHITE'],            '0;31': [1, 'RED'],
-                         '0;32': [2, 'GREEN'],            '0;33': [3, 'BROWN'],
-                         '0;34': [4, 'BLUE'],             '0;35': [5, 'PURPLE'],
-                         '0;36': [6, 'CYAN'],             '0;37': [7, 'LIGHT GREY'],
-                         '1;30': [8, 'DARK GREY'],        '1;31': [9, 'RED'],
-                         '1;32': [10, 'SEA GREEN'],       '1;33': [11, 'YELLOW'],
-                         '1;34': [12, 'LIGHT BLUE'],      '1;35': 
-                                                          [13, 'MEDIUM VIOLET RED'],
-                         '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
-
-    ANSI_STYLES_WHITE = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
-                         '0;32': [2, 'GREEN'],            '0;33': [3, 'BROWN'],
-                         '0;34': [4, 'BLUE'],             '0;35': [5, 'PURPLE'],
-                         '0;36': [6, 'CYAN'],             '0;37': [7, 'LIGHT GREY'],
-                         '1;30': [8, 'DARK GREY'],        '1;31': [9, 'RED'],
-                         '1;32': [10, 'SEA GREEN'],       '1;33': [11, 'YELLOW'],
-                         '1;34': [12, 'LIGHT BLUE'],      '1;35':
-                                                           [13, 'MEDIUM VIOLET RED'],
-                         '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
-
-    def __init__(self, parent, prompt, intro="", background_color="BLACK",
-                 pos=wx.DefaultPosition, ID = -1, size=wx.DefaultSize,
-                 style=0, autocomplete_mode = 'IPYTHON'):
-        '''
-        Initialize console view.
-
-        @param parent: Parent widget
-        @param prompt: User specified prompt
-        @type intro: string
-        @param intro: User specified startup introduction string
-        @type intro: string
-        @param background_color: Can be BLACK or WHITE
-        @type background_color: string
-        @param other: init param of styledTextControl (can be used as-is)
-        @param autocomplete_mode: Can be 'IPYTHON' or 'STC'
-            'IPYTHON' show autocompletion the ipython way
-            'STC" show it scintilla text control way
-        '''
-        stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
-
-        ####### Scintilla configuration ###################################
-        
-        # Ctrl + B or Ctrl + N can be used to zoomin/zoomout the text inside 
-        # the widget
-        self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
-        self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
-
-        #We draw a line at position 80
-        self.SetEdgeMode(stc.STC_EDGE_LINE)
-        self.SetEdgeColumn(80)
-        self.SetEdgeColour(wx.LIGHT_GREY)
-
-        #self.SetViewWhiteSpace(True)
-        #self.SetViewEOL(True)
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        #self.SetWrapMode(stc.STC_WRAP_CHAR)
-        #self.SetWrapMode(stc.STC_WRAP_WORD)
-        self.SetBufferedDraw(True)
-        #self.SetUseAntiAliasing(True)
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-        self.SetUndoCollection(False)
-        self.SetUseTabs(True)
-        self.SetIndent(4)
-        self.SetTabWidth(4)
-
-        self.EnsureCaretVisible()
-        
-        self.SetMargins(3, 3) #text is moved away from border with 3px
-        # Suppressing Scintilla margins
-        self.SetMarginWidth(0, 0)
-        self.SetMarginWidth(1, 0)
-        self.SetMarginWidth(2, 0)
-
-        self.background_color = background_color
-        self.buildStyles()
-        
-        self.indent = 0
-        self.prompt_count = 0
-        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
-        
-        self.write(intro)
-        self.setPrompt(prompt)
-        self.showPrompt()
-
-        self.autocomplete_mode = autocomplete_mode
-        
-        self.Bind(wx.EVT_KEY_DOWN, self._onKeypress)
-        
-    def buildStyles(self):
-        #we define platform specific fonts
-        if wx.Platform == '__WXMSW__':
-            faces = { 'times': 'Times New Roman',
-                      'mono' : 'Courier New',
-                      'helv' : 'Arial',
-                      'other': 'Comic Sans MS',
-                      'size' : 10,
-                      'size2': 8,
-                     }
-        elif wx.Platform == '__WXMAC__':
-            faces = { 'times': 'Times New Roman',
-                      'mono' : 'Monaco',
-                      'helv' : 'Arial',
-                      'other': 'Comic Sans MS',
-                      'size' : 10,
-                      'size2': 8,
-                     }
-        else:
-            faces = { 'times': 'Times',
-                      'mono' : 'Courier',
-                      'helv' : 'Helvetica',
-                      'other': 'new century schoolbook',
-                      'size' : 10,
-                      'size2': 8,
-                     }
-
-        # make some styles
-        if self.background_color != "BLACK":
-            self.background_color = "WHITE"
-            self.SetCaretForeground("BLACK")
-            self.ANSI_STYLES = self.ANSI_STYLES_WHITE
-        else:
-            self.SetCaretForeground("WHITE")
-            self.ANSI_STYLES = self.ANSI_STYLES_BLACK
-
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT, 
-                          "fore:%s,back:%s,size:%d,face:%s" 
-                                    % (self.ANSI_STYLES['0;30'][1],
-                          self.background_color,
-                          faces['size'], faces['mono']))
-        self.StyleClearAll()
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  
-                          "fore:#FF0000,back:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
-                          "fore:#000000,back:#FF0000,bold")
-
-        for style in self.ANSI_STYLES.values():
-            self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
-        
-        #######################################################################
-        
-    def setBackgroundColor(self, color):
-        self.background_color = color
-        self.buildStyles()
-
-    def getBackgroundColor(self, color):
-        return self.background_color
-        
-    def asyncWrite(self, text):
-        '''
-        Write given text to buffer in an asynchroneous way.
-        It is used from another thread to be able to acces the GUI.
-        @param text: Text to append
-        @type text: string
-        '''
-        try:
-            wx.MutexGuiEnter()
-                
-            #be sure not to be interrutpted before the MutexGuiLeave!
-            self.write(text)
-                
-        except KeyboardInterrupt:
-            wx.MutexGuiLeave()
-            raise KeyboardInterrupt
-        wx.MutexGuiLeave()
-        
-                
-    def write(self, text):
-        '''
-        Write given text to buffer.
-
-        @param text: Text to append.
-        @type text: string
-        '''
-        segments = self.color_pat.split(text)
-        segment = segments.pop(0)
-        self.StartStyling(self.getCurrentLineEnd(), 0xFF)
-        self.AppendText(segment)
-        
-        if segments:
-            ansi_tags = self.color_pat.findall(text)
-
-            for tag in ansi_tags:
-                i = segments.index(tag)
-                self.StartStyling(self.getCurrentLineEnd(), 0xFF)
-                self.AppendText(segments[i+1])
-
-                if tag != '0':
-                    self.SetStyling(len(segments[i+1]), self.ANSI_STYLES[tag][0])
-
-                segments.pop(i)
-                
-        self.moveCursor(self.getCurrentLineEnd())
-         
-    def getPromptLen(self):
-        '''
-        Return the length of current prompt
-        '''
-        return len(str(self.prompt_count)) + 7
-
-    def setPrompt(self, prompt):
-        self.prompt = prompt
-
-    def setIndentation(self, indentation):
-        self.indent = indentation
-        
-    def setPromptCount(self, count):
-        self.prompt_count = count
-        
-    def showPrompt(self):
-        '''
-        Prints prompt at start of line.
-
-        @param prompt: Prompt to print.
-        @type prompt: string
-        '''
-        self.write(self.prompt)
-        #now we update the position of end of prompt
-        self.current_start = self.getCurrentLineEnd()
-        
-        autoindent = self.indent*' '
-        autoindent = autoindent.replace('    ','\t')
-        self.write(autoindent)
-        
-    def changeLine(self, text):
-        '''
-        Replace currently entered command line with given text.
-
-        @param text: Text to use as replacement.
-        @type text: string
-        '''
-        self.SetSelection(self.getCurrentPromptStart(), self.getCurrentLineEnd())
-        self.ReplaceSelection(text)
-        self.moveCursor(self.getCurrentLineEnd())
-
-    def getCurrentPromptStart(self):
-        return self.current_start
-
-    def getCurrentLineStart(self):
-        return self.GotoLine(self.LineFromPosition(self.GetCurrentPos()))
-
-    def getCurrentLineEnd(self):
-        return self.GetLength()
-
-    def getCurrentLine(self):
-        '''
-        Get text in current command line.
-
-        @return: Text of current command line.
-        @rtype: string
-        '''
-        return self.GetTextRange(self.getCurrentPromptStart(),
-                                 self.getCurrentLineEnd())
-
-    def moveCursorOnNewValidKey(self):
-        #If cursor is at wrong position put it at last line...
-        if self.GetCurrentPos() < self.getCurrentPromptStart():
-            self.GotoPos(self.getCurrentPromptStart())
-        
-    def removeFromTo(self, from_pos, to_pos):
-        if from_pos < to_pos:
-            self.SetSelection(from_pos, to_pos)
-            self.DeleteBack()
-                                                          
-    def removeCurrentLine(self):
-        self.LineDelete()
-        
-    def moveCursor(self, position):
-        self.GotoPos(position)
-
-    def getCursorPos(self):
-        return self.GetCurrentPos()
-
-    def selectFromTo(self, from_pos, to_pos):
-        self.SetSelectionStart(from_pos)
-        self.SetSelectionEnd(to_pos)
-        
-    def writeHistory(self, history):
-        self.removeFromTo(self.getCurrentPromptStart(), self.getCurrentLineEnd())
-        self.changeLine(history)
-
-    def setCompletionMethod(self, completion):
-        if completion in ['IPYTHON', 'STC']:
-            self.autocomplete_mode = completion
-        else:
-            raise AttributeError
-
-    def getCompletionMethod(self, completion):
-        return self.autocomplete_mode
-        
-    def writeCompletion(self, possibilities):
-        if self.autocomplete_mode == 'IPYTHON':
-            max_len = len(max(possibilities, key=len))
-            max_symbol = ' '*max_len
-            
-            #now we check how much symbol we can put on a line...
-            test_buffer = max_symbol + ' '*4
-            
-            allowed_symbols = 80/len(test_buffer)
-            if allowed_symbols == 0:
-                allowed_symbols = 1
-            
-            pos = 1
-            buf = ''
-            for symbol in possibilities:
-                #buf += symbol+'\n'#*spaces)
-                if pos < allowed_symbols:
-                    spaces = max_len - len(symbol) + 4
-                    buf += symbol+' '*spaces
-                    pos += 1
-                else:
-                    buf += symbol+'\n'
-                    pos = 1
-            self.write(buf)
-        else:
-            possibilities.sort()  # Python sorts are case sensitive
-            self.AutoCompSetIgnoreCase(False)
-            self.AutoCompSetAutoHide(False)
-            #let compute the length ot last word
-            splitter = [' ', '(', '[', '{','=']
-            last_word = self.getCurrentLine()
-            for breaker in splitter:
-                last_word = last_word.split(breaker)[-1]
-            self.AutoCompShow(len(last_word), " ".join(possibilities))
-        
-    def _onKeypress(self, event, skip=True):
-        '''
-        Key press callback used for correcting behavior for console-like
-        interfaces. For example 'home' should go to prompt, not to begining of
-        line.
-
-        @param widget: Widget that key press accored in.
-        @type widget: gtk.Widget
-        @param event: Event object
-        @type event: gtk.gdk.Event
-
-        @return: Return True if event as been catched.
-        @rtype: boolean
-        '''
-        if not self.AutoCompActive():
-            if event.GetKeyCode() == wx.WXK_HOME:
-                if event.Modifiers == wx.MOD_NONE:
-                    self.moveCursorOnNewValidKey()
-                    self.moveCursor(self.getCurrentPromptStart())
-                    return True
-                elif event.Modifiers == wx.MOD_SHIFT:
-                    self.moveCursorOnNewValidKey()
-                    self.selectFromTo(self.getCurrentPromptStart(), self.getCursorPos())
-                    return True
-                else:
-                    return False
-
-            elif event.GetKeyCode() == wx.WXK_LEFT:
-                if event.Modifiers == wx.MOD_NONE:
-                    self.moveCursorOnNewValidKey()
-                    
-                    self.moveCursor(self.getCursorPos()-1)
-                    if self.getCursorPos() < self.getCurrentPromptStart():
-                        self.moveCursor(self.getCurrentPromptStart())
-                    return True
-
-            elif event.GetKeyCode() == wx.WXK_BACK:
-                self.moveCursorOnNewValidKey()
-                if self.getCursorPos() > self.getCurrentPromptStart():
-                    event.Skip()
-                return True
-            
-            if skip:
-                if event.GetKeyCode() not in [wx.WXK_PAGEUP, wx.WXK_PAGEDOWN]\
-                and event.Modifiers == wx.MOD_NONE:
-                    self.moveCursorOnNewValidKey()
-                    
-                event.Skip()
-                return True
-            return False
-        else:
-            event.Skip()
-            
-    def OnUpdateUI(self, evt):
-        # check for matching braces
-        braceAtCaret = -1
-        braceOpposite = -1
-        charBefore = None
-        caretPos = self.GetCurrentPos()
-
-        if caretPos > 0:
-            charBefore = self.GetCharAt(caretPos - 1)
-            styleBefore = self.GetStyleAt(caretPos - 1)
-
-        # check before
-        if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
-            braceAtCaret = caretPos - 1
-
-        # check after
-        if braceAtCaret < 0:
-            charAfter = self.GetCharAt(caretPos)
-            styleAfter = self.GetStyleAt(caretPos)
-
-            if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
-                braceAtCaret = caretPos
-
-        if braceAtCaret >= 0:
-            braceOpposite = self.BraceMatch(braceAtCaret)
-
-        if braceAtCaret != -1  and braceOpposite == -1:
-            self.BraceBadLight(braceAtCaret)
-        else:
-            self.BraceHighlight(braceAtCaret, braceOpposite)
-            #pt = self.PointFromPosition(braceOpposite)
-            #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
-            #print pt
-            #self.Refresh(False)
-        
-class IPShellWidget(wx.Panel):
-    '''
-    This is wx.Panel that embbed the IPython Thread and the wx.StyledTextControl
-    If you want to port this to any other GUI toolkit, just replace the 
-    WxConsoleView by YOURGUIConsoleView and make YOURGUIIPythonView derivate 
-    from whatever container you want. I've choosed to derivate from a wx.Panel 
-    because it seems to be more useful
-    Any idea to make it more 'generic' welcomed.
-    '''
-
-    def __init__(self, parent, intro=None,
-                 background_color="BLACK", add_button_handler=None, 
-                 wx_ip_shell=None, user_ns={},user_global_ns=None,
-                 ):
-        '''
-        Initialize.
-        Instanciate an IPython thread.
-        Instanciate a WxConsoleView.
-        Redirect I/O to console.
-        '''
-        wx.Panel.__init__(self,parent,wx.ID_ANY)
-
-        self.parent = parent
-        ### IPython non blocking shell instanciation ###
-        self.cout = StringIO()
-        self.add_button_handler = add_button_handler
-
-        if wx_ip_shell is not None:
-            self.IP = wx_ip_shell
-        else:
-            self.IP = WxNonBlockingIPShell(self,
-                                    cout = self.cout, cerr = self.cout,
-                                    ask_exit_handler = self.askExitCallback)
-
-        ### IPython wx console view instanciation ###
-        #If user didn't defined an intro text, we create one for him
-        #If you really wnat an empty intro just call wxIPythonViewPanel 
-        #with intro=''
-        if intro is None:
-            welcome_text = "Welcome to WxIPython Shell.\n\n"
-            welcome_text+= self.IP.get_banner()
-            welcome_text+= "!command  -> Execute command in shell\n"
-            welcome_text+= "TAB       -> Autocompletion\n"
-        else:
-            welcome_text = intro
-
-        self.text_ctrl = WxConsoleView(self,
-                                       self.IP.get_prompt(),
-                                       intro=welcome_text,
-                                       background_color=background_color)
-
-        option_text = wx.StaticText(self, -1, "Options:")
-        self.completion_option = wx.CheckBox(self, -1, "Scintilla Completion")
-        self.completion_option.SetToolTip(wx.ToolTip(
-            "Selects the completion type:\nEither Ipython default style or Scintilla one"))
-        #self.completion_option.SetValue(False)
-        self.background_option = wx.CheckBox(self, -1, "White Background")
-        self.background_option.SetToolTip(wx.ToolTip(
-            "Selects the back ground color: BLACK or WHITE"))
-        #self.background_option.SetValue(False)
-        self.threading_option = wx.CheckBox(self, -1, "Execute in thread")
-        self.threading_option.SetToolTip(wx.ToolTip(
-            "Use threading: infinite loop don't freeze the GUI and commands can be breaked\nNo  threading: maximum compatibility"))
-        #self.threading_option.SetValue(False)
-        
-        self.options={'completion':{'value':'IPYTHON',
-                                    'checkbox':self.completion_option,'STC':True,'IPYTHON':False,
-                                    'setfunc':self.text_ctrl.setCompletionMethod},
-                      'background_color':{'value':'BLACK',
-                                          'checkbox':self.background_option,'WHITE':True,'BLACK':False,
-                                          'setfunc':self.text_ctrl.setBackgroundColor},
-                      'threading':{'value':'True',
-                                   'checkbox':self.threading_option,'True':True,'False':False,
-                                   'setfunc':self.IP.set_threading},
-                     }
-
-        #self.cout.write dEfault option is asynchroneous because default sate is threading ON
-        self.cout.write = self.text_ctrl.asyncWrite
-        #we reloard options
-        self.reloadOptions(self.options)
-        
-        self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress)
-        self.completion_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionCompletion)
-        self.background_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionBackgroundColor)
-        self.threading_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionThreading)
-            
-        ### making the layout of the panel ###
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(self.text_ctrl, 1, wx.EXPAND)
-        option_sizer = wx.BoxSizer(wx.HORIZONTAL)
-        sizer.Add(option_sizer, 0)
-        option_sizer.AddMany([(10, 20),
-                              (option_text, 0, wx.ALIGN_CENTER_VERTICAL),
-                              (5, 5),
-                              (self.completion_option, 0, wx.ALIGN_CENTER_VERTICAL),
-                              (8, 8),
-                              (self.background_option, 0, wx.ALIGN_CENTER_VERTICAL),
-                              (8, 8),
-                              (self.threading_option, 0, wx.ALIGN_CENTER_VERTICAL)
-                              ])
-        self.SetAutoLayout(True)
-        sizer.Fit(self)
-        sizer.SetSizeHints(self)
-        self.SetSizer(sizer)
-        #and we focus on the widget :)
-        self.SetFocus()
-
-        #widget state management (for key handling different cases)
-        self.setCurrentState('IDLE')
-        self.pager_state = 'DONE'
-        self.raw_input_current_line = 0
-
-    def askExitCallback(self, event):
-        self.askExitHandler(event)
-        
-    #---------------------- IPython Thread Management ------------------------
-    def stateDoExecuteLine(self):
-        lines=self.text_ctrl.getCurrentLine()
-        self.text_ctrl.write('\n')
-        lines_to_execute = lines.replace('\t',' '*4)
-        lines_to_execute = lines_to_execute.replace('\r','')
-        self.IP.do_execute(lines_to_execute.encode(ENCODING))
-        self.updateHistoryTracker(lines)
-        if(self.text_ctrl.getCursorPos()!=0):
-            self.text_ctrl.removeCurrentLine()
-        self.setCurrentState('WAIT_END_OF_EXECUTION')
-        
-    def evtStateExecuteDone(self,evt):
-        self.doc = self.IP.get_doc_text()
-        self.help = self.IP.get_help_text()
-        if self.doc:
-            self.pager_lines = self.doc[7:].split('\n')
-            self.pager_state = 'INIT'
-            self.setCurrentState('SHOW_DOC')
-            self.pager(self.doc)
-        elif self.help:
-            self.pager_lines = self.help.split('\n')
-            self.pager_state = 'INIT'
-            self.setCurrentState('SHOW_DOC')
-            self.pager(self.help)                
-        else:
-            if(self.text_ctrl.getCursorPos()!=0):
-                self.text_ctrl.removeCurrentLine()
-            self.stateShowPrompt()
-
-    def stateShowPrompt(self):
-        self.setCurrentState('SHOW_PROMPT')
-        self.text_ctrl.setPrompt(self.IP.get_prompt())
-        self.text_ctrl.setIndentation(self.IP.get_indentation())
-        self.text_ctrl.setPromptCount(self.IP.get_prompt_count())
-        self.text_ctrl.showPrompt()
-        self.IP.init_history_index()
-        self.setCurrentState('IDLE')
-
-    def setCurrentState(self, state):
-        self.cur_state = state
-        self.updateStatusTracker(self.cur_state)
-
-    def pager(self,text):
-
-        if self.pager_state == 'INIT':
-            #print >>sys.__stdout__,"PAGER state:",self.pager_state
-            self.pager_nb_lines = len(self.pager_lines)
-            self.pager_index = 0
-            self.pager_do_remove = False
-            self.text_ctrl.write('\n')
-            self.pager_state = 'PROCESS_LINES'
-
-        if self.pager_state == 'PROCESS_LINES':
-            #print >>sys.__stdout__,"PAGER state:",self.pager_state
-            if self.pager_do_remove == True:
-                self.text_ctrl.removeCurrentLine()
-                self.pager_do_remove = False
-
-            if self.pager_nb_lines > 10:
-                #print >>sys.__stdout__,"PAGER processing 10 lines"
-                if self.pager_index > 0:
-                    self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-                else:
-                    self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-                    
-                for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
-                    self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-                self.pager_index += 10
-                self.pager_nb_lines -= 10
-                self.text_ctrl.write("--- Push Enter to continue or 'Q' to quit---")
-                self.pager_do_remove = True
-                self.pager_state = 'WAITING'
-                return
-            else:
-                #print >>sys.__stdout__,"PAGER processing last lines"
-                if self.pager_nb_lines > 0:
-                    if self.pager_index > 0:
-                        self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
-                    else:
-                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
-                            
-                    self.pager_index += 1
-                    self.pager_nb_lines -= 1
-                if self.pager_nb_lines > 0:
-                    for line in self.pager_lines[self.pager_index:]:
-                        self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
-                        self.pager_nb_lines = 0
-                self.pager_state = 'DONE'
-                self.stateShowPrompt()
-            
-    #------------------------ Key Handler ------------------------------------
-    def keyPress(self, event):
-        '''
-        Key press callback with plenty of shell goodness, like history,
-        autocompletions, etc.
-        '''
-        if event.GetKeyCode() == ord('C'):
-            if event.Modifiers == wx.MOD_CONTROL or event.Modifiers == wx.MOD_ALT:
-                if self.cur_state == 'WAIT_END_OF_EXECUTION':
-                    #we raise an exception inside the IPython thread container
-                    self.IP.ce.raise_exc(KeyboardInterrupt)
-                    return
-                
-        #let this before 'wx.WXK_RETURN' because we have to put 'IDLE'
-        #mode if AutoComp has been set as inactive
-        if self.cur_state == 'COMPLETING':
-            if not self.text_ctrl.AutoCompActive():
-                self.cur_state = 'IDLE'
-            else:
-                event.Skip()
-
-        if event.KeyCode == wx.WXK_RETURN:
-            if self.cur_state == 'IDLE':
-                #we change the state ot the state machine
-                self.setCurrentState('DO_EXECUTE_LINE')
-                self.stateDoExecuteLine()
-                return
-
-            if self.pager_state == 'WAITING':
-                self.pager_state = 'PROCESS_LINES'
-                self.pager(self.doc)
-                return
-            
-            if self.cur_state == 'WAITING_USER_INPUT':
-                line=self.text_ctrl.getCurrentLine()
-                self.text_ctrl.write('\n')
-                self.setCurrentState('WAIT_END_OF_EXECUTION')
-                return
-          
-        if event.GetKeyCode() in [ord('q'),ord('Q')]:
-            if self.pager_state == 'WAITING':
-                self.pager_state = 'DONE'
-                self.text_ctrl.write('\n')
-                self.stateShowPrompt()
-                return
-
-        if self.cur_state == 'WAITING_USER_INPUT':
-            event.Skip()   
-            
-        if self.cur_state == 'IDLE':
-            if event.KeyCode == wx.WXK_UP:
-                history = self.IP.history_back()
-                self.text_ctrl.writeHistory(history)
-                return
-            if event.KeyCode == wx.WXK_DOWN:
-                history = self.IP.history_forward()
-                self.text_ctrl.writeHistory(history)
-                return
-            if event.KeyCode == wx.WXK_TAB:
-                #if line empty we disable tab completion
-                if not self.text_ctrl.getCurrentLine().strip():
-                    self.text_ctrl.write('\t')
-                    return
-                completed, possibilities = self.IP.complete(self.text_ctrl.getCurrentLine())
-                if len(possibilities) > 1:
-                    if self.text_ctrl.autocomplete_mode == 'IPYTHON':    
-                        cur_slice = self.text_ctrl.getCurrentLine()
-                        self.text_ctrl.write('\n')
-                        self.text_ctrl.writeCompletion(possibilities)
-                        self.text_ctrl.write('\n')
-
-                        self.text_ctrl.showPrompt()
-                        self.text_ctrl.write(cur_slice)
-                        self.text_ctrl.changeLine(completed or cur_slice)
-                    else:
-                        self.cur_state = 'COMPLETING'
-                        self.text_ctrl.writeCompletion(possibilities)
-                else:
-                    self.text_ctrl.changeLine(completed or cur_slice)
-                return
-            event.Skip()
-
-    #------------------------ Option Section ---------------------------------
-    def evtCheckOptionCompletion(self, event):
-        if event.IsChecked():
-            self.options['completion']['value']='STC'
-        else:
-            self.options['completion']['value']='IPYTHON'
-        self.text_ctrl.setCompletionMethod(self.options['completion']['value'])
-        self.updateOptionTracker('completion',
-                                 self.options['completion']['value'])
-        self.text_ctrl.SetFocus()
-
-    def evtCheckOptionBackgroundColor(self, event):
-        if event.IsChecked():
-            self.options['background_color']['value']='WHITE'
-        else:
-            self.options['background_color']['value']='BLACK'
-        self.text_ctrl.setBackgroundColor(self.options['background_color']['value'])
-        self.updateOptionTracker('background_color',
-                                 self.options['background_color']['value'])
-        self.text_ctrl.SetFocus()
-
-    def evtCheckOptionThreading(self, event):
-        if event.IsChecked():
-            self.options['threading']['value']='True'
-            self.IP.set_threading(True)
-            self.cout.write = self.text_ctrl.asyncWrite
-        else:
-            self.options['threading']['value']='False'
-            self.IP.set_threading(False)
-            self.cout.write = self.text_ctrl.write
-        self.updateOptionTracker('threading',
-                                 self.options['threading']['value'])
-        self.text_ctrl.SetFocus()
-        
-    def getOptions(self):
-        return self.options
-        
-    def reloadOptions(self,options):
-        self.options = options
-        for key in self.options.keys():
-            value = self.options[key]['value']
-            self.options[key]['checkbox'].SetValue(self.options[key][value])
-            self.options[key]['setfunc'](value)
-        
-        if self.options['threading']['value']=='True':
-            self.IP.set_threading(True)
-            self.cout.write = self.text_ctrl.asyncWrite
-        else:
-            self.IP.set_threading(False)
-            self.cout.write = self.text_ctrl.write
-            
-    #------------------------ Hook Section -----------------------------------
-    def updateOptionTracker(self,name,value):
-        '''
-        Default history tracker (does nothing)
-        '''
-        pass
-    
-    def setOptionTrackerHook(self,func):
-        '''
-        Define a new history tracker
-        '''
-        self.updateOptionTracker = func
-
-    def updateHistoryTracker(self,command_line):
-        '''
-        Default history tracker (does nothing)
-        '''
-        pass
-    
-    def setHistoryTrackerHook(self,func):
-        '''
-        Define a new history tracker
-        '''
-        self.updateHistoryTracker = func
-
-    def updateStatusTracker(self,status):
-        '''
-        Default status tracker (does nothing)
-        '''
-        pass
-    
-    def setStatusTrackerHook(self,func):
-        '''
-        Define a new status tracker
-        '''
-        self.updateStatusTracker = func
-
-    def askExitHandler(self, event):
-        '''
-        Default exit handler
-        '''
-        self.text_ctrl.write('\nExit callback has not been set.')
-
-    def setAskExitHandler(self, func):
-        '''
-        Define an exit handler
-        '''
-        self.askExitHandler = func
-
-if __name__ == '__main__':
-    # Some simple code to test the shell widget.
-    class MainWindow(wx.Frame):
-        def __init__(self, parent, id, title):
-            wx.Frame.__init__(self, parent, id, title, size=(300,250))
-            self._sizer = wx.BoxSizer(wx.VERTICAL)
-            self.shell = IPShellWidget(self)
-            self._sizer.Add(self.shell, 1, wx.EXPAND)
-            self.SetSizer(self._sizer)
-            self.SetAutoLayout(1)
-            self.Show(True)
-
-    app = wx.PySimpleApp()
-    frame = MainWindow(None, wx.ID_ANY, 'Ipython')
-    frame.SetSize((780, 460))
-    shell = frame.shell
-
-    app.MainLoop()
diff --git a/IPython/deathrow/gui/wx/thread_ex.py b/IPython/deathrow/gui/wx/thread_ex.py
deleted file mode 100644
index 0af86d0396e..00000000000
--- a/IPython/deathrow/gui/wx/thread_ex.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""
-Thread subclass that can deal with asynchronously function calls via
-raise_exc.
-"""
-
-import threading
-import inspect
-import ctypes
- 
- 
-def _async_raise(tid, exctype):
-    """raises the exception, performs cleanup if needed"""
-    if not inspect.isclass(exctype):
-        raise TypeError("Only types can be raised (not instances)")
-    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
-    if res == 0:
-        raise ValueError("invalid thread id")
-    elif res != 1:
-        # """if it returns a number greater than one, you're in trouble, 
-        # and you should call it again with exc=NULL to revert the effect"""
-        ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
-        raise SystemError("PyThreadState_SetAsyncExc failed")
- 
- 
-class ThreadEx(threading.Thread):
-    def _get_my_tid(self):
-        """determines this (self's) thread id"""
-        if not self.isAlive():
-            raise threading.ThreadError("the thread is not active")
-        
-        # do we have it cached?
-        if hasattr(self, "_thread_id"):
-            return self._thread_id
-        
-        # no, look for it in the _active dict
-        for tid, tobj in threading._active.items():
-            if tobj is self:
-                self._thread_id = tid
-                return tid
-        
-        raise AssertionError("could not determine the thread's id")
-    
-    def raise_exc(self, exctype):
-        """raises the given exception type in the context of this thread"""
-        _async_raise(self._get_my_tid(), exctype)
-    
-    def kill(self):
-        """raises SystemExit in the context of the given thread, which should 
-        cause the thread to exit silently (unless caught)"""
-        self.raise_exc(SystemExit)
diff --git a/IPython/deathrow/gui/wx/wxIPython.py b/IPython/deathrow/gui/wx/wxIPython.py
deleted file mode 100644
index b5158b7b58b..00000000000
--- a/IPython/deathrow/gui/wx/wxIPython.py
+++ /dev/null
@@ -1,266 +0,0 @@
-#!/usr/bin/python
-# -*- coding: iso-8859-15 -*-
-
-import wx.aui
-import sys
-#used for about dialog
-from wx.lib.wordwrap import wordwrap
-
-#used for ipython GUI objects
-from IPython.gui.wx.ipython_view import IPShellWidget
-from IPython.gui.wx.ipython_history import IPythonHistoryPanel
-
-#used to invoke ipython1 wx implementation
-### FIXME ### temporary disabled due to interference with 'show_in_pager' hook
-is_sync_frontend_ok = False
-try:
-    from IPython.frontend.wx.ipythonx import IPythonXController
-except ImportError:
-    is_sync_frontend_ok = False
-
-#used to create options.conf file in user directory
-from IPython.core.ipapi import get
-
-__version__ = 0.91
-__author__  = "Laurent Dufrechou"
-__email__   = "laurent.dufrechou _at_ gmail.com"
-__license__ = "BSD"
-
-#-----------------------------------------
-# Creating one main frame for our 
-# application with movables windows
-#-----------------------------------------
-class MyFrame(wx.Frame):
-    """Creating one main frame for our 
-    application with movables windows"""
-    def __init__(self, parent=None, id=-1, title="WxIPython", 
-                pos=wx.DefaultPosition,
-                size=(800, 600), style=wx.DEFAULT_FRAME_STYLE, sync_ok=False):
-        wx.Frame.__init__(self, parent, id, title, pos, size, style)
-        self._mgr = wx.aui.AuiManager()
-        
-        # notify PyAUI which frame to use
-        self._mgr.SetManagedWindow(self)
-        
-        #create differents panels and make them persistant 
-        self.history_panel    = IPythonHistoryPanel(self)
-
-        self.history_panel.setOptionTrackerHook(self.optionSave)
-        
-        self.ipython_panel    = IPShellWidget(self,background_color = "BLACK")
-        #self.ipython_panel    = IPShellWidget(self,background_color = "WHITE")
-        if(sync_ok):
-            self.ipython_panel2   = IPythonXController(self)
-        else:
-            self.ipython_panel2   = None
-        self.ipython_panel.setHistoryTrackerHook(self.history_panel.write)
-        self.ipython_panel.setStatusTrackerHook(self.updateStatus)
-        self.ipython_panel.setAskExitHandler(self.OnExitDlg)
-        self.ipython_panel.setOptionTrackerHook(self.optionSave)
-
-        #Create a notebook to display different IPython shell implementations
-        self.nb = wx.aui.AuiNotebook(self)
-        
-        self.optionLoad()
-        
-        self.statusbar = self.createStatus()
-        self.createMenu()
-        
-        ########################################################################
-        ### add the panes to the manager
-        # main panels
-        self._mgr.AddPane(self.nb , wx.CENTER, "IPython Shells")
-        self.nb.AddPage(self.ipython_panel , "IPython0 Shell")
-        if(sync_ok):
-            self.nb.AddPage(self.ipython_panel2, "IPython1 Synchroneous Shell")
-
-        self._mgr.AddPane(self.history_panel , wx.RIGHT,  "IPython history")
-                
-        # now we specify some panel characteristics
-        self._mgr.GetPane(self.ipython_panel).CaptionVisible(True);
-        self._mgr.GetPane(self.history_panel).CaptionVisible(True);
-        self._mgr.GetPane(self.history_panel).MinSize((200,400));
-        
-        # tell the manager to "commit" all the changes just made
-        self._mgr.Update()
-
-        #global event handling
-        self.Bind(wx.EVT_CLOSE, self.OnClose)
-        self.Bind(wx.EVT_MENU,  self.OnClose,id=wx.ID_EXIT)
-        self.Bind(wx.EVT_MENU,  self.OnShowIPythonPanel,id=wx.ID_HIGHEST+1)
-        self.Bind(wx.EVT_MENU,  self.OnShowHistoryPanel,id=wx.ID_HIGHEST+2)
-        self.Bind(wx.EVT_MENU,  self.OnShowAbout, id=wx.ID_HIGHEST+3)
-        self.Bind(wx.EVT_MENU,  self.OnShowAllPanel,id=wx.ID_HIGHEST+6)
-        
-        warn_text = 'Hello from IPython and wxPython.\n'
-        warn_text +='Please Note that this work is still EXPERIMENTAL\n'
-        warn_text +='It does NOT emulate currently all the IPython functions.\n'
-        warn_text +="\nIf you use MATPLOTLIB with show() you'll need to deactivate the THREADING option.\n"
-        if(not sync_ok):
-            warn_text +="\n->No twisted package detected, IPython1 example deactivated."
-            
-        dlg = wx.MessageDialog(self,
-                               warn_text,
-                               'Warning Box',
-                               wx.OK | wx.ICON_INFORMATION
-                               )
-        dlg.ShowModal()
-        dlg.Destroy()
-
-    def optionSave(self, name, value):
-        ip = get()
-        path = ip.ipython_dir
-        opt = open(path + '/options.conf','w')
-
-        try:
-            options_ipython_panel = self.ipython_panel.getOptions()
-            options_history_panel = self.history_panel.getOptions()
-
-            for key in options_ipython_panel.keys():
-                opt.write(key + '=' + options_ipython_panel[key]['value']+'\n')
-            for key in options_history_panel.keys():
-                opt.write(key + '=' + options_history_panel[key]['value']+'\n')
-        finally:    
-            opt.close()
-        
-    def optionLoad(self):
-        try:
-            ip = get()
-            path = ip.ipython_dir
-            opt = open(path + '/options.conf','r')
-            lines = opt.readlines()
-            opt.close()
-                      
-            options_ipython_panel = self.ipython_panel.getOptions()
-            options_history_panel = self.history_panel.getOptions()
-            
-            for line in lines:
-                key = line.split('=')[0]
-                value = line.split('=')[1].replace('\n','').replace('\r','')
-                if key in options_ipython_panel.keys():
-                    options_ipython_panel[key]['value'] = value
-                elif key in options_history_panel.keys():
-                    options_history_panel[key]['value'] = value
-                else:
-                    print >>sys.__stdout__,"Warning: key ",key,"not found in widget options. Check Options.conf"
-            self.ipython_panel.reloadOptions(options_ipython_panel)
-            self.history_panel.reloadOptions(options_history_panel)
-        
-        except IOError:
-            print >>sys.__stdout__,"Could not open Options.conf, defaulting to default values."
-            
-        
-    def createMenu(self):
-        """local method used to create one menu bar"""
-        
-        mb = wx.MenuBar()
-
-        file_menu = wx.Menu()
-        file_menu.Append(wx.ID_EXIT, "Exit")
-        
-        view_menu = wx.Menu()
-        view_menu.Append(wx.ID_HIGHEST+1, "Show IPython Panel")
-        view_menu.Append(wx.ID_HIGHEST+2, "Show History Panel")
-        view_menu.AppendSeparator()
-        view_menu.Append(wx.ID_HIGHEST+6, "Show All")
-        
-        about_menu = wx.Menu()
-        about_menu.Append(wx.ID_HIGHEST+3, "About")
-
-        mb.Append(file_menu, "File")
-        mb.Append(view_menu, "View")
-        mb.Append(about_menu, "About")
-        #mb.Append(options_menu, "Options")
-        
-        self.SetMenuBar(mb)
-
-    def createStatus(self):
-        statusbar = self.CreateStatusBar(2, wx.ST_SIZEGRIP)
-        statusbar.SetStatusWidths([-2, -3])
-        statusbar.SetStatusText("Ready", 0)
-        statusbar.SetStatusText("WxIPython "+str(__version__), 1)
-        return statusbar
-
-    def updateStatus(self,text):
-        states = {'IDLE':'Idle',
-                  'DO_EXECUTE_LINE':'Send command',
-                  'WAIT_END_OF_EXECUTION':'Running command',
-                  'WAITING_USER_INPUT':'Waiting user input',
-                  'SHOW_DOC':'Showing doc',
-                  'SHOW_PROMPT':'Showing prompt'}
-        self.statusbar.SetStatusText(states[text], 0)
-        
-    def OnClose(self, event):
-        """#event used to close program  """
-        # deinitialize the frame manager
-        self._mgr.UnInit()
-        self.Destroy()        
-        event.Skip()
-    
-    def OnExitDlg(self, event):
-        dlg = wx.MessageDialog(self, 'Are you sure you want to quit WxIPython',
-                                'WxIPython exit',
-                                wx.ICON_QUESTION |
-                                wx.YES_NO | wx.NO_DEFAULT
-                                )
-        if dlg.ShowModal() == wx.ID_YES:
-            dlg.Destroy()
-            self._mgr.UnInit()
-            self.Destroy()
-        dlg.Destroy()
-      
-    #event to display IPython pannel      
-    def OnShowIPythonPanel(self,event):
-        """ #event to display Boxpannel """
-        self._mgr.GetPane(self.ipython_panel).Show(True)
-        self._mgr.Update()  
-    #event to display History pannel      
-    def OnShowHistoryPanel(self,event):
-        self._mgr.GetPane(self.history_panel).Show(True)
-        self._mgr.Update()  
-         
-    def OnShowAllPanel(self,event):
-        """#event to display all Pannels"""
-        self._mgr.GetPane(self.ipython_panel).Show(True)
-        self._mgr.GetPane(self.history_panel).Show(True)
-        self._mgr.Update()
-
-    def OnShowAbout(self, event):
-        # First we create and fill the info object
-        info = wx.AboutDialogInfo()
-        info.Name = "WxIPython"
-        info.Version = str(__version__)
-        info.Copyright = "(C) 2007 Laurent Dufrechou"
-        info.Description = wordwrap(
-            "A Gui that embbed a multithreaded IPython Shell",
-            350, wx.ClientDC(self))
-        info.WebSite = ("http://ipython.scipy.org/", "IPython home page")
-        info.Developers = [ "Laurent Dufrechou" ]
-        licenseText="BSD License.\nAll rights reserved. This program and the accompanying materials are made available under the terms of the BSD which accompanies this distribution, and is available at http://www.opensource.org/licenses/bsd-license.php"
-        info.License = wordwrap(licenseText, 500, wx.ClientDC(self))
-
-        # Then we call wx.AboutBox giving it that info object
-        wx.AboutBox(info) 
-        
-#-----------------------------------------
-#Creating our application
-#----------------------------------------- 
-class MyApp(wx.PySimpleApp):
-    """Creating our application"""
-    def __init__(self, sync_ok=False):
-        wx.PySimpleApp.__init__(self)
-        
-        self.frame = MyFrame(sync_ok=sync_ok)
-        self.frame.Show()
-        
-#-----------------------------------------
-#Main loop
-#----------------------------------------- 
-def main():
-    app = MyApp(is_sync_frontend_ok)
-    app.SetTopWindow(app.frame)
-    app.MainLoop()
-
-#if launched as main program run this
-if __name__ == '__main__':
-    main()
diff --git a/IPython/deathrow/ibrowse.py b/IPython/deathrow/ibrowse.py
deleted file mode 100644
index f93701220ad..00000000000
--- a/IPython/deathrow/ibrowse.py
+++ /dev/null
@@ -1,1767 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-
-import curses, fcntl, signal, struct, tty, textwrap, inspect
-
-from IPython.core import ipapi
-
-import astyle, ipipe
-
-
-# Python 2.3 compatibility
-try:
-    set
-except NameError:
-    import sets
-    set = sets.Set
-
-# Python 2.3 compatibility
-try:
-    sorted
-except NameError:
-    from ipipe import sorted
-
-
-class UnassignedKeyError(Exception):
-    """
-    Exception that is used for reporting unassigned keys.
-    """
-
-
-class UnknownCommandError(Exception):
-    """
-    Exception that is used for reporting unknown commands (this should never
-    happen).
-    """
-
-
-class CommandError(Exception):
-    """
-    Exception that is used for reporting that a command can't be executed.
-    """
-
-
-class Keymap(dict):
-    """
-    Stores mapping of keys to commands.
-    """
-    def __init__(self):
-        self._keymap = {}
-
-    def __setitem__(self, key, command):
-        if isinstance(key, str):
-            for c in key:
-                dict.__setitem__(self, ord(c), command)
-        else:
-            dict.__setitem__(self, key, command)
-
-    def __getitem__(self, key):
-        if isinstance(key, str):
-            key = ord(key)
-        return dict.__getitem__(self, key)
-
-    def __detitem__(self, key):
-        if isinstance(key, str):
-            key = ord(key)
-        dict.__detitem__(self, key)
-
-    def register(self, command, *keys):
-        for key in keys:
-            self[key] = command
-
-    def get(self, key, default=None):
-        if isinstance(key, str):
-            key = ord(key)
-        return dict.get(self, key, default)
-
-    def findkey(self, command, default=ipipe.noitem):
-        for (key, commandcandidate) in self.iteritems():
-            if commandcandidate == command:
-                return key
-        if default is ipipe.noitem:
-            raise KeyError(command)
-        return default
-
-
-class _BrowserCachedItem(object):
-    # This is used internally by ``ibrowse`` to store a item together with its
-    # marked status.
-    __slots__ = ("item", "marked")
-
-    def __init__(self, item):
-        self.item = item
-        self.marked = False
-
-
-class _BrowserHelp(object):
-    style_header = astyle.Style.fromstr("yellow:black:bold")
-    # This is used internally by ``ibrowse`` for displaying the help screen.
-    def __init__(self, browser):
-        self.browser = browser
-
-    def __xrepr__(self, mode):
-        yield (-1, True)
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default, "ibrowse help screen")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __iter__(self):
-        # Get reverse key mapping
-        allkeys = {}
-        for (key, cmd) in self.browser.keymap.iteritems():
-            allkeys.setdefault(cmd, []).append(key)
-
-        fields = ("key", "description")
-
-        commands = []
-        for name in dir(self.browser):
-            if name.startswith("cmd_"):
-                command = getattr(self.browser, name)
-                commands.append((inspect.getsourcelines(command)[-1], name[4:], command))
-        commands.sort()
-        commands = [(c[1], c[2]) for c in commands]
-        for (i, (name, command)) in enumerate(commands):
-            if i:
-                yield ipipe.Fields(fields, key="", description="")
-
-            description = command.__doc__
-            if description is None:
-                lines = []
-            else:
-                lines = [l.strip() for l in description.splitlines() if l.strip()]
-                description = "\n".join(lines)
-                lines = textwrap.wrap(description, 60)
-            keys = allkeys.get(name, [])
-
-            yield ipipe.Fields(fields, key="", description=astyle.Text((self.style_header, name)))
-            for i in xrange(max(len(keys), len(lines))):
-                try:
-                    key = self.browser.keylabel(keys[i])
-                except IndexError:
-                    key = ""
-                try:
-                    line = lines[i]
-                except IndexError:
-                    line = ""
-                yield ipipe.Fields(fields, key=key, description=line)
-
-
-class _BrowserLevel(object):
-    # This is used internally to store the state (iterator, fetch items,
-    # position of cursor and screen, etc.) of one browser level
-    # An ``ibrowse`` object keeps multiple ``_BrowserLevel`` objects in
-    # a stack.
-    def __init__(self, browser, input, mainsizey, *attrs):
-        self.browser = browser
-        self.input = input
-        self.header = [x for x in ipipe.xrepr(input, "header") if not isinstance(x[0], int)]
-        # iterator for the input
-        self.iterator = ipipe.xiter(input)
-
-        # is the iterator exhausted?
-        self.exhausted = False
-
-        # attributes to be display (autodetected if empty)
-        self.attrs = attrs
-
-        # fetched items (+ marked flag)
-        self.items = ipipe.deque()
-
-        # Number of marked objects
-        self.marked = 0
-
-        # Vertical cursor position
-        self.cury = 0
-
-        # Horizontal cursor position
-        self.curx = 0
-
-        # Index of first data column
-        self.datastartx = 0
-
-        # Index of first data line
-        self.datastarty = 0
-
-        # height of the data display area
-        self.mainsizey = mainsizey
-
-        # width of the data display area (changes when scrolling)
-        self.mainsizex = 0
-
-        # Size of row number (changes when scrolling)
-        self.numbersizex = 0
-
-        # Attributes to display (in this order)
-        self.displayattrs = []
-
-        # index and attribute under the cursor
-        self.displayattr = (None, ipipe.noitem)
-
-        # Maps attributes to column widths
-        self.colwidths = {}
-
-        # Set of hidden attributes
-        self.hiddenattrs = set()
-
-        # This takes care of all the caches etc.
-        self.moveto(0, 0, refresh=True)
-
-    def fetch(self, count):
-        # Try to fill ``self.items`` with at least ``count`` objects.
-        have = len(self.items)
-        while not self.exhausted and have < count:
-            try:
-                item = self.iterator.next()
-            except StopIteration:
-                self.exhausted = True
-                break
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                have += 1
-                self.items.append(_BrowserCachedItem(exc))
-                self.exhausted = True
-                break
-            else:
-                have += 1
-                self.items.append(_BrowserCachedItem(item))
-
-    def calcdisplayattrs(self):
-        # Calculate which attributes are available from the objects that are
-        # currently visible on screen (and store it in ``self.displayattrs``)
-
-        attrs = set()
-        self.displayattrs = []
-        if self.attrs:
-            # If the browser object specifies a fixed list of attributes,
-            # simply use it (removing hidden attributes).
-            for attr in self.attrs:
-                attr = ipipe.upgradexattr(attr)
-                if attr not in attrs and attr not in self.hiddenattrs:
-                    self.displayattrs.append(attr)
-                    attrs.add(attr)
-        else:
-            endy = min(self.datastarty+self.mainsizey, len(self.items))
-            for i in xrange(self.datastarty, endy):
-                for attr in ipipe.xattrs(self.items[i].item, "default"):
-                    if attr not in attrs and attr not in self.hiddenattrs:
-                        self.displayattrs.append(attr)
-                        attrs.add(attr)
-
-    def getrow(self, i):
-        # Return a dictionary with the attributes for the object
-        # ``self.items[i]``. Attribute names are taken from
-        # ``self.displayattrs`` so ``calcdisplayattrs()`` must have been
-        # called before.
-        row = {}
-        item = self.items[i].item
-        for attr in self.displayattrs:
-            try:
-                value = attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                value = exc
-            # only store attribute if it exists (or we got an exception)
-            if value is not ipipe.noitem:
-                # remember alignment, length and colored text
-                row[attr] = ipipe.xformat(value, "cell", self.browser.maxattrlength)
-        return row
-
-    def calcwidths(self):
-        # Recalculate the displayed fields and their widths.
-        # ``calcdisplayattrs()'' must have been called and the cache
-        # for attributes of the objects on screen (``self.displayrows``)
-        # must have been filled. This sets ``self.colwidths`` which maps
-        # attribute descriptors to widths.
-        self.colwidths = {}
-        for row in self.displayrows:
-            for attr in self.displayattrs:
-                try:
-                    length = row[attr][1]
-                except KeyError:
-                    length = 0
-                # always add attribute to colwidths, even if it doesn't exist
-                if attr not in self.colwidths:
-                    self.colwidths[attr] = len(attr.name())
-                newwidth = max(self.colwidths[attr], length)
-                self.colwidths[attr] = newwidth
-
-        # How many characters do we need to paint the largest item number?
-        self.numbersizex = len(str(self.datastarty+self.mainsizey-1))
-        # How must space have we got to display data?
-        self.mainsizex = self.browser.scrsizex-self.numbersizex-3
-        # width of all columns
-        self.datasizex = sum(self.colwidths.itervalues()) + len(self.colwidths)
-
-    def calcdisplayattr(self):
-        # Find out which attribute the cursor is on and store this
-        # information in ``self.displayattr``.
-        pos = 0
-        for (i, attr) in enumerate(self.displayattrs):
-            if pos+self.colwidths[attr] >= self.curx:
-                self.displayattr = (i, attr)
-                break
-            pos += self.colwidths[attr]+1
-        else:
-            self.displayattr = (None, ipipe.noitem)
-
-    def moveto(self, x, y, refresh=False):
-        # Move the cursor to the position ``(x,y)`` (in data coordinates,
-        # not in screen coordinates). If ``refresh`` is true, all cached
-        # values will be recalculated (e.g. because the list has been
-        # resorted, so screen positions etc. are no longer valid).
-        olddatastarty = self.datastarty
-        oldx = self.curx
-        oldy = self.cury
-        x = int(x+0.5)
-        y = int(y+0.5)
-        newx = x # remember where we wanted to move
-        newy = y # remember where we wanted to move
-
-        scrollbordery = min(self.browser.scrollbordery, self.mainsizey//2)
-        scrollborderx = min(self.browser.scrollborderx, self.mainsizex//2)
-
-        # Make sure that the cursor didn't leave the main area vertically
-        if y < 0:
-            y = 0
-        # try to get enough items to fill the screen
-        self.fetch(max(y+scrollbordery+1, self.mainsizey))
-        if y >= len(self.items):
-            y = max(0, len(self.items)-1)
-
-        # Make sure that the cursor stays on screen vertically
-        if y < self.datastarty+scrollbordery:
-            self.datastarty = max(0, y-scrollbordery)
-        elif y >= self.datastarty+self.mainsizey-scrollbordery:
-            self.datastarty = max(0, min(y-self.mainsizey+scrollbordery+1,
-                                         len(self.items)-self.mainsizey))
-
-        if refresh: # Do we need to refresh the complete display?
-            self.calcdisplayattrs()
-            endy = min(self.datastarty+self.mainsizey, len(self.items))
-            self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
-            self.calcwidths()
-        # Did we scroll vertically => update displayrows
-        # and various other attributes
-        elif self.datastarty != olddatastarty:
-            # Recalculate which attributes we have to display
-            olddisplayattrs = self.displayattrs
-            self.calcdisplayattrs()
-            # If there are new attributes, recreate the cache
-            if self.displayattrs != olddisplayattrs:
-                endy = min(self.datastarty+self.mainsizey, len(self.items))
-                self.displayrows = map(self.getrow, xrange(self.datastarty, endy))
-            elif self.datastarty<olddatastarty: # we did scroll up
-                # drop rows from the end
-                del self.displayrows[self.datastarty-olddatastarty:]
-                # fetch new items
-                for i in xrange(min(olddatastarty, self.datastarty+self.mainsizey)-1,
-                                self.datastarty-1, -1):
-                    try:
-                        row = self.getrow(i)
-                    except IndexError:
-                        # we didn't have enough objects to fill the screen
-                        break
-                    self.displayrows.insert(0, row)
-            else: # we did scroll down
-                # drop rows from the start
-                del self.displayrows[:self.datastarty-olddatastarty]
-                # fetch new items
-                for i in xrange(max(olddatastarty+self.mainsizey, self.datastarty),
-                                self.datastarty+self.mainsizey):
-                    try:
-                        row = self.getrow(i)
-                    except IndexError:
-                        # we didn't have enough objects to fill the screen
-                        break
-                    self.displayrows.append(row)
-            self.calcwidths()
-
-        # Make sure that the cursor didn't leave the data area horizontally
-        if x < 0:
-            x = 0
-        elif x >= self.datasizex:
-            x = max(0, self.datasizex-1)
-
-        # Make sure that the cursor stays on screen horizontally
-        if x < self.datastartx+scrollborderx:
-            self.datastartx = max(0, x-scrollborderx)
-        elif x >= self.datastartx+self.mainsizex-scrollborderx:
-            self.datastartx = max(0, min(x-self.mainsizex+scrollborderx+1,
-                                         self.datasizex-self.mainsizex))
-
-        if x == oldx and y == oldy and (x != newx or y != newy): # couldn't move
-            self.browser.beep()
-        else:
-            self.curx = x
-            self.cury = y
-            self.calcdisplayattr()
-
-    def sort(self, key, reverse=False):
-        """
-        Sort the currently list of items using the key function ``key``. If
-        ``reverse`` is true the sort order is reversed.
-        """
-        curitem = self.items[self.cury] # Remember where the cursor is now
-
-        # Sort items
-        def realkey(item):
-            return key(item.item)
-        self.items = ipipe.deque(sorted(self.items, key=realkey, reverse=reverse))
-
-        # Find out where the object under the cursor went
-        cury = self.cury
-        for (i, item) in enumerate(self.items):
-            if item is curitem:
-                cury = i
-                break
-
-        self.moveto(self.curx, cury, refresh=True)
-
-    def refresh(self):
-        """
-        Restart iterating the input.
-        """
-        self.iterator = ipipe.xiter(self.input)
-        self.items.clear()
-        self.exhausted = False
-        self.datastartx = self.datastarty = 0
-        self.moveto(0, 0, refresh=True)
-
-    def refreshfind(self):
-        """
-        Restart iterating the input and go back to the same object as before
-        (if it can be found in the new iterator).
-        """
-        try:
-            oldobject = self.items[self.cury].item
-        except IndexError:
-            oldobject = ipipe.noitem
-        self.iterator = ipipe.xiter(self.input)
-        self.items.clear()
-        self.exhausted = False
-        while True:
-            self.fetch(len(self.items)+1)
-            if self.exhausted:
-                curses.beep()
-                self.datastartx = self.datastarty = 0
-                self.moveto(self.curx, 0, refresh=True)
-                break
-            if self.items[-1].item == oldobject:
-                self.datastartx = self.datastarty = 0
-                self.moveto(self.curx, len(self.items)-1, refresh=True)
-                break
-
-
-class _CommandInput(object):
-    keymap = Keymap()
-    keymap.register("left", curses.KEY_LEFT)
-    keymap.register("right", curses.KEY_RIGHT)
-    keymap.register("home", curses.KEY_HOME, "\x01") # Ctrl-A
-    keymap.register("end", curses.KEY_END, "\x05") # Ctrl-E
-    # FIXME: What's happening here?
-    keymap.register("backspace", curses.KEY_BACKSPACE, "\x08\x7f")
-    keymap.register("delete", curses.KEY_DC)
-    keymap.register("delend", 0x0b) # Ctrl-K
-    keymap.register("execute", "\r\n")
-    keymap.register("up", curses.KEY_UP)
-    keymap.register("down", curses.KEY_DOWN)
-    keymap.register("incsearchup", curses.KEY_PPAGE)
-    keymap.register("incsearchdown", curses.KEY_NPAGE)
-    keymap.register("exit", "\x18"), # Ctrl-X
-
-    def __init__(self, prompt):
-        self.prompt = prompt
-        self.history = []
-        self.maxhistory = 100
-        self.input = ""
-        self.curx = 0
-        self.cury = -1 # blank line
-
-    def start(self):
-        self.input = ""
-        self.curx = 0
-        self.cury = -1 # blank line
-
-    def handlekey(self, browser, key):
-        cmdname = self.keymap.get(key, None)
-        if cmdname is not None:
-            cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
-            if cmdfunc is not None:
-                return cmdfunc(browser)
-            curses.beep()
-        elif key != -1:
-            try:
-                char = chr(key)
-            except ValueError:
-                curses.beep()
-            else:
-                return self.handlechar(browser, char)
-
-    def handlechar(self, browser, char):
-        self.input = self.input[:self.curx] + char + self.input[self.curx:]
-        self.curx += 1
-        return True
-
-    def dohistory(self):
-        self.history.insert(0, self.input)
-        del self.history[:-self.maxhistory]
-
-    def cmd_backspace(self, browser):
-        if self.curx:
-            self.input = self.input[:self.curx-1] + self.input[self.curx:]
-            self.curx -= 1
-            return True
-        else:
-            curses.beep()
-
-    def cmd_delete(self, browser):
-        if self.curx<len(self.input):
-            self.input = self.input[:self.curx] + self.input[self.curx+1:]
-            return True
-        else:
-            curses.beep()
-
-    def cmd_delend(self, browser):
-        if self.curx<len(self.input):
-            self.input = self.input[:self.curx]
-            return True
-
-    def cmd_left(self, browser):
-        if self.curx:
-            self.curx -= 1
-            return True
-        else:
-            curses.beep()
-
-    def cmd_right(self, browser):
-        if self.curx < len(self.input):
-            self.curx += 1
-            return True
-        else:
-            curses.beep()
-
-    def cmd_home(self, browser):
-        if self.curx:
-            self.curx = 0
-            return True
-        else:
-            curses.beep()
-
-    def cmd_end(self, browser):
-        if self.curx < len(self.input):
-            self.curx = len(self.input)
-            return True
-        else:
-            curses.beep()
-
-    def cmd_up(self, browser):
-        if self.cury < len(self.history)-1:
-            self.cury += 1
-            self.input = self.history[self.cury]
-            self.curx = len(self.input)
-            return True
-        else:
-            curses.beep()
-
-    def cmd_down(self, browser):
-        if self.cury >= 0:
-            self.cury -= 1
-            if self.cury>=0:
-                self.input = self.history[self.cury]
-            else:
-                self.input = ""
-            self.curx = len(self.input)
-            return True
-        else:
-            curses.beep()
-
-    def cmd_incsearchup(self, browser):
-        prefix = self.input[:self.curx]
-        cury = self.cury
-        while True:
-            cury += 1
-            if cury >= len(self.history):
-                break
-            if self.history[cury].startswith(prefix):
-                self.input = self.history[cury]
-                self.cury = cury
-                return True
-        curses.beep()
-
-    def cmd_incsearchdown(self, browser):
-        prefix = self.input[:self.curx]
-        cury = self.cury
-        while True:
-            cury -= 1
-            if cury <= 0:
-                break
-            if self.history[cury].startswith(prefix):
-                self.input = self.history[self.cury]
-                self.cury = cury
-                return True
-        curses.beep()
-
-    def cmd_exit(self, browser):
-        browser.mode = "default"
-        return True
-
-    def cmd_execute(self, browser):
-        raise NotImplementedError
-
-
-class _CommandGoto(_CommandInput):
-    def __init__(self):
-        _CommandInput.__init__(self, "goto object #")
-
-    def handlechar(self, browser, char):
-        # Only accept digits
-        if not "0" <= char <= "9":
-            curses.beep()
-        else:
-            return _CommandInput.handlechar(self, browser, char)
-
-    def cmd_execute(self, browser):
-        level = browser.levels[-1]
-        if self.input:
-            self.dohistory()
-            level.moveto(level.curx, int(self.input))
-        browser.mode = "default"
-        return True
-
-
-class _CommandFind(_CommandInput):
-    def __init__(self):
-        _CommandInput.__init__(self, "find expression")
-
-    def cmd_execute(self, browser):
-        level = browser.levels[-1]
-        if self.input:
-            self.dohistory()
-            while True:
-                cury = level.cury
-                level.moveto(level.curx, cury+1)
-                if cury == level.cury:
-                    curses.beep()
-                    break # hit end
-                item = level.items[level.cury].item
-                try:
-                    globals = ipipe.getglobals(None)
-                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
-                        break # found something
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception, exc:
-                    browser.report(exc)
-                    curses.beep()
-                    break  # break on error
-        browser.mode = "default"
-        return True
-
-
-class _CommandFindBackwards(_CommandInput):
-    def __init__(self):
-        _CommandInput.__init__(self, "find backwards expression")
-
-    def cmd_execute(self, browser):
-        level = browser.levels[-1]
-        if self.input:
-            self.dohistory()
-            while level.cury:
-                level.moveto(level.curx, level.cury-1)
-                item = level.items[level.cury].item
-                try:
-                    globals = ipipe.getglobals(None)
-                    if eval(self.input, globals, ipipe.AttrNamespace(item)):
-                        break # found something
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception, exc:
-                    browser.report(exc)
-                    curses.beep()
-                    break # break on error
-            else:
-                curses.beep()
-        browser.mode = "default"
-        return True
-
-
-class ibrowse(ipipe.Display):
-    # Show this many lines from the previous screen when paging horizontally
-    pageoverlapx = 1
-
-    # Show this many lines from the previous screen when paging vertically
-    pageoverlapy = 1
-
-    # Start scrolling when the cursor is less than this number of columns
-    # away from the left or right screen edge
-    scrollborderx = 10
-
-    # Start scrolling when the cursor is less than this number of lines
-    # away from the top or bottom screen edge
-    scrollbordery = 5
-
-    # Accelerate by this factor when scrolling horizontally
-    acceleratex = 1.05
-
-    # Accelerate by this factor when scrolling vertically
-    acceleratey = 1.05
-
-    # The maximum horizontal scroll speed
-    # (as a factor of the screen width (i.e. 0.5 == half a screen width)
-    maxspeedx = 0.5
-
-    # The maximum vertical scroll speed
-    # (as a factor of the screen height (i.e. 0.5 == half a screen height)
-    maxspeedy = 0.5
-
-    # The maximum number of header lines for browser level
-    # if the nesting is deeper, only the innermost levels are displayed
-    maxheaders = 5
-
-    # The approximate maximum length of a column entry
-    maxattrlength = 200
-
-    # Styles for various parts of the GUI
-    style_objheadertext = astyle.Style.fromstr("white:black:bold|reverse")
-    style_objheadernumber = astyle.Style.fromstr("white:blue:bold|reverse")
-    style_objheaderobject = astyle.Style.fromstr("white:black:reverse")
-    style_colheader = astyle.Style.fromstr("blue:white:reverse")
-    style_colheaderhere = astyle.Style.fromstr("green:black:bold|reverse")
-    style_colheadersep = astyle.Style.fromstr("blue:black:reverse")
-    style_number = astyle.Style.fromstr("blue:white:reverse")
-    style_numberhere = astyle.Style.fromstr("green:black:bold|reverse")
-    style_sep = astyle.Style.fromstr("blue:black")
-    style_data = astyle.Style.fromstr("white:black")
-    style_datapad = astyle.Style.fromstr("blue:black:bold")
-    style_footer = astyle.Style.fromstr("black:white")
-    style_report = astyle.Style.fromstr("white:black")
-
-    # Column separator in header
-    headersepchar = "|"
-
-    # Character for padding data cell entries
-    datapadchar = "."
-
-    # Column separator in data area
-    datasepchar = "|"
-
-    # Character to use for "empty" cell (i.e. for non-existing attributes)
-    nodatachar = "-"
-
-    # Prompts for modes that require keyboard input
-    prompts = {
-        "goto": _CommandGoto(),
-        "find": _CommandFind(),
-        "findbackwards": _CommandFindBackwards()
-    }
-
-    # Maps curses key codes to "function" names
-    keymap = Keymap()
-    keymap.register("quit", "q")
-    keymap.register("up", curses.KEY_UP)
-    keymap.register("down", curses.KEY_DOWN)
-    keymap.register("pageup", curses.KEY_PPAGE)
-    keymap.register("pagedown", curses.KEY_NPAGE)
-    keymap.register("left", curses.KEY_LEFT)
-    keymap.register("right", curses.KEY_RIGHT)
-    keymap.register("home", curses.KEY_HOME, "\x01")
-    keymap.register("end", curses.KEY_END, "\x05")
-    keymap.register("prevattr", "<\x1b")
-    keymap.register("nextattr", ">\t")
-    keymap.register("pick", "p")
-    keymap.register("pickattr", "P")
-    keymap.register("pickallattrs", "C")
-    keymap.register("pickmarked", "m")
-    keymap.register("pickmarkedattr", "M")
-    keymap.register("pickinput", "i")
-    keymap.register("pickinputattr", "I")
-    keymap.register("hideattr", "h")
-    keymap.register("unhideattrs", "H")
-    keymap.register("help", "?")
-    keymap.register("enter", "\r\n")
-    keymap.register("enterattr", "E")
-    # FIXME: What's happening here?
-    keymap.register("leave", curses.KEY_BACKSPACE, "x\x08\x7f")
-    keymap.register("detail", "d")
-    keymap.register("detailattr", "D")
-    keymap.register("tooglemark", " ")
-    keymap.register("markrange", "%")
-    keymap.register("sortattrasc", "v")
-    keymap.register("sortattrdesc", "V")
-    keymap.register("goto", "g")
-    keymap.register("find", "f")
-    keymap.register("findbackwards", "b")
-    keymap.register("refresh", "r")
-    keymap.register("refreshfind", "R")
-
-    def __init__(self, input=None, *attrs):
-        """
-        Create a new browser. If ``attrs`` is not empty, it is the list
-        of attributes that will be displayed in the browser, otherwise
-        these will be determined by the objects on screen.
-        """
-        ipipe.Display.__init__(self, input)
-
-        self.attrs = attrs
-
-        # Stack of browser levels
-        self.levels = []
-        # how many colums to scroll (Changes when accelerating)
-        self.stepx = 1.
-
-        # how many rows to scroll (Changes when accelerating)
-        self.stepy = 1.
-
-        # Beep on the edges of the data area? (Will be set to ``False``
-        # once the cursor hits the edge of the screen, so we don't get
-        # multiple beeps).
-        self._dobeep = True
-
-        # Cache for registered ``curses`` colors and styles.
-        self._styles = {}
-        self._colors = {}
-        self._maxcolor = 1
-
-        # How many header lines do we want to paint (the numbers of levels
-        # we have, but with an upper bound)
-        self._headerlines = 1
-
-        # Index of first header line
-        self._firstheaderline = 0
-
-        # curses window
-        self.scr = None
-        # report in the footer line (error, executed command etc.)
-        self._report = None
-
-        # value to be returned to the caller (set by commands)
-        self.returnvalue = None
-
-        # The mode the browser is in
-        # e.g. normal browsing or entering an argument for a command
-        self.mode = "default"
-
-        # set by the SIGWINCH signal handler
-        self.resized = False
-
-    def nextstepx(self, step):
-        """
-        Accelerate horizontally.
-        """
-        return max(1., min(step*self.acceleratex,
-                           self.maxspeedx*self.levels[-1].mainsizex))
-
-    def nextstepy(self, step):
-        """
-        Accelerate vertically.
-        """
-        return max(1., min(step*self.acceleratey,
-                           self.maxspeedy*self.levels[-1].mainsizey))
-
-    def getstyle(self, style):
-        """
-        Register the ``style`` with ``curses`` or get it from the cache,
-        if it has been registered before.
-        """
-        try:
-            return self._styles[style.fg, style.bg, style.attrs]
-        except KeyError:
-            attrs = 0
-            for b in astyle.A2CURSES:
-                if style.attrs & b:
-                    attrs |= astyle.A2CURSES[b]
-            try:
-                color = self._colors[style.fg, style.bg]
-            except KeyError:
-                curses.init_pair(
-                    self._maxcolor,
-                    astyle.COLOR2CURSES[style.fg],
-                    astyle.COLOR2CURSES[style.bg]
-                )
-                color = curses.color_pair(self._maxcolor)
-                self._colors[style.fg, style.bg] = color
-                self._maxcolor += 1
-            c = color | attrs
-            self._styles[style.fg, style.bg, style.attrs] = c
-            return c
-
-    def addstr(self, y, x, begx, endx, text, style):
-        """
-        A version of ``curses.addstr()`` that can handle ``x`` coordinates
-        that are outside the screen.
-        """
-        text2 = text[max(0, begx-x):max(0, endx-x)]
-        if text2:
-            self.scr.addstr(y, max(x, begx), text2, self.getstyle(style))
-        return len(text)
-
-    def addchr(self, y, x, begx, endx, c, l, style):
-        x0 = max(x, begx)
-        x1 = min(x+l, endx)
-        if x1>x0:
-            self.scr.addstr(y, x0, c*(x1-x0), self.getstyle(style))
-        return l
-
-    def _calcheaderlines(self, levels):
-        # Calculate how many headerlines do we have to display, if we have
-        # ``levels`` browser levels
-        if levels is None:
-            levels = len(self.levels)
-        self._headerlines = min(self.maxheaders, levels)
-        self._firstheaderline = levels-self._headerlines
-
-    def getstylehere(self, style):
-        """
-        Return a style for displaying the original style ``style``
-        in the row the cursor is on.
-        """
-        return astyle.Style(style.fg, astyle.COLOR_BLUE, style.attrs | astyle.A_BOLD)
-
-    def report(self, msg):
-        """
-        Store the message ``msg`` for display below the footer line. This
-        will be displayed as soon as the screen is redrawn.
-        """
-        self._report = msg
-
-    def enter(self, item, *attrs):
-        """
-        Enter the object ``item``. If ``attrs`` is specified, it will be used
-        as a fixed list of attributes to display.
-        """
-        if self.levels and item is self.levels[-1].input:
-            curses.beep()
-            self.report(CommandError("Recursion on input object"))
-        else:
-            oldlevels = len(self.levels)
-            self._calcheaderlines(oldlevels+1)
-            try:
-                level = _BrowserLevel(
-                    self,
-                    item,
-                    self.scrsizey-1-self._headerlines-2,
-                    *attrs
-                )
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                if not self.levels:
-                    raise
-                self._calcheaderlines(oldlevels)
-                curses.beep()
-                self.report(exc)
-            else:
-                self.levels.append(level)
-
-    def startkeyboardinput(self, mode):
-        """
-        Enter mode ``mode``, which requires keyboard input.
-        """
-        self.mode = mode
-        self.prompts[mode].start()
-
-    def keylabel(self, keycode):
-        """
-        Return a pretty name for the ``curses`` key ``keycode`` (used in the
-        help screen and in reports about unassigned keys).
-        """
-        if keycode <= 0xff:
-            specialsnames = {
-                ord("\n"): "RETURN",
-                ord(" "): "SPACE",
-                ord("\t"): "TAB",
-                ord("\x7f"): "DELETE",
-                ord("\x08"): "BACKSPACE",
-            }
-            if keycode in specialsnames:
-                return specialsnames[keycode]
-            elif 0x00 < keycode < 0x20:
-                return "CTRL-%s" % chr(keycode + 64)
-            return repr(chr(keycode))
-        for name in dir(curses):
-            if name.startswith("KEY_") and getattr(curses, name) == keycode:
-                return name
-        return str(keycode)
-
-    def beep(self, force=False):
-        if force or self._dobeep:
-            curses.beep()
-            # don't beep again (as long as the same key is pressed)
-            self._dobeep = False
-
-    def cmd_up(self):
-        """
-        Move the cursor to the previous row.
-        """
-        level = self.levels[-1]
-        self.report("up")
-        level.moveto(level.curx, level.cury-self.stepy)
-
-    def cmd_down(self):
-        """
-        Move the cursor to the next row.
-        """
-        level = self.levels[-1]
-        self.report("down")
-        level.moveto(level.curx, level.cury+self.stepy)
-
-    def cmd_pageup(self):
-        """
-        Move the cursor up one page.
-        """
-        level = self.levels[-1]
-        self.report("page up")
-        level.moveto(level.curx, level.cury-level.mainsizey+self.pageoverlapy)
-
-    def cmd_pagedown(self):
-        """
-        Move the cursor down one page.
-        """
-        level = self.levels[-1]
-        self.report("page down")
-        level.moveto(level.curx, level.cury+level.mainsizey-self.pageoverlapy)
-
-    def cmd_left(self):
-        """
-        Move the cursor left.
-        """
-        level = self.levels[-1]
-        self.report("left")
-        level.moveto(level.curx-self.stepx, level.cury)
-
-    def cmd_right(self):
-        """
-        Move the cursor right.
-        """
-        level = self.levels[-1]
-        self.report("right")
-        level.moveto(level.curx+self.stepx, level.cury)
-
-    def cmd_home(self):
-        """
-        Move the cursor to the first column.
-        """
-        level = self.levels[-1]
-        self.report("home")
-        level.moveto(0, level.cury)
-
-    def cmd_end(self):
-        """
-        Move the cursor to the last column.
-        """
-        level = self.levels[-1]
-        self.report("end")
-        level.moveto(level.datasizex+level.mainsizey-self.pageoverlapx, level.cury)
-
-    def cmd_prevattr(self):
-        """
-        Move the cursor one attribute column to the left.
-        """
-        level = self.levels[-1]
-        if level.displayattr[0] is None or level.displayattr[0] == 0:
-            self.beep()
-        else:
-            self.report("prevattr")
-            pos = 0
-            for (i, attrname) in enumerate(level.displayattrs):
-                if i == level.displayattr[0]-1:
-                    break
-                pos += level.colwidths[attrname] + 1
-            level.moveto(pos, level.cury)
-
-    def cmd_nextattr(self):
-        """
-        Move the cursor one attribute column to the right.
-        """
-        level = self.levels[-1]
-        if level.displayattr[0] is None or level.displayattr[0] == len(level.displayattrs)-1:
-            self.beep()
-        else:
-            self.report("nextattr")
-            pos = 0
-            for (i, attrname) in enumerate(level.displayattrs):
-                if i == level.displayattr[0]+1:
-                    break
-                pos += level.colwidths[attrname] + 1
-            level.moveto(pos, level.cury)
-
-    def cmd_pick(self):
-        """
-        'Pick' the object under the cursor (i.e. the row the cursor is on).
-        This leaves the browser and returns the picked object to the caller.
-        (In IPython this object will be available as the ``_`` variable.)
-        """
-        level = self.levels[-1]
-        self.returnvalue = level.items[level.cury].item
-        return True
-
-    def cmd_pickattr(self):
-        """
-        'Pick' the attribute under the cursor (i.e. the row/column the
-        cursor is on).
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        value = attr.value(level.items[level.cury].item)
-        if value is ipipe.noitem:
-            curses.beep()
-            self.report(AttributeError(attr.name()))
-        else:
-            self.returnvalue = value
-            return True
-
-    def cmd_pickallattrs(self):
-        """
-        Pick' the complete column under the cursor (i.e. the attribute under
-        the cursor) from all currently fetched objects. These attributes
-        will be returned as a list.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        result = []
-        for cache in level.items:
-            value = attr.value(cache.item)
-            if value is not ipipe.noitem:
-                result.append(value)
-        self.returnvalue = result
-        return True
-
-    def cmd_pickmarked(self):
-        """
-        'Pick' marked objects. Marked objects will be returned as a list.
-        """
-        level = self.levels[-1]
-        self.returnvalue = [cache.item for cache in level.items if cache.marked]
-        return True
-
-    def cmd_pickmarkedattr(self):
-        """
-        'Pick' the attribute under the cursor from all marked objects
-        (This returns a list).
-        """
-
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        result = []
-        for cache in level.items:
-            if cache.marked:
-                value = attr.value(cache.item)
-                if value is not ipipe.noitem:
-                    result.append(value)
-        self.returnvalue = result
-        return True
-
-    def cmd_pickinput(self):
-        """
-        Use the object under the cursor (i.e. the row the cursor is on) as
-        the next input line. This leaves the browser and puts the picked object
-        in the input.
-        """
-        level = self.levels[-1]
-        value = level.items[level.cury].item
-        self.returnvalue = None
-        api = ipapi.get()
-        api.set_next_input(str(value))
-        return True
-
-    def cmd_pickinputattr(self):
-        """
-        Use the attribute under the cursor i.e. the row/column the cursor is on)
-        as the next input line. This leaves the browser and puts the picked
-        object in the input.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        value = attr.value(level.items[level.cury].item)
-        if value is ipipe.noitem:
-            curses.beep()
-            self.report(AttributeError(attr.name()))
-        self.returnvalue = None
-        api = ipapi.get()
-        api.set_next_input(str(value))
-        return True
-
-    def cmd_markrange(self):
-        """
-        Mark all objects from the last marked object before the current cursor
-        position to the cursor position.
-        """
-        level = self.levels[-1]
-        self.report("markrange")
-        start = None
-        if level.items:
-            for i in xrange(level.cury, -1, -1):
-                if level.items[i].marked:
-                    start = i
-                    break
-        if start is None:
-            self.report(CommandError("no mark before cursor"))
-            curses.beep()
-        else:
-            for i in xrange(start, level.cury+1):
-                cache = level.items[i]
-                if not cache.marked:
-                    cache.marked = True
-                    level.marked += 1
-
-    def cmd_enter(self):
-        """
-        Enter the object under the cursor. (what this mean depends on the object
-        itself (i.e. how it implements iteration). This opens a new browser 'level'.
-        """
-        level = self.levels[-1]
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            self.report("entering object...")
-            self.enter(item)
-
-    def cmd_leave(self):
-        """
-        Leave the current browser level and go back to the previous one.
-        """
-        self.report("leave")
-        if len(self.levels) > 1:
-            self._calcheaderlines(len(self.levels)-1)
-            self.levels.pop(-1)
-        else:
-            self.report(CommandError("This is the last level"))
-            curses.beep()
-
-    def cmd_enterattr(self):
-        """
-        Enter the attribute under the cursor.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            value = attr.value(item)
-            name = attr.name()
-            if value is ipipe.noitem:
-                self.report(AttributeError(name))
-            else:
-                self.report("entering object attribute %s..." % name)
-                self.enter(value)
-
-    def cmd_detail(self):
-        """
-        Show a detail view of the object under the cursor. This shows the
-        name, type, doc string and value of the object attributes (and it
-        might show more attributes than in the list view, depending on
-        the object).
-        """
-        level = self.levels[-1]
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            self.report("entering detail view for object...")
-            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-            self.enter(attrs)
-
-    def cmd_detailattr(self):
-        """
-        Show a detail view of the attribute under the cursor.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no attribute"))
-            return
-        try:
-            item = level.items[level.cury].item
-        except IndexError:
-            self.report(CommandError("No object"))
-            curses.beep()
-        else:
-            try:
-                item = attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                self.report(exc)
-            else:
-                self.report("entering detail view for attribute %s..." % attr.name())
-                attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-                self.enter(attrs)
-
-    def cmd_tooglemark(self):
-        """
-        Mark/unmark the object under the cursor. Marked objects have a '!'
-        after the row number).
-        """
-        level = self.levels[-1]
-        self.report("toggle mark")
-        try:
-            item = level.items[level.cury]
-        except IndexError: # no items?
-            pass
-        else:
-            if item.marked:
-                item.marked = False
-                level.marked -= 1
-            else:
-                item.marked = True
-                level.marked += 1
-
-    def cmd_sortattrasc(self):
-        """
-        Sort the objects (in ascending order) using the attribute under
-        the cursor as the sort key.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        self.report("sort by %s (ascending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        level.sort(key)
-
-    def cmd_sortattrdesc(self):
-        """
-        Sort the objects (in descending order) using the attribute under
-        the cursor as the sort key.
-        """
-        level = self.levels[-1]
-        attr = level.displayattr[1]
-        if attr is ipipe.noitem:
-            curses.beep()
-            self.report(CommandError("no column under cursor"))
-            return
-        self.report("sort by %s (descending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        level.sort(key, reverse=True)
-
-    def cmd_hideattr(self):
-        """
-        Hide the attribute under the cursor.
-        """
-        level = self.levels[-1]
-        if level.displayattr[0] is None:
-            self.beep()
-        else:
-            self.report("hideattr")
-            level.hiddenattrs.add(level.displayattr[1])
-            level.moveto(level.curx, level.cury, refresh=True)
-
-    def cmd_unhideattrs(self):
-        """
-        Make all attributes visible again.
-        """
-        level = self.levels[-1]
-        self.report("unhideattrs")
-        level.hiddenattrs.clear()
-        level.moveto(level.curx, level.cury, refresh=True)
-
-    def cmd_goto(self):
-        """
-        Jump to a row. The row number can be entered at the
-        bottom of the screen.
-        """
-        self.startkeyboardinput("goto")
-
-    def cmd_find(self):
-        """
-        Search forward for a row. The search condition can be entered at the
-        bottom of the screen.
-        """
-        self.startkeyboardinput("find")
-
-    def cmd_findbackwards(self):
-        """
-        Search backward for a row. The search condition can be entered at the
-        bottom of the screen.
-        """
-        self.startkeyboardinput("findbackwards")
-
-    def cmd_refresh(self):
-        """
-        Refreshes the display by restarting the iterator.
-        """
-        level = self.levels[-1]
-        self.report("refresh")
-        level.refresh()
-
-    def cmd_refreshfind(self):
-        """
-        Refreshes the display by restarting the iterator and goes back to the
-        same object the cursor was on before restarting (if this object can't be
-        found the cursor jumps back to the first object).
-        """
-        level = self.levels[-1]
-        self.report("refreshfind")
-        level.refreshfind()
-
-    def cmd_help(self):
-        """
-        Opens the help screen as a new browser level, describing keyboard
-        shortcuts.
-        """
-        for level in self.levels:
-            if isinstance(level.input, _BrowserHelp):
-                curses.beep()
-                self.report(CommandError("help already active"))
-                return
-
-        self.enter(_BrowserHelp(self))
-
-    def cmd_quit(self):
-        """
-        Quit the browser and return to the IPython prompt.
-        """
-        self.returnvalue = None
-        return True
-
-    def sigwinchhandler(self, signal, frame):
-        self.resized = True
-
-    def _dodisplay(self, scr):
-        """
-        This method is the workhorse of the browser. It handles screen
-        drawing and the keyboard.
-        """
-        self.scr = scr
-        curses.halfdelay(1)
-        footery = 2
-
-        keys = []
-        for cmd in ("quit", "help"):
-            key = self.keymap.findkey(cmd, None)
-            if key is not None:
-                keys.append("%s=%s" % (self.keylabel(key), cmd))
-        helpmsg = " | %s" % " ".join(keys)
-
-        scr.clear()
-        msg = "Fetching first batch of objects..."
-        (self.scrsizey, self.scrsizex) = scr.getmaxyx()
-        scr.addstr(self.scrsizey//2, (self.scrsizex-len(msg))//2, msg)
-        scr.refresh()
-
-        lastc = -1
-
-        self.levels = []
-        # enter the first level
-        self.enter(self.input, *self.attrs)
-
-        self._calcheaderlines(None)
-
-        while True:
-            level = self.levels[-1]
-            (self.scrsizey, self.scrsizex) = scr.getmaxyx()
-            level.mainsizey = self.scrsizey-1-self._headerlines-footery
-
-            # Paint object header
-            for i in xrange(self._firstheaderline, self._firstheaderline+self._headerlines):
-                lv = self.levels[i]
-                posx = 0
-                posy = i-self._firstheaderline
-                endx = self.scrsizex
-                if i: # not the first level
-                    msg = " (%d/%d" % (self.levels[i-1].cury, len(self.levels[i-1].items))
-                    if not self.levels[i-1].exhausted:
-                        msg += "+"
-                    msg += ") "
-                    endx -= len(msg)+1
-                posx += self.addstr(posy, posx, 0, endx, " ibrowse #%d: " % i, self.style_objheadertext)
-                for (style, text) in lv.header:
-                    posx += self.addstr(posy, posx, 0, endx, text, self.style_objheaderobject)
-                    if posx >= endx:
-                        break
-                if i:
-                    posx += self.addstr(posy, posx, 0, self.scrsizex, msg, self.style_objheadernumber)
-                posx += self.addchr(posy, posx, 0, self.scrsizex, " ", self.scrsizex-posx, self.style_objheadernumber)
-
-            if not level.items:
-                self.addchr(self._headerlines, 0, 0, self.scrsizex, " ", self.scrsizex, self.style_colheader)
-                self.addstr(self._headerlines+1, 0, 0, self.scrsizex, " <empty>", astyle.style_error)
-                scr.clrtobot()
-            else:
-                # Paint column headers
-                scr.move(self._headerlines, 0)
-                scr.addstr(" %*s " % (level.numbersizex, "#"), self.getstyle(self.style_colheader))
-                scr.addstr(self.headersepchar, self.getstyle(self.style_colheadersep))
-                begx = level.numbersizex+3
-                posx = begx-level.datastartx
-                for attr in level.displayattrs:
-                    attrname = attr.name()
-                    cwidth = level.colwidths[attr]
-                    header = attrname.ljust(cwidth)
-                    if attr is level.displayattr[1]:
-                        style = self.style_colheaderhere
-                    else:
-                        style = self.style_colheader
-                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, header, style)
-                    posx += self.addstr(self._headerlines, posx, begx, self.scrsizex, self.headersepchar, self.style_colheadersep)
-                    if posx >= self.scrsizex:
-                        break
-                else:
-                    scr.addstr(" "*(self.scrsizex-posx), self.getstyle(self.style_colheader))
-
-                # Paint rows
-                posy = self._headerlines+1+level.datastarty
-                for i in xrange(level.datastarty, min(level.datastarty+level.mainsizey, len(level.items))):
-                    cache = level.items[i]
-                    if i == level.cury:
-                        style = self.style_numberhere
-                    else:
-                        style = self.style_number
-
-                    posy = self._headerlines+1+i-level.datastarty
-                    posx = begx-level.datastartx
-
-                    scr.move(posy, 0)
-                    scr.addstr(" %*d%s" % (level.numbersizex, i, " !"[cache.marked]), self.getstyle(style))
-                    scr.addstr(self.headersepchar, self.getstyle(self.style_sep))
-
-                    for attrname in level.displayattrs:
-                        cwidth = level.colwidths[attrname]
-                        try:
-                            (align, length, parts) = level.displayrows[i-level.datastarty][attrname]
-                        except KeyError:
-                            align = 2
-                            style = astyle.style_nodata
-                            if i == level.cury:
-                                style = self.getstylehere(style)
-                        padstyle = self.style_datapad
-                        sepstyle = self.style_sep
-                        if i == level.cury:
-                            padstyle = self.getstylehere(padstyle)
-                            sepstyle = self.getstylehere(sepstyle)
-                        if align == 2:
-                            posx += self.addchr(posy, posx, begx, self.scrsizex, self.nodatachar, cwidth, style)
-                        else:
-                            if align == 1:
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
-                            elif align == 0:
-                                pad1 = (cwidth-length)//2
-                                pad2 = cwidth-length-len(pad1)
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad1, padstyle)
-                            for (style, text) in parts:
-                                if i == level.cury:
-                                    style = self.getstylehere(style)
-                                posx += self.addstr(posy, posx, begx, self.scrsizex, text, style)
-                                if posx >= self.scrsizex:
-                                    break
-                            if align == -1:
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, cwidth-length, padstyle)
-                            elif align == 0:
-                                posx += self.addchr(posy, posx, begx, self.scrsizex, self.datapadchar, pad2, padstyle)
-                        posx += self.addstr(posy, posx, begx, self.scrsizex, self.datasepchar, sepstyle)
-                    else:
-                        scr.clrtoeol()
-
-                # Add blank row headers for the rest of the screen
-                for posy in xrange(posy+1, self.scrsizey-2):
-                    scr.addstr(posy, 0, " " * (level.numbersizex+2), self.getstyle(self.style_colheader))
-                    scr.clrtoeol()
-
-            posy = self.scrsizey-footery
-            # Display footer
-            scr.addstr(posy, 0, " "*self.scrsizex, self.getstyle(self.style_footer))
-
-            if level.exhausted:
-                flag = ""
-            else:
-                flag = "+"
-
-            endx = self.scrsizex-len(helpmsg)-1
-            scr.addstr(posy, endx, helpmsg, self.getstyle(self.style_footer))
-
-            posx = 0
-            msg = " %d%s objects (%d marked): " % (len(level.items), flag, level.marked)
-            posx += self.addstr(posy, posx, 0, endx, msg, self.style_footer)
-            try:
-                item = level.items[level.cury].item
-            except IndexError: # empty
-                pass
-            else:
-                for (nostyle, text) in ipipe.xrepr(item, "footer"):
-                    if not isinstance(nostyle, int):
-                        posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
-                        if posx >= endx:
-                            break
-
-                attrstyle = [(astyle.style_default, "no attribute")]
-                attr = level.displayattr[1]
-                if attr is not ipipe.noitem and not isinstance(attr, ipipe.SelfDescriptor):
-                    posx += self.addstr(posy, posx, 0, endx, " | ", self.style_footer)
-                    posx += self.addstr(posy, posx, 0, endx, attr.name(), self.style_footer)
-                    posx += self.addstr(posy, posx, 0, endx, ": ", self.style_footer)
-                    try:
-                        value = attr.value(item)
-                    except (SystemExit, KeyboardInterrupt):
-                        raise
-                    except Exception, exc:
-                        value = exc
-                    if value is not ipipe.noitem:
-                        attrstyle = ipipe.xrepr(value, "footer")
-                    for (nostyle, text) in attrstyle:
-                        if not isinstance(nostyle, int):
-                            posx += self.addstr(posy, posx, 0, endx, text, self.style_footer)
-                            if posx >= endx:
-                                break
-
-            try:
-                # Display input prompt
-                if self.mode in self.prompts:
-                    history = self.prompts[self.mode]
-                    posx = 0
-                    posy = self.scrsizey-1
-                    posx += self.addstr(posy, posx, 0, endx, history.prompt, astyle.style_default)
-                    posx += self.addstr(posy, posx, 0, endx, " [", astyle.style_default)
-                    if history.cury==-1:
-                        text = "new"
-                    else:
-                        text = str(history.cury+1)
-                    posx += self.addstr(posy, posx, 0, endx, text, astyle.style_type_number)
-                    if history.history:
-                        posx += self.addstr(posy, posx, 0, endx, "/", astyle.style_default)
-                        posx += self.addstr(posy, posx, 0, endx, str(len(history.history)), astyle.style_type_number)
-                    posx += self.addstr(posy, posx, 0, endx, "]: ", astyle.style_default)
-                    inputstartx = posx
-                    posx += self.addstr(posy, posx, 0, endx, history.input, astyle.style_default)
-                # Display report
-                else:
-                    if self._report is not None:
-                        if isinstance(self._report, Exception):
-                            style = self.getstyle(astyle.style_error)
-                            if self._report.__class__.__module__ == "exceptions":
-                                msg = "%s: %s" % \
-                                      (self._report.__class__.__name__, self._report)
-                            else:
-                                msg = "%s.%s: %s" % \
-                                      (self._report.__class__.__module__,
-                                       self._report.__class__.__name__, self._report)
-                        else:
-                            style = self.getstyle(self.style_report)
-                            msg = self._report
-                        scr.addstr(self.scrsizey-1, 0, msg[:self.scrsizex], style)
-                        self._report = None
-                    else:
-                        scr.move(self.scrsizey-1, 0)
-            except curses.error:
-                # Protect against errors from writing to the last line
-                pass
-            scr.clrtoeol()
-
-            # Position cursor
-            if self.mode in self.prompts:
-                history = self.prompts[self.mode]
-                scr.move(self.scrsizey-1, inputstartx+history.curx)
-            else:
-                scr.move(
-                    1+self._headerlines+level.cury-level.datastarty,
-                    level.numbersizex+3+level.curx-level.datastartx
-                )
-            scr.refresh()
-
-            # Check keyboard
-            while True:
-                c = scr.getch()
-                if self.resized:
-                    size = fcntl.ioctl(0, tty.TIOCGWINSZ, "12345678")
-                    size = struct.unpack("4H", size)
-                    oldsize = scr.getmaxyx()
-                    scr.erase()
-                    curses.resize_term(size[0], size[1])
-                    newsize = scr.getmaxyx()
-                    scr.erase()
-                    for l in self.levels:
-                        l.mainsizey += newsize[0]-oldsize[0]
-                        l.moveto(l.curx, l.cury, refresh=True)
-                    scr.refresh()
-                    self.resized = False
-                    break # Redisplay
-                if self.mode in self.prompts:
-                    if self.prompts[self.mode].handlekey(self, c):
-                       break # Redisplay
-                else:
-                    # if no key is pressed slow down and beep again
-                    if c == -1:
-                        self.stepx = 1.
-                        self.stepy = 1.
-                        self._dobeep = True
-                    else:
-                        # if a different key was pressed slow down and beep too
-                        if c != lastc:
-                            lastc = c
-                            self.stepx = 1.
-                            self.stepy = 1.
-                            self._dobeep = True
-                        cmdname = self.keymap.get(c, None)
-                        if cmdname is None:
-                            self.report(
-                                UnassignedKeyError("Unassigned key %s" %
-                                                   self.keylabel(c)))
-                        else:
-                            cmdfunc = getattr(self, "cmd_%s" % cmdname, None)
-                            if cmdfunc is None:
-                                self.report(
-                                    UnknownCommandError("Unknown command %r" %
-                                                        (cmdname,)))
-                            elif cmdfunc():
-                                returnvalue = self.returnvalue
-                                self.returnvalue = None
-                                return returnvalue
-                        self.stepx = self.nextstepx(self.stepx)
-                        self.stepy = self.nextstepy(self.stepy)
-                        curses.flushinp() # get rid of type ahead
-                        break # Redisplay
-        self.scr = None
-
-    def display(self):
-        if hasattr(curses, "resize_term") and hasattr(signal, 'SIGWINCH'):
-            oldhandler = signal.signal(signal.SIGWINCH, self.sigwinchhandler)
-            try:
-                return curses.wrapper(self._dodisplay)
-            finally:
-                signal.signal(signal.SIGWINCH, oldhandler)
-        else:
-            return curses.wrapper(self._dodisplay)
diff --git a/IPython/deathrow/igrid.py b/IPython/deathrow/igrid.py
deleted file mode 100644
index b49793cc419..00000000000
--- a/IPython/deathrow/igrid.py
+++ /dev/null
@@ -1,1126 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-
-import ipipe, os, webbrowser, urllib
-from IPython.core import ipapi
-import wx
-import wx.grid, wx.html
-
-try:
-    sorted
-except NameError:
-    from ipipe import sorted
-try:
-    set
-except:
-    from sets import Set as set
-
-
-__all__ = ["igrid"]
-
-
-help = """
-<?xml version='1.0' encoding='iso-8859-1'?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-<link rel="stylesheet" href="igrid_help.css" type="text/css" />
-<title>igrid help</title>
-</head>
-<body>
-<h1>igrid help</h1>
-
-
-<h2>Commands</h2>
-
-
-<h3>pick (P)</h3>
-<p>Pick the whole row (object is available as "_")</p>
-
-<h3>pickattr (Shift-P)</h3>
-<p>Pick the attribute under the cursor</p>
-
-<h3>pickallattrs (Shift-C)</h3>
-<p>Pick the complete column under the cursor (i.e. the attribute under the
-cursor) from all currently fetched objects. These attributes will be returned
-as a list.</p>
-
-<h3>pickinput (I)</h3>
-<p>Pick the current row as next input line in IPython. Additionally the row is stored as "_"</p>
-
-<h3>pickinputattr (Shift-I)</h3>
-<p>Pick the attribute under the cursor as next input line in IPython. Additionally the row is stored as "_"</p>
-
-<h3>enter (E)</h3>
-<p>Enter the object under the cursor. (what this mean depends on the object
-itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
-
-<h3>enterattr (Shift-E)</h3>
-<p>Enter the attribute under the cursor.</p>
-
-<h3>detail (D)</h3>
-<p>Show a detail view of the object under the cursor. This shows the name,
-type, doc string and value of the object attributes (and it might show more
-attributes than in the list view, depending on the object).</p>
-
-<h3>detailattr (Shift-D)</h3>
-<p>Show a detail view of the attribute under the cursor.</p>
-
-<h3>pickrows (M)</h3>
-<p>Pick multiple selected rows (M)</p>
-
-<h3>pickrowsattr (CTRL-M)</h3>
-<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
-
-<h3>find (CTRL-F)</h3>
-<p>Find text</p>
-
-<h3>find_expression (CTRL-Shift-F)</h3>
-<p>Find entries matching an expression</p>
-
-<h3>find_next (F3)</h3>
-<p>Find next occurrence</p>
-
-<h3>find_previous (Shift-F3)</h3>
-<p>Find previous occurrence</p>
-
-<h3>sortattrasc (V)</h3>
-<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>sortattrdesc (Shift-V)</h3>
-<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>refresh_once (R, F5)</h3>
-<p>Refreshes the display by restarting the iterator</p>
-
-<h3>refresh_every_second</h3>
-<p>Refreshes the display by restarting the iterator every second until stopped by stop_refresh.</p>
-
-<h3>refresh_interval</h3>
-<p>Refreshes the display by restarting the iterator every X ms (X is a custom interval set by the user) until stopped by stop_refresh.</p>
-
-<h3>stop_refresh</h3>
-<p>Stops all refresh timers.</p>
-
-<h3>leave (Backspace, DEL, X)</h3>
-<p>Close current tab (and all the tabs to the right of the current one).</h3>
-
-<h3>quit (ESC,Q)</h3>
-<p>Quit igrid and return to the IPython prompt.</p>
-
-
-<h2>Navigation</h2>
-
-
-<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
-
-<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
-
-<h3>Move the cursor one column to the left (&lt;)</h3>
-
-<h3>Move the cursor one column to the right (&gt;)</h3>
-
-<h3>Jump to the first row in the current column (CTRL-Up)</h3>
-
-<h3>Jump to the last row in the current column (CTRL-Down)</h3>
-
-</body>
-</html>
-
-"""
-
-
-class IGridRenderer(wx.grid.PyGridCellRenderer):
-    """
-    This is a custom renderer for our IGridGrid
-    """
-    def __init__(self, table):
-        self.maxchars = 200
-        self.table = table
-        self.colormap = (
-            (  0,   0,   0),
-            (174,   0,   0),
-            (  0, 174,   0),
-            (174, 174,   0),
-            (  0,   0, 174),
-            (174,   0, 174),
-            (  0, 174, 174),
-            ( 64,  64,  64)
-        )
-
-        wx.grid.PyGridCellRenderer.__init__(self)
-
-    def _getvalue(self, row, col):
-        try:
-            value = self.table._displayattrs[col].value(self.table.items[row])
-            (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
-        except Exception, exc:
-            (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
-        return (align, text)
-
-    def GetBestSize(self, grid, attr, dc, row, col):
-        text = grid.GetCellValue(row, col)
-        (align, text) = self._getvalue(row, col)
-        dc.SetFont(attr.GetFont())
-        (w, h) = dc.GetTextExtent(str(text))
-        return wx.Size(min(w+2, 600), h+2) # add border
-
-    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
-        """
-        Takes care of drawing everything in the cell; aligns the text
-        """
-        text = grid.GetCellValue(row, col)
-        (align, text) = self._getvalue(row, col)
-        if isSelected:
-            bg = grid.GetSelectionBackground()
-        else:
-            bg = ["white", (240, 240, 240)][row%2]
-        dc.SetTextBackground(bg)
-        dc.SetBrush(wx.Brush(bg, wx.SOLID))
-        dc.SetPen(wx.TRANSPARENT_PEN)
-        dc.SetFont(attr.GetFont())
-        dc.DrawRectangleRect(rect)
-        dc.SetClippingRect(rect)
-        # Format the text
-        if align == -1: # left alignment
-            (width, height) = dc.GetTextExtent(str(text))
-            x = rect[0]+1
-            y = rect[1]+0.5*(rect[3]-height)
-
-            for (style, part) in text:
-                if isSelected:
-                    fg = grid.GetSelectionForeground()
-                else:
-                    fg = self.colormap[style.fg]
-                dc.SetTextForeground(fg)
-                (w, h) = dc.GetTextExtent(part)
-                dc.DrawText(part, x, y)
-                x += w
-        elif align == 0: # center alignment
-            (width, height) = dc.GetTextExtent(str(text))
-            x = rect[0]+0.5*(rect[2]-width)
-            y = rect[1]+0.5*(rect[3]-height)
-            for (style, part) in text:
-                if isSelected:
-                    fg = grid.GetSelectionForeground()
-                else:
-                    fg = self.colormap[style.fg]
-                dc.SetTextForeground(fg)
-                (w, h) = dc.GetTextExtent(part)
-                dc.DrawText(part, x, y)
-                x += w
-        else:  # right alignment
-            (width, height) = dc.GetTextExtent(str(text))
-            x = rect[0]+rect[2]-1
-            y = rect[1]+0.5*(rect[3]-height)
-            for (style, part) in reversed(text):
-                (w, h) = dc.GetTextExtent(part)
-                x -= w
-                if isSelected:
-                    fg = grid.GetSelectionForeground()
-                else:
-                    fg = self.colormap[style.fg]
-                dc.SetTextForeground(fg)
-                dc.DrawText(part, x, y)
-        dc.DestroyClippingRegion()
-
-    def Clone(self):
-        return IGridRenderer(self.table)
-
-
-class IGridTable(wx.grid.PyGridTableBase):
-    # The data table for the ``IGridGrid``. Some dirty tricks were used here:
-    # ``GetValue()`` does not get any values (or at least it does not return
-    # anything, accessing the values is done by the renderer)
-    # but rather tries to fetch the objects which were requested into the table.
-    # General behaviour is: Fetch the first X objects. If the user scrolls down
-    # to the last object another bunch of X objects is fetched (if possible)
-    def __init__(self, input, fontsize, *attrs):
-        wx.grid.PyGridTableBase.__init__(self)
-        self.input = input
-        self.iterator = ipipe.xiter(input)
-        self.items = []
-        self.attrs = [ipipe.upgradexattr(attr) for attr in attrs]
-        self._displayattrs = self.attrs[:]
-        self._displayattrset = set(self.attrs)
-        self.fontsize = fontsize
-        self._fetch(1)
-        self.timer = wx.Timer()
-        self.timer.Bind(wx.EVT_TIMER, self.refresh_content)
-
-    def GetAttr(self, *args):
-        attr = wx.grid.GridCellAttr()
-        attr.SetFont(wx.Font(self.fontsize, wx.TELETYPE, wx.NORMAL, wx.NORMAL))
-        return attr
-
-    def GetNumberRows(self):
-        return len(self.items)
-
-    def GetNumberCols(self):
-        return len(self._displayattrs)
-
-    def GetColLabelValue(self, col):
-        if col < len(self._displayattrs):
-            return self._displayattrs[col].name()
-        else:
-            return ""
-
-    def GetRowLabelValue(self, row):
-        return str(row)
-
-    def IsEmptyCell(self, row, col):
-        return False
-
-    def _append(self, item):
-        self.items.append(item)
-        # Nothing to do if the set of attributes has been fixed by the user
-        if not self.attrs:
-            for attr in ipipe.xattrs(item):
-                attr = ipipe.upgradexattr(attr)
-                if attr not in self._displayattrset:
-                    self._displayattrs.append(attr)
-                    self._displayattrset.add(attr)
-
-    def _fetch(self, count):
-        # Try to fill ``self.items`` with at least ``count`` objects.
-        have = len(self.items)
-        while self.iterator is not None and have < count:
-            try:
-                item = self.iterator.next()
-            except StopIteration:
-                self.iterator = None
-                break
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                have += 1
-                self._append(exc)
-                self.iterator = None
-                break
-            else:
-                have += 1
-                self._append(item)
-
-    def GetValue(self, row, col):
-        # some kind of dummy-function: does not return anything but "";
-        # (The value isn't use anyway)
-        # its main task is to trigger the fetch of new objects
-        sizing_needed = False
-        had_cols = len(self._displayattrs)
-        had_rows = len(self.items)
-        if row == had_rows - 1 and self.iterator is not None:
-            self._fetch(row + 20)
-            sizing_needed = True
-        have_rows = len(self.items)
-        have_cols = len(self._displayattrs)
-        if have_rows > had_rows:
-            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, have_rows - had_rows)
-            self.GetView().ProcessTableMessage(msg)
-            sizing_needed = True
-        if row >= have_rows:
-            return ""
-        if have_cols != had_cols:
-            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED, have_cols - had_cols)
-            self.GetView().ProcessTableMessage(msg)
-            sizing_needed = True
-        if sizing_needed:
-            self.GetView().AutoSizeColumns(False)
-        return ""
-
-    def SetValue(self, row, col, value):
-        pass
-
-    def refresh_content(self, event):
-        msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, 0, self.GetNumberRows())
-        self.GetView().ProcessTableMessage(msg)
-        self.iterator = ipipe.xiter(self.input)
-        self.items = []
-        self.attrs = [] # _append will calculate new displayattrs
-        self._fetch(1) # fetch one...
-        if self.items:
-            msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
-            self.GetView().ProcessTableMessage(msg)
-            self.GetValue(0, 0) # and trigger "fetch next 20"
-            item = self.items[0]
-            self.GetView().AutoSizeColumns(False)
-            panel = self.GetView().GetParent()
-            nb = panel.GetParent()
-            current = nb.GetSelection()
-            if nb.GetPage(current) == panel:
-                self.GetView().set_footer(item)
-
-class IGridGrid(wx.grid.Grid):
-    # The actual grid
-    # all methods for selecting/sorting/picking/... data are implemented here
-    def __init__(self, panel, input, *attrs):
-        wx.grid.Grid.__init__(self, panel)
-        fontsize = 9
-        self.input = input
-        self.table = IGridTable(self.input, fontsize, *attrs)
-        self.SetTable(self.table, True)
-        self.SetSelectionMode(wx.grid.Grid.wxGridSelectRows)
-        self.SetDefaultRenderer(IGridRenderer(self.table))
-        self.EnableEditing(False)
-        self.Bind(wx.EVT_KEY_DOWN, self.key_pressed)
-        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.cell_doubleclicked)
-        self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.cell_leftclicked)
-        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_DCLICK, self.label_doubleclicked)
-        self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_label_leftclick)
-        self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self._on_selected_range)
-        self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self._on_selected_cell)
-        self.current_selection = set()
-        self.maxchars = 200
-
-    def on_label_leftclick(self, event):
-        event.Skip()
-
-    def error_output(self, text):
-        wx.Bell()
-        frame = self.GetParent().GetParent().GetParent()
-        frame.SetStatusText(str(text))
-
-    def _on_selected_range(self, event):
-        # Internal update to the selection tracking lists
-        if event.Selecting():
-            # adding to the list...
-            self.current_selection.update(xrange(event.GetTopRow(), event.GetBottomRow()+1))
-        else:
-            # removal from list
-            for index in xrange(event.GetTopRow(), event.GetBottomRow()+1):
-                self.current_selection.discard(index)
-        event.Skip()
-
-    def _on_selected_cell(self, event):
-        # Internal update to the selection tracking list
-        self.current_selection = set([event.GetRow()])
-        event.Skip()
-
-    def sort(self, key, reverse=False):
-        """
-        Sort the current list of items using the key function ``key``. If
-        ``reverse`` is true the sort order is reversed.
-        """
-        row = self.GetGridCursorRow()
-        col = self.GetGridCursorCol()
-        curitem = self.table.items[row] # Remember where the cursor is now
-        # Sort items
-        def realkey(item):
-            try:
-                return key(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        try:
-            self.table.items = ipipe.deque(sorted(self.table.items, key=realkey, reverse=reverse))
-        except TypeError, exc:
-            self.error_output("Exception encountered: %s" % exc)
-            return
-        # Find out where the object under the cursor went
-        for (i, item) in enumerate(self.table.items):
-            if item is curitem:
-                self.SetGridCursor(i,col)
-                self.MakeCellVisible(i,col)
-                self.Refresh()
-
-    def sortattrasc(self):
-        """
-        Sort in ascending order; sorting criteria is the current attribute
-        """
-        col = self.GetGridCursorCol()
-        attr = self.table._displayattrs[col]
-        frame = self.GetParent().GetParent().GetParent()
-        if attr is ipipe.noitem:
-            self.error_output("no column under cursor")
-            return
-        frame.SetStatusText("sort by %s (ascending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        self.sort(key)
-
-    def sortattrdesc(self):
-        """
-        Sort in descending order; sorting criteria is the current attribute
-        """
-        col = self.GetGridCursorCol()
-        attr = self.table._displayattrs[col]
-        frame = self.GetParent().GetParent().GetParent()
-        if attr is ipipe.noitem:
-            self.error_output("no column under cursor")
-            return
-        frame.SetStatusText("sort by %s (descending)" % attr.name())
-        def key(item):
-            try:
-                return attr.value(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception:
-                return None
-        self.sort(key, reverse=True)
-
-    def label_doubleclicked(self, event):
-        row = event.GetRow()
-        col = event.GetCol()
-        if col == -1:
-            self.enter(row)
-
-    def _getvalue(self, row, col):
-        """
-        Gets the text which is displayed at ``(row, col)``
-        """
-        try:
-            value = self.table._displayattrs[col].value(self.table.items[row])
-            (align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
-        except IndexError:
-            raise IndexError
-        except Exception, exc:
-            (align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
-        return text
-
-    def searchexpression(self, searchexp, startrow=None, search_forward=True ):
-        """
-        Find by expression
-        """
-        frame = self.GetParent().GetParent().GetParent()
-        if searchexp:
-            if search_forward:
-                if not startrow:
-                    row = self.GetGridCursorRow()+1
-                else:
-                    row = startrow + 1
-                while True:
-                    try:
-                        foo = self.table.GetValue(row, 0)
-                        item = self.table.items[row]
-                        try:
-                            globals = ipipe.getglobals(None)
-                            if eval(searchexp, globals, ipipe.AttrNamespace(item)):
-                                self.SetGridCursor(row, 0) # found something
-                                self.MakeCellVisible(row, 0)
-                                break
-                        except (KeyboardInterrupt, SystemExit):
-                            raise
-                        except Exception, exc:
-                            frame.SetStatusText(str(exc))
-                            wx.Bell()
-                            break  # break on error
-                    except IndexError:
-                        return
-                    row += 1
-            else:
-                if not startrow:
-                    row = self.GetGridCursorRow() - 1
-                else:
-                    row = startrow - 1
-                while True:
-                    try:
-                        foo = self.table.GetValue(row, 0)
-                        item = self.table.items[row]
-                        try:
-                            globals = ipipe.getglobals(None)
-                            if eval(searchexp, globals, ipipe.AttrNamespace(item)):
-                                self.SetGridCursor(row, 0) # found something
-                                self.MakeCellVisible(row, 0)
-                                break
-                        except (KeyboardInterrupt, SystemExit):
-                            raise
-                        except Exception, exc:
-                            frame.SetStatusText(str(exc))
-                            wx.Bell()
-                            break  # break on error
-                    except IndexError:
-                        return
-                    row -= 1
-
-
-    def search(self, searchtext, startrow=None, startcol=None, search_forward=True):
-        """
-        search for ``searchtext``, starting in ``(startrow, startcol)``;
-        if ``search_forward`` is true the direction is "forward"
-        """
-        searchtext = searchtext.lower()
-        if search_forward:
-            if startrow is not None and startcol is not None:
-                row = startrow
-            else:
-                startcol = self.GetGridCursorCol() + 1
-                row = self.GetGridCursorRow()
-                if startcol >= self.GetNumberCols():
-                    startcol = 0
-                    row += 1
-            while True:
-                for col in xrange(startcol, self.table.GetNumberCols()):
-                    try:
-                        foo = self.table.GetValue(row, col)
-                        text = self._getvalue(row, col)
-                        if searchtext in text.string().lower():
-                            self.SetGridCursor(row, col)
-                            self.MakeCellVisible(row, col)
-                            return
-                    except IndexError:
-                        return
-                startcol = 0
-                row += 1
-        else:
-            if startrow is not None and startcol is not None:
-                row = startrow
-            else:
-                startcol = self.GetGridCursorCol() - 1
-                row = self.GetGridCursorRow()
-                if startcol < 0:
-                    startcol = self.GetNumberCols() - 1
-                    row -= 1
-            while True:
-                for col in xrange(startcol, -1, -1):
-                    try:
-                        foo = self.table.GetValue(row, col)
-                        text = self._getvalue(row, col)
-                        if searchtext in text.string().lower():
-                            self.SetGridCursor(row, col)
-                            self.MakeCellVisible(row, col)
-                            return
-                    except IndexError:
-                        return
-                startcol = self.table.GetNumberCols()-1
-                row -= 1
-
-    def key_pressed(self, event):
-        """
-        Maps pressed keys to functions
-        """
-        frame = self.GetParent().GetParent().GetParent()
-        frame.SetStatusText("")
-        sh = event.ShiftDown()
-        ctrl = event.ControlDown()
-
-        keycode = event.GetKeyCode()
-        if keycode == ord("P"):
-            row = self.GetGridCursorRow()
-            if sh:
-                col = self.GetGridCursorCol()
-                self.pickattr(row, col)
-            else:
-                self.pick(row)
-        elif keycode == ord("M"):
-            if ctrl:
-                col = self.GetGridCursorCol()
-                self.pickrowsattr(sorted(self.current_selection), col)
-            else:
-                self.pickrows(sorted(self.current_selection))
-        elif keycode in (wx.WXK_BACK, wx.WXK_DELETE, ord("X")) and not (ctrl or sh):
-            self.delete_current_notebook()
-        elif keycode in (ord("E"), ord("\r")):
-            row = self.GetGridCursorRow()
-            if sh:
-                col = self.GetGridCursorCol()
-                self.enterattr(row, col)
-            else:
-                self.enter(row)
-        elif keycode == ord("E") and ctrl:
-            row = self.GetGridCursorRow()
-            self.SetGridCursor(row, self.GetNumberCols()-1)
-        elif keycode == wx.WXK_HOME or (keycode == ord("A") and ctrl):
-            row = self.GetGridCursorRow()
-            self.SetGridCursor(row, 0)
-        elif keycode == ord("C") and sh:
-            col = self.GetGridCursorCol()
-            attr = self.table._displayattrs[col]
-            result = []
-            for i in xrange(self.GetNumberRows()):
-                result.append(self.table._displayattrs[col].value(self.table.items[i]))
-            self.quit(result)
-        elif keycode in (wx.WXK_ESCAPE, ord("Q")) and not (ctrl or sh):
-            self.quit()
-        elif keycode == ord("<"):
-            row = self.GetGridCursorRow()
-            col = self.GetGridCursorCol()
-            if not event.ShiftDown():
-                newcol = col - 1
-                if newcol >= 0:
-                    self.SetGridCursor(row, col - 1)
-            else:
-                newcol = col + 1
-                if newcol < self.GetNumberCols():
-                    self.SetGridCursor(row, col + 1)
-        elif keycode == ord("D"):
-            col = self.GetGridCursorCol()
-            row = self.GetGridCursorRow()
-            if not sh:
-                self.detail(row, col)
-            else:
-                self.detail_attr(row, col)
-        elif keycode == ord("F") and ctrl:
-            if sh:
-                frame.enter_searchexpression(event)
-            else:
-                frame.enter_searchtext(event)
-        elif keycode == wx.WXK_F3:
-            if sh:
-                frame.find_previous(event)
-            else:
-                frame.find_next(event)
-        elif keycode == ord("V"):
-            if sh:
-                self.sortattrdesc()
-            else:
-                self.sortattrasc()
-        elif keycode == wx.WXK_DOWN:
-            row = self.GetGridCursorRow()
-            try:
-                item = self.table.items[row+1]
-            except IndexError:
-                item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == wx.WXK_UP:
-            row = self.GetGridCursorRow()
-            if row >= 1:
-                item = self.table.items[row-1]
-            else:
-                item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == wx.WXK_RIGHT:
-            row = self.GetGridCursorRow()
-            item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == wx.WXK_LEFT:
-            row = self.GetGridCursorRow()
-            item = self.table.items[row]
-            self.set_footer(item)
-            event.Skip()
-        elif keycode == ord("R") or keycode == wx.WXK_F5:
-            self.table.refresh_content(event)
-        elif keycode == ord("I"):
-            row = self.GetGridCursorRow()
-            if not sh:
-                self.pickinput(row)
-            else:
-                col = self.GetGridCursorCol()
-                self.pickinputattr(row, col)
-        else:
-            event.Skip()
-
-    def delete_current_notebook(self):
-        """
-        deletes the current notebook tab
-        """
-        panel = self.GetParent()
-        nb = panel.GetParent()
-        current = nb.GetSelection()
-        count = nb.GetPageCount()
-        if count > 1:
-            for i in xrange(count-1, current-1, -1):
-                nb.DeletePage(i)
-            nb.GetCurrentPage().grid.SetFocus()
-        else:
-            frame = nb.GetParent()
-            frame.SetStatusText("This is the last level!")
-
-    def _doenter(self, value, *attrs):
-        """
-        "enter" a special item resulting in a new notebook tab
-        """
-        panel = self.GetParent()
-        nb = panel.GetParent()
-        frame = nb.GetParent()
-        current = nb.GetSelection()
-        count = nb.GetPageCount()
-        try: # if we want to enter something non-iterable, e.g. a function
-            if current + 1 == count and value is not self.input: # we have an event in the last tab
-                frame._add_notebook(value, *attrs)
-            elif value != self.input: # we have to delete all tabs newer than [panel] first
-                for i in xrange(count-1, current, -1): # some tabs don't close if we don't close in *reverse* order
-                    nb.DeletePage(i)
-                frame._add_notebook(value)
-        except TypeError, exc:
-            if exc.__class__.__module__ == "exceptions":
-                msg = "%s: %s" % (exc.__class__.__name__, exc)
-            else:
-                msg = "%s.%s: %s" % (exc.__class__.__module__, exc.__class__.__name__, exc)
-            frame.SetStatusText(msg)
-
-    def enterattr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            value = attr.value(self.table.items[row])
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            self._doenter(value)
-
-    def set_footer(self, item):
-        frame = self.GetParent().GetParent().GetParent()
-        frame.SetStatusText(" ".join([str(text) for (style, text) in ipipe.xformat(item, "footer", 20)[2]]), 0)
-
-    def enter(self, row):
-        try:
-            value = self.table.items[row]
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            self._doenter(value)
-
-    def detail(self, row, col):
-        """
-        shows a detail-view of the current cell
-        """
-        try:
-            attr = self.table._displayattrs[col]
-            item = self.table.items[row]
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-            self._doenter(attrs)
-
-    def detail_attr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            item = attr.value(self.table.items[row])
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
-            self._doenter(attrs)
-
-    def quit(self, result=None):
-        """
-        quit
-        """
-        frame = self.GetParent().GetParent().GetParent()
-        if frame.helpdialog:
-            frame.helpdialog.Destroy()
-        app = frame.parent
-        if app is not None:
-            app.result = result
-        frame.Close()
-        frame.Destroy()
-
-    def cell_doubleclicked(self, event):
-        self.enterattr(event.GetRow(), event.GetCol())
-        event.Skip()
-
-    def cell_leftclicked(self, event):
-        row = event.GetRow()
-        item = self.table.items[row]
-        self.set_footer(item)
-        event.Skip()
-
-    def pick(self, row):
-        """
-        pick a single row and return to the IPython prompt
-        """
-        try:
-            value = self.table.items[row]
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(value)
-
-    def pickinput(self, row):
-        try:
-            value = self.table.items[row]
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            api = ipapi.get()
-            api.set_next_input(str(value))
-            self.quit(value)
-
-    def pickinputattr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            value = attr.value(self.table.items[row])
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            api = ipapi.get()
-            api.set_next_input(str(value))
-            self.quit(value)
-
-    def pickrows(self, rows):
-        """
-        pick multiple rows and return to the IPython prompt
-        """
-        try:
-            value = [self.table.items[row] for row in rows]
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(value)
-
-    def pickrowsattr(self, rows, col):
-        """"
-        pick one column from multiple rows
-        """
-        values = []
-        try:
-            attr = self.table._displayattrs[col]
-            for row in rows:
-                try:
-                    values.append(attr.value(self.table.items[row]))
-                except (SystemExit, KeyboardInterrupt):
-                    raise
-                except Exception:
-                    raise #pass
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(values)
-
-    def pickattr(self, row, col):
-        try:
-            attr = self.table._displayattrs[col]
-            value = attr.value(self.table.items[row])
-        except Exception, exc:
-            self.error_output(str(exc))
-        else:
-            self.quit(value)
-
-
-class IGridPanel(wx.Panel):
-    # Each IGridPanel contains an IGridGrid
-    def __init__(self, parent, input, *attrs):
-        wx.Panel.__init__(self, parent, -1)
-        self.grid = IGridGrid(self, input, *attrs)
-        self.grid.FitInside()
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(self.grid, proportion=1, flag=wx.EXPAND | wx.ALL, border=10)
-        self.SetSizer(sizer)
-        sizer.Fit(self)
-        sizer.SetSizeHints(self)
-
-
-class IGridHTMLHelp(wx.Frame):
-    def __init__(self, parent, title, size):
-        wx.Frame.__init__(self, parent, -1, title, size=size)
-        html = wx.html.HtmlWindow(self)
-        if "gtk2" in wx.PlatformInfo:
-            html.SetStandardFonts()
-        html.SetPage(help)
-
-
-class IGridFrame(wx.Frame):
-    maxtitlelen = 30
-
-    def __init__(self, parent, input):
-        title =  " ".join([str(text) for (style, text) in ipipe.xformat(input, "header", 20)[2]])
-        wx.Frame.__init__(self, None, title=title, size=(640, 480))
-        self.menubar = wx.MenuBar()
-        self.menucounter = 100
-        self.m_help = wx.Menu()
-        self.m_search = wx.Menu()
-        self.m_sort = wx.Menu()
-        self.m_refresh = wx.Menu()
-        self.notebook = wx.Notebook(self, -1, style=0)
-        self.statusbar = self.CreateStatusBar(1, wx.ST_SIZEGRIP)
-        self.statusbar.SetFieldsCount(2)
-        self.SetStatusWidths([-1, 200])
-        self.parent = parent
-        self._add_notebook(input)
-        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
-        self.makemenu(self.m_sort, "&Sort (asc)\tV", "Sort ascending", self.sortasc)
-        self.makemenu(self.m_sort, "Sort (&desc)\tShift-V", "Sort descending", self.sortdesc)
-        self.makemenu(self.m_help, "&Help\tF1", "Help", self.display_help)
-#        self.makemenu(self.m_help, "&Show help in browser", "Show help in browser", self.display_help_in_browser)
-        self.makemenu(self.m_search, "&Find text\tCTRL-F", "Find text", self.enter_searchtext)
-        self.makemenu(self.m_search, "Find by &expression\tCTRL-Shift-F", "Find by expression", self.enter_searchexpression)
-        self.makemenu(self.m_search, "Find &next\tF3", "Find next", self.find_next)
-        self.makemenu(self.m_search, "Find &previous\tShift-F3", "Find previous", self.find_previous)
-        self.makemenu(self.m_refresh, "&Refresh once \tF5", "Refresh once", self.refresh_once)
-        self.makemenu(self.m_refresh, "Refresh every &1s", "Refresh every second", self.refresh_every_second)
-        self.makemenu(self.m_refresh, "Refresh every &X seconds", "Refresh every X seconds", self.refresh_interval)
-        self.makemenu(self.m_refresh, "&Stop all refresh timers", "Stop refresh timers", self.stop_refresh)
-        self.menubar.Append(self.m_search, "&Find")
-        self.menubar.Append(self.m_sort, "&Sort")
-        self.menubar.Append(self.m_refresh, "&Refresh")
-        self.menubar.Append(self.m_help, "&Help")
-        self.SetMenuBar(self.menubar)
-        self.searchtext = ""
-        self.searchexpression = ""
-        self.helpdialog = None
-        self.refresh_interval = 1000
-        self.SetStatusText("Refreshing inactive", 1)
-
-    def refresh_once(self, event):
-        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
-        table.refresh_content(event)
-
-    def refresh_interval(self, event):
-        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
-        dlg = wx.TextEntryDialog(self, "Enter refresh interval (milliseconds):", "Refresh timer:", defaultValue=str(self.refresh_interval))
-        if dlg.ShowModal() == wx.ID_OK:
-            try:
-                milliseconds = int(dlg.GetValue())
-            except ValueError, exc:
-                self.SetStatusText(str(exc))
-            else:
-                table.timer.Start(milliseconds=milliseconds, oneShot=False)
-                self.SetStatusText("Refresh timer set to %s ms" % milliseconds)
-                self.SetStatusText("Refresh interval: %s ms" % milliseconds, 1)
-                self.refresh_interval = milliseconds
-        dlg.Destroy()
-
-    def stop_refresh(self, event):
-        for i in xrange(self.notebook.GetPageCount()):
-            nb = self.notebook.GetPage(i)
-            nb.grid.table.timer.Stop()
-            self.SetStatusText("Refreshing inactive", 1)
-
-    def refresh_every_second(self, event):
-        table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
-        table.timer.Start(milliseconds=1000, oneShot=False)
-        self.SetStatusText("Refresh interval: 1000 ms", 1)
-
-    def sortasc(self, event):
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        grid.sortattrasc()
-
-    def sortdesc(self, event):
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        grid.sortattrdesc()
-
-    def find_previous(self, event):
-        """
-        find previous occurrences
-        """
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        if self.searchtext:
-            row = grid.GetGridCursorRow()
-            col = grid.GetGridCursorCol()
-            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
-            if col-1 >= 0:
-                grid.search(self.searchtext, row, col-1, False)
-            else:
-                grid.search(self.searchtext, row-1, grid.table.GetNumberCols()-1, False)
-        elif self.searchexpression:
-            self.SetStatusText("Search mode: expression; looking for %s" % repr(self.searchexpression)[2:-1])
-            grid.searchexpression(searchexp=self.searchexpression, search_forward=False)
-        else:
-            self.SetStatusText("No search yet: please enter search-text or -expression")
-
-    def find_next(self, event):
-        """
-        find the next occurrence
-        """
-        grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
-        if self.searchtext != "":
-            row = grid.GetGridCursorRow()
-            col = grid.GetGridCursorCol()
-            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
-            if col+1 < grid.table.GetNumberCols():
-                grid.search(self.searchtext, row, col+1)
-            else:
-                grid.search(self.searchtext, row+1, 0)
-        elif self.searchexpression != "":
-            self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
-            grid.searchexpression(searchexp=self.searchexpression)
-        else:
-            self.SetStatusText("No search yet: please enter search-text or -expression")
-
-    def display_help(self, event):
-        """
-        Display a help dialog
-        """
-        if self.helpdialog:
-            self.helpdialog.Destroy()
-        self.helpdialog = IGridHTMLHelp(None, title="Help", size=wx.Size(600,400))
-        self.helpdialog.Show()
-
-    def display_help_in_browser(self, event):
-        """
-        Show the help-HTML in a browser (as a ``HtmlWindow`` does not understand
-        CSS this looks better)
-        """
-        filename = urllib.pathname2url(os.path.abspath(os.path.join(os.path.dirname(__file__), "igrid_help.html")))
-        if not filename.startswith("file"):
-            filename = "file:" + filename
-        webbrowser.open(filename, new=1, autoraise=True)
-
-    def enter_searchexpression(self, event):
-        dlg = wx.TextEntryDialog(self, "Find:", "Find matching expression:", defaultValue=self.searchexpression)
-        if dlg.ShowModal() == wx.ID_OK:
-            self.searchexpression = dlg.GetValue()
-            self.searchtext = ""
-            self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
-            self.notebook.GetPage(self.notebook.GetSelection()).grid.searchexpression(self.searchexpression)
-        dlg.Destroy()
-
-    def makemenu(self, menu, label, help, cmd):
-        menu.Append(self.menucounter, label, help)
-        self.Bind(wx.EVT_MENU, cmd, id=self.menucounter)
-        self.menucounter += 1
-
-    def _add_notebook(self, input, *attrs):
-        # Adds another notebook which has the starting object ``input``
-        panel = IGridPanel(self.notebook, input, *attrs)
-        text = str(ipipe.xformat(input, "header", self.maxtitlelen)[2])
-        if len(text) >= self.maxtitlelen:
-            text = text[:self.maxtitlelen].rstrip(".") + "..."
-        self.notebook.AddPage(panel, text, True)
-        panel.grid.SetFocus()
-        self.Layout()
-
-    def OnCloseWindow(self, event):
-        self.Destroy()
-
-    def enter_searchtext(self, event):
-        # Displays a dialog asking for the searchtext
-        dlg = wx.TextEntryDialog(self, "Find:", "Find in list", defaultValue=self.searchtext)
-        if dlg.ShowModal() == wx.ID_OK:
-            self.searchtext = dlg.GetValue()
-            self.searchexpression = ""
-            self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
-            self.notebook.GetPage(self.notebook.GetSelection()).grid.search(self.searchtext)
-        dlg.Destroy()
-
-
-class App(wx.App):
-    def __init__(self, input):
-        self.input = input
-        self.result = None # Result to be returned to IPython. Set by quit().
-        wx.App.__init__(self)
-
-    def OnInit(self):
-        frame = IGridFrame(self, self.input)
-        frame.Show()
-        self.SetTopWindow(frame)
-        frame.Raise()
-        return True
-
-
-class igrid(ipipe.Display):
-    """
-    This is a wx-based display object that can be used instead of ``ibrowse``
-    (which is curses-based) or ``idump`` (which simply does a print).
-    """
-
-    if wx.VERSION < (2, 7):
-        def display(self):
-            try:
-                # Try to create a "standalone" frame. If this works we're probably
-                # running with -wthread.
-                # Note that this sets the parent of the frame to None, but we can't
-                # pass a result object back to the shell anyway.
-                frame = IGridFrame(None, self.input)
-                frame.Show()
-                frame.Raise()
-            except wx.PyNoAppError:
-                # There's no wx application yet => create one.
-                app = App(self.input)
-                app.MainLoop()
-                return app.result
-    else:
-        # With wx 2.7 it gets simpler.
-        def display(self):
-            app = App(self.input)
-            app.MainLoop()
-            return app.result
-
diff --git a/IPython/deathrow/igrid_help.css b/IPython/deathrow/igrid_help.css
deleted file mode 100644
index c875f4da816..00000000000
--- a/IPython/deathrow/igrid_help.css
+++ /dev/null
@@ -1,45 +0,0 @@
-body
-{
-	background-color: #fff;
-	color: #000;
-	font-family: "Verdana", "Arial", "XHelvetica", "Helvetica", sans-serif;
-	padding: 20px 30px;
-	margin: 0px;
-	font-size: 11px;
-}
-h1
-{
-	font-family: "Trebuchet MS", sans-serif;
-	font-size: 24px;
-	margin: -20px -30px 4px -30px;
-	padding: 6px 30px;
-	font-weight: normal;
-	border-bottom: 1px solid #000;
-	letter-spacing: 1px;
-	background-color: #666;
-	color: #fff;
-}
-h2
-{
-	font-family: "Trebuchet MS", sans-serif;
-	font-size: 20px;
-	padding: 14px 0px 2px 0px;
-	margin: 0px;
-	font-weight: bold;
-	color: #333;
-}
-h3
-{
-	font-family: "Trebuchet MS", sans-serif;
-	font-size: 14px;
-	padding: 12px 0px 2px 0px;
-	margin: 0px;
-	font-weight: bold;
-	color: #333;
-}
-p
-{
-	line-height: 120%;
-	margin: 0px 0px 6px 0px;
-	padding: 0px;
-}
diff --git a/IPython/deathrow/igrid_help.html b/IPython/deathrow/igrid_help.html
deleted file mode 100644
index 3c7122ee4d5..00000000000
--- a/IPython/deathrow/igrid_help.html
+++ /dev/null
@@ -1,86 +0,0 @@
-<?xml version='1.0' encoding='iso-8859-1'?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-<link rel="stylesheet" href="igrid_help.css" type="text/css" />
-<title>igrid help</title>
-</head>
-<body>
-<h1>igrid help</h1>
-
-
-<h2>Commands</h2>
-
-
-<h3>pick (P)</h3>
-<p>Pick the whole row (object is available as "_")</p>
-
-<h3>pickattr (Shift-P)</h3>
-<p>Pick the attribute under the cursor</p>
-
-<h3>pickallattrs (Shift-C)</h3>
-<p>Pick' the complete column under the cursor (i.e. the attribute under the
-cursor) from all currently fetched objects. These attributes will be returned
-as a list.</p>
-
-<h3>enter (E)</h3>
-<p>Enter the object under the cursor. (what this mean depends on the object
-itself, i.e. how it implements iteration). This opens a new browser 'level'.</p>
-
-<h3>enterattr (Shift-E)</h3>
-<p>Enter the attribute under the cursor.</p>
-
-<h3>detail (D)</h3>
-<p>Show a detail view of the object under the cursor. This shows the name,
-type, doc string and value of the object attributes (and it might show more
-attributes than in the list view, depending on the object).</p>
-
-<h3>detailattr (Shift-D)</h3>
-<p>Show a detail view of the attribute under the cursor.</p>
-
-<h3>pickrows (M)</h3>
-<p>Pick multiple selected rows (M)</p>
-
-<h3>pickrowsattr (CTRL-M)</h3>
-<p>From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)</p>
-
-<h3>find (CTRL-F)</h3>
-<p>Find text</p>
-
-<h3>find_next (F3)</h3>
-<p>Find next occurrence of the searchtext</p>
-
-<h3>find_previous (Shift-F3)</h3>
-<p>Find previous occurrence of the searchtext </p>
-
-<h3>sortattrasc (V)</h3>
-<p>Sort the objects (in ascending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>sortattrdesc (Shift-V)</h3>
-<p>Sort the objects (in descending order) using the attribute under the cursor as the sort key.</p>
-
-<h3>leave (Backspace, DEL, X)</h3>
-<p>Close current tab (and all the tabs to the right of the current one).</h3>
-
-<h3>quit (ESC,Q)</h3>
-<p>Quit igrid and return to the IPython prompt.</p>
-
-
-<h2>Navigation</h2>
-
-
-<h3>Jump to the last column of the current row (END, CTRL-E, CTRL-Right)</h3>
-
-<h3>Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)</h3>
-
-<h3>Move the cursor one column to the left (&lt;)</h3>
-
-<h3>Move the cursor one column to the right (&gt;)</h3>
-
-<h3>Jump to the first row in the current column (CTRL-Up)</h3>
-
-<h3>Jump to the last row in the current column (CTRL-Down)</h3>
-
-</body>
-</html>
diff --git a/IPython/deathrow/ipipe.py b/IPython/deathrow/ipipe.py
deleted file mode 100644
index 8c2766df700..00000000000
--- a/IPython/deathrow/ipipe.py
+++ /dev/null
@@ -1,2328 +0,0 @@
-# -*- coding: iso-8859-1 -*-
-
-"""
-``ipipe`` provides classes to be used in an interactive Python session. Doing a
-``from ipipe import *`` is the preferred way to do this. The name of all
-objects imported this way starts with ``i`` to minimize collisions.
-
-``ipipe`` supports "pipeline expressions", which is something resembling Unix
-pipes. An example is::
-
-    >>> ienv | isort("key.lower()")
-
-This gives a listing of all environment variables sorted by name.
-
-
-There are three types of objects in a pipeline expression:
-
-* ``Table``s: These objects produce items. Examples are ``ils`` (listing the
-  current directory, ``ienv`` (listing environment variables), ``ipwd`` (listing
-  user accounts) and ``igrp`` (listing user groups). A ``Table`` must be the
-  first object in a pipe expression.
-
-* ``Pipe``s: These objects sit in the middle of a pipe expression. They
-  transform the input in some way (e.g. filtering or sorting it). Examples are:
-  ``ifilter`` (which filters the input pipe), ``isort`` (which sorts the input
-  pipe) and ``ieval`` (which evaluates a function or expression for each object
-  in the input pipe).
-
-* ``Display``s: These objects can be put as the last object in a pipeline
-  expression. There are responsible for displaying the result of the pipeline
-  expression. If a pipeline expression doesn't end in a display object a default
-  display objects will be used. One example is ``ibrowse`` which is a ``curses``
-  based browser.
-
-
-Adding support for pipeline expressions to your own objects can be done through
-three extensions points (all of them optional):
-
-* An object that will be displayed as a row by a ``Display`` object should
-  implement the method ``__xattrs__(self, mode)`` method or register an
-  implementation of the generic function ``xattrs``. For more info see ``xattrs``.
-
-* When an object ``foo`` is displayed by a ``Display`` object, the generic
-  function ``xrepr`` is used.
-
-* Objects that can be iterated by ``Pipe``s must iterable. For special cases,
-  where iteration for display is different than the normal iteration a special
-  implementation can be registered with the generic function ``xiter``. This
-  makes it possible to use dictionaries and modules in pipeline expressions,
-  for example::
-
-      >>> import sys
-      >>> sys | ifilter("isinstance(value, int)") | idump
-      key        |value
-      api_version|      1012
-      dllhandle  | 503316480
-      hexversion |  33817328
-      maxint     |2147483647
-      maxunicode |     65535
-      >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
-      ...
-
-  Note: The expression strings passed to ``ifilter()`` and ``isort()`` can
-  refer to the object to be filtered or sorted via the variable ``_`` and to any
-  of the attributes of the object, i.e.::
-
-      >>> sys.modules | ifilter("_.value is not None") | isort("_.key.lower()")
-
-  does the same as::
-
-      >>> sys.modules | ifilter("value is not None") | isort("key.lower()")
-
-  In addition to expression strings, it's possible to pass callables (taking
-  the object as an argument) to ``ifilter()``, ``isort()`` and ``ieval()``::
-
-      >>> sys | ifilter(lambda _:isinstance(_.value, int)) \
-      ...     | ieval(lambda _: (_.key, hex(_.value))) | idump
-      0          |1
-      api_version|0x3f4
-      dllhandle  |0x1e000000
-      hexversion |0x20402f0
-      maxint     |0x7fffffff
-      maxunicode |0xffff
-"""
-
-skip_doctest = True  # ignore top-level docstring as a doctest.
-
-import sys, os, os.path, stat, glob, new, csv, datetime, types
-import itertools, mimetypes, StringIO
-
-try: # Python 2.3 compatibility
-    import collections
-except ImportError:
-    deque = list
-else:
-    deque = collections.deque
-
-try: # Python 2.3 compatibility
-    set
-except NameError:
-    import sets
-    set = sets.Set
-
-try: # Python 2.3 compatibility
-    sorted
-except NameError:
-    def sorted(iterator, key=None, reverse=False):
-        items = list(iterator)
-        if key is not None:
-            items.sort(lambda i1, i2: cmp(key(i1), key(i2)))
-        else:
-            items.sort()
-        if reverse:
-            items.reverse()
-        return items
-
-try: # Python 2.4 compatibility
-    GeneratorExit
-except NameError:
-    GeneratorExit = SystemExit
-
-try:
-    import pwd
-except ImportError:
-    pwd = None
-
-try:
-    import grp
-except ImportError:
-    grp = None
-
-from IPython.external import simplegeneric
-from IPython.external import path
-
-try:
-    import IPython.utils.io
-    from IPython.utils import generics
-except ImportError:
-    Term = None
-    generics = None
-
-from IPython.core import ipapi
-
-
-__all__ = [
-    "ifile", "ils", "iglob", "iwalk", "ipwdentry", "ipwd", "igrpentry", "igrp",
-    "icsv", "ix", "ichain", "isort", "ifilter", "ieval", "ienum",
-    "ienv", "ihist", "ialias", "icap", "idump", "iless"
-]
-
-
-os.stat_float_times(True) # enable microseconds
-
-
-class AttrNamespace(object):
-    """
-    Helper class that is used for providing a namespace for evaluating
-    expressions containing attribute names of an object.
-    """
-    def __init__(self, wrapped):
-        self.wrapped = wrapped
-
-    def __getitem__(self, name):
-        if name == "_":
-            return self.wrapped
-        try:
-            return getattr(self.wrapped, name)
-        except AttributeError:
-            raise KeyError(name)
-
-# Python 2.3 compatibility
-# use eval workaround to find out which names are used in the
-# eval string and put them into the locals. This works for most
-# normal uses case, bizarre ones like accessing the locals()
-# will fail
-try:
-    eval("_", None, AttrNamespace(None))
-except TypeError:
-    real_eval = eval
-    def eval(codestring, _globals, _locals):
-        """
-        eval(source[, globals[, locals]]) -> value
-
-        Evaluate the source in the context of globals and locals.
-        The source may be a string representing a Python expression
-        or a code object as returned by compile().
-        The globals must be a dictionary and locals can be any mappping.
-
-        This function is a workaround for the shortcomings of
-        Python 2.3's eval.
-        """
-
-        if isinstance(codestring, basestring):
-            code = compile(codestring, "_eval", "eval")
-        else:
-            code = codestring
-        newlocals = {}
-        for name in code.co_names:
-            try:
-                newlocals[name] = _locals[name]
-            except KeyError:
-                pass
-        return real_eval(code, _globals, newlocals)
-
-
-noitem = object()
-
-
-def item(iterator, index, default=noitem):
-    """
-    Return the ``index``th item from the iterator ``iterator``.
-    ``index`` must be an integer (negative integers are relative to the
-    end (i.e. the last items produced by the iterator)).
-
-    If ``default`` is given, this will be the default value when
-    the iterator doesn't contain an item at this position. Otherwise an
-    ``IndexError`` will be raised.
-
-    Note that using this function will partially or totally exhaust the
-    iterator.
-    """
-    i = index
-    if i>=0:
-        for item in iterator:
-            if not i:
-                return item
-            i -= 1
-    else:
-        i = -index
-        cache = deque()
-        for item in iterator:
-            cache.append(item)
-            if len(cache)>i:
-                cache.popleft()
-        if len(cache)==i:
-            return cache.popleft()
-    if default is noitem:
-        raise IndexError(index)
-    else:
-        return default
-
-
-def getglobals(g):
-    """
-    Return the global namespace that is used for expression strings in
-    ``ifilter`` and others. This is ``g`` or (if ``g`` is ``None``) IPython's
-    user namespace.
-    """
-    if g is None:
-        if ipapi is not None:
-            api = ipapi.get()
-            if api is not None:
-                return api.user_ns
-        return globals()
-    return g
-
-
-class Descriptor(object):
-    """
-    A ``Descriptor`` object is used for describing the attributes of objects.
-    """
-    def __hash__(self):
-        return hash(self.__class__) ^ hash(self.key())
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__ and self.key() == other.key()
-
-    def __ne__(self, other):
-        return self.__class__ is not other.__class__ or self.key() != other.key()
-
-    def key(self):
-        pass
-
-    def name(self):
-        """
-        Return the name of this attribute for display by a ``Display`` object
-        (e.g. as a column title).
-        """
-        key = self.key()
-        if key is None:
-            return "_"
-        return str(key)
-
-    def attrtype(self, obj):
-        """
-        Return the type of this attribute (i.e. something like "attribute" or
-        "method").
-        """
-
-    def valuetype(self, obj):
-        """
-        Return the type of this attribute value of the object ``obj``.
-        """
-
-    def value(self, obj):
-        """
-        Return the value of this attribute of the object ``obj``.
-        """
-
-    def doc(self, obj):
-        """
-        Return the documentation for this attribute.
-        """
-
-    def shortdoc(self, obj):
-        """
-        Return a short documentation for this attribute (defaulting to the
-        first line).
-        """
-        doc = self.doc(obj)
-        if doc is not None:
-            doc = doc.strip().splitlines()[0].strip()
-        return doc
-
-    def iter(self, obj):
-        """
-        Return an iterator for this attribute of the object ``obj``.
-        """
-        return xiter(self.value(obj))
-
-
-class SelfDescriptor(Descriptor):
-    """
-    A ``SelfDescriptor`` describes the object itself.
-    """
-    def key(self):
-        return None
-
-    def attrtype(self, obj):
-        return "self"
-
-    def valuetype(self, obj):
-        return type(obj)
-
-    def value(self, obj):
-        return obj
-
-    def __repr__(self):
-        return "Self"
-
-selfdescriptor = SelfDescriptor() # there's no need for more than one
-
-
-class AttributeDescriptor(Descriptor):
-    """
-    An ``AttributeDescriptor`` describes a simple attribute of an object.
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        return self._doc
-
-    def attrtype(self, obj):
-        return "attr"
-
-    def valuetype(self, obj):
-        return type(getattr(obj, self._name))
-
-    def value(self, obj):
-        return getattr(obj, self._name)
-
-    def __repr__(self):
-        if self._doc is None:
-            return "Attribute(%r)" % self._name
-        else:
-            return "Attribute(%r, %r)" % (self._name, self._doc)
-
-
-class IndexDescriptor(Descriptor):
-    """
-    An ``IndexDescriptor`` describes an "attribute" of an object that is fetched
-    via ``__getitem__``.
-    """
-    __slots__ = ("_index",)
-
-    def __init__(self, index):
-        self._index = index
-
-    def key(self):
-        return self._index
-
-    def attrtype(self, obj):
-        return "item"
-
-    def valuetype(self, obj):
-        return type(obj[self._index])
-
-    def value(self, obj):
-        return obj[self._index]
-
-    def __repr__(self):
-        return "Index(%r)" % self._index
-
-
-class MethodDescriptor(Descriptor):
-    """
-    A ``MethodDescriptor`` describes a method of an object that can be called
-    without argument. Note that this method shouldn't change the object.
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        if self._doc is None:
-            return getattr(obj, self._name).__doc__
-        return self._doc
-
-    def attrtype(self, obj):
-        return "method"
-
-    def valuetype(self, obj):
-        return type(self.value(obj))
-
-    def value(self, obj):
-        return getattr(obj, self._name)()
-
-    def __repr__(self):
-        if self._doc is None:
-            return "Method(%r)" % self._name
-        else:
-            return "Method(%r, %r)" % (self._name, self._doc)
-
-
-class IterAttributeDescriptor(Descriptor):
-    """
-    An ``IterAttributeDescriptor`` works like an ``AttributeDescriptor`` but
-    doesn't return an attribute values (because this value might be e.g. a large
-    list).
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        return self._doc
-
-    def attrtype(self, obj):
-        return "iter"
-
-    def valuetype(self, obj):
-        return noitem
-
-    def value(self, obj):
-        return noitem
-
-    def iter(self, obj):
-        return xiter(getattr(obj, self._name))
-
-    def __repr__(self):
-        if self._doc is None:
-            return "IterAttribute(%r)" % self._name
-        else:
-            return "IterAttribute(%r, %r)" % (self._name, self._doc)
-
-
-class IterMethodDescriptor(Descriptor):
-    """
-    An ``IterMethodDescriptor`` works like an ``MethodDescriptor`` but doesn't
-    return an attribute values (because this value might be e.g. a large list).
-    """
-    __slots__ = ("_name", "_doc")
-
-    def __init__(self, name, doc=None):
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._name
-
-    def doc(self, obj):
-        if self._doc is None:
-            return getattr(obj, self._name).__doc__
-        return self._doc
-
-    def attrtype(self, obj):
-        return "itermethod"
-
-    def valuetype(self, obj):
-        return noitem
-
-    def value(self, obj):
-        return noitem
-
-    def iter(self, obj):
-        return xiter(getattr(obj, self._name)())
-
-    def __repr__(self):
-        if self._doc is None:
-            return "IterMethod(%r)" % self._name
-        else:
-            return "IterMethod(%r, %r)" % (self._name, self._doc)
-
-
-class FunctionDescriptor(Descriptor):
-    """
-    A ``FunctionDescriptor`` turns a function into a descriptor. The function
-    will be called with the object to get the type and value of the attribute.
-    """
-    __slots__ = ("_function", "_name", "_doc")
-
-    def __init__(self, function, name=None, doc=None):
-        self._function = function
-        self._name = name
-        self._doc = doc
-
-    def key(self):
-        return self._function
-
-    def name(self):
-        if self._name is not None:
-            return self._name
-        return getattr(self._function, "__xname__", self._function.__name__)
-
-    def doc(self, obj):
-        if self._doc is None:
-            return self._function.__doc__
-        return self._doc
-
-    def attrtype(self, obj):
-        return "function"
-
-    def valuetype(self, obj):
-        return type(self._function(obj))
-
-    def value(self, obj):
-        return self._function(obj)
-
-    def __repr__(self):
-        if self._doc is None:
-            return "Function(%r)" % self._name
-        else:
-            return "Function(%r, %r)" % (self._name, self._doc)
-
-
-class Table(object):
-    """
-    A ``Table`` is an object that produces items (just like a normal Python
-    iterator/generator does) and can be used as the first object in a pipeline
-    expression. The displayhook will open the default browser for such an object
-    (instead of simply printing the ``repr()`` result).
-    """
-
-    # We want to support ``foo`` and ``foo()`` in pipeline expression:
-    # So we implement the required operators (``|`` and ``+``) in the metaclass,
-    # instantiate the class and forward the operator to the instance
-    class __metaclass__(type):
-        def __iter__(self):
-            return iter(self())
-
-        def __or__(self, other):
-            return self() | other
-
-        def __add__(self, other):
-            return self() + other
-
-        def __radd__(self, other):
-            return other + self()
-
-        def __getitem__(self, index):
-            return self()[index]
-
-    def __getitem__(self, index):
-        return item(self, index)
-
-    def __contains__(self, item):
-        for haveitem in self:
-            if item == haveitem:
-                return True
-        return False
-
-    def __or__(self, other):
-        # autoinstantiate right hand side
-        if isinstance(other, type) and issubclass(other, (Table, Display)):
-            other = other()
-        # treat simple strings and functions as ``ieval`` instances
-        elif not isinstance(other, Display) and not isinstance(other, Table):
-            other = ieval(other)
-        # forward operations to the right hand side
-        return other.__ror__(self)
-
-    def __add__(self, other):
-        # autoinstantiate right hand side
-        if isinstance(other, type) and issubclass(other, Table):
-            other = other()
-        return ichain(self, other)
-
-    def __radd__(self, other):
-        # autoinstantiate left hand side
-        if isinstance(other, type) and issubclass(other, Table):
-            other = other()
-        return ichain(other, self)
-
-
-class Pipe(Table):
-    """
-    A ``Pipe`` is an object that can be used in a pipeline expression. It
-    processes the objects it gets from its input ``Table``/``Pipe``. Note that
-    a ``Pipe`` object can't be used as the first object in a pipeline
-    expression, as it doesn't produces items itself.
-    """
-    class __metaclass__(Table.__metaclass__):
-        def __ror__(self, input):
-            return input | self()
-
-    def __ror__(self, input):
-        # autoinstantiate left hand side
-        if isinstance(input, type) and issubclass(input, Table):
-            input = input()
-        self.input = input
-        return self
-
-
-def xrepr(item, mode="default"):
-    """
-    Generic function that adds color output and different display modes to ``repr``.
-
-    The result of an ``xrepr`` call is iterable and consists of ``(style, string)``
-    tuples. The ``style`` in this tuple must be a ``Style`` object from the
-    ``astring`` module. To reconfigure the output the first yielded tuple can be
-    a ``(aligment, full)`` tuple instead of a ``(style, string)`` tuple.
-    ``alignment``  can be -1 for left aligned, 0 for centered and 1 for right
-    aligned (the default is left alignment). ``full`` is a boolean that specifies
-    whether the complete output must be displayed or the ``Display`` object is
-    allowed to stop output after enough text has been produced (e.g. a syntax
-    highlighted text line would use ``True``, but for a large data structure
-    (i.e. a nested list, tuple or dictionary) ``False`` would be used).
-    The default is full output.
-
-    There are four different possible values for ``mode`` depending on where
-    the ``Display`` object will display ``item``:
-
-    ``"header"``
-        ``item`` will be displayed in a header line (this is used by ``ibrowse``).
-
-    ``"footer"``
-        ``item`` will be displayed in a footer line (this is used by ``ibrowse``).
-
-    ``"cell"``
-        ``item`` will be displayed in a table cell/list.
-
-    ``"default"``
-        default mode. If an ``xrepr`` implementation recursively outputs objects,
-        ``"default"`` must be passed in the recursive calls to ``xrepr``.
-
-    If no implementation is registered for ``item``, ``xrepr`` will try the
-    ``__xrepr__`` method on ``item``. If ``item`` doesn't have an ``__xrepr__``
-    method it falls back to ``repr``/``__repr__`` for all modes.
-    """
-    try:
-        func = item.__xrepr__
-    except AttributeError:
-        yield (astyle.style_default, repr(item))
-    else:
-        try:
-            for x in func(mode):
-                yield x
-        except (KeyboardInterrupt, SystemExit, GeneratorExit):
-            raise
-        except Exception:
-            yield (astyle.style_default, repr(item))
-xrepr = simplegeneric.generic(xrepr)
-
-
-def xrepr_none(self, mode="default"):
-    yield (astyle.style_type_none, repr(self))
-xrepr.when_object(None)(xrepr_none)
-
-
-def xrepr_noitem(self, mode="default"):
-    yield (2, True)
-    yield (astyle.style_nodata, "<?>")
-xrepr.when_object(noitem)(xrepr_noitem)
-
-
-def xrepr_bool(self, mode="default"):
-    yield (astyle.style_type_bool, repr(self))
-xrepr.when_type(bool)(xrepr_bool)
-
-
-def xrepr_str(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_default, repr(self.expandtabs(tab))[1:-1])
-    else:
-        yield (astyle.style_default, repr(self))
-xrepr.when_type(str)(xrepr_str)
-
-
-def xrepr_unicode(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_default, repr(self.expandtabs(tab))[2:-1])
-    else:
-        yield (astyle.style_default, repr(self))
-xrepr.when_type(unicode)(xrepr_unicode)
-
-
-def xrepr_number(self, mode="default"):
-    yield (1, True)
-    yield (astyle.style_type_number, repr(self))
-xrepr.when_type(int)(xrepr_number)
-xrepr.when_type(long)(xrepr_number)
-xrepr.when_type(float)(xrepr_number)
-
-
-def xrepr_complex(self, mode="default"):
-    yield (astyle.style_type_number, repr(self))
-xrepr.when_type(complex)(xrepr_number)
-
-
-def xrepr_datetime(self, mode="default"):
-    if mode == "cell":
-        # Don't use strftime() here, as this requires year >= 1900
-        yield (astyle.style_type_datetime,
-               "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
-                    (self.year, self.month, self.day,
-                     self.hour, self.minute, self.second,
-                     self.microsecond),
-                )
-    else:
-        yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.datetime)(xrepr_datetime)
-
-
-def xrepr_date(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_type_datetime,
-               "%04d-%02d-%02d" % (self.year, self.month, self.day))
-    else:
-        yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.date)(xrepr_date)
-
-
-def xrepr_time(self, mode="default"):
-    if mode == "cell":
-        yield (astyle.style_type_datetime,
-                "%02d:%02d:%02d.%06d" % \
-                    (self.hour, self.minute, self.second, self.microsecond))
-    else:
-        yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.time)(xrepr_time)
-
-
-def xrepr_timedelta(self, mode="default"):
-    yield (astyle.style_type_datetime, repr(self))
-xrepr.when_type(datetime.timedelta)(xrepr_timedelta)
-
-
-def xrepr_type(self, mode="default"):
-    if self.__module__ == "__builtin__":
-        yield (astyle.style_type_type, self.__name__)
-    else:
-        yield (astyle.style_type_type, "%s.%s" % (self.__module__, self.__name__))
-xrepr.when_type(type)(xrepr_type)
-
-
-def xrepr_exception(self, mode="default"):
-    if self.__class__.__module__ == "exceptions":
-        classname = self.__class__.__name__
-    else:
-        classname = "%s.%s" % \
-            (self.__class__.__module__, self.__class__.__name__)
-    if mode == "header" or mode == "footer":
-        yield (astyle.style_error, "%s: %s" % (classname, self))
-    else:
-        yield (astyle.style_error, classname)
-xrepr.when_type(Exception)(xrepr_exception)
-
-
-def xrepr_listtuple(self, mode="default"):
-    if mode == "header" or mode == "footer":
-        if self.__class__.__module__ == "__builtin__":
-            classname = self.__class__.__name__
-        else:
-            classname = "%s.%s" % \
-                (self.__class__.__module__,self.__class__.__name__)
-        yield (astyle.style_default,
-               "<%s object with %d items at 0x%x>" % \
-                   (classname, len(self), id(self)))
-    else:
-        yield (-1, False)
-        if isinstance(self, list):
-            yield (astyle.style_default, "[")
-            end = "]"
-        else:
-            yield (astyle.style_default, "(")
-            end = ")"
-        for (i, subself) in enumerate(self):
-            if i:
-                yield (astyle.style_default, ", ")
-            for part in xrepr(subself, "default"):
-                yield part
-        yield (astyle.style_default, end)
-xrepr.when_type(list)(xrepr_listtuple)
-xrepr.when_type(tuple)(xrepr_listtuple)
-
-
-def xrepr_dict(self, mode="default"):
-    if mode == "header" or mode == "footer":
-        if self.__class__.__module__ == "__builtin__":
-            classname = self.__class__.__name__
-        else:
-            classname = "%s.%s" % \
-                (self.__class__.__module__,self.__class__.__name__)
-        yield (astyle.style_default,
-               "<%s object with %d items at 0x%x>" % \
-                (classname, len(self), id(self)))
-    else:
-        yield (-1, False)
-        if isinstance(self, dict):
-            yield (astyle.style_default, "{")
-            end = "}"
-        else:
-            yield (astyle.style_default, "dictproxy((")
-            end = "})"
-        for (i, (key, value)) in enumerate(self.iteritems()):
-            if i:
-                yield (astyle.style_default, ", ")
-            for part in xrepr(key, "default"):
-                yield part
-            yield (astyle.style_default, ": ")
-            for part in xrepr(value, "default"):
-                yield part
-        yield (astyle.style_default, end)
-xrepr.when_type(dict)(xrepr_dict)
-xrepr.when_type(types.DictProxyType)(xrepr_dict)
-
-
-def upgradexattr(attr):
-    """
-    Convert an attribute descriptor string to a real descriptor object.
-
-    If attr already is a descriptor object return it unmodified. A
-    ``SelfDescriptor`` will be returned if ``attr`` is ``None``. ``"foo"``
-    returns an ``AttributeDescriptor`` for the attribute named ``"foo"``.
-    ``"foo()"`` returns a ``MethodDescriptor`` for the method named ``"foo"``.
-    ``"-foo"`` will return an ``IterAttributeDescriptor`` for the attribute
-    named ``"foo"`` and ``"-foo()"`` will return an ``IterMethodDescriptor``
-    for the method named ``"foo"``. Furthermore integers will return the appropriate
-    ``IndexDescriptor`` and callables will return a ``FunctionDescriptor``.
-    """
-    if attr is None:
-        return selfdescriptor
-    elif isinstance(attr, Descriptor):
-        return attr
-    elif isinstance(attr, basestring):
-        if attr.endswith("()"):
-            if attr.startswith("-"):
-                return IterMethodDescriptor(attr[1:-2])
-            else:
-                return MethodDescriptor(attr[:-2])
-        else:
-            if attr.startswith("-"):
-                return IterAttributeDescriptor(attr[1:])
-            else:
-                return AttributeDescriptor(attr)
-    elif isinstance(attr, (int, long)):
-        return IndexDescriptor(attr)
-    elif callable(attr):
-        return FunctionDescriptor(attr)
-    else:
-        raise TypeError("can't handle descriptor %r" % attr)
-
-
-def xattrs(item, mode="default"):
-    """
-    Generic function that returns an iterable of attribute descriptors
-    to be used for displaying the attributes ob the object ``item`` in display
-    mode ``mode``.
-
-    There are two possible modes:
-
-    ``"detail"``
-        The ``Display`` object wants to display a detailed list of the object
-        attributes.
-
-    ``"default"``
-        The ``Display`` object wants to display the object in a list view.
-
-    If no implementation is registered for the object ``item`` ``xattrs`` falls
-    back to trying the ``__xattrs__`` method of the object. If this doesn't
-    exist either, ``dir(item)`` is used for ``"detail"`` mode and ``(None,)``
-    for ``"default"`` mode.
-
-    The implementation must yield attribute descriptors (see the class
-    ``Descriptor`` for more info). The ``__xattrs__`` method may also return
-    attribute descriptor strings (and ``None``) which will be converted to real
-    descriptors by ``upgradexattr()``.
-    """
-    try:
-        func = item.__xattrs__
-    except AttributeError:
-        if mode == "detail":
-            for attrname in dir(item):
-                yield AttributeDescriptor(attrname)
-        else:
-            yield selfdescriptor
-    else:
-        for attr in func(mode):
-            yield upgradexattr(attr)
-xattrs = simplegeneric.generic(xattrs)
-
-
-def xattrs_complex(self, mode="default"):
-    if mode == "detail":
-        return (AttributeDescriptor("real"), AttributeDescriptor("imag"))
-    return (selfdescriptor,)
-xattrs.when_type(complex)(xattrs_complex)
-
-
-def _isdict(item):
-    try:
-        itermeth = item.__class__.__iter__
-    except (AttributeError, TypeError):
-        return False
-    return itermeth is dict.__iter__ or itermeth is types.DictProxyType.__iter__
-
-
-def _isstr(item):
-    if not isinstance(item, basestring):
-        return False
-    try:
-        itermeth = item.__class__.__iter__
-    except AttributeError:
-        return True
-    return False # ``__iter__`` has been redefined
-
-
-def xiter(item):
-    """
-    Generic function that implements iteration for pipeline expression. If no
-    implementation is registered for ``item`` ``xiter`` falls back to ``iter``.
-    """
-    try:
-        func = item.__xiter__
-    except AttributeError:
-        if _isdict(item):
-            def items(item):
-                fields = ("key", "value")
-                for (key, value) in item.iteritems():
-                    yield Fields(fields, key=key, value=value)
-            return items(item)
-        elif isinstance(item, new.module):
-            def items(item):
-                fields = ("key", "value")
-                for key in sorted(item.__dict__):
-                    yield Fields(fields, key=key, value=getattr(item, key))
-            return items(item)
-        elif _isstr(item):
-            if not item:
-                raise ValueError("can't enter empty string")
-            lines = item.splitlines()
-            if len(lines) == 1:
-               def iterone(item):
-                   yield item
-               return iterone(item)
-            else:
-                return iter(lines)
-        return iter(item)
-    else:
-        return iter(func()) # iter() just to be safe
-xiter = simplegeneric.generic(xiter)
-
-
-class ichain(Pipe):
-    """
-    Chains multiple ``Table``s into one.
-    """
-
-    def __init__(self, *iters):
-        self.iters = iters
-
-    def __iter__(self):
-        return itertools.chain(*self.iters)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            for (i, item) in enumerate(self.iters):
-                if i:
-                    yield (astyle.style_default, "+")
-                if isinstance(item, Pipe):
-                    yield (astyle.style_default, "(")
-                for part in xrepr(item, mode):
-                    yield part
-                if isinstance(item, Pipe):
-                    yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        args = ", ".join([repr(it) for it in self.iters])
-        return "%s.%s(%s)" % \
-            (self.__class__.__module__, self.__class__.__name__, args)
-
-
-class ifile(path.path):
-    """
-    file (or directory) object.
-    """
-
-    def getmode(self):
-        return self.stat().st_mode
-    mode = property(getmode, None, None, "Access mode")
-
-    def gettype(self):
-        data = [
-            (stat.S_ISREG, "file"),
-            (stat.S_ISDIR, "dir"),
-            (stat.S_ISCHR, "chardev"),
-            (stat.S_ISBLK, "blockdev"),
-            (stat.S_ISFIFO, "fifo"),
-            (stat.S_ISLNK, "symlink"),
-            (stat.S_ISSOCK,"socket"),
-        ]
-        lstat = self.lstat()
-        if lstat is not None:
-            types = set([text for (func, text) in data if func(lstat.st_mode)])
-        else:
-            types = set()
-        m = self.mode
-        types.update([text for (func, text) in data if func(m)])
-        return ", ".join(types)
-    type = property(gettype, None, None, "file type (file, directory, link, etc.)")
-
-    def getmodestr(self):
-        m = self.mode
-        data = [
-            (stat.S_IRUSR, "-r"),
-            (stat.S_IWUSR, "-w"),
-            (stat.S_IXUSR, "-x"),
-            (stat.S_IRGRP, "-r"),
-            (stat.S_IWGRP, "-w"),
-            (stat.S_IXGRP, "-x"),
-            (stat.S_IROTH, "-r"),
-            (stat.S_IWOTH, "-w"),
-            (stat.S_IXOTH, "-x"),
-        ]
-        return "".join([text[bool(m&bit)] for (bit, text) in data])
-
-    modestr = property(getmodestr, None, None, "Access mode as string")
-
-    def getblocks(self):
-        return self.stat().st_blocks
-    blocks = property(getblocks, None, None, "File size in blocks")
-
-    def getblksize(self):
-        return self.stat().st_blksize
-    blksize = property(getblksize, None, None, "Filesystem block size")
-
-    def getdev(self):
-        return self.stat().st_dev
-    dev = property(getdev)
-
-    def getnlink(self):
-        return self.stat().st_nlink
-    nlink = property(getnlink, None, None, "Number of links")
-
-    def getuid(self):
-        return self.stat().st_uid
-    uid = property(getuid, None, None, "User id of file owner")
-
-    def getgid(self):
-        return self.stat().st_gid
-    gid = property(getgid, None, None, "Group id of file owner")
-
-    def getowner(self):
-        stat = self.stat()
-        try:
-            return pwd.getpwuid(stat.st_uid).pw_name
-        except KeyError:
-            return stat.st_uid
-    owner = property(getowner, None, None, "Owner name (or id)")
-
-    def getgroup(self):
-        stat = self.stat()
-        try:
-            return grp.getgrgid(stat.st_gid).gr_name
-        except KeyError:
-            return stat.st_gid
-    group = property(getgroup, None, None, "Group name (or id)")
-
-    def getadate(self):
-        return datetime.datetime.utcfromtimestamp(self.atime)
-    adate = property(getadate, None, None, "Access date")
-
-    def getcdate(self):
-        return datetime.datetime.utcfromtimestamp(self.ctime)
-    cdate = property(getcdate, None, None, "Creation date")
-
-    def getmdate(self):
-        return datetime.datetime.utcfromtimestamp(self.mtime)
-    mdate = property(getmdate, None, None, "Modification date")
-
-    def mimetype(self):
-        """
-        Return MIME type guessed from the extension.
-        """
-        return mimetypes.guess_type(self.basename())[0]
-
-    def encoding(self):
-        """
-        Return guessed compression (like "compress" or "gzip").
-        """
-        return mimetypes.guess_type(self.basename())[1]
-
-    def __repr__(self):
-        return "ifile(%s)" % path._base.__repr__(self)
-
-    if sys.platform == "win32":
-        defaultattrs = (None, "type", "size", "modestr", "mdate")
-    else:
-        defaultattrs = (None, "type", "size", "modestr", "owner", "group", "mdate")
-
-    def __xattrs__(self, mode="default"):
-        if mode == "detail":
-            return (
-                "name",
-                "basename()",
-                "abspath()",
-                "realpath()",
-                "type",
-                "mode",
-                "modestr",
-                "stat()",
-                "lstat()",
-                "uid",
-                "gid",
-                "owner",
-                "group",
-                "dev",
-                "nlink",
-                "ctime",
-                "mtime",
-                "atime",
-                "cdate",
-                "mdate",
-                "adate",
-                "size",
-                "blocks",
-                "blksize",
-                "isdir()",
-                "islink()",
-                "mimetype()",
-                "encoding()",
-                "-listdir()",
-                "-dirs()",
-                "-files()",
-                "-walk()",
-                "-walkdirs()",
-                "-walkfiles()",
-            )
-        else:
-            return self.defaultattrs
-
-
-def xiter_ifile(self):
-    if self.isdir():
-        yield (self / os.pardir).abspath()
-        for child in sorted(self.listdir()):
-            yield child
-    else:
-        f = self.open("rb")
-        for line in f:
-            yield line
-        f.close()
-xiter.when_type(ifile)(xiter_ifile)
-
-
-# We need to implement ``xrepr`` for ``ifile`` as a generic function, because
-# otherwise ``xrepr_str`` would kick in.
-def xrepr_ifile(self, mode="default"):
-    try:
-        if self.isdir():
-            name = "idir"
-            style = astyle.style_dir
-        else:
-            name = "ifile"
-            style = astyle.style_file
-    except IOError:
-        name = "ifile"
-        style = astyle.style_default
-    if mode in ("cell", "header", "footer"):
-        abspath = repr(path._base(self.normpath()))
-        if abspath.startswith("u"):
-            abspath = abspath[2:-1]
-        else:
-            abspath = abspath[1:-1]
-        if mode == "cell":
-            yield (style, abspath)
-        else:
-            yield (style, "%s(%s)" % (name, abspath))
-    else:
-        yield (style, repr(self))
-xrepr.when_type(ifile)(xrepr_ifile)
-
-
-class ils(Table):
-    """
-    List the current (or a specified) directory.
-
-    Examples::
-
-        >>> ils
-        <class 'IPython.extensions.ipipe.ils'>
-        >>> ils("/usr/local/lib/python2.4")
-        IPython.extensions.ipipe.ils('/usr/local/lib/python2.4')
-        >>> ils("~")
-        IPython.extensions.ipipe.ils('/home/fperez')
-        # all-random
-    """
-    def __init__(self, base=os.curdir, dirs=True, files=True):
-        self.base = os.path.expanduser(base)
-        self.dirs = dirs
-        self.files = files
-
-    def __iter__(self):
-        base = ifile(self.base)
-        yield (base / os.pardir).abspath()
-        for child in sorted(base.listdir()):
-            if self.dirs:
-                if self.files:
-                    yield child
-                else:
-                    if child.isdir():
-                        yield child
-            elif self.files:
-                if not child.isdir():
-                    yield child
-
-    def __xrepr__(self, mode="default"):
-       return xrepr(ifile(self.base), mode)
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.base)
-
-
-class iglob(Table):
-    """
-    List all files and directories matching a specified pattern.
-    (See ``glob.glob()`` for more info.).
-
-    Examples::
-
-        >>> iglob("*.py")
-        IPython.extensions.ipipe.iglob('*.py')
-    """
-    def __init__(self, glob):
-        self.glob = glob
-
-    def __iter__(self):
-        for name in glob.glob(self.glob):
-            yield ifile(name)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.glob))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.glob)
-
-
-class iwalk(Table):
-    """
-    List all files and directories in a directory and it's subdirectory::
-
-        >>> iwalk
-        <class 'IPython.extensions.ipipe.iwalk'>
-        >>> iwalk("/usr/lib")
-        IPython.extensions.ipipe.iwalk('/usr/lib')
-        >>> iwalk("~")
-        IPython.extensions.ipipe.iwalk('/home/fperez')  # random
-        
-    """
-    def __init__(self, base=os.curdir, dirs=True, files=True):
-        self.base = os.path.expanduser(base)
-        self.dirs = dirs
-        self.files = files
-
-    def __iter__(self):
-        for (dirpath, dirnames, filenames) in os.walk(self.base):
-            if self.dirs:
-                for name in sorted(dirnames):
-                    yield ifile(os.path.join(dirpath, name))
-            if self.files:
-                for name in sorted(filenames):
-                    yield ifile(os.path.join(dirpath, name))
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.base))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.base)
-
-
-class ipwdentry(object):
-    """
-    ``ipwdentry`` objects encapsulate entries in the Unix user account and
-    password database.
-    """
-    def __init__(self, id):
-        self._id = id
-        self._entry = None
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__ and self._id == other._id
-
-    def __ne__(self, other):
-        return self.__class__ is not other.__class__ or self._id != other._id
-
-    def _getentry(self):
-        if self._entry is None:
-            if isinstance(self._id, basestring):
-                self._entry = pwd.getpwnam(self._id)
-            else:
-                self._entry = pwd.getpwuid(self._id)
-        return self._entry
-
-    def getname(self):
-        if isinstance(self._id, basestring):
-            return self._id
-        else:
-            return self._getentry().pw_name
-    name = property(getname, None, None, "User name")
-
-    def getpasswd(self):
-        return self._getentry().pw_passwd
-    passwd = property(getpasswd, None, None, "Password")
-
-    def getuid(self):
-        if isinstance(self._id, basestring):
-            return self._getentry().pw_uid
-        else:
-            return self._id
-    uid = property(getuid, None, None, "User id")
-
-    def getgid(self):
-        return self._getentry().pw_gid
-    gid = property(getgid, None, None, "Primary group id")
-
-    def getgroup(self):
-        return igrpentry(self.gid)
-    group = property(getgroup, None, None, "Group")
-
-    def getgecos(self):
-        return self._getentry().pw_gecos
-    gecos = property(getgecos, None, None, "Information (e.g. full user name)")
-
-    def getdir(self):
-        return self._getentry().pw_dir
-    dir = property(getdir, None, None, "$HOME directory")
-
-    def getshell(self):
-        return self._getentry().pw_shell
-    shell = property(getshell, None, None, "Login shell")
-
-    def __xattrs__(self, mode="default"):
-       return ("name", "passwd", "uid", "gid", "gecos", "dir", "shell")
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self._id)
-
-
-class ipwd(Table):
-    """
-    List all entries in the Unix user account and password database.
-
-    Example::
-
-        >>> ipwd | isort("uid")
-        <IPython.extensions.ipipe.isort key='uid' reverse=False at 0x849efec>
-        # random
-    """
-    def __iter__(self):
-        for entry in pwd.getpwall():
-            yield ipwdentry(entry.pw_name)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default, "%s()" % self.__class__.__name__)
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class igrpentry(object):
-    """
-    ``igrpentry`` objects encapsulate entries in the Unix group database.
-    """
-    def __init__(self, id):
-        self._id = id
-        self._entry = None
-
-    def __eq__(self, other):
-        return self.__class__ is other.__class__ and self._id == other._id
-
-    def __ne__(self, other):
-        return self.__class__ is not other.__class__ or self._id != other._id
-
-    def _getentry(self):
-        if self._entry is None:
-            if isinstance(self._id, basestring):
-                self._entry = grp.getgrnam(self._id)
-            else:
-                self._entry = grp.getgrgid(self._id)
-        return self._entry
-
-    def getname(self):
-        if isinstance(self._id, basestring):
-            return self._id
-        else:
-            return self._getentry().gr_name
-    name = property(getname, None, None, "Group name")
-
-    def getpasswd(self):
-        return self._getentry().gr_passwd
-    passwd = property(getpasswd, None, None, "Password")
-
-    def getgid(self):
-        if isinstance(self._id, basestring):
-            return self._getentry().gr_gid
-        else:
-            return self._id
-    gid = property(getgid, None, None, "Group id")
-
-    def getmem(self):
-        return self._getentry().gr_mem
-    mem = property(getmem, None, None, "Members")
-
-    def __xattrs__(self, mode="default"):
-        return ("name", "passwd", "gid", "mem")
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer" or mode == "cell":
-            yield (astyle.style_default, "group ")
-            try:
-                yield (astyle.style_default, self.name)
-            except KeyError:
-                if isinstance(self._id, basestring):
-                    yield (astyle.style_default, self.name_id)
-                else:
-                    yield (astyle.style_type_number, str(self._id))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __iter__(self):
-        for member in self.mem:
-            yield ipwdentry(member)
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self._id)
-
-
-class igrp(Table):
-    """
-    This ``Table`` lists all entries in the Unix group database.
-    """
-    def __iter__(self):
-        for entry in grp.getgrall():
-            yield igrpentry(entry.gr_name)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default, "%s()" % self.__class__.__name__)
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class Fields(object):
-    def __init__(self, fieldnames, **fields):
-        self.__fieldnames = [upgradexattr(fieldname) for fieldname in fieldnames]
-        for (key, value) in fields.iteritems():
-            setattr(self, key, value)
-
-    def __xattrs__(self, mode="default"):
-        return self.__fieldnames
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "cell":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, f) in enumerate(self.__fieldnames):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, f.name())
-                yield (astyle.style_default, "=")
-                for part in xrepr(getattr(self, f), "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        elif mode == "footer":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, f) in enumerate(self.__fieldnames):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, f.name())
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class FieldTable(Table, list):
-    def __init__(self, *fields):
-        Table.__init__(self)
-        list.__init__(self)
-        self.fields = fields
-
-    def add(self, **fields):
-        self.append(Fields(self.fields, **fields))
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, f) in enumerate(self.__fieldnames):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, f)
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s object with fields=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             ", ".join(map(repr, self.fields)), id(self))
-
-
-class List(list):
-    def __xattrs__(self, mode="default"):
-        return xrange(len(self))
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "cell" or mode == "footer" or mode == "default":
-            yield (astyle.style_default, self.__class__.__name__)
-            yield (astyle.style_default, "(")
-            for (i, item) in enumerate(self):
-                if i:
-                    yield (astyle.style_default, ", ")
-                for part in xrepr(item, "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class ienv(Table):
-    """
-    List environment variables.
-
-    Example::
-
-        >>> ienv
-        <class 'IPython.extensions.ipipe.ienv'>
-    """
-
-    def __iter__(self):
-        fields = ("key", "value")
-        for (key, value) in os.environ.iteritems():
-            yield Fields(fields, key=key, value=value)
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "cell":
-            yield (astyle.style_default, "%s()" % self.__class__.__name__)
-        else:
-            yield (astyle.style_default, repr(self))
-
-
-class ihist(Table):
-    """
-    IPython input history
-
-    Example::
-
-        >>> ihist
-        <class 'IPython.extensions.ipipe.ihist'>
-        >>> ihist(True) # raw mode
-        <IPython.extensions.ipipe.ihist object at 0x849602c>  # random
-    """
-    def __init__(self, raw=True):
-        self.raw = raw
-
-    def __iter__(self):
-        api = ipapi.get()
-        if self.raw:
-            for line in api.input_hist_raw:
-                yield line.rstrip("\n")
-        else:
-            for line in api.input_hist:
-                yield line.rstrip("\n")
-
-
-class Alias(object):
-    """
-    Entry in the alias table
-    """
-    def __init__(self, name, args, command):
-        self.name = name
-        self.args = args
-        self.command = command
-
-    def __xattrs__(self, mode="default"):
-        return ("name", "args", "command")
-
-
-class ialias(Table):
-    """
-    IPython alias list
-
-    Example::
-
-        >>> ialias
-        <class 'IPython.extensions.ipipe.ialias'>
-    """
-    def __iter__(self):
-        api = ipapi.get()
-
-        for (name, (args, command)) in api.alias_manager.alias_table.iteritems():
-            yield Alias(name, args, command)
-
-
-class icsv(Pipe):
-    """
-    This ``Pipe`` turns the input (with must be a pipe outputting lines
-    or an ``ifile``) into lines of CVS columns.
-    """
-    def __init__(self, **csvargs):
-        """
-        Create an ``icsv`` object. ``cvsargs`` will be passed through as
-        keyword arguments to ``cvs.reader()``.
-        """
-        self.csvargs = csvargs
-
-    def __iter__(self):
-        input = self.input
-        if isinstance(input, ifile):
-            input = input.open("rb")
-        reader = csv.reader(input, **self.csvargs)
-        for line in reader:
-            yield List(line)
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, False)
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for (i, (name, value)) in enumerate(self.csvargs.iteritems()):
-                if i:
-                    yield (astyle.style_default, ", ")
-                yield (astyle.style_default, name)
-                yield (astyle.style_default, "=")
-                for part in xrepr(value, "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        args = ", ".join(["%s=%r" % item for item in self.csvargs.iteritems()])
-        return "<%s.%s %s at 0x%x>" % \
-        (self.__class__.__module__, self.__class__.__name__, args, id(self))
-
-
-class ix(Table):
-    """
-    Execute a system command and list its output as lines
-    (similar to ``os.popen()``).
-
-    Examples::
-
-        >>> ix("ps x")
-        IPython.extensions.ipipe.ix('ps x')
-
-        >>> ix("find .") | ifile
-        <IPython.extensions.ipipe.ieval expr=<class 'IPython.extensions.ipipe.ifile'> at 0x8509d2c>
-        # random
-    """
-    def __init__(self, cmd):
-        self.cmd = cmd
-        self._pipeout = None
-
-    def __iter__(self):
-        (_pipein, self._pipeout) = os.popen4(self.cmd)
-        _pipein.close()
-        for l in self._pipeout:
-            yield l.rstrip("\r\n")
-        self._pipeout.close()
-        self._pipeout = None
-
-    def __del__(self):
-        if self._pipeout is not None and not self._pipeout.closed:
-            self._pipeout.close()
-        self._pipeout = None
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.cmd))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.cmd)
-
-
-class ifilter(Pipe):
-    """
-    Filter an input pipe. Only objects where an expression evaluates to true
-    (and doesn't raise an exception) are listed.
-
-    Examples::
-
-        >>> ils | ifilter("_.isfile() and size>1000")
-        >>> igrp | ifilter("len(mem)")
-        >>> sys.modules | ifilter(lambda _:_.value is not None)
-        # all-random
-    """
-
-    def __init__(self, expr, globals=None, errors="raiseifallfail"):
-        """
-        Create an ``ifilter`` object. ``expr`` can be a callable or a string
-        containing an expression. ``globals`` will be used as the global
-        namespace for calling string expressions (defaulting to IPython's
-        user namespace). ``errors`` specifies how exception during evaluation
-        of ``expr`` are handled:
-
-        ``"drop"``
-            drop all items that have errors;
-
-        ``"keep"``
-            keep all items that have errors;
-
-        ``"keeperror"``
-            keep the exception of all items that have errors;
-
-        ``"raise"``
-            raise the exception;
-
-        ``"raiseifallfail"``
-            raise the first exception if all items have errors; otherwise drop
-            those with errors (this is the default).
-        """
-        self.expr = expr
-        self.globals = globals
-        self.errors = errors
-
-    def __iter__(self):
-        if callable(self.expr):
-            test = self.expr
-        else:
-            g = getglobals(self.globals)
-            expr = compile(self.expr, "ipipe-expression", "eval")
-            def test(item):
-                return eval(expr, g, AttrNamespace(item))
-
-        ok = 0
-        exc_info = None
-        for item in xiter(self.input):
-            try:
-                if test(item):
-                    yield item
-                ok += 1
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                if self.errors == "drop":
-                    pass # Ignore errors
-                elif self.errors == "keep":
-                    yield item
-                elif self.errors == "keeperror":
-                    yield exc
-                elif self.errors == "raise":
-                    raise
-                elif self.errors == "raiseifallfail":
-                    if exc_info is None:
-                        exc_info = sys.exc_info()
-        if not ok and exc_info is not None:
-            raise exc_info[0], exc_info[1], exc_info[2]
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for part in xrepr(self.expr, "default"):
-                yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s expr=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             self.expr, id(self))
-
-
-class ieval(Pipe):
-    """
-    Evaluate an expression for each object in the input pipe.
-
-    Examples::
-
-        >>> ils | ieval("_.abspath()")
-        # random
-        >>> sys.path | ieval(ifile)
-        # random
-    """
-
-    def __init__(self, expr, globals=None, errors="raiseifallfail"):
-        """
-        Create an ``ieval`` object. ``expr`` can be a callable or a string
-        containing an expression. For the meaning of ``globals`` and
-        ``errors`` see ``ifilter``.
-        """
-        self.expr = expr
-        self.globals = globals
-        self.errors = errors
-
-    def __iter__(self):
-        if callable(self.expr):
-            do = self.expr
-        else:
-            g = getglobals(self.globals)
-            expr = compile(self.expr, "ipipe-expression", "eval")
-            def do(item):
-                return eval(expr, g, AttrNamespace(item))
-
-        ok = 0
-        exc_info = None
-        for item in xiter(self.input):
-            try:
-                yield do(item)
-            except (KeyboardInterrupt, SystemExit):
-                raise
-            except Exception, exc:
-                if self.errors == "drop":
-                    pass # Ignore errors
-                elif self.errors == "keep":
-                    yield item
-                elif self.errors == "keeperror":
-                    yield exc
-                elif self.errors == "raise":
-                    raise
-                elif self.errors == "raiseifallfail":
-                    if exc_info is None:
-                        exc_info = sys.exc_info()
-        if not ok and exc_info is not None:
-            raise exc_info[0], exc_info[1], exc_info[2]
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for part in xrepr(self.expr, "default"):
-                yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s expr=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             self.expr, id(self))
-
-
-class ienum(Pipe):
-    """
-    Enumerate the input pipe (i.e. wrap each input object in an object
-    with ``index`` and ``object`` attributes).
-
-    Examples::
-
-        >>> xrange(20) | ieval("_,_*_") | ienum | ifilter("index % 2 == 0") | ieval("object")
-    """
-    skip_doctest = True
-    
-    def __iter__(self):
-        fields = ("index", "object")
-        for (index, object) in enumerate(xiter(self.input)):
-            yield Fields(fields, index=index, object=object)
-
-
-class isort(Pipe):
-    """
-    Sorts the input pipe.
-
-    Examples::
-
-        >>> ils | isort("size")
-        <IPython.extensions.ipipe.isort key='size' reverse=False at 0x849ec2c>
-        >>> ils | isort("_.isdir(), _.lower()", reverse=True)
-        <IPython.extensions.ipipe.isort key='_.isdir(), _.lower()' reverse=True at 0x849eacc>
-        # all-random
-    """
-
-    def __init__(self, key=None, globals=None, reverse=False):
-        """
-        Create an ``isort`` object. ``key`` can be a callable or a string
-        containing an expression (or ``None`` in which case the items
-        themselves will be sorted). If ``reverse`` is true the sort order
-        will be reversed. For the meaning of ``globals`` see ``ifilter``.
-        """
-        self.key = key
-        self.globals = globals
-        self.reverse = reverse
-
-    def __iter__(self):
-        if self.key is None:
-            items = sorted(xiter(self.input), reverse=self.reverse)
-        elif callable(self.key):
-            items = sorted(xiter(self.input), key=self.key, reverse=self.reverse)
-        else:
-            g = getglobals(self.globals)
-            key = compile(self.key, "ipipe-expression", "eval")
-            def realkey(item):
-                return eval(key, g, AttrNamespace(item))
-            items = sorted(xiter(self.input), key=realkey, reverse=self.reverse)
-        for item in items:
-            yield item
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            input = getattr(self, "input", None)
-            if input is not None:
-                for part in xrepr(input, mode):
-                    yield part
-                yield (astyle.style_default, " | ")
-            yield (astyle.style_default, "%s(" % self.__class__.__name__)
-            for part in xrepr(self.key, "default"):
-                yield part
-            if self.reverse:
-                yield (astyle.style_default, ", ")
-                for part in xrepr(True, "default"):
-                    yield part
-            yield (astyle.style_default, ")")
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "<%s.%s key=%r reverse=%r at 0x%x>" % \
-            (self.__class__.__module__, self.__class__.__name__,
-             self.key, self.reverse, id(self))
-
-
-tab = 3 # for expandtabs()
-
-def _format(field):
-    if isinstance(field, str):
-        text = repr(field.expandtabs(tab))[1:-1]
-    elif isinstance(field, unicode):
-        text = repr(field.expandtabs(tab))[2:-1]
-    elif isinstance(field, datetime.datetime):
-        # Don't use strftime() here, as this requires year >= 1900
-        text = "%04d-%02d-%02d %02d:%02d:%02d.%06d" % \
-            (field.year, field.month, field.day,
-             field.hour, field.minute, field.second, field.microsecond)
-    elif isinstance(field, datetime.date):
-        text = "%04d-%02d-%02d" % (field.year, field.month, field.day)
-    else:
-        text = repr(field)
-    return text
-
-
-class Display(object):
-    class __metaclass__(type):
-        def __ror__(self, input):
-            return input | self()
-
-    def __init__(self, input=None):
-        self.input = input
-
-    def __ror__(self, input):
-        self.input = input
-        return self
-
-    def display(self):
-        pass
-
-
-class iless(Display):
-    cmd = "less --quit-if-one-screen --LONG-PROMPT --LINE-NUMBERS --chop-long-lines --shift=8 --RAW-CONTROL-CHARS"
-
-    def display(self):
-        try:
-            pager = os.popen(self.cmd, "w")
-            try:
-                for item in xiter(self.input):
-                    first = False
-                    for attr in xattrs(item, "default"):
-                        if first:
-                            first = False
-                        else:
-                            pager.write(" ")
-                        attr = upgradexattr(attr)
-                        if not isinstance(attr, SelfDescriptor):
-                            pager.write(attr.name())
-                            pager.write("=")
-                        pager.write(str(attr.value(item)))
-                    pager.write("\n")
-            finally:
-                pager.close()
-        except Exception, exc:
-            print "%s: %s" % (exc.__class__.__name__, str(exc))
-
-
-class _RedirectIO(object):
-    def __init__(self,*args,**kwargs):
-        """
-        Map the system output streams to self.
-        """
-        self.stream = StringIO.StringIO()
-        self.stdout = sys.stdout
-        sys.stdout = self
-        self.stderr = sys.stderr
-        sys.stderr = self
-
-    def write(self, text):
-        """
-        Write both to screen and to self.
-        """
-        self.stream.write(text)
-        self.stdout.write(text)
-        if "\n" in text:
-            self.stdout.flush()
-
-    def writelines(self, lines):
-        """
-        Write lines both to screen and to self.
-        """
-        self.stream.writelines(lines)
-        self.stdout.writelines(lines)
-        self.stdout.flush()
-
-    def restore(self):
-        """
-        Restore the default system streams.
-        """
-        self.stdout.flush()
-        self.stderr.flush()
-        sys.stdout = self.stdout
-        sys.stderr = self.stderr
-
-
-class icap(Table):
-    """
-    Execute a python string and capture any output to stderr/stdout.
-
-    Examples::
-
-        >>> import time
-        >>> icap("for i in range(10): print i, time.sleep(0.1)")
-
-    """
-    skip_doctest = True
-    
-    def __init__(self, expr, globals=None):
-        self.expr = expr
-        self.globals = globals
-        log = _RedirectIO()
-        try:
-            exec(expr, getglobals(globals))
-        finally:
-            log.restore()
-        self.stream = log.stream
-
-    def __iter__(self):
-        self.stream.seek(0)
-        for line in self.stream:
-            yield line.rstrip("\r\n")
-
-    def __xrepr__(self, mode="default"):
-        if mode == "header" or mode == "footer":
-            yield (astyle.style_default,
-                   "%s(%r)" % (self.__class__.__name__, self.expr))
-        else:
-            yield (astyle.style_default, repr(self))
-
-    def __repr__(self):
-        return "%s.%s(%r)" % \
-            (self.__class__.__module__, self.__class__.__name__, self.expr)
-
-
-def xformat(value, mode, maxlength):
-    align = None
-    full = True
-    width = 0
-    text = astyle.Text()
-    for (style, part) in xrepr(value, mode):
-        # only consider the first result
-        if align is None:
-            if isinstance(style, int):
-                # (style, text) really is (alignment, stop)
-                align = style
-                full = part
-                continue
-            else:
-                align = -1
-                full = True
-        if not isinstance(style, int):
-            text.append((style, part))
-            width += len(part)
-            if width >= maxlength and not full:
-                text.append((astyle.style_ellisis, "..."))
-                width += 3
-                break
-    if align is None: # default to left alignment
-        align = -1
-    return (align, width, text)
-
-
-
-import astyle
-
-class idump(Display):
-    # The approximate maximum length of a column entry
-    maxattrlength = 200
-
-    # Style for column names
-    style_header = astyle.Style.fromstr("white:black:bold")
-
-    def __init__(self, input=None, *attrs):
-        Display.__init__(self, input)
-        self.attrs = [upgradexattr(attr) for attr in attrs]
-        self.headerpadchar = " "
-        self.headersepchar = "|"
-        self.datapadchar = " "
-        self.datasepchar = "|"
-
-    def display(self):
-        stream = Term.cout
-        allattrs = []
-        attrset = set()
-        colwidths = {}
-        rows = []
-        for item in xiter(self.input):
-            row = {}
-            attrs = self.attrs
-            if not attrs:
-                attrs = xattrs(item, "default")
-            for attr in attrs:
-                if attr not in attrset:
-                    allattrs.append(attr)
-                    attrset.add(attr)
-                    colwidths[attr] = len(attr.name())
-                try:
-                    value = attr.value(item)
-                except (KeyboardInterrupt, SystemExit):
-                    raise
-                except Exception, exc:
-                    value = exc
-                (align, width, text) = xformat(value, "cell", self.maxattrlength)
-                colwidths[attr] = max(colwidths[attr], width)
-                # remember alignment, length and colored parts
-                row[attr] = (align, width, text)
-            rows.append(row)
-
-        stream.write("\n")
-        for (i, attr) in enumerate(allattrs):
-            attrname = attr.name()
-            self.style_header(attrname).write(stream)
-            spc = colwidths[attr] - len(attrname)
-            if i < len(colwidths)-1:
-                stream.write(self.headerpadchar*spc)
-                stream.write(self.headersepchar)
-        stream.write("\n")
-
-        for row in rows:
-            for (i, attr) in enumerate(allattrs):
-                (align, width, text) = row[attr]
-                spc = colwidths[attr] - width
-                if align == -1:
-                    text.write(stream)
-                    if i < len(colwidths)-1:
-                        stream.write(self.datapadchar*spc)
-                elif align == 0:
-                    spc = colwidths[attr] - width
-                    spc1 = spc//2
-                    spc2 = spc-spc1
-                    stream.write(self.datapadchar*spc1)
-                    text.write(stream)
-                    if i < len(colwidths)-1:
-                        stream.write(self.datapadchar*spc2)
-                else:
-                    stream.write(self.datapadchar*spc)
-                    text.write(stream)
-                if i < len(colwidths)-1:
-                    stream.write(self.datasepchar)
-            stream.write("\n")
-
-
-class AttributeDetail(Table):
-    """
-    ``AttributeDetail`` objects are use for displaying a detailed list of object
-    attributes.
-    """
-    def __init__(self, object, descriptor):
-        self.object = object
-        self.descriptor = descriptor
-
-    def __iter__(self):
-        return self.descriptor.iter(self.object)
-
-    def name(self):
-        return self.descriptor.name()
-
-    def attrtype(self):
-        return self.descriptor.attrtype(self.object)
-
-    def valuetype(self):
-        return self.descriptor.valuetype(self.object)
-
-    def doc(self):
-        return self.descriptor.doc(self.object)
-
-    def shortdoc(self):
-        return self.descriptor.shortdoc(self.object)
-
-    def value(self):
-        return self.descriptor.value(self.object)
-
-    def __xattrs__(self, mode="default"):
-        attrs = ("name()", "attrtype()", "valuetype()", "value()", "shortdoc()")
-        if mode == "detail":
-            attrs += ("doc()",)
-        return attrs
-
-    def __xrepr__(self, mode="default"):
-        yield (-1, True)
-        valuetype = self.valuetype()
-        if valuetype is not noitem:
-            for part in xrepr(valuetype):
-                yield part
-            yield (astyle.style_default, " ")
-        yield (astyle.style_default, self.attrtype())
-        yield (astyle.style_default, " ")
-        yield (astyle.style_default, self.name())
-        yield (astyle.style_default, " of ")
-        for part in xrepr(self.object):
-            yield part
-
-
-try:
-    from ibrowse import ibrowse
-except ImportError:
-    # No curses (probably Windows) => try igrid
-    try:
-        from igrid import igrid
-    except ImportError:
-        # no wx either => use ``idump`` as the default display.
-        defaultdisplay = idump
-    else:
-        defaultdisplay = igrid
-        __all__.append("igrid")
-else:
-    defaultdisplay = ibrowse
-    __all__.append("ibrowse")
-
-
-# If we're running under IPython, register our objects with IPython's
-# generic function ``result_display``, else install a displayhook
-# directly as sys.displayhook
-if generics is not None:
-    def display_display(obj):
-        return obj.display()
-    generics.result_display.when_type(Display)(display_display)
-
-    def display_tableobject(obj):
-        return display_display(defaultdisplay(obj))
-    generics.result_display.when_type(Table)(display_tableobject)
-
-    def display_tableclass(obj):
-        return display_tableobject(obj())
-    generics.result_display.when_type(Table.__metaclass__)(display_tableclass)
-else:
-    def installdisplayhook():
-        _originalhook = sys.displayhook
-        def displayhook(obj):
-            if isinstance(obj, type) and issubclass(obj, Table):
-                obj = obj()
-            if isinstance(obj, Table):
-                obj = defaultdisplay(obj)
-            if isinstance(obj, Display):
-                return obj.display()
-            else:
-                _originalhook(obj)
-        sys.displayhook = displayhook
-    installdisplayhook()
diff --git a/IPython/deathrow/iplib.py b/IPython/deathrow/iplib.py
deleted file mode 100644
index 95dcc888c4a..00000000000
--- a/IPython/deathrow/iplib.py
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A backwards compatibility layer for IPython.iplib.
-
-Previously, IPython had an IPython.iplib module.  IPython.iplib has been moved
-to IPython.core.iplib and is being refactored.  This new module is provided
-for backwards compatability.  We strongly encourage everyone to start using
-the new code in IPython.core.iplib.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from warnings import warn
-
-msg = """
-This module (IPython.iplib) has been moved to a new location
-(IPython.core.iplib) and is being refactored.  Please update your code
-to use the new IPython.core.iplib module"""
-
-warn(msg, category=DeprecationWarning, stacklevel=1)
-
-from IPython.core.iplib import *
diff --git a/IPython/deathrow/ipy_constants.py b/IPython/deathrow/ipy_constants.py
deleted file mode 100644
index 9e8ea5dbeb3..00000000000
--- a/IPython/deathrow/ipy_constants.py
+++ /dev/null
@@ -1,669 +0,0 @@
-""" Module with physical constants for use with ipython, profile
-"physics".
-
-Definition of Fundamental Physical Constants, CODATA Recommended Values
-
-Source, Peter J. Mohr and Barry N. Taylor,  
-CODATA Recommended Values of the Fundamental
-Physical Constants, 1998                    
-                                            
-Website: physics.nist.gov/constants         
-"""
-# License: BSD-like
-# Copyright: Gael Varoquaux (gael.varoquaux@normalesup.org)
-
-# inspired by maxima's physconst.mac by Cliff Yapp
-
-#from math import * # math MUST be imported BEFORE PhysicalQInteractive 
-from IPython.extensions.PhysicalQInteractive import PhysicalQuantityInteractive
-
-# Math constants:
-
-# Pi mathematical constants
-pi = 3.141592653589793238462643383279502884197169399375105820974944592
-
-# Universal Constants
-#-------------------------------------------------------------------------
-
-c = PhysicalQuantityInteractive(299792458 , 'm/s')
-c.__doc__ = """speed of light in vacuum"""
-c.__doc__ = "speed of light in vacuum"
-
-u_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
-u_0.__doc__ = """magnetic constant"""
-mu_0 = PhysicalQuantityInteractive(4*pi*1E-7 , 'N/(A**2)')
-
-epsilon_0 = PhysicalQuantityInteractive(8.854187817E-12 , 'F/m')
-epsilon_0.__doc__ = """electric constant """
-
-Z_0 = PhysicalQuantityInteractive(376.730313461 , 'ohm')
-Z_0.__doc__ = """characteristic impedance of vacuum """
-
-G = PhysicalQuantityInteractive(6.673E-11 , 'm**3/(kg*s**2)')
-G.__doc__ = """Newtonian constant of gravitation    """
-
-
-h = PhysicalQuantityInteractive(6.62606876E-34 , 'J*s')
-h.__doc__ = """Planck constant    """
-
-
-h_eV = PhysicalQuantityInteractive(4.13566727E-15 , 'eV*s')
-h_eV.__doc__ = """Planck constant in eVs  """
-
-
-h_bar = PhysicalQuantityInteractive(1.054571596E-34 , 'J*s')
-h_bar.__doc__ = """Hbar"""
-
-
-h_bar_eV = PhysicalQuantityInteractive(6.58211889E-16 , 'eV*s')
-h_bar_eV.__doc__ = """Hbar in eV"""
-
-
-P_m = PhysicalQuantityInteractive(2.1767E-8 , 'kg')
-P_m.__doc__ = """Planck mass"""
-
-
-P_l = PhysicalQuantityInteractive(1.6160E-35 , 'm')
-P_l.__doc__ = """Planck length  """
-
-
-P_t = PhysicalQuantityInteractive(5.3906E-44 , 's')
-P_t.__doc__ = """Planck time """
-
-# Electromagnetic Constants
-#------------------------------------------------------------------------
-
-_e = PhysicalQuantityInteractive(1.602176462E-19 , 'C')
-_e.__doc__ = """elementary charge"""
-q = _e
-
-
-capitalphi_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
-capitalphi_0.__doc__ = """magnetic flux quantum """
-mfq_0 = PhysicalQuantityInteractive(2.067833636E-15 , 'Wb')
-
-
-G_0 = PhysicalQuantityInteractive(7.748091696E-5 , 'S')
-G_0.__doc__ = """conductance quantum """
-
-
-K_J = PhysicalQuantityInteractive(483597.898E9 , 'Hz/V')
-K_J.__doc__ = """Josephson constant"""
-
-
-R_K = PhysicalQuantityInteractive(25812.807572 , 'ohm')
-R_K.__doc__ = """von Klitzing constant"""
-
-
-u_B = PhysicalQuantityInteractive(927.400899E-26 , 'J/T')
-u_B.__doc__ = """Bohr magneton"""
-
-ueVT_B = PhysicalQuantityInteractive(5.788381749E-5 , 'eV/T')
-ueVT_B.__doc__ = """Bohr magneton in eV T-1"""
-
-
-u_N = PhysicalQuantityInteractive(5.05078317E-27 , 'J/T')
-u_N.__doc__ = """nuclear magneton """
-
-ueVT_N = PhysicalQuantityInteractive(3.152451238E-8 , 'eV/T')
-ueVT_N.__doc__ = """nuclear magneton in eV T-1      """
-
-# Atomic and Nuclear Constants
-# General
-#-------------------------------------------------------------------------
-# fine-structure constant 
-alpha = 7.297352533E-3
-
-
-Ry = PhysicalQuantityInteractive(10973731.568549 , '1/m')
-Ry.__doc__ = """Rydberg constant  """
-Ry_INF = PhysicalQuantityInteractive(10973731.568549 , '1/m')
-
-
-a_0 = PhysicalQuantityInteractive(0.5291772083E-10 , 'm')
-a_0.__doc__ = """Bohr radius """
-
-
-E_h = PhysicalQuantityInteractive(4.35974381E-18 , 'J')
-E_h.__doc__ = """Hartree energy """
-
-Eev_h = PhysicalQuantityInteractive(27.2113834 , 'eV')
-Eev_h.__doc__ = """Hartree energy in eV    """
-
-
-qcir2 = PhysicalQuantityInteractive(3.636947516E-4 , 'm**2/s')
-qcir2.__doc__ = """quantum of circulation   h/(2me) """
-
-qcir = PhysicalQuantityInteractive(7.273895032E-4 , 'm**2/s')
-qcir.__doc__ = """quantum of circulation   h/(me) """
-
-# Electroweak
-#-------------------------------------------------------------------------
-
-Fcc = PhysicalQuantityInteractive(1.16639E-5 , '1/GeV**2')
-Fcc.__doc__ = """Fermi coupling constant    """
-# weak mixing angled  W (on-shell scheme)
-wma_W = 0.2224
-
-# Electron, e-
-#-------------------------------------------------------------------------
-
-m_e = PhysicalQuantityInteractive(9.10938188E-31 , 'kg')
-m_e.__doc__ = """electron mass    """
-
-m_e_u = PhysicalQuantityInteractive(5.485799110E-4 , 'amu')
-m_e_u.__doc__ = """electron mass (electron relative atomic mass times amu)"""
-
-me_J = PhysicalQuantityInteractive(8.18710414E-14 , 'J')
-me_J.__doc__ = """electron mass - energy equivalent    """
-
-me_MeV = PhysicalQuantityInteractive(0.510998902 , 'MeV')
-me_MeV.__doc__ = """electron mass - energy equivalent in MeV"""
-
-# electron-muon mass ratio
-memu = 4.83633210E-3
-
-# electron-tau mass ratio    
-metau = 2.87555E-4
-
-# electron-proton mass ratio    
-memp = 5.446170232E-4
-
-# electron-neutron mass ratio 
-memn = 5.438673462E-4
-
-# electron-deuteron mass ratio    
-memd = 2.7244371170E-4
-
-# electron to alpha particle mass ratio    
-memalpha = 1.3709335611E-4
-
-
-echargeemass = PhysicalQuantityInteractive(-1.758820174E11 , 'C/kg')
-echargeemass.__doc__ = """electron charge to mass quotient    """
-
-
-Molar_e = PhysicalQuantityInteractive(5.485799110E-7 , 'kg/mol')
-Molar_e.__doc__ = """electron molar mass     """
-
-
-lambdaC = PhysicalQuantityInteractive(2.426310215E-12 , 'm')
-lambdaC.__doc__ = """Compton wavelength """
-
-
-r_e = PhysicalQuantityInteractive(2.817940285E-15 , 'm')
-r_e.__doc__ = """classical electron radius  """
-
-
-sigma_e = PhysicalQuantityInteractive(0.665245854E-28 , 'm**2')
-sigma_e.__doc__ = """Thomson cross section """
-
-
-u_e = PhysicalQuantityInteractive(-928.476362E-26 , 'J/T')
-u_e.__doc__ = """electron magnetic moment    """
-
-# electron magnetic moment to Bohr magneton ratio     
-ueuB = -1.0011596521869
-
-# electron magnetic moment to nuclear magneton ratio    
-ueuN = -1838.2819660
-
-# electron magnetic moment anomaly |ue|/uB - 1    
-a_e = 1.1596521869E-3
-
-# electron g-factor 
-g_e = -2.0023193043737
-
-# electron-muon magnetic moment ratio   
-ueuu = 206.7669720
-
-# electron-proton magnetic moment ratio    
-ueup = -658.2106875
-
-# electron to shielded proton magnetic moment ratio  (H2O, sphere, 25  C)
-ueusp = -658.2275954
-
-# electron-neutron magnetic moment ratio    
-ueun = 960.92050
-
-# electron-deuteron magnetic moment ratio    
-ueud = -2143.923498
-
-# electron to shielded helione magnetic moment ratio  (gas, sphere, 25  C)
-ueush = 864.058255
-
-
-gamma_e = PhysicalQuantityInteractive(1.760859794E11 , '1/(s*T)')
-gamma_e.__doc__ = """electron gyromagnetic ratio """
-
-# Muon, u-
-#-------------------------------------------------------------------------
-
-m_u = PhysicalQuantityInteractive(1.88353109E-28 , 'kg')
-m_u.__doc__ = """muon mass    """
-
-mu_u = PhysicalQuantityInteractive(0.1134289168 , 'amu')
-mu_u.__doc__ = """muon mass in muon relative atomic mass times amu    """
-
-
-muc2_J = PhysicalQuantityInteractive(1.69283332E-11 , 'J')
-muc2_J.__doc__ = """energy equivalent    """
-
-muc2_MeV = PhysicalQuantityInteractive(105.6583568 , 'MeV')
-muc2_MeV.__doc__ = """energy equivalent in MeV """
-
-# muon-electron mass ratio    
-mume = 206.7682657
-
-# muon-tau mass ratio
-mum = 5.94572E-2
-
-# muon-proton mass ratio
-mump = 0.1126095173
-
-# muon-neutron mass ratio 
-mumn = 0.1124545079
-
-
-Molar_u = PhysicalQuantityInteractive(0.1134289168E-3 , 'kg/mol')
-Molar_u.__doc__ = """muon molar mass """
-
-
-lambda_C_u = PhysicalQuantityInteractive(11.73444197E-15 , 'm')
-lambda_C_u.__doc__ = """muon Compton wavelength """
-
-
-uu = PhysicalQuantityInteractive(-4.49044813E-26 , 'J/T')
-uu.__doc__ = """muon magnetic moment    """
-
-# ratio of muon magnetic moment to Bohr magneton ratio 
-uuuB = -4.84197085E-3
-
-# ratio of muon magnetic moment to nuclear magneton ratio    
-uuuN = -8.89059770
-
-# muon magnetic moment anomaly |uu|/(e /2mu) - 1    
-a_u = 1.16591602E-3
-
-# muon g-factor -2(1 + au)
-g_u = -2.0023318320
-
-# muon-proton magnetic moment ratio    
-uuup = -3.18334539
-
-# Tau, tau-
-#-------------------------------------------------------------------------
-
-m_tau = PhysicalQuantityInteractive(3.16788E-27 , 'kg')
-m_tau.__doc__ = """tau mass    """
-
-mu_tau = PhysicalQuantityInteractive(1.90774 , 'amu')
-mu_tau.__doc__ = """tau mass  (tau relative atomic mass times amu)   """
-
-
-mtauc2_J = PhysicalQuantityInteractive(2.84715E-10 , 'J')
-mtauc2_J.__doc__ = """tau mass energy equivalent    """
-
-
-mtauc2_MeV = PhysicalQuantityInteractive(1777.05 , 'MeV')
-mtauc2_MeV.__doc__ = """tau mass energy equivalent in MeV """
-
-# tau-electron mass ratio   
-mtaume = 3477.60
-
-# tau-muon mass ratio    
-mtaumu = 16.8188
-
-# tau-proton mass ratio    
-mtaump = 1.89396
-
-# tau-neutron mass ratio    
-mtaumn = 1.89135
-
-
-Molar_tau = PhysicalQuantityInteractive(1.90774E-3 , 'kg/mol')
-Molar_tau.__doc__ = """tau molar mass """
-
-
-lambda_C_tau = PhysicalQuantityInteractive(0.69770E-15 , 'm')
-lambda_C_tau.__doc__ = """tau Compton wavelength    """
-
-# Proton, p
-#-------------------------------------------------------------------------
-
-m_p = PhysicalQuantityInteractive(1.67262158E-27 , 'kg')
-m_p.__doc__ = """proton mass  """
-
-mu_p = PhysicalQuantityInteractive(1.00727646688 , 'amu')
-mu_p.__doc__ = """proton mass (proton relative atomic mass times amu)  """
-
-
-mpc2_J = PhysicalQuantityInteractive(1.50327731E-10 , 'J')
-mpc2_J.__doc__ = """energy equivalent   """
-
-mpc2_MeV = PhysicalQuantityInteractive(938.271998 , 'MeV')
-mpc2_MeV.__doc__ = """energy equivalent in MeV  """
-
-# proton-electron mass ratio 
-mpme = 1836.1526675
-
-# proton-muon mass ratio
-mpmu = 8.88024408
-
-# proton-tau mass ratio 
-mpmtau = 0.527994
-
-# proton-neutron mass ratio 
-mpmn = 0.99862347855
-
-
-emp = PhysicalQuantityInteractive(9.57883408E7 , 'C/kg')
-emp.__doc__ = """proton charge to mass quotient    """
-
-
-Molar_p = PhysicalQuantityInteractive(1.00727646688E-3 , 'kg/mol')
-Molar_p.__doc__ = """proton molar mass """
-
-
-lambda_C_p = PhysicalQuantityInteractive(1.321409847E-15 , 'm')
-lambda_C_p.__doc__ = """proton Compton wavelength h/mpc  """
-
-
-up = PhysicalQuantityInteractive(1.410606633E-26 , 'J/T')
-up.__doc__ = """proton magnetic moment   """
-
-# proton magnetic moment to Bohr magneton ratio 
-upuB = 1.521032203E-3
-
-# proton magnetic moment to nuclear magneton ratio 
-upuN = 2.792847337
-
-# proton g-factor 2up/uN  
-g_p = 5.585694675
-
-# proton-neutron magnetic moment ratio  
-upun = -1.45989805
-
-
-usp = PhysicalQuantityInteractive(1.410570399E-26 , 'J/T')
-usp.__doc__ = """shielded proton magnetic moment  (H2O, sphere, 25  C)"""
-
-# shielded proton magnetic moment to Bohr magneton ratio 
-uspuB = 1.520993132E-3
-
-# shielded proton magnetic moment to nuclear magneton ratio 
-uspuN = 2.792775597
-
-# proton magnetic shielding correction 1 - u p/up  (H2O, sphere, 25  C)
-spc = 25.687E-6
-
-
-gamma_p = PhysicalQuantityInteractive(2.67522212E8 , '1/(s*T)')
-gamma_p.__doc__ = """proton gyromagnetic ratio """
-
-
-gamma_sp = PhysicalQuantityInteractive(2.67515341E8 , '1/(s*T)')
-gamma_sp.__doc__ = """shielded proton gyromagnetic ratio (H2O, sphere, 25  C)"""
-
-# Neutron, n
-#-------------------------------------------------------------------------
-
-m_n = PhysicalQuantityInteractive(1.67492716E-27 , 'kg')
-m_n.__doc__ = """neutron mass  """
-
-mu_n = PhysicalQuantityInteractive(1.00866491578 , 'amu')
-mu_n.__doc__ = """neutron mass (neutron relative atomic mass times amu) """
-
-
-mnc2_J = PhysicalQuantityInteractive(1.50534946E-10 , 'J')
-mnc2_J.__doc__ = """neutron mass energy equivalent  """
-
-
-mnc2_MeV = PhysicalQuantityInteractive(939.565330 , 'MeV')
-mnc2_MeV.__doc__ = """neutron mass energy equivalent  in MeV  """
-
-# neutron-electron mass ratio 
-mnme = 1838.6836550
-
-# neutron-muon mass ratio 
-mnmu = 8.89248478
-
-# neutron-tau mass ratio 
-mnm = 0.528722
-
-# neutron-proton mass ratio 
-mnmp = 1.00137841887
-
-
-Molar_n = PhysicalQuantityInteractive(1.00866491578E-3 , 'kg/mol')
-Molar_n.__doc__ = """neutron molar mass  """
-
-
-lambda_C_n = PhysicalQuantityInteractive(1.319590898E-15 , 'm')
-lambda_C_n.__doc__ = """neutron Compton wavelength"""
-
-
-un = PhysicalQuantityInteractive(-0.96623640E-26 , 'J/T')
-un.__doc__ = """neutron magnetic moment """
-
-# neutron magnetic moment to Bohr magneton ratio 
-unuB = -1.04187563E-3
-
-# neutron magnetic moment to nuclear magneton ratio 
-unuN = -1.91304272
-
-# neutron g-factor 
-g_n = -3.82608545
-
-# neutron-electron magnetic moment ratio  
-unue = 1.04066882E-3
-
-# neutron-proton magnetic moment ratio 
-unup = -0.68497934
-
-# neutron to shielded proton magnetic moment ratio (H2O, sphere, 25  C)
-unusp = -0.68499694
-
-
-gamma_n = PhysicalQuantityInteractive(1.83247188E8 , '1/(s*T)')
-gamma_n.__doc__ = """neutron gyromagnetic ratio """
-
-# Deuteron, d
-#-------------------------------------------------------------------------
-
-m_d = PhysicalQuantityInteractive(3.34358309E-27 , 'kg')
-m_d.__doc__ = """deuteron mass """
-
-
-mu_d = PhysicalQuantityInteractive(2.01355321271 , 'amu')
-mu_d.__doc__ = """deuteron mass (deuteron relative atomic mass times amu)  """
-
-
-mdc2_J = PhysicalQuantityInteractive(3.00506262E-10 , 'J')
-mdc2_J.__doc__ = """deuteron mass energy equivalent """
-
-
-mdc2_eV = PhysicalQuantityInteractive(1875.612762 , 'MeV')
-mdc2_eV.__doc__ = """deuteron mass energy equivalent in MeV  """
-
-# deuteron-electron mass ratio  
-mdme = 3670.4829550
-
-# deuteron-proton mass ratio 
-mdmp = 1.99900750083
-
-
-Molar_d = PhysicalQuantityInteractive(2.01355321271E-3 , 'kg/mol')
-Molar_d.__doc__ = """deuteron molar mass """
-
-
-ud = PhysicalQuantityInteractive(0.433073457E-26 , 'J/T')
-ud.__doc__ = """deuteron magnetic moment  """
-
-# deuteron magnetic moment to Bohr magneton ratio 
-uduB = 0.4669754556E-3
-
-# deuteron magnetic moment to nuclear magneton ratio 
-uduN = 0.8574382284
-
-# deuteron-electron magnetic moment ratio 
-udue = -4.664345537E-4
-
-# deuteron-proton magnetic moment ratio 
-udup = 0.3070122083
-
-# deuteron-neutron magnetic moment ratio 
-udun = -0.44820652
-
-# Helion, h
-#-------------------------------------------------------------------------
-
-m_h = PhysicalQuantityInteractive(5.00641174E-27 , 'kg')
-m_h.__doc__ = """helion mass """
-
-
-mu_h = PhysicalQuantityInteractive(3.01493223469 , 'amu')
-mu_h.__doc__ = """helion mass (helion relative atomic mass times amu)  """
-
-
-mhc2_J = PhysicalQuantityInteractive(4.49953848E-10 , 'J')
-mhc2_J.__doc__ = """helion mass energy equivalent """
-
-mhc2_MeV = PhysicalQuantityInteractive(2808.39132 , 'MeV')
-mhc2_MeV.__doc__ = """helion mass energy equivalent in MeV """
-
-# helion-electron mass ratio 
-mhme = 5495.885238
-
-# helion-proton mass ratio 
-mhmp = 2.99315265850
-
-
-Molar_h = PhysicalQuantityInteractive(3.01493223469E-3 , 'kg/mol')
-Molar_h.__doc__ = """helion molar mass """
-
-
-ush = PhysicalQuantityInteractive(-1.074552967E-26 , 'J/T')
-ush.__doc__ = """shielded helion magnetic moment (gas, sphere, 25  C)"""
-
-# shielded helion magnetic moment to Bohr magneton ratio 
-ushuB = -1.158671474E-3
-
-# shielded helion magnetic moment to nuclear magneton ratio  
-ushuN = -2.127497718
-
-# shielded helion to proton magnetic moment ratio  (gas, sphere, 25  C)
-ushup = -0.761766563
-
-# shielded helion to shielded proton magnetic moment ratio  (gas/H2O, spheres, 25  C)
-ushusp = -0.7617861313
-
-
-gamma_h = PhysicalQuantityInteractive(2.037894764E8 , '1/(s*T)')
-gamma_h.__doc__ = """shielded helion gyromagnetic  (gas, sphere, 25  C) """
-
-# Alpha particle, 
-#-------------------------------------------------------------------------
-
-m_alpha = PhysicalQuantityInteractive(6.64465598E-27 , 'kg')
-m_alpha.__doc__ = """alpha particle mass  """
-
-mu_alpha = PhysicalQuantityInteractive(4.0015061747 , 'amu')
-mu_alpha.__doc__ = """alpha particle mass (alpha particle relative atomic mass times amu) """
-
-
-malphac2_J = PhysicalQuantityInteractive(5.97191897E-10 , 'J')
-malphac2_J.__doc__ = """alpha particle mass energy equivalent  """
-
-
-malphac2_MeV = PhysicalQuantityInteractive(3727.37904 , 'MeV')
-malphac2_MeV.__doc__ = """alpha particle mass energy equivalent in MeV  """
-
-# alpha particle to electron mass ratio 
-malphame = 7294.299508
-
-# alpha particle to proton mass ratio 
-malphamp = 3.9725996846
-
-
-Molar_alpha = PhysicalQuantityInteractive(4.0015061747E-3 , 'kg/mol')
-Molar_alpha.__doc__ = """alpha particle molar mass"""
-
-# PHYSICO-CHEMICAL
-#-------------------------------------------------------------------------
-
-N_A = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
-N_A.__doc__ = """Avogadro constant  """
-L = PhysicalQuantityInteractive(6.02214199E23 , '1/mol')
-
-
-m_u = PhysicalQuantityInteractive(1.66053873E-27 , 'kg')
-m_u.__doc__ = """atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA"""
-# atomic mass constant mu = 112m(12C) = 1 u = 10E-3 kg mol-1/NA
-amu = m_u
-
-
-muc2_J = PhysicalQuantityInteractive(1.49241778E-10 , 'J')
-muc2_J.__doc__ = """energy equivalent of the atomic mass constant"""
-
-
-muc2_MeV = PhysicalQuantityInteractive(931.494013 , 'MeV')
-muc2_MeV.__doc__ = """energy equivalent of the atomic mass constant in MeV """
-
-
-F = PhysicalQuantityInteractive(96485.3415 , 'C/mol')
-F.__doc__ = """Faraday constant"""
-
-
-N_Ah = PhysicalQuantityInteractive(3.990312689E-10 , 'J*s/mol')
-N_Ah.__doc__ = """molar Planck constant   """
-
-
-R = PhysicalQuantityInteractive(8.314472 , 'J/(mol*K)')
-R.__doc__ = """molar gas constant  """
-
-
-k_J = PhysicalQuantityInteractive(1.3806503E-23 , 'J/K')
-k_J.__doc__ = """Boltzmann constant """
-
-
-k_eV = PhysicalQuantityInteractive(8.617342E-5 , 'eV/K')
-k_eV.__doc__ = """Boltzmann constant in eV """
-
-
-n_0 = PhysicalQuantityInteractive(2.6867775E25 , '1/m**3')
-n_0.__doc__ = """Loschmidt constant  NA/Vm """
-
-
-Vm_1 = PhysicalQuantityInteractive(22.413996E-3 , 'm**3/mol')
-Vm_1.__doc__ = """molar volume of ideal gas RT/p   T = 273.15 K, p = 101.325 kPa """
-
-Vm_2 = PhysicalQuantityInteractive(22.710981E-3 , 'm**3/mol')
-Vm_2.__doc__ = """molar volume of ideal gas RT/p   T = 273.15 K, p = 100 kPa  """
-
-# Sackur-Tetrode constant (absolute entropy constant) 52 + ln_(2 mukT1/h2)3/2kT1/p0
-# T1 = 1 K, p0 = 100 kPa 
-S_0R_1 = -1.1517048
-# T1 = 1 K, p0 = 101.325 kPa  
-S_0R_2 = -1.1648678
-
-
-sigma = PhysicalQuantityInteractive(5.670400E-8 , 'W/(m**2*K**4)')
-sigma.__doc__ = """Stefan-Boltzmann constant """
-
-
-c_1 = PhysicalQuantityInteractive(3.74177107E-16 , 'W*m**2')
-c_1.__doc__ = """first radiation constant"""
-
-
-c_1L = PhysicalQuantityInteractive(1.191042722E-16 , 'W*m**2/sr')
-c_1L.__doc__ = """first radiation constant for spectral radiance"""
-
-
-c_2 = PhysicalQuantityInteractive(1.4387752E-2 , 'm*K')
-c_2.__doc__ = """second radiation constant"""
-
-
-b = PhysicalQuantityInteractive(2.8977686E-3 , 'm*K')
-b.__doc__ = """Wien displacement law constant b =  maxT = c2/4.965 114231... """
-
diff --git a/IPython/deathrow/ipy_defaults.py b/IPython/deathrow/ipy_defaults.py
deleted file mode 100644
index 665a1241db5..00000000000
--- a/IPython/deathrow/ipy_defaults.py
+++ /dev/null
@@ -1,62 +0,0 @@
-""" Set default options for IPython. 
-
-Just import this module to get reasonable defaults for everything.
-
-These configurations used to be performed in ipythonrc (or ipythonrc.ini). 
-Therefore importing this in your config files makes ipython basically
-ignore your ipythonrc. This is *not* imported by default, you need to import 
-this manually in one of your config files.
-
-You can further override these defaults in e.g. your ipy_user_config.py,
-ipy_profile_PROFILENAME etc.
-
-"""
-
-import IPython.utils.rlineimpl as readline
-from IPython.core import ipapi
-ip = ipapi.get()
-
-o = ip.options
-
-o.colors = "Linux"
-o.color_info=1
-o.confirm_exit=1
-o.pprint=1
-o.multi_line_specials=1
-o.xmode="Context"
-
-
-o.prompt_in1='In [\#]: '
-o.prompt_in2 ='   .\D.: '
-o.prompt_out = 'Out[\#]: '
-o.prompts_pad_left=1
-
-o.autoindent = 1
-
-o.readline_remove_delims="-/~"
-o.readline_merge_completions=1
-
-o.readline = 1
-
-rlopts = """\
-tab: complete
-"\C-l": possible-completions
-set show-all-if-ambiguous on
-"\C-o": tab-insert
-"\M-i": "    "
-"\M-o": "\d\d\d\d"
-"\M-I": "\d\d\d\d"
-"\C-r": reverse-search-history
-"\C-s": forward-search-history
-"\C-p": history-search-backward
-"\C-n": history-search-forward
-"\e[A": history-search-backward
-"\e[B": history-search-forward
-"\C-k": kill-line
-"\C-u": unix-line-discard"""
-
-if readline.have_readline:
-    for cmd in rlopts.split('\n'):
-        readline.parse_and_bind(cmd)
-    
-    
diff --git a/IPython/deathrow/ipy_kitcfg.py b/IPython/deathrow/ipy_kitcfg.py
deleted file mode 100644
index 57409c83b93..00000000000
--- a/IPython/deathrow/ipy_kitcfg.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import os,sys
-
-import ipy_rehashdir,glob
-from ipy_rehashdir import selflaunch, PyLauncher
-
-def pylaunchers():
-    """Create launchers for python scripts in cwd and store them in alias table
-    
-    This is useful if you want to invoke .py scripts from ipykit session,
-    just adding .py files in PATH does not work without file association.
-    
-    .ipy files will be run like macros.
-    
-    """
-    fs = glob.glob('*.py') + glob.glob('*.ipy')
-    for f in fs:
-        l = PyLauncher(f)
-        n = os.path.splitext(f)[0]
-        ip.define_alias(n, l)
-        ip.magic('store '+n)
-
-
-def exta_imports():
-    # add some modules that you'd want to be bundled in the ipykit
-    # library zip file here. Do this if you get ImportErrors from scripts you
-    # try to launch with 'py' or pylaunchers. In theory you could include
-    # the whole stdlib here for full script coverage
-    
-    # note that this is never run, it's just here for py2exe
-    import distutils.dir_util
-  
-def kitroot():
-    return os.environ.get('IPYKITROOT', None)
-    
-def main():
-
-    if not kitroot():
-        print "Can't configure ipykit, IPYKITROOT should be set."
-        return
-        
-    os.environ["PATH"] = os.environ["PATH"] + ";" + kitroot() + "\\bin;"
-    ip.push("pylaunchers")
-    cmds = ip.db.get('syscmdlist', None)
-    if cmds is None:
-        ip.magic('rehashx')
-        cmds = ip.db.get('syscmdlist', [])
-    #print cmds
-    if 'sc1' in cmds:
-        print "Default editor: Sc1"
-        import ipy_editors
-        ipy_editors.scite('sc1')
-    
-    # for icp, imv, imkdir, etc.
-    import ipy_fsops
-
-greeting = """\n\n === Welcome to ipykit ===
-
-%quickref - learn quickly about IPython.
-
-"""
-    
-def ipython_firstrun(ip):
-
-    print "First run of ipykit - configuring"
-
-    ip.define_alias('py',selflaunch)
-    ip.define_alias('d','dir /w /og /on')
-    ip.magic('store py')
-    ip.magic('store d')
-    
-    bins = kitroot() +'/bin'
-
-    print greeting
-        
-def init_ipython(ipy):
-    global ip
-    ip = ipy
-    main()
-
-
diff --git a/IPython/deathrow/ipy_legacy.py b/IPython/deathrow/ipy_legacy.py
deleted file mode 100644
index aa7a1482be5..00000000000
--- a/IPython/deathrow/ipy_legacy.py
+++ /dev/null
@@ -1,62 +0,0 @@
-""" Legacy stuff
-
-Various stuff that are there for historical / familiarity reasons.
-
-This is automatically imported by default profile, though not other profiles
-(e.g. 'sh' profile).
-
-Stuff that is considered obsolete / redundant is gradually moved here.
-
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import os,sys
-
-from IPython.utils.genutils import *
-
-# use rehashx
-
-def magic_rehash(self, parameter_s = ''):
-    """Update the alias table with all entries in $PATH.
-
-    This version does no checks on execute permissions or whether the
-    contents of $PATH are truly files (instead of directories or something
-    else).  For such a safer (but slower) version, use %rehashx."""
-
-    # This function (and rehashx) manipulate the alias_table directly
-    # rather than calling magic_alias, for speed reasons.  A rehash on a
-    # typical Linux box involves several thousand entries, so efficiency
-    # here is a top concern.
-
-    path = filter(os.path.isdir,os.environ.get('PATH','').split(os.pathsep))
-    alias_table = self.shell.alias_table
-    for pdir in path:
-        for ff in os.listdir(pdir):
-            # each entry in the alias table must be (N,name), where
-            # N is the number of positional arguments of the alias.
-            alias_table[ff] = (0,ff)
-    # Make sure the alias table doesn't contain keywords or builtins
-    self.shell.alias_table_validate()
-    # Call again init_auto_alias() so we get 'rm -i' and other modified
-    # aliases since %rehash will probably clobber them
-    self.shell.init_auto_alias()
-
-ip.define_magic("rehash", magic_rehash)
-
-# Exit
-def magic_Quit(self, parameter_s=''):
-    """Exit IPython without confirmation (like %Exit)."""
-
-    self.shell.ask_exit()
-
-ip.define_magic("Quit", magic_Quit)
-
-
-# make it autocallable fn if you really need it
-def magic_p(self, parameter_s=''):
-    """Just a short alias for Python's 'print'."""
-    exec 'print ' + parameter_s in self.shell.user_ns
-
-ip.define_magic("p", magic_p)
diff --git a/IPython/deathrow/ipy_p4.py b/IPython/deathrow/ipy_p4.py
deleted file mode 100644
index 0bda2fe765f..00000000000
--- a/IPython/deathrow/ipy_p4.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Add %p4 magic for pythonic p4 (Perforce) usage.
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import os,sys,marshal
-
-import ipy_stock_completers
-
-def p4_f(self, parameter_s=''):
-    cmd = 'p4 -G ' + parameter_s
-    fobj = os.popen(cmd)
-    out = []
-    while 1:
-        try:
-            out.append(marshal.load(fobj))
-        except EOFError:
-            break
-        
-    return out
-
-def p4d(fname):
-    return os.popen('p4 where ' + fname).read().split()[0]
-    
-ip.push("p4d")
-
-ip.define_magic('p4', p4_f)
-
-p4_commands = """\
-add admin annotate branch branches change changes changelist
-changelists client clients counter counters delete depot depots
-describe diff diff2 dirs edit filelog files fix fixes flush fstat
-group groups have help info integrate integrated job jobs jobspec
-label labels labelsync lock logger login logout monitor obliterate
-opened passwd print protect rename reopen resolve resolved revert
-review reviews set submit sync tag tickets triggers typemap unlock
-user users verify workspace workspaces where"""
-    
-def p4_completer(self,event):
-    return ipy_stock_completers.vcs_completer(p4_commands, event)
-
-ip.set_hook('complete_command', p4_completer, str_key = '%p4')
-ip.set_hook('complete_command', p4_completer, str_key = 'p4')
-
diff --git a/IPython/deathrow/ipy_profile_none.py b/IPython/deathrow/ipy_profile_none.py
deleted file mode 100644
index 195aa877115..00000000000
--- a/IPython/deathrow/ipy_profile_none.py
+++ /dev/null
@@ -1,4 +0,0 @@
-""" Config file for 'default' profile """
-
-# get various stuff that are there for historical / familiarity reasons
-import ipy_legacy
\ No newline at end of file
diff --git a/IPython/deathrow/ipy_profile_numpy.py b/IPython/deathrow/ipy_profile_numpy.py
deleted file mode 100644
index 6659884b40a..00000000000
--- a/IPython/deathrow/ipy_profile_numpy.py
+++ /dev/null
@@ -1,24 +0,0 @@
-""" IPython 'numpy' profile, to preload NumPy.
-
-This profile loads the math/cmath modules as well as all of numpy.
-
-It exposes numpy via the 'np' shorthand as well for convenience.
-"""
-
-from IPython.core import ipapi
-import ipy_defaults
-
-def main():
-    ip = ipapi.get()
-
-    try:
-        ip.ex("import math,cmath")
-        ip.ex("import numpy")
-        ip.ex("import numpy as np")
-
-        ip.ex("from numpy import *")
-
-    except ImportError:
-        print "Unable to start NumPy profile, is numpy installed?"
-    
-main()
diff --git a/IPython/deathrow/ipy_profile_scipy.py b/IPython/deathrow/ipy_profile_scipy.py
deleted file mode 100644
index 25defe41ae1..00000000000
--- a/IPython/deathrow/ipy_profile_scipy.py
+++ /dev/null
@@ -1,29 +0,0 @@
-""" IPython 'scipy' profile, preloads NumPy and SciPy.
-
-This profile loads the math/cmath modules as well as all of numpy and scipy.
-
-It exposes numpy and scipy via the 'np' and 'sp' shorthands as well for
-convenience.
-"""
-
-from IPython.core import ipapi
-import ipy_defaults
-
-def main():
-    ip = ipapi.get()
-
-    try:
-        ip.ex("import math,cmath")
-        ip.ex("import numpy")
-        ip.ex("import scipy")
-
-        ip.ex("import numpy as np")
-        ip.ex("import scipy as sp")
-    
-        ip.ex("from numpy import *")
-        ip.ex("from scipy import *")
-
-    except ImportError:
-        print "Unable to start scipy profile, are numpy and scipy installed?"
-    
-main()
diff --git a/IPython/deathrow/ipy_profile_sh.py b/IPython/deathrow/ipy_profile_sh.py
deleted file mode 100644
index 571f5c48267..00000000000
--- a/IPython/deathrow/ipy_profile_sh.py
+++ /dev/null
@@ -1,271 +0,0 @@
-"""Shell mode for IPython.
-
-Start ipython in shell mode by invoking "ipython -p sh"
-
-(the old version, "ipython -p pysh" still works but this is the more "modern" 
-shell mode and is recommended for users who don't care about pysh-mode
-compatibility)
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-import os,re,textwrap
-
-# The import below effectively obsoletes your old-style ipythonrc[.ini],
-# so consider yourself warned!
-
-import ipy_defaults
-
-def main():    
-    ip = ipapi.get()
-    o = ip.options
-    # autocall to "full" mode (smart mode is default, I like full mode)
-    
-    o.autocall = 2
-    
-    # Jason Orendorff's path class is handy to have in user namespace
-    # if you are doing shell-like stuff
-    try:
-        ip.ex("from IPython.external.path import path" )
-    except ImportError:
-        pass
-    
-    # beefed up %env is handy in shell mode
-    import envpersist
-    
-    # To see where mycmd resides (in path/aliases), do %which mycmd 
-    import ipy_which
-    
-    # tab completers for hg, svn, ...
-    import ipy_app_completers
-    
-    # To make executables foo and bar in mybin usable without PATH change, do:
-    # %rehashdir c:/mybin
-    # %store foo
-    # %store bar
-    import ipy_rehashdir
-
-    # does not work without subprocess module!
-    #import ipy_signals
-    
-    ip.ex('import os')
-    ip.ex("def up(): os.chdir('..')")
-    ip.user_ns['LA'] = LastArgFinder() 
-    
-    # You can assign to _prompt_title variable 
-    # to provide some extra information for prompt
-    # (e.g. the current mode, host/username...)
-
-    ip.user_ns['_prompt_title'] = ''
-    
-    # Nice prompt
-    o.prompt_in1= r'\C_Green${_prompt_title}\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#> '
-    o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green> '
-    o.prompt_out= '<\#> '
-    
-    from IPython.core import release
-
-    import sys
-    # Non-chatty banner
-    o.banner = "IPython %s   [on Py %s]\n" % (release.version,sys.version.split(None,1)[0])
-    
-    
-    ip.default_option('cd','-q')
-    ip.default_option('macro', '-r')
-    # If you only rarely want to execute the things you %edit...  
-    #ip.default_option('edit','-x')
-    
-
-    o.prompts_pad_left="1"
-    # Remove all blank lines in between prompts, like a normal shell.
-    o.separate_in="0"
-    o.separate_out="0"
-    o.separate_out2="0"
-    
-    # now alias all syscommands
-    
-    db = ip.db
-    
-    syscmds = db.get("syscmdlist",[] )
-    if not syscmds:
-        print textwrap.dedent("""
-        System command list not initialized, probably the first run...
-        running %rehashx to refresh the command list. Run %rehashx
-        again to refresh command list (after installing new software etc.)
-        """)
-        ip.magic('rehashx')
-        syscmds = db.get("syscmdlist")
-    
-    # lowcase aliases on win32 only
-    if os.name == 'posix':
-        mapper = lambda s:s
-    else:
-        def mapper(s): return s.lower()
-        
-    for cmd in syscmds:
-        # print "sys",cmd #dbg
-        noext, ext = os.path.splitext(cmd)
-        if ext.lower() == '.exe':
-            cmd = noext
-        
-        key = mapper(cmd)
-        if key not in ip.alias_manager.alias_table:
-            # Dots will be removed from alias names, since ipython
-            # assumes names with dots to be python code
-            
-            ip.define_alias(key.replace('.',''), cmd)
-
-    # mglob combines 'find', recursion, exclusion... '%mglob?' to learn more
-    ip.load("IPython.external.mglob")    
-
-    # win32 is crippled w/o cygwin, try to help it a little bit
-    if sys.platform == 'win32':
-        if 'cygwin' in os.environ['PATH'].lower():          
-            # use the colors of cygwin ls (recommended)
-            ip.define_alias('d', 'ls -F --color=auto')
-        else:
-            # get icp, imv, imkdir, igrep, irm,...
-            ip.load('ipy_fsops')
-            
-            # and the next best thing to real 'ls -F'
-            ip.define_alias('d','dir /w /og /on')
-    
-    ip.set_hook('input_prefilter', slash_prefilter_f)
-    extend_shell_behavior(ip)
-
-class LastArgFinder:
-    """ Allow $LA to work as "last argument of previous command", like $! in bash
-    
-    To call this in normal IPython code, do LA()
-    """
-    def __call__(self, hist_idx = None):
-        ip = ipapi.get()
-        if hist_idx is None:
-            return str(self)
-        return ip.input_hist_raw[hist_idx].strip().split()[-1]
-    def __str__(self):
-        ip = ipapi.get()        
-        for cmd in reversed(ip.input_hist_raw):
-            parts = cmd.strip().split()
-            if len(parts) < 2 or parts[-1] in ['$LA', 'LA()']:
-                continue
-            return parts[-1]
-        return ""
-
-def slash_prefilter_f(self,line):
-    """ ./foo, ~/foo and /bin/foo now run foo as system command
-    
-    Removes the need for doing !./foo, !~/foo or !/bin/foo
-    """
-    from IPython.utils import genutils
-    if re.match('(?:[.~]|/[a-zA-Z_0-9]+)/', line):
-        return "get_ipython().system(" + genutils.make_quoted_expr(line)+")"
-    raise TryNext
-
-# XXX You do not need to understand the next function!
-# This should probably be moved out of profile
-
-def extend_shell_behavior(ip):
-
-    # Instead of making signature a global variable tie it to IPSHELL.
-    # In future if it is required to distinguish between different
-    # shells we can assign a signature per shell basis
-    ip.__sig__ = 0xa005
-    # mark the IPSHELL with this signature
-    ip.user_ns['__builtins__'].__dict__['__sig__'] = ip.__sig__
-
-    from IPython.external.Itpl import ItplNS
-    from IPython.utils.genutils import shell
-    # utility to expand user variables via Itpl
-    # xxx do something sensible with depth?
-    ip.var_expand = lambda cmd, lvars=None, depth=2: \
-        str(ItplNS(cmd, ip.user_ns, get_locals()))
-
-    def get_locals():
-        """ Substituting a variable through Itpl deep inside the IPSHELL stack
-            requires the knowledge of all the variables in scope upto the last
-            IPSHELL frame. This routine simply merges all the local variables
-            on the IPSHELL stack without worrying about their scope rules
-        """
-        import sys
-        # note lambda expression constitues a function call
-        # hence fno should be incremented by one
-        getsig = lambda fno: sys._getframe(fno+1).f_globals \
-                             ['__builtins__'].__dict__['__sig__']
-        getlvars = lambda fno: sys._getframe(fno+1).f_locals
-        # trackback until we enter the IPSHELL
-        frame_no = 1
-        sig = ip.__sig__
-        fsig = ~sig
-        while fsig != sig :
-            try:
-                fsig = getsig(frame_no)
-            except (AttributeError, KeyError):
-                frame_no += 1
-            except ValueError:
-                # stack is depleted
-                # call did not originate from IPSHELL
-                return {}
-        first_frame = frame_no
-        # walk further back until we exit from IPSHELL or deplete stack
-        try:
-            while(sig == getsig(frame_no+1)):
-                frame_no += 1
-        except (AttributeError, KeyError, ValueError):
-            pass
-        # merge the locals from top down hence overriding
-        # any re-definitions of variables, functions etc.
-        lvars = {}
-        for fno in range(frame_no, first_frame-1, -1):
-            lvars.update(getlvars(fno))
-        #print '\n'*5, first_frame, frame_no, '\n', lvars, '\n'*5 #dbg
-        return lvars
-
-    def _runlines(lines):
-        """Run a string of one or more lines of source.
-
-        This method is capable of running a string containing multiple source
-        lines, as if they had been entered at the IPython prompt.  Since it
-        exposes IPython's processing machinery, the given strings can contain
-        magic calls (%magic), special shell access (!cmd), etc."""
-
-        # We must start with a clean buffer, in case this is run from an
-        # interactive IPython session (via a magic, for example).
-        ip.resetbuffer()
-        lines = lines.split('\n')
-        more = 0
-        command = ''
-        for line in lines:
-            # skip blank lines so we don't mess up the prompt counter, but do
-            # NOT skip even a blank line if we are in a code block (more is
-            # true)
-            # if command is not empty trim the line
-            if command != '' :
-                line = line.strip()
-            # add the broken line to the command
-            if line and line[-1] == '\\' :
-                command += line[0:-1] + ' '
-                more = True
-                continue
-            else :
-                # add the last (current) line to the command
-                command += line
-                if command or more:
-                    # push to raw history, so hist line numbers stay in sync
-                    ip.input_hist_raw.append("# " + command + "\n")
-                    
-                    more = ip.push_line(ip.prefilter(command,more))
-                    command = ''
-                    # IPython's runsource returns None if there was an error
-                    # compiling the code.  This allows us to stop processing right
-                    # away, so the user gets the error message at the right place.
-                    if more is None:
-                        break
-        # final newline in case the input didn't have it, so that the code
-        # actually does get executed
-        if more:
-            ip.push_line('\n')
-
-    ip.runlines = _runlines
-
-main()
diff --git a/IPython/deathrow/ipy_profile_zope.py b/IPython/deathrow/ipy_profile_zope.py
deleted file mode 100644
index 690b0212bd6..00000000000
--- a/IPython/deathrow/ipy_profile_zope.py
+++ /dev/null
@@ -1,324 +0,0 @@
-# -*- coding: utf-8 -*-
-""" An ipython profile for zope and plone.
-
-Some ideas stolen from http://www.tomster.org.
-
-
-Authors
--------
-- Stefan Eletzhofer <stefan.eletzhofer@inquant.de>
-"""
-
-# File: ipy_profile_zope.py
-#
-# Copyright (c) InQuant GmbH
-#
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-
-from IPython.core import ipapi
-from IPython.core import release
-from types import StringType
-import sys
-import os
-import textwrap
-
-sys_oldstdin  = sys.stdin
-
-# The import below effectively obsoletes your old-style ipythonrc[.ini],
-# so consider yourself warned!
-# import ipy_defaults
-
-_marker = []
-def shasattr(obj, attr, acquire=False):
-    """ See Archetypes/utils.py
-    """
-    if not acquire:
-        obj = obj.aq_base
-    return getattr(obj, attr, _marker) is not _marker
-
-class ZopeDebug(object):
-    def __init__(self):
-
-        self.instancehome = os.environ.get( "INSTANCE_HOME" )
-
-        configfile = os.environ.get( "CONFIG_FILE" )
-        if configfile is None and self.instancehome is not None:
-            configfile = os.path.join( self.instancehome, "etc", "zope.conf" )
-
-        if configfile is None:
-            raise RuntimeError( "CONFIG_FILE env not set" )
-
-        print "CONFIG_FILE=", configfile
-        print "INSTANCE_HOME=", self.instancehome
-
-        self.configfile = configfile
-
-        try:
-            from Zope2 import configure
-        except ImportError:
-            from Zope import configure
-
-        configure( configfile )
-
-        try:
-            import Zope2
-            app = Zope2.app()
-        except ImportError:
-            import Zope
-            app = Zope.app()
-
-        from Testing.makerequest import makerequest
-        self.app = makerequest( app )
-
-        try:
-            self._make_permissive()
-            print "Permissive security installed"
-        except:
-            print "Permissive security NOT installed"
-
-        self._pwd = self.portal or self.app
-
-        try:
-            from zope.component import getSiteManager
-            from zope.component import getGlobalSiteManager
-            from zope.app.component.hooks import setSite
-
-            if self.portal is not None:
-                setSite( self.portal )
-
-                gsm = getGlobalSiteManager()
-                sm = getSiteManager()
-
-                if sm is gsm:
-                    print "ERROR SETTING SITE!"
-        except:
-            pass
-
-
-    @property
-    def utils(self):
-        class Utils(object):
-            commit = self.commit
-            sync = self.sync
-            objectInfo = self.objectInfo
-            ls = self.ls
-            pwd = self.pwd
-            cd = self.cd
-            su = self.su
-            getCatalogInfo = self.getCatalogInfo
-
-            @property
-            def cwd(self):
-                return self.pwd()
-
-        return Utils()
-
-    @property
-    def namespace(self):
-        return dict( utils=self.utils, app=self.app, portal=self.portal )
-
-    @property
-    def portal(self):
-        portals = self.app.objectValues( "Plone Site" )
-        if len(portals):
-            return portals[0]
-        else:
-            raise KeyError( "No Plone Site found.")
-
-    def pwd(self):
-        return self._pwd
-
-    def _make_permissive(self):
-        """
-        Make a permissive security manager with all rights. Hell,
-        we're developers, aren't we? Security is for whimps. :)
-        """
-        from Products.CMFCore.tests.base.security import PermissiveSecurityPolicy
-        import AccessControl
-        from AccessControl.SecurityManagement import newSecurityManager
-        from AccessControl.SecurityManager import setSecurityPolicy
-
-        _policy = PermissiveSecurityPolicy()
-        self.oldpolicy = setSecurityPolicy(_policy)
-        newSecurityManager(None, AccessControl.User.system)
-
-    def su(self, username):
-        """ Change to named user.
-        """
-        # TODO Make it easy to change back to permissive security.
-        user = self.portal.acl_users.getUser(username)
-        if not user:
-            print "Can't find %s in %s" % (username, self.portal.acl_users)
-            return
-
-        from AccessControl import ZopeSecurityPolicy
-        import AccessControl
-        from AccessControl.SecurityManagement import newSecurityManager, getSecurityManager
-        from AccessControl.SecurityManager import setSecurityPolicy
-
-        _policy = ZopeSecurityPolicy
-        self.oldpolicy = setSecurityPolicy(_policy)
-        wrapped_user = user.__of__(self.portal.acl_users)
-        newSecurityManager(None, user)
-        print 'User changed.'
-        return getSecurityManager().getUser()
-
-    def getCatalogInfo(self, obj=None, catalog='portal_catalog', query=None, sort_on='created', sort_order='reverse' ):
-        """ Inspect portal_catalog. Pass an object or object id for a
-        default query on that object, or pass an explicit query.
-        """
-        if obj and query:
-            print "Ignoring %s, using query." % obj
-
-        catalog = self.portal.get(catalog)
-        if not catalog:
-            return 'No catalog'
-
-        indexes = catalog._catalog.indexes
-        if not query:
-            if type(obj) is StringType:
-                cwd = self.pwd()
-                obj = cwd.unrestrictedTraverse( obj )
-            # If the default in the signature is mutable, its value will
-            # persist across invocations.
-            query = {}
-            if indexes.get('path'):
-                from string import join
-                path = join(obj.getPhysicalPath(), '/') 
-                query.update({'path': path})
-            if indexes.get('getID'):
-                query.update({'getID': obj.id, })
-            if indexes.get('UID') and shasattr(obj, 'UID'):
-                query.update({'UID': obj.UID(), })
-        if indexes.get(sort_on):
-            query.update({'sort_on': sort_on, 'sort_order': sort_order})
-        if not query:
-            return 'Empty query'
-        results = catalog(**query)
-
-        result_info = []
-        for r in results:
-            rid = r.getRID()
-            if rid:
-                result_info.append(
-                        {'path': catalog.getpath(rid),
-                        'metadata': catalog.getMetadataForRID(rid),
-                        'indexes': catalog.getIndexDataForRID(rid), }
-                        )
-            else:
-                result_info.append({'missing': rid})
-
-        if len(result_info) == 1:
-            return result_info[0]
-        return result_info
-
-    def commit(self):
-        """
-        Commit the transaction.
-        """
-        try:
-            import transaction
-            transaction.get().commit()
-        except ImportError:
-            get_transaction().commit()
-
-    def sync(self):
-        """
-        Sync the app's view of the zodb.
-        """
-        self.app._p_jar.sync()
-
-    def objectInfo( self, o ):
-        """
-        Return a descriptive string of an object
-        """
-        Title = ""
-        t = getattr( o, 'Title', None )
-        if t:
-            Title = t()
-        return {'id': o.getId(),
-                'Title': Title,
-                'portal_type': getattr( o, 'portal_type', o.meta_type),
-                'folderish': o.isPrincipiaFolderish
-                }
-
-    def cd( self, path ):
-        """
-        Change current dir to a specific folder.
-
-         cd( ".." )
-         cd( "/plone/Members/admin" )
-         cd( portal.Members.admin )
-         etc.
-        """
-        if type(path) is not StringType:
-            path = '/'.join(path.getPhysicalPath())
-        cwd = self.pwd()
-        x = cwd.unrestrictedTraverse( path )
-        if x is None:
-            raise KeyError( "Can't cd to %s" % path )
-
-        print "%s -> %s" % ( self.pwd().getId(), x.getId() )
-        self._pwd = x
-
-    def ls( self, x=None ):
-        """
-        List object(s)
-        """
-        if type(x) is StringType:
-            cwd = self.pwd()
-            x = cwd.unrestrictedTraverse( x )
-        if x is None:
-            x = self.pwd()
-        if x.isPrincipiaFolderish:
-            return [self.objectInfo(o) for id, o in x.objectItems()]
-        else:
-            return self.objectInfo( x )
-
-zope_debug = None
-
-def ipy_set_trace():
-    from IPython.core import debugger
-    debugger.Pdb().set_trace()
-
-def main():
-    global zope_debug
-    ip = ipapi.get()
-    o = ip.options
-    # autocall to "full" mode (smart mode is default, I like full mode)
-    
-    SOFTWARE_HOME = os.environ.get( "SOFTWARE_HOME" )
-    sys.path.append( SOFTWARE_HOME )
-    print "SOFTWARE_HOME=%s\n" % SOFTWARE_HOME
-
-    zope_debug = ZopeDebug()
-
-    # <HACK ALERT>
-    import pdb;
-    pdb.set_trace = ipy_set_trace
-    # </HACK ALERT>
-
-    # I like my banner minimal.
-    o.banner = "ZOPE Py %s IPy %s\n" % (sys.version.split('\n')[0],release.version)
-
-    print textwrap.dedent("""\
-        ZOPE mode iPython shell.
-
-          Bound names:
-           app
-           portal
-           utils.{ %s }
-  
-        Uses the $SOFTWARE_HOME and $CONFIG_FILE environment
-        variables.
-        """ % ( ",".join([ x for x in dir(zope_debug.utils) if not x.startswith("_") ] ) ) )
-
-
-    sys.stdin  = sys_oldstdin
-    ip.user_ns.update( zope_debug.namespace )
-
-
-main()
-# vim: set ft=python ts=4 sw=4 expandtab :
diff --git a/IPython/deathrow/ipy_traits_completer.py b/IPython/deathrow/ipy_traits_completer.py
deleted file mode 100644
index f6092704fd5..00000000000
--- a/IPython/deathrow/ipy_traits_completer.py
+++ /dev/null
@@ -1,219 +0,0 @@
-"""Traits-aware tab completion.
-
-This module provides a custom tab-completer that intelligently hides the names
-that the enthought.traits library (http://code.enthought.com/traits)
-automatically adds to all objects that inherit from its base HasTraits class.
-
-
-Activation
-==========
-
-To use this, put in your ~/.ipython/ipy_user_conf.py file:
-
-    from ipy_traits_completer import activate
-    activate([complete_threshold])
-
-The optional complete_threshold argument is the minimal length of text you need
-to type for tab-completion to list names that are automatically generated by
-traits.  The default value is 3.  Note that at runtime, you can change this
-value simply by doing:
-
-    import ipy_traits_completer
-    ipy_traits_completer.COMPLETE_THRESHOLD = 4
-
-
-Usage
-=====
-
-The system works as follows.  If t is an empty object that HasTraits, then
-(assuming the threshold is at the default value of 3):
-
-In [7]: t.ed<TAB>
-
-doesn't show anything at all, but:
-
-In [7]: t.edi<TAB>
-t.edit_traits      t.editable_traits
-
-shows these two names that come from traits.  This allows you to complete on
-the traits-specific names by typing at least 3 letters from them (or whatever
-you set your threshold to), but to otherwise not see them in normal completion.
-
-
-Notes
-=====
-
-  - This requires Python 2.4 to work (I use sets).  I don't think anyone is
-    using traits with 2.3 anyway, so that's OK.
-
-  - Imports from enthought.traits are deferred until an object with a class that
-    looks like it subclasses from HasTraits comes along. This test is done by
-    looking at the name of the class and its superclasses.
-"""
-
-#############################################################################
-# IPython imports
-from IPython.core.error import TryNext
-from IPython.core.ipapi import get as ipget
-from IPython.utils.dir2 import dir2
-try:
-    set
-except:
-    from sets import Set as set
-
-#############################################################################
-# Module constants
-
-# The completion threshold
-# This is currently implemented as a module global, since this sytem isn't
-# likely to be modified at runtime by multiple instances.  If needed in the
-# future, we can always make it local to the completer as a function attribute.
-COMPLETE_THRESHOLD = 3
-
-# Set of names that Traits automatically adds to ANY traits-inheriting object.
-# These are the names we'll filter out.
-TRAIT_NAMES = None
-def get_trait_names():
-    global TRAIT_NAMES
-    from enthought.traits.api import HasTraits
-    if TRAIT_NAMES is None:
-        TRAIT_NAMES = set( dir2(HasTraits()) ) - set( dir2(object()) )
-    else:
-        return TRAIT_NAMES
-
-#############################################################################
-# Code begins
-
-def looks_like_isinstance(obj, classname):
-    """ Return True if the object has a class or superclass with the given class
-    name.
-
-    Ignores old-style classes.
-    """
-    from types import InstanceType
-
-    t = type(obj)
-    if t is InstanceType:
-        # Old-style classes.
-        return False
-    elif t.__name__ == classname:
-        return True
-    for klass in t.__mro__:
-        if klass.__name__ == classname:
-            return True
-    return False
-
-def trait_completer(self,event):
-    """A custom IPython tab-completer that is traits-aware.
-
-    It tries to hide the internal traits attributes, and reveal them only when
-    it can reasonably guess that the user really is after one of them.
-    """
-    
-    #print '\nevent is:',event  # dbg
-    symbol_parts = event.symbol.split('.')
-    base = '.'.join(symbol_parts[:-1])
-    #print 'base:',base  # dbg
-
-    oinfo = self._ofind(base)
-    if not oinfo['found']:
-        raise TryNext
-
-    obj = oinfo['obj']
-    # OK, we got the object.  See if it's traits, else punt
-    if not looks_like_isinstance(obj, 'HasTraits'):
-        raise TryNext
-
-    # Defer import until here so as not to require Traits until we get something
-    # that looks like it might be a HasTraits instance.
-    from enthought.traits.api import HasTraits
-    if not isinstance(obj, HasTraits):
-        raise TryNext
-
-    # it's a traits object, don't show the tr* attributes unless the completion
-    # begins with 'tr'
-    attrs = dir2(obj)
-    # Now, filter out the attributes that start with the user's request
-    attr_start = symbol_parts[-1]
-    if attr_start:
-        attrs = [a for a in attrs if a.startswith(attr_start)]
-    
-    # Let's also respect the user's readline_omit__names setting:
-    omit__names = ipget().options.readline_omit__names
-    if omit__names == 1:
-        attrs = [a for a in attrs if not a.startswith('__')]
-    elif omit__names == 2:
-        attrs = [a for a in attrs if not a.startswith('_')]
-
-    #print '\nastart:<%r>' % attr_start  # dbg
-
-    if len(attr_start)<COMPLETE_THRESHOLD:
-        attrs = list(set(attrs) - get_trait_names())
-        
-    # The base of the completion, so we can form the final results list
-    bdot = base+'.'
-
-    tcomp = [bdot+a for a in attrs]
-    #print 'tcomp:',tcomp
-    return tcomp
-
-def activate(complete_threshold = COMPLETE_THRESHOLD):
-    """Activate the Traits completer.
-
-    :Keywords:
-      complete_threshold : int
-        The minimum number of letters that a user must type in order to
-      activate completion of traits-private names."""
-    
-    if not (isinstance(complete_threshold,int) and
-            complete_threshold>0):
-        e='complete_threshold must be a positive integer, not %r'  % \
-           complete_threshold
-        raise ValueError(e)
-
-    # Set the module global
-    global COMPLETE_THRESHOLD
-    COMPLETE_THRESHOLD = complete_threshold
-
-    # Activate the traits aware completer
-    ip = ipget()
-    ip.set_hook('complete_command', trait_completer, re_key = '.*')
-
-
-#############################################################################
-if __name__ == '__main__':
-    # Testing/debugging
-    from enthought.traits.api import HasTraits
-
-    # A sorted list of the names we'll filter out
-    TNL = list(get_trait_names())
-    TNL.sort()
-
-    # Make a few objects for testing
-    class TClean(HasTraits): pass
-    class Bunch(object): pass
-    # A clean traits object
-    t = TClean()
-    # A nested object containing t
-    f = Bunch()
-    f.t = t
-    # And a naked new-style object
-    o = object()
-
-    ip = ipget().IP
-    
-    # A few simplistic tests
-
-    # Reset the threshold to the default, in case the test is running inside an
-    # instance of ipython that changed it
-    import ipy_traits_completer
-    ipy_traits_completer.COMPLETE_THRESHOLD = 3
-
-    assert ip.complete('t.ed') ==[]
-
-    # For some bizarre reason, these fail on the first time I run them, but not
-    # afterwards.  Traits does some really weird stuff at object instantiation
-    # time...
-    ta = ip.complete('t.edi')
-    assert ta == ['t.edit_traits', 't.editable_traits']
-    print 'Tests OK'
diff --git a/IPython/deathrow/ipy_vimserver.py b/IPython/deathrow/ipy_vimserver.py
deleted file mode 100644
index 1902c6aa280..00000000000
--- a/IPython/deathrow/ipy_vimserver.py
+++ /dev/null
@@ -1,245 +0,0 @@
-""" Integration with gvim, by Erich Heine
-
-Provides a %vim magic command, and reuses the same vim session. Uses 
-unix domain sockets for communication between vim and IPython. ipy.vim is 
-available in doc/examples of the IPython distribution.
-
-Slightly touched up email announcement (and description how to use it) by 
-Erich Heine is here:
-
-Ive recently been playing with ipython, and like it quite a bit. I did
-however discover a bit of frustration, namely with editor interaction.
-I am a gvim user, and using the command edit on a new file causes
-ipython to try and run that file as soon as the text editor opens
-up. The -x command of course fixes this, but its still a bit annoying,
-switching windows to do a run file, then back to the text
-editor. Being a heavy tab user in gvim, another annoyance is not being
-able to specify weather a new tab is how I choose to open the file.
-
-Not being one to shirk my open source duties (and seeing this as a
-good excuse to poke around ipython internals), Ive created a script
-for having gvim and ipython work very nicely together. Ive attached
-both to this email (hoping of course that the mailing list allows such
-things).
-
-There are 2 files: 
-
-ipy_vimserver.py -- this file contains the ipython stuff
-ipy.vim -- this file contains the gvim stuff
-
-In combination they allow for a few functionalities:
-
-#1. the vim magic command. This is a fancy wrapper around the edit
-magic, that allows for a new option, -t, which opens the text in a new
-gvim tab.  Otherwise it works the same as edit -x. (it internally
-calls edit -x). This magic command also juggles vim server management,
-so when it is called when there is not a gvim running, it creates a
-new gvim instance, named after the ipython session name.  Once such a
-gvim instance is running, it will be used for subsequent uses of the
-vim command.
-
-#2. ipython - gvim interaction. Once a file has been opened with the
-vim magic (and a session set up, see below), pressing the F5 key in
-vim will cause the calling ipython instance to execute run
-filename.py. (if you typo like I do, this is very useful)
-
-#3. ipython server - this is a thread wich listens on a unix domain
-socket, and runs commands sent to that socket.
-
-Note, this only works on POSIX systems, that allow for AF_UNIX type
-sockets. It has only been tested on linux (a fairly recent debian
-testing distro).
-
-To install it put, the ipserver.py in your favorite locaion for
-sourcing ipython scripts. I put the ipy.vim in
-~/.vim/after/ftplugin/python/.
-
-To use (this can be scripted im sure, but i usually have 2 or 3
-ipythons and corresponding gvims open):
-
-import ipy_vimserver
-ipy_vimserver.setup('sessionname')
-
-(Editors note - you can probably add these to your ipy_user_conf.py)
-
-Then use ipython as you normally would, until you need to edit
-something. Instead of edit, use the vim magic.  Thats it!
-
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-
-import socket, select
-import os, threading, subprocess
-import re
-
-try:
-    ERRCONDS = select.POLLHUP|select.POLLERR
-except AttributeError:
-    raise ImportError("Vim server not supported on this platform - select "
-                      "missing necessary POLLHUP/POLLERR functionality")
-
-SERVER = None
-ip = ipapi.get()
-
-# this listens to a unix domain socket in a separate thread, so that comms
-# between a vim instance and ipython can happen in a fun and productive way
-class IpyServer(threading.Thread):
-    def __init__(self, sname):
-        super(IpyServer, self).__init__()
-        self.keep_running = True
-        self.__sname = sname
-        self.socket = socket.socket(socket.AF_UNIX)
-        self.poller = select.poll()
-        self.current_conns = dict()
-        self.setDaemon(True)
-
-    def listen(self):
-        self.socket.bind(self.__sname)
-        self.socket.listen(1)
-
-    def __handle_error(self, socket):
-        if socket == self.socket.fileno():
-            self.keep_running = False
-            for a in self.current_conns.values():
-                a.close()
-            return False
-        else:
-            y = self.current_conns[socket]
-            del self.current_conns[socket]
-        y.close()
-        self.poller.unregister(socket)
-
-    def serve_me(self):
-        self.listen()
-        self.poller.register(self.socket,select.POLLIN|ERRCONDS)
-
-        while self.keep_running:
-            try:
-                avail = self.poller.poll(1)
-            except:
-                continue
-
-            if not avail: continue
-
-            for sock, conds in avail:
-                if conds & (ERRCONDS):
-                    if self.__handle_error(sock): continue
-                    else: break
-
-                if sock == self.socket.fileno():
-                    y = self.socket.accept()[0]
-                    self.poller.register(y, select.POLLIN|ERRCONDS)
-                    self.current_conns[y.fileno()] = y
-                else: y = self.current_conns.get(sock)
-
-                self.handle_request(y)
-
-        os.remove(self.__sname)
-
-    run = serve_me
-
-    def stop(self):
-        self.keep_running = False
-
-    def handle_request(self,sock):
-        sock.settimeout(1)
-        while self.keep_running:
-            try:
-                x = sock.recv(4096)
-            except socket.timeout:
-                pass
-            else:
-                break
-        self.do_it(x)
-
-    def do_it(self, data):
-        data = data.split('\n')
-        cmds = list()
-        for line in data:
-            cmds.append(line)
-        ip.runlines(cmds)
-
-
-# try to help ensure that the unix domain socket is cleaned up proper
-def shutdown_server(self):
-    if SERVER:
-        SERVER.stop()
-        SERVER.join(3)
-    raise TryNext
-
-ip.set_hook('shutdown_hook', shutdown_server, 10)
-
-# this fun function exists to make setup easier for all, and makes the
-# vimhook function ready for instance specific communication
-def setup(sessionname='',socketdir=os.path.expanduser('~/.ipython/')):
-    global SERVER
-
-    if sessionname:
-        session = sessionname
-    elif os.environ.get('IPY_SESSION'):
-        session = os.environ.get('IPY_SESSION')
-    else:
-        session = 'IPYS'
-    vimhook.vimserver=session
-    vimhook.ipyserver = os.path.join(socketdir, session)
-    if not SERVER:
-        SERVER = IpyServer(vimhook.ipyserver)
-        SERVER.start()
-
-
-
-# calls gvim, with all ops happening on the correct gvim instance for this
-# ipython instance. it then calls edit -x (since gvim will return right away)
-# things of note: it sets up a special environment, so that the ipy.vim script
-# can connect back to the ipython instance and do fun things, like run the file
-def vimhook(self, fname, line):
-    env = os.environ.copy()
-    vserver = vimhook.vimserver.upper()
-    check = subprocess.Popen('gvim --serverlist', stdout = subprocess.PIPE,
-        shell=True)
-    check.wait()
-    cval = [l for l in check.stdout.readlines() if vserver in l]
-
-    if cval:
-        vimargs = '--remote%s' % (vimhook.extras,)
-    else:
-        vimargs = ''
-    vimhook.extras = ''
-
-    env['IPY_SESSION'] = vimhook.vimserver
-    env['IPY_SERVER'] = vimhook.ipyserver
-
-    if line is None: line = ''
-    else: line = '+' + line
-    vim_cmd = 'gvim --servername %s %s %s %s' % (vimhook.vimserver, vimargs,
-        line, fname)
-    subprocess.call(vim_cmd, env=env, shell=True)
-
-
-#default values to keep it sane...
-vimhook.vimserver = ''
-vimhook.ipyserver = ''
-
-ip.set_hook('editor',vimhook)
-
-# this is set up so more vim specific commands can be added, instead of just
-# the current -t. all thats required is a compiled regex, a call to do_arg(pat)
-# and the logic to deal with the new feature
-newtab = re.compile(r'-t(?:\s|$)')
-def vim(self, argstr):
-    def do_arg(pat, rarg):
-        x = len(pat.findall(argstr))
-        if x:
-            a = pat.sub('',argstr)
-            return rarg, a
-        else: return '', argstr
-
-    t, argstr = do_arg(newtab, '-tab')
-    vimhook.extras = t
-    argstr = 'edit -x ' + argstr
-    ip.magic(argstr)
-
-ip.define_magic('vim', vim)
-
diff --git a/IPython/deathrow/ipython-wx b/IPython/deathrow/ipython-wx
deleted file mode 100755
index 5741effb8d5..00000000000
--- a/IPython/deathrow/ipython-wx
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""wxIPython -- An enhanced Interactive Python GUI fonrtend
-This script starts the Wx graphical frontend.
-This is experimental so far.
-Currently it support only ipython0 instance. Will be upgraded to ipython1 one.
-"""
-
-from IPython.gui.wx import wxIPython
-
-wxIPython.main()
diff --git a/IPython/deathrow/ipythonx b/IPython/deathrow/ipythonx
deleted file mode 100755
index ef189c45790..00000000000
--- a/IPython/deathrow/ipythonx
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""IPythonX -- An enhanced Interactive Python
-
-This script starts the Wx graphical frontend. This is experimental so
-far.
-"""
-
-from IPython.frontend.wx import ipythonx
-
-ipythonx.main()
diff --git a/IPython/deathrow/numeric_formats.py b/IPython/deathrow/numeric_formats.py
deleted file mode 100644
index b6b2d292041..00000000000
--- a/IPython/deathrow/numeric_formats.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Extension for printing Numeric Arrays in flexible ways.
-"""
-
-from Numeric import ArrayType
-
-def num_display(self,arg):
-    """Display method for printing which treats Numeric arrays specially.
-    """
-
-    # Non-numpy variables are printed using the system default
-    if type(arg) != ArrayType:
-        self._display(arg)
-        return
-    # Otherwise, we do work.
-    format = __IPYTHON__.runtime_rc.numarray_print_format
-    print 'NumPy array, format:',format
-    # Here is where all the printing logic needs to be implemented
-    print arg # nothing yet :)
-
-
-def magic_format(self,parameter_s=''):
-    """Specifies format of numerical output.
-
-    This command is similar to Ocave's format command.
-    """
-
-    valid_formats = ['long','short']
-    
-    if parameter_s in valid_formats:
-        self.runtime_rc.numarray_print_format = parameter_s
-        print 'Numeric output format is now:',parameter_s
-    else:
-        print 'Invalid format:',parameter_s
-        print 'Valid formats:',valid_formats
-
-# setup default format
-__IPYTHON__.runtime_rc.numarray_print_format = 'long'
-
-# Bind our new functions to the interpreter
-__IPYTHON__.__class__.magic_format = magic_format
-__IPYTHON__.hooks.display = num_display
diff --git a/IPython/deathrow/numutils.py b/IPython/deathrow/numutils.py
deleted file mode 100644
index 977d7eef843..00000000000
--- a/IPython/deathrow/numutils.py
+++ /dev/null
@@ -1,302 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-A set of convenient utilities for numerical work.
-
-Most of this module requires Numerical Python or is meant to be used with it.
-See http://www.pfdubois.com/numpy for details.
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2001-2005 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-__all__ = ['sum_flat','mean_flat','rms_flat','base_repr','binary_repr',
-           'amin','amax','amap','zeros_like','empty_like',
-           'frange','diagonal_matrix','identity',
-           'fromfunction_kw','log2','ispower2',
-           'norm','l1norm','l2norm','exp_safe',
-           'inf','infty','Infinity',
-           'Numeric']
-
-#****************************************************************************
-# required modules
-import __main__
-import math
-import operator
-import sys
-
-import Numeric
-from Numeric import *
-
-#*****************************************************************************
-# Globals
-
-# useful for testing infinities in results of array divisions (which don't
-# raise an exception)
-# Python, LaTeX and Mathematica names.
-inf = infty = Infinity = (array([1])/0.0)[0]
-
-#****************************************************************************
-# function definitions        
-exp_safe_MIN = math.log(2.2250738585072014e-308)
-exp_safe_MAX = 1.7976931348623157e+308
-
-def exp_safe(x):
-    """Compute exponentials which safely underflow to zero.
-
-    Slow but convenient to use. Note that NumArray will introduce proper
-    floating point exception handling with access to the underlying
-    hardware."""
-
-    if type(x) is ArrayType:
-        return exp(clip(x,exp_safe_MIN,exp_safe_MAX))
-    else:
-        return math.exp(x)
-
-def amap(fn,*args):
-    """amap(function, sequence[, sequence, ...]) -> array.
-
-    Works like map(), but it returns an array.  This is just a convenient
-    shorthand for Numeric.array(map(...))"""
-    return array(map(fn,*args))
-
-def amin(m,axis=0):
-    """amin(m,axis=0) returns the minimum of m along dimension axis.
-    """
-    return minimum.reduce(asarray(m),axis)
-
-def amax(m,axis=0):
-    """amax(m,axis=0) returns the maximum of m along dimension axis.
-    """
-    return maximum.reduce(asarray(m),axis)
-
-def zeros_like(a):
-    """Return an array of zeros of the shape and typecode of a.
-
-    If you don't explicitly need the array to be zeroed, you should instead
-    use empty_like(), which is faster as it only allocates memory."""
-
-    return zeros(a.shape,a.typecode())
-
-def empty_like(a):
-    """Return an empty (uninitialized) array of the shape and typecode of a.
-
-    Note that this does NOT initialize the returned array.  If you require
-    your array to be initialized, you should use zeros_like().
-
-    This requires Numeric.empty(), which appeared in Numeric 23.7."""
-
-    return empty(a.shape,a.typecode())
-
-def sum_flat(a):
-    """Return the sum of all the elements of a, flattened out.
-
-    It uses a.flat, and if a is not contiguous, a call to ravel(a) is made."""
-
-    if a.iscontiguous():
-        return Numeric.sum(a.flat)
-    else:
-        return Numeric.sum(ravel(a))
-
-def mean_flat(a):
-    """Return the mean of all the elements of a, flattened out."""
-
-    return sum_flat(a)/float(size(a))
-
-def rms_flat(a):
-    """Return the root mean square of all the elements of a, flattened out."""
-
-    return math.sqrt(sum_flat(absolute(a)**2)/float(size(a)))
-
-def l1norm(a):
-    """Return the l1 norm of a, flattened out.
-
-    Implemented as a separate function (not a call to norm() for speed).
-
-    Ref: http://mathworld.wolfram.com/L1-Norm.html"""
-
-    return sum_flat(absolute(a))
-
-def l2norm(a):
-    """Return the l2 norm of a, flattened out.
-
-    Implemented as a separate function (not a call to norm() for speed).
-
-    Ref: http://mathworld.wolfram.com/L2-Norm.html"""
-
-    return math.sqrt(sum_flat(absolute(a)**2))
-
-def norm(a,p=2):
-    """norm(a,p=2) -> l-p norm of a.flat
-
-    Return the l-p norm of a, considered as a flat array.  This is NOT a true
-    matrix norm, since arrays of arbitrary rank are always flattened.
-
-    p can be a number or one of the strings ('inf','Infinity') to get the
-    L-infinity norm.
-
-    Ref: http://mathworld.wolfram.com/VectorNorm.html
-         http://mathworld.wolfram.com/L-Infinity-Norm.html"""
-    
-    if p in ('inf','Infinity'):
-        return max(absolute(a).flat)
-    else:
-        return (sum_flat(absolute(a)**p))**(1.0/p)    
-    
-def frange(xini,xfin=None,delta=None,**kw):
-    """frange([start,] stop[, step, keywords]) -> array of floats
-
-    Return a Numeric array() containing a progression of floats. Similar to
-    arange(), but defaults to a closed interval.
-
-    frange(x0, x1) returns [x0, x0+1, x0+2, ..., x1]; start defaults to 0, and
-    the endpoint *is included*. This behavior is different from that of
-    range() and arange(). This is deliberate, since frange will probably be
-    more useful for generating lists of points for function evaluation, and
-    endpoints are often desired in this use. The usual behavior of range() can
-    be obtained by setting the keyword 'closed=0', in this case frange()
-    basically becomes arange().
-
-    When step is given, it specifies the increment (or decrement). All
-    arguments can be floating point numbers.
-
-    frange(x0,x1,d) returns [x0,x0+d,x0+2d,...,xfin] where xfin<=x1.
-
-    frange can also be called with the keyword 'npts'. This sets the number of
-    points the list should contain (and overrides the value 'step' might have
-    been given). arange() doesn't offer this option.
-
-    Examples:
-    >>> frange(3)
-    array([ 0.,  1.,  2.,  3.])
-    >>> frange(3,closed=0)
-    array([ 0.,  1.,  2.])
-    >>> frange(1,6,2)
-    array([1, 3, 5])
-    >>> frange(1,6.5,npts=5)
-    array([ 1.   ,  2.375,  3.75 ,  5.125,  6.5  ])
-    """
-
-    #defaults
-    kw.setdefault('closed',1)
-    endpoint = kw['closed'] != 0
-        
-    # funny logic to allow the *first* argument to be optional (like range())
-    # This was modified with a simpler version from a similar frange() found
-    # at http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66472
-    if xfin == None:
-        xfin = xini + 0.0
-        xini = 0.0
-        
-    if delta == None:
-        delta = 1.0
-
-    # compute # of points, spacing and return final list
-    try:
-        npts=kw['npts']
-        delta=(xfin-xini)/float(npts-endpoint)
-    except KeyError:
-        # round() gets npts right even with the vagaries of floating point.
-        npts=int(round((xfin-xini)/delta+endpoint))
-
-    return arange(npts)*delta+xini
-
-def diagonal_matrix(diag):
-    """Return square diagonal matrix whose non-zero elements are given by the
-    input array."""
-
-    return diag*identity(len(diag))
-
-def identity(n,rank=2,typecode='l'):
-    """identity(n,r) returns the identity matrix of shape (n,n,...,n) (rank r).
-
-    For ranks higher than 2, this object is simply a multi-index Kronecker
-    delta:
-                        /  1  if i0=i1=...=iR,
-    id[i0,i1,...,iR] = -|
-                        \  0  otherwise.
-
-    Optionally a typecode may be given (it defaults to 'l').
-
-    Since rank defaults to 2, this function behaves in the default case (when
-    only n is given) like the Numeric identity function."""
-    
-    iden = zeros((n,)*rank,typecode=typecode)
-    for i in range(n):
-        idx = (i,)*rank
-        iden[idx] = 1
-    return iden
-
-def base_repr (number, base = 2, padding = 0):
-    """Return the representation of a number in any given base."""
-    chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    if number < base: \
-       return (padding - 1) * chars [0] + chars [int (number)]
-    max_exponent = int (math.log (number)/math.log (base))
-    max_power = long (base) ** max_exponent
-    lead_digit = int (number/max_power)
-    return chars [lead_digit] + \
-           base_repr (number - max_power * lead_digit, base, \
-                      max (padding - 1, max_exponent))
-
-def binary_repr(number, max_length = 1025):
-    """Return the binary representation of the input number as a string.
-
-    This is more efficient than using base_repr with base 2.
-
-    Increase the value of max_length for very large numbers. Note that on
-    32-bit machines, 2**1023 is the largest integer power of 2 which can be
-    converted to a Python float."""
-    
-    assert number < 2L << max_length
-    shifts = map (operator.rshift, max_length * [number], \
-                  range (max_length - 1, -1, -1))
-    digits = map (operator.mod, shifts, max_length * [2])
-    if not digits.count (1): return 0
-    digits = digits [digits.index (1):]
-    return ''.join (map (repr, digits)).replace('L','')
-
-def log2(x,ln2 = math.log(2.0)):
-    """Return the log(x) in base 2.
-    
-    This is a _slow_ function but which is guaranteed to return the correct
-    integer value if the input is an ineger exact power of 2."""
-
-    try:
-        bin_n = binary_repr(x)[1:]
-    except (AssertionError,TypeError):
-        return math.log(x)/ln2
-    else:
-        if '1' in bin_n:
-            return math.log(x)/ln2
-        else:
-            return len(bin_n)
-
-def ispower2(n):
-    """Returns the log base 2 of n if n is a power of 2, zero otherwise.
-
-    Note the potential ambiguity if n==1: 2**0==1, interpret accordingly."""
-
-    bin_n = binary_repr(n)[1:]
-    if '1' in bin_n:
-        return 0
-    else:
-        return len(bin_n)
-
-def fromfunction_kw(function, dimensions, **kwargs):
-    """Drop-in replacement for fromfunction() from Numerical Python.
- 
-    Allows passing keyword arguments to the desired function.
-
-    Call it as (keywords are optional):
-    fromfunction_kw(MyFunction, dimensions, keywords)
-
-    The function MyFunction() is responsible for handling the dictionary of
-    keywords it will recieve."""
-
-    return function(tuple(indices(dimensions)),**kwargs)
-
-#**************************** end file <numutils.py> ************************
diff --git a/IPython/deathrow/oldfrontend/asyncfrontendbase.py b/IPython/deathrow/oldfrontend/asyncfrontendbase.py
deleted file mode 100644
index 1171a831211..00000000000
--- a/IPython/deathrow/oldfrontend/asyncfrontendbase.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""
-Base front end class for all async frontends.
-"""
-__docformat__ = "restructuredtext en"
-
-# Tell nose to skip this module
-__test__ = {}
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-# Third-party
-from twisted.python.failure import Failure
-from zope.interface import implements, classProvides
-
-# From IPython
-from IPython.external import guid
-
-from IPython.frontend.frontendbase import (FrontEndBase, IFrontEnd,
-                                           IFrontEndFactory)
-from IPython.kernel.core.history import FrontEndHistory
-from IPython.kernel.engineservice import IEngineCore
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class AsyncFrontEndBase(FrontEndBase):
-    """
-    Overrides FrontEndBase to wrap execute in a deferred result.
-    All callbacks are made as callbacks on the deferred result.
-    """
-    
-    implements(IFrontEnd)
-    classProvides(IFrontEndFactory)
-    
-    def __init__(self, engine=None, history=None):
-        assert(engine==None or IEngineCore.providedBy(engine))
-        self.engine = IEngineCore(engine)
-        if history is None:
-                self.history = FrontEndHistory(input_cache=[''])
-        else:
-            self.history = history
-        
-    def execute(self, block, blockID=None):
-        """Execute the block and return the deferred result.
-        
-        Parameters:
-            block : {str, AST}
-            blockID : any
-                Caller may provide an ID to identify this block. 
-                result['blockID'] := blockID
-        
-        Result:
-            Deferred result of self.interpreter.execute
-        """
-        
-        if(not self.is_complete(block)):
-            return Failure(Exception("Block is not compilable"))
-        
-        if(blockID == None):
-            blockID = guid.generate() 
-        
-        d = self.engine.execute(block)
-        d.addCallback(self._add_history, block=block)
-        d.addCallbacks(self._add_block_id_for_result,
-                errback=self._add_block_id_for_failure,
-                callbackArgs=(blockID,),
-                errbackArgs=(blockID,))
-        d.addBoth(self.update_cell_prompt, blockID=blockID)
-        d.addCallbacks(self.render_result, 
-            errback=self.render_error)
-        
-        return d
diff --git a/IPython/deathrow/oldfrontend/cocoa/__init__.py b/IPython/deathrow/oldfrontend/cocoa/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/deathrow/oldfrontend/cocoa/cocoa_frontend.py b/IPython/deathrow/oldfrontend/cocoa/cocoa_frontend.py
deleted file mode 100644
index 349e7948576..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/cocoa_frontend.py
+++ /dev/null
@@ -1,560 +0,0 @@
-# encoding: utf-8
-# -*- test-case-name: IPython.frontend.cocoa.tests.test_cocoa_frontend -*-
-
-"""PyObjC classes to provide a Cocoa frontend to the 
-IPython.kernel.engineservice.IEngineBase.
-
-To add an IPython interpreter to a cocoa app, instantiate an 
-IPythonCocoaController in a XIB and connect its textView outlet to an
-NSTextView instance in your UI. That's it.
-
-Author: Barry Wark
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#       Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-import objc
-from IPython.external import guid
-
-from Foundation import NSObject, NSMutableArray, NSMutableDictionary,\
-                        NSLog, NSNotificationCenter, NSMakeRange,\
-                        NSLocalizedString, NSIntersectionRange,\
-                        NSString, NSAutoreleasePool
-                        
-from AppKit import NSApplicationWillTerminateNotification, NSBeep,\
-                    NSTextView, NSRulerView, NSVerticalRuler
-
-from pprint import saferepr
-
-import IPython
-from IPython.kernel.engineservice import ThreadedEngineService
-from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
-
-from twisted.internet.threads import blockingCallFromThread
-from twisted.python.failure import Failure
-
-#-----------------------------------------------------------------------------
-# Classes to implement the Cocoa frontend
-#-----------------------------------------------------------------------------
-
-# TODO: 
-#   1. use MultiEngineClient and out-of-process engine rather than 
-#       ThreadedEngineService?
-#   2. integrate Xgrid launching of engines
-        
-class AutoreleasePoolWrappedThreadedEngineService(ThreadedEngineService):
-    """Wrap all blocks in an NSAutoreleasePool"""
-    
-    def wrapped_execute(self, msg, lines):
-        """wrapped_execute"""
-        try:
-            p = NSAutoreleasePool.alloc().init()
-            result = super(AutoreleasePoolWrappedThreadedEngineService,
-                            self).wrapped_execute(msg, lines)
-        finally:
-            p.drain()
-        
-        return result
-    
-
-
-class Cell(NSObject):
-    """
-    Representation of the prompts, input and output of a cell in the
-    frontend
-    """
-    
-    blockNumber = objc.ivar().unsigned_long()
-    blockID = objc.ivar()
-    inputBlock = objc.ivar()
-    output = objc.ivar()
-     
-
-   
-class CellBlock(object):
-    """
-    Storage for information about text ranges relating to a single cell
-    """
-
-        
-    def __init__(self, inputPromptRange, inputRange=None, outputPromptRange=None,
-                outputRange=None):
-        super(CellBlock, self).__init__()
-        self.inputPromptRange = inputPromptRange
-        self.inputRange = inputRange
-        self.outputPromptRange = outputPromptRange
-        self.outputRange = outputRange
-    
-    def update_ranges_for_insertion(self, text, textRange):
-        """Update ranges for text insertion at textRange"""
-        
-        for r in [self.inputPromptRange,self.inputRange,
-                    self.outputPromptRange, self.outputRange]:
-            if(r == None):
-                continue
-            intersection = NSIntersectionRange(r,textRange)
-            if(intersection.length == 0): #ranges don't intersect
-                if r.location >= textRange.location:
-                    r.location += len(text)
-            else: #ranges intersect
-                if(r.location > textRange.location):
-                    offset = len(text) - intersection.length
-                    r.length -= offset
-                    r.location += offset
-                elif(r.location == textRange.location):
-                    r.length += len(text) - intersection.length
-                else:
-                    r.length -= intersection.length
-    
-    
-    def update_ranges_for_deletion(self, textRange):
-        """Update ranges for text deletion at textRange"""
-        
-        for r in [self.inputPromptRange,self.inputRange,
-                    self.outputPromptRange, self.outputRange]:
-            if(r==None):
-                continue
-            intersection = NSIntersectionRange(r, textRange)
-            if(intersection.length == 0): #ranges don't intersect
-                if r.location >= textRange.location:
-                    r.location -= textRange.length
-            else: #ranges intersect
-                if(r.location > textRange.location):
-                    offset = intersection.length
-                    r.length -= offset
-                    r.location += offset
-                elif(r.location == textRange.location):
-                    r.length += intersection.length
-                else:
-                    r.length -= intersection.length
-    
-    def __repr__(self):
-        return 'CellBlock('+ str((self.inputPromptRange,
-                                self.inputRange,
-                                self.outputPromptRange,
-                                self.outputRange)) + ')'
-    
-
-
-        
-class IPythonCocoaController(NSObject, AsyncFrontEndBase):
-    userNS = objc.ivar() #mirror of engine.user_ns (key=>str(value))
-    waitingForEngine = objc.ivar().bool()
-    textView = objc.IBOutlet()
-    
-    def init(self):
-        self = super(IPythonCocoaController, self).init()
-        AsyncFrontEndBase.__init__(self,
-                    engine=AutoreleasePoolWrappedThreadedEngineService())
-        if(self != None):
-            self._common_init()
-        
-        return self
-    
-    def _common_init(self):
-        """_common_init"""
-        
-        self.userNS = NSMutableDictionary.dictionary()
-        self.waitingForEngine = False
-        
-        self.lines = {}
-        self.tabSpaces = 4
-        self.tabUsesSpaces = True
-        self.currentBlockID = self.next_block_ID()
-        self.blockRanges = {} # blockID=>CellBlock
-    
-    
-    def awakeFromNib(self):
-        """awakeFromNib"""
-        
-        self._common_init()
-        
-        # Start the IPython engine
-        self.engine.startService()
-        NSLog('IPython engine started')
-        
-        # Register for app termination
-        nc = NSNotificationCenter.defaultCenter()
-        nc.addObserver_selector_name_object_(
-                                    self,
-                                    'appWillTerminate:',
-                                    NSApplicationWillTerminateNotification,
-                                    None)
-        
-        self.textView.setDelegate_(self)
-        self.textView.enclosingScrollView().setHasVerticalRuler_(True)
-        r = NSRulerView.alloc().initWithScrollView_orientation_(
-                                        self.textView.enclosingScrollView(),
-                                        NSVerticalRuler)
-        self.verticalRulerView = r
-        self.verticalRulerView.setClientView_(self.textView)
-        self._start_cli_banner()
-        self.start_new_block()
-    
-    
-    def appWillTerminate_(self, notification):
-        """appWillTerminate"""
-        
-        self.engine.stopService()
-    
-    
-    def complete(self, token):
-        """Complete token in engine's user_ns
-        
-        Parameters
-        ----------
-        token : string
-        
-        Result
-        ------
-        Deferred result of 
-        IPython.kernel.engineservice.IEngineBase.complete
-        """
-        
-        return self.engine.complete(token)
-    
-    
-    def execute(self, block, blockID=None):
-        self.waitingForEngine = True
-        self.willChangeValueForKey_('commandHistory')
-        d = super(IPythonCocoaController, self).execute(block,
-                                                        blockID)
-        d.addBoth(self._engine_done)
-        d.addCallback(self._update_user_ns)
-        
-        return d
-    
-    
-    def push_(self, namespace):
-        """Push dictionary of key=>values to python namespace"""
-        
-        self.waitingForEngine = True
-        self.willChangeValueForKey_('commandHistory')
-        d = self.engine.push(namespace)
-        d.addBoth(self._engine_done)
-        d.addCallback(self._update_user_ns)
-    
-    
-    def pull_(self, keys):
-        """Pull keys from python namespace"""
-        
-        self.waitingForEngine = True
-        result = blockingCallFromThread(self.engine.pull, keys)
-        self.waitingForEngine = False
-    
-    @objc.signature('v@:@I')
-    def executeFileAtPath_encoding_(self, path, encoding):
-        """Execute file at path in an empty namespace. Update the engine
-        user_ns with the resulting locals."""
-        
-        lines,err = NSString.stringWithContentsOfFile_encoding_error_(
-            path,
-            encoding,
-            None)
-        self.engine.execute(lines)
-    
-    
-    def _engine_done(self, x):
-        self.waitingForEngine = False
-        self.didChangeValueForKey_('commandHistory')
-        return x
-    
-    def _update_user_ns(self, result):
-        """Update self.userNS from self.engine's namespace"""
-        d = self.engine.keys()
-        d.addCallback(self._get_engine_namespace_values_for_keys)
-        
-        return result
-    
-    
-    def _get_engine_namespace_values_for_keys(self, keys):
-        d = self.engine.pull(keys)
-        d.addCallback(self._store_engine_namespace_values, keys=keys)
-    
-    
-    def _store_engine_namespace_values(self, values, keys=[]):
-        assert(len(values) == len(keys))
-        self.willChangeValueForKey_('userNS')
-        for (k,v) in zip(keys,values):
-            self.userNS[k] = saferepr(v)
-        self.didChangeValueForKey_('userNS')
-    
-    
-    def update_cell_prompt(self, result, blockID=None):
-        print self.blockRanges
-        if(isinstance(result, Failure)):
-            prompt = self.input_prompt()
-            
-        else:
-            prompt = self.input_prompt(number=result['number'])
-        
-        r = self.blockRanges[blockID].inputPromptRange
-        self.insert_text(prompt,
-                textRange=r,
-                scrollToVisible=False
-                )
-        
-        return result
-    
-    
-    def render_result(self, result):
-        blockID = result['blockID']
-        inputRange = self.blockRanges[blockID].inputRange
-        del self.blockRanges[blockID]
-        
-        #print inputRange,self.current_block_range()
-        self.insert_text('\n' +
-                self.output_prompt(number=result['number']) +
-                result.get('display',{}).get('pprint','') +
-                '\n\n',
-                textRange=NSMakeRange(inputRange.location+inputRange.length,
-                                    0))
-        return result
-    
-        
-    def render_error(self, failure):
-        print failure
-        blockID = failure.blockID
-        inputRange = self.blockRanges[blockID].inputRange
-        self.insert_text('\n' +
-                        self.output_prompt() +
-                        '\n' +
-                        failure.getErrorMessage() +
-                        '\n\n',
-                        textRange=NSMakeRange(inputRange.location +
-                                                inputRange.length,
-                                                0))
-        self.start_new_block()
-        return failure
-    
-    
-    def _start_cli_banner(self):
-        """Print banner"""
-        
-        banner = """IPython1 %s -- An enhanced Interactive Python.""" % \
-                    IPython.__version__
-        
-        self.insert_text(banner + '\n\n')
-    
-    
-    def start_new_block(self):
-        """"""
-        
-        self.currentBlockID = self.next_block_ID()
-        self.blockRanges[self.currentBlockID] = self.new_cell_block()
-        self.insert_text(self.input_prompt(), 
-            textRange=self.current_block_range().inputPromptRange)
-    
-    
-    
-    def next_block_ID(self):
-        
-        return guid.generate() 
-    
-    def new_cell_block(self):
-        """A new CellBlock at the end of self.textView.textStorage()"""
-        
-        return CellBlock(NSMakeRange(self.textView.textStorage().length(), 
-                                    0), #len(self.input_prompt())),
-                        NSMakeRange(self.textView.textStorage().length(),# + len(self.input_prompt()),
-                                    0))
-    
-    
-    def current_block_range(self):
-        return self.blockRanges.get(self.currentBlockID, 
-                        self.new_cell_block())
-    
-    def current_block(self):
-        """The current block's text"""
-        
-        return self.text_for_range(self.current_block_range().inputRange)
-    
-    def text_for_range(self, textRange):
-        """text_for_range"""
-        
-        ts = self.textView.textStorage()
-        return ts.string().substringWithRange_(textRange)
-    
-    def current_line(self):
-        block = self.text_for_range(self.current_block_range().inputRange)
-        block = block.split('\n')
-        return block[-1]
-    
-    
-    def insert_text(self, string=None, textRange=None, scrollToVisible=True):
-        """Insert text into textView at textRange, updating blockRanges 
-        as necessary
-        """
-        if(textRange == None):
-            #range for end of text
-            textRange = NSMakeRange(self.textView.textStorage().length(), 0) 
-        
-        
-        self.textView.replaceCharactersInRange_withString_(
-            textRange, string)
-            
-        for r in self.blockRanges.itervalues():
-            r.update_ranges_for_insertion(string, textRange)
-        
-        self.textView.setSelectedRange_(textRange)
-        if(scrollToVisible):
-            self.textView.scrollRangeToVisible_(textRange)
-    
-    
-    
-    def replace_current_block_with_string(self, textView, string):
-        textView.replaceCharactersInRange_withString_(
-                                    self.current_block_range().inputRange,
-                                    string)
-        self.current_block_range().inputRange.length = len(string)
-        r = NSMakeRange(textView.textStorage().length(), 0)
-        textView.scrollRangeToVisible_(r)
-        textView.setSelectedRange_(r)
-    
-    
-    def current_indent_string(self):
-        """returns string for indent or None if no indent"""
-        
-        return self._indent_for_block(self.current_block())
-    
-    
-    def _indent_for_block(self, block):
-        lines = block.split('\n')
-        if(len(lines) > 1):
-            currentIndent = len(lines[-1]) - len(lines[-1].lstrip())
-            if(currentIndent == 0):
-                currentIndent = self.tabSpaces
-        
-            if(self.tabUsesSpaces):
-                result = ' ' * currentIndent
-            else:
-                result = '\t' * (currentIndent/self.tabSpaces)
-        else:
-            result = None
-        
-        return result
-    
-    
-    # NSTextView delegate methods...
-    def textView_doCommandBySelector_(self, textView, selector):
-        assert(textView == self.textView)
-        NSLog("textView_doCommandBySelector_: "+selector)
-        
-        
-        if(selector == 'insertNewline:'):
-            indent = self.current_indent_string()
-            if(indent):
-                line = indent + self.current_line()
-            else:
-                line = self.current_line()
-            
-            if(self.is_complete(self.current_block())):
-                self.execute(self.current_block(),
-                                blockID=self.currentBlockID)
-                self.start_new_block()
-                
-                return True
-            
-            return False
-        
-        elif(selector == 'moveUp:'):
-            prevBlock = self.get_history_previous(self.current_block())
-            if(prevBlock != None):
-                self.replace_current_block_with_string(textView, prevBlock)
-            else:
-                NSBeep()
-            return True
-        
-        elif(selector == 'moveDown:'):
-            nextBlock = self.get_history_next()
-            if(nextBlock != None):
-                self.replace_current_block_with_string(textView, nextBlock)
-            else:
-                NSBeep()
-            return True
-        
-        elif(selector == 'moveToBeginningOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(
-                            self.current_block_range().inputRange.location, 
-                            0))
-            return True
-        elif(selector == 'moveToEndOfParagraph:'):
-            textView.setSelectedRange_(NSMakeRange(
-                            self.current_block_range().inputRange.location + \
-                            self.current_block_range().inputRange.length, 0))
-            return True
-        elif(selector == 'deleteToEndOfParagraph:'):
-            if(textView.selectedRange().location <= \
-                self.current_block_range().location):
-                raise NotImplemented()
-            
-            return False # don't actually handle the delete
-        
-        elif(selector == 'insertTab:'):
-            if(len(self.current_line().strip()) == 0): #only white space
-                return False
-            else:
-                self.textView.complete_(self)
-                return True
-        
-        elif(selector == 'deleteBackward:'):
-            #if we're at the beginning of the current block, ignore
-            if(textView.selectedRange().location == \
-                self.current_block_range().inputRange.location):
-                return True
-            else:
-                for r in self.blockRanges.itervalues():
-                    deleteRange = textView.selectedRange
-                    if(deleteRange.length == 0):
-                        deleteRange.location -= 1
-                        deleteRange.length = 1
-                    r.update_ranges_for_deletion(deleteRange)
-                return False
-        return False
-    
-    
-    def textView_shouldChangeTextInRanges_replacementStrings_(self, 
-        textView, ranges, replacementStrings):
-        """
-        Delegate method for NSTextView.
-        
-        Refuse change text in ranges not at end, but make those changes at 
-        end.
-        """
-        
-        assert(len(ranges) == len(replacementStrings))
-        allow = True
-        for r,s in zip(ranges, replacementStrings):
-            r = r.rangeValue()
-            if(textView.textStorage().length() > 0 and
-                r.location < self.current_block_range().inputRange.location):
-                self.insert_text(s)
-                allow = False
-        
-        return allow
-    
-    def textView_completions_forPartialWordRange_indexOfSelectedItem_(self, 
-        textView, words, charRange, index):
-        try:
-            ts = textView.textStorage()
-            token = ts.string().substringWithRange_(charRange)
-            completions = blockingCallFromThread(self.complete, token)
-        except:
-            completions = objc.nil
-            NSBeep()
-        
-        return (completions,0)
-    
-
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/English.lproj/InfoPlist.strings b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/English.lproj/InfoPlist.strings
deleted file mode 100644
index d6f816ac813..00000000000
Binary files a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/English.lproj/InfoPlist.strings and /dev/null differ
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/English.lproj/MainMenu.xib b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/English.lproj/MainMenu.xib
deleted file mode 100644
index 176e41f2e38..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/English.lproj/MainMenu.xib
+++ /dev/null
@@ -1,3424 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<archive type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="7.01">
-	<data>
-		<int key="IBDocument.SystemTarget">1050</int>
-		<string key="IBDocument.SystemVersion">9D34</string>
-		<string key="IBDocument.InterfaceBuilderVersion">629</string>
-		<string key="IBDocument.AppKitVersion">949.33</string>
-		<string key="IBDocument.HIToolboxVersion">352.00</string>
-		<object class="NSMutableArray" key="IBDocument.EditedObjectIDs">
-			<bool key="EncodedWithXMLCoder">YES</bool>
-			<integer value="416"/>
-			<integer value="29"/>
-		</object>
-		<object class="NSArray" key="IBDocument.PluginDependencies">
-			<bool key="EncodedWithXMLCoder">YES</bool>
-			<string id="885801228">com.apple.InterfaceBuilderKit</string>
-			<string id="113577022">com.apple.InterfaceBuilder.CocoaPlugin</string>
-		</object>
-		<object class="NSMutableArray" key="IBDocument.RootObjects" id="1048">
-			<bool key="EncodedWithXMLCoder">YES</bool>
-			<object class="NSCustomObject" id="1021">
-				<string key="NSClassName" id="190635311">NSApplication</string>
-			</object>
-			<object class="NSCustomObject" id="1014">
-				<string key="NSClassName">FirstResponder</string>
-			</object>
-			<object class="NSCustomObject" id="1050">
-				<reference key="NSClassName" ref="190635311"/>
-			</object>
-			<object class="NSMenu" id="649796088">
-				<string key="NSTitle">AMainMenu</string>
-				<object class="NSMutableArray" key="NSMenuItems">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<object class="NSMenuItem" id="694149608">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="837240250">IPython1Sandbox</string>
-						<string key="NSKeyEquiv" id="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<object class="NSCustomResource" key="NSOnImage" id="271266416">
-							<string key="NSClassName" id="375865337">NSImage</string>
-							<string key="NSResourceName">NSMenuCheckmark</string>
-						</object>
-						<object class="NSCustomResource" key="NSMixedImage" id="508123839">
-							<reference key="NSClassName" ref="375865337"/>
-							<string key="NSResourceName">NSMenuMixedState</string>
-						</object>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="110575045">
-							<reference key="NSTitle" ref="837240250"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="238522557">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">About IPython1Sandbox</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="304266470">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="609285721">
-									<reference key="NSMenu" ref="110575045"/>
-									<string type="base64-UTF8" key="NSTitle">UHJlZmVyZW5jZXPigKY</string>
-									<string key="NSKeyEquiv">,</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="481834944">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1046388886">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle" id="642338826">Services</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="752062318">
-										<reference key="NSTitle" ref="642338826"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-										</object>
-										<string key="NSName">_NSServicesMenu</string>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="646227648">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="755159360">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Hide IPython1Sandbox</string>
-									<string key="NSKeyEquiv" id="940330891">h</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="342932134">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Hide Others</string>
-									<reference key="NSKeyEquiv" ref="940330891"/>
-									<int key="NSKeyEquivModMask">1572864</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="908899353">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Show All</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1056857174">
-									<reference key="NSMenu" ref="110575045"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="632727374">
-									<reference key="NSMenu" ref="110575045"/>
-									<string key="NSTitle">Quit IPython1Sandbox</string>
-									<string key="NSKeyEquiv">q</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-							<string key="NSName">_NSAppleMenu</string>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="379814623">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="881404960">File</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="720053764">
-							<reference key="NSTitle" ref="881404960"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="705341025">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">New</string>
-									<string key="NSKeyEquiv">n</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="722745758">
-									<reference key="NSMenu" ref="720053764"/>
-									<string type="base64-UTF8" key="NSTitle">T3BlbuKApg</string>
-									<string key="NSKeyEquiv">o</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1025936716">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle" id="975517829">Open Recent</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="1065607017">
-										<reference key="NSTitle" ref="975517829"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="759406840">
-												<reference key="NSMenu" ref="1065607017"/>
-												<string key="NSTitle">Clear Menu</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-										<string key="NSName">_NSRecentDocumentsMenu</string>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="425164168">
-									<reference key="NSMenu" ref="720053764"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="776162233">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Close</string>
-									<string key="NSKeyEquiv">w</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1023925487">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Save</string>
-									<string key="NSKeyEquiv">s</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="117038363">
-									<reference key="NSMenu" ref="720053764"/>
-									<string type="base64-UTF8" key="NSTitle">U2F2ZSBBc+KApg</string>
-									<string key="NSKeyEquiv">S</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="579971712">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Revert to Saved</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1010469920">
-									<reference key="NSMenu" ref="720053764"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="294629803">
-									<reference key="NSMenu" ref="720053764"/>
-									<string key="NSTitle">Page Setup...</string>
-									<string key="NSKeyEquiv">P</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<reference key="NSToolTip" ref="255189770"/>
-								</object>
-								<object class="NSMenuItem" id="49223823">
-									<reference key="NSMenu" ref="720053764"/>
-									<string type="base64-UTF8" key="NSTitle">UHJpbnTigKY</string>
-									<string key="NSKeyEquiv">p</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="952259628">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="1037326483">Edit</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="789758025">
-							<reference key="NSTitle" ref="1037326483"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="1058277027">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Undo</string>
-									<string key="NSKeyEquiv">z</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="790794224">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Redo</string>
-									<string key="NSKeyEquiv">Z</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1040322652">
-									<reference key="NSMenu" ref="789758025"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="296257095">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Cut</string>
-									<string key="NSKeyEquiv">x</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="860595796">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Copy</string>
-									<string key="NSKeyEquiv">c</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="29853731">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Paste</string>
-									<string key="NSKeyEquiv">v</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="437104165">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Delete</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="583158037">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle">Select All</string>
-									<string key="NSKeyEquiv">a</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="212016141">
-									<reference key="NSMenu" ref="789758025"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="892235320">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="688083180">Find</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="963351320">
-										<reference key="NSTitle" ref="688083180"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="447796847">
-												<reference key="NSMenu" ref="963351320"/>
-												<string type="base64-UTF8" key="NSTitle">RmluZOKApg</string>
-												<string key="NSKeyEquiv" id="469505129">f</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">1</int>
-											</object>
-											<object class="NSMenuItem" id="326711663">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Find Next</string>
-												<string key="NSKeyEquiv" id="762398675">g</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">2</int>
-											</object>
-											<object class="NSMenuItem" id="270902937">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Find Previous</string>
-												<string key="NSKeyEquiv" id="819654342">G</string>
-												<int key="NSKeyEquivModMask">1179648</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">3</int>
-											</object>
-											<object class="NSMenuItem" id="159080638">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Use Selection for Find</string>
-												<string key="NSKeyEquiv">e</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">7</int>
-											</object>
-											<object class="NSMenuItem" id="88285865">
-												<reference key="NSMenu" ref="963351320"/>
-												<string key="NSTitle">Jump to Selection</string>
-												<string key="NSKeyEquiv">j</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="972420730">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="739167250">Spelling and Grammar</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="769623530">
-										<reference key="NSTitle" ref="739167250"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="679648819">
-												<reference key="NSMenu" ref="769623530"/>
-												<string type="base64-UTF8" key="NSTitle">U2hvdyBTcGVsbGluZ+KApg</string>
-												<string key="NSKeyEquiv">:</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="96193923">
-												<reference key="NSMenu" ref="769623530"/>
-												<string key="NSTitle">Check Spelling</string>
-												<string key="NSKeyEquiv">;</string>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="948374510">
-												<reference key="NSMenu" ref="769623530"/>
-												<string key="NSTitle">Check Spelling While Typing</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="967646866">
-												<reference key="NSMenu" ref="769623530"/>
-												<string key="NSTitle">Check Grammar With Spelling</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="507821607">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="904739598">Substitutions</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="698887838">
-										<reference key="NSTitle" ref="904739598"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="605118523">
-												<reference key="NSMenu" ref="698887838"/>
-												<string key="NSTitle">Smart Copy/Paste</string>
-												<reference key="NSKeyEquiv" ref="469505129"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">1</int>
-											</object>
-											<object class="NSMenuItem" id="197661976">
-												<reference key="NSMenu" ref="698887838"/>
-												<string key="NSTitle">Smart Quotes</string>
-												<reference key="NSKeyEquiv" ref="762398675"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">2</int>
-											</object>
-											<object class="NSMenuItem" id="708854459">
-												<reference key="NSMenu" ref="698887838"/>
-												<string key="NSTitle">Smart Links</string>
-												<reference key="NSKeyEquiv" ref="819654342"/>
-												<int key="NSKeyEquivModMask">1179648</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-												<int key="NSTag">3</int>
-											</object>
-										</object>
-									</object>
-								</object>
-								<object class="NSMenuItem" id="676164635">
-									<reference key="NSMenu" ref="789758025"/>
-									<string key="NSTitle" id="812002426">Speech</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-									<string key="NSAction">submenuAction:</string>
-									<object class="NSMenu" key="NSSubmenu" id="785027613">
-										<reference key="NSTitle" ref="812002426"/>
-										<object class="NSMutableArray" key="NSMenuItems">
-											<bool key="EncodedWithXMLCoder">YES</bool>
-											<object class="NSMenuItem" id="731782645">
-												<reference key="NSMenu" ref="785027613"/>
-												<string key="NSTitle">Start Speaking</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-											<object class="NSMenuItem" id="680220178">
-												<reference key="NSMenu" ref="785027613"/>
-												<string key="NSTitle">Stop Speaking</string>
-												<reference key="NSKeyEquiv" ref="255189770"/>
-												<int key="NSKeyEquivModMask">1048576</int>
-												<int key="NSMnemonicLoc">2147483647</int>
-												<reference key="NSOnImage" ref="271266416"/>
-												<reference key="NSMixedImage" ref="508123839"/>
-											</object>
-										</object>
-									</object>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="626404410">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="241242548">Format</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="502084290">
-							<reference key="NSTitle" ref="241242548"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="519768076">
-									<reference key="NSMenu" ref="502084290"/>
-									<string key="NSTitle">Show Fonts</string>
-									<string key="NSKeyEquiv" id="806579634">t</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="1028416764">
-									<reference key="NSMenu" ref="502084290"/>
-									<string key="NSTitle">Show Colors</string>
-									<string key="NSKeyEquiv">C</string>
-									<int key="NSKeyEquivModMask">1179648</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="586577488">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="809723865">View</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="466310130">
-							<reference key="NSTitle" ref="809723865"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="102151532">
-									<reference key="NSMenu" ref="466310130"/>
-									<string key="NSTitle">Show Toolbar</string>
-									<reference key="NSKeyEquiv" ref="806579634"/>
-									<int key="NSKeyEquivModMask">1572864</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="237841660">
-									<reference key="NSMenu" ref="466310130"/>
-									<string type="base64-UTF8" key="NSTitle">Q3VzdG9taXplIFRvb2xiYXLigKY</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="713487014">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="64165424">Window</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="835318025">
-							<reference key="NSTitle" ref="64165424"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="1011231497">
-									<reference key="NSMenu" ref="835318025"/>
-									<string key="NSTitle">Minimize</string>
-									<string key="NSKeyEquiv">m</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="575023229">
-									<reference key="NSMenu" ref="835318025"/>
-									<string key="NSTitle">Zoom</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="299356726">
-									<reference key="NSMenu" ref="835318025"/>
-									<bool key="NSIsDisabled">YES</bool>
-									<bool key="NSIsSeparator">YES</bool>
-									<reference key="NSTitle" ref="255189770"/>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-								<object class="NSMenuItem" id="625202149">
-									<reference key="NSMenu" ref="835318025"/>
-									<string key="NSTitle">Bring All to Front</string>
-									<reference key="NSKeyEquiv" ref="255189770"/>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-							<string key="NSName">_NSWindowsMenu</string>
-						</object>
-					</object>
-					<object class="NSMenuItem" id="391199113">
-						<reference key="NSMenu" ref="649796088"/>
-						<string key="NSTitle" id="461919786">Help</string>
-						<reference key="NSKeyEquiv" ref="255189770"/>
-						<int key="NSKeyEquivModMask">1048576</int>
-						<int key="NSMnemonicLoc">2147483647</int>
-						<reference key="NSOnImage" ref="271266416"/>
-						<reference key="NSMixedImage" ref="508123839"/>
-						<string key="NSAction">submenuAction:</string>
-						<object class="NSMenu" key="NSSubmenu" id="374024848">
-							<reference key="NSTitle" ref="461919786"/>
-							<object class="NSMutableArray" key="NSMenuItems">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSMenuItem" id="238773614">
-									<reference key="NSMenu" ref="374024848"/>
-									<string key="NSTitle">IPython1Sandbox Help</string>
-									<string key="NSKeyEquiv">?</string>
-									<int key="NSKeyEquivModMask">1048576</int>
-									<int key="NSMnemonicLoc">2147483647</int>
-									<reference key="NSOnImage" ref="271266416"/>
-									<reference key="NSMixedImage" ref="508123839"/>
-								</object>
-							</object>
-						</object>
-					</object>
-				</object>
-				<string key="NSName">_NSMainMenu</string>
-			</object>
-			<object class="NSWindowTemplate" id="972006081">
-				<int key="NSWindowStyleMask">15</int>
-				<int key="NSWindowBacking">2</int>
-				<string key="NSWindowRect">{{335, 413}, {725, 337}}</string>
-				<int key="NSWTFlags">1946157056</int>
-				<string key="NSWindowTitle">IPython1 (Cocoa)</string>
-				<string key="NSWindowClass">NSWindow</string>
-				<nil key="NSViewClass"/>
-				<object class="NSView" key="NSWindowView" id="439893737">
-					<reference key="NSNextResponder"/>
-					<int key="NSvFlags">256</int>
-					<object class="NSMutableArray" key="NSSubviews">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSSplitView" id="741760375">
-							<reference key="NSNextResponder" ref="439893737"/>
-							<int key="NSvFlags">274</int>
-							<object class="NSMutableArray" key="NSSubviews">
-								<bool key="EncodedWithXMLCoder">YES</bool>
-								<object class="NSBox" id="554641139">
-									<reference key="NSNextResponder" ref="741760375"/>
-									<int key="NSvFlags">22</int>
-									<object class="NSMutableArray" key="NSSubviews">
-										<bool key="EncodedWithXMLCoder">YES</bool>
-										<object class="NSView" id="597872307">
-											<reference key="NSNextResponder" ref="554641139"/>
-											<int key="NSvFlags">256</int>
-											<object class="NSMutableArray" key="NSSubviews">
-												<bool key="EncodedWithXMLCoder">YES</bool>
-												<object class="NSScrollView" id="188193463">
-													<reference key="NSNextResponder" ref="597872307"/>
-													<int key="NSvFlags">274</int>
-													<object class="NSMutableArray" key="NSSubviews">
-														<bool key="EncodedWithXMLCoder">YES</bool>
-														<object class="NSClipView" id="638544389">
-															<reference key="NSNextResponder" ref="188193463"/>
-															<int key="NSvFlags">2304</int>
-															<object class="NSMutableArray" key="NSSubviews">
-																<bool key="EncodedWithXMLCoder">YES</bool>
-																<object class="NSTextView" id="163417131">
-																	<reference key="NSNextResponder" ref="638544389"/>
-																	<int key="NSvFlags">2322</int>
-																	<object class="NSMutableSet" key="NSDragTypes">
-																		<bool key="EncodedWithXMLCoder">YES</bool>
-																		<object class="NSMutableArray" key="set.sortedObjects">
-																			<bool key="EncodedWithXMLCoder">YES</bool>
-																			<string>Apple HTML pasteboard type</string>
-																			<string>Apple PDF pasteboard type</string>
-																			<string>Apple PICT pasteboard type</string>
-																			<string>Apple PNG pasteboard type</string>
-																			<string>Apple URL pasteboard type</string>
-																			<string>CorePasteboardFlavorType 0x6D6F6F76</string>
-																			<string>CorePasteboardFlavorType 0x75726C20</string>
-																			<string>NSColor pasteboard type</string>
-																			<string>NSFilenamesPboardType</string>
-																			<string>NSStringPboardType</string>
-																			<string>NeXT Encapsulated PostScript v1.2 pasteboard type</string>
-																			<string>NeXT RTFD pasteboard type</string>
-																			<string>NeXT Rich Text Format v1.0 pasteboard type</string>
-																			<string>NeXT TIFF v4.0 pasteboard type</string>
-																			<string>NeXT font pasteboard type</string>
-																			<string>NeXT ruler pasteboard type</string>
-																			<string>WebURLsWithTitlesPboardType</string>
-																		</object>
-																	</object>
-																	<string key="NSFrame">{{0, 38}, {433, 14}}</string>
-																	<reference key="NSSuperview" ref="638544389"/>
-																	<reference key="NSWindow"/>
-																	<object class="NSTextContainer" key="NSTextContainer" id="662117317">
-																		<object class="NSLayoutManager" key="NSLayoutManager">
-																			<object class="NSTextStorage" key="NSTextStorage">
-																				<object class="NSMutableString" key="NSString">
-																					<characters key="NS.bytes"/>
-																				</object>
-																				<nil key="NSDelegate"/>
-																			</object>
-																			<object class="NSMutableArray" key="NSTextContainers">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<reference ref="662117317"/>
-																			</object>
-																			<int key="NSLMFlags">6</int>
-																			<nil key="NSDelegate"/>
-																		</object>
-																		<reference key="NSTextView" ref="163417131"/>
-																		<double key="NSWidth">4.330000e+02</double>
-																		<int key="NSTCFlags">1</int>
-																	</object>
-																	<object class="NSTextViewSharedData" key="NSSharedData">
-																		<int key="NSFlags">346991</int>
-																		<object class="NSColor" key="NSBackgroundColor">
-																			<int key="NSColorSpace">2</int>
-																			<bytes key="NSRGB">MSAwLjk1Mjk0MTI0IDAuODUwOTgwNDYAA</bytes>
-																		</object>
-																		<object class="NSColor" key="NSInsertionColor" id="555789289">
-																			<int key="NSColorSpace">3</int>
-																			<bytes key="NSWhite">MAA</bytes>
-																		</object>
-																		<object class="NSDictionary" key="NSSelectedAttributes">
-																			<bool key="EncodedWithXMLCoder">YES</bool>
-																			<object class="NSMutableArray" key="dict.sortedKeys">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<string>NSBackgroundColor</string>
-																				<string id="19777717">NSColor</string>
-																			</object>
-																			<object class="NSMutableArray" key="dict.values">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<object class="NSColor">
-																					<int key="NSColorSpace">6</int>
-																					<string key="NSCatalogName" id="484387293">System</string>
-																					<string key="NSColorName">selectedTextBackgroundColor</string>
-																					<object class="NSColor" key="NSColor" id="377165725">
-																						<int key="NSColorSpace">3</int>
-																						<bytes key="NSWhite">MC42NjY2NjY2OQA</bytes>
-																					</object>
-																				</object>
-																				<object class="NSColor">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">selectedTextColor</string>
-																					<reference key="NSColor" ref="555789289"/>
-																				</object>
-																			</object>
-																		</object>
-																		<nil key="NSMarkedAttributes"/>
-																		<object class="NSDictionary" key="NSLinkAttributes">
-																			<bool key="EncodedWithXMLCoder">YES</bool>
-																			<object class="NSMutableArray" key="dict.sortedKeys">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<reference ref="19777717"/>
-																				<string>NSUnderline</string>
-																			</object>
-																			<object class="NSMutableArray" key="dict.values">
-																				<bool key="EncodedWithXMLCoder">YES</bool>
-																				<object class="NSColor">
-																					<int key="NSColorSpace">1</int>
-																					<bytes key="NSRGB">MCAwIDEAA</bytes>
-																				</object>
-																				<integer value="1" id="9"/>
-																			</object>
-																		</object>
-																		<nil key="NSDefaultParagraphStyle"/>
-																	</object>
-																	<int key="NSTVFlags">6</int>
-																	<string key="NSMaxSize">{480, 1e+07}</string>
-																	<string key="NSMinize">{84, 0}</string>
-																	<nil key="NSDelegate"/>
-																</object>
-															</object>
-															<string key="NSFrame">{{1, 1}, {433, 231}}</string>
-															<string key="NSBounds">{{0, 38}, {433, 231}}</string>
-															<reference key="NSSuperview" ref="188193463"/>
-															<reference key="NSWindow"/>
-															<reference key="NSNextKeyView" ref="163417131"/>
-															<reference key="NSDocView" ref="163417131"/>
-															<object class="NSColor" key="NSBGColor" id="521347521">
-																<int key="NSColorSpace">3</int>
-																<bytes key="NSWhite">MQA</bytes>
-															</object>
-															<object class="NSCursor" key="NSCursor">
-																<string key="NSHotSpot">{4, -5}</string>
-																<int key="NSCursorType">1</int>
-															</object>
-															<int key="NScvFlags">4</int>
-														</object>
-														<object class="NSScroller" id="418410897">
-															<reference key="NSNextResponder" ref="188193463"/>
-															<int key="NSvFlags">-2147483392</int>
-															<string key="NSFrame">{{427, 1}, {15, 263}}</string>
-															<reference key="NSSuperview" ref="188193463"/>
-															<reference key="NSWindow"/>
-															<reference key="NSTarget" ref="188193463"/>
-															<string key="NSAction" id="688920982">_doScroller:</string>
-															<double key="NSPercent">3.389175e-01</double>
-														</object>
-														<object class="NSScroller" id="936733673">
-															<reference key="NSNextResponder" ref="188193463"/>
-															<int key="NSvFlags">256</int>
-															<string key="NSFrame">{{-100, -100}, {87, 18}}</string>
-															<reference key="NSSuperview" ref="188193463"/>
-															<reference key="NSWindow"/>
-															<int key="NSsFlags">1</int>
-															<reference key="NSTarget" ref="188193463"/>
-															<reference key="NSAction" ref="688920982"/>
-															<double key="NSCurValue">1.000000e+00</double>
-															<double key="NSPercent">9.456522e-01</double>
-														</object>
-													</object>
-													<string key="NSFrame">{{18, 14}, {435, 233}}</string>
-													<reference key="NSSuperview" ref="597872307"/>
-													<reference key="NSWindow"/>
-													<reference key="NSNextKeyView" ref="638544389"/>
-													<int key="NSsFlags">530</int>
-													<reference key="NSVScroller" ref="418410897"/>
-													<reference key="NSHScroller" ref="936733673"/>
-													<reference key="NSContentView" ref="638544389"/>
-												</object>
-											</object>
-											<string key="NSFrame">{{1, 1}, {471, 257}}</string>
-											<reference key="NSSuperview" ref="554641139"/>
-											<reference key="NSWindow"/>
-										</object>
-									</object>
-									<string key="NSFrameSize">{473, 273}</string>
-									<reference key="NSSuperview" ref="741760375"/>
-									<reference key="NSWindow"/>
-									<string key="NSOffsets" id="1055927954">{0, 0}</string>
-									<object class="NSTextFieldCell" key="NSTitleCell">
-										<int key="NSCellFlags">67239424</int>
-										<int key="NSCellFlags2">0</int>
-										<string key="NSContents">Console</string>
-										<object class="NSFont" key="NSSupport" id="26">
-											<string key="NSName" id="378950370">LucidaGrande</string>
-											<double key="NSSize">1.100000e+01</double>
-											<int key="NSfFlags">3100</int>
-										</object>
-										<object class="NSColor" key="NSBackgroundColor" id="131515055">
-											<int key="NSColorSpace">6</int>
-											<reference key="NSCatalogName" ref="484387293"/>
-											<string key="NSColorName">textBackgroundColor</string>
-											<reference key="NSColor" ref="521347521"/>
-										</object>
-										<object class="NSColor" key="NSTextColor">
-											<int key="NSColorSpace">3</int>
-											<bytes key="NSWhite">MCAwLjgwMDAwMDAxAA</bytes>
-										</object>
-									</object>
-									<reference key="NSContentView" ref="597872307"/>
-									<int key="NSBorderType">1</int>
-									<int key="NSBoxType">0</int>
-									<int key="NSTitlePosition">2</int>
-									<bool key="NSTransparent">NO</bool>
-								</object>
-								<object class="NSBox" id="764100755">
-									<reference key="NSNextResponder" ref="741760375"/>
-									<int key="NSvFlags">51</int>
-									<object class="NSMutableArray" key="NSSubviews">
-										<bool key="EncodedWithXMLCoder">YES</bool>
-										<object class="NSView" id="581281551">
-											<reference key="NSNextResponder" ref="764100755"/>
-											<int key="NSvFlags">256</int>
-											<object class="NSMutableArray" key="NSSubviews">
-												<bool key="EncodedWithXMLCoder">YES</bool>
-												<object class="NSScrollView" id="516244966">
-													<reference key="NSNextResponder" ref="581281551"/>
-													<int key="NSvFlags">274</int>
-													<object class="NSMutableArray" key="NSSubviews">
-														<bool key="EncodedWithXMLCoder">YES</bool>
-														<object class="NSClipView" id="119083427">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">2304</int>
-															<object class="NSMutableArray" key="NSSubviews">
-																<bool key="EncodedWithXMLCoder">YES</bool>
-																<object class="NSTableView" id="23853726">
-																	<reference key="NSNextResponder" ref="119083427"/>
-																	<int key="NSvFlags">256</int>
-																	<string key="NSFrameSize">{156, 200}</string>
-																	<reference key="NSSuperview" ref="119083427"/>
-																	<reference key="NSWindow"/>
-																	<bool key="NSEnabled">YES</bool>
-																	<object class="NSTableHeaderView" key="NSHeaderView" id="1048357090">
-																		<reference key="NSNextResponder" ref="746968320"/>
-																		<int key="NSvFlags">256</int>
-																		<string key="NSFrameSize">{156, 17}</string>
-																		<reference key="NSSuperview" ref="746968320"/>
-																		<reference key="NSWindow"/>
-																		<reference key="NSTableView" ref="23853726"/>
-																	</object>
-																	<object class="_NSCornerView" key="NSCornerView" id="212282722">
-																		<reference key="NSNextResponder" ref="516244966"/>
-																		<int key="NSvFlags">256</int>
-																		<string key="NSFrame">{{157, 0}, {16, 17}}</string>
-																		<reference key="NSSuperview" ref="516244966"/>
-																		<reference key="NSWindow"/>
-																	</object>
-																	<object class="NSMutableArray" key="NSTableColumns">
-																		<bool key="EncodedWithXMLCoder">YES</bool>
-																		<object class="NSTableColumn" id="920426212">
-																			<double key="NSWidth">7.100000e+01</double>
-																			<double key="NSMinWidth">4.000000e+01</double>
-																			<double key="NSMaxWidth">1.000000e+03</double>
-																			<object class="NSTableHeaderCell" key="NSHeaderCell">
-																				<int key="NSCellFlags">75628032</int>
-																				<int key="NSCellFlags2">0</int>
-																				<string key="NSContents">Variable</string>
-																				<reference key="NSSupport" ref="26"/>
-																				<object class="NSColor" key="NSBackgroundColor" id="890615311">
-																					<int key="NSColorSpace">3</int>
-																					<bytes key="NSWhite">MC4zMzMzMzI5OQA</bytes>
-																				</object>
-																				<object class="NSColor" key="NSTextColor" id="866628999">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">headerTextColor</string>
-																					<reference key="NSColor" ref="555789289"/>
-																				</object>
-																			</object>
-																			<object class="NSTextFieldCell" key="NSDataCell" id="525071236">
-																				<int key="NSCellFlags">337772096</int>
-																				<int key="NSCellFlags2">2048</int>
-																				<string key="NSContents" id="456204663">Text Cell</string>
-																				<object class="NSFont" key="NSSupport" id="8196371">
-																					<reference key="NSName" ref="378950370"/>
-																					<double key="NSSize">1.300000e+01</double>
-																					<int key="NSfFlags">1044</int>
-																				</object>
-																				<reference key="NSControlView" ref="23853726"/>
-																				<object class="NSColor" key="NSBackgroundColor" id="224028609">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">controlBackgroundColor</string>
-																					<reference key="NSColor" ref="377165725"/>
-																				</object>
-																				<object class="NSColor" key="NSTextColor" id="205104690">
-																					<int key="NSColorSpace">6</int>
-																					<reference key="NSCatalogName" ref="484387293"/>
-																					<string key="NSColorName">controlTextColor</string>
-																					<reference key="NSColor" ref="555789289"/>
-																				</object>
-																			</object>
-																			<int key="NSResizingMask">3</int>
-																			<bool key="NSIsResizeable">YES</bool>
-																			<bool key="NSIsEditable">YES</bool>
-																			<reference key="NSTableView" ref="23853726"/>
-																		</object>
-																		<object class="NSTableColumn" id="857054683">
-																			<double key="NSWidth">7.900000e+01</double>
-																			<double key="NSMinWidth">4.000000e+01</double>
-																			<double key="NSMaxWidth">1.000000e+03</double>
-																			<object class="NSTableHeaderCell" key="NSHeaderCell">
-																				<int key="NSCellFlags">75628032</int>
-																				<int key="NSCellFlags2">0</int>
-																				<string key="NSContents">Value</string>
-																				<reference key="NSSupport" ref="26"/>
-																				<reference key="NSBackgroundColor" ref="890615311"/>
-																				<reference key="NSTextColor" ref="866628999"/>
-																			</object>
-																			<object class="NSTextFieldCell" key="NSDataCell" id="377147224">
-																				<int key="NSCellFlags">337772096</int>
-																				<int key="NSCellFlags2">2048</int>
-																				<reference key="NSContents" ref="456204663"/>
-																				<reference key="NSSupport" ref="8196371"/>
-																				<reference key="NSControlView" ref="23853726"/>
-																				<reference key="NSBackgroundColor" ref="224028609"/>
-																				<reference key="NSTextColor" ref="205104690"/>
-																			</object>
-																			<int key="NSResizingMask">3</int>
-																			<bool key="NSIsResizeable">YES</bool>
-																			<bool key="NSIsEditable">YES</bool>
-																			<reference key="NSTableView" ref="23853726"/>
-																		</object>
-																	</object>
-																	<double key="NSIntercellSpacingWidth">3.000000e+00</double>
-																	<double key="NSIntercellSpacingHeight">2.000000e+00</double>
-																	<reference key="NSBackgroundColor" ref="521347521"/>
-																	<object class="NSColor" key="NSGridColor">
-																		<int key="NSColorSpace">6</int>
-																		<reference key="NSCatalogName" ref="484387293"/>
-																		<string key="NSColorName">gridColor</string>
-																		<object class="NSColor" key="NSColor">
-																			<int key="NSColorSpace">3</int>
-																			<bytes key="NSWhite">MC41AA</bytes>
-																		</object>
-																	</object>
-																	<double key="NSRowHeight">1.700000e+01</double>
-																	<int key="NSTvFlags">-692060160</int>
-																	<int key="NSGridStyleMask">1</int>
-																	<int key="NSColumnAutoresizingStyle">4</int>
-																	<int key="NSDraggingSourceMaskForLocal">15</int>
-																	<int key="NSDraggingSourceMaskForNonLocal">0</int>
-																	<bool key="NSAllowsTypeSelect">YES</bool>
-																</object>
-															</object>
-															<string key="NSFrame">{{1, 17}, {156, 200}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<reference key="NSNextKeyView" ref="23853726"/>
-															<reference key="NSDocView" ref="23853726"/>
-															<reference key="NSBGColor" ref="224028609"/>
-															<int key="NScvFlags">4</int>
-														</object>
-														<object class="NSScroller" id="512953560">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">256</int>
-															<string key="NSFrame">{{157, 17}, {15, 200}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<reference key="NSTarget" ref="516244966"/>
-															<reference key="NSAction" ref="688920982"/>
-															<double key="NSPercent">9.961240e-01</double>
-														</object>
-														<object class="NSScroller" id="47103270">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">256</int>
-															<string key="NSFrame">{{1, 217}, {156, 15}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<int key="NSsFlags">1</int>
-															<reference key="NSTarget" ref="516244966"/>
-															<reference key="NSAction" ref="688920982"/>
-															<double key="NSPercent">7.179487e-01</double>
-														</object>
-														<object class="NSClipView" id="746968320">
-															<reference key="NSNextResponder" ref="516244966"/>
-															<int key="NSvFlags">2304</int>
-															<object class="NSMutableArray" key="NSSubviews">
-																<bool key="EncodedWithXMLCoder">YES</bool>
-																<reference ref="1048357090"/>
-															</object>
-															<string key="NSFrame">{{1, 0}, {156, 17}}</string>
-															<reference key="NSSuperview" ref="516244966"/>
-															<reference key="NSWindow"/>
-															<reference key="NSNextKeyView" ref="1048357090"/>
-															<reference key="NSDocView" ref="1048357090"/>
-															<reference key="NSBGColor" ref="224028609"/>
-															<int key="NScvFlags">4</int>
-														</object>
-														<reference ref="212282722"/>
-													</object>
-													<string key="NSFrame">{{18, 14}, {173, 233}}</string>
-													<reference key="NSSuperview" ref="581281551"/>
-													<reference key="NSWindow"/>
-													<reference key="NSNextKeyView" ref="119083427"/>
-													<int key="NSsFlags">50</int>
-													<reference key="NSVScroller" ref="512953560"/>
-													<reference key="NSHScroller" ref="47103270"/>
-													<reference key="NSContentView" ref="119083427"/>
-													<reference key="NSHeaderClipView" ref="746968320"/>
-													<reference key="NSCornerView" ref="212282722"/>
-													<bytes key="NSScrollAmts">QSAAAEEgAABBmAAAQZgAAA</bytes>
-												</object>
-											</object>
-											<string key="NSFrame">{{1, 1}, {209, 257}}</string>
-											<reference key="NSSuperview" ref="764100755"/>
-											<reference key="NSWindow"/>
-										</object>
-									</object>
-									<string key="NSFrame">{{474, 0}, {211, 273}}</string>
-									<reference key="NSSuperview" ref="741760375"/>
-									<reference key="NSWindow"/>
-									<reference key="NSOffsets" ref="1055927954"/>
-									<object class="NSTextFieldCell" key="NSTitleCell">
-										<int key="NSCellFlags">67239424</int>
-										<int key="NSCellFlags2">0</int>
-										<string key="NSContents">Workspace</string>
-										<reference key="NSSupport" ref="26"/>
-										<reference key="NSBackgroundColor" ref="131515055"/>
-										<object class="NSColor" key="NSTextColor">
-											<int key="NSColorSpace">3</int>
-											<bytes key="NSWhite">MCAwLjgwMDAwMDAxAA</bytes>
-										</object>
-									</object>
-									<reference key="NSContentView" ref="581281551"/>
-									<int key="NSBorderType">1</int>
-									<int key="NSBoxType">0</int>
-									<int key="NSTitlePosition">2</int>
-									<bool key="NSTransparent">NO</bool>
-								</object>
-							</object>
-							<string key="NSFrame">{{20, 44}, {685, 273}}</string>
-							<reference key="NSSuperview" ref="439893737"/>
-							<reference key="NSWindow"/>
-							<bool key="NSIsVertical">YES</bool>
-							<int key="NSDividerStyle">2</int>
-							<string key="NSAutosaveName">ipython1_console_workspace_split</string>
-						</object>
-						<object class="NSProgressIndicator" id="74807016">
-							<reference key="NSNextResponder" ref="439893737"/>
-							<int key="NSvFlags">1313</int>
-							<object class="NSPSMatrix" key="NSDrawMatrix"/>
-							<string key="NSFrame">{{689, 20}, {16, 16}}</string>
-							<reference key="NSSuperview" ref="439893737"/>
-							<reference key="NSWindow"/>
-							<int key="NSpiFlags">28938</int>
-							<double key="NSMinValue">1.600000e+01</double>
-							<double key="NSMaxValue">1.000000e+02</double>
-						</object>
-					</object>
-					<string key="NSFrameSize">{725, 337}</string>
-					<reference key="NSSuperview"/>
-					<reference key="NSWindow"/>
-				</object>
-				<string key="NSScreenRect">{{0, 0}, {1280, 778}}</string>
-				<string key="NSFrameAutosaveName">ipython1_sandbox</string>
-			</object>
-			<object class="NSCustomObject" id="610635028">
-				<string key="NSClassName" id="982950837">IPython1SandboxAppDelegate</string>
-			</object>
-			<object class="NSDictionaryController" id="808393665">
-				<object class="NSMutableArray" key="NSDeclaredKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<string>keys</string>
-					<string id="181461860">key</string>
-					<string id="276523235">value</string>
-				</object>
-				<bool key="NSEditable">YES</bool>
-				<bool key="NSAvoidsEmptySelection">YES</bool>
-				<bool key="NSPreservesSelection">YES</bool>
-				<bool key="NSSelectsInsertedObjects">YES</bool>
-				<bool key="NSFilterRestrictsInsertion">YES</bool>
-				<object class="NSArray" key="NSSortDescriptors">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<object class="NSSortDescriptor">
-						<reference key="NSKey" ref="181461860"/>
-						<bool key="NSAscending">YES</bool>
-						<string key="NSSelector">compare:</string>
-					</object>
-				</object>
-				<bool key="NSClearsFilterPredicateOnInsertion">YES</bool>
-				<reference key="NSInitialKey" ref="181461860"/>
-				<reference key="NSInitialValue" ref="276523235"/>
-			</object>
-			<object class="NSCustomObject" id="631572152">
-				<string key="NSClassName" id="695797635">IPythonCocoaController</string>
-			</object>
-		</object>
-		<object class="IBObjectContainer" key="IBDocument.Objects">
-			<object class="NSMutableArray" key="connectionRecords">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performMiniaturize:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1011231497"/>
-					</object>
-					<int key="connectionID">37</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">arrangeInFront:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="625202149"/>
-					</object>
-					<int key="connectionID">39</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">print:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="49223823"/>
-					</object>
-					<int key="connectionID">86</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">runPageLayout:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="294629803"/>
-					</object>
-					<int key="connectionID">87</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">clearRecentDocuments:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="759406840"/>
-					</object>
-					<int key="connectionID">127</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">orderFrontStandardAboutPanel:</string>
-						<reference key="source" ref="1021"/>
-						<reference key="destination" ref="238522557"/>
-					</object>
-					<int key="connectionID">142</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performClose:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="776162233"/>
-					</object>
-					<int key="connectionID">193</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleContinuousSpellChecking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="948374510"/>
-					</object>
-					<int key="connectionID">222</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">undo:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1058277027"/>
-					</object>
-					<int key="connectionID">223</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">copy:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="860595796"/>
-					</object>
-					<int key="connectionID">224</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">checkSpelling:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="96193923"/>
-					</object>
-					<int key="connectionID">225</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">paste:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="29853731"/>
-					</object>
-					<int key="connectionID">226</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">stopSpeaking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="680220178"/>
-					</object>
-					<int key="connectionID">227</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">cut:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="296257095"/>
-					</object>
-					<int key="connectionID">228</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">showGuessPanel:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="679648819"/>
-					</object>
-					<int key="connectionID">230</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">redo:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="790794224"/>
-					</object>
-					<int key="connectionID">231</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">selectAll:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="583158037"/>
-					</object>
-					<int key="connectionID">232</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">startSpeaking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="731782645"/>
-					</object>
-					<int key="connectionID">233</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">delete:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="437104165"/>
-					</object>
-					<int key="connectionID">235</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performZoom:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="575023229"/>
-					</object>
-					<int key="connectionID">240</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">performFindPanelAction:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="447796847"/>
-					</object>
-					<int key="connectionID">241</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">centerSelectionInVisibleArea:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="88285865"/>
-					</object>
-					<int key="connectionID">245</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleGrammarChecking:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="967646866"/>
-					</object>
-					<int key="connectionID">347</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleSmartInsertDelete:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="605118523"/>
-					</object>
-					<int key="connectionID">355</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleAutomaticQuoteSubstitution:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="197661976"/>
-					</object>
-					<int key="connectionID">356</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleAutomaticLinkDetection:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="708854459"/>
-					</object>
-					<int key="connectionID">357</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">showHelp:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="238773614"/>
-					</object>
-					<int key="connectionID">360</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">orderFrontColorPanel:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1028416764"/>
-					</object>
-					<int key="connectionID">361</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">saveDocument:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="1023925487"/>
-					</object>
-					<int key="connectionID">362</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">saveDocumentAs:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="117038363"/>
-					</object>
-					<int key="connectionID">363</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">revertDocumentToSaved:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="579971712"/>
-					</object>
-					<int key="connectionID">364</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">runToolbarCustomizationPalette:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="237841660"/>
-					</object>
-					<int key="connectionID">365</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">toggleToolbarShown:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="102151532"/>
-					</object>
-					<int key="connectionID">366</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">hide:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="755159360"/>
-					</object>
-					<int key="connectionID">367</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">hideOtherApplications:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="342932134"/>
-					</object>
-					<int key="connectionID">368</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">terminate:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="632727374"/>
-					</object>
-					<int key="connectionID">369</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBActionConnection" key="connection">
-						<string key="label">unhideAllApplications:</string>
-						<reference key="source" ref="1014"/>
-						<reference key="destination" ref="908899353"/>
-					</object>
-					<int key="connectionID">370</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label" id="606168085">delegate</string>
-						<reference key="source" ref="1050"/>
-						<reference key="destination" ref="610635028"/>
-					</object>
-					<int key="connectionID">374</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="187454546">contentDictionary: userNS</string>
-						<reference key="source" ref="808393665"/>
-						<reference key="destination" ref="631572152"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="808393665"/>
-							<reference key="NSDestination" ref="631572152"/>
-							<reference key="NSLabel" ref="187454546"/>
-							<string key="NSBinding">contentDictionary</string>
-							<string key="NSKeyPath">userNS</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">424</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="688370141">value: arrangedObjects.value</string>
-						<reference key="source" ref="857054683"/>
-						<reference key="destination" ref="808393665"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="857054683"/>
-							<reference key="NSDestination" ref="808393665"/>
-							<reference key="NSLabel" ref="688370141"/>
-							<reference key="NSBinding" ref="276523235"/>
-							<string key="NSKeyPath">arrangedObjects.value</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">427</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="764859820">value: arrangedObjects.key</string>
-						<reference key="source" ref="920426212"/>
-						<reference key="destination" ref="808393665"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="920426212"/>
-							<reference key="NSDestination" ref="808393665"/>
-							<reference key="NSLabel" ref="764859820"/>
-							<reference key="NSBinding" ref="276523235"/>
-							<string key="NSKeyPath">arrangedObjects.key</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">428</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<reference key="label" ref="606168085"/>
-						<reference key="source" ref="972006081"/>
-						<reference key="destination" ref="631572152"/>
-					</object>
-					<int key="connectionID">429</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="97087091">animate: waitingForEngine</string>
-						<reference key="source" ref="74807016"/>
-						<reference key="destination" ref="631572152"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="74807016"/>
-							<reference key="NSDestination" ref="631572152"/>
-							<reference key="NSLabel" ref="97087091"/>
-							<string key="NSBinding">animate</string>
-							<string key="NSKeyPath">waitingForEngine</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">437</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBBindingConnection" key="connection">
-						<string key="label" id="289275654">filterPredicate: workspaceFilterPredicate</string>
-						<reference key="source" ref="808393665"/>
-						<reference key="destination" ref="610635028"/>
-						<object class="NSNibBindingConnector" key="connector">
-							<reference key="NSSource" ref="808393665"/>
-							<reference key="NSDestination" ref="610635028"/>
-							<reference key="NSLabel" ref="289275654"/>
-							<string key="NSBinding">filterPredicate</string>
-							<string key="NSKeyPath">workspaceFilterPredicate</string>
-							<int key="NSNibBindingConnectorVersion">2</int>
-						</object>
-					</object>
-					<int key="connectionID">440</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label">ipythonController</string>
-						<reference key="source" ref="610635028"/>
-						<reference key="destination" ref="631572152"/>
-					</object>
-					<int key="connectionID">441</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label" id="684042788">textView</string>
-						<reference key="source" ref="631572152"/>
-						<reference key="destination" ref="163417131"/>
-					</object>
-					<int key="connectionID">444</int>
-				</object>
-				<object class="IBConnectionRecord">
-					<object class="IBOutletConnection" key="connection">
-						<string key="label">initialFirstResponder</string>
-						<reference key="source" ref="972006081"/>
-						<reference key="destination" ref="163417131"/>
-					</object>
-					<int key="connectionID">445</int>
-				</object>
-			</object>
-			<object class="IBMutableOrderedSet" key="objectRecords">
-				<object class="NSArray" key="orderedObjects">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<object class="IBObjectRecord">
-						<int key="objectID">0</int>
-						<object class="NSArray" key="object" id="1049">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<reference key="children" ref="1048"/>
-						<nil key="parent"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">-2</int>
-						<reference key="object" ref="1021"/>
-						<reference key="parent" ref="1049"/>
-						<string type="base64-UTF8" key="objectName">RmlsZSdzIE93bmVyA</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">-1</int>
-						<reference key="object" ref="1014"/>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">First Responder</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">-3</int>
-						<reference key="object" ref="1050"/>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">Application</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">29</int>
-						<reference key="object" ref="649796088"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="713487014"/>
-							<reference ref="694149608"/>
-							<reference ref="391199113"/>
-							<reference ref="952259628"/>
-							<reference ref="379814623"/>
-							<reference ref="586577488"/>
-							<reference ref="626404410"/>
-						</object>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">MainMenu</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">19</int>
-						<reference key="object" ref="713487014"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="835318025"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">56</int>
-						<reference key="object" ref="694149608"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="110575045"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">103</int>
-						<reference key="object" ref="391199113"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="374024848"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-						<string key="objectName" id="508169456">1</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">217</int>
-						<reference key="object" ref="952259628"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="789758025"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">83</int>
-						<reference key="object" ref="379814623"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="720053764"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">81</int>
-						<reference key="object" ref="720053764"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="1023925487"/>
-							<reference ref="117038363"/>
-							<reference ref="49223823"/>
-							<reference ref="722745758"/>
-							<reference ref="705341025"/>
-							<reference ref="1025936716"/>
-							<reference ref="294629803"/>
-							<reference ref="776162233"/>
-							<reference ref="425164168"/>
-							<reference ref="579971712"/>
-							<reference ref="1010469920"/>
-						</object>
-						<reference key="parent" ref="379814623"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">75</int>
-						<reference key="object" ref="1023925487"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">3</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">80</int>
-						<reference key="object" ref="117038363"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">8</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">78</int>
-						<reference key="object" ref="49223823"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">6</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">72</int>
-						<reference key="object" ref="722745758"/>
-						<reference key="parent" ref="720053764"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">82</int>
-						<reference key="object" ref="705341025"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">9</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">124</int>
-						<reference key="object" ref="1025936716"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="1065607017"/>
-						</object>
-						<reference key="parent" ref="720053764"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">77</int>
-						<reference key="object" ref="294629803"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">5</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">73</int>
-						<reference key="object" ref="776162233"/>
-						<reference key="parent" ref="720053764"/>
-						<reference key="objectName" ref="508169456"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">79</int>
-						<reference key="object" ref="425164168"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">7</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">112</int>
-						<reference key="object" ref="579971712"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName">10</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">74</int>
-						<reference key="object" ref="1010469920"/>
-						<reference key="parent" ref="720053764"/>
-						<string key="objectName" id="464456376">2</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">125</int>
-						<reference key="object" ref="1065607017"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="759406840"/>
-						</object>
-						<reference key="parent" ref="1025936716"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">126</int>
-						<reference key="object" ref="759406840"/>
-						<reference key="parent" ref="1065607017"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">205</int>
-						<reference key="object" ref="789758025"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="437104165"/>
-							<reference ref="583158037"/>
-							<reference ref="1058277027"/>
-							<reference ref="212016141"/>
-							<reference ref="296257095"/>
-							<reference ref="29853731"/>
-							<reference ref="860595796"/>
-							<reference ref="1040322652"/>
-							<reference ref="790794224"/>
-							<reference ref="892235320"/>
-							<reference ref="972420730"/>
-							<reference ref="676164635"/>
-							<reference ref="507821607"/>
-						</object>
-						<reference key="parent" ref="952259628"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">202</int>
-						<reference key="object" ref="437104165"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">198</int>
-						<reference key="object" ref="583158037"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">207</int>
-						<reference key="object" ref="1058277027"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">214</int>
-						<reference key="object" ref="212016141"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">199</int>
-						<reference key="object" ref="296257095"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">203</int>
-						<reference key="object" ref="29853731"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">197</int>
-						<reference key="object" ref="860595796"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">206</int>
-						<reference key="object" ref="1040322652"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">215</int>
-						<reference key="object" ref="790794224"/>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">218</int>
-						<reference key="object" ref="892235320"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="963351320"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">216</int>
-						<reference key="object" ref="972420730"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="769623530"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">200</int>
-						<reference key="object" ref="769623530"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="948374510"/>
-							<reference ref="96193923"/>
-							<reference ref="679648819"/>
-							<reference ref="967646866"/>
-						</object>
-						<reference key="parent" ref="972420730"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">219</int>
-						<reference key="object" ref="948374510"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">201</int>
-						<reference key="object" ref="96193923"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">204</int>
-						<reference key="object" ref="679648819"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">220</int>
-						<reference key="object" ref="963351320"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="270902937"/>
-							<reference ref="88285865"/>
-							<reference ref="159080638"/>
-							<reference ref="326711663"/>
-							<reference ref="447796847"/>
-						</object>
-						<reference key="parent" ref="892235320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">213</int>
-						<reference key="object" ref="270902937"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">210</int>
-						<reference key="object" ref="88285865"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">221</int>
-						<reference key="object" ref="159080638"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">208</int>
-						<reference key="object" ref="326711663"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">209</int>
-						<reference key="object" ref="447796847"/>
-						<reference key="parent" ref="963351320"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">106</int>
-						<reference key="object" ref="374024848"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="238773614"/>
-						</object>
-						<reference key="parent" ref="391199113"/>
-						<reference key="objectName" ref="464456376"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">111</int>
-						<reference key="object" ref="238773614"/>
-						<reference key="parent" ref="374024848"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">57</int>
-						<reference key="object" ref="110575045"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="238522557"/>
-							<reference ref="755159360"/>
-							<reference ref="908899353"/>
-							<reference ref="632727374"/>
-							<reference ref="646227648"/>
-							<reference ref="609285721"/>
-							<reference ref="481834944"/>
-							<reference ref="304266470"/>
-							<reference ref="1046388886"/>
-							<reference ref="1056857174"/>
-							<reference ref="342932134"/>
-						</object>
-						<reference key="parent" ref="694149608"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">58</int>
-						<reference key="object" ref="238522557"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">134</int>
-						<reference key="object" ref="755159360"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">150</int>
-						<reference key="object" ref="908899353"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">136</int>
-						<reference key="object" ref="632727374"/>
-						<reference key="parent" ref="110575045"/>
-						<string key="objectName">1111</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">144</int>
-						<reference key="object" ref="646227648"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">129</int>
-						<reference key="object" ref="609285721"/>
-						<reference key="parent" ref="110575045"/>
-						<string key="objectName">121</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">143</int>
-						<reference key="object" ref="481834944"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">236</int>
-						<reference key="object" ref="304266470"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">131</int>
-						<reference key="object" ref="1046388886"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="752062318"/>
-						</object>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">149</int>
-						<reference key="object" ref="1056857174"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">145</int>
-						<reference key="object" ref="342932134"/>
-						<reference key="parent" ref="110575045"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">130</int>
-						<reference key="object" ref="752062318"/>
-						<reference key="parent" ref="1046388886"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">24</int>
-						<reference key="object" ref="835318025"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="299356726"/>
-							<reference ref="625202149"/>
-							<reference ref="575023229"/>
-							<reference ref="1011231497"/>
-						</object>
-						<reference key="parent" ref="713487014"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">92</int>
-						<reference key="object" ref="299356726"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">5</int>
-						<reference key="object" ref="625202149"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">239</int>
-						<reference key="object" ref="575023229"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">23</int>
-						<reference key="object" ref="1011231497"/>
-						<reference key="parent" ref="835318025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">295</int>
-						<reference key="object" ref="586577488"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="466310130"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">296</int>
-						<reference key="object" ref="466310130"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="102151532"/>
-							<reference ref="237841660"/>
-						</object>
-						<reference key="parent" ref="586577488"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">297</int>
-						<reference key="object" ref="102151532"/>
-						<reference key="parent" ref="466310130"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">298</int>
-						<reference key="object" ref="237841660"/>
-						<reference key="parent" ref="466310130"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">299</int>
-						<reference key="object" ref="626404410"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="502084290"/>
-						</object>
-						<reference key="parent" ref="649796088"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">300</int>
-						<reference key="object" ref="502084290"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="519768076"/>
-							<reference ref="1028416764"/>
-						</object>
-						<reference key="parent" ref="626404410"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">344</int>
-						<reference key="object" ref="519768076"/>
-						<reference key="parent" ref="502084290"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">345</int>
-						<reference key="object" ref="1028416764"/>
-						<reference key="parent" ref="502084290"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">211</int>
-						<reference key="object" ref="676164635"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="785027613"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">212</int>
-						<reference key="object" ref="785027613"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="680220178"/>
-							<reference ref="731782645"/>
-						</object>
-						<reference key="parent" ref="676164635"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">195</int>
-						<reference key="object" ref="680220178"/>
-						<reference key="parent" ref="785027613"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">196</int>
-						<reference key="object" ref="731782645"/>
-						<reference key="parent" ref="785027613"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">346</int>
-						<reference key="object" ref="967646866"/>
-						<reference key="parent" ref="769623530"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">348</int>
-						<reference key="object" ref="507821607"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="698887838"/>
-						</object>
-						<reference key="parent" ref="789758025"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">349</int>
-						<reference key="object" ref="698887838"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="605118523"/>
-							<reference ref="197661976"/>
-							<reference ref="708854459"/>
-						</object>
-						<reference key="parent" ref="507821607"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">350</int>
-						<reference key="object" ref="605118523"/>
-						<reference key="parent" ref="698887838"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">351</int>
-						<reference key="object" ref="197661976"/>
-						<reference key="parent" ref="698887838"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">354</int>
-						<reference key="object" ref="708854459"/>
-						<reference key="parent" ref="698887838"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">371</int>
-						<reference key="object" ref="972006081"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="439893737"/>
-						</object>
-						<reference key="parent" ref="1049"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">372</int>
-						<reference key="object" ref="439893737"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="741760375"/>
-							<reference ref="74807016"/>
-						</object>
-						<reference key="parent" ref="972006081"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">373</int>
-						<reference key="object" ref="610635028"/>
-						<reference key="parent" ref="1049"/>
-						<reference key="objectName" ref="982950837"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">385</int>
-						<reference key="object" ref="808393665"/>
-						<reference key="parent" ref="1049"/>
-						<string key="objectName">User Namespace Controller</string>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">421</int>
-						<reference key="object" ref="741760375"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="554641139"/>
-							<reference ref="764100755"/>
-						</object>
-						<reference key="parent" ref="439893737"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">420</int>
-						<reference key="object" ref="554641139"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="188193463"/>
-						</object>
-						<reference key="parent" ref="741760375"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">416</int>
-						<reference key="object" ref="188193463"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="418410897"/>
-							<reference ref="936733673"/>
-							<reference ref="163417131"/>
-						</object>
-						<reference key="parent" ref="554641139"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">417</int>
-						<reference key="object" ref="418410897"/>
-						<reference key="parent" ref="188193463"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">418</int>
-						<reference key="object" ref="936733673"/>
-						<reference key="parent" ref="188193463"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">419</int>
-						<reference key="object" ref="163417131"/>
-						<reference key="parent" ref="188193463"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">406</int>
-						<reference key="object" ref="764100755"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="516244966"/>
-						</object>
-						<reference key="parent" ref="741760375"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">407</int>
-						<reference key="object" ref="516244966"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="23853726"/>
-							<reference ref="47103270"/>
-							<reference ref="512953560"/>
-							<reference ref="1048357090"/>
-						</object>
-						<reference key="parent" ref="764100755"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">411</int>
-						<reference key="object" ref="23853726"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="857054683"/>
-							<reference ref="920426212"/>
-						</object>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">410</int>
-						<reference key="object" ref="47103270"/>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">409</int>
-						<reference key="object" ref="512953560"/>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">408</int>
-						<reference key="object" ref="1048357090"/>
-						<reference key="parent" ref="516244966"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">413</int>
-						<reference key="object" ref="857054683"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="377147224"/>
-						</object>
-						<reference key="parent" ref="23853726"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">412</int>
-						<reference key="object" ref="920426212"/>
-						<object class="NSMutableArray" key="children">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-							<reference ref="525071236"/>
-						</object>
-						<reference key="parent" ref="23853726"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">415</int>
-						<reference key="object" ref="525071236"/>
-						<reference key="parent" ref="920426212"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">414</int>
-						<reference key="object" ref="377147224"/>
-						<reference key="parent" ref="857054683"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">422</int>
-						<reference key="object" ref="631572152"/>
-						<reference key="parent" ref="1049"/>
-					</object>
-					<object class="IBObjectRecord">
-						<int key="objectID">436</int>
-						<reference key="object" ref="74807016"/>
-						<reference key="parent" ref="439893737"/>
-					</object>
-				</object>
-			</object>
-			<object class="NSMutableDictionary" key="flattenedProperties">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="NSMutableArray" key="dict.sortedKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<string>-1.IBPluginDependency</string>
-					<string>-2.IBPluginDependency</string>
-					<string>-3.IBPluginDependency</string>
-					<string>103.IBPluginDependency</string>
-					<string>103.ImportedFromIB2</string>
-					<string>106.IBPluginDependency</string>
-					<string>106.ImportedFromIB2</string>
-					<string>106.editorWindowContentRectSynchronizationRect</string>
-					<string>111.IBPluginDependency</string>
-					<string>111.ImportedFromIB2</string>
-					<string>112.IBPluginDependency</string>
-					<string>112.ImportedFromIB2</string>
-					<string>124.IBPluginDependency</string>
-					<string>124.ImportedFromIB2</string>
-					<string>125.IBPluginDependency</string>
-					<string>125.ImportedFromIB2</string>
-					<string>125.editorWindowContentRectSynchronizationRect</string>
-					<string>126.IBPluginDependency</string>
-					<string>126.ImportedFromIB2</string>
-					<string>129.IBPluginDependency</string>
-					<string>129.ImportedFromIB2</string>
-					<string>130.IBPluginDependency</string>
-					<string>130.ImportedFromIB2</string>
-					<string>130.editorWindowContentRectSynchronizationRect</string>
-					<string>131.IBPluginDependency</string>
-					<string>131.ImportedFromIB2</string>
-					<string>134.IBPluginDependency</string>
-					<string>134.ImportedFromIB2</string>
-					<string>136.IBPluginDependency</string>
-					<string>136.ImportedFromIB2</string>
-					<string>143.IBPluginDependency</string>
-					<string>143.ImportedFromIB2</string>
-					<string>144.IBPluginDependency</string>
-					<string>144.ImportedFromIB2</string>
-					<string>145.IBPluginDependency</string>
-					<string>145.ImportedFromIB2</string>
-					<string>149.IBPluginDependency</string>
-					<string>149.ImportedFromIB2</string>
-					<string>150.IBPluginDependency</string>
-					<string>150.ImportedFromIB2</string>
-					<string>19.IBPluginDependency</string>
-					<string>19.ImportedFromIB2</string>
-					<string>195.IBPluginDependency</string>
-					<string>195.ImportedFromIB2</string>
-					<string>196.IBPluginDependency</string>
-					<string>196.ImportedFromIB2</string>
-					<string>197.IBPluginDependency</string>
-					<string>197.ImportedFromIB2</string>
-					<string>198.IBPluginDependency</string>
-					<string>198.ImportedFromIB2</string>
-					<string>199.IBPluginDependency</string>
-					<string>199.ImportedFromIB2</string>
-					<string>200.IBPluginDependency</string>
-					<string>200.ImportedFromIB2</string>
-					<string>200.editorWindowContentRectSynchronizationRect</string>
-					<string>201.IBPluginDependency</string>
-					<string>201.ImportedFromIB2</string>
-					<string>202.IBPluginDependency</string>
-					<string>202.ImportedFromIB2</string>
-					<string>203.IBPluginDependency</string>
-					<string>203.ImportedFromIB2</string>
-					<string>204.IBPluginDependency</string>
-					<string>204.ImportedFromIB2</string>
-					<string>205.IBPluginDependency</string>
-					<string>205.ImportedFromIB2</string>
-					<string>205.editorWindowContentRectSynchronizationRect</string>
-					<string>206.IBPluginDependency</string>
-					<string>206.ImportedFromIB2</string>
-					<string>207.IBPluginDependency</string>
-					<string>207.ImportedFromIB2</string>
-					<string>208.IBPluginDependency</string>
-					<string>208.ImportedFromIB2</string>
-					<string>209.IBPluginDependency</string>
-					<string>209.ImportedFromIB2</string>
-					<string>210.IBPluginDependency</string>
-					<string>210.ImportedFromIB2</string>
-					<string>211.IBPluginDependency</string>
-					<string>211.ImportedFromIB2</string>
-					<string>212.IBPluginDependency</string>
-					<string>212.ImportedFromIB2</string>
-					<string>212.editorWindowContentRectSynchronizationRect</string>
-					<string>213.IBPluginDependency</string>
-					<string>213.ImportedFromIB2</string>
-					<string>214.IBPluginDependency</string>
-					<string>214.ImportedFromIB2</string>
-					<string>215.IBPluginDependency</string>
-					<string>215.ImportedFromIB2</string>
-					<string>216.IBPluginDependency</string>
-					<string>216.ImportedFromIB2</string>
-					<string>217.IBPluginDependency</string>
-					<string>217.ImportedFromIB2</string>
-					<string>218.IBPluginDependency</string>
-					<string>218.ImportedFromIB2</string>
-					<string>219.IBPluginDependency</string>
-					<string>219.ImportedFromIB2</string>
-					<string>220.IBPluginDependency</string>
-					<string>220.ImportedFromIB2</string>
-					<string>220.editorWindowContentRectSynchronizationRect</string>
-					<string>221.IBPluginDependency</string>
-					<string>221.ImportedFromIB2</string>
-					<string>23.IBPluginDependency</string>
-					<string>23.ImportedFromIB2</string>
-					<string>236.IBPluginDependency</string>
-					<string>236.ImportedFromIB2</string>
-					<string>239.IBPluginDependency</string>
-					<string>239.ImportedFromIB2</string>
-					<string>24.IBPluginDependency</string>
-					<string>24.ImportedFromIB2</string>
-					<string>24.editorWindowContentRectSynchronizationRect</string>
-					<string>29.IBPluginDependency</string>
-					<string>29.ImportedFromIB2</string>
-					<string>29.WindowOrigin</string>
-					<string>29.editorWindowContentRectSynchronizationRect</string>
-					<string>295.IBPluginDependency</string>
-					<string>296.IBPluginDependency</string>
-					<string>296.editorWindowContentRectSynchronizationRect</string>
-					<string>297.IBPluginDependency</string>
-					<string>298.IBPluginDependency</string>
-					<string>299.IBPluginDependency</string>
-					<string>300.IBPluginDependency</string>
-					<string>300.editorWindowContentRectSynchronizationRect</string>
-					<string>344.IBPluginDependency</string>
-					<string>345.IBPluginDependency</string>
-					<string>346.IBPluginDependency</string>
-					<string>346.ImportedFromIB2</string>
-					<string>348.IBPluginDependency</string>
-					<string>348.ImportedFromIB2</string>
-					<string>349.IBPluginDependency</string>
-					<string>349.ImportedFromIB2</string>
-					<string>349.editorWindowContentRectSynchronizationRect</string>
-					<string>350.IBPluginDependency</string>
-					<string>350.ImportedFromIB2</string>
-					<string>351.IBPluginDependency</string>
-					<string>351.ImportedFromIB2</string>
-					<string>354.IBPluginDependency</string>
-					<string>354.ImportedFromIB2</string>
-					<string>371.IBPluginDependency</string>
-					<string>371.IBViewEditorWindowController.showingLayoutRectangles</string>
-					<string>371.IBWindowTemplateEditedContentRect</string>
-					<string>371.NSWindowTemplate.visibleAtLaunch</string>
-					<string>371.editorWindowContentRectSynchronizationRect</string>
-					<string>372.IBPluginDependency</string>
-					<string>373.IBPluginDependency</string>
-					<string>385.IBPluginDependency</string>
-					<string>407.IBPluginDependency</string>
-					<string>409.IBPluginDependency</string>
-					<string>410.IBPluginDependency</string>
-					<string>411.IBPluginDependency</string>
-					<string>412.IBPluginDependency</string>
-					<string>413.IBPluginDependency</string>
-					<string>414.IBPluginDependency</string>
-					<string>415.IBPluginDependency</string>
-					<string>416.IBPluginDependency</string>
-					<string>417.IBPluginDependency</string>
-					<string>418.IBPluginDependency</string>
-					<string>419.IBAttributePlaceholdersKey</string>
-					<string>419.IBPluginDependency</string>
-					<string>422.IBPluginDependency</string>
-					<string>436.IBPluginDependency</string>
-					<string>5.IBPluginDependency</string>
-					<string>5.ImportedFromIB2</string>
-					<string>56.IBPluginDependency</string>
-					<string>56.ImportedFromIB2</string>
-					<string>57.IBPluginDependency</string>
-					<string>57.ImportedFromIB2</string>
-					<string>57.editorWindowContentRectSynchronizationRect</string>
-					<string>58.IBPluginDependency</string>
-					<string>58.ImportedFromIB2</string>
-					<string>72.IBPluginDependency</string>
-					<string>72.ImportedFromIB2</string>
-					<string>73.IBPluginDependency</string>
-					<string>73.ImportedFromIB2</string>
-					<string>74.IBPluginDependency</string>
-					<string>74.ImportedFromIB2</string>
-					<string>75.IBPluginDependency</string>
-					<string>75.ImportedFromIB2</string>
-					<string>77.IBPluginDependency</string>
-					<string>77.ImportedFromIB2</string>
-					<string>78.IBPluginDependency</string>
-					<string>78.ImportedFromIB2</string>
-					<string>79.IBPluginDependency</string>
-					<string>79.ImportedFromIB2</string>
-					<string>80.IBPluginDependency</string>
-					<string>80.ImportedFromIB2</string>
-					<string>81.IBPluginDependency</string>
-					<string>81.ImportedFromIB2</string>
-					<string>81.editorWindowContentRectSynchronizationRect</string>
-					<string>82.IBPluginDependency</string>
-					<string>82.ImportedFromIB2</string>
-					<string>83.IBPluginDependency</string>
-					<string>83.ImportedFromIB2</string>
-					<string>92.IBPluginDependency</string>
-					<string>92.ImportedFromIB2</string>
-				</object>
-				<object class="NSMutableArray" key="dict.values">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-					<reference ref="113577022"/>
-					<reference ref="885801228"/>
-					<reference ref="885801228"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{596, 852}, {216, 23}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{522, 812}, {146, 23}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{436, 809}, {64, 6}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {275, 83}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{365, 632}, {243, 243}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {167, 43}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {241, 103}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{525, 802}, {197, 73}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{74, 862}</string>
-					<string>{{11, 736}, {489, 20}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<string>{{475, 832}, {234, 43}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<string>{{409, 832}, {176, 43}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{608, 612}, {215, 63}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<integer value="0"/>
-					<string>{{27, 368}, {725, 337}}</string>
-					<reference ref="9"/>
-					<string>{{27, 368}, {725, 337}}</string>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<object class="NSMutableDictionary">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSArray" key="dict.sortedKeys">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<object class="NSMutableArray" key="dict.values">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-					</object>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{23, 794}, {245, 183}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<string>{{323, 672}, {199, 203}}</string>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-					<reference ref="113577022"/>
-					<reference ref="9"/>
-				</object>
-			</object>
-			<object class="NSMutableDictionary" key="unlocalizedProperties">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="NSArray" key="dict.sortedKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-				<object class="NSMutableArray" key="dict.values">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-			</object>
-			<nil key="activeLocalization"/>
-			<object class="NSMutableDictionary" key="localizations">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="NSArray" key="dict.sortedKeys">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-				<object class="NSMutableArray" key="dict.values">
-					<bool key="EncodedWithXMLCoder">YES</bool>
-				</object>
-			</object>
-			<nil key="sourceID"/>
-			<int key="maxID">445</int>
-		</object>
-		<object class="IBClassDescriber" key="IBDocument.Classes">
-			<object class="NSMutableArray" key="referencedPartialClassDescriptions">
-				<bool key="EncodedWithXMLCoder">YES</bool>
-				<object class="IBPartialClassDescription">
-					<reference key="className" ref="695797635"/>
-					<nil key="superclassName"/>
-					<object class="NSMutableDictionary" key="actions">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSArray" key="dict.sortedKeys">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<object class="NSMutableArray" key="dict.values">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-					</object>
-					<object class="NSMutableDictionary" key="outlets">
-						<reference key="NS.key.0" ref="684042788"/>
-						<string key="NS.object.0">NSTextView</string>
-					</object>
-					<object class="IBClassDescriptionSource" key="sourceIdentifier">
-						<string key="majorKey">IBUserSource</string>
-						<reference key="minorKey" ref="255189770"/>
-					</object>
-				</object>
-				<object class="IBPartialClassDescription">
-					<string key="className">IPython1SandboxAppDelegate</string>
-					<string key="superclassName">NSObject</string>
-					<object class="NSMutableDictionary" key="actions">
-						<bool key="EncodedWithXMLCoder">YES</bool>
-						<object class="NSArray" key="dict.sortedKeys">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-						<object class="NSMutableArray" key="dict.values">
-							<bool key="EncodedWithXMLCoder">YES</bool>
-						</object>
-					</object>
-					<object class="NSMutableDictionary" key="outlets">
-						<string key="NS.key.0">ipythonController</string>
-						<string key="NS.object.0">id</string>
-					</object>
-					<object class="IBClassDescriptionSource" key="sourceIdentifier">
-						<string key="majorKey">IBProjectSource</string>
-						<string key="minorKey">IPython1SandboxAppDelegate.py</string>
-					</object>
-				</object>
-			</object>
-		</object>
-		<int key="IBDocument.localizationMode">0</int>
-		<string key="IBDocument.LastKnownRelativeProjectPath">../../IPython1Sandbox.xcodeproj</string>
-		<int key="IBDocument.defaultPropertyAccessControl">3</int>
-		<object class="NSMutableData" key="IBDocument.RunnableNib">
-			<bytes key="NS.bytes">YnBsaXN0MDDUAAEAAgADAAQABQAGAAkAClgkdmVyc2lvblQkdG9wWSRhcmNoaXZlclgkb2JqZWN0cxIA
-AYag0QAHAAhdSUIub2JqZWN0ZGF0YYABXxAPTlNLZXllZEFyY2hpdmVyrxEC/gALAAwAMQA1ADYAPAA9
-AEIAWABZAFoAWwALAGgAbQB7AIAAlQCZAKAApAC0ALoAzQDRAOYA+gD7APwA/QD+AP8BAAEBAQIBAwEE
-AQUBBgEHAQgBCQEKAQsBDwEQARkBIQEmASoBLQExATUBOQE7AT0BTQFSAVUBWgFBAVQBYwFqAWsBbAFv
-AXQBdQF4AYAAkAGBAYQBhwGIAYkBjgGPAZABkwGYAZkBmwGeAasBrAGtAbEBvAG9Ab4BwQHCAcQBxQHG
-AdIB0wHbAdwB3wHkAeUB6AHtAfAB/AIAAgcCCwIdAiUCLwIzAlECUgJaAmQCZQJoAm4CbwJyAncCiAKP
-ApACkwKYApkCnAKmAqcCrAKxArICtwK4ArsCwwLJAsoC0QLWAtcC2gLcAt0C5gLnAvAC8QL1AvYC9wL4
-AvkC/wMAAwIDAwMEAwcDFgMYAxsDHAMfAAsDIAMhAyIDJQNXA10DbQNzASkDdAN5A3oDewN+A4IDgwOG
-A4cDiwOPA5YDmgObA5wDnQOhA6gDrAOtA64DrwOzA7wDwAPBA8IDwwPHA84D0gPTA9QD1QPZA+AD5APl
-A+YD6gPxA/UD9gP3A/gD/AQDBAQEBQQJBBAEEQQSBBMEFwQeBB8EIAQkBCsELwQwBDEENQQ9BD4EPwRA
-BEQESwRMBE0ETgRUBFcEWgRbBFwEXwRjBGoEawRsBG0EcgR1BHYEdwR7BIIEgwSEBIUEiQSQBJUElgSX
-BJgEnASjBKQEpQSmBKoEsQSyBLMEtAS4BL8EwwTEBMUExgTKBNEE0gTTBNQE2ATfBOAE4QTiBOYE7QTx
-BPIE8wT0BPgE/wUABQEFBgUNBQ4FDwUTBRwFHQUeBR8FJAUoBS8FMAUxBTIFNwU4BTwFQwVEBUUFRgVK
-BVEFVgVXBVgFXAVjBWQFZQVpBXAFcQVyBXcFeAV8BYMFhAWFBYkFkAWRBZIFlgWdBZ4FnwWjBaoFqwWs
-BbAFtwW4BbkFugW+BcUFxgXHBcgFzAXTBdQF1QXWBeAF9gX8Bf0F/gX/BgMGCwYMBg8GEQYXBhgGGQYa
-Bh0GJAYlBiYGJwYuBi8GMAY3BjgGOQZABkEGQgZDBq0GuAbCBscGyAbJBs4G1QbWBtgG2QbdBt4GyAbn
-BvAGyAbxBvgHAQbIBwIHEgcbByQHLQbIBy4HNgc9Bz4HRQdGB04HTwdQB1kGyAdaB2AHaQbIB2oHbwdw
-B3oHgwbIB4QHkgebB6IHowekB60HtgbIB7cHvAe/B8AHyQfKB9MGyAfUB+IH6QfqB+sH8gfzB/QH/QgG
-CA8GyAgQCBUIHgbICB8IJggvCDAIOQbICDoIPgg/CKkJFAl/CYAJgQmCCYMJhAmFCYYJhwmICYkJigmL
-CYwJjQmOCY8JkAmRCZIJkwmUCZUJlgmXCZgJmQmaCZsJnAmdCZ4JnwmgCaEJogmjCaQJpQmmCacJqAmp
-CaoJqwmsCa0JrgmvCbAJsQmyCbMJtAm1CbYJtwm4CbkJugm7CbwJvQm+Cb8JwAnBCcIJwwnECcUJxgnH
-CcgJyQnKCcsJzAnNCc4JzwnQCdEJ0gnTCdQJ1QnWCdcJ2AnZCdoJ2wncCd0J3gnfCeAJ4QniCeMJ5Anl
-CeYJ6QnsCoYLIAshCyILIwskCyULJgsnCygLKQsqCysLLAstCy4LLwswCzELMgszCzQLNQs2CzcLOAs5
-CzoLOws8Cz0LPgs/C0ALQQtCC0MLRAtFC0YLRwtIC0kLSgtLC0wLTQtOC08LUAtRC1ILUwtUC1ULVgtX
-C1gLWQtaC1sLXAtdC14LXwtgC2ELYgtjC2QLZQtmC2cLaAtpC2oLawtsC20LbgtvC3ALcQtyC3MLdAt1
-C3YLdwt4C3kLegt7C3wLfQt+C38LgAuBC4ILgwuEC4ULhguHC4gLiQuKC4sLjAuNC44LjwuQC5ELkguT
-C5QLlQuWC5cLmAuZC5oLmwucC50LngufC6ALoQuiC6MLpAulC6YLpwuoC6kLqgurC6wLrQuuC68LsAux
-C7ILswu0C7ULtgu3C7oLvQvAVSRudWxs3xASAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAGgAbABwA
-HQAeAB8AIAAhACIAIwAkACUAJgAnACgAKQAqACsALAAtAC4ALwAwVk5TUm9vdFYkY2xhc3NdTlNPYmpl
-Y3RzS2V5c18QD05TQ2xhc3Nlc1ZhbHVlc18QGU5TQWNjZXNzaWJpbGl0eU9pZHNWYWx1ZXNdTlNDb25u
-ZWN0aW9uc1tOU05hbWVzS2V5c1tOU0ZyYW1ld29ya11OU0NsYXNzZXNLZXlzWk5TT2lkc0tleXNdTlNO
-YW1lc1ZhbHVlc18QGU5TQWNjZXNzaWJpbGl0eUNvbm5lY3RvcnNdTlNGb250TWFuYWdlcl8QEE5TVmlz
-aWJsZVdpbmRvd3NfEA9OU09iamVjdHNWYWx1ZXNfEBdOU0FjY2Vzc2liaWxpdHlPaWRzS2V5c1lOU05l
-eHRPaWRcTlNPaWRzVmFsdWVzgAKBAv2BAZuBAmCBAvyArYEB9oAFgQJfgQJhgQH3gQL6gACABoEB9YEC
-+xEBv4ECYtIADgAyADMANFtOU0NsYXNzTmFtZYAEgANdTlNBcHBsaWNhdGlvbtIANwA4ADkAOlgkY2xh
-c3Nlc1okY2xhc3NuYW1logA6ADteTlNDdXN0b21PYmplY3RYTlNPYmplY3RfEBBJQkNvY29hRnJhbWV3
-b3Jr0gAOAD4APwBAWk5TLm9iamVjdHOAK6EAQYAH2wBDAA4ARABFAEYARwBIAEkASgBLAEwATQBOAE8A
-UABRAFIAUwBUAFUAVgArXE5TV2luZG93Vmlld1xOU1NjcmVlblJlY3RfEBNOU0ZyYW1lQXV0b3NhdmVO
-YW1lXU5TV2luZG93VGl0bGVZTlNXVEZsYWdzXU5TV2luZG93Q2xhc3NcTlNXaW5kb3dSZWN0XxAPTlNX
-aW5kb3dCYWNraW5nXxARTlNXaW5kb3dTdHlsZU1hc2tbTlNWaWV3Q2xhc3OAC4CsgKqAq4AJEnQAAACA
-CoAIEAIQD4AAXxAYe3szMzUsIDQxM30sIHs3MjUsIDMzN319XxAQSVB5dGhvbjEgKENvY29hKVhOU1dp
-bmRvd9cAXAAOAF0AXgBfAFoAYABhAGIAYwBkAGUAYQBnXxAPTlNOZXh0UmVzcG9uZGVyWk5TU3Vidmll
-d3NYTlN2RmxhZ3NbTlNGcmFtZVNpemVbTlNTdXBlcnZpZXeADIBdgA0RAQCAqIAMgKnSAA4APgBpAGqA
-NKIAawBsgA6Ao9oAXAAOAG4AXQBeAG8AcABaAGAAcQBNAHMAdAB1AHYAdwBVAGEATQB6V05TRnJhbWVe
-TlNBdXRvc2F2ZU5hbWVeTlNEaXZpZGVyU3R5bGVcTlNJc1ZlcnRpY2FsgAuAooCggA8RARKAoYAMgAsJ
-0gAOAD4AaQB9gDSiAH4Af4AQgGreAFwAgQAOAIIAgwBdAF4AXwCEAFoAhQCGAGAAhwBrAIkAigCLAIwA
-jQCOAI8AkABhAJIAVQBrAJRZTlNCb3hUeXBlW05TVGl0bGVDZWxsXU5TVHJhbnNwYXJlbnRcTlNCb3Jk
-ZXJUeXBlWU5TT2Zmc2V0c18QD05TVGl0bGVQb3NpdGlvbl1OU0NvbnRlbnRWaWV3gA4QAIBpgGAIgBEQ
-FoBeEAGADIBfgA6AEtIADgA+AGkAl4A0oQCUgBLXAFwADgBuAF0AXgBaAGAAfgBiAJwAnQBkAGEAfoAQ
-gF2AXIATgAyAENIADgA+AGkAooA0oQCjgBTcAFwApQAOAG4ApgBdAF4AWgBgAKcAqACHAJQAqgCrAKwA
-rQCuAHYAYQCUALEAsgCyW05TSFNjcm9sbGVyWE5Tc0ZsYWdzW05TVlNjcm9sbGVyXU5TTmV4dEtleVZp
-ZXeAEoBYgFuAWhECEoAVgAyAEoBUgBaAFtIADgA+AGkAtoA0owCyALEAqoAWgFSAWN0AXAAOAG4AuwC8
-AL0AXQBeAL4AWgC/AGAAqACjAMEAwgDDAMQAxQDGAMcAyABhAMoAowDIWE5TQm91bmRzWE5TQ3Vyc29y
-WU5TY3ZGbGFnc1lOU0RvY1ZpZXdZTlNCR0NvbG9ygBSAU4BNgE6AUBAEgBcRCQCAGIAMgE+AFIAY0gAO
-AD4AaQDPgDShAMiAGN0AXAAOAG4A0gDTANQA1QBeANYAWgDXAGAA2ACyANoA2wDcAN0A3gDfAOAA4QBh
-AOMAsgArXxAPTlNUZXh0Q29udGFpbmVyWU5TVFZGbGFnc1xOU1NoYXJlZERhdGFbTlNEcmFnVHlwZXNZ
-TlNNYXhTaXplWE5TTWluaXplWk5TRGVsZWdhdGWAFoBMgCyALRAGgDeAGREJEoBKgAyAS4AWgADSAA4A
-PgA/AOiAK68QEQDpAOoA6wDsAO0A7gDvAPAA8QDyAPMA9AD1APYA9wD4APmAGoAbgByAHYAegB+AIIAh
-gCKAI4AkgCWAJoAngCiAKYAqXxAZTmVYVCBSVEZEIHBhc3RlYm9hcmQgdHlwZV8QEk5TU3RyaW5nUGJv
-YXJkVHlwZV8QGk5lWFQgcnVsZXIgcGFzdGVib2FyZCB0eXBlXxAeTmVYVCBUSUZGIHY0LjAgcGFzdGVi
-b2FyZCB0eXBlXxAZQXBwbGUgVVJMIHBhc3RlYm9hcmQgdHlwZV8QI0NvcmVQYXN0ZWJvYXJkRmxhdm9y
-VHlwZSAweDZENkY2Rjc2XxAjQ29yZVBhc3RlYm9hcmRGbGF2b3JUeXBlIDB4NzU3MjZDMjBfEBtXZWJV
-UkxzV2l0aFRpdGxlc1Bib2FyZFR5cGVfEBlBcHBsZSBQREYgcGFzdGVib2FyZCB0eXBlXxAZQXBwbGUg
-UE5HIHBhc3RlYm9hcmQgdHlwZV8QGkFwcGxlIEhUTUwgcGFzdGVib2FyZCB0eXBlXxAVTlNGaWxlbmFt
-ZXNQYm9hcmRUeXBlXxAXTlNDb2xvciBwYXN0ZWJvYXJkIHR5cGVfEDFOZVhUIEVuY2Fwc3VsYXRlZCBQ
-b3N0U2NyaXB0IHYxLjIgcGFzdGVib2FyZCB0eXBlXxAaQXBwbGUgUElDVCBwYXN0ZWJvYXJkIHR5cGVf
-EBlOZVhUIGZvbnQgcGFzdGVib2FyZCB0eXBlXxAqTmVYVCBSaWNoIFRleHQgRm9ybWF0IHYxLjAgcGFz
-dGVib2FyZCB0eXBl0gA3ADgBDAENowENAQ4AO1xOU011dGFibGVTZXRVTlNTZXRfEBR7ezAsIDM4fSwg
-ezQzMywgMTR9fdUBEQAOARIBEwEUAJABFQDIARcBGFlOU1RDRmxhZ3NaTlNUZXh0Vmlld1dOU1dpZHRo
-XxAPTlNMYXlvdXRNYW5hZ2VygDaAGCNAexAAAAAAAIAu1QAOARoBGwEcANgBHQEeAR8A3QArXxAQTlNU
-ZXh0Q29udGFpbmVyc11OU1RleHRTdG9yYWdlWU5TTE1GbGFnc4A1gDOAL4AA0wAOASIA2AEjASQAK1hO
-U1N0cmluZ4AygDCAANIADgEnASgBKVlOUy5zdHJpbmeAMVDSADcAOAErASyjASwBIgA7XxAPTlNNdXRh
-YmxlU3RyaW5n0gA3ADgBLgEbpAEbAS8BMAA7XxAZTlNNdXRhYmxlQXR0cmlidXRlZFN0cmluZ18QEk5T
-QXR0cmlidXRlZFN0cmluZ9IADgA+AGkBM4A0oQDcgC3SADcAOAE2ATejATcBOAA7Xk5TTXV0YWJsZUFy
-cmF5V05TQXJyYXnSADcAOAE6ARSiARQAO9IANwA4ATwA0qIA0gA72AAOAT4BPwFAAUEBQgFDAUQBRQFG
-ACsBSAFJAUoAKwFMV05TRmxhZ3NfEBdOU0RlZmF1bHRQYXJhZ3JhcGhTdHlsZV8QEE5TSW5zZXJ0aW9u
-Q29sb3JfEBFOU0JhY2tncm91bmRDb2xvcl8QFE5TU2VsZWN0ZWRBdHRyaWJ1dGVzXxASTlNNYXJrZWRB
-dHRyaWJ1dGVzXxAQTlNMaW5rQXR0cmlidXRlc4BJEgAFS2+AAIA6gDiAO4AAgEXTAA4BTgFPAVAAVQFR
-XE5TQ29sb3JTcGFjZVVOU1JHQoA5TxAYMSAwLjk1Mjk0MTI0IDAuODUwOTgwNDYA0gA3ADgBUwFUogFU
-ADtXTlNDb2xvctMADgFOAVYBUAFYAVlXTlNXaGl0ZYA5EANCMADTAA4BWwA+AVwBXQFgV05TLmtleXOA
-RKIBXgFfgDyAPaIBYQFigD6AQtUADgFUAU4BZAFlAVABZwDdAWgBaVtOU0NvbG9yTmFtZV1OU0NhdGFs
-b2dOYW1lgDmAQYBAgD9WU3lzdGVtXxAbc2VsZWN0ZWRUZXh0QmFja2dyb3VuZENvbG9y0wAOAU4BVgFQ
-AVgBboA5SzAuNjY2NjY2NjkA1QAOAVQBTgFkAWUBUAFIAN0BcgFpgDmAOoBDgD9fEBFzZWxlY3RlZFRl
-eHRDb2xvctIANwA4AXYBd6IBdwA7XE5TRGljdGlvbmFyedMADgFbAD4BXAF6AX2ARKIBewFfgEaAPaIB
-fgF/gEeASFtOU1VuZGVybGluZdMADgFOAU8BUACQAYOAOUYwIDAgMQDSADcAOAGFAYaiAYYAO18QFE5T
-VGV4dFZpZXdTaGFyZWREYXRhXHs0ODAsIDFlKzA3fVd7ODQsIDB90gA3ADgBigESpQESAYsBjAGNADtW
-TlNUZXh0Vk5TVmlld1tOU1Jlc3BvbmRlcl8QFHt7MSwgMX0sIHs0MzMsIDIzMX19XxAVe3swLCAzOH0s
-IHs0MzMsIDIzMX190wAOAU4BVgFQAVgBkoA5QjEA0wAOAZQBlQGWAZcAkFlOU0hvdFNwb3RcTlNDdXJz
-b3JUeXBlgFKAUVd7NCwgLTV90gA3ADgBmgC8ogC8ADvSADcAOAGcAZ2kAZ0BjAGNADtaTlNDbGlwVmll
-d9kAXAGfAA4AbgBeAFoBoABgAaEAowCjAaQBpQGmAGEBqACjAapYTlNUYXJnZXRYTlNBY3Rpb25ZTlNQ
-ZXJjZW50gBSAFIBXgFUT/////4AAAQCADIBWgBQjP9Ww0wAAAABfEBV7ezQyNywgMX0sIHsxNSwgMjYz
-fX1cX2RvU2Nyb2xsZXI60gA3ADgBrgGvpQGvAbABjAGNADtaTlNTY3JvbGxlcllOU0NvbnRyb2zbAFwB
-nwAOAG4ApgBeAFoBoABgAbIBoQCjAKMBpAG2AJAAZABhAagAowG6AbtaTlNDdXJWYWx1ZYAUgBSAV4BZ
-gAyAVoAUIz/wAAAAAAAAIz/uQshgAAAAXxAYe3stMTAwLCAtMTAwfSwgezg3LCAxOH19XxAWe3sxOCwg
-MTR9LCB7NDM1LCAyMzN9fdIANwA4Ab8BwKQBwAGMAY0AO1xOU1Njcm9sbFZpZXdfEBR7ezEsIDF9LCB7
-NDcxLCAyNTd9fdIANwA4AcMBjKMBjAGNADtaezQ3MywgMjczfVZ7MCwgMH3XAccADgFBAcgByQHKAcsB
-zAHNAc4BzwHQAIkB0VtOU0NlbGxGbGFnc1pOU0NvbnRlbnRzWU5TU3VwcG9ydFxOU0NlbGxGbGFnczJb
-TlNUZXh0Q29sb3ISBAH+AIBogGWAYYBigGdXQ29uc29sZdQADgHUAdUB1gHXAdgB2QHaVk5TU2l6ZVZO
-U05hbWVYTlNmRmxhZ3OAZCNAJgAAAAAAAIBjEQwcXEx1Y2lkYUdyYW5kZdIANwA4Ad0B3qIB3gA7Vk5T
-Rm9udNUADgFUAU4BZAFlAVAAygDdAeIBaYA5gE+AZoA/XxATdGV4dEJhY2tncm91bmRDb2xvctMADgFO
-AVYBUAFYAeeAOU0wIDAuODAwMDAwMDEA0gA3ADgB6QHqpAHqAesB7AA7XxAPTlNUZXh0RmllbGRDZWxs
-XE5TQWN0aW9uQ2VsbFZOU0NlbGzSADcAOAHuAe+kAe8BjAGNADtVTlNCb3jeAFwAgQAOAIIAbgCDAF0A
-XgCEAFoAhQCGAGAAhwBrAIkAigHzAfQAjAH2AfcAkABhAJIAVQBrAfuADoBpgJ2AnAiAaxAzgAyAX4AO
-gGzSAA4APgBpAf6ANKEB+4Bs1wBcAA4AbgBdAF4AWgBgAH8AYgIDAgQAZABhAH+AaoBdgJuAbYAMgGrS
-AA4APgBpAgmANKECCoBu3xAPAFwApQAOAG4ApgIMAg0AXQIOAF4AWgBgAKcAqACHAfsCEACrAhICEwIU
-AhUCFgIXAHYAYQH7AhoCGwIbXE5TQ29ybmVyVmlld18QEE5TSGVhZGVyQ2xpcFZpZXdcTlNTY3JvbGxB
-bXRzgGyAloBbgJoQMoB4gHWAb08QEEEgAABBIAAAQZgAAEGYAACADIBsgJSAcIBw0gAOAD4AaQIfgDSl
-AhsCGgIQAhUCFIBwgJSAloB1gHjbAFwADgBuAL0AXQBeAL4AWgC/AGAAqAIKAMECKADFAikAxwIqAGEC
-LAIKAiqAboBTgJOAcYBygAyAhoBugHLSAA4APgBpAjGANKECKoBy3xAVAFwCNAAOAjUCNgFBAjcCDAI4
-AjkCOgBeAF8COwBaAjwCPQBgAj4CPwJAAhsAiQJCAkMCRADKAHoCFAJIAMUCSQBkAkoAegBhAk0AkAIb
-Ak8AVgJQXxAfTlNEcmFnZ2luZ1NvdXJjZU1hc2tGb3JOb25Mb2NhbFlOU1R2RmxhZ3NcTlNIZWFkZXJW
-aWV3XxASTlNBbGxvd3NUeXBlU2VsZWN0XxAXTlNJbnRlcmNlbGxTcGFjaW5nV2lkdGhfEBlOU0NvbHVt
-bkF1dG9yZXNpemluZ1N0eWxlXxAYTlNJbnRlcmNlbGxTcGFjaW5nSGVpZ2h0WU5TRW5hYmxlZFtOU0dy
-aWRDb2xvcl8QD05TR3JpZFN0eWxlTWFza15OU1RhYmxlQ29sdW1uc18QHE5TRHJhZ2dpbmdTb3VyY2VN
-YXNrRm9yTG9jYWxbTlNSb3dIZWlnaHSAcICSE//////WwAAAgHSATwmAeCNACAAAAAAAACNAAAAAAAAA
-AIBzCYAMgI+AcIB7I0AxAAAAAAAAWnsxNTYsIDIwMH3XAFwADgBeAF8AWgBgAlMCFQJVAGQCVgBhAhUC
-KltOU1RhYmxlVmlld4B1gHeAdoAMgHWActsAXAAOAG4AvQBdAF4AvgBaAL8AYACoAgoAwQJdAMUCXgDH
-AkQAYQIsAgoCRIBugFOAmYCYgHSADICGgG6AdFl7MTU2LCAxN33SADcAOAJmAmekAmcBjAGNADtfEBFO
-U1RhYmxlSGVhZGVyVmlld9YAXAAOAG4AXgBaAGACCgJqAmsAZABhAgqAboB6gHmADIBuXxAUe3sxNTcs
-IDB9LCB7MTYsIDE3fX3SADcAOAJwAnGkAnEBjAGNADtdX05TQ29ybmVyVmlld9IADgA+AGkCdIA0ogJ1
-AnaAfICL2gJ4AA4CeQETAnoCewJ8An0CfgJTAHoCgAKBAoICgwFYAoQChQB6AipeTlNJc1Jlc2l6ZWFi
-bGVcTlNIZWFkZXJDZWxsWk5TRGF0YUNlbGxeTlNSZXNpemluZ01hc2taTlNNaW5XaWR0aFpOU01heFdp
-ZHRoXE5TSXNFZGl0YWJsZQmAioB9I0BRwAAAAAAAgIMjQEQAAAAAAAAjQI9AAAAAAAAJgHLXAccADgFB
-AcgByQHKAcsCiQKKAosCjAHQAIkCjhIEgf4AgIKAf4B+gGKAgFhWYXJpYWJsZdMADgFOAVYBUAFYApKA
-OUswLjMzMzMzMjk5ANUADgFUAU4BZAFlAVABSADdApYBaYA5gDqAgYA/XxAPaGVhZGVyVGV4dENvbG9y
-0gA3ADgCmgKbpQKbAeoB6wHsADtfEBFOU1RhYmxlSGVhZGVyQ2VsbNgBxwAOAUEByAHJAp0BygHLAp4B
-zQIsAqECogIqAqQCpV1OU0NvbnRyb2xWaWV3EhQh/kCAaICGgISAhYByEQgAgIhZVGV4dCBDZWxs1AAO
-AdQB1QHWAdcCqQHZAquAZCNAKgAAAAAAAIBjEQQU1QAOAVQBTgFkAWUBUAFnAN0CrwFpgDmAQYCHgD9f
-EBZjb250cm9sQmFja2dyb3VuZENvbG9y1QAOAVQBTgFkAWUBUAFIAN0CtQFpgDmAOoCJgD9fEBBjb250
-cm9sVGV4dENvbG9y0gA3ADgCuQK6ogK6ADtdTlNUYWJsZUNvbHVtbtoCeAAOAnkBEwJ6AnsCfAJ9An4C
-UwB6AoACvgK/AsABWAKEAoUAegIqCYCKgIwjQFPAAAAAAACAjgmActcBxwAOAUEByAHJAcoBywKJAooC
-iwLGAdAAiQKOgIKAf4CNgGKAgFVWYWx1ZdgBxwAOAUEByAHJAp0BygHLAp4BzQIsAqECogIqAqQCpYBo
-gIaAhICFgHKAiNUADgFUAU4BZAFlAVAC0wDdAtQBaYA5gJGAkIA/WWdyaWRDb2xvctMADgFOAVYBUAFY
-AtmAOUQwLjUA0gA3ADgC2wJTpQJTAbABjAGNADtfEBV7ezEsIDE3fSwgezE1NiwgMjAwfX3ZAFwBnwAO
-AG4AXgBaAaAAYAGhAgoCCgGkAuEAZABhAagCCgLlgG6AboBXgJWADIBWgG4jP+/gP4AAAABfEBZ7ezE1
-NywgMTd9LCB7MTUsIDIwMH192gBcAZ8ADgBuAKYAXgBaAaAAYAGhAgoCCgGkAusAkABkAGEBqAIKAu+A
-boBugFeAl4AMgFaAbiM/5vlvoAAAAF8QFXt7MSwgMjE3fSwgezE1NiwgMTV9fdIADgA+AGkC84A0oQJE
-gHRfEBN7ezEsIDB9LCB7MTU2LCAxN319XxAWe3sxOCwgMTR9LCB7MTczLCAyMzN9fV8QFHt7MSwgMX0s
-IHsyMDksIDI1N319XxAWe3s0NzQsIDB9LCB7MjExLCAyNzN9fdcBxwAOAUEByAHJAcoBywHMAc0BzgL8
-AdAAiQL+gGiAZYCegGKAn1lXb3Jrc3BhY2XTAA4BTgFWAVABWAHngDlfEBZ7ezIwLCA0NH0sIHs2ODUs
-IDI3M319XxAgaXB5dGhvbjFfY29uc29sZV93b3Jrc3BhY2Vfc3BsaXTSADcAOAMFAwakAwYBjAGNADtb
-TlNTcGxpdFZpZXfaAFwADgBuAwgDCQBeAFoDCgBgAwsATQMNAw4DDwMQAxEAYQMTAE0DFVpOU01heFZh
-bHVlWk5TTWluVmFsdWVZTlNwaUZsYWdzXE5TRHJhd01hdHJpeIALgKeApiNAWQAAAAAAACNAMAAAAAAA
-ABEFIYAMEXEKgAuApNEADgMXgKXSADcAOAMZAxqiAxoAO1pOU1BTTWF0cml4XxAVe3s2ODksIDIwfSwg
-ezE2LCAxNn190gA3ADgDHQMepAMeAYwBjQA7XxATTlNQcm9ncmVzc0luZGljYXRvclp7NzI1LCAzMzd9
-XxAVe3swLCAwfSwgezEyODAsIDc3OH19XxAQaXB5dGhvbjFfc2FuZGJveNIANwA4AyMDJKIDJAA7XxAQ
-TlNXaW5kb3dUZW1wbGF0ZdIADgA+AGkDJ4A0rxAvAygDKQMqAysDLAMtAy4DLwMwAzEDMgMzAzQDNQM2
-AzcDOAM5AzoDOwM8Az0DPgM/A0ADQQNCA0MDRANFA0YDRwNIA0kDSgNLA0wDTQNOA08DUANRA1IDUwNU
-A1UDVoCugLyAwoDIgM6A1IDZgN+A44DogOyA8YD2gPuBAQGBAQaBAQqBAQ+BARWBARqBAR+BASWBASqB
-AS+BATWBATmBAT2BAUKBAUOBAUiBAUqBAU+BAVSBAViBAVyBAV6BAWKBAWaBAWqBAW6BAXOBAXiBAX2B
-AY2BAZGBAZSBAZfTAA4DWANZA1oDWwNcWE5TU291cmNlV05TTGFiZWyAu4CvgLrYAA4DXgNfA2ADYQNi
-A2MDZANlA2YDZwNoA2kDagNrA2xXTlNUaXRsZV8QEU5TS2V5RXF1aXZNb2RNYXNrWk5TS2V5RXF1aXZd
-TlNNbmVtb25pY0xvY1lOU09uSW1hZ2VcTlNNaXhlZEltYWdlVk5TTWVudYC5gLESABAAAICyEn////+A
-s4C3gLDUAA4DXgHVA24DbwNwA3EDcltOU01lbnVJdGVtc4EBpIEByoEB2YEBzFhTaG93IEFsbNMADgAy
-A3UDdgN3A3heTlNSZXNvdXJjZU5hbWWAtoC0gLVXTlNJbWFnZV8QD05TTWVudUNoZWNrbWFya9IANwA4
-A3wDfaIDfQA7XxAQTlNDdXN0b21SZXNvdXJjZdMADgAyA3UDdgN3A4GAtoC0gLhfEBBOU01lbnVNaXhl
-ZFN0YXRl0gA3ADgDhAOFogOFADtaTlNNZW51SXRlbV8QFnVuaGlkZUFsbEFwcGxpY2F0aW9uczrSADcA
-OAOIA4mjA4kDigA7XxAVTlNOaWJDb250cm9sQ29ubmVjdG9yXk5TTmliQ29ubmVjdG9y0wAOA1gDWQNa
-A40DjoC7gL2AwdgADgNeA18DYANhA2IDYwNkA2UDkQNnA5IDaQNqA2sDlYC5gL+AwICzgLeAvtMADgNe
-A24DbwOYA5mBAaSBAauBAa1eQ2hlY2sgU3BlbGxpbmdRO15jaGVja1NwZWxsaW5nOtMADgNYA1kDWgOf
-A6CAu4DDgMfYAA4DXgNfA2ADYQNiA2MDZANlA6MDZwOkA2kDagNrA6eAuYDFgMaAs4C3gMTTAA4DXgNu
-A28DqgOrgQGkgQHbgQHdZgBQAHIAaQBuAHQgJlFwVnByaW50OtMADgNYA1kDWgOxA7KAu4DJgM3ZAA4D
-XgNfA2ADYQNiA2MDZAO0A2UDtgO3A7gDaQNqA2sDuwFYVU5TVGFngLmAyxIAEgAAgMyAs4C3gMrTAA4D
-XgNuA28DvgO/gQGkgQHAgQHCW1NtYXJ0IExpbmtzUUdfEB10b2dnbGVBdXRvbWF0aWNMaW5rRGV0ZWN0
-aW9uOtMADgNYA1kDWgPFA8aAu4DPgNPYAA4DXgNfA2ADYQNiA2MDZANlA8kDtwPKA2kDagNrA82AuYDR
-gNKAs4C3gNDTAA4DXgNuA28D0APRgQGkgQGvgQGxVFJlZG9RWlVyZWRvOtMADgNYA1kDWgPXA9iAu4DV
-gNjYAA4DXgNfA2ADYQNiA2MDZANlA9sDZwNoA2kDagNrA9+AuYDXgLKAs4C3gNbTAA4DXgNuA28D4gPj
-gQGkgQHEgQHGXlN0YXJ0IFNwZWFraW5nXnN0YXJ0U3BlYWtpbmc60wAOA1gDWQNaA+gD6YC7gNqA3tgA
-DgNeA18DYANhA2IDYwNkA2UD7ANnA+0DaQNqA2sD8IC5gNyA3YCzgLeA29MADgNeA24DbwPzA/SBAaSB
-AfGBAfNfEBRJUHl0aG9uMVNhbmRib3ggSGVscFE/WXNob3dIZWxwOtMADgNYA1kDWgP6A/uAu4DggOLY
-AA4DXgNfA2ADYQNiA2MDZANlA/4DZwNoA2kDagNrA5WAuYDhgLKAs4C3gL5fEBtDaGVjayBTcGVsbGlu
-ZyBXaGlsZSBUeXBpbmdfEB50b2dnbGVDb250aW51b3VzU3BlbGxDaGVja2luZzrTAA4DWANZA1oEBwQI
-gLuA5IDn2AAOA14DXwNgA2EDYgNjA2QDZQQLA2cEDANpA2oDawPNgLmA5YDmgLOAt4DQWlNlbGVjdCBB
-bGxRYVpzZWxlY3RBbGw60wAOA1gDWQNaBBUEFoC7gOmA69gADgNeA18DYANhA2IDYwNkA2UEGQNnA2gD
-aQNqA2sDlYC5gOqAsoCzgLeAvl8QG0NoZWNrIEdyYW1tYXIgV2l0aCBTcGVsbGluZ18QFnRvZ2dsZUdy
-YW1tYXJDaGVja2luZzrTAA4DWANZA1oEIgQjgLuA7YDw2AAOA14DXwNgA2EDYgNjA2QDZQQmA2cDaANp
-A2oDawQqgLmA74CygLOAt4Du0wAOA14DbgNvBC0ELoEBpIEB54EB6W8QEgBDAHUAcwB0AG8AbQBpAHoA
-ZQAgAFQAbwBvAGwAYgBhAHIgJl8QH3J1blRvb2xiYXJDdXN0b21pemF0aW9uUGFsZXR0ZTrTAA4DWANZ
-A1oEMwQ0gLuA8oD12AAOA14DXwNgA2EDYgNjA2QDZQQ3BDgEOQNpA2oDawQqgLmA8xIAGAAAgPSAs4C3
-gO5cU2hvdyBUb29sYmFyUXRfEBN0b2dnbGVUb29sYmFyU2hvd2460wAOA1gDWQNaBEIEQ4C7gPeA+tgA
-DgNeA18DYANhA2IDYwNkA2UERgNnBEcDaQNqA2sDp4C5gPiA+YCzgLeAxFRTYXZlUXNdc2F2ZURvY3Vt
-ZW50OtQADgRPA1gDWQRQBFEEUgRTXU5TRGVzdGluYXRpb26BAQCA/YD8gP/SAA4AMgAzADSABIAD0gAO
-ADIAMwRZgASA/l8QGklQeXRob24xU2FuZGJveEFwcERlbGVnYXRlWGRlbGVnYXRl0gA3ADgEXQReowRe
-A4oAO18QFE5TTmliT3V0bGV0Q29ubmVjdG9y0wAOA1gDWQNaBGEEYoC7gQECgQEF2QAOA14DXwNgA2ED
-YgNjA2QDtANlBGUDZwRmA2kDagNrA7sAVYC5gQEDgQEEgLOAt4DKXFNtYXJ0IFF1b3Rlc1FnXxAhdG9n
-Z2xlQXV0b21hdGljUXVvdGVTdWJzdGl0dXRpb2461AAOBE8DWANZBFAEbwRRBHGBAQCBAQeA/YEBCdIA
-DgAyADMEdIAEgQEIXxAWSVB5dGhvbkNvY29hQ29udHJvbGxlcl8QEWlweXRob25Db250cm9sbGVy0wAO
-A1gDWQNaBHkEeoC7gQELgQEO2AAOA14DXwNgA2EDYgNjA2QDZQR9A2cEfgNpA2oDawNsgLmBAQyBAQ2A
-s4C3gLBfEBRRdWl0IElQeXRob24xU2FuZGJveFFxWnRlcm1pbmF0ZTrTAA4DWANZA1oEhwSIgLuBARCB
-ARTYAA4DXgNfA2ADYQNiA2MDZANlBIsDZwSMA2kDagNrBI+AuYEBEoEBE4CzgLeBARHUAA4DXgHVA24D
-bwSSBJMElIEBpIEB64EB74EB7VhNaW5pbWl6ZVFtXxATcGVyZm9ybU1pbmlhdHVyaXplOtMADgNYA1kD
-WgSaBJuAu4EBFoEBGdgADgNeA18DYANhA2IDYwNkA2UEngNnBJ8DaQNqA2sDzYC5gQEXgQEYgLOAt4DQ
-VFVuZG9RelV1bmRvOtMADgNYA1kDWgSoBKmAu4EBG4EBHtgADgNeA18DYANhA2IDYwNkA2UErANnBK0D
-aQNqA2sDlYC5gQEcgQEdgLOAt4C+bgBTAGgAbwB3ACAAUwBwAGUAbABsAGkAbgBnICZROl8QD3Nob3dH
-dWVzc1BhbmVsOtMADgNYA1kDWgS2BLeAu4EBIIEBJNgADgNeA18DYANhA2IDYwNkA2UEugO3BLsDaQNq
-A2sEvoC5gQEigQEjgLOAt4EBIdMADgNeA24DbwTBBMKBAaSBAZ+BAaFbU2hvdyBDb2xvcnNRQ18QFW9y
-ZGVyRnJvbnRDb2xvclBhbmVsOtMADgNYA1kDWgTIBMmAu4EBJoEBKdgADgNeA18DYANhA2IDYwNkA2UE
-zAQ4BM0DaQNqA2sDbIC5gQEngQEogLOAt4CwW0hpZGUgT3RoZXJzUWhfEBZoaWRlT3RoZXJBcHBsaWNh
-dGlvbnM60wAOA1gDWQNaBNYE14C7gQErgQEu2AAOA14DXwNgA2EDYgNjA2QDZQTaA2cE2wNpA2oDawPN
-gLmBASyBAS2As4C3gNBUQ29weVFjVWNvcHk60wAOA1gDWQNaBOQE5YC7gQEwgQE02QAOA14DXwNgA2ED
-YgNjA2QDtANlBOgDZwTpA2kDagNrBOwAkIC5gQEygQEzgLOAt4EBMdMADgNeA24DbwTvBPCBAaSBAbWB
-AbdlAEYAaQBuAGQgJlFmXxAXcGVyZm9ybUZpbmRQYW5lbEFjdGlvbjrTAA4DWANZA1oE9gT3gLuBATaB
-ATjYAA4DXgNfA2ADYQNiA2MDZANlBPoDZwNoA2kDagNrA9+AuYEBN4CygLOAt4DWXVN0b3AgU3BlYWtp
-bmddc3RvcFNwZWFraW5nOtQADgRPA1gDWQNaAB8FBAUFgLuAAoEBOoEBPNcADgNeA2ADYQNiA2MDZANl
-BQgDaANpA2oDawNsgLmBATuAsoCzgLeAsF8QFUFib3V0IElQeXRob24xU2FuZGJveF8QHW9yZGVyRnJv
-bnRTdGFuZGFyZEFib3V0UGFuZWw60wAOA1gDWQNaBREFEoC7gQE+gQFB2QAOBRQDXgNfA2ADYQNiA2MD
-ZANlA2gFFwO3BRgDaQNqA2sDp1lOU1Rvb2xUaXCAuYCygQE/gQFAgLOAt4DEXVBhZ2UgU2V0dXAuLi5R
-UF5ydW5QYWdlTGF5b3V0OtQADgRPA1gDWQRQBG8AQQRTgQEAgQEHgAeA/9MADgNYA1kDWgUmBSeAu4EB
-RIEBR9gADgNeA18DYANhA2IDYwNkA2UFKgNnBSsDaQNqA2sDzYC5gQFFgQFGgLOAt4DQVVBhc3RlUXZW
-cGFzdGU61AAOBE8DWANZBFAAyABBBTaBAQCAGIAHgQFJXxAVaW5pdGlhbEZpcnN0UmVzcG9uZGVy0wAO
-A1gDWQNaBToFO4C7gQFLgQFO2AAOA14DXwNgA2EDYgNjA2QDZQU+A2cFPwNpA2oDawTsgLmBAUyBAU2A
-s4C3gQExXxARSnVtcCB0byBTZWxlY3Rpb25Ral8QHWNlbnRlclNlbGVjdGlvbkluVmlzaWJsZUFyZWE6
-0wAOA1gDWQNaBUgFSYC7gQFQgQFT2AAOA14DXwNgA2EDYgNjA2QDZQVMA2cDaANpA2oDawVQgLmBAVKA
-soCzgLeBAVHUAA4DXgHVA24DbwVTBVQFVYEBpIEBpYEBp4EBplpDbGVhciBNZW51XxAVY2xlYXJSZWNl
-bnREb2N1bWVudHM60wAOA1gDWQNaBVoFW4C7gQFVgQFX2AAOA14DXwNgA2EDYgNjA2QDZQVeA2cDaANp
-A2oDawPNgLmBAVaAsoCzgLeA0FZEZWxldGVXZGVsZXRlOtMADgNYA1kDWgVnBWiAu4EBWYEBW9cADgNe
-A2ADYQNiA2MDZANlBWsDaANpA2oDawOngLmBAVqAsoCzgLeAxF8QD1JldmVydCB0byBTYXZlZF8QFnJl
-dmVydERvY3VtZW50VG9TYXZlZDrUAA4ETwNYA1kEUADIBG8FdoEBAIAYgQEHgQFdWHRleHRWaWV30wAO
-A1gDWQNaBXoFe4C7gQFfgQFh2AAOA14DXwNgA2EDYgNjA2QDZQV+A2cDaANpA2oDawSPgLmBAWCAsoCz
-gLeBARFfEBJCcmluZyBBbGwgdG8gRnJvbnRfEA9hcnJhbmdlSW5Gcm9udDrTAA4DWANZA1oFhwWIgLuB
-AWOBAWXYAA4DXgNfA2ADYQNiA2MDZANlBYsDZwTNA2kDagNrA2yAuYEBZIEBKICzgLeAsF8QFEhpZGUg
-SVB5dGhvbjFTYW5kYm94VWhpZGU60wAOA1gDWQNaBZQFlYC7gQFngQFp2AAOA14DXwNgA2EDYgNjA2QD
-ZQWYA2cDaANpA2oDawSPgLmBAWiAsoCzgLeBARFUWm9vbVxwZXJmb3JtWm9vbTrTAA4DWANZA1oFoQWi
-gLuBAWuBAW3ZAA4DXgNfA2ADYQNiA2MDZAO0A2UFpQNnBOkDaQNqA2sDuwCQgLmBAWyBATOAs4C3gMpf
-EBBTbWFydCBDb3B5L1Bhc3RlXxAYdG9nZ2xlU21hcnRJbnNlcnREZWxldGU60wAOA1gDWQNaBa4Fr4C7
-gQFvgQFy2AAOA14DXwNgA2EDYgNjA2QDZQWyA7cFswNpA2oDawOngLmBAXCBAXGAs4C3gMRoAFMAYQB2
-AGUAIABBAHMgJlFTXxAPc2F2ZURvY3VtZW50QXM60wAOA1gDWQNaBbwFvYC7gQF0gQF32AAOA14DXwNg
-A2EDYgNjA2QDZQXAA2cFwQNpA2oDawPNgLmBAXWBAXaAs4C3gNBTQ3V0UXhUY3V0OtMADgNYA1kDWgXK
-BcuAu4EBeYEBfNgADgNeA18DYANhA2IDYwNkA2UFzgNnBc8DaQNqA2sDp4C5gQF6gQF7gLOAt4DEVUNs
-b3NlUXddcGVyZm9ybUNsb3NlOtcADgRPBdcF2ANYA1kF2QXaBFEF3AXdBd4F3wBVWU5TS2V5UGF0aFlO
-U0JpbmRpbmdfEBxOU05pYkJpbmRpbmdDb25uZWN0b3JWZXJzaW9ugQGMgP2BAYuBAYqBAX6BAYnbBeEA
-DgXiBeMF5AXlBeYF5wXoBekF6gB6BewAegXuAHoF8AXxAHoAegB6BfVfEBpOU0ZpbHRlclJlc3RyaWN0
-c0luc2VydGlvbl8QFE5TUHJlc2VydmVzU2VsZWN0aW9uXE5TSW5pdGlhbEtleVpOU0VkaXRhYmxlXk5T
-RGVjbGFyZWRLZXlzXk5TSW5pdGlhbFZhbHVlXxAiTlNDbGVhcnNGaWx0ZXJQcmVkaWNhdGVPbkluc2Vy
-dGlvbl8QGE5TU2VsZWN0c0luc2VydGVkT2JqZWN0c18QFk5TQXZvaWRzRW1wdHlTZWxlY3Rpb25fEBFO
-U1NvcnREZXNjcmlwdG9ycwmBAYgJgQGBCYEBf4EBggkJCYEBg9IADgA+AGkF+IA0owX5Be4F8YEBgIEB
-gYEBglRrZXlzU2tleVV2YWx1ZdIADgA+BgAGAYEBh6EGAoEBhNQADgYEBgUGBgYHBe4GCQB6VU5TS2V5
-Wk5TU2VsZWN0b3JbTlNBc2NlbmRpbmeBAYaBAYGBAYUJWGNvbXBhcmU60gA3ADgGDQYOogYOADtfEBBO
-U1NvcnREZXNjcmlwdG9y0gA3ADgGEAE4ogE4ADvSADcAOAYSBhOlBhMGFAYVBhYAO18QFk5TRGljdGlv
-bmFyeUNvbnRyb2xsZXJfEBFOU0FycmF5Q29udHJvbGxlcl8QEk5TT2JqZWN0Q29udHJvbGxlclxOU0Nv
-bnRyb2xsZXJfEClmaWx0ZXJQcmVkaWNhdGU6IHdvcmtzcGFjZUZpbHRlclByZWRpY2F0ZV8QD2ZpbHRl
-clByZWRpY2F0ZV8QGHdvcmtzcGFjZUZpbHRlclByZWRpY2F0ZdIANwA4BhsGHKMGHAOKADtfEBVOU05p
-YkJpbmRpbmdDb25uZWN0b3LXAA4ETwXXBdgDWANZBdkF2gRvBiAGIQXeBiMAVYEBjIEBB4EBkIEBj4EB
-foEBjl8QGWNvbnRlbnREaWN0aW9uYXJ5OiB1c2VyTlNfEBFjb250ZW50RGljdGlvbmFyeVZ1c2VyTlPX
-AA4ETwXXBdgDWANZBdkF2gXeBioF8QJ2Bi0AVYEBjIEBfoEBk4EBgoCLgQGSXxAcdmFsdWU6IGFycmFu
-Z2VkT2JqZWN0cy52YWx1ZV8QFWFycmFuZ2VkT2JqZWN0cy52YWx1ZdcADgRPBdcF2ANYA1kF2QXaBd4G
-MwXxAnUGNgBVgQGMgQF+gQGWgQGCgHyBAZVfEBp2YWx1ZTogYXJyYW5nZWRPYmplY3RzLmtleV8QE2Fy
-cmFuZ2VkT2JqZWN0cy5rZXnXAA4ETwXXBdgDWANZBdkF2gRvBjwGPQBsBj8AVYEBjIEBB4EBmoEBmYCj
-gQGYXxAZYW5pbWF0ZTogd2FpdGluZ0ZvckVuZ2luZVdhbmltYXRlXxAQd2FpdGluZ0ZvckVuZ2luZdIA
-DgA+BgAGRYEBh68QZwZGAGsE5AVaBkoCwAVQBk0CgwZPBlAE1gZSBlMGVARCAE0AfgPwA7sEBwT2A7EE
-FQP6AgoAfwNsBJoGYwOnAEECKgTIA1sEeQPfBSYFegRSBm4EbwPoAMgF3gWuBnQE7AONBUgGeAZ5BGED
-nwOVA80GfgQqBoAEUQaCBREEMwIaBoYGhwaIBokAqgaLBCIFBASoA9cAbAWHBcoCRAaUA8UGlgJ2ALEF
-OgS+BpsFvAJ1Bp4FZwagBIcFoQS2AKMGpQIQBqcGqAWUBqoGqwSPgQGcgA6BATCBAVWBAZ2AjoEBUYEB
-qICDgQGqgQGugQErgQGygQGegQG/gPeAC4AQgNuAyoDkgQE2gMmA6YDggG6AaoCwgQEWgQHYgMSAB4By
-gQEmgK+BAQuA1oEBRIEBX4D8gQHVgQEHgNqAGIEBfoEBb4EB6oEBMYC9gQFQgQHlgQHugQECgMOAvoDQ
-gQG4gO6BAeGA/YEBzoEBPoDygJSBAbyBAcmBAd6BAeaAWIEBtIDtgQE6gQEbgNWAo4EBY4EBeYB0gQHN
-gM+BAdqAi4BUgQFLgQEhgQHwgQF0gHyBAbOBAVmBAcOBARCBAWuBASCAFIEB0YCWgQHSgQGigQFngQG6
-gQHkgQER2gAOA14DXwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA2xdTlNJc1NlcGFyYXRv
-clxOU0lzRGlzYWJsZWSAuYCyCYCyCYCzgLeAsNoADga5A14DXwNgA2EDYgNjA2QBoANlBL4EwQNnA2gD
-aQNqA2sGUwbBWU5TU3VibWVudYC5gQEhgQGfgLKAs4C3gQGegQGg1AAOA14B1QNuA28GxAbFBsaBAaSB
-AceBAfSBAchWRm9ybWF0XnN1Ym1lbnVBY3Rpb2460gAOAD4AaQbLgDSiBqgEtoEBooEBINgADgNeA18D
-YANhA2IDYwNkA2UG0ANnBDkDaQNqA2sEvoC5gQGjgPSAs4C3gQEhWlNob3cgRm9udHPSADcAOAbXA2Si
-A2QAO1tPcGVuIFJlY2VudNIADgA+AGkG24A0oQVIgQFQXxAWX05TUmVjZW50RG9jdW1lbnRzTWVuddoA
-Dga5A14DXwNgA2EDYgNjA2QBoANlBVAFUwNnA2gDaQNqA2sDpwbmgLmBAVGBAaWAsoCzgLeAxIEBqdoA
-Dga5A14DXwNgA2EDYgNjA2QBoANlA5UDmANnA2gDaQNqA2sDzQbvgLmAvoEBq4CygLOAt4DQgQGsXxAU
-U3BlbGxpbmcgYW5kIEdyYW1tYXLSAA4APgBpBvOANKQEqAONA/oEFYEBG4C9gOCA6doADga5A14DXwNg
-A2EDYgNjA2QBoANlA80D0ANnA2gDaQNqA2sGUwcAgLmA0IEBr4CygLOAt4EBnoEBsFRFZGl00gAOAD4A
-aQcEgDStBJoDxQZSBbwE1gUmBVoEBwaeBosGTwZUBqCBARaAz4EBsoEBdIEBK4EBRIEBVYDkgQGzgQG0
-gQGqgQG/gQHD2gAOA14DXwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA82AuYCyCYCyCYCz
-gLeA0NoADgNeA18GrgNgBq8DYQNiA2MDZANlA2gDZwB6A2gAegNpA2oDawPNgLmAsgmAsgmAs4C3gNDa
-AA4GuQNeA18DYANhA2IDYwNkAaADZQTsBO8DZwNoA2kDagNrA80HLIC5gQExgQG1gLKAs4C3gNCBAbZU
-RmluZNIADgA+AGkHMIA0pQTkBn4GqgaGBTqBATCBAbiBAbqBAbyBAUvZAA4DXgNfA2ADYQNiA2MDZAO0
-A2UHOANnBGYDaQNqA2sE7ABVgLmBAbmBAQSAs4C3gQExWUZpbmQgTmV4dNkADgNeA18DYANhA2IDYwNk
-A7QDZQdAA7cDuANpA2oDawTsAViAuYEBu4DMgLOAt4EBMV1GaW5kIFByZXZpb3Vz2QAOA14DXwNgA2ED
-YgNjA2QDtANlB0gDZwdJA2kDagNrBOwHTYC5gQG9gQG+gLOAt4EBMRAHXxAWVXNlIFNlbGVjdGlvbiBm
-b3IgRmluZFFl2gAOBrkDXgNfA2ADYQNiA2MDZAGgA2UDuwO+A2cDaANpA2oDawPNB1iAuYDKgQHAgLKA
-s4C3gNCBAcFdU3Vic3RpdHV0aW9uc9IADgA+AGkHXIA0owWhBGEDsYEBa4EBAoDJ2gAOBrkDXgNfA2AD
-YQNiA2MDZAGgA2UD3wPiA2cDaANpA2oDawPNB2iAuYDWgQHEgLKAs4C3gNCBAcVWU3BlZWNo0gAOAD4A
-aQdsgDSiA9cE9oDVgQE2WUFNYWluTWVuddIADgA+AGkHcoA0pwaHBpYGUAZKBokGdAabgQHJgQHagQGu
-gQGdgQHmgQHqgQHw2gAOBrkDXgNfA2ADYQNiA2MDZAGgA2UDbANwA2cDaANpA2oDawZTB4KAuYCwgQHK
-gLKAs4C3gQGegQHLXxAPSVB5dGhvbjFTYW5kYm940gAOAD4AaQeGgDSrBQQGlAaCBqUGpwZGBYcEyANb
-BmMEeYEBOoEBzYEBzoEB0YEB0oEBnIEBY4EBJoCvgQHYgQEL2gAOA14DXwauA2AGrwNhA2IDYwNkA2UD
-aANnAHoDaAB6A2kDagNrA2yAuYCyCYCyCYCzgLeAsNgADgNeA18DYANhA2IDYwNkA2UHnQNnB54DaQNq
-A2sDbIC5gQHPgQHQgLOAt4CwbABQAHIAZQBmAGUAcgBlAG4AYwBlAHMgJlEs2gAOA14DXwauA2AGrwNh
-A2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA2yAuYCyCYCyCYCzgLeAsNoADga5A14DXwNgA2EDYgNjA2QB
-oANlBm4HsANnA2gDaQNqA2sDbAe1gLmBAdWBAdOAsoCzgLeAsIEB1FhTZXJ2aWNlc9QADgNeAdUDbgNv
-B7AHuge7gQGkgQHTgQHXgQHW0gAOAD4AaQe+gDSgXxAPX05TU2VydmljZXNNZW512gAOA14DXwauA2AG
-rwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA2yAuYCyCYCyCYCzgLeAsFxfTlNBcHBsZU1lbnXaAA4G
-uQNeA18DYANhA2IDYwNkAaADZQOnA6oDZwNoA2kDagNrBlMH0oC5gMSBAduAsoCzgLeBAZ6BAdxURmls
-ZdIADgA+AGkH1oA0qwaIBoAGTQarBcoEQgWuBWcGeAURA5+BAd6BAeGBAaiBAeSBAXmA94EBb4EBWYEB
-5YEBPoDD2AAOA14DXwNgA2EDYgNjA2QDZQfkA2cH5QNpA2oDawOngLmBAd+BAeCAs4C3gMRTTmV3UW7Y
-AA4DXgNfA2ADYQNiA2MDZANlB+0DZwfuA2kDagNrA6eAuYEB4oEB44CzgLeAxGUATwBwAGUAbiAmUW/a
-AA4DXgNfBq4DYAavA2EDYgNjA2QDZQNoA2cAegNoAHoDaQNqA2sDp4C5gLIJgLIJgLOAt4DE2gAOA14D
-XwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrA6eAuYCyCYCyCYCzgLeAxNoADga5A14DXwNg
-A2EDYgNjA2QBoANlBCoELQNnA2gDaQNqA2sGUwgOgLmA7oEB54CygLOAt4EBnoEB6FRWaWV30gAOAD4A
-aQgSgDSiBDMEIoDygO3aAA4GuQNeA18DYANhA2IDYwNkAaADZQSPBJIDZwNoA2kDagNrBlMIHYC5gQER
-gQHrgLKAs4C3gQGegQHsVldpbmRvd9IADgA+AGkIIYA0pASHBZQGeQV6gQEQgQFngQHugQFf2gAOA14D
-XwauA2AGrwNhA2IDYwNkA2UDaANnAHoDaAB6A2kDagNrBI+AuYCyCYCyCYCzgLeBARFeX05TV2luZG93
-c01lbnXaAA4GuQNeA18DYANhA2IDYwNkAaADZQPwA/MDZwNoA2kDagNrBlMIOIC5gNuBAfGAsoCzgLeB
-AZ6BAfJUSGVscNIADgA+AGkIPIA0oQPogNpbX05TTWFpbk1lbnXSAA4APgYACEGBAYevEGcDbABNBOwD
-zQZTAnYGTQOnAnUDzQZTA80DzQAfA80DpwBBAGsGmwZUA80D3wO7A5UDlQB/AGsGhwPNA2wGlgAfAgoD
-bANsA2wGoAPNBI8AHwanAB8D8ACjAB8DpwZTBosDlQVQA6cEjwO7A6cGTwZQBOwGiQOnAB8DbAOnBCoC
-CgTsBlMDpwZTAKMDzQQqA2wDlQPfAE0DbAOnAgoDbAPNBlMCKgCjBOwGSgZTA80CKgPNA6cDzQSPA7sE
-vgB+A2wCCgNsBL4EjwTsA6cGdICwgAuBATGA0IEBnoCLgQGogMSAfIDQgQGegNCA0IACgNCAxIAHgA6B
-AfCBAb+A0IDWgMqAvoC+gGqADoEByYDQgLCBAdqAAoBugLCAsICwgQHDgNCBARGAAoEB0oACgNuAFIAC
-gMSBAZ6BAbSAvoEBUYDEgQERgMqAxIEBqoEBroEBMYEB5oDEgAKAsIDEgO6AboEBMYEBnoDEgQGegBSA
-0IDugLCAvoDWgAuAsIDEgG6AsIDQgQGegHKAFIEBMYEBnYEBnoDQgHKA0IDEgNCBARGAyoEBIYAQgLCA
-boCwgQEhgQERgQExgMSBAerSAA4APgYACKuBAYevEGgAawZGBOQFWgZKAsAFUAZNAoMGTwZQBNYGUgZT
-BlQATQRCAH4D8AO7BAcE9gOxBBUCCgP6AH8DbABBA6cEmgZjAioEyANbBHkD3wUmBXoEUgZuBG8D6ADI
-Bd4AHwWuBnQGeATsA40FSAZ5BGEDnwOVA80EKgZ+BoAEUQaCBREEMwIaBoYGhwaJBogAqgaLBCIFBABs
-BKgD1wWHBcoCRAaUA8UGlgJ2ALEEvgU6BpsFvAJ1Bp4FZwagBIcFoQS2AKMGpQIQBqcGqAWUBqoGqwSP
-gA6BAZyBATCBAVWBAZ2AjoEBUYEBqICDgQGqgQGugQErgQGygQGegQG/gAuA94AQgNuAyoDkgQE2gMmA
-6YBugOCAaoCwgAeAxIEBFoEB2IBygQEmgK+BAQuA1oEBRIEBX4D8gQHVgQEHgNqAGIEBfoACgQFvgQHq
-gQHlgQExgL2BAVCBAe6BAQKAw4C+gNCA7oEBuIEB4YD9gQHOgQE+gPKAlIEBvIEByYEB5oEB3oBYgQG0
-gO2BATqAo4EBG4DVgQFjgQF5gHSBAc2Az4EB2oCLgFSBASGBAUuBAfCBAXSAfIEBs4EBWYEBw4EBEIEB
-a4EBIIAUgQHRgJaBAdKBAaKBAWeBAbqBAeSBARHSAA4APgYACRaBAYevEGgJFwkYCRkJGgkbCRwJHQke
-CR8JIAkhCSIJIwkkCSUJJgknCSgJKQkqCSsJLAktCS4JLwkwCTEJMgkzCTQJNQk2CTcJOAk5CToJOwk8
-CT0JPgk/CUAJQQlCCUMJRAlFCUYJRwlICUkJSglLCUwJTQlOCU8JUAlRCVIEWQlUCVUJVglXCVgJWQla
-CVsJXAldCV4JXwlgCWEJYgljCWQJZQlmCWcJaAlpCWoJawlsCW0JbglvCXAJcQlyCXMJdAl1CXYJdwl4
-CXkJegl7CXwJfQl+gQH4gQH5gQH6gQH7gQH8gQH9gQH+gQH/gQIAgQIBgQICgQIDgQIEgQIFgQIGgQIH
-gQIIgQIJgQIKgQILgQIMgQINgQIOgQIPgQIQgQIRgQISgQITgQIUgQIVgQIWgQIXgQIYgQIZgQIagQIb
-gQIcgQIdgQIegQIfgQIggQIhgQIigQIjgQIkgQIlgQImgQIngQIogQIpgQIqgQIrgQIsgQItgQIugQIv
-gQIwgQIxgQIygQIzgP6BAjSBAjWBAjaBAjeBAjiBAjmBAjqBAjuBAjyBAj2BAj6BAj+BAkCBAkGBAkKB
-AkOBAkSBAkWBAkaBAkeBAkiBAkmBAkqBAkuBAkyBAk2BAk6BAk+BAlCBAlGBAlKBAlOBAlSBAlWBAlaB
-AleBAliBAlmBAlqBAluBAlyBAl2BAl5aU3BsaXQgVmlld1tTZXBhcmF0b3ItM28QEQBNAGUAbgB1ACAA
-SQB0AGUAbQAgACgARgBpAG4AZCAmAClfEBJNZW51IEl0ZW0gKERlbGV0ZSlfEBJNZW51IEl0ZW0gKEZv
-cm1hdClfEBtUZXh0IEZpZWxkIENlbGwgKFRleHQgQ2VsbClfEBJNZW51IChPcGVuIFJlY2VudClfEBdN
-ZW51IEl0ZW0gKE9wZW4gUmVjZW50KV8QHVRleHQgRmllbGQgQ2VsbCAoVGV4dCBDZWxsKS0xXxAgTWVu
-dSBJdGVtIChTcGVsbGluZyBhbmQgR3JhbW1hcilfEBBNZW51IEl0ZW0gKEVkaXQpXxAQTWVudSBJdGVt
-IChDb3B5KVlTZXBhcmF0b3JYTWFpbk1lbnVfEBlNZW51IEl0ZW0gKFN1YnN0aXR1dGlvbnMpXENvbnRl
-bnQgVmlld1EzXUJveCAoQ29uc29sZSlRMl8QFE1lbnUgKFN1YnN0aXR1dGlvbnMpXxAWTWVudSBJdGVt
-IChTZWxlY3QgQWxsKV8QGU1lbnUgSXRlbSAoU3RvcCBTcGVha2luZylfEBdNZW51IEl0ZW0gKFNtYXJ0
-IExpbmtzKV8QJ01lbnUgSXRlbSAoQ2hlY2sgR3JhbW1hciBXaXRoIFNwZWxsaW5nKV1TY3JvbGwgVmll
-dy0xXxAnTWVudSBJdGVtIChDaGVjayBTcGVsbGluZyBXaGlsZSBUeXBpbmcpXxAPQm94IChXb3Jrc3Bh
-Y2UpXxAWTWVudSAoSVB5dGhvbjFTYW5kYm94KV8QGVdpbmRvdyAoSVB5dGhvbjEgKENvY29hKSlbTWVu
-dSAoRmlsZSlfEBBNZW51IEl0ZW0gKFVuZG8pW1NlcGFyYXRvci00XxAcVGFibGUgVmlldyAoVmFyaWFi
-bGUsIFZhbHVlKV8QF01lbnUgSXRlbSAoSGlkZSBPdGhlcnMpXxAUTWVudSBJdGVtIChTaG93IEFsbClU
-MTExMV1NZW51IChTcGVlY2gpXxARTWVudSBJdGVtIChQYXN0ZSlfEB5NZW51IEl0ZW0gKEJyaW5nIEFs
-bCB0byBGcm9udClbQXBwbGljYXRpb25fEA9NZW51IChTZXJ2aWNlcylfEBdQeXRob24gQ29jb2EgQ29u
-dHJvbGxlcl8QIE1lbnUgSXRlbSAoSVB5dGhvbjFTYW5kYm94IEhlbHApWVRleHQgVmlld18QGVVzZXIg
-TmFtZXNwYWNlIENvbnRyb2xsZXJcRmlsZSdzIE93bmVyUThfEBJNZW51IEl0ZW0gKFdpbmRvdylTMi0x
-W01lbnUgKEZpbmQpXxAaTWVudSBJdGVtIChDaGVjayBTcGVsbGluZylfEBZNZW51IEl0ZW0gKENsZWFy
-IE1lbnUpW1NlcGFyYXRvci0yXxAYTWVudSBJdGVtIChTbWFydCBRdW90ZXMpUTZfEBtNZW51IChTcGVs
-bGluZyBhbmQgR3JhbW1hcilbTWVudSAoRWRpdClbTWVudSAoVmlldylfEBVNZW51IEl0ZW0gKEZpbmQg
-TmV4dClvEBEATQBlAG4AdQAgAEkAdABlAG0AIAAoAE8AcABlAG4gJgApUzEyMVE1XxAYTWVudSBJdGVt
-IChTaG93IFRvb2xiYXIpXxATVmVydGljYWwgU2Nyb2xsZXItMV8QIk1lbnUgSXRlbSAoVXNlIFNlbGVj
-dGlvbiBmb3IgRmluZClfEBtNZW51IEl0ZW0gKElQeXRob24xU2FuZGJveClfEBBNZW51IEl0ZW0gKFZp
-ZXcpUTlfEBNIb3Jpem9udGFsIFNjcm9sbGVyXxAQTWVudSBJdGVtIChGaW5kKW8QHgBNAGUAbgB1ACAA
-SQB0AGUAbQAgACgAQwB1AHMAdABvAG0AaQB6AGUAIABUAG8AbwBsAGIAYQByICYAKV8QIU1lbnUgSXRl
-bSAoQWJvdXQgSVB5dGhvbjFTYW5kYm94KVxBc3luYyBBcnJvd3NvEBoATQBlAG4AdQAgAEkAdABlAG0A
-IAAoAFMAaABvAHcAIABTAHAAZQBsAGwAaQBuAGcgJgApXxAaTWVudSBJdGVtIChTdGFydCBTcGVha2lu
-ZylfECBNZW51IEl0ZW0gKEhpZGUgSVB5dGhvbjFTYW5kYm94KVMxLTFfEBFUYWJsZSBIZWFkZXIgVmll
-d1tTZXBhcmF0b3ItNV8QEE1lbnUgSXRlbSAoUmVkbylfEBBNZW51IEl0ZW0gKEZpbGUpXxAUVGFibGUg
-Q29sdW1uIChWYWx1ZSlfEBFWZXJ0aWNhbCBTY3JvbGxlcl1NZW51IChGb3JtYXQpXxAdTWVudSBJdGVt
-IChKdW1wIHRvIFNlbGVjdGlvbilRMV8QD01lbnUgSXRlbSAoQ3V0KV8QF1RhYmxlIENvbHVtbiAoVmFy
-aWFibGUpW1NlcGFyYXRvci0xUjEwXxASTWVudSBJdGVtIChTcGVlY2gpXxAUTWVudSBJdGVtIChNaW5p
-bWl6ZSlfEBxNZW51IEl0ZW0gKFNtYXJ0IENvcHkvUGFzdGUpXxAXTWVudSBJdGVtIChTaG93IENvbG9y
-cylbU2Nyb2xsIFZpZXdbU2VwYXJhdG9yLTZfEBVIb3Jpem9udGFsIFNjcm9sbGVyLTFfEBRNZW51IEl0
-ZW0gKFNlcnZpY2VzKV8QFk1lbnUgSXRlbSAoU2hvdyBGb250cylfEBBNZW51IEl0ZW0gKFpvb20pXxAZ
-TWVudSBJdGVtIChGaW5kIFByZXZpb3VzKVE3XU1lbnUgKFdpbmRvdynSAA4APgYACeiBAYeg0gAOAD4G
-AAnrgQGHoNIADgA+BgAJ7oEBh68QlwZGAGsDUATkBVoGSgM8Az8CwAVQBk0DLQNHA1UCgwNEBk8GUAMr
-A08E1gZSAygDSAZTBlQEQgBNAH4D8AO7BAcE9gOxA0kEFQP6AgoAfwNsBJoGYwOnAEECKgTIA0EDWwNG
-BHkD3wNKBSYFegRSAzQDTgNUA1EDMgM3A00GbgRvA+gAyAXeAB8FrgZ0BOwDjQVIBngDMQM6BnkEYQOf
-AzsDlQPNAzkGfgQqAykGgARRBoIFEQQzAhoDOANFAyoGhgMwBocGiAaJAKoGiwQiAywFBASoA9cAbAWH
-A0wFygM2AkQGlAPFBpYCdgNCAzMDLgCxBToEvgabBbwCdQaeBWcGoAM1Az0EhwNLBaEEtgM+AKMDUgal
-AhADVganBqgDQANDBZQGqgMvA1MGqwSPgQGcgA6BAXOBATCBAVWBAZ2BAR+BAS+AjoEBUYEBqIDUgQFP
-gQGUgIOBAUOBAaqBAa6AyIEBboEBK4EBsoCugQFUgQGegQG/gPeAC4AQgNuAyoDkgQE2gMmBAViA6YDg
-gG6AaoCwgQEWgQHYgMSAB4BygQEmgQE5gK+BAUqBAQuA1oEBXIEBRIEBX4D8gPaBAWqBAZGBAXiA7IEB
-BoEBZoEB1YEBB4DagBiBAX6AAoEBb4EB6oEBMYC9gQFQgQHlgOiBARWBAe6BAQKAw4EBGoC+gNCBAQ+B
-AbiA7oC8gQHhgP2BAc6BAT6A8oCUgQEKgQFIgMKBAbyA44EByYEB3oEB5oBYgQG0gO2AzoEBOoEBG4DV
-gKOBAWOBAWKBAXmBAQGAdIEBzYDPgQHagIuBAT2A8YDZgFSBAUuBASGBAfCBAXSAfIEBs4EBWYEBw4D7
-gQElgQEQgQFegQFrgQEggQEqgBSBAX2BAdGAloEBl4EB0oEBooEBNYEBQoEBZ4EBuoDfgQGNgQHkgQER
-0gAOAD4GAAqIgQGHrxCXCokKigqLCowKjQqOCo8KkAqRCpIKkwqUCpUKlgqXCpgKmQqaCpsKnAqdCp4K
-nwqgCqEKogqjCqQKpQqmCqcKqAqpCqoKqwqsCq0KrgqvCrAKsQqyCrMKtAq1CrYKtwq4CrkKugq7CrwK
-vQq+Cr8KwArBCsIKwwrECsUKxgrHCsgKyQrKCssKzArNCs4KzwrQCtEK0grTCtQK1QrWCtcK2ArZCtoK
-2wrcCt0K3grfCuAK4QriCuMK5ArlCuYK5wroCukK6grrCuwK7QruCu8K8ArxCvIK8wr0CvUK9gr3CvgK
-+Qr6CvsK/Ar9Cv4K/wsACwELAgsDCwQLBQsGCwcLCAsJCwoLCwsMCw0LDgsPCxALEQsSCxMLFAsVCxYL
-FwsYCxkLGgsbCxwLHQseCx+BAmOBAmSBAmWBAmaBAmeBAmiBAmmBAmqBAmuBAmyBAm2BAm6BAm+BAnCB
-AnGBAnKBAnOBAnSBAnWBAnaBAneBAniBAnmBAnqBAnuBAnyBAn2BAn6BAn+BAoCBAoGBAoKBAoOBAoSB
-AoWBAoaBAoeBAoiBAomBAoqBAouBAoyBAo2BAo6BAo+BApCBApGBApKBApOBApSBApWBApaBApeBApiB
-ApmBApqBApuBApyBAp2BAp6BAp+BAqCBAqGBAqKBAqOBAqSBAqWBAqaBAqeBAqiBAqmBAqqBAquBAqyB
-Aq2BAq6BAq+BArCBArGBArKBArOBArSBArWBAraBAreBAriBArmBArqBAruBAryBAr2BAr6BAr+BAsCB
-AsGBAsKBAsOBAsSBAsWBAsaBAseBAsiBAsmBAsqBAsuBAsyBAs2BAs6BAs+BAtCBAtGBAtKBAtOBAtSB
-AtWBAtaBAteBAtiBAtmBAtqBAtuBAtyBAt2BAt6BAt+BAuCBAuGBAuKBAuOBAuSBAuWBAuaBAueBAuiB
-AumBAuqBAuuBAuyBAu2BAu6BAu+BAvCBAvGBAvKBAvOBAvSBAvWBAvaBAveBAviBAvkQkBEBpRDkENEQ
-yhEBKxEBaRDxEQGeEH0QfBDpEH8RAawRAZ8Q4hDYENkRAWURAWsQxRDOEQFyEOsQHREBXBBLEQF0EQGk
-EGoRAV0QxhDDEQFiEQFsEQFaENsRAZcRAZYQORDPEJUQUREBcxEBmxCREI4QlhD1EIgQ1BEBvBDLEAUT
-//////////0RAWoRAWMRAasQwREBbREBuRDwEIIRAaYQbxEBoxEBgREBvhBQEBMQ3BDJEH4QShEBWxDf
-EFwRAV8QThDmEMgQzRAlENARASgQ4RBIEQF1EIEQTREBKREBmREBcREBvRBWEN0Q6BA4EFIRAScRAaIQ
-2hEBKhDnEDoQzBDEEQG0EIYRAW8QSREBZBEBmBDsENcQUxEBnRBXEQFuEQFoEQGhENIRASwQZxDHEQGc
-ENYQcBDTEQF2EQFwEBcQJxEBXhEBWRDgEQGgEQG4EI8RAZoRAbUQgxEBWBDjEQGtEO8Q1RDeEQGoEE8Q
-GNIADgA+AGkLuYA0oNIADgA+BgALvIEBh6DSAA4APgYAC7+BAYeg0gA3ADgLwQvCogvCADteTlNJQk9i
-amVjdERhdGEACAAZACIAJwAxADoAPwBEAFIAVABmBmYGbAa3Br4GxQbTBuUHAQcPBxsHJwc1B0AHTgdq
-B3gHiwedB7cHwQfOB9AH0wfWB9kH3AfeB+EH4wfmB+kH7AfvB/EH8wf2B/kH/Af/CAgIFAgWCBgIJggv
-CDgIQwhICFcIYAhzCHwIhwiJCIwIjgi7CMgI1QjrCPkJAwkRCR4JMAlECVAJUglUCVYJWAlaCV8JYQlj
-CWUJZwlpCYQJlwmgCb0JzwnaCeMJ7wn7Cf0J/woBCgQKBgoICgoKEwoVChoKHAoeCkcKTwpeCm0Kegp8
-Cn4KgAqCCoUKhwqJCosKjAqVCpcKnAqeCqAK2QrjCu8K/QsKCxQLJgs0CzYLOAs6CzwLPQs/C0ELQwtF
-C0cLSQtLC00LVgtYC1sLXQt6C3wLfguAC4ILhAuGC48LkQuUC5YLxwvTC9wL6Av2C/gL+gv8C/4MAQwD
-DAUMBwwJDAsMDQwWDBgMHwwhDCMMJQxaDGMMbAx2DIAMigyMDI4MkAySDJQMlgyYDJsMnQyfDKEMowyl
-DK4MsAyzDLUM6gz8DQYNEw0fDSkNMg09DT8NQQ1DDUUNRw1JDUsNTg1QDVINVA1WDVgNYQ1jDYgNig2M
-DY4NkA2SDZQNlg2YDZoNnA2eDaANog2kDaYNqA2qDcYN2w34DhkONQ5bDoEOnw67DtcO9A8MDyYPWg93
-D5MPwA/JD9AP3Q/jD/oQDxAZECQQLBA+EEAQQhBLEE0QYhB1EIMQjRCPEJEQkxCVEKIQqxCtEK8QsRC6
-EMQQxhDHENAQ1xDpEPIQ+xEXESwRNRE3EToRPBFFEUwRWxFjEWwRcRF6EX8RoBGoEcIR1RHpEgASFRIo
-EioSLxIxEjMSNRI3EjkSOxJIElUSWxJdEngSgRKGEo4SmxKjEqUSpxKqErcSvxLBEsYSyBLKEs8S0RLT
-EugS9BMCEwQTBhMIEwoTERMvEzwTPhNKE18TYRNjE2UTZxN7E4QTiROWE6MTpROqE6wTrhOzE7UTtxPD
-E9AT0hPZE+IT5xP+FAsUExQcFCcULhQ1FEEUWBRwFH0UfxSCFI8UmRSmFKgUqhSyFLsUwBTJFNIU3RUC
-FQsVFBUeFSAVIhUkFSYVLxUxFTMVNRU+FVYVYxVsFXcVghWMFbkVxBXGFcgVyhXMFc4V0BXSFdsV5BX/
-FhgWIRYqFjcWThZXFl4WaRZwFo0WmRakFq4WuxbHFswWzhbQFtIW1BbWFt4W7xb2Fv0XBhcIFxEXExcW
-FyMXLBcxFzgXTRdPF1EXUxdVF2sXeBd6F4gXkReaF6wXuRfAF8kX0hfYGBEYExgVGBcYGRgaGBwYHhgg
-GCIYJBgmGC8YMRg0GDYYUxhVGFcYWRhbGF0YXxhoGGoYbRhvGK4YuxjOGNsY3RjfGOEY4xjlGOcY6Rjr
-GP4ZABkCGQQZBhkIGREZExkeGSAZIhkkGSYZKBlVGVcZWRlbGV0ZXxlhGWMZZRlnGXAZchl1GXcZzhnw
-GfoaBxocGjYaUhptGncagxqVGqQawxrPGtEa0xrcGt4a4BrhGuMa7Br1Gvca+Br6Gvwa/hsAGwkbFBsx
-Gz0bPxtBG0MbRRtHG0kbdht4G3obfBt+G4AbghuEG4YbiBuSG5sbpBu4G9Eb0xvVG9cb2RvbG/Ib+xwE
-HBIcGxwdHCIcJBwmHE8cXhxrHHYchRyQHJscqBypHKscrRy2HLgcwRzKHMsczRzqHO8c8RzzHPUc9xz5
-HQIdDx0RHR0dMh00HTYdOB06HUwdVR1gHXQdlR2jHagdqh2sHa4dsB2yHbUdtx3BHdId1B3dHd8d4h33
-Hfkd+x39Hf8eGB4tHi8eMR4zHjUeSB5RHlYeZB6NHo4ekB6SHpsenR6eHqAevR6/HsEewx7FHscezR7u
-HvAe8h70HvYe+B76Hw8fER8THxUfFx8hHy4fMB81Hz4fSR9hH4YfiB+KH4wfjh+QH5IflB+dH7Yf3x/h
-H+Mf5R/nH+kf6x/tH/YgDiAXIBkgHCAeIDQgTSBkIH0gmiCcIJ4goCCiIKQgriC7IL0g1iD5IQIhCyEX
-IUAhSyFWIWAhbSFvIXEhcyF8IYUhiCGKIY0hjyGRIZYhmCGhIaYhsSHJIdIh2yHxIfwiFCInIjAiNSJI
-IlEiUyK0IrYiuCK6IrwiviLAIsIixCLGIsgiyiLMIs4i0CLTItYi2SLcIt8i4iLlIugi6yLuIvEi9CL3
-Ivoi/SMAIwMjBiMJIwwjDyMSIxUjGCMbIx4jISMkIycjKiMtIzAjMyNAI0kjUSNTI1UjVyN4I4AjlCOf
-I60jtyPEI8sjzSPPI9Qj1iPbI90j3yPhI/Ij/iQBJAQkByQKJBMkICQvJDEkMyQ1JD0kTyRYJF0kcCR9
-JH8kgSSDJJYknySkJK8kyCTRJNgk8CT/JQwlDiUQJRIlMyU1JTclOSU7JT0lPyVMJU8lUiVVJWQlZiV1
-JYIlhCWGJYglqSWrJa0lryWxJbMltSXCJcUlyCXLJdgl2iXhJe4l8CXyJfQmGSYfJiEmIyYoJiomLCYu
-JjAmPSZAJkMmRiZSJlQmdCaBJoMmhSaHJqgmqiasJq4msCayJrQmwSbEJscmyibPJtEm1ybkJuYm6Cbq
-JwsnDScPJxEnEycVJxcnJCcnJyonLSc8J0snWCdaJ1wnXid/J4EngyeFJ4cniSeLJ5gnmyeeJ6EnuCe6
-J8Qn0SfTJ9Un1yf4J/on/Cf+KAAoAigEKCIoQyhQKFIoVChWKHcoeSh7KH0ofyiBKIMojiiQKJsoqCiq
-KKworijPKNEo0yjVKNco2SjbKPkpEikfKSEpIyklKUYpSClKKUwpTilQKVIpXyliKWUpaCmPKbEpvinA
-KcIpxCnlKecp6SnuKfAp8in0KfYqAyoFKhsqKCoqKiwqLipPKlEqUypVKlcqWSpbKmAqYipwKoEqjyqS
-KpQqliqYKqEqoyqlKq4qsCqyKs8q2CrhKugq/ysMKw4rESsUKzkrOys+K0ErQytFK0crVCtWK3oriyuO
-K5ErkyuWK58roSukK70r0SveK+Ar4yvmLAcsCSwMLA8sESwTLBUsLCwuLDksRixILEssTixvLHEsdCx3
-LHkseyx+LI8skiyVLJgsmyykLKYsvCzJLMsszizRLPIs9Cz3LPos/Cz+LQAtBS0HLQ0tGi0cLR8tIi1D
-LUUtSC1LLU0tTy1RLW4tcC2CLY8tkS2ULZctuC26Lb0twC3CLcQtxy3ULdct2i3dLekt6y4DLhAuEi4V
-LhguOS47Lj4uQS5DLkUuRy5TLlUubi57Ln0ugC6DLqQupi6pLqwuri6wLrIuty65Lr8uzC7OLtEu1C75
-Lvsu/i8BLwMvBS8ILxUvGC8bLx4vKS8rL0UvUi9UL1cvWi97L30vgC+CL4Qvhi+IL5YvpC+1L7cvuS+8
-L78v3C/eL+Ev4y/lL+cv6TABMCEwLjAwMDMwNjBbMGUwZzBpMGwwbzBxMHMwdTCDMIUwlDClMKgwqzCt
-MK8wvDC+MMEwxDDlMOcw6jDtMO8w8TDzMPkw+zECMRMxFjEYMRoxHTE1MUIxRDFHMUoxazFtMXAxczF1
-MXcxejGOMZAxsDG9Mb8xwjHFMeYx6DHrMe0x7zHxMfQyBTIIMgsyDjIRMhwyNDJBMkMyRjJJMmoybDJv
-MnEyczJ1MncyfjKGMpMylTKYMpsyuDK6Mr0yvzLBMsMyxTLXMvAzATMEMwYzCTMMMxUzIjMkMyczKjNL
-M00zUDNSM1QzVjNZM24zgDONM48zkjOVM7YzuDO7M74zwDPCM8Qz2zPhM+4z8DPzM/Y0FzQZNBw0HjQg
-NCI0JTQqNDc0RDRGNEk0TDRxNHM0djR5NHs0fTR/NJI0rTS6NLw0vzTCNOM05TToNOs07TTvNPE1AjUE
-NRY1IzUlNSg1KzVMNU41UTVUNVY1WDVaNV41YDVlNXI1dDV3NXo1mzWdNaA1ozWlNac1qTWvNbE1vzXc
-NeY18DYPNhI2FDYXNho2HTYgNk02ajaBNo42mTaoNrc23Db3NxA3JDclNyg3KTcsNy03MDczNzQ3NTc2
-Nzk3QjdEN0s3TjdRN1Q3WTddN2M3bDdvN3I3dTeGN4w3lzejN6Y3qTesN603tje/N8Q31zfgN+U37jf5
-OBI4Jjg7OEg4dDiGOKE4qjixOMk45jjpOOw47zjyOPU4+DkUOSg5LzlMOU85UjlVOVg5WjldOXw5lDmx
-ObQ5tzm6Ob05vznCOd859ToSOhU6GDobOh46IDojOj86RzpaOmM6Zjs3Ozo7PDs/O0I7RTtHO0o7TTtP
-O1I7VTtYO1s7XjthO2M7ZTtnO2k7azttO3A7cjt0O3Y7eDt6O3w7fzuCO4Q7hjuIO4s7jTuQO5I7lTuY
-O5o7nTugO6I7pDunO6o7rTuwO7I7tTu4O7s7vjvAO8I7xDvHO8k7zDvOO9E71DvWO9g72zveO+E75Dvm
-O+k76zvuO/E78zv1O/g7+zv9PAA8AjwFPAc8CTwMPA88EjwVPBc8GjwdPCA8IzwmPCk8KzwuPDA8Mzw2
-PDk8PDw/PEI8azx5PIY8iDyKPIs8jTyOPJA8kjyUPL08xzzJPMw8zzzRPNM81TzYPNs87DzvPPI89Tz4
-PP89Dj0XPRk9Hj0hPSQ9RT1HPUo9TD1OPVA9Uz1ePWc9bD14PYE9gz2GPYk9oj3LPc090D3TPdU91z3Z
-Pds93j4HPgk+Cz4OPhA+Ej4UPhY+GT4wPjk+Oz5EPkc+ST5LPk0+dj54Pno+fT5/PoE+gz6GPok+jj6X
-Ppk+tD63Prk+vD6/PsI+xT7IPso+zT7QPtM+1j7ZPwI/BD8GPwc/CT8KPww/Dj8QPzk/Oz89Pz4/QD9B
-P0M/RT9HP3A/cj91P3g/ej98P34/gD+DP4g/kT+TP54/oT+kP6c/qj+tP9I/1D/XP9o/3D/eP+E/60AQ
-QBJAFUAXQBlAG0AeQCxAUUBTQFZAWUBbQF1AYEBiQHtAfUCmQKhAqkCtQK9AsUCzQLVAuEDGQM9A0UDY
-QNtA3kDgQQlBC0ENQRBBEkEUQRZBGEEbQSJBK0EtQTJBNEE3QUFBSkFMQVtBXkFhQWRBZ0FqQW1BcEGZ
-QZtBnUGgQaJBpEGmQalBrEG+QcdByUHgQeNB5kHpQexB70HyQfVB+EH6Qf1CAEIpQitCLUIuQjBCMUIz
-QjVCN0JYQlpCXUJgQmJCZEJmQn9CgUKqQqxCrkKvQrFCskK0QrZCuELhQuNC5kLpQutC7ULvQvFC9EL9
-Qw5DEUMUQxdDGkMjQyVDJkM4Q2FDY0NlQ2ZDaENpQ2tDbUNvQ3xDpUOnQ6lDrEOuQ7BDskO1Q7hDvUPG
-Q8hD30PiQ+VD6EPrQ+5D8EPzQ/ZD+UP8Q/5EH0QhRCREJ0QpRCtELUQxRDNEVERWRFlEXEReRGBEYkRt
-RG9EmESaRJxEnUSfRKBEokSkRKZEz0TRRNNE1ETWRNdE2UTbRN1FBkUIRQpFDUUPRRFFE0UWRRlFHkUn
-RSlFLkUwRTJFW0VdRWBFY0VlRWdFaUVsRW9FdkV/RYFFikWNRZBFk0WWRb9FwUXDRcRFxkXHRclFy0XO
-Rd1GBkYIRgpGDUYPRhFGE0YWRhlGHkYnRilGLEYuRjpGQ0ZGRxdHGUcbRx5HIEcjRyVHKEcqRyxHLkcx
-RzNHNUc3RzlHO0c9Rz9HQkdFR0dHSUdLR01HT0dRR1NHVkdYR1pHXUdfR2FHY0dlR2dHakdsR29HcUd0
-R3ZHeEd6R3xHfkeBR4RHhkeJR4tHjkeQR5JHlUeYR5tHnkegR6JHpEemR6hHqketR7BHske1R7dHuUe7
-R71Hv0fBR8NHxUfHR8lHy0fNR9BH0kfUR9dH2kfdR99H4UfjR+VH50fqR+xH70fxR/NH9Uf3R/pH/UgA
-SAJIBUgOSBFI5EjmSOlI7EjvSPJI9Ej3SPpI/Ej/SQJJBUkISQtJDkkQSRJJFEkWSRhJGkkdSR9JIUkj
-SSVJJ0kpSStJLUkwSTNJNUk4STpJPUk/SUJJRUlHSUpJTUlPSVFJVElWSVlJXElfSWJJZElnSWpJbUlv
-SXFJc0l1SXhJe0l9SYBJg0mFSYdJikmNSZBJk0mVSZhJmkmdSZ9JokmkSadJqkmsSa9JsUm0SbZJuEm7
-Sb5JwUnEScZJyUnMSc9J0knVSdhJ2kndSd9J4knlSehJ60nuSfFJ+kn9StBK00rWStlK3ErfSuJK5Uro
-SutK7krxSvRK90r6Sv1LAEsDSwZLCUsMSw9LEksVSxhLG0seSyFLJEsnSypLLUswSzNLNks5SzxLP0tC
-S0VLSEtLS05LUUtUS1dLWktdS2BLY0tmS2lLbEtvS3JLdUt4S3tLfkuBS4RLhkuJS4xLj0uSS5VLmEub
-S55LoUukS6dLqkutS7BLs0u2S7lLvEu/S8JLxUvIS8tLzkvRS9RL10vaS91L4EvjS+ZL6UvsS+9L8kv1
-S/hL+0v+TAFMBEwHTBJMHkxDTFhMbUyLTKBMukzaTP1NEE0jTS1NNk1STV9NYU1vTXFNiE2hTb1N104B
-Tg9OOU5LTmROgE6MTp9Oq07KTuRO+08ATw5PIk9DT09PYU97T55PqE/ET9FP00/oT+xP+FAVUC5QOlBV
-UFdQdVCBUI1QpVDKUM5Q0FDrUQFRJlFEUVdRWVFvUYJRwVHlUfJSKVJGUmlSbVKBUo1SoFKzUspS3lLs
-UwxTDlMgUzpTRlNJU15TdVOUU65TulPGU95T9VQOVCFUPVQ/VE1UVlRZVFpUY1RmVGdUcFRzVaRVp1Wp
-VaxVr1WyVbVVuFW7Vb1VwFXDVcVVyFXLVc1V0FXTVdZV2FXbVd5V4VXjVeZV6VXsVe5V8FXyVfRV9lX4
-VftV/VYAVgJWBFYGVghWClYNVhBWElYUVhZWGVYcVh5WIVYkViZWKVYsVi9WMVYzVjZWOVY8Vj5WQVZE
-VkdWSlZMVk5WUVZTVlZWWVZcVl5WYVZkVmZWaVZsVm9WcVZ0VnZWeFZ7Vn5WgFaCVoVWh1aKVo1Wj1aR
-VpRWl1aZVpxWnlahVqRWp1apVqxWrlawVrNWtla4VrpWvVbAVsNWxlbIVstWzVbQVtJW1VbXVtlW21be
-VuFW5FbnVulW7FbvVvJW9Fb3VvpW/VcAVwNXBlcIVwtXDlcQVxNXFlcZVxxXH1ciVyVXJ1cqVy1XMFc5
-VzxYbVhwWHNYdlh5WHxYf1iCWIVYiFiLWI5YkViUWJdYmlidWKBYo1imWKlYrFivWLJYtVi4WLtYvljB
-WMRYx1jKWM1Y0FjTWNZY2VjcWN9Y4ljlWOhY61juWPFY9Fj3WPpY/VkAWQNZBlkJWQxZD1kSWRVZGFkb
-WR5ZIVkkWSdZKlktWTBZM1k2WTlZPFk/WUJZRVlIWUtZTllRWVRZV1laWV1ZYFljWWZZaVlsWW9Zcll1
-WXhZe1l+WYFZhFmHWYpZjVmQWZNZllmZWZxZn1miWaVZqFmrWa5ZsVm0WbdZulm9WcBZw1nGWclZzFnP
-WdJZ1VnYWdtZ3lnhWeRZ51nqWe1Z8FnzWfZZ+Vn8Wf9aAloFWghaC1oOWhFaFFoXWhpaHVogWiNaJlop
-WixaL1oyWjRaN1o5WjtaPVpAWkNaRVpIWkpaTFpOWlBaU1pWWlhaWlpcWl9aYlpkWmZaaVprWm1acFpy
-WnVaeFp6Wn1af1qBWoRah1qKWoxaj1qSWpRallqYWppanVqgWqJapFqmWqhaqlqsWq9asVqzWrxav1rC
-WsVax1rKWs1az1rRWtRa1lrZWtxa31rhWuNa5VrnWula61ruWvBa8lr1Wvda+Vr7Wv1a/1sBWwRbBlsI
-WwtbDVsPWxJbFVsYWxtbHVsfWyFbI1slWyhbK1stWzBbMls0WzZbOFs7Wz1bQFtCW0VbSFtKW0xbTltR
-W1NbVltZW1xbXlthW2NbZVtoW2pbbFtuW3FbdFt2W3hbe1t+W4Bbg1uGW4hbi1uOW5Bbk1uVW5hbmluc
-W55boVujW6VbrluwW7Fbulu9W75bx1vKW8tb1FvZAAAAAAAAAgIAAAAAAAALwwAAAAAAAAAAAAAAAAAA
-W+g</bytes>
-		</object>
-	</data>
-</archive>
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox.xcodeproj/project.pbxproj b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox.xcodeproj/project.pbxproj
deleted file mode 100644
index 92dec61d753..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,293 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 44;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		77631A270C06C501005415CB /* Python.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 77631A260C06C501005415CB /* Python.framework */; };
-		77631A3F0C0748CF005415CB /* main.py in Resources */ = {isa = PBXBuildFile; fileRef = 77631A3E0C0748CF005415CB /* main.py */; };
-		7790198F0C07548A00326F66 /* IPython1SandboxAppDelegate.py in Resources */ = {isa = PBXBuildFile; fileRef = 7790198E0C07548A00326F66 /* IPython1SandboxAppDelegate.py */; };
-		77C8C1F90C07829500965286 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 77C8C1F70C07829500965286 /* MainMenu.xib */; };
-		8D11072B0486CEB800E47090 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C165CFE840E0CC02AAC07 /* InfoPlist.strings */; };
-		8D11072D0486CEB800E47090 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 29B97316FDCFA39411CA2CEA /* main.m */; settings = {ATTRIBUTES = (); }; };
-		8D11072F0486CEB800E47090 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		089C165DFE840E0CC02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = /System/Library/Frameworks/Cocoa.framework; sourceTree = "<absolute>"; };
-		13E42FB307B3F0F600E4EEF1 /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = /System/Library/Frameworks/CoreData.framework; sourceTree = "<absolute>"; };
-		29B97316FDCFA39411CA2CEA /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = "<group>"; };
-		29B97324FDCFA39411CA2CEA /* AppKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AppKit.framework; path = /System/Library/Frameworks/AppKit.framework; sourceTree = "<absolute>"; };
-		29B97325FDCFA39411CA2CEA /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = /System/Library/Frameworks/Foundation.framework; sourceTree = "<absolute>"; };
-		32CA4F630368D1EE00C91783 /* IPython1Sandbox_Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IPython1Sandbox_Prefix.pch; sourceTree = "<group>"; };
-		4CA32F870D8879B100311764 /* IPythonCocoaController Tests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "IPythonCocoaController Tests-Info.plist"; sourceTree = "<group>"; };
-		77631A260C06C501005415CB /* Python.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Python.framework; path = /System/Library/Frameworks/Python.framework; sourceTree = "<absolute>"; };
-		77631A3E0C0748CF005415CB /* main.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = main.py; sourceTree = "<group>"; };
-		7790198E0C07548A00326F66 /* IPython1SandboxAppDelegate.py */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.python; path = IPython1SandboxAppDelegate.py; sourceTree = "<group>"; };
-		77C8C1F80C07829500965286 /* English */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = English; path = English.lproj/MainMenu.xib; sourceTree = "<group>"; };
-		8D1107310486CEB800E47090 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
-		8D1107320486CEB800E47090 /* IPython1Sandbox.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = IPython1Sandbox.app; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		8D11072E0486CEB800E47090 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D11072F0486CEB800E47090 /* Cocoa.framework in Frameworks */,
-				77631A270C06C501005415CB /* Python.framework in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		080E96DDFE201D6D7F000001 /* Classes */ = {
-			isa = PBXGroup;
-			children = (
-				7790198E0C07548A00326F66 /* IPython1SandboxAppDelegate.py */,
-			);
-			name = Classes;
-			sourceTree = "<group>";
-		};
-		1058C7A0FEA54F0111CA2CBB /* Linked Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				77631A260C06C501005415CB /* Python.framework */,
-				1058C7A1FEA54F0111CA2CBB /* Cocoa.framework */,
-			);
-			name = "Linked Frameworks";
-			sourceTree = "<group>";
-		};
-		1058C7A2FEA54F0111CA2CBB /* Other Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				29B97324FDCFA39411CA2CEA /* AppKit.framework */,
-				13E42FB307B3F0F600E4EEF1 /* CoreData.framework */,
-				29B97325FDCFA39411CA2CEA /* Foundation.framework */,
-			);
-			name = "Other Frameworks";
-			sourceTree = "<group>";
-		};
-		19C28FACFE9D520D11CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				8D1107320486CEB800E47090 /* IPython1Sandbox.app */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		29B97314FDCFA39411CA2CEA /* IPython1Sandbox */ = {
-			isa = PBXGroup;
-			children = (
-				080E96DDFE201D6D7F000001 /* Classes */,
-				29B97315FDCFA39411CA2CEA /* Other Sources */,
-				29B97317FDCFA39411CA2CEA /* Resources */,
-				29B97323FDCFA39411CA2CEA /* Frameworks */,
-				19C28FACFE9D520D11CA2CBB /* Products */,
-				4CA32F870D8879B100311764 /* IPythonCocoaController Tests-Info.plist */,
-			);
-			name = IPython1Sandbox;
-			sourceTree = "<group>";
-		};
-		29B97315FDCFA39411CA2CEA /* Other Sources */ = {
-			isa = PBXGroup;
-			children = (
-				32CA4F630368D1EE00C91783 /* IPython1Sandbox_Prefix.pch */,
-				29B97316FDCFA39411CA2CEA /* main.m */,
-				77631A3E0C0748CF005415CB /* main.py */,
-			);
-			name = "Other Sources";
-			sourceTree = "<group>";
-		};
-		29B97317FDCFA39411CA2CEA /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				77C8C1F70C07829500965286 /* MainMenu.xib */,
-				8D1107310486CEB800E47090 /* Info.plist */,
-				089C165CFE840E0CC02AAC07 /* InfoPlist.strings */,
-			);
-			name = Resources;
-			sourceTree = "<group>";
-		};
-		29B97323FDCFA39411CA2CEA /* Frameworks */ = {
-			isa = PBXGroup;
-			children = (
-				1058C7A0FEA54F0111CA2CBB /* Linked Frameworks */,
-				1058C7A2FEA54F0111CA2CBB /* Other Frameworks */,
-			);
-			name = Frameworks;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		8D1107260486CEB800E47090 /* IPython1Sandbox */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = C01FCF4A08A954540054247B /* Build configuration list for PBXNativeTarget "IPython1Sandbox" */;
-			buildPhases = (
-				8D1107290486CEB800E47090 /* Resources */,
-				8D11072C0486CEB800E47090 /* Sources */,
-				8D11072E0486CEB800E47090 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = IPython1Sandbox;
-			productInstallPath = "$(HOME)/Applications";
-			productName = IPython1Sandbox;
-			productReference = 8D1107320486CEB800E47090 /* IPython1Sandbox.app */;
-			productType = "com.apple.product-type.application";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		29B97313FDCFA39411CA2CEA /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = C01FCF4E08A954540054247B /* Build configuration list for PBXProject "IPython1Sandbox" */;
-			compatibilityVersion = "Xcode 3.0";
-			hasScannedForEncodings = 1;
-			mainGroup = 29B97314FDCFA39411CA2CEA /* IPython1Sandbox */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				8D1107260486CEB800E47090 /* IPython1Sandbox */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		8D1107290486CEB800E47090 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D11072B0486CEB800E47090 /* InfoPlist.strings in Resources */,
-				77631A3F0C0748CF005415CB /* main.py in Resources */,
-				7790198F0C07548A00326F66 /* IPython1SandboxAppDelegate.py in Resources */,
-				77C8C1F90C07829500965286 /* MainMenu.xib in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		8D11072C0486CEB800E47090 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D11072D0486CEB800E47090 /* main.m in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXVariantGroup section */
-		089C165CFE840E0CC02AAC07 /* InfoPlist.strings */ = {
-			isa = PBXVariantGroup;
-			children = (
-				089C165DFE840E0CC02AAC07 /* English */,
-			);
-			name = InfoPlist.strings;
-			sourceTree = "<group>";
-		};
-		77C8C1F70C07829500965286 /* MainMenu.xib */ = {
-			isa = PBXVariantGroup;
-			children = (
-				77C8C1F80C07829500965286 /* English */,
-			);
-			name = MainMenu.xib;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		C01FCF4B08A954540054247B /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 1;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = IPython1Sandbox_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Applications";
-				PRODUCT_NAME = IPython1Sandbox;
-				VERSIONING_SYSTEM = "apple-generic";
-				WRAPPER_EXTENSION = app;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		C01FCF4C08A954540054247B /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CURRENT_PROJECT_VERSION = 1;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_MODEL_TUNING = G5;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = IPython1Sandbox_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Applications";
-				PRODUCT_NAME = IPython1Sandbox;
-				VERSIONING_SYSTEM = "apple-generic";
-				WRAPPER_EXTENSION = app;
-			};
-			name = Release;
-		};
-		C01FCF4F08A954540054247B /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-			};
-			name = Debug;
-		};
-		C01FCF5008A954540054247B /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				PREBINDING = NO;
-				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		C01FCF4A08A954540054247B /* Build configuration list for PBXNativeTarget "IPython1Sandbox" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C01FCF4B08A954540054247B /* Debug */,
-				C01FCF4C08A954540054247B /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		C01FCF4E08A954540054247B /* Build configuration list for PBXProject "IPython1Sandbox" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				C01FCF4F08A954540054247B /* Debug */,
-				C01FCF5008A954540054247B /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 29B97313FDCFA39411CA2CEA /* Project object */;
-}
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1SandboxAppDelegate.py b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1SandboxAppDelegate.py
deleted file mode 100644
index 361b7b51ba4..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1SandboxAppDelegate.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#
-#  IPython1SandboxAppDelegate.py
-#  IPython1Sandbox
-#
-#  Created by Barry Wark on 3/4/08.
-#  Copyright __MyCompanyName__ 2008. All rights reserved.
-#
-
-from Foundation import NSObject, NSPredicate
-import objc
-import threading
-
-from PyObjCTools import AppHelper
-
-from twisted.internet import reactor
-
-class IPython1SandboxAppDelegate(NSObject):
-    ipythonController = objc.IBOutlet()
-    
-    def applicationShouldTerminate_(self, sender):
-        if reactor.running:
-            reactor.addSystemEventTrigger(
-                'after', 'shutdown', AppHelper.stopEventLoop)
-            reactor.stop()
-            return False
-        return True
-    
-    
-    def applicationDidFinishLaunching_(self, sender):
-        reactor.interleave(AppHelper.callAfter)
-        assert(reactor.running)
-    
-    
-    def workspaceFilterPredicate(self):
-        return NSPredicate.predicateWithFormat_("NOT (self.value BEGINSWITH '<')")
-
-
-    
-
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox_Prefix.pch b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox_Prefix.pch
deleted file mode 100644
index 7ce12e21cb0..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPython1Sandbox_Prefix.pch
+++ /dev/null
@@ -1,7 +0,0 @@
-//
-// Prefix header for all source files of the 'IPython1Sandbox' target in the 'IPython1Sandbox' project
-//
-
-#ifdef __OBJC__
-    #import <Cocoa/Cocoa.h>
-#endif
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPythonCocoaController Tests-Info.plist b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPythonCocoaController Tests-Info.plist
deleted file mode 100644
index eb983f25037..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/IPythonCocoaController Tests-Info.plist	
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.IPythonCocoaController Tests</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-</dict>
-</plist>
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/Info.plist b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/Info.plist
deleted file mode 100644
index ed102a5449f..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/Info.plist
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.IPython1Sandbox</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>${PRODUCT_NAME}</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-	<key>CFBundleShortVersionString</key>
-	<string>0.1</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-	<key>NSMainNibFile</key>
-	<string>MainMenu</string>
-	<key>NSPrincipalClass</key>
-	<string>NSApplication</string>
-</dict>
-</plist>
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.m b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.m
deleted file mode 100644
index dcf8e84f426..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.m
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-//  main.m
-//  IPython1Sandbox
-//
-//  Created by Barry Wark on 3/4/08.
-//  Copyright __MyCompanyName__ 2008. All rights reserved.
-//
-
-#import <Python/Python.h>
-#import <Cocoa/Cocoa.h>
-
-int main(int argc, char *argv[])
-{
-    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-    
-    NSBundle *mainBundle = [NSBundle mainBundle];
-    NSString *resourcePath = [mainBundle resourcePath];
-    NSArray *pythonPathArray = [NSArray arrayWithObjects: resourcePath, [resourcePath stringByAppendingPathComponent:@"PyObjC"], nil];
-    
-    setenv("PYTHONPATH", [[pythonPathArray componentsJoinedByString:@":"] UTF8String], 1);
-    
-    NSArray *possibleMainExtensions = [NSArray arrayWithObjects: @"py", @"pyc", @"pyo", nil];
-    NSString *mainFilePath = nil;
-    
-    for (NSString *possibleMainExtension in possibleMainExtensions) {
-        mainFilePath = [mainBundle pathForResource: @"main" ofType: possibleMainExtension];
-        if ( mainFilePath != nil ) break;
-    }
-    
-	if ( !mainFilePath ) {
-        [NSException raise: NSInternalInconsistencyException format: @"%s:%d main() Failed to find the Main.{py,pyc,pyo} file in the application wrapper's Resources directory.", __FILE__, __LINE__];
-    }
-    
-    Py_SetProgramName("/usr/bin/python");
-    Py_Initialize();
-    PySys_SetArgv(argc, (char **)argv);
-    
-    const char *mainFilePathPtr = [mainFilePath UTF8String];
-    FILE *mainFile = fopen(mainFilePathPtr, "r");
-    int result = PyRun_SimpleFile(mainFile, (char *)[[mainFilePath lastPathComponent] UTF8String]);
-    
-    if ( result != 0 )
-        [NSException raise: NSInternalInconsistencyException
-                    format: @"%s:%d main() PyRun_SimpleFile failed with file '%@'.  See console for errors.", __FILE__, __LINE__, mainFilePath];
-    
-    [pool drain];
-    
-    return result;
-}
diff --git a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.py b/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.py
deleted file mode 100644
index f01104dccf0..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/examples/IPython1Sandbox/main.py
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-#  main.py
-#  IPython1Sandbox
-#
-#  Created by Barry Wark on 3/4/08.
-#  Copyright __MyCompanyName__ 2008. All rights reserved.
-#
-
-#import modules required by application
-import objc
-import Foundation
-import AppKit
-
-from PyObjCTools import AppHelper
-
-from twisted.internet import _threadedselect
-reactor = _threadedselect.install()
-
-# import modules containing classes required to start application and load MainMenu.nib
-import IPython1SandboxAppDelegate
-import IPython.frontend.cocoa.cocoa_frontend
-
-# pass control to AppKit
-AppHelper.runEventLoop()
diff --git a/IPython/deathrow/oldfrontend/cocoa/plugin/CocoaFrontendPlugin.xcodeproj/project.pbxproj b/IPython/deathrow/oldfrontend/cocoa/plugin/CocoaFrontendPlugin.xcodeproj/project.pbxproj
deleted file mode 100644
index 525d6efec83..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/plugin/CocoaFrontendPlugin.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,256 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXContainerItemProxy section */
-		4C5B7ADB0E1A0BCD006CB905 /* PBXContainerItemProxy */ = {
-			isa = PBXContainerItemProxy;
-			containerPortal = 4C96F4FE0E199AB500B03430 /* Project object */;
-			proxyType = 1;
-			remoteGlobalIDString = 4C96F50C0E199AF100B03430;
-			remoteInfo = "Cocoa Frontend Plugin";
-		};
-/* End PBXContainerItemProxy section */
-
-/* Begin PBXFileReference section */
-		4C5B7A8D0E1A0B4C006CB905 /* Plugin-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "Plugin-Info.plist"; sourceTree = "<group>"; };
-		4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "Placeholder (Do Not Use).bundle"; sourceTree = BUILT_PRODUCTS_DIR; };
-		4C5B7AD40E1A0BC8006CB905 /* Placeholder (Do Not Use)-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "Placeholder (Do Not Use)-Info.plist"; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		4C5B7AD10E1A0BC8006CB905 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		4C5B7A8C0E1A0B4C006CB905 /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		4C96F4FC0E199AB500B03430 = {
-			isa = PBXGroup;
-			children = (
-				4C5B7A8C0E1A0B4C006CB905 /* Products */,
-				4C5B7A8D0E1A0B4C006CB905 /* Plugin-Info.plist */,
-				4C5B7AD40E1A0BC8006CB905 /* Placeholder (Do Not Use)-Info.plist */,
-			);
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXLegacyTarget section */
-		4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */ = {
-			isa = PBXLegacyTarget;
-			buildArgumentsString = "$(ACTION)";
-			buildConfigurationList = 4C96F5110E199B3300B03430 /* Build configuration list for PBXLegacyTarget "Cocoa Frontend Plugin" */;
-			buildPhases = (
-			);
-			buildToolPath = /usr/bin/make;
-			buildWorkingDirectory = "";
-			dependencies = (
-			);
-			name = "Cocoa Frontend Plugin";
-			passBuildSettingsInEnvironment = 1;
-			productName = "Cocoa Frontend Plugin";
-		};
-/* End PBXLegacyTarget section */
-
-/* Begin PBXNativeTarget section */
-		4C5B7AD20E1A0BC8006CB905 /* Placeholder (Do Not Use) */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 4C5B7ADA0E1A0BC9006CB905 /* Build configuration list for PBXNativeTarget "Placeholder (Do Not Use)" */;
-			buildPhases = (
-				4C5B7ACF0E1A0BC8006CB905 /* Resources */,
-				4C5B7AD00E1A0BC8006CB905 /* Sources */,
-				4C5B7AD10E1A0BC8006CB905 /* Frameworks */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-				4C5B7ADC0E1A0BCD006CB905 /* PBXTargetDependency */,
-			);
-			name = "Placeholder (Do Not Use)";
-			productName = "Placeholder (Do Not Use)";
-			productReference = 4C5B7AD30E1A0BC8006CB905 /* Placeholder (Do Not Use).bundle */;
-			productType = "com.apple.product-type.bundle";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		4C96F4FE0E199AB500B03430 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 4C96F5010E199AB500B03430 /* Build configuration list for PBXProject "CocoaFrontendPlugin" */;
-			compatibilityVersion = "Xcode 2.4";
-			hasScannedForEncodings = 0;
-			mainGroup = 4C96F4FC0E199AB500B03430;
-			productRefGroup = 4C5B7A8C0E1A0B4C006CB905 /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */,
-				4C5B7AD20E1A0BC8006CB905 /* Placeholder (Do Not Use) */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		4C5B7ACF0E1A0BC8006CB905 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		4C5B7AD00E1A0BC8006CB905 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXTargetDependency section */
-		4C5B7ADC0E1A0BCD006CB905 /* PBXTargetDependency */ = {
-			isa = PBXTargetDependency;
-			target = 4C96F50C0E199AF100B03430 /* Cocoa Frontend Plugin */;
-			targetProxy = 4C5B7ADB0E1A0BCD006CB905 /* PBXContainerItemProxy */;
-		};
-/* End PBXTargetDependency section */
-
-/* Begin XCBuildConfiguration section */
-		4C5B7AD50E1A0BC9006CB905 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = "$(SYSTEM_LIBRARY_DIR)/Frameworks/AppKit.framework/Headers/AppKit.h";
-				INFOPLIST_FILE = "Placeholder (Do Not Use)-Info.plist";
-				INSTALL_PATH = "$(HOME)/Library/Bundles";
-				OTHER_LDFLAGS = (
-					"-framework",
-					Foundation,
-					"-framework",
-					AppKit,
-				);
-				PREBINDING = NO;
-				PRODUCT_NAME = "Placeholder (Do Not Use)";
-				WRAPPER_EXTENSION = bundle;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		4C5B7AD60E1A0BC9006CB905 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = "$(SYSTEM_LIBRARY_DIR)/Frameworks/AppKit.framework/Headers/AppKit.h";
-				INFOPLIST_FILE = "Placeholder (Do Not Use)-Info.plist";
-				INSTALL_PATH = "$(HOME)/Library/Bundles";
-				OTHER_LDFLAGS = (
-					"-framework",
-					Foundation,
-					"-framework",
-					AppKit,
-				);
-				PREBINDING = NO;
-				PRODUCT_NAME = "Placeholder (Do Not Use)";
-				WRAPPER_EXTENSION = bundle;
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-		4C96F4FF0E199AB500B03430 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-			};
-			name = Debug;
-		};
-		4C96F5000E199AB500B03430 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-			};
-			name = Release;
-		};
-		4C96F50D0E199AF100B03430 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				PRODUCT_NAME = "Cocoa Frontend Plugin";
-			};
-			name = Debug;
-		};
-		4C96F50E0E199AF100B03430 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				GCC_ENABLE_FIX_AND_CONTINUE = NO;
-				PRODUCT_NAME = "Cocoa Frontend Plugin";
-				ZERO_LINK = NO;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		4C5B7ADA0E1A0BC9006CB905 /* Build configuration list for PBXNativeTarget "Placeholder (Do Not Use)" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4C5B7AD50E1A0BC9006CB905 /* Debug */,
-				4C5B7AD60E1A0BC9006CB905 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4C96F5010E199AB500B03430 /* Build configuration list for PBXProject "CocoaFrontendPlugin" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4C96F4FF0E199AB500B03430 /* Debug */,
-				4C96F5000E199AB500B03430 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4C96F5110E199B3300B03430 /* Build configuration list for PBXLegacyTarget "Cocoa Frontend Plugin" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4C96F50D0E199AF100B03430 /* Debug */,
-				4C96F50E0E199AF100B03430 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 4C96F4FE0E199AB500B03430 /* Project object */;
-}
diff --git a/IPython/deathrow/oldfrontend/cocoa/plugin/IPythonCocoaFrontendLoader.py b/IPython/deathrow/oldfrontend/cocoa/plugin/IPythonCocoaFrontendLoader.py
deleted file mode 100644
index a3b547822d9..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/plugin/IPythonCocoaFrontendLoader.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# encoding: utf-8
-"""
-Provides a namespace for loading the Cocoa frontend via a Cocoa plugin.
-
-Author: Barry Wark
-"""
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from PyObjCTools import AppHelper
-from twisted.internet import _threadedselect
-
-#make sure _threadedselect is installed first
-reactor = _threadedselect.install()
-
-# load the Cocoa frontend controller
-from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController
-reactor.interleave(AppHelper.callAfter)
-assert(reactor.running)
diff --git a/IPython/deathrow/oldfrontend/cocoa/plugin/Makefile b/IPython/deathrow/oldfrontend/cocoa/plugin/Makefile
deleted file mode 100644
index 109d8bf9a9a..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/plugin/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-include ./plugins.mk
-
-all : dist/IPythonCocoaController.plugin
-
-dist/IPythonCocoaController.plugin : ./IPythonCocoaFrontendLoader.py\
- ./setup.py
\ No newline at end of file
diff --git a/IPython/deathrow/oldfrontend/cocoa/plugin/Placeholder (Do Not Use)-Info.plist b/IPython/deathrow/oldfrontend/cocoa/plugin/Placeholder (Do Not Use)-Info.plist
deleted file mode 100644
index 01fd88bc3ad..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/plugin/Placeholder (Do Not Use)-Info.plist	
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>${EXECUTABLE_NAME}</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.yourcompany.Placeholder (Do Not Use)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundlePackageType</key>
-	<string>BNDL</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-</dict>
-</plist>
diff --git a/IPython/deathrow/oldfrontend/cocoa/plugin/plugins.mk b/IPython/deathrow/oldfrontend/cocoa/plugin/plugins.mk
deleted file mode 100644
index 2df61f017d2..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/plugin/plugins.mk
+++ /dev/null
@@ -1,21 +0,0 @@
-%.plugin::
-	rm -rf dist/$(notdir $@)
-	rm -rf build dist && \
-	python setup.py py2app -s
-
-%.py:
-	@echo "test -f $@"
-	@test -f %@
-
-%.nib:
-	@echo "test -f $@"
-	@test -f %@
-
-.DEFAULT_GOAL := all
-
-.PHONY : all clean
-
-clean :
-	rm -rf build dist
-
-
diff --git a/IPython/deathrow/oldfrontend/cocoa/plugin/setup.py b/IPython/deathrow/oldfrontend/cocoa/plugin/setup.py
deleted file mode 100644
index 11fdd250c63..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/plugin/setup.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# encoding: utf-8
-"""
-setup.py
-
-Setuptools installer script for generating a Cocoa plugin for the 
-IPython cocoa frontend
-
-Author: Barry Wark
-"""
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from setuptools import setup
-
-infoPlist = dict(
-        CFBundleDevelopmentRegion='English',
-        CFBundleIdentifier='org.scipy.ipython.cocoa_frontend',
-        NSPrincipalClass='IPythonCocoaController',
-)
-
-setup(
-        plugin=['IPythonCocoaFrontendLoader.py'],
-    setup_requires=['py2app'],
-        options=dict(py2app=dict(
-                plist=infoPlist,
-                site_packages=True,
-                excludes=['IPython','twisted','PyObjCTools']
-        )),
-)
\ No newline at end of file
diff --git a/IPython/deathrow/oldfrontend/cocoa/tests/__init__.py b/IPython/deathrow/oldfrontend/cocoa/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/deathrow/oldfrontend/cocoa/tests/test_cocoa_frontend.py b/IPython/deathrow/oldfrontend/cocoa/tests/test_cocoa_frontend.py
deleted file mode 100644
index 58b78e4f71e..00000000000
--- a/IPython/deathrow/oldfrontend/cocoa/tests/test_cocoa_frontend.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# encoding: utf-8
-"""This file contains unittests for the 
-IPython.frontend.cocoa.cocoa_frontend module.
-"""
-__docformat__ = "restructuredtext en"
-                                                                            
-#---------------------------------------------------------------------------
-#       Copyright (C) 2005  The IPython Development Team    
-#                                                                           
-#  Distributed under the terms of the BSD License.  The full license is in  
-#  the file COPYING, distributed as part of this software.                  
-#---------------------------------------------------------------------------
-                                                                            
-#---------------------------------------------------------------------------
-# Imports                                                                   
-#---------------------------------------------------------------------------
-
-# Tell nose to skip this module
-__test__ = {}
-
-from twisted.trial import unittest
-from twisted.internet.defer import succeed
-
-from IPython.kernel.core.interpreter import Interpreter
-import IPython.kernel.engineservice as es
-
-try:
-    from IPython.frontend.cocoa.cocoa_frontend import IPythonCocoaController
-    from Foundation import NSMakeRect
-    from AppKit import NSTextView, NSScrollView
-except ImportError:
-    # This tells twisted.trial to skip this module if PyObjC is not found
-    skip = True
-
-#---------------------------------------------------------------------------
-# Tests
-#---------------------------------------------------------------------------
-class TestIPythonCocoaControler(unittest.TestCase):
-    """Tests for IPythonCocoaController"""
-
-    def setUp(self):
-        self.controller = IPythonCocoaController.alloc().init()
-        self.engine = es.EngineService()
-        self.engine.startService()
-
-    def tearDown(self):
-        self.controller = None
-        self.engine.stopService()
-
-    def testControllerExecutesCode(self):
-        code ="""5+5"""
-        expected = Interpreter().execute(code)
-        del expected['number']
-        def removeNumberAndID(result):
-            del result['number']
-            del result['id']
-            return result
-        d = self.controller.execute(code)
-        d.addCallback(removeNumberAndID)
-        d.addCallback(lambda r: self.assertEquals(r, expected))
-
-    def testControllerMirrorsUserNSWithValuesAsStrings(self):
-        code = """userns1=1;userns2=2"""
-        def testControllerUserNS(result):
-            self.assertEquals(self.controller.userNS['userns1'], 1)
-            self.assertEquals(self.controller.userNS['userns2'], 2)
-        self.controller.execute(code).addCallback(testControllerUserNS)
-
-    def testControllerInstantiatesIEngine(self):
-        self.assert_(es.IEngineBase.providedBy(self.controller.engine))
-
-    def testControllerCompletesToken(self):
-        code = """longNameVariable=10"""
-        def testCompletes(result):
-            self.assert_("longNameVariable" in result)
-
-        def testCompleteToken(result):
-            self.controller.complete("longNa").addCallback(testCompletes)
-
-        self.controller.execute(code).addCallback(testCompletes)
-
-
-    def testCurrentIndent(self):
-        """test that current_indent_string returns current indent or None.
-        Uses _indent_for_block for direct unit testing.
-        """
-        
-        self.controller.tabUsesSpaces = True
-        self.assert_(self.controller._indent_for_block("""a=3""") == None)
-        self.assert_(self.controller._indent_for_block("") == None)
-        block = """def test():\n    a=3"""
-        self.assert_(self.controller._indent_for_block(block) == \
-                    ' ' * self.controller.tabSpaces)
-        
-        block = """if(True):\n%sif(False):\n%spass""" % \
-                    (' '*self.controller.tabSpaces,
-                     2*' '*self.controller.tabSpaces)
-        self.assert_(self.controller._indent_for_block(block) == \
-                    2*(' '*self.controller.tabSpaces))
-
diff --git a/IPython/deathrow/oldfrontend/frontendbase.py b/IPython/deathrow/oldfrontend/frontendbase.py
deleted file mode 100644
index 3ae6e781aa8..00000000000
--- a/IPython/deathrow/oldfrontend/frontendbase.py
+++ /dev/null
@@ -1,343 +0,0 @@
-# encoding: utf-8
-# -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
-"""
-frontendbase provides an interface and base class for GUI frontends for 
-IPython.kernel/IPython.kernel.core.
-
-Frontend implementations will likely want to subclass FrontEndBase. 
-
-Author: Barry Wark
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-import string
-import codeop
-from IPython.external import guid
-
-
-from IPython.frontend.zopeinterface import (
-    Interface, 
-    Attribute, 
-)
-from IPython.kernel.core.history import FrontEndHistory
-from IPython.kernel.core.util import Bunch
-
-##############################################################################
-# TEMPORARY!!! fake configuration, while we decide whether to use tconfig or
-# not
-
-rc = Bunch()
-rc.prompt_in1 = r'In [$number]:  '
-rc.prompt_in2 = r'...'
-rc.prompt_out = r'Out [$number]:  '
-
-##############################################################################
-# Interface definitions
-##############################################################################
-
-class IFrontEndFactory(Interface):
-    """Factory interface for frontends."""
-    
-    def __call__(engine=None, history=None):
-        """
-        Parameters:
-        interpreter : IPython.kernel.engineservice.IEngineCore
-        """
-        
-        pass
-
-
-class IFrontEnd(Interface):
-    """Interface for frontends. All methods return t.i.d.Deferred"""
-    
-    Attribute("input_prompt_template", "string.Template instance\
-                substituteable with execute result.")
-    Attribute("output_prompt_template", "string.Template instance\
-                substituteable with execute result.")
-    Attribute("continuation_prompt_template", "string.Template instance\
-                substituteable with execute result.")
-    
-    def update_cell_prompt(result, blockID=None):
-        """Subclass may override to update the input prompt for a block. 
-
-        In asynchronous frontends, this method will be called as a
-        twisted.internet.defer.Deferred's callback/errback.
-        Implementations should thus return result when finished.
-        
-        Result is a result dict in case of success, and a
-        twisted.python.util.failure.Failure in case of an error
-        """
-        
-        pass
-    
-    def render_result(result):
-        """Render the result of an execute call. Implementors may choose the
-         method of rendering.
-        For example, a notebook-style frontend might render a Chaco plot 
-        inline.
-        
-        Parameters:
-            result : dict (result of IEngineBase.execute )
-                blockID = result['blockID']
-        
-        Result:
-            Output of frontend rendering
-        """
-        
-        pass
-    
-    def render_error(failure):
-        """Subclasses must override to render the failure. 
-        
-        In asynchronous frontend, since this method will be called as a
-        twisted.internet.defer.Deferred's callback. Implementations
-        should thus return result when finished.
-        
-        blockID = failure.blockID
-        """
-        
-        pass
-    
-    def input_prompt(number=''):
-        """Returns the input prompt by subsituting into 
-        self.input_prompt_template
-        """
-        pass
-    
-    def output_prompt(number=''):
-        """Returns the output prompt by subsituting into 
-        self.output_prompt_template
-        """
-        
-        pass
-    
-    def continuation_prompt():
-        """Returns the continuation prompt by subsituting into 
-        self.continuation_prompt_template
-        """
-        
-        pass
-    
-    def is_complete(block):
-        """Returns True if block is complete, False otherwise."""
-        
-        pass
-    
-   
-    def get_history_previous(current_block):
-        """Returns the block previous in  the history. Saves currentBlock if
-        the history_cursor is currently at the end of the input history"""
-        pass
-    
-    def get_history_next():
-        """Returns the next block in the history."""
-        
-        pass
-    
-    def complete(self, line):
-        """Returns the list of possible completions, and the completed
-            line.
-
-        The input argument is the full line to be completed. This method
-        returns both the line completed as much as possible, and the list
-        of further possible completions (full words).
-        """
-        pass
-
-
-##############################################################################
-# Base class for all the frontends. 
-##############################################################################
-
-class FrontEndBase(object):
-    """
-    FrontEndBase manages the state tasks for a CLI frontend:
-        - Input and output history management
-        - Input/continuation and output prompt generation
-        
-    Some issues (due to possibly unavailable engine):
-        - How do we get the current cell number for the engine?
-        - How do we handle completions?
-    """
-    
-    history_cursor = 0
-    
-    input_prompt_template = string.Template(rc.prompt_in1)
-    output_prompt_template = string.Template(rc.prompt_out)
-    continuation_prompt_template = string.Template(rc.prompt_in2)
-    
-    def __init__(self, shell=None, history=None):
-        self.shell = shell
-        if history is None:
-                self.history = FrontEndHistory(input_cache=[''])
-        else:
-            self.history = history
-        
-    
-    def input_prompt(self, number=''):
-        """Returns the current input prompt
-        
-        It would be great to use ipython1.core.prompts.Prompt1 here
-        """
-        return self.input_prompt_template.safe_substitute({'number':number})
-    
-    
-    def continuation_prompt(self):
-        """Returns the current continuation prompt"""
-        
-        return self.continuation_prompt_template.safe_substitute()
-    
-    def output_prompt(self, number=''):
-        """Returns the output prompt for result"""
-        
-        return self.output_prompt_template.safe_substitute({'number':number})
-    
-    
-    def is_complete(self, block):
-        """Determine if block is complete.
-        
-        Parameters
-        block : string
-        
-        Result 
-        True if block can be sent to the engine without compile errors.
-        False otherwise.
-        """
-        
-        try:
-            is_complete = codeop.compile_command(block.rstrip() + '\n\n',
-                            "<string>", "exec") 
-        except:
-            return False
-        
-        lines = block.split('\n')
-        return ((is_complete is not None) 
-                    and (len(lines)==1 or str(lines[-1])==''))
-    
-    
-    def execute(self, block, blockID=None):
-        """Execute the block and return the result.
-        
-        Parameters:
-            block : {str, AST}
-            blockID : any
-                Caller may provide an ID to identify this block. 
-                result['blockID'] := blockID
-        
-        Result:
-            Deferred result of self.interpreter.execute
-        """
-        
-        if(not self.is_complete(block)):
-            raise Exception("Block is not compilable")
-        
-        if(blockID == None):
-            blockID = guid.generate()
-        
-        try:
-            result = self.shell.execute(block)
-        except Exception,e:
-            e = self._add_block_id_for_failure(e, blockID=blockID)
-            e = self.update_cell_prompt(e, blockID=blockID)
-            e = self.render_error(e)
-        else:
-            result = self._add_block_id_for_result(result, blockID=blockID)
-            result = self.update_cell_prompt(result, blockID=blockID)
-            result = self.render_result(result)
-        
-        return result
-    
-    
-    def _add_block_id_for_result(self, result, blockID):
-        """Add the blockID to result or failure. Unfortunatley, we have to 
-        treat failures differently than result dicts.
-        """
-        
-        result['blockID'] = blockID
-        
-        return result
-    
-    def _add_block_id_for_failure(self, failure, blockID):
-        """_add_block_id_for_failure"""
-        failure.blockID = blockID
-        return failure
-    
-    
-    def _add_history(self, result, block=None):
-        """Add block to the history"""
-        
-        assert(block != None)
-        self.history.add_items([block])
-        self.history_cursor += 1
-        
-        return result
-    
-    
-    def get_history_previous(self, current_block):
-        """ Returns previous history string and decrement history cursor.
-        """
-        command = self.history.get_history_item(self.history_cursor - 1)
-        
-        if command is not None:
-            if(self.history_cursor+1 == len(self.history.input_cache)):
-                self.history.input_cache[self.history_cursor] = current_block
-            self.history_cursor -= 1
-        return command
-    
-    
-    def get_history_next(self):
-        """ Returns next history string and increment history cursor.
-        """
-        command = self.history.get_history_item(self.history_cursor+1)
-        
-        if command is not None:
-            self.history_cursor += 1
-        return command
-    
-    ###
-    # Subclasses probably want to override these methods...
-    ###
-    
-    def update_cell_prompt(self, result, blockID=None):
-        """Subclass may override to update the input prompt for a block. 
-
-        This method only really makes sens in asyncrhonous frontend.
-        Since this method will be called as a 
-        twisted.internet.defer.Deferred's callback, implementations should 
-        return result when finished.
-        """
-        
-        raise NotImplementedError
-    
-    
-    def render_result(self, result):
-        """Subclasses must override to render result. 
-        
-        In asynchronous frontends, this method will be called as a
-        twisted.internet.defer.Deferred's callback. Implementations
-        should thus return result when finished.
-        """
-        
-        raise NotImplementedError
-    
-    
-    def render_error(self, failure):
-        """Subclasses must override to render the failure. 
-        
-        In asynchronous frontends, this method will be called as a
-        twisted.internet.defer.Deferred's callback. Implementations
-        should thus return result when finished.
-        """
-        
-        raise NotImplementedError
-
diff --git a/IPython/deathrow/oldfrontend/linefrontendbase.py b/IPython/deathrow/oldfrontend/linefrontendbase.py
deleted file mode 100644
index 1dc570cc2a4..00000000000
--- a/IPython/deathrow/oldfrontend/linefrontendbase.py
+++ /dev/null
@@ -1,373 +0,0 @@
-"""
-Base front end class for all line-oriented frontends, rather than
-block-oriented.
-
-Currently this focuses on synchronous frontends.
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-import re
-
-import sys
-import codeop
-
-from frontendbase import FrontEndBase
-from IPython.kernel.core.interpreter import Interpreter
-
-def common_prefix(strings):
-    """ Given a list of strings, return the common prefix between all
-        these strings.
-    """
-    ref = strings[0]
-    prefix = ''
-    for size in range(len(ref)):
-        test_prefix = ref[:size+1]
-        for string in strings[1:]:
-            if not string.startswith(test_prefix):
-                return prefix
-        prefix = test_prefix
-
-    return prefix
-
-#-----------------------------------------------------------------------------
-# Base class for the line-oriented front ends
-#-----------------------------------------------------------------------------
-
-class LineFrontEndBase(FrontEndBase):
-    """ Concrete implementation of the FrontEndBase class. This is meant
-    to be the base class behind all the frontend that are line-oriented,
-    rather than block-oriented.
-    """
-    
-    # We need to keep the prompt number, to be able to increment
-    # it when there is an exception.
-    prompt_number = 1
-
-    # We keep a reference to the last result: it helps testing and
-    # programatic control of the frontend. 
-    last_result = dict(number=0)
-
-    # The last prompt displayed. Useful for continuation prompts.
-    last_prompt = ''
-
-    # The input buffer being edited
-    input_buffer = ''
-
-    # Set to true for debug output
-    debug = False
-
-    # A banner to print at startup
-    banner = None
-
-    #--------------------------------------------------------------------------
-    # FrontEndBase interface
-    #--------------------------------------------------------------------------
-
-    def __init__(self, shell=None, history=None, banner=None, *args, **kwargs):
-        if shell is None:
-            shell = Interpreter()
-        FrontEndBase.__init__(self, shell=shell, history=history)
-
-        if banner is not None:
-            self.banner = banner
-
-    def start(self):
-        """ Put the frontend in a state where it is ready for user
-            interaction.
-        """
-        if self.banner is not None:
-            self.write(self.banner, refresh=False)
-
-        self.new_prompt(self.input_prompt_template.substitute(number=1))
-
-
-    def complete(self, line):
-        """Complete line in engine's user_ns
-        
-        Parameters
-        ----------
-        line : string
-        
-        Returns
-        -------
-        The replacement for the line and the list of possible completions.
-        """
-        completions = self.shell.complete(line)
-        complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
-        if completions:
-            prefix = common_prefix(completions) 
-            residual = complete_sep.split(line)[:-1]
-            line = line[:-len(residual)] + prefix
-        return line, completions 
- 
-
-    def render_result(self, result):
-        """ Frontend-specific rendering of the result of a calculation
-        that has been sent to an engine.
-        """
-        if 'stdout' in result and result['stdout']:
-            self.write('\n' + result['stdout'])
-        if 'display' in result and result['display']:
-            self.write("%s%s\n" % ( 
-                            self.output_prompt_template.substitute(
-                                    number=result['number']),
-                            result['display']['pprint']
-                            ) )
-       
-
-    def render_error(self, failure):
-        """ Frontend-specific rendering of error. 
-        """
-        self.write('\n\n'+str(failure)+'\n\n')
-        return failure
-
-
-    def is_complete(self, string):
-        """ Check if a string forms a complete, executable set of
-        commands.
-
-        For the line-oriented frontend, multi-line code is not executed
-        as soon as it is complete: the users has to enter two line
-        returns.
-        """
-        if string in ('', '\n'):
-            # Prefiltering, eg through ipython0, may return an empty
-            # string although some operations have been accomplished. We
-            # thus want to consider an empty string as a complete
-            # statement.
-            return True
-        elif ( len(self.input_buffer.split('\n'))>2 
-                        and not re.findall(r"\n[\t ]*\n[\t ]*$", string)):
-            return False
-        else:
-            self.capture_output()
-            try:
-                # Add line returns here, to make sure that the statement is
-                # complete (except if '\' was used).
-                # This should probably be done in a different place (like
-                # maybe 'prefilter_input' method? For now, this works.
-                clean_string = string.rstrip('\n')
-                if not clean_string.endswith('\\'): clean_string +='\n\n' 
-                is_complete = codeop.compile_command(clean_string,
-                            "<string>", "exec")
-                self.release_output()
-            except Exception, e:
-                # XXX: Hack: return True so that the
-                # code gets executed and the error captured.
-                is_complete = True
-            return is_complete
-
-
-    def write(self, string, refresh=True):
-        """ Write some characters to the display.
-
-            Subclass should overide this method.
-
-            The refresh keyword argument is used in frontends with an
-            event loop, to choose whether the write should trigget an UI
-            refresh, and thus be syncrhonous, or not.
-        """
-        print >>sys.__stderr__, string
-
-
-    def execute(self, python_string, raw_string=None):
-        """ Stores the raw_string in the history, and sends the
-        python string to the interpreter.
-        """
-        if raw_string is None:
-            raw_string = python_string
-        # Create a false result, in case there is an exception
-        self.last_result = dict(number=self.prompt_number)
-
-        try:
-            try:
-                self.history.input_cache[-1] = raw_string.rstrip()
-                result = self.shell.execute(python_string)
-                self.last_result = result
-                self.render_result(result)
-            except:
-                self.show_traceback()
-        finally:
-            self.after_execute()
-
-
-    #--------------------------------------------------------------------------
-    # LineFrontEndBase interface
-    #--------------------------------------------------------------------------
-
-    def prefilter_input(self, string):
-        """ Prefilter the input to turn it in valid python.
-        """
-        string = string.replace('\r\n', '\n')
-        string = string.replace('\t', 4*' ')
-        # Clean the trailing whitespace
-        string = '\n'.join(l.rstrip()  for l in string.split('\n'))
-        return string
-
-
-    def after_execute(self):
-        """ All the operations required after an execution to put the
-            terminal back in a shape where it is usable.
-        """
-        self.prompt_number += 1
-        self.new_prompt(self.input_prompt_template.substitute(
-                            number=(self.last_result['number'] + 1)))
-        # Start a new empty history entry
-        self._add_history(None, '')
-        self.history_cursor = len(self.history.input_cache) - 1
-
-
-    def complete_current_input(self):
-        """ Do code completion on current line. 
-        """
-        if self.debug:
-            print >>sys.__stdout__, "complete_current_input", 
-        line = self.input_buffer
-        new_line, completions = self.complete(line)
-        if len(completions)>1:
-            self.write_completion(completions, new_line=new_line)
-        elif not line == new_line:
-            self.input_buffer = new_line
-        if self.debug:
-            print >>sys.__stdout__, 'line', line
-            print >>sys.__stdout__, 'new_line', new_line
-            print >>sys.__stdout__, completions 
-
-
-    def get_line_width(self):
-        """ Return the width of the line in characters.
-        """
-        return 80
-
-
-    def write_completion(self, possibilities, new_line=None):
-        """ Write the list of possible completions.
-
-            new_line is the completed input line that should be displayed
-            after the completion are writen. If None, the input_buffer
-            before the completion is used.
-        """
-        if new_line is None:
-            new_line = self.input_buffer
-        
-        self.write('\n')
-        max_len = len(max(possibilities, key=len)) + 1
-        
-        # Now we check how much symbol we can put on a line...
-        chars_per_line = self.get_line_width()
-        symbols_per_line = max(1, chars_per_line/max_len)
-
-        pos = 1
-        completion_string = []
-        for symbol in possibilities:
-            if pos < symbols_per_line:
-                completion_string.append(symbol.ljust(max_len))
-                pos += 1
-            else:
-                completion_string.append(symbol.rstrip() + '\n')
-                pos = 1
-        self.write(''.join(completion_string))
-        self.new_prompt(self.input_prompt_template.substitute(
-                            number=self.last_result['number'] + 1))
-        self.input_buffer = new_line
-
-
-    def new_prompt(self, prompt):
-        """ Prints a prompt and starts a new editing buffer. 
-
-            Subclasses should use this method to make sure that the
-            terminal is put in a state favorable for a new line
-            input.
-        """
-        self.input_buffer = ''
-        self.write(prompt)
-
-
-    def continuation_prompt(self):
-        """Returns the current continuation prompt.
-        """
-        return ("."*(len(self.last_prompt)-2) + ': ')
- 
-
-    def execute_command(self, command, hidden=False):
-        """ Execute a command, not only in the model, but also in the
-            view, if any.
-        """
-        return self.shell.execute(command)
-
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
- 
-    def _on_enter(self, new_line_pos=0):
-        """ Called when the return key is pressed in a line editing
-            buffer.
-
-            Parameters
-            ----------
-            new_line_pos : integer, optional
-                Position of the new line to add, starting from the
-                end (0 adds a new line after the last line, -1 before
-                the last line...)
-
-            Returns
-            -------
-            True if execution is triggered
-        """
-        current_buffer = self.input_buffer
-        # XXX: This string replace is ugly, but there should be no way it
-        # fails.
-        prompt_less_buffer = re.sub('^' + self.continuation_prompt(),
-                '', current_buffer).replace('\n' + self.continuation_prompt(),
-                                            '\n')
-        cleaned_buffer = self.prefilter_input(prompt_less_buffer)
-        if self.is_complete(cleaned_buffer):
-            self.execute(cleaned_buffer, raw_string=current_buffer)
-            return True
-        else:
-            # Start a new line.
-            new_line_pos = -new_line_pos
-            lines = current_buffer.split('\n')[:-1]
-            prompt_less_lines = prompt_less_buffer.split('\n')
-            # Create the new line, with the continuation prompt, and the 
-            # same amount of indent than the line above it.
-            new_line = self.continuation_prompt() + \
-                  self._get_indent_string('\n'.join(
-                                    prompt_less_lines[:new_line_pos-1]))
-            if len(lines) == 1:
-                # We are starting a first continuation line. Indent it.
-                new_line += '\t'
-            elif current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'):
-                # The last line ends with ":", autoindent the new line.
-                new_line += '\t'
-
-            if new_line_pos == 0:
-                lines.append(new_line)
-            else:
-                lines.insert(new_line_pos, new_line)
-            self.input_buffer = '\n'.join(lines)
-            
-
-    def _get_indent_string(self, string):
-        """ Return the string of whitespace that prefixes a line. Used to
-        add the right amount of indendation when creating a new line.
-        """
-        string = string.replace('\t', ' '*4)
-        string = string.split('\n')[-1]
-        indent_chars = len(string) - len(string.lstrip())
-        indent_string = '\t'*(indent_chars // 4) + \
-                            ' '*(indent_chars % 4)
-
-        return indent_string
- 
-    
diff --git a/IPython/deathrow/oldfrontend/prefilterfrontend.py b/IPython/deathrow/oldfrontend/prefilterfrontend.py
deleted file mode 100644
index 20726e2e65b..00000000000
--- a/IPython/deathrow/oldfrontend/prefilterfrontend.py
+++ /dev/null
@@ -1,256 +0,0 @@
-"""
-Frontend class that uses IPython0 to prefilter the inputs.
-
-Using the IPython0 mechanism gives us access to the magics.
-
-This is a transitory class, used here to do the transition between
-ipython0 and ipython1. This class is meant to be short-lived as more
-functionnality is abstracted out of ipython0 in reusable functions and
-is added on the interpreter. This class can be a used to guide this
-refactoring.
-"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-import sys
-import pydoc
-import os
-import re
-import __builtin__
-
-from IPython.core.iplib import InteractiveShell
-from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
-
-from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
-
-import IPython.utils.io
-
-from linefrontendbase import LineFrontEndBase, common_prefix
-
-#-----------------------------------------------------------------------------
-# Utility functions
-#-----------------------------------------------------------------------------
-
-def mk_system_call(system_call_function, command):
-    """ given a os.system replacement, and a leading string command,
-        returns a function that will execute the command with the given
-        argument string.
-    """
-    def my_system_call(args):
-        system_call_function("%s %s" % (command, args))
-
-    my_system_call.__doc__ = "Calls %s" % command
-    return my_system_call
-
-#-----------------------------------------------------------------------------
-# Frontend class using ipython0 to do the prefiltering. 
-#-----------------------------------------------------------------------------
-
-class PrefilterFrontEnd(LineFrontEndBase):
-    """ Class that uses ipython0 to do prefilter the input, do the
-    completion and the magics.
-
-    The core trick is to use an ipython0 instance to prefilter the
-    input, and share the namespace between the interpreter instance used
-    to execute the statements and the ipython0 used for code
-    completion...
-    """
-
-    debug = False
-    
-    def __init__(self, ipython0=None, *args, **kwargs):
-        """ Parameters
-            ----------
-
-            ipython0: an optional ipython0 instance to use for command
-            prefiltering and completion.
-        """
-        LineFrontEndBase.__init__(self, *args, **kwargs)
-        self.shell.output_trap = RedirectorOutputTrap(
-                            out_callback=self.write,
-                            err_callback=self.write,
-                                            )
-        self.shell.traceback_trap = SyncTracebackTrap(
-                        formatters=self.shell.traceback_trap.formatters,
-                            )
-
-        # Start the ipython0 instance:
-        self.save_output_hooks()
-        if ipython0 is None:
-            # Instanciate an IPython0 InteractiveShell to be able to use the
-            # prefiltering.
-            # Suppress all key input, to avoid waiting
-            def my_rawinput(x=None):
-                return '\n'
-            old_rawinput = __builtin__.raw_input
-            __builtin__.raw_input = my_rawinput
-            ipython0 = InteractiveShell(
-                parent=None, user_ns=self.shell.user_ns,
-                user_global_ns=self.shell.user_global_ns
-            )
-            __builtin__.raw_input = old_rawinput
-        self.ipython0 = ipython0
-        # Set the pager:
-        self.ipython0.set_hook('show_in_pager', 
-                    lambda s, string: self.write("\n" + string))
-        self.ipython0.write = self.write
-        self._ip = _ip = self.ipython0
-        # Make sure the raw system call doesn't get called, as we don't
-        # have a stdin accessible.
-        self._ip.system = self.system_call
-        # XXX: Muck around with magics so that they work better
-        # in our environment
-        if not sys.platform.startswith('win'):
-            self.ipython0.magic_ls = mk_system_call(self.system_call, 
-                                                                'ls -CF')
-        # And now clean up the mess created by ipython0
-        self.release_output()
-
-
-        if not 'banner' in kwargs and self.banner is None:
-            self.banner = self.ipython0.banner
-
-        # FIXME: __init__ and start should be two different steps
-        self.start()
-
-    #--------------------------------------------------------------------------
-    # FrontEndBase interface 
-    #--------------------------------------------------------------------------
-
-    def show_traceback(self):
-        """ Use ipython0 to capture the last traceback and display it.
-        """
-        # Don't do the capture; the except_hook has already done some
-        # modifications to the IO streams, if we store them, we'll be
-        # storing the wrong ones.
-        #self.capture_output()
-        self.ipython0.showtraceback(tb_offset=-1)
-        self.release_output()
-
-
-    def execute(self, python_string, raw_string=None):
-        if self.debug:
-            print 'Executing Python code:', repr(python_string)
-        self.capture_output()
-        LineFrontEndBase.execute(self, python_string,
-                                    raw_string=raw_string)
-        self.release_output()
-
-
-    def save_output_hooks(self):
-        """ Store all the output hooks we can think of, to be able to
-        restore them. 
-        
-        We need to do this early, as starting the ipython0 instance will
-        screw ouput hooks.
-        """
-        self.__old_cout_write = Term.cout.write
-        self.__old_cerr_write = Term.cerr.write
-        self.__old_stdout = sys.stdout
-        self.__old_stderr= sys.stderr
-        self.__old_help_output = pydoc.help.output
-        self.__old_display_hook = sys.displayhook
-
-
-    def capture_output(self):
-        """ Capture all the output mechanisms we can think of.
-        """
-        self.save_output_hooks()
-        Term.cout.write = self.write
-        Term.cerr.write = self.write
-        sys.stdout = Term.cout
-        sys.stderr = Term.cerr
-        pydoc.help.output = self.shell.output_trap.out
-
-
-    def release_output(self):
-        """ Release all the different captures we have made.
-        """
-        Term.cout.write = self.__old_cout_write
-        Term.cerr.write = self.__old_cerr_write
-        sys.stdout = self.__old_stdout
-        sys.stderr = self.__old_stderr
-        pydoc.help.output = self.__old_help_output 
-        sys.displayhook = self.__old_display_hook 
-
-
-    def complete(self, line):
-        # FIXME: This should be factored out in the linefrontendbase
-        # method.
-        word = self._get_completion_text(line)
-        completions = self.ipython0.complete(word)
-        # FIXME: The proper sort should be done in the complete method.
-        key = lambda x: x.replace('_', '')
-        completions.sort(key=key)
-        if completions:
-            prefix = common_prefix(completions) 
-            line = line[:-len(word)] + prefix
-        return line, completions
-    
-    #--------------------------------------------------------------------------
-    # LineFrontEndBase interface 
-    #--------------------------------------------------------------------------
-
-    def prefilter_input(self, input_string):
-        """ Using IPython0 to prefilter the commands to turn them
-        in executable statements that are valid Python strings.
-        """
-        input_string = LineFrontEndBase.prefilter_input(self, input_string)
-        filtered_lines = []
-        # The IPython0 prefilters sometime produce output. We need to
-        # capture it.
-        self.capture_output()
-        self.last_result = dict(number=self.prompt_number)
-        
-        try:
-            try:
-                for line in input_string.split('\n'):
-                    pf = self.ipython0.prefilter_manager.prefilter_lines
-                    filtered_lines.append(pf(line, False).rstrip())
-            except:
-                # XXX: probably not the right thing to do.
-                self.ipython0.showsyntaxerror()
-                self.after_execute()
-        finally:
-            self.release_output()
-
-        # Clean up the trailing whitespace, to avoid indentation errors
-        filtered_string = '\n'.join(filtered_lines)
-        return filtered_string
-
-    #--------------------------------------------------------------------------
-    # PrefilterFrontEnd interface 
-    #--------------------------------------------------------------------------
- 
-    def system_call(self, command_string):
-        """ Allows for frontend to define their own system call, to be
-            able capture output and redirect input.
-        """
-        return os.system(command_string)
-
-    def do_exit(self):
-        """ Exit the shell, cleanup and save the history.
-        """
-        self.ipython0.atexit_operations()
-
-    def _get_completion_text(self, line):
-        """ Returns the text to be completed by breaking the line at specified
-        delimiters.
-        """
-        # Break at: spaces, '=', all parentheses (except if balanced).
-        # FIXME2: In the future, we need to make the implementation similar to
-        # that in the 'pyreadline' module (modes/basemode.py) where we break at
-        # each delimiter and try to complete the residual line, until we get a
-        # successful list of completions.
-        expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})' 
-        complete_sep = re.compile(expression)
-        text = complete_sep.split(line)[-1]
-        return text
diff --git a/IPython/deathrow/oldfrontend/process/__init__.py b/IPython/deathrow/oldfrontend/process/__init__.py
deleted file mode 100644
index af9be72fd65..00000000000
--- a/IPython/deathrow/oldfrontend/process/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""
-Package for dealing for process execution in a callback environment, in a
-portable way.
-
-killable_process.py is a wrapper of subprocess.Popen that allows the
-subprocess and its children to be killed in a reliable way, including
-under windows.
-
-winprocess.py is required by killable_process.py to kill processes under
-windows.
-
-piped_process.py wraps process execution with callbacks to print output,
-in a non-blocking way. It can be used to interact with a subprocess in eg
-a GUI event loop.
-"""
-
-from pipedprocess import PipedProcess
-
-
diff --git a/IPython/deathrow/oldfrontend/process/killableprocess.py b/IPython/deathrow/oldfrontend/process/killableprocess.py
deleted file mode 100644
index 399bd70c6f9..00000000000
--- a/IPython/deathrow/oldfrontend/process/killableprocess.py
+++ /dev/null
@@ -1,184 +0,0 @@
-# Addapted from killableprocess.py.  
-#______________________________________________________________________________
-#
-# killableprocess - subprocesses which can be reliably killed
-#
-# Parts of this module are copied from the subprocess.py file contained
-# in the Python distribution.
-#
-# Copyright (c) 2003-2004 by Peter Astrand <astrand@lysator.liu.se>
-#
-# Additions and modifications written by Benjamin Smedberg
-# <benjamin@smedbergs.us> are Copyright (c) 2006 by the Mozilla Foundation
-# <http://www.mozilla.org/>
-#
-# By obtaining, using, and/or copying this software and/or its
-# associated documentation, you agree that you have read, understood,
-# and will comply with the following terms and conditions:
-#
-# Permission to use, copy, modify, and distribute this software and
-# its associated documentation for any purpose and without fee is
-# hereby granted, provided that the above copyright notice appears in
-# all copies, and that both that copyright notice and this permission
-# notice appear in supporting documentation, and that the name of the
-# author not be used in advertising or publicity pertaining to
-# distribution of the software without specific, written prior
-# permission.
-#
-# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
-# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
-# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-r"""killableprocess - Subprocesses which can be reliably killed
-
-This module is a subclass of the builtin "subprocess" module. It allows
-processes that launch subprocesses to be reliably killed on Windows (via the Popen.kill() method.
-
-It also adds a timeout argument to Wait() for a limited period of time before
-forcefully killing the process.
-
-Note: On Windows, this module requires Windows 2000 or higher (no support for
-Windows 95, 98, or NT 4.0). It also requires ctypes, which is bundled with
-Python 2.5+ or available from http://python.net/crew/theller/ctypes/
-"""
-
-import subprocess
-from subprocess import PIPE
-import sys
-import os
-import types
-
-try:
-    from subprocess import CalledProcessError
-except ImportError:
-    # Python 2.4 doesn't implement CalledProcessError
-    class CalledProcessError(Exception):
-        """This exception is raised when a process run by check_call() returns
-        a non-zero exit status. The exit status will be stored in the
-        returncode attribute."""
-        def __init__(self, returncode, cmd):
-            self.returncode = returncode
-            self.cmd = cmd
-        def __str__(self):
-            return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)
-
-mswindows = (sys.platform == "win32")
-
-skip = False
-
-if mswindows:
-    import platform
-    if platform.uname()[3] == '' or platform.uname()[3] > '6.0.6000':
-        # Killable process does not work under vista when starting for
-        # something else than cmd.
-        skip = True
-    else:
-        import winprocess
-else:
-    import signal
-
-if not mswindows:
-    def DoNothing(*args):
-        pass
-
-
-if skip:
- Popen = subprocess.Popen
-else:
- class Popen(subprocess.Popen):
-    if not mswindows:
-        # Override __init__ to set a preexec_fn
-        def __init__(self, *args, **kwargs):
-            if len(args) >= 7:
-                raise Exception("Arguments preexec_fn and after must be passed by keyword.")
-
-            real_preexec_fn = kwargs.pop("preexec_fn", None)
-            def setpgid_preexec_fn():
-                os.setpgid(0, 0)
-                if real_preexec_fn:
-                    apply(real_preexec_fn)
-
-            kwargs['preexec_fn'] = setpgid_preexec_fn
-
-            subprocess.Popen.__init__(self, *args, **kwargs)
-
-    if mswindows:
-        def _execute_child(self, args, executable, preexec_fn, close_fds,
-                           cwd, env, universal_newlines, startupinfo,
-                           creationflags, shell,
-                           p2cread, p2cwrite,
-                           c2pread, c2pwrite,
-                           errread, errwrite):
-            if not isinstance(args, types.StringTypes):
-                args = subprocess.list2cmdline(args)
-
-            if startupinfo is None:
-                startupinfo = winprocess.STARTUPINFO()
-            
-            if None not in (p2cread, c2pwrite, errwrite):
-                startupinfo.dwFlags |= winprocess.STARTF_USESTDHANDLES
-                
-                startupinfo.hStdInput = int(p2cread)
-                startupinfo.hStdOutput = int(c2pwrite)
-                startupinfo.hStdError = int(errwrite)
-            if shell:
-                startupinfo.dwFlags |= winprocess.STARTF_USESHOWWINDOW
-                startupinfo.wShowWindow = winprocess.SW_HIDE
-                comspec = os.environ.get("COMSPEC", "cmd.exe")
-                args = comspec + " /c " + args
-
-            # We create a new job for this process, so that we can kill
-            # the process and any sub-processes 
-            self._job = winprocess.CreateJobObject()
-
-            creationflags |= winprocess.CREATE_SUSPENDED
-            creationflags |= winprocess.CREATE_UNICODE_ENVIRONMENT
-
-            hp, ht, pid, tid = winprocess.CreateProcess(
-                executable, args,
-                None, None, # No special security
-                1, # Must inherit handles!
-                creationflags,
-                winprocess.EnvironmentBlock(env),
-                cwd, startupinfo)
-            
-            self._child_created = True
-            self._handle = hp
-            self._thread = ht
-            self.pid = pid
-
-            # XXX: A try/except to fix UAC-related problems under
-            # Windows Vista, when reparenting jobs.
-            try:
-                winprocess.AssignProcessToJobObject(self._job, hp)
-            except WindowsError:
-                pass
-            winprocess.ResumeThread(ht)
-
-            if p2cread is not None:
-                p2cread.Close()
-            if c2pwrite is not None:
-                c2pwrite.Close()
-            if errwrite is not None:
-                errwrite.Close()
-
-    def kill(self, group=True):
-        """Kill the process. If group=True, all sub-processes will also be killed."""
-        if mswindows:
-            if group:
-                winprocess.TerminateJobObject(self._job, 127)
-            else:
-                winprocess.TerminateProcess(self._handle, 127)
-            self.returncode = 127    
-        else:
-            if group:
-                os.killpg(self.pid, signal.SIGKILL)
-            else:
-                os.kill(self.pid, signal.SIGKILL)
-            self.returncode = -9
-
-
diff --git a/IPython/deathrow/oldfrontend/process/pipedprocess.py b/IPython/deathrow/oldfrontend/process/pipedprocess.py
deleted file mode 100644
index 1b145af2656..00000000000
--- a/IPython/deathrow/oldfrontend/process/pipedprocess.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# encoding: utf-8
-"""
-Object for encapsulating process execution by using callbacks for stdout, 
-stderr and stdin.
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-from killableprocess import Popen, PIPE
-from threading import Thread
-from time import sleep
-import os
-
-class PipedProcess(Thread):
-    """ Class that encapsulates process execution by using callbacks for
-        stdout, stderr and stdin, and providing a reliable way of
-        killing it.
-    """
-
-    def __init__(self, command_string, out_callback, 
-                        end_callback=None,):
-        """ command_string: the command line executed to start the
-        process. 
-
-        out_callback: the python callable called on stdout/stderr.
-
-        end_callback: an optional callable called when the process
-        finishes.
-
-        These callbacks are called from a different thread as the
-        thread from which is started.
-        """
-        self.command_string = command_string
-        self.out_callback = out_callback
-        self.end_callback = end_callback
-        Thread.__init__(self)
-    
-
-    def run(self):
-        """ Start the process and hook up the callbacks.
-        """
-        env = os.environ
-        env['TERM'] = 'xterm'
-        process = Popen(self.command_string + ' 2>&1', shell=True,
-                                env=env,
-                                universal_newlines=True,
-                                stdout=PIPE, stdin=PIPE, )
-        self.process = process
-        while True:
-            out_char = process.stdout.read(1)
-            if out_char == '':
-                if process.poll() is not None:
-                    # The process has finished
-                    break
-                else:
-                    # The process is not giving any interesting
-                    # output. No use polling it immediatly.
-                    sleep(0.1)
-            else:
-                self.out_callback(out_char)
-
-        if self.end_callback is not None:
-            self.end_callback()
-    
-
diff --git a/IPython/deathrow/oldfrontend/process/winprocess.py b/IPython/deathrow/oldfrontend/process/winprocess.py
deleted file mode 100644
index 18f778df057..00000000000
--- a/IPython/deathrow/oldfrontend/process/winprocess.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# A module to expose various thread/process/job related structures and
-# methods from kernel32
-#
-# The MIT License
-#
-# Copyright (c) 2006 the Mozilla Foundation <http://www.mozilla.org>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense,
-# and/or sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
-from ctypes import c_void_p, POINTER, sizeof, Structure, windll, WinError, WINFUNCTYPE
-from ctypes.wintypes import BOOL, BYTE, DWORD, HANDLE, LPCWSTR, LPWSTR, UINT, WORD
-
-LPVOID = c_void_p
-LPBYTE = POINTER(BYTE)
-LPDWORD = POINTER(DWORD)
-
-SW_HIDE = 0
-
-def ErrCheckBool(result, func, args):
-    """errcheck function for Windows functions that return a BOOL True
-    on success"""
-    if not result:
-        raise WinError()
-    return args
-
-# CloseHandle()
-
-CloseHandleProto = WINFUNCTYPE(BOOL, HANDLE)
-CloseHandle = CloseHandleProto(("CloseHandle", windll.kernel32))
-CloseHandle.errcheck = ErrCheckBool
-
-# AutoHANDLE
-
-class AutoHANDLE(HANDLE):
-    """Subclass of HANDLE which will call CloseHandle() on deletion."""
-    def Close(self):
-        if self.value:
-            CloseHandle(self)
-            self.value = 0
-    
-    def __del__(self):
-        self.Close()
-
-    def __int__(self):
-        return self.value
-
-def ErrCheckHandle(result, func, args):
-    """errcheck function for Windows functions that return a HANDLE."""
-    if not result:
-        raise WinError()
-    return AutoHANDLE(result)
-
-# PROCESS_INFORMATION structure
-
-class PROCESS_INFORMATION(Structure):
-    _fields_ = [("hProcess", HANDLE),
-                ("hThread", HANDLE),
-                ("dwProcessID", DWORD),
-                ("dwThreadID", DWORD)]
-
-    def __init__(self):
-        Structure.__init__(self)
-        
-        self.cb = sizeof(self)
-
-LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION)
-
-# STARTUPINFO structure
-
-class STARTUPINFO(Structure):
-    _fields_ = [("cb", DWORD),
-                ("lpReserved", LPWSTR),
-                ("lpDesktop", LPWSTR),
-                ("lpTitle", LPWSTR),
-                ("dwX", DWORD),
-                ("dwY", DWORD),
-                ("dwXSize", DWORD),
-                ("dwYSize", DWORD),
-                ("dwXCountChars", DWORD),
-                ("dwYCountChars", DWORD),
-                ("dwFillAttribute", DWORD),
-                ("dwFlags", DWORD),
-                ("wShowWindow", WORD),
-                ("cbReserved2", WORD),
-                ("lpReserved2", LPBYTE),
-                ("hStdInput", HANDLE),
-                ("hStdOutput", HANDLE),
-                ("hStdError", HANDLE)
-                ]
-LPSTARTUPINFO = POINTER(STARTUPINFO)
-
-STARTF_USESHOWWINDOW    = 0x01
-STARTF_USESIZE          = 0x02
-STARTF_USEPOSITION      = 0x04
-STARTF_USECOUNTCHARS    = 0x08
-STARTF_USEFILLATTRIBUTE = 0x10
-STARTF_RUNFULLSCREEN    = 0x20
-STARTF_FORCEONFEEDBACK  = 0x40
-STARTF_FORCEOFFFEEDBACK = 0x80
-STARTF_USESTDHANDLES    = 0x100
-
-# EnvironmentBlock
-
-class EnvironmentBlock:
-    """An object which can be passed as the lpEnv parameter of CreateProcess.
-    It is initialized with a dictionary."""
-
-    def __init__(self, dict):
-        if not dict:
-            self._as_parameter_ = None
-        else:
-            values = ["%s=%s" % (key, value)
-                      for (key, value) in dict.iteritems()]
-            values.append("")
-            self._as_parameter_ = LPCWSTR("\0".join(values))
-        
-# CreateProcess()
-
-CreateProcessProto = WINFUNCTYPE(BOOL,                  # Return type
-                                 LPCWSTR,               # lpApplicationName
-                                 LPWSTR,                # lpCommandLine
-                                 LPVOID,                # lpProcessAttributes
-                                 LPVOID,                # lpThreadAttributes
-                                 BOOL,                  # bInheritHandles
-                                 DWORD,                 # dwCreationFlags
-                                 LPVOID,                # lpEnvironment
-                                 LPCWSTR,               # lpCurrentDirectory
-                                 LPSTARTUPINFO,         # lpStartupInfo
-                                 LPPROCESS_INFORMATION  # lpProcessInformation
-                                 )
-
-CreateProcessFlags = ((1, "lpApplicationName", None),
-                      (1, "lpCommandLine"),
-                      (1, "lpProcessAttributes", None),
-                      (1, "lpThreadAttributes", None),
-                      (1, "bInheritHandles", True),
-                      (1, "dwCreationFlags", 0),
-                      (1, "lpEnvironment", None),
-                      (1, "lpCurrentDirectory", None),
-                      (1, "lpStartupInfo"),
-                      (2, "lpProcessInformation"))
-
-def ErrCheckCreateProcess(result, func, args):
-    ErrCheckBool(result, func, args)
-    # return a tuple (hProcess, hThread, dwProcessID, dwThreadID)
-    pi = args[9]
-    return AutoHANDLE(pi.hProcess), AutoHANDLE(pi.hThread), pi.dwProcessID, pi.dwThreadID
-
-CreateProcess = CreateProcessProto(("CreateProcessW", windll.kernel32),
-                                   CreateProcessFlags)
-CreateProcess.errcheck = ErrCheckCreateProcess
-
-CREATE_BREAKAWAY_FROM_JOB = 0x01000000
-CREATE_DEFAULT_ERROR_MODE = 0x04000000
-CREATE_NEW_CONSOLE = 0x00000010
-CREATE_NEW_PROCESS_GROUP = 0x00000200
-CREATE_NO_WINDOW = 0x08000000
-CREATE_SUSPENDED = 0x00000004
-CREATE_UNICODE_ENVIRONMENT = 0x00000400
-DEBUG_ONLY_THIS_PROCESS = 0x00000002
-DEBUG_PROCESS = 0x00000001
-DETACHED_PROCESS = 0x00000008
-
-# CreateJobObject()
-
-CreateJobObjectProto = WINFUNCTYPE(HANDLE,             # Return type
-                                   LPVOID,             # lpJobAttributes
-                                   LPCWSTR             # lpName
-                                   )
-
-CreateJobObjectFlags = ((1, "lpJobAttributes", None),
-                        (1, "lpName", None))
-
-CreateJobObject = CreateJobObjectProto(("CreateJobObjectW", windll.kernel32),
-                                       CreateJobObjectFlags)
-CreateJobObject.errcheck = ErrCheckHandle
-
-# AssignProcessToJobObject()
-
-AssignProcessToJobObjectProto = WINFUNCTYPE(BOOL,      # Return type
-                                            HANDLE,    # hJob
-                                            HANDLE     # hProcess
-                                            )
-AssignProcessToJobObjectFlags = ((1, "hJob"),
-                                 (1, "hProcess"))
-AssignProcessToJobObject = AssignProcessToJobObjectProto(
-    ("AssignProcessToJobObject", windll.kernel32),
-    AssignProcessToJobObjectFlags)
-AssignProcessToJobObject.errcheck = ErrCheckBool
-
-# ResumeThread()
-
-def ErrCheckResumeThread(result, func, args):
-    if result == -1:
-        raise WinError()
-
-    return args
-
-ResumeThreadProto = WINFUNCTYPE(DWORD,      # Return type
-                                HANDLE      # hThread
-                                )
-ResumeThreadFlags = ((1, "hThread"),)
-ResumeThread = ResumeThreadProto(("ResumeThread", windll.kernel32),
-                                 ResumeThreadFlags)
-ResumeThread.errcheck = ErrCheckResumeThread
-
-# TerminateJobObject()
-
-TerminateJobObjectProto = WINFUNCTYPE(BOOL,   # Return type
-                                      HANDLE, # hJob
-                                      UINT    # uExitCode
-                                      )
-TerminateJobObjectFlags = ((1, "hJob"),
-                           (1, "uExitCode", 127))
-TerminateJobObject = TerminateJobObjectProto(
-    ("TerminateJobObject", windll.kernel32),
-    TerminateJobObjectFlags)
-TerminateJobObject.errcheck = ErrCheckBool
-
-# WaitForSingleObject()
-
-WaitForSingleObjectProto = WINFUNCTYPE(DWORD,  # Return type
-                                       HANDLE, # hHandle
-                                       DWORD,  # dwMilliseconds
-                                       )
-WaitForSingleObjectFlags = ((1, "hHandle"),
-                            (1, "dwMilliseconds", -1))
-WaitForSingleObject = WaitForSingleObjectProto(
-    ("WaitForSingleObject", windll.kernel32),
-    WaitForSingleObjectFlags)
-
-INFINITE = -1
-WAIT_TIMEOUT = 0x0102
-WAIT_OBJECT_0 = 0x0
-WAIT_ABANDONED = 0x0080
-
-# GetExitCodeProcess()
-
-GetExitCodeProcessProto = WINFUNCTYPE(BOOL,    # Return type
-                                      HANDLE,  # hProcess
-                                      LPDWORD, # lpExitCode
-                                      )
-GetExitCodeProcessFlags = ((1, "hProcess"),
-                           (2, "lpExitCode"))
-GetExitCodeProcess = GetExitCodeProcessProto(
-    ("GetExitCodeProcess", windll.kernel32),
-    GetExitCodeProcessFlags)
-GetExitCodeProcess.errcheck = ErrCheckBool
diff --git a/IPython/deathrow/oldfrontend/tests/__init__.py b/IPython/deathrow/oldfrontend/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/deathrow/oldfrontend/tests/test_asyncfrontendbase.py b/IPython/deathrow/oldfrontend/tests/test_asyncfrontendbase.py
deleted file mode 100644
index c009f987616..00000000000
--- a/IPython/deathrow/oldfrontend/tests/test_asyncfrontendbase.py
+++ /dev/null
@@ -1,106 +0,0 @@
-# encoding: utf-8
-"""This file contains unittests for the asyncfrontendbase module."""
-
-#---------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team                         
-#                                                                           
-#  Distributed under the terms of the BSD License.  The full license is in  
-#  the file COPYING, distributed as part of this software.                  
-#---------------------------------------------------------------------------
-
-#---------------------------------------------------------------------------
-# Imports                                                                   
-#---------------------------------------------------------------------------
-
-from twisted.trial import unittest
-    
-from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
-from IPython.frontend import frontendbase 
-from IPython.kernel.engineservice import EngineService
-from IPython.testing.parametric import Parametric, parametric
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class FrontEndCallbackChecker(AsyncFrontEndBase):
-    """FrontEndBase subclass for checking callbacks"""
-    def __init__(self, engine=None, history=None):
-        super(FrontEndCallbackChecker, self).__init__(engine=engine, 
-                                                    history=history)
-        self.updateCalled = False
-        self.renderResultCalled = False
-        self.renderErrorCalled = False
-   
-    def update_cell_prompt(self, result, blockID=None):
-        self.updateCalled = True
-        return result
-   
-    def render_result(self, result):
-        self.renderResultCalled = True
-        return result
-    
-    def render_error(self, failure):
-        self.renderErrorCalled = True
-        return failure
-
-
-class TestAsyncFrontendBase(unittest.TestCase):
-    def setUp(self):
-        """Setup the EngineService and FrontEndBase"""
-        
-        self.fb = FrontEndCallbackChecker(engine=EngineService())
-    
-    def test_implements_IFrontEnd(self):
-        self.assert_(frontendbase.IFrontEnd.implementedBy(
-                                    AsyncFrontEndBase))
-    
-    def test_is_complete_returns_False_for_incomplete_block(self):
-        block = """def test(a):"""
-        self.assert_(self.fb.is_complete(block) == False)
-    
-    def test_is_complete_returns_True_for_complete_block(self):
-        block = """def test(a): pass"""
-        self.assert_(self.fb.is_complete(block))
-        block = """a=3"""
-        self.assert_(self.fb.is_complete(block))
-    
-    def test_blockID_added_to_result(self):
-        block = """3+3"""
-        d = self.fb.execute(block, blockID='TEST_ID')
-        d.addCallback(lambda r: self.assert_(r['blockID']=='TEST_ID'))
-        return d
-    
-    def test_blockID_added_to_failure(self):
-        block = "raise Exception()"
-        d = self.fb.execute(block,blockID='TEST_ID')
-        d.addErrback(lambda f: self.assert_(f.blockID=='TEST_ID'))
-        return d
-    
-    def test_callbacks_added_to_execute(self):
-        d = self.fb.execute("10+10")
-        d.addCallback(lambda r: self.assert_(self.fb.updateCalled and self.fb.renderResultCalled))
-        return d
-    
-    def test_error_callback_added_to_execute(self):
-        """Test that render_error called on execution error."""
-        
-        d = self.fb.execute("raise Exception()")
-        d.addErrback(lambda f: self.assert_(self.fb.renderErrorCalled))
-        return d
-    
-    def test_history_returns_expected_block(self):
-        """Make sure history browsing doesn't fail."""
-        
-        blocks = ["a=1","a=2","a=3"]
-        d = self.fb.execute(blocks[0])
-        d.addCallback(lambda _: self.fb.execute(blocks[1]))
-        d.addCallback(lambda _: self.fb.execute(blocks[2]))
-        d.addCallback(lambda _: self.assert_(self.fb.get_history_previous("")==blocks[-2]))
-        d.addCallback(lambda _: self.assert_(self.fb.get_history_previous("")==blocks[-3]))
-        d.addCallback(lambda _: self.assert_(self.fb.get_history_next()==blocks[-2]))
-        return d
-    
-    def test_history_returns_none_at_startup(self):        
-        self.assert_(self.fb.get_history_previous("")==None)
-        self.assert_(self.fb.get_history_next()==None)
diff --git a/IPython/deathrow/oldfrontend/tests/test_frontendbase.py b/IPython/deathrow/oldfrontend/tests/test_frontendbase.py
deleted file mode 100644
index f3f4e5addc3..00000000000
--- a/IPython/deathrow/oldfrontend/tests/test_frontendbase.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# encoding: utf-8
-"""
-Test the basic functionality of frontendbase. 
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is
-#  in the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-from IPython.frontend.frontendbase import FrontEndBase
-
-def test_iscomplete():
-    """ Check that is_complete works. 
-    """
-    f = FrontEndBase()
-    assert f.is_complete('(a + a)')
-    assert not f.is_complete('(a + a')
-    assert f.is_complete('1')
-    assert not f.is_complete('1 + ')
-    assert not f.is_complete('1 + \n\n')
-    assert f.is_complete('if True:\n  print 1\n')
-    assert not f.is_complete('if True:\n  print 1')
-    assert f.is_complete('def f():\n  print 1\n')
-
-if __name__ == '__main__':
-    test_iscomplete()
-
diff --git a/IPython/deathrow/oldfrontend/tests/test_linefrontend.py b/IPython/deathrow/oldfrontend/tests/test_linefrontend.py
deleted file mode 100644
index d0d53acf206..00000000000
--- a/IPython/deathrow/oldfrontend/tests/test_linefrontend.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# encoding: utf-8
-"""
-Test the LineFrontEnd 
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is
-#  in the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-from IPython.frontend.linefrontendbase import LineFrontEndBase
-from copy import deepcopy
-import nose.tools as nt
-
-class ConcreteLineFrontEnd(LineFrontEndBase):
-    """ A concrete class to test the LineFrontEndBase.
-    """
-    def capture_output(self):
-        pass
-
-    def release_output(self):
-        pass
-
-
-def test_is_complete():
-    """ Tests line completion heuristic.
-    """
-    frontend = ConcreteLineFrontEnd()
-    yield nt.assert_true, not frontend.is_complete('for x in \\')
-    yield nt.assert_true, not frontend.is_complete('for x in (1, ):')
-    yield nt.assert_true, frontend.is_complete('for x in (1, ):\n  pass')
-
-
diff --git a/IPython/deathrow/oldfrontend/tests/test_prefilterfrontend.py b/IPython/deathrow/oldfrontend/tests/test_prefilterfrontend.py
deleted file mode 100644
index 432225a77fb..00000000000
--- a/IPython/deathrow/oldfrontend/tests/test_prefilterfrontend.py
+++ /dev/null
@@ -1,268 +0,0 @@
-# encoding: utf-8
-"""
-Test process execution and IO redirection.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is
-#  in the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-from copy import copy, deepcopy
-from cStringIO import StringIO
-import string
-import sys
-
-from nose.tools import assert_equal
-
-from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
-from IPython.testing.globalipapp import get_ipython
-
-#-----------------------------------------------------------------------------
-# Support utilities
-#-----------------------------------------------------------------------------
-
-class TestPrefilterFrontEnd(PrefilterFrontEnd):
-    
-    input_prompt_template = string.Template('')
-    output_prompt_template = string.Template('')
-    banner = ''
-
-    def __init__(self):
-        self.out = StringIO()
-        PrefilterFrontEnd.__init__(self)
-        # Some more code for isolation (yeah, crazy)
-        self._on_enter()
-        self.out.flush()
-        self.out.reset()
-        self.out.truncate()
-
-    def write(self, string, *args, **kwargs):
-       self.out.write(string) 
-
-    def _on_enter(self):
-        self.input_buffer += '\n'
-        PrefilterFrontEnd._on_enter(self)
-
-
-def isolate_ipython0(func):
-    """ Decorator to isolate execution that involves an iptyhon0.
-
-        Notes
-        -----
-
-        Apply only to functions with no arguments. Nose skips functions
-        with arguments.
-    """
-    def my_func():
-        ip0 = get_ipython()
-        if ip0 is None:
-            return func()
-        # We have a real ipython running...
-        user_ns = ip0.user_ns
-        user_global_ns = ip0.user_global_ns
-
-        # Previously the isolation was attempted with a deep copy of the user
-        # dicts, but we found cases where this didn't work correctly. I'm not
-        # quite sure why, but basically it did damage the user namespace, such
-        # that later tests stopped working correctly.  Instead we use a simpler
-        # approach, just computing the list of added keys to the namespace and
-        # eliminating those afterwards.  Existing keys that may have been
-        # modified remain modified.  So far this has proven to be robust.
-
-        # Compute set of old local/global keys
-        old_locals = set(user_ns.keys())
-        old_globals = set(user_global_ns.keys())
-        try:
-            out = func()
-        finally:
-            # Find new keys, and if any, remove them
-            new_locals = set(user_ns.keys()) - old_locals
-            new_globals = set(user_global_ns.keys()) - old_globals
-            for k in new_locals:
-                del user_ns[k]
-            for k in new_globals:
-                del user_global_ns[k]
-        return out
-
-    my_func.__name__ = func.__name__
-    return my_func
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-@isolate_ipython0
-def test_execution():
-    """ Test execution of a command.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'print(1)'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    assert_equal(out_value, '1\n')
-
-
-@isolate_ipython0
-def test_multiline():
-    """ Test execution of a multiline command.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'if True:'
-    f._on_enter()
-    f.input_buffer += 'print 1'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, ''
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1\n'
-    f = TestPrefilterFrontEnd()
-    f.input_buffer='(1 +'
-    f._on_enter()
-    f.input_buffer += '0)'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, ''
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1\n'
-
-
-@isolate_ipython0
-def test_capture():
-    """ Test the capture of output in different channels.
-    """
-    # Test on the OS-level stdout, stderr.
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = \
-            'import os; out=os.fdopen(1, "w"); out.write("1") ; out.flush()'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1'
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = \
-            'import os; out=os.fdopen(2, "w"); out.write("1") ; out.flush()'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '1'
-
-     
-@isolate_ipython0
-def test_magic():
-    """ Test the magic expansion and history.
-    
-        This test is fairly fragile and will break when magics change.
-    """
-    f = TestPrefilterFrontEnd()
-    # Before checking the interactive namespace, make sure it's clear (it can
-    # otherwise pick up things stored in the user's local db)
-    f.input_buffer += '%reset -f'
-    f._on_enter()
-    f.complete_current_input()
-    # Now, run the %who magic and check output
-    f.input_buffer += '%who'
-    f._on_enter()
-    out_value = f.out.getvalue()
-    assert_equal(out_value, 'Interactive namespace is empty.\n')
-
-
-@isolate_ipython0
-def test_help():
-    """ Test object inspection.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer += "def f():"
-    f._on_enter()
-    f.input_buffer += "'foobar'"
-    f._on_enter()
-    f.input_buffer += "pass"
-    f._on_enter()
-    f._on_enter()
-    f.input_buffer += "f?"
-    f._on_enter()
-    assert 'traceback' not in f.last_result
-    ## XXX: ipython doctest magic breaks this. I have no clue why
-    #out_value = f.out.getvalue()
-    #assert out_value.split()[-1] == 'foobar' 
-
-
-@isolate_ipython0
-def test_completion_simple():
-    """ Test command-line completion on trivial examples.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'zzza = 1'
-    f._on_enter()
-    f.input_buffer = 'zzzb = 2'
-    f._on_enter()
-    f.input_buffer = 'zz'
-    f.complete_current_input()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '\nzzza zzzb '
-    yield assert_equal, f.input_buffer, 'zzz'
-
-
-@isolate_ipython0
-def test_completion_parenthesis():
-    """ Test command-line completion when a parenthesis is open.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'zzza = 1'
-    f._on_enter()
-    f.input_buffer = 'zzzb = 2'
-    f._on_enter()
-    f.input_buffer = 'map(zz'
-    f.complete_current_input()
-    out_value = f.out.getvalue()
-    yield assert_equal, out_value, '\nzzza zzzb '
-    yield assert_equal, f.input_buffer, 'map(zzz'
-
-
-@isolate_ipython0
-def test_completion_indexing():
-    """ Test command-line completion when indexing on objects.
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'a = [0]'
-    f._on_enter()
-    f.input_buffer = 'a[0].'
-    f.complete_current_input()
-
-    if sys.version_info[:2] >= (2,6):
-        # In Python 2.6, ints picked up a few non __ methods, so now there are
-        # no completions.
-        assert_equal(f.input_buffer, 'a[0].')
-    else:
-        # Right answer for 2.4/2.5
-        assert_equal(f.input_buffer, 'a[0].__')
-
-
-@isolate_ipython0
-def test_completion_equal():
-    """ Test command-line completion when the delimiter is "=", not " ".
-    """
-    f = TestPrefilterFrontEnd()
-    f.input_buffer = 'a=1.'
-    f.complete_current_input()
-    if sys.version_info[:2] >= (2,6):
-        # In Python 2.6, ints picked up a few non __ methods, so now there are
-        # no completions.
-        assert_equal(f.input_buffer, 'a=1.')
-    else:
-        # Right answer for 2.4/2.5
-        assert_equal(f.input_buffer, 'a=1.__')
-
-
-if __name__ == '__main__':
-    test_magic()
-    test_help()
-    test_execution()
-    test_multiline()
-    test_capture()
-    test_completion_simple()
-    test_completion_complex()
diff --git a/IPython/deathrow/oldfrontend/tests/test_process.py b/IPython/deathrow/oldfrontend/tests/test_process.py
deleted file mode 100644
index ca49c26f2a4..00000000000
--- a/IPython/deathrow/oldfrontend/tests/test_process.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# encoding: utf-8
-"""
-Test process execution and IO redirection.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is
-#  in the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from cStringIO import StringIO
-from time import sleep
-import sys
-
-from IPython.frontend.process import PipedProcess
-from IPython.testing import decorators as testdec
-
-
-def test_capture_out():
-    """ A simple test to see if we can execute a process and get the output.
-    """
-    s = StringIO()
-    p = PipedProcess('echo 1', out_callback=s.write, )
-    p.start()
-    p.join()
-    result = s.getvalue().rstrip()
-    assert result == '1'
-
-
-def test_io():
-    """ Checks that we can send characters on stdin to the process.
-    """
-    s = StringIO()
-    p = PipedProcess(sys.executable + ' -c "a = raw_input(); print a"', 
-                            out_callback=s.write, )
-    p.start()
-    test_string = '12345\n'
-    while not hasattr(p, 'process'):
-        sleep(0.1)
-    p.process.stdin.write(test_string)
-    p.join()
-    result = s.getvalue()
-    assert result == test_string
-
-
-@testdec.skip_win32
-def test_kill():
-    """ Check that we can kill a process, and its subprocess.
-    """
-    s = StringIO()
-    p = PipedProcess(sys.executable + ' -c "a = raw_input();"', 
-                            out_callback=s.write, )
-    p.start()
-    while not hasattr(p, 'process'):
-        sleep(0.1)
-    p.process.kill() 
-    assert p.process.poll() is not None
-
-
-if __name__ == '__main__':
-    test_capture_out()
-    test_io()
-    test_kill()
-
diff --git a/IPython/deathrow/oldfrontend/wx/__init__.py b/IPython/deathrow/oldfrontend/wx/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/deathrow/oldfrontend/wx/console_widget.py b/IPython/deathrow/oldfrontend/wx/console_widget.py
deleted file mode 100644
index 970a61d2aa4..00000000000
--- a/IPython/deathrow/oldfrontend/wx/console_widget.py
+++ /dev/null
@@ -1,625 +0,0 @@
-# encoding: utf-8
-"""
-A Wx widget to act as a console and input commands.
-
-This widget deals with prompts and provides an edit buffer
-restricted to after the last prompt.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is
-#  in the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import wx
-import wx.stc  as  stc
-
-from wx.py import editwindow
-import time
-import sys
-import string
-
-LINESEP = '\n'
-if sys.platform == 'win32':
-    LINESEP = '\n\r'
-
-import re
-
-# FIXME: Need to provide an API for non user-generated display on the
-# screen: this should not be editable by the user.
-#-------------------------------------------------------------------------------
-# Constants 
-#-------------------------------------------------------------------------------
-_COMPLETE_BUFFER_MARKER = 31
-_ERROR_MARKER = 30
-_INPUT_MARKER = 29
-
-_DEFAULT_SIZE = 10
-if sys.platform == 'darwin':
-    _DEFAULT_SIZE = 12
-
-_DEFAULT_STYLE = {
-    #background definition
-    'default'     : 'size:%d' % _DEFAULT_SIZE,
-    'bracegood'   : 'fore:#00AA00,back:#000000,bold',
-    'bracebad'    : 'fore:#FF0000,back:#000000,bold',
-
-    # Edge column: a number of None
-    'edge_column' : -1,
-
-    # properties for the various Python lexer styles
-    'comment'       : 'fore:#007F00',
-    'number'        : 'fore:#007F7F',
-    'string'        : 'fore:#7F007F,italic',
-    'char'          : 'fore:#7F007F,italic',
-    'keyword'       : 'fore:#00007F,bold',
-    'triple'        : 'fore:#7F0000',
-    'tripledouble'  : 'fore:#7F0000',
-    'class'         : 'fore:#0000FF,bold,underline',
-    'def'           : 'fore:#007F7F,bold',
-    'operator'      : 'bold',
-
-    # Default colors
-    'trace'         : '#FAFAF1', # Nice green
-    'stdout'        : '#FDFFD3', # Nice yellow
-    'stderr'        : '#FFF1F1', # Nice red
-
-    # Default scintilla settings
-    'antialiasing'  : True,
-    'carret_color'  : 'BLACK',
-    'background_color' :'WHITE', 
-
-    #prompt definition
-    'prompt_in1'    : \
-        '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02$number\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02',
-
-    'prompt_out': \
-        '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02$number\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02',
-    }
-
-# new style numbers
-_STDOUT_STYLE = 15
-_STDERR_STYLE = 16
-_TRACE_STYLE  = 17
-
-
-# system colors
-#SYS_COLOUR_BACKGROUND = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BACKGROUND)
-
-# Translation table from ANSI escape sequences to color. 
-ANSI_STYLES = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
-               '0;32': [2, 'GREEN'],           '0;33': [3, 'BROWN'],
-               '0;34': [4, 'BLUE'],            '0;35': [5, 'PURPLE'],
-               '0;36': [6, 'CYAN'],            '0;37': [7, 'LIGHT GREY'],
-               '1;30': [8, 'DARK GREY'],       '1;31': [9, 'RED'],
-               '1;32': [10, 'SEA GREEN'],      '1;33': [11, 'YELLOW'],
-               '1;34': [12, 'LIGHT BLUE'],     '1;35': 
-                                                 [13, 'MEDIUM VIOLET RED'],
-               '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
-
-# XXX: Maybe one day we should factor this code with coloransi. Right now
-# coloransi is hard to reuse and makes our code more complex.
-
-#we define platform specific fonts
-if wx.Platform == '__WXMSW__':
-    FACES = { 'times': 'Times New Roman',
-                'mono' : 'Courier New',
-                'helv' : 'Arial',
-                'other': 'Comic Sans MS',
-                'size' : 10,
-                'size2': 8,
-                }
-elif wx.Platform == '__WXMAC__':
-    FACES = { 'times': 'Times New Roman',
-                'mono' : 'Monaco',
-                'helv' : 'Arial',
-                'other': 'Comic Sans MS',
-                'size' : 10,
-                'size2': 8,
-                }
-else:
-    FACES = { 'times': 'Times',
-                'mono' : 'Courier',
-                'helv' : 'Helvetica',
-                'other': 'new century schoolbook',
-                'size' : 10,
-                'size2': 8,
-                }
- 
-
-#-----------------------------------------------------------------------------
-# The console widget class
-#-----------------------------------------------------------------------------
-
-class ConsoleWidget(editwindow.EditWindow):
-    """ Specialized styled text control view for console-like workflow.
-
-        This widget is mainly interested in dealing with the prompt and
-        keeping the cursor inside the editing line.
-    """
-
-    # This is where the title captured from the ANSI escape sequences are
-    # stored.
-    title = 'Console'
-
-    # Last prompt printed
-    last_prompt = ''
-
-    # The buffer being edited.
-    def _set_input_buffer(self, string):
-        self.SetSelection(self.current_prompt_pos, self.GetLength())
-        self.ReplaceSelection(string)
-        self.GotoPos(self.GetLength())
-
-    def _get_input_buffer(self):
-        """ Returns the text in current edit buffer.
-        """
-        input_buffer = self.GetTextRange(self.current_prompt_pos,
-                                                self.GetLength())
-        input_buffer = input_buffer.replace(LINESEP, '\n')
-        return input_buffer
-
-    input_buffer = property(_get_input_buffer, _set_input_buffer)
-
-    style = _DEFAULT_STYLE.copy()
-
-    # Translation table from ANSI escape sequences to color. Override
-    # this to specify your colors.
-    ANSI_STYLES = ANSI_STYLES.copy()
-    
-    # Font faces
-    faces = FACES.copy()
-                 
-    # Store the last time a refresh was done
-    _last_refresh_time = 0
-
-    #--------------------------------------------------------------------------
-    # Public API
-    #--------------------------------------------------------------------------
-    
-    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, 
-                        size=wx.DefaultSize, style=wx.WANTS_CHARS, ):
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        self.configure_scintilla()
-        # Track if 'enter' key as ever been processed
-        # This variable will only be reallowed until key goes up
-        self.enter_catched = False 
-        self.current_prompt_pos = 0
-
-        self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
-        self.Bind(wx.EVT_KEY_UP, self._on_key_up)
-    
-
-    def write(self, text, refresh=True):
-        """ Write given text to buffer, while translating the ansi escape
-            sequences.
-        """
-        # XXX: do not put print statements to sys.stdout/sys.stderr in 
-        # this method, the print statements will call this method, as 
-        # you will end up with an infinit loop
-        title = self.title_pat.split(text)
-        if len(title)>1:
-            self.title = title[-2]
-
-        text = self.title_pat.sub('', text)
-        segments = self.color_pat.split(text)
-        segment = segments.pop(0)
-        self.GotoPos(self.GetLength())
-        self.StartStyling(self.GetLength(), 0xFF)
-        try:
-            self.AppendText(segment)
-        except UnicodeDecodeError:
-            # XXX: Do I really want to skip the exception?
-            pass
-        
-        if segments:
-            for ansi_tag, text in zip(segments[::2], segments[1::2]):
-                self.StartStyling(self.GetLength(), 0xFF)
-                try:
-                    self.AppendText(text)
-                except UnicodeDecodeError:
-                    # XXX: Do I really want to skip the exception?
-                    pass
-
-                if ansi_tag not in self.ANSI_STYLES:
-                    style = 0
-                else:
-                    style = self.ANSI_STYLES[ansi_tag][0]
-
-                self.SetStyling(len(text), style) 
-                
-        self.GotoPos(self.GetLength())
-        if refresh:
-            current_time = time.time()
-            if current_time - self._last_refresh_time > 0.03:
-                if sys.platform == 'win32':
-                    wx.SafeYield()
-                else:
-                    wx.Yield()
-                #    self.ProcessEvent(wx.PaintEvent())
-                self._last_refresh_time = current_time 
-
-   
-    def new_prompt(self, prompt):
-        """ Prints a prompt at start of line, and move the start of the
-            current block there.
-
-            The prompt can be given with ascii escape sequences.
-        """
-        self.write(prompt, refresh=False)
-        # now we update our cursor giving end of prompt
-        self.current_prompt_pos = self.GetLength()
-        self.current_prompt_line = self.GetCurrentLine()
-        self.EnsureCaretVisible()
-        self.last_prompt = prompt
-
-
-    def continuation_prompt(self):
-        """ Returns the current continuation prompt.
-            We need to implement this method here to deal with the
-            ascii escape sequences cleaning up.
-        """
-        # ASCII-less prompt
-        ascii_less = ''.join(self.color_pat.split(self.last_prompt)[2::2])
-        return "."*(len(ascii_less)-2) + ': '
- 
-
-    def scroll_to_bottom(self):
-        maxrange = self.GetScrollRange(wx.VERTICAL)
-        self.ScrollLines(maxrange)
-
-
-    def pop_completion(self, possibilities, offset=0):
-        """ Pops up an autocompletion menu. Offset is the offset
-            in characters of the position at which the menu should
-            appear, relativ to the cursor.
-        """
-        self.AutoCompSetIgnoreCase(False)
-        self.AutoCompSetAutoHide(False)
-        self.AutoCompSetMaxHeight(len(possibilities))
-        self.AutoCompShow(offset, " ".join(possibilities))
-
-
-    def get_line_width(self):
-        """ Return the width of the line in characters.
-        """
-        return self.GetSize()[0]/self.GetCharWidth()
-
-
-    def configure_scintilla(self):
-        """ Set up all the styling option of the embedded scintilla
-            widget.
-        """
-        p = self.style.copy()
-        
-        # Marker for complete buffer.
-        self.MarkerDefine(_COMPLETE_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=p['trace'])
-
-        # Marker for current input buffer.
-        self.MarkerDefine(_INPUT_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=p['stdout'])
-        # Marker for tracebacks.
-        self.MarkerDefine(_ERROR_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=p['stderr'])
-
-        self.SetEOLMode(stc.STC_EOL_LF)
-
-        # Ctrl"+" or Ctrl "-" can be used to zoomin/zoomout the text inside 
-        # the widget
-        self.CmdKeyAssign(ord('+'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
-        self.CmdKeyAssign(ord('-'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
-        # Also allow Ctrl Shift "=" for poor non US keyboard users. 
-        self.CmdKeyAssign(ord('='), stc.STC_SCMOD_CTRL|stc.STC_SCMOD_SHIFT, 
-                                            stc.STC_CMD_ZOOMIN)
-        
-        # Keys: we need to clear some of the keys the that don't play
-        # well with a console.
-        self.CmdKeyClear(ord('D'), stc.STC_SCMOD_CTRL)
-        self.CmdKeyClear(ord('L'), stc.STC_SCMOD_CTRL)
-        self.CmdKeyClear(ord('T'), stc.STC_SCMOD_CTRL)
-        self.CmdKeyClear(ord('A'), stc.STC_SCMOD_CTRL)
-
-        self.SetEOLMode(stc.STC_EOL_CRLF)
-        self.SetWrapMode(stc.STC_WRAP_CHAR)
-        self.SetWrapMode(stc.STC_WRAP_WORD)
-        self.SetBufferedDraw(True)
-
-        self.SetUseAntiAliasing(p['antialiasing'])
-
-        self.SetLayoutCache(stc.STC_CACHE_PAGE)
-        self.SetUndoCollection(False)
-        self.SetUseTabs(True)
-        self.SetIndent(4)
-        self.SetTabWidth(4)
-
-        # we don't want scintilla's autocompletion to choose 
-        # automaticaly out of a single choice list, as we pop it up
-        # automaticaly
-        self.AutoCompSetChooseSingle(False)
-        self.AutoCompSetMaxHeight(10)
-        # XXX: this doesn't seem to have an effect.
-        self.AutoCompSetFillUps('\n')
-
-        self.SetMargins(3, 3) #text is moved away from border with 3px
-        # Suppressing Scintilla margins
-        self.SetMarginWidth(0, 0)
-        self.SetMarginWidth(1, 0)
-        self.SetMarginWidth(2, 0)
-
-        # Xterm escape sequences
-        self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
-        self.title_pat = re.compile('\x1b]0;(.*?)\x07')
-
-        # styles
-        
-        self.SetCaretForeground(p['carret_color'])
-        
-        background_color = p['background_color']
-            
-        if 'default' in p:
-            if 'back' not in p['default']:
-                p['default'] += ',back:%s' % background_color
-            if 'size' not in p['default']:
-                p['default'] += ',size:%s' % self.faces['size']
-            if 'face' not in p['default']:
-                p['default'] += ',face:%s' % self.faces['mono']
-            
-            self.StyleSetSpec(stc.STC_STYLE_DEFAULT, p['default'])
-        else:
-            self.StyleSetSpec(stc.STC_STYLE_DEFAULT, 
-                            "fore:%s,back:%s,size:%d,face:%s" 
-                            % (self.ANSI_STYLES['0;30'][1], 
-                               background_color,
-                               self.faces['size'], self.faces['mono']))
-        
-        self.StyleClearAll()
-        
-        # XXX: two lines below are usefull if not using the lexer        
-        #for style in self.ANSI_STYLES.values():
-        #    self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])        
-
-        # prompt definition
-        self.prompt_in1 = p['prompt_in1']
-        self.prompt_out = p['prompt_out']
-
-        self.output_prompt_template = string.Template(self.prompt_out)
-        self.input_prompt_template = string.Template(self.prompt_in1)
-
-        self.StyleSetSpec(_STDOUT_STYLE, p['stdout'])
-        self.StyleSetSpec(_STDERR_STYLE, p['stderr'])
-        self.StyleSetSpec(_TRACE_STYLE, p['trace'])
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT, p['bracegood'])
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD, p['bracebad'])
-        self.StyleSetSpec(stc.STC_P_COMMENTLINE, p['comment'])
-        self.StyleSetSpec(stc.STC_P_NUMBER, p['number'])
-        self.StyleSetSpec(stc.STC_P_STRING, p['string'])
-        self.StyleSetSpec(stc.STC_P_CHARACTER, p['char'])
-        self.StyleSetSpec(stc.STC_P_WORD, p['keyword'])
-        self.StyleSetSpec(stc.STC_P_WORD2, p['keyword'])
-        self.StyleSetSpec(stc.STC_P_TRIPLE, p['triple'])
-        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, p['tripledouble'])
-        self.StyleSetSpec(stc.STC_P_CLASSNAME, p['class'])
-        self.StyleSetSpec(stc.STC_P_DEFNAME, p['def'])
-        self.StyleSetSpec(stc.STC_P_OPERATOR, p['operator'])
-        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, p['comment'])
-
-        edge_column = p['edge_column']
-        if edge_column is not None and edge_column > 0:
-            #we add a vertical line to console widget
-            self.SetEdgeMode(stc.STC_EDGE_LINE)
-            self.SetEdgeColumn(edge_column)
- 
- 
-    #--------------------------------------------------------------------------
-    # EditWindow API
-    #--------------------------------------------------------------------------
-
-    def OnUpdateUI(self, event):
-        """ Override the OnUpdateUI of the EditWindow class, to prevent 
-            syntax highlighting both for faster redraw, and for more
-            consistent look and feel.
-        """
-
-       
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
-   
-    def _on_key_down(self, event, skip=True):
-        """ Key press callback used for correcting behavior for 
-            console-like interfaces: the cursor is constraint to be after
-            the last prompt.
-
-            Return True if event as been catched.
-        """
-        catched = True
-        # XXX: Would the right way to do this be to have a
-        #  dictionary at the instance level associating keys with
-        #  callbacks? How would we deal with inheritance? And Do the
-        #  different callbacks share local variables?
-
-        # Intercept some specific keys.
-        key_code = event.GetKeyCode()
-        if key_code == ord('L') and event.ControlDown() :
-            self.scroll_to_bottom()
-        elif key_code == ord('K') and event.ControlDown() :
-            self.input_buffer = ''
-        elif key_code == ord('A') and event.ControlDown() :
-            self.GotoPos(self.GetLength())
-            self.SetSelectionStart(self.current_prompt_pos)
-            self.SetSelectionEnd(self.GetCurrentPos())
-            catched = True
-        elif key_code == ord('E') and event.ControlDown() :
-            self.GotoPos(self.GetLength())
-            catched = True
-        elif key_code == wx.WXK_PAGEUP:
-            self.ScrollPages(-1)
-        elif key_code == wx.WXK_PAGEDOWN:
-            self.ScrollPages(1)
-        elif key_code == wx.WXK_HOME:
-            self.GotoPos(self.GetLength())
-        elif key_code == wx.WXK_END:
-            self.GotoPos(self.GetLength())
-        elif key_code == wx.WXK_UP and event.ShiftDown():
-            self.ScrollLines(-1)
-        elif key_code == wx.WXK_DOWN and event.ShiftDown():
-            self.ScrollLines(1)
-        else:
-            catched = False
-
-        if self.AutoCompActive():
-            event.Skip()
-        else:
-            if key_code in (13, wx.WXK_NUMPAD_ENTER):
-                # XXX: not catching modifiers, to be wx2.6-compatible
-                catched = True
-                if not self.enter_catched:
-                    self.CallTipCancel()
-                    if event.ShiftDown():
-                        # Try to force execution
-                        self.GotoPos(self.GetLength())
-                        self.write('\n' + self.continuation_prompt(), 
-                                        refresh=False)
-                        self._on_enter()
-                    else:
-                        self._on_enter()
-                    self.enter_catched = True
-
-            elif key_code == wx.WXK_HOME:
-                if not event.ShiftDown():
-                    self.GotoPos(self.current_prompt_pos)
-                    catched = True
-                else:
-                    # FIXME: This behavior is not ideal: if the selection
-                    # is already started, it will jump.
-                    self.SetSelectionStart(self.current_prompt_pos) 
-                    self.SetSelectionEnd(self.GetCurrentPos())
-                    catched = True
-
-            elif key_code == wx.WXK_UP:
-                if self.GetCurrentLine() > self.current_prompt_line:
-                    if self.GetCurrentLine() == self.current_prompt_line + 1 \
-                            and self.GetColumn(self.GetCurrentPos()) < \
-                                self.GetColumn(self.current_prompt_pos):
-                        self.GotoPos(self.current_prompt_pos)
-                    else:
-                        event.Skip()
-                catched = True
-
-            elif key_code in (wx.WXK_LEFT, wx.WXK_BACK):
-                if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
-                    event.Skip()
-                catched = True
-
-            elif key_code == wx.WXK_RIGHT:
-                if not self._keep_cursor_in_buffer(self.GetCurrentPos() + 1):
-                    event.Skip()
-                catched = True
-
-
-            elif key_code == wx.WXK_DELETE:
-                if not self._keep_cursor_in_buffer(self.GetCurrentPos() - 1):
-                    event.Skip()
-                catched = True
-
-            if skip and not catched:
-                # Put the cursor back in the edit region
-                if not self._keep_cursor_in_buffer():
-                    if not (self.GetCurrentPos() == self.GetLength()
-                                and key_code == wx.WXK_DELETE):
-                        event.Skip()
-                    catched = True
-
-        return catched
-
-
-    def _on_key_up(self, event, skip=True):
-        """ If cursor is outside the editing region, put it back.
-        """
-        if skip:
-            event.Skip()
-        self._keep_cursor_in_buffer()
-
-
-    # XXX:  I need to avoid the problem of having an empty glass;
-    def _keep_cursor_in_buffer(self, pos=None):
-        """ Checks if the cursor is where it is allowed to be. If not,
-            put it back.
-
-            Returns
-            -------
-            cursor_moved: Boolean
-                whether or not the cursor was moved by this routine.
-
-            Notes
-            ------
-                WARNING: This does proper checks only for horizontal
-                movements.
-        """
-        if pos is None:
-            current_pos = self.GetCurrentPos()
-        else:
-            current_pos = pos
-        if  current_pos < self.current_prompt_pos:
-            self.GotoPos(self.current_prompt_pos)
-            return True
-        line_num = self.LineFromPosition(current_pos)
-        if not current_pos > self.GetLength():
-            line_pos = self.GetColumn(current_pos)
-        else:
-            line_pos = self.GetColumn(self.GetLength())
-        line = self.GetLine(line_num)
-        # Jump the continuation prompt
-        continuation_prompt = self.continuation_prompt()
-        if ( line.startswith(continuation_prompt)
-                     and line_pos < len(continuation_prompt)):
-            if line_pos < 2:
-                # We are at the beginning of the line, trying to move
-                # forward: jump forward.
-                self.GotoPos(current_pos + 1 +
-                                    len(continuation_prompt) - line_pos)
-            else:
-                # Jump back up
-                self.GotoPos(self.GetLineEndPosition(line_num-1))
-            return True
-        elif ( current_pos > self.GetLineEndPosition(line_num) 
-                        and not current_pos == self.GetLength()): 
-            # Jump to next line
-            self.GotoPos(current_pos + 1 +
-                                    len(continuation_prompt))
-            return True
-
-        # We re-allow enter event processing
-        self.enter_catched = False 
-        return False
-
-
-if __name__ == '__main__':
-    # Some simple code to test the console widget.
-    class MainWindow(wx.Frame):
-        def __init__(self, parent, id, title):
-            wx.Frame.__init__(self, parent, id, title, size=(300, 250))
-            self._sizer = wx.BoxSizer(wx.VERTICAL)
-            self.console_widget = ConsoleWidget(self)
-            self._sizer.Add(self.console_widget, 1, wx.EXPAND)
-            self.SetSizer(self._sizer)
-            self.SetAutoLayout(1)
-            self.Show(True)
-
-    app = wx.PySimpleApp()
-    w = MainWindow(None, wx.ID_ANY, 'ConsoleWidget')
-    w.SetSize((780, 460))
-    w.Show()
-
-    app.MainLoop()
-
-
diff --git a/IPython/deathrow/oldfrontend/wx/ipythonx.py b/IPython/deathrow/oldfrontend/wx/ipythonx.py
deleted file mode 100644
index e4667b99dd7..00000000000
--- a/IPython/deathrow/oldfrontend/wx/ipythonx.py
+++ /dev/null
@@ -1,118 +0,0 @@
-"""
-Entry point for a simple application giving a graphical frontend to
-ipython.
-"""
-
-try:
-    import wx
-except ImportError, e:
-    e.args[0] = """%s
-________________________________________________________________________________
-You need wxPython to run this application.
-""" % e.args[0]
-    raise e
-
-from wx_frontend import WxController
-import __builtin__
-
-
-class IPythonXController(WxController):
-    """ Sub class of WxController that adds some application-specific
-        bindings.
-    """
-
-    debug = False
-
-    def __init__(self, *args, **kwargs):
-        WxController.__init__(self, *args, **kwargs)
-        self.ipython0.ask_exit = self.do_exit
-        # Scroll to top
-        maxrange = self.GetScrollRange(wx.VERTICAL)
-        self.ScrollLines(-maxrange)
-
-
-    def _on_key_down(self, event, skip=True):
-        # Intercept Ctrl-D to quit
-        if event.KeyCode == ord('D') and event.ControlDown() and \
-                self.input_buffer == '' and \
-                self._input_state == 'readline':
-            wx.CallAfter(self.ask_exit)
-        else:
-            WxController._on_key_down(self, event, skip=skip) 
-
-
-    def ask_exit(self):
-        """ Ask the user whether to exit.
-        """
-        self._input_state = 'subprocess'
-        self.write('\n', refresh=False)
-        self.capture_output()
-        self.ipython0.exit()
-        self.release_output()
-        if not self.ipython0.exit_now:
-            wx.CallAfter(self.new_prompt,
-                         self.input_prompt_template.substitute(
-                                number=self.last_result['number'] + 1))
-        else:
-            wx.CallAfter(wx.GetApp().Exit)
-        self.write('Exiting ...', refresh=False)
- 
-
-    def do_exit(self):
-        """ Exits the interpreter, kills the windows.
-        """
-        WxController.do_exit(self)
-        self.release_output()
-        wx.CallAfter(wx.Exit)
-
-
-
-class IPythonX(wx.Frame):
-    """ Main frame of the IPythonX app.
-    """
-
-    def __init__(self, parent, id, title, debug=False):
-        wx.Frame.__init__(self, parent, id, title, size=(300,250))
-        self._sizer = wx.BoxSizer(wx.VERTICAL)
-        self.shell = IPythonXController(self, debug=debug)
-        self._sizer.Add(self.shell, 1, wx.EXPAND)
-        self.SetSizer(self._sizer)
-        self.SetAutoLayout(1)
-        self.Show(True)
-        wx.EVT_CLOSE(self, self.on_close)
-
-        
-    def on_close(self, event):
-        """ Called on closing the windows. 
-            
-            Stops the event loop, to close all the child windows.
-        """
-        wx.CallAfter(wx.Exit)
-
-
-def main():
-    from optparse import OptionParser
-    usage = """usage: %prog [options]
-
-Simple graphical frontend to IPython, using WxWidgets."""
-    parser = OptionParser(usage=usage)
-    parser.add_option("-d", "--debug",
-                    action="store_true", dest="debug", default=False,
-                    help="Enable debug message for the wx frontend.")
-
-    options, args = parser.parse_args()
-
-    # Clear the options, to avoid having the ipython0 instance complain
-    import sys
-    sys.argv = sys.argv[:1]
-
-    app = wx.PySimpleApp()
-    frame = IPythonX(None, wx.ID_ANY, 'IPythonX', debug=options.debug)
-    frame.shell.SetFocus()
-    frame.shell.app = app
-    frame.SetSize((680, 460))
-
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/deathrow/oldfrontend/wx/wx_frontend.py b/IPython/deathrow/oldfrontend/wx/wx_frontend.py
deleted file mode 100644
index e22c91e6094..00000000000
--- a/IPython/deathrow/oldfrontend/wx/wx_frontend.py
+++ /dev/null
@@ -1,602 +0,0 @@
-# encoding: utf-8 -*- test-case-name:
-# FIXME: Need to add tests.
-# ipython1.frontend.wx.tests.test_wx_frontend -*-
-
-"""Classes to provide a Wx frontend to the
-IPython.kernel.core.interpreter.
-
-This class inherits from ConsoleWidget, that provides a console-like
-widget to provide a text-rendering widget suitable for a terminal.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#       Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-# Major library imports
-import re
-import __builtin__
-import sys
-from threading import Lock
-
-import wx
-from wx import stc
-
-# Ipython-specific imports.
-from IPython.frontend.process import PipedProcess
-from console_widget import ConsoleWidget, _COMPLETE_BUFFER_MARKER, \
-    _ERROR_MARKER, _INPUT_MARKER
-from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
-
-#-------------------------------------------------------------------------------
-# Classes to implement the Wx frontend
-#-------------------------------------------------------------------------------
-class WxController(ConsoleWidget, PrefilterFrontEnd):
-    """Classes to provide a Wx frontend to the
-    IPython.kernel.core.interpreter.
-
-    This class inherits from ConsoleWidget, that provides a console-like
-    widget to provide a text-rendering widget suitable for a terminal.
-    """
-    
-    # Print debug info on what is happening to the console.
-    debug = False
-
-    # The title of the terminal, as captured through the ANSI escape
-    # sequences.
-    def _set_title(self, title):
-            return self.Parent.SetTitle(title)
-
-    def _get_title(self):
-            return self.Parent.GetTitle()
-
-    title = property(_get_title, _set_title)
-
-
-    # The buffer being edited.
-    # We are duplicating the definition here because of multiple
-    # inheritence
-    def _set_input_buffer(self, string):
-        ConsoleWidget._set_input_buffer(self, string)
-        self._colorize_input_buffer()
-
-    def _get_input_buffer(self):
-        """ Returns the text in current edit buffer.
-        """
-        return ConsoleWidget._get_input_buffer(self)
-
-    input_buffer = property(_get_input_buffer, _set_input_buffer)
-
-
-    #--------------------------------------------------------------------------
-    # Private Attributes
-    #--------------------------------------------------------------------------
-
-    # A flag governing the behavior of the input. Can be:
-    #
-    #       'readline' for readline-like behavior with a prompt 
-    #            and an edit buffer.
-    #       'raw_input' similar to readline, but triggered by a raw-input
-    #           call. Can be used by subclasses to act differently.
-    #       'subprocess' for sending the raw input directly to a
-    #           subprocess.
-    #       'buffering' for buffering of the input, that will be used
-    #           when the input state switches back to another state.
-    _input_state = 'readline'
-
-    # Attribute to store reference to the pipes of a subprocess, if we
-    # are running any.
-    _running_process = False
-
-    # A queue for writing fast streams to the screen without flooding the
-    # event loop
-    _out_buffer = []
-
-    # A lock to lock the _out_buffer to make sure we don't empty it
-    # while it is being swapped
-    _out_buffer_lock = Lock()
-
-    # The different line markers used to higlight the prompts.
-    _markers = dict()
-
-    #--------------------------------------------------------------------------
-    # Public API
-    #--------------------------------------------------------------------------
- 
-    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN|wx.WANTS_CHARS,
-                 styledef=None,
-                 *args, **kwds):
-        """ Create Shell instance.
-
-            Parameters
-            -----------
-            styledef : dict, optional
-                styledef is the dictionary of options used to define the
-                style.
-        """
-        if styledef is not None:
-            self.style = styledef
-        ConsoleWidget.__init__(self, parent, id, pos, size, style)
-        PrefilterFrontEnd.__init__(self, **kwds)
-        
-        # Stick in our own raw_input:
-        self.ipython0.raw_input = self.raw_input
-
-        # A time for flushing the write buffer
-        BUFFER_FLUSH_TIMER_ID = 100
-        self._buffer_flush_timer = wx.Timer(self, BUFFER_FLUSH_TIMER_ID)
-        wx.EVT_TIMER(self, BUFFER_FLUSH_TIMER_ID, self._buffer_flush)
-
-        if 'debug' in kwds:
-            self.debug = kwds['debug']
-            kwds.pop('debug')
-
-        # Inject self in namespace, for debug
-        if self.debug:
-            self.shell.user_ns['self'] = self
-        # Inject our own raw_input in namespace
-        self.shell.user_ns['raw_input'] = self.raw_input
-        
-    def raw_input(self, prompt=''):
-        """ A replacement from python's raw_input.
-        """
-        self.new_prompt(prompt)
-        self._input_state = 'raw_input'
-        if hasattr(self, '_cursor'):
-            del self._cursor 
-        self.SetCursor(wx.StockCursor(wx.CURSOR_CROSS))
-        self.__old_on_enter = self._on_enter
-        event_loop = wx.EventLoop()
-        def my_on_enter():
-            event_loop.Exit()
-        self._on_enter = my_on_enter
-        # XXX: Running a separate event_loop. Ugly.
-        event_loop.Run() 
-        self._on_enter = self.__old_on_enter
-        self._input_state = 'buffering'
-        self._cursor = wx.BusyCursor()
-        return self.input_buffer.rstrip('\n')
-
-
-    def system_call(self, command_string):
-        self._input_state = 'subprocess'
-        event_loop = wx.EventLoop()
-        def _end_system_call():
-            self._input_state = 'buffering'
-            self._running_process = False
-            event_loop.Exit()
-
-        self._running_process = PipedProcess(command_string, 
-                    out_callback=self.buffered_write,
-                    end_callback = _end_system_call)
-        self._running_process.start()
-        # XXX: Running a separate event_loop. Ugly.
-        event_loop.Run() 
-        # Be sure to flush the buffer.
-        self._buffer_flush(event=None)
-
-
-    def do_calltip(self):
-        """ Analyse current and displays useful calltip for it.
-        """
-        if self.debug:
-            print >>sys.__stdout__, "do_calltip" 
-        separators =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
-        symbol = self.input_buffer
-        symbol_string = separators.split(symbol)[-1]
-        base_symbol_string = symbol_string.split('.')[0]
-        if base_symbol_string in self.shell.user_ns:
-            symbol = self.shell.user_ns[base_symbol_string]
-        elif base_symbol_string in self.shell.user_global_ns:
-            symbol = self.shell.user_global_ns[base_symbol_string]
-        elif base_symbol_string in __builtin__.__dict__:
-            symbol = __builtin__.__dict__[base_symbol_string]
-        else:
-            return False
-        try:
-            for name in symbol_string.split('.')[1:] + ['__doc__']:
-                symbol = getattr(symbol, name)
-            self.AutoCompCancel()
-            # Check that the symbol can indeed be converted to a string:
-            symbol += ''
-            wx.CallAfter(self.CallTipShow, self.GetCurrentPos(), symbol)
-        except:
-            # The retrieve symbol couldn't be converted to a string
-            pass
-
-
-    def _popup_completion(self, create=False):
-        """ Updates the popup completion menu if it exists. If create is 
-            true, open the menu.
-        """
-        if self.debug:
-            print >>sys.__stdout__, "_popup_completion" 
-        line = self.input_buffer
-        if (self.AutoCompActive() and line and not line[-1] == '.') \
-                    or create==True:
-            suggestion, completions = self.complete(line)
-            if completions:
-                offset = len(self._get_completion_text(line))
-                self.pop_completion(completions, offset=offset)
-                if self.debug:
-                    print >>sys.__stdout__, completions 
-
-
-    def buffered_write(self, text):
-        """ A write method for streams, that caches the stream in order
-            to avoid flooding the event loop.
-
-            This can be called outside of the main loop, in separate
-            threads.
-        """
-        self._out_buffer_lock.acquire()
-        self._out_buffer.append(text)
-        self._out_buffer_lock.release()
-        if not self._buffer_flush_timer.IsRunning():
-            wx.CallAfter(self._buffer_flush_timer.Start, 
-                                        milliseconds=100, oneShot=True)
-
-
-    def clear_screen(self):
-        """ Empty completely the widget.
-        """
-        self.ClearAll()
-        self.new_prompt(self.input_prompt_template.substitute(
-                                number=(self.last_result['number'] + 1)))
-
-
-    #--------------------------------------------------------------------------
-    # LineFrontEnd interface 
-    #--------------------------------------------------------------------------
- 
-    def execute(self, python_string, raw_string=None):
-        self._input_state = 'buffering'
-        self.CallTipCancel()
-        self._cursor = wx.BusyCursor()
-        if raw_string is None:
-            raw_string = python_string
-        end_line = self.current_prompt_line \
-                        + max(1,  len(raw_string.split('\n'))-1)
-        for i in range(self.current_prompt_line, end_line):
-            if i in self._markers:
-                self.MarkerDeleteHandle(self._markers[i])
-            self._markers[i] = self.MarkerAdd(i, _COMPLETE_BUFFER_MARKER)
-        # Use a callafter to update the display robustly under windows
-        def callback():
-            self.GotoPos(self.GetLength())
-            PrefilterFrontEnd.execute(self, python_string, 
-                                            raw_string=raw_string)
-        wx.CallAfter(callback)
-
-
-    def execute_command(self, command, hidden=False):
-        """ Execute a command, not only in the model, but also in the
-            view.
-        """
-        # XXX: This method needs to be integrated in the base fronted
-        # interface
-        if hidden:
-            return self.shell.execute(command)
-        else:
-            # XXX: we are not storing the input buffer previous to the
-            # execution, as this forces us to run the execution
-            # input_buffer a yield, which is not good.
-            ##current_buffer = self.shell.control.input_buffer
-            command = command.rstrip()
-            if len(command.split('\n')) > 1:
-                # The input command is several lines long, we need to
-                # force the execution to happen
-                command += '\n'
-            cleaned_command = self.prefilter_input(command)
-            self.input_buffer = command
-            # Do not use wx.Yield() (aka GUI.process_events()) to avoid
-            # recursive yields.
-            self.ProcessEvent(wx.PaintEvent())
-            self.write('\n')
-            if not self.is_complete(cleaned_command + '\n'):
-                self._colorize_input_buffer()
-                self.render_error('Incomplete or invalid input')
-                self.new_prompt(self.input_prompt_template.substitute(
-                                number=(self.last_result['number'] + 1)))
-                return False
-            self._on_enter()
-            return True
-
-
-    def save_output_hooks(self):    
-        self.__old_raw_input = __builtin__.raw_input
-        PrefilterFrontEnd.save_output_hooks(self)
-
-    def capture_output(self):
-        self.SetLexer(stc.STC_LEX_NULL)
-        PrefilterFrontEnd.capture_output(self)
-        __builtin__.raw_input = self.raw_input
-        
-    
-    def release_output(self):
-        __builtin__.raw_input = self.__old_raw_input
-        PrefilterFrontEnd.release_output(self)
-        self.SetLexer(stc.STC_LEX_PYTHON)
-
-
-    def after_execute(self):
-        PrefilterFrontEnd.after_execute(self)
-        # Clear the wait cursor
-        if hasattr(self, '_cursor'):
-            del self._cursor
-        self.SetCursor(wx.StockCursor(wx.CURSOR_CHAR))
-
-
-    def show_traceback(self):
-        start_line = self.GetCurrentLine()
-        PrefilterFrontEnd.show_traceback(self)
-        self.ProcessEvent(wx.PaintEvent())
-        #wx.Yield()
-        for i in range(start_line, self.GetCurrentLine()):
-            self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
-
-    
-    #--------------------------------------------------------------------------
-    # FrontEndBase interface 
-    #--------------------------------------------------------------------------
-    
-    def render_error(self, e):
-        start_line = self.GetCurrentLine()
-        self.write('\n' + e + '\n')
-        for i in range(start_line, self.GetCurrentLine()):
-            self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
-
-
-    #--------------------------------------------------------------------------
-    # ConsoleWidget interface 
-    #--------------------------------------------------------------------------
-
-    def new_prompt(self, prompt):
-        """ Display a new prompt, and start a new input buffer.
-        """
-        self._input_state = 'readline'
-        ConsoleWidget.new_prompt(self, prompt)
-        i = self.current_prompt_line
-        self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER)
-
-
-    def continuation_prompt(self, *args, **kwargs):
-        # Avoid multiple inheritence, be explicit about which
-        # parent method class gets called
-        return ConsoleWidget.continuation_prompt(self, *args, **kwargs)
-
-
-    def write(self, *args, **kwargs):
-        # Avoid multiple inheritence, be explicit about which
-        # parent method class gets called
-        return ConsoleWidget.write(self, *args, **kwargs)
-
-
-    def _on_key_down(self, event, skip=True):
-        """ Capture the character events, let the parent
-            widget handle them, and put our logic afterward.
-        """
-        # FIXME: This method needs to be broken down in smaller ones.
-        current_line_num = self.GetCurrentLine()
-        key_code = event.GetKeyCode()
-        if key_code in (ord('c'), ord('C')) and event.ControlDown():
-            # Capture Control-C
-            if self._input_state == 'subprocess':
-                if self.debug:
-                    print >>sys.__stderr__, 'Killing running process'
-                if hasattr(self._running_process, 'process'):
-                    self._running_process.process.kill()
-            elif self._input_state == 'buffering':
-                if self.debug:
-                    print >>sys.__stderr__, 'Raising KeyboardInterrupt'
-                raise KeyboardInterrupt
-                # XXX: We need to make really sure we
-                # get back to a prompt.
-        elif self._input_state == 'subprocess' and (
-                ( key_code <256 and not event.ControlDown() )
-                    or 
-                ( key_code in (ord('d'), ord('D')) and
-                  event.ControlDown())):
-            #  We are running a process, we redirect keys.
-            ConsoleWidget._on_key_down(self, event, skip=skip)
-            char = chr(key_code)
-            # Deal with some inconsistency in wx keycodes:
-            if char == '\r':
-                char = '\n'
-            elif not event.ShiftDown():
-                char = char.lower()
-            if event.ControlDown() and key_code in (ord('d'), ord('D')):
-                char = '\04'
-            self._running_process.process.stdin.write(char)
-            self._running_process.process.stdin.flush()
-        elif key_code in (ord('('), 57, 53):
-            # Calltips
-            event.Skip()
-            self.do_calltip()
-        elif self.AutoCompActive() and not key_code == ord('\t'):
-            event.Skip()
-            if key_code in (wx.WXK_BACK, wx.WXK_DELETE): 
-                wx.CallAfter(self._popup_completion, create=True)
-            elif not key_code in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
-                            wx.WXK_RIGHT, wx.WXK_ESCAPE):
-                wx.CallAfter(self._popup_completion)
-        else:
-            # Up history
-            if key_code == wx.WXK_UP and (
-                            event.ControlDown() or
-                            current_line_num == self.current_prompt_line
-                    ):
-                new_buffer = self.get_history_previous(
-                                            self.input_buffer)
-                if new_buffer is not None:
-                    self.input_buffer = new_buffer
-                    if self.GetCurrentLine() > self.current_prompt_line:
-                        # Go to first line, for seemless history up.
-                        self.GotoPos(self.current_prompt_pos)
-            # Down history
-            elif key_code == wx.WXK_DOWN and (
-                            event.ControlDown() or
-                            current_line_num == self.LineCount -1
-                    ):
-                new_buffer = self.get_history_next()
-                if new_buffer is not None:
-                    self.input_buffer = new_buffer
-            # Tab-completion
-            elif key_code == ord('\t'):
-                current_line, current_line_num = self.CurLine
-                if not re.match(r'^%s\s*$' % self.continuation_prompt(), 
-                                                            current_line):
-                    self.complete_current_input()
-                    if self.AutoCompActive():
-                        wx.CallAfter(self._popup_completion, create=True)
-                else:
-                    event.Skip()
-            elif key_code == wx.WXK_BACK:
-                # If characters where erased, check if we have to
-                # remove a line.
-                # XXX: What about DEL?
-                # FIXME: This logics should be in ConsoleWidget, as it is
-                # independant of IPython
-                current_line, _ = self.CurLine
-                current_pos = self.GetCurrentPos()
-                current_line_num = self.LineFromPosition(current_pos)
-                current_col = self.GetColumn(current_pos)
-                len_prompt = len(self.continuation_prompt())
-                if ( current_line.startswith(self.continuation_prompt())
-                                            and current_col == len_prompt):
-                    new_lines = []
-                    for line_num, line in enumerate(
-                                    self.input_buffer.split('\n')):
-                        if (line_num + self.current_prompt_line ==
-                                            current_line_num):
-                            new_lines.append(line[len_prompt:])
-                        else:
-                            new_lines.append('\n'+line)
-                    # The first character is '\n', due to the above
-                    # code:
-                    self.input_buffer = ''.join(new_lines)[1:]
-                    self.GotoPos(current_pos - 1 - len_prompt)
-                else:
-                    ConsoleWidget._on_key_down(self, event, skip=skip)
-            else:
-                ConsoleWidget._on_key_down(self, event, skip=skip)
-                        
-
-
-    def _on_key_up(self, event, skip=True):
-        """ Called when any key is released.
-        """
-        if event.GetKeyCode() in (59, ord('.')):
-            # Intercepting '.'
-            event.Skip()
-            wx.CallAfter(self._popup_completion, create=True)
-        else:
-            ConsoleWidget._on_key_up(self, event, skip=skip)
-        # Make sure the continuation_prompts are always followed by a 
-        # whitespace
-        new_lines = []
-        if self._input_state == 'readline':
-            position = self.GetCurrentPos()
-            continuation_prompt = self.continuation_prompt()[:-1]
-            for line in self.input_buffer.split('\n'):
-                if not line == continuation_prompt:
-                    new_lines.append(line)
-            self.input_buffer = '\n'.join(new_lines)
-            self.GotoPos(position)
-
-
-    def _on_enter(self):
-        """ Called on return key down, in readline input_state.
-        """
-        last_line_num = self.LineFromPosition(self.GetLength())
-        current_line_num = self.LineFromPosition(self.GetCurrentPos())
-        new_line_pos = (last_line_num - current_line_num)
-        if self.debug:
-            print >>sys.__stdout__, repr(self.input_buffer)
-        self.write('\n', refresh=False)
-        # Under windows scintilla seems to be doing funny
-        # stuff to the line returns here, but the getter for
-        # input_buffer filters this out.
-        if sys.platform == 'win32':
-            self.input_buffer = self.input_buffer
-        old_prompt_num = self.current_prompt_pos
-        has_executed = PrefilterFrontEnd._on_enter(self, 
-                                            new_line_pos=new_line_pos)
-        if old_prompt_num == self.current_prompt_pos:
-            # No execution has happened 
-            self.GotoPos(self.GetLineEndPosition(current_line_num + 1))
-        return has_executed
-
-
-    #--------------------------------------------------------------------------
-    # EditWindow API
-    #--------------------------------------------------------------------------
-
-    def OnUpdateUI(self, event):
-        """ Override the OnUpdateUI of the EditWindow class, to prevent 
-            syntax highlighting both for faster redraw, and for more
-            consistent look and feel.
-        """
-        if not self._input_state == 'readline':
-            ConsoleWidget.OnUpdateUI(self, event)
-
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
- 
-    def _buffer_flush(self, event):
-        """ Called by the timer to flush the write buffer.
-            
-            This is always called in the mainloop, by the wx timer.
-        """
-        self._out_buffer_lock.acquire()
-        _out_buffer = self._out_buffer
-        self._out_buffer = []
-        self._out_buffer_lock.release()
-        self.write(''.join(_out_buffer), refresh=False)
-
-
-    def _colorize_input_buffer(self):
-        """ Keep the input buffer lines at a bright color.
-        """
-        if not self._input_state in ('readline', 'raw_input'):
-            return
-        end_line = self.GetCurrentLine()
-        if not sys.platform == 'win32':
-            end_line += 1
-        for i in range(self.current_prompt_line, end_line):
-            if i in self._markers:
-                self.MarkerDeleteHandle(self._markers[i])
-            self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER)
-
-
-if __name__ == '__main__':
-    class MainWindow(wx.Frame):
-        def __init__(self, parent, id, title):
-            wx.Frame.__init__(self, parent, id, title, size=(300,250))
-            self._sizer = wx.BoxSizer(wx.VERTICAL)
-            self.shell = WxController(self)
-            self._sizer.Add(self.shell, 1, wx.EXPAND)
-            self.SetSizer(self._sizer)
-            self.SetAutoLayout(1)
-            self.Show(True)
-
-    app = wx.PySimpleApp()
-    frame = MainWindow(None, wx.ID_ANY, 'Ipython')
-    frame.shell.SetFocus()
-    frame.SetSize((680, 460))
-    self = frame.shell
-
-    app.MainLoop()
-
diff --git a/IPython/deathrow/oldfrontend/zopeinterface.py b/IPython/deathrow/oldfrontend/zopeinterface.py
deleted file mode 100644
index 2081be3f767..00000000000
--- a/IPython/deathrow/oldfrontend/zopeinterface.py
+++ /dev/null
@@ -1,27 +0,0 @@
-# encoding: utf-8
-# -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
-"""
-zope.interface mock. If zope is installed, this module provides a zope
-interface classes, if not it provides mocks for them.
-
-Classes provided: 
-Interface, Attribute, implements, classProvides
-"""
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-try:
-    from zope.interface import Interface, Attribute, implements, classProvides
-except ImportError:
-    #zope.interface is not available
-    Interface = object
-    def Attribute(name, doc): pass
-    def implements(interface): pass
-    def classProvides(interface): pass
-
diff --git a/IPython/deathrow/outputtrap.py b/IPython/deathrow/outputtrap.py
deleted file mode 100644
index c63c798a09f..00000000000
--- a/IPython/deathrow/outputtrap.py
+++ /dev/null
@@ -1,258 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Class to trap stdout and stderr and log them separately.
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2001-2004 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-import exceptions
-import sys
-from cStringIO import StringIO
-
-class OutputTrapError(exceptions.Exception):
-    """Exception for OutputTrap class."""
-
-    def __init__(self,args=None):
-        exceptions.Exception.__init__(self)
-        self.args = args
-
-class OutputTrap:
-
-    """Class to trap standard output and standard error. They get logged in
-    StringIO objects which are available as <instance>.out and
-    <instance>.err. The class also offers summary methods which format this
-    data a bit.
-
-    A word of caution: because it blocks messages, using this class can make
-    debugging very tricky. If you are having bizarre problems silently, try
-    turning your output traps off for a while. You can call the constructor
-    with the parameter debug=1 for these cases. This turns actual trapping
-    off, but you can keep the rest of your code unchanged (this has already
-    been a life saver).
-
-    Example:
-
-    # config: trapper with a line of dots as log separator (final '\\n' needed)
-    config = OutputTrap('Config','Out ','Err ','.'*80+'\\n')
-
-    # start trapping output
-    config.trap_all()
-
-    # now all output is logged ...
-    # do stuff...
-
-    # output back to normal:
-    config.release_all()
-
-    # print all that got logged:
-    print config.summary()
-
-    # print individual raw data:
-    print config.out.getvalue()
-    print config.err.getvalue()
-    """
-
-    def __init__(self,name='Generic Output Trap',
-                 out_head='Standard Output. ',err_head='Standard Error. ',
-                 sum_sep='\n',debug=0,trap_out=0,trap_err=0,
-                 quiet_out=0,quiet_err=0):
-        self.name = name
-        self.out_head = out_head
-        self.err_head = err_head
-        self.sum_sep = sum_sep
-        self.out = StringIO()
-        self.err = StringIO()
-        self.out_save = None
-        self.err_save = None
-        self.debug = debug
-        self.quiet_out = quiet_out
-        self.quiet_err = quiet_err
-        if trap_out:
-            self.trap_out()
-        if trap_err:
-            self.trap_err()
-
-    def trap_out(self):
-        """Trap and log stdout."""
-        if sys.stdout is self.out:
-            raise OutputTrapError,'You are already trapping stdout.'
-        if not self.debug:
-            self._out_save = sys.stdout
-            sys.stdout = self.out
-
-    def release_out(self):
-        """Release stdout."""
-        if not self.debug:
-            if not sys.stdout is self.out:
-                raise OutputTrapError,'You are not trapping stdout.'
-            sys.stdout = self._out_save
-            self.out_save = None
-
-    def summary_out(self):
-        """Return as a string the log from stdout."""
-        out = self.out.getvalue()
-        if out:
-            if self.quiet_out:
-                return out
-            else:
-                return self.out_head + 'Log by '+ self.name + ':\n' + out
-        else:
-            return ''
-
-    def flush_out(self):
-        """Flush the stdout log. All data held in the log is lost."""
-
-        self.out.close()
-        self.out = StringIO()
-
-    def trap_err(self):
-        """Trap and log stderr."""
-        if sys.stderr is self.err:
-            raise OutputTrapError,'You are already trapping stderr.'
-        if not self.debug:
-            self._err_save = sys.stderr
-            sys.stderr = self.err
-
-    def release_err(self):
-        """Release stderr."""
-        if not self.debug:
-            if not sys.stderr is self.err:
-                raise OutputTrapError,'You are not trapping stderr.'
-            sys.stderr = self._err_save
-            self.err_save = None
-
-    def summary_err(self):
-        """Return as a string the log from stderr."""
-        err = self.err.getvalue()
-        if err:
-            if self.quiet_err:
-                return err
-            else:
-                return self.err_head + 'Log by '+ self.name + ':\n' + err
-        else:
-            return ''
-
-    def flush_err(self):
-        """Flush the stdout log. All data held in the log is lost."""
-
-        self.err.close()
-        self.err = StringIO()
-
-    def trap_all(self):
-        """Trap and log both stdout and stderr.
-
-        Cacthes and discards OutputTrapError exceptions raised."""
-        try:
-            self.trap_out()
-        except OutputTrapError:
-            pass
-        try:
-            self.trap_err()
-        except OutputTrapError:
-            pass
-
-    def release_all(self):
-        """Release both stdout and stderr.
-
-        Cacthes and discards OutputTrapError exceptions raised."""
-        try:
-            self.release_out()
-        except OutputTrapError:
-            pass
-        try:
-            self.release_err()
-        except OutputTrapError:
-            pass
-        
-    def summary_all(self):
-        """Return as a string the log from stdout and stderr, prepending a separator
-        to each (defined in __init__ as sum_sep)."""
-        sum = ''
-        sout = self.summary_out()
-        if sout:
-            sum += self.sum_sep + sout
-        serr = self.summary_err()
-        if serr:
-            sum += '\n'+self.sum_sep + serr
-        return sum
-
-    def flush_all(self):
-        """Flush stdout and stderr"""
-        self.flush_out()
-        self.flush_err()
-
-    # a few shorthands
-    trap = trap_all
-    release = release_all
-    summary = summary_all
-    flush = flush_all
-# end OutputTrap
-
-
-#****************************************************************************
-# Module testing. Incomplete, I'm lazy...
-
-def _test_all():
-
-    """Module testing functions, activated when the module is called as a
-    script (not imported)."""
-
-    # Put tests for this module in here.
-    # Define them as nested functions so they don't clobber the
-    # pydoc-generated docs
-
-    def _test_():
-        name = ''
-        print '#'*50+'\nRunning test for ' + name
-        # ...
-        print 'Finished test for '+ name +'\n'+'#'*50
-
-    def _test_OutputTrap():
-        trap = OutputTrap(name = 'Test Trap', sum_sep = '.'*50+'\n',
-                          out_head = 'SOut. ', err_head = 'SErr. ')
-
-        name = 'OutputTrap class'
-        print '#'*50+'\nRunning test for ' + name
-        print 'Trapping out'
-        trap.trap_out()
-        print >>sys.stdout, '>>stdout. stdout is trapped.'
-        print >>sys.stderr, '>>stderr. stdout is trapped.'
-        trap.release_out()
-        print trap.summary_out()
-
-        print 'Trapping err'
-        trap.trap_err()
-        print >>sys.stdout, '>>stdout. stderr is trapped.'
-        print >>sys.stderr, '>>stderr. stderr is trapped.'
-        trap.release_err()
-        print trap.summary_err()
-
-        print 'Trapping all (no flushing)'
-        trap.trap_all()
-        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
-        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
-        trap.release_all()
-        print trap.summary_all()
-
-        print 'Trapping all (flushing first)'
-        trap.flush()
-        trap.trap_all()
-        print >>sys.stdout, '>>stdout. stdout/err is trapped.'
-        print >>sys.stderr, '>>stderr. stdout/err is trapped.'
-        trap.release_all()
-        print trap.summary_all()
-        print 'Finished test for '+ name +'\n'+'#'*50
-
-    # call the actual tests here:
-    _test_OutputTrap()
-
-
-if __name__=="__main__":
-    # _test_all() # XXX BROKEN.
-    pass
-
-#************************ end of file <OutputTrap.py> ************************
diff --git a/IPython/deathrow/quitter.py b/IPython/deathrow/quitter.py
deleted file mode 100755
index 19f7da079f6..00000000000
--- a/IPython/deathrow/quitter.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# coding: utf-8
-"""
-A simple class for quitting IPython.
-
-Authors
--------
-* Fernando Perez
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-class Quitter(object):
-    """Simple class to handle exit, similar to Python 2.5's.
-
-    It handles exiting in an ipython-safe manner, which the one in Python 2.5
-    doesn't do (obviously, since it doesn't know about ipython)."""
-    
-    def __init__(self, shell, name):
-        self.shell = shell
-        self.name = name
-        
-    def __str__(self):
-        return 'Type %s() to exit.' % self.name
-
-    def __call__(self):
-        self.shell.ask_exit()
-
-    # Repr MUST return a string, else display like pprint hooks get confused
-    def __repr__(self):
-        self.shell.ask_exit()
-        return ''
diff --git a/IPython/deathrow/scitedirector.py b/IPython/deathrow/scitedirector.py
deleted file mode 100644
index 86f35fa3278..00000000000
--- a/IPython/deathrow/scitedirector.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import win32api
-import win32gui
-import win32con
-
-import struct
-import array
-
-def findWindows():
-    ret = []
-    sdi = win32api.RegisterWindowMessage("SciTEDirectorInterface")
-    w = win32gui.GetWindow(win32gui.GetDesktopWindow(), win32con.GW_CHILD)
-    while w:
-        res = win32gui.SendMessage(w, sdi, 0, 0)
-        if res == sdi:
-            ret.append(w)
-        w = win32gui.GetWindow(w, win32con.GW_HWNDNEXT)
-
-    return ret
-
-def sendCommand(w, message):
-    CopyDataStruct = "IIP"
-    char_buffer = array.array('c', message)
-    char_buffer_address = char_buffer.buffer_info()[0]
-    char_buffer_size = char_buffer.buffer_info()[1]
-    cds = struct.pack(CopyDataStruct, 0, char_buffer_size, char_buffer_address)
-    win32gui.SendMessage(w, win32con.WM_COPYDATA, 0, cds)
diff --git a/IPython/deathrow/tests/__init__.py b/IPython/deathrow/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/deathrow/tests/test_prefilter.py b/IPython/deathrow/tests/test_prefilter.py
deleted file mode 100644
index 53fffca2643..00000000000
--- a/IPython/deathrow/tests/test_prefilter.py
+++ /dev/null
@@ -1,440 +0,0 @@
-"""
-Test which prefilter transformations get called for various input lines.
-Note that this does *not* test the transformations themselves -- it's just
-verifying that a particular combination of, e.g. config options and escape
-chars trigger the proper handle_X transform of the input line.
-
-Usage: run from the command line with *normal* python, not ipython:
-> python test_prefilter.py
-
-Fairly quiet output by default.  Pass in -v to get everyone's favorite dots.
-"""
-
-# The prefilter always ends in a call to some self.handle_X method.  We swap
-# all of those out so that we can capture which one was called.
-
-import sys
-sys.path.append('..')
-import IPython
-import IPython.ipapi
-
-verbose = False
-if len(sys.argv) > 1:
-    if sys.argv[1] == '-v':
-        sys.argv = sys.argv[:-1]  # IPython is confused by -v, apparently
-        verbose = True
-    
-IPython.Shell.start()
-
-ip = IPython.ipapi.get()
-
-# Collect failed tests + stats and print them at the end
-failures = []
-num_tests = 0
-
-# Store the results in module vars as we go
-last_line      = None
-handler_called = None
-def install_mock_handler(name):
-    """Swap out one of the IP.handle_x methods with a function which can
-    record which handler was called and what line was produced. The mock
-    handler func always returns '', which causes ipython to cease handling
-    the string immediately.  That way, that it doesn't echo output, raise
-    exceptions, etc.  But do note that testing multiline strings thus gets
-    a bit hard."""    
-    def mock_handler(self, line, continue_prompt=None,
-                     pre=None,iFun=None,theRest=None,
-                     obj=None):
-        #print "Inside %s with '%s'" % (name, line)
-        global last_line, handler_called
-        last_line = line
-        handler_called = name
-        return ''
-    mock_handler.name = name
-    setattr(IPython.iplib.InteractiveShell, name, mock_handler)
-
-install_mock_handler('handle_normal')
-install_mock_handler('handle_auto')
-install_mock_handler('handle_magic')
-install_mock_handler('handle_help')
-install_mock_handler('handle_shell_escape')
-install_mock_handler('handle_alias')
-install_mock_handler('handle_emacs')
-
-
-def reset_esc_handlers():
-    """The escape handlers are stored in a hash (as an attribute of the
-    InteractiveShell *instance*), so we have to rebuild that hash to get our
-    new handlers in there."""
-    s = ip.IP
-    s.esc_handlers = {s.ESC_PAREN  : s.handle_auto,
-                      s.ESC_QUOTE  : s.handle_auto,
-                      s.ESC_QUOTE2 : s.handle_auto,
-                      s.ESC_MAGIC  : s.handle_magic,
-                      s.ESC_HELP   : s.handle_help,
-                      s.ESC_SHELL  : s.handle_shell_escape,
-                      s.ESC_SH_CAP : s.handle_shell_escape,
-                      }
-reset_esc_handlers()
-    
-# This is so I don't have to quote over and over.  Gotta be a better way.
-handle_normal       = 'handle_normal'
-handle_auto         = 'handle_auto'
-handle_magic        = 'handle_magic'
-handle_help         = 'handle_help'
-handle_shell_escape = 'handle_shell_escape'
-handle_alias        = 'handle_alias'
-handle_emacs        = 'handle_emacs'
-
-def check(assertion, failure_msg):
-    """Check a boolean assertion and fail with a message if necessary. Store
-    an error essage in module-level failures list in case of failure.  Print
-    '.' or 'F' if module var Verbose is true.
-    """
-    global num_tests
-    num_tests += 1
-    if assertion:
-        if verbose:
-            sys.stdout.write('.')
-            sys.stdout.flush()        
-    else:
-        if verbose:
-            sys.stdout.write('F')
-            sys.stdout.flush()
-        failures.append(failure_msg)
-    
-
-def check_handler(expected_handler, line):
-    """Verify that the expected hander was called (for the given line,
-    passed in for failure reporting).
-    
-    Pulled out to its own function so that tests which don't use
-    run_handler_tests can still take advantage of it."""
-    check(handler_called == expected_handler,
-          "Expected %s to be called for %s, "
-          "instead %s called" % (expected_handler,
-                                 repr(line),
-                                 handler_called))
-    
-
-def run_handler_tests(h_tests):
-    """Loop through a series of (input_line, handler_name) pairs, verifying
-    that, for each ip calls the given handler for the given line. 
-
-    The verbose complaint includes the line passed in, so if that line can
-    include enough info to find the error, the tests are modestly
-    self-documenting.
-    """    
-    for ln, expected_handler in h_tests:
-        global handler_called
-        handler_called = None
-        ip.runlines(ln)
-        check_handler(expected_handler, ln)
-
-def run_one_test(ln, expected_handler):
-    run_handler_tests([(ln, expected_handler)])
-    
-
-# =========================================
-# Tests
-# =========================================
-
-
-# Fundamental escape characters + whitespace & misc
-# =================================================
-esc_handler_tests = [
-    ( '?thing',    handle_help,  ),
-    ( 'thing?',    handle_help ),  # '?' can trail...
-    ( 'thing!',    handle_normal), # but only '?' can trail
-    ( '   ?thing', handle_normal), # leading whitespace turns off esc chars
-    ( '!ls',       handle_shell_escape),
-    ( '! true',    handle_shell_escape),
-    ( '!! true',   handle_shell_escape),
-    ( '%magic',    handle_magic),
-    # XXX Possibly, add test for /,; once those are unhooked from %autocall
-    ( 'emacs_mode # PYTHON-MODE', handle_emacs ),
-    ( ' ',         handle_normal), 
-
-    # Trailing qmark combos.  Odd special cases abound
-
-    # ! always takes priority!
-    ( '!thing?',      handle_shell_escape), 
-    ( '!thing arg?',  handle_shell_escape),
-    ( '!!thing?',     handle_shell_escape),
-    ( '!!thing arg?', handle_shell_escape),
-    ( '    !!thing arg?', handle_shell_escape),
-
-    # For all other leading esc chars, we always trigger help
-    ( '%cmd?',     handle_help),
-    ( '%cmd ?',    handle_help),
-    ( '/cmd?',     handle_help),
-    ( '/cmd ?',    handle_help),
-    ( ';cmd?',     handle_help),
-    ( ',cmd?',     handle_help),
-    ]
-run_handler_tests(esc_handler_tests)
-
-
-
-# Shell Escapes in Multi-line statements
-# ======================================
-#
-# We can't test this via runlines, since the hacked-over-for-testing
-# handlers all return None, so continue_prompt never becomes true.  Instead
-# we drop into prefilter directly and pass in continue_prompt.
-
-old_mls = ip.options.multi_line_specials
-for ln in [ '    !ls $f multi_line_specials %s',
-            '    !!ls $f multi_line_specials %s',  # !! escapes work on mls
-            # Trailing ? doesn't trigger help:            
-            '    !ls $f multi_line_specials %s ?', 
-            '    !!ls $f multi_line_specials %s ?',
-            ]:
-    ip.options.multi_line_specials = 1
-    on_ln = ln % 'on'
-    ignore = ip.IP.prefilter(on_ln, continue_prompt=True)
-    check_handler(handle_shell_escape, on_ln)
-
-    ip.options.multi_line_specials = 0
-    off_ln = ln % 'off'
-    ignore = ip.IP.prefilter(off_ln, continue_prompt=True)
-    check_handler(handle_normal, off_ln)
-
-ip.options.multi_line_specials = old_mls
-
-
-# Automagic
-# =========
-
-# Pick one magic fun and one non_magic fun, make sure both exist
-assert hasattr(ip.IP, "magic_cpaste")
-assert not hasattr(ip.IP, "magic_does_not_exist")
-ip.options.autocall = 0 # gotta have this off to get handle_normal
-ip.options.automagic = 0
-run_handler_tests([
-    # Without automagic, only shows up with explicit escape
-    ( 'cpaste', handle_normal),
-    ( '%cpaste', handle_magic),
-    ( '%does_not_exist', handle_magic),
-    ])
-ip.options.automagic = 1
-run_handler_tests([
-    ( 'cpaste',          handle_magic),
-    ( '%cpaste',         handle_magic),
-    ( 'does_not_exist',  handle_normal),
-    ( '%does_not_exist', handle_magic),
-    ( 'cd /',            handle_magic),
-    ( 'cd = 2',          handle_normal),
-    ( 'r',               handle_magic),
-    ( 'r thing',         handle_magic),
-    ( 'r"str"',          handle_normal),
-    ])
-
-# If next elt starts with anything that could be an assignment, func call,
-# etc, we don't call the magic func, unless explicitly escaped to do so.
-#magic_killing_tests = []
-#for c in list('!=()<>,'):
-#    magic_killing_tests.append(('cpaste %s killed_automagic' % c, handle_normal))
-#    magic_killing_tests.append(('%%cpaste %s escaped_magic' % c,   handle_magic))
-#run_handler_tests(magic_killing_tests)
-
-# magic on indented continuation lines -- on iff multi_line_specials == 1
-ip.options.multi_line_specials = 0
-ln = '    cpaste multi_line off kills magic'
-ignore = ip.IP.prefilter(ln, continue_prompt=True)
-check_handler(handle_normal, ln)
-
-ip.options.multi_line_specials = 1
-ln = '    cpaste multi_line on enables magic'
-ignore = ip.IP.prefilter(ln, continue_prompt=True)
-check_handler(handle_magic, ln)
-
-# user namespace shadows the magic one unless shell escaped
-ip.user_ns['cpaste']     = 'user_ns'
-run_handler_tests([
-    ( 'cpaste',    handle_normal),
-    ( '%cpaste',   handle_magic)])
-del ip.user_ns['cpaste']
-
-
-
-# Check for !=() turning off .ofind
-# =================================
-class AttributeMutator(object):
-    """A class which will be modified on attribute access, to test ofind"""
-    def __init__(self):
-        self.called = False
-
-    def getFoo(self): self.called = True
-    foo = property(getFoo)
-
-attr_mutator = AttributeMutator()
-ip.to_user_ns('attr_mutator')
-
-ip.options.autocall = 1 
-
-run_one_test('attr_mutator.foo should mutate', handle_normal)
-check(attr_mutator.called, 'ofind should be called in absence of assign characters')
-
-for c in list('!=()<>+*/%^&|'): 
-    attr_mutator.called = False
-    run_one_test('attr_mutator.foo %s should *not* mutate' % c, handle_normal)
-    run_one_test('attr_mutator.foo%s should *not* mutate' % c, handle_normal)
-    
-    check(not attr_mutator.called,
-          'ofind should not be called near character %s' % c)
-
-
-
-# Alias expansion
-# ===============
-
-# With autocall on or off, aliases should be shadowed by user, internal and
-# __builtin__ namespaces
-#
-# XXX Can aliases have '.' in their name?  With autocall off, that works,
-# with autocall on, it doesn't.  Hmmm.
-import __builtin__
-for ac_state in [0,1]:
-    ip.options.autocall = ac_state
-    ip.IP.alias_table['alias_cmd'] = 'alias_result'
-    ip.IP.alias_table['alias_head.with_dot'] = 'alias_result'
-    run_handler_tests([
-        ("alias_cmd",           handle_alias),
-        # XXX See note above
-        #("alias_head.with_dot unshadowed, autocall=%s" % ac_state, handle_alias), 
-        ("alias_cmd.something aliases must match whole expr", handle_normal),
-        ("alias_cmd /", handle_alias),
-        ])
-
-    for ns in [ip.user_ns, ip.IP.internal_ns, __builtin__.__dict__ ]:
-        ns['alias_cmd'] = 'a user value'
-        ns['alias_head'] = 'a user value'
-        run_handler_tests([
-            ("alias_cmd",           handle_normal),
-            ("alias_head.with_dot", handle_normal)])
-        del ns['alias_cmd']
-        del ns['alias_head']
-
-ip.options.autocall = 1
-
-
-
-
-# Autocall
-# ========
-
-# For all the tests below, 'len' is callable / 'thing' is not
-
-# Objects which are instances of IPyAutocall are *always* autocalled
-import IPython.ipapi
-class Autocallable(IPython.ipapi.IPyAutocall):
-    def __call__(self):
-        return "called"
-    
-autocallable = Autocallable()
-ip.to_user_ns('autocallable')
-
-
-# First, with autocalling fully off
-ip.options.autocall = 0
-run_handler_tests( [
-    # With no escapes, no autocalling expansions happen, callable or not,
-    # unless the obj extends IPyAutocall
-    ( 'len autocall_0',     handle_normal),
-    ( 'thing autocall_0',   handle_normal),
-    ( 'autocallable',       handle_auto),
-    
-    # With explicit escapes, callable and non-callables both get expanded,
-    # regardless of the %autocall setting:
-    ( '/len autocall_0',    handle_auto),
-    ( ',len autocall_0 b0', handle_auto),
-    ( ';len autocall_0 b0', handle_auto),
-    
-    ( '/thing autocall_0',    handle_auto),
-    ( ',thing autocall_0 b0', handle_auto),
-    ( ';thing autocall_0 b0', handle_auto),
-
-    # Explicit autocall should not trigger if there is leading whitespace
-    ( ' /len autocall_0',    handle_normal),
-    ( ' ;len autocall_0',    handle_normal),
-    ( ' ,len autocall_0',    handle_normal),
-    ( ' / len autocall_0',   handle_normal),
-
-    # But should work if the whitespace comes after the esc char
-    ( '/ len autocall_0',    handle_auto),
-    ( '; len autocall_0',    handle_auto),
-    ( ', len autocall_0',    handle_auto),
-    ( '/  len autocall_0',   handle_auto),
-    ])
-
-
-# Now, with autocall in default, 'smart' mode
-ip.options.autocall = 1 
-run_handler_tests( [
-    # Autocalls without escapes -- only expand if it's callable
-    ( 'len a1',       handle_auto),
-    ( 'thing a1',     handle_normal),
-    ( 'autocallable', handle_auto),
-
-    # As above, all explicit escapes generate auto-calls, callable or not
-    ( '/len a1',      handle_auto),
-    ( ',len a1 b1',   handle_auto),
-    ( ';len a1 b1',   handle_auto),
-    ( '/thing a1',    handle_auto),
-    ( ',thing a1 b1', handle_auto),
-    ( ';thing a1 b1', handle_auto),
-
-    # Autocalls only happen on things which look like funcs, even if
-    # explicitly requested. Which, in this case means they look like a
-    # sequence of identifiers and . attribute references. Possibly the
-    # second of these two should trigger handle_auto.  But not for now.
-    ( '"abc".join range(4)',   handle_normal),
-    ( '/"abc".join range(4)',  handle_normal),
-    ])
-
-
-# No tests for autocall = 2, since the extra magic there happens inside the
-# handle_auto function, which our test doesn't examine.
-
-# Note that we leave autocall in default, 1, 'smart' mode
-
-
-# Autocall / Binary operators
-# ==========================
-
-# Even with autocall on, 'len in thing' won't transform.
-# But ';len in thing' will
-
-# Note, the tests below don't check for multi-char ops. It could.
-
-# XXX % is a binary op and should be in the list, too, but fails
-bin_ops = list(r'<>,&^|*/+-') + 'is not in and or'.split()
-bin_tests = []
-for b in bin_ops:
-    bin_tests.append(('len %s binop_autocall'  % b, handle_normal))
-    bin_tests.append((';len %s binop_autocall' % b, handle_auto))
-    bin_tests.append((',len %s binop_autocall' % b, handle_auto))
-    bin_tests.append(('/len %s binop_autocall' % b, handle_auto))
-    
-# Who loves auto-generating tests? 
-run_handler_tests(bin_tests)
-
-
-# Possibly add tests for namespace shadowing (really ofind's business?).
-#
-# user > ipython internal > python builtin > alias > magic
-
-
-# ============
-# Test Summary
-# ============
-num_f = len(failures)
-if verbose:
-    print 
-print "%s tests run, %s failure%s" % (num_tests,
-                                      num_f,
-                                      num_f != 1 and "s" or "")
-for f in failures:
-    print f
-
diff --git a/IPython/deathrow/twshell.py b/IPython/deathrow/twshell.py
deleted file mode 100644
index dd09e7e1022..00000000000
--- a/IPython/deathrow/twshell.py
+++ /dev/null
@@ -1,287 +0,0 @@
-"""Twisted shell support.
-
-XXX - This module is missing proper docs.
-"""
-# Tell nose to skip this module
-__test__ = {}
-
-import sys
-
-from twisted.internet import reactor, threads
-
-from IPython.core.ipmaker import make_IPython
-from IPython.core.iplib import InteractiveShell 
-from IPython.utils.ipstruct import Struct
-import Queue,thread,threading,signal
-from signal import signal, SIGINT
-import IPython.utils.io, ask_yes_no
-from IPython.utils.warn import warn, error
-from IPython.utils.decorators import flag_calls
-from IPython.core import shellglobals
-
-def install_gtk2():
-    """ Install gtk2 reactor, needs to be called bef """
-    from twisted.internet import gtk2reactor
-    gtk2reactor.install()
-
-
-def hijack_reactor():
-    """Modifies Twisted's reactor with a dummy so user code does
-    not block IPython.  This function returns the original
-    'twisted.internet.reactor' that has been hijacked.
-
-    NOTE: Make sure you call this *AFTER* you've installed
-    the reactor of your choice.
-    """
-    from twisted import internet
-    orig_reactor = internet.reactor
-
-    class DummyReactor(object):
-        def run(self):
-            pass
-        def __getattr__(self, name):
-            return getattr(orig_reactor, name)
-        def __setattr__(self, name, value):
-            return setattr(orig_reactor, name, value)
-    
-    internet.reactor = DummyReactor()
-    return orig_reactor
-
-class TwistedInteractiveShell(InteractiveShell):
-    """Simple multi-threaded shell."""
-
-    # Threading strategy taken from:
-    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by Brian
-    # McErlean and John Finlay.  Modified with corrections by Antoon Pardon,
-    # from the pygtk mailing list, to avoid lockups with system calls.
-
-    # class attribute to indicate whether the class supports threads or not.
-    # Subclasses with thread support should override this as needed.
-    isthreaded = True
-
-    def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
-                 user_ns=None,user_global_ns=None,banner2='',**kw):
-        """Similar to the normal InteractiveShell, but with threading control"""
-        
-        InteractiveShell.__init__(self,name,usage,rc,user_ns,
-                                  user_global_ns,banner2)
-
-
-        # A queue to hold the code to be executed. 
-        self.code_queue = Queue.Queue()
-
-        # Stuff to do at closing time
-        self._kill = None
-        on_kill = kw.get('on_kill', [])
-        # Check that all things to kill are callable:
-        for t in on_kill:
-            if not callable(t):
-                raise TypeError,'on_kill must be a list of callables'
-        self.on_kill = on_kill
-        # thread identity of the "worker thread" (that may execute code directly)
-        self.worker_ident = None
-        self.reactor_started = False
-        self.first_run = True
-        
-    def runsource(self, source, filename="<input>", symbol="single"):
-        """Compile and run some source in the interpreter.
-
-        Modified version of code.py's runsource(), to handle threading issues.
-        See the original for full docstring details."""
-        
-        # If Ctrl-C was typed, we reset the flag and return right away
-        if shellglobals.KBINT:
-            shellglobals.KBINT = False
-            return False
-
-        if self._kill:
-            # can't queue new code if we are being killed
-            return True
-        
-        try:
-            code = self.compile(source, filename, symbol)
-        except (OverflowError, SyntaxError, ValueError):
-            # Case 1
-            self.showsyntaxerror(filename)
-            return False
-
-        if code is None:
-            # Case 2
-            return True
-
-        # shortcut - if we are in worker thread, or the worker thread is not running, 
-        # execute directly (to allow recursion and prevent deadlock if code is run early 
-        # in IPython construction)
-        
-        if (not self.reactor_started or (self.worker_ident is None and not self.first_run) 
-            or self.worker_ident == thread.get_ident() or shellglobals.run_in_frontend(source)):
-            InteractiveShell.runcode(self,code)
-            return
-
-        # Case 3
-        # Store code in queue, so the execution thread can handle it.
- 
-        self.first_run = False
-        completed_ev, received_ev = threading.Event(), threading.Event() 
-        
-        self.code_queue.put((code,completed_ev, received_ev))
-
-        reactor.callLater(0.0,self.runcode)
-        received_ev.wait(5)
-        if not received_ev.isSet():
-            # the mainloop is dead, start executing code directly
-            print "Warning: Timeout for mainloop thread exceeded"
-            print "switching to nonthreaded mode (until mainloop wakes up again)"
-            self.worker_ident = None
-        else:            
-            completed_ev.wait()
-        
-        return False
-
-    def runcode(self):
-        """Execute a code object.
-
-        Multithreaded wrapper around IPython's runcode()."""
-        
-        
-        # we are in worker thread, stash out the id for runsource() 
-        self.worker_ident = thread.get_ident()
-
-        if self._kill:
-            print >>Term.cout, 'Closing threads...',
-            Term.cout.flush()
-            for tokill in self.on_kill:
-                tokill()
-            print >>Term.cout, 'Done.'
-            # allow kill() to return
-            self._kill.set()
-            return True
-
-        # Install SIGINT handler.  We do it every time to ensure that if user
-        # code modifies it, we restore our own handling.
-        try:
-            pass
-            signal(SIGINT,shellglobals.sigint_handler)
-        except SystemError:
-            # This happens under Windows, which seems to have all sorts
-            # of problems with signal handling.  Oh well...
-            pass
-
-        # Flush queue of pending code by calling the run methood of the parent
-        # class with all items which may be in the queue.
-        code_to_run = None
-        while 1:
-            try:
-                code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()                
-            except Queue.Empty:
-                break
-            received_ev.set()
-
-            
-            # Exceptions need to be raised differently depending on which
-            # thread is active.  This convoluted try/except is only there to
-            # protect against asynchronous exceptions, to ensure that a shellglobals.KBINT
-            # at the wrong time doesn't deadlock everything.  The global
-            # CODE_TO_RUN is set to true/false as close as possible to the
-            # runcode() call, so that the KBINT handler is correctly informed.
-            try:
-                try:
-                   shellglobals.CODE_RUN = True
-                   InteractiveShell.runcode(self,code_to_run)
-                except KeyboardInterrupt:
-                   print "Keyboard interrupted in mainloop"
-                   while not self.code_queue.empty():
-                      code = self.code_queue.get_nowait()
-                   break
-            finally:
-                shellglobals.CODE_RUN = False
-                # allow runsource() return from wait
-                completed_ev.set()                
-        
-        # This MUST return true for gtk threading to work
-        return True
-
-    def kill(self):
-        """Kill the thread, returning when it has been shut down."""
-        self._kill = threading.Event()
-        reactor.callLater(0.0,self.runcode)
-        self._kill.wait()
-
-
-
-class IPShellTwisted:
-    """Run a Twisted reactor while in an IPython session.
-
-    Python commands can be passed to the thread where they will be
-    executed.  This is implemented by periodically checking for
-    passed code using a Twisted reactor callback.
-    """
-
-    TIMEOUT = 0.01 # Millisecond interval between reactor runs.
-
-    def __init__(self, argv=None, user_ns=None, debug=1,
-                 shell_class=TwistedInteractiveShell):
-
-        from twisted.internet import reactor
-        self.reactor = hijack_reactor()
-
-        mainquit = self.reactor.stop
-
-        # Make sure IPython keeps going after reactor stop.
-        def reactorstop():
-            pass
-        self.reactor.stop = reactorstop
-        reactorrun_orig = self.reactor.run
-        self.quitting = False
-        def reactorrun():
-            while True and not self.quitting:
-                reactorrun_orig()
-        self.reactor.run = reactorrun
-        
-        self.IP = make_IPython(argv, user_ns=user_ns, debug=debug,
-                               shell_class=shell_class,
-                               on_kill=[mainquit])
-
-        # threading.Thread.__init__(self)
-
-    def run(self):
-        self.IP.mainloop()
-        self.quitting = True
-        self.IP.kill()
-
-    def mainloop(self):
-        def mainLoopThreadDeath(r):
-            print "mainLoopThreadDeath: ", str(r)
-        def spawnMainloopThread():
-            d=threads.deferToThread(self.run)
-            d.addBoth(mainLoopThreadDeath)
-        reactor.callWhenRunning(spawnMainloopThread)
-        self.IP.reactor_started = True
-        self.reactor.run()
-        print "mainloop ending...."   
-        
-exists = True
-
-
-if __name__ == '__main__':
-    # Sample usage.
-
-    # Create the shell object. This steals twisted.internet.reactor
-    # for its own purposes, to make sure you've already installed a
-    # reactor of your choice.
-    shell = IPShellTwisted(
-        argv=[],
-        user_ns={'__name__': '__example__',
-                 'hello': 'world',
-                 },
-        )
-
-    # Run the mainloop.  This runs the actual reactor.run() method.
-    # The twisted.internet.reactor object at this point is a dummy
-    # object that passes through to the actual reactor, but prevents
-    # run() from being called on it again.
-    shell.mainloop()
-
-    # You must exit IPython to terminate your program.
-    print 'Goodbye!'
-
diff --git a/IPython/display.py b/IPython/display.py
new file mode 100644
index 00000000000..da8982d6e2d
--- /dev/null
+++ b/IPython/display.py
@@ -0,0 +1,41 @@
+"""Public API for display tools in IPython."""
+
+# -----------------------------------------------------------------------------
+#       Copyright (C) 2012 The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+from IPython.core.display_functions import *
+from IPython.core.display import (
+    display_pretty as display_pretty,
+    display_html as display_html,
+    display_markdown as display_markdown,
+    display_svg as display_svg,
+    display_png as display_png,
+    display_jpeg as display_jpeg,
+    display_latex as display_latex,
+    display_json as display_json,
+    display_javascript as display_javascript,
+    display_pdf as display_pdf,
+    DisplayObject as DisplayObject,
+    TextDisplayObject as TextDisplayObject,
+    Pretty as Pretty,
+    HTML as HTML,
+    Markdown as Markdown,
+    Math as Math,
+    Latex as Latex,
+    SVG as SVG,
+    ProgressBar as ProgressBar,
+    JSON as JSON,
+    GeoJSON as GeoJSON,
+    Javascript as Javascript,
+    Image as Image,
+    Video as Video,
+)
+from IPython.lib.display import *
diff --git a/IPython/extensions/autoreload.py b/IPython/extensions/autoreload.py
new file mode 100644
index 00000000000..d67c9daa897
--- /dev/null
+++ b/IPython/extensions/autoreload.py
@@ -0,0 +1,915 @@
+"""IPython extension to reload modules before executing user code.
+
+``autoreload`` reloads modules automatically before entering the execution of
+code typed at the IPython prompt.
+
+This makes for example the following workflow possible:
+
+.. sourcecode:: ipython
+
+   In [1]: %load_ext autoreload
+
+   In [2]: %autoreload 2
+
+   In [3]: from foo import some_function
+
+   In [4]: some_function()
+   Out[4]: 42
+
+   In [5]: # open foo.py in an editor and change some_function to return 43
+
+   In [6]: some_function()
+   Out[6]: 43
+
+The module was reloaded without reloading it explicitly, and the object
+imported with ``from foo import ...`` was also updated.
+
+Usage
+=====
+
+The following magic commands are provided:
+
+``%autoreload``, ``%autoreload now``
+
+    Reload all modules (except those excluded by ``%aimport``)
+    automatically now.
+
+``%autoreload 0``, ``%autoreload off``
+
+    Disable automatic reloading.
+
+``%autoreload 1``, ``%autoreload explicit``
+
+    Reload all modules imported with ``%aimport`` every time before
+    executing the Python code typed.
+
+``%autoreload 2``, ``%autoreload all``
+
+    Reload all modules (except those excluded by ``%aimport``) every
+    time before executing the Python code typed.
+
+``%autoreload 3``, ``%autoreload complete``
+
+    Same as 2/all, but also adds any new objects in the module. See
+    unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects
+
+  Adding ``--print`` or ``-p`` to the ``%autoreload`` line will print autoreload activity to
+  standard out. ``--log`` or ``-l`` will do it to the log at INFO level; both can be used
+  simultaneously.
+
+``%aimport``
+
+    List modules which are to be automatically imported or not to be imported.
+
+``%aimport foo``
+
+    Import module 'foo' and mark it to be autoreloaded for ``%autoreload 1``
+
+``%aimport foo, bar``
+
+    Import modules 'foo', 'bar' and mark them to be autoreloaded for ``%autoreload 1``
+
+``%aimport -foo``
+
+    Mark module 'foo' to not be autoreloaded.
+
+Import Conflict Resolution
+==========================
+
+In ``%autoreload 3`` mode, the extension tracks ``from X import Y`` style imports
+and intelligently resolves conflicts when the same name is imported multiple ways.
+
+Import tracking occurs after successful code execution, ensuring that only valid
+imports are tracked. This approach handles edge cases such as:
+
+- Importing a name that doesn't initially exist in a module, then adding that name
+  to the module and importing it again
+- Conflicts between aliased imports (``from X import Y as Z``) and direct imports
+  (``from X import Z``)
+
+When conflicts occur:
+
+- If you first do ``from X import Y as Z`` then later ``from X import Z``,
+  the extension will switch to reloading ``Z`` instead of ``Y`` under the name ``Z``.
+
+- Similarly, if you first do ``from X import Z`` then later ``from X import Y as Z``,
+  the extension will switch to reloading ``Y`` as ``Z`` instead of the original ``Z``.
+
+- The most recent successful import always takes precedence in conflict resolution.
+
+Caveats
+=======
+
+Reloading Python modules in a reliable way is in general difficult,
+and unexpected things may occur. ``%autoreload`` tries to work around
+common pitfalls by replacing function code objects and parts of
+classes previously in the module with new versions. This makes the
+following things to work:
+
+- Functions and classes imported via 'from xxx import foo' are upgraded
+  to new versions when 'xxx' is reloaded.
+
+- Methods and properties of classes are upgraded on reload, so that
+  calling 'c.foo()' on an object 'c' created before the reload causes
+  the new code for 'foo' to be executed.
+
+Some of the known remaining caveats are:
+
+- Replacing code objects does not always succeed: changing a @property
+  in a class to an ordinary method or a method to a member variable
+  can cause problems (but in old objects only).
+
+- Functions that are removed (eg. via monkey-patching) from a module
+  before it is reloaded are not upgraded.
+
+- C extension modules cannot be reloaded, and so cannot be autoreloaded.
+
+- While comparing Enum and Flag, the 'is' Identity Operator is used (even in the case '==' has been used (Similar to the 'None' keyword)).
+
+- Reloading a module, or importing the same module by a different name, creates new Enums. These may look the same, but are not.
+"""
+
+from IPython.core import magic_arguments
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.extensions.deduperreload.deduperreload import DeduperReloader
+
+__skip_doctest__ = True
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2000 Thomas Heller
+#  Copyright (C) 2008 Pauli Virtanen <pav@iki.fi>
+#  Copyright (C) 2012  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+#
+# This IPython module is written by Pauli Virtanen, based on the autoreload
+# code by Thomas Heller.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import ast
+import os
+import sys
+import traceback
+import types
+import weakref
+import gc
+import logging
+from importlib import import_module, reload
+from importlib.util import source_from_cache
+
+# ------------------------------------------------------------------------------
+# Autoreload functionality
+# ------------------------------------------------------------------------------
+
+
+class ModuleReloader:
+    enabled = False
+    """Whether this reloader is enabled"""
+
+    check_all = True
+    """Autoreload all modules, not just those listed in 'modules'"""
+
+    autoload_obj = False
+    """Autoreload all modules AND autoload all new objects"""
+
+    def __init__(self, shell=None):
+        # Modules that failed to reload: {module: mtime-on-failed-reload, ...}
+        self.failed = {}
+        # Modules specially marked as autoreloadable.
+        self.modules = {}
+        # Modules specially marked as not autoreloadable.
+        self.skip_modules = {}
+        # (module-name, name) -> weakref, for replacing old code objects
+        self.old_objects = {}
+        # Module modification timestamps
+        self.modules_mtimes = {}
+        self.shell = shell
+
+        # Reporting callable for verbosity
+        self._report = lambda msg: None  # by default, be quiet.
+
+        # Deduper reloader
+        self.deduper_reloader = DeduperReloader()
+
+        # Persistent import tracker for from-imports
+        self.import_from_tracker = ImportFromTracker({}, {})
+
+        # Cache module modification times
+        self.check(check_all=True, do_reload=False)
+
+        # To hide autoreload errors
+        self.hide_errors = False
+
+    def mark_module_skipped(self, module_name):
+        """Skip reloading the named module in the future"""
+        try:
+            del self.modules[module_name]
+        except KeyError:
+            pass
+        self.skip_modules[module_name] = True
+
+    def mark_module_reloadable(self, module_name):
+        """Reload the named module in the future (if it is imported)"""
+        try:
+            del self.skip_modules[module_name]
+        except KeyError:
+            pass
+        self.modules[module_name] = True
+
+    def clear_import_tracker(self):
+        """Clear the persistent import tracker state"""
+        self.import_from_tracker = ImportFromTracker({}, {})
+
+    def aimport_module(self, module_name):
+        """Import a module, and mark it reloadable
+
+        Returns
+        -------
+        top_module : module
+            The imported module if it is top-level, or the top-level
+        top_name : module
+            Name of top_module
+
+        """
+        self.mark_module_reloadable(module_name)
+
+        import_module(module_name)
+        top_name = module_name.split(".")[0]
+        top_module = sys.modules[top_name]
+        return top_module, top_name
+
+    def filename_and_mtime(self, module):
+        if not hasattr(module, "__file__") or module.__file__ is None:
+            return None, None
+
+        if getattr(module, "__name__", None) in [None, "__mp_main__", "__main__"]:
+            # we cannot reload(__main__) or reload(__mp_main__)
+            return None, None
+
+        filename = module.__file__
+        path, ext = os.path.splitext(filename)
+
+        if ext.lower() == ".py":
+            py_filename = filename
+        else:
+            try:
+                py_filename = source_from_cache(filename)
+            except ValueError:
+                return None, None
+
+        try:
+            pymtime = os.stat(py_filename).st_mtime
+        except OSError:
+            return None, None
+
+        return py_filename, pymtime
+
+    def check(self, check_all=False, do_reload=True, execution_info=None):
+        """Check whether some modules need to be reloaded."""
+
+        if not self.enabled and not check_all:
+            return
+
+        if check_all or self.check_all:
+            modules = list(sys.modules.keys())
+        else:
+            modules = list(self.modules.keys())
+
+        # Use the persistent import_from_tracker
+        import_from_tracker = (
+            self.import_from_tracker if self.import_from_tracker.imports_froms else None
+        )
+        for modname in modules:
+            m = sys.modules.get(modname, None)
+
+            if modname in self.skip_modules:
+                continue
+
+            py_filename, pymtime = self.filename_and_mtime(m)
+            if py_filename is None:
+                continue
+
+            try:
+                if pymtime <= self.modules_mtimes[modname]:
+                    continue
+            except KeyError:
+                self.modules_mtimes[modname] = pymtime
+                continue
+            else:
+                if self.failed.get(py_filename, None) == pymtime:
+                    continue
+
+            self.modules_mtimes[modname] = pymtime
+
+            # If we've reached this point, we should try to reload the module
+            if do_reload:
+                self._report(f"Reloading '{modname}'.")
+                try:
+                    if self.autoload_obj:
+                        superreload(
+                            m,
+                            reload,
+                            self.old_objects,
+                            self.shell,
+                            import_from_tracker=import_from_tracker,
+                        )
+                    # if not using autoload, check if deduperreload is viable for this module
+                    elif self.deduper_reloader.maybe_reload_module(m):
+                        pass
+                    else:
+                        superreload(m, reload, self.old_objects)
+                    if py_filename in self.failed:
+                        del self.failed[py_filename]
+                except:
+                    if not self.hide_errors:
+                        logger = logging.getLogger("autoreload")
+                        logger.exception(
+                            f"Failed to reload module '{modname}' from file '{py_filename}'"
+                        )
+                        print(
+                            "[autoreload of {} failed: {}]".format(
+                                modname, traceback.format_exc(10)
+                            ),
+                            file=sys.stderr,
+                        )
+                    self.failed[py_filename] = pymtime
+        self.deduper_reloader.update_sources()
+
+
+# ------------------------------------------------------------------------------
+# superreload
+# ------------------------------------------------------------------------------
+
+
+func_attrs = [
+    "__code__",
+    "__defaults__",
+    "__doc__",
+    "__closure__",
+    "__globals__",
+    "__dict__",
+]
+
+
+def update_function(old, new):
+    """Upgrade the code object of a function"""
+    for name in func_attrs:
+        try:
+            setattr(old, name, getattr(new, name))
+        except (AttributeError, TypeError):
+            pass
+
+
+def update_instances(old, new):
+    """Use garbage collector to find all instances that refer to the old
+    class definition and update their __class__ to point to the new class
+    definition"""
+
+    refs = gc.get_referrers(old)
+
+    for ref in refs:
+        if type(ref) is old:
+            object.__setattr__(ref, "__class__", new)
+
+
+def update_class(old, new):
+    """Replace stuff in the __dict__ of a class, and upgrade
+    method code objects, and add new methods, if any"""
+    for key in list(old.__dict__.keys()):
+        old_obj = getattr(old, key)
+        try:
+            new_obj = getattr(new, key)
+            # explicitly checking that comparison returns True to handle
+            # cases where `==` doesn't return a boolean.
+            if (old_obj == new_obj) is True:
+                continue
+        except AttributeError:
+            # obsolete attribute: remove it
+            try:
+                delattr(old, key)
+            except (AttributeError, TypeError):
+                pass
+            continue
+        except ValueError:
+            # can't compare nested structures containing
+            # numpy arrays using `==`
+            pass
+
+        if update_generic(old_obj, new_obj):
+            continue
+
+        try:
+            setattr(old, key, getattr(new, key))
+        except (AttributeError, TypeError):
+            pass  # skip non-writable attributes
+
+    for key in list(new.__dict__.keys()):
+        if key not in list(old.__dict__.keys()):
+            try:
+                setattr(old, key, getattr(new, key))
+            except (AttributeError, TypeError):
+                pass  # skip non-writable attributes
+
+    # update all instances of class
+    update_instances(old, new)
+
+
+def update_property(old, new):
+    """Replace get/set/del functions of a property"""
+    update_generic(old.fdel, new.fdel)
+    update_generic(old.fget, new.fget)
+    update_generic(old.fset, new.fset)
+
+
+def isinstance2(a, b, typ):
+    return isinstance(a, typ) and isinstance(b, typ)
+
+
+UPDATE_RULES = [
+    (lambda a, b: isinstance2(a, b, type), update_class),
+    (lambda a, b: isinstance2(a, b, types.FunctionType), update_function),
+    (lambda a, b: isinstance2(a, b, property), update_property),
+]
+UPDATE_RULES.extend(
+    [
+        (
+            lambda a, b: isinstance2(a, b, types.MethodType),
+            lambda a, b: update_function(a.__func__, b.__func__),
+        ),
+    ]
+)
+
+
+def update_generic(a, b):
+    for type_check, update in UPDATE_RULES:
+        if type_check(a, b):
+            update(a, b)
+            return True
+    return False
+
+
+class StrongRef:
+    def __init__(self, obj):
+        self.obj = obj
+
+    def __call__(self):
+        return self.obj
+
+
+mod_attrs = [
+    "__name__",
+    "__doc__",
+    "__package__",
+    "__loader__",
+    "__spec__",
+    "__file__",
+    "__cached__",
+    "__builtins__",
+]
+
+
+class ImportFromTracker:
+    def __init__(self, imports_froms: dict, symbol_map: dict):
+        self.imports_froms = imports_froms
+        # symbol_map maps original_name -> list of resolved_names
+        self.symbol_map = {}
+        if symbol_map:
+            for module_name, mappings in symbol_map.items():
+                self.symbol_map[module_name] = {}
+                for original_name, resolved_names in mappings.items():
+                    if isinstance(resolved_names, list):
+                        self.symbol_map[module_name][original_name] = resolved_names[:]
+                    else:
+                        self.symbol_map[module_name][original_name] = [resolved_names]
+        else:
+            self.symbol_map = symbol_map or {}
+
+    def add_import(
+        self, module_name: str, original_name: str, resolved_name: str
+    ) -> None:
+        """Add an import, handling conflicts with existing imports.
+
+        This method is called after successful code execution, so we know the import is valid.
+        """
+        if module_name not in self.imports_froms:
+            self.imports_froms[module_name] = []
+        if module_name not in self.symbol_map:
+            self.symbol_map[module_name] = {}
+
+        # Check if there's already a different mapping for the same resolved_name from a different original_name
+        # We need to remove any conflicting mappings
+        for orig_name, res_names in list(self.symbol_map[module_name].items()):
+            if resolved_name in res_names and orig_name != original_name:
+                # Remove the conflicting resolved_name from the other original_name's list
+                res_names.remove(resolved_name)
+                if (
+                    not res_names
+                ):  # If the list is now empty, remove the original_name entirely
+                    if orig_name in self.imports_froms[module_name]:
+                        self.imports_froms[module_name].remove(orig_name)
+                    del self.symbol_map[module_name][orig_name]
+
+        # Add the new mapping
+        if original_name not in self.imports_froms[module_name]:
+            self.imports_froms[module_name].append(original_name)
+
+        if original_name not in self.symbol_map[module_name]:
+            self.symbol_map[module_name][original_name] = []
+
+        # Add the resolved_name if it's not already in the list
+        if resolved_name not in self.symbol_map[module_name][original_name]:
+            self.symbol_map[module_name][original_name].append(resolved_name)
+
+
+def append_obj(module, d, name, obj, autoload=False):
+    in_module = hasattr(obj, "__module__") and obj.__module__ == module.__name__
+    if autoload:
+        # check needed for module global built-ins
+        if not in_module and name in mod_attrs:
+            return False
+    else:
+        if not in_module:
+            return False
+
+    key = (module.__name__, name)
+    try:
+        d.setdefault(key, []).append(weakref.ref(obj))
+    except TypeError:
+        pass
+    return True
+
+
+def superreload(
+    module, reload=reload, old_objects=None, shell=None, import_from_tracker=None
+):
+    """Enhanced version of the builtin reload function.
+
+    superreload remembers objects previously in the module, and
+
+    - upgrades the class dictionary of every old class in the module
+    - upgrades the code object of every old function and method
+    - clears the module's namespace before reloading
+
+    """
+    if old_objects is None:
+        old_objects = {}
+
+    # collect old objects in the module
+    for name, obj in list(module.__dict__.items()):
+        if not append_obj(module, old_objects, name, obj):
+            continue
+        key = (module.__name__, name)
+        try:
+            old_objects.setdefault(key, []).append(weakref.ref(obj))
+        except TypeError:
+            pass
+
+    # reload module
+    try:
+        # clear namespace first from old cruft
+        old_dict = module.__dict__.copy()
+        old_name = module.__name__
+        module.__dict__.clear()
+        module.__dict__["__name__"] = old_name
+        module.__dict__["__loader__"] = old_dict["__loader__"]
+    except (TypeError, AttributeError, KeyError):
+        pass
+
+    try:
+        module = reload(module)
+    except:
+        # restore module dictionary on failed reload
+        module.__dict__.update(old_dict)
+        raise
+
+    for name, new_obj in list(module.__dict__.items()):
+        key = (module.__name__, name)
+        if key not in old_objects:
+            # here 'shell' acts both as a flag and as an output var
+            imports_froms = (
+                import_from_tracker.imports_froms if import_from_tracker else None
+            )
+            symbol_map = import_from_tracker.symbol_map if import_from_tracker else None
+            if (
+                shell is None
+                or name == "Enum"
+                or not append_obj(module, old_objects, name, new_obj, True)
+                or (
+                    imports_froms
+                    and module.__name__ in imports_froms
+                    and "*" not in imports_froms[module.__name__]
+                    and name not in imports_froms[module.__name__]
+                )
+            ):
+                continue
+
+            # Handle symbol mapping - now supporting multiple resolved names per original name
+            if symbol_map and name in symbol_map.get(module.__name__, {}):
+                resolved_names = symbol_map.get(module.__name__, {})[name]
+                for resolved_name in resolved_names:
+                    shell.user_ns[resolved_name] = new_obj
+            else:
+                shell.user_ns[name] = new_obj
+
+        new_refs = []
+        for old_ref in old_objects[key]:
+            old_obj = old_ref()
+            if old_obj is None:
+                continue
+            new_refs.append(old_ref)
+            update_generic(old_obj, new_obj)
+
+        if new_refs:
+            old_objects[key] = new_refs
+        else:
+            del old_objects[key]
+
+    return module
+
+
+# ------------------------------------------------------------------------------
+# IPython connectivity
+# ------------------------------------------------------------------------------
+
+
+@magics_class
+class AutoreloadMagics(Magics):
+    def __init__(self, *a, **kw):
+        super().__init__(*a, **kw)
+        self._reloader = ModuleReloader(self.shell)
+        self._reloader.check_all = False
+        self._reloader.autoload_obj = False
+        self.loaded_modules = set(sys.modules)
+
+    @line_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        "mode",
+        type=str,
+        default="now",
+        nargs="?",
+        help="""blank or 'now' - Reload all modules (except those excluded by %%aimport)
+             automatically now.
+
+             '0' or 'off' - Disable automatic reloading.
+
+             '1' or 'explicit' - Reload only modules imported with %%aimport every
+             time before executing the Python code typed.
+
+             '2' or 'all' - Reload all modules (except those excluded by %%aimport)
+             every time before executing the Python code typed.
+
+             '3' or 'complete' - Same as 2/all, but also adds any new
+             objects in the module.
+             
+             By default, a newer autoreload algorithm that diffs the module's source code
+             with the previous version and only reloads changed parts is applied for modes
+             2 and below. To use the original algorithm, add the `-` suffix to the mode,
+             e.g. '%autoreload 2-', or pass in --full.
+             """,
+    )
+    @magic_arguments.argument(
+        "-p",
+        "--print",
+        action="store_true",
+        default=False,
+        help="Show autoreload activity using `print` statements",
+    )
+    @magic_arguments.argument(
+        "-l",
+        "--log",
+        action="store_true",
+        default=False,
+        help="Show autoreload activity using the logger",
+    )
+    @magic_arguments.argument(
+        "--hide-errors",
+        action="store_true",
+        default=False,
+        help="Hide autoreload errors",
+    )
+    @magic_arguments.argument(
+        "--full",
+        action="store_true",
+        default=False,
+        help="Don't ever use new diffing algorithm",
+    )
+    def autoreload(self, line=""):
+        r"""%autoreload => Reload modules automatically
+
+        %autoreload or %autoreload now
+        Reload all modules (except those excluded by %aimport) automatically
+        now.
+
+        %autoreload 0 or %autoreload off
+        Disable automatic reloading.
+
+        %autoreload 1 or %autoreload explicit
+        Reload only modules imported with %aimport every time before executing
+        the Python code typed.
+
+        %autoreload 2 or %autoreload all
+        Reload all modules (except those excluded by %aimport) every time
+        before executing the Python code typed.
+
+        %autoreload 3 or %autoreload complete
+        Same as 2/all, but also but also adds any new objects in the module. See
+        unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects
+
+        The optional arguments --print and --log control display of autoreload activity. The default
+        is to act silently; --print (or -p) will print out the names of modules that are being
+        reloaded, and --log (or -l) outputs them to the log at INFO level.
+
+        The optional argument --hide-errors hides any errors that can happen when trying to
+        reload code.
+
+        Reloading Python modules in a reliable way is in general
+        difficult, and unexpected things may occur. %autoreload tries to
+        work around common pitfalls by replacing function code objects and
+        parts of classes previously in the module with new versions. This
+        makes the following things to work:
+
+        - Functions and classes imported via 'from xxx import foo' are upgraded
+          to new versions when 'xxx' is reloaded.
+
+        - Methods and properties of classes are upgraded on reload, so that
+          calling 'c.foo()' on an object 'c' created before the reload causes
+          the new code for 'foo' to be executed.
+
+        Some of the known remaining caveats are:
+
+        - Replacing code objects does not always succeed: changing a @property
+          in a class to an ordinary method or a method to a member variable
+          can cause problems (but in old objects only).
+
+        - Functions that are removed (eg. via monkey-patching) from a module
+          before it is reloaded are not upgraded.
+
+        - C extension modules cannot be reloaded, and so cannot be
+          autoreloaded.
+
+        """
+        args = magic_arguments.parse_argstring(self.autoreload, line)
+        mode = args.mode.lower()
+
+        enable_deduperreload = not args.full
+        if mode.endswith("-"):
+            enable_deduperreload = False
+            mode = mode[:-1]
+        self._reloader.deduper_reloader.enabled = enable_deduperreload
+
+        p = print
+
+        logger = logging.getLogger("autoreload")
+
+        l = logger.info
+
+        def pl(msg):
+            p(msg)
+            l(msg)
+
+        if args.print is False and args.log is False:
+            self._reloader._report = lambda msg: None
+        elif args.print is True:
+            if args.log is True:
+                self._reloader._report = pl
+            else:
+                self._reloader._report = p
+        elif args.log is True:
+            self._reloader._report = l
+
+        self._reloader.hide_errors = args.hide_errors
+
+        if mode == "" or mode == "now":
+            self._reloader.check(True)
+        elif mode == "0" or mode == "off":
+            self._reloader.enabled = False
+        elif mode == "1" or mode == "explicit":
+            self._reloader.enabled = True
+            self._reloader.check_all = False
+            self._reloader.autoload_obj = False
+        elif mode == "2" or mode == "all":
+            self._reloader.enabled = True
+            self._reloader.check_all = True
+            self._reloader.autoload_obj = False
+        elif mode == "3" or mode == "complete":
+            self._reloader.enabled = True
+            self._reloader.check_all = True
+            self._reloader.autoload_obj = True
+        else:
+            raise ValueError(f'Unrecognized autoreload mode "{mode}".')
+
+    @line_magic
+    def aimport(self, parameter_s="", stream=None):
+        """%aimport => Import modules for automatic reloading.
+
+        %aimport
+        List modules to automatically import and not to import.
+
+        %aimport foo
+        Import module 'foo' and mark it to be autoreloaded for %autoreload explicit
+
+        %aimport foo, bar
+        Import modules 'foo', 'bar' and mark them to be autoreloaded for %autoreload explicit
+
+        %aimport -foo, bar
+        Mark module 'foo' to not be autoreloaded for %autoreload explicit, all, or complete, and 'bar'
+        to be autoreloaded for mode explicit.
+        """
+        modname = parameter_s
+        if not modname:
+            to_reload = sorted(self._reloader.modules.keys())
+            to_skip = sorted(self._reloader.skip_modules.keys())
+            if stream is None:
+                stream = sys.stdout
+            if self._reloader.check_all:
+                stream.write("Modules to reload:\nall-except-skipped\n")
+            else:
+                stream.write("Modules to reload:\n%s\n" % " ".join(to_reload))
+            stream.write("\nModules to skip:\n%s\n" % " ".join(to_skip))
+        else:
+            for _module in [_.strip() for _ in modname.split(",")]:
+                if _module.startswith("-"):
+                    _module = _module[1:].strip()
+                    self._reloader.mark_module_skipped(_module)
+                else:
+                    top_module, top_name = self._reloader.aimport_module(_module)
+
+                    # Inject module to user namespace
+                    self.shell.push({top_name: top_module})
+
+    def pre_run_cell(self, info):
+        # Store the execution info for later use in post_execute_hook
+        self._last_execution_info = info
+
+        if self._reloader.enabled:
+            try:
+                self._reloader.check()
+            except:
+                pass
+
+    def post_execute_hook(self):
+        """Cache the modification times of any modules imported in this execution and track imports"""
+
+        # Track imports from the recently executed code if autoreload 3 is enabled
+        if self._reloader.enabled and self._reloader.autoload_obj:
+            # Use the stored execution info
+            if (
+                hasattr(self, "_last_execution_info")
+                and self._last_execution_info
+                and self._last_execution_info.transformed_cell
+            ):
+                self._track_imports_from_code(
+                    self._last_execution_info.transformed_cell
+                )
+
+        newly_loaded_modules = set(sys.modules) - self.loaded_modules
+        for modname in newly_loaded_modules:
+            _, pymtime = self._reloader.filename_and_mtime(sys.modules[modname])
+            if pymtime is not None:
+                self._reloader.modules_mtimes[modname] = pymtime
+
+        self.loaded_modules.update(newly_loaded_modules)
+
+    def _track_imports_from_code(self, code: str) -> None:
+        """Track import statements from executed code"""
+        try:
+            tree = ast.parse(code)
+
+            for node in ast.walk(tree):
+                # Handle "from X import Y" style imports
+                if isinstance(node, ast.ImportFrom):
+                    mod = node.module
+
+                    # Skip relative imports that don't have a module name
+                    if mod is None:
+                        continue
+
+                    for name in node.names:
+                        # name.name is going to be actual name that we want to import from module
+                        # name.asname is Z in the case of from X import Y as Z
+                        # we should update Z in the shell in this situation, so track it too.
+                        original_name = name.name
+                        resolved_name = name.asname if name.asname else name.name
+
+                        # Since the code executed successfully, we know this import is valid
+                        self._reloader.import_from_tracker.add_import(
+                            mod, original_name, resolved_name
+                        )
+        except (SyntaxError, ValueError):
+            # If there's a syntax error, skip import tracking
+            # (though this shouldn't happen since the code already executed successfully)
+            pass
+
+
+def load_ipython_extension(ip):
+    """Load the extension in IPython."""
+    auto_reload = AutoreloadMagics(ip)
+    ip.register_magics(auto_reload)
+    ip.events.register("pre_run_cell", auto_reload.pre_run_cell)
+    ip.events.register("post_execute", auto_reload.post_execute_hook)
diff --git a/IPython/config/default/__init__.py b/IPython/extensions/deduperreload/__init__.py
similarity index 100%
rename from IPython/config/default/__init__.py
rename to IPython/extensions/deduperreload/__init__.py
diff --git a/IPython/extensions/deduperreload/deduperreload.py b/IPython/extensions/deduperreload/deduperreload.py
new file mode 100644
index 00000000000..3ec4e6095ed
--- /dev/null
+++ b/IPython/extensions/deduperreload/deduperreload.py
@@ -0,0 +1,637 @@
+from __future__ import annotations
+import ast
+import builtins
+import contextlib
+import itertools
+import logging
+import os
+import pickle
+import platform
+import sys
+import textwrap
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, NamedTuple, cast
+from collections.abc import Generator, Iterable
+
+from IPython.extensions.deduperreload.deduperreload_patching import (
+    DeduperReloaderPatchingMixin,
+)
+
+if TYPE_CHECKING:
+    TDefinitionAst = (
+        ast.FunctionDef
+        | ast.AsyncFunctionDef
+        | ast.Import
+        | ast.ImportFrom
+        | ast.Assign
+        | ast.AnnAssign
+    )
+
+
+def get_module_file_name(module: ModuleType | str) -> str | None:
+    """Returns the module's file path, or the empty string if it's inaccessible"""
+    if (mod := sys.modules.get(module) if isinstance(module, str) else module) is None:
+        return ""
+    return getattr(mod, "__file__", "") or ""
+
+
+def compare_ast(node1: ast.AST | list[ast.AST], node2: ast.AST | list[ast.AST]) -> bool:
+    """Checks if node1 and node2 have identical AST structure/values, apart from some attributes"""
+    if type(node1) is not type(node2):
+        return False
+
+    if isinstance(node1, ast.AST):
+        for k, v in node1.__dict__.items():
+            if k in (
+                "lineno",
+                "end_lineno",
+                "col_offset",
+                "end_col_offset",
+                "ctx",
+                "parent",
+            ):
+                continue
+            if not hasattr(node2, k) or not compare_ast(v, getattr(node2, k)):
+                return False
+        return True
+
+    elif isinstance(node1, list) and isinstance(  # type:ignore [redundant-expr]
+        node2, list
+    ):
+        return len(node1) == len(node2) and all(
+            compare_ast(n1, n2) for n1, n2 in zip(node1, node2)
+        )
+    else:
+        return node1 == node2
+
+
+class DependencyNode(NamedTuple):
+    """
+    Each node represents a function.
+    qualified_name: string which represents the namespace/name of the function
+    abstract_syntax_tree: subtree of the overall module which corresponds to this function
+
+    qualified_name is of the structure: (namespace1, namespace2, ..., name)
+
+    For example, foo() in the following would be represented as (A, B, foo):
+
+    class A:
+        class B:
+            def foo():
+                pass
+    """
+
+    qualified_name: tuple[str, ...]
+    abstract_syntax_tree: ast.AST
+
+
+class GatherResult(NamedTuple):
+    import_defs: list[tuple[tuple[str, ...], ast.Import | ast.ImportFrom]] = []
+    assign_defs: list[tuple[tuple[str, ...], ast.Assign | ast.AnnAssign]] = []
+    function_defs: list[
+        tuple[tuple[str, ...], ast.FunctionDef | ast.AsyncFunctionDef]
+    ] = []
+    classes: dict[str, ast.ClassDef] = {}
+    unfixable: list[ast.AST] = []
+
+    @classmethod
+    def create(cls) -> GatherResult:
+        return cls([], [], [], {}, [])
+
+    def all_defs(self) -> Iterable[tuple[tuple[str, ...], TDefinitionAst]]:
+        return itertools.chain(self.import_defs, self.assign_defs, self.function_defs)
+
+    def inplace_merge(self, other: GatherResult) -> None:
+        self.import_defs.extend(other.import_defs)
+        self.assign_defs.extend(other.assign_defs)
+        self.function_defs.extend(other.function_defs)
+        self.classes.update(other.classes)
+        self.unfixable.extend(other.unfixable)
+
+
+class ConstexprDetector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.is_constexpr = True
+        self._allow_builtins_exceptions = True
+
+    @contextlib.contextmanager
+    def disallow_builtins_exceptions(self) -> Generator[None, None, None]:
+        prev_allow = self._allow_builtins_exceptions
+        self._allow_builtins_exceptions = False
+        try:
+            yield
+        finally:
+            self._allow_builtins_exceptions = prev_allow
+
+    def visit_Attribute(self, node: ast.Attribute) -> None:
+        with self.disallow_builtins_exceptions():
+            self.visit(node.value)
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if self._allow_builtins_exceptions and hasattr(builtins, node.id):
+            return
+        self.is_constexpr = False
+
+    def visit(self, node: ast.AST) -> None:
+        if not self.is_constexpr:
+            # can short-circuit if we've already detected that it's not a constexpr
+            return
+        super().visit(node)
+
+    def __call__(self, node: ast.AST) -> bool:
+        self.is_constexpr = True
+        self.visit(node)
+        return self.is_constexpr
+
+
+class AutoreloadTree:
+    """
+    Recursive data structure to keep track of reloadable functions/methods. Each object corresponds to a specific scope level.
+    children: classes inside given scope, maps class name to autoreload tree for that class's scope
+    funcs_to_autoreload: list of function names that can be autoreloaded in given scope.
+    new_nested_classes: Classes getting added in new autoreload cycle
+    """
+
+    def __init__(self) -> None:
+        self.children: dict[str, AutoreloadTree] = {}
+        self.defs_to_reload: list[tuple[tuple[str, ...], ast.AST]] = []
+        self.defs_to_delete: set[str] = set()
+        self.new_nested_classes: dict[str, ast.AST] = {}
+
+    def traverse_prefixes(self, prefixes: list[str]) -> AutoreloadTree:
+        """
+        Return ref to the AutoreloadTree at the namespace specified by prefixes
+        """
+        cur = self
+        for prefix in prefixes:
+            if prefix not in cur.children:
+                cur.children[prefix] = AutoreloadTree()
+            cur = cur.children[prefix]
+        return cur
+
+
+class DeduperReloader(DeduperReloaderPatchingMixin):
+    """
+    This version of autoreload detects when we can leverage targeted recompilation of a subset of a module and patching
+    existing function/method objects to reflect these changes.
+
+    Detects what functions/methods can be reloaded by recursively comparing the old/new AST of module-level classes,
+    module-level classes' methods, recursing through nested classes' methods. If other changes are made, original
+    autoreload algorithm is called directly.
+    """
+
+    def __init__(self) -> None:
+        self._to_autoreload: AutoreloadTree = AutoreloadTree()
+        self.source_by_modname: dict[str, str] = {}
+        self.dependency_graph: dict[tuple[str, ...], list[DependencyNode]] = {}
+        self._enabled = True
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled and platform.python_implementation() == "CPython"
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self._enabled = value
+
+    def update_sources(self) -> None:
+        """
+        Update dictionary source_by_modname with current modules' source codes.
+        """
+        if not self.enabled:
+            return
+        for new_modname in sys.modules.keys() - self.source_by_modname.keys():
+            new_module = sys.modules[new_modname]
+            if (
+                (fname := get_module_file_name(new_module)) is None
+                or "site-packages" in fname
+                or "dist-packages" in fname
+                or not os.access(fname, os.R_OK)
+            ):
+                self.source_by_modname[new_modname] = ""
+                continue
+            # Skip binary files (e.g., .so, .pyd, .pyo)
+            if not fname.endswith(".py"):
+                self.source_by_modname[new_modname] = ""
+                continue
+            try:
+                with open(fname, "r", encoding="utf8") as f:
+                    self.source_by_modname[new_modname] = f.read()
+            except Exception as e:
+                logger = logging.getLogger("autoreload")
+                logger.exception(
+                    f"Failed to read module file '{fname}' for module '{new_modname}': {type(e).__name__}"
+                )
+                self.source_by_modname[new_modname] = ""
+
+    constexpr_detector = ConstexprDetector()
+
+    @staticmethod
+    def is_enum_subclass(node: ast.Module | ast.ClassDef) -> bool:
+        if isinstance(node, ast.Module):
+            return False
+        for base in node.bases:
+            if isinstance(base, ast.Name) and base.id == "Enum":
+                return True
+            elif (
+                isinstance(base, ast.Attribute)
+                and base.attr == "Enum"
+                and isinstance(base.value, ast.Name)
+                and base.value.id == "enum"
+            ):
+                return True
+        return False
+
+    @classmethod
+    def is_constexpr_assign(
+        cls, node: ast.AST, parent_node: ast.Module | ast.ClassDef
+    ) -> bool:
+        if not isinstance(node, (ast.Assign, ast.AnnAssign)) or node.value is None:
+            return False
+        if cls.is_enum_subclass(parent_node):
+            return False
+        for target in node.targets if isinstance(node, ast.Assign) else [node.target]:
+            if not isinstance(target, ast.Name):
+                return False
+        return cls.constexpr_detector(node.value)
+
+    @classmethod
+    def _gather_children(
+        cls, body: list[ast.stmt], parent_node: ast.Module | ast.ClassDef
+    ) -> GatherResult:
+        """
+        Given list of ast elements, return:
+        1. dict mapping function names to their ASTs.
+        2. dict mapping class names to their ASTs.
+        3. list of any other ASTs.
+        """
+        result = GatherResult.create()
+        for ast_node in body:
+            ast_elt: ast.expr | ast.stmt = ast_node
+            while isinstance(ast_elt, ast.Expr):
+                ast_elt = ast_elt.value
+            if isinstance(ast_elt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                result.function_defs.append(((ast_elt.name,), ast_elt))
+            elif isinstance(ast_elt, (ast.Import, ast.ImportFrom)):
+                result.import_defs.append(
+                    (tuple(name.asname or name.name for name in ast_elt.names), ast_elt)
+                )
+            elif isinstance(ast_elt, ast.ClassDef):
+                result.classes[ast_elt.name] = ast_elt
+            elif isinstance(ast_elt, ast.If):
+                result.unfixable.append(ast_elt.test)
+                result.inplace_merge(cls._gather_children(ast_elt.body, parent_node))
+                result.inplace_merge(cls._gather_children(ast_elt.orelse, parent_node))
+            elif isinstance(ast_elt, (ast.AsyncWith, ast.With)):
+                result.unfixable.extend(ast_elt.items)
+                result.inplace_merge(cls._gather_children(ast_elt.body, parent_node))
+            elif isinstance(ast_elt, ast.Try):
+                result.inplace_merge(cls._gather_children(ast_elt.body, parent_node))
+                result.inplace_merge(cls._gather_children(ast_elt.orelse, parent_node))
+                result.inplace_merge(
+                    cls._gather_children(ast_elt.finalbody, parent_node)
+                )
+                for handler in ast_elt.handlers:
+                    if handler.type is not None:
+                        result.unfixable.append(handler.type)
+                    result.inplace_merge(
+                        cls._gather_children(handler.body, parent_node)
+                    )
+            elif not isinstance(ast_elt, (ast.Constant, ast.Pass)):
+                if cls.is_constexpr_assign(ast_elt, parent_node):
+                    assert isinstance(ast_elt, (ast.Assign, ast.AnnAssign))
+                    targets = (
+                        ast_elt.targets
+                        if isinstance(ast_elt, ast.Assign)
+                        else [ast_elt.target]
+                    )
+                    result.assign_defs.append(
+                        (
+                            tuple(cast(ast.Name, target).id for target in targets),
+                            ast_elt,
+                        )
+                    )
+                else:
+                    result.unfixable.append(ast_elt)
+        return result
+
+    def detect_autoreload(
+        self,
+        old_node: ast.Module | ast.ClassDef,
+        new_node: ast.Module | ast.ClassDef,
+        prefixes: list[str] | None = None,
+    ) -> bool:
+        """
+        Returns
+        -------
+        `True` if we can run our targeted autoreload algorithm safely.
+        `False` if we should instead use IPython's original autoreload implementation.
+        """
+        if not self.enabled:
+            return False
+        prefixes = prefixes or []
+
+        old_result = self._gather_children(old_node.body, old_node)
+        new_result = self._gather_children(new_node.body, new_node)
+        old_defs_by_name: dict[str, ast.AST] = {
+            name: ast_def for names, ast_def in old_result.all_defs() for name in names
+        }
+        new_defs_by_name: dict[str, ast.AST] = {
+            name: ast_def for names, ast_def in new_result.all_defs() for name in names
+        }
+
+        if not compare_ast(old_result.unfixable, new_result.unfixable):
+            return False
+
+        cur = self._to_autoreload.traverse_prefixes(prefixes)
+        for names, new_ast_def in new_result.all_defs():
+            names_to_reload = []
+            for name in names:
+                if new_defs_by_name[name] is not new_ast_def:
+                    continue
+                if name not in old_defs_by_name or not compare_ast(
+                    new_ast_def, old_defs_by_name[name]
+                ):
+                    names_to_reload.append(name)
+            if names_to_reload:
+                cur.defs_to_reload.append((tuple(names), new_ast_def))
+        cur.defs_to_delete |= set(old_defs_by_name.keys()) - set(
+            new_defs_by_name.keys()
+        )
+        for name, new_ast_def_class in new_result.classes.items():
+            if name not in old_result.classes:
+                cur.new_nested_classes[name] = new_ast_def_class
+            elif not compare_ast(
+                new_ast_def_class, old_result.classes[name]
+            ) and not self.detect_autoreload(
+                old_result.classes[name], new_ast_def_class, prefixes + [name]
+            ):
+                return False
+        return True
+
+    def _check_dependents(self) -> bool:
+        """
+        If a decorator function is modified, we should similarly reload the functions which are decorated by this
+        decorator. Iterate through the Dependency Graph to find such cases in the given AutoreloadTree.
+        """
+        for node in self._check_dependents_inner():
+            self._add_node_to_autoreload_tree(node)
+        return True
+
+    def _add_node_to_autoreload_tree(self, node: DependencyNode) -> None:
+        """
+        Given a node of the dependency graph, add decorator dependencies to the autoreload tree.
+        """
+        if len(node.qualified_name) == 0:
+            return
+        cur = self._to_autoreload.traverse_prefixes(list(node.qualified_name[:-1]))
+        if node.abstract_syntax_tree is not None:
+            cur.defs_to_reload.append(
+                ((node.qualified_name[-1],), node.abstract_syntax_tree)
+            )
+
+    def _check_dependents_inner(
+        self, prefixes: list[str] | None = None
+    ) -> list[DependencyNode]:
+        prefixes = prefixes or []
+        cur = self._to_autoreload.traverse_prefixes(prefixes)
+        ans = []
+        for (func_name, *_), _ in cur.defs_to_reload:
+            node = tuple(prefixes + [func_name])
+            ans.extend(self._gen_dependents(node))
+        for class_name in cur.new_nested_classes:
+            ans.extend(self._check_dependents_inner(prefixes + [class_name]))
+        return ans
+
+    def _gen_dependents(self, qualname: tuple[str, ...]) -> list[DependencyNode]:
+        ans = []
+        if qualname not in self.dependency_graph:
+            return []
+        for elt in self.dependency_graph[qualname]:
+            ans.extend(self._gen_dependents(elt.qualified_name))
+            ans.append(elt)
+        return ans
+
+    def _patch_namespace_inner(
+        self, ns: ModuleType | type, prefixes: list[str] | None = None
+    ) -> bool:
+        """
+        This function patches module functions and methods. Specifically, only objects with their name in
+        self.to_autoreload will be considered for patching. If an object has been marked to be autoreloaded,
+        new_source_code gets executed in the old version's global environment. Then, replace the old function's
+        attributes with the new function's attributes.
+        """
+        prefixes = prefixes or []
+        cur = self._to_autoreload.traverse_prefixes(prefixes)
+        namespace_to_check = ns
+        for prefix in prefixes:
+            namespace_to_check = namespace_to_check.__dict__[prefix]
+        seen_names: set[str] = set()
+        for names, new_ast_def in cur.defs_to_reload:
+            if len(names) == 1 and names[0] in seen_names:
+                continue
+            seen_names.update(names)
+            local_env: dict[str, Any] = {}
+            if (
+                isinstance(new_ast_def, (ast.FunctionDef, ast.AsyncFunctionDef))
+                and (name := names[0]) in namespace_to_check.__dict__
+            ):
+                assert len(names) == 1
+                to_patch_to = namespace_to_check.__dict__[name]
+                if isinstance(to_patch_to, (staticmethod, classmethod)):
+                    to_patch_to = to_patch_to.__func__
+                # exec new source code using old function's (obj) globals environment.
+                func_code = textwrap.dedent(ast.unparse(new_ast_def))
+                if is_method := (len(prefixes) > 0):
+                    func_code = "class __autoreload_class__:\n" + textwrap.indent(
+                        func_code, "    "
+                    )
+                global_env = ns.__dict__
+                if not isinstance(global_env, dict):
+                    global_env = dict(global_env)
+                # Compile with correct filename to preserve in traceback
+                filename = (
+                    getattr(to_patch_to, "__code__", None)
+                    and to_patch_to.__code__.co_filename
+                    or "<string>"
+                )
+                func_asts = [ast.parse(func_code)]
+                if len(cast(ast.FunctionDef, func_asts[0].body[0]).decorator_list) > 0:
+                    without_decorator_list = pickle.loads(pickle.dumps(func_asts[0]))
+                    cast(
+                        ast.FunctionDef, without_decorator_list.body[0]
+                    ).decorator_list = []
+                    func_asts.insert(0, without_decorator_list)
+                for func_ast in func_asts:
+                    compiled_code = compile(
+                        func_ast, filename, mode="exec", dont_inherit=True
+                    )
+                    exec(compiled_code, global_env, local_env)  # type: ignore[arg-type]
+                    # local_env contains the function exec'd from  new version of function
+                    if is_method:
+                        to_patch_from = getattr(local_env["__autoreload_class__"], name)
+                    else:
+                        to_patch_from = local_env[name]
+                    if isinstance(to_patch_from, (staticmethod, classmethod)):
+                        to_patch_from = to_patch_from.__func__
+                    if isinstance(to_patch_to, property) and isinstance(
+                        to_patch_from, property
+                    ):
+                        for attr in ("fget", "fset", "fdel"):
+                            if (
+                                getattr(to_patch_to, attr) is None
+                                or getattr(to_patch_from, attr) is None
+                            ):
+                                self.try_patch_attr(to_patch_to, to_patch_from, attr)
+                            else:
+                                self.patch_function(
+                                    getattr(to_patch_to, attr),
+                                    getattr(to_patch_from, attr),
+                                    is_method,
+                                )
+                    elif not isinstance(to_patch_to, property) and not isinstance(
+                        to_patch_from, property
+                    ):
+                        self.patch_function(to_patch_to, to_patch_from, is_method)
+                    else:
+                        raise ValueError(
+                            "adding or removing property decorations not supported"
+                        )
+            else:
+                exec(
+                    ast.unparse(new_ast_def),
+                    ns.__dict__ | namespace_to_check.__dict__,
+                    local_env,
+                )
+                for name in names:
+                    setattr(namespace_to_check, name, local_env[name])
+        cur.defs_to_reload.clear()
+        for name in cur.defs_to_delete:
+            try:
+                delattr(namespace_to_check, name)
+            except (AttributeError, TypeError, ValueError):
+                # give up on deleting the attribute, let the stale one dangle
+                pass
+        cur.defs_to_delete.clear()
+        for class_name, class_ast_node in cur.new_nested_classes.items():
+            local_env_class: dict[str, Any] = {}
+            exec(
+                ast.unparse(class_ast_node),
+                ns.__dict__ | namespace_to_check.__dict__,
+                local_env_class,
+            )
+            setattr(namespace_to_check, class_name, local_env_class[class_name])
+        cur.new_nested_classes.clear()
+        for class_name in cur.children.keys():
+            if not self._patch_namespace(ns, prefixes + [class_name]):
+                return False
+        cur.children.clear()
+        return True
+
+    def _patch_namespace(
+        self, ns: ModuleType | type, prefixes: list[str] | None = None
+    ) -> bool:
+        """
+        Wrapper for patching all elements in a namespace as specified by the to_autoreload member variable.
+        Returns `true` if patching was successful, and `false` if unsuccessful.
+        """
+        try:
+            return self._patch_namespace_inner(ns, prefixes=prefixes)
+        except Exception:
+            return False
+
+    def maybe_reload_module(self, module: ModuleType) -> bool:
+        """
+        Uses Deduperreload to try to update a module.
+        Returns `true` on success and `false` on failure.
+        """
+        if not self.enabled:
+            return False
+        if not (modname := getattr(module, "__name__", None)):
+            return False
+        if (fname := get_module_file_name(module)) is None:
+            return False
+        try:
+            with open(fname, "r", encoding="utf8") as f:
+                new_source_code = f.read()
+        except Exception as e:
+            logger = logging.getLogger("autoreload")
+            logger.exception(
+                f"Failed to read module file '{fname}' for module '{modname}': {type(e).__name__}"
+            )
+            return False
+        patched_flag = False
+        if old_source_code := self.source_by_modname.get(modname):
+            # get old/new module ast
+            try:
+                old_module_ast = ast.parse(old_source_code)
+                new_module_ast = ast.parse(new_source_code)
+            except Exception:
+                return False
+            # detect if we are able to use our autoreload algorithm
+            ctx = contextlib.suppress()
+            with ctx:
+                self._build_dependency_graph(new_module_ast)
+                if (
+                    self.detect_autoreload(old_module_ast, new_module_ast)
+                    and self._check_dependents()
+                    and self._patch_namespace(module)
+                ):
+                    patched_flag = True
+
+        self.source_by_modname[modname] = new_source_code
+        self._to_autoreload = AutoreloadTree()
+        return patched_flag
+
+    def _separate_name(
+        self,
+        decorator: ast.Attribute | ast.Name | ast.Call | ast.expr,
+        accept_calls: bool,
+    ) -> list[str] | None:
+        """
+        Generates a qualified name for a given decorator by finding its relative namespace.
+        """
+        if isinstance(decorator, ast.Name):
+            return [decorator.id]
+        elif isinstance(decorator, ast.Call):
+            if accept_calls:
+                return self._separate_name(decorator.func, False)
+            else:
+                return None
+        if not isinstance(decorator, ast.Attribute):
+            return None
+        if pref := self._separate_name(decorator.value, False):
+            return pref + [decorator.attr]
+        else:
+            return None
+
+    def _gather_dependents(
+        self, body: list[ast.stmt], body_prefixes: list[str] | None = None
+    ) -> bool:
+        body_prefixes = body_prefixes or []
+        for ast_node in body:
+            ast_elt: ast.expr | ast.stmt = ast_node
+            if isinstance(ast_elt, ast.ClassDef):
+                self._gather_dependents(ast_elt.body, body_prefixes + [ast_elt.name])
+                continue
+            if not isinstance(ast_elt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            qualified_name = tuple(body_prefixes + [ast_elt.name])
+            cur_dependency_node = DependencyNode(qualified_name, ast_elt)
+            for decorator in ast_elt.decorator_list:
+                decorator_path = self._separate_name(decorator, True)
+                if not decorator_path:
+                    continue
+                decorator_path_tuple = tuple(decorator_path)
+                self.dependency_graph.setdefault(decorator_path_tuple, []).append(
+                    cur_dependency_node
+                )
+        return True
+
+    def _build_dependency_graph(self, new_ast: ast.Module | ast.ClassDef) -> bool:
+        """
+        Wrapper function for generating dependency graph given some AST.
+        Returns `true` on success. Returns `false` on failure.
+        Currently, only returns `true` as we do not block on failure to build this graph.
+        """
+        return self._gather_dependents(new_ast.body)
diff --git a/IPython/extensions/deduperreload/deduperreload_patching.py b/IPython/extensions/deduperreload/deduperreload_patching.py
new file mode 100644
index 00000000000..3bd2a2c928d
--- /dev/null
+++ b/IPython/extensions/deduperreload/deduperreload_patching.py
@@ -0,0 +1,142 @@
+from __future__ import annotations
+import ctypes
+import sys
+from typing import Any
+
+NOT_FOUND: object = object()
+NULL: object = object()
+_MAX_FIELD_SEARCH_OFFSET = 50
+
+POINTER_N_BYTES = ctypes.sizeof(ctypes.c_void_p)
+
+
+class DeduperReloaderPatchingMixin:
+    @staticmethod
+    def infer_field_offset(
+        obj: object,
+        field: str,
+    ) -> int:
+        field_value = getattr(obj, field, NOT_FOUND)
+        if field_value is NOT_FOUND:
+            return -1
+        obj_addr = ctypes.c_void_p.from_buffer(ctypes.py_object(obj)).value
+        field_addr = ctypes.c_void_p.from_buffer(ctypes.py_object(field_value)).value
+        if obj_addr is None or field_addr is None:
+            return -1
+        ret = -1
+        for offset in range(1, _MAX_FIELD_SEARCH_OFFSET):
+            if (
+                ctypes.cast(
+                    obj_addr + POINTER_N_BYTES * offset, ctypes.POINTER(ctypes.c_void_p)
+                ).contents.value
+                == field_addr
+            ):
+                ret = offset
+                break
+        return ret
+
+    @classmethod
+    def try_write_readonly_attr(
+        cls,
+        obj: object,
+        field: str,
+        new_value: object,
+        offset: int | None = None,
+    ) -> None:
+        prev_value = getattr(obj, field, NOT_FOUND)
+        if prev_value is NOT_FOUND:
+            return
+        if offset is None:
+            offset = cls.infer_field_offset(obj, field)
+        if offset == -1:
+            return
+        obj_addr = ctypes.c_void_p.from_buffer(ctypes.py_object(obj)).value
+        if new_value is NULL:
+            new_value_addr: int | None = 0
+        else:
+            new_value_addr = ctypes.c_void_p.from_buffer(
+                ctypes.py_object(new_value)
+            ).value
+        if obj_addr is None or new_value_addr is None:
+            return
+        if prev_value is not None:
+            ctypes.pythonapi.Py_DecRef(ctypes.py_object(prev_value))
+        if new_value not in (None, NULL):
+            ctypes.pythonapi.Py_IncRef(ctypes.py_object(new_value))
+        ctypes.cast(
+            obj_addr + POINTER_N_BYTES * offset, ctypes.POINTER(ctypes.c_void_p)
+        ).contents.value = new_value_addr
+
+    @classmethod
+    def try_patch_readonly_attr(
+        cls,
+        old: object,
+        new: object,
+        field: str,
+        new_is_value: bool = False,
+        offset: int = -1,
+    ) -> None:
+        old_value = getattr(old, field, NOT_FOUND)
+        new_value = new if new_is_value else getattr(new, field, NOT_FOUND)
+        if old_value is NOT_FOUND or new_value is NOT_FOUND:
+            return
+        elif old_value is new_value:
+            return
+        elif old_value is not None and offset < 0:
+            offset = cls.infer_field_offset(old, field)
+        elif offset < 0:
+            assert not new_is_value
+            assert new_value is not None
+            offset = cls.infer_field_offset(new, field)
+        cls.try_write_readonly_attr(old, field, new_value, offset=offset)
+
+    @classmethod
+    def try_patch_attr(
+        cls,
+        old: object,
+        new: object,
+        field: str,
+        new_is_value: bool = False,
+        offset: int = -1,
+    ) -> None:
+        try:
+            setattr(old, field, new if new_is_value else getattr(new, field))
+        except (AttributeError, TypeError, ValueError):
+            cls.try_patch_readonly_attr(old, new, field, new_is_value, offset)
+
+    @classmethod
+    def patch_function(
+        cls, to_patch_to: Any, to_patch_from: Any, is_method: bool
+    ) -> None:
+        new_closure = []
+        for freevar, closure_val in zip(
+            to_patch_from.__code__.co_freevars or [], to_patch_from.__closure__ or []
+        ):
+            if (
+                callable(closure_val.cell_contents)
+                and freevar in to_patch_to.__code__.co_freevars
+            ):
+                new_closure.append(
+                    to_patch_to.__closure__[
+                        to_patch_to.__code__.co_freevars.index(freevar)
+                    ]
+                )
+            else:
+                new_closure.append(closure_val)
+        # lambdas may complain if there is more than one freevar
+        cls.try_patch_attr(to_patch_to, to_patch_from, "__code__")
+        offset = -1
+        if to_patch_to.__closure__ is None and to_patch_from.__closure__ is not None:
+            offset = cls.infer_field_offset(to_patch_from, "__closure__")
+        if to_patch_to.__closure__ is not None or to_patch_from.__closure__ is not None:
+            cls.try_patch_readonly_attr(
+                to_patch_to,
+                tuple(new_closure) or NULL,
+                "__closure__",
+                new_is_value=True,
+                offset=offset,
+            )
+        for attr in ("__defaults__", "__kwdefaults__", "__doc__", "__dict__"):
+            cls.try_patch_attr(to_patch_to, to_patch_from, attr)
+        if is_method:
+            cls.try_patch_readonly_attr(to_patch_to, to_patch_from, "__self__")
diff --git a/IPython/extensions/parallelmagic.py b/IPython/extensions/parallelmagic.py
deleted file mode 100755
index 61c1dfb8c17..00000000000
--- a/IPython/extensions/parallelmagic.py
+++ /dev/null
@@ -1,294 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-"""Magic command interface for interactive parallel work."""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import ast
-import re
-
-from IPython.core.plugin import Plugin
-from IPython.utils.traitlets import Bool, Any, Instance
-from IPython.testing import decorators as testdec
-
-#-----------------------------------------------------------------------------
-# Definitions of magic functions for use with IPython
-#-----------------------------------------------------------------------------
-
-
-NO_ACTIVE_VIEW = """
-Use activate() on a DirectView object to activate it for magics.
-"""
-
-
-class ParalleMagic(Plugin):
-    """A component to manage the %result, %px and %autopx magics."""
-
-    active_view = Instance('IPython.parallel.client.view.DirectView')
-    verbose = Bool(False, config=True)
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-
-    def __init__(self, shell=None, config=None):
-        super(ParalleMagic, self).__init__(shell=shell, config=config)
-        self._define_magics()
-        # A flag showing if autopx is activated or not
-        self.autopx = False
-
-    def _define_magics(self):
-        """Define the magic functions."""
-        self.shell.define_magic('result', self.magic_result)
-        self.shell.define_magic('px', self.magic_px)
-        self.shell.define_magic('autopx', self.magic_autopx)
-
-    @testdec.skip_doctest
-    def magic_result(self, ipself, parameter_s=''):
-        """Print the result of command i on all engines..
-
-        To use this a :class:`DirectView` instance must be created 
-        and then activated by calling its :meth:`activate` method.
-
-        Then you can do the following::
-
-            In [23]: %result
-            Out[23]: 
-            <Results List>
-            [0] In [6]: a = 10
-            [1] In [6]: a = 10
-    
-            In [22]: %result 6
-            Out[22]: 
-            <Results List>
-            [0] In [6]: a = 10
-            [1] In [6]: a = 10
-        """
-        if self.active_view is None:
-            print NO_ACTIVE_VIEW
-            return
-
-        try:
-            index = int(parameter_s)
-        except:
-            index = None
-        result = self.active_view.get_result(index)
-        return result
-
-    @testdec.skip_doctest
-    def magic_px(self, ipself, parameter_s=''):
-        """Executes the given python command in parallel.
-
-        To use this a :class:`DirectView` instance must be created 
-        and then activated by calling its :meth:`activate` method.
-        
-        Then you can do the following::
-
-            In [24]: %px a = 5
-            Parallel execution on engines: all
-            Out[24]: 
-            <Results List>
-            [0] In [7]: a = 5
-            [1] In [7]: a = 5
-        """
-
-        if self.active_view is None:
-            print NO_ACTIVE_VIEW
-            return
-        print "Parallel execution on engines: %s" % self.active_view.targets
-        result = self.active_view.execute(parameter_s, block=False)
-        if self.active_view.block:
-            result.get()
-            self._maybe_display_output(result)
-
-    @testdec.skip_doctest
-    def magic_autopx(self, ipself, parameter_s=''):
-        """Toggles auto parallel mode.
-
-        To use this a :class:`DirectView` instance must be created 
-        and then activated by calling its :meth:`activate` method. Once this
-        is called, all commands typed at the command line are send to
-        the engines to be executed in parallel. To control which engine
-        are used, set the ``targets`` attributed of the multiengine client
-        before entering ``%autopx`` mode.
-
-        Then you can do the following::
-
-            In [25]: %autopx
-            %autopx to enabled
-
-            In [26]: a = 10
-            Parallel execution on engines: [0,1,2,3]
-            In [27]: print a
-            Parallel execution on engines: [0,1,2,3]
-            [stdout:0] 10
-            [stdout:1] 10
-            [stdout:2] 10
-            [stdout:3] 10
-
-
-            In [27]: %autopx
-            %autopx disabled
-        """
-        if self.autopx:
-            self._disable_autopx()
-        else:
-            self._enable_autopx()
-
-    def _enable_autopx(self):
-        """Enable %autopx mode by saving the original run_cell and installing 
-        pxrun_cell.
-        """
-        if self.active_view is None:
-            print NO_ACTIVE_VIEW
-            return
-
-        # override run_cell and run_code
-        self._original_run_cell = self.shell.run_cell
-        self.shell.run_cell = self.pxrun_cell
-        self._original_run_code = self.shell.run_code
-        self.shell.run_code = self.pxrun_code
-
-        self.autopx = True
-        print "%autopx enabled"
-    
-    def _disable_autopx(self):
-        """Disable %autopx by restoring the original InteractiveShell.run_cell.
-        """
-        if self.autopx:
-            self.shell.run_cell = self._original_run_cell
-            self.shell.run_code = self._original_run_code
-            self.autopx = False
-            print "%autopx disabled"
-
-    def _maybe_display_output(self, result):
-        """Maybe display the output of a parallel result.
-
-        If self.active_view.block is True, wait for the result
-        and display the result.  Otherwise, this is a noop.
-        """
-        targets = self.active_view.targets
-        if isinstance(targets, int):
-            targets = [targets]
-        if targets == 'all':
-            targets = self.active_view.client.ids
-        stdout = [s.rstrip() for s in result.stdout]
-        if any(stdout):
-            for i,eid in enumerate(targets):
-                print '[stdout:%i]'%eid, stdout[i]
-
-
-    def pxrun_cell(self, raw_cell, store_history=True):
-        """drop-in replacement for InteractiveShell.run_cell.
-        
-        This executes code remotely, instead of in the local namespace.
-
-        See InteractiveShell.run_cell for details.
-        """
-        
-        if (not raw_cell) or raw_cell.isspace():
-            return
-        
-        ipself = self.shell
-        
-        with ipself.builtin_trap:
-            cell = ipself.prefilter_manager.prefilter_lines(raw_cell)
-        
-            # Store raw and processed history
-            if store_history:
-                ipself.history_manager.store_inputs(ipself.execution_count, 
-                                                  cell, raw_cell)
-
-            # ipself.logger.log(cell, raw_cell)
-        
-            cell_name = ipself.compile.cache(cell, ipself.execution_count)
-        
-            try:
-                code_ast = ast.parse(cell, filename=cell_name)
-            except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
-                # Case 1
-                ipself.showsyntaxerror()
-                ipself.execution_count += 1
-                return None
-            except NameError:
-                # ignore name errors, because we don't know the remote keys
-                pass
-
-        if store_history:
-            # Write output to the database. Does nothing unless
-            # history output logging is enabled.
-            ipself.history_manager.store_output(ipself.execution_count)
-            # Each cell is a *single* input, regardless of how many lines it has
-            ipself.execution_count += 1
-        
-        if re.search(r'get_ipython\(\)\.magic\(u?"%?autopx', cell):
-            self._disable_autopx()
-            return False
-        else:
-            try:
-                result = self.active_view.execute(cell, block=False)
-            except:
-                ipself.showtraceback()
-                return True
-            else:
-                if self.active_view.block:
-                    try:
-                        result.get()
-                    except:
-                        self.shell.showtraceback()
-                        return True
-                    else:
-                        self._maybe_display_output(result)
-                return False
-
-    def pxrun_code(self, code_obj):
-        """drop-in replacement for InteractiveShell.run_code.
-
-        This executes code remotely, instead of in the local namespace.
-
-        See InteractiveShell.run_code for details.
-        """
-        ipself = self.shell
-        # check code object for the autopx magic
-        if 'get_ipython' in code_obj.co_names and 'magic' in code_obj.co_names and \
-            any( [ isinstance(c, basestring) and 'autopx' in c for c in code_obj.co_consts ]):
-            self._disable_autopx()
-            return False
-        else:
-            try:
-                result = self.active_view.execute(code_obj, block=False)
-            except:
-                ipself.showtraceback()
-                return True
-            else:
-                if self.active_view.block:
-                    try:
-                        result.get()
-                    except:
-                        self.shell.showtraceback()
-                        return True
-                    else:
-                        self._maybe_display_output(result)
-                return False
-
-
-
-
-_loaded = False
-
-
-def load_ipython_extension(ip):
-    """Load the extension in IPython."""
-    global _loaded
-    if not _loaded:
-        plugin = ParalleMagic(shell=ip, config=ip.config)
-        ip.plugin_manager.register_plugin('parallelmagic', plugin)
-        _loaded = True
-
diff --git a/IPython/extensions/storemagic.py b/IPython/extensions/storemagic.py
new file mode 100644
index 00000000000..1ab56f72ea8
--- /dev/null
+++ b/IPython/extensions/storemagic.py
@@ -0,0 +1,236 @@
+# -*- coding: utf-8 -*-
+"""
+%store magic for lightweight persistence.
+
+Stores variables, aliases and macros in IPython's database.
+
+To automatically restore stored variables at startup, add this to your
+:file:`ipython_config.py` file::
+
+  c.StoreMagics.autorestore = True
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import inspect, os, sys, textwrap
+
+from IPython.core.error import UsageError
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.testing.skipdoctest import skip_doctest
+from traitlets import Bool
+
+
+def restore_aliases(ip, alias=None):
+    staliases = ip.db.get('stored_aliases', {})
+    if alias is None:
+        for k,v in staliases.items():
+            # print("restore alias",k,v)  # dbg
+            #self.alias_table[k] = v
+            ip.alias_manager.define_alias(k,v)
+    else:
+        ip.alias_manager.define_alias(alias, staliases[alias])
+
+
+def refresh_variables(ip):
+    db = ip.db
+    for key in db.keys('autorestore/*'):
+        # strip autorestore
+        justkey = os.path.basename(key)
+        try:
+            obj = db[key]
+        except KeyError:
+            print("Unable to restore variable '%s', ignoring (use %%store -d to forget!)" % justkey)
+            print("The error was:", sys.exc_info()[0])
+        else:
+            # print("restored",justkey,"=",obj)  # dbg
+            ip.user_ns[justkey] = obj
+
+
+def restore_dhist(ip):
+    ip.user_ns['_dh'] = ip.db.get('dhist',[])
+
+
+def restore_data(ip):
+    refresh_variables(ip)
+    restore_aliases(ip)
+    restore_dhist(ip)
+
+
+@magics_class
+class StoreMagics(Magics):
+    """Lightweight persistence for python variables.
+
+    Provides the %store magic."""
+
+    autorestore = Bool(False, help=
+        """If True, any %store-d variables will be automatically restored
+        when IPython starts.
+        """
+    ).tag(config=True)
+
+    def __init__(self, shell):
+        super(StoreMagics, self).__init__(shell=shell)
+        self.shell.configurables.append(self)
+        if self.autorestore:
+            restore_data(self.shell)
+
+    @skip_doctest
+    @line_magic
+    def store(self, parameter_s=''):
+        """Lightweight persistence for python variables.
+
+        Example::
+
+          In [1]: l = ['hello',10,'world']
+          In [2]: %store l
+          Stored 'l' (list)
+          In [3]: exit
+
+          (IPython session is closed and started again...)
+
+          ville@badger:~$ ipython
+          In [1]: l
+          NameError: name 'l' is not defined
+          In [2]: %store -r
+          In [3]: l
+          Out[3]: ['hello', 10, 'world']
+
+        Usage:
+
+        * ``%store``          - Show list of all variables and their current
+                                values
+        * ``%store spam bar`` - Store the *current* value of the variables spam
+                                and bar to disk
+        * ``%store -d spam``  - Remove the variable and its value from storage
+        * ``%store -z``       - Remove all variables from storage
+        * ``%store -r``       - Refresh all variables, aliases and directory history
+                                from store (overwrite current vals)
+        * ``%store -r spam bar`` - Refresh specified variables and aliases from store
+                                   (delete current val)
+        * ``%store foo >a.txt``  - Store value of foo to new file a.txt
+        * ``%store foo >>a.txt`` - Append value of foo to file a.txt
+
+        It should be noted that if you change the value of a variable, you
+        need to %store it again if you want to persist the new value.
+
+        Note also that the variables will need to be pickleable; most basic
+        python types can be safely %store'd.
+
+        Also aliases can be %store'd across sessions.
+        To remove an alias from the storage, use the %unalias magic.
+        """
+
+        opts,argsl = self.parse_options(parameter_s,'drz',mode='string')
+        args = argsl.split()
+        ip = self.shell
+        db = ip.db
+        # delete
+        if 'd' in opts:
+            try:
+                todel = args[0]
+            except IndexError as e:
+                raise UsageError('You must provide the variable to forget') from e
+            else:
+                try:
+                    del db['autorestore/' + todel]
+                except BaseException as e:
+                    raise UsageError("Can't delete variable '%s'" % todel) from e
+        # reset
+        elif 'z' in opts:
+            for k in db.keys('autorestore/*'):
+                del db[k]
+
+        elif 'r' in opts:
+            if args:
+                for arg in args:
+                    try:
+                        obj = db["autorestore/" + arg]
+                    except KeyError:
+                        try:
+                            restore_aliases(ip, alias=arg)
+                        except KeyError:
+                            print("no stored variable or alias %s" % arg)
+                    else:
+                        ip.user_ns[arg] = obj
+            else:
+                restore_data(ip)
+
+        # run without arguments -> list variables & values
+        elif not args:
+            vars = db.keys('autorestore/*')
+            vars.sort()
+            if vars:
+                size = max(map(len, vars))
+            else:
+                size = 0
+
+            print('Stored variables and their in-db values:')
+            fmt = '%-'+str(size)+'s -> %s'
+            get = db.get
+            for var in vars:
+                justkey = os.path.basename(var)
+                # print 30 first characters from every var
+                print(fmt % (justkey, repr(get(var, '<unavailable>'))[:50]))
+
+        # default action - store the variable
+        else:
+            # %store foo >file.txt or >>file.txt
+            if len(args) > 1 and args[1].startswith(">"):
+                fnam = os.path.expanduser(args[1].lstrip(">").lstrip())
+                if args[1].startswith(">>"):
+                    fil = open(fnam, "a", encoding="utf-8")
+                else:
+                    fil = open(fnam, "w", encoding="utf-8")
+                with fil:
+                    obj = ip.ev(args[0])
+                    print("Writing '%s' (%s) to file '%s'." % (args[0],
+                        obj.__class__.__name__, fnam))
+
+                    if not isinstance (obj, str):
+                        from pprint import pprint
+                        pprint(obj, fil)
+                    else:
+                        fil.write(obj)
+                        if not obj.endswith('\n'):
+                            fil.write('\n')
+
+                return
+
+            # %store foo
+            for arg in args:
+                try:
+                    obj = ip.user_ns[arg]
+                except KeyError:
+                    # it might be an alias
+                    name = arg
+                    try:
+                        cmd = ip.alias_manager.retrieve_alias(name)
+                    except ValueError as e:
+                        raise UsageError("Unknown variable '%s'" % name) from e
+
+                    staliases = db.get('stored_aliases',{})
+                    staliases[name] = cmd
+                    db['stored_aliases'] = staliases
+                    print("Alias stored: %s (%s)" % (name, cmd))
+                    return
+
+                else:
+                    modname = getattr(inspect.getmodule(obj), '__name__', '')
+                    if modname == '__main__':
+                        print(textwrap.dedent("""\
+                        Warning:%s is %s
+                        Proper storage of interactively declared classes (or instances
+                        of those classes) is not possible! Only instances
+                        of classes in real modules on file system can be %%store'd.
+                        """ % (arg, obj) ))
+                        return
+                    #pickled = pickle.dumps(obj)
+                    db[ 'autorestore/' + arg ] = obj
+                    print("Stored '%s' (%s)" % (arg, obj.__class__.__name__))
+
+
+def load_ipython_extension(ip):
+    """Load the extension in IPython."""
+    ip.register_magics(StoreMagics)
+
diff --git a/IPython/extensions/sympy_printing.py b/IPython/extensions/sympy_printing.py
deleted file mode 100644
index 3633469f0e3..00000000000
--- a/IPython/extensions/sympy_printing.py
+++ /dev/null
@@ -1,70 +0,0 @@
-"""A print function that pretty prints sympy Basic objects.
-
-Authors:
-* Brian Granger
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from IPython.lib.latextools import latex_to_png
-from IPython.testing import decorators as dec
-# use @dec.skipif_not_sympy to skip tests requiring sympy
-
-try:
-    from sympy import pretty, latex
-except ImportError:
-    pass
-
-
-#-----------------------------------------------------------------------------
-# Definitions of magic functions for use with IPython
-#-----------------------------------------------------------------------------
-
-def print_basic_unicode(o, p, cycle):
-    """A function to pretty print sympy Basic objects."""
-    if cycle:
-        return p.text('Basic(...)')
-    out = pretty(o, use_unicode=True)
-    if '\n' in out:
-        p.text(u'\n')
-    p.text(out)
-
-
-def print_png(o):
-    """A funciton to display sympy expression using LaTex -> PNG."""
-    s = latex(o, mode='inline')
-    # mathtext does not understand certain latex flags, so we try to replace
-    # them with suitable subs.
-    s = s.replace('\\operatorname','')
-    s = s.replace('\\overline', '\\bar')
-    png = latex_to_png(s, encode=True)
-    return png
-
-_loaded = False
-
-def load_ipython_extension(ip):
-    """Load the extension in IPython."""
-    global _loaded
-    if not _loaded:
-        plaintext_formatter = ip.display_formatter.formatters['text/plain']
-        plaintext_formatter.for_type_by_name(
-            'sympy.core.basic', 'Basic', print_basic_unicode
-        )
-        plaintext_formatter.for_type_by_name(
-            'sympy.matrices.matrices', 'Matrix', print_basic_unicode
-        )
-
-        png_formatter = ip.display_formatter.formatters['image/png']
-        png_formatter.for_type_by_name(
-            'sympy.core.basic', 'Basic', print_png
-        )
-        _loaded = True
-
diff --git a/IPython/extensions/tests/__init__.py b/IPython/extensions/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/extensions/tests/test_deduperreload.py b/IPython/extensions/tests/test_deduperreload.py
new file mode 100755
index 00000000000..7db748849c0
--- /dev/null
+++ b/IPython/extensions/tests/test_deduperreload.py
@@ -0,0 +1,2347 @@
+#!/usr/bin/env python
+from __future__ import annotations
+import ast
+import os
+import platform
+import pytest
+import random
+import shutil
+import sys
+import tempfile
+import textwrap
+import time
+import unittest
+from types import ModuleType
+
+from IPython.extensions.autoreload import AutoreloadMagics
+
+from IPython.extensions.deduperreload.deduperreload import compare_ast, DeduperReloader
+
+if platform.python_implementation() != "CPython":
+    pytest.skip(
+        "We do not support non-CPython versions.",
+        allow_module_level=True,
+    )
+
+
+class DeduperTestReloader(DeduperReloader):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.exceptions_raised: list[Exception] = []
+
+    def _patch_namespace(
+        self, module: ModuleType | type, prefixes: list[str] | None = None
+    ) -> bool:
+        try:
+            assert super()._patch_namespace(module, prefixes)
+            return True
+        except Exception as e:
+            self.exceptions_raised.append(e)
+            return False
+
+
+def is_nonempty_file(fname: str) -> bool:
+    return len(fname) > 0
+
+
+def squish_text(text: str) -> str:
+    """
+    Turns text like this:
+
+    '''        def foo():
+    return "bar"
+            def baz():
+                return "bat"
+    def bam():
+                return "bat"
+    '''
+
+    into this:
+
+    '''def foo():
+        return "bar"
+    def baz():
+        return "bat"
+    def bam():
+        return "bat"
+    '''
+
+    The former is common when we are trying to use string templates
+    whose parameters are multiline and unaware of the existing indentation.
+
+    :param text: a string with messed up indentation
+    :return: `text` but with indentation fixed
+    """
+    prev_indentation = 0
+    transformed_text_lines = []
+    for line in text.strip("\n").splitlines():
+        line_without_indentation = line.lstrip()
+        indentation = len(line) - len(line_without_indentation)
+        if indentation == 0:
+            indentation = prev_indentation
+        else:
+            prev_indentation = indentation
+        transformed_text_lines.append(
+            textwrap.indent(line_without_indentation, " " * indentation)
+        )
+    return textwrap.dedent("\n".join(transformed_text_lines))
+
+
+class AutoreloadDetectionSuite(unittest.TestCase):
+    """
+    Unit tests for autoreload testing logic
+    """
+
+    def test_compare_ast(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                def fn(sdfsdf):
+                    print(sdfsdf)
+                if n < 0:
+                    return "Factorial is not defined for negative numbers."
+                elif n == 0 or n == 1:
+                    return 1
+                else:
+                    result = 1
+                    for i in range(2, n + 1):
+                        result *= i
+                    return result
+                y = 12
+                print(y)
+            print(1)
+            x = 1212121
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                def fn(sdfsdf):
+                    print(sdfsdf+"!!!")
+                if n < 0:
+                    return "Factorial is not defined for negative numbers."
+                elif n == 0 or n == 1:
+                    return 1
+                else:
+                    result = 1
+                    for i in range(2, n + 1):
+                        result *= i
+                    return result
+                y = 12
+                print(y)
+            print(1)
+            x = 1212121
+        """
+        )
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert not compare_ast(ast_1, ast_2)
+
+    def test_compare_ast2(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                def fn(sdfsdf):
+                    print(sdfsdf)
+                if n < 0:
+                    return "Factorial is not defined for negative numbers."
+                elif n == 0 or n == 1:
+                    return 1
+                else:
+                    result = 1
+                    for i in range(2, n + 1):
+                        result *= i
+                    return result
+                y = 12
+                print(y)
+            print(1)
+            x = 1212121
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                def fn(sdfsdf):
+                    print(sdfsdf)
+                if n < 0:
+                    return "Factorial is not defined for negative numbers."
+                elif n == 0 or n == 1:
+                    return 1
+                else:
+                    result = 1
+                    for i in range(2, n + 1):
+                        result *= i
+                    return result
+                y = 12
+                print(y)
+            print(1)
+            x = 1212121
+        """
+        )
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert compare_ast(ast_1, ast_2)
+
+    def test_autoreload_no_changes(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                print(n)
+            print(1)
+            x = 1212121
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                print(n)
+            print(1)
+            x = 1212121
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert deduperreloader._to_autoreload.defs_to_reload == []
+
+    def test_autoreload_static_assign_change_outside_function(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                print(n)
+            print(1)
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                print(n)
+            print(1)
+            x = 1212121
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_changes_inside_function(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                print(n)
+            print(1)
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                print(n + "edit!")
+            print(1)
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert len(deduperreloader._to_autoreload.defs_to_reload) == 1
+
+    def test_autoreload_changes_inside_and_outside_function(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                print(n)
+            print(1)
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                print(n + "edit!")
+            print(2)
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert not deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_changes_inner_function(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                def foo():
+                    x = 3   
+                    return x
+                return foo
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                def foo():
+                    x = 4  
+                    return x
+                return foo
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert len(deduperreloader._to_autoreload.defs_to_reload) == 1
+
+    def test_autoreload_changes_multiple_function(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                def foo():
+                    x = 3   
+                    return x
+                return foo
+            def bar():
+                return 1
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                def foo():
+                    x = 4  
+                    return x
+                return foo
+            def bar():
+                return 2
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert len(deduperreloader._to_autoreload.defs_to_reload) == 2
+
+    def test_autoreload_change_one_function_of_multiple(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                def foo():
+                    x = 3   
+                    return x
+                return foo
+            def bar():
+                return 1
+        """
+        )
+        code2 = squish_text(
+            """
+            def factorial(n):
+                def foo():
+                    x = 4  
+                    return x
+                return foo
+            def bar():
+                return 1
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert len(deduperreloader._to_autoreload.defs_to_reload) == 1
+
+    def test_autoreload_handling_moves(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                return 1
+            x = 1
+        """
+        )
+        code2 = squish_text(
+            """
+            x = 1
+            def factorial(n):
+                return 1
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert len(deduperreloader._to_autoreload.defs_to_reload) == 0
+
+    def test_autoreload_handling_function_moves_success(self):
+        code1 = squish_text(
+            """
+            def factorial(n):
+                return 1
+            x = 1
+            def foo():
+                return 23
+            x = 2
+        """
+        )
+        code2 = squish_text(
+            """
+        x = 1
+        x = 2
+        def foo():
+            return 23
+        def factorial(n):
+            return 1
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert len(deduperreloader._to_autoreload.defs_to_reload) == 0
+
+    def test_autoreload_handling_function_moves_only(self):
+        code1 = squish_text(
+            """
+        def factorial(n):
+            return 1
+        x = 1
+        x = 2
+        """
+        )
+        code2 = squish_text(
+            """
+        x = 1
+        x = 2
+        def factorial(n):
+            return 1
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_handles_new_imports(self):
+        code1 = squish_text(
+            """
+        def factorial(n):
+            return 1
+        x = 1
+        """
+        )
+        code2 = squish_text(
+            """
+        import ast
+        def factorial(n):
+            return 1
+        x = 1
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_async_function(self):
+        code1 = squish_text(
+            """
+        async def sleep():
+            print(f'Time: {time.time() - start:.2f}')
+            await asyncio.sleep(1)
+        """
+        )
+        code2 = squish_text(
+            """
+        async def sleep():
+            print(f'Time: {time.time() - start:.2f}')
+            await asyncio.sleep(10)
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert len(deduperreloader._to_autoreload.defs_to_reload) == 1
+
+    def test_autoreload_add_function(self):
+        code1 = squish_text(
+            """
+        async def sleep():
+            print(f'Time: {time.time() - start:.2f}')
+            await asyncio.sleep(1)
+        """
+        )
+        code2 = squish_text(
+            """
+        async def sleep():
+            print(f'Time: {time.time() - start:.2f}')
+            await asyncio.sleep(1)
+        def add(x,y):
+            pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert list(d[0][0] for d in deduperreloader._to_autoreload.defs_to_reload) == [
+            "add"
+        ]
+
+    def test_autoreload_add_function_ellipsis(self):
+        code1 = squish_text(
+            """
+        async def sleep():
+            print(f'Time: {time.time() - start:.2f}')
+            await asyncio.sleep(1)
+        """
+        )
+        code2 = squish_text(
+            """
+        async def sleep():
+            print(f'Time: {time.time() - start:.2f}')
+            await asyncio.sleep(1)
+        def add(x,y):
+            ...
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert list(d[0][0] for d in deduperreloader._to_autoreload.defs_to_reload) == [
+            "add"
+        ]
+
+
+class AutoreloadPatchingSuite(unittest.TestCase):
+    """
+    Unit tests for autoreload patching logic
+    """
+
+    def setUp(self) -> None:
+        self.deduperreloader = DeduperTestReloader()
+
+    def test_patching(self):
+        code1 = squish_text(
+            """
+            def foo():
+                return 1
+        """
+        )
+        code2 = squish_text(
+            """
+            def foo():
+                return 2
+        """
+        )
+        self.deduperreloader._to_autoreload.defs_to_reload = [
+            (("foo",), ast.parse(code2))
+        ]
+        mod = ModuleType("mod")
+        exec(code1, mod.__dict__)
+        self.deduperreloader._patch_namespace(mod)
+        assert mod.foo() == 2
+
+    def test_patching_parameters(self):
+        code1 = squish_text(
+            """
+            def foo(n,s):
+                return n+s
+        """
+        )
+        code2 = squish_text(
+            """
+            def foo(n):
+                return n
+        """
+        )
+        self.deduperreloader._to_autoreload.defs_to_reload = [
+            (("foo",), ast.parse(code2))
+        ]
+        mod = ModuleType("mod")
+        exec(code1, mod.__dict__)
+        self.deduperreloader._patch_namespace(mod)
+        assert mod.foo(2) == 2
+
+    def test_add_function(self):
+        code1 = squish_text(
+            """
+            def foo2(n):
+                return n
+        """
+        )
+        code2 = squish_text(
+            """
+            def foo(n):
+                return 55
+        """
+        )
+        self.deduperreloader._to_autoreload.defs_to_reload = [
+            (("foo",), ast.parse(code2))
+        ]
+        mod = ModuleType("mod")
+        exec(code1, mod.__dict__)
+        self.deduperreloader._patch_namespace(mod)
+        assert mod.foo(2) == 55
+        assert mod.foo2(2) == 2
+
+    def test_two_operations(self):
+        code1 = squish_text(
+            """
+            def foo(n):
+                return 1
+        """
+        )
+        code2 = squish_text(
+            """
+            def foo(n):
+                return 55
+        """
+        )
+        code3 = squish_text(
+            """
+            def goo():
+                return -1
+            def foo(n):
+                x = 2
+                return x+n
+            def bar():
+                return 200
+        """
+        )
+        self.deduperreloader._to_autoreload.defs_to_reload = [
+            (("foo",), ast.parse(code2))
+        ]
+        mod = ModuleType("mod")
+        exec(code1, mod.__dict__)
+        assert mod.foo(2) == 1
+        self.deduperreloader._patch_namespace(mod)
+        assert mod.foo(2) == 55
+        self.deduperreloader._to_autoreload.defs_to_reload = [
+            (("foo",), ast.parse(code3))
+        ]
+        self.deduperreloader._patch_namespace(mod)
+        assert mod.foo(2) == 4
+
+    def test_using_outside_param(self):
+        code1 = squish_text(
+            """
+            x=1
+            def foo(n):
+                return 1
+        """
+        )
+        code2 = squish_text(
+            """
+            x=1
+            def foo(n):
+                return 55+x
+        """
+        )
+        self.deduperreloader._to_autoreload.defs_to_reload = [
+            (("foo",), ast.parse(code2))
+        ]
+        mod = ModuleType("mod")
+        exec(code1, mod.__dict__)
+        assert mod.foo(2) == 1
+        self.deduperreloader._patch_namespace(mod)
+        assert mod.foo(2) == 56
+
+    def test_importing_func(self):
+        code1 = squish_text(
+            """
+            from os import environ
+            def foo(n):
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            from os import environ
+            def foo():
+                environ._data
+                return 1
+        """
+        )
+        self.deduperreloader._to_autoreload.defs_to_reload = [
+            (("foo",), ast.parse(code2))
+        ]
+        mod = ModuleType("mod")
+        exec(code1, mod.__dict__)
+        self.deduperreloader._patch_namespace(mod)
+        assert mod.foo() == 1
+
+
+class FakeShell:
+    def __init__(self):
+        self.ns = {}
+        self.user_ns = self.ns
+        self.user_ns_hidden = {}
+        self.auto_magics = AutoreloadMagics(shell=self)
+
+    @staticmethod
+    def pre_run_cell(obj):
+        try_with_arg = False
+        try:
+            obj.pre_run_cell()
+        except TypeError:
+            try_with_arg = True
+        if try_with_arg:
+            obj.pre_run_cell(None)
+
+    @staticmethod
+    def post_run_cell(obj):
+        try_with_arg = False
+        try:
+            obj.post_run_cell()
+        except TypeError:
+            try_with_arg = True
+        if try_with_arg:
+            obj.post_run_cell(None)
+
+    def run_code(self, code):
+        self.pre_run_cell(self.auto_magics)
+        exec(code, self.user_ns)
+        self.auto_magics.post_execute_hook()
+
+    def push(self, items):
+        self.ns.update(items)
+
+    def magic_autoreload(self, parameter):
+        self.auto_magics.autoreload(parameter)
+
+
+class ShellFixture(unittest.TestCase):
+    """Fixture for creating test module files"""
+
+    test_dir = None
+    old_sys_path = None
+    filename_chars = "abcdefghijklmopqrstuvwxyz0123456789"
+
+    def setUp(self):
+        self.created_temp_modules = set()
+        self.test_dir = tempfile.mkdtemp()
+        self.old_sys_path = list(sys.path)
+        sys.path.insert(0, self.test_dir)
+        self.shell = FakeShell()
+
+    def tearDown(self):
+        for mod_name in self.created_temp_modules:
+            sys.modules.pop(mod_name, None)
+        shutil.rmtree(self.test_dir)
+        sys.path = self.old_sys_path
+
+        self.test_dir = None
+        self.old_sys_path = None
+        self.shell = None
+
+    def get_module(self):
+        module_name = "tmpmod_" + "".join(random.sample(self.filename_chars, 20))
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+        file_name = os.path.join(self.test_dir, module_name + ".py")
+        return module_name, file_name
+
+    def write_file(self, filename, content):
+        """
+        Write a file, and force a timestamp difference of at least one second
+
+        Notes
+        -----
+        Python's .pyc files record the timestamp of their compilation
+        with a time resolution of one second.
+
+        Therefore, we need to force a timestamp difference between .py
+        and .pyc, without having the .py file be timestamped in the
+        future, and without changing the timestamp of the .pyc file
+        (because that is stored in the file). The only reliable way
+        to achieve this seems to be to sleep.
+
+        Doesn't seem necessary on Darwin so we make this the exception.
+        """
+        if platform.system().lower() != "darwin":
+            time.sleep(1.05)
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(squish_text(content))
+
+    def new_module(self, code):
+        mod_name, mod_fn = self.get_module()
+        with open(mod_fn, "w", encoding="utf-8") as f:
+            f.write(squish_text(code))
+        self.created_temp_modules.add(mod_name)
+        return mod_name, mod_fn
+
+
+class AutoreloadHookSuite(ShellFixture):
+    def test_deduperreloader_basic(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            def foo(y):
+                return y + 5
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 5
+
+    def test_deduperreloader_basic2(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            def foo(y):
+                return y + 5
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 5
+
+    def test_deduperreloader_basic3(self):
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.magic_autoreload("2")
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            def foo(y):
+                return y + 5
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 5
+
+    def test_deduperreloader_basic4(self):
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.magic_autoreload("2")
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            def foo(y):
+                return y + 5
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 5
+
+    def test_deduperreloader_basic5(self):
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.shell.magic_autoreload("2")
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            def foo(y):
+                return y + 5
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 5
+
+    def test_deduperreloader_basic6(self):
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.shell.magic_autoreload("2")
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            def foo(y):
+                return y + 5
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 5
+
+    def test_super(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class Foo:
+                def foo(self):
+                    return 1
+            class Bar(Foo):
+                def bar(self):
+                    return super().foo() + 1
+        """
+        )
+        self.shell.run_code(f"from {mod_name} import Bar; bar = Bar()")
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class Foo:
+                def foo(self):
+                    return 1
+            class Bar(Foo):
+                def bar(self):
+                    return super().foo() + 2
+            """,
+        )
+        self.shell.run_code("result = bar.bar()")
+        # NOTE : only works on CPython, requires read-only patching.
+        if platform.python_implementation() == "CPython":
+            assert self.shell.user_ns["result"] == 3
+
+    def test_deduperreloader_need_to_default_back(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 200
+            def foo(y):
+                return y + 5
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 5
+
+    def test_deduperreloader_failure(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            def foo(y):
+                return y + 3
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            broken broken broken
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo(0) == 3
+
+    def test_deduperreloader_imported_mod(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            from os import environ
+            def foo(n):
+                pass
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            from os import environ
+            def foo():
+                environ._data
+                return 1
+        """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo() == 1
+
+
+class AutoreloadClassMethodsDetectionSuite(unittest.TestCase):
+    """
+    Unit tests for autoreload testing logic
+    """
+
+    def test_autoreload_method(self):
+        code1 = squish_text(
+            """
+            class C(n):
+                def foo():
+                    pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C(n):
+                def foo():
+                    x = 1
+                    return x
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert deduperreloader._to_autoreload.defs_to_reload == []
+        assert "C" in deduperreloader._to_autoreload.children
+        assert ["foo"] == list(
+            d[0][0] for d in deduperreloader._to_autoreload.children["C"].defs_to_reload
+        )
+        assert deduperreloader._to_autoreload.children["C"].children == {}
+
+    def test_autoreload_no_changes(self):
+        code1 = squish_text(
+            """
+            class D(n):
+                def foo():
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class D(n):
+                def foo():
+                    pass
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert deduperreloader._to_autoreload.defs_to_reload == []
+        assert deduperreloader._to_autoreload.children == {}
+
+    def test_autoreload_add_function(self):
+        code1 = squish_text(
+            """
+            class C:
+                def foo():
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                def foo():
+                    x = 1
+                    return x
+                def bar():
+                    return -1
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert deduperreloader._to_autoreload.defs_to_reload == []
+        assert "C" in deduperreloader._to_autoreload.children
+        assert ["foo", "bar"] == list(
+            d[0][0] for d in deduperreloader._to_autoreload.children["C"].defs_to_reload
+        )
+        assert len(deduperreloader._to_autoreload.children["C"].children) == 0
+
+    def test_autoreload_remove_method(self):
+        code1 = squish_text(
+            """
+            class C:
+                def foo():
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                pass
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_remove_class(self):
+        code1 = squish_text(
+            """
+            class C:
+                def foo():
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_add_class_in_class(self):
+        code1 = squish_text(
+            """
+            class C:
+                pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                class D:
+                    pass
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_add_method_in_class_in_class(self):
+        code1 = squish_text(
+            """
+            class C:
+                class D:
+                    x = 1
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                class D:
+                    x = 1
+                    def foo():
+                        return 1
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert deduperreloader._to_autoreload.defs_to_reload == []
+        assert list(deduperreloader._to_autoreload.children.keys()) == ["C"]
+        assert deduperreloader._to_autoreload.children["C"].defs_to_reload == []
+        assert list(deduperreloader._to_autoreload.children["C"].children.keys()) == [
+            "D"
+        ]
+        assert list(
+            d[0][0]
+            for d in deduperreloader._to_autoreload.children["C"]
+            .children["D"]
+            .defs_to_reload
+        ) == ["foo"]
+        assert deduperreloader._to_autoreload.children["C"].children["D"].children == {}
+
+    def test_autoreload_add_var_and_method_in_class_in_class(self):
+        code1 = squish_text(
+            """
+            class C:
+                class D:
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                class D:
+                    x = 1
+                    def foo():
+                        return 1
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+    def test_autoreload_add_method_in_class_in_class_pass(self):
+        code1 = squish_text(
+            """
+            class C:
+                class D:
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                class D:
+                    def foo():
+                        return 1
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert deduperreloader._to_autoreload.defs_to_reload == []
+        assert list(deduperreloader._to_autoreload.children.keys()) == ["C"]
+        assert deduperreloader._to_autoreload.children["C"].defs_to_reload == []
+        assert list(deduperreloader._to_autoreload.children["C"].children.keys()) == [
+            "D"
+        ]
+        assert list(
+            d[0][0]
+            for d in deduperreloader._to_autoreload.children["C"]
+            .children["D"]
+            .defs_to_reload
+        ) == ["foo"]
+        assert deduperreloader._to_autoreload.children["C"].children["D"].children == {}
+
+    def test_autoreload_add_method_in_class_in_class_more(self):
+        code1 = squish_text(
+            """
+            class C:
+                class D:
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                def bar():
+                    return -1
+                class D:
+                    def foo():
+                        return 1
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+        assert deduperreloader._to_autoreload.defs_to_reload == []
+        assert list(deduperreloader._to_autoreload.children.keys()) == ["C"]
+        assert list(
+            d[0][0] for d in deduperreloader._to_autoreload.children["C"].defs_to_reload
+        ) == ["bar"]
+        assert list(deduperreloader._to_autoreload.children["C"].children.keys()) == [
+            "D"
+        ]
+        assert list(
+            d[0][0]
+            for d in deduperreloader._to_autoreload.children["C"]
+            .children["D"]
+            .defs_to_reload
+        ) == ["foo"]
+        assert deduperreloader._to_autoreload.children["C"].children["D"].children == {}
+
+    def test_autoreload_add_method_in_class_in_class_with_members(self):
+        code1 = squish_text(
+            """
+            class C:
+                class D:
+                    pass
+            def foo():
+                pass
+        """
+        )
+        code2 = squish_text(
+            """
+            class C:
+                def bar():
+                    return -1
+                class D:
+                    s = 2
+                    def foo():
+                        return 1
+            def foo():
+                pass
+        """
+        )
+        deduperreloader = DeduperTestReloader()
+        ast_1 = ast.parse(code1)
+        ast_2 = ast.parse(code2)
+
+        assert deduperreloader.detect_autoreload(ast_1, ast_2)
+
+
+class AutoreloadReliabilitySuite(ShellFixture):
+    def test_autoreload_class_basic(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            class C:
+                def foo():
+                    return 1
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            class C:
+                def foo():
+                    return 1
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.foo() == 1
+
+    def test_remove_overridden_method(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class A:
+                def foo(self):
+                    return 1
+            class B(A):
+                def foo(self):
+                    return 42
+        """
+        )
+        self.shell.run_code(f"from {mod_name} import B; b = B()")
+        self.shell.run_code("assert b.foo() == 42")
+        self.write_file(
+            mod_fn,
+            """
+            class A:
+                def foo(self):
+                    return 1
+            class B(A):
+                pass
+            """,
+        )
+        self.shell.run_code("assert b.foo() == 1")
+
+    def test_autoreload_class_use_outside_func(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            class C:
+                def foo():
+                    return 1
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 9
+            class C:
+                def foo():
+                    return 1+x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.foo() == 10
+
+    def test_autoreload_class_use_class_member(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            class C:
+                def foo():
+                    return 1
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def foo():
+                    return 1+C.x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.foo() == 10
+
+    def test_autoreload_class_pass(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            class C:
+                pass
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def foo():
+                    return 1+C.x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.foo() == 10
+
+    def test_autoreload_class_ellipsis(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 9
+            class C:
+                ...
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def foo():
+                    return 1+C.x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.foo() == 10
+
+    def test_autoreload_class_default_autoreload(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                x = 9
+                def foo():
+                    return 1+C.x
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 20
+                def foo():
+                    return 1+C.x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.foo() == 21
+
+    def test_autoreload_class_nested(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                x = 9
+                class D:
+                    def foo():
+                        pass
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                class D:
+                    def foo():
+                        return 10
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.D.foo() == 10
+
+    def test_autoreload_class_nested2(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                x = 9
+                def c():
+                    return 1
+                class D:
+                    def foo():
+                        pass
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def c():
+                    return 1
+                class D:
+                    def foo():
+                        return 10
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.D.foo() == 10
+        assert mod.C.c() == 1
+
+    def test_autoreload_class_nested3(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                x = 9
+                def c():
+                    return 1
+                class D:
+                    def foo():
+                        pass
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def c():
+                    return 13
+                class D:
+                    def foo():
+                        return 10
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.D.foo() == 10
+        assert mod.C.c() == 13
+
+    def test_autoreload_new_class_added(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                x = 9
+                def c():
+                    return 1
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def c():
+                    return 13
+            class D:
+                def c():
+                    return 1
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.c() == 13
+        assert mod.D.c() == 1
+
+    def test_autoreload_class_nested_default(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                pass
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def c():
+                    return 13
+                class D:
+                    def foo():
+                        return 10
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.D.foo() == 10
+        assert mod.C.c() == 13
+
+    def test_autoreload_class_nested_using_members(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                x = 9
+                def c():
+                    return 13
+                class D:
+                    def foo():
+                        return 10
+            """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def c():
+                    return 13
+                class D:
+                    def foo():
+                        return 10 + C.x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.D.foo() == 19
+        assert mod.C.c() == 13
+
+    def test_autoreload_class_nested_using_members_ellipsis(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class C:
+                x = 9
+                def c():
+                    return 13
+                class D:
+                    def foo():
+                        ...
+            """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            class C:
+                x = 9
+                def c():
+                    return 13
+                class D:
+                    def foo():
+                        return 10 + C.x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.C.D.foo() == 19
+        assert mod.C.c() == 13
+
+    def test_method_decorators_no_changes(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 0
+                    
+                @classmethod
+                def foo(cls):
+                    return 42 + cls.bar()
+            
+            foo = Foo.foo
+            """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.foo() == 42
+
+        self.shell.run_code(f"assert {mod_name}.foo() == 42")
+        self.write_file(
+            mod_file,
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 0
+            
+                @classmethod
+                def foo(cls):
+                    return 42 + cls.bar()
+            
+            foo = Foo.foo
+            """,
+        )
+        self.shell.run_code(f"assert {mod_name}.foo() == 42")
+
+    def test_method_decorators_no_changes1(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 0
+                    
+                @classmethod
+                def foo(cls):
+                    return 42 + cls.bar()
+            
+            foo = Foo.foo
+            """
+        )
+
+        self.shell.run_code(f"from {mod_name} import foo")
+        self.shell.run_code("assert foo() == 42")
+        self.write_file(
+            mod_file,
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 0
+            
+                @classmethod
+                def foo(cls):
+                    return 42 + cls.bar()
+            
+            foo = Foo.foo
+            """,
+        )
+        self.shell.run_code("assert foo() == 42")
+
+    def test_method_classmethod_one_change(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 0
+                    
+                @classmethod
+                def func(cls):
+                    return 42 + cls.bar()
+            
+            func = Foo.func
+            """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code(f"assert {mod_name}.func() == 42")
+        self.write_file(
+            mod_file,
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 1
+            
+                @classmethod
+                def func(cls):
+                    return 42 + cls.bar()
+            
+            func = Foo.func
+            """,
+        )
+        mod = sys.modules[mod_name]
+        self.shell.run_code(f"assert {mod_name}.func() == 43")
+
+    def test_method_staticmethod_one_change(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            class Foo:
+                @staticmethod
+                def bar():
+                    return 0
+                    
+                @staticmethod
+                def func():
+                    return 42 + Foo.bar()
+            
+            func = Foo.func
+            """
+        )
+        self.shell.run_code(f"from {mod_name} import func")
+        self.shell.run_code("assert func() == 42")
+        self.write_file(
+            mod_file,
+            """
+            class Foo:
+                @staticmethod
+                def bar():
+                    return 1
+            
+                @staticmethod
+                def func():
+                    return 42 + Foo.bar()
+            
+            func = Foo.func
+            """,
+        )
+        self.shell.run_code("assert func() == 43")
+
+    def test_autoreload_class_default_args(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 42
+            class Foo:
+                def foo(self, y): return y
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 42
+            class Foo:
+                def foo(self, y=x): return y
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        obj = mod.Foo()
+        assert obj.foo(2) == 2
+        assert obj.foo() == 42
+
+    def test_autoreload_class_change_default_args(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 42
+            class Foo:
+                def foo(y): return y
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        self.write_file(
+            mod_fn,
+            """
+            x = 44
+            class Foo:
+                def foo(y=x): return y
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        mod = sys.modules[mod_name]
+        assert mod.Foo.foo() == 44
+
+    def test_autoreload_class_new_class(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 42
+            class Foo:
+                def foo(y=x): return y
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        prev_foo = self.shell.user_ns[mod_name].Foo.foo
+        self.write_file(
+            mod_fn,
+            """
+            x = 42
+            class Foo:
+                def foo(y=x): return y
+            class C:
+                def foo(): return 200
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        self.assertIs(prev_foo, self.shell.user_ns[mod_name].Foo.foo)
+        mod = sys.modules[mod_name]
+        assert mod.Foo.foo() == 42
+        assert mod.C.foo() == 200
+
+    def test_autoreload_overloaded_vars(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 42
+            class Foo:
+                pass
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        mod = sys.modules[mod_name]
+        self.write_file(
+            mod_fn,
+            """
+            x = 44
+            class Foo:
+                def foo(): 
+                    x = 2
+                    return x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        assert mod.Foo.foo() == 2
+
+    def test_autoreload_overloaded_vars2(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            x = 42
+            def foo():
+                return x
+        """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        mod = sys.modules[mod_name]
+        self.write_file(
+            mod_fn,
+            """
+            x = 44
+            def foo(): 
+                x = 2
+                return x
+            """,
+        )
+        self.shell.run_code("pass")
+        self.assertIn(mod_name, self.shell.user_ns)
+        assert mod.foo() == 2
+
+
+class DecoratorPatchingSuite(ShellFixture):
+    """
+    Unit tests for autoreload patching logic
+    """
+
+    def test_modify_property(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            class Foo:
+                @property
+                def foo(self):
+                    return 42
+            """
+        )
+        self.shell.run_code(f"from {mod_name} import Foo")
+        self.shell.run_code("foo = Foo()")
+        self.shell.run_code("assert foo.foo == 42")
+        self.write_file(
+            mod_file,
+            """
+            class Foo:
+                @property
+                def foo(self):
+                    return 43
+            """,
+        )
+        self.shell.run_code("pass")
+        self.shell.run_code("assert foo.foo == 43")
+
+    def test_method_decorator(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            def incremented(f):
+                return lambda *args: f(*args) + 1
+
+            class Foo:
+                @classmethod
+                @incremented
+                def foo(cls):
+                    return 42
+            
+            foo = Foo.foo
+            """
+        )
+        self.shell.run_code(f"from {mod_name} import foo")
+        self.shell.run_code("assert foo() == 43")
+        self.write_file(
+            mod_file,
+            """
+            def incremented(f):
+                return lambda *args: f(*args) + 1
+
+            class Foo:
+                @classmethod
+                def foo(cls):
+                    return 42
+            
+            foo = Foo.foo
+            """,
+        )
+        self.shell.run_code("assert foo() == 42")
+
+    def test_method_modified_decorator(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            def incremented(f):
+                return lambda *args: f(*args) + 1
+
+            class Foo:
+                @classmethod
+                @incremented
+                def foo(cls):
+                    return 42
+            
+            foo = Foo.foo
+            """
+        )
+        self.shell.run_code(f"from {mod_name} import foo")
+        self.shell.run_code("assert foo() == 43")
+        self.write_file(
+            mod_file,
+            """
+            def incremented(f):
+                return lambda *args: f(*args) + 0
+
+            class Foo:
+                @classmethod
+                @incremented
+                def foo(cls):
+                    return 42
+            
+            foo = Foo.foo
+            """,
+        )
+        self.shell.run_code("assert foo() == 42")
+
+    def test_function_decorators(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            def incremented(f):
+                return lambda *args: f(*args) + 1
+            
+            @incremented
+            def foo():
+                return 42
+            """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        mod = sys.modules[mod_name]
+        assert mod.foo() == 43
+        self.write_file(
+            mod_file,
+            """
+            def incremented(f):
+                return lambda *args: f(*args) + 1
+
+            def foo():
+                return 42
+            """,
+        )
+        self.shell.run_code("pass")
+        assert mod.foo() == 42
+        self.write_file(
+            mod_file,
+            """
+            def incremented(v):
+                def deco(f):
+                    return lambda *args: f(*args) + v
+                return deco
+
+            @incremented(2)
+            def foo():
+                return 43
+            """,
+        )
+        self.shell.run_code("pass")
+        assert mod.foo() == 45
+
+    def test_method_decorators_again(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 0
+                    
+                @classmethod
+                def foo(cls):
+                    return 42 + cls.bar()
+            
+            foo = Foo.foo
+            """
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        mod = sys.modules[mod_name]
+        assert mod.foo() == 42
+        self.write_file(
+            mod_file,
+            """
+            class Foo:
+                @classmethod
+                def bar(cls):
+                    return 1
+            
+                @classmethod
+                def foo(cls):
+                    return 42 + cls.bar()
+            
+            foo = Foo.foo
+            """,
+        )
+        self.shell.run_code("pass")
+        assert mod.Foo.foo() == 43
+        assert mod.foo() == 43
+
+    # This test verifies that the correct globals are used when patching a function
+    # decorated by a function from another module. For this example, we should always
+    # use <mod_name>.__dict__ as the global environment when patching foo, which comes
+    # from <mod_name>, and never <other_mod_name>.__dict__, which is what we would get
+    # if we use foo.__globals__ after it has been decorated.
+    def test_function_decorator_from_other_module(self):
+        self.shell.magic_autoreload("2")
+        other_mod_name, _ = self.new_module(
+            """
+            import functools
+
+            def incremented(f):
+                @functools.wraps(f)
+                def wrapper(*args, **kwargs):
+                    return f(*args, **kwargs) + 1
+                return wrapper
+            """
+        )
+        mod_name, mod_file = self.new_module(
+            f"""
+            from {other_mod_name} import incremented as deco
+            @deco
+            def foo():
+                return 42
+            """
+        )
+        self.shell.run_code(f"from {mod_name} import foo")
+        self.shell.run_code("assert foo() == 43")
+        self.write_file(
+            mod_file,
+            f"""
+            from {other_mod_name} import incremented as deco
+            @deco
+            def foo():
+                return 43
+            """,
+        )
+        self.shell.run_code("assert foo() == 44")
+
+    def test_decorators_with_freevars(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_file = self.new_module(
+            """
+            def decorate(func):
+                free_var_x = "x"
+                free_var_y = "y"
+                def wrapper(*args, **kwargs):
+                    return func(*args, **kwargs), free_var_x, free_var_y
+                return wrapper
+            @decorate
+            def f():
+                return "v1"
+            """
+        )
+        self.shell.run_code(f"from {mod_name} import f")
+        mod = sys.modules[mod_name]
+        assert mod.f() == ("v1", "x", "y")
+        self.write_file(
+            mod_file,
+            """
+            def decorate(func):
+                free_var_ax = "ax"
+                free_var_by = "by"
+                def wrapper(*args, **kwargs):
+                    return func(*args, **kwargs), free_var_ax, free_var_by
+                return wrapper
+            @decorate
+            def f():
+                return "v2"
+            """,
+        )
+        self.shell.run_code("pass")
+        val = mod.f()
+        assert val == ("v2", "ax", "by"), val
+
+
+class TestAutoreloadEnum(ShellFixture):
+    def test_reload_enums(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            from enum import Enum
+            class MyEnum(Enum):
+                A = 'A'
+                B = 'B'
+            """,
+        )
+        self.shell.run_code("import %s" % mod_name)
+        self.shell.run_code("pass")
+        mod = sys.modules[mod_name]
+        self.write_file(
+            mod_fn,
+            """
+            from enum import Enum
+            class MyEnum(Enum):
+                A = 'A'
+                B = 'B'
+                C = 'C'
+            """,
+        )
+        self.shell.run_code("pass")
+        assert mod.MyEnum.C.value == "C"
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/IPython/external/Itpl/_Itpl.py b/IPython/external/Itpl/_Itpl.py
deleted file mode 100644
index 671e9ab33e3..00000000000
--- a/IPython/external/Itpl/_Itpl.py
+++ /dev/null
@@ -1,274 +0,0 @@
-# -*- coding: utf-8 -*-
-"""String interpolation for Python (by Ka-Ping Yee, 14 Feb 2000).
-
-This module lets you quickly and conveniently interpolate values into
-strings (in the flavour of Perl or Tcl, but with less extraneous
-punctuation).  You get a bit more power than in the other languages,
-because this module allows subscripting, slicing, function calls,
-attribute lookup, or arbitrary expressions.  Variables and expressions
-are evaluated in the namespace of the caller.
-
-The itpl() function returns the result of interpolating a string, and
-printpl() prints out an interpolated string.  Here are some examples:
-
-    from Itpl import printpl
-    printpl("Here is a $string.")
-    printpl("Here is a $module.member.")
-    printpl("Here is an $object.member.")
-    printpl("Here is a $functioncall(with, arguments).")
-    printpl("Here is an ${arbitrary + expression}.")
-    printpl("Here is an $array[3] member.")
-    printpl("Here is a $dictionary['member'].")
-
-The filter() function filters a file object so that output through it
-is interpolated.  This lets you produce the illusion that Python knows
-how to do interpolation:
-
-    import Itpl
-    sys.stdout = Itpl.filter()
-    f = "fancy"
-    print "Is this not $f?"
-    print "Standard output has been replaced with a $sys.stdout object."
-    sys.stdout = Itpl.unfilter()
-    print "Okay, back $to $normal."
-
-Under the hood, the Itpl class represents a string that knows how to
-interpolate values.  An instance of the class parses the string once
-upon initialization; the evaluation and substitution can then be done
-each time the instance is evaluated with str(instance).  For example:
-
-    from Itpl import Itpl
-    s = Itpl("Here is $foo.")
-    foo = 5
-    print str(s)
-    foo = "bar"
-    print str(s)
-"""
-
-#*****************************************************************************
-#
-# Copyright (c) 2001 Ka-Ping Yee <ping@lfw.org>
-#
-#
-# Published under the terms of the MIT license, hereby reproduced:
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-#*****************************************************************************
-
-__author__  = 'Ka-Ping Yee <ping@lfw.org>'
-__license__ = 'MIT'
-
-import sys
-from tokenize import tokenprog
-
-class ItplError(ValueError):
-    def __init__(self, text, pos):
-        self.text = text
-        self.pos = pos
-    def __str__(self):
-        return "unfinished expression in %s at char %d" % (
-            repr(self.text), self.pos)
-
-def matchorfail(text, pos):
-    match = tokenprog.match(text, pos)
-    if match is None:
-        raise ItplError(text, pos)
-    return match, match.end()
-
-class Itpl:
-    """Class representing a string with interpolation abilities.
-    
-    Upon creation, an instance works out what parts of the format
-    string are literal and what parts need to be evaluated.  The
-    evaluation and substitution happens in the namespace of the
-    caller when str(instance) is called."""
-
-    def __init__(self, format,codec='utf_8',encoding_errors='backslashreplace'):
-        """The single mandatory argument to this constructor is a format
-        string.
-
-        The format string is parsed according to the following rules:
-
-        1.  A dollar sign and a name, possibly followed by any of: 
-              - an open-paren, and anything up to the matching paren 
-              - an open-bracket, and anything up to the matching bracket 
-              - a period and a name 
-            any number of times, is evaluated as a Python expression.
-
-        2.  A dollar sign immediately followed by an open-brace, and
-            anything up to the matching close-brace, is evaluated as
-            a Python expression.
-
-        3.  Outside of the expressions described in the above two rules,
-            two dollar signs in a row give you one literal dollar sign.
-
-        Optional arguments:
-
-        - codec('utf_8'): a string containing the name of a valid Python
-        codec.
-
-        - encoding_errors('backslashreplace'): a string with a valid error handling
-        policy.  See the codecs module documentation for details.
-
-        These are used to encode the format string if a call to str() fails on
-        the expanded result."""
-
-        if not isinstance(format,basestring):
-            raise TypeError, "needs string initializer"
-        self.format = format
-        self.codec = codec
-        self.encoding_errors = encoding_errors
-        
-        namechars = "abcdefghijklmnopqrstuvwxyz" \
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
-        chunks = []
-        pos = 0
-
-        while 1:
-            dollar = format.find("$", pos)
-            if dollar < 0: break
-            nextchar = format[dollar+1]
-
-            if nextchar == "{":
-                chunks.append((0, format[pos:dollar]))
-                pos, level = dollar+2, 1
-                while level:
-                    match, pos = matchorfail(format, pos)
-                    tstart, tend = match.regs[3]
-                    token = format[tstart:tend]
-                    if token == "{": level = level+1
-                    elif token == "}": level = level-1
-                chunks.append((1, format[dollar+2:pos-1]))
-
-            elif nextchar in namechars:
-                chunks.append((0, format[pos:dollar]))
-                match, pos = matchorfail(format, dollar+1)
-                while pos < len(format):
-                    if format[pos] == "." and \
-                        pos+1 < len(format) and format[pos+1] in namechars:
-                        match, pos = matchorfail(format, pos+1)
-                    elif format[pos] in "([":
-                        pos, level = pos+1, 1
-                        while level:
-                            match, pos = matchorfail(format, pos)
-                            tstart, tend = match.regs[3]
-                            token = format[tstart:tend]
-                            if token[0] in "([": level = level+1
-                            elif token[0] in ")]": level = level-1
-                    else: break
-                chunks.append((1, format[dollar+1:pos]))
-
-            else:
-                chunks.append((0, format[pos:dollar+1]))
-                pos = dollar + 1 + (nextchar == "$")
-
-        if pos < len(format): chunks.append((0, format[pos:]))
-        self.chunks = chunks
-
-    def __repr__(self):
-        return "<Itpl %s >" % repr(self.format)
-
-    def _str(self,glob,loc):
-        """Evaluate to a string in the given globals/locals.
-
-        The final output is built by calling str(), but if this fails, the
-        result is encoded with the instance's codec and error handling policy,
-        via a call to out.encode(self.codec,self.encoding_errors)"""
-        result = []
-        app = result.append
-        for live, chunk in self.chunks:
-            if live: app(str(eval(chunk,glob,loc)))
-            else: app(chunk)
-        out = ''.join(result)
-        try:
-            return str(out)
-        except UnicodeError:
-            return out.encode(self.codec,self.encoding_errors)
-
-    def __str__(self):
-        """Evaluate and substitute the appropriate parts of the string."""
-
-        # We need to skip enough frames to get to the actual caller outside of
-        # Itpl.
-        frame = sys._getframe(1)
-        while frame.f_globals["__name__"] == __name__: frame = frame.f_back
-        loc, glob = frame.f_locals, frame.f_globals
-
-        return self._str(glob,loc)
-    
-class ItplNS(Itpl):
-    """Class representing a string with interpolation abilities.
-
-    This inherits from Itpl, but at creation time a namespace is provided
-    where the evaluation will occur.  The interpolation becomes a bit more
-    efficient, as no traceback needs to be extracte.  It also allows the
-    caller to supply a different namespace for the interpolation to occur than
-    its own."""
-    
-    def __init__(self, format,globals,locals=None,
-                 codec='utf_8',encoding_errors='backslashreplace'):
-        """ItplNS(format,globals[,locals]) -> interpolating string instance.
-
-        This constructor, besides a format string, takes a globals dictionary
-        and optionally a locals (which defaults to globals if not provided).
-
-        For further details, see the Itpl constructor."""
-
-        if locals is None:
-            locals = globals
-        self.globals = globals
-        self.locals = locals
-        Itpl.__init__(self,format,codec,encoding_errors)
-        
-    def __str__(self):
-        """Evaluate and substitute the appropriate parts of the string."""
-        return self._str(self.globals,self.locals)
-
-    def __repr__(self):
-        return "<ItplNS %s >" % repr(self.format)
-
-# utilities for fast printing
-def itpl(text): return str(Itpl(text))
-def printpl(text): print itpl(text)
-# versions with namespace
-def itplns(text,globals,locals=None): return str(ItplNS(text,globals,locals))
-def printplns(text,globals,locals=None): print itplns(text,globals,locals)
-
-class ItplFile:
-    """A file object that filters each write() through an interpolator."""
-    def __init__(self, file): self.file = file
-    def __repr__(self): return "<interpolated " + repr(self.file) + ">"
-    def __getattr__(self, attr): return getattr(self.file, attr)
-    def write(self, text): self.file.write(str(Itpl(text)))
-
-def filter(file=sys.stdout):
-    """Return an ItplFile that filters writes to the given file object.
-    
-    'file = filter(file)' replaces 'file' with a filtered object that
-    has a write() method.  When called with no argument, this creates
-    a filter to sys.stdout."""
-    return ItplFile(file)
-
-def unfilter(ifile=None):
-    """Return the original file that corresponds to the given ItplFile.
-    
-    'file = unfilter(file)' undoes the effect of 'file = filter(file)'.
-    'sys.stdout = unfilter()' undoes the effect of 'sys.stdout = filter()'."""
-    return ifile and ifile.file or sys.stdout.file
diff --git a/IPython/external/Itpl/__init__.py b/IPython/external/Itpl/__init__.py
deleted file mode 100644
index 9d94715df00..00000000000
--- a/IPython/external/Itpl/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-try:
-    from Itpl import *
-except ImportError:
-    from _Itpl import *
diff --git a/IPython/external/__init__.py b/IPython/external/__init__.py
index 3104c194622..eedc338eb84 100644
--- a/IPython/external/__init__.py
+++ b/IPython/external/__init__.py
@@ -2,4 +2,6 @@
 This package contains all third-party modules bundled with IPython.
 """
 
-__all__ = ["simplegeneric"]
+from typing import List
+
+__all__: List[str] = []
diff --git a/IPython/external/argparse/__init__.py b/IPython/external/argparse/__init__.py
deleted file mode 100644
index 7865da3699a..00000000000
--- a/IPython/external/argparse/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-try:
-    import argparse
-    # Workaround an argparse bug, FIXED in argparse 1.1.0
-    if 'RawTextHelpFormatterArgumentDefaultsHelpFormatter' in argparse.__all__:
-        import itertools
-        argparse.__all__ = list(itertools.chain( [i for i in argparse.__all__
-            if i != 'RawTextHelpFormatterArgumentDefaultsHelpFormatter'],
-            ['RawTextHelpFormatter', 'ArgumentDefaultsHelpFormatter']))
-    argparse.__all__.append('SUPPRESS')
-    from argparse import *
-except ImportError:
-    from _argparse import *
-    from _argparse import SUPPRESS
diff --git a/IPython/external/argparse/_argparse.py b/IPython/external/argparse/_argparse.py
deleted file mode 100644
index a0601290db2..00000000000
--- a/IPython/external/argparse/_argparse.py
+++ /dev/null
@@ -1,2353 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not
-# use this file except in compliance with the License. You may obtain a copy
-# of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-
-"""Command-line parsing library
-
-This module is an optparse-inspired command-line parsing library that:
-
-    - handles both optional and positional arguments
-    - produces highly informative usage messages
-    - supports parsers that dispatch to sub-parsers
-
-The following is a simple usage example that sums integers from the
-command-line and writes the result to a file::
-
-    parser = argparse.ArgumentParser(
-        description='sum the integers at the command line')
-    parser.add_argument(
-        'integers', metavar='int', nargs='+', type=int,
-        help='an integer to be summed')
-    parser.add_argument(
-        '--log', default=sys.stdout, type=argparse.FileType('w'),
-        help='the file where the sum should be written')
-    args = parser.parse_args()
-    args.log.write('%s' % sum(args.integers))
-    args.log.close()
-
-The module contains the following public classes:
-
-    - ArgumentParser -- The main entry point for command-line parsing. As the
-        example above shows, the add_argument() method is used to populate
-        the parser with actions for optional and positional arguments. Then
-        the parse_args() method is invoked to convert the args at the
-        command-line into an object with attributes.
-
-    - ArgumentError -- The exception raised by ArgumentParser objects when
-        there are errors with the parser's actions. Errors raised while
-        parsing the command-line are caught by ArgumentParser and emitted
-        as command-line messages.
-
-    - FileType -- A factory for defining types of files to be created. As the
-        example above shows, instances of FileType are typically passed as
-        the type= argument of add_argument() calls.
-
-    - Action -- The base class for parser actions. Typically actions are
-        selected by passing strings like 'store_true' or 'append_const' to
-        the action= argument of add_argument(). However, for greater
-        customization of ArgumentParser actions, subclasses of Action may
-        be defined and passed as the action= argument.
-
-    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
-        ArgumentDefaultsHelpFormatter -- Formatter classes which
-        may be passed as the formatter_class= argument to the
-        ArgumentParser constructor. HelpFormatter is the default,
-        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
-        not to change the formatting for help text, and
-        ArgumentDefaultsHelpFormatter adds information about argument defaults
-        to the help.
-
-All other classes in this module are considered implementation details.
-(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
-considered public as object names -- the API of the formatter objects is
-still considered an implementation detail.)
-"""
-
-__version__ = '1.1'
-__all__ = [
-    'ArgumentParser',
-    'ArgumentError',
-    'Namespace',
-    'Action',
-    'FileType',
-    'HelpFormatter',
-    'RawDescriptionHelpFormatter',
-    'RawTextHelpFormatter',
-    'ArgumentDefaultsHelpFormatter',
-]
-
-
-import copy as _copy
-import os as _os
-import re as _re
-import sys as _sys
-import textwrap as _textwrap
-
-from gettext import gettext as _
-
-try:
-    _set = set
-except NameError:
-    from sets import Set as _set
-
-try:
-    _basestring = basestring
-except NameError:
-    _basestring = str
-
-try:
-    _sorted = sorted
-except NameError:
-
-    def _sorted(iterable, reverse=False):
-        result = list(iterable)
-        result.sort()
-        if reverse:
-            result.reverse()
-        return result
-
-
-def _callable(obj):
-    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
-
-# silence Python 2.6 buggy warnings about Exception.message
-if _sys.version_info[:2] == (2, 6):
-    import warnings
-    warnings.filterwarnings(
-        action='ignore',
-        message='BaseException.message has been deprecated as of Python 2.6',
-        category=DeprecationWarning,
-        module='argparse')
-
-
-SUPPRESS = '==SUPPRESS=='
-
-OPTIONAL = '?'
-ZERO_OR_MORE = '*'
-ONE_OR_MORE = '+'
-PARSER = 'A...'
-REMAINDER = '...'
-
-# =============================
-# Utility functions and classes
-# =============================
-
-class _AttributeHolder(object):
-    """Abstract base class that provides __repr__.
-
-    The __repr__ method returns a string in the format::
-        ClassName(attr=name, attr=name, ...)
-    The attributes are determined either by a class-level attribute,
-    '_kwarg_names', or by inspecting the instance __dict__.
-    """
-
-    def __repr__(self):
-        type_name = type(self).__name__
-        arg_strings = []
-        for arg in self._get_args():
-            arg_strings.append(repr(arg))
-        for name, value in self._get_kwargs():
-            arg_strings.append('%s=%r' % (name, value))
-        return '%s(%s)' % (type_name, ', '.join(arg_strings))
-
-    def _get_kwargs(self):
-        return _sorted(self.__dict__.items())
-
-    def _get_args(self):
-        return []
-
-
-def _ensure_value(namespace, name, value):
-    if getattr(namespace, name, None) is None:
-        setattr(namespace, name, value)
-    return getattr(namespace, name)
-
-
-# ===============
-# Formatting Help
-# ===============
-
-class HelpFormatter(object):
-    """Formatter for generating usage messages and argument help strings.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def __init__(self,
-                 prog,
-                 indent_increment=2,
-                 max_help_position=24,
-                 width=None):
-
-        # default setting for width
-        if width is None:
-            try:
-                width = int(_os.environ['COLUMNS'])
-            except (KeyError, ValueError):
-                width = 80
-            width -= 2
-
-        self._prog = prog
-        self._indent_increment = indent_increment
-        self._max_help_position = max_help_position
-        self._width = width
-
-        self._current_indent = 0
-        self._level = 0
-        self._action_max_length = 0
-
-        self._root_section = self._Section(self, None)
-        self._current_section = self._root_section
-
-        self._whitespace_matcher = _re.compile(r'\s+')
-        self._long_break_matcher = _re.compile(r'\n\n\n+')
-
-    # ===============================
-    # Section and indentation methods
-    # ===============================
-    def _indent(self):
-        self._current_indent += self._indent_increment
-        self._level += 1
-
-    def _dedent(self):
-        self._current_indent -= self._indent_increment
-        assert self._current_indent >= 0, 'Indent decreased below 0.'
-        self._level -= 1
-
-    class _Section(object):
-
-        def __init__(self, formatter, parent, heading=None):
-            self.formatter = formatter
-            self.parent = parent
-            self.heading = heading
-            self.items = []
-
-        def format_help(self):
-            # format the indented section
-            if self.parent is not None:
-                self.formatter._indent()
-            join = self.formatter._join_parts
-            for func, args in self.items:
-                func(*args)
-            item_help = join([func(*args) for func, args in self.items])
-            if self.parent is not None:
-                self.formatter._dedent()
-
-            # return nothing if the section was empty
-            if not item_help:
-                return ''
-
-            # add the heading if the section was non-empty
-            if self.heading is not SUPPRESS and self.heading is not None:
-                current_indent = self.formatter._current_indent
-                heading = '%*s%s:\n' % (current_indent, '', self.heading)
-            else:
-                heading = ''
-
-            # join the section-initial newline, the heading and the help
-            return join(['\n', heading, item_help, '\n'])
-
-    def _add_item(self, func, args):
-        self._current_section.items.append((func, args))
-
-    # ========================
-    # Message building methods
-    # ========================
-    def start_section(self, heading):
-        self._indent()
-        section = self._Section(self, self._current_section, heading)
-        self._add_item(section.format_help, [])
-        self._current_section = section
-
-    def end_section(self):
-        self._current_section = self._current_section.parent
-        self._dedent()
-
-    def add_text(self, text):
-        if text is not SUPPRESS and text is not None:
-            self._add_item(self._format_text, [text])
-
-    def add_usage(self, usage, actions, groups, prefix=None):
-        if usage is not SUPPRESS:
-            args = usage, actions, groups, prefix
-            self._add_item(self._format_usage, args)
-
-    def add_argument(self, action):
-        if action.help is not SUPPRESS:
-
-            # find all invocations
-            get_invocation = self._format_action_invocation
-            invocations = [get_invocation(action)]
-            for subaction in self._iter_indented_subactions(action):
-                invocations.append(get_invocation(subaction))
-
-            # update the maximum item length
-            invocation_length = max([len(s) for s in invocations])
-            action_length = invocation_length + self._current_indent
-            self._action_max_length = max(self._action_max_length,
-                                          action_length)
-
-            # add the item to the list
-            self._add_item(self._format_action, [action])
-
-    def add_arguments(self, actions):
-        for action in actions:
-            self.add_argument(action)
-
-    # =======================
-    # Help-formatting methods
-    # =======================
-    def format_help(self):
-        help = self._root_section.format_help()
-        if help:
-            help = self._long_break_matcher.sub('\n\n', help)
-            help = help.strip('\n') + '\n'
-        return help
-
-    def _join_parts(self, part_strings):
-        return ''.join([part
-                        for part in part_strings
-                        if part and part is not SUPPRESS])
-
-    def _format_usage(self, usage, actions, groups, prefix):
-        if prefix is None:
-            prefix = _('usage: ')
-
-        # if usage is specified, use that
-        if usage is not None:
-            usage = usage % dict(prog=self._prog)
-
-        # if no optionals or positionals are available, usage is just prog
-        elif usage is None and not actions:
-            usage = '%(prog)s' % dict(prog=self._prog)
-
-        # if optionals and positionals are available, calculate usage
-        elif usage is None:
-            prog = '%(prog)s' % dict(prog=self._prog)
-
-            # split optionals from positionals
-            optionals = []
-            positionals = []
-            for action in actions:
-                if action.option_strings:
-                    optionals.append(action)
-                else:
-                    positionals.append(action)
-
-            # build full usage string
-            format = self._format_actions_usage
-            action_usage = format(optionals + positionals, groups)
-            usage = ' '.join([s for s in [prog, action_usage] if s])
-
-            # wrap the usage parts if it's too long
-            text_width = self._width - self._current_indent
-            if len(prefix) + len(usage) > text_width:
-
-                # break usage into wrappable parts
-                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
-                opt_usage = format(optionals, groups)
-                pos_usage = format(positionals, groups)
-                opt_parts = _re.findall(part_regexp, opt_usage)
-                pos_parts = _re.findall(part_regexp, pos_usage)
-                assert ' '.join(opt_parts) == opt_usage
-                assert ' '.join(pos_parts) == pos_usage
-
-                # helper for wrapping lines
-                def get_lines(parts, indent, prefix=None):
-                    lines = []
-                    line = []
-                    if prefix is not None:
-                        line_len = len(prefix) - 1
-                    else:
-                        line_len = len(indent) - 1
-                    for part in parts:
-                        if line_len + 1 + len(part) > text_width:
-                            lines.append(indent + ' '.join(line))
-                            line = []
-                            line_len = len(indent) - 1
-                        line.append(part)
-                        line_len += len(part) + 1
-                    if line:
-                        lines.append(indent + ' '.join(line))
-                    if prefix is not None:
-                        lines[0] = lines[0][len(indent):]
-                    return lines
-
-                # if prog is short, follow it with optionals or positionals
-                if len(prefix) + len(prog) <= 0.75 * text_width:
-                    indent = ' ' * (len(prefix) + len(prog) + 1)
-                    if opt_parts:
-                        lines = get_lines([prog] + opt_parts, indent, prefix)
-                        lines.extend(get_lines(pos_parts, indent))
-                    elif pos_parts:
-                        lines = get_lines([prog] + pos_parts, indent, prefix)
-                    else:
-                        lines = [prog]
-
-                # if prog is long, put it on its own line
-                else:
-                    indent = ' ' * len(prefix)
-                    parts = opt_parts + pos_parts
-                    lines = get_lines(parts, indent)
-                    if len(lines) > 1:
-                        lines = []
-                        lines.extend(get_lines(opt_parts, indent))
-                        lines.extend(get_lines(pos_parts, indent))
-                    lines = [prog] + lines
-
-                # join lines into usage
-                usage = '\n'.join(lines)
-
-        # prefix with 'usage:'
-        return '%s%s\n\n' % (prefix, usage)
-
-    def _format_actions_usage(self, actions, groups):
-        # find group indices and identify actions in groups
-        group_actions = _set()
-        inserts = {}
-        for group in groups:
-            try:
-                start = actions.index(group._group_actions[0])
-            except ValueError:
-                continue
-            else:
-                end = start + len(group._group_actions)
-                if actions[start:end] == group._group_actions:
-                    for action in group._group_actions:
-                        group_actions.add(action)
-                    if not group.required:
-                        inserts[start] = '['
-                        inserts[end] = ']'
-                    else:
-                        inserts[start] = '('
-                        inserts[end] = ')'
-                    for i in range(start + 1, end):
-                        inserts[i] = '|'
-
-        # collect all actions format strings
-        parts = []
-        for i, action in enumerate(actions):
-
-            # suppressed arguments are marked with None
-            # remove | separators for suppressed arguments
-            if action.help is SUPPRESS:
-                parts.append(None)
-                if inserts.get(i) == '|':
-                    inserts.pop(i)
-                elif inserts.get(i + 1) == '|':
-                    inserts.pop(i + 1)
-
-            # produce all arg strings
-            elif not action.option_strings:
-                part = self._format_args(action, action.dest)
-
-                # if it's in a group, strip the outer []
-                if action in group_actions:
-                    if part[0] == '[' and part[-1] == ']':
-                        part = part[1:-1]
-
-                # add the action string to the list
-                parts.append(part)
-
-            # produce the first way to invoke the option in brackets
-            else:
-                option_string = action.option_strings[0]
-
-                # if the Optional doesn't take a value, format is:
-                #    -s or --long
-                if action.nargs == 0:
-                    part = '%s' % option_string
-
-                # if the Optional takes a value, format is:
-                #    -s ARGS or --long ARGS
-                else:
-                    default = action.dest.upper()
-                    args_string = self._format_args(action, default)
-                    part = '%s %s' % (option_string, args_string)
-
-                # make it look optional if it's not required or in a group
-                if not action.required and action not in group_actions:
-                    part = '[%s]' % part
-
-                # add the action string to the list
-                parts.append(part)
-
-        # insert things at the necessary indices
-        for i in _sorted(inserts, reverse=True):
-            parts[i:i] = [inserts[i]]
-
-        # join all the action items with spaces
-        text = ' '.join([item for item in parts if item is not None])
-
-        # clean up separators for mutually exclusive groups
-        open = r'[\[(]'
-        close = r'[\])]'
-        text = _re.sub(r'(%s) ' % open, r'\1', text)
-        text = _re.sub(r' (%s)' % close, r'\1', text)
-        text = _re.sub(r'%s *%s' % (open, close), r'', text)
-        text = _re.sub(r'\(([^|]*)\)', r'\1', text)
-        text = text.strip()
-
-        # return the text
-        return text
-
-    def _format_text(self, text):
-        if '%(prog)' in text:
-            text = text % dict(prog=self._prog)
-        text_width = self._width - self._current_indent
-        indent = ' ' * self._current_indent
-        return self._fill_text(text, text_width, indent) + '\n\n'
-
-    def _format_action(self, action):
-        # determine the required width and the entry label
-        help_position = min(self._action_max_length + 2,
-                            self._max_help_position)
-        help_width = self._width - help_position
-        action_width = help_position - self._current_indent - 2
-        action_header = self._format_action_invocation(action)
-
-        # ho nelp; start on same line and add a final newline
-        if not action.help:
-            tup = self._current_indent, '', action_header
-            action_header = '%*s%s\n' % tup
-
-        # short action name; start on the same line and pad two spaces
-        elif len(action_header) <= action_width:
-            tup = self._current_indent, '', action_width, action_header
-            action_header = '%*s%-*s  ' % tup
-            indent_first = 0
-
-        # long action name; start on the next line
-        else:
-            tup = self._current_indent, '', action_header
-            action_header = '%*s%s\n' % tup
-            indent_first = help_position
-
-        # collect the pieces of the action help
-        parts = [action_header]
-
-        # if there was help for the action, add lines of help text
-        if action.help:
-            help_text = self._expand_help(action)
-            help_lines = self._split_lines(help_text, help_width)
-            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
-            for line in help_lines[1:]:
-                parts.append('%*s%s\n' % (help_position, '', line))
-
-        # or add a newline if the description doesn't end with one
-        elif not action_header.endswith('\n'):
-            parts.append('\n')
-
-        # if there are any sub-actions, add their help as well
-        for subaction in self._iter_indented_subactions(action):
-            parts.append(self._format_action(subaction))
-
-        # return a single string
-        return self._join_parts(parts)
-
-    def _format_action_invocation(self, action):
-        if not action.option_strings:
-            metavar, = self._metavar_formatter(action, action.dest)(1)
-            return metavar
-
-        else:
-            parts = []
-
-            # if the Optional doesn't take a value, format is:
-            #    -s, --long
-            if action.nargs == 0:
-                parts.extend(action.option_strings)
-
-            # if the Optional takes a value, format is:
-            #    -s ARGS, --long ARGS
-            else:
-                default = action.dest.upper()
-                args_string = self._format_args(action, default)
-                for option_string in action.option_strings:
-                    parts.append('%s %s' % (option_string, args_string))
-
-            return ', '.join(parts)
-
-    def _metavar_formatter(self, action, default_metavar):
-        if action.metavar is not None:
-            result = action.metavar
-        elif action.choices is not None:
-            choice_strs = [str(choice) for choice in action.choices]
-            result = '{%s}' % ','.join(choice_strs)
-        else:
-            result = default_metavar
-
-        def format(tuple_size):
-            if isinstance(result, tuple):
-                return result
-            else:
-                return (result, ) * tuple_size
-        return format
-
-    def _format_args(self, action, default_metavar):
-        get_metavar = self._metavar_formatter(action, default_metavar)
-        if action.nargs is None:
-            result = '%s' % get_metavar(1)
-        elif action.nargs == OPTIONAL:
-            result = '[%s]' % get_metavar(1)
-        elif action.nargs == ZERO_OR_MORE:
-            result = '[%s [%s ...]]' % get_metavar(2)
-        elif action.nargs == ONE_OR_MORE:
-            result = '%s [%s ...]' % get_metavar(2)
-        elif action.nargs == REMAINDER:
-            result = '...'
-        elif action.nargs == PARSER:
-            result = '%s ...' % get_metavar(1)
-        else:
-            formats = ['%s' for _ in range(action.nargs)]
-            result = ' '.join(formats) % get_metavar(action.nargs)
-        return result
-
-    def _expand_help(self, action):
-        params = dict(vars(action), prog=self._prog)
-        for name in list(params):
-            if params[name] is SUPPRESS:
-                del params[name]
-        for name in list(params):
-            if hasattr(params[name], '__name__'):
-                params[name] = params[name].__name__
-        if params.get('choices') is not None:
-            choices_str = ', '.join([str(c) for c in params['choices']])
-            params['choices'] = choices_str
-        return self._get_help_string(action) % params
-
-    def _iter_indented_subactions(self, action):
-        try:
-            get_subactions = action._get_subactions
-        except AttributeError:
-            pass
-        else:
-            self._indent()
-            for subaction in get_subactions():
-                yield subaction
-            self._dedent()
-
-    def _split_lines(self, text, width):
-        text = self._whitespace_matcher.sub(' ', text).strip()
-        return _textwrap.wrap(text, width)
-
-    def _fill_text(self, text, width, indent):
-        text = self._whitespace_matcher.sub(' ', text).strip()
-        return _textwrap.fill(text, width, initial_indent=indent,
-                                           subsequent_indent=indent)
-
-    def _get_help_string(self, action):
-        return action.help
-
-
-class RawDescriptionHelpFormatter(HelpFormatter):
-    """Help message formatter which retains any formatting in descriptions.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _fill_text(self, text, width, indent):
-        return ''.join([indent + line for line in text.splitlines(True)])
-
-
-class RawTextHelpFormatter(RawDescriptionHelpFormatter):
-    """Help message formatter which retains formatting of all help text.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _split_lines(self, text, width):
-        return text.splitlines()
-
-
-class ArgumentDefaultsHelpFormatter(HelpFormatter):
-    """Help message formatter which adds default values to argument help.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _get_help_string(self, action):
-        help = action.help
-        if '%(default)' not in action.help:
-            if action.default is not SUPPRESS:
-                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
-                if action.option_strings or action.nargs in defaulting_nargs:
-                    help += ' (default: %(default)s)'
-        return help
-
-
-# =====================
-# Options and Arguments
-# =====================
-
-def _get_action_name(argument):
-    if argument is None:
-        return None
-    elif argument.option_strings:
-        return  '/'.join(argument.option_strings)
-    elif argument.metavar not in (None, SUPPRESS):
-        return argument.metavar
-    elif argument.dest not in (None, SUPPRESS):
-        return argument.dest
-    else:
-        return None
-
-
-class ArgumentError(Exception):
-    """An error from creating or using an argument (optional or positional).
-
-    The string value of this exception is the message, augmented with
-    information about the argument that caused it.
-    """
-
-    def __init__(self, argument, message):
-        self.argument_name = _get_action_name(argument)
-        self.message = message
-
-    def __str__(self):
-        if self.argument_name is None:
-            format = '%(message)s'
-        else:
-            format = 'argument %(argument_name)s: %(message)s'
-        return format % dict(message=self.message,
-                             argument_name=self.argument_name)
-
-
-class ArgumentTypeError(Exception):
-    """An error from trying to convert a command line string to a type."""
-    pass
-
-
-# ==============
-# Action classes
-# ==============
-
-class Action(_AttributeHolder):
-    """Information about how to convert command line strings to Python objects.
-
-    Action objects are used by an ArgumentParser to represent the information
-    needed to parse a single argument from one or more strings from the
-    command line. The keyword arguments to the Action constructor are also
-    all attributes of Action instances.
-
-    Keyword Arguments:
-
-        - option_strings -- A list of command-line option strings which
-            should be associated with this action.
-
-        - dest -- The name of the attribute to hold the created object(s)
-
-        - nargs -- The number of command-line arguments that should be
-            consumed. By default, one argument will be consumed and a single
-            value will be produced.  Other values include:
-                - N (an integer) consumes N arguments (and produces a list)
-                - '?' consumes zero or one arguments
-                - '*' consumes zero or more arguments (and produces a list)
-                - '+' consumes one or more arguments (and produces a list)
-            Note that the difference between the default and nargs=1 is that
-            with the default, a single value will be produced, while with
-            nargs=1, a list containing a single value will be produced.
-
-        - const -- The value to be produced if the option is specified and the
-            option uses an action that takes no values.
-
-        - default -- The value to be produced if the option is not specified.
-
-        - type -- The type which the command-line arguments should be converted
-            to, should be one of 'string', 'int', 'float', 'complex' or a
-            callable object that accepts a single string argument. If None,
-            'string' is assumed.
-
-        - choices -- A container of values that should be allowed. If not None,
-            after a command-line argument has been converted to the appropriate
-            type, an exception will be raised if it is not a member of this
-            collection.
-
-        - required -- True if the action must always be specified at the
-            command line. This is only meaningful for optional command-line
-            arguments.
-
-        - help -- The help string describing the argument.
-
-        - metavar -- The name to be used for the option's argument with the
-            help string. If None, the 'dest' value will be used as the name.
-    """
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        self.option_strings = option_strings
-        self.dest = dest
-        self.nargs = nargs
-        self.const = const
-        self.default = default
-        self.type = type
-        self.choices = choices
-        self.required = required
-        self.help = help
-        self.metavar = metavar
-
-    def _get_kwargs(self):
-        names = [
-            'option_strings',
-            'dest',
-            'nargs',
-            'const',
-            'default',
-            'type',
-            'choices',
-            'help',
-            'metavar',
-        ]
-        return [(name, getattr(self, name)) for name in names]
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        raise NotImplementedError(_('.__call__() not defined'))
-
-
-class _StoreAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        if nargs == 0:
-            raise ValueError('nargs for store actions must be > 0; if you '
-                             'have nothing to store, actions such as store '
-                             'true or store const may be more appropriate')
-        if const is not None and nargs != OPTIONAL:
-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
-        super(_StoreAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=nargs,
-            const=const,
-            default=default,
-            type=type,
-            choices=choices,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        setattr(namespace, self.dest, values)
-
-
-class _StoreConstAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 const,
-                 default=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        super(_StoreConstAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            const=const,
-            default=default,
-            required=required,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        setattr(namespace, self.dest, self.const)
-
-
-class _StoreTrueAction(_StoreConstAction):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=False,
-                 required=False,
-                 help=None):
-        super(_StoreTrueAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            const=True,
-            default=default,
-            required=required,
-            help=help)
-
-
-class _StoreFalseAction(_StoreConstAction):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=True,
-                 required=False,
-                 help=None):
-        super(_StoreFalseAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            const=False,
-            default=default,
-            required=required,
-            help=help)
-
-
-class _AppendAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        if nargs == 0:
-            raise ValueError('nargs for append actions must be > 0; if arg '
-                             'strings are not supplying the value to append, '
-                             'the append const action may be more appropriate')
-        if const is not None and nargs != OPTIONAL:
-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
-        super(_AppendAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=nargs,
-            const=const,
-            default=default,
-            type=type,
-            choices=choices,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        items = _copy.copy(_ensure_value(namespace, self.dest, []))
-        items.append(values)
-        setattr(namespace, self.dest, items)
-
-
-class _AppendConstAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 const,
-                 default=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        super(_AppendConstAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            const=const,
-            default=default,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        items = _copy.copy(_ensure_value(namespace, self.dest, []))
-        items.append(self.const)
-        setattr(namespace, self.dest, items)
-
-
-class _CountAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=None,
-                 required=False,
-                 help=None):
-        super(_CountAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            default=default,
-            required=required,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        new_count = _ensure_value(namespace, self.dest, 0) + 1
-        setattr(namespace, self.dest, new_count)
-
-
-class _HelpAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest=SUPPRESS,
-                 default=SUPPRESS,
-                 help=None):
-        super(_HelpAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            default=default,
-            nargs=0,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        parser.print_help()
-        parser.exit()
-
-
-class _VersionAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 version=None,
-                 dest=SUPPRESS,
-                 default=SUPPRESS,
-                 help=None):
-        super(_VersionAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            default=default,
-            nargs=0,
-            help=help)
-        self.version = version
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        version = self.version
-        if version is None:
-            version = parser.version
-        formatter = parser._get_formatter()
-        formatter.add_text(version)
-        parser.exit(message=formatter.format_help())
-
-
-class _SubParsersAction(Action):
-
-    class _ChoicesPseudoAction(Action):
-
-        def __init__(self, name, help):
-            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
-            sup.__init__(option_strings=[], dest=name, help=help)
-
-    def __init__(self,
-                 option_strings,
-                 prog,
-                 parser_class,
-                 dest=SUPPRESS,
-                 help=None,
-                 metavar=None):
-
-        self._prog_prefix = prog
-        self._parser_class = parser_class
-        self._name_parser_map = {}
-        self._choices_actions = []
-
-        super(_SubParsersAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=PARSER,
-            choices=self._name_parser_map,
-            help=help,
-            metavar=metavar)
-
-    def add_parser(self, name, **kwargs):
-        # set prog from the existing prefix
-        if kwargs.get('prog') is None:
-            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
-
-        # create a pseudo-action to hold the choice help
-        if 'help' in kwargs:
-            help = kwargs.pop('help')
-            choice_action = self._ChoicesPseudoAction(name, help)
-            self._choices_actions.append(choice_action)
-
-        # create the parser and add it to the map
-        parser = self._parser_class(**kwargs)
-        self._name_parser_map[name] = parser
-        return parser
-
-    def _get_subactions(self):
-        return self._choices_actions
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        parser_name = values[0]
-        arg_strings = values[1:]
-
-        # set the parser name if requested
-        if self.dest is not SUPPRESS:
-            setattr(namespace, self.dest, parser_name)
-
-        # select the parser
-        try:
-            parser = self._name_parser_map[parser_name]
-        except KeyError:
-            tup = parser_name, ', '.join(self._name_parser_map)
-            msg = _('unknown parser %r (choices: %s)' % tup)
-            raise ArgumentError(self, msg)
-
-        # parse all the remaining options into the namespace
-        parser.parse_args(arg_strings, namespace)
-
-
-# ==============
-# Type classes
-# ==============
-
-class FileType(object):
-    """Factory for creating file object types
-
-    Instances of FileType are typically passed as type= arguments to the
-    ArgumentParser add_argument() method.
-
-    Keyword Arguments:
-        - mode -- A string indicating how the file is to be opened. Accepts the
-            same values as the builtin open() function.
-        - bufsize -- The file's desired buffer size. Accepts the same values as
-            the builtin open() function.
-    """
-
-    def __init__(self, mode='r', bufsize=None):
-        self._mode = mode
-        self._bufsize = bufsize
-
-    def __call__(self, string):
-        # the special argument "-" means sys.std{in,out}
-        if string == '-':
-            if 'r' in self._mode:
-                return _sys.stdin
-            elif 'w' in self._mode:
-                return _sys.stdout
-            else:
-                msg = _('argument "-" with mode %r' % self._mode)
-                raise ValueError(msg)
-
-        # all other arguments are used as file names
-        if self._bufsize:
-            return open(string, self._mode, self._bufsize)
-        else:
-            return open(string, self._mode)
-
-    def __repr__(self):
-        args = [self._mode, self._bufsize]
-        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
-        return '%s(%s)' % (type(self).__name__, args_str)
-
-# ===========================
-# Optional and Positional Parsing
-# ===========================
-
-class Namespace(_AttributeHolder):
-    """Simple object for storing attributes.
-
-    Implements equality by attribute names and values, and provides a simple
-    string representation.
-    """
-
-    def __init__(self, **kwargs):
-        for name in kwargs:
-            setattr(self, name, kwargs[name])
-
-    def __eq__(self, other):
-        return vars(self) == vars(other)
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __contains__(self, key):
-        return key in self.__dict__
-
-
-class _ActionsContainer(object):
-
-    def __init__(self,
-                 description,
-                 prefix_chars,
-                 argument_default,
-                 conflict_handler):
-        super(_ActionsContainer, self).__init__()
-
-        self.description = description
-        self.argument_default = argument_default
-        self.prefix_chars = prefix_chars
-        self.conflict_handler = conflict_handler
-
-        # set up registries
-        self._registries = {}
-
-        # register actions
-        self.register('action', None, _StoreAction)
-        self.register('action', 'store', _StoreAction)
-        self.register('action', 'store_const', _StoreConstAction)
-        self.register('action', 'store_true', _StoreTrueAction)
-        self.register('action', 'store_false', _StoreFalseAction)
-        self.register('action', 'append', _AppendAction)
-        self.register('action', 'append_const', _AppendConstAction)
-        self.register('action', 'count', _CountAction)
-        self.register('action', 'help', _HelpAction)
-        self.register('action', 'version', _VersionAction)
-        self.register('action', 'parsers', _SubParsersAction)
-
-        # raise an exception if the conflict handler is invalid
-        self._get_handler()
-
-        # action storage
-        self._actions = []
-        self._option_string_actions = {}
-
-        # groups
-        self._action_groups = []
-        self._mutually_exclusive_groups = []
-
-        # defaults storage
-        self._defaults = {}
-
-        # determines whether an "option" looks like a negative number
-        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
-
-        # whether or not there are any optionals that look like negative
-        # numbers -- uses a list so it can be shared and edited
-        self._has_negative_number_optionals = []
-
-    # ====================
-    # Registration methods
-    # ====================
-    def register(self, registry_name, value, object):
-        registry = self._registries.setdefault(registry_name, {})
-        registry[value] = object
-
-    def _registry_get(self, registry_name, value, default=None):
-        return self._registries[registry_name].get(value, default)
-
-    # ==================================
-    # Namespace default accessor methods
-    # ==================================
-    def set_defaults(self, **kwargs):
-        self._defaults.update(kwargs)
-
-        # if these defaults match any existing arguments, replace
-        # the previous default on the object with the new one
-        for action in self._actions:
-            if action.dest in kwargs:
-                action.default = kwargs[action.dest]
-
-    def get_default(self, dest):
-        for action in self._actions:
-            if action.dest == dest and action.default is not None:
-                return action.default
-        return self._defaults.get(dest, None)
-
-
-    # =======================
-    # Adding argument actions
-    # =======================
-    def add_argument(self, *args, **kwargs):
-        """
-        add_argument(dest, ..., name=value, ...)
-        add_argument(option_string, option_string, ..., name=value, ...)
-        """
-
-        # if no positional args are supplied or only one is supplied and
-        # it doesn't look like an option string, parse a positional
-        # argument
-        chars = self.prefix_chars
-        if not args or len(args) == 1 and args[0][0] not in chars:
-            if args and 'dest' in kwargs:
-                raise ValueError('dest supplied twice for positional argument')
-            kwargs = self._get_positional_kwargs(*args, **kwargs)
-
-        # otherwise, we're adding an optional argument
-        else:
-            kwargs = self._get_optional_kwargs(*args, **kwargs)
-
-        # if no default was supplied, use the parser-level default
-        if 'default' not in kwargs:
-            dest = kwargs['dest']
-            if dest in self._defaults:
-                kwargs['default'] = self._defaults[dest]
-            elif self.argument_default is not None:
-                kwargs['default'] = self.argument_default
-
-        # create the action object, and add it to the parser
-        action_class = self._pop_action_class(kwargs)
-        if not _callable(action_class):
-            raise ValueError('unknown action "%s"' % action_class)
-        action = action_class(**kwargs)
-
-        # raise an error if the action type is not callable
-        type_func = self._registry_get('type', action.type, action.type)
-        if not _callable(type_func):
-            raise ValueError('%r is not callable' % type_func)
-
-        return self._add_action(action)
-
-    def add_argument_group(self, *args, **kwargs):
-        group = _ArgumentGroup(self, *args, **kwargs)
-        self._action_groups.append(group)
-        return group
-
-    def add_mutually_exclusive_group(self, **kwargs):
-        group = _MutuallyExclusiveGroup(self, **kwargs)
-        self._mutually_exclusive_groups.append(group)
-        return group
-
-    def _add_action(self, action):
-        # resolve any conflicts
-        self._check_conflict(action)
-
-        # add to actions list
-        self._actions.append(action)
-        action.container = self
-
-        # index the action by any option strings it has
-        for option_string in action.option_strings:
-            self._option_string_actions[option_string] = action
-
-        # set the flag if any option strings look like negative numbers
-        for option_string in action.option_strings:
-            if self._negative_number_matcher.match(option_string):
-                if not self._has_negative_number_optionals:
-                    self._has_negative_number_optionals.append(True)
-
-        # return the created action
-        return action
-
-    def _remove_action(self, action):
-        self._actions.remove(action)
-
-    def _add_container_actions(self, container):
-        # collect groups by titles
-        title_group_map = {}
-        for group in self._action_groups:
-            if group.title in title_group_map:
-                msg = _('cannot merge actions - two groups are named %r')
-                raise ValueError(msg % (group.title))
-            title_group_map[group.title] = group
-
-        # map each action to its group
-        group_map = {}
-        for group in container._action_groups:
-
-            # if a group with the title exists, use that, otherwise
-            # create a new group matching the container's group
-            if group.title not in title_group_map:
-                title_group_map[group.title] = self.add_argument_group(
-                    title=group.title,
-                    description=group.description,
-                    conflict_handler=group.conflict_handler)
-
-            # map the actions to their new group
-            for action in group._group_actions:
-                group_map[action] = title_group_map[group.title]
-
-        # add container's mutually exclusive groups
-        # NOTE: if add_mutually_exclusive_group ever gains title= and
-        # description= then this code will need to be expanded as above
-        for group in container._mutually_exclusive_groups:
-            mutex_group = self.add_mutually_exclusive_group(
-                required=group.required)
-
-            # map the actions to their new mutex group
-            for action in group._group_actions:
-                group_map[action] = mutex_group
-
-        # add all actions to this container or their group
-        for action in container._actions:
-            group_map.get(action, self)._add_action(action)
-
-    def _get_positional_kwargs(self, dest, **kwargs):
-        # make sure required is not specified
-        if 'required' in kwargs:
-            msg = _("'required' is an invalid argument for positionals")
-            raise TypeError(msg)
-
-        # mark positional arguments as required if at least one is
-        # always required
-        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
-            kwargs['required'] = True
-        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
-            kwargs['required'] = True
-
-        # return the keyword arguments with no option strings
-        return dict(kwargs, dest=dest, option_strings=[])
-
-    def _get_optional_kwargs(self, *args, **kwargs):
-        # determine short and long option strings
-        option_strings = []
-        long_option_strings = []
-        for option_string in args:
-            # error on strings that don't start with an appropriate prefix
-            if not option_string[0] in self.prefix_chars:
-                msg = _('invalid option string %r: '
-                        'must start with a character %r')
-                tup = option_string, self.prefix_chars
-                raise ValueError(msg % tup)
-
-            # strings starting with two prefix characters are long options
-            option_strings.append(option_string)
-            if option_string[0] in self.prefix_chars:
-                if len(option_string) > 1:
-                    if option_string[1] in self.prefix_chars:
-                        long_option_strings.append(option_string)
-
-        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
-        dest = kwargs.pop('dest', None)
-        if dest is None:
-            if long_option_strings:
-                dest_option_string = long_option_strings[0]
-            else:
-                dest_option_string = option_strings[0]
-            dest = dest_option_string.lstrip(self.prefix_chars)
-            if not dest:
-                msg = _('dest= is required for options like %r')
-                raise ValueError(msg % option_string)
-            dest = dest.replace('-', '_')
-
-        # return the updated keyword arguments
-        return dict(kwargs, dest=dest, option_strings=option_strings)
-
-    def _pop_action_class(self, kwargs, default=None):
-        action = kwargs.pop('action', default)
-        return self._registry_get('action', action, action)
-
-    def _get_handler(self):
-        # determine function from conflict handler string
-        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
-        try:
-            return getattr(self, handler_func_name)
-        except AttributeError:
-            msg = _('invalid conflict_resolution value: %r')
-            raise ValueError(msg % self.conflict_handler)
-
-    def _check_conflict(self, action):
-
-        # find all options that conflict with this option
-        confl_optionals = []
-        for option_string in action.option_strings:
-            if option_string in self._option_string_actions:
-                confl_optional = self._option_string_actions[option_string]
-                confl_optionals.append((option_string, confl_optional))
-
-        # resolve any conflicts
-        if confl_optionals:
-            conflict_handler = self._get_handler()
-            conflict_handler(action, confl_optionals)
-
-    def _handle_conflict_error(self, action, conflicting_actions):
-        message = _('conflicting option string(s): %s')
-        conflict_string = ', '.join([option_string
-                                     for option_string, action
-                                     in conflicting_actions])
-        raise ArgumentError(action, message % conflict_string)
-
-    def _handle_conflict_resolve(self, action, conflicting_actions):
-
-        # remove all conflicting options
-        for option_string, action in conflicting_actions:
-
-            # remove the conflicting option
-            action.option_strings.remove(option_string)
-            self._option_string_actions.pop(option_string, None)
-
-            # if the option now has no option string, remove it from the
-            # container holding it
-            if not action.option_strings:
-                action.container._remove_action(action)
-
-
-class _ArgumentGroup(_ActionsContainer):
-
-    def __init__(self, container, title=None, description=None, **kwargs):
-        # add any missing keyword arguments by checking the container
-        update = kwargs.setdefault
-        update('conflict_handler', container.conflict_handler)
-        update('prefix_chars', container.prefix_chars)
-        update('argument_default', container.argument_default)
-        super_init = super(_ArgumentGroup, self).__init__
-        super_init(description=description, **kwargs)
-
-        # group attributes
-        self.title = title
-        self._group_actions = []
-
-        # share most attributes with the container
-        self._registries = container._registries
-        self._actions = container._actions
-        self._option_string_actions = container._option_string_actions
-        self._defaults = container._defaults
-        self._has_negative_number_optionals = \
-            container._has_negative_number_optionals
-
-    def _add_action(self, action):
-        action = super(_ArgumentGroup, self)._add_action(action)
-        self._group_actions.append(action)
-        return action
-
-    def _remove_action(self, action):
-        super(_ArgumentGroup, self)._remove_action(action)
-        self._group_actions.remove(action)
-
-
-class _MutuallyExclusiveGroup(_ArgumentGroup):
-
-    def __init__(self, container, required=False):
-        super(_MutuallyExclusiveGroup, self).__init__(container)
-        self.required = required
-        self._container = container
-
-    def _add_action(self, action):
-        if action.required:
-            msg = _('mutually exclusive arguments must be optional')
-            raise ValueError(msg)
-        action = self._container._add_action(action)
-        self._group_actions.append(action)
-        return action
-
-    def _remove_action(self, action):
-        self._container._remove_action(action)
-        self._group_actions.remove(action)
-
-
-class ArgumentParser(_AttributeHolder, _ActionsContainer):
-    """Object for parsing command line strings into Python objects.
-
-    Keyword Arguments:
-        - prog -- The name of the program (default: sys.argv[0])
-        - usage -- A usage message (default: auto-generated from arguments)
-        - description -- A description of what the program does
-        - epilog -- Text following the argument descriptions
-        - parents -- Parsers whose arguments should be copied into this one
-        - formatter_class -- HelpFormatter class for printing help messages
-        - prefix_chars -- Characters that prefix optional arguments
-        - fromfile_prefix_chars -- Characters that prefix files containing
-            additional arguments
-        - argument_default -- The default value for all arguments
-        - conflict_handler -- String indicating how to handle conflicts
-        - add_help -- Add a -h/-help option
-    """
-
-    def __init__(self,
-                 prog=None,
-                 usage=None,
-                 description=None,
-                 epilog=None,
-                 version=None,
-                 parents=[],
-                 formatter_class=HelpFormatter,
-                 prefix_chars='-',
-                 fromfile_prefix_chars=None,
-                 argument_default=None,
-                 conflict_handler='error',
-                 add_help=True):
-
-        if version is not None:
-            import warnings
-            warnings.warn(
-                """The "version" argument to ArgumentParser is deprecated. """
-                """Please use """
-                """"add_argument(..., action='version', version="N", ...)" """
-                """instead""", DeprecationWarning)
-
-        superinit = super(ArgumentParser, self).__init__
-        superinit(description=description,
-                  prefix_chars=prefix_chars,
-                  argument_default=argument_default,
-                  conflict_handler=conflict_handler)
-
-        # default setting for prog
-        if prog is None:
-            prog = _os.path.basename(_sys.argv[0])
-
-        self.prog = prog
-        self.usage = usage
-        self.epilog = epilog
-        self.version = version
-        self.formatter_class = formatter_class
-        self.fromfile_prefix_chars = fromfile_prefix_chars
-        self.add_help = add_help
-
-        add_group = self.add_argument_group
-        self._positionals = add_group(_('positional arguments'))
-        self._optionals = add_group(_('optional arguments'))
-        self._subparsers = None
-
-        # register types
-        def identity(string):
-            return string
-        self.register('type', None, identity)
-
-        # add help and version arguments if necessary
-        # (using explicit default to override global argument_default)
-        if self.add_help:
-            self.add_argument(
-                '-h', '--help', action='help', default=SUPPRESS,
-                help=_('show this help message and exit'))
-        if self.version:
-            self.add_argument(
-                '-v', '--version', action='version', default=SUPPRESS,
-                version=self.version,
-                help=_("show program's version number and exit"))
-
-        # add parent arguments and defaults
-        for parent in parents:
-            self._add_container_actions(parent)
-            try:
-                defaults = parent._defaults
-            except AttributeError:
-                pass
-            else:
-                self._defaults.update(defaults)
-
-    # =======================
-    # Pretty __repr__ methods
-    # =======================
-    def _get_kwargs(self):
-        names = [
-            'prog',
-            'usage',
-            'description',
-            'version',
-            'formatter_class',
-            'conflict_handler',
-            'add_help',
-        ]
-        return [(name, getattr(self, name)) for name in names]
-
-    # ==================================
-    # Optional/Positional adding methods
-    # ==================================
-    def add_subparsers(self, **kwargs):
-        if self._subparsers is not None:
-            self.error(_('cannot have multiple subparser arguments'))
-
-        # add the parser class to the arguments if it's not present
-        kwargs.setdefault('parser_class', type(self))
-
-        if 'title' in kwargs or 'description' in kwargs:
-            title = _(kwargs.pop('title', 'subcommands'))
-            description = _(kwargs.pop('description', None))
-            self._subparsers = self.add_argument_group(title, description)
-        else:
-            self._subparsers = self._positionals
-
-        # prog defaults to the usage message of this parser, skipping
-        # optional arguments and with no "usage:" prefix
-        if kwargs.get('prog') is None:
-            formatter = self._get_formatter()
-            positionals = self._get_positional_actions()
-            groups = self._mutually_exclusive_groups
-            formatter.add_usage(self.usage, positionals, groups, '')
-            kwargs['prog'] = formatter.format_help().strip()
-
-        # create the parsers action and add it to the positionals list
-        parsers_class = self._pop_action_class(kwargs, 'parsers')
-        action = parsers_class(option_strings=[], **kwargs)
-        self._subparsers._add_action(action)
-
-        # return the created parsers action
-        return action
-
-    def _add_action(self, action):
-        if action.option_strings:
-            self._optionals._add_action(action)
-        else:
-            self._positionals._add_action(action)
-        return action
-
-    def _get_optional_actions(self):
-        return [action
-                for action in self._actions
-                if action.option_strings]
-
-    def _get_positional_actions(self):
-        return [action
-                for action in self._actions
-                if not action.option_strings]
-
-    # =====================================
-    # Command line argument parsing methods
-    # =====================================
-    def parse_args(self, args=None, namespace=None):
-        args, argv = self.parse_known_args(args, namespace)
-        if argv:
-            msg = _('unrecognized arguments: %s')
-            self.error(msg % ' '.join(argv))
-        return args
-
-    def parse_known_args(self, args=None, namespace=None):
-        # args default to the system args
-        if args is None:
-            args = _sys.argv[1:]
-
-        # default Namespace built from parser defaults
-        if namespace is None:
-            namespace = Namespace()
-
-        # add any action defaults that aren't present
-        for action in self._actions:
-            if action.dest is not SUPPRESS:
-                if not hasattr(namespace, action.dest):
-                    if action.default is not SUPPRESS:
-                        default = action.default
-                        if isinstance(action.default, _basestring):
-                            default = self._get_value(action, default)
-                        setattr(namespace, action.dest, default)
-
-        # add any parser defaults that aren't present
-        for dest in self._defaults:
-            if not hasattr(namespace, dest):
-                setattr(namespace, dest, self._defaults[dest])
-
-        # parse the arguments and exit if there are any errors
-        try:
-            return self._parse_known_args(args, namespace)
-        except ArgumentError:
-            err = _sys.exc_info()[1]
-            self.error(str(err))
-
-    def _parse_known_args(self, arg_strings, namespace):
-        # replace arg strings that are file references
-        if self.fromfile_prefix_chars is not None:
-            arg_strings = self._read_args_from_files(arg_strings)
-
-        # map all mutually exclusive arguments to the other arguments
-        # they can't occur with
-        action_conflicts = {}
-        for mutex_group in self._mutually_exclusive_groups:
-            group_actions = mutex_group._group_actions
-            for i, mutex_action in enumerate(mutex_group._group_actions):
-                conflicts = action_conflicts.setdefault(mutex_action, [])
-                conflicts.extend(group_actions[:i])
-                conflicts.extend(group_actions[i + 1:])
-
-        # find all option indices, and determine the arg_string_pattern
-        # which has an 'O' if there is an option at an index,
-        # an 'A' if there is an argument, or a '-' if there is a '--'
-        option_string_indices = {}
-        arg_string_pattern_parts = []
-        arg_strings_iter = iter(arg_strings)
-        for i, arg_string in enumerate(arg_strings_iter):
-
-            # all args after -- are non-options
-            if arg_string == '--':
-                arg_string_pattern_parts.append('-')
-                for arg_string in arg_strings_iter:
-                    arg_string_pattern_parts.append('A')
-
-            # otherwise, add the arg to the arg strings
-            # and note the index if it was an option
-            else:
-                option_tuple = self._parse_optional(arg_string)
-                if option_tuple is None:
-                    pattern = 'A'
-                else:
-                    option_string_indices[i] = option_tuple
-                    pattern = 'O'
-                arg_string_pattern_parts.append(pattern)
-
-        # join the pieces together to form the pattern
-        arg_strings_pattern = ''.join(arg_string_pattern_parts)
-
-        # converts arg strings to the appropriate and then takes the action
-        seen_actions = _set()
-        seen_non_default_actions = _set()
-
-        def take_action(action, argument_strings, option_string=None):
-            seen_actions.add(action)
-            argument_values = self._get_values(action, argument_strings)
-
-            # error if this argument is not allowed with other previously
-            # seen arguments, assuming that actions that use the default
-            # value don't really count as "present"
-            if argument_values is not action.default:
-                seen_non_default_actions.add(action)
-                for conflict_action in action_conflicts.get(action, []):
-                    if conflict_action in seen_non_default_actions:
-                        msg = _('not allowed with argument %s')
-                        action_name = _get_action_name(conflict_action)
-                        raise ArgumentError(action, msg % action_name)
-
-            # take the action if we didn't receive a SUPPRESS value
-            # (e.g. from a default)
-            if argument_values is not SUPPRESS:
-                action(self, namespace, argument_values, option_string)
-
-        # function to convert arg_strings into an optional action
-        def consume_optional(start_index):
-
-            # get the optional identified at this index
-            option_tuple = option_string_indices[start_index]
-            action, option_string, explicit_arg = option_tuple
-
-            # identify additional optionals in the same arg string
-            # (e.g. -xyz is the same as -x -y -z if no args are required)
-            match_argument = self._match_argument
-            action_tuples = []
-            while True:
-
-                # if we found no optional action, skip it
-                if action is None:
-                    extras.append(arg_strings[start_index])
-                    return start_index + 1
-
-                # if there is an explicit argument, try to match the
-                # optional's string arguments to only this
-                if explicit_arg is not None:
-                    arg_count = match_argument(action, 'A')
-
-                    # if the action is a single-dash option and takes no
-                    # arguments, try to parse more single-dash options out
-                    # of the tail of the option string
-                    chars = self.prefix_chars
-                    if arg_count == 0 and option_string[1] not in chars:
-                        action_tuples.append((action, [], option_string))
-                        for char in self.prefix_chars:
-                            option_string = char + explicit_arg[0]
-                            explicit_arg = explicit_arg[1:] or None
-                            optionals_map = self._option_string_actions
-                            if option_string in optionals_map:
-                                action = optionals_map[option_string]
-                                break
-                        else:
-                            msg = _('ignored explicit argument %r')
-                            raise ArgumentError(action, msg % explicit_arg)
-
-                    # if the action expect exactly one argument, we've
-                    # successfully matched the option; exit the loop
-                    elif arg_count == 1:
-                        stop = start_index + 1
-                        args = [explicit_arg]
-                        action_tuples.append((action, args, option_string))
-                        break
-
-                    # error if a double-dash option did not use the
-                    # explicit argument
-                    else:
-                        msg = _('ignored explicit argument %r')
-                        raise ArgumentError(action, msg % explicit_arg)
-
-                # if there is no explicit argument, try to match the
-                # optional's string arguments with the following strings
-                # if successful, exit the loop
-                else:
-                    start = start_index + 1
-                    selected_patterns = arg_strings_pattern[start:]
-                    arg_count = match_argument(action, selected_patterns)
-                    stop = start + arg_count
-                    args = arg_strings[start:stop]
-                    action_tuples.append((action, args, option_string))
-                    break
-
-            # add the Optional to the list and return the index at which
-            # the Optional's string args stopped
-            assert action_tuples
-            for action, args, option_string in action_tuples:
-                take_action(action, args, option_string)
-            return stop
-
-        # the list of Positionals left to be parsed; this is modified
-        # by consume_positionals()
-        positionals = self._get_positional_actions()
-
-        # function to convert arg_strings into positional actions
-        def consume_positionals(start_index):
-            # match as many Positionals as possible
-            match_partial = self._match_arguments_partial
-            selected_pattern = arg_strings_pattern[start_index:]
-            arg_counts = match_partial(positionals, selected_pattern)
-
-            # slice off the appropriate arg strings for each Positional
-            # and add the Positional and its args to the list
-            for action, arg_count in zip(positionals, arg_counts):
-                args = arg_strings[start_index: start_index + arg_count]
-                start_index += arg_count
-                take_action(action, args)
-
-            # slice off the Positionals that we just parsed and return the
-            # index at which the Positionals' string args stopped
-            positionals[:] = positionals[len(arg_counts):]
-            return start_index
-
-        # consume Positionals and Optionals alternately, until we have
-        # passed the last option string
-        extras = []
-        start_index = 0
-        if option_string_indices:
-            max_option_string_index = max(option_string_indices)
-        else:
-            max_option_string_index = -1
-        while start_index <= max_option_string_index:
-
-            # consume any Positionals preceding the next option
-            next_option_string_index = min([
-                index
-                for index in option_string_indices
-                if index >= start_index])
-            if start_index != next_option_string_index:
-                positionals_end_index = consume_positionals(start_index)
-
-                # only try to parse the next optional if we didn't consume
-                # the option string during the positionals parsing
-                if positionals_end_index > start_index:
-                    start_index = positionals_end_index
-                    continue
-                else:
-                    start_index = positionals_end_index
-
-            # if we consumed all the positionals we could and we're not
-            # at the index of an option string, there were extra arguments
-            if start_index not in option_string_indices:
-                strings = arg_strings[start_index:next_option_string_index]
-                extras.extend(strings)
-                start_index = next_option_string_index
-
-            # consume the next optional and any arguments for it
-            start_index = consume_optional(start_index)
-
-        # consume any positionals following the last Optional
-        stop_index = consume_positionals(start_index)
-
-        # if we didn't consume all the argument strings, there were extras
-        extras.extend(arg_strings[stop_index:])
-
-        # if we didn't use all the Positional objects, there were too few
-        # arg strings supplied.
-        if positionals:
-            self.error(_('too few arguments'))
-
-        # make sure all required actions were present
-        for action in self._actions:
-            if action.required:
-                if action not in seen_actions:
-                    name = _get_action_name(action)
-                    self.error(_('argument %s is required') % name)
-
-        # make sure all required groups had one option present
-        for group in self._mutually_exclusive_groups:
-            if group.required:
-                for action in group._group_actions:
-                    if action in seen_non_default_actions:
-                        break
-
-                # if no actions were used, report the error
-                else:
-                    names = [_get_action_name(action)
-                             for action in group._group_actions
-                             if action.help is not SUPPRESS]
-                    msg = _('one of the arguments %s is required')
-                    self.error(msg % ' '.join(names))
-
-        # return the updated namespace and the extra arguments
-        return namespace, extras
-
-    def _read_args_from_files(self, arg_strings):
-        # expand arguments referencing files
-        new_arg_strings = []
-        for arg_string in arg_strings:
-
-            # for regular arguments, just add them back into the list
-            if arg_string[0] not in self.fromfile_prefix_chars:
-                new_arg_strings.append(arg_string)
-
-            # replace arguments referencing files with the file content
-            else:
-                try:
-                    args_file = open(arg_string[1:])
-                    try:
-                        arg_strings = []
-                        for arg_line in args_file.read().splitlines():
-                            for arg in self.convert_arg_line_to_args(arg_line):
-                                arg_strings.append(arg)
-                        arg_strings = self._read_args_from_files(arg_strings)
-                        new_arg_strings.extend(arg_strings)
-                    finally:
-                        args_file.close()
-                except IOError:
-                    err = _sys.exc_info()[1]
-                    self.error(str(err))
-
-        # return the modified argument list
-        return new_arg_strings
-
-    def convert_arg_line_to_args(self, arg_line):
-        return [arg_line]
-
-    def _match_argument(self, action, arg_strings_pattern):
-        # match the pattern for this action to the arg strings
-        nargs_pattern = self._get_nargs_pattern(action)
-        match = _re.match(nargs_pattern, arg_strings_pattern)
-
-        # raise an exception if we weren't able to find a match
-        if match is None:
-            nargs_errors = {
-                None: _('expected one argument'),
-                OPTIONAL: _('expected at most one argument'),
-                ONE_OR_MORE: _('expected at least one argument'),
-            }
-            default = _('expected %s argument(s)') % action.nargs
-            msg = nargs_errors.get(action.nargs, default)
-            raise ArgumentError(action, msg)
-
-        # return the number of arguments matched
-        return len(match.group(1))
-
-    def _match_arguments_partial(self, actions, arg_strings_pattern):
-        # progressively shorten the actions list by slicing off the
-        # final actions until we find a match
-        result = []
-        for i in range(len(actions), 0, -1):
-            actions_slice = actions[:i]
-            pattern = ''.join([self._get_nargs_pattern(action)
-                               for action in actions_slice])
-            match = _re.match(pattern, arg_strings_pattern)
-            if match is not None:
-                result.extend([len(string) for string in match.groups()])
-                break
-
-        # return the list of arg string counts
-        return result
-
-    def _parse_optional(self, arg_string):
-        # if it's an empty string, it was meant to be a positional
-        if not arg_string:
-            return None
-
-        # if it doesn't start with a prefix, it was meant to be positional
-        if not arg_string[0] in self.prefix_chars:
-            return None
-
-        # if the option string is present in the parser, return the action
-        if arg_string in self._option_string_actions:
-            action = self._option_string_actions[arg_string]
-            return action, arg_string, None
-
-        # if it's just a single character, it was meant to be positional
-        if len(arg_string) == 1:
-            return None
-
-        # if the option string before the "=" is present, return the action
-        if '=' in arg_string:
-            option_string, explicit_arg = arg_string.split('=', 1)
-            if option_string in self._option_string_actions:
-                action = self._option_string_actions[option_string]
-                return action, option_string, explicit_arg
-
-        # search through all possible prefixes of the option string
-        # and all actions in the parser for possible interpretations
-        option_tuples = self._get_option_tuples(arg_string)
-
-        # if multiple actions match, the option string was ambiguous
-        if len(option_tuples) > 1:
-            options = ', '.join([option_string
-                for action, option_string, explicit_arg in option_tuples])
-            tup = arg_string, options
-            self.error(_('ambiguous option: %s could match %s') % tup)
-
-        # if exactly one action matched, this segmentation is good,
-        # so return the parsed action
-        elif len(option_tuples) == 1:
-            option_tuple, = option_tuples
-            return option_tuple
-
-        # if it was not found as an option, but it looks like a negative
-        # number, it was meant to be positional
-        # unless there are negative-number-like options
-        if self._negative_number_matcher.match(arg_string):
-            if not self._has_negative_number_optionals:
-                return None
-
-        # if it contains a space, it was meant to be a positional
-        if ' ' in arg_string:
-            return None
-
-        # it was meant to be an optional but there is no such option
-        # in this parser (though it might be a valid option in a subparser)
-        return None, arg_string, None
-
-    def _get_option_tuples(self, option_string):
-        result = []
-
-        # option strings starting with two prefix characters are only
-        # split at the '='
-        chars = self.prefix_chars
-        if option_string[0] in chars and option_string[1] in chars:
-            if '=' in option_string:
-                option_prefix, explicit_arg = option_string.split('=', 1)
-            else:
-                option_prefix = option_string
-                explicit_arg = None
-            for option_string in self._option_string_actions:
-                if option_string.startswith(option_prefix):
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, explicit_arg
-                    result.append(tup)
-
-        # single character options can be concatenated with their arguments
-        # but multiple character options always have to have their argument
-        # separate
-        elif option_string[0] in chars and option_string[1] not in chars:
-            option_prefix = option_string
-            explicit_arg = None
-            short_option_prefix = option_string[:2]
-            short_explicit_arg = option_string[2:]
-
-            for option_string in self._option_string_actions:
-                if option_string == short_option_prefix:
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, short_explicit_arg
-                    result.append(tup)
-                elif option_string.startswith(option_prefix):
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, explicit_arg
-                    result.append(tup)
-
-        # shouldn't ever get here
-        else:
-            self.error(_('unexpected option string: %s') % option_string)
-
-        # return the collected option tuples
-        return result
-
-    def _get_nargs_pattern(self, action):
-        # in all examples below, we have to allow for '--' args
-        # which are represented as '-' in the pattern
-        nargs = action.nargs
-
-        # the default (None) is assumed to be a single argument
-        if nargs is None:
-            nargs_pattern = '(-*A-*)'
-
-        # allow zero or one arguments
-        elif nargs == OPTIONAL:
-            nargs_pattern = '(-*A?-*)'
-
-        # allow zero or more arguments
-        elif nargs == ZERO_OR_MORE:
-            nargs_pattern = '(-*[A-]*)'
-
-        # allow one or more arguments
-        elif nargs == ONE_OR_MORE:
-            nargs_pattern = '(-*A[A-]*)'
-
-        # allow any number of options or arguments
-        elif nargs == REMAINDER:
-            nargs_pattern = '([-AO]*)'
-
-        # allow one argument followed by any number of options or arguments
-        elif nargs == PARSER:
-            nargs_pattern = '(-*A[-AO]*)'
-
-        # all others should be integers
-        else:
-            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
-
-        # if this is an optional action, -- is not allowed
-        if action.option_strings:
-            nargs_pattern = nargs_pattern.replace('-*', '')
-            nargs_pattern = nargs_pattern.replace('-', '')
-
-        # return the pattern
-        return nargs_pattern
-
-    # ========================
-    # Value conversion methods
-    # ========================
-    def _get_values(self, action, arg_strings):
-        # for everything but PARSER args, strip out '--'
-        if action.nargs not in [PARSER, REMAINDER]:
-            arg_strings = [s for s in arg_strings if s != '--']
-
-        # optional argument produces a default when not present
-        if not arg_strings and action.nargs == OPTIONAL:
-            if action.option_strings:
-                value = action.const
-            else:
-                value = action.default
-            if isinstance(value, _basestring):
-                value = self._get_value(action, value)
-                self._check_value(action, value)
-
-        # when nargs='*' on a positional, if there were no command-line
-        # args, use the default if it is anything other than None
-        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
-              not action.option_strings):
-            if action.default is not None:
-                value = action.default
-            else:
-                value = arg_strings
-            self._check_value(action, value)
-
-        # single argument or optional argument produces a single value
-        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
-            arg_string, = arg_strings
-            value = self._get_value(action, arg_string)
-            self._check_value(action, value)
-
-        # REMAINDER arguments convert all values, checking none
-        elif action.nargs == REMAINDER:
-            value = [self._get_value(action, v) for v in arg_strings]
-
-        # PARSER arguments convert all values, but check only the first
-        elif action.nargs == PARSER:
-            value = [self._get_value(action, v) for v in arg_strings]
-            self._check_value(action, value[0])
-
-        # all other types of nargs produce a list
-        else:
-            value = [self._get_value(action, v) for v in arg_strings]
-            for v in value:
-                self._check_value(action, v)
-
-        # return the converted value
-        return value
-
-    def _get_value(self, action, arg_string):
-        type_func = self._registry_get('type', action.type, action.type)
-        if not _callable(type_func):
-            msg = _('%r is not callable')
-            raise ArgumentError(action, msg % type_func)
-
-        # convert the value to the appropriate type
-        try:
-            result = type_func(arg_string)
-
-        # ArgumentTypeErrors indicate errors
-        except ArgumentTypeError:
-            name = getattr(action.type, '__name__', repr(action.type))
-            msg = str(_sys.exc_info()[1])
-            raise ArgumentError(action, msg)
-
-        # TypeErrors or ValueErrors also indicate errors
-        except (TypeError, ValueError):
-            name = getattr(action.type, '__name__', repr(action.type))
-            msg = _('invalid %s value: %r')
-            raise ArgumentError(action, msg % (name, arg_string))
-
-        # return the converted value
-        return result
-
-    def _check_value(self, action, value):
-        # converted value must be one of the choices (if specified)
-        if action.choices is not None and value not in action.choices:
-            tup = value, ', '.join(map(repr, action.choices))
-            msg = _('invalid choice: %r (choose from %s)') % tup
-            raise ArgumentError(action, msg)
-
-    # =======================
-    # Help-formatting methods
-    # =======================
-    def format_usage(self):
-        formatter = self._get_formatter()
-        formatter.add_usage(self.usage, self._actions,
-                            self._mutually_exclusive_groups)
-        return formatter.format_help()
-
-    def format_help(self):
-        formatter = self._get_formatter()
-
-        # usage
-        formatter.add_usage(self.usage, self._actions,
-                            self._mutually_exclusive_groups)
-
-        # description
-        formatter.add_text(self.description)
-
-        # positionals, optionals and user-defined groups
-        for action_group in self._action_groups:
-            formatter.start_section(action_group.title)
-            formatter.add_text(action_group.description)
-            formatter.add_arguments(action_group._group_actions)
-            formatter.end_section()
-
-        # epilog
-        formatter.add_text(self.epilog)
-
-        # determine help from format above
-        return formatter.format_help()
-
-    def format_version(self):
-        import warnings
-        warnings.warn(
-            'The format_version method is deprecated -- the "version" '
-            'argument to ArgumentParser is no longer supported.',
-            DeprecationWarning)
-        formatter = self._get_formatter()
-        formatter.add_text(self.version)
-        return formatter.format_help()
-
-    def _get_formatter(self):
-        return self.formatter_class(prog=self.prog)
-
-    # =====================
-    # Help-printing methods
-    # =====================
-    def print_usage(self, file=None):
-        if file is None:
-            file = _sys.stdout
-        self._print_message(self.format_usage(), file)
-
-    def print_help(self, file=None):
-        if file is None:
-            file = _sys.stdout
-        self._print_message(self.format_help(), file)
-
-    def print_version(self, file=None):
-        import warnings
-        warnings.warn(
-            'The print_version method is deprecated -- the "version" '
-            'argument to ArgumentParser is no longer supported.',
-            DeprecationWarning)
-        self._print_message(self.format_version(), file)
-
-    def _print_message(self, message, file=None):
-        if message:
-            if file is None:
-                file = _sys.stderr
-            file.write(message)
-
-    # ===============
-    # Exiting methods
-    # ===============
-    def exit(self, status=0, message=None):
-        if message:
-            self._print_message(message, _sys.stderr)
-        _sys.exit(status)
-
-    def error(self, message):
-        """error(message: string)
-
-        Prints a usage message incorporating the message to stderr and
-        exits.
-
-        If you override this in a subclass, it should not return -- it
-        should either exit or raise an exception.
-        """
-        self.print_usage(_sys.stderr)
-        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
diff --git a/IPython/external/configobj/__init__.py b/IPython/external/configobj/__init__.py
deleted file mode 100644
index 70678bda544..00000000000
--- a/IPython/external/configobj/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-try:
-    from configobj import *
-except ImportError:
-    from _configobj import *
diff --git a/IPython/external/configobj/_configobj.py b/IPython/external/configobj/_configobj.py
deleted file mode 100644
index 303f10bbd6c..00000000000
--- a/IPython/external/configobj/_configobj.py
+++ /dev/null
@@ -1,2472 +0,0 @@
-# -*- coding: utf-8 -*-
-# configobj.py
-# A config file reader/writer that supports nested sections in config files.
-# Copyright (C) 2005-2008 Michael Foord, Nicola Larosa
-# E-mail: fuzzyman AT voidspace DOT org DOT uk
-#         nico AT tekNico DOT net
-
-# ConfigObj 4
-# http://www.voidspace.org.uk/python/configobj.html
-
-# Released subject to the BSD License
-# Please see http://www.voidspace.org.uk/python/license.shtml
-
-# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
-# For information about bugfixes, updates and support, please join the
-# ConfigObj mailing list:
-# http://lists.sourceforge.net/lists/listinfo/configobj-develop
-# Comments, suggestions and bug reports welcome.
-
-from __future__ import generators
-
-import sys
-INTP_VER = sys.version_info[:2]
-if INTP_VER < (2, 2):
-    raise RuntimeError("Python v.2.2 or later needed")
-
-import os, re
-compiler = None
-try:
-    import compiler
-except ImportError:
-    # for IronPython
-    pass
-from types import StringTypes
-from warnings import warn
-from codecs import BOM_UTF8, BOM_UTF16, BOM_UTF16_BE, BOM_UTF16_LE
-
-# A dictionary mapping BOM to
-# the encoding to decode with, and what to set the
-# encoding attribute to.
-BOMS = {
-    BOM_UTF8: ('utf_8', None),
-    BOM_UTF16_BE: ('utf16_be', 'utf_16'),
-    BOM_UTF16_LE: ('utf16_le', 'utf_16'),
-    BOM_UTF16: ('utf_16', 'utf_16'),
-    }
-# All legal variants of the BOM codecs.
-# TODO: the list of aliases is not meant to be exhaustive, is there a
-#   better way ?
-BOM_LIST = {
-    'utf_16': 'utf_16',
-    'u16': 'utf_16',
-    'utf16': 'utf_16',
-    'utf-16': 'utf_16',
-    'utf16_be': 'utf16_be',
-    'utf_16_be': 'utf16_be',
-    'utf-16be': 'utf16_be',
-    'utf16_le': 'utf16_le',
-    'utf_16_le': 'utf16_le',
-    'utf-16le': 'utf16_le',
-    'utf_8': 'utf_8',
-    'u8': 'utf_8',
-    'utf': 'utf_8',
-    'utf8': 'utf_8',
-    'utf-8': 'utf_8',
-    }
-
-# Map of encodings to the BOM to write.
-BOM_SET = {
-    'utf_8': BOM_UTF8,
-    'utf_16': BOM_UTF16,
-    'utf16_be': BOM_UTF16_BE,
-    'utf16_le': BOM_UTF16_LE,
-    None: BOM_UTF8
-    }
-
-
-def match_utf8(encoding):
-    return BOM_LIST.get(encoding.lower()) == 'utf_8'
-
-
-# Quote strings used for writing values
-squot = "'%s'"
-dquot = '"%s"'
-noquot = "%s"
-wspace_plus = ' \r\t\n\v\t\'"'
-tsquot = '"""%s"""'
-tdquot = "'''%s'''"
-
-
-__version__ = '4.5.2'
-
-__revision__ = '$Id: configobj.py 156 2006-01-31 14:57:08Z fuzzyman $'
-
-__docformat__ = "restructuredtext en"
-
-__all__ = (
-    '__version__',
-    'DEFAULT_INDENT_TYPE',
-    'DEFAULT_INTERPOLATION',
-    'ConfigObjError',
-    'NestingError',
-    'ParseError',
-    'DuplicateError',
-    'ConfigspecError',
-    'ConfigObj',
-    'SimpleVal',
-    'InterpolationError',
-    'InterpolationLoopError',
-    'MissingInterpolationOption',
-    'RepeatSectionError',
-    'ReloadError',
-    'UnreprError',
-    'UnknownType',
-    '__docformat__',
-    'flatten_errors',
-)
-
-DEFAULT_INTERPOLATION = 'configparser'
-DEFAULT_INDENT_TYPE = '    '
-MAX_INTERPOL_DEPTH = 10
-
-OPTION_DEFAULTS = {
-    'interpolation': True,
-    'raise_errors': False,
-    'list_values': True,
-    'create_empty': False,
-    'file_error': False,
-    'configspec': None,
-    'stringify': True,
-    # option may be set to one of ('', ' ', '\t')
-    'indent_type': None,
-    'encoding': None,
-    'default_encoding': None,
-    'unrepr': False,
-    'write_empty_values': False,
-}
-
-
-
-def getObj(s):
-    s = "a=" + s
-    if compiler is None:
-        raise ImportError('compiler module not available')
-    p = compiler.parse(s)
-    return p.getChildren()[1].getChildren()[0].getChildren()[1]
-
-
-class UnknownType(Exception):
-    pass
-
-
-class Builder(object):
-    
-    def build(self, o):
-        m = getattr(self, 'build_' + o.__class__.__name__, None)
-        if m is None:
-            raise UnknownType(o.__class__.__name__)
-        return m(o)
-    
-    def build_List(self, o):
-        return map(self.build, o.getChildren())
-    
-    def build_Const(self, o):
-        return o.value
-    
-    def build_Dict(self, o):
-        d = {}
-        i = iter(map(self.build, o.getChildren()))
-        for el in i:
-            d[el] = i.next()
-        return d
-    
-    def build_Tuple(self, o):
-        return tuple(self.build_List(o))
-    
-    def build_Name(self, o):
-        if o.name == 'None':
-            return None
-        if o.name == 'True':
-            return True
-        if o.name == 'False':
-            return False
-        
-        # An undefined Name
-        raise UnknownType('Undefined Name')
-    
-    def build_Add(self, o):
-        real, imag = map(self.build_Const, o.getChildren())
-        try:
-            real = float(real)
-        except TypeError:
-            raise UnknownType('Add')
-        if not isinstance(imag, complex) or imag.real != 0.0:
-            raise UnknownType('Add')
-        return real+imag
-    
-    def build_Getattr(self, o):
-        parent = self.build(o.expr)
-        return getattr(parent, o.attrname)
-    
-    def build_UnarySub(self, o):
-        return -self.build_Const(o.getChildren()[0])
-    
-    def build_UnaryAdd(self, o):
-        return self.build_Const(o.getChildren()[0])
-
-
-_builder = Builder()
-
-
-def unrepr(s):
-    if not s:
-        return s
-    return _builder.build(getObj(s))
-
-
-
-class ConfigObjError(SyntaxError):
-    """
-    This is the base class for all errors that ConfigObj raises.
-    It is a subclass of SyntaxError.
-    """
-    def __init__(self, message='', line_number=None, line=''):
-        self.line = line
-        self.line_number = line_number
-        self.message = message
-        SyntaxError.__init__(self, message)
-
-
-class NestingError(ConfigObjError):
-    """
-    This error indicates a level of nesting that doesn't match.
-    """
-
-
-class ParseError(ConfigObjError):
-    """
-    This error indicates that a line is badly written.
-    It is neither a valid ``key = value`` line,
-    nor a valid section marker line.
-    """
-
-
-class ReloadError(IOError):
-    """
-    A 'reload' operation failed.
-    This exception is a subclass of ``IOError``.
-    """
-    def __init__(self):
-        IOError.__init__(self, 'reload failed, filename is not set.')
-
-
-class DuplicateError(ConfigObjError):
-    """
-    The keyword or section specified already exists.
-    """
-
-
-class ConfigspecError(ConfigObjError):
-    """
-    An error occured whilst parsing a configspec.
-    """
-
-
-class InterpolationError(ConfigObjError):
-    """Base class for the two interpolation errors."""
-
-
-class InterpolationLoopError(InterpolationError):
-    """Maximum interpolation depth exceeded in string interpolation."""
-
-    def __init__(self, option):
-        InterpolationError.__init__(
-            self,
-            'interpolation loop detected in value "%s".' % option)
-
-
-class RepeatSectionError(ConfigObjError):
-    """
-    This error indicates additional sections in a section with a
-    ``__many__`` (repeated) section.
-    """
-
-
-class MissingInterpolationOption(InterpolationError):
-    """A value specified for interpolation was missing."""
-
-    def __init__(self, option):
-        InterpolationError.__init__(
-            self,
-            'missing option "%s" in interpolation.' % option)
-
-
-class UnreprError(ConfigObjError):
-    """An error parsing in unrepr mode."""
-
-
-
-class InterpolationEngine(object):
-    """
-    A helper class to help perform string interpolation.
-
-    This class is an abstract base class; its descendants perform
-    the actual work.
-    """
-
-    # compiled regexp to use in self.interpolate()
-    _KEYCRE = re.compile(r"%\(([^)]*)\)s")
-
-    def __init__(self, section):
-        # the Section instance that "owns" this engine
-        self.section = section
-
-
-    def interpolate(self, key, value):
-        def recursive_interpolate(key, value, section, backtrail):
-            """The function that does the actual work.
-
-            ``value``: the string we're trying to interpolate.
-            ``section``: the section in which that string was found
-            ``backtrail``: a dict to keep track of where we've been,
-            to detect and prevent infinite recursion loops
-
-            This is similar to a depth-first-search algorithm.
-            """
-            # Have we been here already?
-            if backtrail.has_key((key, section.name)):
-                # Yes - infinite loop detected
-                raise InterpolationLoopError(key)
-            # Place a marker on our backtrail so we won't come back here again
-            backtrail[(key, section.name)] = 1
-
-            # Now start the actual work
-            match = self._KEYCRE.search(value)
-            while match:
-                # The actual parsing of the match is implementation-dependent,
-                # so delegate to our helper function
-                k, v, s = self._parse_match(match)
-                if k is None:
-                    # That's the signal that no further interpolation is needed
-                    replacement = v
-                else:
-                    # Further interpolation may be needed to obtain final value
-                    replacement = recursive_interpolate(k, v, s, backtrail)
-                # Replace the matched string with its final value
-                start, end = match.span()
-                value = ''.join((value[:start], replacement, value[end:]))
-                new_search_start = start + len(replacement)
-                # Pick up the next interpolation key, if any, for next time
-                # through the while loop
-                match = self._KEYCRE.search(value, new_search_start)
-
-            # Now safe to come back here again; remove marker from backtrail
-            del backtrail[(key, section.name)]
-
-            return value
-
-        # Back in interpolate(), all we have to do is kick off the recursive
-        # function with appropriate starting values
-        value = recursive_interpolate(key, value, self.section, {})
-        return value
-
-
-    def _fetch(self, key):
-        """Helper function to fetch values from owning section.
-
-        Returns a 2-tuple: the value, and the section where it was found.
-        """
-        # switch off interpolation before we try and fetch anything !
-        save_interp = self.section.main.interpolation
-        self.section.main.interpolation = False
-
-        # Start at section that "owns" this InterpolationEngine
-        current_section = self.section
-        while True:
-            # try the current section first
-            val = current_section.get(key)
-            if val is not None:
-                break
-            # try "DEFAULT" next
-            val = current_section.get('DEFAULT', {}).get(key)
-            if val is not None:
-                break
-            # move up to parent and try again
-            # top-level's parent is itself
-            if current_section.parent is current_section:
-                # reached top level, time to give up
-                break
-            current_section = current_section.parent
-
-        # restore interpolation to previous value before returning
-        self.section.main.interpolation = save_interp
-        if val is None:
-            raise MissingInterpolationOption(key)
-        return val, current_section
-
-
-    def _parse_match(self, match):
-        """Implementation-dependent helper function.
-
-        Will be passed a match object corresponding to the interpolation
-        key we just found (e.g., "%(foo)s" or "$foo"). Should look up that
-        key in the appropriate config file section (using the ``_fetch()``
-        helper function) and return a 3-tuple: (key, value, section)
-
-        ``key`` is the name of the key we're looking for
-        ``value`` is the value found for that key
-        ``section`` is a reference to the section where it was found
-
-        ``key`` and ``section`` should be None if no further
-        interpolation should be performed on the resulting value
-        (e.g., if we interpolated "$$" and returned "$").
-        """
-        raise NotImplementedError()
-    
-
-
-class ConfigParserInterpolation(InterpolationEngine):
-    """Behaves like ConfigParser."""
-    _KEYCRE = re.compile(r"%\(([^)]*)\)s")
-
-    def _parse_match(self, match):
-        key = match.group(1)
-        value, section = self._fetch(key)
-        return key, value, section
-
-
-
-class TemplateInterpolation(InterpolationEngine):
-    """Behaves like string.Template."""
-    _delimiter = '$'
-    _KEYCRE = re.compile(r"""
-        \$(?:
-          (?P<escaped>\$)              |   # Two $ signs
-          (?P<named>[_a-z][_a-z0-9]*)  |   # $name format
-          {(?P<braced>[^}]*)}              # ${name} format
-        )
-        """, re.IGNORECASE | re.VERBOSE)
-
-    def _parse_match(self, match):
-        # Valid name (in or out of braces): fetch value from section
-        key = match.group('named') or match.group('braced')
-        if key is not None:
-            value, section = self._fetch(key)
-            return key, value, section
-        # Escaped delimiter (e.g., $$): return single delimiter
-        if match.group('escaped') is not None:
-            # Return None for key and section to indicate it's time to stop
-            return None, self._delimiter, None
-        # Anything else: ignore completely, just return it unchanged
-        return None, match.group(), None
-
-
-interpolation_engines = {
-    'configparser': ConfigParserInterpolation,
-    'template': TemplateInterpolation,
-}
-
-
-
-class Section(dict):
-    """
-    A dictionary-like object that represents a section in a config file.
-    
-    It does string interpolation if the 'interpolation' attribute
-    of the 'main' object is set to True.
-    
-    Interpolation is tried first from this object, then from the 'DEFAULT'
-    section of this object, next from the parent and its 'DEFAULT' section,
-    and so on until the main object is reached.
-    
-    A Section will behave like an ordered dictionary - following the
-    order of the ``scalars`` and ``sections`` attributes.
-    You can use this to change the order of members.
-    
-    Iteration follows the order: scalars, then sections.
-    """
-
-    def __init__(self, parent, depth, main, indict=None, name=None):
-        """
-        * parent is the section above
-        * depth is the depth level of this section
-        * main is the main ConfigObj
-        * indict is a dictionary to initialise the section with
-        """
-        if indict is None:
-            indict = {}
-        dict.__init__(self)
-        # used for nesting level *and* interpolation
-        self.parent = parent
-        # used for the interpolation attribute
-        self.main = main
-        # level of nesting depth of this Section
-        self.depth = depth
-        # purely for information
-        self.name = name
-        #
-        self._initialise()
-        # we do this explicitly so that __setitem__ is used properly
-        # (rather than just passing to ``dict.__init__``)
-        for entry, value in indict.iteritems():
-            self[entry] = value
-            
-            
-    def _initialise(self):
-        # the sequence of scalar values in this Section
-        self.scalars = []
-        # the sequence of sections in this Section
-        self.sections = []
-        # for comments :-)
-        self.comments = {}
-        self.inline_comments = {}
-        # for the configspec
-        self.configspec = {}
-        self._order = []
-        self._configspec_comments = {}
-        self._configspec_inline_comments = {}
-        self._cs_section_comments = {}
-        self._cs_section_inline_comments = {}
-        # for defaults
-        self.defaults = []
-        self.default_values = {}
-
-
-    def _interpolate(self, key, value):
-        try:
-            # do we already have an interpolation engine?
-            engine = self._interpolation_engine
-        except AttributeError:
-            # not yet: first time running _interpolate(), so pick the engine
-            name = self.main.interpolation
-            if name == True:  # note that "if name:" would be incorrect here
-                # backwards-compatibility: interpolation=True means use default
-                name = DEFAULT_INTERPOLATION
-            name = name.lower()  # so that "Template", "template", etc. all work
-            class_ = interpolation_engines.get(name, None)
-            if class_ is None:
-                # invalid value for self.main.interpolation
-                self.main.interpolation = False
-                return value
-            else:
-                # save reference to engine so we don't have to do this again
-                engine = self._interpolation_engine = class_(self)
-        # let the engine do the actual work
-        return engine.interpolate(key, value)
-
-
-    def __getitem__(self, key):
-        """Fetch the item and do string interpolation."""
-        val = dict.__getitem__(self, key)
-        if self.main.interpolation and isinstance(val, StringTypes):
-            return self._interpolate(key, val)
-        return val
-
-
-    def __setitem__(self, key, value, unrepr=False):
-        """
-        Correctly set a value.
-        
-        Making dictionary values Section instances.
-        (We have to special case 'Section' instances - which are also dicts)
-        
-        Keys must be strings.
-        Values need only be strings (or lists of strings) if
-        ``main.stringify`` is set.
-        
-        `unrepr`` must be set when setting a value to a dictionary, without
-        creating a new sub-section.
-        """
-        if not isinstance(key, StringTypes):
-            raise ValueError('The key "%s" is not a string.' % key)
-        
-        # add the comment
-        if not self.comments.has_key(key):
-            self.comments[key] = []
-            self.inline_comments[key] = ''
-        # remove the entry from defaults
-        if key in self.defaults:
-            self.defaults.remove(key)
-        #
-        if isinstance(value, Section):
-            if not self.has_key(key):
-                self.sections.append(key)
-            dict.__setitem__(self, key, value)
-        elif isinstance(value, dict) and not unrepr:
-            # First create the new depth level,
-            # then create the section
-            if not self.has_key(key):
-                self.sections.append(key)
-            new_depth = self.depth + 1
-            dict.__setitem__(
-                self,
-                key,
-                Section(
-                    self,
-                    new_depth,
-                    self.main,
-                    indict=value,
-                    name=key))
-        else:
-            if not self.has_key(key):
-                self.scalars.append(key)
-            if not self.main.stringify:
-                if isinstance(value, StringTypes):
-                    pass
-                elif isinstance(value, (list, tuple)):
-                    for entry in value:
-                        if not isinstance(entry, StringTypes):
-                            raise TypeError('Value is not a string "%s".' % entry)
-                else:
-                    raise TypeError('Value is not a string "%s".' % value)
-            dict.__setitem__(self, key, value)
-
-
-    def __delitem__(self, key):
-        """Remove items from the sequence when deleting."""
-        dict. __delitem__(self, key)
-        if key in self.scalars:
-            self.scalars.remove(key)
-        else:
-            self.sections.remove(key)
-        del self.comments[key]
-        del self.inline_comments[key]
-
-
-    def get(self, key, default=None):
-        """A version of ``get`` that doesn't bypass string interpolation."""
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-
-    def update(self, indict):
-        """
-        A version of update that uses our ``__setitem__``.
-        """
-        for entry in indict:
-            self[entry] = indict[entry]
-
-
-    def pop(self, key, *args):
-        """
-        'D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
-        If key is not found, d is returned if given, otherwise KeyError is raised'
-        """
-        val = dict.pop(self, key, *args)
-        if key in self.scalars:
-            del self.comments[key]
-            del self.inline_comments[key]
-            self.scalars.remove(key)
-        elif key in self.sections:
-            del self.comments[key]
-            del self.inline_comments[key]
-            self.sections.remove(key)
-        if self.main.interpolation and isinstance(val, StringTypes):
-            return self._interpolate(key, val)
-        return val
-
-
-    def popitem(self):
-        """Pops the first (key,val)"""
-        sequence = (self.scalars + self.sections)
-        if not sequence:
-            raise KeyError(": 'popitem(): dictionary is empty'")
-        key = sequence[0]
-        val =  self[key]
-        del self[key]
-        return key, val
-
-
-    def clear(self):
-        """
-        A version of clear that also affects scalars/sections
-        Also clears comments and configspec.
-        
-        Leaves other attributes alone :
-            depth/main/parent are not affected
-        """
-        dict.clear(self)
-        self.scalars = []
-        self.sections = []
-        self.comments = {}
-        self.inline_comments = {}
-        self.configspec = {}
-
-
-    def setdefault(self, key, default=None):
-        """A version of setdefault that sets sequence if appropriate."""
-        try:
-            return self[key]
-        except KeyError:
-            self[key] = default
-            return self[key]
-
-
-    def items(self):
-        """D.items() -> list of D's (key, value) pairs, as 2-tuples"""
-        return zip((self.scalars + self.sections), self.values())
-
-
-    def keys(self):
-        """D.keys() -> list of D's keys"""
-        return (self.scalars + self.sections)
-
-
-    def values(self):
-        """D.values() -> list of D's values"""
-        return [self[key] for key in (self.scalars + self.sections)]
-
-
-    def iteritems(self):
-        """D.iteritems() -> an iterator over the (key, value) items of D"""
-        return iter(self.items())
-
-
-    def iterkeys(self):
-        """D.iterkeys() -> an iterator over the keys of D"""
-        return iter((self.scalars + self.sections))
-
-    __iter__ = iterkeys
-
-
-    def itervalues(self):
-        """D.itervalues() -> an iterator over the values of D"""
-        return iter(self.values())
-
-
-    def __repr__(self):
-        """x.__repr__() <==> repr(x)"""
-        return '{%s}' % ', '.join([('%s: %s' % (repr(key), repr(self[key])))
-            for key in (self.scalars + self.sections)])
-
-    __str__ = __repr__
-    __str__.__doc__ = "x.__str__() <==> str(x)"
-
-
-    # Extra methods - not in a normal dictionary
-
-    def dict(self):
-        """
-        Return a deepcopy of self as a dictionary.
-        
-        All members that are ``Section`` instances are recursively turned to
-        ordinary dictionaries - by calling their ``dict`` method.
-        
-        >>> n = a.dict()
-        >>> n == a
-        1
-        >>> n is a
-        0
-        """
-        newdict = {}
-        for entry in self:
-            this_entry = self[entry]
-            if isinstance(this_entry, Section):
-                this_entry = this_entry.dict()
-            elif isinstance(this_entry, list):
-                # create a copy rather than a reference
-                this_entry = list(this_entry)
-            elif isinstance(this_entry, tuple):
-                # create a copy rather than a reference
-                this_entry = tuple(this_entry)
-            newdict[entry] = this_entry
-        return newdict
-
-
-    def merge(self, indict):
-        """
-        A recursive update - useful for merging config files.
-        
-        >>> a = '''[section1]
-        ...     option1 = True
-        ...     [[subsection]]
-        ...     more_options = False
-        ...     # end of file'''.splitlines()
-        >>> b = '''# File is user.ini
-        ...     [section1]
-        ...     option1 = False
-        ...     # end of file'''.splitlines()
-        >>> c1 = ConfigObj(b)
-        >>> c2 = ConfigObj(a)
-        >>> c2.merge(c1)
-        >>> c2
-        {'section1': {'option1': 'False', 'subsection': {'more_options': 'False'}}}
-        """
-        for key, val in indict.iteritems():
-            if (key in self and isinstance(self[key], dict) and
-                                isinstance(val, dict)):
-                self[key].merge(val)
-            else:   
-                self[key] = val
-
-
-    def rename(self, oldkey, newkey):
-        """
-        Change a keyname to another, without changing position in sequence.
-        
-        Implemented so that transformations can be made on keys,
-        as well as on values. (used by encode and decode)
-        
-        Also renames comments.
-        """
-        if oldkey in self.scalars:
-            the_list = self.scalars
-        elif oldkey in self.sections:
-            the_list = self.sections
-        else:
-            raise KeyError('Key "%s" not found.' % oldkey)
-        pos = the_list.index(oldkey)
-        #
-        val = self[oldkey]
-        dict.__delitem__(self, oldkey)
-        dict.__setitem__(self, newkey, val)
-        the_list.remove(oldkey)
-        the_list.insert(pos, newkey)
-        comm = self.comments[oldkey]
-        inline_comment = self.inline_comments[oldkey]
-        del self.comments[oldkey]
-        del self.inline_comments[oldkey]
-        self.comments[newkey] = comm
-        self.inline_comments[newkey] = inline_comment
-
-
-    def walk(self, function, raise_errors=True,
-            call_on_sections=False, **keywargs):
-        """
-        Walk every member and call a function on the keyword and value.
-        
-        Return a dictionary of the return values
-        
-        If the function raises an exception, raise the errror
-        unless ``raise_errors=False``, in which case set the return value to
-        ``False``.
-        
-        Any unrecognised keyword arguments you pass to walk, will be pased on
-        to the function you pass in.
-        
-        Note: if ``call_on_sections`` is ``True`` then - on encountering a
-        subsection, *first* the function is called for the *whole* subsection,
-        and then recurses into it's members. This means your function must be
-        able to handle strings, dictionaries and lists. This allows you
-        to change the key of subsections as well as for ordinary members. The
-        return value when called on the whole subsection has to be discarded.
-        
-        See  the encode and decode methods for examples, including functions.
-        
-        .. caution::
-        
-            You can use ``walk`` to transform the names of members of a section
-            but you mustn't add or delete members.
-        
-        >>> config = '''[XXXXsection]
-        ... XXXXkey = XXXXvalue'''.splitlines()
-        >>> cfg = ConfigObj(config)
-        >>> cfg
-        {'XXXXsection': {'XXXXkey': 'XXXXvalue'}}
-        >>> def transform(section, key):
-        ...     val = section[key]
-        ...     newkey = key.replace('XXXX', 'CLIENT1')
-        ...     section.rename(key, newkey)
-        ...     if isinstance(val, (tuple, list, dict)):
-        ...         pass
-        ...     else:
-        ...         val = val.replace('XXXX', 'CLIENT1')
-        ...         section[newkey] = val
-        >>> cfg.walk(transform, call_on_sections=True)
-        {'CLIENT1section': {'CLIENT1key': None}}
-        >>> cfg
-        {'CLIENT1section': {'CLIENT1key': 'CLIENT1value'}}
-        """
-        out = {}
-        # scalars first
-        for i in range(len(self.scalars)):
-            entry = self.scalars[i]
-            try:
-                val = function(self, entry, **keywargs)
-                # bound again in case name has changed
-                entry = self.scalars[i]
-                out[entry] = val
-            except Exception:
-                if raise_errors:
-                    raise
-                else:
-                    entry = self.scalars[i]
-                    out[entry] = False
-        # then sections
-        for i in range(len(self.sections)):
-            entry = self.sections[i]
-            if call_on_sections:
-                try:
-                    function(self, entry, **keywargs)
-                except Exception:
-                    if raise_errors:
-                        raise
-                    else:
-                        entry = self.sections[i]
-                        out[entry] = False
-                # bound again in case name has changed
-                entry = self.sections[i]
-            # previous result is discarded
-            out[entry] = self[entry].walk(
-                function,
-                raise_errors=raise_errors,
-                call_on_sections=call_on_sections,
-                **keywargs)
-        return out
-
-
-    def decode(self, encoding):
-        """
-        Decode all strings and values to unicode, using the specified encoding.
-        
-        Works with subsections and list values.
-        
-        Uses the ``walk`` method.
-        
-        Testing ``encode`` and ``decode``.
-        >>> m = ConfigObj(a)
-        >>> m.decode('ascii')
-        >>> def testuni(val):
-        ...     for entry in val:
-        ...         if not isinstance(entry, unicode):
-        ...             print >> sys.stderr, type(entry)
-        ...             raise AssertionError, 'decode failed.'
-        ...         if isinstance(val[entry], dict):
-        ...             testuni(val[entry])
-        ...         elif not isinstance(val[entry], unicode):
-        ...             raise AssertionError, 'decode failed.'
-        >>> testuni(m)
-        >>> m.encode('ascii')
-        >>> a == m
-        1
-        """
-        warn('use of ``decode`` is deprecated.', DeprecationWarning)
-        def decode(section, key, encoding=encoding, warn=True):
-            """ """
-            val = section[key]
-            if isinstance(val, (list, tuple)):
-                newval = []
-                for entry in val:
-                    newval.append(entry.decode(encoding))
-            elif isinstance(val, dict):
-                newval = val
-            else:
-                newval = val.decode(encoding)
-            newkey = key.decode(encoding)
-            section.rename(key, newkey)
-            section[newkey] = newval
-        # using ``call_on_sections`` allows us to modify section names
-        self.walk(decode, call_on_sections=True)
-
-
-    def encode(self, encoding):
-        """
-        Encode all strings and values from unicode,
-        using the specified encoding.
-        
-        Works with subsections and list values.
-        Uses the ``walk`` method.
-        """
-        warn('use of ``encode`` is deprecated.', DeprecationWarning)
-        def encode(section, key, encoding=encoding):
-            """ """
-            val = section[key]
-            if isinstance(val, (list, tuple)):
-                newval = []
-                for entry in val:
-                    newval.append(entry.encode(encoding))
-            elif isinstance(val, dict):
-                newval = val
-            else:
-                newval = val.encode(encoding)
-            newkey = key.encode(encoding)
-            section.rename(key, newkey)
-            section[newkey] = newval
-        self.walk(encode, call_on_sections=True)
-
-
-    def istrue(self, key):
-        """A deprecated version of ``as_bool``."""
-        warn('use of ``istrue`` is deprecated. Use ``as_bool`` method '
-                'instead.', DeprecationWarning)
-        return self.as_bool(key)
-
-
-    def as_bool(self, key):
-        """
-        Accepts a key as input. The corresponding value must be a string or
-        the objects (``True`` or 1) or (``False`` or 0). We allow 0 and 1 to
-        retain compatibility with Python 2.2.
-        
-        If the string is one of  ``True``, ``On``, ``Yes``, or ``1`` it returns 
-        ``True``.
-        
-        If the string is one of  ``False``, ``Off``, ``No``, or ``0`` it returns 
-        ``False``.
-        
-        ``as_bool`` is not case sensitive.
-        
-        Any other input will raise a ``ValueError``.
-        
-        >>> a = ConfigObj()
-        >>> a['a'] = 'fish'
-        >>> a.as_bool('a')
-        Traceback (most recent call last):
-        ValueError: Value "fish" is neither True nor False
-        >>> a['b'] = 'True'
-        >>> a.as_bool('b')
-        1
-        >>> a['b'] = 'off'
-        >>> a.as_bool('b')
-        0
-        """
-        val = self[key]
-        if val == True:
-            return True
-        elif val == False:
-            return False
-        else:
-            try:
-                if not isinstance(val, StringTypes):
-                    # TODO: Why do we raise a KeyError here?
-                    raise KeyError()
-                else:
-                    return self.main._bools[val.lower()]
-            except KeyError:
-                raise ValueError('Value "%s" is neither True nor False' % val)
-
-
-    def as_int(self, key):
-        """
-        A convenience method which coerces the specified value to an integer.
-        
-        If the value is an invalid literal for ``int``, a ``ValueError`` will
-        be raised.
-        
-        >>> a = ConfigObj()
-        >>> a['a'] = 'fish'
-        >>> a.as_int('a')
-        Traceback (most recent call last):
-        ValueError: invalid literal for int(): fish
-        >>> a['b'] = '1'
-        >>> a.as_int('b')
-        1
-        >>> a['b'] = '3.2'
-        >>> a.as_int('b')
-        Traceback (most recent call last):
-        ValueError: invalid literal for int(): 3.2
-        """
-        return int(self[key])
-
-
-    def as_float(self, key):
-        """
-        A convenience method which coerces the specified value to a float.
-        
-        If the value is an invalid literal for ``float``, a ``ValueError`` will
-        be raised.
-        
-        >>> a = ConfigObj()
-        >>> a['a'] = 'fish'
-        >>> a.as_float('a')
-        Traceback (most recent call last):
-        ValueError: invalid literal for float(): fish
-        >>> a['b'] = '1'
-        >>> a.as_float('b')
-        1.0
-        >>> a['b'] = '3.2'
-        >>> a.as_float('b')
-        3.2000000000000002
-        """
-        return float(self[key])
-
-
-    def restore_default(self, key):
-        """
-        Restore (and return) default value for the specified key.
-        
-        This method will only work for a ConfigObj that was created
-        with a configspec and has been validated.
-        
-        If there is no default value for this key, ``KeyError`` is raised.
-        """
-        default = self.default_values[key]
-        dict.__setitem__(self, key, default)
-        if key not in self.defaults:
-            self.defaults.append(key)
-        return default
-
-    
-    def restore_defaults(self):
-        """
-        Recursively restore default values to all members
-        that have them.
-        
-        This method will only work for a ConfigObj that was created
-        with a configspec and has been validated.
-        
-        It doesn't delete or modify entries without default values.
-        """
-        for key in self.default_values:
-            self.restore_default(key)
-            
-        for section in self.sections:
-            self[section].restore_defaults()
-
-
-class ConfigObj(Section):
-    """An object to read, create, and write config files."""
-
-    _keyword = re.compile(r'''^ # line start
-        (\s*)                   # indentation
-        (                       # keyword
-            (?:".*?")|          # double quotes
-            (?:'.*?')|          # single quotes
-            (?:[^'"=].*?)       # no quotes
-        )
-        \s*=\s*                 # divider
-        (.*)                    # value (including list values and comments)
-        $   # line end
-        ''',
-        re.VERBOSE)
-
-    _sectionmarker = re.compile(r'''^
-        (\s*)                     # 1: indentation
-        ((?:\[\s*)+)              # 2: section marker open
-        (                         # 3: section name open
-            (?:"\s*\S.*?\s*")|    # at least one non-space with double quotes
-            (?:'\s*\S.*?\s*')|    # at least one non-space with single quotes
-            (?:[^'"\s].*?)        # at least one non-space unquoted
-        )                         # section name close
-        ((?:\s*\])+)              # 4: section marker close
-        \s*(\#.*)?                # 5: optional comment
-        $''',
-        re.VERBOSE)
-
-    # this regexp pulls list values out as a single string
-    # or single values and comments
-    # FIXME: this regex adds a '' to the end of comma terminated lists
-    #   workaround in ``_handle_value``
-    _valueexp = re.compile(r'''^
-        (?:
-            (?:
-                (
-                    (?:
-                        (?:
-                            (?:".*?")|              # double quotes
-                            (?:'.*?')|              # single quotes
-                            (?:[^'",\#][^,\#]*?)    # unquoted
-                        )
-                        \s*,\s*                     # comma
-                    )*      # match all list items ending in a comma (if any)
-                )
-                (
-                    (?:".*?")|                      # double quotes
-                    (?:'.*?')|                      # single quotes
-                    (?:[^'",\#\s][^,]*?)|           # unquoted
-                    (?:(?<!,))                      # Empty value
-                )?          # last item in a list - or string value
-            )|
-            (,)             # alternatively a single comma - empty list
-        )
-        \s*(\#.*)?          # optional comment
-        $''',
-        re.VERBOSE)
-
-    # use findall to get the members of a list value
-    _listvalueexp = re.compile(r'''
-        (
-            (?:".*?")|          # double quotes
-            (?:'.*?')|          # single quotes
-            (?:[^'",\#].*?)       # unquoted
-        )
-        \s*,\s*                 # comma
-        ''',
-        re.VERBOSE)
-
-    # this regexp is used for the value
-    # when lists are switched off
-    _nolistvalue = re.compile(r'''^
-        (
-            (?:".*?")|          # double quotes
-            (?:'.*?')|          # single quotes
-            (?:[^'"\#].*?)|     # unquoted
-            (?:)                # Empty value
-        )
-        \s*(\#.*)?              # optional comment
-        $''',
-        re.VERBOSE)
-
-    # regexes for finding triple quoted values on one line
-    _single_line_single = re.compile(r"^'''(.*?)'''\s*(#.*)?$")
-    _single_line_double = re.compile(r'^"""(.*?)"""\s*(#.*)?$')
-    _multi_line_single = re.compile(r"^(.*?)'''\s*(#.*)?$")
-    _multi_line_double = re.compile(r'^(.*?)"""\s*(#.*)?$')
-
-    _triple_quote = {
-        "'''": (_single_line_single, _multi_line_single),
-        '"""': (_single_line_double, _multi_line_double),
-    }
-
-    # Used by the ``istrue`` Section method
-    _bools = {
-        'yes': True, 'no': False,
-        'on': True, 'off': False,
-        '1': True, '0': False,
-        'true': True, 'false': False,
-        }
-
-
-    def __init__(self, infile=None, options=None, **kwargs):
-        """
-        Parse a config file or create a config file object.
-        
-        ``ConfigObj(infile=None, options=None, **kwargs)``
-        """
-        # init the superclass
-        Section.__init__(self, self, 0, self)
-        
-        if infile is None:
-            infile = []
-        if options is None:
-            options = {}
-        else:
-            options = dict(options)
-            
-        # keyword arguments take precedence over an options dictionary
-        options.update(kwargs)
-        
-        defaults = OPTION_DEFAULTS.copy()
-        # TODO: check the values too.
-        for entry in options:
-            if entry not in defaults:
-                raise TypeError('Unrecognised option "%s".' % entry)
-        
-        # Add any explicit options to the defaults
-        defaults.update(options)
-        self._initialise(defaults)
-        configspec = defaults['configspec']
-        self._original_configspec = configspec
-        self._load(infile, configspec)
-        
-        
-    def _load(self, infile, configspec):
-        if isinstance(infile, StringTypes):
-            self.filename = infile
-            if os.path.isfile(infile):
-                h = open(infile, 'rb')
-                infile = h.read() or []
-                h.close()
-            elif self.file_error:
-                # raise an error if the file doesn't exist
-                raise IOError('Config file not found: "%s".' % self.filename)
-            else:
-                # file doesn't already exist
-                if self.create_empty:
-                    # this is a good test that the filename specified
-                    # isn't impossible - like on a non-existent device
-                    h = open(infile, 'w')
-                    h.write('')
-                    h.close()
-                infile = []
-                
-        elif isinstance(infile, (list, tuple)):
-            infile = list(infile)
-            
-        elif isinstance(infile, dict):
-            # initialise self
-            # the Section class handles creating subsections
-            if isinstance(infile, ConfigObj):
-                # get a copy of our ConfigObj
-                infile = infile.dict()
-                
-            for entry in infile:
-                self[entry] = infile[entry]
-            del self._errors
-            
-            if configspec is not None:
-                self._handle_configspec(configspec)
-            else:
-                self.configspec = None
-            return
-        
-        elif hasattr(infile, 'read'):
-            # This supports file like objects
-            infile = infile.read() or []
-            # needs splitting into lines - but needs doing *after* decoding
-            # in case it's not an 8 bit encoding
-        else:
-            raise TypeError('infile must be a filename, file like object, or list of lines.')
-        
-        if infile:
-            # don't do it for the empty ConfigObj
-            infile = self._handle_bom(infile)
-            # infile is now *always* a list
-            #
-            # Set the newlines attribute (first line ending it finds)
-            # and strip trailing '\n' or '\r' from lines
-            for line in infile:
-                if (not line) or (line[-1] not in ('\r', '\n', '\r\n')):
-                    continue
-                for end in ('\r\n', '\n', '\r'):
-                    if line.endswith(end):
-                        self.newlines = end
-                        break
-                break
-
-            infile = [line.rstrip('\r\n') for line in infile]
-            
-        self._parse(infile)
-        # if we had any errors, now is the time to raise them
-        if self._errors:
-            info = "at line %s." % self._errors[0].line_number
-            if len(self._errors) > 1:
-                msg = "Parsing failed with several errors.\nFirst error %s" % info
-                error = ConfigObjError(msg)
-            else:
-                error = self._errors[0]
-            # set the errors attribute; it's a list of tuples:
-            # (error_type, message, line_number)
-            error.errors = self._errors
-            # set the config attribute
-            error.config = self
-            raise error
-        # delete private attributes
-        del self._errors
-        
-        if configspec is None:
-            self.configspec = None
-        else:
-            self._handle_configspec(configspec)
-    
-    
-    def _initialise(self, options=None):
-        if options is None:
-            options = OPTION_DEFAULTS
-            
-        # initialise a few variables
-        self.filename = None
-        self._errors = []
-        self.raise_errors = options['raise_errors']
-        self.interpolation = options['interpolation']
-        self.list_values = options['list_values']
-        self.create_empty = options['create_empty']
-        self.file_error = options['file_error']
-        self.stringify = options['stringify']
-        self.indent_type = options['indent_type']
-        self.encoding = options['encoding']
-        self.default_encoding = options['default_encoding']
-        self.BOM = False
-        self.newlines = None
-        self.write_empty_values = options['write_empty_values']
-        self.unrepr = options['unrepr']
-        
-        self.initial_comment = []
-        self.final_comment = []
-        self.configspec = {}
-        
-        # Clear section attributes as well
-        Section._initialise(self)
-        
-        
-    def __repr__(self):
-        return ('ConfigObj({%s})' % 
-                ', '.join([('%s: %s' % (repr(key), repr(self[key]))) 
-                for key in (self.scalars + self.sections)]))
-    
-    
-    def _handle_bom(self, infile):
-        """
-        Handle any BOM, and decode if necessary.
-        
-        If an encoding is specified, that *must* be used - but the BOM should
-        still be removed (and the BOM attribute set).
-        
-        (If the encoding is wrongly specified, then a BOM for an alternative
-        encoding won't be discovered or removed.)
-        
-        If an encoding is not specified, UTF8 or UTF16 BOM will be detected and
-        removed. The BOM attribute will be set. UTF16 will be decoded to
-        unicode.
-        
-        NOTE: This method must not be called with an empty ``infile``.
-        
-        Specifying the *wrong* encoding is likely to cause a
-        ``UnicodeDecodeError``.
-        
-        ``infile`` must always be returned as a list of lines, but may be
-        passed in as a single string.
-        """
-        if ((self.encoding is not None) and
-            (self.encoding.lower() not in BOM_LIST)):
-            # No need to check for a BOM
-            # the encoding specified doesn't have one
-            # just decode
-            return self._decode(infile, self.encoding)
-        
-        if isinstance(infile, (list, tuple)):
-            line = infile[0]
-        else:
-            line = infile
-        if self.encoding is not None:
-            # encoding explicitly supplied
-            # And it could have an associated BOM
-            # TODO: if encoding is just UTF16 - we ought to check for both
-            # TODO: big endian and little endian versions.
-            enc = BOM_LIST[self.encoding.lower()]
-            if enc == 'utf_16':
-                # For UTF16 we try big endian and little endian
-                for BOM, (encoding, final_encoding) in BOMS.iteritems():
-                    if not final_encoding:
-                        # skip UTF8
-                        continue
-                    if infile.startswith(BOM):
-                        ### BOM discovered
-                        ##self.BOM = True
-                        # Don't need to remove BOM
-                        return self._decode(infile, encoding)
-                    
-                # If we get this far, will *probably* raise a DecodeError
-                # As it doesn't appear to start with a BOM
-                return self._decode(infile, self.encoding)
-            
-            # Must be UTF8
-            BOM = BOM_SET[enc]
-            if not line.startswith(BOM):
-                return self._decode(infile, self.encoding)
-            
-            newline = line[len(BOM):]
-            
-            # BOM removed
-            if isinstance(infile, (list, tuple)):
-                infile[0] = newline
-            else:
-                infile = newline
-            self.BOM = True
-            return self._decode(infile, self.encoding)
-        
-        # No encoding specified - so we need to check for UTF8/UTF16
-        for BOM, (encoding, final_encoding) in BOMS.iteritems():
-            if not line.startswith(BOM):
-                continue
-            else:
-                # BOM discovered
-                self.encoding = final_encoding
-                if not final_encoding:
-                    self.BOM = True
-                    # UTF8
-                    # remove BOM
-                    newline = line[len(BOM):]
-                    if isinstance(infile, (list, tuple)):
-                        infile[0] = newline
-                    else:
-                        infile = newline
-                    # UTF8 - don't decode
-                    if isinstance(infile, StringTypes):
-                        return infile.splitlines(True)
-                    else:
-                        return infile
-                # UTF16 - have to decode
-                return self._decode(infile, encoding)
-            
-        # No BOM discovered and no encoding specified, just return
-        if isinstance(infile, StringTypes):
-            # infile read from a file will be a single string
-            return infile.splitlines(True)
-        return infile
-
-
-    def _a_to_u(self, aString):
-        """Decode ASCII strings to unicode if a self.encoding is specified."""
-        if self.encoding:
-            return aString.decode('ascii')
-        else:
-            return aString
-
-
-    def _decode(self, infile, encoding):
-        """
-        Decode infile to unicode. Using the specified encoding.
-        
-        if is a string, it also needs converting to a list.
-        """
-        if isinstance(infile, StringTypes):
-            # can't be unicode
-            # NOTE: Could raise a ``UnicodeDecodeError``
-            return infile.decode(encoding).splitlines(True)
-        for i, line in enumerate(infile):
-            if not isinstance(line, unicode):
-                # NOTE: The isinstance test here handles mixed lists of unicode/string
-                # NOTE: But the decode will break on any non-string values
-                # NOTE: Or could raise a ``UnicodeDecodeError``
-                infile[i] = line.decode(encoding)
-        return infile
-
-
-    def _decode_element(self, line):
-        """Decode element to unicode if necessary."""
-        if not self.encoding:
-            return line
-        if isinstance(line, str) and self.default_encoding:
-            return line.decode(self.default_encoding)
-        return line
-
-
-    def _str(self, value):
-        """
-        Used by ``stringify`` within validate, to turn non-string values
-        into strings.
-        """
-        if not isinstance(value, StringTypes):
-            return str(value)
-        else:
-            return value
-
-
-    def _parse(self, infile):
-        """Actually parse the config file."""
-        temp_list_values = self.list_values
-        if self.unrepr:
-            self.list_values = False
-            
-        comment_list = []
-        done_start = False
-        this_section = self
-        maxline = len(infile) - 1
-        cur_index = -1
-        reset_comment = False
-        
-        while cur_index < maxline:
-            if reset_comment:
-                comment_list = []
-            cur_index += 1
-            line = infile[cur_index]
-            sline = line.strip()
-            # do we have anything on the line ?
-            if not sline or sline.startswith('#'):
-                reset_comment = False
-                comment_list.append(line)
-                continue
-            
-            if not done_start:
-                # preserve initial comment
-                self.initial_comment = comment_list
-                comment_list = []
-                done_start = True
-                
-            reset_comment = True
-            # first we check if it's a section marker
-            mat = self._sectionmarker.match(line)
-            if mat is not None:
-                # is a section line
-                (indent, sect_open, sect_name, sect_close, comment) = mat.groups()
-                if indent and (self.indent_type is None):
-                    self.indent_type = indent
-                cur_depth = sect_open.count('[')
-                if cur_depth != sect_close.count(']'):
-                    self._handle_error("Cannot compute the section depth at line %s.",
-                                       NestingError, infile, cur_index)
-                    continue
-                
-                if cur_depth < this_section.depth:
-                    # the new section is dropping back to a previous level
-                    try:
-                        parent = self._match_depth(this_section,
-                                                   cur_depth).parent
-                    except SyntaxError:
-                        self._handle_error("Cannot compute nesting level at line %s.",
-                                           NestingError, infile, cur_index)
-                        continue
-                elif cur_depth == this_section.depth:
-                    # the new section is a sibling of the current section
-                    parent = this_section.parent
-                elif cur_depth == this_section.depth + 1:
-                    # the new section is a child the current section
-                    parent = this_section
-                else:
-                    self._handle_error("Section too nested at line %s.",
-                                       NestingError, infile, cur_index)
-                    
-                sect_name = self._unquote(sect_name)
-                if parent.has_key(sect_name):
-                    self._handle_error('Duplicate section name at line %s.',
-                                       DuplicateError, infile, cur_index)
-                    continue
-                
-                # create the new section
-                this_section = Section(
-                    parent,
-                    cur_depth,
-                    self,
-                    name=sect_name)
-                parent[sect_name] = this_section
-                parent.inline_comments[sect_name] = comment
-                parent.comments[sect_name] = comment_list
-                continue
-            #
-            # it's not a section marker,
-            # so it should be a valid ``key = value`` line
-            mat = self._keyword.match(line)
-            if mat is None:
-                # it neither matched as a keyword
-                # or a section marker
-                self._handle_error(
-                    'Invalid line at line "%s".',
-                    ParseError, infile, cur_index)
-            else:
-                # is a keyword value
-                # value will include any inline comment
-                (indent, key, value) = mat.groups()
-                if indent and (self.indent_type is None):
-                    self.indent_type = indent
-                # check for a multiline value
-                if value[:3] in ['"""', "'''"]:
-                    try:
-                        (value, comment, cur_index) = self._multiline(
-                            value, infile, cur_index, maxline)
-                    except SyntaxError:
-                        self._handle_error(
-                            'Parse error in value at line %s.',
-                            ParseError, infile, cur_index)
-                        continue
-                    else:
-                        if self.unrepr:
-                            comment = ''
-                            try:
-                                value = unrepr(value)
-                            except Exception, e:
-                                if type(e) == UnknownType:
-                                    msg = 'Unknown name or type in value at line %s.'
-                                else:
-                                    msg = 'Parse error in value at line %s.'
-                                self._handle_error(msg, UnreprError, infile,
-                                    cur_index)
-                                continue
-                else:
-                    if self.unrepr:
-                        comment = ''
-                        try:
-                            value = unrepr(value)
-                        except Exception, e:
-                            if isinstance(e, UnknownType):
-                                msg = 'Unknown name or type in value at line %s.'
-                            else:
-                                msg = 'Parse error in value at line %s.'
-                            self._handle_error(msg, UnreprError, infile,
-                                cur_index)
-                            continue
-                    else:
-                        # extract comment and lists
-                        try:
-                            (value, comment) = self._handle_value(value)
-                        except SyntaxError:
-                            self._handle_error(
-                                'Parse error in value at line %s.',
-                                ParseError, infile, cur_index)
-                            continue
-                #
-                key = self._unquote(key)
-                if this_section.has_key(key):
-                    self._handle_error(
-                        'Duplicate keyword name at line %s.',
-                        DuplicateError, infile, cur_index)
-                    continue
-                # add the key.
-                # we set unrepr because if we have got this far we will never
-                # be creating a new section
-                this_section.__setitem__(key, value, unrepr=True)
-                this_section.inline_comments[key] = comment
-                this_section.comments[key] = comment_list
-                continue
-        #
-        if self.indent_type is None:
-            # no indentation used, set the type accordingly
-            self.indent_type = ''
-
-        # preserve the final comment
-        if not self and not self.initial_comment:
-            self.initial_comment = comment_list
-        elif not reset_comment:
-            self.final_comment = comment_list
-        self.list_values = temp_list_values
-
-
-    def _match_depth(self, sect, depth):
-        """
-        Given a section and a depth level, walk back through the sections
-        parents to see if the depth level matches a previous section.
-        
-        Return a reference to the right section,
-        or raise a SyntaxError.
-        """
-        while depth < sect.depth:
-            if sect is sect.parent:
-                # we've reached the top level already
-                raise SyntaxError()
-            sect = sect.parent
-        if sect.depth == depth:
-            return sect
-        # shouldn't get here
-        raise SyntaxError()
-
-
-    def _handle_error(self, text, ErrorClass, infile, cur_index):
-        """
-        Handle an error according to the error settings.
-        
-        Either raise the error or store it.
-        The error will have occured at ``cur_index``
-        """
-        line = infile[cur_index]
-        cur_index += 1
-        message = text % cur_index
-        error = ErrorClass(message, cur_index, line)
-        if self.raise_errors:
-            # raise the error - parsing stops here
-            raise error
-        # store the error
-        # reraise when parsing has finished
-        self._errors.append(error)
-
-
-    def _unquote(self, value):
-        """Return an unquoted version of a value"""
-        if (value[0] == value[-1]) and (value[0] in ('"', "'")):
-            value = value[1:-1]
-        return value
-
-
-    def _quote(self, value, multiline=True):
-        """
-        Return a safely quoted version of a value.
-        
-        Raise a ConfigObjError if the value cannot be safely quoted.
-        If multiline is ``True`` (default) then use triple quotes
-        if necessary.
-        
-        Don't quote values that don't need it.
-        Recursively quote members of a list and return a comma joined list.
-        Multiline is ``False`` for lists.
-        Obey list syntax for empty and single member lists.
-        
-        If ``list_values=False`` then the value is only quoted if it contains
-        a ``\n`` (is multiline) or '#'.
-        
-        If ``write_empty_values`` is set, and the value is an empty string, it
-        won't be quoted.
-        """
-        if multiline and self.write_empty_values and value == '':
-            # Only if multiline is set, so that it is used for values not
-            # keys, and not values that are part of a list
-            return ''
-        
-        if multiline and isinstance(value, (list, tuple)):
-            if not value:
-                return ','
-            elif len(value) == 1:
-                return self._quote(value[0], multiline=False) + ','
-            return ', '.join([self._quote(val, multiline=False)
-                for val in value])
-        if not isinstance(value, StringTypes):
-            if self.stringify:
-                value = str(value)
-            else:
-                raise TypeError('Value "%s" is not a string.' % value)
-
-        if not value:
-            return '""'
-        
-        no_lists_no_quotes = not self.list_values and '\n' not in value and '#' not in value
-        need_triple = multiline and ((("'" in value) and ('"' in value)) or ('\n' in value ))
-        hash_triple_quote = multiline and not need_triple and ("'" in value) and ('"' in value) and ('#' in value)
-        check_for_single = (no_lists_no_quotes or not need_triple) and not hash_triple_quote
-        
-        if check_for_single:
-            if not self.list_values:
-                # we don't quote if ``list_values=False``
-                quot = noquot
-            # for normal values either single or double quotes will do
-            elif '\n' in value:
-                # will only happen if multiline is off - e.g. '\n' in key
-                raise ConfigObjError('Value "%s" cannot be safely quoted.' % value)
-            elif ((value[0] not in wspace_plus) and
-                    (value[-1] not in wspace_plus) and
-                    (',' not in value)):
-                quot = noquot
-            else:
-                quot = self._get_single_quote(value)
-        else:
-            # if value has '\n' or "'" *and* '"', it will need triple quotes
-            quot = self._get_triple_quote(value)
-        
-        if quot == noquot and '#' in value and self.list_values:
-            quot = self._get_single_quote(value)
-                
-        return quot % value
-    
-    
-    def _get_single_quote(self, value):
-        if ("'" in value) and ('"' in value):
-            raise ConfigObjError('Value "%s" cannot be safely quoted.' % value)
-        elif '"' in value:
-            quot = squot
-        else:
-            quot = dquot
-        return quot
-    
-    
-    def _get_triple_quote(self, value):
-        if (value.find('"""') != -1) and (value.find("'''") != -1):
-            raise ConfigObjError('Value "%s" cannot be safely quoted.' % value)
-        if value.find('"""') == -1:
-            quot = tdquot
-        else:
-            quot = tsquot 
-        return quot
-
-
-    def _handle_value(self, value):
-        """
-        Given a value string, unquote, remove comment,
-        handle lists. (including empty and single member lists)
-        """
-        # do we look for lists in values ?
-        if not self.list_values:
-            mat = self._nolistvalue.match(value)
-            if mat is None:
-                raise SyntaxError()
-            # NOTE: we don't unquote here
-            return mat.groups()
-        #
-        mat = self._valueexp.match(value)
-        if mat is None:
-            # the value is badly constructed, probably badly quoted,
-            # or an invalid list
-            raise SyntaxError()
-        (list_values, single, empty_list, comment) = mat.groups()
-        if (list_values == '') and (single is None):
-            # change this if you want to accept empty values
-            raise SyntaxError()
-        # NOTE: note there is no error handling from here if the regex
-        # is wrong: then incorrect values will slip through
-        if empty_list is not None:
-            # the single comma - meaning an empty list
-            return ([], comment)
-        if single is not None:
-            # handle empty values
-            if list_values and not single:
-                # FIXME: the '' is a workaround because our regex now matches
-                #   '' at the end of a list if it has a trailing comma
-                single = None
-            else:
-                single = single or '""'
-                single = self._unquote(single)
-        if list_values == '':
-            # not a list value
-            return (single, comment)
-        the_list = self._listvalueexp.findall(list_values)
-        the_list = [self._unquote(val) for val in the_list]
-        if single is not None:
-            the_list += [single]
-        return (the_list, comment)
-
-
-    def _multiline(self, value, infile, cur_index, maxline):
-        """Extract the value, where we are in a multiline situation."""
-        quot = value[:3]
-        newvalue = value[3:]
-        single_line = self._triple_quote[quot][0]
-        multi_line = self._triple_quote[quot][1]
-        mat = single_line.match(value)
-        if mat is not None:
-            retval = list(mat.groups())
-            retval.append(cur_index)
-            return retval
-        elif newvalue.find(quot) != -1:
-            # somehow the triple quote is missing
-            raise SyntaxError()
-        #
-        while cur_index < maxline:
-            cur_index += 1
-            newvalue += '\n'
-            line = infile[cur_index]
-            if line.find(quot) == -1:
-                newvalue += line
-            else:
-                # end of multiline, process it
-                break
-        else:
-            # we've got to the end of the config, oops...
-            raise SyntaxError()
-        mat = multi_line.match(line)
-        if mat is None:
-            # a badly formed line
-            raise SyntaxError()
-        (value, comment) = mat.groups()
-        return (newvalue + value, comment, cur_index)
-
-
-    def _handle_configspec(self, configspec):
-        """Parse the configspec."""
-        # FIXME: Should we check that the configspec was created with the 
-        #        correct settings ? (i.e. ``list_values=False``)
-        if not isinstance(configspec, ConfigObj):
-            try:
-                configspec = ConfigObj(configspec,
-                                       raise_errors=True,
-                                       file_error=True,
-                                       list_values=False)
-            except ConfigObjError, e:
-                # FIXME: Should these errors have a reference
-                #        to the already parsed ConfigObj ?
-                raise ConfigspecError('Parsing configspec failed: %s' % e)
-            except IOError, e:
-                raise IOError('Reading configspec failed: %s' % e)
-        
-        self._set_configspec_value(configspec, self)
-
-
-    def _set_configspec_value(self, configspec, section):
-        """Used to recursively set configspec values."""
-        if '__many__' in configspec.sections:
-            section.configspec['__many__'] = configspec['__many__']
-            if len(configspec.sections) > 1:
-                # FIXME: can we supply any useful information here ?
-                raise RepeatSectionError()
-            
-        if hasattr(configspec, 'initial_comment'):
-            section._configspec_initial_comment = configspec.initial_comment
-            section._configspec_final_comment = configspec.final_comment
-            section._configspec_encoding = configspec.encoding
-            section._configspec_BOM = configspec.BOM
-            section._configspec_newlines = configspec.newlines
-            section._configspec_indent_type = configspec.indent_type
-            
-        for entry in configspec.scalars:
-            section._configspec_comments[entry] = configspec.comments[entry]
-            section._configspec_inline_comments[entry] = configspec.inline_comments[entry]
-            section.configspec[entry] = configspec[entry]
-            section._order.append(entry)
-            
-        for entry in configspec.sections:
-            if entry == '__many__':
-                continue
-            
-            section._cs_section_comments[entry] = configspec.comments[entry]
-            section._cs_section_inline_comments[entry] = configspec.inline_comments[entry]
-            if not section.has_key(entry):
-                section[entry] = {}
-            self._set_configspec_value(configspec[entry], section[entry])
-
-
-    def _handle_repeat(self, section, configspec):
-        """Dynamically assign configspec for repeated section."""
-        try:
-            section_keys = configspec.sections
-            scalar_keys = configspec.scalars
-        except AttributeError:
-            section_keys = [entry for entry in configspec 
-                                if isinstance(configspec[entry], dict)]
-            scalar_keys = [entry for entry in configspec 
-                                if not isinstance(configspec[entry], dict)]
-            
-        if '__many__' in section_keys and len(section_keys) > 1:
-            # FIXME: can we supply any useful information here ?
-            raise RepeatSectionError()
-        
-        scalars = {}
-        sections = {}
-        for entry in scalar_keys:
-            val = configspec[entry]
-            scalars[entry] = val
-        for entry in section_keys:
-            val = configspec[entry]
-            if entry == '__many__':
-                scalars[entry] = val
-                continue
-            sections[entry] = val
-            
-        section.configspec = scalars
-        for entry in sections:
-            if not section.has_key(entry):
-                section[entry] = {}
-            self._handle_repeat(section[entry], sections[entry])
-
-
-    def _write_line(self, indent_string, entry, this_entry, comment):
-        """Write an individual line, for the write method"""
-        # NOTE: the calls to self._quote here handles non-StringType values.
-        if not self.unrepr:
-            val = self._decode_element(self._quote(this_entry))
-        else:
-            val = repr(this_entry)
-        return '%s%s%s%s%s' % (indent_string,
-                               self._decode_element(self._quote(entry, multiline=False)),
-                               self._a_to_u(' = '),
-                               val,
-                               self._decode_element(comment))
-
-
-    def _write_marker(self, indent_string, depth, entry, comment):
-        """Write a section marker line"""
-        return '%s%s%s%s%s' % (indent_string,
-                               self._a_to_u('[' * depth),
-                               self._quote(self._decode_element(entry), multiline=False),
-                               self._a_to_u(']' * depth),
-                               self._decode_element(comment))
-
-
-    def _handle_comment(self, comment):
-        """Deal with a comment."""
-        if not comment:
-            return ''
-        start = self.indent_type
-        if not comment.startswith('#'):
-            start += self._a_to_u(' # ')
-        return (start + comment)
-
-
-    # Public methods
-
-    def write(self, outfile=None, section=None):
-        """
-        Write the current ConfigObj as a file
-        
-        tekNico: FIXME: use StringIO instead of real files
-        
-        >>> filename = a.filename
-        >>> a.filename = 'test.ini'
-        >>> a.write()
-        >>> a.filename = filename
-        >>> a == ConfigObj('test.ini', raise_errors=True)
-        1
-        """
-        if self.indent_type is None:
-            # this can be true if initialised from a dictionary
-            self.indent_type = DEFAULT_INDENT_TYPE
-            
-        out = []
-        cs = self._a_to_u('#')
-        csp = self._a_to_u('# ')
-        if section is None:
-            int_val = self.interpolation
-            self.interpolation = False
-            section = self
-            for line in self.initial_comment:
-                line = self._decode_element(line)
-                stripped_line = line.strip()
-                if stripped_line and not stripped_line.startswith(cs):
-                    line = csp + line
-                out.append(line)
-                
-        indent_string = self.indent_type * section.depth
-        for entry in (section.scalars + section.sections):
-            if entry in section.defaults:
-                # don't write out default values
-                continue
-            for comment_line in section.comments[entry]:
-                comment_line = self._decode_element(comment_line.lstrip())
-                if comment_line and not comment_line.startswith(cs):
-                    comment_line = csp + comment_line
-                out.append(indent_string + comment_line)
-            this_entry = section[entry]
-            comment = self._handle_comment(section.inline_comments[entry])
-            
-            if isinstance(this_entry, dict):
-                # a section
-                out.append(self._write_marker(
-                    indent_string,
-                    this_entry.depth,
-                    entry,
-                    comment))
-                out.extend(self.write(section=this_entry))
-            else:
-                out.append(self._write_line(
-                    indent_string,
-                    entry,
-                    this_entry,
-                    comment))
-                
-        if section is self:
-            for line in self.final_comment:
-                line = self._decode_element(line)
-                stripped_line = line.strip()
-                if stripped_line and not stripped_line.startswith(cs):
-                    line = csp + line
-                out.append(line)
-            self.interpolation = int_val
-            
-        if section is not self:
-            return out
-        
-        if (self.filename is None) and (outfile is None):
-            # output a list of lines
-            # might need to encode
-            # NOTE: This will *screw* UTF16, each line will start with the BOM
-            if self.encoding:
-                out = [l.encode(self.encoding) for l in out]
-            if (self.BOM and ((self.encoding is None) or
-                (BOM_LIST.get(self.encoding.lower()) == 'utf_8'))):
-                # Add the UTF8 BOM
-                if not out:
-                    out.append('')
-                out[0] = BOM_UTF8 + out[0]
-            return out
-        
-        # Turn the list to a string, joined with correct newlines
-        newline = self.newlines or os.linesep
-        output = self._a_to_u(newline).join(out)
-        if self.encoding:
-            output = output.encode(self.encoding)
-        if self.BOM and ((self.encoding is None) or match_utf8(self.encoding)):
-            # Add the UTF8 BOM
-            output = BOM_UTF8 + output
-            
-        if not output.endswith(newline):
-            output += newline
-        if outfile is not None:
-            outfile.write(output)
-        else:
-            h = open(self.filename, 'wb')
-            h.write(output)
-            h.close()
-
-
-    def validate(self, validator, preserve_errors=False, copy=False,
-                 section=None):
-        """
-        Test the ConfigObj against a configspec.
-        
-        It uses the ``validator`` object from *validate.py*.
-        
-        To run ``validate`` on the current ConfigObj, call: ::
-        
-            test = config.validate(validator)
-        
-        (Normally having previously passed in the configspec when the ConfigObj
-        was created - you can dynamically assign a dictionary of checks to the
-        ``configspec`` attribute of a section though).
-        
-        It returns ``True`` if everything passes, or a dictionary of
-        pass/fails (True/False). If every member of a subsection passes, it
-        will just have the value ``True``. (It also returns ``False`` if all
-        members fail).
-        
-        In addition, it converts the values from strings to their native
-        types if their checks pass (and ``stringify`` is set).
-        
-        If ``preserve_errors`` is ``True`` (``False`` is default) then instead
-        of a marking a fail with a ``False``, it will preserve the actual
-        exception object. This can contain info about the reason for failure.
-        For example the ``VdtValueTooSmallError`` indicates that the value
-        supplied was too small. If a value (or section) is missing it will
-        still be marked as ``False``.
-        
-        You must have the validate module to use ``preserve_errors=True``.
-        
-        You can then use the ``flatten_errors`` function to turn your nested
-        results dictionary into a flattened list of failures - useful for
-        displaying meaningful error messages.
-        """
-        if section is None:
-            if self.configspec is None:
-                raise ValueError('No configspec supplied.')
-            if preserve_errors:
-                # We do this once to remove a top level dependency on the validate module
-                # Which makes importing configobj faster
-                from validate import VdtMissingValue
-                self._vdtMissingValue = VdtMissingValue
-            section = self
-        #
-        spec_section = section.configspec
-        if copy and hasattr(section, '_configspec_initial_comment'):
-            section.initial_comment = section._configspec_initial_comment
-            section.final_comment = section._configspec_final_comment
-            section.encoding = section._configspec_encoding
-            section.BOM = section._configspec_BOM
-            section.newlines = section._configspec_newlines
-            section.indent_type = section._configspec_indent_type
-            
-        if '__many__' in section.configspec:
-            many = spec_section['__many__']
-            # dynamically assign the configspecs
-            # for the sections below
-            for entry in section.sections:
-                self._handle_repeat(section[entry], many)
-        #
-        out = {}
-        ret_true = True
-        ret_false = True
-        order = [k for k in section._order if k in spec_section]
-        order += [k for k in spec_section if k not in order]
-        for entry in order:
-            if entry == '__many__':
-                continue
-            if (not entry in section.scalars) or (entry in section.defaults):
-                # missing entries
-                # or entries from defaults
-                missing = True
-                val = None
-                if copy and not entry in section.scalars:
-                    # copy comments
-                    section.comments[entry] = (
-                        section._configspec_comments.get(entry, []))
-                    section.inline_comments[entry] = (
-                        section._configspec_inline_comments.get(entry, ''))
-                #
-            else:
-                missing = False
-                val = section[entry]
-            try:
-                check = validator.check(spec_section[entry],
-                                        val,
-                                        missing=missing
-                                        )
-            except validator.baseErrorClass, e:
-                if not preserve_errors or isinstance(e, self._vdtMissingValue):
-                    out[entry] = False
-                else:
-                    # preserve the error
-                    out[entry] = e
-                    ret_false = False
-                ret_true = False
-            else:
-                try: 
-                    section.default_values.pop(entry, None)
-                except AttributeError: 
-                    # For Python 2.2 compatibility
-                    try:
-                        del section.default_values[entry]
-                    except KeyError:
-                        pass
-                    
-                if hasattr(validator, 'get_default_value'):
-                    try: 
-                        section.default_values[entry] = validator.get_default_value(spec_section[entry])
-                    except KeyError:
-                        # No default
-                        pass
-                    
-                ret_false = False
-                out[entry] = True
-                if self.stringify or missing:
-                    # if we are doing type conversion
-                    # or the value is a supplied default
-                    if not self.stringify:
-                        if isinstance(check, (list, tuple)):
-                            # preserve lists
-                            check = [self._str(item) for item in check]
-                        elif missing and check is None:
-                            # convert the None from a default to a ''
-                            check = ''
-                        else:
-                            check = self._str(check)
-                    if (check != val) or missing:
-                        section[entry] = check
-                if not copy and missing and entry not in section.defaults:
-                    section.defaults.append(entry)
-        # Missing sections will have been created as empty ones when the
-        # configspec was read.
-        for entry in section.sections:
-            # FIXME: this means DEFAULT is not copied in copy mode
-            if section is self and entry == 'DEFAULT':
-                continue
-            if copy:
-                section.comments[entry] = section._cs_section_comments[entry]
-                section.inline_comments[entry] = (
-                    section._cs_section_inline_comments[entry])
-            check = self.validate(validator, preserve_errors=preserve_errors,
-                copy=copy, section=section[entry])
-            out[entry] = check
-            if check == False:
-                ret_true = False
-            elif check == True:
-                ret_false = False
-            else:
-                ret_true = False
-                ret_false = False
-        #
-        if ret_true:
-            return True
-        elif ret_false:
-            return False
-        return out
-
-
-    def reset(self):
-        """Clear ConfigObj instance and restore to 'freshly created' state."""
-        self.clear()
-        self._initialise()
-        # FIXME: Should be done by '_initialise', but ConfigObj constructor (and reload)
-        #        requires an empty dictionary
-        self.configspec = None
-        # Just to be sure ;-)
-        self._original_configspec = None
-        
-        
-    def reload(self):
-        """
-        Reload a ConfigObj from file.
-        
-        This method raises a ``ReloadError`` if the ConfigObj doesn't have
-        a filename attribute pointing to a file.
-        """
-        if not isinstance(self.filename, StringTypes):
-            raise ReloadError()
-
-        filename = self.filename
-        current_options = {}
-        for entry in OPTION_DEFAULTS:
-            if entry == 'configspec':
-                continue
-            current_options[entry] = getattr(self, entry)
-            
-        configspec = self._original_configspec
-        current_options['configspec'] = configspec
-            
-        self.clear()
-        self._initialise(current_options)
-        self._load(filename, configspec)
-        
-
-
-class SimpleVal(object):
-    """
-    A simple validator.
-    Can be used to check that all members expected are present.
-    
-    To use it, provide a configspec with all your members in (the value given
-    will be ignored). Pass an instance of ``SimpleVal`` to the ``validate``
-    method of your ``ConfigObj``. ``validate`` will return ``True`` if all
-    members are present, or a dictionary with True/False meaning
-    present/missing. (Whole missing sections will be replaced with ``False``)
-    """
-    
-    def __init__(self):
-        self.baseErrorClass = ConfigObjError
-    
-    def check(self, check, member, missing=False):
-        """A dummy check method, always returns the value unchanged."""
-        if missing:
-            raise self.baseErrorClass()
-        return member
-
-
-# Check / processing functions for options
-def flatten_errors(cfg, res, levels=None, results=None):
-    """
-    An example function that will turn a nested dictionary of results
-    (as returned by ``ConfigObj.validate``) into a flat list.
-    
-    ``cfg`` is the ConfigObj instance being checked, ``res`` is the results
-    dictionary returned by ``validate``.
-    
-    (This is a recursive function, so you shouldn't use the ``levels`` or
-    ``results`` arguments - they are used by the function.
-    
-    Returns a list of keys that failed. Each member of the list is a tuple :
-    ::
-    
-        ([list of sections...], key, result)
-    
-    If ``validate`` was called with ``preserve_errors=False`` (the default)
-    then ``result`` will always be ``False``.
-
-    *list of sections* is a flattened list of sections that the key was found
-    in.
-    
-    If the section was missing then key will be ``None``.
-    
-    If the value (or section) was missing then ``result`` will be ``False``.
-    
-    If ``validate`` was called with ``preserve_errors=True`` and a value
-    was present, but failed the check, then ``result`` will be the exception
-    object returned. You can use this as a string that describes the failure.
-    
-    For example *The value "3" is of the wrong type*.
-    
-    >>> import validate
-    >>> vtor = validate.Validator()
-    >>> my_ini = '''
-    ...     option1 = True
-    ...     [section1]
-    ...     option1 = True
-    ...     [section2]
-    ...     another_option = Probably
-    ...     [section3]
-    ...     another_option = True
-    ...     [[section3b]]
-    ...     value = 3
-    ...     value2 = a
-    ...     value3 = 11
-    ...     '''
-    >>> my_cfg = '''
-    ...     option1 = boolean()
-    ...     option2 = boolean()
-    ...     option3 = boolean(default=Bad_value)
-    ...     [section1]
-    ...     option1 = boolean()
-    ...     option2 = boolean()
-    ...     option3 = boolean(default=Bad_value)
-    ...     [section2]
-    ...     another_option = boolean()
-    ...     [section3]
-    ...     another_option = boolean()
-    ...     [[section3b]]
-    ...     value = integer
-    ...     value2 = integer
-    ...     value3 = integer(0, 10)
-    ...         [[[section3b-sub]]]
-    ...         value = string
-    ...     [section4]
-    ...     another_option = boolean()
-    ...     '''
-    >>> cs = my_cfg.split('\\n')
-    >>> ini = my_ini.split('\\n')
-    >>> cfg = ConfigObj(ini, configspec=cs)
-    >>> res = cfg.validate(vtor, preserve_errors=True)
-    >>> errors = []
-    >>> for entry in flatten_errors(cfg, res):
-    ...     section_list, key, error = entry
-    ...     section_list.insert(0, '[root]')
-    ...     if key is not None:
-    ...        section_list.append(key)
-    ...     else:
-    ...         section_list.append('[missing]')
-    ...     section_string = ', '.join(section_list)
-    ...     errors.append((section_string, ' = ', error))
-    >>> errors.sort()
-    >>> for entry in errors:
-    ...     print entry[0], entry[1], (entry[2] or 0)
-    [root], option2  =  0
-    [root], option3  =  the value "Bad_value" is of the wrong type.
-    [root], section1, option2  =  0
-    [root], section1, option3  =  the value "Bad_value" is of the wrong type.
-    [root], section2, another_option  =  the value "Probably" is of the wrong type.
-    [root], section3, section3b, section3b-sub, [missing]  =  0
-    [root], section3, section3b, value2  =  the value "a" is of the wrong type.
-    [root], section3, section3b, value3  =  the value "11" is too big.
-    [root], section4, [missing]  =  0
-    """
-    if levels is None:
-        # first time called
-        levels = []
-        results = []
-    if res is True:
-        return results
-    if res is False:
-        results.append((levels[:], None, False))
-        if levels:
-            levels.pop()
-        return results
-    for (key, val) in res.iteritems():
-        if val == True:
-            continue
-        if isinstance(cfg.get(key), dict):
-            # Go down one level
-            levels.append(key)
-            flatten_errors(cfg[key], val, levels, results)
-            continue
-        results.append((levels[:], key, val))
-    #
-    # Go up one level
-    if levels:
-        levels.pop()
-    #
-    return results
-
-
-"""*A programming language is a medium of expression.* - Paul Graham"""
diff --git a/IPython/external/decorator/__init__.py b/IPython/external/decorator/__init__.py
deleted file mode 100644
index df568fb1b7d..00000000000
--- a/IPython/external/decorator/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-try:
-    from decorator import *
-    from decorator import getinfo, new_wrapper
-    # the following funcion is deprecated so using the python own one
-    from functools import update_wrapper
-except ImportError:
-    from _decorator import *
-    from _decorator import getinfo, update_wrapper, new_wrapper
diff --git a/IPython/external/decorator/_decorator.py b/IPython/external/decorator/_decorator.py
deleted file mode 100644
index e4b1ce77ac1..00000000000
--- a/IPython/external/decorator/_decorator.py
+++ /dev/null
@@ -1,254 +0,0 @@
-##########################     LICENCE     ###############################
-##
-##   Copyright (c) 2005, Michele Simionato
-##   All rights reserved.
-##
-##   Redistributions of source code must retain the above copyright 
-##   notice, this list of conditions and the following disclaimer.
-##   Redistributions in bytecode form must reproduce the above copyright
-##   notice, this list of conditions and the following disclaimer in
-##   the documentation and/or other materials provided with the
-##   distribution. 
-
-##   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-##   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-##   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-##   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-##   HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-##   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-##   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-##   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-##   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-##   TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-##   USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-##   DAMAGE.
-
-"""
-Decorator module, see http://pypi.python.org/pypi/decorator
-for the documentation.
-"""
-
-__all__ = ["decorator", "FunctionMaker", "partial",
-           "deprecated", "getinfo", "new_wrapper"]
-
-import os, sys, re, inspect, string, warnings
-try:
-    from functools import partial
-except ImportError: # for Python version < 2.5
-    class partial(object):
-        "A simple replacement of functools.partial"
-        def __init__(self, func, *args, **kw):
-            self.func = func
-            self.args = args                
-            self.keywords = kw
-        def __call__(self, *otherargs, **otherkw):
-            kw = self.keywords.copy()
-            kw.update(otherkw)
-            return self.func(*(self.args + otherargs), **kw)
-
-DEF = re.compile('\s*def\s*([_\w][_\w\d]*)\s*\(')
-
-# basic functionality
-class FunctionMaker(object):
-    """
-    An object with the ability to create functions with a given signature.
-    It has attributes name, doc, module, signature, defaults, dict and
-    methods update and make.
-    """
-    def __init__(self, func=None, name=None, signature=None,
-                 defaults=None, doc=None, module=None, funcdict=None):
-        if func:
-            # func can be a class or a callable, but not an instance method
-            self.name = func.__name__
-            if self.name == '<lambda>': # small hack for lambda functions
-                self.name = '_lambda_' 
-            self.doc = func.__doc__
-            self.module = func.__module__
-            if inspect.isfunction(func):
-                argspec = inspect.getargspec(func)
-                self.args, self.varargs, self.keywords, self.defaults = argspec
-                for i, arg in enumerate(self.args):
-                    setattr(self, 'arg%d' % i, arg)
-                self.signature = inspect.formatargspec(
-                    formatvalue=lambda val: "", *argspec)[1:-1]
-                self.dict = func.__dict__.copy()
-        if name:
-            self.name = name
-        if signature is not None:
-            self.signature = signature
-        if defaults:
-            self.defaults = defaults
-        if doc:
-            self.doc = doc
-        if module:
-            self.module = module
-        if funcdict:
-            self.dict = funcdict
-        # check existence required attributes
-        assert hasattr(self, 'name')
-        if not hasattr(self, 'signature'):
-            raise TypeError('You are decorating a non function: %s' % func)
-
-    def update(self, func, **kw):
-        "Update the signature of func with the data in self"
-        func.__name__ = self.name
-        func.__doc__ = getattr(self, 'doc', None)
-        func.__dict__ = getattr(self, 'dict', {})
-        func.func_defaults = getattr(self, 'defaults', ())
-        callermodule = sys._getframe(3).f_globals.get('__name__', '?')
-        func.__module__ = getattr(self, 'module', callermodule)
-        func.__dict__.update(kw)
-
-    def make(self, src_templ, evaldict=None, addsource=False, **attrs):
-        "Make a new function from a given template and update the signature"
-        src = src_templ % vars(self) # expand name and signature
-        evaldict = evaldict or {}
-        mo = DEF.match(src)
-        if mo is None:
-            raise SyntaxError('not a valid function template\n%s' % src)
-        name = mo.group(1) # extract the function name
-        reserved_names = set([name] + [
-            arg.strip(' *') for arg in self.signature.split(',')])
-        for n, v in evaldict.iteritems():
-            if n in reserved_names:
-                raise NameError('%s is overridden in\n%s' % (n, src))
-        if not src.endswith('\n'): # add a newline just for safety
-            src += '\n'
-        try:
-            code = compile(src, '<string>', 'single')
-            exec code in evaldict
-        except:
-            print >> sys.stderr, 'Error in generated code:'
-            print >> sys.stderr, src
-            raise
-        func = evaldict[name]
-        if addsource:
-            attrs['__source__'] = src
-        self.update(func, **attrs)
-        return func
-
-    @classmethod
-    def create(cls, obj, body, evaldict, defaults=None,
-               doc=None, module=None, addsource=True,**attrs):
-        """
-        Create a function from the strings name, signature and body.
-        evaldict is the evaluation dictionary. If addsource is true an attribute
-        __source__ is added to the result. The attributes attrs are added,
-        if any.
-        """
-        if isinstance(obj, str): # "name(signature)"
-            name, rest = obj.strip().split('(', 1)
-            signature = rest[:-1] #strip a right parens            
-            func = None
-        else: # a function
-            name = None
-            signature = None
-            func = obj
-        fun = cls(func, name, signature, defaults, doc, module)
-        ibody = '\n'.join('    ' + line for line in body.splitlines())
-        return fun.make('def %(name)s(%(signature)s):\n' + ibody, 
-                        evaldict, addsource, **attrs)
-  
-def decorator(caller, func=None):
-    """
-    decorator(caller) converts a caller function into a decorator;
-    decorator(caller, func) decorates a function using a caller.
-    """
-    if func is not None: # returns a decorated function
-        return FunctionMaker.create(
-            func, "return _call_(_func_, %(signature)s)",
-            dict(_call_=caller, _func_=func), undecorated=func)
-    else: # returns a decorator
-        if isinstance(caller, partial):
-            return partial(decorator, caller)
-        # otherwise assume caller is a function
-        f = inspect.getargspec(caller)[0][0] # first arg
-        return FunctionMaker.create(
-            '%s(%s)' % (caller.__name__, f), 
-            'return decorator(_call_, %s)' % f,
-            dict(_call_=caller, decorator=decorator), undecorated=caller,
-            doc=caller.__doc__, module=caller.__module__)
-
-###################### deprecated functionality #########################
-
-@decorator
-def deprecated(func, *args, **kw):
-    "A decorator for deprecated functions"
-    warnings.warn(
-        ('Calling the deprecated function %r\n'
-         'Downgrade to decorator 2.3 if you want to use this functionality')
-        % func.__name__, DeprecationWarning, stacklevel=3)
-    return func(*args, **kw)
-
-@deprecated
-def getinfo(func):
-    """
-    Returns an info dictionary containing:
-    - name (the name of the function : str)
-    - argnames (the names of the arguments : list)
-    - defaults (the values of the default arguments : tuple)
-    - signature (the signature : str)
-    - doc (the docstring : str)
-    - module (the module name : str)
-    - dict (the function __dict__ : str)
-    
-    >>> def f(self, x=1, y=2, *args, **kw): pass
-
-    >>> info = getinfo(f)
-
-    >>> info["name"]
-    'f'
-    >>> info["argnames"]
-    ['self', 'x', 'y', 'args', 'kw']
-    
-    >>> info["defaults"]
-    (1, 2)
-
-    >>> info["signature"]
-    'self, x, y, *args, **kw'
-    """
-    assert inspect.ismethod(func) or inspect.isfunction(func)
-    regargs, varargs, varkwargs, defaults = inspect.getargspec(func)
-    argnames = list(regargs)
-    if varargs:
-        argnames.append(varargs)
-    if varkwargs:
-        argnames.append(varkwargs)
-    signature = inspect.formatargspec(regargs, varargs, varkwargs, defaults,
-                                      formatvalue=lambda value: "")[1:-1]
-    return dict(name=func.__name__, argnames=argnames, signature=signature,
-                defaults = func.func_defaults, doc=func.__doc__,
-                module=func.__module__, dict=func.__dict__,
-                globals=func.func_globals, closure=func.func_closure)
-
-@deprecated
-def update_wrapper(wrapper, model, infodict=None):
-    "A replacement for functools.update_wrapper"
-    infodict = infodict or getinfo(model)
-    wrapper.__name__ = infodict['name']
-    wrapper.__doc__ = infodict['doc']
-    wrapper.__module__ = infodict['module']
-    wrapper.__dict__.update(infodict['dict'])
-    wrapper.func_defaults = infodict['defaults']
-    wrapper.undecorated = model
-    return wrapper
-
-@deprecated
-def new_wrapper(wrapper, model):
-    """
-    An improvement over functools.update_wrapper. The wrapper is a generic
-    callable object. It works by generating a copy of the wrapper with the 
-    right signature and by updating the copy, not the original.
-    Moreovoer, 'model' can be a dictionary with keys 'name', 'doc', 'module',
-    'dict', 'defaults'.
-    """
-    if isinstance(model, dict):
-        infodict = model
-    else: # assume model is a function
-        infodict = getinfo(model)
-    assert not '_wrapper_' in infodict["argnames"], (
-        '"_wrapper_" is a reserved argument name!')
-    src = "lambda %(signature)s: _wrapper_(%(signature)s)" % infodict
-    funcopy = eval(src, dict(_wrapper_=wrapper))
-    return update_wrapper(funcopy, model, infodict)
-
diff --git a/IPython/external/decorators/__init__.py b/IPython/external/decorators/__init__.py
deleted file mode 100644
index 64018934042..00000000000
--- a/IPython/external/decorators/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-try:
-    from numpy.testing.decorators import *
-    from numpy.testing.noseclasses import KnownFailure
-except ImportError:
-    from _decorators import *
-    try:
-        from _numpy_testing_noseclasses import KnownFailure
-    except ImportError:
-        pass
diff --git a/IPython/external/decorators/_decorators.py b/IPython/external/decorators/_decorators.py
deleted file mode 100644
index 3698a98914a..00000000000
--- a/IPython/external/decorators/_decorators.py
+++ /dev/null
@@ -1,281 +0,0 @@
-"""
-Decorators for labeling and modifying behavior of test objects.
-
-Decorators that merely return a modified version of the original
-function object are straightforward. Decorators that return a new
-function object need to use
-::
-
-  nose.tools.make_decorator(original_function)(decorator)
-
-in returning the decorator, in order to preserve meta-data such as
-function name, setup and teardown functions and so on - see
-``nose.tools`` for more information.
-
-"""
-import warnings
-
-# IPython changes: make this work if numpy not available
-# Original code:
-#from numpy.testing.utils import \
-#        WarningManager, WarningMessage
-# Our version:
-from _numpy_testing_utils import WarningManager
-try:
-    from _numpy_testing_noseclasses import KnownFailureTest
-except:
-    pass
-
-# End IPython changes
-
-def slow(t):
-    """
-    Label a test as 'slow'.
-
-    The exact definition of a slow test is obviously both subjective and
-    hardware-dependent, but in general any individual test that requires more
-    than a second or two should be labeled as slow (the whole suite consists of
-    thousands of tests, so even a second is significant).
-
-    Parameters
-    ----------
-    t : callable
-        The test to label as slow.
-
-    Returns
-    -------
-    t : callable
-        The decorated test `t`.
-
-    Examples
-    --------
-    The `numpy.testing` module includes ``import decorators as dec``.
-    A test can be decorated as slow like this::
-
-      from numpy.testing import *
-
-      @dec.slow
-      def test_big(self):
-          print 'Big, slow test'
-
-    """
-
-    t.slow = True
-    return t
-
-def setastest(tf=True):
-    """
-    Signals to nose that this function is or is not a test.
-
-    Parameters
-    ----------
-    tf : bool
-        If True, specifies that the decorated callable is a test.
-        If False, specifies that the decorated callable is not a test.
-        Default is True.
-
-    Notes
-    -----
-    This decorator can't use the nose namespace, because it can be
-    called from a non-test module. See also ``istest`` and ``nottest`` in
-    ``nose.tools``.
-
-    Examples
-    --------
-    `setastest` can be used in the following way::
-
-      from numpy.testing.decorators import setastest
-
-      @setastest(False)
-      def func_with_test_in_name(arg1, arg2):
-          pass
-
-    """
-    def set_test(t):
-        t.__test__ = tf
-        return t
-    return set_test
-
-def skipif(skip_condition, msg=None):
-    """
-    Make function raise SkipTest exception if a given condition is true.
-
-    If the condition is a callable, it is used at runtime to dynamically
-    make the decision. This is useful for tests that may require costly
-    imports, to delay the cost until the test suite is actually executed.
-
-    Parameters
-    ----------
-    skip_condition : bool or callable
-        Flag to determine whether to skip the decorated test.
-    msg : str, optional
-        Message to give on raising a SkipTest exception. Default is None.
-
-    Returns
-    -------
-    decorator : function
-        Decorator which, when applied to a function, causes SkipTest
-        to be raised when `skip_condition` is True, and the function
-        to be called normally otherwise.
-
-    Notes
-    -----
-    The decorator itself is decorated with the ``nose.tools.make_decorator``
-    function in order to transmit function name, and various other metadata.
-
-    """
-
-    def skip_decorator(f):
-        # Local import to avoid a hard nose dependency and only incur the
-        # import time overhead at actual test-time.
-        import nose
-
-        # Allow for both boolean or callable skip conditions.
-        if callable(skip_condition):
-            skip_val = lambda : skip_condition()
-        else:
-            skip_val = lambda : skip_condition
-
-        def get_msg(func,msg=None):
-            """Skip message with information about function being skipped."""
-            if msg is None: 
-                out = 'Test skipped due to test condition'
-            else: 
-                out = '\n'+msg
-
-            return "Skipping test: %s%s" % (func.__name__,out)
-
-        # We need to define *two* skippers because Python doesn't allow both
-        # return with value and yield inside the same function.
-        def skipper_func(*args, **kwargs):
-            """Skipper for normal test functions."""
-            if skip_val():
-                raise nose.SkipTest(get_msg(f,msg))
-            else:
-                return f(*args, **kwargs)
-
-        def skipper_gen(*args, **kwargs):
-            """Skipper for test generators."""
-            if skip_val():
-                raise nose.SkipTest(get_msg(f,msg))
-            else:
-                for x in f(*args, **kwargs):
-                    yield x
-
-        # Choose the right skipper to use when building the actual decorator.
-        if nose.util.isgenerator(f):
-            skipper = skipper_gen
-        else:
-            skipper = skipper_func
-            
-        return nose.tools.make_decorator(f)(skipper)
-
-    return skip_decorator
-
-def knownfailureif(fail_condition, msg=None):
-    """
-    Make function raise KnownFailureTest exception if given condition is true.
-
-    If the condition is a callable, it is used at runtime to dynamically
-    make the decision. This is useful for tests that may require costly
-    imports, to delay the cost until the test suite is actually executed.
-
-    Parameters
-    ----------
-    fail_condition : bool or callable
-        Flag to determine whether to mark the decorated test as a known
-        failure (if True) or not (if False).
-    msg : str, optional
-        Message to give on raising a KnownFailureTest exception.
-        Default is None.
-
-    Returns
-    -------
-    decorator : function
-        Decorator, which, when applied to a function, causes SkipTest
-        to be raised when `skip_condition` is True, and the function
-        to be called normally otherwise.
-
-    Notes
-    -----
-    The decorator itself is decorated with the ``nose.tools.make_decorator``
-    function in order to transmit function name, and various other metadata.
-
-    """
-    if msg is None:
-        msg = 'Test skipped due to known failure'
-
-    # Allow for both boolean or callable known failure conditions.
-    if callable(fail_condition):
-        fail_val = lambda : fail_condition()
-    else:
-        fail_val = lambda : fail_condition
-
-    def knownfail_decorator(f):
-        # Local import to avoid a hard nose dependency and only incur the
-        # import time overhead at actual test-time.
-        import nose
-        def knownfailer(*args, **kwargs):
-            if fail_val():
-                raise KnownFailureTest, msg
-            else:
-                return f(*args, **kwargs)
-        return nose.tools.make_decorator(f)(knownfailer)
-
-    return knownfail_decorator
-
-def deprecated(conditional=True):
-    """
-    Filter deprecation warnings while running the test suite.
-
-    This decorator can be used to filter DeprecationWarning's, to avoid
-    printing them during the test suite run, while checking that the test
-    actually raises a DeprecationWarning.
-
-    Parameters
-    ----------
-    conditional : bool or callable, optional
-        Flag to determine whether to mark test as deprecated or not. If the
-        condition is a callable, it is used at runtime to dynamically make the
-        decision. Default is True.
-
-    Returns
-    -------
-    decorator : function
-        The `deprecated` decorator itself.
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    """
-    def deprecate_decorator(f):
-        # Local import to avoid a hard nose dependency and only incur the
-        # import time overhead at actual test-time.
-        import nose
-
-        def _deprecated_imp(*args, **kwargs):
-            # Poor man's replacement for the with statement
-            ctx = WarningManager(record=True)
-            l = ctx.__enter__()
-            warnings.simplefilter('always')
-            try:
-                f(*args, **kwargs)
-                if not len(l) > 0:
-                    raise AssertionError("No warning raised when calling %s"
-                            % f.__name__)
-                if not l[0].category is DeprecationWarning:
-                    raise AssertionError("First warning for %s is not a " \
-                            "DeprecationWarning( is %s)" % (f.__name__, l[0]))
-            finally:
-                ctx.__exit__()
-
-        if callable(conditional):
-            cond = conditional()
-        else:
-            cond = conditional
-        if cond:
-            return nose.tools.make_decorator(f)(_deprecated_imp)
-        else:
-            return f
-    return deprecate_decorator
diff --git a/IPython/external/decorators/_numpy_testing_noseclasses.py b/IPython/external/decorators/_numpy_testing_noseclasses.py
deleted file mode 100644
index ca6ccd87bbc..00000000000
--- a/IPython/external/decorators/_numpy_testing_noseclasses.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# IPython: modified copy of numpy.testing.noseclasses, so
-# IPython.external._decorators works without numpy being installed.
-
-# These classes implement a "known failure" error class.
-
-import os
-
-from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin
-
-class KnownFailureTest(Exception):
-    '''Raise this exception to mark a test as a known failing test.'''
-    pass
-
-
-class KnownFailure(ErrorClassPlugin):
-    '''Plugin that installs a KNOWNFAIL error class for the
-    KnownFailureClass exception.  When KnownFailureTest is raised,
-    the exception will be logged in the knownfail attribute of the
-    result, 'K' or 'KNOWNFAIL' (verbose) will be output, and the
-    exception will not be counted as an error or failure.'''
-    enabled = True
-    knownfail = ErrorClass(KnownFailureTest,
-                           label='KNOWNFAIL',
-                           isfailure=False)
-
-    def options(self, parser, env=os.environ):
-        env_opt = 'NOSE_WITHOUT_KNOWNFAIL'
-        parser.add_option('--no-knownfail', action='store_true',
-                          dest='noKnownFail', default=env.get(env_opt, False),
-                          help='Disable special handling of KnownFailureTest '
-                               'exceptions')
-
-    def configure(self, options, conf):
-        if not self.can_configure:
-            return
-        self.conf = conf
-        disable = getattr(options, 'noKnownFail', False)
-        if disable:
-            self.enabled = False
-
-
diff --git a/IPython/external/decorators/_numpy_testing_utils.py b/IPython/external/decorators/_numpy_testing_utils.py
deleted file mode 100644
index a01e3468853..00000000000
--- a/IPython/external/decorators/_numpy_testing_utils.py
+++ /dev/null
@@ -1,116 +0,0 @@
-# IPython: modified copy of numpy.testing.utils, so
-# IPython.external._decorators works without numpy being installed.
-"""
-Utility function to facilitate testing.
-"""
-
-import sys
-import warnings
-
-# The following two classes are copied from python 2.6 warnings module (context
-# manager)
-class WarningMessage(object):
-
-    """
-    Holds the result of a single showwarning() call.
-
-    Notes
-    -----
-    `WarningMessage` is copied from the Python 2.6 warnings module,
-    so it can be used in NumPy with older Python versions.
-
-    """
-
-    _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file",
-                        "line")
-
-    def __init__(self, message, category, filename, lineno, file=None,
-                    line=None):
-        local_values = locals()
-        for attr in self._WARNING_DETAILS:
-            setattr(self, attr, local_values[attr])
-        if category:
-            self._category_name = category.__name__
-        else:
-            self._category_name = None
-
-    def __str__(self):
-        return ("{message : %r, category : %r, filename : %r, lineno : %s, "
-                    "line : %r}" % (self.message, self._category_name,
-                                    self.filename, self.lineno, self.line))
-
-class WarningManager:
-    """
-    A context manager that copies and restores the warnings filter upon
-    exiting the context.
-
-    The 'record' argument specifies whether warnings should be captured by a
-    custom implementation of ``warnings.showwarning()`` and be appended to a
-    list returned by the context manager. Otherwise None is returned by the
-    context manager. The objects appended to the list are arguments whose
-    attributes mirror the arguments to ``showwarning()``.
-
-    The 'module' argument is to specify an alternative module to the module
-    named 'warnings' and imported under that name. This argument is only useful
-    when testing the warnings module itself.
-
-    Notes
-    -----
-    `WarningManager` is a copy of the ``catch_warnings`` context manager
-    from the Python 2.6 warnings module, with slight modifications.
-    It is copied so it can be used in NumPy with older Python versions.
-
-    """
-    def __init__(self, record=False, module=None):
-        self._record = record
-        if module is None:
-            self._module = sys.modules['warnings']
-        else:
-            self._module = module
-        self._entered = False
-
-    def __enter__(self):
-        if self._entered:
-            raise RuntimeError("Cannot enter %r twice" % self)
-        self._entered = True
-        self._filters = self._module.filters
-        self._module.filters = self._filters[:]
-        self._showwarning = self._module.showwarning
-        if self._record:
-            log = []
-            def showwarning(*args, **kwargs):
-                log.append(WarningMessage(*args, **kwargs))
-            self._module.showwarning = showwarning
-            return log
-        else:
-            return None
-
-    def __exit__(self):
-        if not self._entered:
-            raise RuntimeError("Cannot exit %r without entering first" % self)
-        self._module.filters = self._filters
-        self._module.showwarning = self._showwarning
-
-def assert_warns(warning_class, func, *args, **kw):
-    """Fail unless a warning of class warning_class is thrown by callable when
-    invoked with arguments args and keyword arguments kwargs.
-    
-    If a different type of warning is thrown, it will not be caught, and the
-    test case will be deemed to have suffered an error.
-    """
-
-    # XXX: once we may depend on python >= 2.6, this can be replaced by the
-    # warnings module context manager.
-    ctx = WarningManager(record=True)
-    l = ctx.__enter__()
-    warnings.simplefilter('always')
-    try:
-        func(*args, **kw)
-        if not len(l) > 0:
-            raise AssertionError("No warning raised when calling %s"
-                    % func.__name__)
-        if not l[0].category is warning_class:
-            raise AssertionError("First warning for %s is not a " \
-                    "%s( is %s)" % (func.__name__, warning_class, l[0]))
-    finally:
-        ctx.__exit__()
diff --git a/IPython/external/guid/__init__.py b/IPython/external/guid/__init__.py
deleted file mode 100644
index bb40c41ec87..00000000000
--- a/IPython/external/guid/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-try:
-    from guid import *
-except ImportError:
-    from _guid import *
diff --git a/IPython/external/guid/_guid.py b/IPython/external/guid/_guid.py
deleted file mode 100644
index da1a22691ae..00000000000
--- a/IPython/external/guid/_guid.py
+++ /dev/null
@@ -1,170 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-# GUID.py
-# Version 2.6
-#
-# Copyright (c) 2006 Conan C. Albrecht
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy 
-# of this software and associated documentation files (the "Software"), to deal 
-# in the Software without restriction, including without limitation the rights 
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
-# copies of the Software, and to permit persons to whom the Software is furnished 
-# to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all 
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
-# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
-# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
-# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
-# DEALINGS IN THE SOFTWARE.
-
-
-
-##################################################################################################
-###   A globally-unique identifier made up of time and ip and 8 digits for a counter: 
-###   each GUID is 40 characters wide
-###
-###   A globally unique identifier that combines ip, time, and a counter.  Since the 
-###   time is listed first, you can sort records by guid.  You can also extract the time 
-###   and ip if needed.  
-###
-###   Since the counter has eight hex characters, you can create up to 
-###   0xffffffff (4294967295) GUIDs every millisecond.  If your processor
-###   is somehow fast enough to create more than that in a millisecond (looking
-###   toward the future, of course), the function will wait until the next
-###   millisecond to return.
-###     
-###   GUIDs make wonderful database keys.  They require no access to the 
-###   database (to get the max index number), they are extremely unique, and they sort 
-###   automatically by time.   GUIDs prevent key clashes when merging
-###   two databases together, combining data, or generating keys in distributed
-###   systems.
-###
-###   There is an Internet Draft for UUIDs, but this module does not implement it.
-###   If the draft catches on, perhaps I'll conform the module to it.
-###
-
-
-# Changelog
-# Sometime, 1997     Created the Java version of GUID
-#                    Went through many versions in Java
-# Sometime, 2002     Created the Python version of GUID, mirroring the Java version
-# November 24, 2003  Changed Python version to be more pythonic, took out object and made just a module
-# December 2, 2003   Fixed duplicating GUIDs.  Sometimes they duplicate if multiples are created
-#                    in the same millisecond (it checks the last 100 GUIDs now and has a larger random part)
-# December 9, 2003   Fixed MAX_RANDOM, which was going over sys.maxint
-# June 12, 2004      Allowed a custom IP address to be sent in rather than always using the 
-#                    local IP address.  
-# November 4, 2005   Changed the random part to a counter variable.  Now GUIDs are totally 
-#                    unique and more efficient, as long as they are created by only
-#                    on runtime on a given machine.  The counter part is after the time
-#                    part so it sorts correctly.
-# November 8, 2005   The counter variable now starts at a random long now and cycles
-#                    around.  This is in case two guids are created on the same
-#                    machine at the same millisecond (by different processes).  Even though
-#                    it is possible the GUID can be created, this makes it highly unlikely
-#                    since the counter will likely be different.
-# November 11, 2005  Fixed a bug in the new IP getting algorithm.  Also, use IPv6 range
-#                    for IP when we make it up (when it's no accessible)
-# November 21, 2005  Added better IP-finding code.  It finds IP address better now.
-# January 5, 2006    Fixed a small bug caused in old versions of python (random module use)
-
-import math
-import socket
-import random
-import sys
-import time
-import threading
-
-
-
-#############################
-###   global module variables
-
-#Makes a hex IP from a decimal dot-separated ip (eg: 127.0.0.1)
-make_hexip = lambda ip: ''.join(["%04x" % long(i) for i in ip.split('.')]) # leave space for ip v6 (65K in each sub)
-  
-MAX_COUNTER = 0xfffffffe
-counter = 0L
-firstcounter = MAX_COUNTER
-lasttime = 0
-ip = ''
-lock = threading.RLock()
-try:  # only need to get the IP addresss once
-  ip = socket.getaddrinfo(socket.gethostname(),0)[-1][-1][0]
-  hexip = make_hexip(ip)
-except: # if we don't have an ip, default to someting in the 10.x.x.x private range
-  ip = '10'
-  rand = random.Random()
-  for i in range(3):
-    ip += '.' + str(rand.randrange(1, 0xffff))  # might as well use IPv6 range if we're making it up
-  hexip = make_hexip(ip)
-
-  
-#################################
-###   Public module functions
-
-def generate(ip=None):
-  '''Generates a new guid.  A guid is unique in space and time because it combines
-     the machine IP with the current time in milliseconds.  Be careful about sending in
-     a specified IP address because the ip makes it unique in space.  You could send in
-     the same IP address that is created on another machine.
-  '''
-  global counter, firstcounter, lasttime
-  lock.acquire() # can't generate two guids at the same time
-  try:
-    parts = []
-
-    # do we need to wait for the next millisecond (are we out of counters?)
-    now = long(time.time() * 1000)
-    while lasttime == now and counter == firstcounter: 
-      time.sleep(.01)
-      now = long(time.time() * 1000)
-
-    # time part
-    parts.append("%016x" % now)
-
-    # counter part
-    if lasttime != now:  # time to start counter over since we have a different millisecond
-      firstcounter = long(random.uniform(1, MAX_COUNTER))  # start at random position
-      counter = firstcounter
-    counter += 1
-    if counter > MAX_COUNTER:
-      counter = 0
-    lasttime = now
-    parts.append("%08x" % (counter)) 
-
-    # ip part
-    parts.append(hexip)
-
-    # put them all together
-    return ''.join(parts)
-  finally:
-    lock.release()
-    
-
-def extract_time(guid):
-  '''Extracts the time portion out of the guid and returns the 
-     number of seconds since the epoch as a float'''
-  return float(long(guid[0:16], 16)) / 1000.0
-
-
-def extract_counter(guid):
-  '''Extracts the counter from the guid (returns the bits in decimal)'''
-  return int(guid[16:24], 16)
-
-
-def extract_ip(guid):
-  '''Extracts the ip portion out of the guid and returns it
-     as a string like 10.10.10.10'''
-  # there's probably a more elegant way to do this
-  thisip = []
-  for index in range(24, 40, 4):
-    thisip.append(str(int(guid[index: index + 4], 16)))
-  return '.'.join(thisip)
-
diff --git a/IPython/external/mglob/__init__.py b/IPython/external/mglob/__init__.py
deleted file mode 100644
index 28494fd76d5..00000000000
--- a/IPython/external/mglob/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-try:
-    from mglob import *
-except ImportError:
-    from _mglob import *
diff --git a/IPython/external/mglob/_mglob.py b/IPython/external/mglob/_mglob.py
deleted file mode 100644
index 44a3b491716..00000000000
--- a/IPython/external/mglob/_mglob.py
+++ /dev/null
@@ -1,227 +0,0 @@
-r""" mglob - enhanced file list expansion module
-
-Use as stand-alone utility (for xargs, `backticks` etc.), 
-or a globbing library for own python programs. Globbing the sys.argv is something 
-that almost every Windows script has to perform manually, and this module is here
-to help with that task. Also Unix users will benefit from enhanced modes 
-such as recursion, exclusion, directory omission...
-
-Unlike glob.glob, directories are not included in the glob unless specified 
-with 'dir:'
-
-'expand' is the function to use in python programs. Typical use
-to expand argv (esp. in windows)::
-
-    try:
-        import mglob 
-        files = mglob.expand(sys.argv[1:])
-    except ImportError:
-        print "mglob not found; try 'easy_install mglob' for extra features"
-        files = sys.argv[1:] 
-
-Note that for unix, shell expands *normal* wildcards (*.cpp, etc.) in argv.
-Therefore, you might want to use quotes with normal wildcards to prevent this 
-expansion, in order for mglob to see the wildcards and get the wanted behaviour.
-Not quoting the wildcards is harmless and typically has equivalent results, though.
-
-Author: Ville Vainio <vivainio@gmail.com>
-License: MIT Open Source license
-
-"""
-
-#Assigned in variable for "usage" printing convenience"
-
-globsyntax = """\
-    This program allows specifying filenames with "mglob" mechanism.
-    Supported syntax in globs (wilcard matching patterns)::
-    
-     *.cpp ?ellowo*                
-         - obvious. Differs from normal glob in that dirs are not included.
-           Unix users might want to write this as: "*.cpp" "?ellowo*"
-     rec:/usr/share=*.txt,*.doc    
-         - get all *.txt and *.doc under /usr/share, 
-           recursively
-     rec:/usr/share
-         - All files under /usr/share, recursively
-     rec:*.py
-         - All .py files under current working dir, recursively
-     foo                           
-         - File or dir foo
-     !*.bak readme*                   
-         - readme*, exclude files ending with .bak
-     !.svn/ !.hg/ !*_Data/ rec:.
-         - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
-           Trailing / is the key, \ does not work! Use !.*/ for all hidden.
-     dir:foo                       
-         - the directory foo if it exists (not files in foo)
-     dir:*                         
-         - all directories in current folder
-     foo.py bar.* !h* rec:*.py
-         - Obvious. !h* exclusion only applies for rec:*.py.
-           foo.py is *not* included twice.
-     @filelist.txt
-         - All files listed in 'filelist.txt' file, on separate lines.
-     "cont:class \wak:" rec:*.py
-         - Match files containing regexp. Applies to subsequent files.
-           note quotes because of whitespace.
- """
-
-
-__version__ = "0.2"
-
-
-import os,glob,fnmatch,sys,re
-                
-def expand(flist,exp_dirs = False):
-    """ Expand the glob(s) in flist.
-    
-    flist may be either a whitespace-separated list of globs/files
-    or an array of globs/files.
-    
-    if exp_dirs is true, directory names in glob are expanded to the files
-    contained in them - otherwise, directory names are returned as is.
-    
-    """
-    if isinstance(flist, basestring):
-        import shlex
-        flist = shlex.split(flist)
-    done_set = set()
-    denied_set = set()
-    cont_set = set()
-    cur_rejected_dirs = set()
-    
-    def recfind(p, pats = ["*"]):
-        denied_dirs = [os.path.dirname(d) for d in denied_set if d.endswith("/")]
-        for (dp,dnames,fnames) in os.walk(p):
-            # see if we should ignore the whole directory
-            dp_norm = dp.replace("\\","/") + "/"
-            deny = False
-            # do not traverse under already rejected dirs
-            for d in cur_rejected_dirs:
-                if dp.startswith(d):
-                    deny = True
-                    break
-            if deny:
-                continue
-            
-
-            #print "dp",dp
-            bname = os.path.basename(dp)
-            for deny_pat in denied_dirs:
-                if fnmatch.fnmatch( bname, deny_pat):
-                    deny = True
-                    cur_rejected_dirs.add(dp)
-                    break
-            if deny:
-                continue
-
-                    
-            for f in fnames:
-                matched = False
-                for p in pats:
-                    if fnmatch.fnmatch(f,p):
-                        matched = True
-                        break
-                if matched:
-                    yield os.path.join(dp,f)            
-
-    def once_filter(seq):
-        for it in seq:
-            p = os.path.abspath(it)
-            if p in done_set:
-                continue
-            done_set.add(p)
-            deny = False
-            for deny_pat in denied_set:
-                if fnmatch.fnmatch(os.path.basename(p), deny_pat):
-                    deny = True
-                    break
-            if cont_set:
-                try:
-                    cont = open(p).read()
-                except IOError:
-                    # deny
-                    continue
-                for pat in cont_set:
-                    if not re.search(pat,cont, re.IGNORECASE):
-                        deny = True
-                        break
-                    
-            if not deny:
-                yield it
-        return
-            
-    res = []
-
-    for ent in flist:
-        ent = os.path.expanduser(os.path.expandvars(ent))
-        if ent.lower().startswith('rec:'):
-            fields = ent[4:].split('=')            
-            if len(fields) == 2:
-                pth, patlist = fields
-            elif len(fields) == 1:
-                if os.path.isdir(fields[0]):
-                    # single arg is dir
-                    pth, patlist = fields[0], '*'
-                else: 
-                    # single arg is pattern
-                    pth, patlist = '.', fields[0]
-                    
-            elif len(fields) == 0:
-                pth, pathlist = '.','*'
-                
-            pats = patlist.split(',')
-            res.extend(once_filter(recfind(pth, pats)))
-        # filelist
-        elif ent.startswith('@') and os.path.isfile(ent[1:]):
-            res.extend(once_filter(open(ent[1:]).read().splitlines()))
-        # exclusion
-        elif ent.startswith('!'):
-            denied_set.add(ent[1:])
-        # glob only dirs
-        elif ent.lower().startswith('dir:'):
-            res.extend(once_filter(filter(os.path.isdir,glob.glob(ent[4:]))))
-        elif ent.lower().startswith('cont:'):
-            cont_set.add(ent[5:])
-        # get all files in the specified dir
-        elif os.path.isdir(ent) and exp_dirs:
-            res.extend(once_filter(filter(os.path.isfile,glob.glob(ent + os.sep+"*"))))
-            
-        # glob only files
-
-        elif '*' in ent or '?' in ent:
-            res.extend(once_filter(filter(os.path.isfile,glob.glob(ent))))
-
-        else:
-            res.extend(once_filter([ent]))
-    return res
-            
-            
-def test():
-    assert (
-        expand("*.py ~/.ipython/*.py rec:/usr/share/doc-base") == 
-        expand( ['*.py', '~/.ipython/*.py', 'rec:/usr/share/doc-base'] ) 
-        )
-    
-def main():
-    if len(sys.argv) < 2:
-        print globsyntax
-        return
-    
-    print "\n".join(expand(sys.argv[1:])),
-
-def mglob_f(self, arg):
-    from IPython.utils.text import SList
-    if arg.strip():
-        return SList(expand(arg))
-    print "Please specify pattern!"
-    print globsyntax
-
-def init_ipython(ip):
-    """ register %mglob for IPython """
-    mglob_f.__doc__ = globsyntax
-    ip.define_magic("mglob",mglob_f)  
-    
-# test()
-if __name__ == "__main__":
-    main()
diff --git a/IPython/external/path/__init__.py b/IPython/external/path/__init__.py
deleted file mode 100644
index bd03f5da91a..00000000000
--- a/IPython/external/path/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-try:
-    from path import *
-except ImportError:
-    from _path import *
diff --git a/IPython/external/path/_path.py b/IPython/external/path/_path.py
deleted file mode 100644
index 4abe32d298d..00000000000
--- a/IPython/external/path/_path.py
+++ /dev/null
@@ -1,944 +0,0 @@
-""" path.py - An object representing a path to a file or directory.
-
-Example:
-
-from IPython.external.path import path
-d = path('/home/guido/bin')
-for f in d.files('*.py'):
-    f.chmod(0755)
-
-This module requires Python 2.5 or later.
-
-
-URL:     http://www.jorendorff.com/articles/python/path
-Author:  Jason Orendorff <jason.orendorff\x40gmail\x2ecom> (and others - see the url!)
-Date:    9 Mar 2007
-"""
-
-
-# TODO
-#   - Tree-walking functions don't avoid symlink loops.  Matt Harrison
-#     sent me a patch for this.
-#   - Bug in write_text().  It doesn't support Universal newline mode.
-#   - Better error message in listdir() when self isn't a
-#     directory. (On Windows, the error message really sucks.)
-#   - Make sure everything has a good docstring.
-#   - Add methods for regex find and replace.
-#   - guess_content_type() method?
-#   - Perhaps support arguments to touch().
-
-from __future__ import generators
-
-import sys, warnings, os, fnmatch, glob, shutil, codecs
-from hashlib import md5
-
-__version__ = '2.2'
-__all__ = ['path']
-
-# Platform-specific support for path.owner
-if os.name == 'nt':
-    try:
-        import win32security
-    except ImportError:
-        win32security = None
-else:
-    try:
-        import pwd
-    except ImportError:
-        pwd = None
-
-
-class TreeWalkWarning(Warning):
-    pass
-
-class path(unicode):
-    """ Represents a filesystem path.
-
-    For documentation on individual methods, consult their
-    counterparts in os.path.
-    """
-
-    # --- Special Python methods.
-
-    def __repr__(self):
-        return 'path(%s)' % unicode.__repr__(self)
-
-    # Adding a path and a string yields a path.
-    def __add__(self, more):
-        try:
-            resultStr = unicode.__add__(self, more)
-        except TypeError:  #Python bug
-            resultStr = NotImplemented
-        if resultStr is NotImplemented:
-            return resultStr
-        return self.__class__(resultStr)
-
-    def __radd__(self, other):
-        if isinstance(other, basestring):
-            return self.__class__(other.__add__(self))
-        else:
-            return NotImplemented
-
-    # The / operator joins paths.
-    def __div__(self, rel):
-        """ fp.__div__(rel) == fp / rel == fp.joinpath(rel)
-
-        Join two path components, adding a separator character if
-        needed.
-        """
-        return self.__class__(os.path.join(self, rel))
-
-    # Make the / operator work even when true division is enabled.
-    __truediv__ = __div__
-
-    def getcwd(cls):
-        """ Return the current working directory as a path object. """
-        return cls(os.getcwdu())
-    getcwd = classmethod(getcwd)
-
-
-    # --- Operations on path strings.
-
-    isabs = os.path.isabs
-    def abspath(self):       return self.__class__(os.path.abspath(self))
-    def normcase(self):      return self.__class__(os.path.normcase(self))
-    def normpath(self):      return self.__class__(os.path.normpath(self))
-    def realpath(self):      return self.__class__(os.path.realpath(self))
-    def expanduser(self):    return self.__class__(os.path.expanduser(self))
-    def expandvars(self):    return self.__class__(os.path.expandvars(self))
-    def dirname(self):       return self.__class__(os.path.dirname(self))
-    basename = os.path.basename
-
-    def expand(self):
-        """ Clean up a filename by calling expandvars(),
-        expanduser(), and normpath() on it.
-
-        This is commonly everything needed to clean up a filename
-        read from a configuration file, for example.
-        """
-        return self.expandvars().expanduser().normpath()
-
-    def _get_namebase(self):
-        base, ext = os.path.splitext(self.name)
-        return base
-
-    def _get_ext(self):
-        f, ext = os.path.splitext(unicode(self))
-        return ext
-
-    def _get_drive(self):
-        drive, r = os.path.splitdrive(self)
-        return self.__class__(drive)
-
-    parent = property(
-        dirname, None, None,
-        """ This path's parent directory, as a new path object.
-
-        For example, path('/usr/local/lib/libpython.so').parent == path('/usr/local/lib')
-        """)
-
-    name = property(
-        basename, None, None,
-        """ The name of this file or directory without the full path.
-
-        For example, path('/usr/local/lib/libpython.so').name == 'libpython.so'
-        """)
-
-    namebase = property(
-        _get_namebase, None, None,
-        """ The same as path.name, but with one file extension stripped off.
-
-        For example, path('/home/guido/python.tar.gz').name     == 'python.tar.gz',
-        but          path('/home/guido/python.tar.gz').namebase == 'python.tar'
-        """)
-
-    ext = property(
-        _get_ext, None, None,
-        """ The file extension, for example '.py'. """)
-
-    drive = property(
-        _get_drive, None, None,
-        """ The drive specifier, for example 'C:'.
-        This is always empty on systems that don't use drive specifiers.
-        """)
-
-    def splitpath(self):
-        """ p.splitpath() -> Return (p.parent, p.name). """
-        parent, child = os.path.split(self)
-        return self.__class__(parent), child
-
-    def splitdrive(self):
-        """ p.splitdrive() -> Return (p.drive, <the rest of p>).
-
-        Split the drive specifier from this path.  If there is
-        no drive specifier, p.drive is empty, so the return value
-        is simply (path(''), p).  This is always the case on Unix.
-        """
-        drive, rel = os.path.splitdrive(self)
-        return self.__class__(drive), rel
-
-    def splitext(self):
-        """ p.splitext() -> Return (p.stripext(), p.ext).
-
-        Split the filename extension from this path and return
-        the two parts.  Either part may be empty.
-
-        The extension is everything from '.' to the end of the
-        last path segment.  This has the property that if
-        (a, b) == p.splitext(), then a + b == p.
-        """
-        filename, ext = os.path.splitext(self)
-        return self.__class__(filename), ext
-
-    def stripext(self):
-        """ p.stripext() -> Remove one file extension from the path.
-
-        For example, path('/home/guido/python.tar.gz').stripext()
-        returns path('/home/guido/python.tar').
-        """
-        return self.splitext()[0]
-
-    if hasattr(os.path, 'splitunc'):
-        def splitunc(self):
-            unc, rest = os.path.splitunc(self)
-            return self.__class__(unc), rest
-
-        def _get_uncshare(self):
-            unc, r = os.path.splitunc(self)
-            return self.__class__(unc)
-
-        uncshare = property(
-            _get_uncshare, None, None,
-            """ The UNC mount point for this path.
-            This is empty for paths on local drives. """)
-
-    def joinpath(self, *args):
-        """ Join two or more path components, adding a separator
-        character (os.sep) if needed.  Returns a new path
-        object.
-        """
-        return self.__class__(os.path.join(self, *args))
-
-    def splitall(self):
-        r""" Return a list of the path components in this path.
-
-        The first item in the list will be a path.  Its value will be
-        either os.curdir, os.pardir, empty, or the root directory of
-        this path (for example, '/' or 'C:\\').  The other items in
-        the list will be strings.
-
-        path.path.joinpath(*result) will yield the original path.
-        """
-        parts = []
-        loc = self
-        while loc != os.curdir and loc != os.pardir:
-            prev = loc
-            loc, child = prev.splitpath()
-            if loc == prev:
-                break
-            parts.append(child)
-        parts.append(loc)
-        parts.reverse()
-        return parts
-
-    def relpath(self):
-        """ Return this path as a relative path,
-        based from the current working directory.
-        """
-        cwd = self.__class__(os.getcwd())
-        return cwd.relpathto(self)
-
-    def relpathto(self, dest):
-        """ Return a relative path from self to dest.
-
-        If there is no relative path from self to dest, for example if
-        they reside on different drives in Windows, then this returns
-        dest.abspath().
-        """
-        origin = self.abspath()
-        dest = self.__class__(dest).abspath()
-
-        orig_list = origin.normcase().splitall()
-        # Don't normcase dest!  We want to preserve the case.
-        dest_list = dest.splitall()
-
-        if orig_list[0] != os.path.normcase(dest_list[0]):
-            # Can't get here from there.
-            return dest
-
-        # Find the location where the two paths start to differ.
-        i = 0
-        for start_seg, dest_seg in zip(orig_list, dest_list):
-            if start_seg != os.path.normcase(dest_seg):
-                break
-            i += 1
-
-        # Now i is the point where the two paths diverge.
-        # Need a certain number of "os.pardir"s to work up
-        # from the origin to the point of divergence.
-        segments = [os.pardir] * (len(orig_list) - i)
-        # Need to add the diverging part of dest_list.
-        segments += dest_list[i:]
-        if len(segments) == 0:
-            # If they happen to be identical, use os.curdir.
-            relpath = os.curdir
-        else:
-            relpath = os.path.join(*segments)
-        return self.__class__(relpath)
-
-    # --- Listing, searching, walking, and matching
-
-    def listdir(self, pattern=None):
-        """ D.listdir() -> List of items in this directory.
-
-        Use D.files() or D.dirs() instead if you want a listing
-        of just files or just subdirectories.
-
-        The elements of the list are path objects.
-
-        With the optional 'pattern' argument, this only lists
-        items whose names match the given pattern.
-        """
-        names = os.listdir(self)
-        if pattern is not None:
-            names = fnmatch.filter(names, pattern)
-        return [self / child for child in names]
-
-    def dirs(self, pattern=None):
-        """ D.dirs() -> List of this directory's subdirectories.
-
-        The elements of the list are path objects.
-        This does not walk recursively into subdirectories
-        (but see path.walkdirs).
-
-        With the optional 'pattern' argument, this only lists
-        directories whose names match the given pattern.  For
-        example, d.dirs('build-*').
-        """
-        return [p for p in self.listdir(pattern) if p.isdir()]
-
-    def files(self, pattern=None):
-        """ D.files() -> List of the files in this directory.
-
-        The elements of the list are path objects.
-        This does not walk into subdirectories (see path.walkfiles).
-
-        With the optional 'pattern' argument, this only lists files
-        whose names match the given pattern.  For example,
-        d.files('*.pyc').
-        """
-        
-        return [p for p in self.listdir(pattern) if p.isfile()]
-
-    def walk(self, pattern=None, errors='strict'):
-        """ D.walk() -> iterator over files and subdirs, recursively.
-
-        The iterator yields path objects naming each child item of
-        this directory and its descendants.  This requires that
-        D.isdir().
-
-        This performs a depth-first traversal of the directory tree.
-        Each directory is returned just before all its children.
-
-        The errors= keyword argument controls behavior when an
-        error occurs.  The default is 'strict', which causes an
-        exception.  The other allowed values are 'warn', which
-        reports the error via warnings.warn(), and 'ignore'.
-        """
-        if errors not in ('strict', 'warn', 'ignore'):
-            raise ValueError("invalid errors parameter")
-
-        try:
-            childList = self.listdir()
-        except Exception:
-            if errors == 'ignore':
-                return
-            elif errors == 'warn':
-                warnings.warn(
-                    "Unable to list directory '%s': %s"
-                    % (self, sys.exc_info()[1]),
-                    TreeWalkWarning)
-                return
-            else:
-                raise
-
-        for child in childList:
-            if pattern is None or child.fnmatch(pattern):
-                yield child
-            try:
-                isdir = child.isdir()
-            except Exception:
-                if errors == 'ignore':
-                    isdir = False
-                elif errors == 'warn':
-                    warnings.warn(
-                        "Unable to access '%s': %s"
-                        % (child, sys.exc_info()[1]),
-                        TreeWalkWarning)
-                    isdir = False
-                else:
-                    raise
-
-            if isdir:
-                for item in child.walk(pattern, errors):
-                    yield item
-
-    def walkdirs(self, pattern=None, errors='strict'):
-        """ D.walkdirs() -> iterator over subdirs, recursively.
-
-        With the optional 'pattern' argument, this yields only
-        directories whose names match the given pattern.  For
-        example, mydir.walkdirs('*test') yields only directories
-        with names ending in 'test'.
-
-        The errors= keyword argument controls behavior when an
-        error occurs.  The default is 'strict', which causes an
-        exception.  The other allowed values are 'warn', which
-        reports the error via warnings.warn(), and 'ignore'.
-        """
-        if errors not in ('strict', 'warn', 'ignore'):
-            raise ValueError("invalid errors parameter")
-
-        try:
-            dirs = self.dirs()
-        except Exception:
-            if errors == 'ignore':
-                return
-            elif errors == 'warn':
-                warnings.warn(
-                    "Unable to list directory '%s': %s"
-                    % (self, sys.exc_info()[1]),
-                    TreeWalkWarning)
-                return
-            else:
-                raise
-
-        for child in dirs:
-            if pattern is None or child.fnmatch(pattern):
-                yield child
-            for subsubdir in child.walkdirs(pattern, errors):
-                yield subsubdir
-
-    def walkfiles(self, pattern=None, errors='strict'):
-        """ D.walkfiles() -> iterator over files in D, recursively.
-
-        The optional argument, pattern, limits the results to files
-        with names that match the pattern.  For example,
-        mydir.walkfiles('*.tmp') yields only files with the .tmp
-        extension.
-        """
-        if errors not in ('strict', 'warn', 'ignore'):
-            raise ValueError("invalid errors parameter")
-
-        try:
-            childList = self.listdir()
-        except Exception:
-            if errors == 'ignore':
-                return
-            elif errors == 'warn':
-                warnings.warn(
-                    "Unable to list directory '%s': %s"
-                    % (self, sys.exc_info()[1]),
-                    TreeWalkWarning)
-                return
-            else:
-                raise
-
-        for child in childList:
-            try:
-                isfile = child.isfile()
-                isdir = not isfile and child.isdir()
-            except:
-                if errors == 'ignore':
-                    continue
-                elif errors == 'warn':
-                    warnings.warn(
-                        "Unable to access '%s': %s"
-                        % (self, sys.exc_info()[1]),
-                        TreeWalkWarning)
-                    continue
-                else:
-                    raise
-
-            if isfile:
-                if pattern is None or child.fnmatch(pattern):
-                    yield child
-            elif isdir:
-                for f in child.walkfiles(pattern, errors):
-                    yield f
-
-    def fnmatch(self, pattern):
-        """ Return True if self.name matches the given pattern.
-
-        pattern - A filename pattern with wildcards,
-            for example '*.py'.
-        """
-        return fnmatch.fnmatch(self.name, pattern)
-
-    def glob(self, pattern):
-        """ Return a list of path objects that match the pattern.
-
-        pattern - a path relative to this directory, with wildcards.
-
-        For example, path('/users').glob('*/bin/*') returns a list
-        of all the files users have in their bin directories.
-        """
-        cls = self.__class__
-        return [cls(s) for s in glob.glob(unicode(self / pattern))]
-
-
-    # --- Reading or writing an entire file at once.
-
-    def open(self, mode='r'):
-        """ Open this file.  Return a file object. """
-        return open(self, mode)
-
-    def bytes(self):
-        """ Open this file, read all bytes, return them as a string. """
-        f = self.open('rb')
-        try:
-            return f.read()
-        finally:
-            f.close()
-
-    def write_bytes(self, bytes, append=False):
-        """ Open this file and write the given bytes to it.
-
-        Default behavior is to overwrite any existing file.
-        Call p.write_bytes(bytes, append=True) to append instead.
-        """
-        if append:
-            mode = 'ab'
-        else:
-            mode = 'wb'
-        f = self.open(mode)
-        try:
-            f.write(bytes)
-        finally:
-            f.close()
-
-    def text(self, encoding=None, errors='strict'):
-        r""" Open this file, read it in, return the content as a string.
-
-        This uses 'U' mode in Python 2.3 and later, so '\r\n' and '\r'
-        are automatically translated to '\n'.
-
-        Optional arguments:
-
-        encoding - The Unicode encoding (or character set) of
-            the file.  If present, the content of the file is
-            decoded and returned as a unicode object; otherwise
-            it is returned as an 8-bit str.
-        errors - How to handle Unicode errors; see help(str.decode)
-            for the options.  Default is 'strict'.
-        """
-        if encoding is None:
-            # 8-bit
-            f = self.open('U')
-            try:
-                return f.read()
-            finally:
-                f.close()
-        else:
-            # Unicode
-            f = codecs.open(self, 'r', encoding, errors)
-            # (Note - Can't use 'U' mode here, since codecs.open
-            # doesn't support 'U' mode, even in Python 2.3.)
-            try:
-                t = f.read()
-            finally:
-                f.close()
-            return (t.replace(u'\r\n', u'\n')
-                     .replace(u'\r\x85', u'\n')
-                     .replace(u'\r', u'\n')
-                     .replace(u'\x85', u'\n')
-                     .replace(u'\u2028', u'\n'))
-
-    def write_text(self, text, encoding=None, errors='strict', linesep=os.linesep, append=False):
-        r""" Write the given text to this file.
-
-        The default behavior is to overwrite any existing file;
-        to append instead, use the 'append=True' keyword argument.
-
-        There are two differences between path.write_text() and
-        path.write_bytes(): newline handling and Unicode handling.
-        See below.
-
-        Parameters:
-
-          - text - str/unicode - The text to be written.
-
-          - encoding - str - The Unicode encoding that will be used.
-            This is ignored if 'text' isn't a Unicode string.
-
-          - errors - str - How to handle Unicode encoding errors.
-            Default is 'strict'.  See help(unicode.encode) for the
-            options.  This is ignored if 'text' isn't a Unicode
-            string.
-
-          - linesep - keyword argument - str/unicode - The sequence of
-            characters to be used to mark end-of-line.  The default is
-            os.linesep.  You can also specify None; this means to
-            leave all newlines as they are in 'text'.
-
-          - append - keyword argument - bool - Specifies what to do if
-            the file already exists (True: append to the end of it;
-            False: overwrite it.)  The default is False.
-
-
-        --- Newline handling.
-
-        write_text() converts all standard end-of-line sequences
-        ('\n', '\r', and '\r\n') to your platform's default end-of-line
-        sequence (see os.linesep; on Windows, for example, the
-        end-of-line marker is '\r\n').
-
-        If you don't like your platform's default, you can override it
-        using the 'linesep=' keyword argument.  If you specifically want
-        write_text() to preserve the newlines as-is, use 'linesep=None'.
-
-        This applies to Unicode text the same as to 8-bit text, except
-        there are three additional standard Unicode end-of-line sequences:
-        u'\x85', u'\r\x85', and u'\u2028'.
-
-        (This is slightly different from when you open a file for
-        writing with fopen(filename, "w") in C or file(filename, 'w')
-        in Python.)
-
-
-        --- Unicode
-
-        If 'text' isn't Unicode, then apart from newline handling, the
-        bytes are written verbatim to the file.  The 'encoding' and
-        'errors' arguments are not used and must be omitted.
-
-        If 'text' is Unicode, it is first converted to bytes using the
-        specified 'encoding' (or the default encoding if 'encoding'
-        isn't specified).  The 'errors' argument applies only to this
-        conversion.
-
-        """
-        if isinstance(text, unicode):
-            if linesep is not None:
-                # Convert all standard end-of-line sequences to
-                # ordinary newline characters.
-                text = (text.replace(u'\r\n', u'\n')
-                            .replace(u'\r\x85', u'\n')
-                            .replace(u'\r', u'\n')
-                            .replace(u'\x85', u'\n')
-                            .replace(u'\u2028', u'\n'))
-                text = text.replace(u'\n', linesep)
-            if encoding is None:
-                encoding = sys.getdefaultencoding()
-            bytes = text.encode(encoding, errors)
-        else:
-            # It is an error to specify an encoding if 'text' is
-            # an 8-bit string.
-            assert encoding is None
-
-            if linesep is not None:
-                text = (text.replace('\r\n', '\n')
-                            .replace('\r', '\n'))
-                bytes = text.replace('\n', linesep)
-
-        self.write_bytes(bytes, append)
-
-    def lines(self, encoding=None, errors='strict', retain=True):
-        r""" Open this file, read all lines, return them in a list.
-
-        Optional arguments:
-            encoding - The Unicode encoding (or character set) of
-                the file.  The default is None, meaning the content
-                of the file is read as 8-bit characters and returned
-                as a list of (non-Unicode) str objects.
-            errors - How to handle Unicode errors; see help(str.decode)
-                for the options.  Default is 'strict'
-            retain - If true, retain newline characters; but all newline
-                character combinations ('\r', '\n', '\r\n') are
-                translated to '\n'.  If false, newline characters are
-                stripped off.  Default is True.
-
-        This uses 'U' mode in Python 2.3 and later.
-        """
-        if encoding is None and retain:
-            f = self.open('U')
-            try:
-                return f.readlines()
-            finally:
-                f.close()
-        else:
-            return self.text(encoding, errors).splitlines(retain)
-
-    def write_lines(self, lines, encoding=None, errors='strict',
-                    linesep=os.linesep, append=False):
-        r""" Write the given lines of text to this file.
-
-        By default this overwrites any existing file at this path.
-
-        This puts a platform-specific newline sequence on every line.
-        See 'linesep' below.
-
-        lines - A list of strings.
-
-        encoding - A Unicode encoding to use.  This applies only if
-            'lines' contains any Unicode strings.
-
-        errors - How to handle errors in Unicode encoding.  This
-            also applies only to Unicode strings.
-
-        linesep - The desired line-ending.  This line-ending is
-            applied to every line.  If a line already has any
-            standard line ending ('\r', '\n', '\r\n', u'\x85',
-            u'\r\x85', u'\u2028'), that will be stripped off and
-            this will be used instead.  The default is os.linesep,
-            which is platform-dependent ('\r\n' on Windows, '\n' on
-            Unix, etc.)  Specify None to write the lines as-is,
-            like file.writelines().
-
-        Use the keyword argument append=True to append lines to the
-        file.  The default is to overwrite the file.  Warning:
-        When you use this with Unicode data, if the encoding of the
-        existing data in the file is different from the encoding
-        you specify with the encoding= parameter, the result is
-        mixed-encoding data, which can really confuse someone trying
-        to read the file later.
-        """
-        if append:
-            mode = 'ab'
-        else:
-            mode = 'wb'
-        f = self.open(mode)
-        try:
-            for line in lines:
-                isUnicode = isinstance(line, unicode)
-                if linesep is not None:
-                    # Strip off any existing line-end and add the
-                    # specified linesep string.
-                    if isUnicode:
-                        if line[-2:] in (u'\r\n', u'\x0d\x85'):
-                            line = line[:-2]
-                        elif line[-1:] in (u'\r', u'\n',
-                                           u'\x85', u'\u2028'):
-                            line = line[:-1]
-                    else:
-                        if line[-2:] == '\r\n':
-                            line = line[:-2]
-                        elif line[-1:] in ('\r', '\n'):
-                            line = line[:-1]
-                    line += linesep
-                if isUnicode:
-                    if encoding is None:
-                        encoding = sys.getdefaultencoding()
-                    line = line.encode(encoding, errors)
-                f.write(line)
-        finally:
-            f.close()
-
-    def read_md5(self):
-        """ Calculate the md5 hash for this file.
-
-        This reads through the entire file.
-        """
-        f = self.open('rb')
-        try:
-            m = md5()
-            while True:
-                d = f.read(8192)
-                if not d:
-                    break
-                m.update(d)
-        finally:
-            f.close()
-        return m.digest()
-
-    # --- Methods for querying the filesystem.
-
-    exists = os.path.exists
-    isdir = os.path.isdir
-    isfile = os.path.isfile
-    islink = os.path.islink
-    ismount = os.path.ismount
-
-    if hasattr(os.path, 'samefile'):
-        samefile = os.path.samefile
-
-    getatime = os.path.getatime
-    atime = property(
-        getatime, None, None,
-        """ Last access time of the file. """)
-
-    getmtime = os.path.getmtime
-    mtime = property(
-        getmtime, None, None,
-        """ Last-modified time of the file. """)
-
-    if hasattr(os.path, 'getctime'):
-        getctime = os.path.getctime
-        ctime = property(
-            getctime, None, None,
-            """ Creation time of the file. """)
-
-    getsize = os.path.getsize
-    size = property(
-        getsize, None, None,
-        """ Size of the file, in bytes. """)
-
-    if hasattr(os, 'access'):
-        def access(self, mode):
-            """ Return true if current user has access to this path.
-
-            mode - One of the constants os.F_OK, os.R_OK, os.W_OK, os.X_OK
-            """
-            return os.access(self, mode)
-
-    def stat(self):
-        """ Perform a stat() system call on this path. """
-        return os.stat(self)
-
-    def lstat(self):
-        """ Like path.stat(), but do not follow symbolic links. """
-        return os.lstat(self)
-
-    def get_owner(self):
-        r""" Return the name of the owner of this file or directory.
-
-        This follows symbolic links.
-
-        On Windows, this returns a name of the form ur'DOMAIN\User Name'.
-        On Windows, a group can own a file or directory.
-        """
-        if os.name == 'nt':
-            if win32security is None:
-                raise Exception("path.owner requires win32all to be installed")
-            desc = win32security.GetFileSecurity(
-                self, win32security.OWNER_SECURITY_INFORMATION)
-            sid = desc.GetSecurityDescriptorOwner()
-            account, domain, typecode = win32security.LookupAccountSid(None, sid)
-            return domain + u'\\' + account
-        else:
-            if pwd is None:
-                raise NotImplementedError("path.owner is not implemented on this platform.")
-            st = self.stat()
-            return pwd.getpwuid(st.st_uid).pw_name
-
-    owner = property(
-        get_owner, None, None,
-        """ Name of the owner of this file or directory. """)
-
-    if hasattr(os, 'statvfs'):
-        def statvfs(self):
-            """ Perform a statvfs() system call on this path. """
-            return os.statvfs(self)
-
-    if hasattr(os, 'pathconf'):
-        def pathconf(self, name):
-            return os.pathconf(self, name)
-
-
-    # --- Modifying operations on files and directories
-
-    def utime(self, times):
-        """ Set the access and modified times of this file. """
-        os.utime(self, times)
-
-    def chmod(self, mode):
-        os.chmod(self, mode)
-
-    if hasattr(os, 'chown'):
-        def chown(self, uid, gid):
-            os.chown(self, uid, gid)
-
-    def rename(self, new):
-        os.rename(self, new)
-
-    def renames(self, new):
-        os.renames(self, new)
-
-
-    # --- Create/delete operations on directories
-
-    def mkdir(self, mode=0777):
-        os.mkdir(self, mode)
-
-    def makedirs(self, mode=0777):
-        os.makedirs(self, mode)
-
-    def rmdir(self):
-        os.rmdir(self)
-
-    def removedirs(self):
-        os.removedirs(self)
-
-
-    # --- Modifying operations on files
-
-    def touch(self):
-        """ Set the access/modified times of this file to the current time.
-        Create the file if it does not exist.
-        """
-        fd = os.open(self, os.O_WRONLY | os.O_CREAT, 0666)
-        os.close(fd)
-        os.utime(self, None)
-
-    def remove(self):
-        os.remove(self)
-
-    def unlink(self):
-        os.unlink(self)
-
-
-    # --- Links
-
-    if hasattr(os, 'link'):
-        def link(self, newpath):
-            """ Create a hard link at 'newpath', pointing to this file. """
-            os.link(self, newpath)
-
-    if hasattr(os, 'symlink'):
-        def symlink(self, newlink):
-            """ Create a symbolic link at 'newlink', pointing here. """
-            os.symlink(self, newlink)
-
-    if hasattr(os, 'readlink'):
-        def readlink(self):
-            """ Return the path to which this symbolic link points.
-
-            The result may be an absolute or a relative path.
-            """
-            return self.__class__(os.readlink(self))
-
-        def readlinkabs(self):
-            """ Return the path to which this symbolic link points.
-
-            The result is always an absolute path.
-            """
-            p = self.readlink()
-            if p.isabs():
-                return p
-            else:
-                return (self.parent / p).abspath()
-
-
-    # --- High-level functions from shutil
-
-    copyfile = shutil.copyfile
-    copymode = shutil.copymode
-    copystat = shutil.copystat
-    copy = shutil.copy
-    copy2 = shutil.copy2
-    copytree = shutil.copytree
-    if hasattr(shutil, 'move'):
-        move = shutil.move
-    rmtree = shutil.rmtree
-
-
-    # --- Special stuff from os
-
-    if hasattr(os, 'chroot'):
-        def chroot(self):
-            os.chroot(self)
-
-    if hasattr(os, 'startfile'):
-        def startfile(self):
-            os.startfile(self)
-
diff --git a/IPython/external/pexpect/__init__.py b/IPython/external/pexpect/__init__.py
deleted file mode 100644
index ff99aae250a..00000000000
--- a/IPython/external/pexpect/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-try:
-    import pexpect
-    from pexpect import *
-except ImportError:
-    from _pexpect import *
diff --git a/IPython/external/pexpect/_pexpect.py b/IPython/external/pexpect/_pexpect.py
deleted file mode 100644
index b2c0fe89e62..00000000000
--- a/IPython/external/pexpect/_pexpect.py
+++ /dev/null
@@ -1,1843 +0,0 @@
-"""Pexpect is a Python module for spawning child applications and controlling
-them automatically. Pexpect can be used for automating interactive applications
-such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup
-scripts for duplicating software package installations on different servers. It
-can be used for automated software testing. Pexpect is in the spirit of Don
-Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python
-require TCL and Expect or require C extensions to be compiled. Pexpect does not
-use C, Expect, or TCL extensions. It should work on any platform that supports
-the standard Python pty module. The Pexpect interface focuses on ease of use so
-that simple tasks are easy.
-
-There are two main interfaces to Pexpect -- the function, run() and the class,
-spawn. You can call the run() function to execute a command and return the
-output. This is a handy replacement for os.system().
-
-For example::
-
-    pexpect.run('ls -la')
-
-The more powerful interface is the spawn class. You can use this to spawn an
-external child command and then interact with the child by sending lines and
-expecting responses.
-
-For example::
-
-    child = pexpect.spawn('scp foo myname@host.example.com:.')
-    child.expect ('Password:')
-    child.sendline (mypassword)
-
-This works even for commands that ask for passwords or other input outside of
-the normal stdio streams.
-
-Credits: Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett,
-Robert Stone, Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids
-vander Molen, George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,
-Geoffrey Marshall, Francisco Lourenco, Glen Mabey, Karthik Gurusamy, Fernando
-Perez, Corey Minyard, Jon Cohen, Guillaume Chazarain, Andrew Ryan, Nick
-Craig-Wood, Andrew Stone, Jorgen Grahn (Let me know if I forgot anyone.)
-
-Free, open source, and all that good stuff.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-Pexpect Copyright (c) 2008 Noah Spurrier
-http://pexpect.sourceforge.net/
-
-$Id: pexpect.py 507 2007-12-27 02:40:52Z noah $
-"""
-
-try:
-    import os, sys, time
-    import select
-    import re
-    import struct
-    import resource
-    import types
-    import pty
-    import tty
-    import termios
-    import fcntl
-    import errno
-    import traceback
-    import signal
-except ImportError, e:
-    raise ImportError (str(e) + """
-
-A critical module was not found. Probably this operating system does not
-support it. Pexpect is intended for UNIX-like operating systems.""")
-
-__version__ = '2.3'
-__revision__ = '$Revision: 399 $'
-__all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'run', 'which',
-    'split_command_line', '__version__', '__revision__']
-
-# Exception classes used by this module.
-class ExceptionPexpect(Exception):
-
-    """Base class for all exceptions raised by this module.
-    """
-
-    def __init__(self, value):
-
-        self.value = value
-
-    def __str__(self):
-
-        return str(self.value)
-
-    def get_trace(self):
-
-        """This returns an abbreviated stack trace with lines that only concern
-        the caller. In other words, the stack trace inside the Pexpect module
-        is not included. """
-
-        tblist = traceback.extract_tb(sys.exc_info()[2])
-        #tblist = filter(self.__filter_not_pexpect, tblist)
-        tblist = [item for item in tblist if self.__filter_not_pexpect(item)]
-        tblist = traceback.format_list(tblist)
-        return ''.join(tblist)
-
-    def __filter_not_pexpect(self, trace_list_item):
-
-        """This returns True if list item 0 the string 'pexpect.py' in it. """
-
-        if trace_list_item[0].find('pexpect.py') == -1:
-            return True
-        else:
-            return False
-
-class EOF(ExceptionPexpect):
-
-    """Raised when EOF is read from a child. This usually means the child has exited."""
-
-class TIMEOUT(ExceptionPexpect):
-
-    """Raised when a read time exceeds the timeout. """
-
-##class TIMEOUT_PATTERN(TIMEOUT):
-##    """Raised when the pattern match time exceeds the timeout.
-##    This is different than a read TIMEOUT because the child process may
-##    give output, thus never give a TIMEOUT, but the output
-##    may never match a pattern.
-##    """
-##class MAXBUFFER(ExceptionPexpect):
-##    """Raised when a scan buffer fills before matching an expected pattern."""
-
-def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None, logfile=None, cwd=None, env=None):
-
-    """
-    This function runs the given command; waits for it to finish; then
-    returns all output as a string. STDERR is included in output. If the full
-    path to the command is not given then the path is searched.
-
-    Note that lines are terminated by CR/LF (\\r\\n) combination even on
-    UNIX-like systems because this is the standard for pseudo ttys. If you set
-    'withexitstatus' to true, then run will return a tuple of (command_output,
-    exitstatus). If 'withexitstatus' is false then this returns just
-    command_output.
-
-    The run() function can often be used instead of creating a spawn instance.
-    For example, the following code uses spawn::
-
-        from pexpect import *
-        child = spawn('scp foo myname@host.example.com:.')
-        child.expect ('(?i)password')
-        child.sendline (mypassword)
-
-    The previous code can be replace with the following::
-
-        from pexpect import *
-        run ('scp foo myname@host.example.com:.', events={'(?i)password': mypassword})
-
-    Examples
-    ========
-
-    Start the apache daemon on the local machine::
-
-        from pexpect import *
-        run ("/usr/local/apache/bin/apachectl start")
-
-    Check in a file using SVN::
-
-        from pexpect import *
-        run ("svn ci -m 'automatic commit' my_file.py")
-
-    Run a command and capture exit status::
-
-        from pexpect import *
-        (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)
-
-    Tricky Examples
-    ===============
-
-    The following will run SSH and execute 'ls -l' on the remote machine. The
-    password 'secret' will be sent if the '(?i)password' pattern is ever seen::
-
-        run ("ssh username@machine.example.com 'ls -l'", events={'(?i)password':'secret\\n'})
-
-    This will start mencoder to rip a video from DVD. This will also display
-    progress ticks every 5 seconds as it runs. For example::
-
-        from pexpect import *
-        def print_ticks(d):
-            print d['event_count'],
-        run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5)
-
-    The 'events' argument should be a dictionary of patterns and responses.
-    Whenever one of the patterns is seen in the command out run() will send the
-    associated response string. Note that you should put newlines in your
-    string if Enter is necessary. The responses may also contain callback
-    functions. Any callback is function that takes a dictionary as an argument.
-    The dictionary contains all the locals from the run() function, so you can
-    access the child spawn object or any other variable defined in run()
-    (event_count, child, and extra_args are the most useful). A callback may
-    return True to stop the current run process otherwise run() continues until
-    the next event. A callback may also return a string which will be sent to
-    the child. 'extra_args' is not used by directly run(). It provides a way to
-    pass data to a callback function through run() through the locals
-    dictionary passed to a callback. """
-
-    if timeout == -1:
-        child = spawn(command, maxread=2000, logfile=logfile, cwd=cwd, env=env)
-    else:
-        child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile, cwd=cwd, env=env)
-    if events is not None:
-        patterns = events.keys()
-        responses = events.values()
-    else:
-        patterns=None # We assume that EOF or TIMEOUT will save us.
-        responses=None
-    child_result_list = []
-    event_count = 0
-    while 1:
-        try:
-            index = child.expect (patterns)
-            if type(child.after) in types.StringTypes:
-                child_result_list.append(child.before + child.after)
-            else: # child.after may have been a TIMEOUT or EOF, so don't cat those.
-                child_result_list.append(child.before)
-            if type(responses[index]) in types.StringTypes:
-                child.send(responses[index])
-            elif type(responses[index]) is types.FunctionType:
-                callback_result = responses[index](locals())
-                sys.stdout.flush()
-                if type(callback_result) in types.StringTypes:
-                    child.send(callback_result)
-                elif callback_result:
-                    break
-            else:
-                raise TypeError ('The callback must be a string or function type.')
-            event_count = event_count + 1
-        except TIMEOUT, e:
-            child_result_list.append(child.before)
-            break
-        except EOF, e:
-            child_result_list.append(child.before)
-            break
-    child_result = ''.join(child_result_list)
-    if withexitstatus:
-        child.close()
-        return (child_result, child.exitstatus)
-    else:
-        return child_result
-
-class spawn (object):
-
-    """This is the main class interface for Pexpect. Use this class to start
-    and control child applications. """
-
-    def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None, cwd=None, env=None):
-
-        """This is the constructor. The command parameter may be a string that
-        includes a command and any arguments to the command. For example::
-
-            child = pexpect.spawn ('/usr/bin/ftp')
-            child = pexpect.spawn ('/usr/bin/ssh user@example.com')
-            child = pexpect.spawn ('ls -latr /tmp')
-
-        You may also construct it with a list of arguments like so::
-
-            child = pexpect.spawn ('/usr/bin/ftp', [])
-            child = pexpect.spawn ('/usr/bin/ssh', ['user@example.com'])
-            child = pexpect.spawn ('ls', ['-latr', '/tmp'])
-
-        After this the child application will be created and will be ready to
-        talk to. For normal use, see expect() and send() and sendline().
-
-        Remember that Pexpect does NOT interpret shell meta characters such as
-        redirect, pipe, or wild cards (>, |, or *). This is a common mistake.
-        If you want to run a command and pipe it through another command then
-        you must also start a shell. For example::
-
-            child = pexpect.spawn('/bin/bash -c "ls -l | grep LOG > log_list.txt"')
-            child.expect(pexpect.EOF)
-
-        The second form of spawn (where you pass a list of arguments) is useful
-        in situations where you wish to spawn a command and pass it its own
-        argument list. This can make syntax more clear. For example, the
-        following is equivalent to the previous example::
-
-            shell_cmd = 'ls -l | grep LOG > log_list.txt'
-            child = pexpect.spawn('/bin/bash', ['-c', shell_cmd])
-            child.expect(pexpect.EOF)
-
-        The maxread attribute sets the read buffer size. This is maximum number
-        of bytes that Pexpect will try to read from a TTY at one time. Setting
-        the maxread size to 1 will turn off buffering. Setting the maxread
-        value higher may help performance in cases where large amounts of
-        output are read back from the child. This feature is useful in
-        conjunction with searchwindowsize.
-
-        The searchwindowsize attribute sets the how far back in the incomming
-        seach buffer Pexpect will search for pattern matches. Every time
-        Pexpect reads some data from the child it will append the data to the
-        incomming buffer. The default is to search from the beginning of the
-        imcomming buffer each time new data is read from the child. But this is
-        very inefficient if you are running a command that generates a large
-        amount of data where you want to match The searchwindowsize does not
-        effect the size of the incomming data buffer. You will still have
-        access to the full buffer after expect() returns.
-
-        The logfile member turns on or off logging. All input and output will
-        be copied to the given file object. Set logfile to None to stop
-        logging. This is the default. Set logfile to sys.stdout to echo
-        everything to standard output. The logfile is flushed after each write.
-
-        Example log input and output to a file::
-
-            child = pexpect.spawn('some_command')
-            fout = file('mylog.txt','w')
-            child.logfile = fout
-
-        Example log to stdout::
-
-            child = pexpect.spawn('some_command')
-            child.logfile = sys.stdout
-
-        The logfile_read and logfile_send members can be used to separately log
-        the input from the child and output sent to the child. Sometimes you
-        don't want to see everything you write to the child. You only want to
-        log what the child sends back. For example::
-
-            child = pexpect.spawn('some_command')
-            child.logfile_read = sys.stdout
-
-        To separately log output sent to the child use logfile_send::
-
-            self.logfile_send = fout
-
-        The delaybeforesend helps overcome a weird behavior that many users
-        were experiencing. The typical problem was that a user would expect() a
-        "Password:" prompt and then immediately call sendline() to send the
-        password. The user would then see that their password was echoed back
-        to them. Passwords don't normally echo. The problem is caused by the
-        fact that most applications print out the "Password" prompt and then
-        turn off stdin echo, but if you send your password before the
-        application turned off echo, then you get your password echoed.
-        Normally this wouldn't be a problem when interacting with a human at a
-        real keyboard. If you introduce a slight delay just before writing then
-        this seems to clear up the problem. This was such a common problem for
-        many users that I decided that the default pexpect behavior should be
-        to sleep just before writing to the child application. 1/20th of a
-        second (50 ms) seems to be enough to clear up the problem. You can set
-        delaybeforesend to 0 to return to the old behavior. Most Linux machines
-        don't like this to be below 0.03. I don't know why.
-
-        Note that spawn is clever about finding commands on your path.
-        It uses the same logic that "which" uses to find executables.
-
-        If you wish to get the exit status of the child you must call the
-        close() method. The exit or signal status of the child will be stored
-        in self.exitstatus or self.signalstatus. If the child exited normally
-        then exitstatus will store the exit return code and signalstatus will
-        be None. If the child was terminated abnormally with a signal then
-        signalstatus will store the signal value and exitstatus will be None.
-        If you need more detail you can also read the self.status member which
-        stores the status returned by os.waitpid. You can interpret this using
-        os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG. """
-
-        self.STDIN_FILENO = pty.STDIN_FILENO
-        self.STDOUT_FILENO = pty.STDOUT_FILENO
-        self.STDERR_FILENO = pty.STDERR_FILENO
-        self.stdin = sys.stdin
-        self.stdout = sys.stdout
-        self.stderr = sys.stderr
-
-        self.searcher = None
-        self.ignorecase = False
-        self.before = None
-        self.after = None
-        self.match = None
-        self.match_index = None
-        self.terminated = True
-        self.exitstatus = None
-        self.signalstatus = None
-        self.status = None # status returned by os.waitpid
-        self.flag_eof = False
-        self.pid = None
-        self.child_fd = -1 # initially closed
-        self.timeout = timeout
-        self.delimiter = EOF
-        self.logfile = logfile
-        self.logfile_read = None # input from child (read_nonblocking)
-        self.logfile_send = None # output to send (send, sendline)
-        self.maxread = maxread # max bytes to read at one time into buffer
-        self.buffer = '' # This is the read buffer. See maxread.
-        self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched.
-        # Most Linux machines don't like delaybeforesend to be below 0.03 (30 ms).
-        self.delaybeforesend = 0.05 # Sets sleep time used just before sending data to child. Time in seconds.
-        self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status. Time in seconds.
-        self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status. Time in seconds.
-        self.softspace = False # File-like object.
-        self.name = '<' + repr(self) + '>' # File-like object.
-        self.encoding = None # File-like object.
-        self.closed = True # File-like object.
-        self.cwd = cwd
-        self.env = env
-        self.__irix_hack = (sys.platform.lower().find('irix')>=0) # This flags if we are running on irix
-        # Solaris uses internal __fork_pty(). All others use pty.fork().
-        if (sys.platform.lower().find('solaris')>=0) or (sys.platform.lower().find('sunos5')>=0):
-            self.use_native_pty_fork = False
-        else:
-            self.use_native_pty_fork = True
-
-
-        # allow dummy instances for subclasses that may not use command or args.
-        if command is None:
-            self.command = None
-            self.args = None
-            self.name = '<pexpect factory incomplete>'
-        else:
-            self._spawn (command, args)
-
-    def __del__(self):
-
-        """This makes sure that no system resources are left open. Python only
-        garbage collects Python objects. OS file descriptors are not Python
-        objects, so they must be handled explicitly. If the child file
-        descriptor was opened outside of this class (passed to the constructor)
-        then this does not close it. """
-
-        if not self.closed:
-            # It is possible for __del__ methods to execute during the
-            # teardown of the Python VM itself. Thus self.close() may
-            # trigger an exception because os.close may be None.
-            # -- Fernando Perez
-            try:
-                self.close()
-            except AttributeError:
-                pass
-
-    def __str__(self):
-
-        """This returns a human-readable string that represents the state of
-        the object. """
-
-        s = []
-        s.append(repr(self))
-        s.append('version: ' + __version__ + ' (' + __revision__ + ')')
-        s.append('command: ' + str(self.command))
-        s.append('args: ' + str(self.args))
-        s.append('searcher: ' + str(self.searcher))
-        s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:])
-        s.append('before (last 100 chars): ' + str(self.before)[-100:])
-        s.append('after: ' + str(self.after))
-        s.append('match: ' + str(self.match))
-        s.append('match_index: ' + str(self.match_index))
-        s.append('exitstatus: ' + str(self.exitstatus))
-        s.append('flag_eof: ' + str(self.flag_eof))
-        s.append('pid: ' + str(self.pid))
-        s.append('child_fd: ' + str(self.child_fd))
-        s.append('closed: ' + str(self.closed))
-        s.append('timeout: ' + str(self.timeout))
-        s.append('delimiter: ' + str(self.delimiter))
-        s.append('logfile: ' + str(self.logfile))
-        s.append('logfile_read: ' + str(self.logfile_read))
-        s.append('logfile_send: ' + str(self.logfile_send))
-        s.append('maxread: ' + str(self.maxread))
-        s.append('ignorecase: ' + str(self.ignorecase))
-        s.append('searchwindowsize: ' + str(self.searchwindowsize))
-        s.append('delaybeforesend: ' + str(self.delaybeforesend))
-        s.append('delayafterclose: ' + str(self.delayafterclose))
-        s.append('delayafterterminate: ' + str(self.delayafterterminate))
-        return '\n'.join(s)
-
-    def _spawn(self,command,args=[]):
-
-        """This starts the given command in a child process. This does all the
-        fork/exec type of stuff for a pty. This is called by __init__. If args
-        is empty then command will be parsed (split on spaces) and args will be
-        set to parsed arguments. """
-
-        # The pid and child_fd of this object get set by this method.
-        # Note that it is difficult for this method to fail.
-        # You cannot detect if the child process cannot start.
-        # So the only way you can tell if the child process started
-        # or not is to try to read from the file descriptor. If you get
-        # EOF immediately then it means that the child is already dead.
-        # That may not necessarily be bad because you may haved spawned a child
-        # that performs some task; creates no stdout output; and then dies.
-
-        # If command is an int type then it may represent a file descriptor.
-        if type(command) == type(0):
-            raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.')
-
-        if type (args) != type([]):
-            raise TypeError ('The argument, args, must be a list.')
-
-        if args == []:
-            self.args = split_command_line(command)
-            self.command = self.args[0]
-        else:
-            self.args = args[:] # work with a copy
-            self.args.insert (0, command)
-            self.command = command
-
-        command_with_path = which(self.command)
-        if command_with_path is None:
-            raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command)
-        self.command = command_with_path
-        self.args[0] = self.command
-
-        self.name = '<' + ' '.join (self.args) + '>'
-
-        assert self.pid is None, 'The pid member should be None.'
-        assert self.command is not None, 'The command member should not be None.'
-
-        if self.use_native_pty_fork:
-            try:
-                self.pid, self.child_fd = pty.fork()
-            except OSError, e:
-                raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e))
-        else: # Use internal __fork_pty
-            self.pid, self.child_fd = self.__fork_pty()
-
-        if self.pid == 0: # Child
-            try:
-                self.child_fd = sys.stdout.fileno() # used by setwinsize()
-                self.setwinsize(24, 80)
-            except:
-                # Some platforms do not like setwinsize (Cygwin).
-                # This will cause problem when running applications that
-                # are very picky about window size.
-                # This is a serious limitation, but not a show stopper.
-                pass
-            # Do not allow child to inherit open file descriptors from parent.
-            max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
-            for i in range (3, max_fd):
-                try:
-                    os.close (i)
-                except OSError:
-                    pass
-
-            # I don't know why this works, but ignoring SIGHUP fixes a
-            # problem when trying to start a Java daemon with sudo
-            # (specifically, Tomcat).
-            signal.signal(signal.SIGHUP, signal.SIG_IGN)
-
-            if self.cwd is not None:
-                os.chdir(self.cwd)
-            if self.env is None:
-                os.execv(self.command, self.args)
-            else:
-                os.execvpe(self.command, self.args, self.env)
-
-        # Parent
-        self.terminated = False
-        self.closed = False
-
-    def __fork_pty(self):
-
-        """This implements a substitute for the forkpty system call. This
-        should be more portable than the pty.fork() function. Specifically,
-        this should work on Solaris.
-
-        Modified 10.06.05 by Geoff Marshall: Implemented __fork_pty() method to
-        resolve the issue with Python's pty.fork() not supporting Solaris,
-        particularly ssh. Based on patch to posixmodule.c authored by Noah
-        Spurrier::
-
-            http://mail.python.org/pipermail/python-dev/2003-May/035281.html
-
-        """
-
-        parent_fd, child_fd = os.openpty()
-        if parent_fd < 0 or child_fd < 0:
-            raise ExceptionPexpect, "Error! Could not open pty with os.openpty()."
-
-        pid = os.fork()
-        if pid < 0:
-            raise ExceptionPexpect, "Error! Failed os.fork()."
-        elif pid == 0:
-            # Child.
-            os.close(parent_fd)
-            self.__pty_make_controlling_tty(child_fd)
-
-            os.dup2(child_fd, 0)
-            os.dup2(child_fd, 1)
-            os.dup2(child_fd, 2)
-
-            if child_fd > 2:
-                os.close(child_fd)
-        else:
-            # Parent.
-            os.close(child_fd)
-
-        return pid, parent_fd
-
-    def __pty_make_controlling_tty(self, tty_fd):
-
-        """This makes the pseudo-terminal the controlling tty. This should be
-        more portable than the pty.fork() function. Specifically, this should
-        work on Solaris. """
-
-        child_name = os.ttyname(tty_fd)
-
-        # Disconnect from controlling tty if still connected.
-        fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
-        if fd >= 0:
-            os.close(fd)
-
-        os.setsid()
-
-        # Verify we are disconnected from controlling tty
-        try:
-            fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
-            if fd >= 0:
-                os.close(fd)
-                raise ExceptionPexpect, "Error! We are not disconnected from a controlling tty."
-        except:
-            # Good! We are disconnected from a controlling tty.
-            pass
-
-        # Verify we can open child pty.
-        fd = os.open(child_name, os.O_RDWR);
-        if fd < 0:
-            raise ExceptionPexpect, "Error! Could not open child pty, " + child_name
-        else:
-            os.close(fd)
-
-        # Verify we now have a controlling tty.
-        fd = os.open("/dev/tty", os.O_WRONLY)
-        if fd < 0:
-            raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty"
-        else:
-            os.close(fd)
-
-    def fileno (self):   # File-like object.
-
-        """This returns the file descriptor of the pty for the child.
-        """
-
-        return self.child_fd
-
-    def close (self, force=True):   # File-like object.
-
-        """This closes the connection with the child application. Note that
-        calling close() more than once is valid. This emulates standard Python
-        behavior with files. Set force to True if you want to make sure that
-        the child is terminated (SIGKILL is sent if the child ignores SIGHUP
-        and SIGINT). """
-
-        if not self.closed:
-            self.flush()
-            os.close (self.child_fd)
-            time.sleep(self.delayafterclose) # Give kernel time to update process status.
-            if self.isalive():
-                if not self.terminate(force):
-                    raise ExceptionPexpect ('close() could not terminate the child using terminate()')
-            self.child_fd = -1
-            self.closed = True
-            #self.pid = None
-
-    def flush (self):   # File-like object.
-
-        """This does nothing. It is here to support the interface for a
-        File-like object. """
-
-        pass
-
-    def isatty (self):   # File-like object.
-
-        """This returns True if the file descriptor is open and connected to a
-        tty(-like) device, else False. """
-
-        return os.isatty(self.child_fd)
-
-    def waitnoecho (self, timeout=-1):
-
-        """This waits until the terminal ECHO flag is set False. This returns
-        True if the echo mode is off. This returns False if the ECHO flag was
-        not set False before the timeout. This can be used to detect when the
-        child is waiting for a password. Usually a child application will turn
-        off echo mode when it is waiting for the user to enter a password. For
-        example, instead of expecting the "password:" prompt you can wait for
-        the child to set ECHO off::
-
-            p = pexpect.spawn ('ssh user@example.com')
-            p.waitnoecho()
-            p.sendline(mypassword)
-
-        If timeout is None then this method to block forever until ECHO flag is
-        False.
-
-        """
-
-        if timeout == -1:
-            timeout = self.timeout
-        if timeout is not None:
-            end_time = time.time() + timeout
-        while True:
-            if not self.getecho():
-                return True
-            if timeout < 0 and timeout is not None:
-                return False
-            if timeout is not None:
-                timeout = end_time - time.time()
-            time.sleep(0.1)
-
-    def getecho (self):
-
-        """This returns the terminal echo mode. This returns True if echo is
-        on or False if echo is off. Child applications that are expecting you
-        to enter a password often set ECHO False. See waitnoecho(). """
-
-        attr = termios.tcgetattr(self.child_fd)
-        if attr[3] & termios.ECHO:
-            return True
-        return False
-
-    def setecho (self, state):
-
-        """This sets the terminal echo mode on or off. Note that anything the
-        child sent before the echo will be lost, so you should be sure that
-        your input buffer is empty before you call setecho(). For example, the
-        following will work as expected::
-
-            p = pexpect.spawn('cat')
-            p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
-            p.expect (['1234'])
-            p.expect (['1234'])
-            p.setecho(False) # Turn off tty echo
-            p.sendline ('abcd') # We will set this only once (echoed by cat).
-            p.sendline ('wxyz') # We will set this only once (echoed by cat)
-            p.expect (['abcd'])
-            p.expect (['wxyz'])
-
-        The following WILL NOT WORK because the lines sent before the setecho
-        will be lost::
-
-            p = pexpect.spawn('cat')
-            p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
-            p.setecho(False) # Turn off tty echo
-            p.sendline ('abcd') # We will set this only once (echoed by cat).
-            p.sendline ('wxyz') # We will set this only once (echoed by cat)
-            p.expect (['1234'])
-            p.expect (['1234'])
-            p.expect (['abcd'])
-            p.expect (['wxyz'])
-        """
-
-        self.child_fd
-        attr = termios.tcgetattr(self.child_fd)
-        if state:
-            attr[3] = attr[3] | termios.ECHO
-        else:
-            attr[3] = attr[3] & ~termios.ECHO
-        # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent
-        # and blocked on some platforms. TCSADRAIN is probably ideal if it worked.
-        termios.tcsetattr(self.child_fd, termios.TCSANOW, attr)
-
-    def read_nonblocking (self, size = 1, timeout = -1):
-
-        """This reads at most size characters from the child application. It
-        includes a timeout. If the read does not complete within the timeout
-        period then a TIMEOUT exception is raised. If the end of file is read
-        then an EOF exception will be raised. If a log file was set using
-        setlog() then all data will also be written to the log file.
-
-        If timeout is None then the read may block indefinitely. If timeout is -1
-        then the self.timeout value is used. If timeout is 0 then the child is
-        polled and if there was no data immediately ready then this will raise
-        a TIMEOUT exception.
-
-        The timeout refers only to the amount of time to read at least one
-        character. This is not effected by the 'size' parameter, so if you call
-        read_nonblocking(size=100, timeout=30) and only one character is
-        available right away then one character will be returned immediately.
-        It will not wait for 30 seconds for another 99 characters to come in.
-
-        This is a wrapper around os.read(). It uses select.select() to
-        implement the timeout. """
-
-        if self.closed:
-            raise ValueError ('I/O operation on closed file in read_nonblocking().')
-
-        if timeout == -1:
-            timeout = self.timeout
-
-        # Note that some systems such as Solaris do not give an EOF when
-        # the child dies. In fact, you can still try to read
-        # from the child_fd -- it will block forever or until TIMEOUT.
-        # For this case, I test isalive() before doing any reading.
-        # If isalive() is false, then I pretend that this is the same as EOF.
-        if not self.isalive():
-            r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll"
-            if not r:
-                self.flag_eof = True
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.')
-        elif self.__irix_hack:
-            # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive.
-            # This adds a 2 second delay, but only when the child is terminated.
-            r, w, e = self.__select([self.child_fd], [], [], 2)
-            if not r and not self.isalive():
-                self.flag_eof = True
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.')
-
-        r,w,e = self.__select([self.child_fd], [], [], timeout)
-
-        if not r:
-            if not self.isalive():
-                # Some platforms, such as Irix, will claim that their processes are alive;
-                # then timeout on the select; and then finally admit that they are not alive.
-                self.flag_eof = True
-                raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.')
-            else:
-                raise TIMEOUT ('Timeout exceeded in read_nonblocking().')
-
-        if self.child_fd in r:
-            try:
-                s = os.read(self.child_fd, size)
-            except OSError, e: # Linux does this
-                self.flag_eof = True
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.')
-            if s == '': # BSD style
-                self.flag_eof = True
-                raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.')
-
-            if self.logfile is not None:
-                self.logfile.write (s)
-                self.logfile.flush()
-            if self.logfile_read is not None:
-                self.logfile_read.write (s)
-                self.logfile_read.flush()
-
-            return s
-
-        raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().')
-
-    def read (self, size = -1):   # File-like object.
-
-        """This reads at most "size" bytes from the file (less if the read hits
-        EOF before obtaining size bytes). If the size argument is negative or
-        omitted, read all data until EOF is reached. The bytes are returned as
-        a string object. An empty string is returned when EOF is encountered
-        immediately. """
-
-        if size == 0:
-            return ''
-        if size < 0:
-            self.expect (self.delimiter) # delimiter default is EOF
-            return self.before
-
-        # I could have done this more directly by not using expect(), but
-        # I deliberately decided to couple read() to expect() so that
-        # I would catch any bugs early and ensure consistant behavior.
-        # It's a little less efficient, but there is less for me to
-        # worry about if I have to later modify read() or expect().
-        # Note, it's OK if size==-1 in the regex. That just means it
-        # will never match anything in which case we stop only on EOF.
-        cre = re.compile('.{%d}' % size, re.DOTALL)
-        index = self.expect ([cre, self.delimiter]) # delimiter default is EOF
-        if index == 0:
-            return self.after ### self.before should be ''. Should I assert this?
-        return self.before
-
-    def readline (self, size = -1):    # File-like object.
-
-        """This reads and returns one entire line. A trailing newline is kept
-        in the string, but may be absent when a file ends with an incomplete
-        line. Note: This readline() looks for a \\r\\n pair even on UNIX
-        because this is what the pseudo tty device returns. So contrary to what
-        you may expect you will receive the newline as \\r\\n. An empty string
-        is returned when EOF is hit immediately. Currently, the size argument is
-        mostly ignored, so this behavior is not standard for a file-like
-        object. If size is 0 then an empty string is returned. """
-
-        if size == 0:
-            return ''
-        index = self.expect (['\r\n', self.delimiter]) # delimiter default is EOF
-        if index == 0:
-            return self.before + '\r\n'
-        else:
-            return self.before
-
-    def __iter__ (self):    # File-like object.
-
-        """This is to support iterators over a file-like object.
-        """
-
-        return self
-
-    def next (self):    # File-like object.
-
-        """This is to support iterators over a file-like object.
-        """
-
-        result = self.readline()
-        if result == "":
-            raise StopIteration
-        return result
-
-    def readlines (self, sizehint = -1):    # File-like object.
-
-        """This reads until EOF using readline() and returns a list containing
-        the lines thus read. The optional "sizehint" argument is ignored. """
-
-        lines = []
-        while True:
-            line = self.readline()
-            if not line:
-                break
-            lines.append(line)
-        return lines
-
-    def write(self, s):   # File-like object.
-
-        """This is similar to send() except that there is no return value.
-        """
-
-        self.send (s)
-
-    def writelines (self, sequence):   # File-like object.
-
-        """This calls write() for each element in the sequence. The sequence
-        can be any iterable object producing strings, typically a list of
-        strings. This does not add line separators There is no return value.
-        """
-
-        for s in sequence:
-            self.write (s)
-
-    def send(self, s):
-
-        """This sends a string to the child process. This returns the number of
-        bytes written. If a log file was set then the data is also written to
-        the log. """
-
-        time.sleep(self.delaybeforesend)
-        if self.logfile is not None:
-            self.logfile.write (s)
-            self.logfile.flush()
-        if self.logfile_send is not None:
-            self.logfile_send.write (s)
-            self.logfile_send.flush()
-        c = os.write(self.child_fd, s)
-        return c
-
-    def sendline(self, s=''):
-
-        """This is like send(), but it adds a line feed (os.linesep). This
-        returns the number of bytes written. """
-
-        n = self.send(s)
-        n = n + self.send (os.linesep)
-        return n
-
-    def sendcontrol(self, char):
-
-        """This sends a control character to the child such as Ctrl-C or
-        Ctrl-D. For example, to send a Ctrl-G (ASCII 7)::
-
-            child.sendcontrol('g')
-
-        See also, sendintr() and sendeof().
-        """
-
-        char = char.lower()
-        a = ord(char)
-        if a>=97 and a<=122:
-            a = a - ord('a') + 1
-            return self.send (chr(a))
-        d = {'@':0, '`':0,
-            '[':27, '{':27,
-            '\\':28, '|':28,
-            ']':29, '}': 29,
-            '^':30, '~':30,
-            '_':31,
-            '?':127}
-        if char not in d:
-            return 0
-        return self.send (chr(d[char]))
-
-    def sendeof(self):
-
-        """This sends an EOF to the child. This sends a character which causes
-        the pending parent output buffer to be sent to the waiting child
-        program without waiting for end-of-line. If it is the first character
-        of the line, the read() in the user program returns 0, which signifies
-        end-of-file. This means to work as expected a sendeof() has to be
-        called at the beginning of a line. This method does not send a newline.
-        It is the responsibility of the caller to ensure the eof is sent at the
-        beginning of a line. """
-
-        ### Hmmm... how do I send an EOF?
-        ###C  if ((m = write(pty, *buf, p - *buf)) < 0)
-        ###C      return (errno == EWOULDBLOCK) ? n : -1;
-        #fd = sys.stdin.fileno()
-        #old = termios.tcgetattr(fd) # remember current state
-        #attr = termios.tcgetattr(fd)
-        #attr[3] = attr[3] | termios.ICANON # ICANON must be set to recognize EOF
-        #try: # use try/finally to ensure state gets restored
-        #    termios.tcsetattr(fd, termios.TCSADRAIN, attr)
-        #    if hasattr(termios, 'CEOF'):
-        #        os.write (self.child_fd, '%c' % termios.CEOF)
-        #    else:
-        #        # Silly platform does not define CEOF so assume CTRL-D
-        #        os.write (self.child_fd, '%c' % 4)
-        #finally: # restore state
-        #    termios.tcsetattr(fd, termios.TCSADRAIN, old)
-        if hasattr(termios, 'VEOF'):
-            char = termios.tcgetattr(self.child_fd)[6][termios.VEOF]
-        else:
-            # platform does not define VEOF so assume CTRL-D
-            char = chr(4)
-        self.send(char)
-
-    def sendintr(self):
-
-        """This sends a SIGINT to the child. It does not require
-        the SIGINT to be the first character on a line. """
-
-        if hasattr(termios, 'VINTR'):
-            char = termios.tcgetattr(self.child_fd)[6][termios.VINTR]
-        else:
-            # platform does not define VINTR so assume CTRL-C
-            char = chr(3)
-        self.send (char)
-
-    def eof (self):
-
-        """This returns True if the EOF exception was ever raised.
-        """
-
-        return self.flag_eof
-
-    def terminate(self, force=False):
-
-        """This forces a child process to terminate. It starts nicely with
-        SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This
-        returns True if the child was terminated. This returns False if the
-        child could not be terminated. """
-
-        if not self.isalive():
-            return True
-        try:
-            self.kill(signal.SIGHUP)
-            time.sleep(self.delayafterterminate)
-            if not self.isalive():
-                return True
-            self.kill(signal.SIGCONT)
-            time.sleep(self.delayafterterminate)
-            if not self.isalive():
-                return True
-            self.kill(signal.SIGINT)
-            time.sleep(self.delayafterterminate)
-            if not self.isalive():
-                return True
-            if force:
-                self.kill(signal.SIGKILL)
-                time.sleep(self.delayafterterminate)
-                if not self.isalive():
-                    return True
-                else:
-                    return False
-            return False
-        except OSError, e:
-            # I think there are kernel timing issues that sometimes cause
-            # this to happen. I think isalive() reports True, but the
-            # process is dead to the kernel.
-            # Make one last attempt to see if the kernel is up to date.
-            time.sleep(self.delayafterterminate)
-            if not self.isalive():
-                return True
-            else:
-                return False
-
-    def wait(self):
-
-        """This waits until the child exits. This is a blocking call. This will
-        not read any data from the child, so this will block forever if the
-        child has unread output and has terminated. In other words, the child
-        may have printed output then called exit(); but, technically, the child
-        is still alive until its output is read. """
-
-        if self.isalive():
-            pid, status = os.waitpid(self.pid, 0)
-        else:
-            raise ExceptionPexpect ('Cannot wait for dead child process.')
-        self.exitstatus = os.WEXITSTATUS(status)
-        if os.WIFEXITED (status):
-            self.status = status
-            self.exitstatus = os.WEXITSTATUS(status)
-            self.signalstatus = None
-            self.terminated = True
-        elif os.WIFSIGNALED (status):
-            self.status = status
-            self.exitstatus = None
-            self.signalstatus = os.WTERMSIG(status)
-            self.terminated = True
-        elif os.WIFSTOPPED (status):
-            raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?')
-        return self.exitstatus
-
-    def isalive(self):
-
-        """This tests if the child process is running or not. This is
-        non-blocking. If the child was terminated then this will read the
-        exitstatus or signalstatus of the child. This returns True if the child
-        process appears to be running or False if not. It can take literally
-        SECONDS for Solaris to return the right status. """
-
-        if self.terminated:
-            return False
-
-        if self.flag_eof:
-            # This is for Linux, which requires the blocking form of waitpid to get
-            # status of a defunct process. This is super-lame. The flag_eof would have
-            # been set in read_nonblocking(), so this should be safe.
-            waitpid_options = 0
-        else:
-            waitpid_options = os.WNOHANG
-
-        try:
-            pid, status = os.waitpid(self.pid, waitpid_options)
-        except OSError, e: # No child processes
-            if e[0] == errno.ECHILD:
-                raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?')
-            else:
-                raise e
-
-        # I have to do this twice for Solaris. I can't even believe that I figured this out...
-        # If waitpid() returns 0 it means that no child process wishes to
-        # report, and the value of status is undefined.
-        if pid == 0:
-            try:
-                pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris!
-            except OSError, e: # This should never happen...
-                if e[0] == errno.ECHILD:
-                    raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?')
-                else:
-                    raise e
-
-            # If pid is still 0 after two calls to waitpid() then
-            # the process really is alive. This seems to work on all platforms, except
-            # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking
-            # take care of this situation (unfortunately, this requires waiting through the timeout).
-            if pid == 0:
-                return True
-
-        if pid == 0:
-            return True
-
-        if os.WIFEXITED (status):
-            self.status = status
-            self.exitstatus = os.WEXITSTATUS(status)
-            self.signalstatus = None
-            self.terminated = True
-        elif os.WIFSIGNALED (status):
-            self.status = status
-            self.exitstatus = None
-            self.signalstatus = os.WTERMSIG(status)
-            self.terminated = True
-        elif os.WIFSTOPPED (status):
-            raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?')
-        return False
-
-    def kill(self, sig):
-
-        """This sends the given signal to the child application. In keeping
-        with UNIX tradition it has a misleading name. It does not necessarily
-        kill the child unless you send the right signal. """
-
-        # Same as os.kill, but the pid is given for you.
-        if self.isalive():
-            os.kill(self.pid, sig)
-
-    def compile_pattern_list(self, patterns):
-
-        """This compiles a pattern-string or a list of pattern-strings.
-        Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or a list of
-        those. Patterns may also be None which results in an empty list (you
-        might do this if waiting for an EOF or TIMEOUT condition without
-        expecting any pattern).
-
-        This is used by expect() when calling expect_list(). Thus expect() is
-        nothing more than::
-
-             cpl = self.compile_pattern_list(pl)
-             return self.expect_list(cpl, timeout)
-
-        If you are using expect() within a loop it may be more
-        efficient to compile the patterns first and then call expect_list().
-        This avoid calls in a loop to compile_pattern_list()::
-
-             cpl = self.compile_pattern_list(my_pattern)
-             while some_condition:
-                ...
-                i = self.expect_list(clp, timeout)
-                ...
-        """
-
-        if patterns is None:
-            return []
-        if type(patterns) is not types.ListType:
-            patterns = [patterns]
-
-        compile_flags = re.DOTALL # Allow dot to match \n
-        if self.ignorecase:
-            compile_flags = compile_flags | re.IGNORECASE
-        compiled_pattern_list = []
-        for p in patterns:
-            if type(p) in types.StringTypes:
-                compiled_pattern_list.append(re.compile(p, compile_flags))
-            elif p is EOF:
-                compiled_pattern_list.append(EOF)
-            elif p is TIMEOUT:
-                compiled_pattern_list.append(TIMEOUT)
-            elif type(p) is type(re.compile('')):
-                compiled_pattern_list.append(p)
-            else:
-                raise TypeError ('Argument must be one of StringTypes, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p)))
-
-        return compiled_pattern_list
-
-    def expect(self, pattern, timeout = -1, searchwindowsize=None):
-
-        """This seeks through the stream until a pattern is matched. The
-        pattern is overloaded and may take several types. The pattern can be a
-        StringType, EOF, a compiled re, or a list of any of those types.
-        Strings will be compiled to re types. This returns the index into the
-        pattern list. If the pattern was not a list this returns index 0 on a
-        successful match. This may raise exceptions for EOF or TIMEOUT. To
-        avoid the EOF or TIMEOUT exceptions add EOF or TIMEOUT to the pattern
-        list. That will cause expect to match an EOF or TIMEOUT condition
-        instead of raising an exception.
-
-        If you pass a list of patterns and more than one matches, the first match
-        in the stream is chosen. If more than one pattern matches at that point,
-        the leftmost in the pattern list is chosen. For example::
-
-            # the input is 'foobar'
-            index = p.expect (['bar', 'foo', 'foobar'])
-            # returns 1 ('foo') even though 'foobar' is a "better" match
-
-        Please note, however, that buffering can affect this behavior, since
-        input arrives in unpredictable chunks. For example::
-
-            # the input is 'foobar'
-            index = p.expect (['foobar', 'foo'])
-            # returns 0 ('foobar') if all input is available at once,
-            # but returs 1 ('foo') if parts of the final 'bar' arrive late
-
-        After a match is found the instance attributes 'before', 'after' and
-        'match' will be set. You can see all the data read before the match in
-        'before'. You can see the data that was matched in 'after'. The
-        re.MatchObject used in the re match will be in 'match'. If an error
-        occurred then 'before' will be set to all the data read so far and
-        'after' and 'match' will be None.
-
-        If timeout is -1 then timeout will be set to the self.timeout value.
-
-        A list entry may be EOF or TIMEOUT instead of a string. This will
-        catch these exceptions and return the index of the list entry instead
-        of raising the exception. The attribute 'after' will be set to the
-        exception type. The attribute 'match' will be None. This allows you to
-        write code like this::
-
-                index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
-                if index == 0:
-                    do_something()
-                elif index == 1:
-                    do_something_else()
-                elif index == 2:
-                    do_some_other_thing()
-                elif index == 3:
-                    do_something_completely_different()
-
-        instead of code like this::
-
-                try:
-                    index = p.expect (['good', 'bad'])
-                    if index == 0:
-                        do_something()
-                    elif index == 1:
-                        do_something_else()
-                except EOF:
-                    do_some_other_thing()
-                except TIMEOUT:
-                    do_something_completely_different()
-
-        These two forms are equivalent. It all depends on what you want. You
-        can also just expect the EOF if you are waiting for all output of a
-        child to finish. For example::
-
-                p = pexpect.spawn('/bin/ls')
-                p.expect (pexpect.EOF)
-                print p.before
-
-        If you are trying to optimize for speed then see expect_list().
-        """
-
-        compiled_pattern_list = self.compile_pattern_list(pattern)
-        return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
-
-    def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1):
-
-        """This takes a list of compiled regular expressions and returns the
-        index into the pattern_list that matched the child output. The list may
-        also contain EOF or TIMEOUT (which are not compiled regular
-        expressions). This method is similar to the expect() method except that
-        expect_list() does not recompile the pattern list on every call. This
-        may help if you are trying to optimize for speed, otherwise just use
-        the expect() method.  This is called by expect(). If timeout==-1 then
-        the self.timeout value is used. If searchwindowsize==-1 then the
-        self.searchwindowsize value is used. """
-
-        return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize)
-
-    def expect_exact(self, pattern_list, timeout = -1, searchwindowsize = -1):
-
-        """This is similar to expect(), but uses plain string matching instead
-        of compiled regular expressions in 'pattern_list'. The 'pattern_list'
-        may be a string; a list or other sequence of strings; or TIMEOUT and
-        EOF.
-
-        This call might be faster than expect() for two reasons: string
-        searching is faster than RE matching and it is possible to limit the
-        search to just the end of the input buffer.
-
-        This method is also useful when you don't want to have to worry about
-        escaping regular expression characters that you want to match."""
-
-        if type(pattern_list) in types.StringTypes or pattern_list in (TIMEOUT, EOF):
-            pattern_list = [pattern_list]
-        return self.expect_loop(searcher_string(pattern_list), timeout, searchwindowsize)
-
-    def expect_loop(self, searcher, timeout = -1, searchwindowsize = -1):
-
-        """This is the common loop used inside expect. The 'searcher' should be
-        an instance of searcher_re or searcher_string, which describes how and what
-        to search for in the input.
-
-        See expect() for other arguments, return value and exceptions. """
-
-        self.searcher = searcher
-
-        if timeout == -1:
-            timeout = self.timeout
-        if timeout is not None:
-            end_time = time.time() + timeout
-        if searchwindowsize == -1:
-            searchwindowsize = self.searchwindowsize
-
-        try:
-            incoming = self.buffer
-            freshlen = len(incoming)
-            while True: # Keep reading until exception or return.
-                index = searcher.search(incoming, freshlen, searchwindowsize)
-                if index >= 0:
-                    self.buffer = incoming[searcher.end : ]
-                    self.before = incoming[ : searcher.start]
-                    self.after = incoming[searcher.start : searcher.end]
-                    self.match = searcher.match
-                    self.match_index = index
-                    return self.match_index
-                # No match at this point
-                if timeout < 0 and timeout is not None:
-                    raise TIMEOUT ('Timeout exceeded in expect_any().')
-                # Still have time left, so read more data
-                c = self.read_nonblocking (self.maxread, timeout)
-                freshlen = len(c)
-                time.sleep (0.0001)
-                incoming = incoming + c
-                if timeout is not None:
-                    timeout = end_time - time.time()
-        except EOF, e:
-            self.buffer = ''
-            self.before = incoming
-            self.after = EOF
-            index = searcher.eof_index
-            if index >= 0:
-                self.match = EOF
-                self.match_index = index
-                return self.match_index
-            else:
-                self.match = None
-                self.match_index = None
-                raise EOF (str(e) + '\n' + str(self))
-        except TIMEOUT, e:
-            self.buffer = incoming
-            self.before = incoming
-            self.after = TIMEOUT
-            index = searcher.timeout_index
-            if index >= 0:
-                self.match = TIMEOUT
-                self.match_index = index
-                return self.match_index
-            else:
-                self.match = None
-                self.match_index = None
-                raise TIMEOUT (str(e) + '\n' + str(self))
-        except:
-            self.before = incoming
-            self.after = None
-            self.match = None
-            self.match_index = None
-            raise
-
-    def getwinsize(self):
-
-        """This returns the terminal window size of the child tty. The return
-        value is a tuple of (rows, cols). """
-
-        TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912L)
-        s = struct.pack('HHHH', 0, 0, 0, 0)
-        x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s)
-        return struct.unpack('HHHH', x)[0:2]
-
-    def setwinsize(self, r, c):
-
-        """This sets the terminal window size of the child tty. This will cause
-        a SIGWINCH signal to be sent to the child. This does not change the
-        physical window size. It changes the size reported to TTY-aware
-        applications like vi or curses -- applications that respond to the
-        SIGWINCH signal. """
-
-        # Check for buggy platforms. Some Python versions on some platforms
-        # (notably OSF1 Alpha and RedHat 7.1) truncate the value for
-        # termios.TIOCSWINSZ. It is not clear why this happens.
-        # These platforms don't seem to handle the signed int very well;
-        # yet other platforms like OpenBSD have a large negative value for
-        # TIOCSWINSZ and they don't have a truncate problem.
-        # Newer versions of Linux have totally different values for TIOCSWINSZ.
-        # Note that this fix is a hack.
-        TIOCSWINSZ = getattr(termios, 'TIOCSWINSZ', -2146929561)
-        if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2.
-            TIOCSWINSZ = -2146929561 # Same bits, but with sign.
-        # Note, assume ws_xpixel and ws_ypixel are zero.
-        s = struct.pack('HHHH', r, c, 0, 0)
-        fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)
-
-    def interact(self, escape_character = chr(29), input_filter = None, output_filter = None):
-
-        """This gives control of the child process to the interactive user (the
-        human at the keyboard). Keystrokes are sent to the child process, and
-        the stdout and stderr output of the child process is printed. This
-        simply echos the child stdout and child stderr to the real stdout and
-        it echos the real stdin to the child stdin. When the user types the
-        escape_character this method will stop. The default for
-        escape_character is ^]. This should not be confused with ASCII 27 --
-        the ESC character. ASCII 29 was chosen for historical merit because
-        this is the character used by 'telnet' as the escape character. The
-        escape_character will not be sent to the child process.
-
-        You may pass in optional input and output filter functions. These
-        functions should take a string and return a string. The output_filter
-        will be passed all the output from the child process. The input_filter
-        will be passed all the keyboard input from the user. The input_filter
-        is run BEFORE the check for the escape_character.
-
-        Note that if you change the window size of the parent the SIGWINCH
-        signal will not be passed through to the child. If you want the child
-        window size to change when the parent's window size changes then do
-        something like the following example::
-
-            import pexpect, struct, fcntl, termios, signal, sys
-            def sigwinch_passthrough (sig, data):
-                s = struct.pack("HHHH", 0, 0, 0, 0)
-                a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s))
-                global p
-                p.setwinsize(a[0],a[1])
-            p = pexpect.spawn('/bin/bash') # Note this is global and used in sigwinch_passthrough.
-            signal.signal(signal.SIGWINCH, sigwinch_passthrough)
-            p.interact()
-        """
-
-        # Flush the buffer.
-        self.stdout.write (self.buffer)
-        self.stdout.flush()
-        self.buffer = ''
-        mode = tty.tcgetattr(self.STDIN_FILENO)
-        tty.setraw(self.STDIN_FILENO)
-        try:
-            self.__interact_copy(escape_character, input_filter, output_filter)
-        finally:
-            tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode)
-
-    def __interact_writen(self, fd, data):
-
-        """This is used by the interact() method.
-        """
-
-        while data != '' and self.isalive():
-            n = os.write(fd, data)
-            data = data[n:]
-
-    def __interact_read(self, fd):
-
-        """This is used by the interact() method.
-        """
-
-        return os.read(fd, 1000)
-
-    def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None):
-
-        """This is used by the interact() method.
-        """
-
-        while self.isalive():
-            r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], [])
-            if self.child_fd in r:
-                data = self.__interact_read(self.child_fd)
-                if output_filter: data = output_filter(data)
-                if self.logfile is not None:
-                    self.logfile.write (data)
-                    self.logfile.flush()
-                os.write(self.STDOUT_FILENO, data)
-            if self.STDIN_FILENO in r:
-                data = self.__interact_read(self.STDIN_FILENO)
-                if input_filter: data = input_filter(data)
-                i = data.rfind(escape_character)
-                if i != -1:
-                    data = data[:i]
-                    self.__interact_writen(self.child_fd, data)
-                    break
-                self.__interact_writen(self.child_fd, data)
-
-    def __select (self, iwtd, owtd, ewtd, timeout=None):
-
-        """This is a wrapper around select.select() that ignores signals. If
-        select.select raises a select.error exception and errno is an EINTR
-        error then it is ignored. Mainly this is used to ignore sigwinch
-        (terminal resize). """
-
-        # if select() is interrupted by a signal (errno==EINTR) then
-        # we loop back and enter the select() again.
-        if timeout is not None:
-            end_time = time.time() + timeout
-        while True:
-            try:
-                return select.select (iwtd, owtd, ewtd, timeout)
-            except select.error, e:
-                if e[0] == errno.EINTR:
-                    # if we loop back we have to subtract the amount of time we already waited.
-                    if timeout is not None:
-                        timeout = end_time - time.time()
-                        if timeout < 0:
-                            return ([],[],[])
-                else: # something else caused the select.error, so this really is an exception
-                    raise
-
-##############################################################################
-# The following methods are no longer supported or allowed.
-
-    def setmaxread (self, maxread):
-
-        """This method is no longer supported or allowed. I don't like getters
-        and setters without a good reason. """
-
-        raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the maxread member variable.')
-
-    def setlog (self, fileobject):
-
-        """This method is no longer supported or allowed.
-        """
-
-        raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the logfile member variable.')
-
-##############################################################################
-# End of spawn class
-##############################################################################
-
-class searcher_string (object):
-
-    """This is a plain string search helper for the spawn.expect_any() method.
-
-    Attributes:
-
-        eof_index     - index of EOF, or -1
-        timeout_index - index of TIMEOUT, or -1
-
-    After a successful match by the search() method the following attributes
-    are available:
-
-        start - index into the buffer, first byte of match
-        end   - index into the buffer, first byte after match
-        match - the matching string itself
-    """
-
-    def __init__(self, strings):
-
-        """This creates an instance of searcher_string. This argument 'strings'
-        may be a list; a sequence of strings; or the EOF or TIMEOUT types. """
-
-        self.eof_index = -1
-        self.timeout_index = -1
-        self._strings = []
-        for n, s in zip(range(len(strings)), strings):
-            if s is EOF:
-                self.eof_index = n
-                continue
-            if s is TIMEOUT:
-                self.timeout_index = n
-                continue
-            self._strings.append((n, s))
-
-    def __str__(self):
-
-        """This returns a human-readable string that represents the state of
-        the object."""
-
-        ss =  [ (ns[0],'    %d: "%s"' % ns) for ns in self._strings ]
-        ss.append((-1,'searcher_string:'))
-        if self.eof_index >= 0:
-            ss.append ((self.eof_index,'    %d: EOF' % self.eof_index))
-        if self.timeout_index >= 0:
-            ss.append ((self.timeout_index,'    %d: TIMEOUT' % self.timeout_index))
-        ss.sort()
-        ss = zip(*ss)[1]
-        return '\n'.join(ss)
-
-    def search(self, buffer, freshlen, searchwindowsize=None):
-
-        """This searches 'buffer' for the first occurence of one of the search
-        strings.  'freshlen' must indicate the number of bytes at the end of
-        'buffer' which have not been searched before. It helps to avoid
-        searching the same, possibly big, buffer over and over again.
-
-        See class spawn for the 'searchwindowsize' argument.
-
-        If there is a match this returns the index of that string, and sets
-        'start', 'end' and 'match'. Otherwise, this returns -1. """
-
-        absurd_match = len(buffer)
-        first_match = absurd_match
-
-        # 'freshlen' helps a lot here. Further optimizations could
-        # possibly include:
-        #
-        # using something like the Boyer-Moore Fast String Searching
-        # Algorithm; pre-compiling the search through a list of
-        # strings into something that can scan the input once to
-        # search for all N strings; realize that if we search for
-        # ['bar', 'baz'] and the input is '...foo' we need not bother
-        # rescanning until we've read three more bytes.
-        #
-        # Sadly, I don't know enough about this interesting topic. /grahn
-
-        for index, s in self._strings:
-            if searchwindowsize is None:
-                # the match, if any, can only be in the fresh data,
-                # or at the very end of the old data
-                offset = -(freshlen+len(s))
-            else:
-                # better obey searchwindowsize
-                offset = -searchwindowsize
-            n = buffer.find(s, offset)
-            if n >= 0 and n < first_match:
-                first_match = n
-                best_index, best_match = index, s
-        if first_match == absurd_match:
-            return -1
-        self.match = best_match
-        self.start = first_match
-        self.end = self.start + len(self.match)
-        return best_index
-
-class searcher_re (object):
-
-    """This is regular expression string search helper for the
-    spawn.expect_any() method.
-
-    Attributes:
-
-        eof_index     - index of EOF, or -1
-        timeout_index - index of TIMEOUT, or -1
-
-    After a successful match by the search() method the following attributes
-    are available:
-
-        start - index into the buffer, first byte of match
-        end   - index into the buffer, first byte after match
-        match - the re.match object returned by a succesful re.search
-
-    """
-
-    def __init__(self, patterns):
-
-        """This creates an instance that searches for 'patterns' Where
-        'patterns' may be a list or other sequence of compiled regular
-        expressions, or the EOF or TIMEOUT types."""
-
-        self.eof_index = -1
-        self.timeout_index = -1
-        self._searches = []
-        for n, s in zip(range(len(patterns)), patterns):
-            if s is EOF:
-                self.eof_index = n
-                continue
-            if s is TIMEOUT:
-                self.timeout_index = n
-                continue
-            self._searches.append((n, s))
-
-    def __str__(self):
-
-        """This returns a human-readable string that represents the state of
-        the object."""
-
-        ss =  [ (n,'    %d: re.compile("%s")' % (n,str(s.pattern))) for n,s in self._searches]
-        ss.append((-1,'searcher_re:'))
-        if self.eof_index >= 0:
-            ss.append ((self.eof_index,'    %d: EOF' % self.eof_index))
-        if self.timeout_index >= 0:
-            ss.append ((self.timeout_index,'    %d: TIMEOUT' % self.timeout_index))
-        ss.sort()
-        ss = zip(*ss)[1]
-        return '\n'.join(ss)
-
-    def search(self, buffer, freshlen, searchwindowsize=None):
-
-        """This searches 'buffer' for the first occurence of one of the regular
-        expressions. 'freshlen' must indicate the number of bytes at the end of
-        'buffer' which have not been searched before.
-
-        See class spawn for the 'searchwindowsize' argument.
-
-        If there is a match this returns the index of that string, and sets
-        'start', 'end' and 'match'. Otherwise, returns -1."""
-
-        absurd_match = len(buffer)
-        first_match = absurd_match
-        # 'freshlen' doesn't help here -- we cannot predict the
-        # length of a match, and the re module provides no help.
-        if searchwindowsize is None:
-            searchstart = 0
-        else:
-            searchstart = max(0, len(buffer)-searchwindowsize)
-        for index, s in self._searches:
-            match = s.search(buffer, searchstart)
-            if match is None:
-                continue
-            n = match.start()
-            if n < first_match:
-                first_match = n
-                the_match = match
-                best_index = index
-        if first_match == absurd_match:
-            return -1
-        self.start = first_match
-        self.match = the_match
-        self.end = self.match.end()
-        return best_index
-
-def which (filename):
-
-    """This takes a given filename; tries to find it in the environment path;
-    then checks if it is executable. This returns the full path to the filename
-    if found and executable. Otherwise this returns None."""
-
-    # Special case where filename already contains a path.
-    if os.path.dirname(filename) != '':
-        if os.access (filename, os.X_OK):
-            return filename
-
-    if not os.environ.has_key('PATH') or os.environ['PATH'] == '':
-        p = os.defpath
-    else:
-        p = os.environ['PATH']
-
-    # Oddly enough this was the one line that made Pexpect
-    # incompatible with Python 1.5.2.
-    pathlist = p.split(os.pathsep)
-
-    for path in pathlist:
-        f = os.path.join(path, filename)
-        if os.access(f, os.X_OK):
-            return f
-    return None
-
-def split_command_line(command_line):
-
-    """This splits a command line into a list of arguments. It splits arguments
-    on spaces, but handles embedded quotes, doublequotes, and escaped
-    characters. It's impossible to do this with a regular expression, so I
-    wrote a little state machine to parse the command line. """
-
-    arg_list = []
-    arg = ''
-
-    # Constants to name the states we can be in.
-    state_basic = 0
-    state_esc = 1
-    state_singlequote = 2
-    state_doublequote = 3
-    state_whitespace = 4 # The state of consuming whitespace between commands.
-    state = state_basic
-
-    for c in command_line:
-        if state == state_basic or state == state_whitespace:
-            if c == '\\': # Escape the next character
-                state = state_esc
-            elif c == r"'": # Handle single quote
-                state = state_singlequote
-            elif c == r'"': # Handle double quote
-                state = state_doublequote
-            elif c.isspace():
-                # Add arg to arg_list if we aren't in the middle of whitespace.
-                if state == state_whitespace:
-                    None # Do nothing.
-                else:
-                    arg_list.append(arg)
-                    arg = ''
-                    state = state_whitespace
-            else:
-                arg = arg + c
-                state = state_basic
-        elif state == state_esc:
-            arg = arg + c
-            state = state_basic
-        elif state == state_singlequote:
-            if c == r"'":
-                state = state_basic
-            else:
-                arg = arg + c
-        elif state == state_doublequote:
-            if c == r'"':
-                state = state_basic
-            else:
-                arg = arg + c
-
-    if arg != '':
-        arg_list.append(arg)
-    return arg_list
-
-# vi:ts=4:sw=4:expandtab:ft=python:
diff --git a/IPython/external/pickleshare.py b/IPython/external/pickleshare.py
new file mode 100644
index 00000000000..4aa7d8226ae
--- /dev/null
+++ b/IPython/external/pickleshare.py
@@ -0,0 +1,303 @@
+"""
+Vendoring of pickleshare, reduced to used functionalities.
+
+---
+
+PickleShare - a small 'shelve' like datastore with concurrency support
+
+Like shelve, a PickleShareDB object acts like a normal dictionary. Unlike
+shelve, many processes can access the database simultaneously. Changing a
+value in database is immediately visible to other processes accessing the
+same database.
+
+Concurrency is possible because the values are stored in separate files. Hence
+the "database" is a directory where *all* files are governed by PickleShare.
+
+Example usage::
+
+    from pickleshare import *
+    db = PickleShareDB('~/testpickleshare')
+    db.clear()
+    print "Should be empty:",db.items()
+    db['hello'] = 15
+    db['aku ankka'] = [1,2,313]
+    db['paths/are/ok/key'] = [1,(5,46)]
+    print db.keys()
+    del db['aku ankka']
+
+This module is certainly not ZODB, but can be used for low-load
+(non-mission-critical) situations where tiny code size trumps the
+advanced features of a "real" object database.
+
+Installation guide: pip install pickleshare
+
+Author: Ville Vainio <vivainio@gmail.com>
+License: MIT open source license.
+
+"""
+
+__version__ = "0.7.5"
+
+from pathlib import Path
+
+
+import os, stat, time
+
+try:
+    import collections.abc as collections_abc
+except ImportError:
+    import collections as collections_abc
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+import errno
+import sys
+
+
+def gethashfile(key):
+    return ("%02x" % abs(hash(key) % 256))[-2:]
+
+
+_sentinel = object()
+
+
+class PickleShareDB(collections_abc.MutableMapping):
+    """The main 'connection' object for PickleShare database"""
+
+    def __init__(self, root):
+        """Return a db object that will manage the specied directory"""
+        if not isinstance(root, str):
+            root = str(root)
+        root = os.path.abspath(os.path.expanduser(root))
+        self.root = Path(root)
+        if not self.root.is_dir():
+            # catching the exception is necessary if multiple processes are concurrently trying to create a folder
+            # exists_ok keyword argument of mkdir does the same but only from Python 3.5
+            try:
+                self.root.mkdir(parents=True)
+            except OSError as e:
+                if e.errno != errno.EEXIST:
+                    raise
+        # cache has { 'key' : (obj, orig_mod_time) }
+        self.cache = {}
+
+    def __getitem__(self, key):
+        """db['key'] reading"""
+        fil = self.root / key
+        try:
+            mtime = fil.stat()[stat.ST_MTIME]
+        except OSError:
+            raise KeyError(key)
+
+        if fil in self.cache and mtime == self.cache[fil][1]:
+            return self.cache[fil][0]
+        try:
+            # The cached item has expired, need to read
+            with fil.open("rb") as f:
+                obj = pickle.loads(f.read())
+        except:
+            raise KeyError(key)
+
+        self.cache[fil] = (obj, mtime)
+        return obj
+
+    def __setitem__(self, key, value):
+        """db['key'] = 5"""
+        fil = self.root / key
+        parent = fil.parent
+        if parent and not parent.is_dir():
+            parent.mkdir(parents=True)
+        # We specify protocol 2, so that we can mostly go between Python 2
+        # and Python 3. We can upgrade to protocol 3 when Python 2 is obsolete.
+        with fil.open("wb") as f:
+            pickle.dump(value, f, protocol=2)
+        try:
+            self.cache[fil] = (value, fil.stat().st_mtime)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+
+    def hset(self, hashroot, key, value):
+        """hashed set"""
+        hroot = self.root / hashroot
+        if not hroot.is_dir():
+            hroot.mkdir()
+        hfile = hroot / gethashfile(key)
+        d = self.get(hfile, {})
+        d.update({key: value})
+        self[hfile] = d
+
+    def hget(self, hashroot, key, default=_sentinel, fast_only=True):
+        """hashed get"""
+        hroot = self.root / hashroot
+        hfile = hroot / gethashfile(key)
+
+        d = self.get(hfile, _sentinel)
+        # print "got dict",d,"from",hfile
+        if d is _sentinel:
+            if fast_only:
+                if default is _sentinel:
+                    raise KeyError(key)
+
+                return default
+
+            # slow mode ok, works even after hcompress()
+            d = self.hdict(hashroot)
+
+        return d.get(key, default)
+
+    def hdict(self, hashroot):
+        """Get all data contained in hashed category 'hashroot' as dict"""
+        hfiles = self.keys(hashroot + "/*")
+        hfiles.sort()
+        last = len(hfiles) and hfiles[-1] or ""
+        if last.endswith("xx"):
+            # print "using xx"
+            hfiles = [last] + hfiles[:-1]
+
+        all = {}
+
+        for f in hfiles:
+            # print "using",f
+            try:
+                all.update(self[f])
+            except KeyError:
+                print("Corrupt", f, "deleted - hset is not threadsafe!")
+                del self[f]
+
+            self.uncache(f)
+
+        return all
+
+    def hcompress(self, hashroot):
+        """Compress category 'hashroot', so hset is fast again
+
+        hget will fail if fast_only is True for compressed items (that were
+        hset before hcompress).
+
+        """
+        hfiles = self.keys(hashroot + "/*")
+        all = {}
+        for f in hfiles:
+            # print "using",f
+            all.update(self[f])
+            self.uncache(f)
+
+        self[hashroot + "/xx"] = all
+        for f in hfiles:
+            p = self.root / f
+            if p.name == "xx":
+                continue
+            p.unlink()
+
+    def __delitem__(self, key):
+        """del db["key"]"""
+        fil = self.root / key
+        self.cache.pop(fil, None)
+        try:
+            fil.unlink()
+        except OSError:
+            # notfound and permission denied are ok - we
+            # lost, the other process wins the conflict
+            pass
+
+    def _normalized(self, p):
+        """Make a key suitable for user's eyes"""
+        return str(p.relative_to(self.root)).replace("\\", "/")
+
+    def keys(self, globpat=None):
+        """All keys in DB, or all keys matching a glob"""
+
+        if globpat is None:
+            files = self.root.rglob("*")
+        else:
+            files = self.root.glob(globpat)
+        return [self._normalized(p) for p in files if p.is_file()]
+
+    def __iter__(self):
+        return iter(self.keys())
+
+    def __len__(self):
+        return len(self.keys())
+
+    def uncache(self, *items):
+        """Removes all, or specified items from cache
+
+        Use this after reading a large amount of large objects
+        to free up memory, when you won't be needing the objects
+        for a while.
+
+        """
+        if not items:
+            self.cache = {}
+        for it in items:
+            self.cache.pop(it, None)
+
+    def waitget(self, key, maxwaittime=60):
+        """Wait (poll) for a key to get a value
+
+        Will wait for `maxwaittime` seconds before raising a KeyError.
+        The call exits normally if the `key` field in db gets a value
+        within the timeout period.
+
+        Use this for synchronizing different processes or for ensuring
+        that an unfortunately timed "db['key'] = newvalue" operation
+        in another process (which causes all 'get' operation to cause a
+        KeyError for the duration of pickling) won't screw up your program
+        logic.
+        """
+
+        wtimes = [0.2] * 3 + [0.5] * 2 + [1]
+        tries = 0
+        waited = 0
+        while 1:
+            try:
+                val = self[key]
+                return val
+            except KeyError:
+                pass
+
+            if waited > maxwaittime:
+                raise KeyError(key)
+
+            time.sleep(wtimes[tries])
+            waited += wtimes[tries]
+            if tries < len(wtimes) - 1:
+                tries += 1
+
+    def getlink(self, folder):
+        """Get a convenient link for accessing items"""
+        return PickleShareLink(self, folder)
+
+    def __repr__(self):
+        return "PickleShareDB('%s')" % self.root
+
+
+class PickleShareLink:
+    """A shortdand for accessing nested PickleShare data conveniently.
+
+    Created through PickleShareDB.getlink(), example::
+
+        lnk = db.getlink('myobjects/test')
+        lnk.foo = 2
+        lnk.bar = lnk.foo + 5
+
+    """
+
+    def __init__(self, db, keydir):
+        self.__dict__.update(locals())
+
+    def __getattr__(self, key):
+        return self.__dict__["db"][self.__dict__["keydir"] + "/" + key]
+
+    def __setattr__(self, key, val):
+        self.db[self.keydir + "/" + key] = val
+
+    def __repr__(self):
+        db = self.__dict__["db"]
+        keys = db.keys(self.__dict__["keydir"] + "/*")
+        return "<PickleShareLink '%s': %s>" % (
+            self.__dict__["keydir"],
+            ";".join([Path(k).basename() for k in keys]),
+        )
diff --git a/IPython/external/pyparsing/__init__.py b/IPython/external/pyparsing/__init__.py
deleted file mode 100644
index e8f0fda8178..00000000000
--- a/IPython/external/pyparsing/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-try:
-    from pyparsing import *
-except ImportError:
-    from _pyparsing import *
diff --git a/IPython/external/pyparsing/_pyparsing.py b/IPython/external/pyparsing/_pyparsing.py
deleted file mode 100644
index aa60fd89d41..00000000000
--- a/IPython/external/pyparsing/_pyparsing.py
+++ /dev/null
@@ -1,3708 +0,0 @@
-# -*- coding: utf-8 -*-
-# module pyparsing.py
-#
-# Copyright (c) 2003-2009  Paul T. McGuire
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-#from __future__ import generators
-
-__doc__ = \
-"""
-pyparsing module - Classes and methods to define and execute parsing grammars
-
-The pyparsing module is an alternative approach to creating and executing simple grammars,
-vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
-don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
-provides a library of classes that you use to construct the grammar directly in Python.
-
-Here is a program to parse "Hello, World!" (or any greeting of the form "<salutation>, <addressee>!")::
-
-    from pyparsing import Word, alphas
-
-    # define grammar of a greeting
-    greet = Word( alphas ) + "," + Word( alphas ) + "!"
-
-    hello = "Hello, World!"
-    print hello, "->", greet.parseString( hello )
-
-The program outputs the following::
-
-    Hello, World! -> ['Hello', ',', 'World', '!']
-
-The Python representation of the grammar is quite readable, owing to the self-explanatory
-class names, and the use of '+', '|' and '^' operators.
-
-The parsed results returned from parseString() can be accessed as a nested list, a dictionary, or an
-object with named attributes.
-
-The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
- - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
- - quoted strings
- - embedded comments
-"""
-
-__version__ = "1.5.2"
-__versionTime__ = "17 February 2009 19:45"
-__author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
-
-import string
-from weakref import ref as wkref
-import copy
-import sys
-import warnings
-import re
-import sre_constants
-#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
-
-__all__ = [
-'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
-'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
-'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
-'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
-'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
-'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 'Upcase',
-'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
-'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
-'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
-'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'getTokensEndLoc', 'hexnums',
-'htmlComment', 'javaStyleComment', 'keepOriginalText', 'line', 'lineEnd', 'lineStart', 'lineno',
-'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
-'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
-'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity', 
-'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
-'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
-'indentedBlock', 'originalTextFor',
-]
-
-
-"""
-Detect if we are running version 3.X and make appropriate changes
-Robert A. Clark
-"""
-if sys.version_info[0] > 2:
-    _PY3K = True
-    _MAX_INT = sys.maxsize
-    basestring = str
-else:
-    _PY3K = False
-    _MAX_INT = sys.maxint
-
-if not _PY3K:
-    def _ustr(obj):
-        """Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
-           str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
-           then < returns the unicode object | encodes it with the default encoding | ... >.
-        """
-        if isinstance(obj,unicode):
-            return obj
-
-        try:
-            # If this works, then _ustr(obj) has the same behaviour as str(obj), so
-            # it won't break any existing code.
-            return str(obj)
-
-        except UnicodeEncodeError:
-            # The Python docs (http://docs.python.org/ref/customization.html#l2h-182)
-            # state that "The return value must be a string object". However, does a
-            # unicode object (being a subclass of basestring) count as a "string
-            # object"?
-            # If so, then return a unicode object:
-            return unicode(obj)
-            # Else encode it... but how? There are many choices... :)
-            # Replace unprintables with escape codes?
-            #return unicode(obj).encode(sys.getdefaultencoding(), 'backslashreplace_errors')
-            # Replace unprintables with question marks?
-            #return unicode(obj).encode(sys.getdefaultencoding(), 'replace')
-            # ...
-else:
-    _ustr = str
-    unichr = chr
-
-if not _PY3K:
-	def _str2dict(strg):
-	    return dict( [(c,0) for c in strg] )
-else:
-	_str2dict = set
-
-def _xml_escape(data):
-    """Escape &, <, >, ", ', etc. in a string of data."""
-
-    # ampersand must be replaced first
-    from_symbols = '&><"\''
-    to_symbols = ['&'+s+';' for s in "amp gt lt quot apos".split()]
-    for from_,to_ in zip(from_symbols, to_symbols):
-        data = data.replace(from_, to_)
-    return data
-
-class _Constants(object):
-    pass
-
-if not _PY3K:
-    alphas     = string.lowercase + string.uppercase
-else:
-    alphas     = string.ascii_lowercase + string.ascii_uppercase
-nums       = string.digits
-hexnums    = nums + "ABCDEFabcdef"
-alphanums  = alphas + nums
-_bslash = chr(92)
-printables = "".join( [ c for c in string.printable if c not in string.whitespace ] )
-
-class ParseBaseException(Exception):
-    """base exception class for all parsing runtime exceptions"""
-    # Performance tuning: we construct a *lot* of these, so keep this
-    # constructor as small and fast as possible
-    def __init__( self, pstr, loc=0, msg=None, elem=None ):
-        self.loc = loc
-        if msg is None:
-            self.msg = pstr
-            self.pstr = ""
-        else:
-            self.msg = msg
-            self.pstr = pstr
-        self.parserElement = elem
-
-    def __getattr__( self, aname ):
-        """supported attributes by name are:
-            - lineno - returns the line number of the exception text
-            - col - returns the column number of the exception text
-            - line - returns the line containing the exception text
-        """
-        if( aname == "lineno" ):
-            return lineno( self.loc, self.pstr )
-        elif( aname in ("col", "column") ):
-            return col( self.loc, self.pstr )
-        elif( aname == "line" ):
-            return line( self.loc, self.pstr )
-        else:
-            raise AttributeError(aname)
-
-    def __str__( self ):
-        return "%s (at char %d), (line:%d, col:%d)" % \
-                ( self.msg, self.loc, self.lineno, self.column )
-    def __repr__( self ):
-        return _ustr(self)
-    def markInputline( self, markerString = ">!<" ):
-        """Extracts the exception line from the input string, and marks
-           the location of the exception with a special symbol.
-        """
-        line_str = self.line
-        line_column = self.column - 1
-        if markerString:
-            line_str = "".join( [line_str[:line_column],
-                                markerString, line_str[line_column:]])
-        return line_str.strip()
-    def __dir__(self):
-        return "loc msg pstr parserElement lineno col line " \
-               "markInputLine __str__ __repr__".split()
-
-class ParseException(ParseBaseException):
-    """exception thrown when parse expressions don't match class;
-       supported attributes by name are:
-        - lineno - returns the line number of the exception text
-        - col - returns the column number of the exception text
-        - line - returns the line containing the exception text
-    """
-    pass
-
-class ParseFatalException(ParseBaseException):
-    """user-throwable exception thrown when inconsistent parse content
-       is found; stops all parsing immediately"""
-    pass
-
-class ParseSyntaxException(ParseFatalException):
-    """just like ParseFatalException, but thrown internally when an
-       ErrorStop indicates that parsing is to stop immediately because
-       an unbacktrackable syntax error has been found"""
-    def __init__(self, pe):
-        super(ParseSyntaxException, self).__init__(
-                                    pe.pstr, pe.loc, pe.msg, pe.parserElement)
-
-#~ class ReparseException(ParseBaseException):
-    #~ """Experimental class - parse actions can raise this exception to cause
-       #~ pyparsing to reparse the input string:
-        #~ - with a modified input string, and/or
-        #~ - with a modified start location
-       #~ Set the values of the ReparseException in the constructor, and raise the
-       #~ exception in a parse action to cause pyparsing to use the new string/location.
-       #~ Setting the values as None causes no change to be made.
-       #~ """
-    #~ def __init_( self, newstring, restartLoc ):
-        #~ self.newParseText = newstring
-        #~ self.reparseLoc = restartLoc
-
-class RecursiveGrammarException(Exception):
-    """exception thrown by validate() if the grammar could be improperly recursive"""
-    def __init__( self, parseElementList ):
-        self.parseElementTrace = parseElementList
-
-    def __str__( self ):
-        return "RecursiveGrammarException: %s" % self.parseElementTrace
-
-class _ParseResultsWithOffset(object):
-    def __init__(self,p1,p2):
-        self.tup = (p1,p2)
-    def __getitem__(self,i):
-        return self.tup[i]
-    def __repr__(self):
-        return repr(self.tup)
-    def setOffset(self,i):
-        self.tup = (self.tup[0],i)
-
-class ParseResults(object):
-    """Structured parse results, to provide multiple means of access to the parsed data:
-       - as a list (len(results))
-       - by list index (results[0], results[1], etc.)
-       - by attribute (results.<resultsName>)
-       """
-    __slots__ = ( "__toklist", "__tokdict", "__doinit", "__name", "__parent", "__accumNames", "__weakref__" )
-    def __new__(cls, toklist, name=None, asList=True, modal=True ):
-        if isinstance(toklist, cls):
-            return toklist
-        retobj = object.__new__(cls)
-        retobj.__doinit = True
-        return retobj
-
-    # Performance tuning: we construct a *lot* of these, so keep this
-    # constructor as small and fast as possible
-    def __init__( self, toklist, name=None, asList=True, modal=True ):
-        if self.__doinit:
-            self.__doinit = False
-            self.__name = None
-            self.__parent = None
-            self.__accumNames = {}
-            if isinstance(toklist, list):
-                self.__toklist = toklist[:]
-            else:
-                self.__toklist = [toklist]
-            self.__tokdict = dict()
-
-        if name:
-            if not modal:
-                self.__accumNames[name] = 0
-            if isinstance(name,int):
-                name = _ustr(name) # will always return a str, but use _ustr for consistency
-            self.__name = name
-            if not toklist in (None,'',[]):
-                if isinstance(toklist,basestring):
-                    toklist = [ toklist ]
-                if asList:
-                    if isinstance(toklist,ParseResults):
-                        self[name] = _ParseResultsWithOffset(toklist.copy(),0)
-                    else:
-                        self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
-                    self[name].__name = name
-                else:
-                    try:
-                        self[name] = toklist[0]
-                    except (KeyError,TypeError,IndexError):
-                        self[name] = toklist
-
-    def __getitem__( self, i ):
-        if isinstance( i, (int,slice) ):
-            return self.__toklist[i]
-        else:
-            if i not in self.__accumNames:
-                return self.__tokdict[i][-1][0]
-            else:
-                return ParseResults([ v[0] for v in self.__tokdict[i] ])
-
-    def __setitem__( self, k, v ):
-        if isinstance(v,_ParseResultsWithOffset):
-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
-            sub = v[0]
-        elif isinstance(k,int):
-            self.__toklist[k] = v
-            sub = v
-        else:
-            self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
-            sub = v
-        if isinstance(sub,ParseResults):
-            sub.__parent = wkref(self)
-
-    def __delitem__( self, i ):
-        if isinstance(i,(int,slice)):
-            mylen = len( self.__toklist )
-            del self.__toklist[i]
-
-            # convert int to slice
-            if isinstance(i, int):
-                if i < 0:
-                    i += mylen
-                i = slice(i, i+1)
-            # get removed indices
-            removed = list(range(*i.indices(mylen)))
-            removed.reverse()
-            # fixup indices in token dictionary
-            for name in self.__tokdict:
-                occurrences = self.__tokdict[name]
-                for j in removed:
-                    for k, (value, position) in enumerate(occurrences):
-                        occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
-        else:
-            del self.__tokdict[i]
-
-    def __contains__( self, k ):
-        return k in self.__tokdict
-
-    def __len__( self ): return len( self.__toklist )
-    def __bool__(self): return len( self.__toklist ) > 0
-    __nonzero__ = __bool__
-    def __iter__( self ): return iter( self.__toklist )
-    def __reversed__( self ): return iter( reversed(self.__toklist) )
-    def keys( self ):
-        """Returns all named result keys."""
-        return self.__tokdict.keys()
-
-    def pop( self, index=-1 ):
-        """Removes and returns item at specified index (default=last).
-           Will work with either numeric indices or dict-key indicies."""
-        ret = self[index]
-        del self[index]
-        return ret
-
-    def get(self, key, defaultValue=None):
-        """Returns named result matching the given key, or if there is no
-           such name, then returns the given defaultValue or None if no
-           defaultValue is specified."""
-        if key in self:
-            return self[key]
-        else:
-            return defaultValue
-
-    def insert( self, index, insStr ):
-        self.__toklist.insert(index, insStr)
-        # fixup indices in token dictionary
-        for name in self.__tokdict:
-            occurrences = self.__tokdict[name]
-            for k, (value, position) in enumerate(occurrences):
-                occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
-
-    def items( self ):
-        """Returns all named result keys and values as a list of tuples."""
-        return [(k,self[k]) for k in self.__tokdict]
-
-    def values( self ):
-        """Returns all named result values."""
-        return [ v[-1][0] for v in self.__tokdict.itervalues() ]
-
-    def __getattr__( self, name ):
-        if name not in self.__slots__:
-            if name in self.__tokdict:
-                if name not in self.__accumNames:
-                    return self.__tokdict[name][-1][0]
-                else:
-                    return ParseResults([ v[0] for v in self.__tokdict[name] ])
-            else:
-                return ""
-        return None
-
-    def __add__( self, other ):
-        ret = self.copy()
-        ret += other
-        return ret
-
-    def __iadd__( self, other ):
-        if other.__tokdict:
-            offset = len(self.__toklist)
-            addoffset = ( lambda a: (a<0 and offset) or (a+offset) )
-            otheritems = other.__tokdict.iteritems()
-            otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
-                                for (k,vlist) in otheritems for v in vlist]
-            for k,v in otherdictitems:
-                self[k] = v
-                if isinstance(v[0],ParseResults):
-                    v[0].__parent = wkref(self)
-            
-        self.__toklist += other.__toklist
-        self.__accumNames.update( other.__accumNames )
-        del other
-        return self
-
-    def __repr__( self ):
-        return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
-
-    def __str__( self ):
-        out = "["
-        sep = ""
-        for i in self.__toklist:
-            if isinstance(i, ParseResults):
-                out += sep + _ustr(i)
-            else:
-                out += sep + repr(i)
-            sep = ", "
-        out += "]"
-        return out
-
-    def _asStringList( self, sep='' ):
-        out = []
-        for item in self.__toklist:
-            if out and sep:
-                out.append(sep)
-            if isinstance( item, ParseResults ):
-                out += item._asStringList()
-            else:
-                out.append( _ustr(item) )
-        return out
-
-    def asList( self ):
-        """Returns the parse results as a nested list of matching tokens, all converted to strings."""
-        out = []
-        for res in self.__toklist:
-            if isinstance(res,ParseResults):
-                out.append( res.asList() )
-            else:
-                out.append( res )
-        return out
-
-    def asDict( self ):
-        """Returns the named parse results as dictionary."""
-        return dict( self.items() )
-
-    def copy( self ):
-        """Returns a new copy of a ParseResults object."""
-        ret = ParseResults( self.__toklist )
-        ret.__tokdict = self.__tokdict.copy()
-        ret.__parent = self.__parent
-        ret.__accumNames.update( self.__accumNames )
-        ret.__name = self.__name
-        return ret
-
-    def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
-        """Returns the parse results as XML. Tags are created for tokens and lists that have defined results names."""
-        nl = "\n"
-        out = []
-        namedItems = dict([(v[1],k) for (k,vlist) in self.__tokdict.iteritems()
-                                                            for v in vlist ] )
-        nextLevelIndent = indent + "  "
-
-        # collapse out indents if formatting is not desired
-        if not formatted:
-            indent = ""
-            nextLevelIndent = ""
-            nl = ""
-
-        selfTag = None
-        if doctag is not None:
-            selfTag = doctag
-        else:
-            if self.__name:
-                selfTag = self.__name
-
-        if not selfTag:
-            if namedItemsOnly:
-                return ""
-            else:
-                selfTag = "ITEM"
-
-        out += [ nl, indent, "<", selfTag, ">" ]
-
-        worklist = self.__toklist
-        for i,res in enumerate(worklist):
-            if isinstance(res,ParseResults):
-                if i in namedItems:
-                    out += [ res.asXML(namedItems[i],
-                                        namedItemsOnly and doctag is None,
-                                        nextLevelIndent,
-                                        formatted)]
-                else:
-                    out += [ res.asXML(None,
-                                        namedItemsOnly and doctag is None,
-                                        nextLevelIndent,
-                                        formatted)]
-            else:
-                # individual token, see if there is a name for it
-                resTag = None
-                if i in namedItems:
-                    resTag = namedItems[i]
-                if not resTag:
-                    if namedItemsOnly:
-                        continue
-                    else:
-                        resTag = "ITEM"
-                xmlBodyText = _xml_escape(_ustr(res))
-                out += [ nl, nextLevelIndent, "<", resTag, ">",
-                                                xmlBodyText,
-                                                "</", resTag, ">" ]
-
-        out += [ nl, indent, "</", selfTag, ">" ]
-        return "".join(out)
-
-    def __lookup(self,sub):
-        for k,vlist in self.__tokdict.iteritems():
-            for v,loc in vlist:
-                if sub is v:
-                    return k
-        return None
-
-    def getName(self):
-        """Returns the results name for this token expression."""
-        if self.__name:
-            return self.__name
-        elif self.__parent:
-            par = self.__parent()
-            if par:
-                return par.__lookup(self)
-            else:
-                return None
-        elif (len(self) == 1 and
-               len(self.__tokdict) == 1 and
-               self.__tokdict.values()[0][0][1] in (0,-1)):
-            return self.__tokdict.keys()[0]
-        else:
-            return None
-
-    def dump(self,indent='',depth=0):
-        """Diagnostic method for listing out the contents of a ParseResults.
-           Accepts an optional indent argument so that this string can be embedded
-           in a nested display of other data."""
-        out = []
-        out.append( indent+_ustr(self.asList()) )
-        keys = self.items()
-        keys.sort()
-        for k,v in keys:
-            if out:
-                out.append('\n')
-            out.append( "%s%s- %s: " % (indent,('  '*depth), k) )
-            if isinstance(v,ParseResults):
-                if v.keys():
-                    #~ out.append('\n')
-                    out.append( v.dump(indent,depth+1) )
-                    #~ out.append('\n')
-                else:
-                    out.append(_ustr(v))
-            else:
-                out.append(_ustr(v))
-        #~ out.append('\n')
-        return "".join(out)
-
-    # add support for pickle protocol
-    def __getstate__(self):
-        return ( self.__toklist,
-                 ( self.__tokdict.copy(),
-                   self.__parent is not None and self.__parent() or None,
-                   self.__accumNames,
-                   self.__name ) )
-
-    def __setstate__(self,state):
-        self.__toklist = state[0]
-        self.__tokdict, \
-        par, \
-        inAccumNames, \
-        self.__name = state[1]
-        self.__accumNames = {}
-        self.__accumNames.update(inAccumNames)
-        if par is not None:
-            self.__parent = wkref(par)
-        else:
-            self.__parent = None
-
-    def __dir__(self):
-        return dir(super(ParseResults,self)) + self.keys()
-
-def col (loc,strg):
-    """Returns current column within a string, counting newlines as line separators.
-   The first column is number 1.
-
-   Note: the default parsing behavior is to expand tabs in the input string
-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
-   on parsing strings containing <TAB>s, and suggested methods to maintain a
-   consistent view of the parsed string, the parse location, and line and column
-   positions within the parsed string.
-   """
-    return (loc<len(strg) and strg[loc] == '\n') and 1 or loc - strg.rfind("\n", 0, loc)
-
-def lineno(loc,strg):
-    """Returns current line number within a string, counting newlines as line separators.
-   The first line is number 1.
-
-   Note: the default parsing behavior is to expand tabs in the input string
-   before starting the parsing process.  See L{I{ParserElement.parseString}<ParserElement.parseString>} for more information
-   on parsing strings containing <TAB>s, and suggested methods to maintain a
-   consistent view of the parsed string, the parse location, and line and column
-   positions within the parsed string.
-   """
-    return strg.count("\n",0,loc) + 1
-
-def line( loc, strg ):
-    """Returns the line of text containing loc within a string, counting newlines as line separators.
-       """
-    lastCR = strg.rfind("\n", 0, loc)
-    nextCR = strg.find("\n", loc)
-    if nextCR > 0:
-        return strg[lastCR+1:nextCR]
-    else:
-        return strg[lastCR+1:]
-
-def _defaultStartDebugAction( instring, loc, expr ):
-    print ("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
-
-def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
-    print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
-
-def _defaultExceptionDebugAction( instring, loc, expr, exc ):
-    print ("Exception raised:" + _ustr(exc))
-
-def nullDebugAction(*args):
-    """'Do-nothing' debug action, to suppress debugging output during parsing."""
-    pass
-
-class ParserElement(object):
-    """Abstract base level parser element class."""
-    DEFAULT_WHITE_CHARS = " \n\t\r"
-
-    def setDefaultWhitespaceChars( chars ):
-        """Overrides the default whitespace chars
-        """
-        ParserElement.DEFAULT_WHITE_CHARS = chars
-    setDefaultWhitespaceChars = staticmethod(setDefaultWhitespaceChars)
-
-    def __init__( self, savelist=False ):
-        self.parseAction = list()
-        self.failAction = None
-        #~ self.name = "<unknown>"  # don't define self.name, let subclasses try/except upcall
-        self.strRepr = None
-        self.resultsName = None
-        self.saveAsList = savelist
-        self.skipWhitespace = True
-        self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
-        self.copyDefaultWhiteChars = True
-        self.mayReturnEmpty = False # used when checking for left-recursion
-        self.keepTabs = False
-        self.ignoreExprs = list()
-        self.debug = False
-        self.streamlined = False
-        self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
-        self.errmsg = ""
-        self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
-        self.debugActions = ( None, None, None ) #custom debug actions
-        self.re = None
-        self.callPreparse = True # used to avoid redundant calls to preParse
-        self.callDuringTry = False
-
-    def copy( self ):
-        """Make a copy of this ParserElement.  Useful for defining different parse actions
-           for the same parsing pattern, using copies of the original parse element."""
-        cpy = copy.copy( self )
-        cpy.parseAction = self.parseAction[:]
-        cpy.ignoreExprs = self.ignoreExprs[:]
-        if self.copyDefaultWhiteChars:
-            cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
-        return cpy
-
-    def setName( self, name ):
-        """Define name for this expression, for use in debugging."""
-        self.name = name
-        self.errmsg = "Expected " + self.name
-        if hasattr(self,"exception"):
-            self.exception.msg = self.errmsg
-        return self
-
-    def setResultsName( self, name, listAllMatches=False ):
-        """Define name for referencing matching tokens as a nested attribute
-           of the returned parse results.
-           NOTE: this returns a *copy* of the original ParserElement object;
-           this is so that the client can define a basic element, such as an
-           integer, and reference it in multiple places with different names.
-        """
-        newself = self.copy()
-        newself.resultsName = name
-        newself.modalResults = not listAllMatches
-        return newself
-
-    def setBreak(self,breakFlag = True):
-        """Method to invoke the Python pdb debugger when this element is
-           about to be parsed. Set breakFlag to True to enable, False to
-           disable.
-        """
-        if breakFlag:
-            _parseMethod = self._parse
-            def breaker(instring, loc, doActions=True, callPreParse=True):
-                import pdb
-                pdb.set_trace()
-                return _parseMethod( instring, loc, doActions, callPreParse )
-            breaker._originalParseMethod = _parseMethod
-            self._parse = breaker
-        else:
-            if hasattr(self._parse,"_originalParseMethod"):
-                self._parse = self._parse._originalParseMethod
-        return self
-
-    def _normalizeParseActionArgs( f ):
-        """Internal method used to decorate parse actions that take fewer than 3 arguments,
-           so that all parse actions can be called as f(s,l,t)."""
-        STAR_ARGS = 4
-
-        try:
-            restore = None
-            if isinstance(f,type):
-                restore = f
-                f = f.__init__
-            if not _PY3K:
-                codeObj = f.func_code
-            else:
-                codeObj = f.code
-            if codeObj.co_flags & STAR_ARGS:
-                return f
-            numargs = codeObj.co_argcount
-            if not _PY3K:
-                if hasattr(f,"im_self"):
-                    numargs -= 1
-            else:
-                if hasattr(f,"__self__"):
-                    numargs -= 1
-            if restore:
-                f = restore
-        except AttributeError:
-            try:
-                if not _PY3K:
-                    call_im_func_code = f.__call__.im_func.func_code
-                else:
-                    call_im_func_code = f.__code__
-
-                # not a function, must be a callable object, get info from the
-                # im_func binding of its bound __call__ method
-                if call_im_func_code.co_flags & STAR_ARGS:
-                    return f
-                numargs = call_im_func_code.co_argcount
-                if not _PY3K:
-                    if hasattr(f.__call__,"im_self"):
-                        numargs -= 1
-                else:
-                    if hasattr(f.__call__,"__self__"):
-                        numargs -= 0
-            except AttributeError:
-                if not _PY3K:
-                    call_func_code = f.__call__.func_code
-                else:
-                    call_func_code = f.__call__.__code__
-                # not a bound method, get info directly from __call__ method
-                if call_func_code.co_flags & STAR_ARGS:
-                    return f
-                numargs = call_func_code.co_argcount
-                if not _PY3K:
-                    if hasattr(f.__call__,"im_self"):
-                        numargs -= 1
-                else:
-                    if hasattr(f.__call__,"__self__"):
-                        numargs -= 1
-
-
-        #~ print ("adding function %s with %d args" % (f.func_name,numargs))
-        if numargs == 3:
-            return f
-        else:
-            if numargs > 3:
-                def tmp(s,l,t):
-                    return f(f.__call__.__self__, s,l,t)
-            if numargs == 2:
-                def tmp(s,l,t):
-                    return f(l,t)
-            elif numargs == 1:
-                def tmp(s,l,t):
-                    return f(t)
-            else: #~ numargs == 0:
-                def tmp(s,l,t):
-                    return f()
-            try:
-                tmp.__name__ = f.__name__
-            except (AttributeError,TypeError):
-                # no need for special handling if attribute doesnt exist
-                pass
-            try:
-                tmp.__doc__ = f.__doc__
-            except (AttributeError,TypeError):
-                # no need for special handling if attribute doesnt exist
-                pass
-            try:
-                tmp.__dict__.update(f.__dict__)
-            except (AttributeError,TypeError):
-                # no need for special handling if attribute doesnt exist
-                pass
-            return tmp
-    _normalizeParseActionArgs = staticmethod(_normalizeParseActionArgs)
-
-    def setParseAction( self, *fns, **kwargs ):
-        """Define action to perform when successfully matching parse element definition.
-           Parse action fn is a callable method with 0-3 arguments, called as fn(s,loc,toks),
-           fn(loc,toks), fn(toks), or just fn(), where:
-            - s   = the original string being parsed (see note below)
-            - loc = the location of the matching substring
-            - toks = a list of the matched tokens, packaged as a ParseResults object
-           If the functions in fns modify the tokens, they can return them as the return
-           value from fn, and the modified list of tokens will replace the original.
-           Otherwise, fn does not need to return any value.
-
-           Note: the default parsing behavior is to expand tabs in the input string
-           before starting the parsing process.  See L{I{parseString}<parseString>} for more information
-           on parsing strings containing <TAB>s, and suggested methods to maintain a
-           consistent view of the parsed string, the parse location, and line and column
-           positions within the parsed string.
-           """
-        self.parseAction = list(map(self._normalizeParseActionArgs, list(fns)))
-        self.callDuringTry = ("callDuringTry" in kwargs and kwargs["callDuringTry"])
-        return self
-
-    def addParseAction( self, *fns, **kwargs ):
-        """Add parse action to expression's list of parse actions. See L{I{setParseAction}<setParseAction>}."""
-        self.parseAction += list(map(self._normalizeParseActionArgs, list(fns)))
-        self.callDuringTry = self.callDuringTry or ("callDuringTry" in kwargs and kwargs["callDuringTry"])
-        return self
-
-    def setFailAction( self, fn ):
-        """Define action to perform if parsing fails at this expression.
-           Fail acton fn is a callable function that takes the arguments
-           fn(s,loc,expr,err) where:
-            - s = string being parsed
-            - loc = location where expression match was attempted and failed
-            - expr = the parse expression that failed
-            - err = the exception thrown
-           The function returns no value.  It may throw ParseFatalException
-           if it is desired to stop parsing immediately."""
-        self.failAction = fn
-        return self
-
-    def _skipIgnorables( self, instring, loc ):
-        exprsFound = True
-        while exprsFound:
-            exprsFound = False
-            for e in self.ignoreExprs:
-                try:
-                    while 1:
-                        loc,dummy = e._parse( instring, loc )
-                        exprsFound = True
-                except ParseException:
-                    pass
-        return loc
-
-    def preParse( self, instring, loc ):
-        if self.ignoreExprs:
-            loc = self._skipIgnorables( instring, loc )
-
-        if self.skipWhitespace:
-            wt = self.whiteChars
-            instrlen = len(instring)
-            while loc < instrlen and instring[loc] in wt:
-                loc += 1
-
-        return loc
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        return loc, []
-
-    def postParse( self, instring, loc, tokenlist ):
-        return tokenlist
-
-    #~ @profile
-    def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
-        debugging = ( self.debug ) #and doActions )
-
-        if debugging or self.failAction:
-            #~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
-            if (self.debugActions[0] ):
-                self.debugActions[0]( instring, loc, self )
-            if callPreParse and self.callPreparse:
-                preloc = self.preParse( instring, loc )
-            else:
-                preloc = loc
-            tokensStart = loc
-            try:
-                try:
-                    loc,tokens = self.parseImpl( instring, preloc, doActions )
-                except IndexError:
-                    raise ParseException( instring, len(instring), self.errmsg, self )
-            except ParseBaseException, err:
-                #~ print ("Exception raised:", err)
-                if self.debugActions[2]:
-                    self.debugActions[2]( instring, tokensStart, self, err )
-                if self.failAction:
-                    self.failAction( instring, tokensStart, self, err )
-                raise
-        else:
-            if callPreParse and self.callPreparse:
-                preloc = self.preParse( instring, loc )
-            else:
-                preloc = loc
-            tokensStart = loc
-            if self.mayIndexError or loc >= len(instring):
-                try:
-                    loc,tokens = self.parseImpl( instring, preloc, doActions )
-                except IndexError:
-                    raise ParseException( instring, len(instring), self.errmsg, self )
-            else:
-                loc,tokens = self.parseImpl( instring, preloc, doActions )
-
-        tokens = self.postParse( instring, loc, tokens )
-
-        retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
-        if self.parseAction and (doActions or self.callDuringTry):
-            if debugging:
-                try:
-                    for fn in self.parseAction:
-                        tokens = fn( instring, tokensStart, retTokens )
-                        if tokens is not None:
-                            retTokens = ParseResults( tokens,
-                                                      self.resultsName,
-                                                      asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
-                                                      modal=self.modalResults )
-                except ParseBaseException, err:
-                    #~ print "Exception raised in user parse action:", err
-                    if (self.debugActions[2] ):
-                        self.debugActions[2]( instring, tokensStart, self, err )
-                    raise
-            else:
-                for fn in self.parseAction:
-                    tokens = fn( instring, tokensStart, retTokens )
-                    if tokens is not None:
-                        retTokens = ParseResults( tokens,
-                                                  self.resultsName,
-                                                  asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
-                                                  modal=self.modalResults )
-
-        if debugging:
-            #~ print ("Matched",self,"->",retTokens.asList())
-            if (self.debugActions[1] ):
-                self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
-
-        return loc, retTokens
-
-    def tryParse( self, instring, loc ):
-        try:
-            return self._parse( instring, loc, doActions=False )[0]
-        except ParseFatalException:
-            raise ParseException( instring, loc, self.errmsg, self)
-
-    # this method gets repeatedly called during backtracking with the same arguments -
-    # we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
-    def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
-        lookup = (self,instring,loc,callPreParse,doActions)
-        if lookup in ParserElement._exprArgCache:
-            value = ParserElement._exprArgCache[ lookup ]
-            if isinstance(value,Exception):
-                raise value
-            return value
-        else:
-            try:
-                value = self._parseNoCache( instring, loc, doActions, callPreParse )
-                ParserElement._exprArgCache[ lookup ] = (value[0],value[1].copy())
-                return value
-            except ParseBaseException, pe:
-                ParserElement._exprArgCache[ lookup ] = pe
-                raise
-
-    _parse = _parseNoCache
-
-    # argument cache for optimizing repeated calls when backtracking through recursive expressions
-    _exprArgCache = {}
-    def resetCache():
-        ParserElement._exprArgCache.clear()
-    resetCache = staticmethod(resetCache)
-
-    _packratEnabled = False
-    def enablePackrat():
-        """Enables "packrat" parsing, which adds memoizing to the parsing logic.
-           Repeated parse attempts at the same string location (which happens
-           often in many complex grammars) can immediately return a cached value,
-           instead of re-executing parsing/validating code.  Memoizing is done of
-           both valid results and parsing exceptions.
-
-           This speedup may break existing programs that use parse actions that
-           have side-effects.  For this reason, packrat parsing is disabled when
-           you first import pyparsing.  To activate the packrat feature, your
-           program must call the class method ParserElement.enablePackrat().  If
-           your program uses psyco to "compile as you go", you must call
-           enablePackrat before calling psyco.full().  If you do not do this,
-           Python will crash.  For best results, call enablePackrat() immediately
-           after importing pyparsing.
-        """
-        if not ParserElement._packratEnabled:
-            ParserElement._packratEnabled = True
-            ParserElement._parse = ParserElement._parseCache
-    enablePackrat = staticmethod(enablePackrat)
-
-    def parseString( self, instring, parseAll=False ):
-        """Execute the parse expression with the given string.
-           This is the main interface to the client code, once the complete
-           expression has been built.
-
-           If you want the grammar to require that the entire input string be
-           successfully parsed, then set parseAll to True (equivalent to ending
-           the grammar with StringEnd()).
-
-           Note: parseString implicitly calls expandtabs() on the input string,
-           in order to report proper column numbers in parse actions.
-           If the input string contains tabs and
-           the grammar uses parse actions that use the loc argument to index into the
-           string being parsed, you can ensure you have a consistent view of the input
-           string by:
-            - calling parseWithTabs on your grammar before calling parseString
-              (see L{I{parseWithTabs}<parseWithTabs>})
-            - define your parse action using the full (s,loc,toks) signature, and
-              reference the input string using the parse action's s argument
-            - explictly expand the tabs in your input string before calling
-              parseString
-        """
-        ParserElement.resetCache()
-        if not self.streamlined:
-            self.streamline()
-            #~ self.saveAsList = True
-        for e in self.ignoreExprs:
-            e.streamline()
-        if not self.keepTabs:
-            instring = instring.expandtabs()
-        try:
-            loc, tokens = self._parse( instring, 0 )
-            if parseAll:
-                loc = self.preParse( instring, loc )
-                StringEnd()._parse( instring, loc )
-        except ParseBaseException, exc:
-            # catch and re-raise exception from here, clears out pyparsing internal stack trace
-            raise exc
-        else:
-            return tokens
-
-    def scanString( self, instring, maxMatches=_MAX_INT ):
-        """Scan the input string for expression matches.  Each match will return the
-           matching tokens, start location, and end location.  May be called with optional
-           maxMatches argument, to clip scanning after 'n' matches are found.
-
-           Note that the start and end locations are reported relative to the string
-           being parsed.  See L{I{parseString}<parseString>} for more information on parsing
-           strings with embedded tabs."""
-        if not self.streamlined:
-            self.streamline()
-        for e in self.ignoreExprs:
-            e.streamline()
-
-        if not self.keepTabs:
-            instring = _ustr(instring).expandtabs()
-        instrlen = len(instring)
-        loc = 0
-        preparseFn = self.preParse
-        parseFn = self._parse
-        ParserElement.resetCache()
-        matches = 0
-        try:
-            while loc <= instrlen and matches < maxMatches:
-                try:
-                    preloc = preparseFn( instring, loc )
-                    nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
-                except ParseException:
-                    loc = preloc+1
-                else:
-                    matches += 1
-                    yield tokens, preloc, nextLoc
-                    loc = nextLoc
-        except ParseBaseException, pe:
-            raise pe
-
-    def transformString( self, instring ):
-        """Extension to scanString, to modify matching text with modified tokens that may
-           be returned from a parse action.  To use transformString, define a grammar and
-           attach a parse action to it that modifies the returned token list.
-           Invoking transformString() on a target string will then scan for matches,
-           and replace the matched text patterns according to the logic in the parse
-           action.  transformString() returns the resulting transformed string."""
-        out = []
-        lastE = 0
-        # force preservation of <TAB>s, to minimize unwanted transformation of string, and to
-        # keep string locs straight between transformString and scanString
-        self.keepTabs = True
-        try:
-            for t,s,e in self.scanString( instring ):
-                out.append( instring[lastE:s] )
-                if t:
-                    if isinstance(t,ParseResults):
-                        out += t.asList()
-                    elif isinstance(t,list):
-                        out += t
-                    else:
-                        out.append(t)
-                lastE = e
-            out.append(instring[lastE:])
-            return "".join(map(_ustr,out))
-        except ParseBaseException, pe:
-            raise pe
-
-    def searchString( self, instring, maxMatches=_MAX_INT ):
-        """Another extension to scanString, simplifying the access to the tokens found
-           to match the given parse expression.  May be called with optional
-           maxMatches argument, to clip searching after 'n' matches are found.
-        """
-        try:
-            return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
-        except ParseBaseException, pe:
-            raise pe
-
-    def __add__(self, other ):
-        """Implementation of + operator - returns And"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return And( [ self, other ] )
-
-    def __radd__(self, other ):
-        """Implementation of + operator when left operand is not a ParserElement"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other + self
-
-    def __sub__(self, other):
-        """Implementation of - operator, returns And with error stop"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return And( [ self, And._ErrorStop(), other ] )
-
-    def __rsub__(self, other ):
-        """Implementation of - operator when left operand is not a ParserElement"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other - self
-
-    def __mul__(self,other):
-        if isinstance(other,int):
-            minElements, optElements = other,0
-        elif isinstance(other,tuple):
-            other = (other + (None, None))[:2]
-            if other[0] is None:
-                other = (0, other[1])
-            if isinstance(other[0],int) and other[1] is None:
-                if other[0] == 0:
-                    return ZeroOrMore(self)
-                if other[0] == 1:
-                    return OneOrMore(self)
-                else:
-                    return self*other[0] + ZeroOrMore(self)
-            elif isinstance(other[0],int) and isinstance(other[1],int):
-                minElements, optElements = other
-                optElements -= minElements
-            else:
-                raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
-        else:
-            raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
-
-        if minElements < 0:
-            raise ValueError("cannot multiply ParserElement by negative value")
-        if optElements < 0:
-            raise ValueError("second tuple value must be greater or equal to first tuple value")
-        if minElements == optElements == 0:
-            raise ValueError("cannot multiply ParserElement by 0 or (0,0)")
-
-        if (optElements):
-            def makeOptionalList(n):
-                if n>1:
-                    return Optional(self + makeOptionalList(n-1))
-                else:
-                    return Optional(self)
-            if minElements:
-                if minElements == 1:
-                    ret = self + makeOptionalList(optElements)
-                else:
-                    ret = And([self]*minElements) + makeOptionalList(optElements)
-            else:
-                ret = makeOptionalList(optElements)
-        else:
-            if minElements == 1:
-                ret = self
-            else:
-                ret = And([self]*minElements)
-        return ret
-
-    def __rmul__(self, other):
-        return self.__mul__(other)
-
-    def __or__(self, other ):
-        """Implementation of | operator - returns MatchFirst"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return MatchFirst( [ self, other ] )
-
-    def __ror__(self, other ):
-        """Implementation of | operator when left operand is not a ParserElement"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other | self
-
-    def __xor__(self, other ):
-        """Implementation of ^ operator - returns Or"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return Or( [ self, other ] )
-
-    def __rxor__(self, other ):
-        """Implementation of ^ operator when left operand is not a ParserElement"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other ^ self
-
-    def __and__(self, other ):
-        """Implementation of & operator - returns Each"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return Each( [ self, other ] )
-
-    def __rand__(self, other ):
-        """Implementation of & operator when left operand is not a ParserElement"""
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        if not isinstance( other, ParserElement ):
-            warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
-                    SyntaxWarning, stacklevel=2)
-            return None
-        return other & self
-
-    def __invert__( self ):
-        """Implementation of ~ operator - returns NotAny"""
-        return NotAny( self )
-
-    def __call__(self, name):
-        """Shortcut for setResultsName, with listAllMatches=default::
-             userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
-           could be written as::
-             userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")
-           """
-        return self.setResultsName(name)
-
-    def suppress( self ):
-        """Suppresses the output of this ParserElement; useful to keep punctuation from
-           cluttering up returned output.
-        """
-        return Suppress( self )
-
-    def leaveWhitespace( self ):
-        """Disables the skipping of whitespace before matching the characters in the
-           ParserElement's defined pattern.  This is normally only used internally by
-           the pyparsing module, but may be needed in some whitespace-sensitive grammars.
-        """
-        self.skipWhitespace = False
-        return self
-
-    def setWhitespaceChars( self, chars ):
-        """Overrides the default whitespace chars
-        """
-        self.skipWhitespace = True
-        self.whiteChars = chars
-        self.copyDefaultWhiteChars = False
-        return self
-
-    def parseWithTabs( self ):
-        """Overrides default behavior to expand <TAB>s to spaces before parsing the input string.
-           Must be called before parseString when the input grammar contains elements that
-           match <TAB> characters."""
-        self.keepTabs = True
-        return self
-
-    def ignore( self, other ):
-        """Define expression to be ignored (e.g., comments) while doing pattern
-           matching; may be called repeatedly, to define multiple comment or other
-           ignorable patterns.
-        """
-        if isinstance( other, Suppress ):
-            if other not in self.ignoreExprs:
-                self.ignoreExprs.append( other )
-        else:
-            self.ignoreExprs.append( Suppress( other ) )
-        return self
-
-    def setDebugActions( self, startAction, successAction, exceptionAction ):
-        """Enable display of debugging messages while doing pattern matching."""
-        self.debugActions = (startAction or _defaultStartDebugAction,
-                             successAction or _defaultSuccessDebugAction,
-                             exceptionAction or _defaultExceptionDebugAction)
-        self.debug = True
-        return self
-
-    def setDebug( self, flag=True ):
-        """Enable display of debugging messages while doing pattern matching.
-           Set flag to True to enable, False to disable."""
-        if flag:
-            self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
-        else:
-            self.debug = False
-        return self
-
-    def __str__( self ):
-        return self.name
-
-    def __repr__( self ):
-        return _ustr(self)
-
-    def streamline( self ):
-        self.streamlined = True
-        self.strRepr = None
-        return self
-
-    def checkRecursion( self, parseElementList ):
-        pass
-
-    def validate( self, validateTrace=[] ):
-        """Check defined expressions for valid structure, check for infinite recursive definitions."""
-        self.checkRecursion( [] )
-
-    def parseFile( self, file_or_filename, parseAll=False ):
-        """Execute the parse expression on the given file or filename.
-           If a filename is specified (instead of a file object),
-           the entire file is opened, read, and closed before parsing.
-        """
-        try:
-            file_contents = file_or_filename.read()
-        except AttributeError:
-            f = open(file_or_filename, "rb")
-            file_contents = f.read()
-            f.close()
-        try:
-            return self.parseString(file_contents, parseAll)
-        except ParseBaseException, exc:
-            # catch and re-raise exception from here, clears out pyparsing internal stack trace
-            raise exc
-
-    def getException(self):
-        return ParseException("",0,self.errmsg,self)
-
-    def __getattr__(self,aname):
-        if aname == "myException":
-            self.myException = ret = self.getException();
-            return ret;
-        else:
-            raise AttributeError("no such attribute " + aname)
-
-    def __eq__(self,other):
-        if isinstance(other, ParserElement):
-            return self is other or self.__dict__ == other.__dict__
-        elif isinstance(other, basestring):
-            try:
-                self.parseString(_ustr(other), parseAll=True)
-                return True
-            except ParseBaseException:
-                return False
-        else:
-            return super(ParserElement,self)==other
-
-    def __ne__(self,other):
-        return not (self == other)
-
-    def __hash__(self):
-        return hash(id(self))
-
-    def __req__(self,other):
-        return self == other
-
-    def __rne__(self,other):
-        return not (self == other)
-
-
-class Token(ParserElement):
-    """Abstract ParserElement subclass, for defining atomic matching patterns."""
-    def __init__( self ):
-        super(Token,self).__init__( savelist=False )
-        #self.myException = ParseException("",0,"",self)
-
-    def setName(self, name):
-        s = super(Token,self).setName(name)
-        self.errmsg = "Expected " + self.name
-        #s.myException.msg = self.errmsg
-        return s
-
-
-class Empty(Token):
-    """An empty token, will always match."""
-    def __init__( self ):
-        super(Empty,self).__init__()
-        self.name = "Empty"
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-
-
-class NoMatch(Token):
-    """A token that will never match."""
-    def __init__( self ):
-        super(NoMatch,self).__init__()
-        self.name = "NoMatch"
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-        self.errmsg = "Unmatchable token"
-        #self.myException.msg = self.errmsg
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        exc = self.myException
-        exc.loc = loc
-        exc.pstr = instring
-        raise exc
-
-
-class Literal(Token):
-    """Token to exactly match a specified string."""
-    def __init__( self, matchString ):
-        super(Literal,self).__init__()
-        self.match = matchString
-        self.matchLen = len(matchString)
-        try:
-            self.firstMatchChar = matchString[0]
-        except IndexError:
-            warnings.warn("null string passed to Literal; use Empty() instead",
-                            SyntaxWarning, stacklevel=2)
-            self.__class__ = Empty
-        self.name = '"%s"' % _ustr(self.match)
-        self.errmsg = "Expected " + self.name
-        self.mayReturnEmpty = False
-        #self.myException.msg = self.errmsg
-        self.mayIndexError = False
-
-    # Performance tuning: this routine gets called a *lot*
-    # if this is a single character match string  and the first character matches,
-    # short-circuit as quickly as possible, and avoid calling startswith
-    #~ @profile
-    def parseImpl( self, instring, loc, doActions=True ):
-        if (instring[loc] == self.firstMatchChar and
-            (self.matchLen==1 or instring.startswith(self.match,loc)) ):
-            return loc+self.matchLen, self.match
-        #~ raise ParseException( instring, loc, self.errmsg )
-        exc = self.myException
-        exc.loc = loc
-        exc.pstr = instring
-        raise exc
-_L = Literal
-
-class Keyword(Token):
-    """Token to exactly match a specified string as a keyword, that is, it must be
-       immediately followed by a non-keyword character.  Compare with Literal::
-         Literal("if") will match the leading 'if' in 'ifAndOnlyIf'.
-         Keyword("if") will not; it will only match the leading 'if in 'if x=1', or 'if(y==2)'
-       Accepts two optional constructor arguments in addition to the keyword string:
-       identChars is a string of characters that would be valid identifier characters,
-       defaulting to all alphanumerics + "_" and "$"; caseless allows case-insensitive
-       matching, default is False.
-    """
-    DEFAULT_KEYWORD_CHARS = alphanums+"_$"
-
-    def __init__( self, matchString, identChars=DEFAULT_KEYWORD_CHARS, caseless=False ):
-        super(Keyword,self).__init__()
-        self.match = matchString
-        self.matchLen = len(matchString)
-        try:
-            self.firstMatchChar = matchString[0]
-        except IndexError:
-            warnings.warn("null string passed to Keyword; use Empty() instead",
-                            SyntaxWarning, stacklevel=2)
-        self.name = '"%s"' % self.match
-        self.errmsg = "Expected " + self.name
-        self.mayReturnEmpty = False
-        #self.myException.msg = self.errmsg
-        self.mayIndexError = False
-        self.caseless = caseless
-        if caseless:
-            self.caselessmatch = matchString.upper()
-            identChars = identChars.upper()
-        self.identChars = _str2dict(identChars)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.caseless:
-            if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
-                 (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
-                 (loc == 0 or instring[loc-1].upper() not in self.identChars) ):
-                return loc+self.matchLen, self.match
-        else:
-            if (instring[loc] == self.firstMatchChar and
-                (self.matchLen==1 or instring.startswith(self.match,loc)) and
-                (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
-                (loc == 0 or instring[loc-1] not in self.identChars) ):
-                return loc+self.matchLen, self.match
-        #~ raise ParseException( instring, loc, self.errmsg )
-        exc = self.myException
-        exc.loc = loc
-        exc.pstr = instring
-        raise exc
-
-    def copy(self):
-        c = super(Keyword,self).copy()
-        c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
-        return c
-
-    def setDefaultKeywordChars( chars ):
-        """Overrides the default Keyword chars
-        """
-        Keyword.DEFAULT_KEYWORD_CHARS = chars
-    setDefaultKeywordChars = staticmethod(setDefaultKeywordChars)
-
-class CaselessLiteral(Literal):
-    """Token to match a specified string, ignoring case of letters.
-       Note: the matched results will always be in the case of the given
-       match string, NOT the case of the input text.
-    """
-    def __init__( self, matchString ):
-        super(CaselessLiteral,self).__init__( matchString.upper() )
-        # Preserve the defining literal.
-        self.returnString = matchString
-        self.name = "'%s'" % self.returnString
-        self.errmsg = "Expected " + self.name
-        #self.myException.msg = self.errmsg
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if instring[ loc:loc+self.matchLen ].upper() == self.match:
-            return loc+self.matchLen, self.returnString
-        #~ raise ParseException( instring, loc, self.errmsg )
-        exc = self.myException
-        exc.loc = loc
-        exc.pstr = instring
-        raise exc
-
-class CaselessKeyword(Keyword):
-    def __init__( self, matchString, identChars=Keyword.DEFAULT_KEYWORD_CHARS ):
-        super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
-             (loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
-            return loc+self.matchLen, self.match
-        #~ raise ParseException( instring, loc, self.errmsg )
-        exc = self.myException
-        exc.loc = loc
-        exc.pstr = instring
-        raise exc
-
-class Word(Token):
-    """Token for matching words composed of allowed character sets.
-       Defined with string containing all allowed initial characters,
-       an optional string containing allowed body characters (if omitted,
-       defaults to the initial character set), and an optional minimum,
-       maximum, and/or exact length.  The default value for min is 1 (a
-       minimum value < 1 is not valid); the default values for max and exact
-       are 0, meaning no maximum or exact length restriction.
-    """
-    def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False ):
-        super(Word,self).__init__()
-        self.initCharsOrig = initChars
-        self.initChars = _str2dict(initChars)
-        if bodyChars :
-            self.bodyCharsOrig = bodyChars
-            self.bodyChars = _str2dict(bodyChars)
-        else:
-            self.bodyCharsOrig = initChars
-            self.bodyChars = _str2dict(initChars)
-
-        self.maxSpecified = max > 0
-
-        if min < 1:
-            raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
-
-        self.minLen = min
-
-        if max > 0:
-            self.maxLen = max
-        else:
-            self.maxLen = _MAX_INT
-
-        if exact > 0:
-            self.maxLen = exact
-            self.minLen = exact
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        #self.myException.msg = self.errmsg
-        self.mayIndexError = False
-        self.asKeyword = asKeyword
-
-        if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
-            if self.bodyCharsOrig == self.initCharsOrig:
-                self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
-            elif len(self.bodyCharsOrig) == 1:
-                self.reString = "%s[%s]*" % \
-                                      (re.escape(self.initCharsOrig),
-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
-            else:
-                self.reString = "[%s][%s]*" % \
-                                      (_escapeRegexRangeChars(self.initCharsOrig),
-                                      _escapeRegexRangeChars(self.bodyCharsOrig),)
-            if self.asKeyword:
-                self.reString = r"\b"+self.reString+r"\b"
-            try:
-                self.re = re.compile( self.reString )
-            except:
-                self.re = None
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.re:
-            result = self.re.match(instring,loc)
-            if not result:
-                exc = self.myException
-                exc.loc = loc
-                exc.pstr = instring
-                raise exc
-
-            loc = result.end()
-            return loc,result.group()
-
-        if not(instring[ loc ] in self.initChars):
-            #~ raise ParseException( instring, loc, self.errmsg )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-        start = loc
-        loc += 1
-        instrlen = len(instring)
-        bodychars = self.bodyChars
-        maxloc = start + self.maxLen
-        maxloc = min( maxloc, instrlen )
-        while loc < maxloc and instring[loc] in bodychars:
-            loc += 1
-
-        throwException = False
-        if loc - start < self.minLen:
-            throwException = True
-        if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
-            throwException = True
-        if self.asKeyword:
-            if (start>0 and instring[start-1] in bodychars) or (loc<instrlen and instring[loc] in bodychars):
-                throwException = True
-
-        if throwException:
-            #~ raise ParseException( instring, loc, self.errmsg )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-        return loc, instring[start:loc]
-
-    def __str__( self ):
-        try:
-            return super(Word,self).__str__()
-        except:
-            pass
-
-
-        if self.strRepr is None:
-
-            def charsAsStr(s):
-                if len(s)>4:
-                    return s[:4]+"..."
-                else:
-                    return s
-
-            if ( self.initCharsOrig != self.bodyCharsOrig ):
-                self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
-            else:
-                self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)
-
-        return self.strRepr
-
-
-class Regex(Token):
-    """Token for matching strings that match a given regular expression.
-       Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
-    """
-    def __init__( self, pattern, flags=0):
-        """The parameters pattern and flags are passed to the re.compile() function as-is. See the Python re module for an explanation of the acceptable patterns and flags."""
-        super(Regex,self).__init__()
-
-        if len(pattern) == 0:
-            warnings.warn("null string passed to Regex; use Empty() instead",
-                    SyntaxWarning, stacklevel=2)
-
-        self.pattern = pattern
-        self.flags = flags
-
-        try:
-            self.re = re.compile(self.pattern, self.flags)
-            self.reString = self.pattern
-        except sre_constants.error:
-            warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
-                SyntaxWarning, stacklevel=2)
-            raise
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        #self.myException.msg = self.errmsg
-        self.mayIndexError = False
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        result = self.re.match(instring,loc)
-        if not result:
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-        loc = result.end()
-        d = result.groupdict()
-        ret = ParseResults(result.group())
-        if d:
-            for k in d:
-                ret[k] = d[k]
-        return loc,ret
-
-    def __str__( self ):
-        try:
-            return super(Regex,self).__str__()
-        except:
-            pass
-
-        if self.strRepr is None:
-            self.strRepr = "Re:(%s)" % repr(self.pattern)
-
-        return self.strRepr
-
-
-class QuotedString(Token):
-    """Token for matching strings that are delimited by quoting characters.
-    """
-    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None):
-        """
-           Defined with the following parameters:
-            - quoteChar - string of one or more characters defining the quote delimiting string
-            - escChar - character to escape quotes, typically backslash (default=None)
-            - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=None)
-            - multiline - boolean indicating whether quotes can span multiple lines (default=False)
-            - unquoteResults - boolean indicating whether the matched text should be unquoted (default=True)
-            - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=None => same as quoteChar)
-        """
-        super(QuotedString,self).__init__()
-
-        # remove white space from quote chars - wont work anyway
-        quoteChar = quoteChar.strip()
-        if len(quoteChar) == 0:
-            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
-            raise SyntaxError()
-
-        if endQuoteChar is None:
-            endQuoteChar = quoteChar
-        else:
-            endQuoteChar = endQuoteChar.strip()
-            if len(endQuoteChar) == 0:
-                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
-                raise SyntaxError()
-
-        self.quoteChar = quoteChar
-        self.quoteCharLen = len(quoteChar)
-        self.firstQuoteChar = quoteChar[0]
-        self.endQuoteChar = endQuoteChar
-        self.endQuoteCharLen = len(endQuoteChar)
-        self.escChar = escChar
-        self.escQuote = escQuote
-        self.unquoteResults = unquoteResults
-
-        if multiline:
-            self.flags = re.MULTILINE | re.DOTALL
-            self.pattern = r'%s(?:[^%s%s]' % \
-                ( re.escape(self.quoteChar),
-                  _escapeRegexRangeChars(self.endQuoteChar[0]),
-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
-        else:
-            self.flags = 0
-            self.pattern = r'%s(?:[^%s\n\r%s]' % \
-                ( re.escape(self.quoteChar),
-                  _escapeRegexRangeChars(self.endQuoteChar[0]),
-                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
-        if len(self.endQuoteChar) > 1:
-            self.pattern += (
-                '|(?:' + ')|(?:'.join(["%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
-                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
-                                    for i in range(len(self.endQuoteChar)-1,0,-1)]) + ')'
-                )
-        if escQuote:
-            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
-        if escChar:
-            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
-            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
-        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))
-
-        try:
-            self.re = re.compile(self.pattern, self.flags)
-            self.reString = self.pattern
-        except sre_constants.error:
-            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
-                SyntaxWarning, stacklevel=2)
-            raise
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        #self.myException.msg = self.errmsg
-        self.mayIndexError = False
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
-        if not result:
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-        loc = result.end()
-        ret = result.group()
-
-        if self.unquoteResults:
-
-            # strip off quotes
-            ret = ret[self.quoteCharLen:-self.endQuoteCharLen]
-
-            if isinstance(ret,basestring):
-                # replace escaped characters
-                if self.escChar:
-                    ret = re.sub(self.escCharReplacePattern,"\g<1>",ret)
-
-                # replace escaped quotes
-                if self.escQuote:
-                    ret = ret.replace(self.escQuote, self.endQuoteChar)
-
-        return loc, ret
-
-    def __str__( self ):
-        try:
-            return super(QuotedString,self).__str__()
-        except:
-            pass
-
-        if self.strRepr is None:
-            self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)
-
-        return self.strRepr
-
-
-class CharsNotIn(Token):
-    """Token for matching words composed of characters *not* in a given set.
-       Defined with string containing all disallowed characters, and an optional
-       minimum, maximum, and/or exact length.  The default value for min is 1 (a
-       minimum value < 1 is not valid); the default values for max and exact
-       are 0, meaning no maximum or exact length restriction.
-    """
-    def __init__( self, notChars, min=1, max=0, exact=0 ):
-        super(CharsNotIn,self).__init__()
-        self.skipWhitespace = False
-        self.notChars = notChars
-
-        if min < 1:
-            raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")
-
-        self.minLen = min
-
-        if max > 0:
-            self.maxLen = max
-        else:
-            self.maxLen = _MAX_INT
-
-        if exact > 0:
-            self.maxLen = exact
-            self.minLen = exact
-
-        self.name = _ustr(self)
-        self.errmsg = "Expected " + self.name
-        self.mayReturnEmpty = ( self.minLen == 0 )
-        #self.myException.msg = self.errmsg
-        self.mayIndexError = False
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if instring[loc] in self.notChars:
-            #~ raise ParseException( instring, loc, self.errmsg )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-        start = loc
-        loc += 1
-        notchars = self.notChars
-        maxlen = min( start+self.maxLen, len(instring) )
-        while loc < maxlen and \
-              (instring[loc] not in notchars):
-            loc += 1
-
-        if loc - start < self.minLen:
-            #~ raise ParseException( instring, loc, self.errmsg )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-        return loc, instring[start:loc]
-
-    def __str__( self ):
-        try:
-            return super(CharsNotIn, self).__str__()
-        except:
-            pass
-
-        if self.strRepr is None:
-            if len(self.notChars) > 4:
-                self.strRepr = "!W:(%s...)" % self.notChars[:4]
-            else:
-                self.strRepr = "!W:(%s)" % self.notChars
-
-        return self.strRepr
-
-class White(Token):
-    """Special matching class for matching whitespace.  Normally, whitespace is ignored
-       by pyparsing grammars.  This class is included when some whitespace structures
-       are significant.  Define with a string containing the whitespace characters to be
-       matched; default is " \\t\\r\\n".  Also takes optional min, max, and exact arguments,
-       as defined for the Word class."""
-    whiteStrs = {
-        " " : "<SPC>",
-        "\t": "<TAB>",
-        "\n": "<LF>",
-        "\r": "<CR>",
-        "\f": "<FF>",
-        }
-    def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
-        super(White,self).__init__()
-        self.matchWhite = ws
-        self.setWhitespaceChars( "".join([c for c in self.whiteChars if c not in self.matchWhite]) )
-        #~ self.leaveWhitespace()
-        self.name = ("".join([White.whiteStrs[c] for c in self.matchWhite]))
-        self.mayReturnEmpty = True
-        self.errmsg = "Expected " + self.name
-        #self.myException.msg = self.errmsg
-
-        self.minLen = min
-
-        if max > 0:
-            self.maxLen = max
-        else:
-            self.maxLen = _MAX_INT
-
-        if exact > 0:
-            self.maxLen = exact
-            self.minLen = exact
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if not(instring[ loc ] in self.matchWhite):
-            #~ raise ParseException( instring, loc, self.errmsg )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-        start = loc
-        loc += 1
-        maxloc = start + self.maxLen
-        maxloc = min( maxloc, len(instring) )
-        while loc < maxloc and instring[loc] in self.matchWhite:
-            loc += 1
-
-        if loc - start < self.minLen:
-            #~ raise ParseException( instring, loc, self.errmsg )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-        return loc, instring[start:loc]
-
-
-class _PositionToken(Token):
-    def __init__( self ):
-        super(_PositionToken,self).__init__()
-        self.name=self.__class__.__name__
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-
-class GoToColumn(_PositionToken):
-    """Token to advance to a specific column of input text; useful for tabular report scraping."""
-    def __init__( self, colno ):
-        super(GoToColumn,self).__init__()
-        self.col = colno
-
-    def preParse( self, instring, loc ):
-        if col(loc,instring) != self.col:
-            instrlen = len(instring)
-            if self.ignoreExprs:
-                loc = self._skipIgnorables( instring, loc )
-            while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
-                loc += 1
-        return loc
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        thiscol = col( loc, instring )
-        if thiscol > self.col:
-            raise ParseException( instring, loc, "Text not in expected column", self )
-        newloc = loc + self.col - thiscol
-        ret = instring[ loc: newloc ]
-        return newloc, ret
-
-class LineStart(_PositionToken):
-    """Matches if current position is at the beginning of a line within the parse string"""
-    def __init__( self ):
-        super(LineStart,self).__init__()
-        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
-        self.errmsg = "Expected start of line"
-        #self.myException.msg = self.errmsg
-
-    def preParse( self, instring, loc ):
-        preloc = super(LineStart,self).preParse(instring,loc)
-        if instring[preloc] == "\n":
-            loc += 1
-        return loc
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if not( loc==0 or
-            (loc == self.preParse( instring, 0 )) or
-            (instring[loc-1] == "\n") ): #col(loc, instring) != 1:
-            #~ raise ParseException( instring, loc, "Expected start of line" )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-        return loc, []
-
-class LineEnd(_PositionToken):
-    """Matches if current position is at the end of a line within the parse string"""
-    def __init__( self ):
-        super(LineEnd,self).__init__()
-        self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
-        self.errmsg = "Expected end of line"
-        #self.myException.msg = self.errmsg
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if loc<len(instring):
-            if instring[loc] == "\n":
-                return loc+1, "\n"
-            else:
-                #~ raise ParseException( instring, loc, "Expected end of line" )
-                exc = self.myException
-                exc.loc = loc
-                exc.pstr = instring
-                raise exc
-        elif loc == len(instring):
-            return loc+1, []
-        else:
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-class StringStart(_PositionToken):
-    """Matches if current position is at the beginning of the parse string"""
-    def __init__( self ):
-        super(StringStart,self).__init__()
-        self.errmsg = "Expected start of text"
-        #self.myException.msg = self.errmsg
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if loc != 0:
-            # see if entire string up to here is just whitespace and ignoreables
-            if loc != self.preParse( instring, 0 ):
-                #~ raise ParseException( instring, loc, "Expected start of text" )
-                exc = self.myException
-                exc.loc = loc
-                exc.pstr = instring
-                raise exc
-        return loc, []
-
-class StringEnd(_PositionToken):
-    """Matches if current position is at the end of the parse string"""
-    def __init__( self ):
-        super(StringEnd,self).__init__()
-        self.errmsg = "Expected end of text"
-        #self.myException.msg = self.errmsg
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if loc < len(instring):
-            #~ raise ParseException( instring, loc, "Expected end of text" )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-        elif loc == len(instring):
-            return loc+1, []
-        elif loc > len(instring):
-            return loc, []
-        else:
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-
-class WordStart(_PositionToken):
-    """Matches if the current position is at the beginning of a Word, and
-       is not preceded by any character in a given set of wordChars
-       (default=printables). To emulate the \b behavior of regular expressions,
-       use WordStart(alphanums). WordStart will also match at the beginning of
-       the string being parsed, or at the beginning of a line.
-    """
-    def __init__(self, wordChars = printables):
-        super(WordStart,self).__init__()
-        self.wordChars = _str2dict(wordChars)
-        self.errmsg = "Not at the start of a word"
-
-    def parseImpl(self, instring, loc, doActions=True ):
-        if loc != 0:
-            if (instring[loc-1] in self.wordChars or
-                instring[loc] not in self.wordChars):
-                exc = self.myException
-                exc.loc = loc
-                exc.pstr = instring
-                raise exc
-        return loc, []
-
-class WordEnd(_PositionToken):
-    """Matches if the current position is at the end of a Word, and
-       is not followed by any character in a given set of wordChars
-       (default=printables). To emulate the \b behavior of regular expressions,
-       use WordEnd(alphanums). WordEnd will also match at the end of
-       the string being parsed, or at the end of a line.
-    """
-    def __init__(self, wordChars = printables):
-        super(WordEnd,self).__init__()
-        self.wordChars = _str2dict(wordChars)
-        self.skipWhitespace = False
-        self.errmsg = "Not at the end of a word"
-
-    def parseImpl(self, instring, loc, doActions=True ):
-        instrlen = len(instring)
-        if instrlen>0 and loc<instrlen:
-            if (instring[loc] in self.wordChars or
-                instring[loc-1] not in self.wordChars):
-                #~ raise ParseException( instring, loc, "Expected end of word" )
-                exc = self.myException
-                exc.loc = loc
-                exc.pstr = instring
-                raise exc
-        return loc, []
-
-
-class ParseExpression(ParserElement):
-    """Abstract subclass of ParserElement, for combining and post-processing parsed tokens."""
-    def __init__( self, exprs, savelist = False ):
-        super(ParseExpression,self).__init__(savelist)
-        if isinstance( exprs, list ):
-            self.exprs = exprs
-        elif isinstance( exprs, basestring ):
-            self.exprs = [ Literal( exprs ) ]
-        else:
-            try:
-                self.exprs = list( exprs )
-            except TypeError:
-                self.exprs = [ exprs ]
-        self.callPreparse = False
-
-    def __getitem__( self, i ):
-        return self.exprs[i]
-
-    def append( self, other ):
-        self.exprs.append( other )
-        self.strRepr = None
-        return self
-
-    def leaveWhitespace( self ):
-        """Extends leaveWhitespace defined in base class, and also invokes leaveWhitespace on
-           all contained expressions."""
-        self.skipWhitespace = False
-        self.exprs = [ e.copy() for e in self.exprs ]
-        for e in self.exprs:
-            e.leaveWhitespace()
-        return self
-
-    def ignore( self, other ):
-        if isinstance( other, Suppress ):
-            if other not in self.ignoreExprs:
-                super( ParseExpression, self).ignore( other )
-                for e in self.exprs:
-                    e.ignore( self.ignoreExprs[-1] )
-        else:
-            super( ParseExpression, self).ignore( other )
-            for e in self.exprs:
-                e.ignore( self.ignoreExprs[-1] )
-        return self
-
-    def __str__( self ):
-        try:
-            return super(ParseExpression,self).__str__()
-        except:
-            pass
-
-        if self.strRepr is None:
-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.exprs) )
-        return self.strRepr
-
-    def streamline( self ):
-        super(ParseExpression,self).streamline()
-
-        for e in self.exprs:
-            e.streamline()
-
-        # collapse nested And's of the form And( And( And( a,b), c), d) to And( a,b,c,d )
-        # but only if there are no parse actions or resultsNames on the nested And's
-        # (likewise for Or's and MatchFirst's)
-        if ( len(self.exprs) == 2 ):
-            other = self.exprs[0]
-            if ( isinstance( other, self.__class__ ) and
-                  not(other.parseAction) and
-                  other.resultsName is None and
-                  not other.debug ):
-                self.exprs = other.exprs[:] + [ self.exprs[1] ]
-                self.strRepr = None
-                self.mayReturnEmpty |= other.mayReturnEmpty
-                self.mayIndexError  |= other.mayIndexError
-
-            other = self.exprs[-1]
-            if ( isinstance( other, self.__class__ ) and
-                  not(other.parseAction) and
-                  other.resultsName is None and
-                  not other.debug ):
-                self.exprs = self.exprs[:-1] + other.exprs[:]
-                self.strRepr = None
-                self.mayReturnEmpty |= other.mayReturnEmpty
-                self.mayIndexError  |= other.mayIndexError
-
-        return self
-
-    def setResultsName( self, name, listAllMatches=False ):
-        ret = super(ParseExpression,self).setResultsName(name,listAllMatches)
-        return ret
-
-    def validate( self, validateTrace=[] ):
-        tmp = validateTrace[:]+[self]
-        for e in self.exprs:
-            e.validate(tmp)
-        self.checkRecursion( [] )
-
-class And(ParseExpression):
-    """Requires all given ParseExpressions to be found in the given order.
-       Expressions may be separated by whitespace.
-       May be constructed using the '+' operator.
-    """
-
-    class _ErrorStop(Empty):
-        def __init__(self, *args, **kwargs):
-            super(Empty,self).__init__(*args, **kwargs)
-            self.leaveWhitespace()
-
-    def __init__( self, exprs, savelist = True ):
-        super(And,self).__init__(exprs, savelist)
-        self.mayReturnEmpty = True
-        for e in self.exprs:
-            if not e.mayReturnEmpty:
-                self.mayReturnEmpty = False
-                break
-        self.setWhitespaceChars( exprs[0].whiteChars )
-        self.skipWhitespace = exprs[0].skipWhitespace
-        self.callPreparse = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        # pass False as last arg to _parse for first element, since we already
-        # pre-parsed the string as part of our And pre-parsing
-        loc, resultlist = self.exprs[0]._parse( instring, loc, doActions, callPreParse=False )
-        errorStop = False
-        for e in self.exprs[1:]:
-            if isinstance(e, And._ErrorStop):
-                errorStop = True
-                continue
-            if errorStop:
-                try:
-                    loc, exprtokens = e._parse( instring, loc, doActions )
-                except ParseSyntaxException:
-                    raise
-                except ParseBaseException, pe:
-                    raise ParseSyntaxException(pe)
-                except IndexError, ie:
-                    raise ParseSyntaxException( ParseException(instring, len(instring), self.errmsg, self) )
-            else:
-                loc, exprtokens = e._parse( instring, loc, doActions )
-            if exprtokens or exprtokens.keys():
-                resultlist += exprtokens
-        return loc, resultlist
-
-    def __iadd__(self, other ):
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        return self.append( other ) #And( [ self, other ] )
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-            if not e.mayReturnEmpty:
-                break
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
-
-        return self.strRepr
-
-
-class Or(ParseExpression):
-    """Requires that at least one ParseExpression is found.
-       If two expressions match, the expression that matches the longest string will be used.
-       May be constructed using the '^' operator.
-    """
-    def __init__( self, exprs, savelist = False ):
-        super(Or,self).__init__(exprs, savelist)
-        self.mayReturnEmpty = False
-        for e in self.exprs:
-            if e.mayReturnEmpty:
-                self.mayReturnEmpty = True
-                break
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        maxExcLoc = -1
-        maxMatchLoc = -1
-        maxException = None
-        for e in self.exprs:
-            try:
-                loc2 = e.tryParse( instring, loc )
-            except ParseException, err:
-                if err.loc > maxExcLoc:
-                    maxException = err
-                    maxExcLoc = err.loc
-            except IndexError:
-                if len(instring) > maxExcLoc:
-                    maxException = ParseException(instring,len(instring),e.errmsg,self)
-                    maxExcLoc = len(instring)
-            else:
-                if loc2 > maxMatchLoc:
-                    maxMatchLoc = loc2
-                    maxMatchExp = e
-
-        if maxMatchLoc < 0:
-            if maxException is not None:
-                raise maxException
-            else:
-                raise ParseException(instring, loc, "no defined alternatives to match", self)
-
-        return maxMatchExp._parse( instring, loc, doActions )
-
-    def __ixor__(self, other ):
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        return self.append( other ) #Or( [ self, other ] )
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " ^ ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
-
-        return self.strRepr
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-
-
-class MatchFirst(ParseExpression):
-    """Requires that at least one ParseExpression is found.
-       If two expressions match, the first one listed is the one that will match.
-       May be constructed using the '|' operator.
-    """
-    def __init__( self, exprs, savelist = False ):
-        super(MatchFirst,self).__init__(exprs, savelist)
-        if exprs:
-            self.mayReturnEmpty = False
-            for e in self.exprs:
-                if e.mayReturnEmpty:
-                    self.mayReturnEmpty = True
-                    break
-        else:
-            self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        maxExcLoc = -1
-        maxException = None
-        for e in self.exprs:
-            try:
-                ret = e._parse( instring, loc, doActions )
-                return ret
-            except ParseException, err:
-                if err.loc > maxExcLoc:
-                    maxException = err
-                    maxExcLoc = err.loc
-            except IndexError:
-                if len(instring) > maxExcLoc:
-                    maxException = ParseException(instring,len(instring),e.errmsg,self)
-                    maxExcLoc = len(instring)
-
-        # only got here if no expression matched, raise exception for match that made it the furthest
-        else:
-            if maxException is not None:
-                raise maxException
-            else:
-                raise ParseException(instring, loc, "no defined alternatives to match", self)
-
-    def __ior__(self, other ):
-        if isinstance( other, basestring ):
-            other = Literal( other )
-        return self.append( other ) #MatchFirst( [ self, other ] )
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " | ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
-
-        return self.strRepr
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-
-
-class Each(ParseExpression):
-    """Requires all given ParseExpressions to be found, but in any order.
-       Expressions may be separated by whitespace.
-       May be constructed using the '&' operator.
-    """
-    def __init__( self, exprs, savelist = True ):
-        super(Each,self).__init__(exprs, savelist)
-        self.mayReturnEmpty = True
-        for e in self.exprs:
-            if not e.mayReturnEmpty:
-                self.mayReturnEmpty = False
-                break
-        self.skipWhitespace = True
-        self.initExprGroups = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.initExprGroups:
-            self.optionals = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
-            self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
-            self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
-            self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
-            self.required += self.multirequired
-            self.initExprGroups = False
-        tmpLoc = loc
-        tmpReqd = self.required[:]
-        tmpOpt  = self.optionals[:]
-        matchOrder = []
-
-        keepMatching = True
-        while keepMatching:
-            tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
-            failed = []
-            for e in tmpExprs:
-                try:
-                    tmpLoc = e.tryParse( instring, tmpLoc )
-                except ParseException:
-                    failed.append(e)
-                else:
-                    matchOrder.append(e)
-                    if e in tmpReqd:
-                        tmpReqd.remove(e)
-                    elif e in tmpOpt:
-                        tmpOpt.remove(e)
-            if len(failed) == len(tmpExprs):
-                keepMatching = False
-
-        if tmpReqd:
-            missing = ", ".join( [ _ustr(e) for e in tmpReqd ] )
-            raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )
-
-        # add any unmatched Optionals, in case they have default values defined
-        matchOrder += list(e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt)
-
-        resultlist = []
-        for e in matchOrder:
-            loc,results = e._parse(instring,loc,doActions)
-            resultlist.append(results)
-
-        finalResults = ParseResults([])
-        for r in resultlist:
-            dups = {}
-            for k in r.keys():
-                if k in finalResults.keys():
-                    tmp = ParseResults(finalResults[k])
-                    tmp += ParseResults(r[k])
-                    dups[k] = tmp
-            finalResults += ParseResults(r)
-            for k,v in dups.iteritems():
-                finalResults[k] = v
-        return loc, finalResults
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + " & ".join( [ _ustr(e) for e in self.exprs ] ) + "}"
-
-        return self.strRepr
-
-    def checkRecursion( self, parseElementList ):
-        subRecCheckList = parseElementList[:] + [ self ]
-        for e in self.exprs:
-            e.checkRecursion( subRecCheckList )
-
-
-class ParseElementEnhance(ParserElement):
-    """Abstract subclass of ParserElement, for combining and post-processing parsed tokens."""
-    def __init__( self, expr, savelist=False ):
-        super(ParseElementEnhance,self).__init__(savelist)
-        if isinstance( expr, basestring ):
-            expr = Literal(expr)
-        self.expr = expr
-        self.strRepr = None
-        if expr is not None:
-            self.mayIndexError = expr.mayIndexError
-            self.mayReturnEmpty = expr.mayReturnEmpty
-            self.setWhitespaceChars( expr.whiteChars )
-            self.skipWhitespace = expr.skipWhitespace
-            self.saveAsList = expr.saveAsList
-            self.callPreparse = expr.callPreparse
-            self.ignoreExprs.extend(expr.ignoreExprs)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        if self.expr is not None:
-            return self.expr._parse( instring, loc, doActions, callPreParse=False )
-        else:
-            raise ParseException("",loc,self.errmsg,self)
-
-    def leaveWhitespace( self ):
-        self.skipWhitespace = False
-        self.expr = self.expr.copy()
-        if self.expr is not None:
-            self.expr.leaveWhitespace()
-        return self
-
-    def ignore( self, other ):
-        if isinstance( other, Suppress ):
-            if other not in self.ignoreExprs:
-                super( ParseElementEnhance, self).ignore( other )
-                if self.expr is not None:
-                    self.expr.ignore( self.ignoreExprs[-1] )
-        else:
-            super( ParseElementEnhance, self).ignore( other )
-            if self.expr is not None:
-                self.expr.ignore( self.ignoreExprs[-1] )
-        return self
-
-    def streamline( self ):
-        super(ParseElementEnhance,self).streamline()
-        if self.expr is not None:
-            self.expr.streamline()
-        return self
-
-    def checkRecursion( self, parseElementList ):
-        if self in parseElementList:
-            raise RecursiveGrammarException( parseElementList+[self] )
-        subRecCheckList = parseElementList[:] + [ self ]
-        if self.expr is not None:
-            self.expr.checkRecursion( subRecCheckList )
-
-    def validate( self, validateTrace=[] ):
-        tmp = validateTrace[:]+[self]
-        if self.expr is not None:
-            self.expr.validate(tmp)
-        self.checkRecursion( [] )
-
-    def __str__( self ):
-        try:
-            return super(ParseElementEnhance,self).__str__()
-        except:
-            pass
-
-        if self.strRepr is None and self.expr is not None:
-            self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
-        return self.strRepr
-
-
-class FollowedBy(ParseElementEnhance):
-    """Lookahead matching of the given parse expression.  FollowedBy
-    does *not* advance the parsing position within the input string, it only
-    verifies that the specified parse expression matches at the current
-    position.  FollowedBy always returns a null token list."""
-    def __init__( self, expr ):
-        super(FollowedBy,self).__init__(expr)
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        self.expr.tryParse( instring, loc )
-        return loc, []
-
-
-class NotAny(ParseElementEnhance):
-    """Lookahead to disallow matching with the given parse expression.  NotAny
-    does *not* advance the parsing position within the input string, it only
-    verifies that the specified parse expression does *not* match at the current
-    position.  Also, NotAny does *not* skip over leading whitespace. NotAny
-    always returns a null token list.  May be constructed using the '~' operator."""
-    def __init__( self, expr ):
-        super(NotAny,self).__init__(expr)
-        #~ self.leaveWhitespace()
-        self.skipWhitespace = False  # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
-        self.mayReturnEmpty = True
-        self.errmsg = "Found unwanted token, "+_ustr(self.expr)
-        #self.myException = ParseException("",0,self.errmsg,self)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        try:
-            self.expr.tryParse( instring, loc )
-        except (ParseException,IndexError):
-            pass
-        else:
-            #~ raise ParseException(instring, loc, self.errmsg )
-            exc = self.myException
-            exc.loc = loc
-            exc.pstr = instring
-            raise exc
-        return loc, []
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "~{" + _ustr(self.expr) + "}"
-
-        return self.strRepr
-
-
-class ZeroOrMore(ParseElementEnhance):
-    """Optional repetition of zero or more of the given expression."""
-    def __init__( self, expr ):
-        super(ZeroOrMore,self).__init__(expr)
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        tokens = []
-        try:
-            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
-            hasIgnoreExprs = ( len(self.ignoreExprs) > 0 )
-            while 1:
-                if hasIgnoreExprs:
-                    preloc = self._skipIgnorables( instring, loc )
-                else:
-                    preloc = loc
-                loc, tmptokens = self.expr._parse( instring, preloc, doActions )
-                if tmptokens or tmptokens.keys():
-                    tokens += tmptokens
-        except (ParseException,IndexError):
-            pass
-
-        return loc, tokens
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "[" + _ustr(self.expr) + "]..."
-
-        return self.strRepr
-
-    def setResultsName( self, name, listAllMatches=False ):
-        ret = super(ZeroOrMore,self).setResultsName(name,listAllMatches)
-        ret.saveAsList = True
-        return ret
-
-
-class OneOrMore(ParseElementEnhance):
-    """Repetition of one or more of the given expression."""
-    def parseImpl( self, instring, loc, doActions=True ):
-        # must be at least one
-        loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
-        try:
-            hasIgnoreExprs = ( len(self.ignoreExprs) > 0 )
-            while 1:
-                if hasIgnoreExprs:
-                    preloc = self._skipIgnorables( instring, loc )
-                else:
-                    preloc = loc
-                loc, tmptokens = self.expr._parse( instring, preloc, doActions )
-                if tmptokens or tmptokens.keys():
-                    tokens += tmptokens
-        except (ParseException,IndexError):
-            pass
-
-        return loc, tokens
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "{" + _ustr(self.expr) + "}..."
-
-        return self.strRepr
-
-    def setResultsName( self, name, listAllMatches=False ):
-        ret = super(OneOrMore,self).setResultsName(name,listAllMatches)
-        ret.saveAsList = True
-        return ret
-
-class _NullToken(object):
-    def __bool__(self):
-        return False
-    __nonzero__ = __bool__
-    def __str__(self):
-        return ""
-
-_optionalNotMatched = _NullToken()
-class Optional(ParseElementEnhance):
-    """Optional matching of the given expression.
-       A default return string can also be specified, if the optional expression
-       is not found.
-    """
-    def __init__( self, exprs, default=_optionalNotMatched ):
-        super(Optional,self).__init__( exprs, savelist=False )
-        self.defaultValue = default
-        self.mayReturnEmpty = True
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        try:
-            loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
-        except (ParseException,IndexError):
-            if self.defaultValue is not _optionalNotMatched:
-                if self.expr.resultsName:
-                    tokens = ParseResults([ self.defaultValue ])
-                    tokens[self.expr.resultsName] = self.defaultValue
-                else:
-                    tokens = [ self.defaultValue ]
-            else:
-                tokens = []
-        return loc, tokens
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        if self.strRepr is None:
-            self.strRepr = "[" + _ustr(self.expr) + "]"
-
-        return self.strRepr
-
-
-class SkipTo(ParseElementEnhance):
-    """Token for skipping over all undefined text until the matched expression is found.
-       If include is set to true, the matched expression is also parsed (the skipped text
-       and matched expression are returned as a 2-element list).  The ignore
-       argument is used to define grammars (typically quoted strings and comments) that
-       might contain false matches.
-    """
-    def __init__( self, other, include=False, ignore=None, failOn=None ):
-        super( SkipTo, self ).__init__( other )
-        self.ignoreExpr = ignore
-        self.mayReturnEmpty = True
-        self.mayIndexError = False
-        self.includeMatch = include
-        self.asList = False
-        if failOn is not None and isinstance(failOn, basestring):
-            self.failOn = Literal(failOn)
-        else:
-            self.failOn = failOn
-        self.errmsg = "No match found for "+_ustr(self.expr)
-        #self.myException = ParseException("",0,self.errmsg,self)
-
-    def parseImpl( self, instring, loc, doActions=True ):
-        startLoc = loc
-        instrlen = len(instring)
-        expr = self.expr
-        failParse = False
-        while loc <= instrlen:
-            try:
-                if self.failOn:
-                    try:
-                        self.failOn.tryParse(instring, loc)
-                    except ParseBaseException:
-                        pass
-                    else:
-                        failParse = True
-                        raise ParseException(instring, loc, "Found expression " + str(self.failOn))
-                    failParse = False
-                if self.ignoreExpr is not None:
-                    while 1:
-                        try:
-                            loc = self.ignoreExpr.tryParse(instring,loc)
-                            print "found ignoreExpr, advance to", loc
-                        except ParseBaseException:
-                            break
-                expr._parse( instring, loc, doActions=False, callPreParse=False )
-                skipText = instring[startLoc:loc]
-                if self.includeMatch:
-                    loc,mat = expr._parse(instring,loc,doActions,callPreParse=False)
-                    if mat:
-                        skipRes = ParseResults( skipText )
-                        skipRes += mat
-                        return loc, [ skipRes ]
-                    else:
-                        return loc, [ skipText ]
-                else:
-                    return loc, [ skipText ]
-            except (ParseException,IndexError):
-                if failParse:
-                    raise
-                else:
-                    loc += 1
-        exc = self.myException
-        exc.loc = loc
-        exc.pstr = instring
-        raise exc
-
-class Forward(ParseElementEnhance):
-    """Forward declaration of an expression to be defined later -
-       used for recursive grammars, such as algebraic infix notation.
-       When the expression is known, it is assigned to the Forward variable using the '<<' operator.
-
-       Note: take care when assigning to Forward not to overlook precedence of operators.
-       Specifically, '|' has a lower precedence than '<<', so that::
-          fwdExpr << a | b | c
-       will actually be evaluated as::
-          (fwdExpr << a) | b | c
-       thereby leaving b and c out as parseable alternatives.  It is recommended that you
-       explicitly group the values inserted into the Forward::
-          fwdExpr << (a | b | c)
-    """
-    def __init__( self, other=None ):
-        super(Forward,self).__init__( other, savelist=False )
-
-    def __lshift__( self, other ):
-        if isinstance( other, basestring ):
-            other = Literal(other)
-        self.expr = other
-        self.mayReturnEmpty = other.mayReturnEmpty
-        self.strRepr = None
-        self.mayIndexError = self.expr.mayIndexError
-        self.mayReturnEmpty = self.expr.mayReturnEmpty
-        self.setWhitespaceChars( self.expr.whiteChars )
-        self.skipWhitespace = self.expr.skipWhitespace
-        self.saveAsList = self.expr.saveAsList
-        self.ignoreExprs.extend(self.expr.ignoreExprs)
-        return None
-
-    def leaveWhitespace( self ):
-        self.skipWhitespace = False
-        return self
-
-    def streamline( self ):
-        if not self.streamlined:
-            self.streamlined = True
-            if self.expr is not None:
-                self.expr.streamline()
-        return self
-
-    def validate( self, validateTrace=[] ):
-        if self not in validateTrace:
-            tmp = validateTrace[:]+[self]
-            if self.expr is not None:
-                self.expr.validate(tmp)
-        self.checkRecursion([])
-
-    def __str__( self ):
-        if hasattr(self,"name"):
-            return self.name
-
-        self._revertClass = self.__class__
-        self.__class__ = _ForwardNoRecurse
-        try:
-            if self.expr is not None:
-                retString = _ustr(self.expr)
-            else:
-                retString = "None"
-        finally:
-            self.__class__ = self._revertClass
-        return self.__class__.__name__ + ": " + retString
-
-    def copy(self):
-        if self.expr is not None:
-            return super(Forward,self).copy()
-        else:
-            ret = Forward()
-            ret << self
-            return ret
-
-class _ForwardNoRecurse(Forward):
-    def __str__( self ):
-        return "..."
-
-class TokenConverter(ParseElementEnhance):
-    """Abstract subclass of ParseExpression, for converting parsed results."""
-    def __init__( self, expr, savelist=False ):
-        super(TokenConverter,self).__init__( expr )#, savelist )
-        self.saveAsList = False
-
-class Upcase(TokenConverter):
-    """Converter to upper case all matching tokens."""
-    def __init__(self, *args):
-        super(Upcase,self).__init__(*args)
-        warnings.warn("Upcase class is deprecated, use upcaseTokens parse action instead",
-                       DeprecationWarning,stacklevel=2)
-
-    def postParse( self, instring, loc, tokenlist ):
-        return list(map( string.upper, tokenlist ))
-
-
-class Combine(TokenConverter):
-    """Converter to concatenate all matching tokens to a single string.
-       By default, the matching patterns must also be contiguous in the input string;
-       this can be disabled by specifying 'adjacent=False' in the constructor.
-    """
-    def __init__( self, expr, joinString="", adjacent=True ):
-        super(Combine,self).__init__( expr )
-        # suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
-        if adjacent:
-            self.leaveWhitespace()
-        self.adjacent = adjacent
-        self.skipWhitespace = True
-        self.joinString = joinString
-
-    def ignore( self, other ):
-        if self.adjacent:
-            ParserElement.ignore(self, other)
-        else:
-            super( Combine, self).ignore( other )
-        return self
-
-    def postParse( self, instring, loc, tokenlist ):
-        retToks = tokenlist.copy()
-        del retToks[:]
-        retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)
-
-        if self.resultsName and len(retToks.keys())>0:
-            return [ retToks ]
-        else:
-            return retToks
-
-class Group(TokenConverter):
-    """Converter to return the matched tokens as a list - useful for returning tokens of ZeroOrMore and OneOrMore expressions."""
-    def __init__( self, expr ):
-        super(Group,self).__init__( expr )
-        self.saveAsList = True
-
-    def postParse( self, instring, loc, tokenlist ):
-        return [ tokenlist ]
-
-class Dict(TokenConverter):
-    """Converter to return a repetitive expression as a list, but also as a dictionary.
-       Each element can also be referenced using the first token in the expression as its key.
-       Useful for tabular report scraping when the first column can be used as a item key.
-    """
-    def __init__( self, exprs ):
-        super(Dict,self).__init__( exprs )
-        self.saveAsList = True
-
-    def postParse( self, instring, loc, tokenlist ):
-        for i,tok in enumerate(tokenlist):
-            if len(tok) == 0:
-                continue
-            ikey = tok[0]
-            if isinstance(ikey,int):
-                ikey = _ustr(tok[0]).strip()
-            if len(tok)==1:
-                tokenlist[ikey] = _ParseResultsWithOffset("",i)
-            elif len(tok)==2 and not isinstance(tok[1],ParseResults):
-                tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
-            else:
-                dictvalue = tok.copy() #ParseResults(i)
-                del dictvalue[0]
-                if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.keys()):
-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
-                else:
-                    tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)
-
-        if self.resultsName:
-            return [ tokenlist ]
-        else:
-            return tokenlist
-
-
-class Suppress(TokenConverter):
-    """Converter for ignoring the results of a parsed expression."""
-    def postParse( self, instring, loc, tokenlist ):
-        return []
-
-    def suppress( self ):
-        return self
-
-
-class OnlyOnce(object):
-    """Wrapper for parse actions, to ensure they are only called once."""
-    def __init__(self, methodCall):
-        self.callable = ParserElement._normalizeParseActionArgs(methodCall)
-        self.called = False
-    def __call__(self,s,l,t):
-        if not self.called:
-            results = self.callable(s,l,t)
-            self.called = True
-            return results
-        raise ParseException(s,l,"")
-    def reset(self):
-        self.called = False
-
-def traceParseAction(f):
-    """Decorator for debugging parse actions."""
-    f = ParserElement._normalizeParseActionArgs(f)
-    def z(*paArgs):
-        thisFunc = f.func_name
-        s,l,t = paArgs[-3:]
-        if len(paArgs)>3:
-            thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
-        sys.stderr.write( ">>entering %s(line: '%s', %d, %s)\n" % (thisFunc,line(l,s),l,t) )
-        try:
-            ret = f(*paArgs)
-        except Exception, exc:
-            sys.stderr.write( "<<leaving %s (exception: %s)\n" % (thisFunc,exc) )
-            raise
-        sys.stderr.write( "<<leaving %s (ret: %s)\n" % (thisFunc,ret) )
-        return ret
-    try:
-        z.__name__ = f.__name__
-    except AttributeError:
-        pass
-    return z
-
-#
-# global helpers
-#
-def delimitedList( expr, delim=",", combine=False ):
-    """Helper to define a delimited list of expressions - the delimiter defaults to ','.
-       By default, the list elements and delimiters can have intervening whitespace, and
-       comments, but this can be overridden by passing 'combine=True' in the constructor.
-       If combine is set to True, the matching tokens are returned as a single token
-       string, with the delimiters included; otherwise, the matching tokens are returned
-       as a list of tokens, with the delimiters suppressed.
-    """
-    dlName = _ustr(expr)+" ["+_ustr(delim)+" "+_ustr(expr)+"]..."
-    if combine:
-        return Combine( expr + ZeroOrMore( delim + expr ) ).setName(dlName)
-    else:
-        return ( expr + ZeroOrMore( Suppress( delim ) + expr ) ).setName(dlName)
-
-def countedArray( expr ):
-    """Helper to define a counted list of expressions.
-       This helper defines a pattern of the form::
-           integer expr expr expr...
-       where the leading integer tells how many expr expressions follow.
-       The matched tokens returns the array of expr tokens as a list - the leading count token is suppressed.
-    """
-    arrayExpr = Forward()
-    def countFieldParseAction(s,l,t):
-        n = int(t[0])
-        arrayExpr << (n and Group(And([expr]*n)) or Group(empty))
-        return []
-    return ( Word(nums).setName("arrayLen").setParseAction(countFieldParseAction, callDuringTry=True) + arrayExpr )
-
-def _flatten(L):
-    if type(L) is not list: return [L]
-    if L == []: return L
-    return _flatten(L[0]) + _flatten(L[1:])
-
-def matchPreviousLiteral(expr):
-    """Helper to define an expression that is indirectly defined from
-       the tokens matched in a previous expression, that is, it looks
-       for a 'repeat' of a previous expression.  For example::
-           first = Word(nums)
-           second = matchPreviousLiteral(first)
-           matchExpr = first + ":" + second
-       will match "1:1", but not "1:2".  Because this matches a
-       previous literal, will also match the leading "1:1" in "1:10".
-       If this is not desired, use matchPreviousExpr.
-       Do *not* use with packrat parsing enabled.
-    """
-    rep = Forward()
-    def copyTokenToRepeater(s,l,t):
-        if t:
-            if len(t) == 1:
-                rep << t[0]
-            else:
-                # flatten t tokens
-                tflat = _flatten(t.asList())
-                rep << And( [ Literal(tt) for tt in tflat ] )
-        else:
-            rep << Empty()
-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
-    return rep
-
-def matchPreviousExpr(expr):
-    """Helper to define an expression that is indirectly defined from
-       the tokens matched in a previous expression, that is, it looks
-       for a 'repeat' of a previous expression.  For example::
-           first = Word(nums)
-           second = matchPreviousExpr(first)
-           matchExpr = first + ":" + second
-       will match "1:1", but not "1:2".  Because this matches by
-       expressions, will *not* match the leading "1:1" in "1:10";
-       the expressions are evaluated first, and then compared, so
-       "1" is compared with "10".
-       Do *not* use with packrat parsing enabled.
-    """
-    rep = Forward()
-    e2 = expr.copy()
-    rep << e2
-    def copyTokenToRepeater(s,l,t):
-        matchTokens = _flatten(t.asList())
-        def mustMatchTheseTokens(s,l,t):
-            theseTokens = _flatten(t.asList())
-            if  theseTokens != matchTokens:
-                raise ParseException("",0,"")
-        rep.setParseAction( mustMatchTheseTokens, callDuringTry=True )
-    expr.addParseAction(copyTokenToRepeater, callDuringTry=True)
-    return rep
-
-def _escapeRegexRangeChars(s):
-    #~  escape these chars: ^-]
-    for c in r"\^-]":
-        s = s.replace(c,_bslash+c)
-    s = s.replace("\n",r"\n")
-    s = s.replace("\t",r"\t")
-    return _ustr(s)
-
-def oneOf( strs, caseless=False, useRegex=True ):
-    """Helper to quickly define a set of alternative Literals, and makes sure to do
-       longest-first testing when there is a conflict, regardless of the input order,
-       but returns a MatchFirst for best performance.
-
-       Parameters:
-        - strs - a string of space-delimited literals, or a list of string literals
-        - caseless - (default=False) - treat all literals as caseless
-        - useRegex - (default=True) - as an optimization, will generate a Regex
-          object; otherwise, will generate a MatchFirst object (if caseless=True, or
-          if creating a Regex raises an exception)
-    """
-    if caseless:
-        isequal = ( lambda a,b: a.upper() == b.upper() )
-        masks = ( lambda a,b: b.upper().startswith(a.upper()) )
-        parseElementClass = CaselessLiteral
-    else:
-        isequal = ( lambda a,b: a == b )
-        masks = ( lambda a,b: b.startswith(a) )
-        parseElementClass = Literal
-
-    if isinstance(strs,(list,tuple)):
-        symbols = list(strs[:])
-    elif isinstance(strs,basestring):
-        symbols = strs.split()
-    else:
-        warnings.warn("Invalid argument to oneOf, expected string or list",
-                SyntaxWarning, stacklevel=2)
-
-    i = 0
-    while i < len(symbols)-1:
-        cur = symbols[i]
-        for j,other in enumerate(symbols[i+1:]):
-            if ( isequal(other, cur) ):
-                del symbols[i+j+1]
-                break
-            elif ( masks(cur, other) ):
-                del symbols[i+j+1]
-                symbols.insert(i,other)
-                cur = other
-                break
-        else:
-            i += 1
-
-    if not caseless and useRegex:
-        #~ print (strs,"->", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
-        try:
-            if len(symbols)==len("".join(symbols)):
-                return Regex( "[%s]" % "".join( [ _escapeRegexRangeChars(sym) for sym in symbols] ) )
-            else:
-                return Regex( "|".join( [ re.escape(sym) for sym in symbols] ) )
-        except:
-            warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
-                    SyntaxWarning, stacklevel=2)
-
-
-    # last resort, just use MatchFirst
-    return MatchFirst( [ parseElementClass(sym) for sym in symbols ] )
-
-def dictOf( key, value ):
-    """Helper to easily and clearly define a dictionary by specifying the respective patterns
-       for the key and value.  Takes care of defining the Dict, ZeroOrMore, and Group tokens
-       in the proper order.  The key pattern can include delimiting markers or punctuation,
-       as long as they are suppressed, thereby leaving the significant key text.  The value
-       pattern can include named results, so that the Dict results can include named token
-       fields.
-    """
-    return Dict( ZeroOrMore( Group ( key + value ) ) )
-
-def originalTextFor(expr, asString=True):
-    """Helper to return the original, untokenized text for a given expression.  Useful to
-       restore the parsed fields of an HTML start tag into the raw tag text itself, or to
-       revert separate tokens with intervening whitespace back to the original matching
-       input text. Simpler to use than the parse action keepOriginalText, and does not
-       require the inspect module to chase up the call stack.  By default, returns a 
-       string containing the original parsed text.  
-       
-       If the optional asString argument is passed as False, then the return value is a 
-       ParseResults containing any results names that were originally matched, and a 
-       single token containing the original matched text from the input string.  So if 
-       the expression passed to originalTextFor contains expressions with defined
-       results names, you must set asString to False if you want to preserve those
-       results name values."""
-    locMarker = Empty().setParseAction(lambda s,loc,t: loc)
-    matchExpr = locMarker("_original_start") + expr + locMarker("_original_end")
-    if asString:
-        extractText = lambda s,l,t: s[t._original_start:t._original_end]
-    else:
-        def extractText(s,l,t):
-            del t[:]
-            t.insert(0, s[t._original_start:t._original_end])
-            del t["_original_start"]
-            del t["_original_end"]
-    matchExpr.setParseAction(extractText)
-    return matchExpr
-    
-# convenience constants for positional expressions
-empty       = Empty().setName("empty")
-lineStart   = LineStart().setName("lineStart")
-lineEnd     = LineEnd().setName("lineEnd")
-stringStart = StringStart().setName("stringStart")
-stringEnd   = StringEnd().setName("stringEnd")
-
-_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
-_printables_less_backslash = "".join([ c for c in printables if c not in  r"\]" ])
-_escapedHexChar = Combine( Suppress(_bslash + "0x") + Word(hexnums) ).setParseAction(lambda s,l,t:unichr(int(t[0],16)))
-_escapedOctChar = Combine( Suppress(_bslash) + Word("0","01234567") ).setParseAction(lambda s,l,t:unichr(int(t[0],8)))
-_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(_printables_less_backslash,exact=1)
-_charRange = Group(_singleChar + Suppress("-") + _singleChar)
-_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
-
-_expanded = lambda p: (isinstance(p,ParseResults) and ''.join([ unichr(c) for c in range(ord(p[0]),ord(p[1])+1) ]) or p)
-
-def srange(s):
-    r"""Helper to easily define string ranges for use in Word construction.  Borrows
-       syntax from regexp '[]' string range definitions::
-          srange("[0-9]")   -> "0123456789"
-          srange("[a-z]")   -> "abcdefghijklmnopqrstuvwxyz"
-          srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
-       The input string must be enclosed in []'s, and the returned string is the expanded
-       character set joined into a single string.
-       The values enclosed in the []'s may be::
-          a single character
-          an escaped character with a leading backslash (such as \- or \])
-          an escaped hex character with a leading '\0x' (\0x21, which is a '!' character)
-          an escaped octal character with a leading '\0' (\041, which is a '!' character)
-          a range of any of the above, separated by a dash ('a-z', etc.)
-          any combination of the above ('aeiouy', 'a-zA-Z0-9_$', etc.)
-    """
-    try:
-        return "".join([_expanded(part) for part in _reBracketExpr.parseString(s).body])
-    except:
-        return ""
-
-def matchOnlyAtCol(n):
-    """Helper method for defining parse actions that require matching at a specific
-       column in the input text.
-    """
-    def verifyCol(strg,locn,toks):
-        if col(locn,strg) != n:
-            raise ParseException(strg,locn,"matched token not at column %d" % n)
-    return verifyCol
-
-def replaceWith(replStr):
-    """Helper method for common parse actions that simply return a literal value.  Especially
-       useful when used with transformString().
-    """
-    def _replFunc(*args):
-        return [replStr]
-    return _replFunc
-
-def removeQuotes(s,l,t):
-    """Helper parse action for removing quotation marks from parsed quoted strings.
-       To use, add this parse action to quoted string using::
-         quotedString.setParseAction( removeQuotes )
-    """
-    return t[0][1:-1]
-
-def upcaseTokens(s,l,t):
-    """Helper parse action to convert tokens to upper case."""
-    return [ tt.upper() for tt in map(_ustr,t) ]
-
-def downcaseTokens(s,l,t):
-    """Helper parse action to convert tokens to lower case."""
-    return [ tt.lower() for tt in map(_ustr,t) ]
-
-def keepOriginalText(s,startLoc,t):
-    """Helper parse action to preserve original parsed text,
-       overriding any nested parse actions."""
-    try:
-        endloc = getTokensEndLoc()
-    except ParseException:
-        raise ParseFatalException("incorrect usage of keepOriginalText - may only be called as a parse action")
-    del t[:]
-    t += ParseResults(s[startLoc:endloc])
-    return t
-
-def getTokensEndLoc():
-    """Method to be called from within a parse action to determine the end
-       location of the parsed tokens."""
-    import inspect
-    fstack = inspect.stack()
-    try:
-        # search up the stack (through intervening argument normalizers) for correct calling routine
-        for f in fstack[2:]:
-            if f[3] == "_parseNoCache":
-                endloc = f[0].f_locals["loc"]
-                return endloc
-        else:
-            raise ParseFatalException("incorrect usage of getTokensEndLoc - may only be called from within a parse action")
-    finally:
-        del fstack
-
-def _makeTags(tagStr, xml):
-    """Internal helper to construct opening and closing tag expressions, given a tag name"""
-    if isinstance(tagStr,basestring):
-        resname = tagStr
-        tagStr = Keyword(tagStr, caseless=not xml)
-    else:
-        resname = tagStr.name
-
-    tagAttrName = Word(alphas,alphanums+"_-:")
-    if (xml):
-        tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
-        openTag = Suppress("<") + tagStr + \
-                Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
-    else:
-        printablesLessRAbrack = "".join( [ c for c in printables if c not in ">" ] )
-        tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
-        openTag = Suppress("<") + tagStr + \
-                Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
-                Optional( Suppress("=") + tagAttrValue ) ))) + \
-                Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
-    closeTag = Combine(_L("</") + tagStr + ">")
-
-    openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % tagStr)
-    closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("</%s>" % tagStr)
-
-    return openTag, closeTag
-
-def makeHTMLTags(tagStr):
-    """Helper to construct opening and closing tag expressions for HTML, given a tag name"""
-    return _makeTags( tagStr, False )
-
-def makeXMLTags(tagStr):
-    """Helper to construct opening and closing tag expressions for XML, given a tag name"""
-    return _makeTags( tagStr, True )
-
-def withAttribute(*args,**attrDict):
-    """Helper to create a validating parse action to be used with start tags created
-       with makeXMLTags or makeHTMLTags. Use withAttribute to qualify a starting tag
-       with a required attribute value, to avoid false matches on common tags such as
-       <TD> or <DIV>.
-
-       Call withAttribute with a series of attribute names and values. Specify the list
-       of filter attributes names and values as:
-        - keyword arguments, as in (class="Customer",align="right"), or
-        - a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
-       For attribute names with a namespace prefix, you must use the second form.  Attribute
-       names are matched insensitive to upper/lower case.
-
-       To verify that the attribute exists, but without specifying a value, pass
-       withAttribute.ANY_VALUE as the value.
-       """
-    if args:
-        attrs = args[:]
-    else:
-        attrs = attrDict.iteritems()
-    attrs = [(k,v) for k,v in attrs]
-    def pa(s,l,tokens):
-        for attrName,attrValue in attrs:
-            if attrName not in tokens:
-                raise ParseException(s,l,"no matching attribute " + attrName)
-            if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
-                raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
-                                            (attrName, tokens[attrName], attrValue))
-    return pa
-withAttribute.ANY_VALUE = object()
-
-opAssoc = _Constants()
-opAssoc.LEFT = object()
-opAssoc.RIGHT = object()
-
-def operatorPrecedence( baseExpr, opList ):
-    """Helper method for constructing grammars of expressions made up of
-       operators working in a precedence hierarchy.  Operators may be unary or
-       binary, left- or right-associative.  Parse actions can also be attached
-       to operator expressions.
-
-       Parameters:
-        - baseExpr - expression representing the most basic element for the nested
-        - opList - list of tuples, one for each operator precedence level in the
-          expression grammar; each tuple is of the form
-          (opExpr, numTerms, rightLeftAssoc, parseAction), where:
-           - opExpr is the pyparsing expression for the operator;
-              may also be a string, which will be converted to a Literal;
-              if numTerms is 3, opExpr is a tuple of two expressions, for the
-              two operators separating the 3 terms
-           - numTerms is the number of terms for this operator (must
-              be 1, 2, or 3)
-           - rightLeftAssoc is the indicator whether the operator is
-              right or left associative, using the pyparsing-defined
-              constants opAssoc.RIGHT and opAssoc.LEFT.
-           - parseAction is the parse action to be associated with
-              expressions matching this operator expression (the
-              parse action tuple member may be omitted)
-    """
-    ret = Forward()
-    lastExpr = baseExpr | ( Suppress('(') + ret + Suppress(')') )
-    for i,operDef in enumerate(opList):
-        opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
-        if arity == 3:
-            if opExpr is None or len(opExpr) != 2:
-                raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
-            opExpr1, opExpr2 = opExpr
-        thisExpr = Forward()#.setName("expr%d" % i)
-        if rightLeftAssoc == opAssoc.LEFT:
-            if arity == 1:
-                matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
-            elif arity == 2:
-                if opExpr is not None:
-                    matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
-                else:
-                    matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
-            elif arity == 3:
-                matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
-                            Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
-            else:
-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
-        elif rightLeftAssoc == opAssoc.RIGHT:
-            if arity == 1:
-                # try to avoid LR with this extra test
-                if not isinstance(opExpr, Optional):
-                    opExpr = Optional(opExpr)
-                matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
-            elif arity == 2:
-                if opExpr is not None:
-                    matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
-                else:
-                    matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
-            elif arity == 3:
-                matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
-                            Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
-            else:
-                raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
-        else:
-            raise ValueError("operator must indicate right or left associativity")
-        if pa:
-            matchExpr.setParseAction( pa )
-        thisExpr << ( matchExpr | lastExpr )
-        lastExpr = thisExpr
-    ret << lastExpr
-    return ret
-
-dblQuotedString = Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\x[0-9a-fA-F]+)|(?:\\.))*"').setName("string enclosed in double quotes")
-sglQuotedString = Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\x[0-9a-fA-F]+)|(?:\\.))*'").setName("string enclosed in single quotes")
-quotedString = Regex(r'''(?:"(?:[^"\n\r\\]|(?:"")|(?:\\x[0-9a-fA-F]+)|(?:\\.))*")|(?:'(?:[^'\n\r\\]|(?:'')|(?:\\x[0-9a-fA-F]+)|(?:\\.))*')''').setName("quotedString using single or double quotes")
-unicodeString = Combine(_L('u') + quotedString.copy())
-
-def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString):
-    """Helper method for defining nested lists enclosed in opening and closing
-       delimiters ("(" and ")" are the default).
-
-       Parameters:
-        - opener - opening character for a nested list (default="("); can also be a pyparsing expression
-        - closer - closing character for a nested list (default=")"); can also be a pyparsing expression
-        - content - expression for items within the nested lists (default=None)
-        - ignoreExpr - expression for ignoring opening and closing delimiters (default=quotedString)
-
-       If an expression is not provided for the content argument, the nested
-       expression will capture all whitespace-delimited content between delimiters
-       as a list of separate values.
-
-       Use the ignoreExpr argument to define expressions that may contain
-       opening or closing characters that should not be treated as opening
-       or closing characters for nesting, such as quotedString or a comment
-       expression.  Specify multiple expressions using an Or or MatchFirst.
-       The default is quotedString, but if no expressions are to be ignored,
-       then pass None for this argument.
-    """
-    if opener == closer:
-        raise ValueError("opening and closing strings cannot be the same")
-    if content is None:
-        if isinstance(opener,basestring) and isinstance(closer,basestring):
-            if len(opener) == 1 and len(closer)==1:
-                if ignoreExpr is not None:
-                    content = (Combine(OneOrMore(~ignoreExpr +
-                                    CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
-                                ).setParseAction(lambda t:t[0].strip()))
-                else:
-                    content = (empty+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
-                                ).setParseAction(lambda t:t[0].strip()))
-            else:
-                if ignoreExpr is not None:
-                    content = (Combine(OneOrMore(~ignoreExpr + 
-                                    ~Literal(opener) + ~Literal(closer) +
-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
-                                ).setParseAction(lambda t:t[0].strip()))
-                else:
-                    content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
-                                    CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
-                                ).setParseAction(lambda t:t[0].strip()))
-        else:
-            raise ValueError("opening and closing arguments must be strings if no content expression is given")
-    ret = Forward()
-    if ignoreExpr is not None:
-        ret << Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
-    else:
-        ret << Group( Suppress(opener) + ZeroOrMore( ret | content )  + Suppress(closer) )
-    return ret
-
-def indentedBlock(blockStatementExpr, indentStack, indent=True):
-    """Helper method for defining space-delimited indentation blocks, such as
-       those used to define block statements in Python source code.
-
-       Parameters:
-        - blockStatementExpr - expression defining syntax of statement that
-            is repeated within the indented block
-        - indentStack - list created by caller to manage indentation stack
-            (multiple statementWithIndentedBlock expressions within a single grammar
-            should share a common indentStack)
-        - indent - boolean indicating whether block must be indented beyond the
-            the current level; set to False for block of left-most statements
-            (default=True)
-
-       A valid block must contain at least one blockStatement.
-    """
-    def checkPeerIndent(s,l,t):
-        if l >= len(s): return
-        curCol = col(l,s)
-        if curCol != indentStack[-1]:
-            if curCol > indentStack[-1]:
-                raise ParseFatalException(s,l,"illegal nesting")
-            raise ParseException(s,l,"not a peer entry")
-
-    def checkSubIndent(s,l,t):
-        curCol = col(l,s)
-        if curCol > indentStack[-1]:
-            indentStack.append( curCol )
-        else:
-            raise ParseException(s,l,"not a subentry")
-
-    def checkUnindent(s,l,t):
-        if l >= len(s): return
-        curCol = col(l,s)
-        if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
-            raise ParseException(s,l,"not an unindent")
-        indentStack.pop()
-
-    NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
-    INDENT = Empty() + Empty().setParseAction(checkSubIndent)
-    PEER   = Empty().setParseAction(checkPeerIndent)
-    UNDENT = Empty().setParseAction(checkUnindent)
-    if indent:
-        smExpr = Group( Optional(NL) +
-            FollowedBy(blockStatementExpr) +
-            INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
-    else:
-        smExpr = Group( Optional(NL) +
-            (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
-    blockStatementExpr.ignore(_bslash + LineEnd())
-    return smExpr
-
-alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
-punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
-
-anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:"))
-commonHTMLEntity = Combine(_L("&") + oneOf("gt lt amp nbsp quot").setResultsName("entity") +";").streamline()
-_htmlEntityMap = dict(zip("gt lt amp nbsp quot".split(),'><& "'))
-replaceHTMLEntity = lambda t : t.entity in _htmlEntityMap and _htmlEntityMap[t.entity] or None
-
-# it's easy to get these comment structures wrong - they're very common, so may as well make them available
-cStyleComment = Regex(r"/\*(?:[^*]*\*+)+?/").setName("C style comment")
-
-htmlComment = Regex(r"<!--[\s\S]*?-->")
-restOfLine = Regex(r".*").leaveWhitespace()
-dblSlashComment = Regex(r"\/\/(\\\n|.)*").setName("// comment")
-cppStyleComment = Regex(r"/(?:\*(?:[^*]*\*+)+?/|/[^\n]*(?:\n[^\n]*)*?(?:(?<!\\)|\Z))").setName("C++ style comment")
-
-javaStyleComment = cppStyleComment
-pythonStyleComment = Regex(r"#.*").setName("Python style comment")
-_noncomma = "".join( [ c for c in printables if c != "," ] )
-_commasepitem = Combine(OneOrMore(Word(_noncomma) +
-                                  Optional( Word(" \t") +
-                                            ~Literal(",") + ~LineEnd() ) ) ).streamline().setName("commaItem")
-commaSeparatedList = delimitedList( Optional( quotedString | _commasepitem, default="") ).setName("commaSeparatedList")
-
-
-if __name__ == "__main__":
-
-    def test( teststring ):
-        try:
-            tokens = simpleSQL.parseString( teststring )
-            tokenlist = tokens.asList()
-            print (teststring + "->"   + str(tokenlist))
-            print ("tokens = "         + str(tokens))
-            print ("tokens.columns = " + str(tokens.columns))
-            print ("tokens.tables = "  + str(tokens.tables))
-            print (tokens.asXML("SQL",True))
-        except ParseBaseException,err:
-            print (teststring + "->")
-            print (err.line)
-            print (" "*(err.column-1) + "^")
-            print (err)
-        print()
-
-    selectToken    = CaselessLiteral( "select" )
-    fromToken      = CaselessLiteral( "from" )
-
-    ident          = Word( alphas, alphanums + "_$" )
-    columnName     = delimitedList( ident, ".", combine=True ).setParseAction( upcaseTokens )
-    columnNameList = Group( delimitedList( columnName ) )#.setName("columns")
-    tableName      = delimitedList( ident, ".", combine=True ).setParseAction( upcaseTokens )
-    tableNameList  = Group( delimitedList( tableName ) )#.setName("tables")
-    simpleSQL      = ( selectToken + \
-                     ( '*' | columnNameList ).setResultsName( "columns" ) + \
-                     fromToken + \
-                     tableNameList.setResultsName( "tables" ) )
-
-    test( "SELECT * from XYZZY, ABC" )
-    test( "select * from SYS.XYZZY" )
-    test( "Select A from Sys.dual" )
-    test( "Select AA,BB,CC from Sys.dual" )
-    test( "Select A, B, C from Sys.dual" )
-    test( "Select A, B, C from Sys.dual" )
-    test( "Xelect A, B, C from Sys.dual" )
-    test( "Select A, B, C frox Sys.dual" )
-    test( "Select" )
-    test( "Select ^^^ frox Sys.dual" )
-    test( "Select A, B, C from Sys.dual, Table2   " )
diff --git a/IPython/external/qt.py b/IPython/external/qt.py
deleted file mode 100644
index 129aadc29cf..00000000000
--- a/IPython/external/qt.py
+++ /dev/null
@@ -1,32 +0,0 @@
-""" A Qt API selector that can be used to switch between PyQt and PySide.
-"""
-
-import os
-
-# Available APIs.
-QT_API_PYQT = 'pyqt'
-QT_API_PYSIDE = 'pyside'
-
-# Use PyQt by default until PySide is stable.
-QT_API = os.environ.get('QT_API', QT_API_PYQT)
-
-if QT_API == QT_API_PYQT:
-    # For PySide compatibility, use the new-style string API that automatically
-    # converts QStrings to Unicode Python strings. Also, automatically unpack
-    # QVariants to their underlying objects.
-    import sip
-    sip.setapi('QString', 2)
-    sip.setapi('QVariant', 2)
-
-    from PyQt4 import QtCore, QtGui, QtSvg
-
-    # Alias PyQt-specific functions for PySide compatibility.
-    QtCore.Signal = QtCore.pyqtSignal
-    QtCore.Slot = QtCore.pyqtSlot
-
-elif QT_API == QT_API_PYSIDE:
-    from PySide import QtCore, QtGui, QtSvg
-
-else:
-    raise RuntimeError('Invalid Qt API %r, valid values are: %r or %r' % 
-                       (QT_API, QT_API_PYQT, QT_API_PYSIDE))
diff --git a/IPython/external/qt_for_kernel.py b/IPython/external/qt_for_kernel.py
new file mode 100644
index 00000000000..125f4e6d2ae
--- /dev/null
+++ b/IPython/external/qt_for_kernel.py
@@ -0,0 +1,124 @@
+"""Import Qt in a manner suitable for an IPython kernel.
+
+This is the import used for the `gui=qt` or `matplotlib=qt` initialization.
+
+Import Priority:
+
+if Qt has been imported anywhere else:
+   use that
+
+if matplotlib has been imported and doesn't support v2 (<= 1.0.1):
+    use PyQt4 @v1
+
+Next, ask QT_API env variable
+
+if QT_API not set:
+    ask matplotlib what it's using. If Qt4Agg or Qt5Agg, then use the
+        version matplotlib is configured with
+
+    else: (matplotlib said nothing)
+        # this is the default path - nobody told us anything
+        try in this order:
+            PyQt default version, PySide, PyQt5
+else:
+    use what QT_API says
+
+    Note that %gui's implementation will always set a `QT_API`, see
+    `IPython.terminal.pt_inputhooks.get_inputhook_name_and_func`
+
+"""
+# NOTE: This is no longer an external, third-party module, and should be
+# considered part of IPython. For compatibility however, it is being kept in
+# IPython/external.
+
+import os
+import sys
+
+from IPython.external.qt_loaders import (
+    load_qt,
+    loaded_api,
+    enum_factory,
+    # QT6
+    QT_API_PYQT6,
+    QT_API_PYSIDE6,
+    # QT5
+    QT_API_PYQT5,
+    QT_API_PYSIDE2,
+    # QT4
+    QT_API_PYQT,
+    QT_API_PYSIDE,
+    # default
+    QT_API_PYQT_DEFAULT,
+)
+
+_qt_apis = (
+    # QT6
+    QT_API_PYQT6,
+    QT_API_PYSIDE6,
+    # QT5
+    QT_API_PYQT5,
+    QT_API_PYSIDE2,
+    # default
+    QT_API_PYQT_DEFAULT,
+)
+
+
+def matplotlib_options(mpl):
+    """Constraints placed on an imported matplotlib."""
+    if mpl is None:
+        return
+    backend = mpl.rcParams.get('backend', None)
+    if backend == 'Qt4Agg':
+        mpqt = mpl.rcParams.get('backend.qt4', None)
+        if mpqt is None:
+            return None
+        if mpqt.lower() == 'pyside':
+            return [QT_API_PYSIDE]
+        elif mpqt.lower() == 'pyqt4':
+            return [QT_API_PYQT_DEFAULT]
+        elif mpqt.lower() == 'pyqt4v2':
+            return [QT_API_PYQT]
+        raise ImportError("unhandled value for backend.qt4 from matplotlib: %r" %
+                          mpqt)
+    elif backend == 'Qt5Agg':
+        mpqt = mpl.rcParams.get('backend.qt5', None)
+        if mpqt is None:
+            return None
+        if mpqt.lower() == 'pyqt5':
+            return [QT_API_PYQT5]
+        raise ImportError("unhandled value for backend.qt5 from matplotlib: %r" %
+                          mpqt)
+
+def get_options():
+    """Return a list of acceptable QT APIs, in decreasing order of preference."""
+    #already imported Qt somewhere. Use that
+    loaded = loaded_api()
+    if loaded is not None:
+        return [loaded]
+
+    mpl = sys.modules.get("matplotlib", None)
+
+    if mpl is not None and tuple(mpl.__version__.split(".")) < ("1", "0", "2"):
+        # 1.0.1 only supports PyQt4 v1
+        return [QT_API_PYQT_DEFAULT]
+
+    qt_api = os.environ.get('QT_API', None)
+    if qt_api is None:
+        #no ETS variable. Ask mpl, then use default fallback path
+        return matplotlib_options(mpl) or [
+            QT_API_PYQT_DEFAULT,
+            QT_API_PYQT6,
+            QT_API_PYSIDE6,
+            QT_API_PYQT5,
+            QT_API_PYSIDE2,
+        ]
+    elif qt_api not in _qt_apis:
+        raise RuntimeError("Invalid Qt API %r, valid values are: %r" %
+                           (qt_api, ', '.join(_qt_apis)))
+    else:
+        return [qt_api]
+
+
+api_opts = get_options()
+QtCore, QtGui, QtSvg, QT_API = load_qt(api_opts)
+enum_helper = enum_factory(QT_API, QtCore)
diff --git a/IPython/external/qt_loaders.py b/IPython/external/qt_loaders.py
new file mode 100644
index 00000000000..87b716582a1
--- /dev/null
+++ b/IPython/external/qt_loaders.py
@@ -0,0 +1,423 @@
+"""
+This module contains factory functions that attempt
+to return Qt submodules from the various python Qt bindings.
+
+It also protects against double-importing Qt with different
+bindings, which is unstable and likely to crash
+
+This is used primarily by qt and qt_for_kernel, and shouldn't
+be accessed directly from the outside
+"""
+
+import importlib.abc
+import sys
+import os
+import types
+from functools import partial, lru_cache
+import operator
+
+# ### Available APIs.
+# Qt6
+QT_API_PYQT6 = "pyqt6"
+QT_API_PYSIDE6 = "pyside6"
+
+# Qt5
+QT_API_PYQT5 = 'pyqt5'
+QT_API_PYSIDE2 = 'pyside2'
+
+# Qt4
+# NOTE: Here for legacy matplotlib compatibility, but not really supported on the IPython side.
+QT_API_PYQT = "pyqt"  # Force version 2
+QT_API_PYQTv1 = "pyqtv1"  # Force version 2
+QT_API_PYSIDE = "pyside"
+
+QT_API_PYQT_DEFAULT = "pyqtdefault"  # use system default for version 1 vs. 2
+
+api_to_module = {
+    # Qt6
+    QT_API_PYQT6: "PyQt6",
+    QT_API_PYSIDE6: "PySide6",
+    # Qt5
+    QT_API_PYQT5: "PyQt5",
+    QT_API_PYSIDE2: "PySide2",
+    # Qt4
+    QT_API_PYSIDE: "PySide",
+    QT_API_PYQT: "PyQt4",
+    QT_API_PYQTv1: "PyQt4",
+    # default
+    QT_API_PYQT_DEFAULT: "PyQt6",
+}
+
+
+class ImportDenier(importlib.abc.MetaPathFinder):
+    """Import Hook that will guard against bad Qt imports
+    once IPython commits to a specific binding
+    """
+
+    def __init__(self):
+        self.__forbidden = set()
+
+    def forbid(self, module_name):
+        sys.modules.pop(module_name, None)
+        self.__forbidden.add(module_name)
+
+    def find_spec(self, fullname, path, target=None):
+        if path:
+            return
+        if fullname in self.__forbidden:
+            raise ImportError(
+                """
+    Importing %s disabled by IPython, which has
+    already imported an Incompatible QT Binding: %s
+    """
+                % (fullname, loaded_api())
+            )
+
+
+ID = ImportDenier()
+sys.meta_path.insert(0, ID)
+
+
+def commit_api(api):
+    """Commit to a particular API, and trigger ImportErrors on subsequent
+    dangerous imports"""
+    modules = set(api_to_module.values())
+
+    modules.remove(api_to_module[api])
+    for mod in modules:
+        ID.forbid(mod)
+
+
+def loaded_api():
+    """Return which API is loaded, if any
+
+    If this returns anything besides None,
+    importing any other Qt binding is unsafe.
+
+    Returns
+    -------
+    None, 'pyside6', 'pyqt6', 'pyside2', 'pyside', 'pyqt', 'pyqt5', 'pyqtv1'
+    """
+    if sys.modules.get("PyQt6.QtCore"):
+        return QT_API_PYQT6
+    elif sys.modules.get("PySide6.QtCore"):
+        return QT_API_PYSIDE6
+    elif sys.modules.get("PyQt5.QtCore"):
+        return QT_API_PYQT5
+    elif sys.modules.get("PySide2.QtCore"):
+        return QT_API_PYSIDE2
+    elif sys.modules.get("PyQt4.QtCore"):
+        if qtapi_version() == 2:
+            return QT_API_PYQT
+        else:
+            return QT_API_PYQTv1
+    elif sys.modules.get("PySide.QtCore"):
+        return QT_API_PYSIDE
+
+    return None
+
+
+def has_binding(api):
+    """Safely check for PyQt4/5, PySide or PySide2, without importing submodules
+
+    Parameters
+    ----------
+    api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyside2' | 'pyqtdefault']
+        Which module to check for
+
+    Returns
+    -------
+    True if the relevant module appears to be importable
+    """
+    module_name = api_to_module[api]
+    from importlib.util import find_spec
+
+    required = ['QtCore', 'QtGui', 'QtSvg']
+    if api in (QT_API_PYQT5, QT_API_PYSIDE2, QT_API_PYQT6, QT_API_PYSIDE6):
+        # QT5 requires QtWidgets too
+        required.append('QtWidgets')
+
+    for submod in required:
+        try:
+            spec = find_spec('%s.%s' % (module_name, submod))
+        except ImportError:
+            # Package (e.g. PyQt5) not found
+            return False
+        else:
+            if spec is None:
+                # Submodule (e.g. PyQt5.QtCore) not found
+                return False
+
+    if api == QT_API_PYSIDE:
+        # We can also safely check PySide version
+        import PySide
+
+        return PySide.__version_info__ >= (1, 0, 3)
+
+    return True
+
+
+def qtapi_version():
+    """Return which QString API has been set, if any
+
+    Returns
+    -------
+    The QString API version (1 or 2), or None if not set
+    """
+    try:
+        import sip
+    except ImportError:
+        # as of PyQt5 5.11, sip is no longer available as a top-level
+        # module and needs to be imported from the PyQt5 namespace
+        try:
+            from PyQt5 import sip
+        except ImportError:
+            return
+    try:
+        return sip.getapi('QString')
+    except ValueError:
+        return
+
+
+def can_import(api):
+    """Safely query whether an API is importable, without importing it"""
+    if not has_binding(api):
+        return False
+
+    current = loaded_api()
+    if api == QT_API_PYQT_DEFAULT:
+        return current in [QT_API_PYQT6, None]
+    else:
+        return current in [api, None]
+
+
+def import_pyqt4(version=2):
+    """
+    Import PyQt4
+
+    Parameters
+    ----------
+    version : 1, 2, or None
+        Which QString/QVariant API to use. Set to None to use the system
+        default
+    ImportErrors raised within this function are non-recoverable
+    """
+    # The new-style string API (version=2) automatically
+    # converts QStrings to Unicode Python strings. Also, automatically unpacks
+    # QVariants to their underlying objects.
+    import sip
+
+    if version is not None:
+        sip.setapi('QString', version)
+        sip.setapi('QVariant', version)
+
+    from PyQt4 import QtGui, QtCore, QtSvg
+
+    if QtCore.PYQT_VERSION < 0x040700:
+        raise ImportError("IPython requires PyQt4 >= 4.7, found %s" %
+                          QtCore.PYQT_VERSION_STR)
+
+    # Alias PyQt-specific functions for PySide compatibility.
+    QtCore.Signal = QtCore.pyqtSignal
+    QtCore.Slot = QtCore.pyqtSlot
+
+    # query for the API version (in case version == None)
+    version = sip.getapi('QString')
+    api = QT_API_PYQTv1 if version == 1 else QT_API_PYQT
+    return QtCore, QtGui, QtSvg, api
+
+
+def import_pyqt5():
+    """
+    Import PyQt5
+
+    ImportErrors raised within this function are non-recoverable
+    """
+
+    from PyQt5 import QtCore, QtSvg, QtWidgets, QtGui
+
+    # Alias PyQt-specific functions for PySide compatibility.
+    QtCore.Signal = QtCore.pyqtSignal
+    QtCore.Slot = QtCore.pyqtSlot
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType('QtGuiCompat')
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+
+    api = QT_API_PYQT5
+    return QtCore, QtGuiCompat, QtSvg, api
+
+
+def import_pyqt6():
+    """
+    Import PyQt6
+
+    ImportErrors raised within this function are non-recoverable
+    """
+
+    from PyQt6 import QtCore, QtSvg, QtWidgets, QtGui
+
+    # Alias PyQt-specific functions for PySide compatibility.
+    QtCore.Signal = QtCore.pyqtSignal
+    QtCore.Slot = QtCore.pyqtSlot
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType("QtGuiCompat")
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+
+    api = QT_API_PYQT6
+    return QtCore, QtGuiCompat, QtSvg, api
+
+
+def import_pyside():
+    """
+    Import PySide
+
+    ImportErrors raised within this function are non-recoverable
+    """
+    from PySide import QtGui, QtCore, QtSvg
+    return QtCore, QtGui, QtSvg, QT_API_PYSIDE
+
+def import_pyside2():
+    """
+    Import PySide2
+
+    ImportErrors raised within this function are non-recoverable
+    """
+    from PySide2 import QtGui, QtCore, QtSvg, QtWidgets, QtPrintSupport
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType('QtGuiCompat')
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+    QtGuiCompat.__dict__.update(QtPrintSupport.__dict__)
+
+    return QtCore, QtGuiCompat, QtSvg, QT_API_PYSIDE2
+
+
+def import_pyside6():
+    """
+    Import PySide6
+
+    ImportErrors raised within this function are non-recoverable
+    """
+
+    def get_attrs(module):
+        return {
+            name: getattr(module, name)
+            for name in dir(module)
+            if not name.startswith("_")
+        }
+
+    from PySide6 import QtGui, QtCore, QtSvg, QtWidgets, QtPrintSupport
+
+    # Join QtGui and QtWidgets for Qt4 compatibility.
+    QtGuiCompat = types.ModuleType("QtGuiCompat")
+    QtGuiCompat.__dict__.update(QtGui.__dict__)
+    if QtCore.__version_info__ < (6, 7):
+        QtGuiCompat.__dict__.update(QtWidgets.__dict__)
+        QtGuiCompat.__dict__.update(QtPrintSupport.__dict__)
+    else:
+        QtGuiCompat.__dict__.update(get_attrs(QtWidgets))
+        QtGuiCompat.__dict__.update(get_attrs(QtPrintSupport))
+
+    return QtCore, QtGuiCompat, QtSvg, QT_API_PYSIDE6
+
+
+def load_qt(api_options):
+    """
+    Attempt to import Qt, given a preference list
+    of permissible bindings
+
+    It is safe to call this function multiple times.
+
+    Parameters
+    ----------
+    api_options : List of strings
+        The order of APIs to try. Valid items are 'pyside', 'pyside2',
+        'pyqt', 'pyqt5', 'pyqtv1' and 'pyqtdefault'
+
+    Returns
+    -------
+    A tuple of QtCore, QtGui, QtSvg, QT_API
+    The first three are the Qt modules. The last is the
+    string indicating which module was loaded.
+
+    Raises
+    ------
+    ImportError, if it isn't possible to import any requested
+    bindings (either because they aren't installed, or because
+    an incompatible library has already been installed)
+    """
+    loaders = {
+        # Qt6
+        QT_API_PYQT6: import_pyqt6,
+        QT_API_PYSIDE6: import_pyside6,
+        # Qt5
+        QT_API_PYQT5: import_pyqt5,
+        QT_API_PYSIDE2: import_pyside2,
+        # Qt4
+        QT_API_PYSIDE: import_pyside,
+        QT_API_PYQT: import_pyqt4,
+        QT_API_PYQTv1: partial(import_pyqt4, version=1),
+        # default
+        QT_API_PYQT_DEFAULT: import_pyqt6,
+    }
+
+    for api in api_options:
+
+        if api not in loaders:
+            raise RuntimeError(
+                "Invalid Qt API %r, valid values are: %s" %
+                (api, ", ".join(["%r" % k for k in loaders.keys()])))
+
+        if not can_import(api):
+            continue
+
+        #cannot safely recover from an ImportError during this
+        result = loaders[api]()
+        api = result[-1]  # changed if api = QT_API_PYQT_DEFAULT
+        commit_api(api)
+        return result
+    else:
+        # Clear the environment variable since it doesn't work.
+        if "QT_API" in os.environ:
+            del os.environ["QT_API"]
+
+        raise ImportError(
+            """
+    Could not load requested Qt binding. Please ensure that
+    PyQt4 >= 4.7, PyQt5, PyQt6, PySide >= 1.0.3, PySide2, or
+    PySide6 is available, and only one is imported per session.
+
+    Currently-imported Qt library:                              %r
+    PyQt5 available (requires QtCore, QtGui, QtSvg, QtWidgets): %s
+    PyQt6 available (requires QtCore, QtGui, QtSvg, QtWidgets): %s
+    PySide2 installed:                                          %s
+    PySide6 installed:                                          %s
+    Tried to load:                                              %r
+    """
+            % (
+                loaded_api(),
+                has_binding(QT_API_PYQT5),
+                has_binding(QT_API_PYQT6),
+                has_binding(QT_API_PYSIDE2),
+                has_binding(QT_API_PYSIDE6),
+                api_options,
+            )
+        )
+
+
+def enum_factory(QT_API, QtCore):
+    """Construct an enum helper to account for PyQt5 <-> PyQt6 changes."""
+
+    @lru_cache(None)
+    def _enum(name):
+        # foo.bar.Enum.Entry (PyQt6) <=> foo.bar.Entry (non-PyQt6).
+        return operator.attrgetter(
+            name if QT_API == QT_API_PYQT6 else name.rpartition(".")[0]
+        )(sys.modules[QtCore.__package__])
+
+    return _enum
diff --git a/IPython/external/simplegeneric/__init__.py b/IPython/external/simplegeneric/__init__.py
deleted file mode 100644
index be48f270c81..00000000000
--- a/IPython/external/simplegeneric/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-try:
-    from simplegeneric import *
-except ImportError:
-    from _simplegeneric import *
diff --git a/IPython/external/simplegeneric/_simplegeneric.py b/IPython/external/simplegeneric/_simplegeneric.py
deleted file mode 100644
index 556d6f29940..00000000000
--- a/IPython/external/simplegeneric/_simplegeneric.py
+++ /dev/null
@@ -1,139 +0,0 @@
-#Name: simplegeneric
-#Version: 0.6
-#Summary: Simple generic functions (similar to Python's own len(), pickle.dump(), etc.)
-#Home-page: http://cheeseshop.python.org/pypi/simplegeneric
-#Author: Phillip J. Eby
-#Author-email: peak@eby-sarna.com
-#License: PSF or ZPL
-
-# This is version 0.6 of Philip J. Eby's simplegeneric module
-# (http://cheeseshop.python.org/pypi/simplegeneric) patched to work
-# with Python 2.3 (which doesn't support assigning to __name__)
-
-__all__ = ["generic"]
-
-
-from types import ClassType, InstanceType
-classtypes = type, ClassType
-
-def generic(func):
-    """Create a simple generic function"""
-
-    _sentinel = object()
-
-    def _by_class(*args, **kw):
-        cls = args[0].__class__
-        for t in type(cls.__name__, (cls,object), {}).__mro__:
-            f = _gbt(t, _sentinel)
-            if f is not _sentinel:
-                return f(*args, **kw)
-        else:
-            return func(*args, **kw)
-
-    _by_type = {object: func, InstanceType: _by_class}
-    _gbt = _by_type.get
-
-    def when_type(t):
-        """Decorator to add a method that will be called for type `t`"""
-        if not isinstance(t, classtypes):
-            raise TypeError(
-                "%r is not a type or class" % (t,)
-            )
-        def decorate(f):
-            if _by_type.setdefault(t,f) is not f:
-                raise TypeError(
-                    "%r already has method for type %r" % (func, t)
-                )
-            return f
-        return decorate
-
-
-
-
-
-
-    _by_object = {}
-    _gbo = _by_object.get
-
-    def when_object(o):
-        """Decorator to add a method that will be called for object `o`"""
-        def decorate(f):
-            if _by_object.setdefault(id(o), (o,f))[1] is not f:
-                raise TypeError(
-                    "%r already has method for object %r" % (func, o)
-                )
-            return f
-        return decorate
-
-
-    def dispatch(*args, **kw):
-        f = _gbo(id(args[0]), _sentinel)
-        if f is _sentinel:
-            for t in type(args[0]).__mro__:
-                f = _gbt(t, _sentinel)
-                if f is not _sentinel:
-                    return f(*args, **kw)
-            else:
-                return func(*args, **kw)
-        else:
-            return f[1](*args, **kw)
-
-    try:
-        dispatch.__name__       = func.__name__
-    except TypeError:
-        pass
-    dispatch.__dict__       = func.__dict__.copy()
-    dispatch.__doc__        = func.__doc__
-    dispatch.__module__     = func.__module__
-
-    dispatch.when_type = when_type
-    dispatch.when_object = when_object
-    dispatch.default = func
-    dispatch.has_object = lambda o: id(o) in _by_object
-    dispatch.has_type   = lambda t: t in _by_type
-    return dispatch
-
-
-
-
-def test_suite():
-    import doctest
-    return doctest.DocFileSuite(
-        'README.txt',
-        optionflags=doctest.ELLIPSIS|doctest.REPORT_ONLY_FIRST_FAILURE,
-    )
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/IPython/external/ssh/__init__.py b/IPython/external/ssh/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/external/ssh/forward.py b/IPython/external/ssh/forward.py
deleted file mode 100644
index f441523a230..00000000000
--- a/IPython/external/ssh/forward.py
+++ /dev/null
@@ -1,90 +0,0 @@
-#!/usr/bin/env python
-
-#
-# This file is adapted from a paramiko demo, and thus licensed under LGPL 2.1.
-# Original Copyright (C) 2003-2007  Robey Pointer <robeypointer@gmail.com>
-# Edits Copyright (C) 2010 The IPython Team
-#
-# Paramiko is free software; you can redistribute it and/or modify it under the
-# terms of the GNU Lesser General Public License as published by the Free
-# Software Foundation; either version 2.1 of the License, or (at your option)
-# any later version.
-#
-# Paramiko is distrubuted in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with Paramiko; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
-
-"""
-Sample script showing how to do local port forwarding over paramiko.
-
-This script connects to the requested SSH server and sets up local port
-forwarding (the openssh -L option) from a local port through a tunneled
-connection to a destination reachable from the SSH server machine.
-"""
-
-from __future__ import print_function
-
-import logging
-import select
-import SocketServer
-
-logger = logging.getLogger('ssh')
-
-class ForwardServer (SocketServer.ThreadingTCPServer):
-    daemon_threads = True
-    allow_reuse_address = True
-    
-
-class Handler (SocketServer.BaseRequestHandler):
-
-    def handle(self):
-        try:
-            chan = self.ssh_transport.open_channel('direct-tcpip',
-                                                   (self.chain_host, self.chain_port),
-                                                   self.request.getpeername())
-        except Exception, e:
-            logger.debug('Incoming request to %s:%d failed: %s' % (self.chain_host,
-                                                              self.chain_port,
-                                                              repr(e)))
-            return
-        if chan is None:
-            logger.debug('Incoming request to %s:%d was rejected by the SSH server.' %
-                    (self.chain_host, self.chain_port))
-            return
-
-        logger.debug('Connected!  Tunnel open %r -> %r -> %r' % (self.request.getpeername(),
-                                                            chan.getpeername(), (self.chain_host, self.chain_port)))
-        while True:
-            r, w, x = select.select([self.request, chan], [], [])
-            if self.request in r:
-                data = self.request.recv(1024)
-                if len(data) == 0:
-                    break
-                chan.send(data)
-            if chan in r:
-                data = chan.recv(1024)
-                if len(data) == 0:
-                    break
-                self.request.send(data)
-        chan.close()
-        self.request.close()
-        logger.debug('Tunnel closed ')
-
-
-def forward_tunnel(local_port, remote_host, remote_port, transport):
-    # this is a little convoluted, but lets me configure things for the Handler
-    # object.  (SocketServer doesn't give Handlers any way to access the outer
-    # server normally.)
-    class SubHander (Handler):
-        chain_host = remote_host
-        chain_port = remote_port
-        ssh_transport = transport
-    ForwardServer(('127.0.0.1', local_port), SubHander).serve_forever()
-
-
-__all__ = ['forward_tunnel']
\ No newline at end of file
diff --git a/IPython/external/ssh/tunnel.py b/IPython/external/ssh/tunnel.py
deleted file mode 100644
index 6a11a6b1865..00000000000
--- a/IPython/external/ssh/tunnel.py
+++ /dev/null
@@ -1,295 +0,0 @@
-"""Basic ssh tunneling utilities."""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from __future__ import print_function
-
-import os,sys, atexit
-from multiprocessing import Process
-from getpass import getpass, getuser
-import warnings
-
-try:
-    with warnings.catch_warnings():
-        warnings.simplefilter('ignore', DeprecationWarning)
-        import paramiko
-except ImportError:
-    paramiko = None
-else:
-    from forward import forward_tunnel
-
-try:
-    from IPython.external import pexpect
-except ImportError:
-    pexpect = None
-
-from IPython.parallel.util import select_random_ports
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Check for passwordless login
-#-----------------------------------------------------------------------------
-
-def try_passwordless_ssh(server, keyfile, paramiko=None):
-    """Attempt to make an ssh connection without a password.
-    This is mainly used for requiring password input only once
-    when many tunnels may be connected to the same server.
-    
-    If paramiko is None, the default for the platform is chosen.
-    """
-    if paramiko is None:
-        paramiko = sys.platform == 'win32'
-    if not paramiko:
-        f = _try_passwordless_openssh
-    else:
-        f = _try_passwordless_paramiko
-    return f(server, keyfile)
-
-def _try_passwordless_openssh(server, keyfile):
-    """Try passwordless login with shell ssh command."""
-    if pexpect is None:
-        raise ImportError("pexpect unavailable, use paramiko")
-    cmd = 'ssh -f '+ server
-    if keyfile:
-        cmd += ' -i ' + keyfile
-    cmd += ' exit'
-    p = pexpect.spawn(cmd)
-    while True:
-        try:
-            p.expect('[Ppassword]:', timeout=.1)
-        except pexpect.TIMEOUT:
-            continue
-        except pexpect.EOF:
-            return True
-        else:
-            return False
-
-def _try_passwordless_paramiko(server, keyfile):
-    """Try passwordless login with paramiko."""
-    if paramiko is None:
-        raise ImportError("paramiko unavailable, use openssh")
-    username, server, port = _split_server(server)
-    client = paramiko.SSHClient()
-    client.load_system_host_keys()
-    client.set_missing_host_key_policy(paramiko.WarningPolicy())
-    try:
-        client.connect(server, port, username=username, key_filename=keyfile,
-               look_for_keys=True)
-    except paramiko.AuthenticationException:
-        return False
-    else:
-        client.close()
-        return True
-
-
-def tunnel_connection(socket, addr, server, keyfile=None, password=None, paramiko=None):
-    """Connect a socket to an address via an ssh tunnel.
-    
-    This is a wrapper for socket.connect(addr), when addr is not accessible
-    from the local machine.  It simply creates an ssh tunnel using the remaining args,
-    and calls socket.connect('tcp://localhost:lport') where lport is the randomly
-    selected local port of the tunnel.
-    
-    """
-    lport = select_random_ports(1)[0]
-    transport, addr = addr.split('://')
-    ip,rport = addr.split(':')
-    rport = int(rport)
-    if paramiko is None:
-        paramiko = sys.platform == 'win32'
-    if paramiko:
-        tunnelf = paramiko_tunnel
-    else:
-        tunnelf = openssh_tunnel
-    tunnel = tunnelf(lport, rport, server, remoteip=ip, keyfile=keyfile, password=password)
-    socket.connect('tcp://127.0.0.1:%i'%lport)
-    return tunnel
-
-def openssh_tunnel(lport, rport, server, remoteip='127.0.0.1', keyfile=None, password=None, timeout=15):
-    """Create an ssh tunnel using command-line ssh that connects port lport
-    on this machine to localhost:rport on server.  The tunnel
-    will automatically close when not in use, remaining open
-    for a minimum of timeout seconds for an initial connection.
-    
-    This creates a tunnel redirecting `localhost:lport` to `remoteip:rport`,
-    as seen from `server`.
-    
-    keyfile and password may be specified, but ssh config is checked for defaults.
-    
-    Parameters
-    ----------
-    
-        lport : int
-            local port for connecting to the tunnel from this machine.
-        rport : int
-            port on the remote machine to connect to.
-        server : str
-            The ssh server to connect to. The full ssh server string will be parsed.
-            user@server:port
-        remoteip : str [Default: 127.0.0.1]
-            The remote ip, specifying the destination of the tunnel.
-            Default is localhost, which means that the tunnel would redirect
-            localhost:lport on this machine to localhost:rport on the *server*.
-        
-        keyfile : str; path to public key file
-            This specifies a key to be used in ssh login, default None.
-            Regular default ssh keys will be used without specifying this argument.
-        password : str; 
-            Your ssh password to the ssh server. Note that if this is left None,
-            you will be prompted for it if passwordless key based login is unavailable.
-    
-    """
-    if pexpect is None:
-        raise ImportError("pexpect unavailable, use paramiko_tunnel")
-    ssh="ssh "
-    if keyfile:
-        ssh += "-i " + keyfile 
-    cmd = ssh + " -f -L 127.0.0.1:%i:%s:%i %s sleep %i"%(lport, remoteip, rport, server, timeout)
-    tunnel = pexpect.spawn(cmd)
-    failed = False
-    while True:
-        try:
-            tunnel.expect('[Pp]assword:', timeout=.1)
-        except pexpect.TIMEOUT:
-            continue
-        except pexpect.EOF:
-            if tunnel.exitstatus:
-                print (tunnel.exitstatus)
-                print (tunnel.before)
-                print (tunnel.after)
-                raise RuntimeError("tunnel '%s' failed to start"%(cmd))
-            else:
-                return tunnel.pid
-        else:
-            if failed:
-                print("Password rejected, try again")
-                password=None
-            if password is None:
-                password = getpass("%s's password: "%(server))
-            tunnel.sendline(password)
-            failed = True
-    
-def _split_server(server):
-    if '@' in server:
-        username,server = server.split('@', 1)
-    else:
-        username = getuser()
-    if ':' in server:
-        server, port = server.split(':')
-        port = int(port)
-    else:
-        port = 22
-    return username, server, port
-
-def paramiko_tunnel(lport, rport, server, remoteip='127.0.0.1', keyfile=None, password=None, timeout=15):
-    """launch a tunner with paramiko in a subprocess. This should only be used
-    when shell ssh is unavailable (e.g. Windows).
-    
-    This creates a tunnel redirecting `localhost:lport` to `remoteip:rport`,
-    as seen from `server`.
-    
-    If you are familiar with ssh tunnels, this creates the tunnel:
-    
-    ssh server -L localhost:lport:remoteip:rport
-    
-    keyfile and password may be specified, but ssh config is checked for defaults.
-    
-    
-    Parameters
-    ----------
-    
-        lport : int
-            local port for connecting to the tunnel from this machine.
-        rport : int
-            port on the remote machine to connect to.
-        server : str
-            The ssh server to connect to. The full ssh server string will be parsed.
-            user@server:port
-        remoteip : str [Default: 127.0.0.1]
-            The remote ip, specifying the destination of the tunnel.
-            Default is localhost, which means that the tunnel would redirect
-            localhost:lport on this machine to localhost:rport on the *server*.
-        
-        keyfile : str; path to public key file
-            This specifies a key to be used in ssh login, default None.
-            Regular default ssh keys will be used without specifying this argument.
-        password : str; 
-            Your ssh password to the ssh server. Note that if this is left None,
-            you will be prompted for it if passwordless key based login is unavailable.
-    
-    """
-    if paramiko is None:
-        raise ImportError("Paramiko not available")
-    
-    if password is None:
-        if not _check_passwordless_paramiko(server, keyfile):
-            password = getpass("%s's password: "%(server))
-
-    p = Process(target=_paramiko_tunnel, 
-            args=(lport, rport, server, remoteip), 
-            kwargs=dict(keyfile=keyfile, password=password))
-    p.daemon=False
-    p.start()
-    atexit.register(_shutdown_process, p)
-    return p
-    
-def _shutdown_process(p):
-    if p.isalive():
-        p.terminate()
-
-def _paramiko_tunnel(lport, rport, server, remoteip, keyfile=None, password=None):
-    """Function for actually starting a paramiko tunnel, to be passed
-    to multiprocessing.Process(target=this), and not called directly.
-    """
-    username, server, port = _split_server(server)
-    client = paramiko.SSHClient()
-    client.load_system_host_keys()
-    client.set_missing_host_key_policy(paramiko.WarningPolicy())
-
-    try:
-        client.connect(server, port, username=username, key_filename=keyfile,
-                       look_for_keys=True, password=password)
-#    except paramiko.AuthenticationException:
-#        if password is None:
-#            password = getpass("%s@%s's password: "%(username, server))
-#            client.connect(server, port, username=username, password=password)
-#        else:
-#            raise
-    except Exception as e:
-        print ('*** Failed to connect to %s:%d: %r' % (server, port, e))
-        sys.exit(1)
-
-    # print ('Now forwarding port %d to %s:%d ...' % (lport, server, rport))
-
-    try:
-        forward_tunnel(lport, remoteip, rport, client.get_transport())
-    except KeyboardInterrupt:
-        print ('SIGINT: Port forwarding stopped cleanly')
-        sys.exit(0)
-    except Exception as e:
-        print ("Port forwarding stopped uncleanly: %s"%e)
-        sys.exit(255)
-
-if sys.platform == 'win32':
-    ssh_tunnel = paramiko_tunnel
-else:
-    ssh_tunnel = openssh_tunnel
-
-    
-__all__ = ['tunnel_connection', 'ssh_tunnel', 'openssh_tunnel', 'paramiko_tunnel', 'try_passwordless_ssh']
-
-
diff --git a/IPython/external/validate/__init__.py b/IPython/external/validate/__init__.py
deleted file mode 100644
index 30840ce4906..00000000000
--- a/IPython/external/validate/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-try:
-    import validate
-    if '__docformat__' in validate.__all__ and validate.__version__.split('.') >= ['1', '0', '1']:
-        # __docformat__ was removed in 1.0.1 but 
-        validate.__all__ = [i for i in validate.__all__ if i != '__docformat__']
-    from validate import *
-except ImportError:
-    from _validate import *
diff --git a/IPython/external/validate/_validate.py b/IPython/external/validate/_validate.py
deleted file mode 100644
index 764b18a752a..00000000000
--- a/IPython/external/validate/_validate.py
+++ /dev/null
@@ -1,1414 +0,0 @@
-# validate.py
-# A Validator object
-# Copyright (C) 2005 Michael Foord, Mark Andrews, Nicola Larosa
-# E-mail: fuzzyman AT voidspace DOT org DOT uk
-#         mark AT la-la DOT com
-#         nico AT tekNico DOT net
-
-# This software is licensed under the terms of the BSD license.
-# http://www.voidspace.org.uk/python/license.shtml
-# Basically you're free to copy, modify, distribute and relicense it,
-# So long as you keep a copy of the license with it.
-
-# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
-# For information about bugfixes, updates and support, please join the
-# ConfigObj mailing list:
-# http://lists.sourceforge.net/lists/listinfo/configobj-develop
-# Comments, suggestions and bug reports welcome.
-
-"""
-    The Validator object is used to check that supplied values 
-    conform to a specification.
-    
-    The value can be supplied as a string - e.g. from a config file.
-    In this case the check will also *convert* the value to
-    the required type. This allows you to add validation
-    as a transparent layer to access data stored as strings.
-    The validation checks that the data is correct *and*
-    converts it to the expected type.
-    
-    Some standard checks are provided for basic data types.
-    Additional checks are easy to write. They can be
-    provided when the ``Validator`` is instantiated or
-    added afterwards.
-    
-    The standard functions work with the following basic data types :
-    
-    * integers
-    * floats
-    * booleans
-    * strings
-    * ip_addr
-    
-    plus lists of these datatypes
-    
-    Adding additional checks is done through coding simple functions.
-    
-    The full set of standard checks are : 
-    
-    * 'integer': matches integer values (including negative)
-                 Takes optional 'min' and 'max' arguments : ::
-    
-                   integer()
-                   integer(3, 9)  # any value from 3 to 9
-                   integer(min=0) # any positive value
-                   integer(max=9)
-    
-    * 'float': matches float values
-               Has the same parameters as the integer check.
-    
-    * 'boolean': matches boolean values - ``True`` or ``False``
-                 Acceptable string values for True are :
-                   true, on, yes, 1
-                 Acceptable string values for False are :
-                   false, off, no, 0
-    
-                 Any other value raises an error.
-    
-    * 'ip_addr': matches an Internet Protocol address, v.4, represented
-                 by a dotted-quad string, i.e. '1.2.3.4'.
-    
-    * 'string': matches any string.
-                Takes optional keyword args 'min' and 'max'
-                to specify min and max lengths of the string.
-    
-    * 'list': matches any list.
-              Takes optional keyword args 'min', and 'max' to specify min and
-              max sizes of the list. (Always returns a list.)
-    
-    * 'tuple': matches any tuple.
-              Takes optional keyword args 'min', and 'max' to specify min and
-              max sizes of the tuple. (Always returns a tuple.)
-    
-    * 'int_list': Matches a list of integers.
-                  Takes the same arguments as list.
-    
-    * 'float_list': Matches a list of floats.
-                    Takes the same arguments as list.
-    
-    * 'bool_list': Matches a list of boolean values.
-                   Takes the same arguments as list.
-    
-    * 'ip_addr_list': Matches a list of IP addresses.
-                     Takes the same arguments as list.
-    
-    * 'string_list': Matches a list of strings.
-                     Takes the same arguments as list.
-    
-    * 'mixed_list': Matches a list with different types in 
-                    specific positions. List size must match
-                    the number of arguments.
-    
-                    Each position can be one of :
-                    'integer', 'float', 'ip_addr', 'string', 'boolean'
-    
-                    So to specify a list with two strings followed
-                    by two integers, you write the check as : ::
-    
-                      mixed_list('string', 'string', 'integer', 'integer')
-    
-    * 'pass': This check matches everything ! It never fails
-              and the value is unchanged.
-    
-              It is also the default if no check is specified.
-    
-    * 'option': This check matches any from a list of options.
-                You specify this check with : ::
-    
-                  option('option 1', 'option 2', 'option 3')
-    
-    You can supply a default value (returned if no value is supplied)
-    using the default keyword argument.
-    
-    You specify a list argument for default using a list constructor syntax in
-    the check : ::
-    
-        checkname(arg1, arg2, default=list('val 1', 'val 2', 'val 3'))
-    
-    A badly formatted set of arguments will raise a ``VdtParamError``.
-"""
-
-__docformat__ = "restructuredtext en"
-
-__version__ = '0.3.2'
-
-__revision__ = '$Id: validate.py 123 2005-09-08 08:54:28Z fuzzyman $'
-
-__all__ = (
-    '__version__',
-    'dottedQuadToNum',
-    'numToDottedQuad',
-    'ValidateError',
-    'VdtUnknownCheckError',
-    'VdtParamError',
-    'VdtTypeError',
-    'VdtValueError',
-    'VdtValueTooSmallError',
-    'VdtValueTooBigError',
-    'VdtValueTooShortError',
-    'VdtValueTooLongError',
-    'VdtMissingValue',
-    'Validator',
-    'is_integer',
-    'is_float',
-    'is_boolean',
-    'is_list',
-    'is_tuple',
-    'is_ip_addr',
-    'is_string',
-    'is_int_list',
-    'is_bool_list',
-    'is_float_list',
-    'is_string_list',
-    'is_ip_addr_list',
-    'is_mixed_list',
-    'is_option',
-    '__docformat__',
-)
-
-
-import sys
-INTP_VER = sys.version_info[:2]
-if INTP_VER < (2, 2):
-    raise RuntimeError("Python v.2.2 or later needed")
-
-import re
-StringTypes = (str, unicode)
-
-
-_list_arg = re.compile(r'''
-    (?:
-        ([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*list\(
-            (
-                (?:
-                    \s*
-                    (?:
-                        (?:".*?")|              # double quotes
-                        (?:'.*?')|              # single quotes
-                        (?:[^'",\s\)][^,\)]*?)  # unquoted
-                    )
-                    \s*,\s*
-                )*
-                (?:
-                    (?:".*?")|              # double quotes
-                    (?:'.*?')|              # single quotes
-                    (?:[^'",\s\)][^,\)]*?)  # unquoted
-                )?                          # last one
-            )
-        \)
-    )
-''', re.VERBOSE)    # two groups
-
-_list_members = re.compile(r'''
-    (
-        (?:".*?")|              # double quotes
-        (?:'.*?')|              # single quotes
-        (?:[^'",\s=][^,=]*?)       # unquoted
-    )
-    (?:
-    (?:\s*,\s*)|(?:\s*$)            # comma
-    )
-''', re.VERBOSE)    # one group
-
-_paramstring = r'''
-    (?:
-        (
-            (?:
-                [a-zA-Z_][a-zA-Z0-9_]*\s*=\s*list\(
-                    (?:
-                        \s*
-                        (?:
-                            (?:".*?")|              # double quotes
-                            (?:'.*?')|              # single quotes
-                            (?:[^'",\s\)][^,\)]*?)       # unquoted
-                        )
-                        \s*,\s*
-                    )*
-                    (?:
-                        (?:".*?")|              # double quotes
-                        (?:'.*?')|              # single quotes
-                        (?:[^'",\s\)][^,\)]*?)       # unquoted
-                    )?                              # last one
-                \)
-            )|
-            (?:
-                (?:".*?")|              # double quotes
-                (?:'.*?')|              # single quotes
-                (?:[^'",\s=][^,=]*?)|       # unquoted
-                (?:                         # keyword argument
-                    [a-zA-Z_][a-zA-Z0-9_]*\s*=\s*
-                    (?:
-                        (?:".*?")|              # double quotes
-                        (?:'.*?')|              # single quotes
-                        (?:[^'",\s=][^,=]*?)       # unquoted
-                    )
-                )
-            )
-        )
-        (?:
-            (?:\s*,\s*)|(?:\s*$)            # comma
-        )
-    )
-    '''
-
-_matchstring = '^%s*' % _paramstring
-
-# Python pre 2.2.1 doesn't have bool
-try:
-    bool
-except NameError:
-    def bool(val):
-        """Simple boolean equivalent function. """
-        if val:
-            return 1
-        else:
-            return 0
-
-
-def dottedQuadToNum(ip):
-    """
-    Convert decimal dotted quad string to long integer
-    
-    >>> dottedQuadToNum('1 ')
-    1L
-    >>> dottedQuadToNum(' 1.2')
-    16777218L
-    >>> dottedQuadToNum(' 1.2.3 ')
-    16908291L
-    >>> dottedQuadToNum('1.2.3.4')
-    16909060L
-    >>> dottedQuadToNum('1.2.3. 4')
-    Traceback (most recent call last):
-    ValueError: Not a good dotted-quad IP: 1.2.3. 4
-    >>> dottedQuadToNum('255.255.255.255')
-    4294967295L
-    >>> dottedQuadToNum('255.255.255.256')
-    Traceback (most recent call last):
-    ValueError: Not a good dotted-quad IP: 255.255.255.256
-    """
-    
-    # import here to avoid it when ip_addr values are not used
-    import socket, struct
-    
-    try:
-        return struct.unpack('!L',
-            socket.inet_aton(ip.strip()))[0]
-    except socket.error:
-        # bug in inet_aton, corrected in Python 2.3
-        if ip.strip() == '255.255.255.255':
-            return 0xFFFFFFFFL
-        else:
-            raise ValueError('Not a good dotted-quad IP: %s' % ip)
-    return
-
-
-def numToDottedQuad(num):
-    """
-    Convert long int to dotted quad string
-    
-    >>> numToDottedQuad(-1L)
-    Traceback (most recent call last):
-    ValueError: Not a good numeric IP: -1
-    >>> numToDottedQuad(1L)
-    '0.0.0.1'
-    >>> numToDottedQuad(16777218L)
-    '1.0.0.2'
-    >>> numToDottedQuad(16908291L)
-    '1.2.0.3'
-    >>> numToDottedQuad(16909060L)
-    '1.2.3.4'
-    >>> numToDottedQuad(4294967295L)
-    '255.255.255.255'
-    >>> numToDottedQuad(4294967296L)
-    Traceback (most recent call last):
-    ValueError: Not a good numeric IP: 4294967296
-    """
-    
-    # import here to avoid it when ip_addr values are not used
-    import socket, struct
-    
-    # no need to intercept here, 4294967295L is fine
-    try:
-        return socket.inet_ntoa(
-            struct.pack('!L', long(num)))
-    except (socket.error, struct.error, OverflowError):
-        raise ValueError('Not a good numeric IP: %s' % num)
-
-
-class ValidateError(Exception):
-    """
-    This error indicates that the check failed.
-    It can be the base class for more specific errors.
-    
-    Any check function that fails ought to raise this error.
-    (or a subclass)
-    
-    >>> raise ValidateError
-    Traceback (most recent call last):
-    ValidateError
-    """
-
-
-class VdtMissingValue(ValidateError):
-    """No value was supplied to a check that needed one."""
-
-
-class VdtUnknownCheckError(ValidateError):
-    """An unknown check function was requested"""
-
-    def __init__(self, value):
-        """
-        >>> raise VdtUnknownCheckError('yoda')
-        Traceback (most recent call last):
-        VdtUnknownCheckError: the check "yoda" is unknown.
-        """
-        ValidateError.__init__(self, 'the check "%s" is unknown.' % (value,))
-
-
-class VdtParamError(SyntaxError):
-    """An incorrect parameter was passed"""
-
-    def __init__(self, name, value):
-        """
-        >>> raise VdtParamError('yoda', 'jedi')
-        Traceback (most recent call last):
-        VdtParamError: passed an incorrect value "jedi" for parameter "yoda".
-        """
-        SyntaxError.__init__(self, 'passed an incorrect value "%s" for parameter "%s".' % (value, name))
-
-
-class VdtTypeError(ValidateError):
-    """The value supplied was of the wrong type"""
-
-    def __init__(self, value):
-        """
-        >>> raise VdtTypeError('jedi')
-        Traceback (most recent call last):
-        VdtTypeError: the value "jedi" is of the wrong type.
-        """
-        ValidateError.__init__(self, 'the value "%s" is of the wrong type.' % (value,))
-
-
-class VdtValueError(ValidateError):
-    """The value supplied was of the correct type, but was not an allowed value."""
-    
-    def __init__(self, value):
-        """
-        >>> raise VdtValueError('jedi')
-        Traceback (most recent call last):
-        VdtValueError: the value "jedi" is unacceptable.
-        """
-        ValidateError.__init__(self, 'the value "%s" is unacceptable.' % (value,))
-
-
-class VdtValueTooSmallError(VdtValueError):
-    """The value supplied was of the correct type, but was too small."""
-
-    def __init__(self, value):
-        """
-        >>> raise VdtValueTooSmallError('0')
-        Traceback (most recent call last):
-        VdtValueTooSmallError: the value "0" is too small.
-        """
-        ValidateError.__init__(self, 'the value "%s" is too small.' % (value,))
-
-
-class VdtValueTooBigError(VdtValueError):
-    """The value supplied was of the correct type, but was too big."""
-
-    def __init__(self, value):
-        """
-        >>> raise VdtValueTooBigError('1')
-        Traceback (most recent call last):
-        VdtValueTooBigError: the value "1" is too big.
-        """
-        ValidateError.__init__(self, 'the value "%s" is too big.' % (value,))
-
-
-class VdtValueTooShortError(VdtValueError):
-    """The value supplied was of the correct type, but was too short."""
-
-    def __init__(self, value):
-        """
-        >>> raise VdtValueTooShortError('jed')
-        Traceback (most recent call last):
-        VdtValueTooShortError: the value "jed" is too short.
-        """
-        ValidateError.__init__(
-            self,
-            'the value "%s" is too short.' % (value,))
-
-
-class VdtValueTooLongError(VdtValueError):
-    """The value supplied was of the correct type, but was too long."""
-
-    def __init__(self, value):
-        """
-        >>> raise VdtValueTooLongError('jedie')
-        Traceback (most recent call last):
-        VdtValueTooLongError: the value "jedie" is too long.
-        """
-        ValidateError.__init__(self, 'the value "%s" is too long.' % (value,))
-
-
-class Validator(object):
-    """
-    Validator is an object that allows you to register a set of 'checks'.
-    These checks take input and test that it conforms to the check.
-    
-    This can also involve converting the value from a string into
-    the correct datatype.
-    
-    The ``check`` method takes an input string which configures which
-    check is to be used and applies that check to a supplied value.
-    
-    An example input string would be:
-    'int_range(param1, param2)'
-    
-    You would then provide something like:
-    
-    >>> def int_range_check(value, min, max):
-    ...     # turn min and max from strings to integers
-    ...     min = int(min)
-    ...     max = int(max)
-    ...     # check that value is of the correct type.
-    ...     # possible valid inputs are integers or strings
-    ...     # that represent integers
-    ...     if not isinstance(value, (int, long, StringTypes)):
-    ...         raise VdtTypeError(value)
-    ...     elif isinstance(value, StringTypes):
-    ...         # if we are given a string
-    ...         # attempt to convert to an integer
-    ...         try:
-    ...             value = int(value)
-    ...         except ValueError:
-    ...             raise VdtValueError(value)
-    ...     # check the value is between our constraints
-    ...     if not min <= value:
-    ...          raise VdtValueTooSmallError(value)
-    ...     if not value <= max:
-    ...          raise VdtValueTooBigError(value)
-    ...     return value
-    
-    >>> fdict = {'int_range': int_range_check}
-    >>> vtr1 = Validator(fdict)
-    >>> vtr1.check('int_range(20, 40)', '30')
-    30
-    >>> vtr1.check('int_range(20, 40)', '60')
-    Traceback (most recent call last):
-    VdtValueTooBigError: the value "60" is too big.
-    
-    New functions can be added with : ::
-    
-    >>> vtr2 = Validator()       
-    >>> vtr2.functions['int_range'] = int_range_check
-    
-    Or by passing in a dictionary of functions when Validator 
-    is instantiated.
-    
-    Your functions *can* use keyword arguments,
-    but the first argument should always be 'value'.
-    
-    If the function doesn't take additional arguments,
-    the parentheses are optional in the check.
-    It can be written with either of : ::
-    
-        keyword = function_name
-        keyword = function_name()
-    
-    The first program to utilise Validator() was Michael Foord's
-    ConfigObj, an alternative to ConfigParser which supports lists and
-    can validate a config file using a config schema.
-    For more details on using Validator with ConfigObj see:
-    http://www.voidspace.org.uk/python/configobj.html
-    """
-
-    # this regex does the initial parsing of the checks
-    _func_re = re.compile(r'(.+?)\((.*)\)')
-
-    # this regex takes apart keyword arguments
-    _key_arg = re.compile(r'^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$')
-
-
-    # this regex finds keyword=list(....) type values
-    _list_arg = _list_arg
-
-    # this regex takes individual values out of lists - in one pass
-    _list_members = _list_members
-
-    # These regexes check a set of arguments for validity
-    # and then pull the members out
-    _paramfinder = re.compile(_paramstring, re.VERBOSE)
-    _matchfinder = re.compile(_matchstring, re.VERBOSE)
-
-
-    def __init__(self, functions=None):
-        """
-        >>> vtri = Validator()
-        """
-        self.functions = {
-            '': self._pass,
-            'integer': is_integer,
-            'float': is_float,
-            'boolean': is_boolean,
-            'ip_addr': is_ip_addr,
-            'string': is_string,
-            'list': is_list,
-            'tuple': is_tuple,
-            'int_list': is_int_list,
-            'float_list': is_float_list,
-            'bool_list': is_bool_list,
-            'ip_addr_list': is_ip_addr_list,
-            'string_list': is_string_list,
-            'mixed_list': is_mixed_list,
-            'pass': self._pass,
-            'option': is_option,
-        }
-        if functions is not None:
-            self.functions.update(functions)
-        # tekNico: for use by ConfigObj
-        self.baseErrorClass = ValidateError
-        self._cache = {}
-
-
-    def check(self, check, value, missing=False):
-        """
-        Usage: check(check, value)
-        
-        Arguments:
-            check: string representing check to apply (including arguments)
-            value: object to be checked
-        Returns value, converted to correct type if necessary
-        
-        If the check fails, raises a ``ValidateError`` subclass.
-        
-        >>> vtor.check('yoda', '')
-        Traceback (most recent call last):
-        VdtUnknownCheckError: the check "yoda" is unknown.
-        >>> vtor.check('yoda()', '')
-        Traceback (most recent call last):
-        VdtUnknownCheckError: the check "yoda" is unknown.
-        
-        >>> vtor.check('string(default="")', '', missing=True)
-        ''
-        """
-        fun_name, fun_args, fun_kwargs, default = self._parse_with_caching(check)
-            
-        if missing:
-            if default is None:
-                # no information needed here - to be handled by caller
-                raise VdtMissingValue()
-            value = self._handle_none(default)
-                
-        if value is None:
-            return None
-        
-        return self._check_value(value, fun_name, fun_args, fun_kwargs)
-
-
-    def _handle_none(self, value):
-        if value == 'None':
-            value = None
-        elif value in ("'None'", '"None"'):
-            # Special case a quoted None
-            value = self._unquote(value)
-        return value
-
-
-    def _parse_with_caching(self, check):
-        if check in self._cache:
-            fun_name, fun_args, fun_kwargs, default = self._cache[check]
-            # We call list and dict below to work with *copies* of the data
-            # rather than the original (which are mutable of course)
-            fun_args = list(fun_args)
-            fun_kwargs = dict(fun_kwargs)
-        else:
-            fun_name, fun_args, fun_kwargs, default = self._parse_check(check)
-            fun_kwargs = dict((str(key), value) for (key, value) in fun_kwargs.items())
-            self._cache[check] = fun_name, list(fun_args), dict(fun_kwargs), default
-        return fun_name, fun_args, fun_kwargs, default
-        
-        
-    def _check_value(self, value, fun_name, fun_args, fun_kwargs):
-        try:
-            fun = self.functions[fun_name]
-        except KeyError:
-            raise VdtUnknownCheckError(fun_name)
-        else:
-            return fun(value, *fun_args, **fun_kwargs)
-
-
-    def _parse_check(self, check):
-        fun_match = self._func_re.match(check)
-        if fun_match:
-            fun_name = fun_match.group(1)
-            arg_string = fun_match.group(2)
-            arg_match = self._matchfinder.match(arg_string)
-            if arg_match is None:
-                # Bad syntax
-                raise VdtParamError('Bad syntax in check "%s".' % check)
-            fun_args = []
-            fun_kwargs = {}
-            # pull out args of group 2
-            for arg in self._paramfinder.findall(arg_string):
-                # args may need whitespace removing (before removing quotes)
-                arg = arg.strip()
-                listmatch = self._list_arg.match(arg)
-                if listmatch:
-                    key, val = self._list_handle(listmatch)
-                    fun_kwargs[key] = val
-                    continue
-                keymatch = self._key_arg.match(arg)
-                if keymatch:
-                    val = keymatch.group(2)
-                    if not val in ("'None'", '"None"'):
-                        # Special case a quoted None
-                        val = self._unquote(val)
-                    fun_kwargs[keymatch.group(1)] = val
-                    continue
-                
-                fun_args.append(self._unquote(arg))
-        else:
-            # allows for function names without (args)
-            return check, (), {}, None
-
-        # Default must be deleted if the value is specified too,
-        # otherwise the check function will get a spurious "default" keyword arg
-        try:
-            default = fun_kwargs.pop('default', None)
-        except AttributeError:
-            # Python 2.2 compatibility
-            default = None
-            try:
-                default = fun_kwargs['default']
-                del fun_kwargs['default']
-            except KeyError:
-                pass
-            
-        return fun_name, fun_args, fun_kwargs, default
-
-
-    def _unquote(self, val):
-        """Unquote a value if necessary."""
-        if (len(val) >= 2) and (val[0] in ("'", '"')) and (val[0] == val[-1]):
-            val = val[1:-1]
-        return val
-
-
-    def _list_handle(self, listmatch):
-        """Take apart a ``keyword=list('val, 'val')`` type string."""
-        out = []
-        name = listmatch.group(1)
-        args = listmatch.group(2)
-        for arg in self._list_members.findall(args):
-            out.append(self._unquote(arg))
-        return name, out
-
-
-    def _pass(self, value):
-        """
-        Dummy check that always passes
-        
-        >>> vtor.check('', 0)
-        0
-        >>> vtor.check('', '0')
-        '0'
-        """
-        return value
-    
-    
-    def get_default_value(self, check):
-        """
-        Given a check, return the default value for the check
-        (converted to the right type).
-        
-        If the check doesn't specify a default value then a
-        ``KeyError`` will be raised.
-        """
-        fun_name, fun_args, fun_kwargs, default = self._parse_with_caching(check)
-        if default is None:
-            raise KeyError('Check "%s" has no default value.' % check)
-        value = self._handle_none(default)
-        if value is None:
-            return value
-        return self._check_value(value, fun_name, fun_args, fun_kwargs)
-
-
-def _is_num_param(names, values, to_float=False):
-    """
-    Return numbers from inputs or raise VdtParamError.
-    
-    Lets ``None`` pass through.
-    Pass in keyword argument ``to_float=True`` to
-    use float for the conversion rather than int.
-    
-    >>> _is_num_param(('', ''), (0, 1.0))
-    [0, 1]
-    >>> _is_num_param(('', ''), (0, 1.0), to_float=True)
-    [0.0, 1.0]
-    >>> _is_num_param(('a'), ('a'))
-    Traceback (most recent call last):
-    VdtParamError: passed an incorrect value "a" for parameter "a".
-    """
-    fun = to_float and float or int
-    out_params = []
-    for (name, val) in zip(names, values):
-        if val is None:
-            out_params.append(val)
-        elif isinstance(val, (int, long, float, StringTypes)):
-            try:
-                out_params.append(fun(val))
-            except ValueError, e:
-                raise VdtParamError(name, val)
-        else:
-            raise VdtParamError(name, val)
-    return out_params
-
-
-# built in checks
-# you can override these by setting the appropriate name
-# in Validator.functions
-# note: if the params are specified wrongly in your input string,
-#       you will also raise errors.
-
-def is_integer(value, min=None, max=None):
-    """
-    A check that tests that a given value is an integer (int, or long)
-    and optionally, between bounds. A negative value is accepted, while
-    a float will fail.
-    
-    If the value is a string, then the conversion is done - if possible.
-    Otherwise a VdtError is raised.
-    
-    >>> vtor.check('integer', '-1')
-    -1
-    >>> vtor.check('integer', '0')
-    0
-    >>> vtor.check('integer', 9)
-    9
-    >>> vtor.check('integer', 'a')
-    Traceback (most recent call last):
-    VdtTypeError: the value "a" is of the wrong type.
-    >>> vtor.check('integer', '2.2')
-    Traceback (most recent call last):
-    VdtTypeError: the value "2.2" is of the wrong type.
-    >>> vtor.check('integer(10)', '20')
-    20
-    >>> vtor.check('integer(max=20)', '15')
-    15
-    >>> vtor.check('integer(10)', '9')
-    Traceback (most recent call last):
-    VdtValueTooSmallError: the value "9" is too small.
-    >>> vtor.check('integer(10)', 9)
-    Traceback (most recent call last):
-    VdtValueTooSmallError: the value "9" is too small.
-    >>> vtor.check('integer(max=20)', '35')
-    Traceback (most recent call last):
-    VdtValueTooBigError: the value "35" is too big.
-    >>> vtor.check('integer(max=20)', 35)
-    Traceback (most recent call last):
-    VdtValueTooBigError: the value "35" is too big.
-    >>> vtor.check('integer(0, 9)', False)
-    0
-    """
-    (min_val, max_val) = _is_num_param(('min', 'max'), (min, max))
-    if not isinstance(value, (int, long, StringTypes)):
-        raise VdtTypeError(value)
-    if isinstance(value, StringTypes):
-        # if it's a string - does it represent an integer ?
-        try:
-            value = int(value)
-        except ValueError:
-            raise VdtTypeError(value)
-    if (min_val is not None) and (value < min_val):
-        raise VdtValueTooSmallError(value)
-    if (max_val is not None) and (value > max_val):
-        raise VdtValueTooBigError(value)
-    return value
-
-
-def is_float(value, min=None, max=None):
-    """
-    A check that tests that a given value is a float
-    (an integer will be accepted), and optionally - that it is between bounds.
-    
-    If the value is a string, then the conversion is done - if possible.
-    Otherwise a VdtError is raised.
-    
-    This can accept negative values.
-    
-    >>> vtor.check('float', '2')
-    2.0
-    
-    From now on we multiply the value to avoid comparing decimals
-    
-    >>> vtor.check('float', '-6.8') * 10
-    -68.0
-    >>> vtor.check('float', '12.2') * 10
-    122.0
-    >>> vtor.check('float', 8.4) * 10
-    84.0
-    >>> vtor.check('float', 'a')
-    Traceback (most recent call last):
-    VdtTypeError: the value "a" is of the wrong type.
-    >>> vtor.check('float(10.1)', '10.2') * 10
-    102.0
-    >>> vtor.check('float(max=20.2)', '15.1') * 10
-    151.0
-    >>> vtor.check('float(10.0)', '9.0')
-    Traceback (most recent call last):
-    VdtValueTooSmallError: the value "9.0" is too small.
-    >>> vtor.check('float(max=20.0)', '35.0')
-    Traceback (most recent call last):
-    VdtValueTooBigError: the value "35.0" is too big.
-    """
-    (min_val, max_val) = _is_num_param(
-        ('min', 'max'), (min, max), to_float=True)
-    if not isinstance(value, (int, long, float, StringTypes)):
-        raise VdtTypeError(value)
-    if not isinstance(value, float):
-        # if it's a string - does it represent a float ?
-        try:
-            value = float(value)
-        except ValueError:
-            raise VdtTypeError(value)
-    if (min_val is not None) and (value < min_val):
-        raise VdtValueTooSmallError(value)
-    if (max_val is not None) and (value > max_val):
-        raise VdtValueTooBigError(value)
-    return value
-
-
-bool_dict = {
-    True: True, 'on': True, '1': True, 'true': True, 'yes': True, 
-    False: False, 'off': False, '0': False, 'false': False, 'no': False,
-}
-
-
-def is_boolean(value):
-    """
-    Check if the value represents a boolean.
-    
-    >>> vtor.check('boolean', 0)
-    0
-    >>> vtor.check('boolean', False)
-    0
-    >>> vtor.check('boolean', '0')
-    0
-    >>> vtor.check('boolean', 'off')
-    0
-    >>> vtor.check('boolean', 'false')
-    0
-    >>> vtor.check('boolean', 'no')
-    0
-    >>> vtor.check('boolean', 'nO')
-    0
-    >>> vtor.check('boolean', 'NO')
-    0
-    >>> vtor.check('boolean', 1)
-    1
-    >>> vtor.check('boolean', True)
-    1
-    >>> vtor.check('boolean', '1')
-    1
-    >>> vtor.check('boolean', 'on')
-    1
-    >>> vtor.check('boolean', 'true')
-    1
-    >>> vtor.check('boolean', 'yes')
-    1
-    >>> vtor.check('boolean', 'Yes')
-    1
-    >>> vtor.check('boolean', 'YES')
-    1
-    >>> vtor.check('boolean', '')
-    Traceback (most recent call last):
-    VdtTypeError: the value "" is of the wrong type.
-    >>> vtor.check('boolean', 'up')
-    Traceback (most recent call last):
-    VdtTypeError: the value "up" is of the wrong type.
-    
-    """
-    if isinstance(value, StringTypes):
-        try:
-            return bool_dict[value.lower()]
-        except KeyError:
-            raise VdtTypeError(value)
-    # we do an equality test rather than an identity test
-    # this ensures Python 2.2 compatibilty
-    # and allows 0 and 1 to represent True and False
-    if value == False:
-        return False
-    elif value == True:
-        return True
-    else:
-        raise VdtTypeError(value)
-
-
-def is_ip_addr(value):
-    """
-    Check that the supplied value is an Internet Protocol address, v.4,
-    represented by a dotted-quad string, i.e. '1.2.3.4'.
-    
-    >>> vtor.check('ip_addr', '1 ')
-    '1'
-    >>> vtor.check('ip_addr', ' 1.2')
-    '1.2'
-    >>> vtor.check('ip_addr', ' 1.2.3 ')
-    '1.2.3'
-    >>> vtor.check('ip_addr', '1.2.3.4')
-    '1.2.3.4'
-    >>> vtor.check('ip_addr', '0.0.0.0')
-    '0.0.0.0'
-    >>> vtor.check('ip_addr', '255.255.255.255')
-    '255.255.255.255'
-    >>> vtor.check('ip_addr', '255.255.255.256')
-    Traceback (most recent call last):
-    VdtValueError: the value "255.255.255.256" is unacceptable.
-    >>> vtor.check('ip_addr', '1.2.3.4.5')
-    Traceback (most recent call last):
-    VdtValueError: the value "1.2.3.4.5" is unacceptable.
-    >>> vtor.check('ip_addr', '1.2.3. 4')
-    Traceback (most recent call last):
-    VdtValueError: the value "1.2.3. 4" is unacceptable.
-    >>> vtor.check('ip_addr', 0)
-    Traceback (most recent call last):
-    VdtTypeError: the value "0" is of the wrong type.
-    """
-    if not isinstance(value, StringTypes):
-        raise VdtTypeError(value)
-    value = value.strip()
-    try:
-        dottedQuadToNum(value)
-    except ValueError:
-        raise VdtValueError(value)
-    return value
-
-
-def is_list(value, min=None, max=None):
-    """
-    Check that the value is a list of values.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    It does no check on list members.
-    
-    >>> vtor.check('list', ())
-    []
-    >>> vtor.check('list', [])
-    []
-    >>> vtor.check('list', (1, 2))
-    [1, 2]
-    >>> vtor.check('list', [1, 2])
-    [1, 2]
-    >>> vtor.check('list(3)', (1, 2))
-    Traceback (most recent call last):
-    VdtValueTooShortError: the value "(1, 2)" is too short.
-    >>> vtor.check('list(max=5)', (1, 2, 3, 4, 5, 6))
-    Traceback (most recent call last):
-    VdtValueTooLongError: the value "(1, 2, 3, 4, 5, 6)" is too long.
-    >>> vtor.check('list(min=3, max=5)', (1, 2, 3, 4))
-    [1, 2, 3, 4]
-    >>> vtor.check('list', 0)
-    Traceback (most recent call last):
-    VdtTypeError: the value "0" is of the wrong type.
-    >>> vtor.check('list', '12')
-    Traceback (most recent call last):
-    VdtTypeError: the value "12" is of the wrong type.
-    """
-    (min_len, max_len) = _is_num_param(('min', 'max'), (min, max))
-    if isinstance(value, StringTypes):
-        raise VdtTypeError(value)
-    try:
-        num_members = len(value)
-    except TypeError:
-        raise VdtTypeError(value)
-    if min_len is not None and num_members < min_len:
-        raise VdtValueTooShortError(value)
-    if max_len is not None and num_members > max_len:
-        raise VdtValueTooLongError(value)
-    return list(value)
-
-
-def is_tuple(value, min=None, max=None):
-    """
-    Check that the value is a tuple of values.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    It does no check on members.
-    
-    >>> vtor.check('tuple', ())
-    ()
-    >>> vtor.check('tuple', [])
-    ()
-    >>> vtor.check('tuple', (1, 2))
-    (1, 2)
-    >>> vtor.check('tuple', [1, 2])
-    (1, 2)
-    >>> vtor.check('tuple(3)', (1, 2))
-    Traceback (most recent call last):
-    VdtValueTooShortError: the value "(1, 2)" is too short.
-    >>> vtor.check('tuple(max=5)', (1, 2, 3, 4, 5, 6))
-    Traceback (most recent call last):
-    VdtValueTooLongError: the value "(1, 2, 3, 4, 5, 6)" is too long.
-    >>> vtor.check('tuple(min=3, max=5)', (1, 2, 3, 4))
-    (1, 2, 3, 4)
-    >>> vtor.check('tuple', 0)
-    Traceback (most recent call last):
-    VdtTypeError: the value "0" is of the wrong type.
-    >>> vtor.check('tuple', '12')
-    Traceback (most recent call last):
-    VdtTypeError: the value "12" is of the wrong type.
-    """
-    return tuple(is_list(value, min, max))
-
-
-def is_string(value, min=None, max=None):
-    """
-    Check that the supplied value is a string.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    >>> vtor.check('string', '0')
-    '0'
-    >>> vtor.check('string', 0)
-    Traceback (most recent call last):
-    VdtTypeError: the value "0" is of the wrong type.
-    >>> vtor.check('string(2)', '12')
-    '12'
-    >>> vtor.check('string(2)', '1')
-    Traceback (most recent call last):
-    VdtValueTooShortError: the value "1" is too short.
-    >>> vtor.check('string(min=2, max=3)', '123')
-    '123'
-    >>> vtor.check('string(min=2, max=3)', '1234')
-    Traceback (most recent call last):
-    VdtValueTooLongError: the value "1234" is too long.
-    """
-    if not isinstance(value, StringTypes):
-        raise VdtTypeError(value)
-    (min_len, max_len) = _is_num_param(('min', 'max'), (min, max))
-    try:
-        num_members = len(value)
-    except TypeError:
-        raise VdtTypeError(value)
-    if min_len is not None and num_members < min_len:
-        raise VdtValueTooShortError(value)
-    if max_len is not None and num_members > max_len:
-        raise VdtValueTooLongError(value)
-    return value
-
-
-def is_int_list(value, min=None, max=None):
-    """
-    Check that the value is a list of integers.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    Each list member is checked that it is an integer.
-    
-    >>> vtor.check('int_list', ())
-    []
-    >>> vtor.check('int_list', [])
-    []
-    >>> vtor.check('int_list', (1, 2))
-    [1, 2]
-    >>> vtor.check('int_list', [1, 2])
-    [1, 2]
-    >>> vtor.check('int_list', [1, 'a'])
-    Traceback (most recent call last):
-    VdtTypeError: the value "a" is of the wrong type.
-    """
-    return [is_integer(mem) for mem in is_list(value, min, max)]
-
-
-def is_bool_list(value, min=None, max=None):
-    """
-    Check that the value is a list of booleans.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    Each list member is checked that it is a boolean.
-    
-    >>> vtor.check('bool_list', ())
-    []
-    >>> vtor.check('bool_list', [])
-    []
-    >>> check_res = vtor.check('bool_list', (True, False))
-    >>> check_res == [True, False]
-    1
-    >>> check_res = vtor.check('bool_list', [True, False])
-    >>> check_res == [True, False]
-    1
-    >>> vtor.check('bool_list', [True, 'a'])
-    Traceback (most recent call last):
-    VdtTypeError: the value "a" is of the wrong type.
-    """
-    return [is_boolean(mem) for mem in is_list(value, min, max)]
-
-
-def is_float_list(value, min=None, max=None):
-    """
-    Check that the value is a list of floats.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    Each list member is checked that it is a float.
-    
-    >>> vtor.check('float_list', ())
-    []
-    >>> vtor.check('float_list', [])
-    []
-    >>> vtor.check('float_list', (1, 2.0))
-    [1.0, 2.0]
-    >>> vtor.check('float_list', [1, 2.0])
-    [1.0, 2.0]
-    >>> vtor.check('float_list', [1, 'a'])
-    Traceback (most recent call last):
-    VdtTypeError: the value "a" is of the wrong type.
-    """
-    return [is_float(mem) for mem in is_list(value, min, max)]
-
-
-def is_string_list(value, min=None, max=None):
-    """
-    Check that the value is a list of strings.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    Each list member is checked that it is a string.
-    
-    >>> vtor.check('string_list', ())
-    []
-    >>> vtor.check('string_list', [])
-    []
-    >>> vtor.check('string_list', ('a', 'b'))
-    ['a', 'b']
-    >>> vtor.check('string_list', ['a', 1])
-    Traceback (most recent call last):
-    VdtTypeError: the value "1" is of the wrong type.
-    >>> vtor.check('string_list', 'hello')
-    Traceback (most recent call last):
-    VdtTypeError: the value "hello" is of the wrong type.
-    """
-    if isinstance(value, StringTypes):
-        raise VdtTypeError(value)
-    return [is_string(mem) for mem in is_list(value, min, max)]
-
-
-def is_ip_addr_list(value, min=None, max=None):
-    """
-    Check that the value is a list of IP addresses.
-    
-    You can optionally specify the minimum and maximum number of members.
-    
-    Each list member is checked that it is an IP address.
-    
-    >>> vtor.check('ip_addr_list', ())
-    []
-    >>> vtor.check('ip_addr_list', [])
-    []
-    >>> vtor.check('ip_addr_list', ('1.2.3.4', '5.6.7.8'))
-    ['1.2.3.4', '5.6.7.8']
-    >>> vtor.check('ip_addr_list', ['a'])
-    Traceback (most recent call last):
-    VdtValueError: the value "a" is unacceptable.
-    """
-    return [is_ip_addr(mem) for mem in is_list(value, min, max)]
-
-
-fun_dict = {
-    'integer': is_integer,
-    'float': is_float,
-    'ip_addr': is_ip_addr,
-    'string': is_string,
-    'boolean': is_boolean,
-}
-
-
-def is_mixed_list(value, *args):
-    """
-    Check that the value is a list.
-    Allow specifying the type of each member.
-    Work on lists of specific lengths.
-    
-    You specify each member as a positional argument specifying type
-    
-    Each type should be one of the following strings :
-      'integer', 'float', 'ip_addr', 'string', 'boolean'
-    
-    So you can specify a list of two strings, followed by
-    two integers as :
-    
-      mixed_list('string', 'string', 'integer', 'integer')
-    
-    The length of the list must match the number of positional
-    arguments you supply.
-    
-    >>> mix_str = "mixed_list('integer', 'float', 'ip_addr', 'string', 'boolean')"
-    >>> check_res = vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a', True))
-    >>> check_res == [1, 2.0, '1.2.3.4', 'a', True]
-    1
-    >>> check_res = vtor.check(mix_str, ('1', '2.0', '1.2.3.4', 'a', 'True'))
-    >>> check_res == [1, 2.0, '1.2.3.4', 'a', True]
-    1
-    >>> vtor.check(mix_str, ('b', 2.0, '1.2.3.4', 'a', True))
-    Traceback (most recent call last):
-    VdtTypeError: the value "b" is of the wrong type.
-    >>> vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a'))
-    Traceback (most recent call last):
-    VdtValueTooShortError: the value "(1, 2.0, '1.2.3.4', 'a')" is too short.
-    >>> vtor.check(mix_str, (1, 2.0, '1.2.3.4', 'a', 1, 'b'))
-    Traceback (most recent call last):
-    VdtValueTooLongError: the value "(1, 2.0, '1.2.3.4', 'a', 1, 'b')" is too long.
-    >>> vtor.check(mix_str, 0)
-    Traceback (most recent call last):
-    VdtTypeError: the value "0" is of the wrong type.
-    
-    This test requires an elaborate setup, because of a change in error string
-    output from the interpreter between Python 2.2 and 2.3 .
-    
-    >>> res_seq = (
-    ...     'passed an incorrect value "',
-    ...     'yoda',
-    ...     '" for parameter "mixed_list".',
-    ... )
-    >>> if INTP_VER == (2, 2):
-    ...     res_str = "".join(res_seq)
-    ... else:
-    ...     res_str = "'".join(res_seq)
-    >>> try:
-    ...     vtor.check('mixed_list("yoda")', ('a'))
-    ... except VdtParamError, err:
-    ...     str(err) == res_str
-    1
-    """
-    try:
-        length = len(value)
-    except TypeError:
-        raise VdtTypeError(value)
-    if length < len(args):
-        raise VdtValueTooShortError(value)
-    elif length > len(args):
-        raise VdtValueTooLongError(value)
-    try:
-        return [fun_dict[arg](val) for arg, val in zip(args, value)]
-    except KeyError, e:
-        raise VdtParamError('mixed_list', e)
-
-
-def is_option(value, *options):
-    """
-    This check matches the value to any of a set of options.
-    
-    >>> vtor.check('option("yoda", "jedi")', 'yoda')
-    'yoda'
-    >>> vtor.check('option("yoda", "jedi")', 'jed')
-    Traceback (most recent call last):
-    VdtValueError: the value "jed" is unacceptable.
-    >>> vtor.check('option("yoda", "jedi")', 0)
-    Traceback (most recent call last):
-    VdtTypeError: the value "0" is of the wrong type.
-    """
-    if not isinstance(value, StringTypes):
-        raise VdtTypeError(value)
-    if not value in options:
-        raise VdtValueError(value)
-    return value
-
-
-def _test(value, *args, **keywargs):
-    """
-    A function that exists for test purposes.
-    
-    >>> checks = [
-    ...     '3, 6, min=1, max=3, test=list(a, b, c)',
-    ...     '3',
-    ...     '3, 6',
-    ...     '3,',
-    ...     'min=1, test="a b c"',
-    ...     'min=5, test="a, b, c"',
-    ...     'min=1, max=3, test="a, b, c"',
-    ...     'min=-100, test=-99',
-    ...     'min=1, max=3',
-    ...     '3, 6, test="36"',
-    ...     '3, 6, test="a, b, c"',
-    ...     '3, max=3, test=list("a", "b", "c")',
-    ...     '''3, max=3, test=list("'a'", 'b', "x=(c)")''',
-    ...     "test='x=fish(3)'",
-    ...    ]
-    >>> v = Validator({'test': _test})
-    >>> for entry in checks:
-    ...     print v.check(('test(%s)' % entry), 3)
-    (3, ('3', '6'), {'test': ['a', 'b', 'c'], 'max': '3', 'min': '1'})
-    (3, ('3',), {})
-    (3, ('3', '6'), {})
-    (3, ('3',), {})
-    (3, (), {'test': 'a b c', 'min': '1'})
-    (3, (), {'test': 'a, b, c', 'min': '5'})
-    (3, (), {'test': 'a, b, c', 'max': '3', 'min': '1'})
-    (3, (), {'test': '-99', 'min': '-100'})
-    (3, (), {'max': '3', 'min': '1'})
-    (3, ('3', '6'), {'test': '36'})
-    (3, ('3', '6'), {'test': 'a, b, c'})
-    (3, ('3',), {'test': ['a', 'b', 'c'], 'max': '3'})
-    (3, ('3',), {'test': ["'a'", 'b', 'x=(c)'], 'max': '3'})
-    (3, (), {'test': 'x=fish(3)'})
-    
-    >>> v = Validator()
-    >>> v.check('integer(default=6)', '3')
-    3
-    >>> v.check('integer(default=6)', None, True)
-    6
-    >>> v.get_default_value('integer(default=6)')
-    6
-    >>> v.get_default_value('float(default=6)')
-    6.0
-    >>> v.get_default_value('pass(default=None)')
-    >>> v.get_default_value("string(default='None')")
-    'None'
-    >>> v.get_default_value('pass')
-    Traceback (most recent call last):
-    KeyError: 'Check "pass" has no default value.'
-    >>> v.get_default_value('pass(default=list(1, 2, 3, 4))')
-    ['1', '2', '3', '4']
-    
-    >>> v = Validator()
-    >>> v.check("pass(default=None)", None, True)
-    >>> v.check("pass(default='None')", None, True)
-    'None'
-    >>> v.check('pass(default="None")', None, True)
-    'None'
-    >>> v.check('pass(default=list(1, 2, 3, 4))', None, True)
-    ['1', '2', '3', '4']
-    
-    Bug test for unicode arguments
-    >>> v = Validator()
-    >>> v.check(u'string(min=4)', u'test')
-    u'test'
-    
-    >>> v = Validator()
-    >>> v.get_default_value(u'string(min=4, default="1234")')
-    u'1234'
-    >>> v.check(u'string(min=4, default="1234")', u'test')
-    u'test'
-    
-    >>> v = Validator()
-    >>> default = v.get_default_value('string(default=None)')
-    >>> default == None
-    1
-    """
-    return (value, args, keywargs)
-
-
-if __name__ == '__main__':
-    # run the code tests in doctest format
-    import doctest
-    m = sys.modules.get('__main__')
-    globs = m.__dict__.copy()
-    globs.update({
-        'INTP_VER': INTP_VER,
-        'vtor': Validator(),
-    })
-    doctest.testmod(m, globs=globs)
diff --git a/IPython/frontend/__init__.py b/IPython/frontend/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/frontend/qt/__init__.py b/IPython/frontend/qt/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/frontend/qt/base_frontend_mixin.py b/IPython/frontend/qt/base_frontend_mixin.py
deleted file mode 100644
index 2e54e086d68..00000000000
--- a/IPython/frontend/qt/base_frontend_mixin.py
+++ /dev/null
@@ -1,109 +0,0 @@
-""" Defines a convenient mix-in class for implementing Qt frontends.
-"""
-
-class BaseFrontendMixin(object):
-    """ A mix-in class for implementing Qt frontends.
-
-    To handle messages of a particular type, frontends need only define an
-    appropriate handler method. For example, to handle 'stream' messaged, define
-    a '_handle_stream(msg)' method.
-    """
-
-    #---------------------------------------------------------------------------
-    # 'BaseFrontendMixin' concrete interface
-    #---------------------------------------------------------------------------
-    
-    def _get_kernel_manager(self):
-        """ Returns the current kernel manager.
-        """
-        return self._kernel_manager
-
-    def _set_kernel_manager(self, kernel_manager):
-        """ Disconnect from the current kernel manager (if any) and set a new
-            kernel manager.
-        """
-        # Disconnect the old kernel manager, if necessary.
-        old_manager = self._kernel_manager
-        if old_manager is not None:
-            old_manager.started_channels.disconnect(self._started_channels)
-            old_manager.stopped_channels.disconnect(self._stopped_channels)
-
-            # Disconnect the old kernel manager's channels.
-            old_manager.sub_channel.message_received.disconnect(self._dispatch)
-            old_manager.xreq_channel.message_received.disconnect(self._dispatch)
-            old_manager.rep_channel.message_received.disconnect(self._dispatch)
-            old_manager.hb_channel.kernel_died.disconnect(
-                self._handle_kernel_died)
-    
-            # Handle the case where the old kernel manager is still listening.
-            if old_manager.channels_running:
-                self._stopped_channels()
-
-        # Set the new kernel manager.
-        self._kernel_manager = kernel_manager
-        if kernel_manager is None:
-            return
-
-        # Connect the new kernel manager.
-        kernel_manager.started_channels.connect(self._started_channels)
-        kernel_manager.stopped_channels.connect(self._stopped_channels)
-
-        # Connect the new kernel manager's channels.
-        kernel_manager.sub_channel.message_received.connect(self._dispatch)
-        kernel_manager.xreq_channel.message_received.connect(self._dispatch)
-        kernel_manager.rep_channel.message_received.connect(self._dispatch)
-        kernel_manager.hb_channel.kernel_died.connect(self._handle_kernel_died)
-
-        # Handle the case where the kernel manager started channels before
-        # we connected.
-        if kernel_manager.channels_running:
-            self._started_channels()
-
-    kernel_manager = property(_get_kernel_manager, _set_kernel_manager)
-
-    #---------------------------------------------------------------------------
-    # 'BaseFrontendMixin' abstract interface
-    #---------------------------------------------------------------------------
-
-    def _handle_kernel_died(self, since_last_heartbeat):
-        """ This is called when the ``kernel_died`` signal is emitted.
-
-        This method is called when the kernel heartbeat has not been
-        active for a certain amount of time. The typical action will be to
-        give the user the option of restarting the kernel.
-
-        Parameters
-        ----------
-        since_last_heartbeat : float
-            The time since the heartbeat was last received.
-        """
-    
-    def _started_channels(self):
-        """ Called when the KernelManager channels have started listening or 
-            when the frontend is assigned an already listening KernelManager.
-        """
-
-    def _stopped_channels(self):
-        """ Called when the KernelManager channels have stopped listening or
-            when a listening KernelManager is removed from the frontend.
-        """
-
-    #---------------------------------------------------------------------------
-    # 'BaseFrontendMixin' protected interface
-    #---------------------------------------------------------------------------
-
-    def _dispatch(self, msg):
-        """ Calls the frontend handler associated with the message type of the 
-            given message.
-        """
-        msg_type = msg['msg_type']
-        handler = getattr(self, '_handle_' + msg_type, None)
-        if handler:
-            handler(msg)
-
-    def _is_from_this_session(self, msg):
-        """ Returns whether a reply from the kernel originated from a request
-            from this frontend.
-        """
-        session = self._kernel_manager.session.session
-        return msg['parent_header']['session'] == session
diff --git a/IPython/frontend/qt/console/__init__.py b/IPython/frontend/qt/console/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/frontend/qt/console/ansi_code_processor.py b/IPython/frontend/qt/console/ansi_code_processor.py
deleted file mode 100644
index cb530132b20..00000000000
--- a/IPython/frontend/qt/console/ansi_code_processor.py
+++ /dev/null
@@ -1,334 +0,0 @@
-""" Utilities for processing ANSI escape codes and special ASCII characters.
-"""
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports
-from collections import namedtuple
-import re
-
-# System library imports
-from IPython.external.qt import QtCore, QtGui
-
-#-----------------------------------------------------------------------------
-# Constants and datatypes
-#-----------------------------------------------------------------------------
-
-# An action for erase requests (ED and EL commands).
-EraseAction = namedtuple('EraseAction', ['action', 'area', 'erase_to'])
-
-# An action for cursor move requests (CUU, CUD, CUF, CUB, CNL, CPL, CHA, CUP,
-# and HVP commands).
-# FIXME: Not implemented in AnsiCodeProcessor.
-MoveAction = namedtuple('MoveAction', ['action', 'dir', 'unit', 'count'])
-
-# An action for scroll requests (SU and ST) and form feeds.
-ScrollAction = namedtuple('ScrollAction', ['action', 'dir', 'unit', 'count'])
-
-# Regular expressions.
-CSI_COMMANDS = 'ABCDEFGHJKSTfmnsu'
-CSI_SUBPATTERN = '\[(.*?)([%s])' % CSI_COMMANDS
-OSC_SUBPATTERN = '\](.*?)[\x07\x1b]'
-ANSI_PATTERN = re.compile('\x01?\x1b(%s|%s)\x02?' % \
-                              (CSI_SUBPATTERN, OSC_SUBPATTERN))
-SPECIAL_PATTERN = re.compile('([\f])')
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-class AnsiCodeProcessor(object):
-    """ Translates special ASCII characters and ANSI escape codes into readable
-        attributes. It also supports a few non-standard, xterm-specific codes.
-    """
-
-    # Whether to increase intensity or set boldness for SGR code 1.
-    # (Different terminals handle this in different ways.)
-    bold_text_enabled = False
-
-    # We provide an empty default color map because subclasses will likely want
-    # to use a custom color format.
-    default_color_map = {}
-
-    #---------------------------------------------------------------------------
-    # AnsiCodeProcessor interface
-    #---------------------------------------------------------------------------
-
-    def __init__(self):
-        self.actions = []
-        self.color_map = self.default_color_map.copy()
-        self.reset_sgr()
-
-    def reset_sgr(self):
-        """ Reset graphics attributs to their default values.
-        """
-        self.intensity = 0
-        self.italic = False
-        self.bold = False
-        self.underline = False
-        self.foreground_color = None
-        self.background_color = None
-
-    def split_string(self, string):
-        """ Yields substrings for which the same escape code applies.
-        """
-        self.actions = []
-        start = 0
-
-        for match in ANSI_PATTERN.finditer(string):
-            raw = string[start:match.start()]
-            substring = SPECIAL_PATTERN.sub(self._replace_special, raw)
-            if substring or self.actions:
-                yield substring
-            start = match.end()
-
-            self.actions = []
-            groups = filter(lambda x: x is not None, match.groups())
-            params = [ param for param in groups[1].split(';') if param ]
-            if groups[0].startswith('['):
-                # Case 1: CSI code.
-                try:
-                    params = map(int, params)
-                except ValueError:
-                    # Silently discard badly formed codes.
-                    pass
-                else:
-                    self.set_csi_code(groups[2], params)
-
-            elif groups[0].startswith(']'):
-                # Case 2: OSC code.
-                self.set_osc_code(params)
-
-        raw = string[start:]
-        substring = SPECIAL_PATTERN.sub(self._replace_special, raw)
-        if substring or self.actions:
-            yield substring
-
-    def set_csi_code(self, command, params=[]):
-        """ Set attributes based on CSI (Control Sequence Introducer) code.
-
-        Parameters
-        ----------
-        command : str
-            The code identifier, i.e. the final character in the sequence.
-        
-        params : sequence of integers, optional
-            The parameter codes for the command.
-        """
-        if command == 'm':   # SGR - Select Graphic Rendition
-            if params:
-                self.set_sgr_code(params)
-            else:
-                self.set_sgr_code([0])
-
-        elif (command == 'J' or # ED - Erase Data
-              command == 'K'):  # EL - Erase in Line
-            code = params[0] if params else 0
-            if 0 <= code <= 2:
-                area = 'screen' if command == 'J' else 'line'
-                if code == 0:
-                    erase_to = 'end'
-                elif code == 1:
-                    erase_to = 'start'
-                elif code == 2:
-                    erase_to = 'all'
-                self.actions.append(EraseAction('erase', area, erase_to))
-
-        elif (command == 'S' or # SU - Scroll Up
-              command == 'T'):  # SD - Scroll Down
-            dir = 'up' if command == 'S' else 'down'
-            count = params[0] if params else 1
-            self.actions.append(ScrollAction('scroll', dir, 'line', count))
-
-    def set_osc_code(self, params):
-        """ Set attributes based on OSC (Operating System Command) parameters.
-        
-        Parameters
-        ----------
-        params : sequence of str
-            The parameters for the command.
-        """
-        try:
-            command = int(params.pop(0))
-        except (IndexError, ValueError):
-            return
-
-        if command == 4:
-            # xterm-specific: set color number to color spec.
-            try:
-                color = int(params.pop(0))
-                spec = params.pop(0)
-                self.color_map[color] = self._parse_xterm_color_spec(spec)
-            except (IndexError, ValueError):
-                pass
-        
-    def set_sgr_code(self, params):
-        """ Set attributes based on SGR (Select Graphic Rendition) codes.
-
-        Parameters
-        ----------
-        params : sequence of ints
-            A list of SGR codes for one or more SGR commands. Usually this
-            sequence will have one element per command, although certain
-            xterm-specific commands requires multiple elements.
-        """
-        # Always consume the first parameter.
-        if not params:
-            return
-        code = params.pop(0)
-
-        if code == 0:
-            self.reset_sgr()
-        elif code == 1:
-            if self.bold_text_enabled:
-                self.bold = True
-            else:
-                self.intensity = 1
-        elif code == 2:
-            self.intensity = 0
-        elif code == 3:
-            self.italic = True
-        elif code == 4:
-            self.underline = True
-        elif code == 22:
-            self.intensity = 0
-            self.bold = False
-        elif code == 23:
-            self.italic = False
-        elif code == 24:
-            self.underline = False
-        elif code >= 30 and code <= 37:
-            self.foreground_color = code - 30
-        elif code == 38 and params and params.pop(0) == 5: 
-            # xterm-specific: 256 color support.
-            if params:
-                self.foreground_color = params.pop(0)
-        elif code == 39:
-            self.foreground_color = None
-        elif code >= 40 and code <= 47:
-            self.background_color = code - 40
-        elif code == 48 and params and params.pop(0) == 5:
-            # xterm-specific: 256 color support.
-            if params:
-                self.background_color = params.pop(0)
-        elif code == 49:
-            self.background_color = None
-
-        # Recurse with unconsumed parameters.
-        self.set_sgr_code(params)
-
-    #---------------------------------------------------------------------------
-    # Protected interface
-    #---------------------------------------------------------------------------
-
-    def _parse_xterm_color_spec(self, spec):
-        if spec.startswith('rgb:'):
-            return tuple(map(lambda x: int(x, 16), spec[4:].split('/')))
-        elif spec.startswith('rgbi:'):
-            return tuple(map(lambda x: int(float(x) * 255), 
-                             spec[5:].split('/')))
-        elif spec == '?':
-            raise ValueError('Unsupported xterm color spec')
-        return spec
-
-    def _replace_special(self, match):
-        special = match.group(1)
-        if special == '\f':
-            self.actions.append(ScrollAction('scroll', 'down', 'page', 1))
-        return ''
-        
-
-class QtAnsiCodeProcessor(AnsiCodeProcessor):
-    """ Translates ANSI escape codes into QTextCharFormats.
-    """
-
-    # A map from ANSI color codes to SVG color names or RGB(A) tuples.
-    darkbg_color_map = {
-        0  : 'black',       # black
-        1  : 'darkred',     # red
-        2  : 'darkgreen',   # green
-        3  : 'brown',       # yellow
-        4  : 'darkblue',    # blue
-        5  : 'darkviolet',  # magenta
-        6  : 'steelblue',   # cyan
-        7  : 'grey',        # white
-        8  : 'grey',        # black (bright)
-        9  : 'red',         # red (bright)
-        10 : 'lime',        # green (bright)
-        11 : 'yellow',      # yellow (bright)
-        12 : 'deepskyblue', # blue (bright)
-        13 : 'magenta',     # magenta (bright)
-        14 : 'cyan',        # cyan (bright)
-        15 : 'white' }      # white (bright)
-
-    # Set the default color map for super class.
-    default_color_map = darkbg_color_map.copy()
-
-    def get_color(self, color, intensity=0):
-        """ Returns a QColor for a given color code, or None if one cannot be
-            constructed.
-        """
-        if color is None:
-            return None
-
-        # Adjust for intensity, if possible.
-        if color < 8 and intensity > 0:
-            color += 8
-
-        constructor = self.color_map.get(color, None)
-        if isinstance(constructor, basestring):
-            # If this is an X11 color name, we just hope there is a close SVG
-            # color name. We could use QColor's static method
-            # 'setAllowX11ColorNames()', but this is global and only available
-            # on X11. It seems cleaner to aim for uniformity of behavior.
-            return QtGui.QColor(constructor)
-
-        elif isinstance(constructor, (tuple, list)):
-            return QtGui.QColor(*constructor)
-
-        return None
-    
-    def get_format(self):
-        """ Returns a QTextCharFormat that encodes the current style attributes.
-        """
-        format = QtGui.QTextCharFormat()
-
-        # Set foreground color
-        qcolor = self.get_color(self.foreground_color, self.intensity)
-        if qcolor is not None:
-            format.setForeground(qcolor)
-
-        # Set background color
-        qcolor = self.get_color(self.background_color, self.intensity)
-        if qcolor is not None:
-            format.setBackground(qcolor)
-
-        # Set font weight/style options
-        if self.bold:
-            format.setFontWeight(QtGui.QFont.Bold)
-        else:
-            format.setFontWeight(QtGui.QFont.Normal)
-        format.setFontItalic(self.italic)
-        format.setFontUnderline(self.underline)
-
-        return format
-
-    def set_background_color(self, color):
-        """ Given a background color (a QColor), attempt to set a color map
-            that will be aesthetically pleasing.
-        """
-        # Set a new default color map.
-        self.default_color_map = self.darkbg_color_map.copy()
-
-        if color.value() >= 127:
-            # Colors appropriate for a terminal with a light background. For 
-            # now, only use non-bright colors...
-            for i in xrange(8):
-                self.default_color_map[i + 8] = self.default_color_map[i]
-
-            # ...and replace white with black.
-            self.default_color_map[7] = self.default_color_map[15] = 'black'
-
-        # Update the current color map with the new defaults.
-        self.color_map.update(self.default_color_map)
diff --git a/IPython/frontend/qt/console/bracket_matcher.py b/IPython/frontend/qt/console/bracket_matcher.py
deleted file mode 100644
index da822c3d42d..00000000000
--- a/IPython/frontend/qt/console/bracket_matcher.py
+++ /dev/null
@@ -1,100 +0,0 @@
-""" Provides bracket matching for Q[Plain]TextEdit widgets.
-"""
-
-# System library imports
-from IPython.external.qt import QtCore, QtGui
-
-
-class BracketMatcher(QtCore.QObject):
-    """ Matches square brackets, braces, and parentheses based on cursor
-        position.
-    """
-    
-    # Protected class variables.
-    _opening_map = { '(':')', '{':'}', '[':']' }
-    _closing_map = { ')':'(', '}':'{', ']':'[' }
-
-    #--------------------------------------------------------------------------
-    # 'QObject' interface
-    #--------------------------------------------------------------------------
-
-    def __init__(self, text_edit):
-        """ Create a call tip manager that is attached to the specified Qt
-            text edit widget.
-        """
-        assert isinstance(text_edit, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
-        super(BracketMatcher, self).__init__()
-
-        # The format to apply to matching brackets.
-        self.format = QtGui.QTextCharFormat()
-        self.format.setBackground(QtGui.QColor('silver'))
-
-        self._text_edit = text_edit
-        text_edit.cursorPositionChanged.connect(self._cursor_position_changed)
-
-    #--------------------------------------------------------------------------
-    # Protected interface
-    #--------------------------------------------------------------------------
-
-    def _find_match(self, position):
-        """ Given a valid position in the text document, try to find the
-            position of the matching bracket. Returns -1 if unsuccessful.
-        """
-        # Decide what character to search for and what direction to search in.
-        document = self._text_edit.document()
-        start_char = document.characterAt(position)
-        search_char = self._opening_map.get(start_char)
-        if search_char:
-            increment = 1
-        else:
-            search_char = self._closing_map.get(start_char)
-            if search_char:
-                increment = -1
-            else:
-                return -1
-
-        # Search for the character.
-        char = start_char
-        depth = 0
-        while position >= 0 and position < document.characterCount():
-            if char == start_char:
-                depth += 1
-            elif char == search_char:
-                depth -= 1
-            if depth == 0:
-                break
-            position += increment
-            char = document.characterAt(position)
-        else:
-            position = -1
-        return position
-
-    def _selection_for_character(self, position):
-        """ Convenience method for selecting a character.
-        """
-        selection = QtGui.QTextEdit.ExtraSelection()
-        cursor = self._text_edit.textCursor()
-        cursor.setPosition(position)
-        cursor.movePosition(QtGui.QTextCursor.NextCharacter, 
-                            QtGui.QTextCursor.KeepAnchor)
-        selection.cursor = cursor
-        selection.format = self.format
-        return selection
-
-    #------ Signal handlers ----------------------------------------------------
-
-    def _cursor_position_changed(self):
-        """ Updates the document formatting based on the new cursor position.
-        """
-        # Clear out the old formatting.
-        self._text_edit.setExtraSelections([])
-
-        # Attempt to match a bracket for the new cursor position.
-        cursor = self._text_edit.textCursor()
-        if not cursor.hasSelection():
-            position = cursor.position() - 1
-            match_position = self._find_match(position)
-            if match_position != -1:
-                extra_selections = [ self._selection_for_character(pos)
-                                     for pos in (position, match_position) ]
-                self._text_edit.setExtraSelections(extra_selections)
diff --git a/IPython/frontend/qt/console/call_tip_widget.py b/IPython/frontend/qt/console/call_tip_widget.py
deleted file mode 100644
index 48f3654c604..00000000000
--- a/IPython/frontend/qt/console/call_tip_widget.py
+++ /dev/null
@@ -1,230 +0,0 @@
-# Standard library imports
-import re
-from textwrap import dedent
-from unicodedata import category
-
-# System library imports
-from IPython.external.qt import QtCore, QtGui
-
-
-class CallTipWidget(QtGui.QLabel):
-    """ Shows call tips by parsing the current text of Q[Plain]TextEdit.
-    """
-
-    #--------------------------------------------------------------------------
-    # 'QObject' interface
-    #--------------------------------------------------------------------------
-
-    def __init__(self, text_edit):
-        """ Create a call tip manager that is attached to the specified Qt
-            text edit widget.
-        """
-        assert isinstance(text_edit, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
-        super(CallTipWidget, self).__init__(None, QtCore.Qt.ToolTip)
-
-        self._hide_timer = QtCore.QBasicTimer()
-        self._text_edit = text_edit
-
-        self.setFont(text_edit.document().defaultFont())
-        self.setForegroundRole(QtGui.QPalette.ToolTipText)
-        self.setBackgroundRole(QtGui.QPalette.ToolTipBase)
-        self.setPalette(QtGui.QToolTip.palette())
-
-        self.setAlignment(QtCore.Qt.AlignLeft)
-        self.setIndent(1)
-        self.setFrameStyle(QtGui.QFrame.NoFrame)
-        self.setMargin(1 + self.style().pixelMetric(
-                QtGui.QStyle.PM_ToolTipLabelFrameWidth, None, self))
-        self.setWindowOpacity(self.style().styleHint(
-                QtGui.QStyle.SH_ToolTipLabel_Opacity, None, self, None) / 255.0)
-
-    def eventFilter(self, obj, event):
-        """ Reimplemented to hide on certain key presses and on text edit focus
-            changes.
-        """
-        if obj == self._text_edit:
-            etype = event.type()
-
-            if etype == QtCore.QEvent.KeyPress:
-                key = event.key()
-                if key in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return):
-                    self.hide()
-                elif key == QtCore.Qt.Key_Escape:
-                    self.hide()
-                    return True
-
-            elif etype == QtCore.QEvent.FocusOut:
-                self.hide()
-
-            elif etype == QtCore.QEvent.Enter:
-                self._hide_timer.stop()
-
-            elif etype == QtCore.QEvent.Leave:
-                self._leave_event_hide()
-
-        return super(CallTipWidget, self).eventFilter(obj, event)
-
-    def timerEvent(self, event):
-        """ Reimplemented to hide the widget when the hide timer fires.
-        """
-        if event.timerId() == self._hide_timer.timerId():
-            self._hide_timer.stop()
-            self.hide()
-
-    #--------------------------------------------------------------------------
-    # 'QWidget' interface
-    #--------------------------------------------------------------------------
-
-    def enterEvent(self, event):
-        """ Reimplemented to cancel the hide timer.
-        """
-        super(CallTipWidget, self).enterEvent(event)
-        self._hide_timer.stop()
-
-    def hideEvent(self, event):
-        """ Reimplemented to disconnect signal handlers and event filter.
-        """
-        super(CallTipWidget, self).hideEvent(event)
-        self._text_edit.cursorPositionChanged.disconnect(
-            self._cursor_position_changed)
-        self._text_edit.removeEventFilter(self)
-
-    def leaveEvent(self, event):
-        """ Reimplemented to start the hide timer.
-        """
-        super(CallTipWidget, self).leaveEvent(event)
-        self._leave_event_hide()
-
-    def paintEvent(self, event):
-        """ Reimplemented to paint the background panel.
-        """
-        painter = QtGui.QStylePainter(self)
-        option = QtGui.QStyleOptionFrame()
-        option.initFrom(self)
-        painter.drawPrimitive(QtGui.QStyle.PE_PanelTipLabel, option)
-        painter.end()
-
-        super(CallTipWidget, self).paintEvent(event)
-
-    def setFont(self, font):
-        """ Reimplemented to allow use of this method as a slot.
-        """
-        super(CallTipWidget, self).setFont(font)
-
-    def showEvent(self, event):
-        """ Reimplemented to connect signal handlers and event filter.
-        """
-        super(CallTipWidget, self).showEvent(event)
-        self._text_edit.cursorPositionChanged.connect(
-            self._cursor_position_changed)
-        self._text_edit.installEventFilter(self)
-
-    #--------------------------------------------------------------------------
-    # 'CallTipWidget' interface
-    #--------------------------------------------------------------------------
-
-    def show_call_info(self, call_line=None, doc=None, maxlines=20):
-        """ Attempts to show the specified call line and docstring at the
-            current cursor location. The docstring is possibly truncated for
-            length.
-        """
-        if doc:
-            match = re.match("(?:[^\n]*\n){%i}" % maxlines, doc)
-            if match:
-                doc = doc[:match.end()] + '\n[Documentation continues...]'
-        else:
-            doc = ''
-            
-        if call_line:
-            doc = '\n\n'.join([call_line, doc])
-        return self.show_tip(doc)
-
-    def show_tip(self, tip):
-        """ Attempts to show the specified tip at the current cursor location.
-        """
-        # Attempt to find the cursor position at which to show the call tip.
-        text_edit = self._text_edit
-        document = text_edit.document()
-        cursor = text_edit.textCursor()
-        search_pos = cursor.position() - 1
-        self._start_position, _ = self._find_parenthesis(search_pos, 
-                                                         forward=False)
-        if self._start_position == -1:
-            return False
-
-        # Set the text and resize the widget accordingly.
-        self.setText(tip)
-        self.resize(self.sizeHint())
-    
-        # Locate and show the widget. Place the tip below the current line
-        # unless it would be off the screen. In that case, place it above
-        # the current line.
-        padding = 3 # Distance in pixels between cursor bounds and tip box.
-        cursor_rect = text_edit.cursorRect(cursor)
-        screen_rect = QtGui.qApp.desktop().screenGeometry(text_edit)
-        point = text_edit.mapToGlobal(cursor_rect.bottomRight())
-        point.setY(point.y() + padding)
-        tip_height = self.size().height()
-        if point.y() + tip_height > screen_rect.height():
-            point = text_edit.mapToGlobal(cursor_rect.topRight())
-            point.setY(point.y() - tip_height - padding)
-        self.move(point)
-        self.show()
-        return True
-            
-    #--------------------------------------------------------------------------
-    # Protected interface
-    #--------------------------------------------------------------------------
-
-    def _find_parenthesis(self, position, forward=True):
-        """ If 'forward' is True (resp. False), proceed forwards
-            (resp. backwards) through the line that contains 'position' until an
-            unmatched closing (resp. opening) parenthesis is found. Returns a
-            tuple containing the position of this parenthesis (or -1 if it is
-            not found) and the number commas (at depth 0) found along the way.
-        """
-        commas = depth = 0
-        document = self._text_edit.document()
-        char = document.characterAt(position)
-        # Search until a match is found or a non-printable character is
-        # encountered.
-        while category(char) != 'Cc' and position > 0:
-            if char == ',' and depth == 0:
-                commas += 1
-            elif char == ')':
-                if forward and depth == 0:
-                    break
-                depth += 1
-            elif char == '(':
-                if not forward and depth == 0:
-                    break
-                depth -= 1
-            position += 1 if forward else -1
-            char = document.characterAt(position)
-        else:
-            position = -1
-        return position, commas
-
-    def _leave_event_hide(self):
-        """ Hides the tooltip after some time has passed (assuming the cursor is
-            not over the tooltip).
-        """
-        if (not self._hide_timer.isActive() and
-            # If Enter events always came after Leave events, we wouldn't need
-            # this check. But on Mac OS, it sometimes happens the other way
-            # around when the tooltip is created.
-            QtGui.qApp.topLevelAt(QtGui.QCursor.pos()) != self):
-            self._hide_timer.start(300, self)
-
-    #------ Signal handlers ----------------------------------------------------
-
-    def _cursor_position_changed(self):
-        """ Updates the tip based on user cursor movement.
-        """
-        cursor = self._text_edit.textCursor()
-        if cursor.position() <= self._start_position:
-            self.hide()
-        else:
-            position, commas = self._find_parenthesis(self._start_position + 1)
-            if position != -1:
-                self.hide()
diff --git a/IPython/frontend/qt/console/completion_lexer.py b/IPython/frontend/qt/console/completion_lexer.py
deleted file mode 100644
index abadf0cb6a7..00000000000
--- a/IPython/frontend/qt/console/completion_lexer.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# System library imports
-from pygments.token import Token, is_token_subtype
-
-
-class CompletionLexer(object):
-    """ Uses Pygments and some auxillary information to lex code snippets for 
-        symbol contexts.
-    """
-
-    # Maps Lexer names to a list of possible name separators
-    separator_map = { 'C' : [ '.', '->' ],
-                      'C++' : [ '.', '->', '::' ],
-                      'Python' : [ '.' ] }
-
-    def __init__(self, lexer):
-        """ Create a CompletionLexer using the specified Pygments lexer.
-        """
-        self.lexer = lexer
-
-    def get_context(self, string):
-        """ Assuming the cursor is at the end of the specified string, get the
-            context (a list of names) for the symbol at cursor position.
-        """
-        context = []
-        reversed_tokens = list(self._lexer.get_tokens(string))
-        reversed_tokens.reverse()
-
-        # Pygments often tacks on a newline when none is specified in the input.
-        # Remove this newline.
-        if reversed_tokens and reversed_tokens[0][1].endswith('\n') and \
-                not string.endswith('\n'):
-            reversed_tokens.pop(0)
-        
-        current_op = ''
-        for token, text in reversed_tokens:
-
-            if is_token_subtype(token, Token.Name):
-
-                # Handle a trailing separator, e.g 'foo.bar.'
-                if current_op in self._name_separators:
-                    if not context:
-                        context.insert(0, '')
-
-                # Handle non-separator operators and punction.
-                elif current_op:
-                    break
-
-                context.insert(0, text)
-                current_op = ''
-
-            # Pygments doesn't understand that, e.g., '->' is a single operator
-            # in C++. This is why we have to build up an operator from
-            # potentially several tokens.
-            elif token is Token.Operator or token is Token.Punctuation:
-                current_op = text + current_op
-
-            # Break on anything that is not a Operator, Punctuation, or Name.
-            else:
-                break
-
-        return context
-
-    def get_lexer(self, lexer):
-        return self._lexer
-
-    def set_lexer(self, lexer, name_separators=None):
-        self._lexer = lexer
-        if name_separators is None:
-            self._name_separators = self.separator_map.get(lexer.name, ['.'])
-        else:
-            self._name_separators = list(name_separators)
-
-    lexer = property(get_lexer, set_lexer)
-    
diff --git a/IPython/frontend/qt/console/completion_widget.py b/IPython/frontend/qt/console/completion_widget.py
deleted file mode 100644
index b6db0a704a7..00000000000
--- a/IPython/frontend/qt/console/completion_widget.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# System library imports
-from IPython.external.qt import QtCore, QtGui
-
-
-class CompletionWidget(QtGui.QListWidget):
-    """ A widget for GUI tab completion.
-    """
-
-    #--------------------------------------------------------------------------
-    # 'QObject' interface
-    #--------------------------------------------------------------------------
-
-    def __init__(self, text_edit):
-        """ Create a completion widget that is attached to the specified Qt
-            text edit widget.
-        """
-        assert isinstance(text_edit, (QtGui.QTextEdit, QtGui.QPlainTextEdit))
-        super(CompletionWidget, self).__init__()
-
-        self._text_edit = text_edit
-
-        self.setAttribute(QtCore.Qt.WA_StaticContents)
-        self.setWindowFlags(QtCore.Qt.ToolTip | QtCore.Qt.WindowStaysOnTopHint)
-
-        # Ensure that the text edit keeps focus when widget is displayed.
-        self.setFocusProxy(self._text_edit)
-
-        self.setFrameShadow(QtGui.QFrame.Plain)
-        self.setFrameShape(QtGui.QFrame.StyledPanel)
-
-        self.itemActivated.connect(self._complete_current)
-
-    def eventFilter(self, obj, event):
-        """ Reimplemented to handle keyboard input and to auto-hide when the
-            text edit loses focus.
-        """
-        if obj == self._text_edit:
-            etype = event.type()
-
-            if etype == QtCore.QEvent.KeyPress:
-                key, text = event.key(), event.text()
-                if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter, 
-                           QtCore.Qt.Key_Tab):
-                    self._complete_current()
-                    return True
-                elif key == QtCore.Qt.Key_Escape:
-                    self.hide()
-                    return True
-                elif key in (QtCore.Qt.Key_Up, QtCore.Qt.Key_Down, 
-                             QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown, 
-                             QtCore.Qt.Key_Home, QtCore.Qt.Key_End):
-                    self.keyPressEvent(event)
-                    return True
-
-            elif etype == QtCore.QEvent.FocusOut:
-                self.hide()
-
-        return super(CompletionWidget, self).eventFilter(obj, event)
-
-    #--------------------------------------------------------------------------
-    # 'QWidget' interface
-    #--------------------------------------------------------------------------
-
-    def hideEvent(self, event):
-        """ Reimplemented to disconnect signal handlers and event filter.
-        """
-        super(CompletionWidget, self).hideEvent(event)
-        self._text_edit.cursorPositionChanged.disconnect(self._update_current)
-        self._text_edit.removeEventFilter(self)
-
-    def showEvent(self, event):
-        """ Reimplemented to connect signal handlers and event filter.
-        """
-        super(CompletionWidget, self).showEvent(event)
-        self._text_edit.cursorPositionChanged.connect(self._update_current)
-        self._text_edit.installEventFilter(self)
-
-    #--------------------------------------------------------------------------
-    # 'CompletionWidget' interface
-    #--------------------------------------------------------------------------
-
-    def show_items(self, cursor, items):
-        """ Shows the completion widget with 'items' at the position specified
-            by 'cursor'.
-        """
-        text_edit = self._text_edit
-        point = text_edit.cursorRect(cursor).bottomRight()
-        point = text_edit.mapToGlobal(point)
-        screen_rect = QtGui.QApplication.desktop().availableGeometry(self)
-        if screen_rect.size().height() - point.y() - self.height() < 0:
-            point = text_edit.mapToGlobal(text_edit.cursorRect().topRight())
-            point.setY(point.y() - self.height())
-        self.move(point)
-
-        self._start_position = cursor.position()
-        self.clear()
-        self.addItems(items)
-        self.setCurrentRow(0)
-        self.show()
-
-    #--------------------------------------------------------------------------
-    # Protected interface
-    #--------------------------------------------------------------------------
-
-    def _complete_current(self):
-        """ Perform the completion with the currently selected item.
-        """
-        self._current_text_cursor().insertText(self.currentItem().text())
-        self.hide()
-
-    def _current_text_cursor(self):
-        """ Returns a cursor with text between the start position and the
-            current position selected.
-        """
-        cursor = self._text_edit.textCursor()
-        if cursor.position() >= self._start_position:
-            cursor.setPosition(self._start_position, 
-                               QtGui.QTextCursor.KeepAnchor)
-        return cursor
-        
-    def _update_current(self):
-        """ Updates the current item based on the current text.
-        """
-        prefix = self._current_text_cursor().selection().toPlainText()
-        if prefix:
-            items = self.findItems(prefix, (QtCore.Qt.MatchStartsWith | 
-                                            QtCore.Qt.MatchCaseSensitive))
-            if items:
-                self.setCurrentItem(items[0])
-            else:
-                self.hide()
-        else:
-            self.hide()
diff --git a/IPython/frontend/qt/console/console_widget.py b/IPython/frontend/qt/console/console_widget.py
deleted file mode 100644
index 8674e9a931c..00000000000
--- a/IPython/frontend/qt/console/console_widget.py
+++ /dev/null
@@ -1,1738 +0,0 @@
-""" An abstract base class for console-type widgets.
-"""
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports
-import os
-from os.path import commonprefix
-import re
-import sys
-from textwrap import dedent
-from unicodedata import category
-
-# System library imports
-from IPython.external.qt import QtCore, QtGui
-
-# Local imports
-from IPython.config.configurable import Configurable
-from IPython.frontend.qt.rich_text import HtmlExporter
-from IPython.frontend.qt.util import MetaQObjectHasTraits, get_font
-from IPython.utils.traitlets import Bool, Enum, Int
-from ansi_code_processor import QtAnsiCodeProcessor
-from completion_widget import CompletionWidget
-
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-def is_letter_or_number(char):
-    """ Returns whether the specified unicode character is a letter or a number.
-    """
-    cat = category(char)
-    return cat.startswith('L') or cat.startswith('N')
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-class ConsoleWidget(Configurable, QtGui.QWidget):
-    """ An abstract base class for console-type widgets. This class has 
-        functionality for:
-
-            * Maintaining a prompt and editing region
-            * Providing the traditional Unix-style console keyboard shortcuts 
-            * Performing tab completion
-            * Paging text
-            * Handling ANSI escape codes
-
-        ConsoleWidget also provides a number of utility methods that will be
-        convenient to implementors of a console-style widget.
-    """
-    __metaclass__ = MetaQObjectHasTraits
-
-    #------ Configuration ------------------------------------------------------
-
-    # Whether to process ANSI escape codes.
-    ansi_codes = Bool(True, config=True)
-
-    # The maximum number of lines of text before truncation. Specifying a
-    # non-positive number disables text truncation (not recommended).
-    buffer_size = Int(500, config=True)
-
-    # Whether to use a list widget or plain text output for tab completion.
-    gui_completion = Bool(False, config=True)
-
-    # The type of underlying text widget to use. Valid values are 'plain', which
-    # specifies a QPlainTextEdit, and 'rich', which specifies a QTextEdit.
-    # NOTE: this value can only be specified during initialization.
-    kind = Enum(['plain', 'rich'], default_value='plain', config=True)
-
-    # The type of paging to use. Valid values are:
-    #     'inside' : The widget pages like a traditional terminal.
-    #     'hsplit' : When paging is requested, the widget is split
-    #                horizontally. The top pane contains the console, and the
-    #                bottom pane contains the paged text.
-    #     'vsplit' : Similar to 'hsplit', except that a vertical splitter used.
-    #     'custom' : No action is taken by the widget beyond emitting a
-    #                'custom_page_requested(str)' signal.
-    #     'none'   : The text is written directly to the console.
-    # NOTE: this value can only be specified during initialization.
-    paging = Enum(['inside', 'hsplit', 'vsplit', 'custom', 'none'], 
-                  default_value='inside', config=True)
-
-    # Whether to override ShortcutEvents for the keybindings defined by this
-    # widget (Ctrl+n, Ctrl+a, etc). Enable this if you want this widget to take
-    # priority (when it has focus) over, e.g., window-level menu shortcuts.
-    override_shortcuts = Bool(False)
-
-    #------ Signals ------------------------------------------------------------
-
-    # Signals that indicate ConsoleWidget state.
-    copy_available = QtCore.Signal(bool)
-    redo_available = QtCore.Signal(bool)
-    undo_available = QtCore.Signal(bool)
-
-    # Signal emitted when paging is needed and the paging style has been
-    # specified as 'custom'.
-    custom_page_requested = QtCore.Signal(object)
-
-    # Signal emitted when the font is changed.
-    font_changed = QtCore.Signal(QtGui.QFont)
-
-    #------ Protected class variables ------------------------------------------
-
-    # When the control key is down, these keys are mapped.
-    _ctrl_down_remap = { QtCore.Qt.Key_B : QtCore.Qt.Key_Left,
-                         QtCore.Qt.Key_F : QtCore.Qt.Key_Right,
-                         QtCore.Qt.Key_A : QtCore.Qt.Key_Home,
-                         QtCore.Qt.Key_P : QtCore.Qt.Key_Up,
-                         QtCore.Qt.Key_N : QtCore.Qt.Key_Down,
-                         QtCore.Qt.Key_H : QtCore.Qt.Key_Backspace,
-                         QtCore.Qt.Key_D : QtCore.Qt.Key_Delete, }
-    if not sys.platform == 'darwin':
-        # On OS X, Ctrl-E already does the right thing, whereas End moves the
-        # cursor to the bottom of the buffer.
-        _ctrl_down_remap[QtCore.Qt.Key_E] = QtCore.Qt.Key_End
-
-    # The shortcuts defined by this widget. We need to keep track of these to
-    # support 'override_shortcuts' above.
-    _shortcuts = set(_ctrl_down_remap.keys() +
-                     [ QtCore.Qt.Key_C, QtCore.Qt.Key_G, QtCore.Qt.Key_O,
-                       QtCore.Qt.Key_V ])
-
-    #---------------------------------------------------------------------------
-    # 'QObject' interface
-    #---------------------------------------------------------------------------
-
-    def __init__(self, parent=None, **kw):
-        """ Create a ConsoleWidget.
-
-        Parameters:
-        -----------
-        parent : QWidget, optional [default None]
-            The parent for this widget.
-        """
-        QtGui.QWidget.__init__(self, parent)
-        Configurable.__init__(self, **kw)
-
-        # Create the layout and underlying text widget.
-        layout = QtGui.QStackedLayout(self)
-        layout.setContentsMargins(0, 0, 0, 0)
-        self._control = self._create_control()
-        self._page_control = None
-        self._splitter = None
-        if self.paging in ('hsplit', 'vsplit'):
-            self._splitter = QtGui.QSplitter()
-            if self.paging == 'hsplit':
-                self._splitter.setOrientation(QtCore.Qt.Horizontal)
-            else:
-                self._splitter.setOrientation(QtCore.Qt.Vertical)
-            self._splitter.addWidget(self._control)
-            layout.addWidget(self._splitter)
-        else:
-            layout.addWidget(self._control)
-
-        # Create the paging widget, if necessary.
-        if self.paging in ('inside', 'hsplit', 'vsplit'):
-            self._page_control = self._create_page_control()
-            if self._splitter:
-                self._page_control.hide()
-                self._splitter.addWidget(self._page_control)
-            else:
-                layout.addWidget(self._page_control)
-
-        # Initialize protected variables. Some variables contain useful state
-        # information for subclasses; they should be considered read-only.
-        self._ansi_processor = QtAnsiCodeProcessor()
-        self._completion_widget = CompletionWidget(self._control)
-        self._continuation_prompt = '> '
-        self._continuation_prompt_html = None
-        self._executing = False
-        self._filter_drag = False
-        self._filter_resize = False
-        self._html_exporter = HtmlExporter(self._control)
-        self._prompt = ''
-        self._prompt_html = None
-        self._prompt_pos = 0
-        self._prompt_sep = ''
-        self._reading = False
-        self._reading_callback = None
-        self._tab_width = 8
-        self._text_completing_pos = 0
-
-        # Set a monospaced font.
-        self.reset_font()
-
-        # Configure actions.
-        action = QtGui.QAction('Print', None)
-        action.setEnabled(True)
-        printkey = QtGui.QKeySequence(QtGui.QKeySequence.Print)
-        if printkey.matches("Ctrl+P") and sys.platform != 'darwin':
-            # Only override the default if there is a collision.
-            # Qt ctrl = cmd on OSX, so the match gets a false positive on OSX.
-            printkey = "Ctrl+Shift+P"
-        action.setShortcut(printkey)
-        action.triggered.connect(self.print_)
-        self.addAction(action)
-        self._print_action = action
-
-        action = QtGui.QAction('Save as HTML/XML', None)
-        action.setShortcut(QtGui.QKeySequence.Save)
-        action.triggered.connect(self.export_html)
-        self.addAction(action)
-        self._export_action = action
-        
-        action = QtGui.QAction('Select All', None)
-        action.setEnabled(True)
-        action.setShortcut(QtGui.QKeySequence.SelectAll)
-        action.triggered.connect(self.select_all)
-        self.addAction(action)
-        self._select_all_action = action
-
-    def eventFilter(self, obj, event):
-        """ Reimplemented to ensure a console-like behavior in the underlying
-            text widgets.
-        """
-        etype = event.type()
-        if etype == QtCore.QEvent.KeyPress:
-
-            # Re-map keys for all filtered widgets.
-            key = event.key()
-            if self._control_key_down(event.modifiers()) and \
-                    key in self._ctrl_down_remap:
-                new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, 
-                                            self._ctrl_down_remap[key],
-                                            QtCore.Qt.NoModifier)
-                QtGui.qApp.sendEvent(obj, new_event)
-                return True
-
-            elif obj == self._control:
-                return self._event_filter_console_keypress(event)
-
-            elif obj == self._page_control:
-                return self._event_filter_page_keypress(event)
-
-        # Make middle-click paste safe.
-        elif etype == QtCore.QEvent.MouseButtonRelease and \
-                event.button() == QtCore.Qt.MidButton and \
-                obj == self._control.viewport():
-            cursor = self._control.cursorForPosition(event.pos())
-            self._control.setTextCursor(cursor)
-            self.paste(QtGui.QClipboard.Selection)
-            return True
-
-        # Manually adjust the scrollbars *after* a resize event is dispatched.
-        elif etype == QtCore.QEvent.Resize and not self._filter_resize:
-            self._filter_resize = True
-            QtGui.qApp.sendEvent(obj, event)
-            self._adjust_scrollbars()
-            self._filter_resize = False
-            return True
-
-        # Override shortcuts for all filtered widgets.
-        elif etype == QtCore.QEvent.ShortcutOverride and \
-                self.override_shortcuts and \
-                self._control_key_down(event.modifiers()) and \
-                event.key() in self._shortcuts:
-            event.accept()
-
-        # Ensure that drags are safe. The problem is that the drag starting
-        # logic, which determines whether the drag is a Copy or Move, is locked
-        # down in QTextControl. If the widget is editable, which it must be if
-        # we're not executing, the drag will be a Move. The following hack
-        # prevents QTextControl from deleting the text by clearing the selection
-        # when a drag leave event originating from this widget is dispatched.
-        # The fact that we have to clear the user's selection is unfortunate,
-        # but the alternative--trying to prevent Qt from using its hardwired
-        # drag logic and writing our own--is worse.
-        elif etype == QtCore.QEvent.DragEnter and \
-                obj == self._control.viewport() and \
-                event.source() == self._control.viewport():
-            self._filter_drag = True
-        elif etype == QtCore.QEvent.DragLeave and \
-                obj == self._control.viewport() and \
-                self._filter_drag:
-            cursor = self._control.textCursor()
-            cursor.clearSelection()
-            self._control.setTextCursor(cursor)
-            self._filter_drag = False
-
-        # Ensure that drops are safe.
-        elif etype == QtCore.QEvent.Drop and obj == self._control.viewport():
-            cursor = self._control.cursorForPosition(event.pos())
-            if self._in_buffer(cursor.position()):
-                text = event.mimeData().text()
-                self._insert_plain_text_into_buffer(cursor, text)
-
-            # Qt is expecting to get something here--drag and drop occurs in its
-            # own event loop. Send a DragLeave event to end it.
-            QtGui.qApp.sendEvent(obj, QtGui.QDragLeaveEvent())
-            return True
-
-        return super(ConsoleWidget, self).eventFilter(obj, event)
-
-    #---------------------------------------------------------------------------
-    # 'QWidget' interface
-    #---------------------------------------------------------------------------
-
-    def sizeHint(self):
-        """ Reimplemented to suggest a size that is 80 characters wide and
-            25 lines high.
-        """
-        font_metrics = QtGui.QFontMetrics(self.font)
-        margin = (self._control.frameWidth() +
-                  self._control.document().documentMargin()) * 2
-        style = self.style()
-        splitwidth = style.pixelMetric(QtGui.QStyle.PM_SplitterWidth)
-
-        # Note 1: Despite my best efforts to take the various margins into
-        # account, the width is still coming out a bit too small, so we include
-        # a fudge factor of one character here.
-        # Note 2: QFontMetrics.maxWidth is not used here or anywhere else due
-        # to a Qt bug on certain Mac OS systems where it returns 0.
-        width = font_metrics.width(' ') * 81 + margin
-        width += style.pixelMetric(QtGui.QStyle.PM_ScrollBarExtent)
-        if self.paging == 'hsplit':
-            width = width * 2 + splitwidth
-
-        height = font_metrics.height() * 25 + margin
-        if self.paging == 'vsplit':
-            height = height * 2 + splitwidth
-
-        return QtCore.QSize(width, height)
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' public interface
-    #---------------------------------------------------------------------------
-
-    def can_copy(self):
-        """ Returns whether text can be copied to the clipboard.
-        """
-        return self._control.textCursor().hasSelection()
-
-    def can_cut(self):
-        """ Returns whether text can be cut to the clipboard.
-        """
-        cursor = self._control.textCursor()
-        return (cursor.hasSelection() and 
-                self._in_buffer(cursor.anchor()) and 
-                self._in_buffer(cursor.position()))
-        
-    def can_paste(self):
-        """ Returns whether text can be pasted from the clipboard.
-        """
-        if self._control.textInteractionFlags() & QtCore.Qt.TextEditable:
-            return bool(QtGui.QApplication.clipboard().text())
-        return False
-
-    def clear(self, keep_input=True):
-        """ Clear the console. 
-
-        Parameters:
-        -----------
-        keep_input : bool, optional (default True)
-            If set, restores the old input buffer if a new prompt is written.
-        """
-        if self._executing:
-            self._control.clear()
-        else:
-            if keep_input:
-                input_buffer = self.input_buffer
-            self._control.clear()
-            self._show_prompt()
-            if keep_input:
-                self.input_buffer = input_buffer
-
-    def copy(self):
-        """ Copy the currently selected text to the clipboard.
-        """
-        self._control.copy()
-
-    def cut(self):
-        """ Copy the currently selected text to the clipboard and delete it
-            if it's inside the input buffer.
-        """
-        self.copy()
-        if self.can_cut():
-            self._control.textCursor().removeSelectedText()
-
-    def execute(self, source=None, hidden=False, interactive=False):
-        """ Executes source or the input buffer, possibly prompting for more
-        input.
-
-        Parameters:
-        -----------     
-        source : str, optional
-
-            The source to execute. If not specified, the input buffer will be
-            used. If specified and 'hidden' is False, the input buffer will be
-            replaced with the source before execution.
-
-        hidden : bool, optional (default False)
-
-            If set, no output will be shown and the prompt will not be modified.
-            In other words, it will be completely invisible to the user that
-            an execution has occurred.
-
-        interactive : bool, optional (default False)
-
-            Whether the console is to treat the source as having been manually
-            entered by the user. The effect of this parameter depends on the
-            subclass implementation.
-
-        Raises:
-        -------
-        RuntimeError
-            If incomplete input is given and 'hidden' is True. In this case,
-            it is not possible to prompt for more input.
-
-        Returns:
-        --------
-        A boolean indicating whether the source was executed.
-        """
-        # WARNING: The order in which things happen here is very particular, in
-        # large part because our syntax highlighting is fragile. If you change
-        # something, test carefully!
-
-        # Decide what to execute.
-        if source is None:
-            source = self.input_buffer
-            if not hidden:
-                # A newline is appended later, but it should be considered part
-                # of the input buffer.
-                source += '\n'
-        elif not hidden:
-            self.input_buffer = source
-            
-        # Execute the source or show a continuation prompt if it is incomplete.
-        complete = self._is_complete(source, interactive)
-        if hidden:
-            if complete:
-                self._execute(source, hidden)
-            else:
-                error = 'Incomplete noninteractive input: "%s"'
-                raise RuntimeError(error % source)                
-        else:
-            if complete:
-                self._append_plain_text('\n')
-                self._executing_input_buffer = self.input_buffer
-                self._executing = True
-                self._prompt_finished()
-
-                # The maximum block count is only in effect during execution.
-                # This ensures that _prompt_pos does not become invalid due to
-                # text truncation.
-                self._control.document().setMaximumBlockCount(self.buffer_size)
-
-                # Setting a positive maximum block count will automatically
-                # disable the undo/redo history, but just to be safe:
-                self._control.setUndoRedoEnabled(False)
-
-                # Perform actual execution.
-                self._execute(source, hidden)
-            
-            else:
-                # Do this inside an edit block so continuation prompts are
-                # removed seamlessly via undo/redo.
-                cursor = self._get_end_cursor()
-                cursor.beginEditBlock()
-                cursor.insertText('\n')
-                self._insert_continuation_prompt(cursor)
-                cursor.endEditBlock()
-
-                # Do not do this inside the edit block. It works as expected
-                # when using a QPlainTextEdit control, but does not have an 
-                # effect when using a QTextEdit. I believe this is a Qt bug.
-                self._control.moveCursor(QtGui.QTextCursor.End)
-
-        return complete
-
-    def export_html(self):
-        """ Shows a dialog to export HTML/XML in various formats.
-        """
-        self._html_exporter.export()
-
-    def _get_input_buffer(self):
-        """ The text that the user has entered entered at the current prompt.
-        """
-        # If we're executing, the input buffer may not even exist anymore due to
-        # the limit imposed by 'buffer_size'. Therefore, we store it.
-        if self._executing:
-            return self._executing_input_buffer
-
-        cursor = self._get_end_cursor()
-        cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor)
-        input_buffer = cursor.selection().toPlainText()
-
-        # Strip out continuation prompts.
-        return input_buffer.replace('\n' + self._continuation_prompt, '\n')
-
-    def _set_input_buffer(self, string):
-        """ Replaces the text in the input buffer with 'string'.
-        """
-        # For now, it is an error to modify the input buffer during execution.
-        if self._executing:
-            raise RuntimeError("Cannot change input buffer during execution.")
-
-        # Remove old text.
-        cursor = self._get_end_cursor()
-        cursor.beginEditBlock()
-        cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor)
-        cursor.removeSelectedText()
-
-        # Insert new text with continuation prompts.
-        self._insert_plain_text_into_buffer(self._get_prompt_cursor(), string)
-        cursor.endEditBlock()
-        self._control.moveCursor(QtGui.QTextCursor.End)
-
-    input_buffer = property(_get_input_buffer, _set_input_buffer)
-
-    def _get_font(self):
-        """ The base font being used by the ConsoleWidget.
-        """
-        return self._control.document().defaultFont()
-
-    def _set_font(self, font):
-        """ Sets the base font for the ConsoleWidget to the specified QFont.
-        """
-        font_metrics = QtGui.QFontMetrics(font)
-        self._control.setTabStopWidth(self.tab_width * font_metrics.width(' '))
-
-        self._completion_widget.setFont(font)
-        self._control.document().setDefaultFont(font)
-        if self._page_control:
-            self._page_control.document().setDefaultFont(font)
-
-        self.font_changed.emit(font)
-
-    font = property(_get_font, _set_font)
-
-    def paste(self, mode=QtGui.QClipboard.Clipboard):
-        """ Paste the contents of the clipboard into the input region.
-
-        Parameters:
-        -----------
-        mode : QClipboard::Mode, optional [default QClipboard::Clipboard]
-
-            Controls which part of the system clipboard is used. This can be
-            used to access the selection clipboard in X11 and the Find buffer
-            in Mac OS. By default, the regular clipboard is used.
-        """
-        if self._control.textInteractionFlags() & QtCore.Qt.TextEditable:
-            # Make sure the paste is safe.
-            self._keep_cursor_in_buffer()
-            cursor = self._control.textCursor()
-
-            # Remove any trailing newline, which confuses the GUI and forces the
-            # user to backspace.
-            text = QtGui.QApplication.clipboard().text(mode).rstrip()
-            self._insert_plain_text_into_buffer(cursor, dedent(text))
-
-    def print_(self, printer = None):
-        """ Print the contents of the ConsoleWidget to the specified QPrinter.
-        """
-        if (not printer):
-            printer = QtGui.QPrinter()
-            if(QtGui.QPrintDialog(printer).exec_() != QtGui.QDialog.Accepted):
-                return
-        self._control.print_(printer)
-
-    def prompt_to_top(self):
-        """ Moves the prompt to the top of the viewport.
-        """
-        if not self._executing:
-            prompt_cursor = self._get_prompt_cursor()
-            if self._get_cursor().blockNumber() < prompt_cursor.blockNumber():
-                self._set_cursor(prompt_cursor)
-            self._set_top_cursor(prompt_cursor)
-            
-    def redo(self):
-        """ Redo the last operation. If there is no operation to redo, nothing
-            happens.
-        """
-        self._control.redo()
-
-    def reset_font(self):
-        """ Sets the font to the default fixed-width font for this platform.
-        """
-        if sys.platform == 'win32':
-            # Consolas ships with Vista/Win7, fallback to Courier if needed
-            family, fallback = 'Consolas', 'Courier'
-        elif sys.platform == 'darwin':
-            # OSX always has Monaco, no need for a fallback
-            family, fallback = 'Monaco', None
-        else:
-            # FIXME: remove Consolas as a default on Linux once our font
-            # selections are configurable by the user.
-            family, fallback = 'Consolas', 'Monospace'
-        font = get_font(family, fallback)
-        font.setPointSize(QtGui.qApp.font().pointSize())
-        font.setStyleHint(QtGui.QFont.TypeWriter)
-        self._set_font(font)
-
-    def change_font_size(self, delta):
-        """Change the font size by the specified amount (in points).
-        """
-        font = self.font
-        font.setPointSize(font.pointSize() + delta)
-        self._set_font(font)
-
-    def select_all(self):
-        """ Selects all the text in the buffer.
-        """
-        self._control.selectAll()
-
-    def _get_tab_width(self):
-        """ The width (in terms of space characters) for tab characters.
-        """
-        return self._tab_width
-
-    def _set_tab_width(self, tab_width):
-        """ Sets the width (in terms of space characters) for tab characters.
-        """
-        font_metrics = QtGui.QFontMetrics(self.font)
-        self._control.setTabStopWidth(tab_width * font_metrics.width(' '))
-
-        self._tab_width = tab_width
-
-    tab_width = property(_get_tab_width, _set_tab_width)
-
-    def undo(self):
-        """ Undo the last operation. If there is no operation to undo, nothing
-            happens.
-        """
-        self._control.undo()
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' abstract interface
-    #---------------------------------------------------------------------------
-
-    def _is_complete(self, source, interactive):
-        """ Returns whether 'source' can be executed. When triggered by an
-            Enter/Return key press, 'interactive' is True; otherwise, it is
-            False.
-        """
-        raise NotImplementedError
-
-    def _execute(self, source, hidden):
-        """ Execute 'source'. If 'hidden', do not show any output.
-        """
-        raise NotImplementedError
-
-    def _prompt_started_hook(self):
-        """ Called immediately after a new prompt is displayed.
-        """
-        pass
-
-    def _prompt_finished_hook(self):
-        """ Called immediately after a prompt is finished, i.e. when some input
-            will be processed and a new prompt displayed.
-        """
-        pass
-
-    def _up_pressed(self, shift_modifier):
-        """ Called when the up key is pressed. Returns whether to continue
-            processing the event.
-        """
-        return True
-
-    def _down_pressed(self, shift_modifier):
-        """ Called when the down key is pressed. Returns whether to continue
-            processing the event.
-        """
-        return True
-
-    def _tab_pressed(self):
-        """ Called when the tab key is pressed. Returns whether to continue
-            processing the event.
-        """
-        return False
-
-    #--------------------------------------------------------------------------
-    # 'ConsoleWidget' protected interface
-    #--------------------------------------------------------------------------
-
-    def _append_html(self, html):
-        """ Appends html at the end of the console buffer.
-        """
-        cursor = self._get_end_cursor()
-        self._insert_html(cursor, html)
-
-    def _append_html_fetching_plain_text(self, html):
-        """ Appends 'html', then returns the plain text version of it.
-        """
-        cursor = self._get_end_cursor()
-        return self._insert_html_fetching_plain_text(cursor, html)
-
-    def _append_plain_text(self, text):
-        """ Appends plain text at the end of the console buffer, processing
-            ANSI codes if enabled.
-        """
-        cursor = self._get_end_cursor()
-        self._insert_plain_text(cursor, text)
-
-    def _append_plain_text_keeping_prompt(self, text):
-        """ Writes 'text' after the current prompt, then restores the old prompt
-            with its old input buffer.
-        """
-        input_buffer = self.input_buffer
-        self._append_plain_text('\n')
-        self._prompt_finished()
-
-        self._append_plain_text(text)
-        self._show_prompt()
-        self.input_buffer = input_buffer
-
-    def _cancel_text_completion(self):
-        """ If text completion is progress, cancel it.
-        """
-        if self._text_completing_pos:
-            self._clear_temporary_buffer()
-            self._text_completing_pos = 0
-
-    def _clear_temporary_buffer(self):
-        """ Clears the "temporary text" buffer, i.e. all the text following
-            the prompt region.
-        """
-        # Select and remove all text below the input buffer.
-        cursor = self._get_prompt_cursor()
-        prompt = self._continuation_prompt.lstrip()
-        while cursor.movePosition(QtGui.QTextCursor.NextBlock):
-            temp_cursor = QtGui.QTextCursor(cursor)
-            temp_cursor.select(QtGui.QTextCursor.BlockUnderCursor)
-            text = temp_cursor.selection().toPlainText().lstrip()
-            if not text.startswith(prompt):
-                break
-        else:
-            # We've reached the end of the input buffer and no text follows.
-            return
-        cursor.movePosition(QtGui.QTextCursor.Left) # Grab the newline.
-        cursor.movePosition(QtGui.QTextCursor.End,
-                            QtGui.QTextCursor.KeepAnchor)
-        cursor.removeSelectedText()
-
-        # After doing this, we have no choice but to clear the undo/redo
-        # history. Otherwise, the text is not "temporary" at all, because it
-        # can be recalled with undo/redo. Unfortunately, Qt does not expose
-        # fine-grained control to the undo/redo system.
-        if self._control.isUndoRedoEnabled():
-            self._control.setUndoRedoEnabled(False)
-            self._control.setUndoRedoEnabled(True)
-
-    def _complete_with_items(self, cursor, items):
-        """ Performs completion with 'items' at the specified cursor location.
-        """
-        self._cancel_text_completion()
-
-        if len(items) == 1:
-            cursor.setPosition(self._control.textCursor().position(), 
-                               QtGui.QTextCursor.KeepAnchor)
-            cursor.insertText(items[0])
-
-        elif len(items) > 1:
-            current_pos = self._control.textCursor().position()
-            prefix = commonprefix(items)
-            if prefix:
-                cursor.setPosition(current_pos, QtGui.QTextCursor.KeepAnchor)
-                cursor.insertText(prefix)
-                current_pos = cursor.position()
-
-            if self.gui_completion:
-                cursor.movePosition(QtGui.QTextCursor.Left, n=len(prefix))
-                self._completion_widget.show_items(cursor, items) 
-            else:
-                cursor.beginEditBlock()
-                self._append_plain_text('\n')
-                self._page(self._format_as_columns(items))
-                cursor.endEditBlock()
-
-                cursor.setPosition(current_pos)
-                self._control.moveCursor(QtGui.QTextCursor.End)
-                self._control.setTextCursor(cursor)
-                self._text_completing_pos = current_pos
-
-    def _context_menu_make(self, pos):
-        """ Creates a context menu for the given QPoint (in widget coordinates).
-        """
-        menu = QtGui.QMenu(self)
-
-        cut_action = menu.addAction('Cut', self.cut)
-        cut_action.setEnabled(self.can_cut())
-        cut_action.setShortcut(QtGui.QKeySequence.Cut)
-
-        copy_action = menu.addAction('Copy', self.copy)
-        copy_action.setEnabled(self.can_copy())
-        copy_action.setShortcut(QtGui.QKeySequence.Copy)
-
-        paste_action = menu.addAction('Paste', self.paste)
-        paste_action.setEnabled(self.can_paste())
-        paste_action.setShortcut(QtGui.QKeySequence.Paste)
-
-        menu.addSeparator()
-        menu.addAction(self._select_all_action)
-
-        menu.addSeparator()
-        menu.addAction(self._export_action)
-        menu.addAction(self._print_action)
-
-        return menu
-
-    def _control_key_down(self, modifiers, include_command=False):
-        """ Given a KeyboardModifiers flags object, return whether the Control
-        key is down.
-
-        Parameters:
-        -----------
-        include_command : bool, optional (default True)
-            Whether to treat the Command key as a (mutually exclusive) synonym
-            for Control when in Mac OS.
-        """
-        # Note that on Mac OS, ControlModifier corresponds to the Command key
-        # while MetaModifier corresponds to the Control key.
-        if sys.platform == 'darwin':
-            down = include_command and (modifiers & QtCore.Qt.ControlModifier)
-            return bool(down) ^ bool(modifiers & QtCore.Qt.MetaModifier)
-        else:
-            return bool(modifiers & QtCore.Qt.ControlModifier)
-
-    def _create_control(self):
-        """ Creates and connects the underlying text widget.
-        """
-        # Create the underlying control.
-        if self.kind == 'plain':
-            control = QtGui.QPlainTextEdit()
-        elif self.kind == 'rich':
-            control = QtGui.QTextEdit()
-            control.setAcceptRichText(False)
-
-        # Install event filters. The filter on the viewport is needed for
-        # mouse events and drag events.
-        control.installEventFilter(self)
-        control.viewport().installEventFilter(self)
-
-        # Connect signals.
-        control.cursorPositionChanged.connect(self._cursor_position_changed)
-        control.customContextMenuRequested.connect(
-            self._custom_context_menu_requested)
-        control.copyAvailable.connect(self.copy_available)
-        control.redoAvailable.connect(self.redo_available)
-        control.undoAvailable.connect(self.undo_available)
-
-        # Hijack the document size change signal to prevent Qt from adjusting
-        # the viewport's scrollbar. We are relying on an implementation detail
-        # of Q(Plain)TextEdit here, which is potentially dangerous, but without
-        # this functionality we cannot create a nice terminal interface.
-        layout = control.document().documentLayout()
-        layout.documentSizeChanged.disconnect()
-        layout.documentSizeChanged.connect(self._adjust_scrollbars)
-
-        # Configure the control.
-        control.setAttribute(QtCore.Qt.WA_InputMethodEnabled, True)
-        control.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
-        control.setReadOnly(True)
-        control.setUndoRedoEnabled(False)
-        control.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
-        return control
-
-    def _create_page_control(self):
-        """ Creates and connects the underlying paging widget.
-        """
-        if self.kind == 'plain':
-            control = QtGui.QPlainTextEdit()
-        elif self.kind == 'rich':
-            control = QtGui.QTextEdit()
-        control.installEventFilter(self)
-        control.setReadOnly(True)
-        control.setUndoRedoEnabled(False)
-        control.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
-        return control
-
-    def _event_filter_console_keypress(self, event):
-        """ Filter key events for the underlying text widget to create a
-            console-like interface.
-        """
-        intercepted = False
-        cursor = self._control.textCursor()
-        position = cursor.position()
-        key = event.key()
-        ctrl_down = self._control_key_down(event.modifiers())
-        alt_down = event.modifiers() & QtCore.Qt.AltModifier
-        shift_down = event.modifiers() & QtCore.Qt.ShiftModifier
-
-        #------ Special sequences ----------------------------------------------
-
-        if event.matches(QtGui.QKeySequence.Copy):
-            self.copy()
-            intercepted = True
-
-        elif event.matches(QtGui.QKeySequence.Cut):
-            self.cut()
-            intercepted = True
-
-        elif event.matches(QtGui.QKeySequence.Paste):
-            self.paste()
-            intercepted = True
-
-        #------ Special modifier logic -----------------------------------------
-
-        elif key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
-            intercepted = True
-                
-            # Special handling when tab completing in text mode.
-            self._cancel_text_completion()
-
-            if self._in_buffer(position):
-                if self._reading:
-                    self._append_plain_text('\n')
-                    self._reading = False
-                    if self._reading_callback:
-                        self._reading_callback()
-
-                # If the input buffer is a single line or there is only
-                # whitespace after the cursor, execute. Otherwise, split the
-                # line with a continuation prompt.
-                elif not self._executing:
-                    cursor.movePosition(QtGui.QTextCursor.End,
-                                        QtGui.QTextCursor.KeepAnchor)
-                    at_end = len(cursor.selectedText().strip()) == 0
-                    single_line = (self._get_end_cursor().blockNumber() ==
-                                   self._get_prompt_cursor().blockNumber())
-                    if (at_end or shift_down or single_line) and not ctrl_down:
-                        self.execute(interactive = not shift_down)
-                    else:
-                        # Do this inside an edit block for clean undo/redo.
-                        cursor.beginEditBlock()
-                        cursor.setPosition(position)
-                        cursor.insertText('\n')
-                        self._insert_continuation_prompt(cursor)
-                        cursor.endEditBlock()
-
-                        # Ensure that the whole input buffer is visible.
-                        # FIXME: This will not be usable if the input buffer is
-                        # taller than the console widget.
-                        self._control.moveCursor(QtGui.QTextCursor.End)
-                        self._control.setTextCursor(cursor)
-
-        #------ Control/Cmd modifier -------------------------------------------
-
-        elif ctrl_down:
-            if key == QtCore.Qt.Key_G:
-                self._keyboard_quit()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_K:
-                if self._in_buffer(position):
-                    cursor.movePosition(QtGui.QTextCursor.EndOfLine,
-                                        QtGui.QTextCursor.KeepAnchor)
-                    if not cursor.hasSelection():
-                        # Line deletion (remove continuation prompt)
-                        cursor.movePosition(QtGui.QTextCursor.NextBlock,
-                                            QtGui.QTextCursor.KeepAnchor)
-                        cursor.movePosition(QtGui.QTextCursor.Right,
-                                            QtGui.QTextCursor.KeepAnchor,
-                                            len(self._continuation_prompt))
-                    cursor.removeSelectedText()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_L:
-                self.prompt_to_top()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_O:
-                if self._page_control and self._page_control.isVisible():
-                    self._page_control.setFocus()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_U:
-                if self._in_buffer(position):
-                    start_line = cursor.blockNumber()
-                    if start_line == self._get_prompt_cursor().blockNumber():
-                        offset = len(self._prompt)
-                    else:
-                        offset = len(self._continuation_prompt)
-                    cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
-                                        QtGui.QTextCursor.KeepAnchor)
-                    cursor.movePosition(QtGui.QTextCursor.Right,
-                                        QtGui.QTextCursor.KeepAnchor, offset)
-                    cursor.removeSelectedText()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Y:
-                self.paste()
-                intercepted = True
-
-            elif key in (QtCore.Qt.Key_Backspace, QtCore.Qt.Key_Delete):
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Plus:
-                self.change_font_size(1)
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Minus:
-                self.change_font_size(-1)
-                intercepted = True
-
-        #------ Alt modifier ---------------------------------------------------
-
-        elif alt_down:
-            if key == QtCore.Qt.Key_B:
-                self._set_cursor(self._get_word_start_cursor(position))
-                intercepted = True
-                
-            elif key == QtCore.Qt.Key_F:
-                self._set_cursor(self._get_word_end_cursor(position))
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Backspace:
-                cursor = self._get_word_start_cursor(position)
-                cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
-                cursor.removeSelectedText()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_D:
-                cursor = self._get_word_end_cursor(position)
-                cursor.setPosition(position, QtGui.QTextCursor.KeepAnchor)
-                cursor.removeSelectedText()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Delete:
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Greater:
-                self._control.moveCursor(QtGui.QTextCursor.End)
-                intercepted = True
-                
-            elif key == QtCore.Qt.Key_Less:
-                self._control.setTextCursor(self._get_prompt_cursor())
-                intercepted = True
-
-        #------ No modifiers ---------------------------------------------------
-
-        else:
-            if shift_down:
-                anchormode = QtGui.QTextCursor.KeepAnchor
-            else:
-                anchormode = QtGui.QTextCursor.MoveAnchor
-            
-            if key == QtCore.Qt.Key_Escape:
-                self._keyboard_quit()
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Up:
-                if self._reading or not self._up_pressed(shift_down):
-                    intercepted = True
-                else:
-                    prompt_line = self._get_prompt_cursor().blockNumber()
-                    intercepted = cursor.blockNumber() <= prompt_line
-
-            elif key == QtCore.Qt.Key_Down:
-                if self._reading or not self._down_pressed(shift_down):
-                    intercepted = True
-                else:
-                    end_line = self._get_end_cursor().blockNumber()
-                    intercepted = cursor.blockNumber() == end_line
-
-            elif key == QtCore.Qt.Key_Tab:
-                if not self._reading:
-                    intercepted = not self._tab_pressed()
-
-            elif key == QtCore.Qt.Key_Left:
-
-                # Move to the previous line
-                line, col = cursor.blockNumber(), cursor.columnNumber()
-                if line > self._get_prompt_cursor().blockNumber() and \
-                        col == len(self._continuation_prompt):
-                    self._control.moveCursor(QtGui.QTextCursor.PreviousBlock, 
-                                             mode=anchormode)
-                    self._control.moveCursor(QtGui.QTextCursor.EndOfBlock, 
-                                             mode=anchormode)
-                    intercepted = True
-
-                # Regular left movement
-                else:
-                    intercepted = not self._in_buffer(position - 1)
-                    
-            elif key == QtCore.Qt.Key_Right:
-                original_block_number = cursor.blockNumber()
-                cursor.movePosition(QtGui.QTextCursor.Right, 
-                                mode=anchormode)
-                if cursor.blockNumber() != original_block_number:
-                    cursor.movePosition(QtGui.QTextCursor.Right,
-                                        n=len(self._continuation_prompt),
-                                        mode=anchormode)
-                self._set_cursor(cursor)
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Home:
-                start_line = cursor.blockNumber()
-                if start_line == self._get_prompt_cursor().blockNumber():
-                    start_pos = self._prompt_pos
-                else:
-                    cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
-                                        QtGui.QTextCursor.KeepAnchor)
-                    start_pos = cursor.position()
-                    start_pos += len(self._continuation_prompt)
-                    cursor.setPosition(position)
-                if shift_down and self._in_buffer(position):
-                    cursor.setPosition(start_pos, QtGui.QTextCursor.KeepAnchor)
-                else:
-                    cursor.setPosition(start_pos)
-                self._set_cursor(cursor)
-                intercepted = True
-
-            elif key == QtCore.Qt.Key_Backspace:
-
-                # Line deletion (remove continuation prompt)
-                line, col = cursor.blockNumber(), cursor.columnNumber()
-                if not self._reading and \
-                        col == len(self._continuation_prompt) and \
-                        line > self._get_prompt_cursor().blockNumber():
-                    cursor.beginEditBlock()
-                    cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
-                                        QtGui.QTextCursor.KeepAnchor)
-                    cursor.removeSelectedText()
-                    cursor.deletePreviousChar()
-                    cursor.endEditBlock()
-                    intercepted = True
-
-                # Regular backwards deletion
-                else:
-                    anchor = cursor.anchor()
-                    if anchor == position:
-                        intercepted = not self._in_buffer(position - 1)
-                    else:
-                        intercepted = not self._in_buffer(min(anchor, position))
-
-            elif key == QtCore.Qt.Key_Delete:
-
-                # Line deletion (remove continuation prompt)
-                if not self._reading and self._in_buffer(position) and \
-                        cursor.atBlockEnd() and not cursor.hasSelection():
-                    cursor.movePosition(QtGui.QTextCursor.NextBlock,
-                                        QtGui.QTextCursor.KeepAnchor)
-                    cursor.movePosition(QtGui.QTextCursor.Right,
-                                        QtGui.QTextCursor.KeepAnchor,
-                                        len(self._continuation_prompt))
-                    cursor.removeSelectedText()
-                    intercepted = True
-
-                # Regular forwards deletion:
-                else:
-                    anchor = cursor.anchor()
-                    intercepted = (not self._in_buffer(anchor) or
-                                   not self._in_buffer(position))
-
-        # Don't move the cursor if Control/Cmd is pressed to allow copy-paste
-        # using the keyboard in any part of the buffer.
-        if not self._control_key_down(event.modifiers(), include_command=True):
-            self._keep_cursor_in_buffer()
-
-        return intercepted
-
-    def _event_filter_page_keypress(self, event):
-        """ Filter key events for the paging widget to create console-like 
-            interface.
-        """
-        key = event.key()
-        ctrl_down = self._control_key_down(event.modifiers())
-        alt_down = event.modifiers() & QtCore.Qt.AltModifier
-
-        if ctrl_down:
-            if key == QtCore.Qt.Key_O:
-                self._control.setFocus()
-                intercept = True
-
-        elif alt_down:
-            if key == QtCore.Qt.Key_Greater:
-                self._page_control.moveCursor(QtGui.QTextCursor.End)
-                intercepted = True
-                
-            elif key == QtCore.Qt.Key_Less:
-                self._page_control.moveCursor(QtGui.QTextCursor.Start)
-                intercepted = True
-
-        elif key in (QtCore.Qt.Key_Q, QtCore.Qt.Key_Escape):
-            if self._splitter:
-                self._page_control.hide()
-            else:
-                self.layout().setCurrentWidget(self._control)
-            return True
-
-        elif key in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return):
-            new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, 
-                                        QtCore.Qt.Key_PageDown, 
-                                        QtCore.Qt.NoModifier)
-            QtGui.qApp.sendEvent(self._page_control, new_event)
-            return True
-
-        elif key == QtCore.Qt.Key_Backspace:
-            new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
-                                        QtCore.Qt.Key_PageUp, 
-                                        QtCore.Qt.NoModifier)
-            QtGui.qApp.sendEvent(self._page_control, new_event)
-            return True
-
-        return False
-
-    def _format_as_columns(self, items, separator='  '):
-        """ Transform a list of strings into a single string with columns.
-
-        Parameters
-        ----------
-        items : sequence of strings
-            The strings to process.
-
-        separator : str, optional [default is two spaces]
-            The string that separates columns.
-
-        Returns
-        -------
-        The formatted string.
-        """
-        # Note: this code is adapted from columnize 0.3.2.
-        # See http://code.google.com/p/pycolumnize/
-
-        # Calculate the number of characters available.
-        width = self._control.viewport().width()
-        char_width = QtGui.QFontMetrics(self.font).width(' ')
-        displaywidth = max(10, (width / char_width) - 1)
-
-        # Some degenerate cases.
-        size = len(items)
-        if size == 0: 
-            return '\n'
-        elif size == 1:
-            return '%s\n' % items[0]
-
-        # Try every row count from 1 upwards
-        array_index = lambda nrows, row, col: nrows*col + row
-        for nrows in range(1, size):
-            ncols = (size + nrows - 1) // nrows
-            colwidths = []
-            totwidth = -len(separator)
-            for col in range(ncols):
-                # Get max column width for this column
-                colwidth = 0
-                for row in range(nrows):
-                    i = array_index(nrows, row, col)
-                    if i >= size: break
-                    x = items[i]
-                    colwidth = max(colwidth, len(x))
-                colwidths.append(colwidth)
-                totwidth += colwidth + len(separator)
-                if totwidth > displaywidth: 
-                    break
-            if totwidth <= displaywidth: 
-                break
-
-        # The smallest number of rows computed and the max widths for each
-        # column has been obtained. Now we just have to format each of the rows.
-        string = ''
-        for row in range(nrows):
-            texts = []
-            for col in range(ncols):
-                i = row + nrows*col
-                if i >= size:
-                    texts.append('')
-                else:
-                    texts.append(items[i])
-            while texts and not texts[-1]:
-                del texts[-1]
-            for col in range(len(texts)):
-                texts[col] = texts[col].ljust(colwidths[col])
-            string += '%s\n' % separator.join(texts)
-        return string
-
-    def _get_block_plain_text(self, block):
-        """ Given a QTextBlock, return its unformatted text.
-        """
-        cursor = QtGui.QTextCursor(block)
-        cursor.movePosition(QtGui.QTextCursor.StartOfBlock)
-        cursor.movePosition(QtGui.QTextCursor.EndOfBlock, 
-                            QtGui.QTextCursor.KeepAnchor)
-        return cursor.selection().toPlainText()
-
-    def _get_cursor(self):
-        """ Convenience method that returns a cursor for the current position.
-        """
-        return self._control.textCursor()
-                
-    def _get_end_cursor(self):
-        """ Convenience method that returns a cursor for the last character.
-        """
-        cursor = self._control.textCursor()
-        cursor.movePosition(QtGui.QTextCursor.End)
-        return cursor
-
-    def _get_input_buffer_cursor_column(self):
-        """ Returns the column of the cursor in the input buffer, excluding the
-            contribution by the prompt, or -1 if there is no such column.
-        """
-        prompt = self._get_input_buffer_cursor_prompt()
-        if prompt is None:
-            return -1
-        else:
-            cursor = self._control.textCursor()
-            return cursor.columnNumber() - len(prompt)
-
-    def _get_input_buffer_cursor_line(self):
-        """ Returns the text of the line of the input buffer that contains the
-            cursor, or None if there is no such line.
-        """
-        prompt = self._get_input_buffer_cursor_prompt()
-        if prompt is None:
-            return None
-        else:
-            cursor = self._control.textCursor()
-            text = self._get_block_plain_text(cursor.block())
-            return text[len(prompt):]
-
-    def _get_input_buffer_cursor_prompt(self):
-        """ Returns the (plain text) prompt for line of the input buffer that
-            contains the cursor, or None if there is no such line.
-        """
-        if self._executing:
-            return None
-        cursor = self._control.textCursor()
-        if cursor.position() >= self._prompt_pos:
-            if cursor.blockNumber() == self._get_prompt_cursor().blockNumber():
-                return self._prompt
-            else:
-                return self._continuation_prompt
-        else:
-            return None
-
-    def _get_prompt_cursor(self):
-        """ Convenience method that returns a cursor for the prompt position.
-        """
-        cursor = self._control.textCursor()
-        cursor.setPosition(self._prompt_pos)
-        return cursor
-
-    def _get_selection_cursor(self, start, end):
-        """ Convenience method that returns a cursor with text selected between
-            the positions 'start' and 'end'.
-        """
-        cursor = self._control.textCursor()
-        cursor.setPosition(start)
-        cursor.setPosition(end, QtGui.QTextCursor.KeepAnchor)
-        return cursor
-
-    def _get_word_start_cursor(self, position):
-        """ Find the start of the word to the left the given position. If a
-            sequence of non-word characters precedes the first word, skip over
-            them. (This emulates the behavior of bash, emacs, etc.)
-        """
-        document = self._control.document()
-        position -= 1
-        while position >= self._prompt_pos and \
-                  not is_letter_or_number(document.characterAt(position)):
-            position -= 1
-        while position >= self._prompt_pos and \
-                  is_letter_or_number(document.characterAt(position)):
-            position -= 1
-        cursor = self._control.textCursor()
-        cursor.setPosition(position + 1)
-        return cursor
-
-    def _get_word_end_cursor(self, position):
-        """ Find the end of the word to the right the given position. If a
-            sequence of non-word characters precedes the first word, skip over
-            them. (This emulates the behavior of bash, emacs, etc.)
-        """
-        document = self._control.document()
-        end = self._get_end_cursor().position()
-        while position < end and \
-                  not is_letter_or_number(document.characterAt(position)):
-            position += 1
-        while position < end and \
-                  is_letter_or_number(document.characterAt(position)):
-            position += 1
-        cursor = self._control.textCursor()
-        cursor.setPosition(position)
-        return cursor
-
-    def _insert_continuation_prompt(self, cursor):
-        """ Inserts new continuation prompt using the specified cursor.
-        """
-        if self._continuation_prompt_html is None:
-            self._insert_plain_text(cursor, self._continuation_prompt)
-        else:
-            self._continuation_prompt = self._insert_html_fetching_plain_text(
-                cursor, self._continuation_prompt_html)
-
-    def _insert_html(self, cursor, html):
-        """ Inserts HTML using the specified cursor in such a way that future
-            formatting is unaffected.
-        """
-        cursor.beginEditBlock()
-        cursor.insertHtml(html)
-
-        # After inserting HTML, the text document "remembers" it's in "html
-        # mode", which means that subsequent calls adding plain text will result
-        # in unwanted formatting, lost tab characters, etc. The following code
-        # hacks around this behavior, which I consider to be a bug in Qt, by
-        # (crudely) resetting the document's style state.
-        cursor.movePosition(QtGui.QTextCursor.Left,
-                            QtGui.QTextCursor.KeepAnchor)
-        if cursor.selection().toPlainText() == ' ':
-            cursor.removeSelectedText()
-        else:
-            cursor.movePosition(QtGui.QTextCursor.Right)
-        cursor.insertText(' ', QtGui.QTextCharFormat())
-        cursor.endEditBlock()
-
-    def _insert_html_fetching_plain_text(self, cursor, html):
-        """ Inserts HTML using the specified cursor, then returns its plain text
-            version.
-        """
-        cursor.beginEditBlock()
-        cursor.removeSelectedText()
-
-        start = cursor.position()
-        self._insert_html(cursor, html)
-        end = cursor.position()
-        cursor.setPosition(start, QtGui.QTextCursor.KeepAnchor)
-        text = cursor.selection().toPlainText()
-
-        cursor.setPosition(end)
-        cursor.endEditBlock()
-        return text
-
-    def _insert_plain_text(self, cursor, text):
-        """ Inserts plain text using the specified cursor, processing ANSI codes
-            if enabled.
-        """
-        cursor.beginEditBlock()
-        if self.ansi_codes:
-            for substring in self._ansi_processor.split_string(text):
-                for act in self._ansi_processor.actions:
-
-                    # Unlike real terminal emulators, we don't distinguish
-                    # between the screen and the scrollback buffer. A screen
-                    # erase request clears everything.
-                    if act.action == 'erase' and act.area == 'screen':
-                        cursor.select(QtGui.QTextCursor.Document)
-                        cursor.removeSelectedText()
-
-                    # Simulate a form feed by scrolling just past the last line.
-                    elif act.action == 'scroll' and act.unit == 'page':
-                        cursor.insertText('\n')
-                        cursor.endEditBlock()
-                        self._set_top_cursor(cursor)
-                        cursor.joinPreviousEditBlock()
-                        cursor.deletePreviousChar()
-                        
-                format = self._ansi_processor.get_format()
-                cursor.insertText(substring, format)
-        else:
-            cursor.insertText(text)
-        cursor.endEditBlock()
-
-    def _insert_plain_text_into_buffer(self, cursor, text):
-        """ Inserts text into the input buffer using the specified cursor (which
-            must be in the input buffer), ensuring that continuation prompts are
-            inserted as necessary.
-        """
-        lines = text.splitlines(True)
-        if lines:
-            cursor.beginEditBlock()
-            cursor.insertText(lines[0])
-            for line in lines[1:]:
-                if self._continuation_prompt_html is None:
-                    cursor.insertText(self._continuation_prompt)
-                else:
-                    self._continuation_prompt = \
-                        self._insert_html_fetching_plain_text(
-                            cursor, self._continuation_prompt_html)
-                cursor.insertText(line)
-            cursor.endEditBlock()
-
-    def _in_buffer(self, position=None):
-        """ Returns whether the current cursor (or, if specified, a position) is
-            inside the editing region.
-        """
-        cursor = self._control.textCursor()
-        if position is None:
-            position = cursor.position()
-        else:
-            cursor.setPosition(position)
-        line = cursor.blockNumber()
-        prompt_line = self._get_prompt_cursor().blockNumber()
-        if line == prompt_line:
-            return position >= self._prompt_pos
-        elif line > prompt_line:
-            cursor.movePosition(QtGui.QTextCursor.StartOfBlock)
-            prompt_pos = cursor.position() + len(self._continuation_prompt)
-            return position >= prompt_pos
-        return False
-
-    def _keep_cursor_in_buffer(self):
-        """ Ensures that the cursor is inside the editing region. Returns
-            whether the cursor was moved.
-        """
-        moved = not self._in_buffer()
-        if moved:
-            cursor = self._control.textCursor()
-            cursor.movePosition(QtGui.QTextCursor.End)
-            self._control.setTextCursor(cursor)
-        return moved
-
-    def _keyboard_quit(self):
-        """ Cancels the current editing task ala Ctrl-G in Emacs.
-        """
-        if self._text_completing_pos:
-            self._cancel_text_completion()
-        else:
-            self.input_buffer = ''
-        
-    def _page(self, text, html=False):
-        """ Displays text using the pager if it exceeds the height of the
-        viewport.
-
-        Parameters:
-        -----------
-        html : bool, optional (default False)
-            If set, the text will be interpreted as HTML instead of plain text.
-        """
-        line_height = QtGui.QFontMetrics(self.font).height()
-        minlines = self._control.viewport().height() / line_height
-        if self.paging != 'none' and \
-                re.match("(?:[^\n]*\n){%i}" % minlines, text):
-            if self.paging == 'custom':
-                self.custom_page_requested.emit(text)
-            else:
-                self._page_control.clear()
-                cursor = self._page_control.textCursor()
-                if html:
-                    self._insert_html(cursor, text)
-                else:
-                    self._insert_plain_text(cursor, text)
-                self._page_control.moveCursor(QtGui.QTextCursor.Start)
-
-                self._page_control.viewport().resize(self._control.size())
-                if self._splitter:
-                    self._page_control.show()
-                    self._page_control.setFocus()
-                else:
-                    self.layout().setCurrentWidget(self._page_control)
-        elif html:
-            self._append_plain_html(text)
-        else:
-            self._append_plain_text(text)
-
-    def _prompt_finished(self):
-        """ Called immediately after a prompt is finished, i.e. when some input
-            will be processed and a new prompt displayed.
-        """
-        self._control.setReadOnly(True)
-        self._prompt_finished_hook()
-
-    def _prompt_started(self):
-        """ Called immediately after a new prompt is displayed.
-        """
-        # Temporarily disable the maximum block count to permit undo/redo and 
-        # to ensure that the prompt position does not change due to truncation.
-        self._control.document().setMaximumBlockCount(0)
-        self._control.setUndoRedoEnabled(True)
-
-        # Work around bug in QPlainTextEdit: input method is not re-enabled
-        # when read-only is disabled.
-        self._control.setReadOnly(False)
-        self._control.setAttribute(QtCore.Qt.WA_InputMethodEnabled, True)
-
-        self._control.moveCursor(QtGui.QTextCursor.End)
-        self._executing = False
-        self._prompt_started_hook()
-
-    def _readline(self, prompt='', callback=None):
-        """ Reads one line of input from the user. 
-
-        Parameters
-        ----------
-        prompt : str, optional
-            The prompt to print before reading the line.
-
-        callback : callable, optional
-            A callback to execute with the read line. If not specified, input is
-            read *synchronously* and this method does not return until it has
-            been read.
-
-        Returns
-        -------
-        If a callback is specified, returns nothing. Otherwise, returns the
-        input string with the trailing newline stripped.
-        """
-        if self._reading:
-            raise RuntimeError('Cannot read a line. Widget is already reading.')
-
-        if not callback and not self.isVisible():
-            # If the user cannot see the widget, this function cannot return.
-            raise RuntimeError('Cannot synchronously read a line if the widget '
-                               'is not visible!')
-
-        self._reading = True
-        self._show_prompt(prompt, newline=False)
-
-        if callback is None:
-            self._reading_callback = None
-            while self._reading:
-                QtCore.QCoreApplication.processEvents()
-            return self.input_buffer.rstrip('\n')
-
-        else:
-            self._reading_callback = lambda: \
-                callback(self.input_buffer.rstrip('\n'))
-
-    def _set_continuation_prompt(self, prompt, html=False):
-        """ Sets the continuation prompt.
-
-        Parameters
-        ----------
-        prompt : str
-            The prompt to show when more input is needed.
-
-        html : bool, optional (default False)
-            If set, the prompt will be inserted as formatted HTML. Otherwise,
-            the prompt will be treated as plain text, though ANSI color codes
-            will be handled.
-        """
-        if html:
-            self._continuation_prompt_html = prompt
-        else:
-            self._continuation_prompt = prompt
-            self._continuation_prompt_html = None
-            
-    def _set_cursor(self, cursor):
-        """ Convenience method to set the current cursor.
-        """
-        self._control.setTextCursor(cursor)
-
-    def _set_top_cursor(self, cursor):
-        """ Scrolls the viewport so that the specified cursor is at the top.
-        """
-        scrollbar = self._control.verticalScrollBar()
-        scrollbar.setValue(scrollbar.maximum())
-        original_cursor = self._control.textCursor()
-        self._control.setTextCursor(cursor)
-        self._control.ensureCursorVisible()
-        self._control.setTextCursor(original_cursor)
-
-    def _show_prompt(self, prompt=None, html=False, newline=True):
-        """ Writes a new prompt at the end of the buffer.
-
-        Parameters
-        ----------
-        prompt : str, optional
-            The prompt to show. If not specified, the previous prompt is used.
-
-        html : bool, optional (default False)
-            Only relevant when a prompt is specified. If set, the prompt will
-            be inserted as formatted HTML. Otherwise, the prompt will be treated
-            as plain text, though ANSI color codes will be handled.
-
-        newline : bool, optional (default True)
-            If set, a new line will be written before showing the prompt if 
-            there is not already a newline at the end of the buffer.
-        """
-        # Insert a preliminary newline, if necessary.
-        if newline:
-            cursor = self._get_end_cursor()
-            if cursor.position() > 0:
-                cursor.movePosition(QtGui.QTextCursor.Left, 
-                                    QtGui.QTextCursor.KeepAnchor)
-                if cursor.selection().toPlainText() != '\n':
-                    self._append_plain_text('\n')
-
-        # Write the prompt.
-        self._append_plain_text(self._prompt_sep)
-        if prompt is None:
-            if self._prompt_html is None:
-                self._append_plain_text(self._prompt)
-            else:
-                self._append_html(self._prompt_html)
-        else:
-            if html:
-                self._prompt = self._append_html_fetching_plain_text(prompt)
-                self._prompt_html = prompt
-            else:
-                self._append_plain_text(prompt)
-                self._prompt = prompt
-                self._prompt_html = None
-
-        self._prompt_pos = self._get_end_cursor().position()
-        self._prompt_started()
-
-    #------ Signal handlers ----------------------------------------------------
-
-    def _adjust_scrollbars(self):
-        """ Expands the vertical scrollbar beyond the range set by Qt.
-        """
-        # This code is adapted from _q_adjustScrollbars in qplaintextedit.cpp
-        # and qtextedit.cpp.
-        document = self._control.document()
-        scrollbar = self._control.verticalScrollBar()
-        viewport_height = self._control.viewport().height()
-        if isinstance(self._control, QtGui.QPlainTextEdit):
-            maximum = max(0, document.lineCount() - 1)
-            step = viewport_height / self._control.fontMetrics().lineSpacing()
-        else:
-            # QTextEdit does not do line-based layout and blocks will not in
-            # general have the same height. Therefore it does not make sense to
-            # attempt to scroll in line height increments.
-            maximum = document.size().height()
-            step = viewport_height
-        diff = maximum - scrollbar.maximum()
-        scrollbar.setRange(0, maximum)
-        scrollbar.setPageStep(step)
-
-        # Compensate for undesirable scrolling that occurs automatically due to
-        # maximumBlockCount() text truncation.
-        if diff < 0 and document.blockCount() == document.maximumBlockCount():
-            scrollbar.setValue(scrollbar.value() + diff)
-
-    def _cursor_position_changed(self):
-        """ Clears the temporary buffer based on the cursor position.
-        """
-        if self._text_completing_pos:
-            document = self._control.document()
-            if self._text_completing_pos < document.characterCount():
-                cursor = self._control.textCursor()
-                pos = cursor.position()
-                text_cursor = self._control.textCursor()
-                text_cursor.setPosition(self._text_completing_pos)
-                if pos < self._text_completing_pos or \
-                        cursor.blockNumber() > text_cursor.blockNumber():
-                    self._clear_temporary_buffer()
-                    self._text_completing_pos = 0
-            else:
-                self._clear_temporary_buffer()
-                self._text_completing_pos = 0
-
-    def _custom_context_menu_requested(self, pos):
-        """ Shows a context menu at the given QPoint (in widget coordinates).
-        """
-        menu = self._context_menu_make(pos)
-        menu.exec_(self._control.mapToGlobal(pos))
diff --git a/IPython/frontend/qt/console/frontend_widget.py b/IPython/frontend/qt/console/frontend_widget.py
deleted file mode 100644
index 94e506af2be..00000000000
--- a/IPython/frontend/qt/console/frontend_widget.py
+++ /dev/null
@@ -1,616 +0,0 @@
-from __future__ import print_function
-
-# Standard library imports
-from collections import namedtuple
-import sys
-import time
-
-# System library imports
-from pygments.lexers import PythonLexer
-from IPython.external.qt import QtCore, QtGui
-
-# Local imports
-from IPython.core.inputsplitter import InputSplitter, transform_classic_prompt
-from IPython.core.oinspect import call_tip
-from IPython.frontend.qt.base_frontend_mixin import BaseFrontendMixin
-from IPython.utils.traitlets import Bool
-from bracket_matcher import BracketMatcher
-from call_tip_widget import CallTipWidget
-from completion_lexer import CompletionLexer
-from history_console_widget import HistoryConsoleWidget
-from pygments_highlighter import PygmentsHighlighter
-
-
-class FrontendHighlighter(PygmentsHighlighter):
-    """ A PygmentsHighlighter that can be turned on and off and that ignores
-        prompts.
-    """
-
-    def __init__(self, frontend):
-        super(FrontendHighlighter, self).__init__(frontend._control.document())
-        self._current_offset = 0
-        self._frontend = frontend
-        self.highlighting_on = False
-
-    def highlightBlock(self, string):
-        """ Highlight a block of text. Reimplemented to highlight selectively.
-        """
-        if not self.highlighting_on:
-            return
-
-        # The input to this function is a unicode string that may contain
-        # paragraph break characters, non-breaking spaces, etc. Here we acquire
-        # the string as plain text so we can compare it.
-        current_block = self.currentBlock()
-        string = self._frontend._get_block_plain_text(current_block)
-
-        # Decide whether to check for the regular or continuation prompt.
-        if current_block.contains(self._frontend._prompt_pos):
-            prompt = self._frontend._prompt
-        else:
-            prompt = self._frontend._continuation_prompt
-
-        # Don't highlight the part of the string that contains the prompt.
-        if string.startswith(prompt):
-            self._current_offset = len(prompt)
-            string = string[len(prompt):]
-        else:
-            self._current_offset = 0
-
-        PygmentsHighlighter.highlightBlock(self, string)
-
-    def rehighlightBlock(self, block):
-        """ Reimplemented to temporarily enable highlighting if disabled.
-        """
-        old = self.highlighting_on
-        self.highlighting_on = True
-        super(FrontendHighlighter, self).rehighlightBlock(block)
-        self.highlighting_on = old
-
-    def setFormat(self, start, count, format):
-        """ Reimplemented to highlight selectively.
-        """
-        start += self._current_offset
-        PygmentsHighlighter.setFormat(self, start, count, format)
-
-
-class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):
-    """ A Qt frontend for a generic Python kernel.
-    """
-
-    # An option and corresponding signal for overriding the default kernel
-    # interrupt behavior.
-    custom_interrupt = Bool(False)
-    custom_interrupt_requested = QtCore.Signal()
-
-    # An option and corresponding signals for overriding the default kernel
-    # restart behavior.
-    custom_restart = Bool(False)
-    custom_restart_kernel_died = QtCore.Signal(float)
-    custom_restart_requested = QtCore.Signal()
-
-    # Emitted when a user visible 'execute_request' has been submitted to the
-    # kernel from the FrontendWidget. Contains the code to be executed.
-    executing = QtCore.Signal(object)
-
-    # Emitted when a user-visible 'execute_reply' has been received from the
-    # kernel and processed by the FrontendWidget. Contains the response message.
-    executed = QtCore.Signal(object)
-
-    # Emitted when an exit request has been received from the kernel.
-    exit_requested = QtCore.Signal()
-    
-    # Protected class variables.
-    _CallTipRequest = namedtuple('_CallTipRequest', ['id', 'pos'])
-    _CompletionRequest = namedtuple('_CompletionRequest', ['id', 'pos'])
-    _ExecutionRequest = namedtuple('_ExecutionRequest', ['id', 'kind'])
-    _input_splitter_class = InputSplitter
-    _local_kernel = False
-
-    #---------------------------------------------------------------------------
-    # 'object' interface
-    #---------------------------------------------------------------------------
-    
-    def __init__(self, *args, **kw):
-        super(FrontendWidget, self).__init__(*args, **kw)
-
-        # FrontendWidget protected variables.
-        self._bracket_matcher = BracketMatcher(self._control)
-        self._call_tip_widget = CallTipWidget(self._control)
-        self._completion_lexer = CompletionLexer(PythonLexer())
-        self._copy_raw_action = QtGui.QAction('Copy (Raw Text)', None)
-        self._hidden = False
-        self._highlighter = FrontendHighlighter(self)
-        self._input_splitter = self._input_splitter_class(input_mode='cell')
-        self._kernel_manager = None
-        self._request_info = {}
-
-        # Configure the ConsoleWidget.
-        self.tab_width = 4
-        self._set_continuation_prompt('... ')
-
-        # Configure the CallTipWidget.
-        self._call_tip_widget.setFont(self.font)
-        self.font_changed.connect(self._call_tip_widget.setFont)
-
-        # Configure actions.
-        action = self._copy_raw_action
-        key = QtCore.Qt.CTRL | QtCore.Qt.SHIFT | QtCore.Qt.Key_C
-        action.setEnabled(False)
-        action.setShortcut(QtGui.QKeySequence(key))
-        action.setShortcutContext(QtCore.Qt.WidgetWithChildrenShortcut)
-        action.triggered.connect(self.copy_raw)
-        self.copy_available.connect(action.setEnabled)
-        self.addAction(action)
-
-        # Connect signal handlers.
-        document = self._control.document()
-        document.contentsChange.connect(self._document_contents_change)
-        
-        # Set flag for whether we are connected via localhost.
-        self._local_kernel = kw.get('local_kernel', 
-                                    FrontendWidget._local_kernel)
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' public interface
-    #---------------------------------------------------------------------------
-
-    def copy(self):
-        """ Copy the currently selected text to the clipboard, removing prompts.
-        """
-        text = self._control.textCursor().selection().toPlainText()
-        if text:
-            lines = map(transform_classic_prompt, text.splitlines())
-            text = '\n'.join(lines)
-            QtGui.QApplication.clipboard().setText(text)
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' abstract interface
-    #---------------------------------------------------------------------------
-
-    def _is_complete(self, source, interactive):
-        """ Returns whether 'source' can be completely processed and a new
-            prompt created. When triggered by an Enter/Return key press,
-            'interactive' is True; otherwise, it is False.
-        """
-        complete = self._input_splitter.push(source)
-        if interactive:
-            complete = not self._input_splitter.push_accepts_more()
-        return complete
-
-    def _execute(self, source, hidden):
-        """ Execute 'source'. If 'hidden', do not show any output.
-
-        See parent class :meth:`execute` docstring for full details.
-        """
-        msg_id = self.kernel_manager.xreq_channel.execute(source, hidden)
-        self._request_info['execute'] = self._ExecutionRequest(msg_id, 'user')
-        self._hidden = hidden
-        if not hidden:
-            self.executing.emit(source)
-        
-    def _prompt_started_hook(self):
-        """ Called immediately after a new prompt is displayed.
-        """
-        if not self._reading:
-            self._highlighter.highlighting_on = True
-
-    def _prompt_finished_hook(self):
-        """ Called immediately after a prompt is finished, i.e. when some input
-            will be processed and a new prompt displayed.
-        """
-        # Flush all state from the input splitter so the next round of
-        # reading input starts with a clean buffer.
-        self._input_splitter.reset()
-
-        if not self._reading:
-            self._highlighter.highlighting_on = False
-
-    def _tab_pressed(self):
-        """ Called when the tab key is pressed. Returns whether to continue
-            processing the event.
-        """
-        # Perform tab completion if:
-        # 1) The cursor is in the input buffer.
-        # 2) There is a non-whitespace character before the cursor.
-        text = self._get_input_buffer_cursor_line()
-        if text is None:
-            return False
-        complete = bool(text[:self._get_input_buffer_cursor_column()].strip())
-        if complete:
-            self._complete()
-        return not complete
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' protected interface
-    #---------------------------------------------------------------------------
-
-    def _context_menu_make(self, pos):
-        """ Reimplemented to add an action for raw copy.
-        """
-        menu = super(FrontendWidget, self)._context_menu_make(pos)
-        for before_action in menu.actions():
-            if before_action.shortcut().matches(QtGui.QKeySequence.Paste) == \
-                    QtGui.QKeySequence.ExactMatch:
-                menu.insertAction(before_action, self._copy_raw_action)
-                break
-        return menu
-
-    def _event_filter_console_keypress(self, event):
-        """ Reimplemented for execution interruption and smart backspace.
-        """
-        key = event.key()
-        if self._control_key_down(event.modifiers(), include_command=False):
-
-            if key == QtCore.Qt.Key_C and self._executing:
-                self.interrupt_kernel()
-                return True
-
-            elif key == QtCore.Qt.Key_Period:
-                message = 'Are you sure you want to restart the kernel?'
-                self.restart_kernel(message, now=False)
-                return True
-
-        elif not event.modifiers() & QtCore.Qt.AltModifier:
-
-            # Smart backspace: remove four characters in one backspace if:
-            # 1) everything left of the cursor is whitespace
-            # 2) the four characters immediately left of the cursor are spaces
-            if key == QtCore.Qt.Key_Backspace:
-                col = self._get_input_buffer_cursor_column()
-                cursor = self._control.textCursor()
-                if col > 3 and not cursor.hasSelection():
-                    text = self._get_input_buffer_cursor_line()[:col]
-                    if text.endswith('    ') and not text.strip():
-                        cursor.movePosition(QtGui.QTextCursor.Left,
-                                            QtGui.QTextCursor.KeepAnchor, 4)
-                        cursor.removeSelectedText()
-                        return True
-
-        return super(FrontendWidget, self)._event_filter_console_keypress(event)
-
-    def _insert_continuation_prompt(self, cursor):
-        """ Reimplemented for auto-indentation.
-        """
-        super(FrontendWidget, self)._insert_continuation_prompt(cursor)
-        cursor.insertText(' ' * self._input_splitter.indent_spaces)
-
-    #---------------------------------------------------------------------------
-    # 'BaseFrontendMixin' abstract interface
-    #---------------------------------------------------------------------------
-
-    def _handle_complete_reply(self, rep):
-        """ Handle replies for tab completion.
-        """
-        cursor = self._get_cursor()
-        info = self._request_info.get('complete')
-        if info and info.id == rep['parent_header']['msg_id'] and \
-                info.pos == cursor.position():
-            text = '.'.join(self._get_context())
-            cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
-            self._complete_with_items(cursor, rep['content']['matches'])
-
-    def _handle_execute_reply(self, msg):
-        """ Handles replies for code execution.
-        """
-        info = self._request_info.get('execute')
-        if info and info.id == msg['parent_header']['msg_id'] and \
-                info.kind == 'user' and not self._hidden:
-            # Make sure that all output from the SUB channel has been processed
-            # before writing a new prompt.
-            self.kernel_manager.sub_channel.flush()
-
-            # Reset the ANSI style information to prevent bad text in stdout
-            # from messing up our colors. We're not a true terminal so we're
-            # allowed to do this.
-            if self.ansi_codes:
-                self._ansi_processor.reset_sgr()
-
-            content = msg['content']
-            status = content['status']
-            if status == 'ok':
-                self._process_execute_ok(msg)
-            elif status == 'error':
-                self._process_execute_error(msg)
-            elif status == 'abort':
-                self._process_execute_abort(msg)
-
-            self._show_interpreter_prompt_for_reply(msg)
-            self.executed.emit(msg)
-
-    def _handle_input_request(self, msg):
-        """ Handle requests for raw_input.
-        """
-        if self._hidden:
-            raise RuntimeError('Request for raw input during hidden execution.')
-
-        # Make sure that all output from the SUB channel has been processed
-        # before entering readline mode.
-        self.kernel_manager.sub_channel.flush()
-
-        def callback(line):
-            self.kernel_manager.rep_channel.input(line)
-        self._readline(msg['content']['prompt'], callback=callback)
-
-    def _handle_kernel_died(self, since_last_heartbeat):
-        """ Handle the kernel's death by asking if the user wants to restart.
-        """
-        if self.custom_restart:
-            self.custom_restart_kernel_died.emit(since_last_heartbeat)
-        else:
-            message = 'The kernel heartbeat has been inactive for %.2f ' \
-                'seconds. Do you want to restart the kernel? You may ' \
-                'first want to check the network connection.' % \
-                since_last_heartbeat
-            self.restart_kernel(message, now=True)
-
-    def _handle_object_info_reply(self, rep):
-        """ Handle replies for call tips.
-        """
-        cursor = self._get_cursor()
-        info = self._request_info.get('call_tip')
-        if info and info.id == rep['parent_header']['msg_id'] and \
-                info.pos == cursor.position():
-            # Get the information for a call tip.  For now we format the call
-            # line as string, later we can pass False to format_call and
-            # syntax-highlight it ourselves for nicer formatting in the
-            # calltip.
-            if rep['content']['ismagic']:
-                # Don't generate a call-tip for magics. Ideally, we should
-                # generate a tooltip, but not on ( like we do for actual
-                # callables.
-                call_info, doc = None, None
-            else:
-                call_info, doc = call_tip(rep['content'], format_call=True)
-            if call_info or doc:
-                self._call_tip_widget.show_call_info(call_info, doc)
-
-    def _handle_pyout(self, msg):
-        """ Handle display hook output.
-        """
-        if not self._hidden and self._is_from_this_session(msg):
-            self._append_plain_text(msg['content']['data']['text/plain'] + '\n')
-
-    def _handle_stream(self, msg):
-        """ Handle stdout, stderr, and stdin.
-        """
-        if not self._hidden and self._is_from_this_session(msg):
-            # Most consoles treat tabs as being 8 space characters. Convert tabs
-            # to spaces so that output looks as expected regardless of this
-            # widget's tab width.
-            text = msg['content']['data'].expandtabs(8)
-            
-            self._append_plain_text(text)
-            self._control.moveCursor(QtGui.QTextCursor.End)
-
-    def _handle_shutdown_reply(self, msg):
-        """ Handle shutdown signal, only if from other console.
-        """
-        if not self._hidden and not self._is_from_this_session(msg):
-            if self._local_kernel:
-                if not msg['content']['restart']:
-                    sys.exit(0)
-                else:
-                    # we just got notified of a restart!
-                    time.sleep(0.25) # wait 1/4 sec to reset
-                                     # lest the request for a new prompt
-                                     # goes to the old kernel
-                    self.reset()
-            else: # remote kernel, prompt on Kernel shutdown/reset
-                title = self.window().windowTitle()
-                if not msg['content']['restart']:
-                    reply = QtGui.QMessageBox.question(self, title,
-                        "Kernel has been shutdown permanently. "
-                        "Close the Console?",
-                        QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)
-                    if reply == QtGui.QMessageBox.Yes:
-                        sys.exit(0)
-                else:
-                    reply = QtGui.QMessageBox.question(self, title,
-                        "Kernel has been reset. Clear the Console?",
-                        QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)
-                    if reply == QtGui.QMessageBox.Yes:
-                        time.sleep(0.25) # wait 1/4 sec to reset
-                                         # lest the request for a new prompt
-                                         # goes to the old kernel
-                        self.reset()
-
-    def _started_channels(self):
-        """ Called when the KernelManager channels have started listening or 
-            when the frontend is assigned an already listening KernelManager.
-        """
-        self.reset()
-
-    #---------------------------------------------------------------------------
-    # 'FrontendWidget' public interface
-    #---------------------------------------------------------------------------
-
-    def copy_raw(self):
-        """ Copy the currently selected text to the clipboard without attempting
-            to remove prompts or otherwise alter the text.
-        """
-        self._control.copy()
-
-    def execute_file(self, path, hidden=False):
-        """ Attempts to execute file with 'path'. If 'hidden', no output is
-            shown.
-        """
-        self.execute('execfile(%r)' % path, hidden=hidden)
-
-    def interrupt_kernel(self):
-        """ Attempts to interrupt the running kernel.
-        """
-        if self.custom_interrupt:
-            self.custom_interrupt_requested.emit()
-        elif self.kernel_manager.has_kernel:
-            self.kernel_manager.interrupt_kernel()
-        else:
-            self._append_plain_text('Kernel process is either remote or '
-                                    'unspecified. Cannot interrupt.\n')
-
-    def reset(self):
-        """ Resets the widget to its initial state. Similar to ``clear``, but
-            also re-writes the banner and aborts execution if necessary.
-        """ 
-        if self._executing:
-            self._executing = False
-            self._request_info['execute'] = None
-        self._reading = False
-        self._highlighter.highlighting_on = False
-
-        self._control.clear()
-        self._append_plain_text(self._get_banner())
-        self._show_interpreter_prompt()
-
-    def restart_kernel(self, message, now=False):
-        """ Attempts to restart the running kernel.
-        """
-        # FIXME: now should be configurable via a checkbox in the dialog.  Right
-        # now at least the heartbeat path sets it to True and the manual restart
-        # to False.  But those should just be the pre-selected states of a
-        # checkbox that the user could override if so desired.  But I don't know
-        # enough Qt to go implementing the checkbox now.
-
-        if self.custom_restart:
-            self.custom_restart_requested.emit()
-
-        elif self.kernel_manager.has_kernel:
-            # Pause the heart beat channel to prevent further warnings.
-            self.kernel_manager.hb_channel.pause()
-
-            # Prompt the user to restart the kernel. Un-pause the heartbeat if
-            # they decline. (If they accept, the heartbeat will be un-paused
-            # automatically when the kernel is restarted.)
-            buttons = QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
-            result = QtGui.QMessageBox.question(self, 'Restart kernel?',
-                                                message, buttons)
-            if result == QtGui.QMessageBox.Yes:
-                try:
-                    self.kernel_manager.restart_kernel(now=now)
-                except RuntimeError:
-                    self._append_plain_text('Kernel started externally. '
-                                            'Cannot restart.\n')
-                else:
-                    self.reset()
-            else:
-                self.kernel_manager.hb_channel.unpause()
-
-        else:
-            self._append_plain_text('Kernel process is either remote or '
-                                    'unspecified. Cannot restart.\n')
-
-    #---------------------------------------------------------------------------
-    # 'FrontendWidget' protected interface
-    #---------------------------------------------------------------------------
-
-    def _call_tip(self):
-        """ Shows a call tip, if appropriate, at the current cursor location.
-        """
-        # Decide if it makes sense to show a call tip
-        cursor = self._get_cursor()
-        cursor.movePosition(QtGui.QTextCursor.Left)
-        if cursor.document().characterAt(cursor.position()) != '(':
-            return False
-        context = self._get_context(cursor)
-        if not context:
-            return False
-
-        # Send the metadata request to the kernel
-        name = '.'.join(context)
-        msg_id = self.kernel_manager.xreq_channel.object_info(name)
-        pos = self._get_cursor().position()
-        self._request_info['call_tip'] = self._CallTipRequest(msg_id, pos)
-        return True
-
-    def _complete(self):
-        """ Performs completion at the current cursor location.
-        """
-        context = self._get_context()
-        if context:
-            # Send the completion request to the kernel
-            msg_id = self.kernel_manager.xreq_channel.complete(
-                '.'.join(context),                       # text
-                self._get_input_buffer_cursor_line(),    # line
-                self._get_input_buffer_cursor_column(),  # cursor_pos
-                self.input_buffer)                       # block 
-            pos = self._get_cursor().position()
-            info = self._CompletionRequest(msg_id, pos)
-            self._request_info['complete'] = info
-
-    def _get_banner(self):
-        """ Gets a banner to display at the beginning of a session.
-        """
-        banner = 'Python %s on %s\nType "help", "copyright", "credits" or ' \
-            '"license" for more information.'
-        return banner % (sys.version, sys.platform)
-
-    def _get_context(self, cursor=None):
-        """ Gets the context for the specified cursor (or the current cursor
-            if none is specified).
-        """
-        if cursor is None:
-            cursor = self._get_cursor()
-        cursor.movePosition(QtGui.QTextCursor.StartOfBlock, 
-                            QtGui.QTextCursor.KeepAnchor)
-        text = cursor.selection().toPlainText()
-        return self._completion_lexer.get_context(text)
-
-    def _process_execute_abort(self, msg):
-        """ Process a reply for an aborted execution request.
-        """
-        self._append_plain_text("ERROR: execution aborted\n")
-
-    def _process_execute_error(self, msg):
-        """ Process a reply for an execution request that resulted in an error.
-        """
-        content = msg['content']
-        # If a SystemExit is passed along, this means exit() was called - also
-        # all the ipython %exit magic syntax of '-k' to be used to keep
-        # the kernel running
-        if content['ename']=='SystemExit':
-            keepkernel = content['evalue']=='-k' or content['evalue']=='True'
-            self._keep_kernel_on_exit = keepkernel
-            self.exit_requested.emit()
-        else:
-            traceback = ''.join(content['traceback'])
-            self._append_plain_text(traceback)
-
-    def _process_execute_ok(self, msg):
-        """ Process a reply for a successful execution equest.
-        """
-        payload = msg['content']['payload']
-        for item in payload:
-            if not self._process_execute_payload(item):
-                warning = 'Warning: received unknown payload of type %s'
-                print(warning % repr(item['source']))
-
-    def _process_execute_payload(self, item):
-        """ Process a single payload item from the list of payload items in an
-            execution reply. Returns whether the payload was handled.
-        """
-        # The basic FrontendWidget doesn't handle payloads, as they are a
-        # mechanism for going beyond the standard Python interpreter model.
-        return False
-
-    def _show_interpreter_prompt(self):
-        """ Shows a prompt for the interpreter.
-        """
-        self._show_prompt('>>> ')
-
-    def _show_interpreter_prompt_for_reply(self, msg):
-        """ Shows a prompt for the interpreter given an 'execute_reply' message.
-        """
-        self._show_interpreter_prompt()
-
-    #------ Signal handlers ----------------------------------------------------
-
-    def _document_contents_change(self, position, removed, added):
-        """ Called whenever the document's content changes. Display a call tip
-            if appropriate.
-        """
-        # Calculate where the cursor should be *after* the change:
-        position += added
-
-        document = self._control.document()
-        if position == self._get_cursor().position():
-            self._call_tip()
diff --git a/IPython/frontend/qt/console/history_console_widget.py b/IPython/frontend/qt/console/history_console_widget.py
deleted file mode 100644
index 40de7d41ef8..00000000000
--- a/IPython/frontend/qt/console/history_console_widget.py
+++ /dev/null
@@ -1,234 +0,0 @@
-# System library imports
-from IPython.external.qt import QtGui
-
-# Local imports
-from IPython.utils.traitlets import Bool
-from console_widget import ConsoleWidget
-
-
-class HistoryConsoleWidget(ConsoleWidget):
-    """ A ConsoleWidget that keeps a history of the commands that have been
-        executed and provides a readline-esque interface to this history.
-    """
-
-    #------ Configuration ------------------------------------------------------
-
-    # If enabled, the input buffer will become "locked" to history movement when
-    # an edit is made to a multi-line input buffer. To override the lock, use
-    # Shift in conjunction with the standard history cycling keys.
-    history_lock = Bool(False, config=True)
-    
-    #---------------------------------------------------------------------------
-    # 'object' interface
-    #---------------------------------------------------------------------------
-
-    def __init__(self, *args, **kw):
-        super(HistoryConsoleWidget, self).__init__(*args, **kw)
-
-        # HistoryConsoleWidget protected variables.
-        self._history = []
-        self._history_edits = {}
-        self._history_index = 0
-        self._history_prefix = ''
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' public interface
-    #---------------------------------------------------------------------------
-
-    def execute(self, source=None, hidden=False, interactive=False):
-        """ Reimplemented to the store history.
-        """
-        if not hidden:
-            history = self.input_buffer if source is None else source
-
-        executed = super(HistoryConsoleWidget, self).execute(
-            source, hidden, interactive)
-
-        if executed and not hidden:
-            # Save the command unless it was an empty string or was identical 
-            # to the previous command.
-            history = history.rstrip()
-            if history and (not self._history or self._history[-1] != history):
-                self._history.append(history)
-
-            # Emulate readline: reset all history edits.
-            self._history_edits = {}
-
-            # Move the history index to the most recent item.
-            self._history_index = len(self._history)
-
-        return executed
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' abstract interface
-    #---------------------------------------------------------------------------
-
-    def _up_pressed(self, shift_modifier):
-        """ Called when the up key is pressed. Returns whether to continue
-            processing the event.
-        """
-        prompt_cursor = self._get_prompt_cursor()
-        if self._get_cursor().blockNumber() == prompt_cursor.blockNumber():
-            # Bail out if we're locked.
-            if self._history_locked() and not shift_modifier:
-                return False
-
-            # Set a search prefix based on the cursor position.
-            col = self._get_input_buffer_cursor_column()
-            input_buffer = self.input_buffer
-            if self._history_index == len(self._history) or \
-                    (self._history_prefix and col != len(self._history_prefix)):
-                self._history_index = len(self._history)
-                self._history_prefix = input_buffer[:col]
-
-            # Perform the search.
-            self.history_previous(self._history_prefix)
-
-            # Go to the first line of the prompt for seemless history scrolling.
-            # Emulate readline: keep the cursor position fixed for a prefix
-            # search.
-            cursor = self._get_prompt_cursor()
-            if self._history_prefix:
-                cursor.movePosition(QtGui.QTextCursor.Right, 
-                                    n=len(self._history_prefix))
-            else:
-                cursor.movePosition(QtGui.QTextCursor.EndOfLine)
-            self._set_cursor(cursor)
-
-            return False
-
-        return True
-
-    def _down_pressed(self, shift_modifier):
-        """ Called when the down key is pressed. Returns whether to continue
-            processing the event.
-        """
-        end_cursor = self._get_end_cursor()
-        if self._get_cursor().blockNumber() == end_cursor.blockNumber():
-            # Bail out if we're locked.
-            if self._history_locked() and not shift_modifier:
-                return False
-
-            # Perform the search.
-            replaced = self.history_next(self._history_prefix)
-
-            # Emulate readline: keep the cursor position fixed for a prefix
-            # search. (We don't need to move the cursor to the end of the buffer
-            # in the other case because this happens automatically when the
-            # input buffer is set.)
-            if self._history_prefix and replaced:
-                cursor = self._get_prompt_cursor()
-                cursor.movePosition(QtGui.QTextCursor.Right, 
-                                    n=len(self._history_prefix))
-                self._set_cursor(cursor)
-
-            return False
-
-        return True
-
-    #---------------------------------------------------------------------------
-    # 'HistoryConsoleWidget' public interface
-    #---------------------------------------------------------------------------
-
-    def history_previous(self, prefix=''):
-        """ If possible, set the input buffer to a previous history item.
-
-        Parameters:
-        -----------
-        prefix : str, optional
-            If specified, search for an item with this prefix.
-
-        Returns:
-        --------
-        Whether the input buffer was changed.
-        """
-        index = self._history_index
-        replace = False
-        while index > 0:
-            index -= 1
-            history = self._get_edited_history(index)
-            if history.startswith(prefix):
-                replace = True
-                break
-        
-        if replace:
-            self._store_edits()
-            self._history_index = index
-            self.input_buffer = history
-
-        return replace
-
-    def history_next(self, prefix=''):
-        """ If possible, set the input buffer to a subsequent history item.
-
-        Parameters:
-        -----------
-        prefix : str, optional
-            If specified, search for an item with this prefix.
-
-        Returns:
-        --------
-        Whether the input buffer was changed.
-        """
-        index = self._history_index
-        replace = False
-        while self._history_index < len(self._history):
-            index += 1
-            history = self._get_edited_history(index)
-            if history.startswith(prefix):
-                replace = True
-                break
-            
-        if replace:
-            self._store_edits()
-            self._history_index = index
-            self.input_buffer = history
-
-        return replace
-
-    def history_tail(self, n=10):
-        """ Get the local history list.
-
-        Parameters:
-        -----------
-        n : int
-            The (maximum) number of history items to get.
-        """
-        return self._history[-n:]
-        
-    #---------------------------------------------------------------------------
-    # 'HistoryConsoleWidget' protected interface
-    #---------------------------------------------------------------------------
-
-    def _history_locked(self):
-        """ Returns whether history movement is locked.
-        """
-        return (self.history_lock and 
-                (self._get_edited_history(self._history_index) != 
-                 self.input_buffer) and
-                (self._get_prompt_cursor().blockNumber() !=
-                 self._get_end_cursor().blockNumber()))
-
-    def _get_edited_history(self, index):
-        """ Retrieves a history item, possibly with temporary edits.
-        """
-        if index in self._history_edits:
-            return self._history_edits[index]
-        elif index == len(self._history):
-            return unicode()
-        return self._history[index]
-
-    def _set_history(self, history):
-        """ Replace the current history with a sequence of history items.
-        """
-        self._history = list(history)
-        self._history_edits = {}
-        self._history_index = len(self._history)
-
-    def _store_edits(self):
-        """ If there are edits to the current input buffer, store them.
-        """
-        current = self.input_buffer
-        if self._history_index == len(self._history) or \
-                self._history[self._history_index] != current:
-            self._history_edits[self._history_index] = current
diff --git a/IPython/frontend/qt/console/ipython_widget.py b/IPython/frontend/qt/console/ipython_widget.py
deleted file mode 100644
index 291aaafcfbe..00000000000
--- a/IPython/frontend/qt/console/ipython_widget.py
+++ /dev/null
@@ -1,496 +0,0 @@
-""" A FrontendWidget that emulates the interface of the console IPython and
-    supports the additional functionality provided by the IPython kernel.
-"""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports
-from collections import namedtuple
-import os.path
-import re
-from subprocess import Popen
-import sys
-from textwrap import dedent
-
-# System library imports
-from IPython.external.qt import QtCore, QtGui
-
-# Local imports
-from IPython.core.inputsplitter import IPythonInputSplitter, \
-    transform_ipy_prompt
-from IPython.core.usage import default_gui_banner
-from IPython.utils.traitlets import Bool, Str, Unicode
-from frontend_widget import FrontendWidget
-from styles import (default_light_style_sheet,  default_light_syntax_style,
-                    default_dark_style_sheet, default_dark_syntax_style,
-                    default_bw_style_sheet, default_bw_syntax_style)
-
-#-----------------------------------------------------------------------------
-# Constants
-#-----------------------------------------------------------------------------
-
-# Default strings to build and display input and output prompts (and separators
-# in between)
-default_in_prompt = 'In [<span class="in-prompt-number">%i</span>]: '
-default_out_prompt = 'Out[<span class="out-prompt-number">%i</span>]: '
-default_input_sep = '\n'
-default_output_sep = ''
-default_output_sep2 = ''
-
-# Base path for most payload sources.
-zmq_shell_source = 'IPython.zmq.zmqshell.ZMQInteractiveShell'
-
-#-----------------------------------------------------------------------------
-# IPythonWidget class
-#-----------------------------------------------------------------------------
-
-class IPythonWidget(FrontendWidget):
-    """ A FrontendWidget for an IPython kernel.
-    """
-
-    # If set, the 'custom_edit_requested(str, int)' signal will be emitted when
-    # an editor is needed for a file. This overrides 'editor' and 'editor_line'
-    # settings.
-    custom_edit = Bool(False)
-    custom_edit_requested = QtCore.Signal(object, object)
-
-    # A command for invoking a system text editor. If the string contains a
-    # {filename} format specifier, it will be used. Otherwise, the filename will
-    # be appended to the end the command.
-    editor = Unicode('default', config=True)
-
-    # The editor command to use when a specific line number is requested. The
-    # string should contain two format specifiers: {line} and {filename}. If
-    # this parameter is not specified, the line number option to the %edit magic
-    # will be ignored.
-    editor_line = Unicode(config=True)
-
-    # A CSS stylesheet. The stylesheet can contain classes for:
-    #     1. Qt: QPlainTextEdit, QFrame, QWidget, etc
-    #     2. Pygments: .c, .k, .o, etc (see PygmentsHighlighter)
-    #     3. IPython: .error, .in-prompt, .out-prompt, etc
-    style_sheet = Unicode(config=True)
-    
-    # If not empty, use this Pygments style for syntax highlighting. Otherwise,
-    # the style sheet is queried for Pygments style information.
-    syntax_style = Str(config=True)
-
-    # Prompts.
-    in_prompt = Str(default_in_prompt, config=True)
-    out_prompt = Str(default_out_prompt, config=True)
-    input_sep = Str(default_input_sep, config=True)
-    output_sep = Str(default_output_sep, config=True)
-    output_sep2 = Str(default_output_sep2, config=True)
-
-    # FrontendWidget protected class variables.
-    _input_splitter_class = IPythonInputSplitter
-
-    # IPythonWidget protected class variables.
-    _PromptBlock = namedtuple('_PromptBlock', ['block', 'length', 'number'])
-    _payload_source_edit = zmq_shell_source + '.edit_magic'
-    _payload_source_exit = zmq_shell_source + '.ask_exit'
-    _payload_source_loadpy = zmq_shell_source + '.magic_loadpy'
-    _payload_source_page = 'IPython.zmq.page.page'
-
-    #---------------------------------------------------------------------------
-    # 'object' interface
-    #---------------------------------------------------------------------------
-    
-    def __init__(self, *args, **kw):
-        super(IPythonWidget, self).__init__(*args, **kw)
-
-        # IPythonWidget protected variables.
-        self._code_to_load = None
-        self._payload_handlers = { 
-            self._payload_source_edit : self._handle_payload_edit,
-            self._payload_source_exit : self._handle_payload_exit,
-            self._payload_source_page : self._handle_payload_page,
-            self._payload_source_loadpy : self._handle_payload_loadpy }
-        self._previous_prompt_obj = None
-        self._keep_kernel_on_exit = None
-
-        # Initialize widget styling.
-        if self.style_sheet:
-            self._style_sheet_changed()
-            self._syntax_style_changed()
-        else:
-            self.set_default_style()
-
-    #---------------------------------------------------------------------------
-    # 'BaseFrontendMixin' abstract interface
-    #---------------------------------------------------------------------------
-
-    def _handle_complete_reply(self, rep):
-        """ Reimplemented to support IPython's improved completion machinery.
-        """
-        cursor = self._get_cursor()
-        info = self._request_info.get('complete')
-        if info and info.id == rep['parent_header']['msg_id'] and \
-                info.pos == cursor.position():
-            matches = rep['content']['matches']
-            text = rep['content']['matched_text']
-            offset = len(text)
-
-            # Clean up matches with period and path separators if the matched
-            # text has not been transformed. This is done by truncating all
-            # but the last component and then suitably decreasing the offset
-            # between the current cursor position and the start of completion.
-            if len(matches) > 1 and matches[0][:offset] == text:
-                parts = re.split(r'[./\\]', text) 
-                sep_count = len(parts) - 1
-                if sep_count:
-                    chop_length = sum(map(len, parts[:sep_count])) + sep_count
-                    matches = [ match[chop_length:] for match in matches ]
-                    offset -= chop_length
-
-            # Move the cursor to the start of the match and complete.
-            cursor.movePosition(QtGui.QTextCursor.Left, n=offset)
-            self._complete_with_items(cursor, matches)
-
-    def _handle_execute_reply(self, msg):
-        """ Reimplemented to support prompt requests.
-        """
-        info = self._request_info.get('execute')
-        if info and info.id == msg['parent_header']['msg_id']:
-            if info.kind == 'prompt':
-                number = msg['content']['execution_count'] + 1
-                self._show_interpreter_prompt(number)
-            else:
-                super(IPythonWidget, self)._handle_execute_reply(msg)
-
-    def _handle_history_tail_reply(self, msg):
-        """ Implemented to handle history tail replies, which are only supported
-            by the IPython kernel.
-        """
-        history_items = msg['content']['history']
-        items = [ line.rstrip() for _, _, line in history_items ]
-        self._set_history(items)
-
-    def _handle_pyout(self, msg):
-        """ Reimplemented for IPython-style "display hook".
-        """
-        if not self._hidden and self._is_from_this_session(msg):
-            content = msg['content']
-            prompt_number = content['execution_count']
-            data = content['data']
-            if data.has_key('text/html'):
-                self._append_plain_text(self.output_sep)
-                self._append_html(self._make_out_prompt(prompt_number))
-                html = data['text/html']
-                self._append_plain_text('\n')
-                self._append_html(html + self.output_sep2)
-            elif data.has_key('text/plain'):
-                self._append_plain_text(self.output_sep)
-                self._append_html(self._make_out_prompt(prompt_number))
-                text = data['text/plain']
-                self._append_plain_text(text + self.output_sep2)
-
-    def _handle_display_data(self, msg):
-        """ The base handler for the ``display_data`` message.
-        """
-        # For now, we don't display data from other frontends, but we 
-        # eventually will as this allows all frontends to monitor the display
-        # data. But we need to figure out how to handle this in the GUI.
-        if not self._hidden and self._is_from_this_session(msg):
-            source = msg['content']['source']
-            data = msg['content']['data']
-            metadata = msg['content']['metadata']
-            # In the regular IPythonWidget, we simply print the plain text
-            # representation.
-            if data.has_key('text/html'):
-                html = data['text/html']
-                self._append_html(html)
-            elif data.has_key('text/plain'):
-                text = data['text/plain']
-                self._append_plain_text(text)
-            # This newline seems to be needed for text and html output.
-            self._append_plain_text(u'\n')
-
-    def _started_channels(self):
-        """ Reimplemented to make a history request.
-        """
-        super(IPythonWidget, self)._started_channels()
-        self.kernel_manager.xreq_channel.history_tail(1000)
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' public interface
-    #---------------------------------------------------------------------------
-
-    def copy(self):
-        """ Copy the currently selected text to the clipboard, removing prompts
-            if possible.
-        """
-        text = self._control.textCursor().selection().toPlainText()
-        if text:
-            lines = map(transform_ipy_prompt, text.splitlines())
-            text = '\n'.join(lines)
-            QtGui.QApplication.clipboard().setText(text)
-
-    #---------------------------------------------------------------------------
-    # 'FrontendWidget' public interface
-    #---------------------------------------------------------------------------
-
-    def execute_file(self, path, hidden=False):
-        """ Reimplemented to use the 'run' magic.
-        """
-        # Use forward slashes on Windows to avoid escaping each separator.
-        if sys.platform == 'win32':
-            path = os.path.normpath(path).replace('\\', '/')
-
-        self.execute('%%run %s' % path, hidden=hidden)
-
-    #---------------------------------------------------------------------------
-    # 'FrontendWidget' protected interface
-    #---------------------------------------------------------------------------
-
-    def _complete(self):
-        """ Reimplemented to support IPython's improved completion machinery.
-        """
-        # We let the kernel split the input line, so we *always* send an empty
-        # text field. Readline-based frontends do get a real text field which
-        # they can use.
-        text = ''
-        
-        # Send the completion request to the kernel
-        msg_id = self.kernel_manager.xreq_channel.complete(
-            text,                                    # text
-            self._get_input_buffer_cursor_line(),    # line
-            self._get_input_buffer_cursor_column(),  # cursor_pos
-            self.input_buffer)                       # block 
-        pos = self._get_cursor().position()
-        info = self._CompletionRequest(msg_id, pos)
-        self._request_info['complete'] = info
-
-    def _get_banner(self):
-        """ Reimplemented to return IPython's default banner.
-        """
-        return default_gui_banner
-
-    def _process_execute_error(self, msg):
-        """ Reimplemented for IPython-style traceback formatting.
-        """
-        content = msg['content']
-        traceback = '\n'.join(content['traceback']) + '\n'
-        if False:
-            # FIXME: For now, tracebacks come as plain text, so we can't use
-            # the html renderer yet.  Once we refactor ultratb to produce
-            # properly styled tracebacks, this branch should be the default
-            traceback = traceback.replace(' ', '&nbsp;')
-            traceback = traceback.replace('\n', '<br/>')
-
-            ename = content['ename']
-            ename_styled = '<span class="error">%s</span>' % ename
-            traceback = traceback.replace(ename, ename_styled)
-
-            self._append_html(traceback)
-        else:
-            # This is the fallback for now, using plain text with ansi escapes
-            self._append_plain_text(traceback)    
-
-    def _process_execute_payload(self, item):
-        """ Reimplemented to dispatch payloads to handler methods.
-        """
-        handler = self._payload_handlers.get(item['source'])
-        if handler is None:
-            # We have no handler for this type of payload, simply ignore it
-            return False
-        else:
-            handler(item)
-            return True
-        
-    def _show_interpreter_prompt(self, number=None):
-        """ Reimplemented for IPython-style prompts.
-        """
-        # If a number was not specified, make a prompt number request.
-        if number is None:
-            msg_id = self.kernel_manager.xreq_channel.execute('', silent=True)
-            info = self._ExecutionRequest(msg_id, 'prompt')
-            self._request_info['execute'] = info
-            return
-
-        # Show a new prompt and save information about it so that it can be
-        # updated later if the prompt number turns out to be wrong.
-        self._prompt_sep = self.input_sep
-        self._show_prompt(self._make_in_prompt(number), html=True)
-        block = self._control.document().lastBlock()
-        length = len(self._prompt)
-        self._previous_prompt_obj = self._PromptBlock(block, length, number)
-
-        # Update continuation prompt to reflect (possibly) new prompt length.
-        self._set_continuation_prompt(
-            self._make_continuation_prompt(self._prompt), html=True)
-
-        # Load code from the %loadpy magic, if necessary.
-        if self._code_to_load is not None:
-            self.input_buffer = dedent(self._code_to_load.rstrip())
-            self._code_to_load = None
-
-    def _show_interpreter_prompt_for_reply(self, msg):
-        """ Reimplemented for IPython-style prompts.
-        """
-        # Update the old prompt number if necessary.
-        content = msg['content']
-        previous_prompt_number = content['execution_count']
-        if self._previous_prompt_obj and \
-                self._previous_prompt_obj.number != previous_prompt_number:
-            block = self._previous_prompt_obj.block
-
-            # Make sure the prompt block has not been erased.
-            if block.isValid() and block.text():
-
-                # Remove the old prompt and insert a new prompt.
-                cursor = QtGui.QTextCursor(block)
-                cursor.movePosition(QtGui.QTextCursor.Right,
-                                    QtGui.QTextCursor.KeepAnchor, 
-                                    self._previous_prompt_obj.length)
-                prompt = self._make_in_prompt(previous_prompt_number)
-                self._prompt = self._insert_html_fetching_plain_text(
-                    cursor, prompt)
-
-                # When the HTML is inserted, Qt blows away the syntax
-                # highlighting for the line, so we need to rehighlight it.
-                self._highlighter.rehighlightBlock(cursor.block())
-
-            self._previous_prompt_obj = None
-
-        # Show a new prompt with the kernel's estimated prompt number.
-        self._show_interpreter_prompt(previous_prompt_number + 1)
-
-    #---------------------------------------------------------------------------
-    # 'IPythonWidget' interface
-    #---------------------------------------------------------------------------
-
-    def set_default_style(self, colors='lightbg'):
-        """ Sets the widget style to the class defaults.
-
-        Parameters:
-        -----------
-        colors : str, optional (default lightbg)
-            Whether to use the default IPython light background or dark
-            background or B&W style.
-        """
-        colors = colors.lower()
-        if colors=='lightbg':
-            self.style_sheet = default_light_style_sheet
-            self.syntax_style = default_light_syntax_style
-        elif colors=='linux':
-            self.style_sheet = default_dark_style_sheet
-            self.syntax_style = default_dark_syntax_style
-        elif colors=='nocolor':
-            self.style_sheet = default_bw_style_sheet
-            self.syntax_style = default_bw_syntax_style
-        else:
-            raise KeyError("No such color scheme: %s"%colors)
-
-    #---------------------------------------------------------------------------
-    # 'IPythonWidget' protected interface
-    #---------------------------------------------------------------------------
-
-    def _edit(self, filename, line=None):
-        """ Opens a Python script for editing.
-
-        Parameters:
-        -----------
-        filename : str
-            A path to a local system file.
-
-        line : int, optional
-            A line of interest in the file.
-        """
-        if self.custom_edit:
-            self.custom_edit_requested.emit(filename, line)
-        elif self.editor == 'default':
-            self._append_plain_text('No default editor available.\n')
-        else:
-            try:
-                filename = '"%s"' % filename
-                if line and self.editor_line:
-                    command = self.editor_line.format(filename=filename,
-                                                      line=line)
-                else:
-                    try:
-                        command = self.editor.format()
-                    except KeyError:
-                        command = self.editor.format(filename=filename)
-                    else:
-                        command += ' ' + filename
-            except KeyError:
-                self._append_plain_text('Invalid editor command.\n')
-            else:
-                try:
-                    Popen(command, shell=True)
-                except OSError:
-                    msg = 'Opening editor with command "%s" failed.\n'
-                    self._append_plain_text(msg % command)
-
-    def _make_in_prompt(self, number):
-        """ Given a prompt number, returns an HTML In prompt.
-        """
-        body = self.in_prompt % number
-        return '<span class="in-prompt">%s</span>' % body
-
-    def _make_continuation_prompt(self, prompt):
-        """ Given a plain text version of an In prompt, returns an HTML
-            continuation prompt.
-        """
-        end_chars = '...: '
-        space_count = len(prompt.lstrip('\n')) - len(end_chars)
-        body = '&nbsp;' * space_count + end_chars
-        return '<span class="in-prompt">%s</span>' % body
-        
-    def _make_out_prompt(self, number):
-        """ Given a prompt number, returns an HTML Out prompt.
-        """
-        body = self.out_prompt % number
-        return '<span class="out-prompt">%s</span>' % body
-
-    #------ Payload handlers --------------------------------------------------
-
-    # Payload handlers with a generic interface: each takes the opaque payload
-    # dict, unpacks it and calls the underlying functions with the necessary
-    # arguments.
-
-    def _handle_payload_edit(self, item):
-        self._edit(item['filename'], item['line_number'])
-
-    def _handle_payload_exit(self, item):
-        self._keep_kernel_on_exit = item['keepkernel']
-        self.exit_requested.emit()
-
-    def _handle_payload_loadpy(self, item):
-        # Simple save the text of the .py file for later. The text is written
-        # to the buffer when _prompt_started_hook is called.
-        self._code_to_load = item['text']
-
-    def _handle_payload_page(self, item):
-        # Since the plain text widget supports only a very small subset of HTML
-        # and we have no control over the HTML source, we only page HTML
-        # payloads in the rich text widget.
-        if item['html'] and self.kind == 'rich':
-            self._page(item['html'], html=True)
-        else:
-            self._page(item['text'], html=False)
-
-    #------ Trait change handlers --------------------------------------------
-
-    def _style_sheet_changed(self):
-        """ Set the style sheets of the underlying widgets.
-        """
-        self.setStyleSheet(self.style_sheet)
-        self._control.document().setDefaultStyleSheet(self.style_sheet)
-        if self._page_control:
-            self._page_control.document().setDefaultStyleSheet(self.style_sheet)
-
-        bg_color = self._control.palette().window().color()
-        self._ansi_processor.set_background_color(bg_color)
-
-    def _syntax_style_changed(self):
-        """ Set the style for the syntax highlighter.
-        """
-        if self.syntax_style:
-            self._highlighter.set_style(self.syntax_style)
-        else:
-            self._highlighter.set_style_sheet(self.style_sheet)
-
diff --git a/IPython/frontend/qt/console/ipythonqt.py b/IPython/frontend/qt/console/ipythonqt.py
deleted file mode 100644
index 3607b9a85ea..00000000000
--- a/IPython/frontend/qt/console/ipythonqt.py
+++ /dev/null
@@ -1,277 +0,0 @@
-""" A minimal application using the Qt console-style IPython frontend.
-"""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Systemm library imports
-from IPython.external.qt import QtGui
-from pygments.styles import get_all_styles
-
-# Local imports
-from IPython.external.argparse import ArgumentParser
-from IPython.frontend.qt.console.frontend_widget import FrontendWidget
-from IPython.frontend.qt.console.ipython_widget import IPythonWidget
-from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
-from IPython.frontend.qt.console import styles
-from IPython.frontend.qt.kernelmanager import QtKernelManager
-
-#-----------------------------------------------------------------------------
-# Network Constants
-#-----------------------------------------------------------------------------
-
-from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-class MainWindow(QtGui.QMainWindow):
-
-    #---------------------------------------------------------------------------
-    # 'object' interface
-    #---------------------------------------------------------------------------
-    
-    def __init__(self, app, frontend, existing=False, may_close=True):
-        """ Create a MainWindow for the specified FrontendWidget.
-        
-        The app is passed as an argument to allow for different
-        closing behavior depending on whether we are the Kernel's parent.
-        
-        If existing is True, then this Console does not own the Kernel.
-        
-        If may_close is True, then this Console is permitted to close the kernel
-        """
-        super(MainWindow, self).__init__()
-        self._app = app
-        self._frontend = frontend
-        self._existing = existing
-        if existing:
-            self._may_close = may_close
-        else:
-            self._may_close = True
-        self._frontend.exit_requested.connect(self.close)
-        self.setCentralWidget(frontend)
-    
-    #---------------------------------------------------------------------------
-    # QWidget interface
-    #---------------------------------------------------------------------------
-    
-    def closeEvent(self, event):
-        """ Close the window and the kernel (if necessary).
-        
-        This will prompt the user if they are finished with the kernel, and if
-        so, closes the kernel cleanly. Alternatively, if the exit magic is used,
-        it closes without prompt.
-        """
-        keepkernel = None #Use the prompt by default
-        if hasattr(self._frontend,'_keep_kernel_on_exit'): #set by exit magic
-            keepkernel = self._frontend._keep_kernel_on_exit
-        
-        kernel_manager = self._frontend.kernel_manager
-        
-        if keepkernel is None: #show prompt
-            if kernel_manager and kernel_manager.channels_running:
-                title = self.window().windowTitle()
-                cancel = QtGui.QMessageBox.Cancel
-                okay = QtGui.QMessageBox.Ok
-                if self._may_close:
-                    msg = "You are closing this Console window."
-                    info = "Would you like to quit the Kernel and all attached Consoles as well?"
-                    justthis = QtGui.QPushButton("&No, just this Console", self)
-                    justthis.setShortcut('N')
-                    closeall = QtGui.QPushButton("&Yes, quit everything", self)
-                    closeall.setShortcut('Y')
-                    box = QtGui.QMessageBox(QtGui.QMessageBox.Question,
-                                            title, msg)
-                    box.setInformativeText(info)
-                    box.addButton(cancel)
-                    box.addButton(justthis, QtGui.QMessageBox.NoRole)
-                    box.addButton(closeall, QtGui.QMessageBox.YesRole)
-                    box.setDefaultButton(closeall)
-                    box.setEscapeButton(cancel)
-                    reply = box.exec_()
-                    if reply == 1: # close All
-                        kernel_manager.shutdown_kernel()
-                        #kernel_manager.stop_channels()
-                        event.accept()
-                    elif reply == 0: # close Console
-                        if not self._existing:
-                            # Have kernel: don't quit, just close the window
-                            self._app.setQuitOnLastWindowClosed(False)
-                            self.deleteLater()
-                        event.accept()
-                    else:
-                        event.ignore()
-                else:
-                    reply = QtGui.QMessageBox.question(self, title,
-                        "Are you sure you want to close this Console?"+
-                        "\nThe Kernel and other Consoles will remain active.",
-                        okay|cancel,
-                        defaultButton=okay
-                        )
-                    if reply == okay:
-                        event.accept()
-                    else:
-                        event.ignore()
-        elif keepkernel: #close console but leave kernel running (no prompt)
-            if kernel_manager and kernel_manager.channels_running:
-                if not self._existing:
-                    # I have the kernel: don't quit, just close the window
-                    self._app.setQuitOnLastWindowClosed(False)
-                event.accept()
-        else: #close console and kernel (no prompt)
-            if kernel_manager and kernel_manager.channels_running:
-                kernel_manager.shutdown_kernel()
-                event.accept()
-
-#-----------------------------------------------------------------------------
-# Main entry point
-#-----------------------------------------------------------------------------
-
-def main():
-    """ Entry point for application.
-    """
-    # Parse command line arguments.
-    parser = ArgumentParser()
-    kgroup = parser.add_argument_group('kernel options')
-    kgroup.add_argument('-e', '--existing', action='store_true',
-                        help='connect to an existing kernel')
-    kgroup.add_argument('--ip', type=str, default=LOCALHOST,
-                        help=\
-            "set the kernel\'s IP address [default localhost].\
-            If the IP address is something other than localhost, then \
-            Consoles on other machines will be able to connect\
-            to the Kernel, so be careful!")
-    kgroup.add_argument('--xreq', type=int, metavar='PORT', default=0,
-                        help='set the XREQ channel port [default random]')
-    kgroup.add_argument('--sub', type=int, metavar='PORT', default=0,
-                        help='set the SUB channel port [default random]')
-    kgroup.add_argument('--rep', type=int, metavar='PORT', default=0,
-                        help='set the REP channel port [default random]')
-    kgroup.add_argument('--hb', type=int, metavar='PORT', default=0,
-                        help='set the heartbeat port [default random]')
-
-    egroup = kgroup.add_mutually_exclusive_group()
-    egroup.add_argument('--pure', action='store_true', help = \
-                        'use a pure Python kernel instead of an IPython kernel')
-    egroup.add_argument('--pylab', type=str, metavar='GUI', nargs='?', 
-                       const='auto', help = \
-        "Pre-load matplotlib and numpy for interactive use. If GUI is not \
-         given, the GUI backend is matplotlib's, otherwise use one of: \
-         ['tk', 'gtk', 'qt', 'wx', 'inline'].")
-
-    wgroup = parser.add_argument_group('widget options')
-    wgroup.add_argument('--paging', type=str, default='inside',
-                        choices = ['inside', 'hsplit', 'vsplit', 'none'],
-                        help='set the paging style [default inside]')
-    wgroup.add_argument('--plain', action='store_true',
-                        help='disable rich text support')
-    wgroup.add_argument('--gui-completion', action='store_true',
-                        help='use a GUI widget for tab completion')
-    wgroup.add_argument('--style', type=str,
-                        choices = list(get_all_styles()),
-                        help='specify a pygments style for by name')
-    wgroup.add_argument('--stylesheet', type=str,
-                        help='path to a custom CSS stylesheet')
-    wgroup.add_argument('--colors', type=str, help = \
-        "Set the color scheme (LightBG,Linux,NoColor). This is guessed \
-         based on the pygments style if not set.")
-
-    args = parser.parse_args()
-
-    # parse the colors arg down to current known labels
-    if args.colors:
-        colors=args.colors.lower()
-        if colors in ('lightbg', 'light'):
-            colors='lightbg'
-        elif colors in ('dark', 'linux'):
-            colors='linux'
-        else:
-            colors='nocolor'
-    elif args.style:
-        if args.style=='bw':
-            colors='nocolor'
-        elif styles.dark_style(args.style):
-            colors='linux'
-        else:
-            colors='lightbg'
-    else:
-        colors=None
-
-    # Don't let Qt or ZMQ swallow KeyboardInterupts.
-    import signal
-    signal.signal(signal.SIGINT, signal.SIG_DFL)
-
-    # Create a KernelManager and start a kernel.
-    kernel_manager = QtKernelManager(xreq_address=(args.ip, args.xreq),
-                                     sub_address=(args.ip, args.sub),
-                                     rep_address=(args.ip, args.rep),
-                                     hb_address=(args.ip, args.hb))
-    if not args.existing:
-        # if not args.ip in LOCAL_IPS+ALL_ALIAS:
-        #     raise ValueError("Must bind a local ip, such as: %s"%LOCAL_IPS)
-
-        kwargs = dict(ip=args.ip)
-        if args.pure:
-            kwargs['ipython']=False
-        else:
-            kwargs['colors']=colors
-            if args.pylab:
-                kwargs['pylab']=args.pylab
-
-        kernel_manager.start_kernel(**kwargs)
-    kernel_manager.start_channels()
-
-    # Create the widget.
-    app = QtGui.QApplication([])
-    local_kernel = (not args.existing) or args.ip in LOCAL_IPS
-    if args.pure:
-        kind = 'plain' if args.plain else 'rich'
-        widget = FrontendWidget(kind=kind, paging=args.paging, 
-                                local_kernel=local_kernel)
-    elif args.plain:
-        widget = IPythonWidget(paging=args.paging, local_kernel=local_kernel)
-    else:
-        widget = RichIPythonWidget(paging=args.paging, 
-                                   local_kernel=local_kernel)
-    widget.gui_completion = args.gui_completion
-    widget.kernel_manager = kernel_manager
-
-    # Configure the style.
-    if not args.pure: # only IPythonWidget supports styles
-        if args.style:
-            widget.syntax_style = args.style
-            widget.style_sheet = styles.sheet_from_template(args.style, colors)
-            widget._syntax_style_changed()
-            widget._style_sheet_changed()
-        elif colors:
-            # use a default style
-            widget.set_default_style(colors=colors)
-        else:
-            # this is redundant for now, but allows the widget's
-            # defaults to change
-            widget.set_default_style()
-
-        if args.stylesheet:
-            # we got an expicit stylesheet
-            if os.path.isfile(args.stylesheet):
-                with open(args.stylesheet) as f:
-                    sheet = f.read()
-                widget.style_sheet = sheet
-                widget._style_sheet_changed()
-            else:
-                raise IOError("Stylesheet %r not found."%args.stylesheet)
-
-    # Create the main window.
-    window = MainWindow(app, widget, args.existing, may_close=local_kernel)
-    window.setWindowTitle('Python' if args.pure else 'IPython')
-    window.show()
-
-    # Start the application main loop.
-    app.exec_()
-
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/frontend/qt/console/pygments_highlighter.py b/IPython/frontend/qt/console/pygments_highlighter.py
deleted file mode 100644
index 02551de7238..00000000000
--- a/IPython/frontend/qt/console/pygments_highlighter.py
+++ /dev/null
@@ -1,224 +0,0 @@
-# System library imports.
-from IPython.external.qt import QtGui
-from pygments.formatters.html import HtmlFormatter
-from pygments.lexer import RegexLexer, _TokenType, Text, Error
-from pygments.lexers import PythonLexer
-from pygments.styles import get_style_by_name
-
-
-def get_tokens_unprocessed(self, text, stack=('root',)):
-    """ Split ``text`` into (tokentype, text) pairs.
-
-        Monkeypatched to store the final stack on the object itself.
-    """
-    pos = 0
-    tokendefs = self._tokens
-    if hasattr(self, '_saved_state_stack'):
-        statestack = list(self._saved_state_stack)
-    else:
-        statestack = list(stack)
-    statetokens = tokendefs[statestack[-1]]
-    while 1:
-        for rexmatch, action, new_state in statetokens:
-            m = rexmatch(text, pos)
-            if m:
-                if type(action) is _TokenType:
-                    yield pos, action, m.group()
-                else:
-                    for item in action(self, m):
-                        yield item
-                pos = m.end()
-                if new_state is not None:
-                    # state transition
-                    if isinstance(new_state, tuple):
-                        for state in new_state:
-                            if state == '#pop':
-                                statestack.pop()
-                            elif state == '#push':
-                                statestack.append(statestack[-1])
-                            else:
-                                statestack.append(state)
-                    elif isinstance(new_state, int):
-                        # pop
-                        del statestack[new_state:]
-                    elif new_state == '#push':
-                        statestack.append(statestack[-1])
-                    else:
-                        assert False, "wrong state def: %r" % new_state
-                    statetokens = tokendefs[statestack[-1]]
-                break
-        else:
-            try:
-                if text[pos] == '\n':
-                    # at EOL, reset state to "root"
-                    pos += 1
-                    statestack = ['root']
-                    statetokens = tokendefs['root']
-                    yield pos, Text, u'\n'
-                    continue
-                yield pos, Error, text[pos]
-                pos += 1
-            except IndexError:
-                break
-    self._saved_state_stack = list(statestack)
-
-# Monkeypatch!
-RegexLexer.get_tokens_unprocessed = get_tokens_unprocessed
-
-
-class PygmentsBlockUserData(QtGui.QTextBlockUserData):
-    """ Storage for the user data associated with each line.
-    """
-
-    syntax_stack = ('root',)
-
-    def __init__(self, **kwds):
-        for key, value in kwds.iteritems():
-            setattr(self, key, value)
-        QtGui.QTextBlockUserData.__init__(self)
-
-    def __repr__(self):
-        attrs = ['syntax_stack']
-        kwds = ', '.join([ '%s=%r' % (attr, getattr(self, attr)) 
-                           for attr in attrs ])
-        return 'PygmentsBlockUserData(%s)' % kwds
-
-
-class PygmentsHighlighter(QtGui.QSyntaxHighlighter):
-    """ Syntax highlighter that uses Pygments for parsing. """
-
-    #---------------------------------------------------------------------------
-    # 'QSyntaxHighlighter' interface
-    #---------------------------------------------------------------------------
-
-    def __init__(self, parent, lexer=None):
-        super(PygmentsHighlighter, self).__init__(parent)
-
-        self._document = QtGui.QTextDocument()
-        self._formatter = HtmlFormatter(nowrap=True)
-        self._lexer = lexer if lexer else PythonLexer()
-        self.set_style('default')
-
-    def highlightBlock(self, string):
-        """ Highlight a block of text.
-        """
-        prev_data = self.currentBlock().previous().userData()
-        if prev_data is not None:
-            self._lexer._saved_state_stack = prev_data.syntax_stack
-        elif hasattr(self._lexer, '_saved_state_stack'):
-            del self._lexer._saved_state_stack
-
-        # Lex the text using Pygments
-        index = 0
-        for token, text in self._lexer.get_tokens(string):
-            length = len(text)
-            self.setFormat(index, length, self._get_format(token))
-            index += length
-
-        if hasattr(self._lexer, '_saved_state_stack'):
-            data = PygmentsBlockUserData(
-                syntax_stack=self._lexer._saved_state_stack)
-            self.currentBlock().setUserData(data)
-            # Clean up for the next go-round.
-            del self._lexer._saved_state_stack
-
-    #---------------------------------------------------------------------------
-    # 'PygmentsHighlighter' interface
-    #---------------------------------------------------------------------------
-
-    def set_style(self, style):
-        """ Sets the style to the specified Pygments style.
-        """
-        if isinstance(style, basestring):
-            style = get_style_by_name(style)
-        self._style = style
-        self._clear_caches()
-
-    def set_style_sheet(self, stylesheet):
-        """ Sets a CSS stylesheet. The classes in the stylesheet should
-        correspond to those generated by:
-
-            pygmentize -S <style> -f html
-
-        Note that 'set_style' and 'set_style_sheet' completely override each
-        other, i.e. they cannot be used in conjunction.
-        """
-        self._document.setDefaultStyleSheet(stylesheet)
-        self._style = None
-        self._clear_caches()
-
-    #---------------------------------------------------------------------------
-    # Protected interface
-    #---------------------------------------------------------------------------
-
-    def _clear_caches(self):
-        """ Clear caches for brushes and formats.
-        """
-        self._brushes = {}
-        self._formats = {}
-
-    def _get_format(self, token):
-        """ Returns a QTextCharFormat for token or None.
-        """
-        if token in self._formats:
-            return self._formats[token]
-
-        if self._style is None:
-            result = self._get_format_from_document(token, self._document)
-        else:
-            result = self._get_format_from_style(token, self._style)
-
-        self._formats[token] = result
-        return result
-
-    def _get_format_from_document(self, token, document):
-        """ Returns a QTextCharFormat for token by 
-        """
-        code, html = self._formatter._format_lines([(token, 'dummy')]).next()
-        self._document.setHtml(html)
-        return QtGui.QTextCursor(self._document).charFormat()
-
-    def _get_format_from_style(self, token, style):
-        """ Returns a QTextCharFormat for token by reading a Pygments style.
-        """
-        result = QtGui.QTextCharFormat()
-        for key, value in style.style_for_token(token).items():
-            if value:
-                if key == 'color':
-                    result.setForeground(self._get_brush(value))
-                elif key == 'bgcolor':
-                    result.setBackground(self._get_brush(value))
-                elif key == 'bold':
-                    result.setFontWeight(QtGui.QFont.Bold)
-                elif key == 'italic':
-                    result.setFontItalic(True)
-                elif key == 'underline':
-                    result.setUnderlineStyle(
-                        QtGui.QTextCharFormat.SingleUnderline)
-                elif key == 'sans':
-                    result.setFontStyleHint(QtGui.QFont.SansSerif)
-                elif key == 'roman':
-                    result.setFontStyleHint(QtGui.QFont.Times)
-                elif key == 'mono':
-                    result.setFontStyleHint(QtGui.QFont.TypeWriter)
-        return result
-
-    def _get_brush(self, color):
-        """ Returns a brush for the color.
-        """
-        result = self._brushes.get(color)
-        if result is None:
-            qcolor = self._get_color(color)
-            result = QtGui.QBrush(qcolor)
-            self._brushes[color] = result
-        return result
-
-    def _get_color(self, color):
-        """ Returns a QColor built from a Pygments color string.
-        """
-        qcolor = QtGui.QColor()
-        qcolor.setRgb(int(color[:2], base=16),
-                      int(color[2:4], base=16),
-                      int(color[4:6], base=16))
-        return qcolor
-
diff --git a/IPython/frontend/qt/console/rich_ipython_widget.py b/IPython/frontend/qt/console/rich_ipython_widget.py
deleted file mode 100644
index d416b626b88..00000000000
--- a/IPython/frontend/qt/console/rich_ipython_widget.py
+++ /dev/null
@@ -1,249 +0,0 @@
-# Standard libary imports.
-from base64 import decodestring
-import os
-import re
-
-# System libary imports.
-from IPython.external.qt import QtCore, QtGui
-
-# Local imports
-from IPython.frontend.qt.svg import save_svg, svg_to_clipboard, svg_to_image
-from ipython_widget import IPythonWidget
-
-
-class RichIPythonWidget(IPythonWidget):
-    """ An IPythonWidget that supports rich text, including lists, images, and
-        tables. Note that raw performance will be reduced compared to the plain
-        text version.
-    """
-
-    # RichIPythonWidget protected class variables.
-    _payload_source_plot = 'IPython.zmq.pylab.backend_payload.add_plot_payload'
-
-    #---------------------------------------------------------------------------
-    # 'object' interface
-    #---------------------------------------------------------------------------
-
-    def __init__(self, *args, **kw):
-        """ Create a RichIPythonWidget.
-        """
-        kw['kind'] = 'rich'
-        super(RichIPythonWidget, self).__init__(*args, **kw)
-
-        # Configure the ConsoleWidget HTML exporter for our formats.
-        self._html_exporter.image_tag = self._get_image_tag
-
-        # Dictionary for resolving document resource names to SVG data.
-        self._name_to_svg_map = {}
-
-    #---------------------------------------------------------------------------
-    # 'ConsoleWidget' protected interface
-    #---------------------------------------------------------------------------
-
-    def _context_menu_make(self, pos):
-        """ Reimplemented to return a custom context menu for images.
-        """
-        format = self._control.cursorForPosition(pos).charFormat()
-        name = format.stringProperty(QtGui.QTextFormat.ImageName)
-        if name:
-            menu = QtGui.QMenu()
-
-            menu.addAction('Copy Image', lambda: self._copy_image(name))
-            menu.addAction('Save Image As...', lambda: self._save_image(name))
-            menu.addSeparator()
-
-            svg = self._name_to_svg_map.get(name, None)
-            if svg is not None:
-                menu.addSeparator()
-                menu.addAction('Copy SVG', lambda: svg_to_clipboard(svg))
-                menu.addAction('Save SVG As...', 
-                               lambda: save_svg(svg, self._control))
-        else:
-            menu = super(RichIPythonWidget, self)._context_menu_make(pos)
-        return menu
-
-    #---------------------------------------------------------------------------
-    # 'BaseFrontendMixin' abstract interface
-    #---------------------------------------------------------------------------
-
-    def _handle_pyout(self, msg):
-        """ Overridden to handle rich data types, like SVG.
-        """
-        if not self._hidden and self._is_from_this_session(msg):
-            content = msg['content']
-            prompt_number = content['execution_count']
-            data = content['data']
-            if data.has_key('image/svg+xml'):
-                self._append_plain_text(self.output_sep)
-                self._append_html(self._make_out_prompt(prompt_number))
-                # TODO: try/except this call.
-                self._append_svg(data['image/svg+xml'])
-                self._append_html(self.output_sep2)
-            elif data.has_key('image/png'):
-                self._append_plain_text(self.output_sep)
-                self._append_html(self._make_out_prompt(prompt_number))
-                # This helps the output to look nice.
-                self._append_plain_text('\n')
-                # TODO: try/except these calls
-                png = decodestring(data['image/png'])
-                self._append_png(png)
-                self._append_html(self.output_sep2)
-            else:
-                # Default back to the plain text representation.
-                return super(RichIPythonWidget, self)._handle_pyout(msg)
-
-    def _handle_display_data(self, msg):
-        """ Overridden to handle rich data types, like SVG.
-        """
-        if not self._hidden and self._is_from_this_session(msg):
-            source = msg['content']['source']
-            data = msg['content']['data']
-            metadata = msg['content']['metadata']
-            # Try to use the svg or html representations.
-            # FIXME: Is this the right ordering of things to try?
-            if data.has_key('image/svg+xml'):
-                svg = data['image/svg+xml']
-                # TODO: try/except this call.
-                self._append_svg(svg)
-            elif data.has_key('image/png'):
-                # TODO: try/except these calls
-                # PNG data is base64 encoded as it passes over the network
-                # in a JSON structure so we decode it.
-                png = decodestring(data['image/png'])
-                self._append_png(png)
-            else:
-                # Default back to the plain text representation.
-                return super(RichIPythonWidget, self)._handle_display_data(msg)
-
-    #---------------------------------------------------------------------------
-    # 'RichIPythonWidget' protected interface
-    #---------------------------------------------------------------------------
-
-    def _append_svg(self, svg):
-        """ Append raw svg data to the widget.
-        """
-        try:
-            image = svg_to_image(svg)
-        except ValueError:
-            self._append_plain_text('Received invalid plot data.')
-        else:
-            format = self._add_image(image)
-            self._name_to_svg_map[format.name()] = svg
-            cursor = self._get_end_cursor()
-            cursor.insertBlock()
-            cursor.insertImage(format)
-            cursor.insertBlock()
-
-    def _append_png(self, png):
-        """ Append raw svg data to the widget.
-        """
-        try:
-            image = QtGui.QImage()
-            image.loadFromData(png, 'PNG')
-        except ValueError:
-            self._append_plain_text('Received invalid plot data.')
-        else:
-            format = self._add_image(image)
-            cursor = self._get_end_cursor()
-            cursor.insertBlock()
-            cursor.insertImage(format)
-            cursor.insertBlock()
-
-    def _add_image(self, image):
-        """ Adds the specified QImage to the document and returns a
-            QTextImageFormat that references it.
-        """
-        document = self._control.document()
-        name = str(image.cacheKey())
-        document.addResource(QtGui.QTextDocument.ImageResource,
-                             QtCore.QUrl(name), image)
-        format = QtGui.QTextImageFormat()
-        format.setName(name)
-        return format
-
-    def _copy_image(self, name):
-        """ Copies the ImageResource with 'name' to the clipboard.
-        """
-        image = self._get_image(name)
-        QtGui.QApplication.clipboard().setImage(image)
-
-    def _get_image(self, name):
-        """ Returns the QImage stored as the ImageResource with 'name'.
-        """
-        document = self._control.document()
-        image = document.resource(QtGui.QTextDocument.ImageResource,
-                                  QtCore.QUrl(name))
-        return image
-
-    def _get_image_tag(self, match, path = None, format = "png"):
-        """ Return (X)HTML mark-up for the image-tag given by match.
-
-        Parameters
-        ----------
-        match : re.SRE_Match
-            A match to an HTML image tag as exported by Qt, with
-            match.group("Name") containing the matched image ID.
-
-        path : string|None, optional [default None]
-            If not None, specifies a path to which supporting files may be
-            written (e.g., for linked images).  If None, all images are to be
-            included inline.
-
-        format : "png"|"svg", optional [default "png"]
-            Format for returned or referenced images.
-        """
-        if format == "png":
-            try:
-                image = self._get_image(match.group("name"))
-            except KeyError:
-                return "<b>Couldn't find image %s</b>" % match.group("name")
-
-            if path is not None:
-                if not os.path.exists(path):
-                    os.mkdir(path)
-                relpath = os.path.basename(path)
-                if image.save("%s/qt_img%s.png" % (path,match.group("name")),
-                              "PNG"):
-                    return '<img src="%s/qt_img%s.png">' % (relpath,
-                                                            match.group("name"))
-                else:
-                    return "<b>Couldn't save image!</b>"
-            else:
-                ba = QtCore.QByteArray()
-                buffer_ = QtCore.QBuffer(ba)
-                buffer_.open(QtCore.QIODevice.WriteOnly)
-                image.save(buffer_, "PNG")
-                buffer_.close()
-                return '<img src="data:image/png;base64,\n%s\n" />' % (
-                    re.sub(r'(.{60})',r'\1\n',str(ba.toBase64())))
-
-        elif format == "svg":
-            try:
-                svg = str(self._name_to_svg_map[match.group("name")])
-            except KeyError:
-                return "<b>Couldn't find image %s</b>" % match.group("name")
-
-            # Not currently checking path, because it's tricky to find a
-            # cross-browser way to embed external SVG images (e.g., via
-            # object or embed tags).
-
-            # Chop stand-alone header from matplotlib SVG
-            offset = svg.find("<svg")
-            assert(offset > -1)
-            
-            return svg[offset:]
-
-        else:
-            return '<b>Unrecognized image format</b>'
-
-    def _save_image(self, name, format='PNG'):
-        """ Shows a save dialog for the ImageResource with 'name'.
-        """
-        dialog = QtGui.QFileDialog(self._control, 'Save Image')
-        dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
-        dialog.setDefaultSuffix(format.lower())
-        dialog.setNameFilter('%s file (*.%s)' % (format, format.lower()))
-        if dialog.exec_():
-            filename = dialog.selectedFiles()[0]
-            image = self._get_image(name)
-            image.save(filename, format)
diff --git a/IPython/frontend/qt/console/styles.py b/IPython/frontend/qt/console/styles.py
deleted file mode 100644
index e92eaf03ea3..00000000000
--- a/IPython/frontend/qt/console/styles.py
+++ /dev/null
@@ -1,119 +0,0 @@
-""" Style utilities, templates, and defaults for syntax highlighting widgets.
-"""
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from colorsys import rgb_to_hls
-from pygments.styles import get_style_by_name
-from pygments.token import Token
-
-#-----------------------------------------------------------------------------
-# Constants
-#-----------------------------------------------------------------------------
-
-# The default light style sheet: black text on a white background.
-default_light_style_template = '''
-    QPlainTextEdit, QTextEdit { background-color: %(bgcolor)s;
-            color: %(fgcolor)s ;
-            selection-background-color: %(select)s}
-    .error { color: red; }
-    .in-prompt { color: navy; }
-    .in-prompt-number { font-weight: bold; }
-    .out-prompt { color: darkred; }
-    .out-prompt-number { font-weight: bold; }
-'''
-default_light_style_sheet = default_light_style_template%dict(
-                bgcolor='white', fgcolor='black', select="#ccc")
-default_light_syntax_style = 'default'
-
-# The default dark style sheet: white text on a black background.
-default_dark_style_template = '''
-    QPlainTextEdit, QTextEdit { background-color: %(bgcolor)s;
-            color: %(fgcolor)s ;
-            selection-background-color: %(select)s}
-    QFrame { border: 1px solid grey; }
-    .error { color: red; }
-    .in-prompt { color: lime; }
-    .in-prompt-number { color: lime; font-weight: bold; }
-    .out-prompt { color: red; }
-    .out-prompt-number { color: red; font-weight: bold; }
-'''
-default_dark_style_sheet = default_dark_style_template%dict(
-                bgcolor='black', fgcolor='white', select="#555")
-default_dark_syntax_style = 'monokai'
-
-# The default monochrome
-default_bw_style_sheet = '''
-    QPlainTextEdit, QTextEdit { background-color: white;
-            color: black ;
-            selection-background-color: #cccccc}
-    .in-prompt-number { font-weight: bold; }
-    .out-prompt-number { font-weight: bold; }
-'''
-default_bw_syntax_style = 'bw'
-
-
-def hex_to_rgb(color):
-    """Convert a hex color to rgb integer tuple."""
-    if color.startswith('#'):
-        color = color[1:]
-    if len(color) == 3:
-        color = ''.join([c*2 for c in color])
-    if len(color) != 6:
-        return False
-    try:
-        r = int(color[:2],16)
-        g = int(color[:2],16)
-        b = int(color[:2],16)
-    except ValueError:
-        return False
-    else:
-        return r,g,b
-
-def dark_color(color):
-    """Check whether a color is 'dark'.
-
-    Currently, this is simply whether the luminance is <50%"""
-    rgb = hex_to_rgb(color)
-    if rgb:
-        return rgb_to_hls(*rgb)[1] < 128
-    else: # default to False
-        return False
-
-def dark_style(stylename):
-    """Guess whether the background of the style with name 'stylename'
-    counts as 'dark'."""
-    return dark_color(get_style_by_name(stylename).background_color)
-
-def get_colors(stylename):
-    """Construct the keys to be used building the base stylesheet
-    from a templatee."""
-    style = get_style_by_name(stylename)
-    fgcolor = style.style_for_token(Token.Text)['color'] or ''
-    if len(fgcolor) in (3,6):
-        # could be 'abcdef' or 'ace' hex, which needs '#' prefix
-        try:
-            int(fgcolor, 16)
-        except TypeError:
-            pass
-        else:
-            fgcolor = "#"+fgcolor
-
-    return dict(
-        bgcolor = style.background_color,
-        select = style.highlight_color,
-        fgcolor = fgcolor
-    )
-
-def sheet_from_template(name, colors='lightbg'):
-    """Use one of the base templates, and set bg/fg/select colors."""
-    colors = colors.lower()
-    if colors=='lightbg':
-        return default_light_style_template%get_colors(name)
-    elif colors=='linux':
-        return default_dark_style_template%get_colors(name)
-    elif colors=='nocolor':
-        return default_bw_style_sheet
-    else:
-        raise KeyError("No such color scheme: %s"%colors)
diff --git a/IPython/frontend/qt/console/tests/__init__.py b/IPython/frontend/qt/console/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/frontend/qt/console/tests/test_ansi_code_processor.py b/IPython/frontend/qt/console/tests/test_ansi_code_processor.py
deleted file mode 100644
index f71334a6c25..00000000000
--- a/IPython/frontend/qt/console/tests/test_ansi_code_processor.py
+++ /dev/null
@@ -1,107 +0,0 @@
-# Standard library imports
-import unittest
-
-# Local imports
-from IPython.frontend.qt.console.ansi_code_processor import AnsiCodeProcessor
-
-
-class TestAnsiCodeProcessor(unittest.TestCase):
-
-    def setUp(self):
-        self.processor = AnsiCodeProcessor()
-
-    def test_clear(self):
-        """ Do control sequences for clearing the console work?
-        """
-        string = '\x1b[2J\x1b[K'
-        i = -1
-        for i, substring in enumerate(self.processor.split_string(string)):
-            if i == 0:
-                self.assertEquals(len(self.processor.actions), 1)
-                action = self.processor.actions[0]
-                self.assertEquals(action.action, 'erase')
-                self.assertEquals(action.area, 'screen')
-                self.assertEquals(action.erase_to, 'all')
-            elif i == 1:
-                self.assertEquals(len(self.processor.actions), 1)
-                action = self.processor.actions[0]
-                self.assertEquals(action.action, 'erase')
-                self.assertEquals(action.area, 'line')
-                self.assertEquals(action.erase_to, 'end')
-            else:
-                self.fail('Too many substrings.')
-        self.assertEquals(i, 1, 'Too few substrings.')
-
-    def test_colors(self):
-        """ Do basic controls sequences for colors work?
-        """
-        string = 'first\x1b[34mblue\x1b[0mlast'
-        i = -1
-        for i, substring in enumerate(self.processor.split_string(string)):
-            if i == 0:
-                self.assertEquals(substring, 'first')
-                self.assertEquals(self.processor.foreground_color, None)
-            elif i == 1:
-                self.assertEquals(substring, 'blue')
-                self.assertEquals(self.processor.foreground_color, 4)
-            elif i == 2:
-                self.assertEquals(substring, 'last')
-                self.assertEquals(self.processor.foreground_color, None)
-            else:
-                self.fail('Too many substrings.')
-        self.assertEquals(i, 2, 'Too few substrings.')
-
-    def test_colors_xterm(self):
-        """ Do xterm-specific control sequences for colors work?
-        """
-        string = '\x1b]4;20;rgb:ff/ff/ff\x1b' \
-            '\x1b]4;25;rgbi:1.0/1.0/1.0\x1b'
-        substrings = list(self.processor.split_string(string))
-        desired = { 20 : (255, 255, 255),
-                    25 : (255, 255, 255) }
-        self.assertEquals(self.processor.color_map, desired)
-
-        string = '\x1b[38;5;20m\x1b[48;5;25m'
-        substrings = list(self.processor.split_string(string))
-        self.assertEquals(self.processor.foreground_color, 20)
-        self.assertEquals(self.processor.background_color, 25)
-
-    def test_scroll(self):
-        """ Do control sequences for scrolling the buffer work?
-        """
-        string = '\x1b[5S\x1b[T'
-        i = -1
-        for i, substring in enumerate(self.processor.split_string(string)):
-            if i == 0:
-                self.assertEquals(len(self.processor.actions), 1)
-                action = self.processor.actions[0]
-                self.assertEquals(action.action, 'scroll')
-                self.assertEquals(action.dir, 'up')
-                self.assertEquals(action.unit, 'line')
-                self.assertEquals(action.count, 5)
-            elif i == 1:
-                self.assertEquals(len(self.processor.actions), 1)
-                action = self.processor.actions[0]
-                self.assertEquals(action.action, 'scroll')
-                self.assertEquals(action.dir, 'down')
-                self.assertEquals(action.unit, 'line')
-                self.assertEquals(action.count, 1)
-            else:
-                self.fail('Too many substrings.')
-        self.assertEquals(i, 1, 'Too few substrings.')
-
-    def test_specials(self):
-        """ Are special characters processed correctly?
-        """
-        string = '\f' # form feed
-        self.assertEquals(list(self.processor.split_string(string)), [''])
-        self.assertEquals(len(self.processor.actions), 1)
-        action = self.processor.actions[0]
-        self.assertEquals(action.action, 'scroll')
-        self.assertEquals(action.dir, 'down')
-        self.assertEquals(action.unit, 'page')
-        self.assertEquals(action.count, 1)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/IPython/frontend/qt/console/tests/test_completion_lexer.py b/IPython/frontend/qt/console/tests/test_completion_lexer.py
deleted file mode 100644
index ed958d84f1a..00000000000
--- a/IPython/frontend/qt/console/tests/test_completion_lexer.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# Standard library imports
-import unittest
-
-# System library imports
-from pygments.lexers import CLexer, CppLexer, PythonLexer
-
-# Local imports
-from IPython.frontend.qt.console.completion_lexer import CompletionLexer
-
-
-class TestCompletionLexer(unittest.TestCase):
-    
-    def testPython(self):
-        """ Does the CompletionLexer work for Python?
-        """
-        lexer = CompletionLexer(PythonLexer())
-
-        # Test simplest case.
-        self.assertEquals(lexer.get_context("foo.bar.baz"),
-                          [ "foo", "bar", "baz" ])
-
-        # Test trailing period.
-        self.assertEquals(lexer.get_context("foo.bar."), [ "foo", "bar", "" ])
-
-        # Test with prompt present.
-        self.assertEquals(lexer.get_context(">>> foo.bar.baz"),
-                          [ "foo", "bar", "baz" ])
-
-        # Test spacing in name.
-        self.assertEquals(lexer.get_context("foo.bar. baz"), [ "baz" ])
-
-        # Test parenthesis.
-        self.assertEquals(lexer.get_context("foo("), [])
-
-    def testC(self):
-        """ Does the CompletionLexer work for C/C++?
-        """
-        lexer = CompletionLexer(CLexer())
-        self.assertEquals(lexer.get_context("foo.bar"), [ "foo", "bar" ])
-        self.assertEquals(lexer.get_context("foo->bar"), [ "foo", "bar" ])
-
-        lexer = CompletionLexer(CppLexer())
-        self.assertEquals(lexer.get_context("Foo::Bar"), [ "Foo", "Bar" ])
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/IPython/frontend/qt/kernelmanager.py b/IPython/frontend/qt/kernelmanager.py
deleted file mode 100644
index c47b489e951..00000000000
--- a/IPython/frontend/qt/kernelmanager.py
+++ /dev/null
@@ -1,243 +0,0 @@
-""" Defines a KernelManager that provides signals and slots.
-"""
-
-# System library imports.
-from IPython.external.qt import QtCore
-
-# IPython imports.
-from IPython.utils.traitlets import Type
-from IPython.zmq.kernelmanager import KernelManager, SubSocketChannel, \
-    XReqSocketChannel, RepSocketChannel, HBSocketChannel
-from util import MetaQObjectHasTraits, SuperQObject
-
-
-class SocketChannelQObject(SuperQObject):
-
-    # Emitted when the channel is started.
-    started = QtCore.Signal()
-
-    # Emitted when the channel is stopped.
-    stopped = QtCore.Signal()
-
-    #---------------------------------------------------------------------------
-    # 'ZmqSocketChannel' interface
-    #---------------------------------------------------------------------------
-
-    def start(self):
-        """ Reimplemented to emit signal.
-        """
-        super(SocketChannelQObject, self).start()
-        self.started.emit()
-
-    def stop(self):
-        """ Reimplemented to emit signal.
-        """
-        super(SocketChannelQObject, self).stop()
-        self.stopped.emit()
-
-
-class QtXReqSocketChannel(SocketChannelQObject, XReqSocketChannel):
-
-    # Emitted when any message is received.
-    message_received = QtCore.Signal(object)
-
-    # Emitted when a reply has been received for the corresponding request
-    # type.
-    execute_reply = QtCore.Signal(object)
-    complete_reply = QtCore.Signal(object)
-    object_info_reply = QtCore.Signal(object)
-    history_tail_reply = QtCore.Signal(object)
-
-    # Emitted when the first reply comes back.
-    first_reply = QtCore.Signal()
-
-    # Used by the first_reply signal logic to determine if a reply is the 
-    # first.
-    _handlers_called = False
-
-    #---------------------------------------------------------------------------
-    # 'XReqSocketChannel' interface
-    #---------------------------------------------------------------------------
-    
-    def call_handlers(self, msg):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        # Emit the generic signal.
-        self.message_received.emit(msg)
-        
-        # Emit signals for specialized message types.
-        msg_type = msg['msg_type']
-        signal = getattr(self, msg_type, None)
-        if signal:
-            signal.emit(msg)
-
-        if not self._handlers_called:
-            self.first_reply.emit()
-            self._handlers_called = True
-
-    #---------------------------------------------------------------------------
-    # 'QtXReqSocketChannel' interface
-    #---------------------------------------------------------------------------
-
-    def reset_first_reply(self):
-        """ Reset the first_reply signal to fire again on the next reply.
-        """
-        self._handlers_called = False
-
-
-class QtSubSocketChannel(SocketChannelQObject, SubSocketChannel):
-
-    # Emitted when any message is received.
-    message_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'stream' is received.
-    stream_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'pyin' is received.
-    pyin_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'pyout' is received.
-    pyout_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'pyerr' is received.
-    pyerr_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'display_data' is received
-    display_data_received = QtCore.Signal(object)
-
-    # Emitted when a crash report message is received from the kernel's
-    # last-resort sys.excepthook.
-    crash_received = QtCore.Signal(object)
-
-    # Emitted when a shutdown is noticed.
-    shutdown_reply_received = QtCore.Signal(object)
-
-    #---------------------------------------------------------------------------
-    # 'SubSocketChannel' interface
-    #---------------------------------------------------------------------------
-    
-    def call_handlers(self, msg):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        # Emit the generic signal.
-        self.message_received.emit(msg)
-        # Emit signals for specialized message types.
-        msg_type = msg['msg_type']
-        signal = getattr(self, msg_type + '_received', None)
-        if signal:
-            signal.emit(msg)
-        elif msg_type in ('stdout', 'stderr'):
-            self.stream_received.emit(msg)
-
-    def flush(self):
-        """ Reimplemented to ensure that signals are dispatched immediately.
-        """
-        super(QtSubSocketChannel, self).flush()
-        QtCore.QCoreApplication.instance().processEvents()
-
-
-class QtRepSocketChannel(SocketChannelQObject, RepSocketChannel):
-
-    # Emitted when any message is received.
-    message_received = QtCore.Signal(object)
-
-    # Emitted when an input request is received.
-    input_requested = QtCore.Signal(object)
-
-    #---------------------------------------------------------------------------
-    # 'RepSocketChannel' interface
-    #---------------------------------------------------------------------------
-
-    def call_handlers(self, msg):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        # Emit the generic signal.
-        self.message_received.emit(msg)
-        
-        # Emit signals for specialized message types.
-        msg_type = msg['msg_type']
-        if msg_type == 'input_request':
-            self.input_requested.emit(msg)
-
-
-class QtHBSocketChannel(SocketChannelQObject, HBSocketChannel):
-
-    # Emitted when the kernel has died.
-    kernel_died = QtCore.Signal(object)
-
-    #---------------------------------------------------------------------------
-    # 'HBSocketChannel' interface
-    #---------------------------------------------------------------------------
-
-    def call_handlers(self, since_last_heartbeat):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        # Emit the generic signal.
-        self.kernel_died.emit(since_last_heartbeat)
-
-
-class QtKernelManager(KernelManager, SuperQObject):
-    """ A KernelManager that provides signals and slots.
-    """
-
-    __metaclass__ = MetaQObjectHasTraits
-
-    # Emitted when the kernel manager has started listening.
-    started_channels = QtCore.Signal()
-
-    # Emitted when the kernel manager has stopped listening.
-    stopped_channels = QtCore.Signal()
-
-    # Use Qt-specific channel classes that emit signals.
-    sub_channel_class = Type(QtSubSocketChannel)
-    xreq_channel_class = Type(QtXReqSocketChannel)
-    rep_channel_class = Type(QtRepSocketChannel)
-    hb_channel_class = Type(QtHBSocketChannel)
-
-    #---------------------------------------------------------------------------
-    # 'KernelManager' interface
-    #---------------------------------------------------------------------------
-
-    #------ Kernel process management ------------------------------------------
-
-    def start_kernel(self, *args, **kw):
-        """ Reimplemented for proper heartbeat management.
-        """
-        if self._xreq_channel is not None:
-            self._xreq_channel.reset_first_reply()
-        super(QtKernelManager, self).start_kernel(*args, **kw)
-
-    #------ Channel management -------------------------------------------------
-    
-    def start_channels(self, *args, **kw):
-        """ Reimplemented to emit signal.
-        """
-        super(QtKernelManager, self).start_channels(*args, **kw)
-        self.started_channels.emit()
-
-    def stop_channels(self):
-        """ Reimplemented to emit signal.
-        """ 
-        super(QtKernelManager, self).stop_channels()
-        self.stopped_channels.emit()
-
-    @property
-    def xreq_channel(self):
-        """ Reimplemented for proper heartbeat management.
-        """
-        if self._xreq_channel is None:
-            self._xreq_channel = super(QtKernelManager, self).xreq_channel
-            self._xreq_channel.first_reply.connect(self._first_reply)
-        return self._xreq_channel
-
-    #---------------------------------------------------------------------------
-    # Protected interface
-    #---------------------------------------------------------------------------
-    
-    def _first_reply(self):
-        """ Unpauses the heartbeat channel when the first reply is received on
-            the execute channel. Note that this will *not* start the heartbeat
-            channel if it is not already running!
-        """
-        if self._hb_channel is not None:
-            self._hb_channel.unpause()
diff --git a/IPython/frontend/qt/rich_text.py b/IPython/frontend/qt/rich_text.py
deleted file mode 100644
index f7a97f47da0..00000000000
--- a/IPython/frontend/qt/rich_text.py
+++ /dev/null
@@ -1,235 +0,0 @@
-""" Defines classes and functions for working with Qt's rich text system.
-"""
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports.
-import os
-import re
-
-# System library imports.
-from IPython.external.qt import QtGui
-
-#-----------------------------------------------------------------------------
-# Constants
-#-----------------------------------------------------------------------------
-
-# A regular expression for an HTML paragraph with no content.
-EMPTY_P_RE = re.compile(r'<p[^/>]*>\s*</p>')
-
-# A regular expression for matching images in rich text HTML.
-# Note that this is overly restrictive, but Qt's output is predictable...
-IMG_RE = re.compile(r'<img src="(?P<name>[\d]+)" />')
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-class HtmlExporter(object):
-    """ A stateful HTML exporter for a Q(Plain)TextEdit.
-
-    This class is designed for convenient user interaction.
-    """
-
-    def __init__(self, control):
-        """ Creates an HtmlExporter for the given Q(Plain)TextEdit.
-        """
-        assert isinstance(control, (QtGui.QPlainTextEdit, QtGui.QTextEdit))
-        self.control = control
-        self.filename = 'ipython.html'
-        self.image_tag = None
-        self.inline_png = None
-
-    def export(self):
-        """ Displays a dialog for exporting HTML generated by Qt's rich text
-        system.
-
-        Returns
-        -------
-        The name of the file that was saved, or None if no file was saved.
-        """
-        parent = self.control.window()
-        dialog = QtGui.QFileDialog(parent, 'Save as...')
-        dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
-        filters = [
-            'HTML with PNG figures (*.html *.htm)',
-            'XHTML with inline SVG figures (*.xhtml *.xml)'
-        ]
-        dialog.setNameFilters(filters)
-        if self.filename:
-            dialog.selectFile(self.filename)
-            root,ext = os.path.splitext(self.filename)
-            if ext.lower() in ('.xml', '.xhtml'):
-                dialog.selectNameFilter(filters[-1])
-
-        if dialog.exec_():
-            self.filename = dialog.selectedFiles()[0]
-            choice = dialog.selectedNameFilter()
-            html = self.control.document().toHtml().encode('utf-8')
-
-            # Configure the exporter.
-            if choice.startswith('XHTML'):
-                exporter = export_xhtml
-            else:
-                # If there are PNGs, decide how to export them.
-                inline = self.inline_png
-                if inline is None and IMG_RE.search(html):
-                    dialog = QtGui.QDialog(parent)
-                    dialog.setWindowTitle('Save as...')
-                    layout = QtGui.QVBoxLayout(dialog)
-                    msg = "Exporting HTML with PNGs"
-                    info = "Would you like inline PNGs (single large html " \
-                        "file) or external image files?"
-                    checkbox = QtGui.QCheckBox("&Don't ask again")
-                    checkbox.setShortcut('D')
-                    ib = QtGui.QPushButton("&Inline")
-                    ib.setShortcut('I')
-                    eb = QtGui.QPushButton("&External")
-                    eb.setShortcut('E')
-                    box = QtGui.QMessageBox(QtGui.QMessageBox.Question, 
-                                            dialog.windowTitle(), msg)
-                    box.setInformativeText(info)
-                    box.addButton(ib, QtGui.QMessageBox.NoRole)
-                    box.addButton(eb, QtGui.QMessageBox.YesRole)
-                    box.setDefaultButton(ib)
-                    layout.setSpacing(0)
-                    layout.addWidget(box)
-                    layout.addWidget(checkbox)
-                    dialog.setLayout(layout)
-                    dialog.show()
-                    reply = box.exec_()
-                    dialog.hide()
-                    inline = (reply == 0)
-                    if checkbox.checkState():
-                        # Don't ask anymore; always use this choice.
-                        self.inline_png = inline
-                exporter = lambda h, f, i: export_html(h, f, i, inline)
-
-            # Perform the export!
-            try:
-                return exporter(html, self.filename, self.image_tag)
-            except Exception, e:
-                msg = "Error exporting HTML to %s\n" % self.filename + str(e)
-                reply = QtGui.QMessageBox.warning(parent, 'Error', msg,
-                    QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
-
-        return None
-
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-def export_html(html, filename, image_tag = None, inline = True):
-    """ Export the contents of the ConsoleWidget as HTML.
-
-    Parameters:
-    -----------
-    html : str,
-        A utf-8 encoded Python string containing the Qt HTML to export.
-
-    filename : str
-        The file to be saved.
-
-    image_tag : callable, optional (default None)
-        Used to convert images. See ``default_image_tag()`` for information.
-
-    inline : bool, optional [default True]
-        If True, include images as inline PNGs.  Otherwise, include them as
-        links to external PNG files, mimicking web browsers' "Web Page,
-        Complete" behavior.
-    """
-    if image_tag is None:
-        image_tag = default_image_tag
-
-    if inline:
-        path = None
-    else:
-        root,ext = os.path.splitext(filename)
-        path = root + "_files"
-        if os.path.isfile(path):
-            raise OSError("%s exists, but is not a directory." % path)
-
-    with open(filename, 'w') as f:
-        html = fix_html(html)
-        f.write(IMG_RE.sub(lambda x: image_tag(x, path = path, format = "png"),
-                           html))
-
-
-def export_xhtml(html, filename, image_tag=None):
-    """ Export the contents of the ConsoleWidget as XHTML with inline SVGs.
-
-    Parameters:
-    -----------
-    html : str,
-        A utf-8 encoded Python string containing the Qt HTML to export.
-
-    filename : str
-        The file to be saved.
-
-    image_tag : callable, optional (default None)
-        Used to convert images. See ``default_image_tag()`` for information.
-    """
-    if image_tag is None:
-        image_tag = default_image_tag
-
-    with open(filename, 'w') as f:
-        # Hack to make xhtml header -- note that we are not doing any check for
-        # valid XML.
-        offset = html.find("<html>")
-        assert offset > -1, 'Invalid HTML string: no <html> tag.'
-        html = ('<html xmlns="http://www.w3.org/1999/xhtml">\n'+
-                html[offset+6:])
-
-        html = fix_html(html)
-        f.write(IMG_RE.sub(lambda x: image_tag(x, path = None, format = "svg"),
-                           html))
-
-
-def default_image_tag(match, path = None, format = "png"):
-    """ Return (X)HTML mark-up for the image-tag given by match.
-
-    This default implementation merely removes the image, and exists mostly
-    for documentation purposes. More information than is present in the Qt 
-    HTML is required to supply the images.
-
-    Parameters
-    ----------
-    match : re.SRE_Match 
-        A match to an HTML image tag as exported by Qt, with match.group("Name")
-        containing the matched image ID.
-
-    path : string|None, optional [default None]
-        If not None, specifies a path to which supporting files may be written
-        (e.g., for linked images).  If None, all images are to be included
-        inline.
-
-    format : "png"|"svg", optional [default "png"]
-        Format for returned or referenced images.
-    """
-    return ''
-
-
-def fix_html(html):
-    """ Transforms a Qt-generated HTML string into a standards-compliant one.
-    
-    Parameters:
-    -----------
-    html : str,
-        A utf-8 encoded Python string containing the Qt HTML.
-    """
-    # A UTF-8 declaration is needed for proper rendering of some characters
-    # (e.g., indented commands) when viewing exported HTML on a local system
-    # (i.e., without seeing an encoding declaration in an HTTP header).
-    # C.f. http://www.w3.org/International/O-charset for details.
-    offset = html.find('<head>')
-    if offset > -1:
-        html = (html[:offset+6]+
-                '\n<meta http-equiv="Content-Type" '+
-                'content="text/html; charset=utf-8" />\n'+
-                html[offset+6:])
-
-    # Replace empty paragraphs tags with line breaks.
-    html = re.sub(EMPTY_P_RE, '<br/>', html)
-
-    return html
diff --git a/IPython/frontend/qt/svg.py b/IPython/frontend/qt/svg.py
deleted file mode 100644
index 8081dca0c07..00000000000
--- a/IPython/frontend/qt/svg.py
+++ /dev/null
@@ -1,86 +0,0 @@
-""" Defines utility functions for working with SVG documents in Qt.
-"""
-
-# System library imports.
-from IPython.external.qt import QtCore, QtGui, QtSvg
-
-
-def save_svg(string, parent=None):
-    """ Prompts the user to save an SVG document to disk.
-
-    Parameters:
-    -----------
-    string : basestring
-        A Python string containing a SVG document.
-
-    parent : QWidget, optional
-        The parent to use for the file dialog.
-
-    Returns:
-    --------
-    The name of the file to which the document was saved, or None if the save
-    was cancelled.
-    """
-    dialog = QtGui.QFileDialog(parent, 'Save SVG Document')
-    dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
-    dialog.setDefaultSuffix('svg')
-    dialog.setNameFilter('SVG document (*.svg)')
-    if dialog.exec_():
-        filename = dialog.selectedFiles()[0]
-        f = open(filename, 'w')
-        try:
-            f.write(string)
-        finally:
-            f.close()
-        return filename
-    return None
-
-def svg_to_clipboard(string):
-    """ Copy a SVG document to the clipboard.
-
-    Parameters:
-    -----------
-    string : basestring
-        A Python string containing a SVG document.
-    """
-    if isinstance(string, unicode):
-        string = string.encode('utf-8')
-
-    mime_data = QtCore.QMimeData()
-    mime_data.setData('image/svg+xml', string)
-    QtGui.QApplication.clipboard().setMimeData(mime_data)
-        
-def svg_to_image(string, size=None):
-    """ Convert a SVG document to a QImage.
-
-    Parameters:
-    -----------
-    string : basestring
-        A Python string containing a SVG document.
-
-    size : QSize, optional
-        The size of the image that is produced. If not specified, the SVG
-        document's default size is used.
-    
-    Raises:
-    -------
-    ValueError
-        If an invalid SVG string is provided.
-
-    Returns:
-    --------
-    A QImage of format QImage.Format_ARGB32.
-    """
-    if isinstance(string, unicode):
-        string = string.encode('utf-8')
-
-    renderer = QtSvg.QSvgRenderer(QtCore.QByteArray(string))
-    if not renderer.isValid():
-        raise ValueError('Invalid SVG data.')
-
-    if size is None:
-        size = renderer.defaultSize()
-    image = QtGui.QImage(size, QtGui.QImage.Format_ARGB32)
-    painter = QtGui.QPainter(image)
-    renderer.render(painter)
-    return image
diff --git a/IPython/frontend/qt/util.py b/IPython/frontend/qt/util.py
deleted file mode 100644
index 096c27ea1ab..00000000000
--- a/IPython/frontend/qt/util.py
+++ /dev/null
@@ -1,106 +0,0 @@
-""" Defines miscellaneous Qt-related helper classes and functions.
-"""
-
-# Standard library imports.
-import inspect
-
-# System library imports.
-from IPython.external.qt import QtCore, QtGui
-
-# IPython imports.
-from IPython.utils.traitlets import HasTraits, TraitType
-
-#-----------------------------------------------------------------------------
-# Metaclasses
-#-----------------------------------------------------------------------------
-
-MetaHasTraits = type(HasTraits)
-MetaQObject = type(QtCore.QObject)
-
-class MetaQObjectHasTraits(MetaQObject, MetaHasTraits):
-    """ A metaclass that inherits from the metaclasses of HasTraits and QObject.
-
-    Using this metaclass allows a class to inherit from both HasTraits and
-    QObject. Using SuperQObject instead of QObject is highly recommended. See
-    QtKernelManager for an example.
-    """
-    def __new__(mcls, name, bases, classdict):
-        # FIXME: this duplicates the code from MetaHasTraits.
-        # I don't think a super() call will help me here.
-        for k,v in classdict.iteritems():
-            if isinstance(v, TraitType):
-                v.name = k
-            elif inspect.isclass(v):
-                if issubclass(v, TraitType):
-                    vinst = v()
-                    vinst.name = k
-                    classdict[k] = vinst
-        cls = MetaQObject.__new__(mcls, name, bases, classdict)
-        return cls
-
-    def __init__(mcls, name, bases, classdict):
-        # Note: super() did not work, so we explicitly call these.
-        MetaQObject.__init__(mcls, name, bases, classdict)
-        MetaHasTraits.__init__(mcls, name, bases, classdict)
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-class SuperQObject(QtCore.QObject):
-    """ Permits the use of super() in class hierarchies that contain QObject.
-
-    Unlike QObject, SuperQObject does not accept a QObject parent. If it did,
-    super could not be emulated properly (all other classes in the heierarchy
-    would have to accept the parent argument--they don't, of course, because
-    they don't inherit QObject.)
-
-    This class is primarily useful for attaching signals to existing non-Qt
-    classes. See QtKernelManager for an example.
-    """
-
-    def __new__(cls, *args, **kw):
-        # We initialize QObject as early as possible. Without this, Qt complains
-        # if SuperQObject is not the first class in the super class list.
-        inst = QtCore.QObject.__new__(cls)
-        QtCore.QObject.__init__(inst)
-        return inst
-
-    def __init__(self, *args, **kw):
-        # Emulate super by calling the next method in the MRO, if there is one.
-        mro = self.__class__.mro()
-        for qt_class in QtCore.QObject.mro():
-            mro.remove(qt_class)
-        next_index = mro.index(SuperQObject) + 1
-        if next_index < len(mro):
-            mro[next_index].__init__(self, *args, **kw)
-
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-def get_font(family, fallback=None):
-    """Return a font of the requested family, using fallback as alternative.
-
-    If a fallback is provided, it is used in case the requested family isn't
-    found.  If no fallback is given, no alternative is chosen and Qt's internal
-    algorithms may automatically choose a fallback font.
-
-    Parameters
-    ----------
-    family : str
-      A font name.
-    fallback : str
-      A font name.
-
-    Returns
-    -------
-    font : QFont object
-    """
-    font = QtGui.QFont(family)
-    # Check whether we got what we wanted using QFontInfo, since exactMatch()
-    # is overly strict and returns false in too many cases.
-    font_info = QtGui.QFontInfo(font)
-    if fallback is not None and font_info.family() != family:
-        font = QtGui.QFont(fallback)
-    return font
diff --git a/IPython/frontend/terminal/__init__.py b/IPython/frontend/terminal/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/frontend/terminal/embed.py b/IPython/frontend/terminal/embed.py
deleted file mode 100755
index 81674bdc10d..00000000000
--- a/IPython/frontend/terminal/embed.py
+++ /dev/null
@@ -1,246 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-An embedded IPython shell.
-
-Authors:
-
-* Brian Granger
-* Fernando Perez
-
-Notes
------
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from __future__ import with_statement
-import __main__
-
-import sys
-from contextlib import nested
-
-from IPython.core import ultratb
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
-from IPython.frontend.terminal.ipapp import load_default_config
-
-from IPython.utils.traitlets import Bool, Str, CBool, Unicode
-from IPython.utils.io import ask_yes_no
-
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-# This is an additional magic that is exposed in embedded shells.
-def kill_embedded(self,parameter_s=''):
-    """%kill_embedded : deactivate for good the current embedded IPython.
-
-    This function (after asking for confirmation) sets an internal flag so that
-    an embedded IPython will never activate again.  This is useful to
-    permanently disable a shell that is being called inside a loop: once you've
-    figured out what you needed from it, you may then kill it and the program
-    will then continue to run without the interactive shell interfering again.
-    """
-    
-    kill = ask_yes_no("Are you sure you want to kill this embedded instance "
-                     "(y/n)? [y/N] ",'n')
-    if kill:
-        self.embedded_active = False
-        print "This embedded IPython will not reactivate anymore once you exit."
-
-
-class InteractiveShellEmbed(TerminalInteractiveShell):
-
-    dummy_mode = Bool(False)
-    exit_msg = Unicode('')
-    embedded = CBool(True)
-    embedded_active = CBool(True)
-    # Like the base class display_banner is not configurable, but here it
-    # is True by default.
-    display_banner = CBool(True)
-
-    def __init__(self, config=None, ipython_dir=None, user_ns=None,
-                 user_global_ns=None, custom_exceptions=((),None),
-                 usage=None, banner1=None, banner2=None,
-                 display_banner=None, exit_msg=u''):
-
-        super(InteractiveShellEmbed,self).__init__(
-            config=config, ipython_dir=ipython_dir, user_ns=user_ns,
-            user_global_ns=user_global_ns, custom_exceptions=custom_exceptions,
-            usage=usage, banner1=banner1, banner2=banner2,
-            display_banner=display_banner
-        )
-
-        self.exit_msg = exit_msg
-        self.define_magic("kill_embedded", kill_embedded)
-
-        # don't use the ipython crash handler so that user exceptions aren't
-        # trapped
-        sys.excepthook = ultratb.FormattedTB(color_scheme=self.colors,
-                                             mode=self.xmode,
-                                             call_pdb=self.pdb)
-
-    def init_sys_modules(self):
-        pass
-
-    def __call__(self, header='', local_ns=None, global_ns=None, dummy=None,
-                 stack_depth=1):
-        """Activate the interactive interpreter.
-
-        __call__(self,header='',local_ns=None,global_ns,dummy=None) -> Start
-        the interpreter shell with the given local and global namespaces, and
-        optionally print a header string at startup.
-
-        The shell can be globally activated/deactivated using the
-        set/get_dummy_mode methods. This allows you to turn off a shell used
-        for debugging globally.
-
-        However, *each* time you call the shell you can override the current
-        state of dummy_mode with the optional keyword parameter 'dummy'. For
-        example, if you set dummy mode on with IPShell.set_dummy_mode(1), you
-        can still have a specific call work by making it as IPShell(dummy=0).
-
-        The optional keyword parameter dummy controls whether the call
-        actually does anything.
-        """
-
-        # If the user has turned it off, go away
-        if not self.embedded_active:
-            return
-
-        # Normal exits from interactive mode set this flag, so the shell can't
-        # re-enter (it checks this variable at the start of interactive mode).
-        self.exit_now = False
-
-        # Allow the dummy parameter to override the global __dummy_mode
-        if dummy or (dummy != 0 and self.dummy_mode):
-            return
-
-        if self.has_readline:
-            self.set_readline_completer()
-
-        # self.banner is auto computed
-        if header:
-            self.old_banner2 = self.banner2
-            self.banner2 = self.banner2 + '\n' + header + '\n'
-        else:
-            self.old_banner2 = ''
-
-        # Call the embedding code with a stack depth of 1 so it can skip over
-        # our call and get the original caller's namespaces.
-        self.mainloop(local_ns, global_ns, stack_depth=stack_depth)
-
-        self.banner2 = self.old_banner2
-
-        if self.exit_msg is not None:
-            print self.exit_msg
-
-    def mainloop(self, local_ns=None, global_ns=None, stack_depth=0,
-                 display_banner=None):
-        """Embeds IPython into a running python program.
-
-        Input:
-
-          - header: An optional header message can be specified.
-
-          - local_ns, global_ns: working namespaces. If given as None, the
-          IPython-initialized one is updated with __main__.__dict__, so that
-          program variables become visible but user-specific configuration
-          remains possible.
-
-          - stack_depth: specifies how many levels in the stack to go to
-          looking for namespaces (when local_ns and global_ns are None).  This
-          allows an intermediate caller to make sure that this function gets
-          the namespace from the intended level in the stack.  By default (0)
-          it will get its locals and globals from the immediate caller.
-
-        Warning: it's possible to use this in a program which is being run by
-        IPython itself (via %run), but some funny things will happen (a few
-        globals get overwritten). In the future this will be cleaned up, as
-        there is no fundamental reason why it can't work perfectly."""
-
-        # Get locals and globals from caller
-        if local_ns is None or global_ns is None:
-            call_frame = sys._getframe(stack_depth).f_back
-
-            if local_ns is None:
-                local_ns = call_frame.f_locals
-            if global_ns is None:
-                global_ns = call_frame.f_globals
-
-        # Update namespaces and fire up interpreter
-
-        # The global one is easy, we can just throw it in
-        self.user_global_ns = global_ns
-
-        # but the user/local one is tricky: ipython needs it to store internal
-        # data, but we also need the locals.  We'll copy locals in the user
-        # one, but will track what got copied so we can delete them at exit.
-        # This is so that a later embedded call doesn't see locals from a
-        # previous call (which most likely existed in a separate scope).
-        local_varnames = local_ns.keys()
-        self.user_ns.update(local_ns)
-        #self.user_ns['local_ns'] = local_ns  # dbg
-
-        # Patch for global embedding to make sure that things don't overwrite
-        # user globals accidentally. Thanks to Richard <rxe@renre-europe.com>
-        # FIXME. Test this a bit more carefully (the if.. is new)
-        if local_ns is None and global_ns is None:
-            self.user_global_ns.update(__main__.__dict__)
-
-        # make sure the tab-completer has the correct frame information, so it
-        # actually completes using the frame's locals/globals
-        self.set_completer_frame()
-
-        with nested(self.builtin_trap, self.display_trap):
-            self.interact(display_banner=display_banner)
-        
-            # now, purge out the user namespace from anything we might have added
-            # from the caller's local namespace
-            delvar = self.user_ns.pop
-            for var in local_varnames:
-                delvar(var,None)
-
-
-_embedded_shell = None
-
-
-def embed(**kwargs):
-    """Call this to embed IPython at the current point in your program.
-
-    The first invocation of this will create an :class:`InteractiveShellEmbed`
-    instance and then call it.  Consecutive calls just call the already
-    created instance.
-
-    Here is a simple example::
-
-        from IPython import embed
-        a = 10
-        b = 20
-        embed('First time')
-        c = 30
-        d = 40
-        embed
-
-    Full customization can be done by passing a :class:`Struct` in as the 
-    config argument.
-    """
-    config = kwargs.get('config')
-    header = kwargs.pop('header', u'')
-    if config is None:
-        config = load_default_config()
-        config.InteractiveShellEmbed = config.TerminalInteractiveShell
-    global _embedded_shell
-    if _embedded_shell is None:
-        _embedded_shell = InteractiveShellEmbed(**kwargs)
-    _embedded_shell(header=header, stack_depth=2)
diff --git a/IPython/frontend/terminal/interactiveshell.py b/IPython/frontend/terminal/interactiveshell.py
deleted file mode 100644
index 8c7f192d793..00000000000
--- a/IPython/frontend/terminal/interactiveshell.py
+++ /dev/null
@@ -1,558 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Subclass of InteractiveShell for terminal based frontends."""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2001 Janko Hauser <jhauser@zscout.de>
-#  Copyright (C) 2001-2007 Fernando Perez. <fperez@colorado.edu>
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import __builtin__
-import bdb
-from contextlib import nested
-import os
-import re
-import sys
-
-from IPython.core.error import TryNext
-from IPython.core.usage import interactive_usage, default_banner
-from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
-from IPython.lib.inputhook import enable_gui
-from IPython.lib.pylabtools import pylab_activate
-from IPython.testing import decorators as testdec
-from IPython.utils.terminal import toggle_set_term_title, set_term_title
-from IPython.utils.process import abbrev_cwd
-from IPython.utils.warn import warn
-from IPython.utils.text import num_ini_spaces
-from IPython.utils.traitlets import Int, Str, CBool, Unicode
-
-#-----------------------------------------------------------------------------
-# Utilities
-#-----------------------------------------------------------------------------
-
-def get_default_editor():
-    try:
-        ed = os.environ['EDITOR']
-    except KeyError:
-        if os.name == 'posix':
-            ed = 'vi'  # the only one guaranteed to be there!
-        else:
-            ed = 'notepad' # same in Windows!
-    return ed
-
-
-# store the builtin raw_input globally, and use this always, in case user code
-# overwrites it (like wx.py.PyShell does)
-raw_input_original = raw_input
-
-#-----------------------------------------------------------------------------
-# Main class
-#-----------------------------------------------------------------------------
-
-class TerminalInteractiveShell(InteractiveShell):
-
-    autoedit_syntax = CBool(False, config=True)
-    banner = Unicode('')
-    banner1 = Unicode(default_banner, config=True)
-    banner2 = Unicode('', config=True)
-    confirm_exit = CBool(True, config=True)
-    # This display_banner only controls whether or not self.show_banner()
-    # is called when mainloop/interact are called.  The default is False
-    # because for the terminal based application, the banner behavior
-    # is controlled by Global.display_banner, which IPythonApp looks at
-    # to determine if *it* should call show_banner() by hand or not.
-    display_banner = CBool(False) # This isn't configurable!
-    embedded = CBool(False)
-    embedded_active = CBool(False)
-    editor = Unicode(get_default_editor(), config=True)
-    pager = Unicode('less', config=True)
-
-    screen_length = Int(0, config=True)
-    term_title = CBool(False, config=True)
-
-    def __init__(self, config=None, ipython_dir=None, user_ns=None,
-                 user_global_ns=None, custom_exceptions=((),None),
-                 usage=None, banner1=None, banner2=None,
-                 display_banner=None):
-
-        super(TerminalInteractiveShell, self).__init__(
-            config=config, ipython_dir=ipython_dir, user_ns=user_ns,
-            user_global_ns=user_global_ns, custom_exceptions=custom_exceptions
-        )
-        self.init_term_title()
-        self.init_usage(usage)
-        self.init_banner(banner1, banner2, display_banner)
-
-    #-------------------------------------------------------------------------
-    # Things related to the terminal
-    #-------------------------------------------------------------------------
-
-    @property
-    def usable_screen_length(self):
-        if self.screen_length == 0:
-            return 0
-        else:
-            num_lines_bot = self.separate_in.count('\n')+1
-            return self.screen_length - num_lines_bot
-
-    def init_term_title(self):
-        # Enable or disable the terminal title.
-        if self.term_title:
-            toggle_set_term_title(True)
-            set_term_title('IPython: ' + abbrev_cwd())
-        else:
-            toggle_set_term_title(False)
-
-    #-------------------------------------------------------------------------
-    # Things related to aliases
-    #-------------------------------------------------------------------------
-
-    def init_alias(self):
-        # The parent class defines aliases that can be safely used with any
-        # frontend.
-        super(TerminalInteractiveShell, self).init_alias()
-
-        # Now define aliases that only make sense on the terminal, because they
-        # need direct access to the console in a way that we can't emulate in
-        # GUI or web frontend
-        if os.name == 'posix':
-            aliases = [('clear', 'clear'), ('more', 'more'), ('less', 'less'),
-                       ('man', 'man')]
-        elif os.name == 'nt':
-            aliases = [('cls', 'cls')]
-
-
-        for name, cmd in aliases:
-            self.alias_manager.define_alias(name, cmd)
-
-    #-------------------------------------------------------------------------
-    # Things related to the banner and usage
-    #-------------------------------------------------------------------------
-
-    def _banner1_changed(self):
-        self.compute_banner()
-
-    def _banner2_changed(self):
-        self.compute_banner()
-
-    def _term_title_changed(self, name, new_value):
-        self.init_term_title()
-
-    def init_banner(self, banner1, banner2, display_banner):
-        if banner1 is not None:
-            self.banner1 = banner1
-        if banner2 is not None:
-            self.banner2 = banner2
-        if display_banner is not None:
-            self.display_banner = display_banner
-        self.compute_banner()
-
-    def show_banner(self, banner=None):
-        if banner is None:
-            banner = self.banner
-        self.write(banner)
-
-    def compute_banner(self):
-        self.banner = self.banner1
-        if self.profile:
-            self.banner += '\nIPython profile: %s\n' % self.profile
-        if self.banner2:
-            self.banner += '\n' + self.banner2
-
-    def init_usage(self, usage=None):
-        if usage is None:
-            self.usage = interactive_usage
-        else:
-            self.usage = usage
-
-    #-------------------------------------------------------------------------
-    # Mainloop and code execution logic
-    #-------------------------------------------------------------------------
-
-    def mainloop(self, display_banner=None):
-        """Start the mainloop.
-
-        If an optional banner argument is given, it will override the
-        internally created default banner.
-        """
-        
-        with nested(self.builtin_trap, self.display_trap):
-
-            while 1:
-                try:
-                    self.interact(display_banner=display_banner)
-                    #self.interact_with_readline()                
-                    # XXX for testing of a readline-decoupled repl loop, call
-                    # interact_with_readline above
-                    break
-                except KeyboardInterrupt:
-                    # this should not be necessary, but KeyboardInterrupt
-                    # handling seems rather unpredictable...
-                    self.write("\nKeyboardInterrupt in interact()\n")
-
-    def interact(self, display_banner=None):
-        """Closely emulate the interactive Python console."""
-
-        # batch run -> do not interact        
-        if self.exit_now:
-            return
-
-        if display_banner is None:
-            display_banner = self.display_banner
-        if display_banner:
-            self.show_banner()
-
-        more = False
-        
-        # Mark activity in the builtins
-        __builtin__.__dict__['__IPYTHON__active'] += 1
-        
-        if self.has_readline:
-            self.readline_startup_hook(self.pre_readline)
-        # exit_now is set by a call to %Exit or %Quit, through the
-        # ask_exit callback.
-
-        while not self.exit_now:
-            self.hooks.pre_prompt_hook()
-            if more:
-                try:
-                    prompt = self.hooks.generate_prompt(True)
-                except:
-                    self.showtraceback()
-                if self.autoindent:
-                    self.rl_do_indent = True
-                    
-            else:
-                try:
-                    prompt = self.hooks.generate_prompt(False)
-                except:
-                    self.showtraceback()
-            try:
-                line = self.raw_input(prompt)
-                if self.exit_now:
-                    # quick exit on sys.std[in|out] close
-                    break
-                if self.autoindent:
-                    self.rl_do_indent = False
-                    
-            except KeyboardInterrupt:
-                #double-guard against keyboardinterrupts during kbdint handling
-                try:
-                    self.write('\nKeyboardInterrupt\n')
-                    self.input_splitter.reset()
-                    more = False
-                except KeyboardInterrupt:
-                    pass
-            except EOFError:
-                if self.autoindent:
-                    self.rl_do_indent = False
-                    if self.has_readline:
-                        self.readline_startup_hook(None)
-                self.write('\n')
-                self.exit()
-            except bdb.BdbQuit:
-                warn('The Python debugger has exited with a BdbQuit exception.\n'
-                     'Because of how pdb handles the stack, it is impossible\n'
-                     'for IPython to properly format this particular exception.\n'
-                     'IPython will resume normal operation.')
-            except:
-                # exceptions here are VERY RARE, but they can be triggered
-                # asynchronously by signal handlers, for example.
-                self.showtraceback()
-            else:
-                self.input_splitter.push(line)
-                more = self.input_splitter.push_accepts_more()
-                if (self.SyntaxTB.last_syntax_error and
-                    self.autoedit_syntax):
-                    self.edit_syntax_error()
-                if not more:
-                    source_raw = self.input_splitter.source_raw_reset()[1]
-                    self.run_cell(source_raw)
-                
-        # We are off again...
-        __builtin__.__dict__['__IPYTHON__active'] -= 1
-
-        # Turn off the exit flag, so the mainloop can be restarted if desired
-        self.exit_now = False
-
-    def raw_input(self, prompt=''):
-        """Write a prompt and read a line.
-
-        The returned line does not include the trailing newline.
-        When the user enters the EOF key sequence, EOFError is raised.
-
-        Optional inputs:
-
-          - prompt(''): a string to be printed to prompt the user.
-
-          - continue_prompt(False): whether this line is the first one or a
-          continuation in a sequence of inputs.
-        """
-        # Code run by the user may have modified the readline completer state.
-        # We must ensure that our completer is back in place.
-
-        if self.has_readline:
-            self.set_readline_completer()
-        
-        try:
-            line = raw_input_original(prompt).decode(self.stdin_encoding)
-        except ValueError:
-            warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
-                 " or sys.stdout.close()!\nExiting IPython!")
-            self.ask_exit()
-            return ""
-
-        # Try to be reasonably smart about not re-indenting pasted input more
-        # than necessary.  We do this by trimming out the auto-indent initial
-        # spaces, if the user's actual input started itself with whitespace.
-        if self.autoindent:
-            if num_ini_spaces(line) > self.indent_current_nsp:
-                line = line[self.indent_current_nsp:]
-                self.indent_current_nsp = 0
-        
-        return line
-
-    #-------------------------------------------------------------------------
-    # Methods to support auto-editing of SyntaxErrors.
-    #-------------------------------------------------------------------------
-
-    def edit_syntax_error(self):
-        """The bottom half of the syntax error handler called in the main loop.
-
-        Loop until syntax error is fixed or user cancels.
-        """
-
-        while self.SyntaxTB.last_syntax_error:
-            # copy and clear last_syntax_error
-            err = self.SyntaxTB.clear_err_state()
-            if not self._should_recompile(err):
-                return
-            try:
-                # may set last_syntax_error again if a SyntaxError is raised
-                self.safe_execfile(err.filename,self.user_ns)
-            except:
-                self.showtraceback()
-            else:
-                try:
-                    f = file(err.filename)
-                    try:
-                        # This should be inside a display_trap block and I 
-                        # think it is.
-                        sys.displayhook(f.read())
-                    finally:
-                        f.close()
-                except:
-                    self.showtraceback()
-
-    def _should_recompile(self,e):
-        """Utility routine for edit_syntax_error"""
-
-        if e.filename in ('<ipython console>','<input>','<string>',
-                          '<console>','<BackgroundJob compilation>',
-                          None):
-                              
-            return False
-        try:
-            if (self.autoedit_syntax and 
-                not self.ask_yes_no('Return to editor to correct syntax error? '
-                              '[Y/n] ','y')):
-                return False
-        except EOFError:
-            return False
-
-        def int0(x):
-            try:
-                return int(x)
-            except TypeError:
-                return 0
-        # always pass integer line and offset values to editor hook
-        try:
-            self.hooks.fix_error_editor(e.filename,
-                int0(e.lineno),int0(e.offset),e.msg)
-        except TryNext:
-            warn('Could not open editor')
-            return False
-        return True
-
-    #-------------------------------------------------------------------------
-    # Things related to GUI support and pylab
-    #-------------------------------------------------------------------------
-
-    def enable_pylab(self, gui=None):
-        """Activate pylab support at runtime.
-
-        This turns on support for matplotlib, preloads into the interactive
-        namespace all of numpy and pylab, and configures IPython to correcdtly
-        interact with the GUI event loop.  The GUI backend to be used can be
-        optionally selected with the optional :param:`gui` argument.
-
-        Parameters
-        ----------
-        gui : optional, string
-
-          If given, dictates the choice of matplotlib GUI backend to use
-          (should be one of IPython's supported backends, 'tk', 'qt', 'wx' or
-          'gtk'), otherwise we use the default chosen by matplotlib (as
-          dictated by the matplotlib build-time options plus the user's
-          matplotlibrc configuration file).
-        """
-        # We want to prevent the loading of pylab to pollute the user's
-        # namespace as shown by the %who* magics, so we execute the activation
-        # code in an empty namespace, and we update *both* user_ns and
-        # user_ns_hidden with this information.
-        ns = {}
-        gui = pylab_activate(ns, gui)
-        self.user_ns.update(ns)
-        self.user_ns_hidden.update(ns)
-        # Now we must activate the gui pylab wants to use, and fix %run to take
-        # plot updates into account
-        enable_gui(gui)
-        self.magic_run = self._pylab_magic_run
-
-    #-------------------------------------------------------------------------
-    # Things related to exiting
-    #-------------------------------------------------------------------------
-
-    def ask_exit(self):
-        """ Ask the shell to exit. Can be overiden and used as a callback. """
-        self.exit_now = True
-
-    def exit(self):
-        """Handle interactive exit.
-
-        This method calls the ask_exit callback."""
-        if self.confirm_exit:
-            if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
-                self.ask_exit()
-        else:
-            self.ask_exit()
-            
-    #------------------------------------------------------------------------
-    # Magic overrides
-    #------------------------------------------------------------------------
-    # Once the base class stops inheriting from magic, this code needs to be
-    # moved into a separate machinery as well.  For now, at least isolate here
-    # the magics which this class needs to implement differently from the base
-    # class, or that are unique to it.
-
-    def magic_autoindent(self, parameter_s = ''):
-        """Toggle autoindent on/off (if available)."""
-
-        self.shell.set_autoindent()
-        print "Automatic indentation is:",['OFF','ON'][self.shell.autoindent]
-
-    @testdec.skip_doctest
-    def magic_cpaste(self, parameter_s=''):
-        """Paste & execute a pre-formatted code block from clipboard.
-        
-        You must terminate the block with '--' (two minus-signs) alone on the
-        line. You can also provide your own sentinel with '%paste -s %%' ('%%' 
-        is the new sentinel for this operation)
-        
-        The block is dedented prior to execution to enable execution of method
-        definitions. '>' and '+' characters at the beginning of a line are
-        ignored, to allow pasting directly from e-mails, diff files and
-        doctests (the '...' continuation prompt is also stripped).  The
-        executed block is also assigned to variable named 'pasted_block' for
-        later editing with '%edit pasted_block'.
-        
-        You can also pass a variable name as an argument, e.g. '%cpaste foo'.
-        This assigns the pasted block to variable 'foo' as string, without 
-        dedenting or executing it (preceding >>> and + is still stripped)
-        
-        '%cpaste -r' re-executes the block previously entered by cpaste.
-        
-        Do not be alarmed by garbled output on Windows (it's a readline bug). 
-        Just press enter and type -- (and press enter again) and the block 
-        will be what was just pasted.
-        
-        IPython statements (magics, shell escapes) are not supported (yet).
-
-        See also
-        --------
-        paste: automatically pull code from clipboard.
-        
-        Examples
-        --------
-        ::
-        
-          In [8]: %cpaste
-          Pasting code; enter '--' alone on the line to stop.
-          :>>> a = ["world!", "Hello"]
-          :>>> print " ".join(sorted(a))
-          :--
-          Hello world!
-        """
-        
-        opts,args = self.parse_options(parameter_s,'rs:',mode='string')
-        par = args.strip()
-        if opts.has_key('r'):
-            self._rerun_pasted()
-            return
-        
-        sentinel = opts.get('s','--')
-
-        block = self._strip_pasted_lines_for_code(
-            self._get_pasted_lines(sentinel))
-
-        self._execute_block(block, par)
-
-    def magic_paste(self, parameter_s=''):
-        """Paste & execute a pre-formatted code block from clipboard.
-        
-        The text is pulled directly from the clipboard without user
-        intervention and printed back on the screen before execution (unless
-        the -q flag is given to force quiet mode).
-
-        The block is dedented prior to execution to enable execution of method
-        definitions. '>' and '+' characters at the beginning of a line are
-        ignored, to allow pasting directly from e-mails, diff files and
-        doctests (the '...' continuation prompt is also stripped).  The
-        executed block is also assigned to variable named 'pasted_block' for
-        later editing with '%edit pasted_block'.
-        
-        You can also pass a variable name as an argument, e.g. '%paste foo'.
-        This assigns the pasted block to variable 'foo' as string, without 
-        dedenting or executing it (preceding >>> and + is still stripped)
-
-        Options
-        -------
-        
-          -r: re-executes the block previously entered by cpaste.
-
-          -q: quiet mode: do not echo the pasted text back to the terminal.
-        
-        IPython statements (magics, shell escapes) are not supported (yet).
-
-        See also
-        --------
-        cpaste: manually paste code into terminal until you mark its end.
-        """
-        opts,args = self.parse_options(parameter_s,'rq',mode='string')
-        par = args.strip()
-        if opts.has_key('r'):
-            self._rerun_pasted()
-            return
-
-        text = self.shell.hooks.clipboard_get()
-        block = self._strip_pasted_lines_for_code(text.splitlines())
-
-        # By default, echo back to terminal unless quiet mode is requested
-        if not opts.has_key('q'):
-            write = self.shell.write
-            write(self.shell.pycolorize(block))
-            if not block.endswith('\n'):
-                write('\n')
-            write("## -- End pasted text --\n")
-            
-        self._execute_block(block, par)
-
-
-InteractiveShellABC.register(TerminalInteractiveShell)
diff --git a/IPython/frontend/terminal/ipapp.py b/IPython/frontend/terminal/ipapp.py
deleted file mode 100755
index 3b6e3fff4db..00000000000
--- a/IPython/frontend/terminal/ipapp.py
+++ /dev/null
@@ -1,664 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-The :class:`~IPython.core.application.Application` object for the command
-line :command:`ipython` program.
-
-Authors
--------
-
-* Brian Granger
-* Fernando Perez
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from __future__ import absolute_import
-
-import logging
-import os
-import sys
-
-from IPython.core import release
-from IPython.core.crashhandler import CrashHandler
-from IPython.core.application import Application, BaseAppConfigLoader
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
-from IPython.config.loader import (
-    Config,
-    PyFileConfigLoader
-)
-from IPython.lib import inputhook
-from IPython.utils.path import filefind, get_ipython_dir
-from IPython.core import usage
-
-#-----------------------------------------------------------------------------
-# Globals, utilities and helpers
-#-----------------------------------------------------------------------------
-
-#: The default config file name for this application.
-default_config_file_name = u'ipython_config.py'
-
-
-class IPAppConfigLoader(BaseAppConfigLoader):
-
-    def _add_arguments(self):
-        super(IPAppConfigLoader, self)._add_arguments()
-        paa = self.parser.add_argument
-        paa('-p', 
-            '--profile', dest='Global.profile', type=unicode,
-            help=
-            """The string name of the ipython profile to be used.  Assume that your
-            config file is ipython_config-<name>.py (looks in current dir first,
-            then in IPYTHON_DIR). This is a quick way to keep and load multiple
-            config files for different tasks, especially if include your basic one
-            in your more specialized ones.  You can keep a basic
-            IPYTHON_DIR/ipython_config.py file and then have other 'profiles' which
-            include this one and load extra things for particular tasks.""",
-            metavar='Global.profile')
-        paa('--config-file', 
-            dest='Global.config_file', type=unicode,
-            help=
-            """Set the config file name to override default.  Normally IPython
-            loads ipython_config.py (from current directory) or
-            IPYTHON_DIR/ipython_config.py.  If the loading of your config file
-            fails, IPython starts with a bare bones configuration (no modules
-            loaded at all).""",
-            metavar='Global.config_file')
-        paa('--autocall', 
-            dest='InteractiveShell.autocall', type=int, 
-            help=
-            """Make IPython automatically call any callable object even if you
-            didn't type explicit parentheses. For example, 'str 43' becomes
-            'str(43)' automatically.  The value can be '0' to disable the feature,
-            '1' for 'smart' autocall, where it is not applied if there are no more
-            arguments on the line, and '2' for 'full' autocall, where all callable
-            objects are automatically called (even if no arguments are present).
-            The default is '1'.""",
-            metavar='InteractiveShell.autocall')
-        paa('--autoindent',
-            action='store_true', dest='InteractiveShell.autoindent',
-            help='Turn on autoindenting.')
-        paa('--no-autoindent',
-            action='store_false', dest='InteractiveShell.autoindent',
-            help='Turn off autoindenting.')
-        paa('--automagic',
-            action='store_true', dest='InteractiveShell.automagic',
-            help=
-            """Turn on the auto calling of magic commands. Type %%magic at the
-            IPython  prompt  for  more information.""")
-        paa('--no-automagic',
-            action='store_false', dest='InteractiveShell.automagic',
-            help='Turn off the auto calling of magic commands.')
-        paa('--autoedit-syntax',
-            action='store_true', dest='TerminalInteractiveShell.autoedit_syntax',
-            help='Turn on auto editing of files with syntax errors.')
-        paa('--no-autoedit-syntax',
-            action='store_false', dest='TerminalInteractiveShell.autoedit_syntax',
-            help='Turn off auto editing of files with syntax errors.')
-        paa('--banner',
-            action='store_true', dest='Global.display_banner',
-            help='Display a banner upon starting IPython.')
-        paa('--no-banner',
-            action='store_false', dest='Global.display_banner',
-            help="Don't display a banner upon starting IPython.")
-        paa('--cache-size',
-            type=int, dest='InteractiveShell.cache_size',
-            help=
-            """Set the size of the output cache.  The default is 1000, you can
-            change it permanently in your config file.  Setting it to 0 completely
-            disables the caching system, and the minimum value accepted is 20 (if
-            you provide a value less than 20, it is reset to 0 and a warning is
-            issued).  This limit is defined because otherwise you'll spend more
-            time re-flushing a too small cache than working""",
-            metavar='InteractiveShell.cache_size')
-        paa('--classic',
-            action='store_true', dest='Global.classic',
-            help="Gives IPython a similar feel to the classic Python prompt.")
-        paa('--colors',
-            type=str, dest='InteractiveShell.colors',
-            help="Set the color scheme (NoColor, Linux, and LightBG).",
-            metavar='InteractiveShell.colors')
-        paa('--color-info',
-            action='store_true', dest='InteractiveShell.color_info',
-            help=
-            """IPython can display information about objects via a set of func-
-            tions, and optionally can use colors for this, syntax highlighting
-            source code and various other elements.  However, because this
-            information is passed through a pager (like 'less') and many pagers get
-            confused with color codes, this option is off by default.  You can test
-            it and turn it on permanently in your ipython_config.py file if it
-            works for you.  Test it and turn it on permanently if it works with
-            your system.  The magic function %%color_info allows you to toggle this
-            inter- actively for testing.""")
-        paa('--no-color-info',
-            action='store_false', dest='InteractiveShell.color_info',
-            help="Disable using colors for info related things.")
-        paa('--confirm-exit',
-            action='store_true', dest='TerminalInteractiveShell.confirm_exit',
-            help=
-            """Set to confirm when you try to exit IPython with an EOF (Control-D
-            in Unix, Control-Z/Enter in Windows). By typing 'exit', 'quit' or
-            '%%Exit', you can force a direct exit without any confirmation.""")
-        paa('--no-confirm-exit',
-            action='store_false', dest='TerminalInteractiveShell.confirm_exit',
-            help="Don't prompt the user when exiting.")
-        paa('--deep-reload',
-            action='store_true', dest='InteractiveShell.deep_reload',
-            help=
-            """Enable deep (recursive) reloading by default. IPython can use the
-            deep_reload module which reloads changes in modules recursively (it
-            replaces the reload() function, so you don't need to change anything to
-            use it). deep_reload() forces a full reload of modules whose code may
-            have changed, which the default reload() function does not.  When
-            deep_reload is off, IPython will use the normal reload(), but
-            deep_reload will still be available as dreload(). This fea- ture is off
-            by default [which means that you have both normal reload() and
-            dreload()].""")
-        paa('--no-deep-reload',
-            action='store_false', dest='InteractiveShell.deep_reload',
-            help="Disable deep (recursive) reloading by default.")
-        paa('--editor',
-            type=str, dest='TerminalInteractiveShell.editor',
-            help="Set the editor used by IPython (default to $EDITOR/vi/notepad).",
-            metavar='TerminalInteractiveShell.editor')
-        paa('--log','-l', 
-            action='store_true', dest='InteractiveShell.logstart',
-            help="Start logging to the default log file (./ipython_log.py).")
-        paa('--logfile','-lf',
-            type=unicode, dest='InteractiveShell.logfile',
-            help="Start logging to logfile with this name.",
-            metavar='InteractiveShell.logfile')
-        paa('--log-append','-la',
-            type=unicode, dest='InteractiveShell.logappend',
-            help="Start logging to the given file in append mode.",
-            metavar='InteractiveShell.logfile')
-        paa('--pdb',
-            action='store_true', dest='InteractiveShell.pdb',
-            help="Enable auto calling the pdb debugger after every exception.")
-        paa('--no-pdb',
-            action='store_false', dest='InteractiveShell.pdb',
-            help="Disable auto calling the pdb debugger after every exception.")
-        paa('--pprint',
-            action='store_true', dest='PlainTextFormatter.pprint',
-            help="Enable auto pretty printing of results.")
-        paa('--no-pprint',
-            action='store_false', dest='PlainTextFormatter.pprint',
-            help="Disable auto auto pretty printing of results.")
-        paa('--prompt-in1','-pi1',
-            type=str, dest='InteractiveShell.prompt_in1',
-            help=
-            """Set the main input prompt ('In [\#]: ').  Note that if you are using
-            numbered prompts, the number is represented with a '\#' in the string.
-            Don't forget to quote strings with spaces embedded in them. Most
-            bash-like escapes can be used to customize IPython's prompts, as well
-            as a few additional ones which are IPython-spe- cific.  All valid
-            prompt escapes are described in detail in the Customization section of
-            the IPython manual.""",
-            metavar='InteractiveShell.prompt_in1')
-        paa('--prompt-in2','-pi2',
-            type=str, dest='InteractiveShell.prompt_in2',
-            help=
-            """Set the secondary input prompt (' .\D.: ').  Similar to the previous
-            option, but used for the continuation prompts. The special sequence
-            '\D' is similar to '\#', but with all digits replaced by dots (so you
-            can have your continuation prompt aligned with your input prompt).
-            Default: ' .\D.: ' (note three spaces at the start for alignment with
-            'In [\#]')""",
-            metavar='InteractiveShell.prompt_in2')
-        paa('--prompt-out','-po',
-            type=str, dest='InteractiveShell.prompt_out',
-            help="Set the output prompt ('Out[\#]:')",
-            metavar='InteractiveShell.prompt_out')
-        paa('--quick',
-            action='store_true', dest='Global.quick',
-            help="Enable quick startup with no config files.")
-        paa('--readline',
-            action='store_true', dest='InteractiveShell.readline_use',
-            help="Enable readline for command line usage.")
-        paa('--no-readline',
-            action='store_false', dest='InteractiveShell.readline_use',
-            help="Disable readline for command line usage.")
-        paa('--screen-length','-sl',
-            type=int, dest='TerminalInteractiveShell.screen_length',
-            help=
-            """Number of lines of your screen, used to control printing of very
-            long strings.  Strings longer than this number of lines will be sent
-            through a pager instead of directly printed.  The default value for
-            this is 0, which means IPython will auto-detect your screen size every
-            time it needs to print certain potentially long strings (this doesn't
-            change the behavior of the 'print' keyword, it's only triggered
-            internally). If for some reason this isn't working well (it needs
-            curses support), specify it yourself. Otherwise don't change the
-            default.""",
-            metavar='TerminalInteractiveShell.screen_length')
-        paa('--separate-in','-si',
-            type=str, dest='InteractiveShell.separate_in',
-            help="Separator before input prompts.  Default '\\n'.",
-            metavar='InteractiveShell.separate_in')
-        paa('--separate-out','-so',
-            type=str, dest='InteractiveShell.separate_out',
-            help="Separator before output prompts.  Default 0 (nothing).",
-            metavar='InteractiveShell.separate_out')
-        paa('--separate-out2','-so2', 
-            type=str, dest='InteractiveShell.separate_out2',
-            help="Separator after output prompts.  Default 0 (nonight).",
-            metavar='InteractiveShell.separate_out2')
-        paa('--no-sep',
-            action='store_true', dest='Global.nosep',
-            help="Eliminate all spacing between prompts.")
-        paa('--term-title',
-            action='store_true', dest='TerminalInteractiveShell.term_title',
-            help="Enable auto setting the terminal title.")
-        paa('--no-term-title',
-            action='store_false', dest='TerminalInteractiveShell.term_title',
-            help="Disable auto setting the terminal title.")
-        paa('--xmode',
-            type=str, dest='InteractiveShell.xmode',
-            help=
-            """Exception reporting mode ('Plain','Context','Verbose').  Plain:
-            similar to python's normal traceback printing.  Context: prints 5 lines
-            of context source code around each line in the traceback.  Verbose:
-            similar to Context, but additionally prints the variables currently
-            visible where the exception happened (shortening their strings if too
-            long).  This can potentially be very slow, if you happen to have a huge
-            data structure whose string representation is complex to compute.
-            Your computer may appear to freeze for a while with cpu usage at 100%%.
-            If this occurs, you can cancel the traceback with Ctrl-C (maybe hitting
-            it more than once).
-            """,
-            metavar='InteractiveShell.xmode')
-        paa('--ext',
-            type=str, dest='Global.extra_extension',
-            help="The dotted module name of an IPython extension to load.",
-            metavar='Global.extra_extension')
-        paa('-c',
-            type=str, dest='Global.code_to_run',
-            help="Execute the given command string.",
-            metavar='Global.code_to_run')
-        paa('-i',
-            action='store_true', dest='Global.force_interact',
-            help=
-            "If running code from the command line, become interactive afterwards.")
-
-        # Options to start with GUI control enabled from the beginning
-        paa('--gui',
-            type=str, dest='Global.gui',
-            help="Enable GUI event loop integration ('qt', 'wx', 'gtk').",
-            metavar='gui-mode')
-        paa('--pylab','-pylab',
-            type=str, dest='Global.pylab',
-            nargs='?', const='auto', metavar='gui-mode',
-            help="Pre-load matplotlib and numpy for interactive use. "+
-            "If no value is given, the gui backend is matplotlib's, else use "+
-            "one of:  ['tk', 'qt', 'wx', 'gtk', 'osx'].")
-
-        # Legacy GUI options.  Leave them in for backwards compatibility, but the
-        # 'thread' names are really a misnomer now.
-        paa('--wthread', '-wthread',
-            action='store_true', dest='Global.wthread',
-            help=
-            """Enable wxPython event loop integration. (DEPRECATED, use --gui wx)""")
-        paa('--q4thread', '--qthread', '-q4thread', '-qthread',
-            action='store_true', dest='Global.q4thread',
-            help=
-            """Enable Qt4 event loop integration. Qt3 is no longer supported.
-            (DEPRECATED, use --gui qt)""")
-        paa('--gthread', '-gthread',
-            action='store_true', dest='Global.gthread',
-            help=
-            """Enable GTK event loop integration. (DEPRECATED, use --gui gtk)""")
-
-
-#-----------------------------------------------------------------------------
-# Crash handler for this application
-#-----------------------------------------------------------------------------
-
-_message_template = """\
-Oops, $self.app_name crashed. We do our best to make it stable, but...
-
-A crash report was automatically generated with the following information:
-  - A verbatim copy of the crash traceback.
-  - A copy of your input history during this session.
-  - Data on your current $self.app_name configuration.
-
-It was left in the file named:
-\t'$self.crash_report_fname'
-If you can email this file to the developers, the information in it will help
-them in understanding and correcting the problem.
-
-You can mail it to: $self.contact_name at $self.contact_email
-with the subject '$self.app_name Crash Report'.
-
-If you want to do it now, the following command will work (under Unix):
-mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
-
-To ensure accurate tracking of this issue, please file a report about it at:
-$self.bug_tracker
-"""
-
-class IPAppCrashHandler(CrashHandler):
-    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
-
-    message_template = _message_template
-
-    def __init__(self, app):
-        contact_name = release.authors['Fernando'][0]
-        contact_email = release.authors['Fernando'][1]
-        bug_tracker = 'http://github.com/ipython/ipython/issues'
-        super(IPAppCrashHandler,self).__init__(
-            app, contact_name, contact_email, bug_tracker
-        )
-
-    def make_report(self,traceback):
-        """Return a string containing a crash report."""
-
-        sec_sep = self.section_sep
-        # Start with parent report
-        report = [super(IPAppCrashHandler, self).make_report(traceback)]
-        # Add interactive-specific info we may have
-        rpt_add = report.append
-        try:
-            rpt_add(sec_sep+"History of session input:")
-            for line in self.app.shell.user_ns['_ih']:
-                rpt_add(line)
-            rpt_add('\n*** Last line of input (may not be in above history):\n')
-            rpt_add(self.app.shell._last_input_line+'\n')
-        except:
-            pass
-
-        return ''.join(report)
-
-
-#-----------------------------------------------------------------------------
-# Main classes and functions
-#-----------------------------------------------------------------------------
-
-class IPythonApp(Application):
-    name = u'ipython'
-    #: argparse formats better the 'usage' than the 'description' field
-    description = None
-    usage = usage.cl_usage
-    command_line_loader = IPAppConfigLoader
-    default_config_file_name = default_config_file_name
-    crash_handler_class = IPAppCrashHandler
-
-    def create_default_config(self):
-        super(IPythonApp, self).create_default_config()
-        # Eliminate multiple lookups
-        Global = self.default_config.Global
-
-        # Set all default values
-        Global.display_banner = True
-        
-        # If the -c flag is given or a file is given to run at the cmd line
-        # like "ipython foo.py", normally we exit without starting the main
-        # loop.  The force_interact config variable allows a user to override
-        # this and interact.  It is also set by the -i cmd line flag, just
-        # like Python.
-        Global.force_interact = False
-
-        # By default always interact by starting the IPython mainloop.
-        Global.interact = True
-
-        # No GUI integration by default
-        Global.gui = False
-        # Pylab off by default
-        Global.pylab = False
-
-        # Deprecated versions of gui support that used threading, we support
-        # them just for bacwards compatibility as an alternate spelling for
-        # '--gui X'
-        Global.qthread = False
-        Global.q4thread = False
-        Global.wthread = False
-        Global.gthread = False
-
-    def load_file_config(self):
-        if hasattr(self.command_line_config.Global, 'quick'):
-            if self.command_line_config.Global.quick:
-                self.file_config = Config()
-                return
-        super(IPythonApp, self).load_file_config()
-
-    def post_load_file_config(self):
-        if hasattr(self.command_line_config.Global, 'extra_extension'):
-            if not hasattr(self.file_config.Global, 'extensions'):
-                self.file_config.Global.extensions = []
-            self.file_config.Global.extensions.append(
-                self.command_line_config.Global.extra_extension)
-            del self.command_line_config.Global.extra_extension
-
-    def pre_construct(self):
-        config = self.master_config
-
-        if hasattr(config.Global, 'classic'):
-            if config.Global.classic:
-                config.InteractiveShell.cache_size = 0
-                config.PlainTextFormatter.pprint = False
-                config.InteractiveShell.prompt_in1 = '>>> '
-                config.InteractiveShell.prompt_in2 = '... '
-                config.InteractiveShell.prompt_out = ''
-                config.InteractiveShell.separate_in = \
-                    config.InteractiveShell.separate_out = \
-                    config.InteractiveShell.separate_out2 = ''
-                config.InteractiveShell.colors = 'NoColor'
-                config.InteractiveShell.xmode = 'Plain'
-
-        if hasattr(config.Global, 'nosep'):
-            if config.Global.nosep:
-                config.InteractiveShell.separate_in = \
-                config.InteractiveShell.separate_out = \
-                config.InteractiveShell.separate_out2 = ''
-
-        # if there is code of files to run from the cmd line, don't interact
-        # unless the -i flag (Global.force_interact) is true.
-        code_to_run = config.Global.get('code_to_run','')
-        file_to_run = False
-        if self.extra_args and self.extra_args[0]:
-                file_to_run = True
-        if file_to_run or code_to_run:
-            if not config.Global.force_interact:
-                config.Global.interact = False
-
-    def construct(self):
-        # I am a little hesitant to put these into InteractiveShell itself.
-        # But that might be the place for them
-        sys.path.insert(0, '')
-
-        # Create an InteractiveShell instance.
-        self.shell = TerminalInteractiveShell.instance(config=self.master_config)
-
-    def post_construct(self):
-        """Do actions after construct, but before starting the app."""
-        config = self.master_config
-        
-        # shell.display_banner should always be False for the terminal 
-        # based app, because we call shell.show_banner() by hand below
-        # so the banner shows *before* all extension loading stuff.
-        self.shell.display_banner = False
-        if config.Global.display_banner and \
-            config.Global.interact:
-            self.shell.show_banner()
-
-        # Make sure there is a space below the banner.
-        if self.log_level <= logging.INFO: print
-
-        # Now a variety of things that happen after the banner is printed.
-        self._enable_gui_pylab()
-        self._load_extensions()
-        self._run_exec_lines()
-        self._run_exec_files()
-        self._run_cmd_line_code()
-
-    def _enable_gui_pylab(self):
-        """Enable GUI event loop integration, taking pylab into account."""
-        Global = self.master_config.Global
-
-        # Select which gui to use
-        if Global.gui:
-            gui = Global.gui
-        # The following are deprecated, but there's likely to be a lot of use
-        # of this form out there, so we might as well support it for now.  But
-        # the --gui option above takes precedence.
-        elif Global.wthread:
-            gui = inputhook.GUI_WX
-        elif Global.qthread:
-            gui = inputhook.GUI_QT
-        elif Global.gthread:
-            gui = inputhook.GUI_GTK
-        else:
-            gui = None
-
-        # Using --pylab will also require gui activation, though which toolkit
-        # to use may be chosen automatically based on mpl configuration.
-        if Global.pylab:
-            activate = self.shell.enable_pylab
-            if Global.pylab == 'auto':
-                gui = None
-            else:
-                gui = Global.pylab
-        else:
-            # Enable only GUI integration, no pylab
-            activate = inputhook.enable_gui
-
-        if gui or Global.pylab:
-            try:
-                self.log.info("Enabling GUI event loop integration, "
-                              "toolkit=%s, pylab=%s" % (gui, Global.pylab) )
-                activate(gui)
-            except:
-                self.log.warn("Error in enabling GUI event loop integration:")
-                self.shell.showtraceback()
-
-    def _load_extensions(self):
-        """Load all IPython extensions in Global.extensions.
-
-        This uses the :meth:`ExtensionManager.load_extensions` to load all
-        the extensions listed in ``self.master_config.Global.extensions``.
-        """
-        try:
-            if hasattr(self.master_config.Global, 'extensions'):
-                self.log.debug("Loading IPython extensions...")
-                extensions = self.master_config.Global.extensions
-                for ext in extensions:
-                    try:
-                        self.log.info("Loading IPython extension: %s" % ext)                        
-                        self.shell.extension_manager.load_extension(ext)
-                    except:
-                        self.log.warn("Error in loading extension: %s" % ext)
-                        self.shell.showtraceback()
-        except:
-            self.log.warn("Unknown error in loading extensions:")
-            self.shell.showtraceback()
-
-    def _run_exec_lines(self):
-        """Run lines of code in Global.exec_lines in the user's namespace."""
-        try:
-            if hasattr(self.master_config.Global, 'exec_lines'):
-                self.log.debug("Running code from Global.exec_lines...")
-                exec_lines = self.master_config.Global.exec_lines
-                for line in exec_lines:
-                    try:
-                        self.log.info("Running code in user namespace: %s" %
-                                      line)
-                        self.shell.run_cell(line, store_history=False)
-                    except:
-                        self.log.warn("Error in executing line in user "
-                                      "namespace: %s" % line)
-                        self.shell.showtraceback()
-        except:
-            self.log.warn("Unknown error in handling Global.exec_lines:")
-            self.shell.showtraceback()
-
-    def _exec_file(self, fname):
-        full_filename = filefind(fname, [u'.', self.ipython_dir])
-        if os.path.isfile(full_filename):
-            if full_filename.endswith(u'.py'):
-                self.log.info("Running file in user namespace: %s" %
-                              full_filename)
-                # Ensure that __file__ is always defined to match Python behavior
-                self.shell.user_ns['__file__'] = fname
-                try:
-                    self.shell.safe_execfile(full_filename, self.shell.user_ns)
-                finally:
-                    del self.shell.user_ns['__file__']
-            elif full_filename.endswith('.ipy'):
-                self.log.info("Running file in user namespace: %s" %
-                              full_filename)
-                self.shell.safe_execfile_ipy(full_filename)
-            else:
-                self.log.warn("File does not have a .py or .ipy extension: <%s>"
-                               % full_filename)
-    def _run_exec_files(self):
-        try:
-            if hasattr(self.master_config.Global, 'exec_files'):
-                self.log.debug("Running files in Global.exec_files...")
-                exec_files = self.master_config.Global.exec_files
-                for fname in exec_files:
-                    self._exec_file(fname)
-        except:
-            self.log.warn("Unknown error in handling Global.exec_files:")
-            self.shell.showtraceback()
-
-    def _run_cmd_line_code(self):
-        if hasattr(self.master_config.Global, 'code_to_run'):
-            line = self.master_config.Global.code_to_run
-            try:
-                self.log.info("Running code given at command line (-c): %s" %
-                              line)
-                self.shell.run_cell(line, store_history=False)
-            except:
-                self.log.warn("Error in executing line in user namespace: %s" %
-                              line)
-                self.shell.showtraceback()
-            return
-        # Like Python itself, ignore the second if the first of these is present
-        try:
-            fname = self.extra_args[0]
-        except:
-            pass
-        else:
-            try:
-                self._exec_file(fname)
-            except:
-                self.log.warn("Error in executing file in user namespace: %s" %
-                              fname)
-                self.shell.showtraceback()
-
-    def start_app(self):
-        if self.master_config.Global.interact:
-            self.log.debug("Starting IPython's mainloop...")
-            self.shell.mainloop()
-        else:
-            self.log.debug("IPython not interactive, start_app is no-op...")
-
-
-def load_default_config(ipython_dir=None):
-    """Load the default config file from the default ipython_dir.
-
-    This is useful for embedded shells.
-    """
-    if ipython_dir is None:
-        ipython_dir = get_ipython_dir()
-    cl = PyFileConfigLoader(default_config_file_name, ipython_dir)
-    config = cl.load_config()
-    return config
-
-
-def launch_new_instance():
-    """Create and run a full blown IPython instance"""
-    app = IPythonApp()
-    app.start()
-
-
-if __name__ == '__main__':
-    launch_new_instance()
diff --git a/IPython/frontend/terminal/tests/__init__.py b/IPython/frontend/terminal/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/kernel/__init__.py b/IPython/kernel/__init__.py
deleted file mode 100644
index a126c0b0ac0..00000000000
--- a/IPython/kernel/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""IPython.kernel has been replaced by IPython.parallel.
-
-The previous version of IPython's parallel library was located at this
-location (IPython.kernel). It has been moved to the IPython.parallel
-subpackage and has been refactored to use zeromq/pyzmq instead of twisted.
-
-Please see INSERT URL for further details.
-"""
-
-raise ImportError(__doc__)
diff --git a/IPython/lib/__init__.py b/IPython/lib/__init__.py
index 7b14e55aa1d..cf8ccb04151 100644
--- a/IPython/lib/__init__.py
+++ b/IPython/lib/__init__.py
@@ -1,29 +1,11 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """
 Extra capabilities for IPython
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from IPython.lib.inputhook import (
-    enable_wx, disable_wx,
-    enable_gtk, disable_gtk,
-    enable_qt4, disable_qt4,
-    enable_tk, disable_tk,
-    set_inputhook, clear_inputhook,
-    current_gui
-)
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
diff --git a/IPython/lib/backgroundjobs.py b/IPython/lib/backgroundjobs.py
index aec45266768..29345ab87ac 100644
--- a/IPython/lib/backgroundjobs.py
+++ b/IPython/lib/backgroundjobs.py
@@ -17,6 +17,9 @@
 
 (although ultimately no code from this text was used, as IPython's system is a
 separate implementation).
+
+An example notebook is provided in our documentation illustrating interactive
+use of the system.
 """
 
 #*****************************************************************************
@@ -30,8 +33,10 @@
 import sys
 import threading
 
+from IPython import get_ipython
 from IPython.core.ultratb import AutoFormattedTB
-from IPython.utils.warn import warn, error
+from logging import error, debug
+
 
 class BackgroundJobManager:
     """Class to manage a pool of backgrounded threaded jobs.
@@ -52,7 +57,7 @@ class BackgroundJobManager:
 
       jobs.remove(N) -> remove (finished) job N
 
-      jobs.flush_finished() -> remove all finished jobs
+      jobs.flush() -> remove all finished jobs
       
     As a convenience feature, BackgroundJobManager instances provide the
     utility result and traceback methods which retrieve the corresponding
@@ -63,17 +68,16 @@ class BackgroundJobManager:
 
     While this appears minor, it allows you to use tab completion
     interactively on the job manager instance.
-
-    In interactive mode, IPython provides the magic fuction %bg for quick
-    creation of backgrounded expression-based jobs. Type bg? for details."""
+    """
 
     def __init__(self):
-        # Lists for job management
-        self.jobs_run  = []
-        self.jobs_comp = []
-        self.jobs_dead = []
+        # Lists for job management, accessed via a property to ensure they're
+        # up to date.x
+        self._running  = []
+        self._completed = []
+        self._dead = []
         # A dict of all jobs, so users can easily access any of them
-        self.jobs_all = {}
+        self.all = {}
         # For reporting
         self._comp_report = []
         self._dead_report = []
@@ -82,8 +86,24 @@ def __init__(self):
         self._s_running   = BackgroundJobBase.stat_running_c
         self._s_completed = BackgroundJobBase.stat_completed_c
         self._s_dead      = BackgroundJobBase.stat_dead_c
+        self._current_job_id = 0
+
+    @property
+    def running(self):
+        self._update_status()
+        return self._running
+
+    @property
+    def dead(self):
+        self._update_status()
+        return self._dead
 
-    def new(self,func_or_exp,*args,**kwargs):
+    @property
+    def completed(self):
+        self._update_status()
+        return self._completed
+
+    def new(self, func_or_exp, *args, **kwargs):
         """Add a new background job and start it in a separate thread.
 
         There are two types of jobs which can be created:
@@ -96,7 +116,7 @@ def new(self,func_or_exp,*args,**kwargs):
         The given expression is passed to eval(), along with the optional
         global/local dicts provided.  If no dicts are given, they are
         extracted automatically from the caller's frame.
-        
+
         A Python statement is NOT a valid eval() expression.  Basically, you
         can only use as an eval() argument something which can go on the right
         of an '=' sign and be assigned to a variable.
@@ -106,22 +126,24 @@ def new(self,func_or_exp,*args,**kwargs):
         2. Jobs given a function object, optionally passing additional
         positional arguments:
 
-          job_manager.new(myfunc,x,y)
+          job_manager.new(myfunc, x, y)
 
         The function is called with the given arguments.
 
         If you need to pass keyword arguments to your function, you must
         supply them as a dict named kw:
 
-          job_manager.new(myfunc,x,y,kw=dict(z=1))
+          job_manager.new(myfunc, x, y, kw=dict(z=1))
 
-        The reason for this assymmetry is that the new() method needs to
+        The reason for this asymmetry is that the new() method needs to
         maintain access to its own keywords, and this prevents name collisions
         between arguments to new() and arguments to your own functions.
 
         In both cases, the result is stored in the job.result field of the
         background job object.
 
+        You can set `daemon` attribute of the thread by giving the keyword
+        argument `daemon`.
 
         Notes and caveats:
 
@@ -149,7 +171,7 @@ def new(self,func_or_exp,*args,**kwargs):
         if callable(func_or_exp):
             kw  = kwargs.get('kw',{})
             job = BackgroundJobFunc(func_or_exp,*args,**kw)
-        elif isinstance(func_or_exp,basestring):
+        elif isinstance(func_or_exp, str):
             if not args:
                 frame = sys._getframe(1)
                 glob, loc = frame.f_globals, frame.f_locals
@@ -158,30 +180,31 @@ def new(self,func_or_exp,*args,**kwargs):
             elif len(args)==2:
                 glob,loc = args
             else:
-                raise ValueError,\
-                      'Expression jobs take at most 2 args (globals,locals)'
-            job = BackgroundJobExpr(func_or_exp,glob,loc)
-        else:
-            raise
-        jkeys = self.jobs_all.keys()
-        if jkeys:
-            job.num = max(jkeys)+1
+                raise ValueError(
+                      'Expression jobs take at most 2 args (globals,locals)')
+            job = BackgroundJobExpr(func_or_exp, glob, loc)
         else:
-            job.num = 0
-        self.jobs_run.append(job)
-        self.jobs_all[job.num] = job
-        print 'Starting job # %s in a separate thread.' % job.num
+            raise TypeError('invalid args for new job')
+
+        if kwargs.get('daemon', False):
+            job.daemon = True
+        job.num = self._current_job_id
+        self._current_job_id += 1
+        self.running.append(job)
+        self.all[job.num] = job
+        debug('Starting job # %s in a separate thread.' % job.num)
         job.start()
         return job
 
-    def __getitem__(self,key):
-        return self.jobs_all[key]
+    def __getitem__(self, job_key):
+        num = job_key if isinstance(job_key, int) else job_key.num
+        return self.all[num]
 
     def __call__(self):
         """An alias to self.status(),
 
         This allows you to simply call a job manager instance much like the
-        Unix jobs shell command."""
+        Unix `jobs` shell command."""
 
         return self.status()
 
@@ -189,29 +212,34 @@ def _update_status(self):
         """Update the status of the job lists.
 
         This method moves finished jobs to one of two lists:
-          - self.jobs_comp: jobs which completed successfully
-          - self.jobs_dead: jobs which finished but died.
+          - self.completed: jobs which completed successfully
+          - self.dead: jobs which finished but died.
 
         It also copies those jobs to corresponding _report lists.  These lists
         are used to report jobs completed/dead since the last update, and are
         then cleared by the reporting function after each call."""
-        
-        run,comp,dead = self._s_running,self._s_completed,self._s_dead
-        jobs_run = self.jobs_run
-        for num in range(len(jobs_run)):
-            job  = jobs_run[num]
+
+        # Status codes
+        srun, scomp, sdead = self._s_running, self._s_completed, self._s_dead
+        # State lists, use the actual lists b/c the public names are properties
+        # that call this very function on access
+        running, completed, dead = self._running, self._completed, self._dead
+
+        # Now, update all state lists
+        for num, job in enumerate(running):
             stat = job.stat_code
-            if stat == run:
+            if stat == srun:
                 continue
-            elif stat == comp:
-                self.jobs_comp.append(job)
+            elif stat == scomp:
+                completed.append(job)
                 self._comp_report.append(job)
-                jobs_run[num] = False
-            elif stat == dead:
-                self.jobs_dead.append(job)
+                running[num] = False
+            elif stat == sdead:
+                dead.append(job)
                 self._dead_report.append(job)
-                jobs_run[num] = False
-        self.jobs_run = filter(None,self.jobs_run)
+                running[num] = False
+        # Remove dead/completed jobs from running list
+        running[:] = filter(None, running)
 
     def _group_report(self,group,name):
         """Report summary for a given job group.
@@ -219,10 +247,10 @@ def _group_report(self,group,name):
         Return True if the group had any elements."""
 
         if group:
-            print '%s jobs:' % name
+            print('%s jobs:' % name)
             for job in group:
-                print '%s : %s' % (job.num,job)
-            print
+                print('%s : %s' % (job.num,job))
+            print()
             return True
 
     def _group_flush(self,group,name):
@@ -233,7 +261,7 @@ def _group_flush(self,group,name):
         njobs = len(group)
         if njobs:
             plural = {1:''}.setdefault(njobs,'s')
-            print 'Flushing %s %s job%s.' % (njobs,name,plural)
+            print('Flushing %s %s job%s.' % (njobs,name,plural))
             group[:] = []
             return True
         
@@ -246,7 +274,7 @@ def _status_new(self):
         which have finished since the last time it was called."""
 
         self._update_status()
-        new_comp = self._group_report(self._comp_report,'Completed')
+        new_comp = self._group_report(self._comp_report, 'Completed')
         new_dead = self._group_report(self._dead_report,
                                       'Dead, call jobs.traceback() for details')
         self._comp_report[:] = []
@@ -257,9 +285,9 @@ def status(self,verbose=0):
         """Print a status of all jobs currently being managed."""
 
         self._update_status()
-        self._group_report(self.jobs_run,'Running')
-        self._group_report(self.jobs_comp,'Completed')
-        self._group_report(self.jobs_dead,'Dead')
+        self._group_report(self.running,'Running')
+        self._group_report(self.completed,'Completed')
+        self._group_report(self.dead,'Dead')
         # Also flush the report queues
         self._comp_report[:] = []
         self._dead_report[:] = []
@@ -268,7 +296,7 @@ def remove(self,num):
         """Remove a finished (completed or dead) job."""
 
         try:
-            job = self.jobs_all[num]
+            job = self.all[num]
         except KeyError:
             error('Job #%s not found' % num)
         else:
@@ -277,12 +305,12 @@ def remove(self,num):
                 error('Job #%s is still running, it can not be removed.' % num)
                 return
             elif stat_code == self._s_completed:
-                self.jobs_comp.remove(job)
+                self.completed.remove(job)
             elif stat_code == self._s_dead:
-                self.jobs_dead.remove(job)
+                self.dead.remove(job)
 
-    def flush_finished(self):
-        """Flush all jobs finished (completed and dead) from lists.
+    def flush(self):
+        """Flush all finished jobs (completed and dead) from lists.
 
         Running jobs are never flushed.
 
@@ -290,35 +318,41 @@ def flush_finished(self):
         completed since the last _status_new() call, the flush operation
         aborts."""
 
-        if self._status_new():
-            error('New jobs completed since last '\
-                  '_status_new(), aborting flush.')
-            return
-
         # Remove the finished jobs from the master dict
-        jobs_all = self.jobs_all
-        for job in self.jobs_comp+self.jobs_dead:
-            del(jobs_all[job.num])
+        alljobs = self.all
+        for job in self.completed+self.dead:
+            del(alljobs[job.num])
 
         # Now flush these lists completely
-        fl_comp = self._group_flush(self.jobs_comp,'Completed')
-        fl_dead = self._group_flush(self.jobs_dead,'Dead')
+        fl_comp = self._group_flush(self.completed, 'Completed')
+        fl_dead = self._group_flush(self.dead, 'Dead')
         if not (fl_comp or fl_dead):
-            print 'No jobs to flush.'
+            print('No jobs to flush.')
 
     def result(self,num):
         """result(N) -> return the result of job N."""
         try:
-            return self.jobs_all[num].result
+            return self.all[num].result
         except KeyError:
             error('Job #%s not found' % num)
 
-    def traceback(self,num):
+    def _traceback(self, job):
+        num = job if isinstance(job, int) else job.num
         try:
-            self.jobs_all[num].traceback()
+            self.all[num].traceback()
         except KeyError:
             error('Job #%s not found' % num)
 
+    def traceback(self, job=None):
+        if job is None:
+            self._update_status()
+            for deadjob in self.dead:
+                print("Traceback for: %r" % deadjob)
+                self._traceback(deadjob)
+                print()
+        else:
+            self._traceback(job)
+
 
 class BackgroundJobBase(threading.Thread):
     """Base class to build BackgroundJob classes.
@@ -326,13 +360,14 @@ class BackgroundJobBase(threading.Thread):
     The derived classes must implement:
 
     - Their own __init__, since the one here raises NotImplementedError.  The
-    derived constructor must call self._init() at the end, to provide common
-    initialization.
+      derived constructor must call self._init() at the end, to provide common
+      initialization.
 
     - A strform attribute used in calls to __str__.
 
     - A call() method, which will make the actual execution call and must
-    return a value to be held in the 'result' field of the job object."""
+      return a value to be held in the 'result' field of the job object.
+    """
 
     # Class constants for status, in string and as numerical codes (when
     # updating jobs lists, we don't want to do string comparisons).  This will
@@ -344,8 +379,11 @@ class BackgroundJobBase(threading.Thread):
     stat_dead_c = -1
 
     def __init__(self):
-        raise NotImplementedError, \
-              "This class can not be instantiated directly."
+        """Must be implemented in subclasses.
+
+        Subclasses must call :meth:`_init` for standard initialisation.
+        """
+        raise NotImplementedError("This class can not be instantiated directly.")
 
     def _init(self):
         """Common initialization for all BackgroundJob objects"""
@@ -360,14 +398,19 @@ def _init(self):
         self.stat_code = BackgroundJobBase.stat_created_c
         self.finished  = False
         self.result    = '<BackgroundJob has not completed>'
+        
         # reuse the ipython traceback handler if we can get to it, otherwise
         # make a new one
         try:
-            self._make_tb = __IPYTHON__.InteractiveTB.text
+            make_tb = get_ipython().InteractiveTB.text
         except:
-            self._make_tb = AutoFormattedTB(mode = 'Context',
-                                           color_scheme='NoColor',
-                                           tb_offset = 1).text
+            make_tb = AutoFormattedTB(
+                mode="Context", color_scheme="nocolor", tb_offset=1
+            ).text
+        # Note that the actual API for text() requires the three args to be
+        # passed in, so we wrap it in a simple lambda.
+        self._make_tb = lambda : make_tb(None, None, None)
+
         # Hold a formatted traceback if one is generated.
         self._tb = None
         
@@ -377,10 +420,10 @@ def __str__(self):
         return self.strform
 
     def __repr__(self):
-        return '<BackgroundJob: %s>' % self.strform
+        return '<BackgroundJob #%d: %s>' % (self.num, self.strform)
 
     def traceback(self):
-        print self._tb
+        print(self._tb)
         
     def run(self):
         try:
@@ -398,10 +441,11 @@ def run(self):
             self.stat_code = BackgroundJobBase.stat_completed_c
             self.finished  = True
 
+
 class BackgroundJobExpr(BackgroundJobBase):
     """Evaluate an expression as a background job (uses a separate thread)."""
 
-    def __init__(self,expression,glob=None,loc=None):
+    def __init__(self, expression, glob=None, loc=None):
         """Create a new job from a string which can be fed to eval().
 
         global/locals dicts can be provided, which will be passed to the eval
@@ -410,11 +454,8 @@ def __init__(self,expression,glob=None,loc=None):
         # fail immediately if the given expression can't be compiled
         self.code = compile(expression,'<BackgroundJob compilation>','eval')
                 
-        if glob is None:
-            glob = {}
-        if loc is None:
-            loc = {}
-            
+        glob = {} if glob is None else glob
+        loc = {} if loc is None else loc
         self.expression = self.strform = expression
         self.glob = glob
         self.loc = loc
@@ -423,21 +464,19 @@ def __init__(self,expression,glob=None,loc=None):
     def call(self):
         return eval(self.code,self.glob,self.loc)
 
+
 class BackgroundJobFunc(BackgroundJobBase):
     """Run a function call as a background job (uses a separate thread)."""
 
-    def __init__(self,func,*args,**kwargs):
+    def __init__(self, func, *args, **kwargs):
         """Create a new job from a callable object.
 
         Any positional arguments and keyword args given to this constructor
         after the initial callable are passed directly to it."""
 
-        assert callable(func),'first argument must be callable'
-        
-        if args is None:
-            args = []
-        if kwargs is None:
-            kwargs = {}
+        if not callable(func):
+            raise TypeError(
+                'first argument to BackgroundJobFunc must be callable')
         
         self.func = func
         self.args = args
@@ -449,42 +488,4 @@ def __init__(self,func,*args,**kwargs):
         self._init()
 
     def call(self):
-        return self.func(*self.args,**self.kwargs)
-
-
-if __name__=='__main__':
-
-    import time
-
-    def sleepfunc(interval=2,*a,**kw):
-        args = dict(interval=interval,
-                    args=a,
-                    kwargs=kw)
-        time.sleep(interval)
-        return args
-
-    def diefunc(interval=2,*a,**kw):
-        time.sleep(interval)
-        die
-
-    def printfunc(interval=1,reps=5):
-        for n in range(reps):
-            time.sleep(interval)
-            print 'In the background...'
-
-    jobs = BackgroundJobManager()
-    # first job will have # 0
-    jobs.new(sleepfunc,4)
-    jobs.new(sleepfunc,kw={'reps':2})
-    # This makes a job which will die
-    jobs.new(diefunc,1)
-    jobs.new('printfunc(1,3)')
-
-    # after a while, you can get the traceback of a dead job.  Run the line
-    # below again interactively until it prints a traceback (check the status
-    # of the job):
-    print jobs[1].status
-    jobs[1].traceback()
-    
-    # Run this line again until the printed result changes
-    print "The result of job #0 is:",jobs[0].result
+        return self.func(*self.args, **self.kwargs)
diff --git a/IPython/lib/clipboard.py b/IPython/lib/clipboard.py
index f42b93b0513..e0bf80b0755 100644
--- a/IPython/lib/clipboard.py
+++ b/IPython/lib/clipboard.py
@@ -1,10 +1,15 @@
 """ Utilities for accessing the platform's clipboard.
 """
 
+import os
 import subprocess
-import sys
 
 from IPython.core.error import TryNext
+import IPython.utils.py3compat as py3compat
+
+
+class ClipboardEmpty(ValueError):
+    pass
 
 
 def win32_clipboard_get():
@@ -14,26 +19,35 @@ def win32_clipboard_get():
     """
     try:
         import win32clipboard
-    except ImportError:
-        message = ("Getting text from the clipboard requires the pywin32 "
-            "extensions: http://sourceforge.net/projects/pywin32/")
-        raise TryNext(message)
-    win32clipboard.OpenClipboard() 
-    text = win32clipboard.GetClipboardData(win32clipboard.CF_TEXT) 
-    # FIXME: convert \r\n to \n?
-    win32clipboard.CloseClipboard() 
+    except ImportError as e:
+        raise TryNext("Getting text from the clipboard requires the pywin32 "
+                      "extensions: http://sourceforge.net/projects/pywin32/") from e
+    win32clipboard.OpenClipboard()
+    try:
+        text = win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
+    except (TypeError, win32clipboard.error):
+        try:
+            text = win32clipboard.GetClipboardData(win32clipboard.CF_TEXT)
+            text = py3compat.cast_unicode(text, py3compat.DEFAULT_ENCODING)
+        except (TypeError, win32clipboard.error) as e:
+            raise ClipboardEmpty from e
+    finally:
+        win32clipboard.CloseClipboard()
     return text
 
-def osx_clipboard_get():
+
+def osx_clipboard_get() -> str:
     """ Get the clipboard's text on OS X.
     """
     p = subprocess.Popen(['pbpaste', '-Prefer', 'ascii'],
         stdout=subprocess.PIPE)
-    text, stderr = p.communicate()
+    bytes_, stderr = p.communicate()
     # Text comes in with old Mac \r line endings. Change them to \n.
-    text = text.replace('\r', '\n')
+    bytes_ = bytes_.replace(b'\r', b'\n')
+    text = py3compat.decode(bytes_)
     return text
 
+
 def tkinter_clipboard_get():
     """ Get the clipboard's text using Tkinter.
 
@@ -42,15 +56,47 @@ def tkinter_clipboard_get():
     implementation that uses that toolkit.
     """
     try:
-        import Tkinter
-    except ImportError:
-        message = ("Getting text from the clipboard on this platform "
-            "requires Tkinter.")
-        raise TryNext(message)
-    root = Tkinter.Tk()
+        from tkinter import Tk, TclError 
+    except ImportError as e:
+        raise TryNext("Getting text from the clipboard on this platform requires tkinter.") from e
+        
+    root = Tk()
     root.withdraw()
-    text = root.clipboard_get()
-    root.destroy()
+    try:
+        text = root.clipboard_get()
+    except TclError as e:
+        raise ClipboardEmpty from e
+    finally:
+        root.destroy()
+    text = py3compat.cast_unicode(text, py3compat.DEFAULT_ENCODING)
     return text
 
 
+def wayland_clipboard_get():
+    """Get the clipboard's text under Wayland using wl-paste command.
+
+    This requires Wayland and wl-clipboard installed and running.
+    """
+    if os.environ.get("XDG_SESSION_TYPE") != "wayland":
+        raise TryNext("wayland is not detected")
+
+    try:
+        with subprocess.Popen(["wl-paste"], stdout=subprocess.PIPE) as p:
+            raw, err = p.communicate()
+            if p.wait():
+                raise TryNext(err)
+    except FileNotFoundError as e:
+        raise TryNext(
+            "Getting text from the clipboard under Wayland requires the wl-clipboard "
+            "extension: https://github.com/bugaevc/wl-clipboard"
+        ) from e
+
+    if not raw:
+        raise ClipboardEmpty
+
+    try:
+        text = py3compat.decode(raw)
+    except UnicodeDecodeError as e:
+        raise ClipboardEmpty from e
+
+    return text
diff --git a/IPython/lib/deepreload.py b/IPython/lib/deepreload.py
index 5925ee00c53..aaedab24255 100644
--- a/IPython/lib/deepreload.py
+++ b/IPython/lib/deepreload.py
@@ -1,22 +1,24 @@
 # -*- coding: utf-8 -*-
 """
-A module to change reload() so that it acts recursively.
-To enable it type::
+Provides a reload() function that acts recursively.
 
-    import __builtin__, deepreload
-    __builtin__.reload = deepreload.reload
+Python's normal :func:`python:reload` function only reloads the module that it's
+passed. The :func:`reload` function in this module also reloads everything
+imported from that module, which is useful when you're changing files deep
+inside a package.
 
-You can then disable it with::
+To use this as your default reload function, type this::
 
-    __builtin__.reload = deepreload.original_reload
-    
-Alternatively, you can add a dreload builtin alongside normal reload with::
+    import builtins
+    from IPython.lib import deepreload
+    builtins.reload = deepreload.reload
 
-    __builtin__.dreload = deepreload.reload
-    
-This code is almost entirely based on knee.py from the standard library.
-"""
+A reference to the original :func:`python:reload` is stored in this module as
+:data:`original_reload`, so you can restore it later.
 
+This code is almost entirely based on knee.py, which is a Python
+re-implementation of hierarchical module import.
+"""
 #*****************************************************************************
 #       Copyright (C) 2001 Nathaniel Gray <n8gray@caltech.edu>
 #
@@ -24,162 +26,285 @@
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-import __builtin__
-import imp
+import builtins as builtin_mod
+from contextlib import contextmanager
+import importlib
 import sys
 
-# Replacement for __import__()
-def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1):
-    # For now level is ignored, it's just there to prevent crash  
-    # with from __future__ import absolute_import
-    parent = determine_parent(globals)
-    q, tail = find_head_package(parent, name)
-    m = load_tail(q, tail)
-    if not fromlist:
-        return q
-    if hasattr(m, "__path__"):
-        ensure_fromlist(m, fromlist)
-    return m
+from types import ModuleType
+from warnings import warn
+import types
+
+original_import = builtin_mod.__import__
+
+@contextmanager
+def replace_import_hook(new_import):
+    saved_import = builtin_mod.__import__
+    builtin_mod.__import__ = new_import
+    try:
+        yield
+    finally:
+        builtin_mod.__import__ = saved_import
+
+def get_parent(globals, level):
+    """
+    parent, name = get_parent(globals, level)
+
+    Return the package that an import is being performed in.  If globals comes
+    from the module foo.bar.bat (not itself a package), this returns the
+    sys.modules entry for foo.bar.  If globals is from a package's __init__.py,
+    the package's entry in sys.modules is returned.
+
+    If globals doesn't come from a package or a module in a package, or a
+    corresponding entry is not found in sys.modules, None is returned.
+    """
+    orig_level = level
+
+    if not level or not isinstance(globals, dict):
+        return None, ''
+
+    pkgname = globals.get('__package__', None)
 
-def determine_parent(globals):
-    if not globals or  not globals.has_key("__name__"):
-        return None
-    pname = globals['__name__']
-    if globals.has_key("__path__"):
-        parent = sys.modules[pname]
-        assert globals is parent.__dict__
-        return parent
-    if '.' in pname:
-        i = pname.rfind('.')
-        pname = pname[:i]
-        parent = sys.modules[pname]
-        assert parent.__name__ == pname
-        return parent
-    return None
-
-def find_head_package(parent, name):
-    # Import the first
-    if '.' in name:
-        # 'some.nested.package' -> head = 'some', tail = 'nested.package'
-        i = name.find('.')
-        head = name[:i]
-        tail = name[i+1:]
+    if pkgname is not None:
+        # __package__ is set, so use it
+        if not hasattr(pkgname, 'rindex'):
+            raise ValueError('__package__ set to non-string')
+        if len(pkgname) == 0:
+            if level > 0:
+                raise ValueError('Attempted relative import in non-package')
+            return None, ''
+        name = pkgname
     else:
-        # 'packagename' -> head = 'packagename', tail = ''
-        head = name
-        tail = ""
-    if parent:
-        # If this is a subpackage then qname = parent's name + head
-        qname = "%s.%s" % (parent.__name__, head)
+        # __package__ not set, so figure it out and set it
+        if '__name__' not in globals:
+            return None, ''
+        modname = globals['__name__']
+
+        if '__path__' in globals:
+            # __path__ is set, so modname is already the package name
+            globals['__package__'] = name = modname
+        else:
+            # Normal module, so work out the package name if any
+            lastdot = modname.rfind('.')
+            if lastdot < 0 < level:
+                raise ValueError("Attempted relative import in non-package")
+            if lastdot < 0:
+                globals['__package__'] = None
+                return None, ''
+            globals['__package__'] = name = modname[:lastdot]
+
+    dot = len(name)
+    for x in range(level, 1, -1):
+        try:
+            dot = name.rindex('.', 0, dot)
+        except ValueError as e:
+            raise ValueError("attempted relative import beyond top-level "
+                             "package") from e
+    name = name[:dot]
+
+    try:
+        parent = sys.modules[name]
+    except BaseException as e:
+        if orig_level < 1:
+            warn("Parent module '%.200s' not found while handling absolute "
+                 "import" % name)
+            parent = None
+        else:
+            raise SystemError("Parent module '%.200s' not loaded, cannot "
+                              "perform relative import" % name) from e
+
+    # We expect, but can't guarantee, if parent != None, that:
+    # - parent.__name__ == name
+    # - parent.__dict__ is globals
+    # If this is violated...  Who cares?
+    return parent, name
+
+def load_next(mod, altmod, name, buf):
+    """
+    mod, name, buf = load_next(mod, altmod, name, buf)
+
+    altmod is either None or same as mod
+    """
+
+    if len(name) == 0:
+        # completely empty module name should only happen in
+        # 'from . import' (or '__import__("")')
+        return mod, None, buf
+
+    dot = name.find('.')
+    if dot == 0:
+        raise ValueError('Empty module name')
+
+    if dot < 0:
+        subname = name
+        next = None
     else:
-        qname = head
-    q = import_module(head, qname, parent)
-    if q: return q, tail
-    if parent:
-        qname = head
-        parent = None
-        q = import_module(head, qname, parent)
-        if q: return q, tail
-    raise ImportError, "No module named " + qname
-
-def load_tail(q, tail):
-    m = q
-    while tail:
-        i = tail.find('.')
-        if i < 0: i = len(tail)
-        head, tail = tail[:i], tail[i+1:]
-
-        # fperez: fix dotted.name reloading failures by changing:
-        #mname = "%s.%s" % (m.__name__, head)
-        # to:
-        mname = m.__name__
-        # This needs more testing!!! (I don't understand this module too well)
-        
-        #print '** head,tail=|%s|->|%s|, mname=|%s|' % (head,tail,mname)  # dbg
-        m = import_module(head, mname, m)
-        if not m:
-            raise ImportError, "No module named " + mname
-    return m
+        subname = name[:dot]
+        next = name[dot+1:]
+
+    if buf != '':
+        buf += '.'
+    buf += subname
+
+    result = import_submodule(mod, subname, buf)
+    if result is None and mod != altmod:
+        result = import_submodule(altmod, subname, subname)
+        if result is not None:
+            buf = subname
+
+    if result is None:
+        raise ImportError("No module named %.200s" % name)
+
+    return result, next, buf
 
-def ensure_fromlist(m, fromlist, recursive=0):
-    for sub in fromlist:
-        if sub == "*":
-            if not recursive:
-                try:
-                    all = m.__all__
-                except AttributeError:
-                    pass
-                else:
-                    ensure_fromlist(m, all, 1)
-            continue
-        if sub != "*" and not hasattr(m, sub):
-            subname = "%s.%s" % (m.__name__, sub)
-            submod = import_module(sub, subname, m)
-            if not submod:
-                raise ImportError, "No module named " + subname
 
 # Need to keep track of what we've already reloaded to prevent cyclic evil
 found_now = {}
 
-def import_module(partname, fqname, parent):
+def import_submodule(mod, subname, fullname):
+    """m = import_submodule(mod, subname, fullname)"""
+    # Require:
+    # if mod == None: subname == fullname
+    # else: mod.__name__ + "." + subname == fullname
+
     global found_now
-    if found_now.has_key(fqname):
+    if fullname in found_now and fullname in sys.modules:
+        m = sys.modules[fullname]
+    else:
+        print('Reloading', fullname)
+        found_now[fullname] = 1
+        oldm = sys.modules.get(fullname, None)
         try:
-            return sys.modules[fqname]    
-        except KeyError:
-            pass
-    
-    print 'Reloading', fqname #, sys.excepthook is sys.__excepthook__, \
-            #sys.displayhook is sys.__displayhook__
-    
-    found_now[fqname] = 1
-    try:
-        fp, pathname, stuff = imp.find_module(partname,
-                                              parent and parent.__path__)
-    except ImportError:
-        return None
-        
-    try:
-        m = imp.load_module(fqname, fp, pathname, stuff)
-    finally:
-        if fp: fp.close()
-        
-    if parent:
-        setattr(parent, partname, m)
+            if oldm is not None:
+                m = importlib.reload(oldm)
+            else:
+                m = importlib.import_module(subname, mod)
+        except:
+            # load_module probably removed name from modules because of
+            # the error.  Put back the original module object.
+            if oldm:
+                sys.modules[fullname] = oldm
+            raise
+
+        add_submodule(mod, m, fullname, subname)
 
     return m
 
-def deep_reload_hook(module):
-    name = module.__name__
-    if '.' not in name:
-        return import_module(name, name, None)
-    i = name.rfind('.')
-    pname = name[:i]
-    parent = sys.modules[pname]
-    return import_module(name[i+1:], name, parent)
+def add_submodule(mod, submod, fullname, subname):
+    """mod.{subname} = submod"""
+    if mod is None:
+        return #Nothing to do here.
+
+    if submod is None:
+        submod = sys.modules[fullname]
+
+    setattr(mod, subname, submod)
+
+    return
+
+def ensure_fromlist(mod, fromlist, buf, recursive):
+    """Handle 'from module import a, b, c' imports."""
+    if not hasattr(mod, '__path__'):
+        return
+    for item in fromlist:
+        if not hasattr(item, 'rindex'):
+            raise TypeError("Item in ``from list'' not a string")
+        if item == '*':
+            if recursive:
+                continue # avoid endless recursion
+            try:
+                all = mod.__all__
+            except AttributeError:
+                pass
+            else:
+                ret = ensure_fromlist(mod, all, buf, 1)
+                if not ret:
+                    return 0
+        elif not hasattr(mod, item):
+            import_submodule(mod, item, buf + '.' + item)
+
+def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1):
+    """Replacement for __import__()"""
+    parent, buf = get_parent(globals, level)
+
+    head, name, buf = load_next(parent, None if level < 0 else parent, name, buf)
+
+    tail = head
+    while name:
+        tail, name, buf = load_next(tail, tail, name, buf)
+
+    # If tail is None, both get_parent and load_next found
+    # an empty module name: someone called __import__("") or
+    # doctored faulty bytecode
+    if tail is None:
+        raise ValueError('Empty module name')
+
+    if not fromlist:
+        return head
+
+    ensure_fromlist(tail, fromlist, buf, 0)
+    return tail
+
+modules_reloading = {}
+
+def deep_reload_hook(m):
+    """Replacement for reload()."""
+    # Hardcode this one  as it would raise a NotImplementedError from the
+    # bowels of Python and screw up the import machinery after.
+    # unlike other imports the `exclude` list already in place is not enough.
+
+    if m is types:
+        return m
+    if not isinstance(m, ModuleType):
+        raise TypeError("reload() argument must be module")
+
+    name = m.__name__
+
+    if name not in sys.modules:
+        raise ImportError("reload(): module %.200s not in sys.modules" % name)
+
+    global modules_reloading
+    try:
+        return modules_reloading[name]
+    except:
+        modules_reloading[name] = m
+
+    try:
+        newm = importlib.reload(m)
+    except:
+        sys.modules[name] = m
+        raise
+    finally:
+        modules_reloading.clear()
+    return newm
 
 # Save the original hooks
-original_reload = __builtin__.reload
+original_reload = importlib.reload
 
 # Replacement for reload()
-def reload(module, exclude=['sys', '__builtin__', '__main__']):
+def reload(
+    module,
+    exclude=(
+        *sys.builtin_module_names,
+        "sys",
+        "os.path",
+        "builtins",
+        "__main__",
+        "numpy",
+        "numpy._globals",
+    ),
+):
     """Recursively reload all modules used in the given module.  Optionally
     takes a list of modules to exclude from reloading.  The default exclude
-    list contains sys, __main__, and __builtin__, to prevent, e.g., resetting 
+    list contains modules listed in sys.builtin_module_names with additional
+    sys, os.path, builtins and __main__, to prevent, e.g., resetting
     display, exception, and io hooks.
     """
     global found_now
     for i in exclude:
         found_now[i] = 1
-    original_import = __builtin__.__import__
-    __builtin__.__import__ = deep_import_hook    
     try:
-        ret = deep_reload_hook(module)
+        with replace_import_hook(deep_import_hook):
+            return deep_reload_hook(module)
     finally:
-        __builtin__.__import__ = original_import
         found_now = {}
-    return ret
-
-# Uncomment the following to automatically activate deep reloading whenever
-# this module is imported
-#__builtin__.reload = reload
diff --git a/IPython/lib/demo.py b/IPython/lib/demo.py
index e2bc7c5fb47..c3908955fca 100644
--- a/IPython/lib/demo.py
+++ b/IPython/lib/demo.py
@@ -7,21 +7,21 @@
 
 
 Provided classes
-================
+----------------
 
 The classes are (see their docstrings for further details):
 
  - Demo: pure python demos
 
  - IPythonDemo: demos with input to be processed by IPython as if it had been
- typed interactively (so magics work, as well as any other special syntax you
- may have added via input prefilters).
+   typed interactively (so magics work, as well as any other special syntax you
+   may have added via input prefilters).
 
  - LineDemo: single-line version of the Demo class.  These demos are executed
- one line at a time, and require no markup.
+   one line at a time, and require no markup.
 
  - IPythonLineDemo: IPython version of the LineDemo class (the demo is
- executed a line at a time, but processed via IPython).
+   executed a line at a time, but processed via IPython).
 
  - ClearMixin: mixin to make Demo classes with less visual clutter.  It
    declares an empty marquee and a pre_cmd that clears the screen before each
@@ -30,13 +30,20 @@
  - ClearDemo, ClearIPDemo: mixin-enabled versions of the Demo and IPythonDemo
    classes.
 
+Inheritance diagram:
+
+.. inheritance-diagram:: IPython.lib.demo
+   :parts: 3
 
 Subclassing
-===========
+-----------
 
 The classes here all include a few methods meant to make customization by
 subclassing more convenient.  Their docstrings below have some more details:
 
+  - highlight(): format every block and optionally highlight comments and
+    docstring content.
+
   - marquee(): generates a marquee to provide visible on-screen markers at each
     block start and end.
 
@@ -44,10 +51,10 @@
 
   - post_cmd(): run right after the execution of each block.  If the block
     raises an exception, this is NOT called.
-    
+
 
 Operation
-=========
+---------
 
 The file is run in its own empty namespace (though you can pass it a string of
 arguments as if in a command line environment, and it will see those as
@@ -72,14 +79,14 @@
   word 'stop', to help visually distinguish the blocks in a text editor:
 
   # <demo> --- stop ---
-  
+
 
 # <demo> silent
 
   Make a block execute silently (and hence automatically).  Typically used in
   cases where you have some boilerplate or initialization code which you need
   executed but do not want to be seen in the demo.
-  
+
 # <demo> auto
 
   Make a block execute automatically, but still being printed.  Useful for
@@ -100,11 +107,11 @@
 the execution.
 
 This is probably best explained with the simple example file below.  You can
-copy this into a file named ex_demo.py, and try running it via:
+copy this into a file named ex_demo.py, and try running it via::
 
-from IPython.demo import Demo
-d = Demo('ex_demo.py')
-d()  <--- Call the d object (omit the parens if you have autocall set to 2).
+    from IPython.lib.demo import Demo
+    d = Demo('ex_demo.py')
+    d()
 
 Each time you call the demo object, it runs the next block.  The demo object
 has a few useful methods for navigation, like again(), edit(), jump(), seek()
@@ -116,51 +123,54 @@
 an IPython session, and type::
 
   %run demo-exercizer.py
-  
+
 and then follow the directions.
 
 Example
-=======
+-------
 
 The following is a very simple example of a valid demo file.
 
-#################### EXAMPLE DEMO <ex_demo.py> ###############################
-'''A simple interactive demo to illustrate the use of IPython's Demo class.'''
+::
 
-print 'Hello, welcome to an interactive IPython demo.'
+    #################### EXAMPLE DEMO <ex_demo.py> ###############################
+    '''A simple interactive demo to illustrate the use of IPython's Demo class.'''
 
-# The mark below defines a block boundary, which is a point where IPython will
-# stop execution and return to the interactive prompt. The dashes are actually
-# optional and used only as a visual aid to clearly separate blocks while
-# editing the demo code.
-# <demo> stop
+    print('Hello, welcome to an interactive IPython demo.')
 
-x = 1
-y = 2
+    # The mark below defines a block boundary, which is a point where IPython will
+    # stop execution and return to the interactive prompt. The dashes are actually
+    # optional and used only as a visual aid to clearly separate blocks while
+    # editing the demo code.
+    # <demo> stop
 
-# <demo> stop
+    x = 1
+    y = 2
 
-# the mark below makes this block as silent
-# <demo> silent
+    # <demo> stop
 
-print 'This is a silent block, which gets executed but not printed.'
+    # the mark below makes this block as silent
+    # <demo> silent
 
-# <demo> stop
-# <demo> auto
-print 'This is an automatic block.'
-print 'It is executed without asking for confirmation, but printed.'
-z = x+y
+    print('This is a silent block, which gets executed but not printed.')
 
-print 'z=',x
+    # <demo> stop
+    # <demo> auto
+    print('This is an automatic block.')
+    print('It is executed without asking for confirmation, but printed.')
+    z = x + y
 
-# <demo> stop
-# This is just another normal block.
-print 'z is now:', z
+    print('z =', x)
+
+    # <demo> stop
+    # This is just another normal block.
+    print('z is now:', z)
 
-print 'bye!'
-################### END EXAMPLE DEMO <ex_demo.py> ############################
+    print('bye!')
+    ################### END EXAMPLE DEMO <ex_demo.py> ############################
 """
 
+
 #*****************************************************************************
 #     Copyright (C) 2005-2006 Fernando Perez. <Fernando.Perez@colorado.edu>
 #
@@ -169,58 +179,67 @@
 #
 #*****************************************************************************
 
-import exceptions
 import os
 import re
 import shlex
 import sys
+import pygments
+from pathlib import Path
 
-from IPython.utils.PyColorize import Parser
-from IPython.utils import io
-from IPython.utils.io import file_read, file_readlines
 from IPython.utils.text import marquee
-
+from IPython.utils import openpy
+from IPython.utils import py3compat
 __all__ = ['Demo','IPythonDemo','LineDemo','IPythonLineDemo','DemoError']
 
-class DemoError(exceptions.Exception): pass
+class DemoError(Exception): pass
 
 def re_mark(mark):
     return re.compile(r'^\s*#\s+<demo>\s+%s\s*$' % mark,re.MULTILINE)
 
-class Demo(object):
+class Demo:
 
-    re_stop     = re_mark('-*\s?stop\s?-*')
+    re_stop     = re_mark(r'-*\s?stop\s?-*')
     re_silent   = re_mark('silent')
     re_auto     = re_mark('auto')
     re_auto_all = re_mark('auto_all')
 
-    def __init__(self,src,title='',arg_str='',auto_all=None):
+    def __init__(self,src,title='',arg_str='',auto_all=None, format_rst=False,
+                 formatter='terminal', style='default'):
         """Make a new demo object.  To run the demo, simply call the object.
 
         See the module docstring for full details and an example (you can use
         IPython.Demo? in IPython to see it).
 
         Inputs:
-        
+
           - src is either a file, or file-like object, or a
               string that can be resolved to a filename.
 
         Optional inputs:
-        
+
           - title: a string to use as the demo name.  Of most use when the demo
-          you are making comes from an object that has no filename, or if you 
-          want an alternate denotation distinct from the filename.
+            you are making comes from an object that has no filename, or if you
+            want an alternate denotation distinct from the filename.
 
           - arg_str(''): a string of arguments, internally converted to a list
-          just like sys.argv, so the demo script can see a similar
-          environment.
+            just like sys.argv, so the demo script can see a similar
+            environment.
 
           - auto_all(None): global flag to run all blocks automatically without
-          confirmation.  This attribute overrides the block-level tags and
-          applies to the whole demo.  It is an attribute of the object, and
-          can be changed at runtime simply by reassigning it to a boolean
-          value.
-          """
+            confirmation.  This attribute overrides the block-level tags and
+            applies to the whole demo.  It is an attribute of the object, and
+            can be changed at runtime simply by reassigning it to a boolean
+            value.
+
+          - format_rst(False): a bool to enable comments and doc strings
+            formatting with pygments rst lexer
+
+          - formatter('terminal'): a string of pygments formatter name to be
+            used. Useful values for terminals: terminal, terminal256,
+            terminal16m
+
+          - style('default'): a string of pygments style name to be used.
+        """
         if hasattr(src, "read"):
              # It seems to be a file or a file-like object
             self.fname = "from a file-like object"
@@ -239,17 +258,30 @@ def __init__(self,src,title='',arg_str='',auto_all=None):
         self.sys_argv = [src] + shlex.split(arg_str)
         self.auto_all = auto_all
         self.src = src
-        
-        # get a few things from ipython.  While it's a bit ugly design-wise,
-        # it ensures that things like color scheme and the like are always in
-        # sync with the ipython mode being used.  This class is only meant to
-        # be used inside ipython anyways,  so it's OK.
-        ip = get_ipython()  # this is in builtins whenever IPython is running
-        self.ip_ns       = ip.user_ns
-        self.ip_colorize = ip.pycolorize
-        self.ip_showtb   = ip.showtraceback
-        self.ip_run_cell = ip.run_cell
-        self.shell       = ip
+
+        try:
+            ip = get_ipython()  # this is in builtins whenever IPython is running
+            self.inside_ipython = True
+        except NameError:
+            self.inside_ipython = False
+
+        if self.inside_ipython:
+            # get a few things from ipython.  While it's a bit ugly design-wise,
+            # it ensures that things like color scheme and the like are always in
+            # sync with the ipython mode being used.  This class is only meant to
+            # be used inside ipython anyways,  so it's OK.
+            self.ip_ns       = ip.user_ns
+            self.ip_colorize = ip.pycolorize
+            self.ip_showtb   = ip.showtraceback
+            self.ip_run_cell = ip.run_cell
+            self.shell       = ip
+
+        self.formatter = pygments.formatters.get_formatter_by_name(formatter,
+                                                                   style=style)
+        self.python_lexer = pygments.lexers.get_lexer_by_name("py3")
+        self.format_rst = format_rst
+        if format_rst:
+            self.rst_lexer = pygments.lexers.get_lexer_by_name("rst")
 
         # load user data and initialize data structures
         self.reload()
@@ -264,13 +296,13 @@ def fload(self):
             self.fobj = self.src
         else:
              # Assume it's a string or something that can be converted to one
-            self.fobj = open(self.fname)
+            self.fobj = openpy.open(self.fname)
 
     def reload(self):
         """Reload source from disk and initialize state."""
         self.fload()
-        
-        self.src     = self.fobj.read()
+
+        self.src     = "".join(openpy.strip_encoding_cookie(self.fobj))
         src_b        = [b.strip() for b in self.re_stop.split(self.src) if b]
         self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
         self._auto   = [bool(self.re_auto.findall(b)) for b in src_b]
@@ -297,7 +329,7 @@ def reload(self):
         self.src_blocks = src_blocks
 
         # also build syntax-highlighted source
-        self.src_blocks_colored = map(self.ip_colorize,self.src_blocks)
+        self.src_blocks_colored = list(map(self.highlight,self.src_blocks))
 
         # ensure clean namespace and seek offset
         self.reset()
@@ -316,10 +348,10 @@ def _get_index(self,index):
         """Get the current block index, validating and checking status.
 
         Returns None if the demo is finished"""
-        
+
         if index is None:
             if self.finished:
-                print >>io.stdout, 'Demo finished.  Use <demo_name>.reset() if you want to rerun it.'
+                print('Demo finished.  Use <demo_name>.reset() if you want to rerun it.')
                 return None
             index = self.block_index
         else:
@@ -370,17 +402,18 @@ def edit(self,index=None):
         # that the default demo.edit() call opens up the sblock we've last run
         if index>0:
             index -= 1
-            
+
         filename = self.shell.mktempfile(self.src_blocks[index])
-        self.shell.hooks.editor(filename,1)
-        new_block = file_read(filename)
+        self.shell.hooks.editor(filename, 1)
+        with open(Path(filename), "r", encoding="utf-8") as f:
+            new_block = f.read()
         # update the source and colored block
         self.src_blocks[index] = new_block
-        self.src_blocks_colored[index] = self.ip_colorize(new_block)
+        self.src_blocks_colored[index] = self.highlight(new_block)
         self.block_index = index
         # call to run with the newly edited index
         self()
-        
+
     def show(self,index=None):
         """Show a single block on screen"""
 
@@ -388,9 +421,9 @@ def show(self,index=None):
         if index is None:
             return
 
-        print >>io.stdout, self.marquee('<%s> block # %s (%s remaining)' %
-                           (self.title,index,self.nblocks-index-1))
-        print >>io.stdout,(self.src_blocks_colored[index])
+        print(self.marquee('<%s> block # %s (%s remaining)' %
+                           (self.title,index,self.nblocks-index-1)))
+        print(self.src_blocks_colored[index])
         sys.stdout.flush()
 
     def show_all(self):
@@ -403,19 +436,19 @@ def show_all(self):
         marquee = self.marquee
         for index,block in enumerate(self.src_blocks_colored):
             if silent[index]:
-                print >>io.stdout, marquee('<%s> SILENT block # %s (%s remaining)' %
-                              (title,index,nblocks-index-1))
+                print(marquee('<%s> SILENT block # %s (%s remaining)' %
+                              (title,index,nblocks-index-1)))
             else:
-                print >>io.stdout, marquee('<%s> block # %s (%s remaining)' %
-                              (title,index,nblocks-index-1))
-            print >>io.stdout, block,
+                print(marquee('<%s> block # %s (%s remaining)' %
+                              (title,index,nblocks-index-1)))
+            print(block, end=' ')
         sys.stdout.flush()
 
     def run_cell(self,source):
         """Execute a string with one or more lines of code"""
 
-        exec source in self.user_ns
-        
+        exec(source, self.user_ns)
+
     def __call__(self,index=None):
         """run a block of the demo.
 
@@ -433,18 +466,18 @@ def __call__(self,index=None):
             next_block = self.src_blocks[index]
             self.block_index += 1
             if self._silent[index]:
-                print >>io.stdout, marquee('Executing silent block # %s (%s remaining)' %
-                              (index,self.nblocks-index-1))
+                print(marquee('Executing silent block # %s (%s remaining)' %
+                              (index,self.nblocks-index-1)))
             else:
                 self.pre_cmd()
                 self.show(index)
                 if self.auto_all or self._auto[index]:
-                    print >>io.stdout, marquee('output:')
+                    print(marquee('output:'))
                 else:
-                    print >>io.stdout, marquee('Press <q> to quit, <Enter> to execute...'),
-                    ans = raw_input().strip()
+                    print(marquee('Press <q> to quit, <Enter> to execute...'), end=' ')
+                    ans = py3compat.input().strip()
                     if ans:
-                        print >>io.stdout, marquee('Block NOT executed')
+                        print(marquee('Block NOT executed'))
                         return
             try:
                 save_argv = sys.argv
@@ -453,19 +486,21 @@ def __call__(self,index=None):
                 self.post_cmd()
             finally:
                 sys.argv = save_argv
-            
+
         except:
-            self.ip_showtb(filename=self.fname)
+            if self.inside_ipython:
+                self.ip_showtb(filename=self.fname)
         else:
-            self.ip_ns.update(self.user_ns)
+            if self.inside_ipython:
+                self.ip_ns.update(self.user_ns)
 
         if self.block_index == self.nblocks:
             mq1 = self.marquee('END OF DEMO')
             if mq1:
-                # avoid spurious print >>io.stdout,s if empty marquees are used
-                print >>io.stdout
-                print >>io.stdout, mq1
-                print >>io.stdout, self.marquee('Use <demo_name>.reset() if you want to rerun it.')
+                # avoid spurious print if empty marquees are used
+                print()
+                print(mq1)
+                print(self.marquee('Use <demo_name>.reset() if you want to rerun it.'))
             self.finished = True
 
     # These methods are meant to be overridden by subclasses who may wish to
@@ -482,6 +517,28 @@ def post_cmd(self):
         """Method called after executing each block."""
         pass
 
+    def highlight(self, block):
+        """Method called on each block to highlight it content"""
+        tokens = pygments.lex(block, self.python_lexer)
+        if self.format_rst:
+            from pygments.token import Token
+            toks = []
+            for token in tokens:
+                if token[0] == Token.String.Doc and len(token[1]) > 6:
+                    toks += pygments.lex(token[1][:3], self.python_lexer)
+                    # parse doc string content by rst lexer
+                    toks += pygments.lex(token[1][3:-3], self.rst_lexer)
+                    toks += pygments.lex(token[1][-3:], self.python_lexer)
+                elif token[0] == Token.Comment.Single:
+                    toks.append((Token.Comment.Single, token[1][0]))
+                    # parse comment content by rst lexer
+                    # remove the extra newline added by rst lexer
+                    toks += list(pygments.lex(token[1][1:], self.rst_lexer))[:-1]
+                else:
+                    toks.append(token)
+            tokens = toks
+        return pygments.format(tokens, self.formatter)
+
 
 class IPythonDemo(Demo):
     """Class for interactive demos with IPython's input processing applied.
@@ -500,7 +557,7 @@ def run_cell(self,source):
         """Execute a string with one or more lines of code"""
 
         self.shell.run_cell(source)
-        
+
 class LineDemo(Demo):
     """Demo where each line is executed as a separate block.
 
@@ -514,7 +571,7 @@ class LineDemo(Demo):
     Note: the input can not have *any* indentation, which means that only
     single-lines of input are accepted, not even function definitions are
     valid."""
-    
+
     def reload(self):
         """Reload source from disk and initialize state."""
         # read data and parse into blocks
@@ -530,7 +587,7 @@ def reload(self):
         self.src_blocks = src_b
 
         # also build syntax-highlighted source
-        self.src_blocks_colored = map(self.ip_colorize,self.src_blocks)
+        self.src_blocks_colored = list(map(self.highlight,self.src_blocks))
 
         # ensure clean namespace and seek offset
         self.reset()
@@ -541,31 +598,31 @@ class IPythonLineDemo(IPythonDemo,LineDemo):
     pass
 
 
-class ClearMixin(object):
+class ClearMixin:
     """Use this mixin to make Demo classes with less visual clutter.
-    
+
     Demos using this mixin will clear the screen before every block and use
     blank marquees.
-    
+
     Note that in order for the methods defined here to actually override those
     of the classes it's mixed with, it must go /first/ in the inheritance
     tree.  For example:
-    
+
         class ClearIPDemo(ClearMixin,IPythonDemo): pass
-    
+
     will provide an IPythonDemo class with the mixin's features.
     """
-    
+
     def marquee(self,txt='',width=78,mark='*'):
         """Blank marquee that returns '' no matter what the input."""
         return ''
-    
+
     def pre_cmd(self):
         """Method called before executing each block.
-        
+
         This one simply clears the screen."""
-        from IPython.utils.terminal import term_clear
-        term_clear()
+        from IPython.utils.terminal import _term_clear
+        _term_clear()
 
 class ClearDemo(ClearMixin,Demo):
     pass
@@ -573,3 +630,43 @@ class ClearDemo(ClearMixin,Demo):
 
 class ClearIPDemo(ClearMixin,IPythonDemo):
     pass
+
+
+def slide(file_path, noclear=False, format_rst=True, formatter="terminal",
+          style="native", auto_all=False, delimiter='...'):
+    if noclear:
+        demo_class = Demo
+    else:
+        demo_class = ClearDemo
+    demo = demo_class(file_path, format_rst=format_rst, formatter=formatter,
+                      style=style, auto_all=auto_all)
+    while not demo.finished:
+        demo()
+        try:
+            py3compat.input('\n' + delimiter)
+        except KeyboardInterrupt:
+            exit(1)
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser(description='Run python demos')
+    parser.add_argument('--noclear', '-C', action='store_true',
+                        help='Do not clear terminal on each slide')
+    parser.add_argument('--rst', '-r', action='store_true',
+                        help='Highlight comments and dostrings as rst')
+    parser.add_argument('--formatter', '-f', default='terminal',
+                        help='pygments formatter name could be: terminal, '
+                        'terminal256, terminal16m')
+    parser.add_argument('--style', '-s', default='default',
+                        help='pygments style name')
+    parser.add_argument('--auto', '-a', action='store_true',
+                        help='Run all blocks automatically without'
+                        'confirmation')
+    parser.add_argument('--delimiter', '-d', default='...',
+                        help='slides delimiter added after each slide run')
+    parser.add_argument('file', nargs=1,
+                        help='python demo file')
+    args = parser.parse_args()
+    slide(args.file[0], noclear=args.noclear, format_rst=args.rst,
+          formatter=args.formatter, style=args.style, auto_all=args.auto,
+          delimiter=args.delimiter)
diff --git a/IPython/lib/display.py b/IPython/lib/display.py
new file mode 100644
index 00000000000..0e45b6ea74d
--- /dev/null
+++ b/IPython/lib/display.py
@@ -0,0 +1,678 @@
+"""Various display related classes.
+
+Authors : MinRK, gregcaporaso, dannystaple
+"""
+from html import escape as html_escape
+from os.path import exists, isfile, splitext, abspath, join, isdir
+from os import walk, sep, fsdecode
+
+from IPython.core.display import DisplayObject, TextDisplayObject
+
+from typing import Tuple, Optional
+from collections.abc import Iterable
+
+__all__ = ['Audio', 'IFrame', 'YouTubeVideo', 'VimeoVideo', 'ScribdDocument',
+           'FileLink', 'FileLinks', 'Code']
+
+
+class Audio(DisplayObject):
+    """Create an audio object.
+
+    When this object is returned by an input cell or passed to the
+    display function, it will result in Audio controls being displayed
+    in the frontend (only works in the notebook).
+
+    Parameters
+    ----------
+    data : numpy array, list, unicode, str or bytes
+        Can be one of
+
+          * Numpy 1d array containing the desired waveform (mono)
+          * Numpy 2d array containing waveforms for each channel.
+            Shape=(NCHAN, NSAMPLES). For the standard channel order, see
+            http://msdn.microsoft.com/en-us/library/windows/hardware/dn653308(v=vs.85).aspx
+          * List of float or integer representing the waveform (mono)
+          * String containing the filename
+          * Bytestring containing raw PCM data or
+          * URL pointing to a file on the web.
+
+        If the array option is used, the waveform will be normalized.
+
+        If a filename or url is used, the format support will be browser
+        dependent.
+    url : unicode
+        A URL to download the data from.
+    filename : unicode
+        Path to a local file to load the data from.
+    embed : boolean
+        Should the audio data be embedded using a data URI (True) or should
+        the original source be referenced. Set this to True if you want the
+        audio to playable later with no internet connection in the notebook.
+
+        Default is `True`, unless the keyword argument `url` is set, then
+        default value is `False`.
+    rate : integer
+        The sampling rate of the raw data.
+        Only required when data parameter is being used as an array
+    autoplay : bool
+        Set to True if the audio should immediately start playing.
+        Default is `False`.
+    normalize : bool
+        Whether audio should be normalized (rescaled) to the maximum possible
+        range. Default is `True`. When set to `False`, `data` must be between
+        -1 and 1 (inclusive), otherwise an error is raised.
+        Applies only when `data` is a list or array of samples; other types of
+        audio are never normalized.
+
+    Examples
+    --------
+
+    >>> import pytest
+    >>> np = pytest.importorskip("numpy")
+
+    Generate a sound
+
+    >>> import numpy as np
+    >>> framerate = 44100
+    >>> t = np.linspace(0,5,framerate*5)
+    >>> data = np.sin(2*np.pi*220*t) + np.sin(2*np.pi*224*t)
+    >>> Audio(data, rate=framerate)
+    <IPython.lib.display.Audio object>
+
+    Can also do stereo or more channels
+
+    >>> dataleft = np.sin(2*np.pi*220*t)
+    >>> dataright = np.sin(2*np.pi*224*t)
+    >>> Audio([dataleft, dataright], rate=framerate)
+    <IPython.lib.display.Audio object>
+
+    From URL:
+
+    >>> Audio("http://www.nch.com.au/acm/8k16bitpcm.wav")  # doctest: +SKIP
+    >>> Audio(url="http://www.w3schools.com/html/horse.ogg")  # doctest: +SKIP
+
+    From a File:
+
+    >>> Audio('IPython/lib/tests/test.wav')  # doctest: +SKIP
+    >>> Audio(filename='IPython/lib/tests/test.wav')  # doctest: +SKIP
+
+    From Bytes:
+
+    >>> Audio(b'RAW_WAV_DATA..')  # doctest: +SKIP
+    >>> Audio(data=b'RAW_WAV_DATA..')  # doctest: +SKIP
+
+    See Also
+    --------
+    ipywidgets.Audio
+
+         Audio widget with more more flexibility and options.
+
+    """
+    _read_flags = 'rb'
+
+    def __init__(self, data=None, filename=None, url=None, embed=None, rate=None, autoplay=False, normalize=True, *,
+                 element_id=None):
+        if filename is None and url is None and data is None:
+            raise ValueError("No audio data found. Expecting filename, url, or data.")
+        if embed is False and url is None:
+            raise ValueError("No url found. Expecting url when embed=False")
+
+        if url is not None and embed is not True:
+            self.embed = False
+        else:
+            self.embed = True
+        self.autoplay = autoplay
+        self.element_id = element_id
+        super(Audio, self).__init__(data=data, url=url, filename=filename)
+
+        if self.data is not None and not isinstance(self.data, bytes):
+            if rate is None:
+                raise ValueError("rate must be specified when data is a numpy array or list of audio samples.")
+            self.data = Audio._make_wav(data, rate, normalize)
+
+    def reload(self):
+        """Reload the raw data from file or URL."""
+        import mimetypes
+        if self.embed:
+            super(Audio, self).reload()
+
+        if self.filename is not None:
+            self.mimetype = mimetypes.guess_type(self.filename)[0]
+        elif self.url is not None:
+            self.mimetype = mimetypes.guess_type(self.url)[0]
+        else:
+            self.mimetype = "audio/wav"
+
+    @staticmethod
+    def _make_wav(data, rate, normalize):
+        """ Transform a numpy array to a PCM bytestring """
+        from io import BytesIO
+        import wave
+
+        try:
+            scaled, nchan = Audio._validate_and_normalize_with_numpy(data, normalize)
+        except ImportError:
+            scaled, nchan = Audio._validate_and_normalize_without_numpy(data, normalize)
+
+        fp = BytesIO()
+        waveobj = wave.open(fp,mode='wb')
+        waveobj.setnchannels(nchan)
+        waveobj.setframerate(rate)
+        waveobj.setsampwidth(2)
+        waveobj.setcomptype('NONE','NONE')
+        waveobj.writeframes(scaled)
+        val = fp.getvalue()
+        waveobj.close()
+
+        return val
+
+    @staticmethod
+    def _validate_and_normalize_with_numpy(data, normalize) -> Tuple[bytes, int]:
+        import numpy as np
+
+        data = np.array(data, dtype=float)
+        if len(data.shape) == 1:
+            nchan = 1
+        elif len(data.shape) == 2:
+            # In wave files,channels are interleaved. E.g.,
+            # "L1R1L2R2..." for stereo. See
+            # http://msdn.microsoft.com/en-us/library/windows/hardware/dn653308(v=vs.85).aspx
+            # for channel ordering
+            nchan = data.shape[0]
+            data = data.T.ravel()
+        else:
+            raise ValueError('Array audio input must be a 1D or 2D array')
+        
+        max_abs_value = np.max(np.abs(data))
+        normalization_factor = Audio._get_normalization_factor(max_abs_value, normalize)
+        scaled = data / normalization_factor * 32767
+        return scaled.astype("<h").tobytes(), nchan
+
+    @staticmethod
+    def _validate_and_normalize_without_numpy(data, normalize):
+        import array
+        import sys
+
+        data = array.array('f', data)
+
+        try:
+            max_abs_value = float(max([abs(x) for x in data]))
+        except TypeError as e:
+            raise TypeError('Only lists of mono audio are '
+                'supported if numpy is not installed') from e
+
+        normalization_factor = Audio._get_normalization_factor(max_abs_value, normalize)
+        scaled = array.array('h', [int(x / normalization_factor * 32767) for x in data])
+        if sys.byteorder == 'big':
+            scaled.byteswap()
+        nchan = 1
+        return scaled.tobytes(), nchan
+
+    @staticmethod
+    def _get_normalization_factor(max_abs_value, normalize):
+        if not normalize and max_abs_value > 1:
+            raise ValueError('Audio data must be between -1 and 1 when normalize=False.')
+        return max_abs_value if normalize else 1
+
+    def _data_and_metadata(self):
+        """shortcut for returning metadata with url information, if defined"""
+        md = {}
+        if self.url:
+            md['url'] = self.url
+        if md:
+            return self.data, md
+        else:
+            return self.data
+
+    def _repr_html_(self):
+        src = """
+                <audio {element_id} controls="controls" {autoplay}>
+                    <source src="{src}" type="{type}" />
+                    Your browser does not support the audio element.
+                </audio>
+              """
+        return src.format(src=self.src_attr(), type=self.mimetype, autoplay=self.autoplay_attr(),
+                          element_id=self.element_id_attr())
+
+    def src_attr(self):
+        import base64
+        if self.embed and (self.data is not None):
+            data = base64=base64.b64encode(self.data).decode('ascii')
+            return """data:{type};base64,{base64}""".format(type=self.mimetype,
+                                                            base64=data)
+        elif self.url is not None:
+            return self.url
+        else:
+            return ""
+
+    def autoplay_attr(self):
+        if(self.autoplay):
+            return 'autoplay="autoplay"'
+        else:
+            return ''
+    
+    def element_id_attr(self):
+        if (self.element_id):
+            return 'id="{element_id}"'.format(element_id=self.element_id)
+        else:
+            return ''
+
+class IFrame:
+    """
+    Generic class to embed an iframe in an IPython notebook
+    """
+
+    iframe = """
+        <iframe
+            width="{width}"
+            height="{height}"
+            src="{src}{params}"
+            frameborder="0"
+            allowfullscreen
+            {extras}
+        ></iframe>
+        """
+
+    def __init__(
+        self, src, width, height, extras: Optional[Iterable[str]] = None, **kwargs
+    ):
+        if extras is None:
+            extras = []
+
+        self.src = src
+        self.width = width
+        self.height = height
+        self.extras = extras
+        self.params = kwargs
+
+    def _repr_html_(self):
+        """return the embed iframe"""
+        if self.params:
+            from urllib.parse import urlencode
+            params = "?" + urlencode(self.params)
+        else:
+            params = ""
+        return self.iframe.format(
+            src=self.src,
+            width=self.width,
+            height=self.height,
+            params=params,
+            extras=" ".join(self.extras),
+        )
+
+
+class YouTubeVideo(IFrame):
+    """Class for embedding a YouTube Video in an IPython session, based on its video id.
+
+    e.g. to embed the video from https://www.youtube.com/watch?v=foo , you would
+    do::
+
+        vid = YouTubeVideo("foo")
+        display(vid)
+
+    To start from 30 seconds::
+
+        vid = YouTubeVideo("abc", start=30)
+        display(vid)
+
+    To calculate seconds from time as hours, minutes, seconds use
+    :class:`datetime.timedelta`::
+
+        start=int(timedelta(hours=1, minutes=46, seconds=40).total_seconds())
+
+    Other parameters can be provided as documented at
+    https://developers.google.com/youtube/player_parameters#Parameters
+    
+    When converting the notebook using nbconvert, a jpeg representation of the video
+    will be inserted in the document.
+    """
+
+    def __init__(self, id, width=400, height=300, allow_autoplay=False, **kwargs):
+        self.id=id
+        src = "https://www.youtube.com/embed/{0}".format(id)
+        if allow_autoplay:
+            extras = list(kwargs.get("extras", [])) + ['allow="autoplay"']
+            kwargs.update(autoplay=1, extras=extras)
+        super(YouTubeVideo, self).__init__(src, width, height, **kwargs)
+
+    def _repr_jpeg_(self):
+        # Deferred import
+        from urllib.request import urlopen
+
+        try:
+            return urlopen("https://img.youtube.com/vi/{id}/hqdefault.jpg".format(id=self.id)).read()
+        except IOError:
+            return None
+
+class VimeoVideo(IFrame):
+    """
+    Class for embedding a Vimeo video in an IPython session, based on its video id.
+    """
+
+    def __init__(self, id, width=400, height=300, **kwargs):
+        src="https://player.vimeo.com/video/{0}".format(id)
+        super(VimeoVideo, self).__init__(src, width, height, **kwargs)
+
+class ScribdDocument(IFrame):
+    """
+    Class for embedding a Scribd document in an IPython session
+
+    Use the start_page params to specify a starting point in the document
+    Use the view_mode params to specify display type one off scroll | slideshow | book
+
+    e.g to Display Wes' foundational paper about PANDAS in book mode from page 3
+
+    ScribdDocument(71048089, width=800, height=400, start_page=3, view_mode="book")
+    """
+
+    def __init__(self, id, width=400, height=300, **kwargs):
+        src="https://www.scribd.com/embeds/{0}/content".format(id)
+        super(ScribdDocument, self).__init__(src, width, height, **kwargs)
+
+class FileLink:
+    """Class for embedding a local file link in an IPython session, based on path
+
+    e.g. to embed a link that was generated in the IPython notebook as my/data.txt
+
+    you would do::
+
+        local_file = FileLink("my/data.txt")
+        display(local_file)
+
+    or in the HTML notebook, just::
+
+        FileLink("my/data.txt")
+    """
+
+    html_link_str = "<a href='%s' target='_blank'>%s</a>"
+
+    def __init__(self,
+                 path,
+                 url_prefix='',
+                 result_html_prefix='',
+                 result_html_suffix='<br>'):
+        """
+        Parameters
+        ----------
+        path : str
+            path to the file or directory that should be formatted
+        url_prefix : str
+            prefix to be prepended to all files to form a working link [default:
+            '']
+        result_html_prefix : str
+            text to append to beginning to link [default: '']
+        result_html_suffix : str
+            text to append at the end of link [default: '<br>']
+        """
+        if isdir(path):
+            raise ValueError("Cannot display a directory using FileLink. "
+              "Use FileLinks to display '%s'." % path)
+        self.path = fsdecode(path)
+        self.url_prefix = url_prefix
+        self.result_html_prefix = result_html_prefix
+        self.result_html_suffix = result_html_suffix
+
+    def _format_path(self):
+        fp = ''.join([self.url_prefix, html_escape(self.path)])
+        return ''.join([self.result_html_prefix,
+                        self.html_link_str % \
+                            (fp, html_escape(self.path, quote=False)),
+                        self.result_html_suffix])
+
+    def _repr_html_(self):
+        """return html link to file
+        """
+        if not exists(self.path):
+            return ("Path (<tt>%s</tt>) doesn't exist. "
+                    "It may still be in the process of "
+                    "being generated, or you may have the "
+                    "incorrect path." % self.path)
+
+        return self._format_path()
+
+    def __repr__(self):
+        """return absolute path to file
+        """
+        return abspath(self.path)
+
+class FileLinks(FileLink):
+    """Class for embedding local file links in an IPython session, based on path
+
+    e.g. to embed links to files that were generated in the IPython notebook
+    under ``my/data``, you would do::
+
+        local_files = FileLinks("my/data")
+        display(local_files)
+
+    or in the HTML notebook, just::
+
+        FileLinks("my/data")
+    """
+    def __init__(self,
+                 path,
+                 url_prefix='',
+                 included_suffixes=None,
+                 result_html_prefix='',
+                 result_html_suffix='<br>',
+                 notebook_display_formatter=None,
+                 terminal_display_formatter=None,
+                 recursive=True):
+        """
+        See :class:`FileLink` for the ``path``, ``url_prefix``,
+        ``result_html_prefix`` and ``result_html_suffix`` parameters.
+
+        included_suffixes : list
+          Filename suffixes to include when formatting output [default: include
+          all files]
+
+        notebook_display_formatter : function
+          Used to format links for display in the notebook. See discussion of
+          formatter functions below.
+
+        terminal_display_formatter : function
+          Used to format links for display in the terminal. See discussion of
+          formatter functions below.
+
+        Formatter functions must be of the form::
+
+            f(dirname, fnames, included_suffixes)
+
+        dirname : str
+          The name of a directory
+        fnames : list
+          The files in that directory
+        included_suffixes : list
+          The file suffixes that should be included in the output (passing None
+          meansto include all suffixes in the output in the built-in formatters)
+        recursive : boolean
+          Whether to recurse into subdirectories. Default is True.
+
+        The function should return a list of lines that will be printed in the
+        notebook (if passing notebook_display_formatter) or the terminal (if
+        passing terminal_display_formatter). This function is iterated over for
+        each directory in self.path. Default formatters are in place, can be
+        passed here to support alternative formatting.
+
+        """
+        if isfile(path):
+            raise ValueError("Cannot display a file using FileLinks. "
+              "Use FileLink to display '%s'." % path)
+        self.included_suffixes = included_suffixes
+        # remove trailing slashes for more consistent output formatting
+        path = path.rstrip('/')
+
+        self.path = path
+        self.url_prefix = url_prefix
+        self.result_html_prefix = result_html_prefix
+        self.result_html_suffix = result_html_suffix
+
+        self.notebook_display_formatter = \
+             notebook_display_formatter or self._get_notebook_display_formatter()
+        self.terminal_display_formatter = \
+             terminal_display_formatter or self._get_terminal_display_formatter()
+
+        self.recursive = recursive
+
+    def _get_display_formatter(
+        self, dirname_output_format, fname_output_format, fp_format, fp_cleaner=None
+    ):
+        """generate built-in formatter function
+
+        this is used to define both the notebook and terminal built-in
+         formatters as they only differ by some wrapper text for each entry
+
+        dirname_output_format: string to use for formatting directory
+         names, dirname will be substituted for a single "%s" which
+         must appear in this string
+        fname_output_format: string to use for formatting file names,
+         if a single "%s" appears in the string, fname will be substituted
+         if two "%s" appear in the string, the path to fname will be
+          substituted for the first and fname will be substituted for the
+          second
+        fp_format: string to use for formatting filepaths, must contain
+         exactly two "%s" and the dirname will be substituted for the first
+         and fname will be substituted for the second
+        """
+        def f(dirname, fnames, included_suffixes=None):
+            result = []
+            # begin by figuring out which filenames, if any,
+            # are going to be displayed
+            display_fnames = []
+            for fname in fnames:
+                if (isfile(join(dirname,fname)) and
+                       (included_suffixes is None or
+                        splitext(fname)[1] in included_suffixes)):
+                      display_fnames.append(fname)
+
+            if len(display_fnames) == 0:
+                # if there are no filenames to display, don't print anything
+                # (not even the directory name)
+                pass
+            else:
+                # otherwise print the formatted directory name followed by
+                # the formatted filenames
+                dirname_output_line = dirname_output_format % dirname
+                result.append(dirname_output_line)
+                for fname in display_fnames:
+                    fp = fp_format % (dirname,fname)
+                    if fp_cleaner is not None:
+                        fp = fp_cleaner(fp)
+                    try:
+                        # output can include both a filepath and a filename...
+                        fname_output_line = fname_output_format % (fp, fname)
+                    except TypeError:
+                        # ... or just a single filepath
+                        fname_output_line = fname_output_format % fname
+                    result.append(fname_output_line)
+            return result
+        return f
+
+    def _get_notebook_display_formatter(self,
+                                        spacer="&nbsp;&nbsp;"):
+        """ generate function to use for notebook formatting
+        """
+        dirname_output_format = \
+         self.result_html_prefix + "%s/" + self.result_html_suffix
+        fname_output_format = \
+         self.result_html_prefix + spacer + self.html_link_str + self.result_html_suffix
+        fp_format = self.url_prefix + '%s/%s'
+        if sep == "\\":
+            # Working on a platform where the path separator is "\", so
+            # must convert these to "/" for generating a URI
+            def fp_cleaner(fp):
+                # Replace all occurrences of backslash ("\") with a forward
+                # slash ("/") - this is necessary on windows when a path is
+                # provided as input, but we must link to a URI
+                return fp.replace('\\','/')
+        else:
+            fp_cleaner = None
+
+        return self._get_display_formatter(dirname_output_format,
+                                           fname_output_format,
+                                           fp_format,
+                                           fp_cleaner)
+
+    def _get_terminal_display_formatter(self,
+                                        spacer="  "):
+        """ generate function to use for terminal formatting
+        """
+        dirname_output_format = "%s/"
+        fname_output_format = spacer + "%s"
+        fp_format = '%s/%s'
+
+        return self._get_display_formatter(dirname_output_format,
+                                           fname_output_format,
+                                           fp_format)
+
+    def _format_path(self):
+        result_lines = []
+        if self.recursive:
+            walked_dir = list(walk(self.path))
+        else:
+            walked_dir = [next(walk(self.path))]
+        walked_dir.sort()
+        for dirname, subdirs, fnames in walked_dir:
+            result_lines += self.notebook_display_formatter(dirname, fnames, self.included_suffixes)
+        return '\n'.join(result_lines)
+
+    def __repr__(self):
+        """return newline-separated absolute paths
+        """
+        result_lines = []
+        if self.recursive:
+            walked_dir = list(walk(self.path))
+        else:
+            walked_dir = [next(walk(self.path))]
+        walked_dir.sort()
+        for dirname, subdirs, fnames in walked_dir:
+            result_lines += self.terminal_display_formatter(dirname, fnames, self.included_suffixes)
+        return '\n'.join(result_lines)
+
+
+class Code(TextDisplayObject):
+    """Display syntax-highlighted source code.
+
+    This uses Pygments to highlight the code for HTML and Latex output.
+
+    Parameters
+    ----------
+    data : str
+        The code as a string
+    url : str
+        A URL to fetch the code from
+    filename : str
+        A local filename to load the code from
+    language : str
+        The short name of a Pygments lexer to use for highlighting.
+        If not specified, it will guess the lexer based on the filename
+        or the code. Available lexers: http://pygments.org/docs/lexers/
+    """
+    def __init__(self, data=None, url=None, filename=None, language=None):
+        self.language = language
+        super().__init__(data=data, url=url, filename=filename)
+
+    def _get_lexer(self):
+        if self.language:
+            from pygments.lexers import get_lexer_by_name
+            return get_lexer_by_name(self.language)
+        elif self.filename:
+            from pygments.lexers import get_lexer_for_filename
+            return get_lexer_for_filename(self.filename)
+        else:
+            from pygments.lexers import guess_lexer
+            return guess_lexer(self.data)
+
+    def __repr__(self):
+        return self.data
+
+    def _repr_html_(self):
+        from pygments import highlight
+        from pygments.formatters import HtmlFormatter
+        fmt = HtmlFormatter()
+        style = '<style>{}</style>'.format(fmt.get_style_defs('.output_html'))
+        return style + highlight(self.data, self._get_lexer(), fmt)
+
+    def _repr_latex_(self):
+        from pygments import highlight
+        from pygments.formatters import LatexFormatter
+        return highlight(self.data, self._get_lexer(), LatexFormatter())
diff --git a/IPython/lib/editorhooks.py b/IPython/lib/editorhooks.py
new file mode 100644
index 00000000000..d8bd6ac81bc
--- /dev/null
+++ b/IPython/lib/editorhooks.py
@@ -0,0 +1,127 @@
+""" 'editor' hooks for common editors that work well with ipython
+
+They should honor the line number argument, at least.
+
+Contributions are *very* welcome.
+"""
+
+import os
+import shlex
+import subprocess
+import sys
+
+from IPython import get_ipython
+from IPython.core.error import TryNext
+from IPython.utils import py3compat
+
+
+def install_editor(template, wait=False):
+    """Installs the editor that is called by IPython for the %edit magic.
+
+    This overrides the default editor, which is generally set by your EDITOR
+    environment variable or is notepad (windows) or vi (linux). By supplying a
+    template string `run_template`, you can control how the editor is invoked
+    by IPython -- (e.g. the format in which it accepts command line options)
+
+    Parameters
+    ----------
+    template : basestring
+        run_template acts as a template for how your editor is invoked by
+        the shell. It should contain '{filename}', which will be replaced on
+        invocation with the file name, and '{line}', $line by line number
+        (or 0) to invoke the file with.
+    wait : bool
+        If `wait` is true, wait until the user presses enter before returning,
+        to facilitate non-blocking editors that exit immediately after
+        the call.
+    """
+
+    # not all editors support $line, so we'll leave out this check
+    # for substitution in ['$file', '$line']:
+    #    if not substitution in run_template:
+    #        raise ValueError(('run_template should contain %s'
+    #        ' for string substitution. You supplied "%s"' % (substitution,
+    #            run_template)))
+
+    def call_editor(self, filename, line=0):
+        if line is None:
+            line = 0
+        cmd = template.format(filename=shlex.quote(filename), line=line)
+        print(">", cmd)
+        # shlex.quote doesn't work right on Windows, but it does after splitting
+        if sys.platform.startswith('win'):
+            cmd = shlex.split(cmd)
+        proc = subprocess.Popen(cmd, shell=True)
+        if proc.wait() != 0:
+            raise TryNext()
+        if wait:
+            py3compat.input("Press Enter when done editing:")
+
+    get_ipython().set_hook('editor', call_editor)
+    get_ipython().editor = template
+
+
+# in these, exe is always the path/name of the executable. Useful
+# if you don't have the editor directory in your path
+def komodo(exe=u'komodo'):
+    """ Activestate Komodo [Edit] """
+    install_editor(exe + u' -l {line} {filename}', wait=True)
+
+
+def scite(exe=u"scite"):
+    """ SciTE or Sc1 """
+    install_editor(exe + u' {filename} -goto:{line}')
+
+
+def notepadplusplus(exe=u'notepad++'):
+    """ Notepad++ http://notepad-plus.sourceforge.net """
+    install_editor(exe + u' -n{line} {filename}')
+
+
+def jed(exe=u'jed'):
+    """ JED, the lightweight emacsish editor """
+    install_editor(exe + u' +{line} {filename}')
+
+
+def idle(exe=u'idle'):
+    """ Idle, the editor bundled with python
+
+    Parameters
+    ----------
+    exe : str, None
+        If none, should be pretty smart about finding the executable.
+    """
+    if exe is None:
+        import idlelib
+        p = os.path.dirname(idlelib.__filename__)
+        # i'm not sure if this actually works. Is this idle.py script
+        # guaranteed to be executable?
+        exe = os.path.join(p, 'idle.py')
+    install_editor(exe + u' {filename}')
+
+
+def mate(exe=u'mate'):
+    """ TextMate, the missing editor"""
+    # wait=True is not required since we're using the -w flag to mate
+    install_editor(exe + u' -w -l {line} {filename}')
+
+
+# ##########################################
+# these are untested, report any problems
+# ##########################################
+
+
+def emacs(exe=u'emacs'):
+    install_editor(exe + u' +{line} {filename}')
+
+
+def gnuclient(exe=u'gnuclient'):
+    install_editor(exe + u' -nw +{line} {filename}')
+
+
+def crimson_editor(exe=u'cedt.exe'):
+    install_editor(exe + u' /L:{line} {filename}')
+
+
+def kate(exe=u'kate'):
+    install_editor(exe + u' -u -l {line} {filename}')
diff --git a/IPython/lib/guisupport.py b/IPython/lib/guisupport.py
index e16645b46b3..4d532d0f4d5 100644
--- a/IPython/lib/guisupport.py
+++ b/IPython/lib/guisupport.py
@@ -1,19 +1,18 @@
-#!/usr/bin/env python
 # coding: utf-8
 """
 Support for creating GUI apps and starting event loops.
 
-IPython's GUI integration allows interative plotting and GUI usage in IPython
+IPython's GUI integration allows interactive plotting and GUI usage in IPython
 session. IPython has two different types of GUI integration:
 
 1. The terminal based IPython supports GUI event loops through Python's
    PyOS_InputHook. PyOS_InputHook is a hook that Python calls periodically
    whenever raw_input is waiting for a user to type code. We implement GUI
-   support in the terminal by setting PyOS_InputHook to a function that 
+   support in the terminal by setting PyOS_InputHook to a function that
    iterates the event loop for a short while. It is important to note that
    in this situation, the real GUI event loop is NOT run in the normal
    manner, so you can't use the normal means to detect that it is running.
-2. In the two process IPython kernel/frontend, the GUI event loop is run in 
+2. In the two process IPython kernel/frontend, the GUI event loop is run in
    the kernel. In this case, the event loop is run in the normal manner by
    calling the function or method of the GUI toolkit that starts the event
    loop.
@@ -48,7 +47,7 @@
   *must* use its value. If it has not been set, you can query the toolkit
   in the normal manner.
 * If you want GUI support and no one else has created an application or
-  started the event loop you *must* do this. We don't want projects to 
+  started the event loop you *must* do this. We don't want projects to
   attempt to defer these things to someone else if they themselves need it.
 
 The functions below implement this logic for each GUI toolkit. If you need
@@ -58,16 +57,10 @@
 
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+from IPython.core.getipython import get_ipython
 
 #-----------------------------------------------------------------------------
 # wx
@@ -78,13 +71,22 @@ def get_app_wx(*args, **kwargs):
     import wx
     app = wx.GetApp()
     if app is None:
-        if not kwargs.has_key('redirect'):
+        if 'redirect' not in kwargs:
             kwargs['redirect'] = False
         app = wx.PySimpleApp(*args, **kwargs)
     return app
 
 def is_event_loop_running_wx(app=None):
     """Is the wx event loop running."""
+    # New way: check attribute on shell instance
+    ip = get_ipython()
+    if ip is not None:
+        if ip.active_eventloop and ip.active_eventloop == 'wx':
+            return True
+        # Fall through to checking the application, because Wx has a native way
+        # to check if the event loop is running, unlike Qt.
+
+    # Old way: check Wx application
     if app is None:
         app = get_app_wx()
     if hasattr(app, '_in_event_loop'):
@@ -104,33 +106,39 @@ def start_event_loop_wx(app=None):
         app._in_event_loop = True
 
 #-----------------------------------------------------------------------------
-# qt4
+# Qt
 #-----------------------------------------------------------------------------
 
 def get_app_qt4(*args, **kwargs):
-    """Create a new qt4 app or return an existing one."""
-    from PyQt4 import QtGui
+    """Create a new Qt app or return an existing one."""
+    from IPython.external.qt_for_kernel import QtGui
     app = QtGui.QApplication.instance()
     if app is None:
         if not args:
-            args = ([''],)
+            args = ([""],)
         app = QtGui.QApplication(*args, **kwargs)
     return app
 
 def is_event_loop_running_qt4(app=None):
-    """Is the qt4 event loop running."""
+    """Is the qt event loop running."""
+    # New way: check attribute on shell instance
+    ip = get_ipython()
+    if ip is not None:
+        return ip.active_eventloop and ip.active_eventloop.startswith('qt')
+
+    # Old way: check attribute on QApplication singleton
     if app is None:
-        app = get_app_qt4([''])
+        app = get_app_qt4([""])
     if hasattr(app, '_in_event_loop'):
         return app._in_event_loop
     else:
-        # Does qt4 provide a other way to detect this?
+        # Does qt provide a other way to detect this?
         return False
 
 def start_event_loop_qt4(app=None):
-    """Start the qt4 event loop in a consistent manner."""
+    """Start the qt event loop in a consistent manner."""
     if app is None:
-        app = get_app_qt4([''])
+        app = get_app_qt4([""])
     if not is_event_loop_running_qt4(app):
         app._in_event_loop = True
         app.exec_()
diff --git a/IPython/lib/inputhook.py b/IPython/lib/inputhook.py
deleted file mode 100755
index bb619cb9b00..00000000000
--- a/IPython/lib/inputhook.py
+++ /dev/null
@@ -1,326 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-"""
-Inputhook management for GUI event loop integration.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import ctypes
-import sys
-
-#-----------------------------------------------------------------------------
-# Constants
-#-----------------------------------------------------------------------------
-
-# Constants for identifying the GUI toolkits.
-GUI_WX = 'wx'
-GUI_QT = 'qt'
-GUI_QT4 = 'qt4'
-GUI_GTK = 'gtk'
-GUI_TK = 'tk'
-GUI_OSX = 'osx'
-
-#-----------------------------------------------------------------------------
-# Utility classes
-#-----------------------------------------------------------------------------
-
-
-#-----------------------------------------------------------------------------
-# Main InputHookManager class
-#-----------------------------------------------------------------------------
-
-
-class InputHookManager(object):
-    """Manage PyOS_InputHook for different GUI toolkits.
-
-    This class installs various hooks under ``PyOSInputHook`` to handle
-    GUI event loop integration.
-    """
-    
-    def __init__(self):
-        self.PYFUNC = ctypes.PYFUNCTYPE(ctypes.c_int)
-        self._apps = {}
-        self._reset()
-
-    def _reset(self):
-        self._callback_pyfunctype = None
-        self._callback = None
-        self._installed = False
-        self._current_gui = None
-
-    def get_pyos_inputhook(self):
-        """Return the current PyOS_InputHook as a ctypes.c_void_p."""
-        return ctypes.c_void_p.in_dll(ctypes.pythonapi,"PyOS_InputHook")
-
-    def get_pyos_inputhook_as_func(self):
-        """Return the current PyOS_InputHook as a ctypes.PYFUNCYPE."""
-        return self.PYFUNC.in_dll(ctypes.pythonapi,"PyOS_InputHook")
-
-    def set_inputhook(self, callback):
-        """Set PyOS_InputHook to callback and return the previous one."""
-        self._callback = callback
-        self._callback_pyfunctype = self.PYFUNC(callback)
-        pyos_inputhook_ptr = self.get_pyos_inputhook()
-        original = self.get_pyos_inputhook_as_func()
-        pyos_inputhook_ptr.value = \
-            ctypes.cast(self._callback_pyfunctype, ctypes.c_void_p).value
-        self._installed = True
-        return original
-
-    def clear_inputhook(self, app=None):
-        """Set PyOS_InputHook to NULL and return the previous one.
-
-        Parameters
-        ----------
-        app : optional, ignored
-          This parameter is allowed only so that clear_inputhook() can be
-          called with a similar interface as all the ``enable_*`` methods.  But
-          the actual value of the parameter is ignored.  This uniform interface
-          makes it easier to have user-level entry points in the main IPython
-          app like :meth:`enable_gui`."""
-        pyos_inputhook_ptr = self.get_pyos_inputhook()
-        original = self.get_pyos_inputhook_as_func()
-        pyos_inputhook_ptr.value = ctypes.c_void_p(None).value
-        self._reset()
-        return original
-
-    def clear_app_refs(self, gui=None):
-        """Clear IPython's internal reference to an application instance.
-
-        Whenever we create an app for a user on qt4 or wx, we hold a
-        reference to the app.  This is needed because in some cases bad things
-        can happen if a user doesn't hold a reference themselves.  This
-        method is provided to clear the references we are holding.
-
-        Parameters
-        ----------
-        gui : None or str
-            If None, clear all app references.  If ('wx', 'qt4') clear
-            the app for that toolkit.  References are not held for gtk or tk
-            as those toolkits don't have the notion of an app.
-        """
-        if gui is None:
-            self._apps = {}
-        elif self._apps.has_key(gui):
-            del self._apps[gui]
-
-    def enable_wx(self):
-        """Enable event loop integration with wxPython.
-
-        Parameters
-        ----------
-        app : bool
-            Create a running application object or not.
-
-        Notes
-        -----
-        This methods sets the ``PyOS_InputHook`` for wxPython, which allows
-        the wxPython to integrate with terminal based applications like
-        IPython.
-
-        If ``app`` is True, 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.App(redirect=False, clearSigInt=False)
-        app._in_event_loop = True
-        self._apps[GUI_WX] = app
-        return app
-
-    def disable_wx(self):
-        """Disable event loop integration with wxPython.
-
-        This merely sets PyOS_InputHook to NULL.
-        """
-        if self._apps.has_key(GUI_WX):
-            self._apps[GUI_WX]._in_event_loop = False
-        self.clear_inputhook()
-
-    def enable_qt4(self):
-        """Enable event loop integration with PyQt4.
-        
-        Parameters
-        ----------
-        app : bool
-            Create a running application object or not.
-
-        Notes
-        -----
-        This methods sets the PyOS_InputHook for PyQt4, which allows
-        the PyQt4 to integrate with terminal based applications like
-        IPython.
-
-        If ``app`` is True, 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 PyQt4 import QtCore
-        # PyQt4 has had this since 4.3.1.  In version 4.2, PyOS_InputHook
-        # was set when QtCore was imported, but if it ever got removed,
-        # you couldn't reset it.  For earlier versions we can
-        # probably implement a ctypes version.
-        try:
-            QtCore.pyqtRestoreInputHook()
-        except AttributeError:
-            pass
-        self._current_gui = GUI_QT4
-        from PyQt4 import QtGui
-        app = QtCore.QCoreApplication.instance()
-        if app is None:
-            app = QtGui.QApplication([" "])
-        app._in_event_loop = True
-        self._apps[GUI_QT4] = app
-        return app
-
-    def disable_qt4(self):
-        """Disable event loop integration with PyQt4.
-
-        This merely sets PyOS_InputHook to NULL.
-        """
-        if self._apps.has_key(GUI_QT4):
-            self._apps[GUI_QT4]._in_event_loop = False
-        self.clear_inputhook()
-
-    def enable_gtk(self, app=False):
-        """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.
-
-        Notes
-        -----
-        This methods sets the PyOS_InputHook for PyGTK, which allows
-        the PyGTK to integrate with terminal based applications like
-        IPython.
-        """
-        import gtk
-        try:
-            gtk.set_interactive(True)
-            self._current_gui = GUI_GTK
-        except AttributeError:
-            # For older versions of gtk, use our own ctypes version
-            from IPython.lib.inputhookgtk import inputhook_gtk
-            self.set_inputhook(inputhook_gtk)
-            self._current_gui = GUI_GTK
-
-    def disable_gtk(self):
-        """Disable event loop integration with PyGTK.
-        
-        This merely sets PyOS_InputHook to NULL.
-        """
-        self.clear_inputhook()
-
-    def enable_tk(self, app=False):
-        """Enable event loop integration with Tk.
-
-        Parameters
-        ----------
-        app : bool
-            Create a running application object or not.
-
-        Notes
-        -----
-        Currently this is a no-op as creating a :class:`Tkinter.Tk` object 
-        sets ``PyOS_InputHook``.
-        """
-        self._current_gui = GUI_TK
-        if app:
-            import Tkinter
-            app = Tkinter.Tk()
-            app.withdraw()
-            self._apps[GUI_TK] = app
-            return app
-
-    def disable_tk(self):
-        """Disable event loop integration with Tkinter.
-        
-        This merely sets PyOS_InputHook to NULL.
-        """
-        self.clear_inputhook()
-
-    def current_gui(self):
-        """Return a string indicating the currently active GUI or None."""
-        return self._current_gui
-
-inputhook_manager = InputHookManager()
-
-enable_wx = inputhook_manager.enable_wx
-disable_wx = inputhook_manager.disable_wx
-enable_qt4 = inputhook_manager.enable_qt4
-disable_qt4 = inputhook_manager.disable_qt4
-enable_gtk = inputhook_manager.enable_gtk
-disable_gtk = inputhook_manager.disable_gtk
-enable_tk = inputhook_manager.enable_tk
-disable_tk = inputhook_manager.disable_tk
-clear_inputhook = inputhook_manager.clear_inputhook
-set_inputhook = inputhook_manager.set_inputhook
-current_gui = inputhook_manager.current_gui
-clear_app_refs = inputhook_manager.clear_app_refs
-
-
-# Convenience function to switch amongst them
-def enable_gui(gui=None):
-    """Switch amongst GUI input hooks by name.
-
-    This is just a utility wrapper around the methods of the InputHookManager
-    object.
-
-    Parameters
-    ----------
-    gui : optional, string or 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.
-
-    Returns
-    -------
-    The output of the underlying gui switch routine, typically the actual
-    PyOS_InputHook wrapper object or the GUI toolkit app created, if there was
-    one.
-    """
-    guis = {None: clear_inputhook,
-            GUI_OSX: lambda app=False: None,
-            GUI_TK: enable_tk,
-            GUI_GTK: enable_gtk,
-            GUI_WX: enable_wx,
-            GUI_QT: enable_qt4, # qt3 not supported
-            GUI_QT4: enable_qt4 }
-    try:
-        gui_hook = guis[gui]
-    except KeyError:
-        e="Invalid GUI request %r, valid ones are:%s" % (gui, guis.keys())
-        raise ValueError(e)
-    return gui_hook()
-
diff --git a/IPython/lib/inputhookgtk.py b/IPython/lib/inputhookgtk.py
deleted file mode 100644
index 782a65c11c3..00000000000
--- a/IPython/lib/inputhookgtk.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Enable pygtk to be used interacive by setting PyOS_InputHook.
-
-Authors: Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-import gtk, gobject
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-def _main_quit(*args, **kwargs):
-    gtk.main_quit()
-    return False
-
-def inputhook_gtk():
-    gobject.io_add_watch(sys.stdin, gobject.IO_IN, _main_quit)
-    gtk.main()
-    return 0
-
diff --git a/IPython/lib/inputhookwx.py b/IPython/lib/inputhookwx.py
deleted file mode 100644
index e79b3ceed9c..00000000000
--- a/IPython/lib/inputhookwx.py
+++ /dev/null
@@ -1,179 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-"""
-Enable wxPython to be used interacive by setting PyOS_InputHook.
-
-Authors:  Robin Dunn, Brian Granger, Ondrej Certik
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import signal
-import sys
-import time
-from timeit import default_timer as clock
-import wx
-
-if os.name == 'posix':
-    import select
-elif sys.platform == 'win32':
-    import msvcrt
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-def stdin_ready():
-    if os.name == 'posix':
-        infds, outfds, erfds = select.select([sys.stdin],[],[],0)
-        if infds:
-            return True
-        else:
-            return False
-    elif sys.platform == 'win32':
-        return msvcrt.kbhit()
-
-
-def inputhook_wx1():
-    """Run the wx event loop by processing pending events only.
-    
-    This approach seems to work, but its performance is not great as it 
-    relies on having PyOS_InputHook called regularly.
-    """
-    try:
-        app = wx.GetApp()
-        if app is not None:
-            assert wx.Thread_IsMain()
-
-            # Make a temporary event loop and process system events until
-            # there are no more waiting, then allow idle events (which
-            # will also deal with pending or posted wx events.)
-            evtloop = wx.EventLoop()
-            ea = wx.EventLoopActivator(evtloop)
-            while evtloop.Pending():
-                evtloop.Dispatch()
-            app.ProcessIdle()
-            del ea
-    except KeyboardInterrupt:
-        pass
-    return 0
-
-class EventLoopTimer(wx.Timer):
-
-    def __init__(self, func):
-        self.func = func
-        wx.Timer.__init__(self)
-
-    def Notify(self):
-        self.func()
-
-class EventLoopRunner(object):
-
-    def Run(self, time):
-        self.evtloop = wx.EventLoop()
-        self.timer = EventLoopTimer(self.check_stdin)
-        self.timer.Start(time)
-        self.evtloop.Run()
-
-    def check_stdin(self):
-        if stdin_ready():
-            self.timer.Stop()
-            self.evtloop.Exit()
-
-def inputhook_wx2():
-    """Run the wx event loop, polling for stdin.
-    
-    This version runs the wx eventloop for an undetermined amount of time,
-    during which it periodically checks to see if anything is ready on
-    stdin.  If anything is ready on stdin, the event loop exits.
-    
-    The argument to elr.Run controls how often the event loop looks at stdin.
-    This determines the responsiveness at the keyboard.  A setting of 1000
-    enables a user to type at most 1 char per second.  I have found that a
-    setting of 10 gives good keyboard response.  We can shorten it further, 
-    but eventually performance would suffer from calling select/kbhit too 
-    often.
-    """
-    try:
-        app = wx.GetApp()
-        if app is not None:
-            assert wx.Thread_IsMain()
-            elr = EventLoopRunner()
-            # As this time is made shorter, keyboard response improves, but idle
-            # CPU load goes up.  10 ms seems like a good compromise.
-            elr.Run(time=10)  # CHANGE time here to control polling interval
-    except KeyboardInterrupt:
-        pass
-    return 0
-
-def inputhook_wx3():
-    """Run the wx event loop by processing pending events only.
-    
-    This is like inputhook_wx1, but it keeps processing pending events
-    until stdin is ready.  After processing all pending events, a call to 
-    time.sleep is inserted.  This is needed, otherwise, CPU usage is at 100%.
-    This sleep time should be tuned though for best performance.
-    """
-    # We need to protect against a user pressing Control-C when IPython is
-    # idle and this is running. We trap KeyboardInterrupt and pass.
-    try:
-        app = wx.GetApp()
-        if app is not None:
-            assert wx.Thread_IsMain()
-
-            # The import of wx on Linux sets the handler for signal.SIGINT
-            # to 0.  This is a bug in wx or gtk.  We fix by just setting it
-            # back to the Python default.
-            if not callable(signal.getsignal(signal.SIGINT)):
-                signal.signal(signal.SIGINT, signal.default_int_handler)
-
-            evtloop = wx.EventLoop()
-            ea = wx.EventLoopActivator(evtloop)
-            t = clock()
-            while not stdin_ready():
-                while evtloop.Pending():
-                    t = clock()
-                    evtloop.Dispatch()
-                app.ProcessIdle()
-                # We need to sleep at this point to keep the idle CPU load
-                # low.  However, if sleep to long, GUI response is poor.  As 
-                # a compromise, we watch how often GUI events are being processed
-                # and switch between a short and long sleep time.  Here are some
-                # stats useful in helping to tune this.
-                # time    CPU load
-                # 0.001   13%
-                # 0.005   3%
-                # 0.01    1.5%
-                # 0.05    0.5%
-                used_time = clock() - t
-                if used_time > 5*60.0:
-                    # print 'Sleep for 5 s'  # dbg
-                    time.sleep(5.0)
-                elif used_time > 10.0:
-                    # print 'Sleep for 1 s'  # dbg
-                    time.sleep(1.0)
-                elif used_time > 0.1:
-                    # Few GUI events coming in, so we can sleep longer
-                    # print 'Sleep for 0.05 s'  # dbg
-                    time.sleep(0.05)
-                else:
-                    # Many GUI events coming in, so sleep only very little
-                    time.sleep(0.001)
-            del ea
-    except KeyboardInterrupt:
-        pass
-    return 0
-
-# This is our default implementation
-inputhook_wx = inputhook_wx3
diff --git a/IPython/lib/irunner.py b/IPython/lib/irunner.py
deleted file mode 100755
index 5c97cfa6405..00000000000
--- a/IPython/lib/irunner.py
+++ /dev/null
@@ -1,441 +0,0 @@
-#!/usr/bin/env python
-"""Module for interactively running scripts.
-
-This module implements classes for interactively running scripts written for
-any system with a prompt which can be matched by a regexp suitable for
-pexpect.  It can be used to run as if they had been typed up interactively, an
-arbitrary series of commands for the target system.
-
-The module includes classes ready for IPython (with the default prompts),
-plain Python and SAGE, but making a new one is trivial.  To see how to use it,
-simply run the module as a script:
-
-./irunner.py --help
-
-
-This is an extension of Ken Schutte <kschutte-AT-csail.mit.edu>'s script
-contributed on the ipython-user list:
-
-http://scipy.net/pipermail/ipython-user/2006-May/001705.html
-
-
-NOTES:
-
- - This module requires pexpect, available in most linux distros, or which can
- be downloaded from
-
-    http://pexpect.sourceforge.net
-
- - Because pexpect only works under Unix or Windows-Cygwin, this has the same
- limitations.  This means that it will NOT work under native windows Python.
-"""
-
-# Stdlib imports
-import optparse
-import os
-import sys
-
-# Third-party modules.
-import pexpect
-
-# Global usage strings, to avoid indentation issues when typing it below.
-USAGE = """
-Interactive script runner, type: %s
-
-runner [opts] script_name
-"""
-
-def pexpect_monkeypatch():
-    """Patch pexpect to prevent unhandled exceptions at VM teardown.
-
-    Calling this function will monkeypatch the pexpect.spawn class and modify
-    its __del__ method to make it more robust in the face of failures that can
-    occur if it is called when the Python VM is shutting down.
-
-    Since Python may fire __del__ methods arbitrarily late, it's possible for
-    them to execute during the teardown of the Python VM itself.  At this
-    point, various builtin modules have been reset to None.  Thus, the call to
-    self.close() will trigger an exception because it tries to call os.close(),
-    and os is now None.
-    """
-    
-    if pexpect.__version__[:3] >= '2.2':
-        # No need to patch, fix is already the upstream version.
-        return
-    
-    def __del__(self):
-        """This makes sure that no system resources are left open.
-        Python only garbage collects Python objects. OS file descriptors
-        are not Python objects, so they must be handled explicitly.
-        If the child file descriptor was opened outside of this class
-        (passed to the constructor) then this does not close it.
-        """
-        if not self.closed:
-            try:
-                self.close()
-            except AttributeError:
-                pass
-
-    pexpect.spawn.__del__ = __del__
-
-pexpect_monkeypatch()
-
-# The generic runner class
-class InteractiveRunner(object):
-    """Class to run a sequence of commands through an interactive program."""
-    
-    def __init__(self,program,prompts,args=None,out=sys.stdout,echo=True):
-        """Construct a runner.
-
-        Inputs:
-
-          - program: command to execute the given program.
-
-          - prompts: a list of patterns to match as valid prompts, in the
-          format used by pexpect.  This basically means that it can be either
-          a string (to be compiled as a regular expression) or a list of such
-          (it must be a true list, as pexpect does type checks).
-
-          If more than one prompt is given, the first is treated as the main
-          program prompt and the others as 'continuation' prompts, like
-          python's.  This means that blank lines in the input source are
-          ommitted when the first prompt is matched, but are NOT ommitted when
-          the continuation one matches, since this is how python signals the
-          end of multiline input interactively.
-
-        Optional inputs:
-
-          - args(None): optional list of strings to pass as arguments to the
-          child program.
-
-          - out(sys.stdout): if given, an output stream to be used when writing
-          output.  The only requirement is that it must have a .write() method.
-
-        Public members not parameterized in the constructor:
-
-          - delaybeforesend(0): Newer versions of pexpect have a delay before
-          sending each new input.  For our purposes here, it's typically best
-          to just set this to zero, but if you encounter reliability problems
-          or want an interactive run to pause briefly at each prompt, just
-          increase this value (it is measured in seconds).  Note that this
-          variable is not honored at all by older versions of pexpect.
-        """
-        
-        self.program = program
-        self.prompts = prompts
-        if args is None: args = []
-        self.args = args
-        self.out = out
-        self.echo = echo
-        # Other public members which we don't make as parameters, but which
-        # users may occasionally want to tweak
-        self.delaybeforesend = 0
-
-        # Create child process and hold on to it so we don't have to re-create
-        # for every single execution call
-        c = self.child = pexpect.spawn(self.program,self.args,timeout=None)
-        c.delaybeforesend = self.delaybeforesend
-        # pexpect hard-codes the terminal size as (24,80) (rows,columns).
-        # This causes problems because any line longer than 80 characters gets
-        # completely overwrapped on the printed outptut (even though
-        # internally the code runs fine).  We reset this to 99 rows X 200
-        # columns (arbitrarily chosen), which should avoid problems in all
-        # reasonable cases.
-        c.setwinsize(99,200)
-
-    def close(self):
-        """close child process"""
-
-        self.child.close()
-
-    def run_file(self,fname,interact=False,get_output=False):
-        """Run the given file interactively.
-
-        Inputs:
-
-          -fname: name of the file to execute.
-
-        See the run_source docstring for the meaning of the optional
-        arguments."""
-
-        fobj = open(fname,'r')
-        try:
-            out = self.run_source(fobj,interact,get_output)
-        finally:
-            fobj.close()
-        if get_output:
-            return out
-
-    def run_source(self,source,interact=False,get_output=False):
-        """Run the given source code interactively.
-
-        Inputs:
-
-          - source: a string of code to be executed, or an open file object we
-          can iterate over.
-
-        Optional inputs:
-
-          - interact(False): if true, start to interact with the running
-          program at the end of the script.  Otherwise, just exit.
-
-          - get_output(False): if true, capture the output of the child process
-          (filtering the input commands out) and return it as a string.
-
-        Returns:
-          A string containing the process output, but only if requested.
-          """
-
-        # if the source is a string, chop it up in lines so we can iterate
-        # over it just as if it were an open file.
-        if not isinstance(source,file):
-            source = source.splitlines(True)
-
-        if self.echo:
-            # normalize all strings we write to use the native OS line
-            # separators.
-            linesep  = os.linesep
-            stdwrite = self.out.write
-            write    = lambda s: stdwrite(s.replace('\r\n',linesep))
-        else:
-            # Quiet mode, all writes are no-ops
-            write = lambda s: None
-            
-        c = self.child
-        prompts = c.compile_pattern_list(self.prompts)
-        prompt_idx = c.expect_list(prompts)
-
-        # Flag whether the script ends normally or not, to know whether we can
-        # do anything further with the underlying process.
-        end_normal = True
-
-        # If the output was requested, store it in a list for return at the end
-        if get_output:
-            output = []
-            store_output = output.append
-        
-        for cmd in source:
-            # skip blank lines for all matches to the 'main' prompt, while the
-            # secondary prompts do not
-            if prompt_idx==0 and \
-                   (cmd.isspace() or cmd.lstrip().startswith('#')):
-                write(cmd)
-                continue
-
-            # write('AFTER: '+c.after)  # dbg
-            write(c.after)
-            c.send(cmd)
-            try:
-                prompt_idx = c.expect_list(prompts)
-            except pexpect.EOF:
-                # this will happen if the child dies unexpectedly
-                write(c.before)
-                end_normal = False
-                break
-            
-            write(c.before)
-
-            # With an echoing process, the output we get in c.before contains
-            # the command sent, a newline, and then the actual process output
-            if get_output:
-                store_output(c.before[len(cmd+'\n'):])
-                #write('CMD: <<%s>>' % cmd)  # dbg
-                #write('OUTPUT: <<%s>>' % output[-1])  # dbg
-
-        self.out.flush()
-        if end_normal:
-            if interact:
-                c.send('\n')
-                print '<< Starting interactive mode >>',
-                try:
-                    c.interact()
-                except OSError:
-                    # This is what fires when the child stops.  Simply print a
-                    # newline so the system prompt is aligned.  The extra
-                    # space is there to make sure it gets printed, otherwise
-                    # OS buffering sometimes just suppresses it.
-                    write(' \n')
-                    self.out.flush()
-        else:
-            if interact:
-                e="Further interaction is not possible: child process is dead."
-                print >> sys.stderr, e
-
-        # Leave the child ready for more input later on, otherwise select just
-        # hangs on the second invocation.
-        c.send('\n')
-        
-        # Return any requested output
-        if get_output:
-            return ''.join(output)
-                
-    def main(self,argv=None):
-        """Run as a command-line script."""
-
-        parser = optparse.OptionParser(usage=USAGE % self.__class__.__name__)
-        newopt = parser.add_option
-        newopt('-i','--interact',action='store_true',default=False,
-               help='Interact with the program after the script is run.')
-
-        opts,args = parser.parse_args(argv)
-
-        if len(args) != 1:
-            print >> sys.stderr,"You must supply exactly one file to run."
-            sys.exit(1)
-
-        self.run_file(args[0],opts.interact)
-
-
-# Specific runners for particular programs
-class IPythonRunner(InteractiveRunner):
-    """Interactive IPython runner.
-
-    This initalizes IPython in 'nocolor' mode for simplicity.  This lets us
-    avoid having to write a regexp that matches ANSI sequences, though pexpect
-    does support them.  If anyone contributes patches for ANSI color support,
-    they will be welcome.
-
-    It also sets the prompts manually, since the prompt regexps for
-    pexpect need to be matched to the actual prompts, so user-customized
-    prompts would break this.
-    """
-    
-    def __init__(self,program = 'ipython',args=None,out=sys.stdout,echo=True):
-        """New runner, optionally passing the ipython command to use."""
-        
-        args0 = ['--colors','NoColor',
-                 '-pi1','In [\\#]: ',
-                 '-pi2','   .\\D.: ',
-                 '--no-term-title',
-                 '--no-autoindent']
-        if args is None: args = args0
-        else: args = args0 + args
-        prompts = [r'In \[\d+\]: ',r'   \.*: ']
-        InteractiveRunner.__init__(self,program,prompts,args,out,echo)
-
-
-class PythonRunner(InteractiveRunner):
-    """Interactive Python runner."""
-
-    def __init__(self,program='python',args=None,out=sys.stdout,echo=True):
-        """New runner, optionally passing the python command to use."""
-
-        prompts = [r'>>> ',r'\.\.\. ']
-        InteractiveRunner.__init__(self,program,prompts,args,out,echo)
-
-
-class SAGERunner(InteractiveRunner):
-    """Interactive SAGE runner.
-    
-    WARNING: this runner only works if you manually configure your SAGE copy
-    to use 'colors NoColor' in the ipythonrc config file, since currently the
-    prompt matching regexp does not identify color sequences."""
-
-    def __init__(self,program='sage',args=None,out=sys.stdout,echo=True):
-        """New runner, optionally passing the sage command to use."""
-
-        prompts = ['sage: ',r'\s*\.\.\. ']
-        InteractiveRunner.__init__(self,program,prompts,args,out,echo)
-
-
-class RunnerFactory(object):
-    """Code runner factory.
-
-    This class provides an IPython code runner, but enforces that only one
-    runner is ever instantiated.  The runner is created based on the extension
-    of the first file to run, and it raises an exception if a runner is later
-    requested for a different extension type.
-
-    This ensures that we don't generate example files for doctest with a mix of
-    python and ipython syntax.
-    """
-
-    def __init__(self,out=sys.stdout):
-        """Instantiate a code runner."""
-        
-        self.out = out
-        self.runner = None
-        self.runnerClass = None
-
-    def _makeRunner(self,runnerClass):
-        self.runnerClass = runnerClass
-        self.runner = runnerClass(out=self.out)
-        return self.runner
-          
-    def __call__(self,fname):
-        """Return a runner for the given filename."""
-
-        if fname.endswith('.py'):
-            runnerClass = PythonRunner
-        elif fname.endswith('.ipy'):
-            runnerClass = IPythonRunner
-        else:
-            raise ValueError('Unknown file type for Runner: %r' % fname)
-
-        if self.runner is None:
-            return self._makeRunner(runnerClass)
-        else:
-            if runnerClass==self.runnerClass:
-                return self.runner
-            else:
-                e='A runner of type %r can not run file %r' % \
-                   (self.runnerClass,fname)
-                raise ValueError(e)
-
-
-# Global usage string, to avoid indentation issues if typed in a function def.
-MAIN_USAGE = """
-%prog [options] file_to_run
-
-This is an interface to the various interactive runners available in this
-module.  If you want to pass specific options to one of the runners, you need
-to first terminate the main options with a '--', and then provide the runner's
-options.  For example:
-
-irunner.py --python -- --help
-
-will pass --help to the python runner.  Similarly,
-
-irunner.py --ipython -- --interact script.ipy
-
-will run the script.ipy file under the IPython runner, and then will start to
-interact with IPython at the end of the script (instead of exiting).
-
-The already implemented runners are listed below; adding one for a new program
-is a trivial task, see the source for examples.
-
-WARNING: the SAGE runner only works if you manually configure your SAGE copy
-to use 'colors NoColor' in the ipythonrc config file, since currently the
-prompt matching regexp does not identify color sequences.
-"""
-
-def main():
-    """Run as a command-line script."""
-
-    parser = optparse.OptionParser(usage=MAIN_USAGE)
-    newopt = parser.add_option
-    parser.set_defaults(mode='ipython')
-    newopt('--ipython',action='store_const',dest='mode',const='ipython',
-           help='IPython interactive runner (default).')
-    newopt('--python',action='store_const',dest='mode',const='python',
-           help='Python interactive runner.')
-    newopt('--sage',action='store_const',dest='mode',const='sage',
-           help='SAGE interactive runner.')
-
-    opts,args = parser.parse_args()
-    runners = dict(ipython=IPythonRunner,
-                   python=PythonRunner,
-                   sage=SAGERunner)
-
-    try:
-        ext = os.path.splitext(args[0])[-1]
-    except IndexError:
-        ext = ''
-    modes = {'.ipy':'ipython',
-             '.py':'python',
-             '.sage':'sage'}
-    mode = modes.get(ext,opts.mode)
-    runners[mode]().main(args)
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/lib/latextools.py b/IPython/lib/latextools.py
index 3d97975b594..7e739f783d9 100644
--- a/IPython/lib/latextools.py
+++ b/IPython/lib/latextools.py
@@ -1,51 +1,244 @@
 # -*- coding: utf-8 -*-
-"""Tools for handling LaTeX.
+"""Tools for handling LaTeX."""
 
-Authors:
-
-* Brian Granger
-"""
-#-----------------------------------------------------------------------------
-# Copyright (c) 2010, IPython Development Team.
-#
+# Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+from io import BytesIO
+import os
+import tempfile
+import shutil
+import subprocess
+from base64 import encodebytes
+import textwrap
+
+from pathlib import Path
+
+from IPython.utils.process import find_cmd, FindCmdError
+from traitlets.config import get_config
+from traitlets.config.configurable import SingletonConfigurable
+from traitlets import List, Bool, Unicode
+
+
+class LaTeXTool(SingletonConfigurable):
+    """An object to store configuration of the LaTeX tool."""
+    def _config_default(self):
+        return get_config()
+
+    backends = List(
+        Unicode(), ["matplotlib", "dvipng"],
+        help="Preferred backend to draw LaTeX math equations. "
+        "Backends in the list are checked one by one and the first "
+        "usable one is used.  Note that `matplotlib` backend "
+        "is usable only for inline style equations.  To draw  "
+        "display style equations, `dvipng` backend must be specified. ",
+        # It is a List instead of Enum, to make configuration more
+        # flexible.  For example, to use matplotlib mainly but dvipng
+        # for display style, the default ["matplotlib", "dvipng"] can
+        # be used.  To NOT use dvipng so that other repr such as
+        # unicode pretty printing is used, you can use ["matplotlib"].
+        ).tag(config=True)
+
+    use_breqn = Bool(
+        True,
+        help="Use breqn.sty to automatically break long equations. "
+        "This configuration takes effect only for dvipng backend.",
+        ).tag(config=True)
 
-from StringIO import StringIO
-from base64 import encodestring
+    packages = List(
+        ['amsmath', 'amsthm', 'amssymb', 'bm'],
+        help="A list of packages to use for dvipng backend. "
+        "'breqn' will be automatically appended when use_breqn=True.",
+        ).tag(config=True)
 
-#-----------------------------------------------------------------------------
-# Tools
-#-----------------------------------------------------------------------------
+    preamble = Unicode(
+        help="Additional preamble to use when generating LaTeX source "
+        "for dvipng backend.",
+        ).tag(config=True)
 
 
-def latex_to_png(s, encode=True):
-    """Render a LaTeX string to PNG using matplotlib.mathtext.
+def latex_to_png(
+    s: str, encode=False, backend=None, wrap=False, color="Black", scale=1.0
+):
+    """Render a LaTeX string to PNG.
 
     Parameters
     ----------
     s : str
         The raw string containing valid inline LaTeX.
     encode : bool, optional
-        Should the PNG data bebase64 encoded to make it JSON'able.
+        Should the PNG data base64 encoded to make it JSON'able.
+    backend : {matplotlib, dvipng}
+        Backend for producing PNG data.
+    wrap : bool
+        If true, Automatically wrap `s` as a LaTeX equation.
+    color : string
+        Foreground color name among dvipsnames, e.g. 'Maroon' or on hex RGB
+        format, e.g. '#AA20FA'.
+    scale : float
+        Scale factor for the resulting PNG.
+    None is returned when the backend cannot be used.
+
     """
-    from matplotlib import mathtext
-    
-    mt = mathtext.MathTextParser('bitmap')
-    f = StringIO()
-    mt.to_png(f, s, fontsize=12)
-    bin_data = f.getvalue()
-    if encode:
-        bin_data = encodestring(bin_data)
+    assert isinstance(s, str)
+    allowed_backends = LaTeXTool.instance().backends
+    if backend is None:
+        backend = allowed_backends[0]
+    if backend not in allowed_backends:
+        return None
+    if backend == 'matplotlib':
+        f = latex_to_png_mpl
+    elif backend == 'dvipng':
+        f = latex_to_png_dvipng
+        if color.startswith('#'):
+            # Convert hex RGB color to LaTeX RGB color.
+            if len(color) == 7:
+                try:
+                    color = "RGB {}".format(" ".join([str(int(x, 16)) for x in
+                                                      textwrap.wrap(color[1:], 2)]))
+                except ValueError as e:
+                    raise ValueError('Invalid color specification {}.'.format(color)) from e
+            else:
+                raise ValueError('Invalid color specification {}.'.format(color))
+    else:
+        raise ValueError('No such backend {0}'.format(backend))
+    bin_data = f(s, wrap, color, scale)
+    if encode and bin_data:
+        bin_data = encodebytes(bin_data)
     return bin_data
 
-_data_uri_template_png = """<img src="data:image/png;base64,%s" alt=%s />"""
+
+def latex_to_png_mpl(s, wrap, color='Black', scale=1.0):
+    try:
+        from matplotlib import figure, font_manager, mathtext
+        from matplotlib.backends import backend_agg
+        from pyparsing import ParseFatalException
+    except ImportError:
+        return None
+
+    # mpl mathtext doesn't support display math, force inline
+    s = s.replace('$$', '$')
+    if wrap:
+        s = u'${0}$'.format(s)
+
+    try:
+        prop = font_manager.FontProperties(size=12)
+        dpi = 120 * scale
+        buffer = BytesIO()
+
+        # Adapted from mathtext.math_to_image
+        parser = mathtext.MathTextParser("path")
+        width, height, depth, _, _ = parser.parse(s, dpi=72, prop=prop)
+        fig = figure.Figure(figsize=(width / 72, height / 72))
+        fig.text(0, depth / height, s, fontproperties=prop, color=color)
+        backend_agg.FigureCanvasAgg(fig)
+        fig.savefig(buffer, dpi=dpi, format="png", transparent=True)
+        return buffer.getvalue()
+    except (ValueError, RuntimeError, ParseFatalException):
+        return None
+
+
+def latex_to_png_dvipng(s, wrap, color='Black', scale=1.0):
+    try:
+        find_cmd('latex')
+        find_cmd('dvipng')
+    except FindCmdError:
+        return None
+
+    startupinfo = None
+    if os.name == "nt":
+        # prevent popup-windows
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+
+    try:
+        workdir = Path(tempfile.mkdtemp())
+        tmpfile = "tmp.tex"
+        dvifile = "tmp.dvi"
+        outfile = "tmp.png"
+
+        with workdir.joinpath(tmpfile).open("w", encoding="utf8") as f:
+            f.writelines(genelatex(s, wrap))
+
+        subprocess.check_call(
+            ["latex", "-halt-on-error", "-interaction", "batchmode", tmpfile],
+            cwd=workdir,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            startupinfo=startupinfo,
+        )
+
+        resolution = round(150 * scale)
+        subprocess.check_call(
+            [
+                "dvipng",
+                "-T",
+                "tight",
+                "-D",
+                str(resolution),
+                "-z",
+                "9",
+                "-bg",
+                "Transparent",
+                "-o",
+                outfile,
+                dvifile,
+                "-fg",
+                color,
+            ],
+            cwd=workdir,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            startupinfo=startupinfo,
+        )
+
+        with workdir.joinpath(outfile).open("rb") as f:
+            return f.read()
+    except subprocess.CalledProcessError:
+        return None
+    finally:
+        shutil.rmtree(workdir)
+
+
+def kpsewhich(filename):
+    """Invoke kpsewhich command with an argument `filename`."""
+    try:
+        find_cmd("kpsewhich")
+        proc = subprocess.Popen(
+            ["kpsewhich", filename],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        (stdout, stderr) = proc.communicate()
+        return stdout.strip().decode('utf8', 'replace')
+    except FindCmdError:
+        pass
+
+
+def genelatex(body, wrap):
+    """Generate LaTeX document for dvipng backend."""
+    lt = LaTeXTool.instance()
+    breqn = wrap and lt.use_breqn and kpsewhich("breqn.sty")
+    yield r'\documentclass{article}'
+    packages = lt.packages
+    if breqn:
+        packages = packages + ['breqn']
+    for pack in packages:
+        yield r'\usepackage{{{0}}}'.format(pack)
+    yield r'\pagestyle{empty}'
+    if lt.preamble:
+        yield lt.preamble
+    yield r'\begin{document}'
+    if breqn:
+        yield r'\begin{dmath*}'
+        yield body
+        yield r'\end{dmath*}'
+    elif wrap:
+        yield u'$${0}$$'.format(body)
+    else:
+        yield body
+    yield u'\\end{document}'
+
+
+_data_uri_template_png = u"""<img src="data:image/png;base64,%s" alt=%s />"""
 
 def latex_to_html(s, alt='image'):
     """Render LaTeX to HTML with embedded PNG data using data URIs.
@@ -57,6 +250,8 @@ def latex_to_html(s, alt='image'):
     alt : str
         The alt text to use for the HTML.
     """
-    base64_data = latex_to_png(s, encode=True)
-    return _data_uri_template_png  % (base64_data, alt)
+    base64_data = latex_to_png(s, encode=True).decode('ascii')
+    if base64_data:
+        return _data_uri_template_png  % (base64_data, alt)
+
 
diff --git a/IPython/lib/lexers.py b/IPython/lib/lexers.py
new file mode 100644
index 00000000000..c13eeb3f031
--- /dev/null
+++ b/IPython/lib/lexers.py
@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+"""
+The IPython lexers are now a separate package, ipython-pygments-lexers.
+
+Importing from here is deprecated and may break in the future.
+"""
+# -----------------------------------------------------------------------------
+# Copyright (c) 2013, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+from ipython_pygments_lexers import (
+    IPythonLexer,
+    IPython3Lexer,
+    IPythonPartialTracebackLexer,
+    IPythonTracebackLexer,
+    IPythonConsoleLexer,
+    IPyLexer,
+)
+
+
+__all__ = [
+    "IPython3Lexer",
+    "IPythonLexer",
+    "IPythonPartialTracebackLexer",
+    "IPythonTracebackLexer",
+    "IPythonConsoleLexer",
+    "IPyLexer",
+]
diff --git a/IPython/lib/pretty.py b/IPython/lib/pretty.py
index 66ef7b76bff..fc3c524b72b 100644
--- a/IPython/lib/pretty.py
+++ b/IPython/lib/pretty.py
@@ -1,145 +1,178 @@
-# -*- coding: utf-8 -*-
 """
-    pretty
-    ~~
+Python advanced pretty printer.  This pretty printer is intended to
+replace the old `pprint` python module which does not allow developers
+to provide their own pretty print callbacks.
 
-    Python advanced pretty printer.  This pretty printer is intended to
-    replace the old `pprint` python module which does not allow developers
-    to provide their own pretty print callbacks.
+This module is based on ruby's `prettyprint.rb` library by `Tanaka Akira`.
 
-    This module is based on ruby's `prettyprint.rb` library by `Tanaka Akira`.
 
+Example Usage
+-------------
 
-    Example Usage
-    =============
+To directly print the representation of an object use `pprint`::
 
-    To directly print the representation of an object use `pprint`::
+    from pretty import pprint
+    pprint(complex_object)
 
-        from pretty import pprint
-        pprint(complex_object)
+To get a string of the output use `pretty`::
 
-    To get a string of the output use `pretty`::
+    from pretty import pretty
+    string = pretty(complex_object)
 
-        from pretty import pretty
-        string = pretty(complex_object)
 
+Extending
+---------
 
-    Extending
-    =========
+The pretty library allows developers to add pretty printing rules for their
+own objects.  This process is straightforward.  All you have to do is to
+add a `_repr_pretty_` method to your object and call the methods on the
+pretty printer passed::
 
-    The pretty library allows developers to add pretty printing rules for their
-    own objects.  This process is straightforward.  All you have to do is to
-    add a `__pretty__` method to your object and call the methods on the
-    pretty printer passed::
+    class MyObject(object):
 
-        class MyObject(object):
+        def _repr_pretty_(self, p, cycle):
+            ...
 
-            def __pretty__(self, p, cycle):
-                ...
+Here's an example for a class with a simple constructor::
 
-    Depending on the python version you want to support you have two
-    possibilities.  The following list shows the python 2.5 version and the
-    compatibility one.
+    class MySimpleObject:
 
+        def __init__(self, a, b, *, c=None):
+            self.a = a
+            self.b = b
+            self.c = c
 
-    Here the example implementation of a `__pretty__` method for a list
-    subclass for python 2.5 and higher (python 2.5 requires the with statement
-    __future__ import)::
+        def _repr_pretty_(self, p, cycle):
+            ctor = CallExpression.factory(self.__class__.__name__)
+            if self.c is None:
+                p.pretty(ctor(a, b))
+            else:
+                p.pretty(ctor(a, b, c=c))
 
-        class MyList(list):
+Here is an example implementation of a `_repr_pretty_` method for a list
+subclass::
 
-            def __pretty__(self, p, cycle):
-                if cycle:
-                    p.text('MyList(...)')
-                else:
-                    with p.group(8, 'MyList([', '])'):
-                        for idx, item in enumerate(self):
-                            if idx:
-                                p.text(',')
-                                p.breakable()
-                            p.pretty(item)
-
-    The `cycle` parameter is `True` if pretty detected a cycle.  You *have* to
-    react to that or the result is an infinite loop.  `p.text()` just adds
-    non breaking text to the output, `p.breakable()` either adds a whitespace
-    or breaks here.  If you pass it an argument it's used instead of the
-    default space.  `p.pretty` prettyprints another object using the pretty print
-    method.
-
-    The first parameter to the `group` function specifies the extra indentation
-    of the next line.  In this example the next item will either be not
-    breaked (if the items are short enough) or aligned with the right edge of
-    the opening bracked of `MyList`.
-
-    If you want to support python 2.4 and lower you can use this code::
-
-        class MyList(list):
-
-            def __pretty__(self, p, cycle):
-                if cycle:
-                    p.text('MyList(...)')
-                else:
-                    p.begin_group(8, 'MyList([')
+    class MyList(list):
+
+        def _repr_pretty_(self, p, cycle):
+            if cycle:
+                p.text('MyList(...)')
+            else:
+                with p.group(8, 'MyList([', '])'):
                     for idx, item in enumerate(self):
                         if idx:
                             p.text(',')
                             p.breakable()
                         p.pretty(item)
-                    p.end_group(8, '])')
 
-    If you just want to indent something you can use the group function
-    without open / close parameters.  Under python 2.5 you can also use this
-    code::
+The `cycle` parameter is `True` if pretty detected a cycle.  You *have* to
+react to that or the result is an infinite loop.  `p.text()` just adds
+non breaking text to the output, `p.breakable()` either adds a whitespace
+or breaks here.  If you pass it an argument it's used instead of the
+default space.  `p.pretty` prettyprints another object using the pretty print
+method.
 
-        with p.indent(2):
-            ...
+The first parameter to the `group` function specifies the extra indentation
+of the next line.  In this example the next item will either be on the same
+line (if the items are short enough) or aligned with the right edge of the
+opening bracket of `MyList`.
 
-    Or under python2.4 you might want to modify ``p.indentation`` by hand but
-    this is rather ugly.
+If you just want to indent something you can use the group function
+without open / close parameters.  You can also use this code::
 
-    :copyright: 2007 by Armin Ronacher.
-                Portions (c) 2009 by Robert Kern.
-    :license: BSD License.
+    with p.indent(2):
+        ...
+
+Inheritance diagram:
+
+.. inheritance-diagram:: IPython.lib.pretty
+   :parts: 3
+
+:copyright: 2007 by Armin Ronacher.
+            Portions (c) 2009 by Robert Kern.
+:license: BSD License.
 """
-from __future__ import with_statement
+
 from contextlib import contextmanager
+import datetime
+import os
+import re
 import sys
 import types
-import re
-import datetime
-from StringIO import StringIO
 from collections import deque
+from inspect import signature
+from io import StringIO
+from warnings import warn
+
+from IPython.utils.decorators import undoc
+from IPython.utils.py3compat import PYPY
+
+from typing import Dict
+
+# Allow pretty-printing of functions with PEP-649 annotations
+if sys.version_info >= (3, 14):
+    from annotationlib import Format
+    from functools import partial
+
+    signature = partial(signature, annotation_format=Format.FORWARDREF)
 
 
 __all__ = ['pretty', 'pprint', 'PrettyPrinter', 'RepresentationPrinter',
-    'for_type', 'for_type_by_name']
+    'for_type', 'for_type_by_name', 'RawText', 'RawStringLiteral', 'CallExpression']
 
 
+MAX_SEQ_LENGTH = 1000
 _re_pattern_type = type(re.compile(''))
 
+def _safe_getattr(obj, attr, default=None):
+    """Safe version of getattr.
+
+    Same as getattr, but will return ``default`` on any Exception,
+    rather than raising.
+    """
+    try:
+        return getattr(obj, attr, default)
+    except Exception:
+        return default
+
+def _sorted_for_pprint(items):
+    """
+    Sort the given items for pretty printing. Since some predictable
+    sorting is better than no sorting at all, we sort on the string
+    representation if normal sorting fails.
+    """
+    items = list(items)
+    try:
+        return sorted(items)
+    except Exception:
+        try:
+            return sorted(items, key=str)
+        except Exception:
+            return items
 
-def pretty(obj, verbose=False, max_width=79, newline='\n'):
+def pretty(obj, verbose=False, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
     """
     Pretty print the object's representation.
     """
     stream = StringIO()
-    printer = RepresentationPrinter(stream, verbose, max_width, newline)
+    printer = RepresentationPrinter(stream, verbose, max_width, newline, max_seq_length=max_seq_length)
     printer.pretty(obj)
     printer.flush()
     return stream.getvalue()
 
 
-def pprint(obj, verbose=False, max_width=79, newline='\n'):
+def pprint(obj, verbose=False, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
     """
     Like `pretty` but print to stdout.
     """
-    printer = RepresentationPrinter(sys.stdout, verbose, max_width, newline)
+    printer = RepresentationPrinter(sys.stdout, verbose, max_width, newline, max_seq_length=max_seq_length)
     printer.pretty(obj)
     printer.flush()
     sys.stdout.write(newline)
     sys.stdout.flush()
 
-class _PrettyPrinterBase(object):
+
+class _PrettyPrinterBase:
 
     @contextmanager
     def indent(self, indent):
@@ -155,8 +188,7 @@ def group(self, indent=0, open='', close=''):
         """like begin_group / end_group but for the with statement."""
         self.begin_group(indent, open)
         try:
-            with self.indent(indent):
-                yield
+            yield
         finally:
             self.end_group(indent, close)
 
@@ -164,14 +196,15 @@ class PrettyPrinter(_PrettyPrinterBase):
     """
     Baseclass for the `RepresentationPrinter` prettyprinter that is used to
     generate pretty reprs of objects.  Contrary to the `RepresentationPrinter`
-    this printer knows nothing about the default pprinters or the `__pretty__`
+    this printer knows nothing about the default pprinters or the `_repr_pretty_`
     callback method.
     """
 
-    def __init__(self, output, max_width=79, newline='\n'):
+    def __init__(self, output, max_width=79, newline='\n', max_seq_length=MAX_SEQ_LENGTH):
         self.output = output
         self.max_width = max_width
         self.newline = newline
+        self.max_seq_length = max_seq_length
         self.output_width = 0
         self.buffer_width = 0
         self.buffer = deque()
@@ -181,19 +214,22 @@ def __init__(self, output, max_width=79, newline='\n'):
         self.group_queue = GroupQueue(root_group)
         self.indentation = 0
 
+    def _break_one_group(self, group):
+        while group.breakables:
+            x = self.buffer.popleft()
+            self.output_width = x.output(self.output, self.output_width)
+            self.buffer_width -= x.width
+        while self.buffer and isinstance(self.buffer[0], Text):
+            x = self.buffer.popleft()
+            self.output_width = x.output(self.output, self.output_width)
+            self.buffer_width -= x.width
+
     def _break_outer_groups(self):
         while self.max_width < self.output_width + self.buffer_width:
             group = self.group_queue.deq()
             if not group:
                 return
-            while group.breakables:
-                x = self.buffer.popleft()
-                self.output_width = x.output(self.output, self.output_width)
-                self.buffer_width -= x.width
-            while self.buffer and isinstance(self.buffer[0], Text):
-                x = self.buffer.popleft()
-                self.output_width = x.output(self.output, self.output_width)
-                self.buffer_width -= x.width
+            self._break_one_group(group)
 
     def text(self, obj):
         """Add literal text to the output."""
@@ -229,21 +265,23 @@ def breakable(self, sep=' '):
             self.buffer_width += width
             self._break_outer_groups()
 
-
-    def begin_group(self, indent=0, open=''):
+    def break_(self):
         """
-        Begin a group.  If you want support for python < 2.5 which doesn't has
-        the with statement this is the preferred way:
-
-            p.begin_group(1, '{')
-            ...
-            p.end_group(1, '}')
-
-        The python 2.5 expression would be this:
+        Explicitly insert a newline into the output, maintaining correct indentation.
+        """
+        group = self.group_queue.deq()
+        if group:
+            self._break_one_group(group)
+        self.flush()
+        self.output.write(self.newline)
+        self.output.write(' ' * self.indentation)
+        self.output_width = self.indentation
+        self.buffer_width = 0
 
-            with p.group(1, '{', '}'):
-                ...
 
+    def begin_group(self, indent=0, open=''):
+        """
+        Begin a group.
         The first parameter specifies the indentation for the next line (usually
         the width of the opening text), the second the opening text.  All
         parameters are optional.
@@ -255,6 +293,16 @@ def begin_group(self, indent=0, open=''):
         self.group_queue.enq(group)
         self.indentation += indent
 
+    def _enumerate(self, seq):
+        """like enumerate, but with an upper limit on the number of items"""
+        for idx, x in enumerate(seq):
+            if self.max_seq_length and idx >= self.max_seq_length:
+                self.text(',')
+                self.breakable()
+                self.text('...')
+                return
+            yield idx, x
+
     def end_group(self, dedent=0, close=''):
         """End a group. See `begin_group` for more details."""
         self.indentation -= dedent
@@ -307,9 +355,10 @@ class RepresentationPrinter(PrettyPrinter):
     """
 
     def __init__(self, output, verbose=False, max_width=79, newline='\n',
-        singleton_pprinters=None, type_pprinters=None, deferred_pprinters=None):
+        singleton_pprinters=None, type_pprinters=None, deferred_pprinters=None,
+        max_seq_length=MAX_SEQ_LENGTH):
 
-        PrettyPrinter.__init__(self, output, max_width, newline)
+        PrettyPrinter.__init__(self, output, max_width, newline, max_seq_length=max_seq_length)
         self.verbose = verbose
         self.stack = []
         if singleton_pprinters is None:
@@ -329,22 +378,47 @@ def pretty(self, obj):
         self.stack.append(obj_id)
         self.begin_group()
         try:
-            obj_class = getattr(obj, '__class__', None) or type(obj)
-            if hasattr(obj_class, '__pretty__'):
-                return obj_class.__pretty__(obj, self, cycle)
+            obj_class = _safe_getattr(obj, '__class__', None) or type(obj)
+            # First try to find registered singleton printers for the type.
             try:
                 printer = self.singleton_pprinters[obj_id]
             except (TypeError, KeyError):
                 pass
             else:
                 return printer(obj, self, cycle)
+            # Next walk the mro and check for either:
+            #   1) a registered printer
+            #   2) a _repr_pretty_ method
             for cls in _get_mro(obj_class):
                 if cls in self.type_pprinters:
+                    # printer registered in self.type_pprinters
                     return self.type_pprinters[cls](obj, self, cycle)
                 else:
+                    # deferred printer
                     printer = self._in_deferred_types(cls)
                     if printer is not None:
                         return printer(obj, self, cycle)
+                    else:
+                        # Finally look for special method names.
+                        # Some objects automatically create any requested
+                        # attribute. Try to ignore most of them by checking for
+                        # callability.
+                        if '_repr_pretty_' in cls.__dict__:
+                            meth = cls._repr_pretty_
+                            if callable(meth):
+                                return meth(obj, self, cycle)
+                        if (
+                            cls is not object
+                            # check if cls defines __repr__
+                            and "__repr__" in cls.__dict__
+                            # check if __repr__ is callable.
+                            # Note: we need to test getattr(cls, '__repr__')
+                            #   instead of cls.__dict__['__repr__']
+                            #   in order to work with descriptors like partialmethod,
+                            and callable(_safe_getattr(cls, "__repr__", None))
+                        ):
+                            return _repr_pprint(obj, self, cycle)
+
             return _default_pprint(obj, self, cycle)
         finally:
             self.end_group()
@@ -358,8 +432,8 @@ def _in_deferred_types(self, cls):
         class is not in the registry. Successful matches will be moved to the
         regular type registry for future use.
         """
-        mod = getattr(cls, '__module__', None)
-        name = getattr(cls, '__name__', None)
+        mod = _safe_getattr(cls, '__module__', None)
+        name = _safe_getattr(cls, '__name__', None)
         key = (mod, name)
         printer = None
         if key in self.deferred_pprinters:
@@ -369,7 +443,7 @@ class is not in the registry. Successful matches will be moved to the
         return printer
 
 
-class Printable(object):
+class Printable:
 
     def output(self, stream, output_width):
         return output_width
@@ -421,7 +495,7 @@ def __init__(self, depth):
         self.want_break = False
 
 
-class GroupQueue(object):
+class GroupQueue:
 
     def __init__(self, *groups):
         self.queue = []
@@ -452,7 +526,73 @@ def remove(self, group):
             pass
 
 
-_baseclass_reprs = (object.__repr__, types.InstanceType.__repr__)
+class RawText:
+    """ Object such that ``p.pretty(RawText(value))`` is the same as ``p.text(value)``.
+
+    An example usage of this would be to show a list as binary numbers, using
+    ``p.pretty([RawText(bin(i)) for i in integers])``.
+    """
+    def __init__(self, value):
+        self.value = value
+
+    def _repr_pretty_(self, p, cycle):
+        p.text(self.value)
+
+
+class CallExpression:
+    """ Object which emits a line-wrapped call expression in the form `__name(*args, **kwargs)` """
+    def __init__(__self, __name, *args, **kwargs):
+        # dunders are to avoid clashes with kwargs, as python's name managing
+        # will kick in.
+        self = __self
+        self.name = __name
+        self.args = args
+        self.kwargs = kwargs
+
+    @classmethod
+    def factory(cls, name):
+        def inner(*args, **kwargs):
+            return cls(name, *args, **kwargs)
+        return inner
+
+    def _repr_pretty_(self, p, cycle):
+        # dunders are to avoid clashes with kwargs, as python's name managing
+        # will kick in.
+
+        started = False
+        def new_item():
+            nonlocal started
+            if started:
+                p.text(",")
+                p.breakable()
+            started = True
+
+        prefix = self.name + "("
+        with p.group(len(prefix), prefix, ")"):
+            for arg in self.args:
+                new_item()
+                p.pretty(arg)
+            for arg_name, arg in self.kwargs.items():
+                new_item()
+                arg_prefix = arg_name + "="
+                with p.group(len(arg_prefix), arg_prefix):
+                    p.pretty(arg)
+
+
+class RawStringLiteral:
+    """ Wrapper that shows a string with a `r` prefix """
+    def __init__(self, value):
+        self.value = value
+
+    def _repr_pretty_(self, p, cycle):
+        base_repr = repr(self.value)
+        if base_repr[:1] in 'uU':
+            base_repr = base_repr[1:]
+            prefix = 'ur'
+        else:
+            prefix = 'r'
+        base_repr = prefix + base_repr.replace('\\\\', '\\')
+        p.text(base_repr)
 
 
 def _default_pprint(obj, p, cycle):
@@ -460,10 +600,10 @@ def _default_pprint(obj, p, cycle):
     The default print function.  Used if an object does not provide one and
     it's none of the builtin objects.
     """
-    klass = getattr(obj, '__class__', None) or type(obj)
-    if getattr(klass, '__repr__', None) not in _baseclass_reprs:
-        # A user-provided repr.
-        p.text(repr(obj))
+    klass = _safe_getattr(obj, '__class__', None) or type(obj)
+    if _safe_getattr(klass, '__repr__', None) is not object.__repr__:
+        # A user-provided repr. Find newlines and replace them with p.break_()
+        _repr_pprint(obj, p, cycle)
         return
     p.begin_group(1, '<')
     p.pretty(klass)
@@ -496,25 +636,52 @@ def _default_pprint(obj, p, cycle):
 def _seq_pprinter_factory(start, end):
     """
     Factory that returns a pprint function useful for sequences.  Used by
-    the default pprint for tuples, dicts, lists, sets and frozensets.
+    the default pprint for tuples and lists.
     """
     def inner(obj, p, cycle):
         if cycle:
             return p.text(start + '...' + end)
         step = len(start)
         p.begin_group(step, start)
-        for idx, x in enumerate(obj):
+        for idx, x in p._enumerate(obj):
             if idx:
                 p.text(',')
                 p.breakable()
             p.pretty(x)
-        if len(obj) == 1 and type(obj) is tuple:
+        if len(obj) == 1 and isinstance(obj, tuple):
             # Special case for 1-item tuples.
             p.text(',')
         p.end_group(step, end)
     return inner
 
 
+def _set_pprinter_factory(start, end):
+    """
+    Factory that returns a pprint function useful for sets and frozensets.
+    """
+    def inner(obj, p, cycle):
+        if cycle:
+            return p.text(start + '...' + end)
+        if len(obj) == 0:
+            # Special case.
+            p.text(type(obj).__name__ + '()')
+        else:
+            step = len(start)
+            p.begin_group(step, start)
+            # Like dictionary keys, we will try to sort the items if there aren't too many
+            if not (p.max_seq_length and len(obj) >= p.max_seq_length):
+                items = _sorted_for_pprint(obj)
+            else:
+                items = obj
+            for idx, x in p._enumerate(items):
+                if idx:
+                    p.text(',')
+                    p.breakable()
+                p.pretty(x)
+            p.end_group(step, end)
+    return inner
+
+
 def _dict_pprinter_factory(start, end):
     """
     Factory that returns a pprint function used by the default pprint of
@@ -523,102 +690,141 @@ def _dict_pprinter_factory(start, end):
     def inner(obj, p, cycle):
         if cycle:
             return p.text('{...}')
-        p.begin_group(1, start)
+        step = len(start)
+        p.begin_group(step, start)
         keys = obj.keys()
-        try:
-            keys.sort()
-        except Exception, e:
-            # Sometimes the keys don't sort.
-            pass
-        for idx, key in enumerate(keys):
+        for idx, key in p._enumerate(keys):
             if idx:
                 p.text(',')
                 p.breakable()
             p.pretty(key)
             p.text(': ')
             p.pretty(obj[key])
-        p.end_group(1, end)
+        p.end_group(step, end)
     return inner
 
 
 def _super_pprint(obj, p, cycle):
     """The pprint for the super type."""
     p.begin_group(8, '<super: ')
-    p.pretty(obj.__self_class__)
+    p.pretty(obj.__thisclass__)
     p.text(',')
     p.breakable()
-    p.pretty(obj.__self__)
+    if PYPY: # In PyPy, super() objects don't have __self__ attributes
+        dself = obj.__repr__.__self__
+        p.pretty(None if dself is obj else dself)
+    else:
+        p.pretty(obj.__self__)
     p.end_group(8, '>')
 
 
-def _re_pattern_pprint(obj, p, cycle):
-    """The pprint function for regular expression patterns."""
-    p.text('re.compile(')
-    pattern = repr(obj.pattern)
-    if pattern[:1] in 'uU':
-        pattern = pattern[1:]
-        prefix = 'ur'
-    else:
-        prefix = 'r'
-    pattern = prefix + pattern.replace('\\\\', '\\')
-    p.text(pattern)
-    if obj.flags:
-        p.text(',')
-        p.breakable()
+
+class _ReFlags:
+    def __init__(self, value):
+        self.value = value
+
+    def _repr_pretty_(self, p, cycle):
         done_one = False
-        for flag in ('TEMPLATE', 'IGNORECASE', 'LOCALE', 'MULTILINE', 'DOTALL',
-            'UNICODE', 'VERBOSE', 'DEBUG'):
-            if obj.flags & getattr(re, flag):
+        for flag in (
+            "IGNORECASE",
+            "LOCALE",
+            "MULTILINE",
+            "DOTALL",
+            "UNICODE",
+            "VERBOSE",
+            "DEBUG",
+        ):
+            if self.value & getattr(re, flag):
                 if done_one:
                     p.text('|')
                 p.text('re.' + flag)
                 done_one = True
-    p.text(')')
+
+
+def _re_pattern_pprint(obj, p, cycle):
+    """The pprint function for regular expression patterns."""
+    re_compile = CallExpression.factory('re.compile')
+    if obj.flags:
+        p.pretty(re_compile(RawStringLiteral(obj.pattern), _ReFlags(obj.flags)))
+    else:
+        p.pretty(re_compile(RawStringLiteral(obj.pattern)))
+
+
+def _types_simplenamespace_pprint(obj, p, cycle):
+    """The pprint function for types.SimpleNamespace."""
+    namespace = CallExpression.factory('namespace')
+    if cycle:
+        p.pretty(namespace(RawText("...")))
+    else:
+        p.pretty(namespace(**obj.__dict__))
 
 
 def _type_pprint(obj, p, cycle):
     """The pprint for classes and types."""
-    if obj.__module__ in ('__builtin__', 'exceptions'):
+    # Heap allocated types might not have the module attribute,
+    # and others may set it to None.
+
+    # Checks for a __repr__ override in the metaclass. Can't compare the
+    # type(obj).__repr__ directly because in PyPy the representation function
+    # inherited from type isn't the same type.__repr__
+    if [m for m in _get_mro(type(obj)) if "__repr__" in vars(m)][:1] != [type]:
+        _repr_pprint(obj, p, cycle)
+        return
+
+    mod = _safe_getattr(obj, '__module__', None)
+    try:
+        name = obj.__qualname__
+        if not isinstance(name, str):
+            # This can happen if the type implements __qualname__ as a property
+            # or other descriptor in Python 2.
+            raise Exception("Try __name__")
+    except Exception:
         name = obj.__name__
+        if not isinstance(name, str):
+            name = '<unknown type>'
+
+    if mod in (None, '__builtin__', 'builtins', 'exceptions'):
+        p.text(name)
     else:
-        name = obj.__module__ + '.' + obj.__name__
-    p.text(name)
+        p.text(mod + '.' + name)
 
 
 def _repr_pprint(obj, p, cycle):
     """A pprint that just redirects to the normal repr function."""
-    p.text(repr(obj))
+    # Find newlines and replace them with p.break_()
+    output = repr(obj)
+    lines = output.splitlines()
+    with p.group():
+        for idx, output_line in enumerate(lines):
+            if idx:
+                p.break_()
+            p.text(output_line)
 
 
 def _function_pprint(obj, p, cycle):
     """Base pprint for all functions and builtin functions."""
-    if obj.__module__ in ('__builtin__', 'exceptions') or not obj.__module__:
-        name = obj.__name__
-    else:
-        name = obj.__module__ + '.' + obj.__name__
-    p.text('<function %s>' % name)
+    name = _safe_getattr(obj, '__qualname__', obj.__name__)
+    mod = obj.__module__
+    if mod and mod not in ('__builtin__', 'builtins', 'exceptions'):
+        name = mod + '.' + name
+    try:
+       func_def = name + str(signature(obj))
+    except ValueError:
+       func_def = name
+    p.text('<function %s>' % func_def)
 
 
 def _exception_pprint(obj, p, cycle):
     """Base pprint for all exceptions."""
-    if obj.__class__.__module__ == 'exceptions':
-        name = obj.__class__.__name__
-    else:
-        name = '%s.%s' % (
-            obj.__class__.__module__,
-            obj.__class__.__name__
-        )
-    step = len(name) + 1
-    p.begin_group(step, '(')
-    for idx, arg in enumerate(getattr(obj, 'args', ())):
-        if idx:
-            p.text(',')
-            p.breakable()
-        p.pretty(arg)
-    p.end_group(step, ')')
+    name = getattr(obj.__class__, '__qualname__', obj.__class__.__name__)
+    if obj.__class__.__module__ not in ('exceptions', 'builtins'):
+        name = '%s.%s' % (obj.__class__.__module__, name)
+
+    p.pretty(CallExpression(name, *getattr(obj, 'args', ())))
 
 
 #: the exception base
+_exception_base: type
 try:
     _exception_base = BaseException
 except NameError:
@@ -628,33 +834,40 @@ def _exception_pprint(obj, p, cycle):
 #: printers for builtin types
 _type_pprinters = {
     int:                        _repr_pprint,
-    long:                       _repr_pprint,
     float:                      _repr_pprint,
     str:                        _repr_pprint,
-    unicode:                    _repr_pprint,
     tuple:                      _seq_pprinter_factory('(', ')'),
     list:                       _seq_pprinter_factory('[', ']'),
     dict:                       _dict_pprinter_factory('{', '}'),
-    types.DictProxyType:        _dict_pprinter_factory('<dictproxy {', '}>'),
-    set:                        _seq_pprinter_factory('set([', '])'),
-    frozenset:                  _seq_pprinter_factory('frozenset([', '])'),
+    set:                        _set_pprinter_factory('{', '}'),
+    frozenset:                  _set_pprinter_factory('frozenset({', '})'),
     super:                      _super_pprint,
     _re_pattern_type:           _re_pattern_pprint,
     type:                       _type_pprint,
-    types.ClassType:            _type_pprint,
     types.FunctionType:         _function_pprint,
     types.BuiltinFunctionType:  _function_pprint,
-    types.SliceType:            _repr_pprint,
     types.MethodType:           _repr_pprint,
-    xrange:                     _repr_pprint,
+    types.SimpleNamespace:      _types_simplenamespace_pprint,
     datetime.datetime:          _repr_pprint,
     datetime.timedelta:         _repr_pprint,
     _exception_base:            _exception_pprint
 }
 
+# render os.environ like a dict
+_env_type = type(os.environ)
+# future-proof in case os.environ becomes a plain dict?
+if _env_type is not dict:
+    _type_pprinters[_env_type] = _dict_pprinter_factory('environ{', '}')
+
+_type_pprinters[types.MappingProxyType] = _dict_pprinter_factory("mappingproxy({", "})")
+_type_pprinters[slice] = _repr_pprint
+
+_type_pprinters[range] = _repr_pprint
+_type_pprinters[bytes] = _repr_pprint
+
 #: printers for types specified by name
-_deferred_type_pprinters = {
-}
+_deferred_type_pprinters: Dict = {}
+
 
 def for_type(typ, func):
     """
@@ -684,9 +897,59 @@ def for_type_by_name(type_module, type_name, func):
                                       NotImplemented]), _repr_pprint)
 
 
+def _defaultdict_pprint(obj, p, cycle):
+    cls_ctor = CallExpression.factory(obj.__class__.__name__)
+    if cycle:
+        p.pretty(cls_ctor(RawText("...")))
+    else:
+        p.pretty(cls_ctor(obj.default_factory, dict(obj)))
+
+def _ordereddict_pprint(obj, p, cycle):
+    cls_ctor = CallExpression.factory(obj.__class__.__name__)
+    if cycle:
+        p.pretty(cls_ctor(RawText("...")))
+    elif len(obj):
+        p.pretty(cls_ctor(list(obj.items())))
+    else:
+        p.pretty(cls_ctor())
+
+def _deque_pprint(obj, p, cycle):
+    cls_ctor = CallExpression.factory(obj.__class__.__name__)
+    if cycle:
+        p.pretty(cls_ctor(RawText("...")))
+    elif obj.maxlen is not None:
+        p.pretty(cls_ctor(list(obj), maxlen=obj.maxlen))
+    else:
+        p.pretty(cls_ctor(list(obj)))
+
+def _counter_pprint(obj, p, cycle):
+    cls_ctor = CallExpression.factory(obj.__class__.__name__)
+    if cycle:
+        p.pretty(cls_ctor(RawText("...")))
+    elif len(obj):
+        p.pretty(cls_ctor(dict(obj.most_common())))
+    else:
+        p.pretty(cls_ctor())
+
+
+def _userlist_pprint(obj, p, cycle):
+    cls_ctor = CallExpression.factory(obj.__class__.__name__)
+    if cycle:
+        p.pretty(cls_ctor(RawText("...")))
+    else:
+        p.pretty(cls_ctor(obj.data))
+
+
+for_type_by_name('collections', 'defaultdict', _defaultdict_pprint)
+for_type_by_name('collections', 'OrderedDict', _ordereddict_pprint)
+for_type_by_name('collections', 'deque', _deque_pprint)
+for_type_by_name('collections', 'Counter', _counter_pprint)
+for_type_by_name("collections", "UserList", _userlist_pprint)
+
 if __name__ == '__main__':
     from random import randrange
-    class Foo(object):
+
+    class Foo:
         def __init__(self):
             self.foo = 1
             self.bar = re.compile(r'\s+')
@@ -695,6 +958,6 @@ def __init__(self):
             self.list = ["blub", "blah", self]
 
         def get_foo(self):
-            print "foo"
+            print("foo")
 
     pprint(Foo(), verbose=True)
diff --git a/IPython/lib/pylabtools.py b/IPython/lib/pylabtools.py
deleted file mode 100644
index a7afc2605b1..00000000000
--- a/IPython/lib/pylabtools.py
+++ /dev/null
@@ -1,299 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Pylab (matplotlib) support utilities.
-
-Authors
--------
-
-* Fernando Perez.
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from cStringIO import StringIO
-
-from IPython.utils.decorators import flag_calls
-
-# If user specifies a GUI, that dictates the backend, otherwise we read the
-# user's mpl default from the mpl rc structure
-backends = {'tk': 'TkAgg',
-            'gtk': 'GTKAgg',
-            'wx': 'WXAgg',
-            'qt': 'Qt4Agg', # qt3 not supported
-            'qt4': 'Qt4Agg',
-            'osx': 'MacOSX',
-            'inline' : 'module://IPython.zmq.pylab.backend_inline'}
-
-#-----------------------------------------------------------------------------
-# Matplotlib utilities
-#-----------------------------------------------------------------------------
-
-
-def getfigs(*fig_nums):
-    """Get a list of matplotlib figures by figure numbers.
-
-    If no arguments are given, all available figures are returned.  If the
-    argument list contains references to invalid figures, a warning is printed
-    but the function continues pasting further figures.
-
-    Parameters
-    ----------
-    figs : tuple
-        A tuple of ints giving the figure numbers of the figures to return.
-    """
-    from matplotlib._pylab_helpers import Gcf
-    if not fig_nums:
-        fig_managers = Gcf.get_all_fig_managers()
-        return [fm.canvas.figure for fm in fig_managers]
-    else:
-        figs = []
-        for num in fig_nums:
-            f = Gcf.figs.get(num)
-            if f is None:
-                print('Warning: figure %s not available.' % num)
-            figs.append(f.canvas.figure)
-        return figs
-
-
-def figsize(sizex, sizey):
-    """Set the default figure size to be [sizex, sizey].
-
-    This is just an easy to remember, convenience wrapper that sets::
-
-      matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
-    """
-    import matplotlib
-    matplotlib.rcParams['figure.figsize'] = [sizex, sizey]
-
-
-def figure_to_svg(fig):
-    """Convert a figure to svg for inline display."""
-    # When there's an empty figure, we shouldn't return anything, otherwise we
-    # get big blank areas in the qt console.
-    if not fig.axes:
-        return
-
-    fc = fig.get_facecolor()
-    ec = fig.get_edgecolor()
-    fig.set_facecolor('white')
-    fig.set_edgecolor('white')
-    try:
-        string_io = StringIO()
-        fig.canvas.print_figure(string_io, format='svg')
-        svg = string_io.getvalue()
-    finally:
-        fig.set_facecolor(fc)
-        fig.set_edgecolor(ec)
-    return svg
-
-
-# We need a little factory function here to create the closure where
-# safe_execfile can live.
-def mpl_runner(safe_execfile):
-    """Factory to return a matplotlib-enabled runner for %run.
-
-    Parameters
-    ----------
-    safe_execfile : function
-      This must be a function with the same interface as the
-      :meth:`safe_execfile` method of IPython.
-
-    Returns
-    -------
-    A function suitable for use as the ``runner`` argument of the %run magic
-    function.
-    """
-    
-    def mpl_execfile(fname,*where,**kw):
-        """matplotlib-aware wrapper around safe_execfile.
-
-        Its interface is identical to that of the :func:`execfile` builtin.
-
-        This is ultimately a call to execfile(), but wrapped in safeties to
-        properly handle interactive rendering."""
-
-        import matplotlib
-        import matplotlib.pylab as pylab
-
-        #print '*** Matplotlib runner ***' # dbg
-        # turn off rendering until end of script
-        is_interactive = matplotlib.rcParams['interactive']
-        matplotlib.interactive(False)
-        safe_execfile(fname,*where,**kw)
-        matplotlib.interactive(is_interactive)
-        # make rendering call now, if the user tried to do it
-        if pylab.draw_if_interactive.called:
-            pylab.draw()
-            pylab.draw_if_interactive.called = False
-
-    return mpl_execfile
-
-
-#-----------------------------------------------------------------------------
-# Code for initializing matplotlib and importing pylab
-#-----------------------------------------------------------------------------
-
-
-def find_gui_and_backend(gui=None):
-    """Given a gui string return the gui and mpl backend.
-
-    Parameters
-    ----------
-    gui : str
-        Can be one of ('tk','gtk','wx','qt','qt4','inline').
-
-    Returns
-    -------
-    A tuple of (gui, backend) where backend is one of ('TkAgg','GTKAgg',
-    'WXAgg','Qt4Agg','module://IPython.zmq.pylab.backend_inline').
-    """
-
-    import matplotlib
-
-    if gui:
-        # select backend based on requested gui
-        backend = backends[gui]
-    else:
-        backend = matplotlib.rcParams['backend']
-        # In this case, we need to find what the appropriate gui selection call
-        # should be for IPython, so we can activate inputhook accordingly
-        g2b = backends  # maps gui names to mpl backend names
-        b2g = dict(zip(g2b.values(), g2b.keys()))  # reverse dict
-        gui = b2g.get(backend, None)
-    return gui, backend
-
-
-def activate_matplotlib(backend):
-    """Activate the given backend and set interactive to True."""
-
-    import matplotlib
-    if backend.startswith('module://'):
-        # Work around bug in matplotlib: matplotlib.use converts the
-        # backend_id to lowercase even if a module name is specified!
-        matplotlib.rcParams['backend'] = backend
-    else:
-        matplotlib.use(backend)
-    matplotlib.interactive(True)
-
-    # This must be imported last in the matplotlib series, after
-    # backend/interactivity choices have been made
-    import matplotlib.pylab as pylab
-
-    # XXX For now leave this commented out, but depending on discussions with
-    # mpl-dev, we may be able to allow interactive switching...
-    #import matplotlib.pyplot
-    #matplotlib.pyplot.switch_backend(backend)
-
-    pylab.show._needmain = False
-    # We need to detect at runtime whether show() is called by the user.
-    # For this, we wrap it into a decorator which adds a 'called' flag.
-    pylab.draw_if_interactive = flag_calls(pylab.draw_if_interactive)
-
-
-def import_pylab(user_ns, backend, import_all=True, shell=None):
-    """Import the standard pylab symbols into user_ns."""
-
-    # Import numpy as np/pyplot as plt are conventions we're trying to
-    # somewhat standardize on.  Making them available to users by default
-    # will greatly help this.
-    s = ("import numpy\n"
-          "import matplotlib\n"
-          "from matplotlib import pylab, mlab, pyplot\n"
-          "np = numpy\n"
-          "plt = pyplot\n"
-          )
-    exec s in user_ns
-
-    if shell is not None:
-        exec s in shell.user_ns_hidden
-        # If using our svg payload backend, register the post-execution
-        # function that will pick up the results for display.  This can only be
-        # done with access to the real shell object.
-        if backend == backends['inline']:
-            from IPython.zmq.pylab.backend_inline import flush_svg
-            from matplotlib import pyplot
-            shell.register_post_execute(flush_svg)
-            # The typical default figure size is too large for inline use,
-            # so we shrink the figure size to 6x4, and tweak fonts to
-            # make that fit.  This is configurable via Global.pylab_inline_rc,
-            # or rather it will be once the zmq kernel is hooked up to
-            # the config system.
-            
-            default_rc = {
-                'figure.figsize': (6.0,4.0),
-                # 12pt labels get cutoff on 6x4 logplots, so use 10pt.
-                'font.size': 10,
-                # 10pt still needs a little more room on the xlabel:
-                'figure.subplot.bottom' : .125
-            }
-            rc = getattr(shell.config.Global, 'pylab_inline_rc', default_rc)
-            pyplot.rcParams.update(rc)
-            shell.config.Global.pylab_inline_rc = rc
-            
-            # Add 'figsize' to pyplot and to the user's namespace
-            user_ns['figsize'] = pyplot.figsize = figsize
-            shell.user_ns_hidden['figsize'] = figsize
-        
-        # The old pastefig function has been replaced by display
-        # Always add this svg formatter so display works.
-        from IPython.core.display import display, display_svg
-        svg_formatter = shell.display_formatter.formatters['image/svg+xml']
-        svg_formatter.for_type_by_name(
-            'matplotlib.figure','Figure',figure_to_svg
-        )
-        # Add display and display_png to the user's namespace
-        user_ns['display'] = display
-        shell.user_ns_hidden['display'] = display
-        user_ns['display_svg'] = display_svg
-        shell.user_ns_hidden['display_svg'] = display_svg
-        user_ns['getfigs'] = getfigs
-        shell.user_ns_hidden['getfigs'] = getfigs
-
-    if import_all:
-        s = ("from matplotlib.pylab import *\n"
-             "from numpy import *\n")
-        exec s in user_ns
-        if shell is not None:
-            exec s in shell.user_ns_hidden
-
-
-def pylab_activate(user_ns, gui=None, import_all=True):
-    """Activate pylab mode in the user's namespace.
-
-    Loads and initializes numpy, matplotlib and friends for interactive use.
-
-    Parameters
-    ----------
-    user_ns : dict
-      Namespace where the imports will occur.
-
-    gui : optional, string
-      A valid gui name following the conventions of the %gui magic.
-
-    import_all : optional, boolean
-      If true, an 'import *' is done from numpy and pylab.
-
-    Returns
-    -------
-    The actual gui used (if not given as input, it was obtained from matplotlib
-    itself, and will be needed next to configure IPython's gui integration.
-    """
-    gui, backend = find_gui_and_backend(gui)
-    activate_matplotlib(backend)
-    import_pylab(user_ns, backend)
-
-    print """
-Welcome to pylab, a matplotlib-based Python environment [backend: %s].
-For more information, type 'help(pylab)'.""" % backend
-    
-    return gui
-
diff --git a/IPython/lib/tests/__init__.py b/IPython/lib/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/lib/tests/test_imports.py b/IPython/lib/tests/test_imports.py
deleted file mode 100644
index e0e9e9ed85c..00000000000
--- a/IPython/lib/tests/test_imports.py
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-def test_import_backgroundjobs():
-    from IPython.lib import backgroundjobs
-
-def test_import_deepreload():
-    from IPython.lib import deepreload
-
-def test_import_demo():
-    from IPython.lib import demo
-
-def test_import_irunner():
-    from IPython.lib import demo
diff --git a/IPython/lib/tests/test_irunner.py b/IPython/lib/tests/test_irunner.py
deleted file mode 100755
index 2be81f82056..00000000000
--- a/IPython/lib/tests/test_irunner.py
+++ /dev/null
@@ -1,170 +0,0 @@
-"""Test suite for the irunner module.
-
-Not the most elegant or fine-grained, but it does cover at least the bulk
-functionality."""
-
-# Global to make tests extra verbose and help debugging
-VERBOSE = True
-
-# stdlib imports
-import cStringIO as StringIO
-import sys
-import unittest
-
-# IPython imports
-from IPython.lib import irunner
-
-# Testing code begins
-class RunnerTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.out = StringIO.StringIO()
-        #self.out = sys.stdout
-
-    def _test_runner(self,runner,source,output):
-        """Test that a given runner's input/output match."""
-        
-        runner.run_source(source)
-        out = self.out.getvalue()
-        #out = ''
-        # this output contains nasty \r\n lineends, and the initial ipython
-        # banner.  clean it up for comparison, removing lines of whitespace
-        output_l = [l for l in output.splitlines() if l and not l.isspace()]
-        out_l = [l for l in out.splitlines() if l and not l.isspace()]
-        mismatch  = 0
-        if len(output_l) != len(out_l):
-            message = ("Mismatch in number of lines\n\n"
-                       "Expected:\n"
-                       "~~~~~~~~~\n"
-                       "%s\n\n"
-                       "Got:\n"
-                       "~~~~~~~~~\n"
-                       "%s"
-                       ) % ("\n".join(output_l), "\n".join(out_l))
-            self.fail(message)
-        for n in range(len(output_l)):
-            # Do a line-by-line comparison
-            ol1 = output_l[n].strip()
-            ol2 = out_l[n].strip()
-            if ol1 != ol2:
-                mismatch += 1
-                if VERBOSE:
-                    print '<<< line %s does not match:' % n
-                    print repr(ol1)
-                    print repr(ol2)
-                    print '>>>'
-        self.assert_(mismatch==0,'Number of mismatched lines: %s' %
-                     mismatch)
-
-    def testIPython(self):
-        """Test the IPython runner."""
-        source = """
-print 'hello, this is python'
-# some more code
-x=1;y=2
-x+y**2
-
-# An example of autocall functionality
-from math import *
-autocall 1
-cos pi
-autocall 0
-cos pi
-cos(pi)
-
-for i in range(5):
-    print i,
-
-print "that's all folks!"
-
-exit
-"""
-        output = """\
-In [1]: print 'hello, this is python'
-hello, this is python
-
-
-# some more code
-In [2]: x=1;y=2
-
-In [3]: x+y**2
-Out[3]: 5
-
-
-# An example of autocall functionality
-In [4]: from math import *
-
-In [5]: autocall 1
-Automatic calling is: Smart
-
-In [6]: cos pi
-------> cos(pi)
-Out[6]: -1.0
-
-In [7]: autocall 0
-Automatic calling is: OFF
-
-In [8]: cos pi
-   File "<ipython-input-8-586f1104ea44>", line 1
-     cos pi
-          ^
-SyntaxError: unexpected EOF while parsing
-
-
-In [9]: cos(pi)
-Out[9]: -1.0
-
-
-In [10]: for i in range(5):
-   ....:     print i,
-   ....:
-0 1 2 3 4
-
-In [11]: print "that's all folks!"
-that's all folks!
-
-
-In [12]: exit
-"""
-        runner = irunner.IPythonRunner(out=self.out)
-        self._test_runner(runner,source,output)
-
-    def testPython(self):
-        """Test the Python runner."""
-        runner = irunner.PythonRunner(out=self.out)
-        source = """
-print 'hello, this is python'
-
-# some more code
-x=1;y=2
-x+y**2
-
-from math import *
-cos(pi)
-
-for i in range(5):
-    print i,
-
-print "that's all folks!"
-        """
-        output = """\
->>> print 'hello, this is python'
-hello, this is python
-
-# some more code
->>> x=1;y=2
->>> x+y**2
-5
-
->>> from math import *
->>> cos(pi)
--1.0
-
->>> for i in range(5):
-...     print i,
-...
-0 1 2 3 4
->>> print "that's all folks!"
-that's all folks!
-"""
-        self._test_runner(runner,source,output)
diff --git a/IPython/lib/tests/test_pylabtools.py b/IPython/lib/tests/test_pylabtools.py
deleted file mode 100644
index af07523ba3f..00000000000
--- a/IPython/lib/tests/test_pylabtools.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""Tests for pylab tools module.
-"""
-#-----------------------------------------------------------------------------
-# Copyright (c) 2011, the IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Stdlib imports
-
-# Third-party imports
-import matplotlib; matplotlib.use('Agg')
-import nose.tools as nt
-
-from matplotlib import pyplot as plt
-
-# Our own imports
-from IPython.testing import decorators as dec
-from .. import pylabtools as pt
-
-#-----------------------------------------------------------------------------
-# Globals and constants
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Local utilities
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-@dec.parametric
-def test_figure_to_svg():
-    # simple empty-figure test
-    fig = plt.figure()
-    yield nt.assert_equal(pt.figure_to_svg(fig), None)
-
-    plt.close('all')
-
-    # simple check for at least svg-looking output
-    fig = plt.figure()
-    ax = fig.add_subplot(1,1,1)
-    ax.plot([1,2,3])
-    plt.draw()
-    svg = pt.figure_to_svg(fig)[:100].lower()
-    yield nt.assert_true('doctype svg' in svg)
diff --git a/IPython/parallel/__init__.py b/IPython/parallel/__init__.py
deleted file mode 100644
index 3e8bde32ec2..00000000000
--- a/IPython/parallel/__init__.py
+++ /dev/null
@@ -1,32 +0,0 @@
-"""The IPython ZMQ-based parallel computing interface."""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2011 The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import zmq
-
-
-if os.name == 'nt':
-    if zmq.__version__ < '2.1dev':
-        raise ImportError("On Windows, IPython.parallel depends on bugfixes only "
-        "in current git master of pyzmq, you appear to have %s"%zmq.__version__)
-elif zmq.__version__ < '2.1.4':
-    raise ImportError("IPython.parallel requires pyzmq/0MQ >= 2.1.4, you appear to have %s"%zmq.__version__)
-
-from IPython.utils.pickleutil import Reference
-
-from .client.asyncresult import *
-from .client.client import Client
-from .client.remotefunction import *
-from .client.view import *
-from .controller.dependency import *
-
-
diff --git a/IPython/parallel/apps/__init__.py b/IPython/parallel/apps/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/parallel/apps/clusterdir.py b/IPython/parallel/apps/clusterdir.py
deleted file mode 100755
index b3f958ccfb3..00000000000
--- a/IPython/parallel/apps/clusterdir.py
+++ /dev/null
@@ -1,537 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-The IPython cluster directory
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from __future__ import with_statement
-
-import os
-import logging
-import re
-import shutil
-import sys
-
-from IPython.config.loader import PyFileConfigLoader
-from IPython.config.configurable import Configurable
-from IPython.core.application import Application, BaseAppConfigLoader
-from IPython.core.crashhandler import CrashHandler
-from IPython.core import release
-from IPython.utils.path import (
-    get_ipython_package_dir,
-    expand_path
-)
-from IPython.utils.traitlets import Unicode
-
-#-----------------------------------------------------------------------------
-# Module errors
-#-----------------------------------------------------------------------------
-
-class ClusterDirError(Exception):
-    pass
-
-
-class PIDFileError(Exception):
-    pass
-
-
-#-----------------------------------------------------------------------------
-# Class for managing cluster directories
-#-----------------------------------------------------------------------------
-
-class ClusterDir(Configurable):
-    """An object to manage the cluster directory and its resources.
-
-    The cluster directory is used by :command:`ipengine`, 
-    :command:`ipcontroller` and :command:`ipclsuter` to manage the
-    configuration, logging and security of these applications.
-
-    This object knows how to find, create and manage these directories. This
-    should be used by any code that want's to handle cluster directories.
-    """
-
-    security_dir_name = Unicode('security')
-    log_dir_name = Unicode('log')
-    pid_dir_name = Unicode('pid')
-    security_dir = Unicode(u'')
-    log_dir = Unicode(u'')
-    pid_dir = Unicode(u'')
-    location = Unicode(u'')
-
-    def __init__(self, location=u''):
-        super(ClusterDir, self).__init__(location=location)
-
-    def _location_changed(self, name, old, new):
-        if not os.path.isdir(new):
-            os.makedirs(new)
-        self.security_dir = os.path.join(new, self.security_dir_name)
-        self.log_dir = os.path.join(new, self.log_dir_name)
-        self.pid_dir = os.path.join(new, self.pid_dir_name)
-        self.check_dirs()
-
-    def _log_dir_changed(self, name, old, new):
-        self.check_log_dir()
-
-    def check_log_dir(self):
-        if not os.path.isdir(self.log_dir):
-            os.mkdir(self.log_dir)
-
-    def _security_dir_changed(self, name, old, new):
-        self.check_security_dir()
-
-    def check_security_dir(self):
-        if not os.path.isdir(self.security_dir):
-            os.mkdir(self.security_dir, 0700)
-        os.chmod(self.security_dir, 0700)
-
-    def _pid_dir_changed(self, name, old, new):
-        self.check_pid_dir()
-
-    def check_pid_dir(self):
-        if not os.path.isdir(self.pid_dir):
-            os.mkdir(self.pid_dir, 0700)
-        os.chmod(self.pid_dir, 0700)
-
-    def check_dirs(self):
-        self.check_security_dir()
-        self.check_log_dir()
-        self.check_pid_dir()
-
-    def load_config_file(self, filename):
-        """Load a config file from the top level of the cluster dir.
-
-        Parameters
-        ----------
-        filename : unicode or str
-            The filename only of the config file that must be located in
-            the top-level of the cluster directory.
-        """
-        loader = PyFileConfigLoader(filename, self.location)
-        return loader.load_config()
-
-    def copy_config_file(self, config_file, path=None, overwrite=False):
-        """Copy a default config file into the active cluster directory.
-
-        Default configuration files are kept in :mod:`IPython.config.default`.
-        This function moves these from that location to the working cluster
-        directory.
-        """
-        if path is None:
-            import IPython.config.default
-            path = IPython.config.default.__file__.split(os.path.sep)[:-1]
-            path = os.path.sep.join(path)
-        src = os.path.join(path, config_file)
-        dst = os.path.join(self.location, config_file)
-        if not os.path.isfile(dst) or overwrite:
-            shutil.copy(src, dst)
-
-    def copy_all_config_files(self, path=None, overwrite=False):
-        """Copy all config files into the active cluster directory."""
-        for f in [u'ipcontroller_config.py', u'ipengine_config.py',
-                  u'ipcluster_config.py']:
-            self.copy_config_file(f, path=path, overwrite=overwrite)
-
-    @classmethod
-    def create_cluster_dir(csl, cluster_dir):
-        """Create a new cluster directory given a full path.
-
-        Parameters
-        ----------
-        cluster_dir : str
-            The full path to the cluster directory.  If it does exist, it will
-            be used.  If not, it will be created.
-        """
-        return ClusterDir(location=cluster_dir)
-
-    @classmethod
-    def create_cluster_dir_by_profile(cls, path, profile=u'default'):
-        """Create a cluster dir by profile name and path.
-
-        Parameters
-        ----------
-        path : str
-            The path (directory) to put the cluster directory in.
-        profile : str
-            The name of the profile.  The name of the cluster directory will
-            be "cluster_<profile>".
-        """
-        if not os.path.isdir(path):
-            raise ClusterDirError('Directory not found: %s' % path)
-        cluster_dir = os.path.join(path, u'cluster_' + profile)
-        return ClusterDir(location=cluster_dir)
-
-    @classmethod
-    def find_cluster_dir_by_profile(cls, ipython_dir, profile=u'default'):
-        """Find an existing cluster dir by profile name, return its ClusterDir.
-
-        This searches through a sequence of paths for a cluster dir.  If it
-        is not found, a :class:`ClusterDirError` exception will be raised.
-
-        The search path algorithm is:
-        1. ``os.getcwd()``
-        2. ``ipython_dir``
-        3. The directories found in the ":" separated 
-           :env:`IPCLUSTER_DIR_PATH` environment variable.
-
-        Parameters
-        ----------
-        ipython_dir : unicode or str
-            The IPython directory to use.
-        profile : unicode or str
-            The name of the profile.  The name of the cluster directory
-            will be "cluster_<profile>".
-        """
-        dirname = u'cluster_' + profile
-        cluster_dir_paths = os.environ.get('IPCLUSTER_DIR_PATH','')
-        if cluster_dir_paths:
-            cluster_dir_paths = cluster_dir_paths.split(':')
-        else:
-            cluster_dir_paths = []
-        paths = [os.getcwd(), ipython_dir] + cluster_dir_paths
-        for p in paths:
-            cluster_dir = os.path.join(p, dirname)
-            if os.path.isdir(cluster_dir):
-                return ClusterDir(location=cluster_dir)
-        else:
-            raise ClusterDirError('Cluster directory not found in paths: %s' % dirname)
-
-    @classmethod
-    def find_cluster_dir(cls, cluster_dir):
-        """Find/create a cluster dir and return its ClusterDir.
-
-        This will create the cluster directory if it doesn't exist.
-
-        Parameters
-        ----------
-        cluster_dir : unicode or str
-            The path of the cluster directory.  This is expanded using
-            :func:`IPython.utils.genutils.expand_path`.
-        """
-        cluster_dir = expand_path(cluster_dir)
-        if not os.path.isdir(cluster_dir):
-            raise ClusterDirError('Cluster directory not found: %s' % cluster_dir)
-        return ClusterDir(location=cluster_dir)
-
-
-#-----------------------------------------------------------------------------
-# Command line options
-#-----------------------------------------------------------------------------
-
-class ClusterDirConfigLoader(BaseAppConfigLoader):
-
-    def _add_cluster_profile(self, parser):
-        paa = parser.add_argument
-        paa('-p', '--profile',
-            dest='Global.profile',type=unicode,
-            help=
-            """The string name of the profile to be used. This determines the name
-            of the cluster dir as: cluster_<profile>. The default profile is named
-            'default'.  The cluster directory is resolve this way if the
-            --cluster-dir option is not used.""",
-            metavar='Global.profile')
-
-    def _add_cluster_dir(self, parser):
-        paa = parser.add_argument
-        paa('--cluster-dir',
-            dest='Global.cluster_dir',type=unicode,
-            help="""Set the cluster dir. This overrides the logic used by the
-            --profile option.""",
-            metavar='Global.cluster_dir')
-
-    def _add_work_dir(self, parser):
-        paa = parser.add_argument
-        paa('--work-dir',
-            dest='Global.work_dir',type=unicode,
-            help='Set the working dir for the process.',
-            metavar='Global.work_dir')
-
-    def _add_clean_logs(self, parser):
-        paa = parser.add_argument
-        paa('--clean-logs',
-            dest='Global.clean_logs', action='store_true',
-            help='Delete old log flies before starting.')
-
-    def _add_no_clean_logs(self, parser):
-        paa = parser.add_argument
-        paa('--no-clean-logs',
-            dest='Global.clean_logs', action='store_false',
-            help="Don't Delete old log flies before starting.")
-
-    def _add_arguments(self):
-        super(ClusterDirConfigLoader, self)._add_arguments()
-        self._add_cluster_profile(self.parser)
-        self._add_cluster_dir(self.parser)
-        self._add_work_dir(self.parser)
-        self._add_clean_logs(self.parser)
-        self._add_no_clean_logs(self.parser)
-
-
-#-----------------------------------------------------------------------------
-# Crash handler for this application
-#-----------------------------------------------------------------------------
-
-
-_message_template = """\
-Oops, $self.app_name crashed. We do our best to make it stable, but...
-
-A crash report was automatically generated with the following information:
-  - A verbatim copy of the crash traceback.
-  - Data on your current $self.app_name configuration.
-
-It was left in the file named:
-\t'$self.crash_report_fname'
-If you can email this file to the developers, the information in it will help
-them in understanding and correcting the problem.
-
-You can mail it to: $self.contact_name at $self.contact_email
-with the subject '$self.app_name Crash Report'.
-
-If you want to do it now, the following command will work (under Unix):
-mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
-
-To ensure accurate tracking of this issue, please file a report about it at:
-$self.bug_tracker
-"""
-
-class ClusterDirCrashHandler(CrashHandler):
-    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
-
-    message_template = _message_template
-
-    def __init__(self, app):
-        contact_name = release.authors['Brian'][0]
-        contact_email = release.authors['Brian'][1]
-        bug_tracker = 'http://github.com/ipython/ipython/issues'
-        super(ClusterDirCrashHandler,self).__init__(
-            app, contact_name, contact_email, bug_tracker
-        )
-
-
-#-----------------------------------------------------------------------------
-# Main application
-#-----------------------------------------------------------------------------
-
-class ApplicationWithClusterDir(Application):
-    """An application that puts everything into a cluster directory.
-
-    Instead of looking for things in the ipython_dir, this type of application
-    will use its own private directory called the "cluster directory"
-    for things like config files, log files, etc.
-
-    The cluster directory is resolved as follows:
-
-    * If the ``--cluster-dir`` option is given, it is used.
-    * If ``--cluster-dir`` is not given, the application directory is 
-      resolve using the profile name as ``cluster_<profile>``. The search 
-      path for this directory is then i) cwd if it is found there
-      and ii) in ipython_dir otherwise.
-
-    The config file for the application is to be put in the cluster
-    dir and named the value of the ``config_file_name`` class attribute.
-    """
-
-    command_line_loader = ClusterDirConfigLoader
-    crash_handler_class = ClusterDirCrashHandler
-    auto_create_cluster_dir = True
-    # temporarily override default_log_level to INFO
-    default_log_level = logging.INFO
-
-    def create_default_config(self):
-        super(ApplicationWithClusterDir, self).create_default_config()
-        self.default_config.Global.profile = u'default'
-        self.default_config.Global.cluster_dir = u''
-        self.default_config.Global.work_dir = os.getcwd()
-        self.default_config.Global.log_to_file = False
-        self.default_config.Global.log_url = None
-        self.default_config.Global.clean_logs = False
-
-    def find_resources(self):
-        """This resolves the cluster directory.
-
-        This tries to find the cluster directory and if successful, it will
-        have done:
-        * Sets ``self.cluster_dir_obj`` to the :class:`ClusterDir` object for 
-          the application.
-        * Sets ``self.cluster_dir`` attribute of the application and config
-          objects.
-
-        The algorithm used for this is as follows:
-        1. Try ``Global.cluster_dir``.
-        2. Try using ``Global.profile``.
-        3. If both of these fail and ``self.auto_create_cluster_dir`` is
-           ``True``, then create the new cluster dir in the IPython directory.
-        4. If all fails, then raise :class:`ClusterDirError`.
-        """
-
-        try:
-            cluster_dir = self.command_line_config.Global.cluster_dir
-        except AttributeError:
-            cluster_dir = self.default_config.Global.cluster_dir
-        cluster_dir = expand_path(cluster_dir)
-        try:
-            self.cluster_dir_obj = ClusterDir.find_cluster_dir(cluster_dir)
-        except ClusterDirError:
-            pass
-        else:
-            self.log.info('Using existing cluster dir: %s' % \
-                self.cluster_dir_obj.location
-            )
-            self.finish_cluster_dir()
-            return
-
-        try:
-            self.profile = self.command_line_config.Global.profile
-        except AttributeError:
-            self.profile = self.default_config.Global.profile
-        try:
-            self.cluster_dir_obj = ClusterDir.find_cluster_dir_by_profile(
-                self.ipython_dir, self.profile)
-        except ClusterDirError:
-            pass
-        else:
-            self.log.info('Using existing cluster dir: %s' % \
-                self.cluster_dir_obj.location
-            )
-            self.finish_cluster_dir()
-            return
-
-        if self.auto_create_cluster_dir:
-            self.cluster_dir_obj = ClusterDir.create_cluster_dir_by_profile(
-                self.ipython_dir, self.profile
-            )
-            self.log.info('Creating new cluster dir: %s' % \
-                self.cluster_dir_obj.location
-            )
-            self.finish_cluster_dir()
-        else:
-            raise ClusterDirError('Could not find a valid cluster directory.')
-
-    def finish_cluster_dir(self):
-        # Set the cluster directory
-        self.cluster_dir = self.cluster_dir_obj.location
-        
-        # These have to be set because they could be different from the one
-        # that we just computed.  Because command line has the highest
-        # priority, this will always end up in the master_config.
-        self.default_config.Global.cluster_dir = self.cluster_dir
-        self.command_line_config.Global.cluster_dir = self.cluster_dir
-
-    def find_config_file_name(self):
-        """Find the config file name for this application."""
-        # For this type of Application it should be set as a class attribute.
-        if not hasattr(self, 'default_config_file_name'):
-            self.log.critical("No config filename found")
-        else:
-            self.config_file_name = self.default_config_file_name
-
-    def find_config_file_paths(self):
-        # Set the search path to to the cluster directory. We should NOT
-        # include IPython.config.default here as the default config files
-        # are ALWAYS automatically moved to the cluster directory.
-        conf_dir = os.path.join(get_ipython_package_dir(), 'config', 'default')
-        self.config_file_paths = (self.cluster_dir,)
-
-    def pre_construct(self):
-        # The log and security dirs were set earlier, but here we put them
-        # into the config and log them.
-        config = self.master_config
-        sdir = self.cluster_dir_obj.security_dir
-        self.security_dir = config.Global.security_dir = sdir
-        ldir = self.cluster_dir_obj.log_dir
-        self.log_dir = config.Global.log_dir = ldir
-        pdir = self.cluster_dir_obj.pid_dir
-        self.pid_dir = config.Global.pid_dir = pdir
-        self.log.info("Cluster directory set to: %s" % self.cluster_dir)
-        config.Global.work_dir = unicode(expand_path(config.Global.work_dir))
-        # Change to the working directory. We do this just before construct
-        # is called so all the components there have the right working dir.
-        self.to_work_dir()
-
-    def to_work_dir(self):
-        wd = self.master_config.Global.work_dir
-        if unicode(wd) != unicode(os.getcwd()):
-            os.chdir(wd)
-            self.log.info("Changing to working dir: %s" % wd)
-
-    def start_logging(self):
-        # Remove old log files
-        if self.master_config.Global.clean_logs:
-            log_dir = self.master_config.Global.log_dir
-            for f in os.listdir(log_dir):
-                if re.match(r'%s-\d+\.(log|err|out)'%self.name,f):
-                # if f.startswith(self.name + u'-') and f.endswith('.log'):
-                    os.remove(os.path.join(log_dir, f))
-        # Start logging to the new log file
-        if self.master_config.Global.log_to_file:
-            log_filename = self.name + u'-' + str(os.getpid()) + u'.log'
-            logfile = os.path.join(self.log_dir, log_filename)
-            open_log_file = open(logfile, 'w')
-        elif self.master_config.Global.log_url:
-            open_log_file = None
-        else:
-            open_log_file = sys.stdout
-        if open_log_file is not None:
-            self.log.removeHandler(self._log_handler)
-            self._log_handler = logging.StreamHandler(open_log_file)
-            self._log_formatter = logging.Formatter("[%(name)s] %(message)s")
-            self._log_handler.setFormatter(self._log_formatter)
-            self.log.addHandler(self._log_handler)
-        # log.startLogging(open_log_file)
-
-    def write_pid_file(self, overwrite=False):
-        """Create a .pid file in the pid_dir with my pid.
-
-        This must be called after pre_construct, which sets `self.pid_dir`.
-        This raises :exc:`PIDFileError` if the pid file exists already.
-        """
-        pid_file = os.path.join(self.pid_dir, self.name + u'.pid')
-        if os.path.isfile(pid_file):
-            pid = self.get_pid_from_file()
-            if not overwrite:
-                raise PIDFileError(
-                    'The pid file [%s] already exists. \nThis could mean that this '
-                    'server is already running with [pid=%s].' % (pid_file, pid)
-                )
-        with open(pid_file, 'w') as f:
-            self.log.info("Creating pid file: %s" % pid_file)
-            f.write(repr(os.getpid())+'\n')
-
-    def remove_pid_file(self):
-        """Remove the pid file.
-
-        This should be called at shutdown by registering a callback with
-        :func:`reactor.addSystemEventTrigger`. This needs to return
-        ``None``.
-        """
-        pid_file = os.path.join(self.pid_dir, self.name + u'.pid')
-        if os.path.isfile(pid_file):
-            try:
-                self.log.info("Removing pid file: %s" % pid_file)
-                os.remove(pid_file)
-            except:
-                self.log.warn("Error removing the pid file: %s" % pid_file)
-
-    def get_pid_from_file(self):
-        """Get the pid from the pid file.
-
-        If the  pid file doesn't exist a :exc:`PIDFileError` is raised.
-        """
-        pid_file = os.path.join(self.pid_dir, self.name + u'.pid')
-        if os.path.isfile(pid_file):
-            with open(pid_file, 'r') as f:
-                pid = int(f.read().strip())
-                return pid
-        else:
-            raise PIDFileError('pid file not found: %s' % pid_file)
-
diff --git a/IPython/parallel/apps/ipclusterapp.py b/IPython/parallel/apps/ipclusterapp.py
deleted file mode 100755
index 35ac171301c..00000000000
--- a/IPython/parallel/apps/ipclusterapp.py
+++ /dev/null
@@ -1,593 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-The ipcluster application.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import errno
-import logging
-import os
-import re
-import signal
-
-import zmq
-from zmq.eventloop import ioloop
-
-from IPython.external.argparse import ArgumentParser, SUPPRESS
-from IPython.utils.importstring import import_item
-
-from IPython.parallel.apps.clusterdir import (
-    ApplicationWithClusterDir, ClusterDirConfigLoader,
-    ClusterDirError, PIDFileError
-)
-
-
-#-----------------------------------------------------------------------------
-# Module level variables
-#-----------------------------------------------------------------------------
-
-
-default_config_file_name = u'ipcluster_config.py'
-
-
-_description = """\
-Start an IPython cluster for parallel computing.\n\n
-
-An IPython cluster consists of 1 controller and 1 or more engines.
-This command automates the startup of these processes using a wide
-range of startup methods (SSH, local processes, PBS, mpiexec,
-Windows HPC Server 2008). To start a cluster with 4 engines on your
-local host simply do 'ipcluster start -n 4'. For more complex usage 
-you will typically do 'ipcluster create -p mycluster', then edit
-configuration files, followed by 'ipcluster start -p mycluster -n 4'.
-"""
-
-
-# Exit codes for ipcluster
-
-# This will be the exit code if the ipcluster appears to be running because
-# a .pid file exists
-ALREADY_STARTED = 10
-
-
-# This will be the exit code if ipcluster stop is run, but there is not .pid
-# file to be found.
-ALREADY_STOPPED = 11
-
-# This will be the exit code if ipcluster engines is run, but there is not .pid
-# file to be found.
-NO_CLUSTER = 12
-
-
-#-----------------------------------------------------------------------------
-# Command line options
-#-----------------------------------------------------------------------------
-
-
-class IPClusterAppConfigLoader(ClusterDirConfigLoader):
-
-    def _add_arguments(self):
-        # Don't call ClusterDirConfigLoader._add_arguments as we don't want
-        # its defaults on self.parser. Instead, we will put those on
-        # default options on our subparsers.
-        
-        # This has all the common options that all subcommands use
-        parent_parser1 = ArgumentParser(
-            add_help=False,
-            argument_default=SUPPRESS
-        )
-        self._add_ipython_dir(parent_parser1)
-        self._add_log_level(parent_parser1)
-
-        # This has all the common options that other subcommands use
-        parent_parser2 = ArgumentParser(
-            add_help=False,
-            argument_default=SUPPRESS
-        )
-        self._add_cluster_profile(parent_parser2)
-        self._add_cluster_dir(parent_parser2)
-        self._add_work_dir(parent_parser2)
-        paa = parent_parser2.add_argument
-        paa('--log-to-file',
-            action='store_true', dest='Global.log_to_file', 
-            help='Log to a file in the log directory (default is stdout)')
-
-        # Create the object used to create the subparsers.
-        subparsers = self.parser.add_subparsers(
-            dest='Global.subcommand',
-            title='ipcluster subcommands',
-            description=
-            """ipcluster has a variety of subcommands. The general way of 
-            running ipcluster is 'ipcluster <cmd> [options]'. To get help
-            on a particular subcommand do 'ipcluster <cmd> -h'."""
-            # help="For more help, type 'ipcluster <cmd> -h'",
-        )
-
-        # The "list" subcommand parser
-        parser_list = subparsers.add_parser(
-            'list',
-            parents=[parent_parser1],
-            argument_default=SUPPRESS,
-            help="List all clusters in cwd and ipython_dir.",
-            description=
-            """List all available clusters, by cluster directory, that can
-            be found in the current working directly or in the ipython
-            directory. Cluster directories are named using the convention
-            'cluster_<profile>'."""
-        )
-
-        # The "create" subcommand parser
-        parser_create = subparsers.add_parser(
-            'create',
-            parents=[parent_parser1, parent_parser2],
-            argument_default=SUPPRESS,
-            help="Create a new cluster directory.",
-            description=
-            """Create an ipython cluster directory by its profile name or 
-            cluster directory path. Cluster directories contain 
-            configuration, log and security related files and are named 
-            using the convention 'cluster_<profile>'. By default they are
-            located in your ipython directory. Once created, you will
-            probably need to edit the configuration files in the cluster
-            directory to configure your cluster. Most users will create a
-            cluster directory by profile name, 
-            'ipcluster create -p mycluster', which will put the directory
-            in '<ipython_dir>/cluster_mycluster'. 
-            """
-        )
-        paa = parser_create.add_argument
-        paa('--reset-config',
-            dest='Global.reset_config', action='store_true',
-            help=
-            """Recopy the default config files to the cluster directory.
-            You will loose any modifications you have made to these files.""")
-
-        # The "start" subcommand parser
-        parser_start = subparsers.add_parser(
-            'start',
-            parents=[parent_parser1, parent_parser2],
-            argument_default=SUPPRESS,
-            help="Start a cluster.",
-            description=
-            """Start an ipython cluster by its profile name or cluster 
-            directory. Cluster directories contain configuration, log and
-            security related files and are named using the convention
-            'cluster_<profile>' and should be creating using the 'start'
-            subcommand of 'ipcluster'. If your cluster directory is in 
-            the cwd or the ipython directory, you can simply refer to it
-            using its profile name, 'ipcluster start -n 4 -p <profile>`,
-            otherwise use the '--cluster-dir' option.
-            """
-        )
-        
-        paa = parser_start.add_argument
-        paa('-n', '--number',
-            type=int, dest='Global.n',
-            help='The number of engines to start.',
-            metavar='Global.n')
-        paa('--clean-logs',
-            dest='Global.clean_logs', action='store_true',
-            help='Delete old log flies before starting.')
-        paa('--no-clean-logs',
-            dest='Global.clean_logs', action='store_false',
-            help="Don't delete old log flies before starting.")
-        paa('--daemon',
-            dest='Global.daemonize', action='store_true',
-            help='Daemonize the ipcluster program. This implies --log-to-file')
-        paa('--no-daemon',
-            dest='Global.daemonize', action='store_false',
-            help="Dont't daemonize the ipcluster program.")
-        paa('--delay',
-            type=float, dest='Global.delay',
-            help="Specify the delay (in seconds) between starting the controller and starting the engine(s).")
-
-        # The "stop" subcommand parser
-        parser_stop = subparsers.add_parser(
-            'stop',
-            parents=[parent_parser1, parent_parser2],
-            argument_default=SUPPRESS,
-            help="Stop a running cluster.",
-            description=
-            """Stop a running ipython cluster by its profile name or cluster 
-            directory. Cluster directories are named using the convention
-            'cluster_<profile>'. If your cluster directory is in 
-            the cwd or the ipython directory, you can simply refer to it
-            using its profile name, 'ipcluster stop -p <profile>`, otherwise
-            use the '--cluster-dir' option.
-            """
-        )
-        paa = parser_stop.add_argument
-        paa('--signal',
-            dest='Global.signal', type=int,
-            help="The signal number to use in stopping the cluster (default=2).",
-            metavar="Global.signal")
-        
-        # the "engines" subcommand parser
-        parser_engines = subparsers.add_parser(
-            'engines',
-            parents=[parent_parser1, parent_parser2],
-            argument_default=SUPPRESS,
-            help="Attach some engines to an existing controller or cluster.",
-            description=
-            """Start one or more engines to connect to an existing Cluster
-            by profile name or cluster directory.
-            Cluster directories contain configuration, log and
-            security related files and are named using the convention
-            'cluster_<profile>' and should be creating using the 'start'
-            subcommand of 'ipcluster'. If your cluster directory is in 
-            the cwd or the ipython directory, you can simply refer to it
-            using its profile name, 'ipcluster engines -n 4 -p <profile>`,
-            otherwise use the '--cluster-dir' option.
-            """
-        )
-        paa = parser_engines.add_argument
-        paa('-n', '--number',
-            type=int, dest='Global.n',
-            help='The number of engines to start.',
-            metavar='Global.n')
-        paa('--daemon',
-            dest='Global.daemonize', action='store_true',
-            help='Daemonize the ipcluster program. This implies --log-to-file')
-        paa('--no-daemon',
-            dest='Global.daemonize', action='store_false',
-            help="Dont't daemonize the ipcluster program.")
-
-#-----------------------------------------------------------------------------
-# Main application
-#-----------------------------------------------------------------------------
-
-
-class IPClusterApp(ApplicationWithClusterDir):
-
-    name = u'ipcluster'
-    description = _description
-    usage = None
-    command_line_loader = IPClusterAppConfigLoader
-    default_config_file_name = default_config_file_name
-    default_log_level = logging.INFO
-    auto_create_cluster_dir = False
-
-    def create_default_config(self):
-        super(IPClusterApp, self).create_default_config()
-        self.default_config.Global.controller_launcher = \
-            'IPython.parallel.apps.launcher.LocalControllerLauncher'
-        self.default_config.Global.engine_launcher = \
-            'IPython.parallel.apps.launcher.LocalEngineSetLauncher'
-        self.default_config.Global.n = 2
-        self.default_config.Global.delay = 2
-        self.default_config.Global.reset_config = False
-        self.default_config.Global.clean_logs = True
-        self.default_config.Global.signal = signal.SIGINT
-        self.default_config.Global.daemonize = False
-
-    def find_resources(self):
-        subcommand = self.command_line_config.Global.subcommand
-        if subcommand=='list':
-            self.list_cluster_dirs()
-            # Exit immediately because there is nothing left to do.
-            self.exit()
-        elif subcommand=='create':
-            self.auto_create_cluster_dir = True
-            super(IPClusterApp, self).find_resources()
-        elif subcommand=='start' or subcommand=='stop':
-            self.auto_create_cluster_dir = True
-            try:
-                super(IPClusterApp, self).find_resources()
-            except ClusterDirError:
-                raise ClusterDirError(
-                    "Could not find a cluster directory. A cluster dir must "
-                    "be created before running 'ipcluster start'.  Do "
-                    "'ipcluster create -h' or 'ipcluster list -h' for more "
-                    "information about creating and listing cluster dirs."
-                )
-        elif subcommand=='engines':
-            self.auto_create_cluster_dir = False
-            try:
-                super(IPClusterApp, self).find_resources()
-            except ClusterDirError:
-                raise ClusterDirError(
-                    "Could not find a cluster directory. A cluster dir must "
-                    "be created before running 'ipcluster start'.  Do "
-                    "'ipcluster create -h' or 'ipcluster list -h' for more "
-                    "information about creating and listing cluster dirs."
-                )
-
-    def list_cluster_dirs(self):
-        # Find the search paths
-        cluster_dir_paths = os.environ.get('IPCLUSTER_DIR_PATH','')
-        if cluster_dir_paths:
-            cluster_dir_paths = cluster_dir_paths.split(':')
-        else:
-            cluster_dir_paths = []
-        try:
-            ipython_dir = self.command_line_config.Global.ipython_dir
-        except AttributeError:
-            ipython_dir = self.default_config.Global.ipython_dir
-        paths = [os.getcwd(), ipython_dir] + \
-            cluster_dir_paths
-        paths = list(set(paths))
-
-        self.log.info('Searching for cluster dirs in paths: %r' % paths)
-        for path in paths:
-            files = os.listdir(path)
-            for f in files:
-                full_path = os.path.join(path, f)
-                if os.path.isdir(full_path) and f.startswith('cluster_'):
-                    profile = full_path.split('_')[-1]
-                    start_cmd = 'ipcluster start -p %s -n 4' % profile
-                    print start_cmd + " ==> " + full_path
-
-    def pre_construct(self):
-        # IPClusterApp.pre_construct() is where we cd to the working directory.
-        super(IPClusterApp, self).pre_construct()
-        config = self.master_config
-        try:
-            daemon = config.Global.daemonize
-            if daemon:
-                config.Global.log_to_file = True
-        except AttributeError:
-            pass
-
-    def construct(self):
-        config = self.master_config
-        subcmd = config.Global.subcommand
-        reset = config.Global.reset_config
-        if subcmd == 'list':
-            return
-        if subcmd == 'create':
-            self.log.info('Copying default config files to cluster directory '
-            '[overwrite=%r]' % (reset,))
-            self.cluster_dir_obj.copy_all_config_files(overwrite=reset)
-        if subcmd =='start':
-            self.cluster_dir_obj.copy_all_config_files(overwrite=False)
-            self.start_logging()
-            self.loop = ioloop.IOLoop.instance()
-            # reactor.callWhenRunning(self.start_launchers)
-            dc = ioloop.DelayedCallback(self.start_launchers, 0, self.loop)
-            dc.start()
-        if subcmd == 'engines':
-            self.start_logging()
-            self.loop = ioloop.IOLoop.instance()
-            # reactor.callWhenRunning(self.start_launchers)
-            engine_only = lambda : self.start_launchers(controller=False)
-            dc = ioloop.DelayedCallback(engine_only, 0, self.loop)
-            dc.start()
-
-    def start_launchers(self, controller=True):
-        config = self.master_config
-
-        # Create the launchers. In both bases, we set the work_dir of
-        # the launcher to the cluster_dir. This is where the launcher's
-        # subprocesses will be launched. It is not where the controller
-        # and engine will be launched.
-        if controller:
-            cl_class = import_item(config.Global.controller_launcher)
-            self.controller_launcher = cl_class(
-                work_dir=self.cluster_dir, config=config,
-                logname=self.log.name
-            )
-            # Setup the observing of stopping. If the controller dies, shut
-            # everything down as that will be completely fatal for the engines.
-            self.controller_launcher.on_stop(self.stop_launchers)
-            # But, we don't monitor the stopping of engines. An engine dying
-            # is just fine and in principle a user could start a new engine.
-            # Also, if we did monitor engine stopping, it is difficult to
-            # know what to do when only some engines die. Currently, the
-            # observing of engine stopping is inconsistent. Some launchers
-            # might trigger on a single engine stopping, other wait until
-            # all stop.  TODO: think more about how to handle this.
-        else:
-            self.controller_launcher = None
-        
-        el_class = import_item(config.Global.engine_launcher)
-        self.engine_launcher = el_class(
-            work_dir=self.cluster_dir, config=config, logname=self.log.name
-        )
-
-        # Setup signals
-        signal.signal(signal.SIGINT, self.sigint_handler)
-
-        # Start the controller and engines
-        self._stopping = False  # Make sure stop_launchers is not called 2x.
-        if controller:
-            self.start_controller()
-        dc = ioloop.DelayedCallback(self.start_engines, 1000*config.Global.delay*controller, self.loop)
-        dc.start()
-        self.startup_message()
-
-    def startup_message(self, r=None):
-        self.log.info("IPython cluster: started")
-        return r
-        
-    def start_controller(self, r=None):
-        # self.log.info("In start_controller")
-        config = self.master_config
-        d = self.controller_launcher.start(
-            cluster_dir=config.Global.cluster_dir
-        )
-        return d
-            
-    def start_engines(self, r=None):
-        # self.log.info("In start_engines")
-        config = self.master_config
-        
-        d = self.engine_launcher.start(
-            config.Global.n,
-            cluster_dir=config.Global.cluster_dir
-        )
-        return d
-
-    def stop_controller(self, r=None):
-        # self.log.info("In stop_controller")
-        if self.controller_launcher and self.controller_launcher.running:
-            return self.controller_launcher.stop()
-
-    def stop_engines(self, r=None):
-        # self.log.info("In stop_engines")
-        if self.engine_launcher.running:
-            d = self.engine_launcher.stop()
-            # d.addErrback(self.log_err)
-            return d
-        else:
-            return None
-
-    def log_err(self, f):
-        self.log.error(f.getTraceback())
-        return None
-        
-    def stop_launchers(self, r=None):
-        if not self._stopping:
-            self._stopping = True
-            # if isinstance(r, failure.Failure):
-            #     self.log.error('Unexpected error in ipcluster:')
-            #     self.log.info(r.getTraceback())
-            self.log.error("IPython cluster: stopping")
-            # These return deferreds. We are not doing anything with them
-            # but we are holding refs to them as a reminder that they 
-            # do return deferreds.
-            d1 = self.stop_engines()
-            d2 = self.stop_controller()
-            # Wait a few seconds to let things shut down.
-            dc = ioloop.DelayedCallback(self.loop.stop, 4000, self.loop)
-            dc.start()
-            # reactor.callLater(4.0, reactor.stop)
-
-    def sigint_handler(self, signum, frame):
-        self.stop_launchers()
-        
-    def start_logging(self):
-        # Remove old log files of the controller and engine
-        if self.master_config.Global.clean_logs:
-            log_dir = self.master_config.Global.log_dir
-            for f in os.listdir(log_dir):
-                if re.match(r'ip(engine|controller)z-\d+\.(log|err|out)',f):
-                    os.remove(os.path.join(log_dir, f))
-        # This will remove old log files for ipcluster itself
-        super(IPClusterApp, self).start_logging()
-
-    def start_app(self):
-        """Start the application, depending on what subcommand is used."""
-        subcmd = self.master_config.Global.subcommand
-        if subcmd=='create' or subcmd=='list':
-            return
-        elif subcmd=='start':
-            self.start_app_start()
-        elif subcmd=='stop':
-            self.start_app_stop()
-        elif subcmd=='engines':
-            self.start_app_engines()
-
-    def start_app_start(self):
-        """Start the app for the start subcommand."""
-        config = self.master_config
-        # First see if the cluster is already running
-        try:
-            pid = self.get_pid_from_file()
-        except PIDFileError:
-            pass
-        else:
-            self.log.critical(
-                'Cluster is already running with [pid=%s]. '
-                'use "ipcluster stop" to stop the cluster.' % pid
-            )
-            # Here I exit with a unusual exit status that other processes
-            # can watch for to learn how I existed.
-            self.exit(ALREADY_STARTED)
-
-        # Now log and daemonize
-        self.log.info(
-            'Starting ipcluster with [daemon=%r]' % config.Global.daemonize
-        )
-        # TODO: Get daemonize working on Windows or as a Windows Server.
-        if config.Global.daemonize:
-            if os.name=='posix':
-                from twisted.scripts._twistd_unix import daemonize
-                daemonize()
-
-        # Now write the new pid file AFTER our new forked pid is active.
-        self.write_pid_file()
-        try:
-            self.loop.start()
-        except KeyboardInterrupt:
-            pass
-        except zmq.ZMQError as e:
-            if e.errno == errno.EINTR:
-                pass
-            else:
-                raise
-        self.remove_pid_file()
-
-    def start_app_engines(self):
-        """Start the app for the start subcommand."""
-        config = self.master_config
-        # First see if the cluster is already running
-        
-        # Now log and daemonize
-        self.log.info(
-            'Starting engines with [daemon=%r]' % config.Global.daemonize
-        )
-        # TODO: Get daemonize working on Windows or as a Windows Server.
-        if config.Global.daemonize:
-            if os.name=='posix':
-                from twisted.scripts._twistd_unix import daemonize
-                daemonize()
-
-        # Now write the new pid file AFTER our new forked pid is active.
-        # self.write_pid_file()
-        try:
-            self.loop.start()
-        except KeyboardInterrupt:
-            pass
-        except zmq.ZMQError as e:
-            if e.errno == errno.EINTR:
-                pass
-            else:
-                raise
-        # self.remove_pid_file()
-    
-    def start_app_stop(self):
-        """Start the app for the stop subcommand."""
-        config = self.master_config
-        try:
-            pid = self.get_pid_from_file()
-        except PIDFileError:
-            self.log.critical(
-                'Problem reading pid file, cluster is probably not running.'
-            )
-            # Here I exit with a unusual exit status that other processes
-            # can watch for to learn how I existed.
-            self.exit(ALREADY_STOPPED)
-        else:
-            if os.name=='posix':
-                sig = config.Global.signal
-                self.log.info(
-                    "Stopping cluster [pid=%r] with [signal=%r]" % (pid, sig)
-                )
-                os.kill(pid, sig)
-            elif os.name=='nt':
-                # As of right now, we don't support daemonize on Windows, so
-                # stop will not do anything. Minimally, it should clean up the
-                # old .pid files.
-                self.remove_pid_file()
-
-
-def launch_new_instance():
-    """Create and run the IPython cluster."""
-    app = IPClusterApp()
-    app.start()
-
-
-if __name__ == '__main__':
-    launch_new_instance()
-
diff --git a/IPython/parallel/apps/ipcontrollerapp.py b/IPython/parallel/apps/ipcontrollerapp.py
deleted file mode 100755
index 0cc69ace954..00000000000
--- a/IPython/parallel/apps/ipcontrollerapp.py
+++ /dev/null
@@ -1,433 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-The IPython controller application.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from __future__ import with_statement
-
-import copy
-import os
-import logging
-import socket
-import stat
-import sys
-import uuid
-
-import zmq
-from zmq.log.handlers import PUBHandler
-from zmq.utils import jsonapi as json
-
-from IPython.config.loader import Config
-
-from IPython.parallel import factory
-
-from IPython.parallel.apps.clusterdir import (
-    ApplicationWithClusterDir,
-    ClusterDirConfigLoader
-)
-from IPython.parallel.util import disambiguate_ip_address, split_url
-# from IPython.kernel.fcutil import FCServiceFactory, FURLError
-from IPython.utils.traitlets import Instance, Unicode
-
-from IPython.parallel.controller.controller import ControllerFactory
-
-
-#-----------------------------------------------------------------------------
-# Module level variables
-#-----------------------------------------------------------------------------
-
-
-#: The default config file name for this application
-default_config_file_name = u'ipcontroller_config.py'
-
-
-_description = """Start the IPython controller for parallel computing.
-
-The IPython controller provides a gateway between the IPython engines and
-clients. The controller needs to be started before the engines and can be
-configured using command line options or using a cluster directory. Cluster
-directories contain config, log and security files and are usually located in
-your ipython directory and named as "cluster_<profile>". See the --profile
-and --cluster-dir options for details.
-"""
-
-#-----------------------------------------------------------------------------
-# Default interfaces
-#-----------------------------------------------------------------------------
-
-# The default client interfaces for FCClientServiceFactory.interfaces
-default_client_interfaces = Config()
-default_client_interfaces.Default.url_file = 'ipcontroller-client.url'
-
-# Make this a dict we can pass to Config.__init__ for the default
-default_client_interfaces = dict(copy.deepcopy(default_client_interfaces.items()))
-
-
-
-# The default engine interfaces for FCEngineServiceFactory.interfaces
-default_engine_interfaces = Config()
-default_engine_interfaces.Default.url_file = u'ipcontroller-engine.url'
-
-# Make this a dict we can pass to Config.__init__ for the default
-default_engine_interfaces = dict(copy.deepcopy(default_engine_interfaces.items()))
-
-
-#-----------------------------------------------------------------------------
-# Service factories
-#-----------------------------------------------------------------------------
-
-# 
-# class FCClientServiceFactory(FCServiceFactory):
-#     """A Foolscap implementation of the client services."""
-# 
-#     cert_file = Unicode(u'ipcontroller-client.pem', config=True)
-#     interfaces = Instance(klass=Config, kw=default_client_interfaces,
-#                           allow_none=False, config=True)
-# 
-# 
-# class FCEngineServiceFactory(FCServiceFactory):
-#     """A Foolscap implementation of the engine services."""
-# 
-#     cert_file = Unicode(u'ipcontroller-engine.pem', config=True)
-#     interfaces = Instance(klass=dict, kw=default_engine_interfaces,
-#                           allow_none=False, config=True)
-# 
-
-#-----------------------------------------------------------------------------
-# Command line options
-#-----------------------------------------------------------------------------
-
-
-class IPControllerAppConfigLoader(ClusterDirConfigLoader):
-
-    def _add_arguments(self):
-        super(IPControllerAppConfigLoader, self)._add_arguments()
-        paa = self.parser.add_argument
-        
-        ## Hub Config:
-        paa('--mongodb', 
-            dest='HubFactory.db_class', action='store_const',
-            const='IPython.parallel.controller.mongodb.MongoDB', 
-            help='Use MongoDB for task storage [default: in-memory]')
-        paa('--sqlite', 
-            dest='HubFactory.db_class', action='store_const',
-            const='IPython.parallel.controller.sqlitedb.SQLiteDB',
-            help='Use SQLite3 for DB task storage [default: in-memory]')
-        paa('--hb',
-            type=int, dest='HubFactory.hb', nargs=2,
-            help='The (2) ports the Hub\'s Heartmonitor will use for the heartbeat '
-            'connections [default: random]',
-            metavar='Hub.hb_ports')
-        paa('--ping',
-            type=int, dest='HubFactory.ping',
-            help='The frequency at which the Hub pings the engines for heartbeats '
-            ' (in ms) [default: 100]',
-            metavar='Hub.ping')
-        
-        # Client config
-        paa('--client-ip',
-            type=str, dest='HubFactory.client_ip', 
-            help='The IP address or hostname the Hub will listen on for '
-            'client connections. Both engine-ip and client-ip can be set simultaneously '
-            'via --ip [default: loopback]',
-            metavar='Hub.client_ip')
-        paa('--client-transport',
-            type=str, dest='HubFactory.client_transport', 
-            help='The ZeroMQ transport the Hub will use for '
-            'client connections. Both engine-transport and client-transport can be set simultaneously '
-            'via --transport [default: tcp]',
-            metavar='Hub.client_transport')
-        paa('--query',
-            type=int, dest='HubFactory.query_port', 
-            help='The port on which the Hub XREP socket will listen for result queries from clients [default: random]',
-            metavar='Hub.query_port')
-        paa('--notifier',
-            type=int, dest='HubFactory.notifier_port', 
-            help='The port on which the Hub PUB socket will listen for notification connections [default: random]',
-            metavar='Hub.notifier_port')
-        
-        # Engine config
-        paa('--engine-ip',
-            type=str, dest='HubFactory.engine_ip', 
-            help='The IP address or hostname the Hub will listen on for '
-            'engine connections. This applies to the Hub and its schedulers'
-            'engine-ip and client-ip can be set simultaneously '
-            'via --ip [default: loopback]',
-            metavar='Hub.engine_ip')
-        paa('--engine-transport',
-            type=str, dest='HubFactory.engine_transport', 
-            help='The ZeroMQ transport the Hub will use for '
-            'client connections. Both engine-transport and client-transport can be set simultaneously '
-            'via --transport [default: tcp]',
-            metavar='Hub.engine_transport')
-        
-        # Scheduler config
-        paa('--mux',
-            type=int, dest='ControllerFactory.mux', nargs=2,
-            help='The (2) ports the MUX scheduler will listen on for client,engine '
-            'connections, respectively [default: random]',
-            metavar='Scheduler.mux_ports')
-        paa('--task',
-            type=int, dest='ControllerFactory.task', nargs=2,
-            help='The (2) ports the Task scheduler will listen on for client,engine '
-            'connections, respectively [default: random]',
-            metavar='Scheduler.task_ports')
-        paa('--control',
-            type=int, dest='ControllerFactory.control', nargs=2,
-            help='The (2) ports the Control scheduler will listen on for client,engine '
-            'connections, respectively [default: random]',
-            metavar='Scheduler.control_ports')
-        paa('--iopub',
-            type=int, dest='ControllerFactory.iopub', nargs=2,
-            help='The (2) ports the IOPub scheduler will listen on for client,engine '
-            'connections, respectively [default: random]',
-            metavar='Scheduler.iopub_ports')
-            
-        paa('--scheme',
-            type=str, dest='HubFactory.scheme',
-            choices = ['pure', 'lru', 'plainrandom', 'weighted', 'twobin','leastload'],
-            help='select the task scheduler scheme  [default: Python LRU]',
-            metavar='Scheduler.scheme')
-        paa('--usethreads',
-            dest='ControllerFactory.usethreads', action="store_true",
-            help='Use threads instead of processes for the schedulers',
-            )
-        paa('--hwm',
-            dest='TaskScheduler.hwm', type=int,
-            help='specify the High Water Mark (HWM) '
-            'in the Python scheduler. This is the maximum number '
-            'of allowed outstanding tasks on each engine.',
-            )
-        
-        ## Global config
-        paa('--log-to-file',
-            action='store_true', dest='Global.log_to_file',
-            help='Log to a file in the log directory (default is stdout)')
-        paa('--log-url',
-            type=str, dest='Global.log_url',
-            help='Broadcast logs to an iploggerz process [default: disabled]')
-        paa('-r','--reuse-files', 
-            action='store_true', dest='Global.reuse_files',
-            help='Try to reuse existing json connection files.')
-        paa('--no-secure',
-            action='store_false', dest='Global.secure',
-            help='Turn off execution keys (default).')
-        paa('--secure',
-            action='store_true', dest='Global.secure',
-            help='Turn on execution keys.')
-        paa('--execkey',
-            type=str, dest='Global.exec_key',
-            help='path to a file containing an execution key.',
-            metavar='keyfile')
-        paa('--ssh',
-            type=str, dest='Global.sshserver',
-            help='ssh url for clients to use when connecting to the Controller '
-            'processes. It should be of the form: [user@]server[:port]. The '
-            'Controller\'s listening addresses must be accessible from the ssh server',
-            metavar='Global.sshserver')
-        paa('--location',
-            type=str, dest='Global.location',
-            help="The external IP or domain name of this machine, used for disambiguating "
-            "engine and client connections.",
-            metavar='Global.location')
-        factory.add_session_arguments(self.parser)
-        factory.add_registration_arguments(self.parser)
-
-
-#-----------------------------------------------------------------------------
-# The main application
-#-----------------------------------------------------------------------------
-
-
-class IPControllerApp(ApplicationWithClusterDir):
-
-    name = u'ipcontroller'
-    description = _description
-    command_line_loader = IPControllerAppConfigLoader
-    default_config_file_name = default_config_file_name
-    auto_create_cluster_dir = True
-    
-
-    def create_default_config(self):
-        super(IPControllerApp, self).create_default_config()
-        # Don't set defaults for Global.secure or Global.reuse_furls
-        # as those are set in a component.
-        self.default_config.Global.import_statements = []
-        self.default_config.Global.clean_logs = True
-        self.default_config.Global.secure = True
-        self.default_config.Global.reuse_files = False
-        self.default_config.Global.exec_key = "exec_key.key"
-        self.default_config.Global.sshserver = None
-        self.default_config.Global.location = None
-
-    def pre_construct(self):
-        super(IPControllerApp, self).pre_construct()
-        c = self.master_config
-        # The defaults for these are set in FCClientServiceFactory and
-        # FCEngineServiceFactory, so we only set them here if the global
-        # options have be set to override the class level defaults.
-        
-        # if hasattr(c.Global, 'reuse_furls'):
-        #     c.FCClientServiceFactory.reuse_furls = c.Global.reuse_furls
-        #     c.FCEngineServiceFactory.reuse_furls = c.Global.reuse_furls
-        #     del c.Global.reuse_furls
-        # if hasattr(c.Global, 'secure'):
-        #     c.FCClientServiceFactory.secure = c.Global.secure
-        #     c.FCEngineServiceFactory.secure = c.Global.secure
-        #     del c.Global.secure
-    
-    def save_connection_dict(self, fname, cdict):
-        """save a connection dict to json file."""
-        c = self.master_config
-        url = cdict['url']
-        location = cdict['location']
-        if not location:
-            try:
-                proto,ip,port = split_url(url)
-            except AssertionError:
-                pass
-            else:
-                location = socket.gethostbyname_ex(socket.gethostname())[2][-1]
-            cdict['location'] = location
-        fname = os.path.join(c.Global.security_dir, fname)
-        with open(fname, 'w') as f:
-            f.write(json.dumps(cdict, indent=2))
-        os.chmod(fname, stat.S_IRUSR|stat.S_IWUSR)
-    
-    def load_config_from_json(self):
-        """load config from existing json connector files."""
-        c = self.master_config
-        # load from engine config
-        with open(os.path.join(c.Global.security_dir, 'ipcontroller-engine.json')) as f:
-            cfg = json.loads(f.read())
-        key = c.SessionFactory.exec_key = cfg['exec_key']
-        xport,addr = cfg['url'].split('://')
-        c.HubFactory.engine_transport = xport
-        ip,ports = addr.split(':')
-        c.HubFactory.engine_ip = ip
-        c.HubFactory.regport = int(ports)
-        c.Global.location = cfg['location']
-        
-        # load client config
-        with open(os.path.join(c.Global.security_dir, 'ipcontroller-client.json')) as f:
-            cfg = json.loads(f.read())
-        assert key == cfg['exec_key'], "exec_key mismatch between engine and client keys"
-        xport,addr = cfg['url'].split('://')
-        c.HubFactory.client_transport = xport
-        ip,ports = addr.split(':')
-        c.HubFactory.client_ip = ip
-        c.Global.sshserver = cfg['ssh']
-        assert int(ports) == c.HubFactory.regport, "regport mismatch"
-    
-    def construct(self):
-        # This is the working dir by now.
-        sys.path.insert(0, '')
-        c = self.master_config
-        
-        self.import_statements()
-        reusing = c.Global.reuse_files
-        if reusing:
-            try:
-                self.load_config_from_json()
-            except (AssertionError,IOError):
-                reusing=False
-        # check again, because reusing may have failed:
-        if reusing:
-            pass
-        elif c.Global.secure:
-            keyfile = os.path.join(c.Global.security_dir, c.Global.exec_key)
-            key = str(uuid.uuid4())
-            with open(keyfile, 'w') as f:
-                f.write(key)
-            os.chmod(keyfile, stat.S_IRUSR|stat.S_IWUSR)
-            c.SessionFactory.exec_key = key
-        else:
-            c.SessionFactory.exec_key = ''
-            key = None
-        
-        try:
-            self.factory = ControllerFactory(config=c, logname=self.log.name)
-            self.start_logging()
-            self.factory.construct()
-        except:
-            self.log.error("Couldn't construct the Controller", exc_info=True)
-            self.exit(1)
-        
-        if not reusing:
-            # save to new json config files
-            f = self.factory
-            cdict = {'exec_key' : key,
-                    'ssh' : c.Global.sshserver,
-                    'url' : "%s://%s:%s"%(f.client_transport, f.client_ip, f.regport),
-                    'location' : c.Global.location
-                    }
-            self.save_connection_dict('ipcontroller-client.json', cdict)
-            edict = cdict
-            edict['url']="%s://%s:%s"%((f.client_transport, f.client_ip, f.regport))
-            self.save_connection_dict('ipcontroller-engine.json', edict)
-        
-    
-    def save_urls(self):
-        """save the registration urls to files."""
-        c = self.master_config
-        
-        sec_dir = c.Global.security_dir
-        cf = self.factory
-        
-        with open(os.path.join(sec_dir, 'ipcontroller-engine.url'), 'w') as f:
-            f.write("%s://%s:%s"%(cf.engine_transport, cf.engine_ip, cf.regport))
-        
-        with open(os.path.join(sec_dir, 'ipcontroller-client.url'), 'w') as f:
-            f.write("%s://%s:%s"%(cf.client_transport, cf.client_ip, cf.regport))
-        
-    
-    def import_statements(self):
-        statements = self.master_config.Global.import_statements
-        for s in statements:
-            try:
-                self.log.msg("Executing statement: '%s'" % s)
-                exec s in globals(), locals()
-            except:
-                self.log.msg("Error running statement: %s" % s)
-
-    def start_logging(self):
-        super(IPControllerApp, self).start_logging()
-        if self.master_config.Global.log_url:
-            context = self.factory.context
-            lsock = context.socket(zmq.PUB)
-            lsock.connect(self.master_config.Global.log_url)
-            handler = PUBHandler(lsock)
-            handler.root_topic = 'controller'
-            handler.setLevel(self.log_level)
-            self.log.addHandler(handler)
-    # 
-    def start_app(self):
-        # Start the subprocesses:
-        self.factory.start()
-        self.write_pid_file(overwrite=True)
-        try:
-            self.factory.loop.start()
-        except KeyboardInterrupt:
-            self.log.critical("Interrupted, Exiting...\n")
-
-
-def launch_new_instance():
-    """Create and run the IPython controller"""
-    app = IPControllerApp()
-    app.start()
-
-
-if __name__ == '__main__':
-    launch_new_instance()
diff --git a/IPython/parallel/apps/ipengineapp.py b/IPython/parallel/apps/ipengineapp.py
deleted file mode 100755
index 1d4abc08d0e..00000000000
--- a/IPython/parallel/apps/ipengineapp.py
+++ /dev/null
@@ -1,303 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-The IPython engine application
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import json
-import os
-import sys
-
-import zmq
-from zmq.eventloop import ioloop
-
-from IPython.parallel.apps.clusterdir import (
-    ApplicationWithClusterDir,
-    ClusterDirConfigLoader
-)
-from IPython.zmq.log import EnginePUBHandler
-
-from IPython.parallel import factory
-from IPython.parallel.engine.engine import EngineFactory
-from IPython.parallel.engine.streamkernel import Kernel
-from IPython.parallel.util import disambiguate_url
-
-from IPython.utils.importstring import import_item
-
-
-#-----------------------------------------------------------------------------
-# Module level variables
-#-----------------------------------------------------------------------------
-
-#: The default config file name for this application
-default_config_file_name = u'ipengine_config.py'
-
-
-mpi4py_init = """from mpi4py import MPI as mpi
-mpi.size = mpi.COMM_WORLD.Get_size()
-mpi.rank = mpi.COMM_WORLD.Get_rank()
-"""
-
-
-pytrilinos_init = """from PyTrilinos import Epetra
-class SimpleStruct:
-pass
-mpi = SimpleStruct()
-mpi.rank = 0
-mpi.size = 0
-"""
-
-
-_description = """Start an IPython engine for parallel computing.\n\n
-
-IPython engines run in parallel and perform computations on behalf of a client
-and controller. A controller needs to be started before the engines. The
-engine can be configured using command line options or using a cluster
-directory. Cluster directories contain config, log and security files and are
-usually located in your ipython directory and named as "cluster_<profile>".
-See the --profile and --cluster-dir options for details.
-"""
-
-#-----------------------------------------------------------------------------
-# Command line options
-#-----------------------------------------------------------------------------
-
-
-class IPEngineAppConfigLoader(ClusterDirConfigLoader):
-
-    def _add_arguments(self):
-        super(IPEngineAppConfigLoader, self)._add_arguments()
-        paa = self.parser.add_argument
-        # Controller config
-        paa('--file', '-f',
-            type=unicode, dest='Global.url_file',
-            help='The full location of the file containing the connection information fo '
-            'controller. If this is not given, the file must be in the '
-            'security directory of the cluster directory.  This location is '
-            'resolved using the --profile and --app-dir options.',
-            metavar='Global.url_file')
-        # MPI
-        paa('--mpi',
-            type=str, dest='MPI.use',
-            help='How to enable MPI (mpi4py, pytrilinos, or empty string to disable).',
-            metavar='MPI.use')
-        # Global config
-        paa('--log-to-file',
-            action='store_true', dest='Global.log_to_file',
-            help='Log to a file in the log directory (default is stdout)')
-        paa('--log-url',
-            dest='Global.log_url',
-            help="url of ZMQ logger, as started with iploggerz")
-        # paa('--execkey',
-        #     type=str, dest='Global.exec_key',
-        #     help='path to a file containing an execution key.',
-        #     metavar='keyfile')
-        # paa('--no-secure',
-        #     action='store_false', dest='Global.secure',
-        #     help='Turn off execution keys.')
-        # paa('--secure',
-        #     action='store_true', dest='Global.secure',
-        #     help='Turn on execution keys (default).')
-        # init command
-        paa('-c',
-            type=str, dest='Global.extra_exec_lines',
-            help='specify a command to be run at startup')
-        paa('-s',
-            type=unicode, dest='Global.extra_exec_file',
-            help='specify a script to be run at startup')
-        
-        factory.add_session_arguments(self.parser)
-        factory.add_registration_arguments(self.parser)
-
-
-#-----------------------------------------------------------------------------
-# Main application
-#-----------------------------------------------------------------------------
-
-
-class IPEngineApp(ApplicationWithClusterDir):
-
-    name = u'ipengine'
-    description = _description
-    command_line_loader = IPEngineAppConfigLoader
-    default_config_file_name = default_config_file_name
-    auto_create_cluster_dir = True
-
-    def create_default_config(self):
-        super(IPEngineApp, self).create_default_config()
-
-        # The engine should not clean logs as we don't want to remove the
-        # active log files of other running engines.
-        self.default_config.Global.clean_logs = False
-        self.default_config.Global.secure = True
-
-        # Global config attributes
-        self.default_config.Global.exec_lines = []
-        self.default_config.Global.extra_exec_lines = ''
-        self.default_config.Global.extra_exec_file = u''
-
-        # Configuration related to the controller
-        # This must match the filename (path not included) that the controller
-        # used for the FURL file.
-        self.default_config.Global.url_file = u''
-        self.default_config.Global.url_file_name = u'ipcontroller-engine.json'
-        # If given, this is the actual location of the controller's FURL file.
-        # If not, this is computed using the profile, app_dir and furl_file_name
-        # self.default_config.Global.key_file_name = u'exec_key.key'
-        # self.default_config.Global.key_file = u''
-
-        # MPI related config attributes
-        self.default_config.MPI.use = ''
-        self.default_config.MPI.mpi4py = mpi4py_init
-        self.default_config.MPI.pytrilinos = pytrilinos_init
-
-    def post_load_command_line_config(self):
-        pass
-
-    def pre_construct(self):
-        super(IPEngineApp, self).pre_construct()
-        # self.find_cont_url_file()
-        self.find_url_file()
-        if self.master_config.Global.extra_exec_lines:
-            self.master_config.Global.exec_lines.append(self.master_config.Global.extra_exec_lines)
-        if self.master_config.Global.extra_exec_file:
-            enc = sys.getfilesystemencoding() or 'utf8'
-            cmd="execfile(%r)"%self.master_config.Global.extra_exec_file.encode(enc)
-            self.master_config.Global.exec_lines.append(cmd)
-
-    # def find_key_file(self):
-    #     """Set the key file.
-    # 
-    #     Here we don't try to actually see if it exists for is valid as that
-    #     is hadled by the connection logic.
-    #     """
-    #     config = self.master_config
-    #     # Find the actual controller key file
-    #     if not config.Global.key_file:
-    #         try_this = os.path.join(
-    #             config.Global.cluster_dir, 
-    #             config.Global.security_dir,
-    #             config.Global.key_file_name
-    #         )
-    #         config.Global.key_file = try_this
-        
-    def find_url_file(self):
-        """Set the key file.
-
-        Here we don't try to actually see if it exists for is valid as that
-        is hadled by the connection logic.
-        """
-        config = self.master_config
-        # Find the actual controller key file
-        if not config.Global.url_file:
-            try_this = os.path.join(
-                config.Global.cluster_dir, 
-                config.Global.security_dir,
-                config.Global.url_file_name
-            )
-            config.Global.url_file = try_this
-        
-    def construct(self):
-        # This is the working dir by now.
-        sys.path.insert(0, '')
-        config = self.master_config
-        # if os.path.exists(config.Global.key_file) and config.Global.secure:
-        #     config.SessionFactory.exec_key = config.Global.key_file
-        if os.path.exists(config.Global.url_file):
-            with open(config.Global.url_file) as f:
-                d = json.loads(f.read())
-                for k,v in d.iteritems():
-                    if isinstance(v, unicode):
-                        d[k] = v.encode()
-            if d['exec_key']:
-                config.SessionFactory.exec_key = d['exec_key']
-            d['url'] = disambiguate_url(d['url'], d['location'])
-            config.RegistrationFactory.url=d['url']
-            config.EngineFactory.location = d['location']
-        
-        
-        
-        config.Kernel.exec_lines = config.Global.exec_lines
-
-        self.start_mpi()
-
-        # Create the underlying shell class and EngineService
-        # shell_class = import_item(self.master_config.Global.shell_class)
-        try:
-            self.engine = EngineFactory(config=config, logname=self.log.name)
-        except:
-            self.log.error("Couldn't start the Engine", exc_info=True)
-            self.exit(1)
-        
-        self.start_logging()
-
-        # Create the service hierarchy
-        # self.main_service = service.MultiService()
-        # self.engine_service.setServiceParent(self.main_service)
-        # self.tub_service = Tub()
-        # self.tub_service.setServiceParent(self.main_service)
-        # # This needs to be called before the connection is initiated
-        # self.main_service.startService()
-
-        # This initiates the connection to the controller and calls
-        # register_engine to tell the controller we are ready to do work
-        # self.engine_connector = EngineConnector(self.tub_service)
-
-        # self.log.info("Using furl file: %s" % self.master_config.Global.furl_file)
-
-        # reactor.callWhenRunning(self.call_connect)
-
-
-    def start_logging(self):
-        super(IPEngineApp, self).start_logging()
-        if self.master_config.Global.log_url:
-            context = self.engine.context
-            lsock = context.socket(zmq.PUB)
-            lsock.connect(self.master_config.Global.log_url)
-            handler = EnginePUBHandler(self.engine, lsock)
-            handler.setLevel(self.log_level)
-            self.log.addHandler(handler)
-    
-    def start_mpi(self):
-        global mpi
-        mpikey = self.master_config.MPI.use
-        mpi_import_statement = self.master_config.MPI.get(mpikey, None)
-        if mpi_import_statement is not None:
-            try:
-                self.log.info("Initializing MPI:")
-                self.log.info(mpi_import_statement)
-                exec mpi_import_statement in globals()
-            except:
-                mpi = None
-        else:
-            mpi = None
-
-
-    def start_app(self):
-        self.engine.start()
-        try:
-            self.engine.loop.start()
-        except KeyboardInterrupt:
-            self.log.critical("Engine Interrupted, shutting down...\n")
-
-
-def launch_new_instance():
-    """Create and run the IPython controller"""
-    app = IPEngineApp()
-    app.start()
-
-
-if __name__ == '__main__':
-    launch_new_instance()
-
diff --git a/IPython/parallel/apps/iploggerapp.py b/IPython/parallel/apps/iploggerapp.py
deleted file mode 100755
index 25ac4c15c86..00000000000
--- a/IPython/parallel/apps/iploggerapp.py
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A simple IPython logger application
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import sys
-
-import zmq
-
-from IPython.parallel.apps.clusterdir import (
-    ApplicationWithClusterDir,
-    ClusterDirConfigLoader
-)
-from IPython.parallel.apps.logwatcher import LogWatcher
-
-#-----------------------------------------------------------------------------
-# Module level variables
-#-----------------------------------------------------------------------------
-
-#: The default config file name for this application
-default_config_file_name = u'iplogger_config.py'
-
-_description = """Start an IPython logger for parallel computing.\n\n
-
-IPython controllers and engines (and your own processes) can broadcast log messages
-by registering a `zmq.log.handlers.PUBHandler` with the `logging` module. The
-logger can be configured using command line options or using a cluster
-directory. Cluster directories contain config, log and security files and are
-usually located in your ipython directory and named as "cluster_<profile>".
-See the --profile and --cluster-dir options for details.
-"""
-
-#-----------------------------------------------------------------------------
-# Command line options
-#-----------------------------------------------------------------------------
-
-
-class IPLoggerAppConfigLoader(ClusterDirConfigLoader):
-
-    def _add_arguments(self):
-        super(IPLoggerAppConfigLoader, self)._add_arguments()
-        paa = self.parser.add_argument
-        # Controller config
-        paa('--url',
-            type=str, dest='LogWatcher.url',
-            help='The url the LogWatcher will listen on',
-            )
-        # MPI
-        paa('--topics',
-            type=str, dest='LogWatcher.topics', nargs='+',
-            help='What topics to subscribe to',
-            metavar='topics')
-        # Global config
-        paa('--log-to-file',
-            action='store_true', dest='Global.log_to_file',
-            help='Log to a file in the log directory (default is stdout)')
-        
-
-#-----------------------------------------------------------------------------
-# Main application
-#-----------------------------------------------------------------------------
-
-
-class IPLoggerApp(ApplicationWithClusterDir):
-
-    name = u'iploggerz'
-    description = _description
-    command_line_loader = IPLoggerAppConfigLoader
-    default_config_file_name = default_config_file_name
-    auto_create_cluster_dir = True
-
-    def create_default_config(self):
-        super(IPLoggerApp, self).create_default_config()
-
-        # The engine should not clean logs as we don't want to remove the
-        # active log files of other running engines.
-        self.default_config.Global.clean_logs = False
-
-        # If given, this is the actual location of the logger's URL file.
-        # If not, this is computed using the profile, app_dir and furl_file_name
-        self.default_config.Global.url_file_name = u'iplogger.url'
-        self.default_config.Global.url_file = u''
-
-    def post_load_command_line_config(self):
-        pass
-
-    def pre_construct(self):
-        super(IPLoggerApp, self).pre_construct()
-
-    def construct(self):
-        # This is the working dir by now.
-        sys.path.insert(0, '')
-
-        self.start_logging()
-
-        try:
-            self.watcher = LogWatcher(config=self.master_config, logname=self.log.name)
-        except:
-            self.log.error("Couldn't start the LogWatcher", exc_info=True)
-            self.exit(1)
-        
-
-    def start_app(self):
-        try:
-            self.watcher.start()
-            self.watcher.loop.start()
-        except KeyboardInterrupt:
-            self.log.critical("Logging Interrupted, shutting down...\n")
-
-
-def launch_new_instance():
-    """Create and run the IPython LogWatcher"""
-    app = IPLoggerApp()
-    app.start()
-
-
-if __name__ == '__main__':
-    launch_new_instance()
-
diff --git a/IPython/parallel/apps/launcher.py b/IPython/parallel/apps/launcher.py
deleted file mode 100644
index 171a248aee5..00000000000
--- a/IPython/parallel/apps/launcher.py
+++ /dev/null
@@ -1,996 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Facilities for launching IPython processes asynchronously.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import copy
-import logging
-import os
-import re
-import stat
-
-# signal imports, handling various platforms, versions
-
-from signal import SIGINT, SIGTERM
-try:
-    from signal import SIGKILL
-except ImportError:
-    # Windows
-    SIGKILL=SIGTERM
-
-try:
-    # Windows >= 2.7, 3.2
-    from signal import CTRL_C_EVENT as SIGINT
-except ImportError:
-    pass
-
-from subprocess import Popen, PIPE, STDOUT
-try:
-    from subprocess import check_output
-except ImportError:
-    # pre-2.7, define check_output with Popen
-    def check_output(*args, **kwargs):
-        kwargs.update(dict(stdout=PIPE))
-        p = Popen(*args, **kwargs)
-        out,err = p.communicate()
-        return out
-
-from zmq.eventloop import ioloop
-
-from IPython.external import Itpl
-# from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import Any, Str, Int, List, Unicode, Dict, Instance, CUnicode
-from IPython.utils.path import get_ipython_module_path
-from IPython.utils.process import find_cmd, pycmd2argv, FindCmdError
-
-from IPython.parallel.factory import LoggingFactory
-
-from .win32support import forward_read_events
-
-from .winhpcjob import IPControllerTask, IPEngineTask, IPControllerJob, IPEngineSetJob
-
-WINDOWS = os.name == 'nt'
-
-#-----------------------------------------------------------------------------
-# Paths to the kernel apps
-#-----------------------------------------------------------------------------
-
-
-ipcluster_cmd_argv = pycmd2argv(get_ipython_module_path(
-    'IPython.parallel.apps.ipclusterapp'
-))
-
-ipengine_cmd_argv = pycmd2argv(get_ipython_module_path(
-    'IPython.parallel.apps.ipengineapp'
-))
-
-ipcontroller_cmd_argv = pycmd2argv(get_ipython_module_path(
-    'IPython.parallel.apps.ipcontrollerapp'
-))
-
-#-----------------------------------------------------------------------------
-# Base launchers and errors
-#-----------------------------------------------------------------------------
-
-
-class LauncherError(Exception):
-    pass
-
-
-class ProcessStateError(LauncherError):
-    pass
-
-
-class UnknownStatus(LauncherError):
-    pass
-
-
-class BaseLauncher(LoggingFactory):
-    """An asbtraction for starting, stopping and signaling a process."""
-
-    # In all of the launchers, the work_dir is where child processes will be
-    # run. This will usually be the cluster_dir, but may not be. any work_dir
-    # passed into the __init__ method will override the config value.
-    # This should not be used to set the work_dir for the actual engine
-    # and controller. Instead, use their own config files or the
-    # controller_args, engine_args attributes of the launchers to add
-    # the --work-dir option.
-    work_dir = Unicode(u'.')
-    loop = Instance('zmq.eventloop.ioloop.IOLoop')
-    
-    start_data = Any()
-    stop_data = Any()
-    
-    def _loop_default(self):
-        return ioloop.IOLoop.instance()
-
-    def __init__(self, work_dir=u'.', config=None, **kwargs):
-        super(BaseLauncher, self).__init__(work_dir=work_dir, config=config, **kwargs)
-        self.state = 'before' # can be before, running, after
-        self.stop_callbacks = []
-        self.start_data = None
-        self.stop_data = None
-
-    @property
-    def args(self):
-        """A list of cmd and args that will be used to start the process.
-
-        This is what is passed to :func:`spawnProcess` and the first element
-        will be the process name.
-        """
-        return self.find_args()
-
-    def find_args(self):
-        """The ``.args`` property calls this to find the args list.
-
-        Subcommand should implement this to construct the cmd and args.
-        """
-        raise NotImplementedError('find_args must be implemented in a subclass')
-
-    @property
-    def arg_str(self):
-        """The string form of the program arguments."""
-        return ' '.join(self.args)
-
-    @property
-    def running(self):
-        """Am I running."""
-        if self.state == 'running':
-            return True
-        else:
-            return False
-
-    def start(self):
-        """Start the process.
-
-        This must return a deferred that fires with information about the
-        process starting (like a pid, job id, etc.).
-        """
-        raise NotImplementedError('start must be implemented in a subclass')
-
-    def stop(self):
-        """Stop the process and notify observers of stopping.
-
-        This must return a deferred that fires with information about the
-        processing stopping, like errors that occur while the process is
-        attempting to be shut down. This deferred won't fire when the process
-        actually stops. To observe the actual process stopping, see
-        :func:`observe_stop`.
-        """
-        raise NotImplementedError('stop must be implemented in a subclass')
-
-    def on_stop(self, f):
-        """Get a deferred that will fire when the process stops.
-
-        The deferred will fire with data that contains information about
-        the exit status of the process.
-        """
-        if self.state=='after':
-            return f(self.stop_data)
-        else:
-            self.stop_callbacks.append(f)
-
-    def notify_start(self, data):
-        """Call this to trigger startup actions.
-
-        This logs the process startup and sets the state to 'running'.  It is
-        a pass-through so it can be used as a callback.
-        """
-
-        self.log.info('Process %r started: %r' % (self.args[0], data))
-        self.start_data = data
-        self.state = 'running'
-        return data
-
-    def notify_stop(self, data):
-        """Call this to trigger process stop actions.
-
-        This logs the process stopping and sets the state to 'after'. Call
-        this to trigger all the deferreds from :func:`observe_stop`."""
-
-        self.log.info('Process %r stopped: %r' % (self.args[0], data))
-        self.stop_data = data
-        self.state = 'after'
-        for i in range(len(self.stop_callbacks)):
-            d = self.stop_callbacks.pop()
-            d(data)
-        return data
-
-    def signal(self, sig):
-        """Signal the process.
-
-        Return a semi-meaningless deferred after signaling the process.
-
-        Parameters
-        ----------
-        sig : str or int
-            'KILL', 'INT', etc., or any signal number
-        """
-        raise NotImplementedError('signal must be implemented in a subclass')
-
-
-#-----------------------------------------------------------------------------
-# Local process launchers
-#-----------------------------------------------------------------------------
-
-
-class LocalProcessLauncher(BaseLauncher):
-    """Start and stop an external process in an asynchronous manner.
-
-    This will launch the external process with a working directory of
-    ``self.work_dir``.
-    """
-
-    # This is used to to construct self.args, which is passed to 
-    # spawnProcess.
-    cmd_and_args = List([])
-    poll_frequency = Int(100) # in ms
-
-    def __init__(self, work_dir=u'.', config=None, **kwargs):
-        super(LocalProcessLauncher, self).__init__(
-            work_dir=work_dir, config=config, **kwargs
-        )
-        self.process = None
-        self.start_deferred = None
-        self.poller = None
-
-    def find_args(self):
-        return self.cmd_and_args
-
-    def start(self):
-        if self.state == 'before':
-            self.process = Popen(self.args,
-                stdout=PIPE,stderr=PIPE,stdin=PIPE,
-                env=os.environ,
-                cwd=self.work_dir
-            )
-            if WINDOWS:
-                self.stdout = forward_read_events(self.process.stdout)
-                self.stderr = forward_read_events(self.process.stderr)
-            else:
-                self.stdout = self.process.stdout.fileno()
-                self.stderr = self.process.stderr.fileno()
-            self.loop.add_handler(self.stdout, self.handle_stdout, self.loop.READ)
-            self.loop.add_handler(self.stderr, self.handle_stderr, self.loop.READ)
-            self.poller = ioloop.PeriodicCallback(self.poll, self.poll_frequency, self.loop)
-            self.poller.start()
-            self.notify_start(self.process.pid)
-        else:
-            s = 'The process was already started and has state: %r' % self.state
-            raise ProcessStateError(s)
-
-    def stop(self):
-        return self.interrupt_then_kill()
-
-    def signal(self, sig):
-        if self.state == 'running':
-            if WINDOWS and sig != SIGINT:
-                # use Windows tree-kill for better child cleanup
-                check_output(['taskkill', '-pid', str(self.process.pid), '-t', '-f'])
-            else:
-                self.process.send_signal(sig)
-
-    def interrupt_then_kill(self, delay=2.0):
-        """Send INT, wait a delay and then send KILL."""
-        try:
-            self.signal(SIGINT)
-        except Exception:
-            self.log.debug("interrupt failed")
-            pass
-        self.killer  = ioloop.DelayedCallback(lambda : self.signal(SIGKILL), delay*1000, self.loop)
-        self.killer.start()
-
-    # callbacks, etc:
-    
-    def handle_stdout(self, fd, events):
-        if WINDOWS:
-            line = self.stdout.recv()
-        else:
-            line = self.process.stdout.readline()
-        # a stopped process will be readable but return empty strings
-        if line:
-            self.log.info(line[:-1])
-        else:
-            self.poll()
-    
-    def handle_stderr(self, fd, events):
-        if WINDOWS:
-            line = self.stderr.recv()
-        else:
-            line = self.process.stderr.readline()
-        # a stopped process will be readable but return empty strings
-        if line:
-            self.log.error(line[:-1])
-        else:
-            self.poll()
-    
-    def poll(self):
-        status = self.process.poll()
-        if status is not None:
-            self.poller.stop()
-            self.loop.remove_handler(self.stdout)
-            self.loop.remove_handler(self.stderr)
-            self.notify_stop(dict(exit_code=status, pid=self.process.pid))
-        return status
-
-class LocalControllerLauncher(LocalProcessLauncher):
-    """Launch a controller as a regular external process."""
-
-    controller_cmd = List(ipcontroller_cmd_argv, config=True)
-    # Command line arguments to ipcontroller.
-    controller_args = List(['--log-to-file','--log-level', str(logging.INFO)], config=True)
-
-    def find_args(self):
-        return self.controller_cmd + self.controller_args
-
-    def start(self, cluster_dir):
-        """Start the controller by cluster_dir."""
-        self.controller_args.extend(['--cluster-dir', cluster_dir])
-        self.cluster_dir = unicode(cluster_dir)
-        self.log.info("Starting LocalControllerLauncher: %r" % self.args)
-        return super(LocalControllerLauncher, self).start()
-
-
-class LocalEngineLauncher(LocalProcessLauncher):
-    """Launch a single engine as a regular externall process."""
-
-    engine_cmd = List(ipengine_cmd_argv, config=True)
-    # Command line arguments for ipengine.
-    engine_args = List(
-        ['--log-to-file','--log-level', str(logging.INFO)], config=True
-    )
-
-    def find_args(self):
-        return self.engine_cmd + self.engine_args
-
-    def start(self, cluster_dir):
-        """Start the engine by cluster_dir."""
-        self.engine_args.extend(['--cluster-dir', cluster_dir])
-        self.cluster_dir = unicode(cluster_dir)
-        return super(LocalEngineLauncher, self).start()
-
-
-class LocalEngineSetLauncher(BaseLauncher):
-    """Launch a set of engines as regular external processes."""
-
-    # Command line arguments for ipengine.
-    engine_args = List(
-        ['--log-to-file','--log-level', str(logging.INFO)], config=True
-    )
-    # launcher class
-    launcher_class = LocalEngineLauncher
-    
-    launchers = Dict()
-    stop_data = Dict()
-    
-    def __init__(self, work_dir=u'.', config=None, **kwargs):
-        super(LocalEngineSetLauncher, self).__init__(
-            work_dir=work_dir, config=config, **kwargs
-        )
-        self.stop_data = {}
-
-    def start(self, n, cluster_dir):
-        """Start n engines by profile or cluster_dir."""
-        self.cluster_dir = unicode(cluster_dir)
-        dlist = []
-        for i in range(n):
-            el = self.launcher_class(work_dir=self.work_dir, config=self.config, logname=self.log.name)
-            # Copy the engine args over to each engine launcher.
-            el.engine_args = copy.deepcopy(self.engine_args)
-            el.on_stop(self._notice_engine_stopped)
-            d = el.start(cluster_dir)
-            if i==0:
-                self.log.info("Starting LocalEngineSetLauncher: %r" % el.args)
-            self.launchers[i] = el
-            dlist.append(d)
-        self.notify_start(dlist)
-        # The consumeErrors here could be dangerous
-        # dfinal = gatherBoth(dlist, consumeErrors=True)
-        # dfinal.addCallback(self.notify_start)
-        return dlist
-
-    def find_args(self):
-        return ['engine set']
-
-    def signal(self, sig):
-        dlist = []
-        for el in self.launchers.itervalues():
-            d = el.signal(sig)
-            dlist.append(d)
-        # dfinal = gatherBoth(dlist, consumeErrors=True)
-        return dlist
-
-    def interrupt_then_kill(self, delay=1.0):
-        dlist = []
-        for el in self.launchers.itervalues():
-            d = el.interrupt_then_kill(delay)
-            dlist.append(d)
-        # dfinal = gatherBoth(dlist, consumeErrors=True)
-        return dlist
-
-    def stop(self):
-        return self.interrupt_then_kill()
-    
-    def _notice_engine_stopped(self, data):
-        pid = data['pid']
-        for idx,el in self.launchers.iteritems():
-            if el.process.pid == pid:
-                break
-        self.launchers.pop(idx)
-        self.stop_data[idx] = data
-        if not self.launchers:
-            self.notify_stop(self.stop_data)
-
-
-#-----------------------------------------------------------------------------
-# MPIExec launchers
-#-----------------------------------------------------------------------------
-
-
-class MPIExecLauncher(LocalProcessLauncher):
-    """Launch an external process using mpiexec."""
-
-    # The mpiexec command to use in starting the process.
-    mpi_cmd = List(['mpiexec'], config=True)
-    # The command line arguments to pass to mpiexec.
-    mpi_args = List([], config=True)
-    # The program to start using mpiexec.
-    program = List(['date'], config=True)
-    # The command line argument to the program.
-    program_args = List([], config=True)
-    # The number of instances of the program to start.
-    n = Int(1, config=True)
-
-    def find_args(self):
-        """Build self.args using all the fields."""
-        return self.mpi_cmd + ['-n', str(self.n)] + self.mpi_args + \
-               self.program + self.program_args
-
-    def start(self, n):
-        """Start n instances of the program using mpiexec."""
-        self.n = n
-        return super(MPIExecLauncher, self).start()
-
-
-class MPIExecControllerLauncher(MPIExecLauncher):
-    """Launch a controller using mpiexec."""
-
-    controller_cmd = List(ipcontroller_cmd_argv, config=True)
-    # Command line arguments to ipcontroller.
-    controller_args = List(['--log-to-file','--log-level', str(logging.INFO)], config=True)
-    n = Int(1, config=False)
-
-    def start(self, cluster_dir):
-        """Start the controller by cluster_dir."""
-        self.controller_args.extend(['--cluster-dir', cluster_dir])
-        self.cluster_dir = unicode(cluster_dir)
-        self.log.info("Starting MPIExecControllerLauncher: %r" % self.args)
-        return super(MPIExecControllerLauncher, self).start(1)
-
-    def find_args(self):
-        return self.mpi_cmd + ['-n', self.n] + self.mpi_args + \
-               self.controller_cmd + self.controller_args
-
-
-class MPIExecEngineSetLauncher(MPIExecLauncher):
-
-    program = List(ipengine_cmd_argv, config=True)
-    # Command line arguments for ipengine.
-    program_args = List(
-        ['--log-to-file','--log-level', str(logging.INFO)], config=True
-    )
-    n = Int(1, config=True)
-
-    def start(self, n, cluster_dir):
-        """Start n engines by profile or cluster_dir."""
-        self.program_args.extend(['--cluster-dir', cluster_dir])
-        self.cluster_dir = unicode(cluster_dir)
-        self.n = n
-        self.log.info('Starting MPIExecEngineSetLauncher: %r' % self.args)
-        return super(MPIExecEngineSetLauncher, self).start(n)
-
-#-----------------------------------------------------------------------------
-# SSH launchers
-#-----------------------------------------------------------------------------
-
-# TODO: Get SSH Launcher working again.
-
-class SSHLauncher(LocalProcessLauncher):
-    """A minimal launcher for ssh.
-
-    To be useful this will probably have to be extended to use the ``sshx``
-    idea for environment variables.  There could be other things this needs
-    as well.
-    """
-
-    ssh_cmd = List(['ssh'], config=True)
-    ssh_args = List(['-tt'], config=True)
-    program = List(['date'], config=True)
-    program_args = List([], config=True)
-    hostname = CUnicode('', config=True)
-    user = CUnicode('', config=True)
-    location = CUnicode('')
-
-    def _hostname_changed(self, name, old, new):
-        if self.user:
-            self.location = u'%s@%s' % (self.user, new)
-        else:
-            self.location = new
-
-    def _user_changed(self, name, old, new):
-        self.location = u'%s@%s' % (new, self.hostname)
-
-    def find_args(self):
-        return self.ssh_cmd + self.ssh_args + [self.location] + \
-               self.program + self.program_args
-
-    def start(self, cluster_dir, hostname=None, user=None):
-        self.cluster_dir = unicode(cluster_dir)
-        if hostname is not None:
-            self.hostname = hostname
-        if user is not None:
-            self.user = user
-        
-        return super(SSHLauncher, self).start()
-    
-    def signal(self, sig):
-        if self.state == 'running':
-            # send escaped ssh connection-closer
-            self.process.stdin.write('~.')
-            self.process.stdin.flush()
-        
-
-
-class SSHControllerLauncher(SSHLauncher):
-
-    program = List(ipcontroller_cmd_argv, config=True)
-    # Command line arguments to ipcontroller.
-    program_args = List(['-r', '--log-to-file','--log-level', str(logging.INFO)], config=True)
-
-
-class SSHEngineLauncher(SSHLauncher):
-    program = List(ipengine_cmd_argv, config=True)
-    # Command line arguments for ipengine.
-    program_args = List(
-        ['--log-to-file','--log-level', str(logging.INFO)], config=True
-    )
-    
-class SSHEngineSetLauncher(LocalEngineSetLauncher):
-    launcher_class = SSHEngineLauncher
-    engines = Dict(config=True)
-    
-    def start(self, n, cluster_dir):
-        """Start engines by profile or cluster_dir.
-        `n` is ignored, and the `engines` config property is used instead.
-        """
-        
-        self.cluster_dir = unicode(cluster_dir)
-        dlist = []
-        for host, n in self.engines.iteritems():
-            if isinstance(n, (tuple, list)):
-                n, args = n
-            else:
-                args = copy.deepcopy(self.engine_args)
-            
-            if '@' in host:
-                user,host = host.split('@',1)
-            else:
-                user=None
-            for i in range(n):
-                el = self.launcher_class(work_dir=self.work_dir, config=self.config, logname=self.log.name)
-                
-                # Copy the engine args over to each engine launcher.
-                i
-                el.program_args = args
-                el.on_stop(self._notice_engine_stopped)
-                d = el.start(cluster_dir, user=user, hostname=host)
-                if i==0:
-                    self.log.info("Starting SSHEngineSetLauncher: %r" % el.args)
-                self.launchers[host+str(i)] = el
-                dlist.append(d)
-        self.notify_start(dlist)
-        return dlist
-    
-
-
-#-----------------------------------------------------------------------------
-# Windows HPC Server 2008 scheduler launchers
-#-----------------------------------------------------------------------------
-
-
-# This is only used on Windows.
-def find_job_cmd():
-    if WINDOWS:
-        try:
-            return find_cmd('job')
-        except (FindCmdError, ImportError):
-            # ImportError will be raised if win32api is not installed
-            return 'job'
-    else:
-        return 'job'
-
-
-class WindowsHPCLauncher(BaseLauncher):
-
-    # A regular expression used to get the job id from the output of the 
-    # submit_command.
-    job_id_regexp = Str(r'\d+', config=True)
-    # The filename of the instantiated job script.
-    job_file_name = CUnicode(u'ipython_job.xml', config=True)
-    # The full path to the instantiated job script. This gets made dynamically
-    # by combining the work_dir with the job_file_name.
-    job_file = CUnicode(u'')
-    # The hostname of the scheduler to submit the job to
-    scheduler = CUnicode('', config=True)
-    job_cmd = CUnicode(find_job_cmd(), config=True)
-
-    def __init__(self, work_dir=u'.', config=None, **kwargs):
-        super(WindowsHPCLauncher, self).__init__(
-            work_dir=work_dir, config=config, **kwargs
-        )
-
-    @property
-    def job_file(self):
-        return os.path.join(self.work_dir, self.job_file_name)
-
-    def write_job_file(self, n):
-        raise NotImplementedError("Implement write_job_file in a subclass.")
-
-    def find_args(self):
-        return [u'job.exe']
-        
-    def parse_job_id(self, output):
-        """Take the output of the submit command and return the job id."""
-        m = re.search(self.job_id_regexp, output)
-        if m is not None:
-            job_id = m.group()
-        else:
-            raise LauncherError("Job id couldn't be determined: %s" % output)
-        self.job_id = job_id
-        self.log.info('Job started with job id: %r' % job_id)
-        return job_id
-
-    def start(self, n):
-        """Start n copies of the process using the Win HPC job scheduler."""
-        self.write_job_file(n)
-        args = [
-            'submit',
-            '/jobfile:%s' % self.job_file,
-            '/scheduler:%s' % self.scheduler
-        ]
-        self.log.info("Starting Win HPC Job: %s" % (self.job_cmd + ' ' + ' '.join(args),))
-        # Twisted will raise DeprecationWarnings if we try to pass unicode to this
-        output = check_output([self.job_cmd]+args,
-            env=os.environ,
-            cwd=self.work_dir,
-            stderr=STDOUT
-        )
-        job_id = self.parse_job_id(output)
-        self.notify_start(job_id)
-        return job_id
-
-    def stop(self):
-        args = [
-            'cancel',
-            self.job_id,
-            '/scheduler:%s' % self.scheduler
-        ]
-        self.log.info("Stopping Win HPC Job: %s" % (self.job_cmd + ' ' + ' '.join(args),))
-        try:
-            output = check_output([self.job_cmd]+args,
-                env=os.environ,
-                cwd=self.work_dir,
-                stderr=STDOUT
-            )
-        except:
-            output = 'The job already appears to be stoppped: %r' % self.job_id
-        self.notify_stop(dict(job_id=self.job_id, output=output))  # Pass the output of the kill cmd
-        return output
-
-
-class WindowsHPCControllerLauncher(WindowsHPCLauncher):
-
-    job_file_name = CUnicode(u'ipcontroller_job.xml', config=True)
-    extra_args = List([], config=False)
-
-    def write_job_file(self, n):
-        job = IPControllerJob(config=self.config)
-
-        t = IPControllerTask(config=self.config)
-        # The tasks work directory is *not* the actual work directory of 
-        # the controller. It is used as the base path for the stdout/stderr
-        # files that the scheduler redirects to.
-        t.work_directory = self.cluster_dir
-        # Add the --cluster-dir and from self.start().
-        t.controller_args.extend(self.extra_args)
-        job.add_task(t)
-
-        self.log.info("Writing job description file: %s" % self.job_file)
-        job.write(self.job_file)
-
-    @property
-    def job_file(self):
-        return os.path.join(self.cluster_dir, self.job_file_name)
-
-    def start(self, cluster_dir):
-        """Start the controller by cluster_dir."""
-        self.extra_args = ['--cluster-dir', cluster_dir]
-        self.cluster_dir = unicode(cluster_dir)
-        return super(WindowsHPCControllerLauncher, self).start(1)
-
-
-class WindowsHPCEngineSetLauncher(WindowsHPCLauncher):
-
-    job_file_name = CUnicode(u'ipengineset_job.xml', config=True)
-    extra_args = List([], config=False)
-
-    def write_job_file(self, n):
-        job = IPEngineSetJob(config=self.config)
-
-        for i in range(n):
-            t = IPEngineTask(config=self.config)
-            # The tasks work directory is *not* the actual work directory of 
-            # the engine. It is used as the base path for the stdout/stderr
-            # files that the scheduler redirects to.
-            t.work_directory = self.cluster_dir
-            # Add the --cluster-dir and from self.start().
-            t.engine_args.extend(self.extra_args)
-            job.add_task(t)
-
-        self.log.info("Writing job description file: %s" % self.job_file)
-        job.write(self.job_file)
-
-    @property
-    def job_file(self):
-        return os.path.join(self.cluster_dir, self.job_file_name)
-
-    def start(self, n, cluster_dir):
-        """Start the controller by cluster_dir."""
-        self.extra_args = ['--cluster-dir', cluster_dir]
-        self.cluster_dir = unicode(cluster_dir)
-        return super(WindowsHPCEngineSetLauncher, self).start(n)
-
-
-#-----------------------------------------------------------------------------
-# Batch (PBS) system launchers
-#-----------------------------------------------------------------------------
-
-class BatchSystemLauncher(BaseLauncher):
-    """Launch an external process using a batch system.
-
-    This class is designed to work with UNIX batch systems like PBS, LSF,
-    GridEngine, etc.  The overall model is that there are different commands
-    like qsub, qdel, etc. that handle the starting and stopping of the process.
-
-    This class also has the notion of a batch script. The ``batch_template``
-    attribute can be set to a string that is a template for the batch script.
-    This template is instantiated using Itpl. Thus the template can use
-    ${n} fot the number of instances. Subclasses can add additional variables
-    to the template dict.
-    """
-
-    # Subclasses must fill these in.  See PBSEngineSet
-    # The name of the command line program used to submit jobs.
-    submit_command = List([''], config=True)
-    # The name of the command line program used to delete jobs.
-    delete_command = List([''], config=True)
-    # A regular expression used to get the job id from the output of the 
-    # submit_command.
-    job_id_regexp = CUnicode('', config=True)
-    # The string that is the batch script template itself.
-    batch_template = CUnicode('', config=True)
-    # The file that contains the batch template
-    batch_template_file = CUnicode(u'', config=True)
-    # The filename of the instantiated batch script.
-    batch_file_name = CUnicode(u'batch_script', config=True)
-    # The PBS Queue
-    queue = CUnicode(u'', config=True)
-    
-    # not configurable, override in subclasses
-    # PBS Job Array regex
-    job_array_regexp = CUnicode('')
-    job_array_template = CUnicode('')
-    # PBS Queue regex
-    queue_regexp = CUnicode('')
-    queue_template = CUnicode('')
-    # The default batch template, override in subclasses
-    default_template = CUnicode('')
-    # The full path to the instantiated batch script.
-    batch_file = CUnicode(u'')
-    # the format dict used with batch_template:
-    context = Dict()
-
-    
-    def find_args(self):
-        return self.submit_command + [self.batch_file]
-    
-    def __init__(self, work_dir=u'.', config=None, **kwargs):
-        super(BatchSystemLauncher, self).__init__(
-            work_dir=work_dir, config=config, **kwargs
-        )
-        self.batch_file = os.path.join(self.work_dir, self.batch_file_name)
-
-    def parse_job_id(self, output):
-        """Take the output of the submit command and return the job id."""
-        m = re.search(self.job_id_regexp, output)
-        if m is not None:
-            job_id = m.group()
-        else:
-            raise LauncherError("Job id couldn't be determined: %s" % output)
-        self.job_id = job_id
-        self.log.info('Job submitted with job id: %r' % job_id)
-        return job_id
-
-    def write_batch_script(self, n):
-        """Instantiate and write the batch script to the work_dir."""
-        self.context['n'] = n
-        self.context['queue'] = self.queue
-        print self.context
-        # first priority is batch_template if set
-        if self.batch_template_file and not self.batch_template:
-            # second priority is batch_template_file
-            with open(self.batch_template_file) as f:
-                self.batch_template = f.read()
-        if not self.batch_template:
-            # third (last) priority is default_template
-            self.batch_template = self.default_template
-        
-        regex = re.compile(self.job_array_regexp)
-        # print regex.search(self.batch_template)
-        if not regex.search(self.batch_template):
-            self.log.info("adding job array settings to batch script")
-            firstline, rest = self.batch_template.split('\n',1)
-            self.batch_template = u'\n'.join([firstline, self.job_array_template, rest])
-        
-        regex = re.compile(self.queue_regexp)
-        # print regex.search(self.batch_template)
-        if self.queue and not regex.search(self.batch_template):
-            self.log.info("adding PBS queue settings to batch script")
-            firstline, rest = self.batch_template.split('\n',1)
-            self.batch_template = u'\n'.join([firstline, self.queue_template, rest])
-            
-        script_as_string = Itpl.itplns(self.batch_template, self.context)
-        self.log.info('Writing instantiated batch script: %s' % self.batch_file)
-    
-        with open(self.batch_file, 'w') as f:
-            f.write(script_as_string)
-        os.chmod(self.batch_file, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
-
-    def start(self, n, cluster_dir):
-        """Start n copies of the process using a batch system."""
-        # Here we save profile and cluster_dir in the context so they
-        # can be used in the batch script template as ${profile} and
-        # ${cluster_dir}
-        self.context['cluster_dir'] = cluster_dir
-        self.cluster_dir = unicode(cluster_dir)
-        self.write_batch_script(n)
-        output = check_output(self.args, env=os.environ)
-        
-        job_id = self.parse_job_id(output)
-        self.notify_start(job_id)
-        return job_id
-
-    def stop(self):
-        output = check_output(self.delete_command+[self.job_id], env=os.environ)
-        self.notify_stop(dict(job_id=self.job_id, output=output)) # Pass the output of the kill cmd
-        return output
-
-
-class PBSLauncher(BatchSystemLauncher):
-    """A BatchSystemLauncher subclass for PBS."""
-
-    submit_command = List(['qsub'], config=True)
-    delete_command = List(['qdel'], config=True)
-    job_id_regexp = CUnicode(r'\d+', config=True)
-    
-    batch_file = CUnicode(u'')
-    job_array_regexp = CUnicode('#PBS\W+-t\W+[\w\d\-\$]+')
-    job_array_template = CUnicode('#PBS -t 1-$n')
-    queue_regexp = CUnicode('#PBS\W+-q\W+\$?\w+')
-    queue_template = CUnicode('#PBS -q $queue')
-
-
-class PBSControllerLauncher(PBSLauncher):
-    """Launch a controller using PBS."""
-
-    batch_file_name = CUnicode(u'pbs_controller', config=True)
-    default_template= CUnicode("""#!/bin/sh
-#PBS -V
-#PBS -N ipcontroller
-%s --log-to-file --cluster-dir $cluster_dir
-"""%(' '.join(ipcontroller_cmd_argv)))
-
-    def start(self, cluster_dir):
-        """Start the controller by profile or cluster_dir."""
-        self.log.info("Starting PBSControllerLauncher: %r" % self.args)
-        return super(PBSControllerLauncher, self).start(1, cluster_dir)
-
-
-class PBSEngineSetLauncher(PBSLauncher):
-    """Launch Engines using PBS"""
-    batch_file_name = CUnicode(u'pbs_engines', config=True)
-    default_template= CUnicode(u"""#!/bin/sh
-#PBS -V
-#PBS -N ipengine
-%s --cluster-dir $cluster_dir
-"""%(' '.join(ipengine_cmd_argv)))
-
-    def start(self, n, cluster_dir):
-        """Start n engines by profile or cluster_dir."""
-        self.log.info('Starting %i engines with PBSEngineSetLauncher: %r' % (n, self.args))
-        return super(PBSEngineSetLauncher, self).start(n, cluster_dir)
-
-#SGE is very similar to PBS
-
-class SGELauncher(PBSLauncher):
-    """Sun GridEngine is a PBS clone with slightly different syntax"""
-    job_array_regexp = CUnicode('#$$\W+-t\W+[\w\d\-\$]+')
-    job_array_template = CUnicode('#$$ -t 1-$n')
-    queue_regexp = CUnicode('#$$\W+-q\W+\$?\w+')
-    queue_template = CUnicode('#$$ -q $queue')
-
-class SGEControllerLauncher(SGELauncher):
-    """Launch a controller using SGE."""
-
-    batch_file_name = CUnicode(u'sge_controller', config=True)
-    default_template= CUnicode(u"""#$$ -V
-#$$ -S /bin/sh
-#$$ -N ipcontroller
-%s --log-to-file --cluster-dir $cluster_dir
-"""%(' '.join(ipcontroller_cmd_argv)))
-
-    def start(self, cluster_dir):
-        """Start the controller by profile or cluster_dir."""
-        self.log.info("Starting PBSControllerLauncher: %r" % self.args)
-        return super(PBSControllerLauncher, self).start(1, cluster_dir)
-
-class SGEEngineSetLauncher(SGELauncher):
-    """Launch Engines with SGE"""
-    batch_file_name = CUnicode(u'sge_engines', config=True)
-    default_template = CUnicode("""#$$ -V
-#$$ -S /bin/sh
-#$$ -N ipengine
-%s --cluster-dir $cluster_dir
-"""%(' '.join(ipengine_cmd_argv)))
-
-    def start(self, n, cluster_dir):
-        """Start n engines by profile or cluster_dir."""
-        self.log.info('Starting %i engines with SGEEngineSetLauncher: %r' % (n, self.args))
-        return super(SGEEngineSetLauncher, self).start(n, cluster_dir)
-
-
-#-----------------------------------------------------------------------------
-# A launcher for ipcluster itself!
-#-----------------------------------------------------------------------------
-
-
-class IPClusterLauncher(LocalProcessLauncher):
-    """Launch the ipcluster program in an external process."""
-
-    ipcluster_cmd = List(ipcluster_cmd_argv, config=True)
-    # Command line arguments to pass to ipcluster.
-    ipcluster_args = List(
-        ['--clean-logs', '--log-to-file', '--log-level', str(logging.INFO)], config=True)
-    ipcluster_subcommand = Str('start')
-    ipcluster_n = Int(2)
-
-    def find_args(self):
-        return self.ipcluster_cmd + [self.ipcluster_subcommand] + \
-            ['-n', repr(self.ipcluster_n)] + self.ipcluster_args
-
-    def start(self):
-        self.log.info("Starting ipcluster: %r" % self.args)
-        return super(IPClusterLauncher, self).start()
-
diff --git a/IPython/parallel/apps/logwatcher.py b/IPython/parallel/apps/logwatcher.py
deleted file mode 100644
index adf4355e533..00000000000
--- a/IPython/parallel/apps/logwatcher.py
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env python
-"""A simple logger object that consolidates messages incoming from ipcluster processes."""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-import logging
-import sys
-
-import zmq
-from zmq.eventloop import ioloop, zmqstream
-
-from IPython.utils.traitlets import Int, Str, Instance, List
-
-from IPython.parallel.factory import LoggingFactory
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-
-class LogWatcher(LoggingFactory):
-    """A simple class that receives messages on a SUB socket, as published
-    by subclasses of `zmq.log.handlers.PUBHandler`, and logs them itself.
-    
-    This can subscribe to multiple topics, but defaults to all topics.
-    """
-    # configurables
-    topics = List([''], config=True)
-    url = Str('tcp://127.0.0.1:20202', config=True)
-    
-    # internals
-    context = Instance(zmq.Context, (), {})
-    stream = Instance('zmq.eventloop.zmqstream.ZMQStream')
-    loop = Instance('zmq.eventloop.ioloop.IOLoop')
-    def _loop_default(self):
-        return ioloop.IOLoop.instance()
-    
-    def __init__(self, **kwargs):
-        super(LogWatcher, self).__init__(**kwargs)
-        s = self.context.socket(zmq.SUB)
-        s.bind(self.url)
-        self.stream = zmqstream.ZMQStream(s, self.loop)
-        self.subscribe()
-        self.on_trait_change(self.subscribe, 'topics')
-    
-    def start(self):
-        self.stream.on_recv(self.log_message)
-    
-    def stop(self):
-        self.stream.stop_on_recv()
-    
-    def subscribe(self):
-        """Update our SUB socket's subscriptions."""
-        self.stream.setsockopt(zmq.UNSUBSCRIBE, '')
-        for topic in self.topics:
-            self.log.debug("Subscribing to: %r"%topic)
-            self.stream.setsockopt(zmq.SUBSCRIBE, topic)
-    
-    def _extract_level(self, topic_str):
-        """Turn 'engine.0.INFO.extra' into (logging.INFO, 'engine.0.extra')"""
-        topics = topic_str.split('.')
-        for idx,t in enumerate(topics):
-            level = getattr(logging, t, None)
-            if level is not None:
-                break
-        
-        if level is None:
-            level = logging.INFO
-        else:
-            topics.pop(idx)
-        
-        return level, '.'.join(topics)
-            
-            
-    def log_message(self, raw):
-        """receive and parse a message, then log it."""
-        if len(raw) != 2 or '.' not in raw[0]:
-            self.log.error("Invalid log message: %s"%raw)
-            return
-        else:
-            topic, msg = raw
-            # don't newline, since log messages always newline:
-            topic,level_name = topic.rsplit('.',1)
-            level,topic = self._extract_level(topic)
-            if msg[-1] == '\n':
-                msg = msg[:-1]
-            logging.log(level, "[%s] %s" % (topic, msg))
-
diff --git a/IPython/parallel/apps/win32support.py b/IPython/parallel/apps/win32support.py
deleted file mode 100644
index 9d97225d309..00000000000
--- a/IPython/parallel/apps/win32support.py
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/usr/bin/env python
-"""Utility for forwarding file read events over a zmq socket.
-
-This is necessary because select on Windows only supports"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import uuid
-import zmq
-
-from threading import Thread
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-class ForwarderThread(Thread):
-    def __init__(self, sock, fd):
-        Thread.__init__(self)
-        self.daemon=True
-        self.sock = sock
-        self.fd = fd
-
-    def run(self):
-        """loop through lines in self.fd, and send them over self.sock"""
-        line = self.fd.readline()
-        # allow for files opened in unicode mode
-        if isinstance(line, unicode):
-            send = self.sock.send_unicode
-        else:
-            send = self.sock.send
-        while line:
-            send(line)
-            line = self.fd.readline()
-        # line == '' means EOF
-        self.fd.close()
-        self.sock.close()
-
-def forward_read_events(fd, context=None):
-    """forward read events from an FD over a socket.
-
-    This method wraps a file in a socket pair, so it can
-    be polled for read events by select (specifically zmq.eventloop.ioloop)
-    """
-    if context is None:
-        context = zmq.Context.instance()
-    push = context.socket(zmq.PUSH)
-    push.setsockopt(zmq.LINGER, -1)
-    pull = context.socket(zmq.PULL)
-    addr='inproc://%s'%uuid.uuid4()
-    push.bind(addr)
-    pull.connect(addr)
-    forwarder = ForwarderThread(push, fd)
-    forwarder.start()
-    return pull
-
-
-__all__ = ['forward_read_events']
\ No newline at end of file
diff --git a/IPython/parallel/apps/winhpcjob.py b/IPython/parallel/apps/winhpcjob.py
deleted file mode 100644
index 492df584909..00000000000
--- a/IPython/parallel/apps/winhpcjob.py
+++ /dev/null
@@ -1,314 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Job and task components for writing .xml files that the Windows HPC Server 
-2008 can use to start jobs.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import re
-import uuid
-
-from xml.etree import ElementTree as ET
-
-from IPython.config.configurable import Configurable
-from IPython.utils.traitlets import (
-    Str, Int, List, Instance,
-    Enum, Bool, CStr
-)
-
-#-----------------------------------------------------------------------------
-# Job and Task classes
-#-----------------------------------------------------------------------------
-
-
-def as_str(value):
-    if isinstance(value, str):
-        return value
-    elif isinstance(value, bool):
-        if value:
-            return 'true'
-        else:
-            return 'false'
-    elif isinstance(value, (int, float)):
-        return repr(value)
-    else:
-        return value
-
-
-def indent(elem, level=0):
-    i = "\n" + level*"  "
-    if len(elem):
-        if not elem.text or not elem.text.strip():
-            elem.text = i + "  "
-        if not elem.tail or not elem.tail.strip():
-            elem.tail = i
-        for elem in elem:
-            indent(elem, level+1)
-        if not elem.tail or not elem.tail.strip():
-            elem.tail = i
-    else:
-        if level and (not elem.tail or not elem.tail.strip()):
-            elem.tail = i
-
-
-def find_username():
-    domain = os.environ.get('USERDOMAIN')
-    username = os.environ.get('USERNAME','')
-    if domain is None:
-        return username
-    else:
-        return '%s\\%s' % (domain, username)
-
-
-class WinHPCJob(Configurable):
-
-    job_id = Str('')
-    job_name = Str('MyJob', config=True)
-    min_cores = Int(1, config=True)
-    max_cores = Int(1, config=True)
-    min_sockets = Int(1, config=True)
-    max_sockets = Int(1, config=True)
-    min_nodes = Int(1, config=True)
-    max_nodes = Int(1, config=True)
-    unit_type = Str("Core", config=True)
-    auto_calculate_min = Bool(True, config=True)
-    auto_calculate_max = Bool(True, config=True)
-    run_until_canceled = Bool(False, config=True)
-    is_exclusive = Bool(False, config=True)
-    username = Str(find_username(), config=True)
-    job_type = Str('Batch', config=True)
-    priority = Enum(('Lowest','BelowNormal','Normal','AboveNormal','Highest'),
-        default_value='Highest', config=True)
-    requested_nodes = Str('', config=True)
-    project = Str('IPython', config=True)
-    xmlns = Str('http://schemas.microsoft.com/HPCS2008/scheduler/')
-    version = Str("2.000")
-    tasks = List([])
-
-    @property
-    def owner(self):
-        return self.username
-
-    def _write_attr(self, root, attr, key):
-        s = as_str(getattr(self, attr, ''))
-        if s:
-            root.set(key, s)
-
-    def as_element(self):
-        # We have to add _A_ type things to get the right order than
-        # the MSFT XML parser expects.
-        root = ET.Element('Job')
-        self._write_attr(root, 'version', '_A_Version')
-        self._write_attr(root, 'job_name', '_B_Name')
-        self._write_attr(root, 'unit_type', '_C_UnitType')
-        self._write_attr(root, 'min_cores', '_D_MinCores')
-        self._write_attr(root, 'max_cores', '_E_MaxCores')
-        self._write_attr(root, 'min_sockets', '_F_MinSockets')
-        self._write_attr(root, 'max_sockets', '_G_MaxSockets')
-        self._write_attr(root, 'min_nodes', '_H_MinNodes')
-        self._write_attr(root, 'max_nodes', '_I_MaxNodes')
-        self._write_attr(root, 'run_until_canceled', '_J_RunUntilCanceled')
-        self._write_attr(root, 'is_exclusive', '_K_IsExclusive')
-        self._write_attr(root, 'username', '_L_UserName')
-        self._write_attr(root, 'job_type', '_M_JobType')
-        self._write_attr(root, 'priority', '_N_Priority')
-        self._write_attr(root, 'requested_nodes', '_O_RequestedNodes')
-        self._write_attr(root, 'auto_calculate_max', '_P_AutoCalculateMax')
-        self._write_attr(root, 'auto_calculate_min', '_Q_AutoCalculateMin')
-        self._write_attr(root, 'project', '_R_Project')
-        self._write_attr(root, 'owner', '_S_Owner')
-        self._write_attr(root, 'xmlns', '_T_xmlns')
-        dependencies = ET.SubElement(root, "Dependencies")
-        etasks = ET.SubElement(root, "Tasks")
-        for t in self.tasks:
-            etasks.append(t.as_element())
-        return root
-
-    def tostring(self):
-        """Return the string representation of the job description XML."""
-        root = self.as_element()
-        indent(root)
-        txt = ET.tostring(root, encoding="utf-8")
-        # Now remove the tokens used to order the attributes.
-        txt = re.sub(r'_[A-Z]_','',txt)
-        txt = '<?xml version="1.0" encoding="utf-8"?>\n' + txt
-        return txt
-
-    def write(self, filename):
-        """Write the XML job description to a file."""
-        txt = self.tostring()
-        with open(filename, 'w') as f:
-            f.write(txt)
-
-    def add_task(self, task):
-        """Add a task to the job.
-
-        Parameters
-        ----------
-        task : :class:`WinHPCTask`
-            The task object to add.
-        """
-        self.tasks.append(task)
-
-
-class WinHPCTask(Configurable):
-
-    task_id = Str('')
-    task_name = Str('')
-    version = Str("2.000")
-    min_cores = Int(1, config=True)
-    max_cores = Int(1, config=True)
-    min_sockets = Int(1, config=True)
-    max_sockets = Int(1, config=True)
-    min_nodes = Int(1, config=True)
-    max_nodes = Int(1, config=True)
-    unit_type = Str("Core", config=True)
-    command_line = CStr('', config=True)
-    work_directory = CStr('', config=True)
-    is_rerunnaable = Bool(True, config=True)
-    std_out_file_path = CStr('', config=True)
-    std_err_file_path = CStr('', config=True)
-    is_parametric = Bool(False, config=True)
-    environment_variables = Instance(dict, args=(), config=True)
-
-    def _write_attr(self, root, attr, key):
-        s = as_str(getattr(self, attr, ''))
-        if s:
-            root.set(key, s)
-
-    def as_element(self):
-        root = ET.Element('Task')
-        self._write_attr(root, 'version', '_A_Version')
-        self._write_attr(root, 'task_name', '_B_Name')
-        self._write_attr(root, 'min_cores', '_C_MinCores')
-        self._write_attr(root, 'max_cores', '_D_MaxCores')
-        self._write_attr(root, 'min_sockets', '_E_MinSockets')
-        self._write_attr(root, 'max_sockets', '_F_MaxSockets')
-        self._write_attr(root, 'min_nodes', '_G_MinNodes')
-        self._write_attr(root, 'max_nodes', '_H_MaxNodes')
-        self._write_attr(root, 'command_line', '_I_CommandLine')
-        self._write_attr(root, 'work_directory', '_J_WorkDirectory')
-        self._write_attr(root, 'is_rerunnaable', '_K_IsRerunnable')
-        self._write_attr(root, 'std_out_file_path', '_L_StdOutFilePath')
-        self._write_attr(root, 'std_err_file_path', '_M_StdErrFilePath')
-        self._write_attr(root, 'is_parametric', '_N_IsParametric')
-        self._write_attr(root, 'unit_type', '_O_UnitType')
-        root.append(self.get_env_vars())
-        return root
-
-    def get_env_vars(self):
-        env_vars = ET.Element('EnvironmentVariables')
-        for k, v in self.environment_variables.iteritems():
-            variable = ET.SubElement(env_vars, "Variable")
-            name = ET.SubElement(variable, "Name")
-            name.text = k
-            value = ET.SubElement(variable, "Value")
-            value.text = v
-        return env_vars
-
-
-
-# By declaring these, we can configure the controller and engine separately!
-
-class IPControllerJob(WinHPCJob):
-    job_name = Str('IPController', config=False)
-    is_exclusive = Bool(False, config=True)
-    username = Str(find_username(), config=True)
-    priority = Enum(('Lowest','BelowNormal','Normal','AboveNormal','Highest'),
-        default_value='Highest', config=True)
-    requested_nodes = Str('', config=True)
-    project = Str('IPython', config=True)
-
-
-class IPEngineSetJob(WinHPCJob):
-    job_name = Str('IPEngineSet', config=False)
-    is_exclusive = Bool(False, config=True)
-    username = Str(find_username(), config=True)
-    priority = Enum(('Lowest','BelowNormal','Normal','AboveNormal','Highest'),
-        default_value='Highest', config=True)
-    requested_nodes = Str('', config=True)
-    project = Str('IPython', config=True)
-
-
-class IPControllerTask(WinHPCTask):
-
-    task_name = Str('IPController', config=True)
-    controller_cmd = List(['ipcontroller.exe'], config=True)
-    controller_args = List(['--log-to-file', '--log-level', '40'], config=True)
-    # I don't want these to be configurable
-    std_out_file_path = CStr('', config=False)
-    std_err_file_path = CStr('', config=False)
-    min_cores = Int(1, config=False)
-    max_cores = Int(1, config=False)
-    min_sockets = Int(1, config=False)
-    max_sockets = Int(1, config=False)
-    min_nodes = Int(1, config=False)
-    max_nodes = Int(1, config=False)
-    unit_type = Str("Core", config=False)
-    work_directory = CStr('', config=False)
-
-    def __init__(self, config=None):
-        super(IPControllerTask, self).__init__(config=config)
-        the_uuid = uuid.uuid1()
-        self.std_out_file_path = os.path.join('log','ipcontroller-%s.out' % the_uuid)
-        self.std_err_file_path = os.path.join('log','ipcontroller-%s.err' % the_uuid)
-
-    @property
-    def command_line(self):
-        return ' '.join(self.controller_cmd + self.controller_args)
-
-
-class IPEngineTask(WinHPCTask):
-
-    task_name = Str('IPEngine', config=True)
-    engine_cmd = List(['ipengine.exe'], config=True)
-    engine_args = List(['--log-to-file', '--log-level', '40'], config=True)
-    # I don't want these to be configurable
-    std_out_file_path = CStr('', config=False)
-    std_err_file_path = CStr('', config=False)
-    min_cores = Int(1, config=False)
-    max_cores = Int(1, config=False)
-    min_sockets = Int(1, config=False)
-    max_sockets = Int(1, config=False)
-    min_nodes = Int(1, config=False)
-    max_nodes = Int(1, config=False)
-    unit_type = Str("Core", config=False)
-    work_directory = CStr('', config=False)
-
-    def __init__(self, config=None):
-        super(IPEngineTask,self).__init__(config=config)
-        the_uuid = uuid.uuid1()
-        self.std_out_file_path = os.path.join('log','ipengine-%s.out' % the_uuid)
-        self.std_err_file_path = os.path.join('log','ipengine-%s.err' % the_uuid)
-    
-    @property
-    def command_line(self):
-        return ' '.join(self.engine_cmd + self.engine_args)
-
-
-# j = WinHPCJob(None)
-# j.job_name = 'IPCluster'
-# j.username = 'GNET\\bgranger'
-# j.requested_nodes = 'GREEN'
-# 
-# t = WinHPCTask(None)
-# t.task_name = 'Controller'
-# t.command_line = r"\\blue\domainusers$\bgranger\Python\Python25\Scripts\ipcontroller.exe --log-to-file -p default --log-level 10"
-# t.work_directory = r"\\blue\domainusers$\bgranger\.ipython\cluster_default"
-# t.std_out_file_path = 'controller-out.txt'
-# t.std_err_file_path = 'controller-err.txt'
-# t.environment_variables['PYTHONPATH'] = r"\\blue\domainusers$\bgranger\Python\Python25\Lib\site-packages"
-# j.add_task(t)
-
diff --git a/IPython/parallel/client/__init__.py b/IPython/parallel/client/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/parallel/client/asyncresult.py b/IPython/parallel/client/asyncresult.py
deleted file mode 100644
index ab87c5597ed..00000000000
--- a/IPython/parallel/client/asyncresult.py
+++ /dev/null
@@ -1,340 +0,0 @@
-"""AsyncResult objects for the client"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import time
-
-from zmq import MessageTracker
-
-from IPython.external.decorator import decorator
-from IPython.parallel import error
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-# global empty tracker that's always done:
-finished_tracker = MessageTracker()
-
-@decorator
-def check_ready(f, self, *args, **kwargs):
-    """Call spin() to sync state prior to calling the method."""
-    self.wait(0)
-    if not self._ready:
-        raise error.TimeoutError("result not ready")
-    return f(self, *args, **kwargs)
-
-class AsyncResult(object):
-    """Class for representing results of non-blocking calls.
-    
-    Provides the same interface as :py:class:`multiprocessing.pool.AsyncResult`.
-    """
-    
-    msg_ids = None
-    _targets = None
-    _tracker = None
-    _single_result = False
-    
-    def __init__(self, client, msg_ids, fname='unknown', targets=None, tracker=None):
-        if isinstance(msg_ids, basestring):
-            # always a list
-            msg_ids = [msg_ids]
-        if tracker is None:
-            # default to always done
-            tracker = finished_tracker
-        self._client = client
-        self.msg_ids = msg_ids
-        self._fname=fname
-        self._targets = targets
-        self._tracker = tracker
-        self._ready = False
-        self._success = None
-        if len(msg_ids) == 1:
-            self._single_result = not isinstance(targets, (list, tuple))
-        else:
-            self._single_result = False
-    
-    def __repr__(self):
-        if self._ready:
-            return "<%s: finished>"%(self.__class__.__name__)
-        else:
-            return "<%s: %s>"%(self.__class__.__name__,self._fname)
-    
-    
-    def _reconstruct_result(self, res):
-        """Reconstruct our result from actual result list (always a list)
-        
-        Override me in subclasses for turning a list of results
-        into the expected form.
-        """
-        if self._single_result:
-            return res[0]
-        else:
-            return res
-        
-    def get(self, timeout=-1):
-        """Return the result when it arrives. 
-        
-        If `timeout` is not ``None`` and the result does not arrive within
-        `timeout` seconds then ``TimeoutError`` is raised. If the
-        remote call raised an exception then that exception will be reraised
-        by get() inside a `RemoteError`.
-        """
-        if not self.ready():
-            self.wait(timeout)
-        
-        if self._ready:
-            if self._success:
-                return self._result
-            else:
-                raise self._exception
-        else:
-            raise error.TimeoutError("Result not ready.")
-    
-    def ready(self):
-        """Return whether the call has completed."""
-        if not self._ready:
-            self.wait(0)
-        return self._ready
-    
-    def wait(self, timeout=-1):
-        """Wait until the result is available or until `timeout` seconds pass.
-        
-        This method always returns None.
-        """
-        if self._ready:
-            return
-        self._ready = self._client.wait(self.msg_ids, timeout)
-        if self._ready:
-            try:
-                results = map(self._client.results.get, self.msg_ids)
-                self._result = results
-                if self._single_result:
-                    r = results[0]
-                    if isinstance(r, Exception):
-                        raise r
-                else:
-                    results = error.collect_exceptions(results, self._fname)
-                self._result = self._reconstruct_result(results)
-            except Exception, e:
-                self._exception = e
-                self._success = False
-            else:
-                self._success = True
-            finally:
-                self._metadata = map(self._client.metadata.get, self.msg_ids)
-            
-    
-    def successful(self):
-        """Return whether the call completed without raising an exception. 
-        
-        Will raise ``AssertionError`` if the result is not ready.
-        """
-        assert self.ready()
-        return self._success
-    
-    #----------------------------------------------------------------
-    # Extra methods not in mp.pool.AsyncResult
-    #----------------------------------------------------------------
-    
-    def get_dict(self, timeout=-1):
-        """Get the results as a dict, keyed by engine_id.
-        
-        timeout behavior is described in `get()`.
-        """
-        
-        results = self.get(timeout)
-        engine_ids = [ md['engine_id'] for md in self._metadata ]
-        bycount = sorted(engine_ids, key=lambda k: engine_ids.count(k))
-        maxcount = bycount.count(bycount[-1])
-        if maxcount > 1:
-            raise ValueError("Cannot build dict, %i jobs ran on engine #%i"%(
-                    maxcount, bycount[-1]))
-        
-        return dict(zip(engine_ids,results))
-    
-    @property
-    def result(self):
-        """result property wrapper for `get(timeout=0)`."""
-        return self.get()
-    
-    # abbreviated alias:
-    r = result
-    
-    @property
-    @check_ready
-    def metadata(self):
-        """property for accessing execution metadata."""
-        if self._single_result:
-            return self._metadata[0]
-        else:
-            return self._metadata
-    
-    @property
-    def result_dict(self):
-        """result property as a dict."""
-        return self.get_dict()
-    
-    def __dict__(self):
-        return self.get_dict(0)
-    
-    def abort(self):
-        """abort my tasks."""
-        assert not self.ready(), "Can't abort, I am already done!"
-        return self.client.abort(self.msg_ids, targets=self._targets, block=True)
-
-    @property
-    def sent(self):
-        """check whether my messages have been sent."""
-        return self._tracker.done
-    
-    def wait_for_send(self, timeout=-1):
-        """wait for pyzmq send to complete.
-        
-        This is necessary when sending arrays that you intend to edit in-place.
-        `timeout` is in seconds, and will raise TimeoutError if it is reached
-        before the send completes.
-        """
-        return self._tracker.wait(timeout)
-
-    #-------------------------------------
-    # dict-access
-    #-------------------------------------
-    
-    @check_ready
-    def __getitem__(self, key):
-        """getitem returns result value(s) if keyed by int/slice, or metadata if key is str.
-        """
-        if isinstance(key, int):
-            return error.collect_exceptions([self._result[key]], self._fname)[0]
-        elif isinstance(key, slice):
-            return error.collect_exceptions(self._result[key], self._fname)
-        elif isinstance(key, basestring):
-            values = [ md[key] for md in self._metadata ]
-            if self._single_result:
-                return values[0]
-            else:
-                return values
-        else:
-            raise TypeError("Invalid key type %r, must be 'int','slice', or 'str'"%type(key))
-    
-    @check_ready
-    def __getattr__(self, key):
-        """getattr maps to getitem for convenient attr access to metadata."""
-        if key not in self._metadata[0].keys():
-            raise AttributeError("%r object has no attribute %r"%(
-                    self.__class__.__name__, key))
-        return self.__getitem__(key)
-    
-    # asynchronous iterator:
-    def __iter__(self):
-        if self._single_result:
-            raise TypeError("AsyncResults with a single result are not iterable.")
-        try:
-            rlist = self.get(0)
-        except error.TimeoutError:
-            # wait for each result individually
-            for msg_id in self.msg_ids:
-                ar = AsyncResult(self._client, msg_id, self._fname)
-                yield ar.get()
-        else:
-            # already done
-            for r in rlist:
-                yield r
-
-
-    
-class AsyncMapResult(AsyncResult):
-    """Class for representing results of non-blocking gathers.
-    
-    This will properly reconstruct the gather.
-    """
-    
-    def __init__(self, client, msg_ids, mapObject, fname=''):
-        AsyncResult.__init__(self, client, msg_ids, fname=fname)
-        self._mapObject = mapObject
-        self._single_result = False
-    
-    def _reconstruct_result(self, res):
-        """Perform the gather on the actual results."""
-        return self._mapObject.joinPartitions(res)
-    
-    # asynchronous iterator:
-    def __iter__(self):
-        try:
-            rlist = self.get(0)
-        except error.TimeoutError:
-            # wait for each result individually
-            for msg_id in self.msg_ids:
-                ar = AsyncResult(self._client, msg_id, self._fname)
-                rlist = ar.get()
-                try:
-                    for r in rlist:
-                        yield r
-                except TypeError:
-                    # flattened, not a list
-                    # this could get broken by flattened data that returns iterables
-                    # but most calls to map do not expose the `flatten` argument
-                    yield rlist
-        else:
-            # already done
-            for r in rlist:
-                yield r
-
-
-class AsyncHubResult(AsyncResult):
-    """Class to wrap pending results that must be requested from the Hub.
-    
-    Note that waiting/polling on these objects requires polling the Hubover the network,
-    so use `AsyncHubResult.wait()` sparingly.
-    """
-    
-    def wait(self, timeout=-1):
-        """wait for result to complete."""
-        start = time.time()
-        if self._ready:
-            return
-        local_ids = filter(lambda msg_id: msg_id in self._client.outstanding, self.msg_ids)
-        local_ready = self._client.wait(local_ids, timeout)
-        if local_ready:
-            remote_ids = filter(lambda msg_id: msg_id not in self._client.results, self.msg_ids)
-            if not remote_ids:
-                self._ready = True
-            else:
-                rdict = self._client.result_status(remote_ids, status_only=False)
-                pending = rdict['pending']
-                while pending and (timeout < 0 or time.time() < start+timeout):
-                    rdict = self._client.result_status(remote_ids, status_only=False)
-                    pending = rdict['pending']
-                    if pending:
-                        time.sleep(0.1)
-                if not pending:
-                    self._ready = True
-        if self._ready:
-            try:
-                results = map(self._client.results.get, self.msg_ids)
-                self._result = results
-                if self._single_result:
-                    r = results[0]
-                    if isinstance(r, Exception):
-                        raise r
-                else:
-                    results = error.collect_exceptions(results, self._fname)
-                self._result = self._reconstruct_result(results)
-            except Exception, e:
-                self._exception = e
-                self._success = False
-            else:
-                self._success = True
-            finally:
-                self._metadata = map(self._client.metadata.get, self.msg_ids)
-        
-__all__ = ['AsyncResult', 'AsyncMapResult', 'AsyncHubResult']
\ No newline at end of file
diff --git a/IPython/parallel/client/client.py b/IPython/parallel/client/client.py
deleted file mode 100644
index de810a2ebfa..00000000000
--- a/IPython/parallel/client/client.py
+++ /dev/null
@@ -1,1292 +0,0 @@
-"""A semi-synchronous Client for the ZMQ cluster"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import json
-import time
-import warnings
-from datetime import datetime
-from getpass import getpass
-from pprint import pprint
-
-pjoin = os.path.join
-
-import zmq
-# from zmq.eventloop import ioloop, zmqstream
-
-from IPython.utils.path import get_ipython_dir
-from IPython.utils.traitlets import (HasTraits, Int, Instance, CUnicode, 
-                                    Dict, List, Bool, Str, Set)
-from IPython.external.decorator import decorator
-from IPython.external.ssh import tunnel
-
-from IPython.parallel import error
-from IPython.parallel import streamsession as ss
-from IPython.parallel import util
-
-from .asyncresult import AsyncResult, AsyncHubResult
-from IPython.parallel.apps.clusterdir import ClusterDir, ClusterDirError
-from .view import DirectView, LoadBalancedView
-
-#--------------------------------------------------------------------------
-# Decorators for Client methods
-#--------------------------------------------------------------------------
-
-@decorator
-def spin_first(f, self, *args, **kwargs):
-    """Call spin() to sync state prior to calling the method."""
-    self.spin()
-    return f(self, *args, **kwargs)
-
-
-#--------------------------------------------------------------------------
-# Classes
-#--------------------------------------------------------------------------
-
-class Metadata(dict):
-    """Subclass of dict for initializing metadata values.
-    
-    Attribute access works on keys.
-    
-    These objects have a strict set of keys - errors will raise if you try
-    to add new keys.
-    """
-    def __init__(self, *args, **kwargs):
-        dict.__init__(self)
-        md = {'msg_id' : None,
-              'submitted' : None,
-              'started' : None,
-              'completed' : None,
-              'received' : None,
-              'engine_uuid' : None,
-              'engine_id' : None,
-              'follow' : None,
-              'after' : None,
-              'status' : None,
-
-              'pyin' : None,
-              'pyout' : None,
-              'pyerr' : None,
-              'stdout' : '',
-              'stderr' : '',
-            }
-        self.update(md)
-        self.update(dict(*args, **kwargs))
-    
-    def __getattr__(self, key):
-        """getattr aliased to getitem"""
-        if key in self.iterkeys():
-            return self[key]
-        else:
-            raise AttributeError(key)
-
-    def __setattr__(self, key, value):
-        """setattr aliased to setitem, with strict"""
-        if key in self.iterkeys():
-            self[key] = value
-        else:
-            raise AttributeError(key)
-    
-    def __setitem__(self, key, value):
-        """strict static key enforcement"""
-        if key in self.iterkeys():
-            dict.__setitem__(self, key, value)
-        else:
-            raise KeyError(key)
-        
-
-class Client(HasTraits):
-    """A semi-synchronous client to the IPython ZMQ cluster
-    
-    Parameters
-    ----------
-    
-    url_or_file : bytes; zmq url or path to ipcontroller-client.json
-        Connection information for the Hub's registration.  If a json connector
-        file is given, then likely no further configuration is necessary.
-        [Default: use profile]
-    profile : bytes
-        The name of the Cluster profile to be used to find connector information.
-        [Default: 'default']
-    context : zmq.Context
-        Pass an existing zmq.Context instance, otherwise the client will create its own.
-    username : bytes
-        set username to be passed to the Session object
-    debug : bool
-        flag for lots of message printing for debug purposes
- 
-    #-------------- ssh related args ----------------
-    # These are args for configuring the ssh tunnel to be used
-    # credentials are used to forward connections over ssh to the Controller
-    # Note that the ip given in `addr` needs to be relative to sshserver
-    # The most basic case is to leave addr as pointing to localhost (127.0.0.1),
-    # and set sshserver as the same machine the Controller is on. However, 
-    # the only requirement is that sshserver is able to see the Controller
-    # (i.e. is within the same trusted network).
-    
-    sshserver : str
-        A string of the form passed to ssh, i.e. 'server.tld' or 'user@server.tld:port'
-        If keyfile or password is specified, and this is not, it will default to
-        the ip given in addr.
-    sshkey : str; path to public ssh key file
-        This specifies a key to be used in ssh login, default None.
-        Regular default ssh keys will be used without specifying this argument.
-    password : str 
-        Your ssh password to sshserver. Note that if this is left None,
-        you will be prompted for it if passwordless key based login is unavailable.
-    paramiko : bool
-        flag for whether to use paramiko instead of shell ssh for tunneling.
-        [default: True on win32, False else]
-    
-    ------- exec authentication args -------
-    If even localhost is untrusted, you can have some protection against
-    unauthorized execution by using a key.  Messages are still sent
-    as cleartext, so if someone can snoop your loopback traffic this will
-    not help against malicious attacks.
-    
-    exec_key : str
-        an authentication key or file containing a key
-        default: None
-    
-    
-    Attributes
-    ----------
-    
-    ids : list of int engine IDs
-        requesting the ids attribute always synchronizes
-        the registration state. To request ids without synchronization,
-        use semi-private _ids attributes.
-    
-    history : list of msg_ids
-        a list of msg_ids, keeping track of all the execution
-        messages you have submitted in order.
-    
-    outstanding : set of msg_ids
-        a set of msg_ids that have been submitted, but whose
-        results have not yet been received.
-    
-    results : dict
-        a dict of all our results, keyed by msg_id
-    
-    block : bool
-        determines default behavior when block not specified
-        in execution methods
-    
-    Methods
-    -------
-    
-    spin
-        flushes incoming results and registration state changes
-        control methods spin, and requesting `ids` also ensures up to date
-    
-    wait
-        wait on one or more msg_ids
-    
-    execution methods
-        apply
-        legacy: execute, run
-    
-    data movement
-        push, pull, scatter, gather
-    
-    query methods
-        queue_status, get_result, purge, result_status
-    
-    control methods
-        abort, shutdown
-    
-    """
-    
-    
-    block = Bool(False)
-    outstanding = Set()
-    results = Instance('collections.defaultdict', (dict,))
-    metadata = Instance('collections.defaultdict', (Metadata,))
-    history = List()
-    debug = Bool(False)
-    profile=CUnicode('default')
-    
-    _outstanding_dict = Instance('collections.defaultdict', (set,))
-    _ids = List()
-    _connected=Bool(False)
-    _ssh=Bool(False)
-    _context = Instance('zmq.Context')
-    _config = Dict()
-    _engines=Instance(util.ReverseDict, (), {})
-    # _hub_socket=Instance('zmq.Socket')
-    _query_socket=Instance('zmq.Socket')
-    _control_socket=Instance('zmq.Socket')
-    _iopub_socket=Instance('zmq.Socket')
-    _notification_socket=Instance('zmq.Socket')
-    _mux_socket=Instance('zmq.Socket')
-    _task_socket=Instance('zmq.Socket')
-    _task_scheme=Str()
-    _closed = False
-    _ignored_control_replies=Int(0)
-    _ignored_hub_replies=Int(0)
-    
-    def __init__(self, url_or_file=None, profile='default', cluster_dir=None, ipython_dir=None,
-            context=None, username=None, debug=False, exec_key=None,
-            sshserver=None, sshkey=None, password=None, paramiko=None,
-            timeout=10
-            ):
-        super(Client, self).__init__(debug=debug, profile=profile)
-        if context is None:
-            context = zmq.Context.instance()
-        self._context = context
-            
-        
-        self._setup_cluster_dir(profile, cluster_dir, ipython_dir)
-        if self._cd is not None:
-            if url_or_file is None:
-                url_or_file = pjoin(self._cd.security_dir, 'ipcontroller-client.json')
-        assert url_or_file is not None, "I can't find enough information to connect to a hub!"\
-            " Please specify at least one of url_or_file or profile."
-        
-        try:
-            util.validate_url(url_or_file)
-        except AssertionError:
-            if not os.path.exists(url_or_file):
-                if self._cd:
-                    url_or_file = os.path.join(self._cd.security_dir, url_or_file)
-                assert os.path.exists(url_or_file), "Not a valid connection file or url: %r"%url_or_file
-            with open(url_or_file) as f:
-                cfg = json.loads(f.read())
-        else:
-            cfg = {'url':url_or_file}
-        
-        # sync defaults from args, json:
-        if sshserver:
-            cfg['ssh'] = sshserver
-        if exec_key:
-            cfg['exec_key'] = exec_key
-        exec_key = cfg['exec_key']
-        sshserver=cfg['ssh']
-        url = cfg['url']
-        location = cfg.setdefault('location', None)
-        cfg['url'] = util.disambiguate_url(cfg['url'], location)
-        url = cfg['url']
-        
-        self._config = cfg
-        
-        self._ssh = bool(sshserver or sshkey or password)
-        if self._ssh and sshserver is None:
-            # default to ssh via localhost
-            sshserver = url.split('://')[1].split(':')[0]
-        if self._ssh and password is None:
-            if tunnel.try_passwordless_ssh(sshserver, sshkey, paramiko):
-                password=False
-            else:
-                password = getpass("SSH Password for %s: "%sshserver)
-        ssh_kwargs = dict(keyfile=sshkey, password=password, paramiko=paramiko)
-        if exec_key is not None and os.path.isfile(exec_key):
-            arg = 'keyfile'
-        else:
-            arg = 'key'
-        key_arg = {arg:exec_key}
-        if username is None:
-            self.session = ss.StreamSession(**key_arg)
-        else:
-            self.session = ss.StreamSession(username, **key_arg)
-        self._query_socket = self._context.socket(zmq.XREQ)
-        self._query_socket.setsockopt(zmq.IDENTITY, self.session.session)
-        if self._ssh:
-            tunnel.tunnel_connection(self._query_socket, url, sshserver, **ssh_kwargs)
-        else:
-            self._query_socket.connect(url)
-        
-        self.session.debug = self.debug
-        
-        self._notification_handlers = {'registration_notification' : self._register_engine,
-                                    'unregistration_notification' : self._unregister_engine,
-                                    'shutdown_notification' : lambda msg: self.close(),
-                                    }
-        self._queue_handlers = {'execute_reply' : self._handle_execute_reply,
-                                'apply_reply' : self._handle_apply_reply}
-        self._connect(sshserver, ssh_kwargs, timeout)
-        
-    def __del__(self):
-        """cleanup sockets, but _not_ context."""
-        self.close()
-    
-    def _setup_cluster_dir(self, profile, cluster_dir, ipython_dir):
-        if ipython_dir is None:
-            ipython_dir = get_ipython_dir()
-        if cluster_dir is not None:
-            try:
-                self._cd = ClusterDir.find_cluster_dir(cluster_dir)
-                return
-            except ClusterDirError:
-                pass
-        elif profile is not None:
-            try:
-                self._cd = ClusterDir.find_cluster_dir_by_profile(
-                    ipython_dir, profile)
-                return
-            except ClusterDirError:
-                pass
-        self._cd = None
-    
-    def _update_engines(self, engines):
-        """Update our engines dict and _ids from a dict of the form: {id:uuid}."""
-        for k,v in engines.iteritems():
-            eid = int(k)
-            self._engines[eid] = bytes(v) # force not unicode
-            self._ids.append(eid)
-        self._ids = sorted(self._ids)
-        if sorted(self._engines.keys()) != range(len(self._engines)) and \
-                        self._task_scheme == 'pure' and self._task_socket:
-            self._stop_scheduling_tasks()
-    
-    def _stop_scheduling_tasks(self):
-        """Stop scheduling tasks because an engine has been unregistered
-        from a pure ZMQ scheduler.
-        """
-        self._task_socket.close()
-        self._task_socket = None
-        msg = "An engine has been unregistered, and we are using pure " +\
-              "ZMQ task scheduling.  Task farming will be disabled."
-        if self.outstanding:
-            msg += " If you were running tasks when this happened, " +\
-                   "some `outstanding` msg_ids may never resolve."
-        warnings.warn(msg, RuntimeWarning)
-    
-    def _build_targets(self, targets):
-        """Turn valid target IDs or 'all' into two lists:
-        (int_ids, uuids).
-        """
-        if not self._ids:
-            # flush notification socket if no engines yet, just in case
-            if not self.ids:
-                raise error.NoEnginesRegistered("Can't build targets without any engines")
-        
-        if targets is None:
-            targets = self._ids
-        elif isinstance(targets, str):
-            if targets.lower() == 'all':
-                targets = self._ids
-            else:
-                raise TypeError("%r not valid str target, must be 'all'"%(targets))
-        elif isinstance(targets, int):
-            if targets < 0:
-                targets = self.ids[targets]
-            if targets not in self._ids:
-                raise IndexError("No such engine: %i"%targets)
-            targets = [targets]
-        
-        if isinstance(targets, slice):
-            indices = range(len(self._ids))[targets]
-            ids = self.ids
-            targets = [ ids[i] for i in indices ]
-        
-        if not isinstance(targets, (tuple, list, xrange)):
-            raise TypeError("targets by int/slice/collection of ints only, not %s"%(type(targets)))
-            
-        return [self._engines[t] for t in targets], list(targets)
-    
-    def _connect(self, sshserver, ssh_kwargs, timeout):
-        """setup all our socket connections to the cluster. This is called from
-        __init__."""
-        
-        # Maybe allow reconnecting?
-        if self._connected:
-            return
-        self._connected=True
-
-        def connect_socket(s, url):
-            url = util.disambiguate_url(url, self._config['location'])
-            if self._ssh:
-                return tunnel.tunnel_connection(s, url, sshserver, **ssh_kwargs)
-            else:
-                return s.connect(url)
-            
-        self.session.send(self._query_socket, 'connection_request')
-        r,w,x = zmq.select([self._query_socket],[],[], timeout)
-        if not r:
-            raise error.TimeoutError("Hub connection request timed out")
-        idents,msg = self.session.recv(self._query_socket,mode=0)
-        if self.debug:
-            pprint(msg)
-        msg = ss.Message(msg)
-        content = msg.content
-        self._config['registration'] = dict(content)
-        if content.status == 'ok':
-            if content.mux:
-                self._mux_socket = self._context.socket(zmq.XREQ)
-                self._mux_socket.setsockopt(zmq.IDENTITY, self.session.session)
-                connect_socket(self._mux_socket, content.mux)
-            if content.task:
-                self._task_scheme, task_addr = content.task
-                self._task_socket = self._context.socket(zmq.XREQ)
-                self._task_socket.setsockopt(zmq.IDENTITY, self.session.session)
-                connect_socket(self._task_socket, task_addr)
-            if content.notification:
-                self._notification_socket = self._context.socket(zmq.SUB)
-                connect_socket(self._notification_socket, content.notification)
-                self._notification_socket.setsockopt(zmq.SUBSCRIBE, b'')
-            # if content.query:
-            #     self._query_socket = self._context.socket(zmq.XREQ)
-            #     self._query_socket.setsockopt(zmq.IDENTITY, self.session.session)
-            #     connect_socket(self._query_socket, content.query)
-            if content.control:
-                self._control_socket = self._context.socket(zmq.XREQ)
-                self._control_socket.setsockopt(zmq.IDENTITY, self.session.session)
-                connect_socket(self._control_socket, content.control)
-            if content.iopub:
-                self._iopub_socket = self._context.socket(zmq.SUB)
-                self._iopub_socket.setsockopt(zmq.SUBSCRIBE, b'')
-                self._iopub_socket.setsockopt(zmq.IDENTITY, self.session.session)
-                connect_socket(self._iopub_socket, content.iopub)
-            self._update_engines(dict(content.engines))
-        else:
-            self._connected = False
-            raise Exception("Failed to connect!")
-    
-    #--------------------------------------------------------------------------
-    # handlers and callbacks for incoming messages
-    #--------------------------------------------------------------------------
-    
-    def _unwrap_exception(self, content):
-        """unwrap exception, and remap engine_id to int."""
-        e = error.unwrap_exception(content)
-        # print e.traceback
-        if e.engine_info:
-            e_uuid = e.engine_info['engine_uuid']
-            eid = self._engines[e_uuid]
-            e.engine_info['engine_id'] = eid
-        return e
-    
-    def _extract_metadata(self, header, parent, content):
-        md = {'msg_id' : parent['msg_id'],
-              'received' : datetime.now(),
-              'engine_uuid' : header.get('engine', None),
-              'follow' : parent.get('follow', []),
-              'after' : parent.get('after', []),
-              'status' : content['status'],
-            }
-        
-        if md['engine_uuid'] is not None:
-            md['engine_id'] = self._engines.get(md['engine_uuid'], None)
-        
-        if 'date' in parent:
-            md['submitted'] = datetime.strptime(parent['date'], util.ISO8601)
-        if 'started' in header:
-            md['started'] = datetime.strptime(header['started'], util.ISO8601)
-        if 'date' in header:
-            md['completed'] = datetime.strptime(header['date'], util.ISO8601)
-        return md
-    
-    def _register_engine(self, msg):
-        """Register a new engine, and update our connection info."""
-        content = msg['content']
-        eid = content['id']
-        d = {eid : content['queue']}
-        self._update_engines(d)
-
-    def _unregister_engine(self, msg):
-        """Unregister an engine that has died."""
-        content = msg['content']
-        eid = int(content['id'])
-        if eid in self._ids:
-            self._ids.remove(eid)
-            uuid = self._engines.pop(eid)
-            
-            self._handle_stranded_msgs(eid, uuid)
-                
-        if self._task_socket and self._task_scheme == 'pure':
-            self._stop_scheduling_tasks()
-    
-    def _handle_stranded_msgs(self, eid, uuid):
-        """Handle messages known to be on an engine when the engine unregisters.
-        
-        It is possible that this will fire prematurely - that is, an engine will
-        go down after completing a result, and the client will be notified
-        of the unregistration and later receive the successful result.
-        """
-        
-        outstanding = self._outstanding_dict[uuid]
-        
-        for msg_id in list(outstanding):
-            if msg_id in self.results:
-                # we already 
-                continue
-            try:
-                raise error.EngineError("Engine %r died while running task %r"%(eid, msg_id))
-            except:
-                content = error.wrap_exception()
-            # build a fake message:
-            parent = {}
-            header = {}
-            parent['msg_id'] = msg_id
-            header['engine'] = uuid
-            header['date'] = datetime.now().strftime(util.ISO8601)
-            msg = dict(parent_header=parent, header=header, content=content)
-            self._handle_apply_reply(msg)
-    
-    def _handle_execute_reply(self, msg):
-        """Save the reply to an execute_request into our results.
-        
-        execute messages are never actually used. apply is used instead.
-        """
-        
-        parent = msg['parent_header']
-        msg_id = parent['msg_id']
-        if msg_id not in self.outstanding:
-            if msg_id in self.history:
-                print ("got stale result: %s"%msg_id)
-            else:
-                print ("got unknown result: %s"%msg_id)
-        else:
-            self.outstanding.remove(msg_id)
-        self.results[msg_id] = self._unwrap_exception(msg['content'])
-    
-    def _handle_apply_reply(self, msg):
-        """Save the reply to an apply_request into our results."""
-        parent = msg['parent_header']
-        msg_id = parent['msg_id']
-        if msg_id not in self.outstanding:
-            if msg_id in self.history:
-                print ("got stale result: %s"%msg_id)
-                print self.results[msg_id]
-                print msg
-            else:
-                print ("got unknown result: %s"%msg_id)
-        else:
-            self.outstanding.remove(msg_id)
-        content = msg['content']
-        header = msg['header']
-        
-        # construct metadata:
-        md = self.metadata[msg_id]
-        md.update(self._extract_metadata(header, parent, content))
-        # is this redundant?
-        self.metadata[msg_id] = md
-        
-        e_outstanding = self._outstanding_dict[md['engine_uuid']]
-        if msg_id in e_outstanding:
-            e_outstanding.remove(msg_id)
-        
-        # construct result:
-        if content['status'] == 'ok':
-            self.results[msg_id] = util.unserialize_object(msg['buffers'])[0]
-        elif content['status'] == 'aborted':
-            self.results[msg_id] = error.TaskAborted(msg_id)
-        elif content['status'] == 'resubmitted':
-            # TODO: handle resubmission
-            pass
-        else:
-            self.results[msg_id] = self._unwrap_exception(content)
-    
-    def _flush_notifications(self):
-        """Flush notifications of engine registrations waiting
-        in ZMQ queue."""
-        msg = self.session.recv(self._notification_socket, mode=zmq.NOBLOCK)
-        while msg is not None:
-            if self.debug:
-                pprint(msg)
-            msg = msg[-1]
-            msg_type = msg['msg_type']
-            handler = self._notification_handlers.get(msg_type, None)
-            if handler is None:
-                raise Exception("Unhandled message type: %s"%msg.msg_type)
-            else:
-                handler(msg)
-            msg = self.session.recv(self._notification_socket, mode=zmq.NOBLOCK)
-    
-    def _flush_results(self, sock):
-        """Flush task or queue results waiting in ZMQ queue."""
-        msg = self.session.recv(sock, mode=zmq.NOBLOCK)
-        while msg is not None:
-            if self.debug:
-                pprint(msg)
-            msg = msg[-1]
-            msg_type = msg['msg_type']
-            handler = self._queue_handlers.get(msg_type, None)
-            if handler is None:
-                raise Exception("Unhandled message type: %s"%msg.msg_type)
-            else:
-                handler(msg)
-            msg = self.session.recv(sock, mode=zmq.NOBLOCK)
-    
-    def _flush_control(self, sock):
-        """Flush replies from the control channel waiting
-        in the ZMQ queue.
-        
-        Currently: ignore them."""
-        if self._ignored_control_replies <= 0:
-            return
-        msg = self.session.recv(sock, mode=zmq.NOBLOCK)
-        while msg is not None:
-            self._ignored_control_replies -= 1
-            if self.debug:
-                pprint(msg)
-            msg = self.session.recv(sock, mode=zmq.NOBLOCK)
-    
-    def _flush_ignored_control(self):
-        """flush ignored control replies"""
-        while self._ignored_control_replies > 0:
-            self.session.recv(self._control_socket)
-            self._ignored_control_replies -= 1
-    
-    def _flush_ignored_hub_replies(self):
-        msg = self.session.recv(self._query_socket, mode=zmq.NOBLOCK)
-        while msg is not None:
-            msg = self.session.recv(self._query_socket, mode=zmq.NOBLOCK)
-    
-    def _flush_iopub(self, sock):
-        """Flush replies from the iopub channel waiting
-        in the ZMQ queue.
-        """
-        msg = self.session.recv(sock, mode=zmq.NOBLOCK)
-        while msg is not None:
-            if self.debug:
-                pprint(msg)
-            msg = msg[-1]
-            parent = msg['parent_header']
-            msg_id = parent['msg_id']
-            content = msg['content']
-            header = msg['header']
-            msg_type = msg['msg_type']
-            
-            # init metadata:
-            md = self.metadata[msg_id]
-            
-            if msg_type == 'stream':
-                name = content['name']
-                s = md[name] or ''
-                md[name] = s + content['data']
-            elif msg_type == 'pyerr':
-                md.update({'pyerr' : self._unwrap_exception(content)})
-            elif msg_type == 'pyin':
-                md.update({'pyin' : content['code']})
-            else:
-                md.update({msg_type : content.get('data', '')})
-            
-            # reduntant?
-            self.metadata[msg_id] = md
-            
-            msg = self.session.recv(sock, mode=zmq.NOBLOCK)
-    
-    #--------------------------------------------------------------------------
-    # len, getitem
-    #--------------------------------------------------------------------------
-    
-    def __len__(self):
-        """len(client) returns # of engines."""
-        return len(self.ids)
-    
-    def __getitem__(self, key):
-        """index access returns DirectView multiplexer objects
-        
-        Must be int, slice, or list/tuple/xrange of ints"""
-        if not isinstance(key, (int, slice, tuple, list, xrange)):
-            raise TypeError("key by int/slice/iterable of ints only, not %s"%(type(key)))
-        else:
-            return self.direct_view(key)
-    
-    #--------------------------------------------------------------------------
-    # Begin public methods
-    #--------------------------------------------------------------------------
-    
-    @property
-    def ids(self):
-        """Always up-to-date ids property."""
-        self._flush_notifications()
-        # always copy:
-        return list(self._ids)
-        
-    def close(self):
-        if self._closed:
-            return
-        snames = filter(lambda n: n.endswith('socket'), dir(self))
-        for socket in map(lambda name: getattr(self, name), snames):
-            if isinstance(socket, zmq.Socket) and not socket.closed:
-                socket.close()
-        self._closed = True
-    
-    def spin(self):
-        """Flush any registration notifications and execution results
-        waiting in the ZMQ queue.
-        """
-        if self._notification_socket:
-            self._flush_notifications()
-        if self._mux_socket:
-            self._flush_results(self._mux_socket)
-        if self._task_socket:
-            self._flush_results(self._task_socket)
-        if self._control_socket:
-            self._flush_control(self._control_socket)
-        if self._iopub_socket:
-            self._flush_iopub(self._iopub_socket)
-        if self._query_socket:
-            self._flush_ignored_hub_replies()
-    
-    def wait(self, jobs=None, timeout=-1):
-        """waits on one or more `jobs`, for up to `timeout` seconds.
-        
-        Parameters
-        ----------
-        
-        jobs : int, str, or list of ints and/or strs, or one or more AsyncResult objects
-                ints are indices to self.history
-                strs are msg_ids
-                default: wait on all outstanding messages
-        timeout : float
-                a time in seconds, after which to give up.
-                default is -1, which means no timeout
-        
-        Returns
-        -------
-        
-        True : when all msg_ids are done
-        False : timeout reached, some msg_ids still outstanding
-        """
-        tic = time.time()
-        if jobs is None:
-            theids = self.outstanding
-        else:
-            if isinstance(jobs, (int, str, AsyncResult)):
-                jobs = [jobs]
-            theids = set()
-            for job in jobs:
-                if isinstance(job, int):
-                    # index access
-                    job = self.history[job]
-                elif isinstance(job, AsyncResult):
-                    map(theids.add, job.msg_ids)
-                    continue
-                theids.add(job)
-        if not theids.intersection(self.outstanding):
-            return True
-        self.spin()
-        while theids.intersection(self.outstanding):
-            if timeout >= 0 and ( time.time()-tic ) > timeout:
-                break
-            time.sleep(1e-3)
-            self.spin()
-        return len(theids.intersection(self.outstanding)) == 0
-    
-    #--------------------------------------------------------------------------
-    # Control methods
-    #--------------------------------------------------------------------------
-    
-    @spin_first
-    def clear(self, targets=None, block=None):
-        """Clear the namespace in target(s)."""
-        block = self.block if block is None else block
-        targets = self._build_targets(targets)[0]
-        for t in targets:
-            self.session.send(self._control_socket, 'clear_request', content={}, ident=t)
-        error = False
-        if block:
-            self._flush_ignored_control()
-            for i in range(len(targets)):
-                idents,msg = self.session.recv(self._control_socket,0)
-                if self.debug:
-                    pprint(msg)
-                if msg['content']['status'] != 'ok':
-                    error = self._unwrap_exception(msg['content'])
-        else:
-            self._ignored_control_replies += len(targets)
-        if error:
-            raise error
-        
-    
-    @spin_first
-    def abort(self, jobs=None, targets=None, block=None):
-        """Abort specific jobs from the execution queues of target(s).
-        
-        This is a mechanism to prevent jobs that have already been submitted
-        from executing.
-        
-        Parameters
-        ----------
-        
-        jobs : msg_id, list of msg_ids, or AsyncResult
-            The jobs to be aborted
-        
-        
-        """
-        block = self.block if block is None else block
-        targets = self._build_targets(targets)[0]
-        msg_ids = []
-        if isinstance(jobs, (basestring,AsyncResult)):
-            jobs = [jobs]
-        bad_ids = filter(lambda obj: not isinstance(obj, (basestring, AsyncResult)), jobs)
-        if bad_ids:
-            raise TypeError("Invalid msg_id type %r, expected str or AsyncResult"%bad_ids[0])
-        for j in jobs:
-            if isinstance(j, AsyncResult):
-                msg_ids.extend(j.msg_ids)
-            else:
-                msg_ids.append(j)
-        content = dict(msg_ids=msg_ids)
-        for t in targets:
-            self.session.send(self._control_socket, 'abort_request', 
-                    content=content, ident=t)
-        error = False
-        if block:
-            self._flush_ignored_control()
-            for i in range(len(targets)):
-                idents,msg = self.session.recv(self._control_socket,0)
-                if self.debug:
-                    pprint(msg)
-                if msg['content']['status'] != 'ok':
-                    error = self._unwrap_exception(msg['content'])
-        else:
-            self._ignored_control_replies += len(targets)
-        if error:
-            raise error
-    
-    @spin_first
-    def shutdown(self, targets=None, restart=False, hub=False, block=None):
-        """Terminates one or more engine processes, optionally including the hub."""
-        block = self.block if block is None else block
-        if hub:
-            targets = 'all'
-        targets = self._build_targets(targets)[0]
-        for t in targets:
-            self.session.send(self._control_socket, 'shutdown_request', 
-                        content={'restart':restart},ident=t)
-        error = False
-        if block or hub:
-            self._flush_ignored_control()
-            for i in range(len(targets)):
-                idents,msg = self.session.recv(self._control_socket, 0)
-                if self.debug:
-                    pprint(msg)
-                if msg['content']['status'] != 'ok':
-                    error = self._unwrap_exception(msg['content'])
-        else:
-            self._ignored_control_replies += len(targets)
-        
-        if hub:
-            time.sleep(0.25)
-            self.session.send(self._query_socket, 'shutdown_request')
-            idents,msg = self.session.recv(self._query_socket, 0)
-            if self.debug:
-                pprint(msg)
-            if msg['content']['status'] != 'ok':
-                error = self._unwrap_exception(msg['content'])
-        
-        if error:
-            raise error
-    
-    #--------------------------------------------------------------------------
-    # Execution related methods
-    #--------------------------------------------------------------------------
-    
-    def _maybe_raise(self, result):
-        """wrapper for maybe raising an exception if apply failed."""
-        if isinstance(result, error.RemoteError):
-            raise result
-        
-        return result
-    
-    def send_apply_message(self, socket, f, args=None, kwargs=None, subheader=None, track=False,
-                            ident=None):
-        """construct and send an apply message via a socket.
-        
-        This is the principal method with which all engine execution is performed by views.
-        """
-                            
-        assert not self._closed, "cannot use me anymore, I'm closed!"
-        # defaults:
-        args = args if args is not None else []
-        kwargs = kwargs if kwargs is not None else {}
-        subheader = subheader if subheader is not None else {}
-        
-        # validate arguments
-        if not callable(f):
-            raise TypeError("f must be callable, not %s"%type(f))
-        if not isinstance(args, (tuple, list)):
-            raise TypeError("args must be tuple or list, not %s"%type(args))
-        if not isinstance(kwargs, dict):
-            raise TypeError("kwargs must be dict, not %s"%type(kwargs))
-        if not isinstance(subheader, dict):
-            raise TypeError("subheader must be dict, not %s"%type(subheader))
-        
-        bufs = util.pack_apply_message(f,args,kwargs)
-        
-        msg = self.session.send(socket, "apply_request", buffers=bufs, ident=ident,
-                            subheader=subheader, track=track)
-        
-        msg_id = msg['msg_id']
-        self.outstanding.add(msg_id)
-        if ident:
-            # possibly routed to a specific engine
-            if isinstance(ident, list):
-                ident = ident[-1]
-            if ident in self._engines.values():
-                # save for later, in case of engine death
-                self._outstanding_dict[ident].add(msg_id)
-        self.history.append(msg_id)
-        self.metadata[msg_id]['submitted'] = datetime.now()
-        
-        return msg
-
-    #--------------------------------------------------------------------------
-    # construct a View object
-    #--------------------------------------------------------------------------
-    
-    def load_balanced_view(self, targets=None):
-        """construct a DirectView object.
-        
-        If no arguments are specified, create a LoadBalancedView
-        using all engines.
-        
-        Parameters
-        ----------
-        
-        targets: list,slice,int,etc. [default: use all engines]
-            The subset of engines across which to load-balance
-        """
-        if targets is not None:
-            targets = self._build_targets(targets)[1]
-        return LoadBalancedView(client=self, socket=self._task_socket, targets=targets)
-    
-    def direct_view(self, targets='all'):
-        """construct a DirectView object.
-        
-        If no targets are specified, create a DirectView
-        using all engines.
-        
-        Parameters
-        ----------
-        
-        targets: list,slice,int,etc. [default: use all engines]
-            The engines to use for the View
-        """
-        single = isinstance(targets, int)
-        targets = self._build_targets(targets)[1]
-        if single:
-            targets = targets[0]
-        return DirectView(client=self, socket=self._mux_socket, targets=targets)
-    
-    #--------------------------------------------------------------------------
-    # Query methods
-    #--------------------------------------------------------------------------
-    
-    @spin_first
-    def get_result(self, indices_or_msg_ids=None, block=None):
-        """Retrieve a result by msg_id or history index, wrapped in an AsyncResult object.
-        
-        If the client already has the results, no request to the Hub will be made.
-        
-        This is a convenient way to construct AsyncResult objects, which are wrappers
-        that include metadata about execution, and allow for awaiting results that
-        were not submitted by this Client.
-        
-        It can also be a convenient way to retrieve the metadata associated with
-        blocking execution, since it always retrieves
-        
-        Examples
-        --------
-        ::
-        
-            In [10]: r = client.apply()
-        
-        Parameters
-        ----------
-        
-        indices_or_msg_ids : integer history index, str msg_id, or list of either
-            The indices or msg_ids of indices to be retrieved
-        
-        block : bool
-            Whether to wait for the result to be done
-        
-        Returns
-        -------
-        
-        AsyncResult
-            A single AsyncResult object will always be returned.
-        
-        AsyncHubResult
-            A subclass of AsyncResult that retrieves results from the Hub
-        
-        """
-        block = self.block if block is None else block
-        if indices_or_msg_ids is None:
-            indices_or_msg_ids = -1
-        
-        if not isinstance(indices_or_msg_ids, (list,tuple)):
-            indices_or_msg_ids = [indices_or_msg_ids]
-        
-        theids = []
-        for id in indices_or_msg_ids:
-            if isinstance(id, int):
-                id = self.history[id]
-            if not isinstance(id, str):
-                raise TypeError("indices must be str or int, not %r"%id)
-            theids.append(id)
-        
-        local_ids = filter(lambda msg_id: msg_id in self.history or msg_id in self.results, theids)
-        remote_ids = filter(lambda msg_id: msg_id not in local_ids, theids)
-        
-        if remote_ids:
-            ar = AsyncHubResult(self, msg_ids=theids)
-        else:
-            ar = AsyncResult(self, msg_ids=theids)
-        
-        if block:
-            ar.wait()
-        
-        return ar
-    
-    @spin_first
-    def result_status(self, msg_ids, status_only=True):
-        """Check on the status of the result(s) of the apply request with `msg_ids`.
-        
-        If status_only is False, then the actual results will be retrieved, else
-        only the status of the results will be checked.
-        
-        Parameters
-        ----------
-        
-        msg_ids : list of msg_ids
-            if int:
-                Passed as index to self.history for convenience.
-        status_only : bool (default: True)
-            if False:
-                Retrieve the actual results of completed tasks.
-        
-        Returns
-        -------
-        
-        results : dict
-            There will always be the keys 'pending' and 'completed', which will
-            be lists of msg_ids that are incomplete or complete. If `status_only`
-            is False, then completed results will be keyed by their `msg_id`.
-        """
-        if not isinstance(msg_ids, (list,tuple)):
-            msg_ids = [msg_ids]
-            
-        theids = []
-        for msg_id in msg_ids:
-            if isinstance(msg_id, int):
-                msg_id = self.history[msg_id]
-            if not isinstance(msg_id, basestring):
-                raise TypeError("msg_ids must be str, not %r"%msg_id)
-            theids.append(msg_id)
-        
-        completed = []
-        local_results = {}
-        
-        # comment this block out to temporarily disable local shortcut:
-        for msg_id in theids:
-            if msg_id in self.results:
-                completed.append(msg_id)
-                local_results[msg_id] = self.results[msg_id]
-                theids.remove(msg_id)
-        
-        if theids: # some not locally cached
-            content = dict(msg_ids=theids, status_only=status_only)
-            msg = self.session.send(self._query_socket, "result_request", content=content)
-            zmq.select([self._query_socket], [], [])
-            idents,msg = self.session.recv(self._query_socket, zmq.NOBLOCK)
-            if self.debug:
-                pprint(msg)
-            content = msg['content']
-            if content['status'] != 'ok':
-                raise self._unwrap_exception(content)
-            buffers = msg['buffers']
-        else:
-            content = dict(completed=[],pending=[])
-        
-        content['completed'].extend(completed)
-        
-        if status_only:
-            return content
-        
-        failures = []
-        # load cached results into result:
-        content.update(local_results)
-        # update cache with results:
-        for msg_id in sorted(theids):
-            if msg_id in content['completed']:
-                rec = content[msg_id]
-                parent = rec['header']
-                header = rec['result_header']
-                rcontent = rec['result_content']
-                iodict = rec['io']
-                if isinstance(rcontent, str):
-                    rcontent = self.session.unpack(rcontent)
-                
-                md = self.metadata[msg_id]
-                md.update(self._extract_metadata(header, parent, rcontent))
-                md.update(iodict)
-                
-                if rcontent['status'] == 'ok':
-                    res,buffers = util.unserialize_object(buffers)
-                else:
-                    print rcontent
-                    res = self._unwrap_exception(rcontent)
-                    failures.append(res)
-                
-                self.results[msg_id] = res
-                content[msg_id] = res
-        
-        if len(theids) == 1 and failures:
-                raise failures[0]
-        
-        error.collect_exceptions(failures, "result_status")
-        return content
-
-    @spin_first
-    def queue_status(self, targets='all', verbose=False):
-        """Fetch the status of engine queues.
-        
-        Parameters
-        ----------
-        
-        targets : int/str/list of ints/strs
-                the engines whose states are to be queried.
-                default : all
-        verbose : bool
-                Whether to return lengths only, or lists of ids for each element
-        """
-        engine_ids = self._build_targets(targets)[1]
-        content = dict(targets=engine_ids, verbose=verbose)
-        self.session.send(self._query_socket, "queue_request", content=content)
-        idents,msg = self.session.recv(self._query_socket, 0)
-        if self.debug:
-            pprint(msg)
-        content = msg['content']
-        status = content.pop('status')
-        if status != 'ok':
-            raise self._unwrap_exception(content)
-        content = util.rekey(content)
-        if isinstance(targets, int):
-            return content[targets]
-        else:
-            return content
-        
-    @spin_first
-    def purge_results(self, jobs=[], targets=[]):
-        """Tell the Hub to forget results.
-        
-        Individual results can be purged by msg_id, or the entire
-        history of specific targets can be purged.
-        
-        Parameters
-        ----------
-        
-        jobs : str or list of str or AsyncResult objects
-                the msg_ids whose results should be forgotten.
-        targets : int/str/list of ints/strs
-                The targets, by uuid or int_id, whose entire history is to be purged.
-                Use `targets='all'` to scrub everything from the Hub's memory.
-                
-                default : None
-        """
-        if not targets and not jobs:
-            raise ValueError("Must specify at least one of `targets` and `jobs`")
-        if targets:
-            targets = self._build_targets(targets)[1]
-        
-        # construct msg_ids from jobs
-        msg_ids = []
-        if isinstance(jobs, (basestring,AsyncResult)):
-            jobs = [jobs]
-        bad_ids = filter(lambda obj: not isinstance(obj, (basestring, AsyncResult)), jobs)
-        if bad_ids:
-            raise TypeError("Invalid msg_id type %r, expected str or AsyncResult"%bad_ids[0])
-        for j in jobs:
-            if isinstance(j, AsyncResult):
-                msg_ids.extend(j.msg_ids)
-            else:
-                msg_ids.append(j)
-        
-        content = dict(targets=targets, msg_ids=msg_ids)
-        self.session.send(self._query_socket, "purge_request", content=content)
-        idents, msg = self.session.recv(self._query_socket, 0)
-        if self.debug:
-            pprint(msg)
-        content = msg['content']
-        if content['status'] != 'ok':
-            raise self._unwrap_exception(content)
-
-    @spin_first
-    def hub_history(self):
-        """Get the Hub's history
-        
-        Just like the Client, the Hub has a history, which is a list of msg_ids.
-        This will contain the history of all clients, and, depending on configuration,
-        may contain history across multiple cluster sessions.
-        
-        Any msg_id returned here is a valid argument to `get_result`.
-        
-        Returns
-        -------
-        
-        msg_ids : list of strs
-                list of all msg_ids, ordered by task submission time.
-        """
-        
-        self.session.send(self._query_socket, "history_request", content={})
-        idents, msg = self.session.recv(self._query_socket, 0)
-        
-        if self.debug:
-            pprint(msg)
-        content = msg['content']
-        if content['status'] != 'ok':
-            raise self._unwrap_exception(content)
-        else:
-            return content['history']
-
-    @spin_first
-    def db_query(self, query, keys=None):
-        """Query the Hub's TaskRecord database
-        
-        This will return a list of task record dicts that match `query`
-        
-        Parameters
-        ----------
-        
-        query : mongodb query dict
-            The search dict. See mongodb query docs for details.
-        keys : list of strs [optional]
-            THe subset of keys to be returned.  The default is to fetch everything.
-            'msg_id' will *always* be included.
-        """
-        content = dict(query=query, keys=keys)
-        self.session.send(self._query_socket, "db_request", content=content)
-        idents, msg = self.session.recv(self._query_socket, 0)
-        if self.debug:
-            pprint(msg)
-        content = msg['content']
-        if content['status'] != 'ok':
-            raise self._unwrap_exception(content)
-        
-        records = content['records']
-        buffer_lens = content['buffer_lens']
-        result_buffer_lens = content['result_buffer_lens']
-        buffers = msg['buffers']
-        has_bufs = buffer_lens is not None
-        has_rbufs = result_buffer_lens is not None
-        for i,rec in enumerate(records):
-            # relink buffers
-            if has_bufs:
-                blen = buffer_lens[i]
-                rec['buffers'], buffers = buffers[:blen],buffers[blen:]
-            if has_rbufs:
-                blen = result_buffer_lens[i]
-                rec['result_buffers'], buffers = buffers[:blen],buffers[blen:]
-            # turn timestamps back into times
-            for key in 'submitted started completed resubmitted'.split():
-                maybedate = rec.get(key, None)
-                if maybedate and util.ISO8601_RE.match(maybedate):
-                    rec[key] = datetime.strptime(maybedate, util.ISO8601)
-            
-        return records
-
-__all__ = [ 'Client' ]
diff --git a/IPython/parallel/client/map.py b/IPython/parallel/client/map.py
deleted file mode 100644
index c2c7b2fcc63..00000000000
--- a/IPython/parallel/client/map.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# encoding: utf-8
-
-"""Classes used in scattering and gathering sequences.
-
-Scattering consists of partitioning a sequence and sending the various
-pieces to individual nodes in a cluster.
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import types
-
-from IPython.utils.data import flatten as utils_flatten
-
-#-------------------------------------------------------------------------------
-# Figure out which array packages are present and their array types
-#-------------------------------------------------------------------------------
-
-arrayModules = []
-try:
-    import Numeric
-except ImportError:
-    pass
-else:
-    arrayModules.append({'module':Numeric, 'type':Numeric.arraytype})
-try:
-    import numpy
-except ImportError:
-    pass
-else:
-    arrayModules.append({'module':numpy, 'type':numpy.ndarray})
-try:
-    import numarray
-except ImportError:
-    pass
-else:
-    arrayModules.append({'module':numarray,
-        'type':numarray.numarraycore.NumArray})
-
-class Map:
-    """A class for partitioning a sequence using a map."""
-            
-    def getPartition(self, seq, p, q):
-        """Returns the pth partition of q partitions of seq."""
-        
-        # Test for error conditions here
-        if p<0 or p>=q:
-          print "No partition exists."
-          return
-          
-        remainder = len(seq)%q
-        basesize = len(seq)/q
-        hi = []
-        lo = []
-        for n in range(q):
-            if n < remainder:
-                lo.append(n * (basesize + 1))
-                hi.append(lo[-1] + basesize + 1)
-            else:
-                lo.append(n*basesize + remainder)
-                hi.append(lo[-1] + basesize)
-
-        
-        result = seq[lo[p]:hi[p]]
-        return result
-           
-    def joinPartitions(self, listOfPartitions):
-        return self.concatenate(listOfPartitions)
-                    
-    def concatenate(self, listOfPartitions):
-        testObject = listOfPartitions[0]
-        # First see if we have a known array type
-        for m in arrayModules:
-            #print m
-            if isinstance(testObject, m['type']):
-                return m['module'].concatenate(listOfPartitions)
-        # Next try for Python sequence types
-        if isinstance(testObject, (types.ListType, types.TupleType)):
-            return utils_flatten(listOfPartitions)
-        # If we have scalars, just return listOfPartitions
-        return listOfPartitions
-
-class RoundRobinMap(Map):
-    """Partitions a sequence in a roun robin fashion.
-    
-    This currently does not work!
-    """
-
-    def getPartition(self, seq, p, q):
-        # if not isinstance(seq,(list,tuple)):
-        #     raise NotImplementedError("cannot RR partition type %s"%type(seq))
-        return seq[p:len(seq):q]
-        #result = []
-        #for i in range(p,len(seq),q):
-        #    result.append(seq[i])
-        #return result
-
-    def joinPartitions(self, listOfPartitions):
-        testObject = listOfPartitions[0]
-        # First see if we have a known array type
-        for m in arrayModules:
-            #print m
-            if isinstance(testObject, m['type']):
-                return self.flatten_array(m['type'], listOfPartitions)
-        if isinstance(testObject, (types.ListType, types.TupleType)):
-            return self.flatten_list(listOfPartitions)
-        return listOfPartitions
-    
-    def flatten_array(self, klass, listOfPartitions):
-        test = listOfPartitions[0]
-        shape = list(test.shape)
-        shape[0] = sum([ p.shape[0] for p in listOfPartitions])
-        A = klass(shape)
-        N = shape[0]
-        q = len(listOfPartitions)
-        for p,part in enumerate(listOfPartitions):
-            A[p:N:q] = part
-        return A
-    
-    def flatten_list(self, listOfPartitions):
-        flat = []
-        for i in range(len(listOfPartitions[0])):
-            flat.extend([ part[i] for part in listOfPartitions if len(part) > i ])
-        return flat
-        #lengths = [len(x) for x in listOfPartitions]
-        #maxPartitionLength = len(listOfPartitions[0])
-        #numberOfPartitions = len(listOfPartitions)
-        #concat = self.concatenate(listOfPartitions)
-        #totalLength = len(concat)
-        #result = []
-        #for i in range(maxPartitionLength):
-        #    result.append(concat[i:totalLength:maxPartitionLength])
-        # return self.concatenate(listOfPartitions)
-
-def mappable(obj):
-    """return whether an object is mappable or not."""
-    if isinstance(obj, (tuple,list)):
-        return True
-    for m in arrayModules:
-        if isinstance(obj,m['type']):
-            return True
-    return False
-
-dists = {'b':Map,'r':RoundRobinMap}
-
-    
-    
diff --git a/IPython/parallel/client/remotefunction.py b/IPython/parallel/client/remotefunction.py
deleted file mode 100644
index 66f1f8d7101..00000000000
--- a/IPython/parallel/client/remotefunction.py
+++ /dev/null
@@ -1,200 +0,0 @@
-"""Remote Functions and decorators for Views."""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import warnings
-
-from IPython.testing import decorators as testdec
-
-from . import map as Map
-from .asyncresult import AsyncMapResult
-
-#-----------------------------------------------------------------------------
-# Decorators
-#-----------------------------------------------------------------------------
-
-@testdec.skip_doctest
-def remote(view, block=None, **flags):
-    """Turn a function into a remote function.
-    
-    This method can be used for map:
-    
-    In [1]: @remote(view,block=True)
-       ...: def func(a):
-       ...:    pass
-    """
-    
-    def remote_function(f):
-        return RemoteFunction(view, f, block=block, **flags)
-    return remote_function
-
-@testdec.skip_doctest
-def parallel(view, dist='b', block=None, **flags):
-    """Turn a function into a parallel remote function.
-    
-    This method can be used for map:
-    
-    In [1]: @parallel(view, block=True)
-       ...: def func(a):
-       ...:    pass
-    """
-    
-    def parallel_function(f):
-        return ParallelFunction(view, f, dist=dist, block=block, **flags)
-    return parallel_function
-
-#--------------------------------------------------------------------------
-# Classes
-#--------------------------------------------------------------------------
-
-class RemoteFunction(object):
-    """Turn an existing function into a remote function.
-    
-    Parameters
-    ----------
-    
-    view : View instance
-        The view to be used for execution
-    f : callable
-        The function to be wrapped into a remote function
-    block : bool [default: None]
-        Whether to wait for results or not.  The default behavior is
-        to use the current `block` attribute of `view`
-    
-    **flags : remaining kwargs are passed to View.temp_flags
-    """
-    
-    view = None # the remote connection
-    func = None # the wrapped function
-    block = None # whether to block
-    flags = None # dict of extra kwargs for temp_flags
-    
-    def __init__(self, view, f, block=None, **flags):
-        self.view = view
-        self.func = f
-        self.block=block
-        self.flags=flags
-    
-    def __call__(self, *args, **kwargs):
-        block = self.view.block if self.block is None else self.block
-        with self.view.temp_flags(block=block, **self.flags):
-            return self.view.apply(self.func, *args, **kwargs)
-    
-
-class ParallelFunction(RemoteFunction):
-    """Class for mapping a function to sequences.
-    
-    This will distribute the sequences according the a mapper, and call
-    the function on each sub-sequence.  If called via map, then the function
-    will be called once on each element, rather that each sub-sequence.
-    
-    Parameters
-    ----------
-    
-    view : View instance
-        The view to be used for execution
-    f : callable
-        The function to be wrapped into a remote function
-    dist : str [default: 'b']
-        The key for which mapObject to use to distribute sequences
-        options are:
-          * 'b' : use contiguous chunks in order
-          * 'r' : use round-robin striping
-    block : bool [default: None]
-        Whether to wait for results or not.  The default behavior is
-        to use the current `block` attribute of `view`
-    chunksize : int or None
-        The size of chunk to use when breaking up sequences in a load-balanced manner
-    **flags : remaining kwargs are passed to View.temp_flags
-    """
-    
-    chunksize=None
-    mapObject=None
-    
-    def __init__(self, view, f, dist='b', block=None, chunksize=None, **flags):
-        super(ParallelFunction, self).__init__(view, f, block=block, **flags)
-        self.chunksize = chunksize
-        
-        mapClass = Map.dists[dist]
-        self.mapObject = mapClass()
-    
-    def __call__(self, *sequences):
-        # check that the length of sequences match
-        len_0 = len(sequences[0])
-        for s in sequences:
-            if len(s)!=len_0:
-                msg = 'all sequences must have equal length, but %i!=%i'%(len_0,len(s))
-                raise ValueError(msg)
-        balanced = 'Balanced' in self.view.__class__.__name__
-        if balanced:
-            if self.chunksize:
-                nparts = len_0/self.chunksize + int(len_0%self.chunksize > 0)
-            else:
-                nparts = len_0
-            targets = [None]*nparts
-        else:
-            if self.chunksize:
-                warnings.warn("`chunksize` is ignored unless load balancing", UserWarning)
-            # multiplexed:
-            targets = self.view.targets
-            nparts = len(targets)
-        
-        msg_ids = []
-        # my_f = lambda *a: map(self.func, *a)
-        client = self.view.client
-        for index, t in enumerate(targets):
-            args = []
-            for seq in sequences:
-                part = self.mapObject.getPartition(seq, index, nparts)
-                if len(part) == 0:
-                    continue
-                else:
-                    args.append(part)
-            if not args:
-                continue
-            
-            # print (args)
-            if hasattr(self, '_map'):
-                f = map
-                args = [self.func]+args
-            else:
-                f=self.func
-            
-            view = self.view if balanced else client[t]
-            with view.temp_flags(block=False, **self.flags):
-                ar = view.apply(f, *args)
-            
-            msg_ids.append(ar.msg_ids[0])
-        
-        r = AsyncMapResult(self.view.client, msg_ids, self.mapObject, fname=self.func.__name__)
-        
-        if self.block:
-            try:
-                return r.get()
-            except KeyboardInterrupt:
-                return r
-        else:
-            return r
-    
-    def map(self, *sequences):
-        """call a function on each element of a sequence remotely. 
-        This should behave very much like the builtin map, but return an AsyncMapResult
-        if self.block is False.
-        """
-        # set _map as a flag for use inside self.__call__
-        self._map = True
-        try:
-            ret = self.__call__(*sequences)
-        finally:
-            del self._map
-        return ret
-
-__all__ = ['remote', 'parallel', 'RemoteFunction', 'ParallelFunction']
\ No newline at end of file
diff --git a/IPython/parallel/client/view.py b/IPython/parallel/client/view.py
deleted file mode 100644
index 647729df2f8..00000000000
--- a/IPython/parallel/client/view.py
+++ /dev/null
@@ -1,1033 +0,0 @@
-"""Views of remote engines."""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import imp
-import sys
-import warnings
-from contextlib import contextmanager
-from types import ModuleType
-
-import zmq
-
-from IPython.testing import decorators as testdec
-from IPython.utils.traitlets import HasTraits, Any, Bool, List, Dict, Set, Int, Instance, CFloat
-
-from IPython.external.decorator import decorator
-
-from IPython.parallel import util
-from IPython.parallel.controller.dependency import Dependency, dependent
-
-from . import map as Map
-from .asyncresult import AsyncResult, AsyncMapResult
-from .remotefunction import ParallelFunction, parallel, remote
-
-#-----------------------------------------------------------------------------
-# Decorators
-#-----------------------------------------------------------------------------
-
-@decorator
-def save_ids(f, self, *args, **kwargs):
-    """Keep our history and outstanding attributes up to date after a method call."""
-    n_previous = len(self.client.history)
-    try:
-        ret = f(self, *args, **kwargs)
-    finally:
-        nmsgs = len(self.client.history) - n_previous
-        msg_ids = self.client.history[-nmsgs:]
-        self.history.extend(msg_ids)
-        map(self.outstanding.add, msg_ids)
-    return ret
-
-@decorator
-def sync_results(f, self, *args, **kwargs):
-    """sync relevant results from self.client to our results attribute."""
-    ret = f(self, *args, **kwargs)
-    delta = self.outstanding.difference(self.client.outstanding)
-    completed = self.outstanding.intersection(delta)
-    self.outstanding = self.outstanding.difference(completed)
-    for msg_id in completed:
-        self.results[msg_id] = self.client.results[msg_id]
-    return ret
-
-@decorator
-def spin_after(f, self, *args, **kwargs):
-    """call spin after the method."""
-    ret = f(self, *args, **kwargs)
-    self.spin()
-    return ret
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-@testdec.skip_doctest
-class View(HasTraits):
-    """Base View class for more convenint apply(f,*args,**kwargs) syntax via attributes.
-    
-    Don't use this class, use subclasses.
-    
-    Methods
-    -------
-    
-    spin
-        flushes incoming results and registration state changes
-        control methods spin, and requesting `ids` also ensures up to date
-    
-    wait
-        wait on one or more msg_ids
-    
-    execution methods
-        apply
-        legacy: execute, run
-    
-    data movement
-        push, pull, scatter, gather
-    
-    query methods
-        get_result, queue_status, purge_results, result_status
-    
-    control methods
-        abort, shutdown
-    
-    """
-    # flags
-    block=Bool(False)
-    track=Bool(True)
-    targets = Any()
-    
-    history=List()
-    outstanding = Set()
-    results = Dict()
-    client = Instance('IPython.parallel.Client')
-    
-    _socket = Instance('zmq.Socket')
-    _flag_names = List(['targets', 'block', 'track'])
-    _targets = Any()
-    _idents = Any()
-    
-    def __init__(self, client=None, socket=None, **flags):
-        super(View, self).__init__(client=client, _socket=socket)
-        self.block = client.block
-        
-        self.set_flags(**flags)
-        
-        assert not self.__class__ is View, "Don't use base View objects, use subclasses"
-        
-
-    def __repr__(self):
-        strtargets = str(self.targets)
-        if len(strtargets) > 16:
-            strtargets = strtargets[:12]+'...]'
-        return "<%s %s>"%(self.__class__.__name__, strtargets)
-
-    def set_flags(self, **kwargs):
-        """set my attribute flags by keyword.
-        
-        Views determine behavior with a few attributes (`block`, `track`, etc.).
-        These attributes can be set all at once by name with this method.
-        
-        Parameters
-        ----------
-        
-        block : bool
-            whether to wait for results
-        track : bool
-            whether to create a MessageTracker to allow the user to 
-            safely edit after arrays and buffers during non-copying
-            sends.
-        """
-        for name, value in kwargs.iteritems():
-            if name not in self._flag_names:
-                raise KeyError("Invalid name: %r"%name)
-            else:
-                setattr(self, name, value)
-    
-    @contextmanager
-    def temp_flags(self, **kwargs):
-        """temporarily set flags, for use in `with` statements.
-        
-        See set_flags for permanent setting of flags
-        
-        Examples
-        --------
-        
-        >>> view.track=False
-        ...
-        >>> with view.temp_flags(track=True):
-        ...    ar = view.apply(dostuff, my_big_array)
-        ...    ar.tracker.wait() # wait for send to finish
-        >>> view.track
-        False
-        
-        """
-        # preflight: save flags, and set temporaries
-        saved_flags = {}
-        for f in self._flag_names:
-            saved_flags[f] = getattr(self, f)
-        self.set_flags(**kwargs)
-        # yield to the with-statement block
-        try:
-            yield
-        finally:
-            # postflight: restore saved flags
-            self.set_flags(**saved_flags)
-        
-        
-    #----------------------------------------------------------------
-    # apply
-    #----------------------------------------------------------------
-    
-    @sync_results
-    @save_ids
-    def _really_apply(self, f, args, kwargs, block=None, **options):
-        """wrapper for client.send_apply_message"""
-        raise NotImplementedError("Implement in subclasses")
-    
-    def apply(self, f, *args, **kwargs):
-        """calls f(*args, **kwargs) on remote engines, returning the result.
-        
-        This method sets all apply flags via this View's attributes.
-        
-        if self.block is False:
-            returns AsyncResult
-        else:
-            returns actual result of f(*args, **kwargs)
-        """
-        return self._really_apply(f, args, kwargs)
-
-    def apply_async(self, f, *args, **kwargs):
-        """calls f(*args, **kwargs) on remote engines in a nonblocking manner.
-        
-        returns AsyncResult
-        """
-        return self._really_apply(f, args, kwargs, block=False)
-
-    @spin_after
-    def apply_sync(self, f, *args, **kwargs):
-        """calls f(*args, **kwargs) on remote engines in a blocking manner,
-         returning the result.
-        
-        returns: actual result of f(*args, **kwargs)
-        """
-        return self._really_apply(f, args, kwargs, block=True)
-
-    #----------------------------------------------------------------
-    # wrappers for client and control methods
-    #----------------------------------------------------------------
-    @sync_results
-    def spin(self):
-        """spin the client, and sync"""
-        self.client.spin()
-    
-    @sync_results
-    def wait(self, jobs=None, timeout=-1):
-        """waits on one or more `jobs`, for up to `timeout` seconds.
-        
-        Parameters
-        ----------
-        
-        jobs : int, str, or list of ints and/or strs, or one or more AsyncResult objects
-                ints are indices to self.history
-                strs are msg_ids
-                default: wait on all outstanding messages
-        timeout : float
-                a time in seconds, after which to give up.
-                default is -1, which means no timeout
-        
-        Returns
-        -------
-        
-        True : when all msg_ids are done
-        False : timeout reached, some msg_ids still outstanding
-        """
-        if jobs is None:
-            jobs = self.history
-        return self.client.wait(jobs, timeout)
-    
-    def abort(self, jobs=None, targets=None, block=None):
-        """Abort jobs on my engines.
-        
-        Parameters
-        ----------
-        
-        jobs : None, str, list of strs, optional
-            if None: abort all jobs.
-            else: abort specific msg_id(s).
-        """
-        block = block if block is not None else self.block
-        targets = targets if targets is not None else self.targets
-        return self.client.abort(jobs=jobs, targets=targets, block=block)
-
-    def queue_status(self, targets=None, verbose=False):
-        """Fetch the Queue status of my engines"""
-        targets = targets if targets is not None else self.targets
-        return self.client.queue_status(targets=targets, verbose=verbose)
-    
-    def purge_results(self, jobs=[], targets=[]):
-        """Instruct the controller to forget specific results."""
-        if targets is None or targets == 'all':
-            targets = self.targets
-        return self.client.purge_results(jobs=jobs, targets=targets)
-    
-    def shutdown(self, targets=None, restart=False, hub=False, block=None):
-        """Terminates one or more engine processes, optionally including the hub.
-        """
-        block = self.block if block is None else block
-        if targets is None or targets == 'all':
-            targets = self.targets
-        return self.client.shutdown(targets=targets, restart=restart, hub=hub, block=block)
-    
-    @spin_after
-    def get_result(self, indices_or_msg_ids=None):
-        """return one or more results, specified by history index or msg_id.
-        
-        See client.get_result for details.
-        
-        """
-        
-        if indices_or_msg_ids is None:
-            indices_or_msg_ids = -1
-        if isinstance(indices_or_msg_ids, int):
-            indices_or_msg_ids = self.history[indices_or_msg_ids]
-        elif isinstance(indices_or_msg_ids, (list,tuple,set)):
-            indices_or_msg_ids = list(indices_or_msg_ids)
-            for i,index in enumerate(indices_or_msg_ids):
-                if isinstance(index, int):
-                    indices_or_msg_ids[i] = self.history[index]
-        return self.client.get_result(indices_or_msg_ids)
-    
-    #-------------------------------------------------------------------
-    # Map
-    #-------------------------------------------------------------------
-    
-    def map(self, f, *sequences, **kwargs):
-        """override in subclasses"""
-        raise NotImplementedError
-    
-    def map_async(self, f, *sequences, **kwargs):
-        """Parallel version of builtin `map`, using this view's engines.
-        
-        This is equivalent to map(...block=False)
-        
-        See `self.map` for details.
-        """
-        if 'block' in kwargs:
-            raise TypeError("map_async doesn't take a `block` keyword argument.")
-        kwargs['block'] = False
-        return self.map(f,*sequences,**kwargs)
-    
-    def map_sync(self, f, *sequences, **kwargs):
-        """Parallel version of builtin `map`, using this view's engines.
-        
-        This is equivalent to map(...block=True)
-        
-        See `self.map` for details.
-        """
-        if 'block' in kwargs:
-            raise TypeError("map_sync doesn't take a `block` keyword argument.")
-        kwargs['block'] = True
-        return self.map(f,*sequences,**kwargs)
-    
-    def imap(self, f, *sequences, **kwargs):
-        """Parallel version of `itertools.imap`.
-        
-        See `self.map` for details.
-        
-        """
-        
-        return iter(self.map_async(f,*sequences, **kwargs))
-    
-    #-------------------------------------------------------------------
-    # Decorators
-    #-------------------------------------------------------------------
-    
-    def remote(self, block=True, **flags):
-        """Decorator for making a RemoteFunction"""
-        block = self.block if block is None else block
-        return remote(self, block=block, **flags)
-    
-    def parallel(self, dist='b', block=None, **flags):
-        """Decorator for making a ParallelFunction"""
-        block = self.block if block is None else block
-        return parallel(self, dist=dist, block=block, **flags)
-
-@testdec.skip_doctest
-class DirectView(View):
-    """Direct Multiplexer View of one or more engines.
-    
-    These are created via indexed access to a client:
-    
-    >>> dv_1 = client[1]
-    >>> dv_all = client[:]
-    >>> dv_even = client[::2]
-    >>> dv_some = client[1:3]
-    
-    This object provides dictionary access to engine namespaces:
-    
-    # push a=5:
-    >>> dv['a'] = 5 
-    # pull 'foo':
-    >>> db['foo']
-    
-    """
-    
-    def __init__(self, client=None, socket=None, targets=None):
-        super(DirectView, self).__init__(client=client, socket=socket, targets=targets)
-    
-    @property
-    def importer(self):
-        """sync_imports(local=True) as a property.
-        
-        See sync_imports for details.
-        
-        """
-        return self.sync_imports(True)
-    
-    @contextmanager
-    def sync_imports(self, local=True):
-        """Context Manager for performing simultaneous local and remote imports.
-        
-        'import x as y' will *not* work.  The 'as y' part will simply be ignored.
-        
-        >>> with view.sync_imports():
-        ...    from numpy import recarray
-        importing recarray from numpy on engine(s)
-        
-        """
-        import __builtin__
-        local_import = __builtin__.__import__
-        modules = set()
-        results = []
-        @util.interactive
-        def remote_import(name, fromlist, level):
-            """the function to be passed to apply, that actually performs the import
-            on the engine, and loads up the user namespace.
-            """
-            import sys
-            user_ns = globals()
-            mod = __import__(name, fromlist=fromlist, level=level)
-            if fromlist:
-                for key in fromlist:
-                    user_ns[key] = getattr(mod, key)
-            else:
-                user_ns[name] = sys.modules[name]
-        
-        def view_import(name, globals={}, locals={}, fromlist=[], level=-1):
-            """the drop-in replacement for __import__, that optionally imports
-            locally as well.
-            """
-            # don't override nested imports
-            save_import = __builtin__.__import__
-            __builtin__.__import__ = local_import
-            
-            if imp.lock_held():
-                # this is a side-effect import, don't do it remotely, or even
-                # ignore the local effects
-                return local_import(name, globals, locals, fromlist, level)
-            
-            imp.acquire_lock()
-            if local:
-                mod = local_import(name, globals, locals, fromlist, level)
-            else:
-                raise NotImplementedError("remote-only imports not yet implemented")
-            imp.release_lock()
-            
-            key = name+':'+','.join(fromlist or [])
-            if level == -1 and key not in modules:
-                modules.add(key)
-                if fromlist:
-                    print "importing %s from %s on engine(s)"%(','.join(fromlist), name)
-                else:
-                    print "importing %s on engine(s)"%name
-                results.append(self.apply_async(remote_import, name, fromlist, level))
-            # restore override
-            __builtin__.__import__ = save_import
-                
-            return mod
-        
-        # override __import__
-        __builtin__.__import__ = view_import
-        try:
-            # enter the block
-            yield
-        except ImportError:
-            if not local:
-                # ignore import errors if not doing local imports
-                pass
-        finally:
-            # always restore __import__
-            __builtin__.__import__ = local_import
-        
-        for r in results:
-            # raise possible remote ImportErrors here
-            r.get()
-            
-    
-    @sync_results
-    @save_ids
-    def _really_apply(self, f, args=None, kwargs=None, targets=None, block=None, track=None):
-        """calls f(*args, **kwargs) on remote engines, returning the result.
-        
-        This method sets all of `apply`'s flags via this View's attributes.
-        
-        Parameters
-        ----------
-        
-        f : callable
-        
-        args : list [default: empty]
-        
-        kwargs : dict [default: empty]
-        
-        targets : target list [default: self.targets]
-            where to run
-        block : bool [default: self.block]
-            whether to block 
-        track : bool [default: self.track]
-            whether to ask zmq to track the message, for safe non-copying sends
-        
-        Returns
-        -------
-        
-        if self.block is False:
-            returns AsyncResult
-        else:
-            returns actual result of f(*args, **kwargs) on the engine(s)
-            This will be a list of self.targets is also a list (even length 1), or
-            the single result if self.targets is an integer engine id
-        """
-        args = [] if args is None else args
-        kwargs = {} if kwargs is None else kwargs
-        block = self.block if block is None else block
-        track = self.track if track is None else track
-        targets = self.targets if targets is None else targets
-        
-        _idents = self.client._build_targets(targets)[0]
-        msg_ids = []
-        trackers = []
-        for ident in _idents:
-            msg = self.client.send_apply_message(self._socket, f, args, kwargs, track=track,
-                                    ident=ident)
-            if track:
-                trackers.append(msg['tracker'])
-            msg_ids.append(msg['msg_id'])
-        tracker = None if track is False else zmq.MessageTracker(*trackers)
-        ar = AsyncResult(self.client, msg_ids, fname=f.__name__, targets=targets, tracker=tracker)
-        if block:
-            try:
-                return ar.get()
-            except KeyboardInterrupt:
-                pass
-        return ar
-    
-    @spin_after
-    def map(self, f, *sequences, **kwargs):
-        """view.map(f, *sequences, block=self.block) => list|AsyncMapResult
-        
-        Parallel version of builtin `map`, using this View's `targets`.
-        
-        There will be one task per target, so work will be chunked
-        if the sequences are longer than `targets`.  
-        
-        Results can be iterated as they are ready, but will become available in chunks.
-        
-        Parameters
-        ----------
-        
-        f : callable
-            function to be mapped
-        *sequences: one or more sequences of matching length
-            the sequences to be distributed and passed to `f`
-        block : bool
-            whether to wait for the result or not [default self.block]
-        
-        Returns
-        -------
-        
-        if block=False:
-            AsyncMapResult
-                An object like AsyncResult, but which reassembles the sequence of results
-                into a single list. AsyncMapResults can be iterated through before all
-                results are complete.
-        else:
-            list
-                the result of map(f,*sequences)
-        """
-        
-        block = kwargs.pop('block', self.block)
-        for k in kwargs.keys():
-            if k not in ['block', 'track']:
-                raise TypeError("invalid keyword arg, %r"%k)
-        
-        assert len(sequences) > 0, "must have some sequences to map onto!"
-        pf = ParallelFunction(self, f, block=block, **kwargs)
-        return pf.map(*sequences)
-    
-    def execute(self, code, targets=None, block=None):
-        """Executes `code` on `targets` in blocking or nonblocking manner.
-        
-        ``execute`` is always `bound` (affects engine namespace)
-        
-        Parameters
-        ----------
-        
-        code : str
-                the code string to be executed
-        block : bool
-                whether or not to wait until done to return
-                default: self.block
-        """
-        return self._really_apply(util._execute, args=(code,), block=block, targets=targets)
-    
-    def run(self, filename, targets=None, block=None):
-        """Execute contents of `filename` on my engine(s). 
-        
-        This simply reads the contents of the file and calls `execute`.
-        
-        Parameters
-        ----------
-        
-        filename : str
-                The path to the file
-        targets : int/str/list of ints/strs
-                the engines on which to execute
-                default : all
-        block : bool
-                whether or not to wait until done
-                default: self.block
-        
-        """
-        with open(filename, 'r') as f:
-            # add newline in case of trailing indented whitespace
-            # which will cause SyntaxError
-            code = f.read()+'\n'
-        return self.execute(code, block=block, targets=targets)
-    
-    def update(self, ns):
-        """update remote namespace with dict `ns`
-        
-        See `push` for details.
-        """
-        return self.push(ns, block=self.block, track=self.track)
-    
-    def push(self, ns, targets=None, block=None, track=None):
-        """update remote namespace with dict `ns`
-        
-        Parameters
-        ----------
-        
-        ns : dict
-            dict of keys with which to update engine namespace(s)
-        block : bool [default : self.block]
-            whether to wait to be notified of engine receipt
-        
-        """
-        
-        block = block if block is not None else self.block
-        track = track if track is not None else self.track
-        targets = targets if targets is not None else self.targets
-        # applier = self.apply_sync if block else self.apply_async
-        if not isinstance(ns, dict):
-            raise TypeError("Must be a dict, not %s"%type(ns))
-        return self._really_apply(util._push, (ns,), block=block, track=track, targets=targets)
-
-    def get(self, key_s):
-        """get object(s) by `key_s` from remote namespace
-        
-        see `pull` for details.
-        """
-        # block = block if block is not None else self.block
-        return self.pull(key_s, block=True)
-    
-    def pull(self, names, targets=None, block=None):
-        """get object(s) by `name` from remote namespace
-        
-        will return one object if it is a key.
-        can also take a list of keys, in which case it will return a list of objects.
-        """
-        block = block if block is not None else self.block
-        targets = targets if targets is not None else self.targets
-        applier = self.apply_sync if block else self.apply_async
-        if isinstance(names, basestring):
-            pass
-        elif isinstance(names, (list,tuple,set)):
-            for key in names:
-                if not isinstance(key, basestring):
-                    raise TypeError("keys must be str, not type %r"%type(key))
-        else:
-            raise TypeError("names must be strs, not %r"%names)
-        return self._really_apply(util._pull, (names,), block=block, targets=targets)
-    
-    def scatter(self, key, seq, dist='b', flatten=False, targets=None, block=None, track=None):
-        """
-        Partition a Python sequence and send the partitions to a set of engines.
-        """
-        block = block if block is not None else self.block
-        track = track if track is not None else self.track
-        targets = targets if targets is not None else self.targets
-        
-        mapObject = Map.dists[dist]()
-        nparts = len(targets)
-        msg_ids = []
-        trackers = []
-        for index, engineid in enumerate(targets):
-            partition = mapObject.getPartition(seq, index, nparts)
-            if flatten and len(partition) == 1:
-                ns = {key: partition[0]}
-            else:
-                ns = {key: partition}
-            r = self.push(ns, block=False, track=track, targets=engineid)
-            msg_ids.extend(r.msg_ids)
-            if track:
-                trackers.append(r._tracker)
-        
-        if track:
-            tracker = zmq.MessageTracker(*trackers)
-        else:
-            tracker = None
-        
-        r = AsyncResult(self.client, msg_ids, fname='scatter', targets=targets, tracker=tracker)
-        if block:
-            r.wait()
-        else:
-            return r
-    
-    @sync_results
-    @save_ids
-    def gather(self, key, dist='b', targets=None, block=None):
-        """
-        Gather a partitioned sequence on a set of engines as a single local seq.
-        """
-        block = block if block is not None else self.block
-        targets = targets if targets is not None else self.targets
-        mapObject = Map.dists[dist]()
-        msg_ids = []
-        
-        for index, engineid in enumerate(targets):
-            msg_ids.extend(self.pull(key, block=False, targets=engineid).msg_ids)
-        
-        r = AsyncMapResult(self.client, msg_ids, mapObject, fname='gather')
-        
-        if block:
-            try:
-                return r.get()
-            except KeyboardInterrupt:
-                pass
-        return r
-    
-    def __getitem__(self, key):
-        return self.get(key)
-    
-    def __setitem__(self,key, value):
-        self.update({key:value})
-    
-    def clear(self, targets=None, block=False):
-        """Clear the remote namespaces on my engines."""
-        block = block if block is not None else self.block
-        targets = targets if targets is not None else self.targets
-        return self.client.clear(targets=targets, block=block)
-    
-    def kill(self, targets=None, block=True):
-        """Kill my engines."""
-        block = block if block is not None else self.block
-        targets = targets if targets is not None else self.targets
-        return self.client.kill(targets=targets, block=block)
-    
-    #----------------------------------------
-    # activate for %px,%autopx magics
-    #----------------------------------------
-    def activate(self):
-        """Make this `View` active for parallel magic commands.
-        
-        IPython has a magic command syntax to work with `MultiEngineClient` objects.
-        In a given IPython session there is a single active one.  While
-        there can be many `Views` created and used by the user, 
-        there is only one active one.  The active `View` is used whenever 
-        the magic commands %px and %autopx are used.
-        
-        The activate() method is called on a given `View` to make it 
-        active.  Once this has been done, the magic commands can be used.
-        """
-        
-        try:
-            # This is injected into __builtins__.
-            ip = get_ipython()
-        except NameError:
-            print "The IPython parallel magics (%result, %px, %autopx) only work within IPython."
-        else:
-            pmagic = ip.plugin_manager.get_plugin('parallelmagic')
-            if pmagic is None:
-                ip.magic_load_ext('parallelmagic')
-                pmagic = ip.plugin_manager.get_plugin('parallelmagic')
-
-            pmagic.active_view = self
-
-
-@testdec.skip_doctest
-class LoadBalancedView(View):
-    """An load-balancing View that only executes via the Task scheduler.
-    
-    Load-balanced views can be created with the client's `view` method:
-    
-    >>> v = client.load_balanced_view()
-    
-    or targets can be specified, to restrict the potential destinations:
-    
-    >>> v = client.client.load_balanced_view(([1,3])
-    
-    which would restrict loadbalancing to between engines 1 and 3.
-    
-    """
-    
-    follow=Any()
-    after=Any()
-    timeout=CFloat()
-    
-    _task_scheme = Any()
-    _flag_names = List(['targets', 'block', 'track', 'follow', 'after', 'timeout'])
-    
-    def __init__(self, client=None, socket=None, **flags):
-        super(LoadBalancedView, self).__init__(client=client, socket=socket, **flags)
-        self._task_scheme=client._task_scheme
-    
-    def _validate_dependency(self, dep):
-        """validate a dependency.
-        
-        For use in `set_flags`.
-        """
-        if dep is None or isinstance(dep, (str, AsyncResult, Dependency)):
-            return True
-        elif isinstance(dep, (list,set, tuple)):
-            for d in dep:
-                if not isinstance(d, (str, AsyncResult)):
-                    return False
-        elif isinstance(dep, dict):
-            if set(dep.keys()) != set(Dependency().as_dict().keys()):
-                return False
-            if not isinstance(dep['msg_ids'], list):
-                return False
-            for d in dep['msg_ids']:
-                if not isinstance(d, str):
-                    return False
-        else:
-            return False
-        
-        return True
-                
-    def _render_dependency(self, dep):
-        """helper for building jsonable dependencies from various input forms."""
-        if isinstance(dep, Dependency):
-            return dep.as_dict()
-        elif isinstance(dep, AsyncResult):
-            return dep.msg_ids
-        elif dep is None:
-            return []
-        else:
-            # pass to Dependency constructor
-            return list(Dependency(dep))
-
-    def set_flags(self, **kwargs):
-        """set my attribute flags by keyword.
-        
-        A View is a wrapper for the Client's apply method, but with attributes
-        that specify keyword arguments, those attributes can be set by keyword
-        argument with this method.
-        
-        Parameters
-        ----------
-        
-        block : bool
-            whether to wait for results
-        track : bool
-            whether to create a MessageTracker to allow the user to 
-            safely edit after arrays and buffers during non-copying
-            sends.
-        #
-        after : Dependency or collection of msg_ids
-            Only for load-balanced execution (targets=None)
-            Specify a list of msg_ids as a time-based dependency.
-            This job will only be run *after* the dependencies
-            have been met.
-
-        follow : Dependency or collection of msg_ids
-            Only for load-balanced execution (targets=None)
-            Specify a list of msg_ids as a location-based dependency.
-            This job will only be run on an engine where this dependency
-            is met.
-
-        timeout : float/int or None
-            Only for load-balanced execution (targets=None)
-            Specify an amount of time (in seconds) for the scheduler to
-            wait for dependencies to be met before failing with a
-            DependencyTimeout.
-        """
-        
-        super(LoadBalancedView, self).set_flags(**kwargs)
-        for name in ('follow', 'after'):
-            if name in kwargs:
-                value = kwargs[name]
-                if self._validate_dependency(value):
-                    setattr(self, name, value)
-                else:
-                    raise ValueError("Invalid dependency: %r"%value)
-        if 'timeout' in kwargs:
-            t = kwargs['timeout']
-            if not isinstance(t, (int, long, float, type(None))):
-                raise TypeError("Invalid type for timeout: %r"%type(t))
-            if t is not None:
-                if t < 0:
-                    raise ValueError("Invalid timeout: %s"%t)
-            self.timeout = t
-    
-    @sync_results
-    @save_ids
-    def _really_apply(self, f, args=None, kwargs=None, block=None, track=None,
-                                        after=None, follow=None, timeout=None,
-                                        targets=None):
-        """calls f(*args, **kwargs) on a remote engine, returning the result.
-        
-        This method temporarily sets all of `apply`'s flags for a single call.
-        
-        Parameters
-        ----------
-        
-        f : callable
-        
-        args : list [default: empty]
-        
-        kwargs : dict [default: empty]
-        
-        block : bool [default: self.block]
-            whether to block 
-        track : bool [default: self.track]
-            whether to ask zmq to track the message, for safe non-copying sends
-            
-        !!!!!! TODO: THE REST HERE  !!!!
-        
-        Returns
-        -------
-        
-        if self.block is False:
-            returns AsyncResult
-        else:
-            returns actual result of f(*args, **kwargs) on the engine(s)
-            This will be a list of self.targets is also a list (even length 1), or
-            the single result if self.targets is an integer engine id
-        """
-
-        # validate whether we can run
-        if self._socket.closed:
-            msg = "Task farming is disabled"
-            if self._task_scheme == 'pure':
-                msg += " because the pure ZMQ scheduler cannot handle"
-                msg += " disappearing engines."
-            raise RuntimeError(msg)
-        
-        if self._task_scheme == 'pure':
-            # pure zmq scheme doesn't support dependencies
-            msg = "Pure ZMQ scheduler doesn't support dependencies"
-            if (follow or after):
-                # hard fail on DAG dependencies
-                raise RuntimeError(msg)
-            if isinstance(f, dependent):
-                # soft warn on functional dependencies
-                warnings.warn(msg, RuntimeWarning)
-        
-        # build args
-        args = [] if args is None else args
-        kwargs = {} if kwargs is None else kwargs
-        block = self.block if block is None else block
-        track = self.track if track is None else track
-        after = self.after if after is None else after
-        follow = self.follow if follow is None else follow
-        timeout = self.timeout if timeout is None else timeout
-        targets = self.targets if targets is None else targets
-        
-        if targets is None:
-            idents = []
-        else:
-            idents = self.client._build_targets(targets)[0]
-        
-        after = self._render_dependency(after)
-        follow = self._render_dependency(follow)
-        subheader = dict(after=after, follow=follow, timeout=timeout, targets=idents)
-        
-        msg = self.client.send_apply_message(self._socket, f, args, kwargs, track=track,
-                                subheader=subheader)
-        tracker = None if track is False else msg['tracker']
-        
-        ar = AsyncResult(self.client, msg['msg_id'], fname=f.__name__, targets=None, tracker=tracker)
-        
-        if block:
-            try:
-                return ar.get()
-            except KeyboardInterrupt:
-                pass
-        return ar
-        
-    @spin_after
-    @save_ids
-    def map(self, f, *sequences, **kwargs):
-        """view.map(f, *sequences, block=self.block, chunksize=1) => list|AsyncMapResult
-        
-        Parallel version of builtin `map`, load-balanced by this View.
-        
-        `block`, and `chunksize` can be specified by keyword only.
-        
-        Each `chunksize` elements will be a separate task, and will be
-        load-balanced. This lets individual elements be available for iteration
-        as soon as they arrive.
-        
-        Parameters
-        ----------
-        
-        f : callable
-            function to be mapped
-        *sequences: one or more sequences of matching length
-            the sequences to be distributed and passed to `f`
-        block : bool
-            whether to wait for the result or not [default self.block]
-        track : bool
-            whether to create a MessageTracker to allow the user to 
-            safely edit after arrays and buffers during non-copying
-            sends.
-        chunksize : int
-            how many elements should be in each task [default 1]
-        
-        Returns
-        -------
-        
-        if block=False:
-            AsyncMapResult
-                An object like AsyncResult, but which reassembles the sequence of results
-                into a single list. AsyncMapResults can be iterated through before all
-                results are complete.
-            else:
-                the result of map(f,*sequences)
-        
-        """
-        
-        # default
-        block = kwargs.get('block', self.block)
-        chunksize = kwargs.get('chunksize', 1)
-        
-        keyset = set(kwargs.keys())
-        extra_keys = keyset.difference_update(set(['block', 'chunksize']))
-        if extra_keys:
-            raise TypeError("Invalid kwargs: %s"%list(extra_keys))
-        
-        assert len(sequences) > 0, "must have some sequences to map onto!"
-        
-        pf = ParallelFunction(self, f, block=block,  chunksize=chunksize)
-        return pf.map(*sequences)
-
-__all__ = ['LoadBalancedView', 'DirectView']
\ No newline at end of file
diff --git a/IPython/parallel/controller/__init__.py b/IPython/parallel/controller/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/parallel/controller/controller.py b/IPython/parallel/controller/controller.py
deleted file mode 100755
index e19ed97ae7f..00000000000
--- a/IPython/parallel/controller/controller.py
+++ /dev/null
@@ -1,116 +0,0 @@
-#!/usr/bin/env python
-"""The IPython Controller with 0MQ
-This is a collection of one Hub and several Schedulers.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-from multiprocessing import Process
-
-import zmq
-from zmq.devices import ProcessMonitoredQueue
-# internal:
-from IPython.utils.importstring import import_item
-from IPython.utils.traitlets import Int, CStr, Instance, List, Bool
-
-from IPython.parallel.util import signal_children
-from .hub import Hub, HubFactory
-from .scheduler import launch_scheduler
-
-#-----------------------------------------------------------------------------
-# Configurable
-#-----------------------------------------------------------------------------
-
-
-class ControllerFactory(HubFactory):
-    """Configurable for setting up a Hub and Schedulers."""
-    
-    usethreads = Bool(False, config=True)
-    
-    # internal
-    children = List()
-    mq_class = CStr('zmq.devices.ProcessMonitoredQueue')
-    
-    def _usethreads_changed(self, name, old, new):
-        self.mq_class = 'zmq.devices.%sMonitoredQueue'%('Thread' if new else 'Process')
-        
-    def __init__(self, **kwargs):
-        super(ControllerFactory, self).__init__(**kwargs)
-        self.subconstructors.append(self.construct_schedulers)
-    
-    def start(self):
-        super(ControllerFactory, self).start()
-        child_procs = []
-        for child in self.children:
-            child.start()
-            if isinstance(child, ProcessMonitoredQueue):
-                child_procs.append(child.launcher)
-            elif isinstance(child, Process):
-                child_procs.append(child)
-        if child_procs:
-            signal_children(child_procs)
-        
-    
-    def construct_schedulers(self):
-        children = self.children
-        mq = import_item(self.mq_class)
-        
-        # maybe_inproc = 'inproc://monitor' if self.usethreads else self.monitor_url
-        # IOPub relay (in a Process)
-        q = mq(zmq.PUB, zmq.SUB, zmq.PUB, 'N/A','iopub')
-        q.bind_in(self.client_info['iopub'])
-        q.bind_out(self.engine_info['iopub'])
-        q.setsockopt_out(zmq.SUBSCRIBE, '')
-        q.connect_mon(self.monitor_url)
-        q.daemon=True
-        children.append(q)
-
-        # Multiplexer Queue (in a Process)
-        q = mq(zmq.XREP, zmq.XREP, zmq.PUB, 'in', 'out')
-        q.bind_in(self.client_info['mux'])
-        q.setsockopt_in(zmq.IDENTITY, 'mux')
-        q.bind_out(self.engine_info['mux'])
-        q.connect_mon(self.monitor_url)
-        q.daemon=True
-        children.append(q)
-
-        # Control Queue (in a Process)
-        q = mq(zmq.XREP, zmq.XREP, zmq.PUB, 'incontrol', 'outcontrol')
-        q.bind_in(self.client_info['control'])
-        q.setsockopt_in(zmq.IDENTITY, 'control')
-        q.bind_out(self.engine_info['control'])
-        q.connect_mon(self.monitor_url)
-        q.daemon=True
-        children.append(q)
-        # Task Queue (in a Process)
-        if self.scheme == 'pure':
-            self.log.warn("task::using pure XREQ Task scheduler")
-            q = mq(zmq.XREP, zmq.XREQ, zmq.PUB, 'intask', 'outtask')
-            q.bind_in(self.client_info['task'][1])
-            q.setsockopt_in(zmq.IDENTITY, 'task')
-            q.bind_out(self.engine_info['task'])
-            q.connect_mon(self.monitor_url)
-            q.daemon=True
-            children.append(q)
-        elif self.scheme == 'none':
-            self.log.warn("task::using no Task scheduler")
-            
-        else:
-            self.log.info("task::using Python %s Task scheduler"%self.scheme)
-            sargs = (self.client_info['task'][1], self.engine_info['task'],
-                                self.monitor_url, self.client_info['notification'])
-            kwargs = dict(scheme=self.scheme,logname=self.log.name, loglevel=self.log.level,
-                                                            config=dict(self.config))
-            q = Process(target=launch_scheduler, args=sargs, kwargs=kwargs)
-            q.daemon=True
-            children.append(q)
-
diff --git a/IPython/parallel/controller/dependency.py b/IPython/parallel/controller/dependency.py
deleted file mode 100644
index 5727b24994c..00000000000
--- a/IPython/parallel/controller/dependency.py
+++ /dev/null
@@ -1,196 +0,0 @@
-"""Dependency utilities"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from types import ModuleType
-
-from IPython.parallel.client.asyncresult import AsyncResult
-from IPython.parallel.error import UnmetDependency
-from IPython.parallel.util import interactive
-
-class depend(object):
-    """Dependency decorator, for use with tasks.
-    
-    `@depend` lets you define a function for engine dependencies
-    just like you use `apply` for tasks.
-    
-    
-    Examples
-    --------
-    ::
-    
-        @depend(df, a,b, c=5)
-        def f(m,n,p)
-        
-        view.apply(f, 1,2,3)
-    
-    will call df(a,b,c=5) on the engine, and if it returns False or
-    raises an UnmetDependency error, then the task will not be run
-    and another engine will be tried.
-    """
-    def __init__(self, f, *args, **kwargs):
-        self.f = f
-        self.args = args
-        self.kwargs = kwargs
-    
-    def __call__(self, f):
-        return dependent(f, self.f, *self.args, **self.kwargs)
-
-class dependent(object):
-    """A function that depends on another function.
-    This is an object to prevent the closure used
-    in traditional decorators, which are not picklable.
-    """
-
-    def __init__(self, f, df, *dargs, **dkwargs):
-        self.f = f
-        self.func_name = getattr(f, '__name__', 'f')
-        self.df = df
-        self.dargs = dargs
-        self.dkwargs = dkwargs
-
-    def __call__(self, *args, **kwargs):
-        # if hasattr(self.f, 'func_globals') and hasattr(self.df, 'func_globals'):
-        #     self.df.func_globals = self.f.func_globals
-        if self.df(*self.dargs, **self.dkwargs) is False:
-            raise UnmetDependency()
-        return self.f(*args, **kwargs)
-    
-    @property
-    def __name__(self):
-        return self.func_name
-
-@interactive
-def _require(*names):
-    """Helper for @require decorator."""
-    from IPython.parallel.error import UnmetDependency
-    user_ns = globals()
-    for name in names:
-        if name in user_ns:
-            continue
-        try:
-            exec 'import %s'%name in user_ns
-        except ImportError:
-            raise UnmetDependency(name)
-    return True
-
-def require(*mods):
-    """Simple decorator for requiring names to be importable.
-    
-    Examples
-    --------
-    
-    In [1]: @require('numpy')
-       ...: def norm(a):
-       ...:     import numpy
-       ...:     return numpy.linalg.norm(a,2)
-    """
-    names = []
-    for mod in mods:
-        if isinstance(mod, ModuleType):
-            mod = mod.__name__
-        
-        if isinstance(mod, basestring):
-            names.append(mod)
-        else:
-            raise TypeError("names must be modules or module names, not %s"%type(mod))
-    
-    return depend(_require, *names)
-
-class Dependency(set):
-    """An object for representing a set of msg_id dependencies.
-    
-    Subclassed from set().
-    
-    Parameters
-    ----------
-    dependencies: list/set of msg_ids or AsyncResult objects or output of Dependency.as_dict()
-        The msg_ids to depend on
-    all : bool [default True]
-        Whether the dependency should be considered met when *all* depending tasks have completed
-        or only when *any* have been completed.
-    success : bool [default True]
-        Whether to consider successes as fulfilling dependencies.
-    failure : bool [default False]
-        Whether to consider failures as fulfilling dependencies.
-    
-    If `all=success=True` and `failure=False`, then the task will fail with an ImpossibleDependency
-        as soon as the first depended-upon task fails.
-    """
-    
-    all=True
-    success=True
-    failure=True
-    
-    def __init__(self, dependencies=[], all=True, success=True, failure=False):
-        if isinstance(dependencies, dict):
-            # load from dict
-            all = dependencies.get('all', True)
-            success = dependencies.get('success', success)
-            failure = dependencies.get('failure', failure)
-            dependencies = dependencies.get('dependencies', [])
-        ids = []
-        
-        # extract ids from various sources:
-        if isinstance(dependencies, (basestring, AsyncResult)):
-            dependencies = [dependencies]
-        for d in dependencies:
-            if isinstance(d, basestring):
-                ids.append(d)
-            elif isinstance(d, AsyncResult):
-                ids.extend(d.msg_ids)
-            else:
-                raise TypeError("invalid dependency type: %r"%type(d))
-        
-        set.__init__(self, ids)
-        self.all = all
-        if not (success or failure):
-            raise ValueError("Must depend on at least one of successes or failures!")
-        self.success=success
-        self.failure = failure
-    
-    def check(self, completed, failed=None):
-        """check whether our dependencies have been met."""
-        if len(self) == 0:
-            return True
-        against = set()
-        if self.success:
-            against = completed
-        if failed is not None and self.failure:
-            against = against.union(failed)
-        if self.all:
-            return self.issubset(against)
-        else:
-            return not self.isdisjoint(against)
-    
-    def unreachable(self, completed, failed=None):
-        """return whether this dependency has become impossible."""
-        if len(self) == 0:
-            return False
-        against = set()
-        if not self.success:
-            against = completed
-        if failed is not None and not self.failure:
-            against = against.union(failed)
-        if self.all:
-            return not self.isdisjoint(against)
-        else:
-            return self.issubset(against)
-        
-    
-    def as_dict(self):
-        """Represent this dependency as a dict. For json compatibility."""
-        return dict(
-            dependencies=list(self),
-            all=self.all,
-            success=self.success,
-            failure=self.failure
-        )
-
-
-__all__ = ['depend', 'require', 'dependent', 'Dependency']
-
diff --git a/IPython/parallel/controller/dictdb.py b/IPython/parallel/controller/dictdb.py
deleted file mode 100644
index 6bf2ca89429..00000000000
--- a/IPython/parallel/controller/dictdb.py
+++ /dev/null
@@ -1,180 +0,0 @@
-"""A Task logger that presents our DB interface, 
-but exists entirely in memory and implemented with dicts.
-
-TaskRecords are dicts of the form:
-{
-    'msg_id' : str(uuid),
-    'client_uuid' : str(uuid),
-    'engine_uuid' : str(uuid) or None,
-    'header' : dict(header),
-    'content': dict(content),
-    'buffers': list(buffers),
-    'submitted': datetime,
-    'started': datetime or None,
-    'completed': datetime or None,
-    'resubmitted': datetime or None,
-    'result_header' : dict(header) or None,
-    'result_content' : dict(content) or None,
-    'result_buffers' : list(buffers) or None,
-}
-With this info, many of the special categories of tasks can be defined by query:
-
-pending:  completed is None
-client's outstanding: client_uuid = uuid && completed is None
-MIA: arrived is None (and completed is None)
-etc.
-
-EngineRecords are dicts of the form:
-{
-    'eid' : int(id),
-    'uuid': str(uuid)
-}
-This may be extended, but is currently.
-
-We support a subset of mongodb operators:
-    $lt,$gt,$lte,$gte,$ne,$in,$nin,$all,$mod,$exists
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-
-from datetime import datetime
-
-from IPython.config.configurable import Configurable
-
-from IPython.utils.traitlets import Dict, CUnicode
-
-filters = {
- '$lt' : lambda a,b: a < b,
- '$gt' : lambda a,b: b > a,
- '$eq' : lambda a,b: a == b,
- '$ne' : lambda a,b: a != b,
- '$lte': lambda a,b: a <= b,
- '$gte': lambda a,b: a >= b,
- '$in' : lambda a,b: a in b,
- '$nin': lambda a,b: a not in b,
- '$all': lambda a,b: all([ a in bb for bb in b ]),
- '$mod': lambda a,b: a%b[0] == b[1],
- '$exists' : lambda a,b: (b and a is not None) or (a is None and not b)
-}
-
-
-class CompositeFilter(object):
-    """Composite filter for matching multiple properties."""
-    
-    def __init__(self, dikt):
-        self.tests = []
-        self.values = []
-        for key, value in dikt.iteritems():
-            self.tests.append(filters[key])
-            self.values.append(value)
-
-    def __call__(self, value):
-        for test,check in zip(self.tests, self.values):
-            if not test(value, check):
-                return False
-        return True
-
-class BaseDB(Configurable):
-    """Empty Parent class so traitlets work on DB."""
-    # base configurable traits:
-    session = CUnicode("")
-
-class DictDB(BaseDB):
-    """Basic in-memory dict-based object for saving Task Records.
-    
-    This is the first object to present the DB interface
-    for logging tasks out of memory.
-    
-    The interface is based on MongoDB, so adding a MongoDB
-    backend should be straightforward.
-    """
-    
-    _records = Dict()
-    
-    def _match_one(self, rec, tests):
-        """Check if a specific record matches tests."""
-        for key,test in tests.iteritems():
-            if not test(rec.get(key, None)):
-                return False
-        return True
-        
-    def _match(self, check):
-        """Find all the matches for a check dict."""
-        matches = []
-        tests = {}
-        for k,v in check.iteritems():
-            if isinstance(v, dict):
-                tests[k] = CompositeFilter(v)
-            else:
-                tests[k] = lambda o: o==v
-        
-        for rec in self._records.itervalues():
-            if self._match_one(rec, tests):
-                matches.append(rec)
-        return matches
-    
-    def _extract_subdict(self, rec, keys):
-        """extract subdict of keys"""
-        d = {}
-        d['msg_id'] = rec['msg_id']
-        for key in keys:
-            d[key] = rec[key]
-        return d
-    
-    def add_record(self, msg_id, rec):
-        """Add a new Task Record, by msg_id."""
-        if self._records.has_key(msg_id):
-            raise KeyError("Already have msg_id %r"%(msg_id))
-        self._records[msg_id] = rec
-    
-    def get_record(self, msg_id):
-        """Get a specific Task Record, by msg_id."""
-        if not self._records.has_key(msg_id):
-            raise KeyError("No such msg_id %r"%(msg_id))
-        return self._records[msg_id]
-    
-    def update_record(self, msg_id, rec):
-        """Update the data in an existing record."""
-        self._records[msg_id].update(rec)
-    
-    def drop_matching_records(self, check):
-        """Remove a record from the DB."""
-        matches = self._match(check)
-        for m in matches:
-            del self._records[m]
-        
-    def drop_record(self, msg_id):
-        """Remove a record from the DB."""
-        del self._records[msg_id]
-        
-    
-    def find_records(self, check, keys=None):
-        """Find records matching a query dict, optionally extracting subset of keys.
-        
-        Returns dict keyed by msg_id of matching records.
-        
-        Parameters
-        ----------
-        
-        check: dict
-            mongodb-style query argument
-        keys: list of strs [optional]
-            if specified, the subset of keys to extract.  msg_id will *always* be
-            included.
-        """
-        matches = self._match(check)
-        if keys:
-            return [ self._extract_subdict(rec, keys) for rec in matches ]
-        else:
-            return matches
-        
-    
-    def get_history(self):
-        """get all msg_ids, ordered by time submitted."""
-        msg_ids = self._records.keys()
-        return sorted(msg_ids, key=lambda m: self._records[m]['submitted'])
diff --git a/IPython/parallel/controller/heartmonitor.py b/IPython/parallel/controller/heartmonitor.py
deleted file mode 100644
index 31429ca44c1..00000000000
--- a/IPython/parallel/controller/heartmonitor.py
+++ /dev/null
@@ -1,163 +0,0 @@
-#!/usr/bin/env python
-"""
-A multi-heart Heartbeat system using PUB and XREP sockets. pings are sent out on the PUB,
-and hearts are tracked based on their XREQ identities.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from __future__ import print_function
-import time
-import uuid
-
-import zmq
-from zmq.devices import ProcessDevice, ThreadDevice
-from zmq.eventloop import ioloop, zmqstream
-
-from IPython.utils.traitlets import Set, Instance, CFloat, Bool
-from IPython.parallel.factory import LoggingFactory
-
-class Heart(object):
-    """A basic heart object for responding to a HeartMonitor.
-    This is a simple wrapper with defaults for the most common
-    Device model for responding to heartbeats.
-    
-    It simply builds a threadsafe zmq.FORWARDER Device, defaulting to using 
-    SUB/XREQ for in/out.
-    
-    You can specify the XREQ's IDENTITY via the optional heart_id argument."""
-    device=None
-    id=None
-    def __init__(self, in_addr, out_addr, in_type=zmq.SUB, out_type=zmq.XREQ, heart_id=None):
-        self.device = ThreadDevice(zmq.FORWARDER, in_type, out_type)
-        self.device.daemon=True
-        self.device.connect_in(in_addr)
-        self.device.connect_out(out_addr)
-        if in_type == zmq.SUB:
-            self.device.setsockopt_in(zmq.SUBSCRIBE, "")
-        if heart_id is None:
-            heart_id = str(uuid.uuid4())
-        self.device.setsockopt_out(zmq.IDENTITY, heart_id)
-        self.id = heart_id
-    
-    def start(self):
-        return self.device.start()
-        
-class HeartMonitor(LoggingFactory):
-    """A basic HeartMonitor class
-    pingstream: a PUB stream
-    pongstream: an XREP stream
-    period: the period of the heartbeat in milliseconds"""
-    
-    period=CFloat(1000, config=True) # in milliseconds
-    
-    pingstream=Instance('zmq.eventloop.zmqstream.ZMQStream')
-    pongstream=Instance('zmq.eventloop.zmqstream.ZMQStream')
-    loop = Instance('zmq.eventloop.ioloop.IOLoop')
-    def _loop_default(self):
-        return ioloop.IOLoop.instance()
-    debug=Bool(False)
-    
-    # not settable:
-    hearts=Set()
-    responses=Set()
-    on_probation=Set()
-    last_ping=CFloat(0)
-    _new_handlers = Set()
-    _failure_handlers = Set()
-    lifetime = CFloat(0)
-    tic = CFloat(0)
-    
-    def __init__(self, **kwargs):
-        super(HeartMonitor, self).__init__(**kwargs)
-        
-        self.pongstream.on_recv(self.handle_pong)
-    
-    def start(self):
-        self.caller = ioloop.PeriodicCallback(self.beat, self.period, self.loop)
-        self.caller.start()
-    
-    def add_new_heart_handler(self, handler):
-        """add a new handler for new hearts"""
-        self.log.debug("heartbeat::new_heart_handler: %s"%handler)
-        self._new_handlers.add(handler)
-        
-    def add_heart_failure_handler(self, handler):
-        """add a new handler for heart failure"""
-        self.log.debug("heartbeat::new heart failure handler: %s"%handler)
-        self._failure_handlers.add(handler)
-            
-    def beat(self):
-        self.pongstream.flush() 
-        self.last_ping = self.lifetime
-        
-        toc = time.time()
-        self.lifetime += toc-self.tic
-        self.tic = toc
-        # self.log.debug("heartbeat::%s"%self.lifetime)
-        goodhearts = self.hearts.intersection(self.responses)
-        missed_beats = self.hearts.difference(goodhearts)
-        heartfailures = self.on_probation.intersection(missed_beats)
-        newhearts = self.responses.difference(goodhearts)
-        map(self.handle_new_heart, newhearts)
-        map(self.handle_heart_failure, heartfailures)
-        self.on_probation = missed_beats.intersection(self.hearts)
-        self.responses = set()
-        # print self.on_probation, self.hearts
-        # self.log.debug("heartbeat::beat %.3f, %i beating hearts"%(self.lifetime, len(self.hearts)))
-        self.pingstream.send(str(self.lifetime))
-    
-    def handle_new_heart(self, heart):
-        if self._new_handlers:
-            for handler in self._new_handlers:
-                handler(heart)
-        else:
-            self.log.info("heartbeat::yay, got new heart %s!"%heart)
-        self.hearts.add(heart)
-    
-    def handle_heart_failure(self, heart):
-        if self._failure_handlers:
-            for handler in self._failure_handlers:
-                try:
-                    handler(heart)
-                except Exception as e:
-                    self.log.error("heartbeat::Bad Handler! %s"%handler, exc_info=True)
-                    pass
-        else:
-            self.log.info("heartbeat::Heart %s failed :("%heart)
-        self.hearts.remove(heart)
-        
-    
-    def handle_pong(self, msg):
-        "a heart just beat"
-        if msg[1] == str(self.lifetime):
-            delta = time.time()-self.tic
-            # self.log.debug("heartbeat::heart %r took %.2f ms to respond"%(msg[0], 1000*delta))
-            self.responses.add(msg[0])
-        elif msg[1] == str(self.last_ping):
-            delta = time.time()-self.tic + (self.lifetime-self.last_ping)
-            self.log.warn("heartbeat::heart %r missed a beat, and took %.2f ms to respond"%(msg[0], 1000*delta))
-            self.responses.add(msg[0])
-        else:
-            self.log.warn("heartbeat::got bad heartbeat (possibly old?): %s (current=%.3f)"%
-            (msg[1],self.lifetime))
-
-
-if __name__ == '__main__':
-    loop = ioloop.IOLoop.instance()
-    context = zmq.Context()
-    pub = context.socket(zmq.PUB)
-    pub.bind('tcp://127.0.0.1:5555')
-    xrep = context.socket(zmq.XREP)
-    xrep.bind('tcp://127.0.0.1:5556')
-    
-    outstream = zmqstream.ZMQStream(pub, loop)
-    instream = zmqstream.ZMQStream(xrep, loop)
-    
-    hb = HeartMonitor(loop, outstream, instream)
-    
-    loop.start()
diff --git a/IPython/parallel/controller/hub.py b/IPython/parallel/controller/hub.py
deleted file mode 100755
index 9b2ffcbe2a7..00000000000
--- a/IPython/parallel/controller/hub.py
+++ /dev/null
@@ -1,1193 +0,0 @@
-#!/usr/bin/env python
-"""The IPython Controller Hub with 0MQ
-This is the master object that handles connections from engines and clients,
-and monitors traffic through the various queues.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-import sys
-import time
-from datetime import datetime
-
-import zmq
-from zmq.eventloop import ioloop
-from zmq.eventloop.zmqstream import ZMQStream
-
-# internal:
-from IPython.utils.importstring import import_item
-from IPython.utils.traitlets import HasTraits, Instance, Int, CStr, Str, Dict, Set, List, Bool
-
-from IPython.parallel import error, util
-from IPython.parallel.factory import RegistrationFactory, LoggingFactory
-
-from .heartmonitor import HeartMonitor
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-def _passer(*args, **kwargs):
-    return
-
-def _printer(*args, **kwargs):
-    print (args)
-    print (kwargs)
-
-def empty_record():
-    """Return an empty dict with all record keys."""
-    return {
-        'msg_id' : None,
-        'header' : None,
-        'content': None,
-        'buffers': None,
-        'submitted': None,
-        'client_uuid' : None,
-        'engine_uuid' : None,
-        'started': None,
-        'completed': None,
-        'resubmitted': None,
-        'result_header' : None,
-        'result_content' : None,
-        'result_buffers' : None,
-        'queue' : None,
-        'pyin' : None,
-        'pyout': None,
-        'pyerr': None,
-        'stdout': '',
-        'stderr': '',
-    }
-    
-def init_record(msg):
-    """Initialize a TaskRecord based on a request."""
-    header = msg['header']
-    return {
-        'msg_id' : header['msg_id'],
-        'header' : header,
-        'content': msg['content'],
-        'buffers': msg['buffers'],
-        'submitted': datetime.strptime(header['date'], util.ISO8601),
-        'client_uuid' : None,
-        'engine_uuid' : None,
-        'started': None,
-        'completed': None,
-        'resubmitted': None,
-        'result_header' : None,
-        'result_content' : None,
-        'result_buffers' : None,
-        'queue' : None,
-        'pyin' : None,
-        'pyout': None,
-        'pyerr': None,
-        'stdout': '',
-        'stderr': '',
-    }
-
-
-class EngineConnector(HasTraits):
-    """A simple object for accessing the various zmq connections of an object.
-    Attributes are:
-    id (int): engine ID
-    uuid (str): uuid (unused?)
-    queue (str): identity of queue's XREQ socket
-    registration (str): identity of registration XREQ socket
-    heartbeat (str): identity of heartbeat XREQ socket
-    """
-    id=Int(0)
-    queue=Str()
-    control=Str()
-    registration=Str()
-    heartbeat=Str()
-    pending=Set()
-
-class HubFactory(RegistrationFactory):
-    """The Configurable for setting up a Hub."""
-    
-    # name of a scheduler scheme
-    scheme = Str('leastload', config=True)
-    
-    # port-pairs for monitoredqueues:
-    hb = Instance(list, config=True)
-    def _hb_default(self):
-        return util.select_random_ports(2)
-    
-    mux = Instance(list, config=True)
-    def _mux_default(self):
-        return util.select_random_ports(2)
-    
-    task = Instance(list, config=True)
-    def _task_default(self):
-        return util.select_random_ports(2)
-    
-    control = Instance(list, config=True)
-    def _control_default(self):
-        return util.select_random_ports(2)
-    
-    iopub = Instance(list, config=True)
-    def _iopub_default(self):
-        return util.select_random_ports(2)
-    
-    # single ports:
-    mon_port = Instance(int, config=True)
-    def _mon_port_default(self):
-        return util.select_random_ports(1)[0]
-    
-    notifier_port = Instance(int, config=True)
-    def _notifier_port_default(self):
-        return util.select_random_ports(1)[0]
-    
-    ping = Int(1000, config=True) # ping frequency
-    
-    engine_ip = CStr('127.0.0.1', config=True)
-    engine_transport = CStr('tcp', config=True)
-    
-    client_ip = CStr('127.0.0.1', config=True)
-    client_transport = CStr('tcp', config=True)
-    
-    monitor_ip = CStr('127.0.0.1', config=True)
-    monitor_transport = CStr('tcp', config=True)
-    
-    monitor_url = CStr('')
-    
-    db_class = CStr('IPython.parallel.controller.dictdb.DictDB', config=True)
-    
-    # not configurable
-    db = Instance('IPython.parallel.controller.dictdb.BaseDB')
-    heartmonitor = Instance('IPython.parallel.controller.heartmonitor.HeartMonitor')
-    subconstructors = List()
-    _constructed = Bool(False)
-    
-    def _ip_changed(self, name, old, new):
-        self.engine_ip = new
-        self.client_ip = new
-        self.monitor_ip = new
-        self._update_monitor_url()
-    
-    def _update_monitor_url(self):
-        self.monitor_url = "%s://%s:%i"%(self.monitor_transport, self.monitor_ip, self.mon_port)
-    
-    def _transport_changed(self, name, old, new):
-        self.engine_transport = new
-        self.client_transport = new
-        self.monitor_transport = new
-        self._update_monitor_url()
-        
-    def __init__(self, **kwargs):
-        super(HubFactory, self).__init__(**kwargs)
-        self._update_monitor_url()
-        # self.on_trait_change(self._sync_ips, 'ip')
-        # self.on_trait_change(self._sync_transports, 'transport')
-        self.subconstructors.append(self.construct_hub)
-    
-    
-    def construct(self):
-        assert not self._constructed, "already constructed!"
-        
-        for subc in self.subconstructors:
-            subc()
-        
-        self._constructed = True
-        
-    
-    def start(self):
-        assert self._constructed, "must be constructed by self.construct() first!"
-        self.heartmonitor.start()
-        self.log.info("Heartmonitor started")
-    
-    def construct_hub(self):
-        """construct"""
-        client_iface = "%s://%s:"%(self.client_transport, self.client_ip) + "%i"
-        engine_iface = "%s://%s:"%(self.engine_transport, self.engine_ip) + "%i"
-        
-        ctx = self.context
-        loop = self.loop
-        
-        # Registrar socket
-        q = ZMQStream(ctx.socket(zmq.XREP), loop)
-        q.bind(client_iface % self.regport)
-        self.log.info("Hub listening on %s for registration."%(client_iface%self.regport))
-        if self.client_ip != self.engine_ip:
-            q.bind(engine_iface % self.regport)
-            self.log.info("Hub listening on %s for registration."%(engine_iface%self.regport))
-        
-        ### Engine connections ###
-
-        # heartbeat
-        hpub = ctx.socket(zmq.PUB)
-        hpub.bind(engine_iface % self.hb[0])
-        hrep = ctx.socket(zmq.XREP)
-        hrep.bind(engine_iface % self.hb[1])
-        self.heartmonitor = HeartMonitor(loop=loop, pingstream=ZMQStream(hpub,loop), pongstream=ZMQStream(hrep,loop), 
-                                period=self.ping, logname=self.log.name)
-
-        ### Client connections ###
-        # Notifier socket
-        n = ZMQStream(ctx.socket(zmq.PUB), loop)
-        n.bind(client_iface%self.notifier_port)
-
-        ### build and launch the queues ###
-
-        # monitor socket
-        sub = ctx.socket(zmq.SUB)
-        sub.setsockopt(zmq.SUBSCRIBE, "")
-        sub.bind(self.monitor_url)
-        sub.bind('inproc://monitor')
-        sub = ZMQStream(sub, loop)
-        
-        # connect the db
-        self.log.info('Hub using DB backend: %r'%(self.db_class.split()[-1]))
-        # cdir = self.config.Global.cluster_dir
-        self.db = import_item(self.db_class)(session=self.session.session, config=self.config)
-        time.sleep(.25)
-
-        # build connection dicts
-        self.engine_info = {
-            'control' : engine_iface%self.control[1],
-            'mux': engine_iface%self.mux[1],
-            'heartbeat': (engine_iface%self.hb[0], engine_iface%self.hb[1]),
-            'task' : engine_iface%self.task[1],
-            'iopub' : engine_iface%self.iopub[1],
-            # 'monitor' : engine_iface%self.mon_port,
-            }
-
-        self.client_info = {
-            'control' : client_iface%self.control[0],
-            'mux': client_iface%self.mux[0],
-            'task' : (self.scheme, client_iface%self.task[0]),
-            'iopub' : client_iface%self.iopub[0],
-            'notification': client_iface%self.notifier_port
-            }
-        self.log.debug("Hub engine addrs: %s"%self.engine_info)
-        self.log.debug("Hub client addrs: %s"%self.client_info)
-        self.hub = Hub(loop=loop, session=self.session, monitor=sub, heartmonitor=self.heartmonitor,
-                query=q, notifier=n, db=self.db,
-                engine_info=self.engine_info, client_info=self.client_info,
-                logname=self.log.name)
-    
-
-class Hub(LoggingFactory):
-    """The IPython Controller Hub with 0MQ connections
-    
-    Parameters
-    ==========
-    loop: zmq IOLoop instance
-    session: StreamSession object
-    <removed> context: zmq context for creating new connections (?)
-    queue: ZMQStream for monitoring the command queue (SUB)
-    query: ZMQStream for engine registration and client queries requests (XREP)
-    heartbeat: HeartMonitor object checking the pulse of the engines
-    notifier: ZMQStream for broadcasting engine registration changes (PUB)
-    db: connection to db for out of memory logging of commands
-                NotImplemented
-    engine_info: dict of zmq connection information for engines to connect
-                to the queues.
-    client_info: dict of zmq connection information for engines to connect
-                to the queues.
-    """
-    # internal data structures:
-    ids=Set() # engine IDs
-    keytable=Dict()
-    by_ident=Dict()
-    engines=Dict()
-    clients=Dict()
-    hearts=Dict()
-    pending=Set()
-    queues=Dict()  # pending msg_ids keyed by engine_id
-    tasks=Dict() # pending msg_ids submitted as tasks, keyed by client_id
-    completed=Dict() # completed msg_ids keyed by engine_id
-    all_completed=Set() # completed msg_ids keyed by engine_id
-    dead_engines=Set() # completed msg_ids keyed by engine_id
-    unassigned=Set() # set of task msg_ds not yet assigned a destination
-    incoming_registrations=Dict()
-    registration_timeout=Int()
-    _idcounter=Int(0)
-    
-    # objects from constructor:
-    loop=Instance(ioloop.IOLoop)
-    query=Instance(ZMQStream)
-    monitor=Instance(ZMQStream)
-    heartmonitor=Instance(HeartMonitor)
-    notifier=Instance(ZMQStream)
-    db=Instance(object)
-    client_info=Dict()
-    engine_info=Dict()
-    
-    
-    def __init__(self, **kwargs):
-        """
-        # universal:
-        loop: IOLoop for creating future connections
-        session: streamsession for sending serialized data
-        # engine:
-        queue: ZMQStream for monitoring queue messages
-        query: ZMQStream for engine+client registration and client requests
-        heartbeat: HeartMonitor object for tracking engines
-        # extra:
-        db: ZMQStream for db connection (NotImplemented)
-        engine_info: zmq address/protocol dict for engine connections
-        client_info: zmq address/protocol dict for client connections
-        """
-        
-        super(Hub, self).__init__(**kwargs)
-        self.registration_timeout = max(5000, 2*self.heartmonitor.period)
-        
-        # validate connection dicts:
-        for k,v in self.client_info.iteritems():
-            if k == 'task':
-                util.validate_url_container(v[1])
-            else:
-                util.validate_url_container(v)
-        # util.validate_url_container(self.client_info)
-        util.validate_url_container(self.engine_info)
-        
-        # register our callbacks
-        self.query.on_recv(self.dispatch_query)
-        self.monitor.on_recv(self.dispatch_monitor_traffic)
-        
-        self.heartmonitor.add_heart_failure_handler(self.handle_heart_failure)
-        self.heartmonitor.add_new_heart_handler(self.handle_new_heart)
-        
-        self.monitor_handlers = { 'in' : self.save_queue_request,
-                                'out': self.save_queue_result,
-                                'intask': self.save_task_request,
-                                'outtask': self.save_task_result,
-                                'tracktask': self.save_task_destination,
-                                'incontrol': _passer,
-                                'outcontrol': _passer,
-                                'iopub': self.save_iopub_message,
-        }
-        
-        self.query_handlers = {'queue_request': self.queue_status,
-                                'result_request': self.get_results,
-                                'history_request': self.get_history,
-                                'db_request': self.db_query,
-                                'purge_request': self.purge_results,
-                                'load_request': self.check_load,
-                                'resubmit_request': self.resubmit_task,
-                                'shutdown_request': self.shutdown_request,
-                                'registration_request' : self.register_engine,
-                                'unregistration_request' : self.unregister_engine,
-                                'connection_request': self.connection_request,
-        }
-        
-        self.log.info("hub::created hub")
-    
-    @property
-    def _next_id(self):
-        """gemerate a new ID.
-        
-        No longer reuse old ids, just count from 0."""
-        newid = self._idcounter
-        self._idcounter += 1
-        return newid
-        # newid = 0
-        # incoming = [id[0] for id in self.incoming_registrations.itervalues()]
-        # # print newid, self.ids, self.incoming_registrations
-        # while newid in self.ids or newid in incoming:
-        #     newid += 1
-        # return newid
-    
-    #-----------------------------------------------------------------------------
-    # message validation
-    #-----------------------------------------------------------------------------
-    
-    def _validate_targets(self, targets):
-        """turn any valid targets argument into a list of integer ids"""
-        if targets is None:
-            # default to all
-            targets = self.ids
-            
-        if isinstance(targets, (int,str,unicode)):
-            # only one target specified
-            targets = [targets]
-        _targets = []
-        for t in targets:
-            # map raw identities to ids
-            if isinstance(t, (str,unicode)):
-                t = self.by_ident.get(t, t)
-            _targets.append(t)
-        targets = _targets
-        bad_targets = [ t for t in targets if t not in self.ids ]
-        if bad_targets:
-            raise IndexError("No Such Engine: %r"%bad_targets)
-        if not targets:
-            raise IndexError("No Engines Registered")
-        return targets
-    
-    #-----------------------------------------------------------------------------
-    # dispatch methods (1 per stream)
-    #-----------------------------------------------------------------------------
-    
-    # def dispatch_registration_request(self, msg):
-    #     """"""
-    #     self.log.debug("registration::dispatch_register_request(%s)"%msg)
-    #     idents,msg = self.session.feed_identities(msg)
-    #     if not idents:
-    #         self.log.error("Bad Query Message: %s"%msg, exc_info=True)
-    #         return
-    #     try:
-    #         msg = self.session.unpack_message(msg,content=True)
-    #     except:
-    #         self.log.error("registration::got bad registration message: %s"%msg, exc_info=True)
-    #         return
-    #     
-    #     msg_type = msg['msg_type']
-    #     content = msg['content']
-    #     
-    #     handler = self.query_handlers.get(msg_type, None)
-    #     if handler is None:
-    #         self.log.error("registration::got bad registration message: %s"%msg)
-    #     else:
-    #         handler(idents, msg)
-    
-    def dispatch_monitor_traffic(self, msg):
-        """all ME and Task queue messages come through here, as well as
-        IOPub traffic."""
-        self.log.debug("monitor traffic: %s"%msg[:2])
-        switch = msg[0]
-        idents, msg = self.session.feed_identities(msg[1:])
-        if not idents:
-            self.log.error("Bad Monitor Message: %s"%msg)
-            return
-        handler = self.monitor_handlers.get(switch, None)
-        if handler is not None:
-            handler(idents, msg)
-        else:
-            self.log.error("Invalid monitor topic: %s"%switch)
-        
-    
-    def dispatch_query(self, msg):
-        """Route registration requests and queries from clients."""
-        idents, msg = self.session.feed_identities(msg)
-        if not idents:
-            self.log.error("Bad Query Message: %s"%msg)
-            return
-        client_id = idents[0]
-        try:
-            msg = self.session.unpack_message(msg, content=True)
-        except:
-            content = error.wrap_exception()
-            self.log.error("Bad Query Message: %s"%msg, exc_info=True)
-            self.session.send(self.query, "hub_error", ident=client_id, 
-                    content=content)
-            return
-        
-        # print client_id, header, parent, content
-        #switch on message type:
-        msg_type = msg['msg_type']
-        self.log.info("client::client %s requested %s"%(client_id, msg_type))
-        handler = self.query_handlers.get(msg_type, None)
-        try:
-            assert handler is not None, "Bad Message Type: %s"%msg_type
-        except:
-            content = error.wrap_exception()
-            self.log.error("Bad Message Type: %s"%msg_type, exc_info=True)
-            self.session.send(self.query, "hub_error", ident=client_id, 
-                    content=content)
-            return
-        else:
-            handler(idents, msg)
-            
-    def dispatch_db(self, msg):
-        """"""
-        raise NotImplementedError
-    
-    #---------------------------------------------------------------------------
-    # handler methods (1 per event)
-    #---------------------------------------------------------------------------
-    
-    #----------------------- Heartbeat --------------------------------------
-    
-    def handle_new_heart(self, heart):
-        """handler to attach to heartbeater.
-        Called when a new heart starts to beat.
-        Triggers completion of registration."""
-        self.log.debug("heartbeat::handle_new_heart(%r)"%heart)
-        if heart not in self.incoming_registrations:
-            self.log.info("heartbeat::ignoring new heart: %r"%heart)
-        else:
-            self.finish_registration(heart)
-        
-    
-    def handle_heart_failure(self, heart):
-        """handler to attach to heartbeater.
-        called when a previously registered heart fails to respond to beat request.
-        triggers unregistration"""
-        self.log.debug("heartbeat::handle_heart_failure(%r)"%heart)
-        eid = self.hearts.get(heart, None)
-        queue = self.engines[eid].queue
-        if eid is None:
-            self.log.info("heartbeat::ignoring heart failure %r"%heart)
-        else:
-            self.unregister_engine(heart, dict(content=dict(id=eid, queue=queue)))
-    
-    #----------------------- MUX Queue Traffic ------------------------------
-    
-    def save_queue_request(self, idents, msg):
-        if len(idents) < 2:
-            self.log.error("invalid identity prefix: %s"%idents)
-            return
-        queue_id, client_id = idents[:2]
-        try:
-            msg = self.session.unpack_message(msg, content=False)
-        except:
-            self.log.error("queue::client %r sent invalid message to %r: %s"%(client_id, queue_id, msg), exc_info=True)
-            return
-        
-        eid = self.by_ident.get(queue_id, None)
-        if eid is None:
-            self.log.error("queue::target %r not registered"%queue_id)
-            self.log.debug("queue::    valid are: %s"%(self.by_ident.keys()))
-            return
-            
-        header = msg['header']
-        msg_id = header['msg_id']
-        record = init_record(msg)
-        record['engine_uuid'] = queue_id
-        record['client_uuid'] = client_id
-        record['queue'] = 'mux'
-
-        try:
-            # it's posible iopub arrived first:
-            existing = self.db.get_record(msg_id)
-            for key,evalue in existing.iteritems():
-                rvalue = record[key]
-                if evalue and rvalue and evalue != rvalue:
-                    self.log.error("conflicting initial state for record: %s:%s <> %s"%(msg_id, rvalue, evalue))
-                elif evalue and not rvalue:
-                    record[key] = evalue
-            self.db.update_record(msg_id, record)
-        except KeyError:
-            self.db.add_record(msg_id, record)
-        
-        self.pending.add(msg_id)
-        self.queues[eid].append(msg_id)
-    
-    def save_queue_result(self, idents, msg):
-        if len(idents) < 2:
-            self.log.error("invalid identity prefix: %s"%idents)
-            return
-            
-        client_id, queue_id = idents[:2]
-        try:
-            msg = self.session.unpack_message(msg, content=False)
-        except:
-            self.log.error("queue::engine %r sent invalid message to %r: %s"%(
-                    queue_id,client_id, msg), exc_info=True)
-            return
-        
-        eid = self.by_ident.get(queue_id, None)
-        if eid is None:
-            self.log.error("queue::unknown engine %r is sending a reply: "%queue_id)
-            # self.log.debug("queue::       %s"%msg[2:])
-            return
-        
-        parent = msg['parent_header']
-        if not parent:
-            return
-        msg_id = parent['msg_id']
-        if msg_id in self.pending:
-            self.pending.remove(msg_id)
-            self.all_completed.add(msg_id)
-            self.queues[eid].remove(msg_id)
-            self.completed[eid].append(msg_id)
-        elif msg_id not in self.all_completed:
-            # it could be a result from a dead engine that died before delivering the
-            # result
-            self.log.warn("queue:: unknown msg finished %s"%msg_id)
-            return
-        # update record anyway, because the unregistration could have been premature
-        rheader = msg['header']
-        completed = datetime.strptime(rheader['date'], util.ISO8601)
-        started = rheader.get('started', None)
-        if started is not None:
-            started = datetime.strptime(started, util.ISO8601)
-        result = {
-            'result_header' : rheader,
-            'result_content': msg['content'],
-            'started' : started,
-            'completed' : completed
-        }
-
-        result['result_buffers'] = msg['buffers']
-        try:
-            self.db.update_record(msg_id, result)
-        except Exception:
-            self.log.error("DB Error updating record %r"%msg_id, exc_info=True)
-        
-            
-    #--------------------- Task Queue Traffic ------------------------------
-    
-    def save_task_request(self, idents, msg):
-        """Save the submission of a task."""
-        client_id = idents[0]
-        
-        try:
-            msg = self.session.unpack_message(msg, content=False)
-        except:
-            self.log.error("task::client %r sent invalid task message: %s"%(
-                    client_id, msg), exc_info=True)
-            return
-        record = init_record(msg)
-
-        record['client_uuid'] = client_id
-        record['queue'] = 'task'
-        header = msg['header']
-        msg_id = header['msg_id']
-        self.pending.add(msg_id)
-        self.unassigned.add(msg_id)
-        try:
-            # it's posible iopub arrived first:
-            existing = self.db.get_record(msg_id)
-            for key,evalue in existing.iteritems():
-                rvalue = record[key]
-                if evalue and rvalue and evalue != rvalue:
-                    self.log.error("conflicting initial state for record: %s:%s <> %s"%(msg_id, rvalue, evalue))
-                elif evalue and not rvalue:
-                    record[key] = evalue
-            self.db.update_record(msg_id, record)
-        except KeyError:
-            self.db.add_record(msg_id, record)
-        except Exception:
-            self.log.error("DB Error saving task request %r"%msg_id, exc_info=True)
-    
-    def save_task_result(self, idents, msg):
-        """save the result of a completed task."""
-        client_id = idents[0]
-        try:
-            msg = self.session.unpack_message(msg, content=False)
-        except:
-            self.log.error("task::invalid task result message send to %r: %s"%(
-                    client_id, msg), exc_info=True)
-            raise
-            return
-        
-        parent = msg['parent_header']
-        if not parent:
-            # print msg
-            self.log.warn("Task %r had no parent!"%msg)
-            return
-        msg_id = parent['msg_id']
-        if msg_id in self.unassigned:
-            self.unassigned.remove(msg_id)
-        
-        header = msg['header']
-        engine_uuid = header.get('engine', None)
-        eid = self.by_ident.get(engine_uuid, None)
-        
-        if msg_id in self.pending:
-            self.pending.remove(msg_id)
-            self.all_completed.add(msg_id)
-            if eid is not None:
-                self.completed[eid].append(msg_id)
-                if msg_id in self.tasks[eid]:
-                    self.tasks[eid].remove(msg_id)
-            completed = datetime.strptime(header['date'], util.ISO8601)
-            started = header.get('started', None)
-            if started is not None:
-                started = datetime.strptime(started, util.ISO8601)
-            result = {
-                'result_header' : header,
-                'result_content': msg['content'],
-                'started' : started,
-                'completed' : completed,
-                'engine_uuid': engine_uuid
-            }
-
-            result['result_buffers'] = msg['buffers']
-            try:
-                self.db.update_record(msg_id, result)
-            except Exception:
-                self.log.error("DB Error saving task request %r"%msg_id, exc_info=True)
-            
-        else:
-            self.log.debug("task::unknown task %s finished"%msg_id)
-    
-    def save_task_destination(self, idents, msg):
-        try:
-            msg = self.session.unpack_message(msg, content=True)
-        except:
-            self.log.error("task::invalid task tracking message", exc_info=True)
-            return
-        content = msg['content']
-        # print (content)
-        msg_id = content['msg_id']
-        engine_uuid = content['engine_id']
-        eid = self.by_ident[engine_uuid]
-        
-        self.log.info("task::task %s arrived on %s"%(msg_id, eid))
-        if msg_id in self.unassigned:
-            self.unassigned.remove(msg_id)
-        # else:
-        #     self.log.debug("task::task %s not listed as MIA?!"%(msg_id))
-        
-        self.tasks[eid].append(msg_id)
-        # self.pending[msg_id][1].update(received=datetime.now(),engine=(eid,engine_uuid))
-        try:
-            self.db.update_record(msg_id, dict(engine_uuid=engine_uuid))
-        except Exception:
-            self.log.error("DB Error saving task destination %r"%msg_id, exc_info=True)
-            
-    
-    def mia_task_request(self, idents, msg):
-        raise NotImplementedError
-        client_id = idents[0]
-        # content = dict(mia=self.mia,status='ok')
-        # self.session.send('mia_reply', content=content, idents=client_id)
-        
-        
-    #--------------------- IOPub Traffic ------------------------------
-    
-    def save_iopub_message(self, topics, msg):
-        """save an iopub message into the db"""
-        # print (topics)
-        try:
-            msg = self.session.unpack_message(msg, content=True)
-        except:
-            self.log.error("iopub::invalid IOPub message", exc_info=True)
-            return
-        
-        parent = msg['parent_header']
-        if not parent:
-            self.log.error("iopub::invalid IOPub message: %s"%msg)
-            return
-        msg_id = parent['msg_id']
-        msg_type = msg['msg_type']
-        content = msg['content']
-        
-        # ensure msg_id is in db
-        try:
-            rec = self.db.get_record(msg_id)
-        except KeyError:
-            rec = empty_record()
-            rec['msg_id'] = msg_id
-            self.db.add_record(msg_id, rec)
-        # stream
-        d = {}
-        if msg_type == 'stream':
-            name = content['name']
-            s = rec[name] or ''
-            d[name] = s + content['data']
-            
-        elif msg_type == 'pyerr':
-            d['pyerr'] = content
-        elif msg_type == 'pyin':
-            d['pyin'] = content['code']
-        else:
-            d[msg_type] = content.get('data', '')
-        
-        try:
-            self.db.update_record(msg_id, d)
-        except Exception:
-            self.log.error("DB Error saving iopub message %r"%msg_id, exc_info=True)
-        
-    
-            
-    #-------------------------------------------------------------------------
-    # Registration requests
-    #-------------------------------------------------------------------------
-        
-    def connection_request(self, client_id, msg):
-        """Reply with connection addresses for clients."""
-        self.log.info("client::client %s connected"%client_id)
-        content = dict(status='ok')
-        content.update(self.client_info)
-        jsonable = {}
-        for k,v in self.keytable.iteritems():
-            if v not in self.dead_engines:
-                jsonable[str(k)] = v
-        content['engines'] = jsonable
-        self.session.send(self.query, 'connection_reply', content, parent=msg, ident=client_id)
-    
-    def register_engine(self, reg, msg):
-        """Register a new engine."""
-        content = msg['content']
-        try:
-            queue = content['queue']
-        except KeyError:
-            self.log.error("registration::queue not specified", exc_info=True)
-            return
-        heart = content.get('heartbeat', None)
-        """register a new engine, and create the socket(s) necessary"""
-        eid = self._next_id
-        # print (eid, queue, reg, heart)
-        
-        self.log.debug("registration::register_engine(%i, %r, %r, %r)"%(eid, queue, reg, heart))
-        
-        content = dict(id=eid,status='ok')
-        content.update(self.engine_info)
-        # check if requesting available IDs:
-        if queue in self.by_ident:
-            try:
-                raise KeyError("queue_id %r in use"%queue)
-            except:
-                content = error.wrap_exception()
-                self.log.error("queue_id %r in use"%queue, exc_info=True)
-        elif heart in self.hearts: # need to check unique hearts?
-            try:
-                raise KeyError("heart_id %r in use"%heart)
-            except:
-                self.log.error("heart_id %r in use"%heart, exc_info=True)
-                content = error.wrap_exception()
-        else:
-            for h, pack in self.incoming_registrations.iteritems():
-                if heart == h:
-                    try:
-                        raise KeyError("heart_id %r in use"%heart)
-                    except:
-                        self.log.error("heart_id %r in use"%heart, exc_info=True)
-                        content = error.wrap_exception()
-                    break
-                elif queue == pack[1]:
-                    try:
-                        raise KeyError("queue_id %r in use"%queue)
-                    except:
-                        self.log.error("queue_id %r in use"%queue, exc_info=True)
-                        content = error.wrap_exception()
-                    break
-        
-        msg = self.session.send(self.query, "registration_reply", 
-                content=content, 
-                ident=reg)
-        
-        if content['status'] == 'ok':
-            if heart in self.heartmonitor.hearts:
-                # already beating
-                self.incoming_registrations[heart] = (eid,queue,reg[0],None)
-                self.finish_registration(heart)
-            else:
-                purge = lambda : self._purge_stalled_registration(heart)
-                dc = ioloop.DelayedCallback(purge, self.registration_timeout, self.loop)
-                dc.start()
-                self.incoming_registrations[heart] = (eid,queue,reg[0],dc)
-        else:
-            self.log.error("registration::registration %i failed: %s"%(eid, content['evalue']))
-        return eid
-    
-    def unregister_engine(self, ident, msg):
-        """Unregister an engine that explicitly requested to leave."""
-        try:
-            eid = msg['content']['id']
-        except:
-            self.log.error("registration::bad engine id for unregistration: %s"%ident, exc_info=True)
-            return
-        self.log.info("registration::unregister_engine(%s)"%eid)
-        # print (eid)
-        uuid = self.keytable[eid]
-        content=dict(id=eid, queue=uuid)
-        self.dead_engines.add(uuid)
-        # self.ids.remove(eid)
-        # uuid = self.keytable.pop(eid)
-        # 
-        # ec = self.engines.pop(eid)
-        # self.hearts.pop(ec.heartbeat)
-        # self.by_ident.pop(ec.queue)
-        # self.completed.pop(eid)
-        handleit = lambda : self._handle_stranded_msgs(eid, uuid)
-        dc = ioloop.DelayedCallback(handleit, self.registration_timeout, self.loop)
-        dc.start()
-        ############## TODO: HANDLE IT ################
-        
-        if self.notifier:
-            self.session.send(self.notifier, "unregistration_notification", content=content)
-    
-    def _handle_stranded_msgs(self, eid, uuid):
-        """Handle messages known to be on an engine when the engine unregisters.
-        
-        It is possible that this will fire prematurely - that is, an engine will
-        go down after completing a result, and the client will be notified
-        that the result failed and later receive the actual result.
-        """
-        
-        outstanding = self.queues[eid]
-        
-        for msg_id in outstanding:
-            self.pending.remove(msg_id)
-            self.all_completed.add(msg_id)
-            try:
-                raise error.EngineError("Engine %r died while running task %r"%(eid, msg_id))
-            except:
-                content = error.wrap_exception()
-            # build a fake header:
-            header = {}
-            header['engine'] = uuid
-            header['date'] = datetime.now()
-            rec = dict(result_content=content, result_header=header, result_buffers=[])
-            rec['completed'] = header['date']
-            rec['engine_uuid'] = uuid
-            try:
-                self.db.update_record(msg_id, rec)
-            except Exception:
-                self.log.error("DB Error handling stranded msg %r"%msg_id, exc_info=True)
-                
-    
-    def finish_registration(self, heart):
-        """Second half of engine registration, called after our HeartMonitor
-        has received a beat from the Engine's Heart."""
-        try: 
-            (eid,queue,reg,purge) = self.incoming_registrations.pop(heart)
-        except KeyError:
-            self.log.error("registration::tried to finish nonexistant registration", exc_info=True)
-            return
-        self.log.info("registration::finished registering engine %i:%r"%(eid,queue))
-        if purge is not None:
-            purge.stop()
-        control = queue
-        self.ids.add(eid)
-        self.keytable[eid] = queue
-        self.engines[eid] = EngineConnector(id=eid, queue=queue, registration=reg, 
-                                    control=control, heartbeat=heart)
-        self.by_ident[queue] = eid
-        self.queues[eid] = list()
-        self.tasks[eid] = list()
-        self.completed[eid] = list()
-        self.hearts[heart] = eid
-        content = dict(id=eid, queue=self.engines[eid].queue)
-        if self.notifier:
-            self.session.send(self.notifier, "registration_notification", content=content)
-        self.log.info("engine::Engine Connected: %i"%eid)
-    
-    def _purge_stalled_registration(self, heart):
-        if heart in self.incoming_registrations:
-            eid = self.incoming_registrations.pop(heart)[0]
-            self.log.info("registration::purging stalled registration: %i"%eid)
-        else:
-            pass
-            
-    #-------------------------------------------------------------------------
-    # Client Requests
-    #-------------------------------------------------------------------------
-    
-    def shutdown_request(self, client_id, msg):
-        """handle shutdown request."""
-        self.session.send(self.query, 'shutdown_reply', content={'status': 'ok'}, ident=client_id)
-        # also notify other clients of shutdown
-        self.session.send(self.notifier, 'shutdown_notice', content={'status': 'ok'})
-        dc = ioloop.DelayedCallback(lambda : self._shutdown(), 1000, self.loop)
-        dc.start()
-    
-    def _shutdown(self):
-        self.log.info("hub::hub shutting down.")
-        time.sleep(0.1)
-        sys.exit(0)
-        
-    
-    def check_load(self, client_id, msg):
-        content = msg['content']
-        try:
-            targets = content['targets']
-            targets = self._validate_targets(targets)
-        except:
-            content = error.wrap_exception()
-            self.session.send(self.query, "hub_error", 
-                    content=content, ident=client_id)
-            return
-        
-        content = dict(status='ok')
-        # loads = {}
-        for t in targets:
-            content[bytes(t)] = len(self.queues[t])+len(self.tasks[t])
-        self.session.send(self.query, "load_reply", content=content, ident=client_id)
-            
-    
-    def queue_status(self, client_id, msg):
-        """Return the Queue status of one or more targets.
-        if verbose: return the msg_ids
-        else: return len of each type.
-        keys: queue (pending MUX jobs)
-            tasks (pending Task jobs)
-            completed (finished jobs from both queues)"""
-        content = msg['content']
-        targets = content['targets']
-        try:
-            targets = self._validate_targets(targets)
-        except:
-            content = error.wrap_exception()
-            self.session.send(self.query, "hub_error", 
-                    content=content, ident=client_id)
-            return
-        verbose = content.get('verbose', False)
-        content = dict(status='ok')
-        for t in targets:
-            queue = self.queues[t]
-            completed = self.completed[t]
-            tasks = self.tasks[t]
-            if not verbose:
-                queue = len(queue)
-                completed = len(completed)
-                tasks = len(tasks)
-            content[bytes(t)] = {'queue': queue, 'completed': completed , 'tasks': tasks}
-        content['unassigned'] = list(self.unassigned) if verbose else len(self.unassigned)
-        
-        self.session.send(self.query, "queue_reply", content=content, ident=client_id)
-    
-    def purge_results(self, client_id, msg):
-        """Purge results from memory. This method is more valuable before we move
-        to a DB based message storage mechanism."""
-        content = msg['content']
-        msg_ids = content.get('msg_ids', [])
-        reply = dict(status='ok')
-        if msg_ids == 'all':
-            try:
-                self.db.drop_matching_records(dict(completed={'$ne':None}))
-            except Exception:
-                reply = error.wrap_exception()
-        else:
-            for msg_id in msg_ids:
-                if msg_id in self.all_completed:
-                    self.db.drop_record(msg_id)
-                else:
-                    if msg_id in self.pending:
-                        try:
-                            raise IndexError("msg pending: %r"%msg_id)
-                        except:
-                            reply = error.wrap_exception()
-                    else:
-                        try:
-                            raise IndexError("No such msg: %r"%msg_id)
-                        except:
-                            reply = error.wrap_exception()
-                    break
-            eids = content.get('engine_ids', [])
-            for eid in eids:
-                if eid not in self.engines:
-                    try:
-                        raise IndexError("No such engine: %i"%eid)
-                    except:
-                        reply = error.wrap_exception()
-                    break
-                msg_ids = self.completed.pop(eid)
-                uid = self.engines[eid].queue
-                try:
-                    self.db.drop_matching_records(dict(engine_uuid=uid, completed={'$ne':None}))
-                except Exception:
-                    reply = error.wrap_exception()
-                    break
-        
-        self.session.send(self.query, 'purge_reply', content=reply, ident=client_id)
-    
-    def resubmit_task(self, client_id, msg, buffers):
-        """Resubmit a task."""
-        raise NotImplementedError
-    
-    def _extract_record(self, rec):
-        """decompose a TaskRecord dict into subsection of reply for get_result"""
-        io_dict = {}
-        for key in 'pyin pyout pyerr stdout stderr'.split():
-                io_dict[key] = rec[key]
-        content = { 'result_content': rec['result_content'],
-                            'header': rec['header'],
-                            'result_header' : rec['result_header'],
-                            'io' : io_dict,
-                          }
-        if rec['result_buffers']:
-            buffers = map(str, rec['result_buffers'])
-        else:
-            buffers = []
-        
-        return content, buffers
-    
-    def get_results(self, client_id, msg):
-        """Get the result of 1 or more messages."""
-        content = msg['content']
-        msg_ids = sorted(set(content['msg_ids']))
-        statusonly = content.get('status_only', False)
-        pending = []
-        completed = []
-        content = dict(status='ok')
-        content['pending'] = pending
-        content['completed'] = completed
-        buffers = []
-        if not statusonly:
-            try:
-                matches = self.db.find_records(dict(msg_id={'$in':msg_ids}))
-                # turn match list into dict, for faster lookup
-                records = {}
-                for rec in matches:
-                    records[rec['msg_id']] = rec
-            except Exception:
-                content = error.wrap_exception()
-                self.session.send(self.query, "result_reply", content=content, 
-                                                    parent=msg, ident=client_id)
-                return
-        else:
-            records = {}
-        for msg_id in msg_ids:
-            if msg_id in self.pending:
-                pending.append(msg_id)
-            elif msg_id in self.all_completed or msg_id in records:
-                completed.append(msg_id)
-                if not statusonly:
-                    c,bufs = self._extract_record(records[msg_id])
-                    content[msg_id] = c
-                    buffers.extend(bufs)
-            else:
-                try:
-                    raise KeyError('No such message: '+msg_id)
-                except:
-                    content = error.wrap_exception()
-                break
-        self.session.send(self.query, "result_reply", content=content, 
-                                            parent=msg, ident=client_id,
-                                            buffers=buffers)
-
-    def get_history(self, client_id, msg):
-        """Get a list of all msg_ids in our DB records"""
-        try:
-            msg_ids = self.db.get_history()
-        except Exception as e:
-            content = error.wrap_exception()
-        else:
-            content = dict(status='ok', history=msg_ids)
-        
-        self.session.send(self.query, "history_reply", content=content, 
-                                            parent=msg, ident=client_id)
-
-    def db_query(self, client_id, msg):
-        """Perform a raw query on the task record database."""
-        content = msg['content']
-        query = content.get('query', {})
-        keys = content.get('keys', None)
-        query = util.extract_dates(query)
-        buffers = []
-        empty = list()
-        
-        try:
-            records = self.db.find_records(query, keys)
-        except Exception as e:
-            content = error.wrap_exception()
-        else:
-            # extract buffers from reply content:
-            if keys is not None:
-                buffer_lens = [] if 'buffers' in keys else None
-                result_buffer_lens = [] if 'result_buffers' in keys else None
-            else:
-                buffer_lens = []
-                result_buffer_lens = []
-            
-            for rec in records:
-                # buffers may be None, so double check
-                if buffer_lens is not None:
-                    b = rec.pop('buffers', empty) or empty
-                    buffer_lens.append(len(b))
-                    buffers.extend(b)
-                if result_buffer_lens is not None:
-                    rb = rec.pop('result_buffers', empty) or empty
-                    result_buffer_lens.append(len(rb))
-                    buffers.extend(rb)
-            content = dict(status='ok', records=records, buffer_lens=buffer_lens,
-                                    result_buffer_lens=result_buffer_lens)
-        
-        self.session.send(self.query, "db_reply", content=content, 
-                                            parent=msg, ident=client_id,
-                                            buffers=buffers)
-
diff --git a/IPython/parallel/controller/mongodb.py b/IPython/parallel/controller/mongodb.py
deleted file mode 100644
index 9100d48f9b1..00000000000
--- a/IPython/parallel/controller/mongodb.py
+++ /dev/null
@@ -1,96 +0,0 @@
-"""A TaskRecord backend using mongodb"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from datetime import datetime
-
-from pymongo import Connection
-from pymongo.binary import Binary
-
-from IPython.utils.traitlets import Dict, List, CUnicode
-
-from .dictdb import BaseDB
-
-#-----------------------------------------------------------------------------
-# MongoDB class
-#-----------------------------------------------------------------------------
-
-class MongoDB(BaseDB):
-    """MongoDB TaskRecord backend."""
-    
-    connection_args = List(config=True) # args passed to pymongo.Connection
-    connection_kwargs = Dict(config=True) # kwargs passed to pymongo.Connection
-    database = CUnicode(config=True) # name of the mongodb database
-    _table = Dict()
-    
-    def __init__(self, **kwargs):
-        super(MongoDB, self).__init__(**kwargs)
-        self._connection = Connection(*self.connection_args, **self.connection_kwargs)
-        if not self.database:
-            self.database = self.session
-        self._db = self._connection[self.database]
-        self._records = self._db['task_records']
-    
-    def _binary_buffers(self, rec):
-        for key in ('buffers', 'result_buffers'):
-            if rec.get(key, None):
-                rec[key] = map(Binary, rec[key])
-        return rec
-    
-    def add_record(self, msg_id, rec):
-        """Add a new Task Record, by msg_id."""
-        # print rec
-        rec = self._binary_buffers(rec)
-        obj_id = self._records.insert(rec)
-        self._table[msg_id] = obj_id
-    
-    def get_record(self, msg_id):
-        """Get a specific Task Record, by msg_id."""
-        return self._records.find_one(self._table[msg_id])
-    
-    def update_record(self, msg_id, rec):
-        """Update the data in an existing record."""
-        rec = self._binary_buffers(rec)
-        obj_id = self._table[msg_id]
-        self._records.update({'_id':obj_id}, {'$set': rec})
-    
-    def drop_matching_records(self, check):
-        """Remove a record from the DB."""
-        self._records.remove(check)
-        
-    def drop_record(self, msg_id):
-        """Remove a record from the DB."""
-        obj_id = self._table.pop(msg_id)
-        self._records.remove(obj_id)
-    
-    def find_records(self, check, keys=None):
-        """Find records matching a query dict, optionally extracting subset of keys.
-        
-        Returns list of matching records.
-        
-        Parameters
-        ----------
-        
-        check: dict
-            mongodb-style query argument
-        keys: list of strs [optional]
-            if specified, the subset of keys to extract.  msg_id will *always* be
-            included.
-        """
-        if keys and 'msg_id' not in keys:
-            keys.append('msg_id')
-        matches = list(self._records.find(check,keys))
-        for rec in matches:
-            rec.pop('_id')
-        return matches
-
-    def get_history(self):
-        """get all msg_ids, ordered by time submitted."""
-        cursor = self._records.find({},{'msg_id':1}).sort('submitted')
-        return [ rec['msg_id'] for rec in cursor ]
-
-
diff --git a/IPython/parallel/controller/scheduler.py b/IPython/parallel/controller/scheduler.py
deleted file mode 100644
index 05da905e316..00000000000
--- a/IPython/parallel/controller/scheduler.py
+++ /dev/null
@@ -1,621 +0,0 @@
-"""The Python scheduler for rich scheduling.
-
-The Pure ZMQ scheduler does not allow routing schemes other than LRU,
-nor does it check msg_id DAG dependencies. For those, a slightly slower
-Python Scheduler exists.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#----------------------------------------------------------------------
-# Imports
-#----------------------------------------------------------------------
-
-from __future__ import print_function
-
-import logging
-import sys
-
-from datetime import datetime, timedelta
-from random import randint, random
-from types import FunctionType
-
-try:
-    import numpy
-except ImportError:
-    numpy = None
-
-import zmq
-from zmq.eventloop import ioloop, zmqstream
-
-# local imports
-from IPython.external.decorator import decorator
-from IPython.config.loader import Config
-from IPython.utils.traitlets import Instance, Dict, List, Set, Int
-
-from IPython.parallel import error
-from IPython.parallel.factory import SessionFactory
-from IPython.parallel.util import connect_logger, local_logger
-
-from .dependency import Dependency
-
-@decorator
-def logged(f,self,*args,**kwargs):
-    # print ("#--------------------")
-    self.log.debug("scheduler::%s(*%s,**%s)"%(f.func_name, args, kwargs))
-    # print ("#--")
-    return f(self,*args, **kwargs)
-
-#----------------------------------------------------------------------
-# Chooser functions
-#----------------------------------------------------------------------
-
-def plainrandom(loads):
-    """Plain random pick."""
-    n = len(loads)
-    return randint(0,n-1)
-
-def lru(loads):
-    """Always pick the front of the line.
-    
-    The content of `loads` is ignored.
-    
-    Assumes LRU ordering of loads, with oldest first.
-    """
-    return 0
-
-def twobin(loads):
-    """Pick two at random, use the LRU of the two.
-    
-    The content of loads is ignored.
-    
-    Assumes LRU ordering of loads, with oldest first.
-    """
-    n = len(loads)
-    a = randint(0,n-1)
-    b = randint(0,n-1)
-    return min(a,b)
-
-def weighted(loads):
-    """Pick two at random using inverse load as weight.
-    
-    Return the less loaded of the two.
-    """
-    # weight 0 a million times more than 1:
-    weights = 1./(1e-6+numpy.array(loads))
-    sums = weights.cumsum()
-    t = sums[-1]
-    x = random()*t
-    y = random()*t
-    idx = 0
-    idy = 0
-    while sums[idx] < x:
-        idx += 1
-    while sums[idy] < y:
-        idy += 1
-    if weights[idy] > weights[idx]:
-        return idy
-    else:
-        return idx
-
-def leastload(loads):
-    """Always choose the lowest load.
-    
-    If the lowest load occurs more than once, the first
-    occurance will be used.  If loads has LRU ordering, this means
-    the LRU of those with the lowest load is chosen.
-    """
-    return loads.index(min(loads))
-
-#---------------------------------------------------------------------
-# Classes
-#---------------------------------------------------------------------
-# store empty default dependency:
-MET = Dependency([])
-
-class TaskScheduler(SessionFactory):
-    """Python TaskScheduler object.
-    
-    This is the simplest object that supports msg_id based
-    DAG dependencies. *Only* task msg_ids are checked, not
-    msg_ids of jobs submitted via the MUX queue.
-    
-    """
-    
-    hwm = Int(0, config=True) # limit number of outstanding tasks
-    
-    # input arguments:
-    scheme = Instance(FunctionType, default=leastload) # function for determining the destination
-    client_stream = Instance(zmqstream.ZMQStream) # client-facing stream
-    engine_stream = Instance(zmqstream.ZMQStream) # engine-facing stream
-    notifier_stream = Instance(zmqstream.ZMQStream) # hub-facing sub stream
-    mon_stream = Instance(zmqstream.ZMQStream) # hub-facing pub stream
-    
-    # internals:
-    graph = Dict() # dict by msg_id of [ msg_ids that depend on key ]
-    # waiting = List() # list of msg_ids ready to run, but haven't due to HWM
-    depending = Dict() # dict by msg_id of (msg_id, raw_msg, after, follow)
-    pending = Dict() # dict by engine_uuid of submitted tasks
-    completed = Dict() # dict by engine_uuid of completed tasks
-    failed = Dict() # dict by engine_uuid of failed tasks
-    destinations = Dict() # dict by msg_id of engine_uuids where jobs ran (reverse of completed+failed)
-    clients = Dict() # dict by msg_id for who submitted the task
-    targets = List() # list of target IDENTs
-    loads = List() # list of engine loads
-    # full = Set() # set of IDENTs that have HWM outstanding tasks
-    all_completed = Set() # set of all completed tasks
-    all_failed = Set() # set of all failed tasks
-    all_done = Set() # set of all finished tasks=union(completed,failed)
-    all_ids = Set() # set of all submitted task IDs
-    blacklist = Dict() # dict by msg_id of locations where a job has encountered UnmetDependency
-    auditor = Instance('zmq.eventloop.ioloop.PeriodicCallback')
-    
-    
-    def start(self):
-        self.engine_stream.on_recv(self.dispatch_result, copy=False)
-        self._notification_handlers = dict(
-            registration_notification = self._register_engine,
-            unregistration_notification = self._unregister_engine
-        )
-        self.notifier_stream.on_recv(self.dispatch_notification)
-        self.auditor = ioloop.PeriodicCallback(self.audit_timeouts, 2e3, self.loop) # 1 Hz
-        self.auditor.start()
-        self.log.info("Scheduler started...%r"%self)
-    
-    def resume_receiving(self):
-        """Resume accepting jobs."""
-        self.client_stream.on_recv(self.dispatch_submission, copy=False)
-    
-    def stop_receiving(self):
-        """Stop accepting jobs while there are no engines.
-        Leave them in the ZMQ queue."""
-        self.client_stream.on_recv(None)
-    
-    #-----------------------------------------------------------------------
-    # [Un]Registration Handling
-    #-----------------------------------------------------------------------
-    
-    def dispatch_notification(self, msg):
-        """dispatch register/unregister events."""
-        idents,msg = self.session.feed_identities(msg)
-        msg = self.session.unpack_message(msg)
-        msg_type = msg['msg_type']
-        handler = self._notification_handlers.get(msg_type, None)
-        if handler is None:
-            raise Exception("Unhandled message type: %s"%msg_type)
-        else:
-            try:
-                handler(str(msg['content']['queue']))
-            except KeyError:
-                self.log.error("task::Invalid notification msg: %s"%msg)
-    
-    @logged
-    def _register_engine(self, uid):
-        """New engine with ident `uid` became available."""
-        # head of the line:
-        self.targets.insert(0,uid)
-        self.loads.insert(0,0)
-        # initialize sets
-        self.completed[uid] = set()
-        self.failed[uid] = set()
-        self.pending[uid] = {}
-        if len(self.targets) == 1:
-            self.resume_receiving()
-
-    def _unregister_engine(self, uid):
-        """Existing engine with ident `uid` became unavailable."""
-        if len(self.targets) == 1:
-            # this was our only engine
-            self.stop_receiving()
-        
-        # handle any potentially finished tasks:
-        self.engine_stream.flush()
-        
-        self.completed.pop(uid)
-        self.failed.pop(uid)
-        # don't pop destinations, because it might be used later
-        # map(self.destinations.pop, self.completed.pop(uid))
-        # map(self.destinations.pop, self.failed.pop(uid))
-        idx = self.targets.index(uid)
-        self.targets.pop(idx)
-        self.loads.pop(idx)
-        
-        # wait 5 seconds before cleaning up pending jobs, since the results might
-        # still be incoming
-        if self.pending[uid]:
-            dc = ioloop.DelayedCallback(lambda : self.handle_stranded_tasks(uid), 5000, self.loop)
-            dc.start()
-    
-    @logged
-    def handle_stranded_tasks(self, engine):
-        """Deal with jobs resident in an engine that died."""
-        lost = self.pending.pop(engine)
-        
-        for msg_id, (raw_msg, targets, MET, follow, timeout) in lost.iteritems():
-            self.all_failed.add(msg_id)
-            self.all_done.add(msg_id)
-            idents,msg = self.session.feed_identities(raw_msg, copy=False)
-            msg = self.session.unpack_message(msg, copy=False, content=False)
-            parent = msg['header']
-            idents = [idents[0],engine]+idents[1:]
-            # print (idents)
-            try:
-                raise error.EngineError("Engine %r died while running task %r"%(engine, msg_id))
-            except:
-                content = error.wrap_exception()
-            msg = self.session.send(self.client_stream, 'apply_reply', content, 
-                                                    parent=parent, ident=idents)
-            self.session.send(self.mon_stream, msg, ident=['outtask']+idents)
-            self.update_graph(msg_id)
-    
-    
-    #-----------------------------------------------------------------------
-    # Job Submission
-    #-----------------------------------------------------------------------
-    @logged
-    def dispatch_submission(self, raw_msg):
-        """Dispatch job submission to appropriate handlers."""
-        # ensure targets up to date:
-        self.notifier_stream.flush()
-        try:
-            idents, msg = self.session.feed_identities(raw_msg, copy=False)
-            msg = self.session.unpack_message(msg, content=False, copy=False)
-        except Exception:
-            self.log.error("task::Invaid task: %s"%raw_msg, exc_info=True)
-            return
-        
-        # send to monitor
-        self.mon_stream.send_multipart(['intask']+raw_msg, copy=False)
-        
-        header = msg['header']
-        msg_id = header['msg_id']
-        self.all_ids.add(msg_id)
-        
-        # targets
-        targets = set(header.get('targets', []))
-        
-        # time dependencies
-        after = Dependency(header.get('after', []))
-        if after.all:
-            if after.success:
-                after.difference_update(self.all_completed)
-            if after.failure:
-                after.difference_update(self.all_failed)
-        if after.check(self.all_completed, self.all_failed):
-            # recast as empty set, if `after` already met,
-            # to prevent unnecessary set comparisons
-            after = MET
-        
-        # location dependencies
-        follow = Dependency(header.get('follow', []))
-        
-        # turn timeouts into datetime objects:
-        timeout = header.get('timeout', None)
-        if timeout:
-            timeout = datetime.now() + timedelta(0,timeout,0)
-        
-        args = [raw_msg, targets, after, follow, timeout]
-        
-        # validate and reduce dependencies:
-        for dep in after,follow:
-            # check valid:
-            if msg_id in dep or dep.difference(self.all_ids):
-                self.depending[msg_id] = args
-                return self.fail_unreachable(msg_id, error.InvalidDependency)
-            # check if unreachable:
-            if dep.unreachable(self.all_completed, self.all_failed):
-                self.depending[msg_id] = args
-                return self.fail_unreachable(msg_id)
-        
-        if after.check(self.all_completed, self.all_failed):
-            # time deps already met, try to run
-            if not self.maybe_run(msg_id, *args):
-                # can't run yet
-                self.save_unmet(msg_id, *args)
-        else:
-            self.save_unmet(msg_id, *args)
-    
-    # @logged
-    def audit_timeouts(self):
-        """Audit all waiting tasks for expired timeouts."""
-        now = datetime.now()
-        for msg_id in self.depending.keys():
-            # must recheck, in case one failure cascaded to another:
-            if msg_id in self.depending:
-                raw,after,targets,follow,timeout = self.depending[msg_id]
-                if timeout and timeout < now:
-                    self.fail_unreachable(msg_id, timeout=True)
-                
-    @logged
-    def fail_unreachable(self, msg_id, why=error.ImpossibleDependency):
-        """a task has become unreachable, send a reply with an ImpossibleDependency
-        error."""
-        if msg_id not in self.depending:
-            self.log.error("msg %r already failed!"%msg_id)
-            return
-        raw_msg,targets,after,follow,timeout = self.depending.pop(msg_id)
-        for mid in follow.union(after):
-            if mid in self.graph:
-                self.graph[mid].remove(msg_id)
-        
-        # FIXME: unpacking a message I've already unpacked, but didn't save:
-        idents,msg = self.session.feed_identities(raw_msg, copy=False)
-        msg = self.session.unpack_message(msg, copy=False, content=False)
-        header = msg['header']
-        
-        try:
-            raise why()
-        except:
-            content = error.wrap_exception()
-        
-        self.all_done.add(msg_id)
-        self.all_failed.add(msg_id)
-        
-        msg = self.session.send(self.client_stream, 'apply_reply', content, 
-                                                parent=header, ident=idents)
-        self.session.send(self.mon_stream, msg, ident=['outtask']+idents)
-        
-        self.update_graph(msg_id, success=False)
-    
-    @logged
-    def maybe_run(self, msg_id, raw_msg, targets, after, follow, timeout):
-        """check location dependencies, and run if they are met."""
-        blacklist = self.blacklist.setdefault(msg_id, set())
-        if follow or targets or blacklist or self.hwm:
-            # we need a can_run filter
-            def can_run(idx):
-                # check hwm
-                if self.loads[idx] == self.hwm:
-                    return False
-                target = self.targets[idx]
-                # check blacklist
-                if target in blacklist:
-                    return False
-                # check targets
-                if targets and target not in targets:
-                    return False
-                # check follow
-                return follow.check(self.completed[target], self.failed[target])
-            
-            indices = filter(can_run, range(len(self.targets)))
-            if not indices:
-                # couldn't run
-                if follow.all:
-                    # check follow for impossibility
-                    dests = set()
-                    relevant = set()
-                    if follow.success:
-                        relevant = self.all_completed
-                    if follow.failure:
-                        relevant = relevant.union(self.all_failed)
-                    for m in follow.intersection(relevant):
-                        dests.add(self.destinations[m])
-                    if len(dests) > 1:
-                        self.fail_unreachable(msg_id)
-                        return False
-                if targets:
-                    # check blacklist+targets for impossibility
-                    targets.difference_update(blacklist)
-                    if not targets or not targets.intersection(self.targets):
-                        self.fail_unreachable(msg_id)
-                        return False
-                return False
-        else:
-            indices = None
-            
-        self.submit_task(msg_id, raw_msg, targets, follow, timeout, indices)
-        return True
-            
-    @logged
-    def save_unmet(self, msg_id, raw_msg, targets, after, follow, timeout):
-        """Save a message for later submission when its dependencies are met."""
-        self.depending[msg_id] = [raw_msg,targets,after,follow,timeout]
-        # track the ids in follow or after, but not those already finished
-        for dep_id in after.union(follow).difference(self.all_done):
-            if dep_id not in self.graph:
-                self.graph[dep_id] = set()
-            self.graph[dep_id].add(msg_id)
-    
-    @logged
-    def submit_task(self, msg_id, raw_msg, targets, follow, timeout, indices=None):
-        """Submit a task to any of a subset of our targets."""
-        if indices:
-            loads = [self.loads[i] for i in indices]
-        else:
-            loads = self.loads
-        idx = self.scheme(loads)
-        if indices:
-            idx = indices[idx]
-        target = self.targets[idx]
-        # print (target, map(str, msg[:3]))
-        # send job to the engine
-        self.engine_stream.send(target, flags=zmq.SNDMORE, copy=False)
-        self.engine_stream.send_multipart(raw_msg, copy=False)
-        # update load
-        self.add_job(idx)
-        self.pending[target][msg_id] = (raw_msg, targets, MET, follow, timeout)
-        # notify Hub
-        content = dict(msg_id=msg_id, engine_id=target)
-        self.session.send(self.mon_stream, 'task_destination', content=content, 
-                        ident=['tracktask',self.session.session])
-        
-    
-    #-----------------------------------------------------------------------
-    # Result Handling
-    #-----------------------------------------------------------------------
-    @logged
-    def dispatch_result(self, raw_msg):
-        """dispatch method for result replies"""
-        try:
-            idents,msg = self.session.feed_identities(raw_msg, copy=False)
-            msg = self.session.unpack_message(msg, content=False, copy=False)
-            engine = idents[0]
-            idx = self.targets.index(engine)
-            self.finish_job(idx)
-        except Exception:
-            self.log.error("task::Invaid result: %s"%raw_msg, exc_info=True)
-            return
-
-        header = msg['header']
-        if header.get('dependencies_met', True):
-            success = (header['status'] == 'ok')
-            self.handle_result(idents, msg['parent_header'], raw_msg, success)
-            # send to Hub monitor
-            self.mon_stream.send_multipart(['outtask']+raw_msg, copy=False)
-        else:
-            self.handle_unmet_dependency(idents, msg['parent_header'])
-        
-    @logged
-    def handle_result(self, idents, parent, raw_msg, success=True):
-        """handle a real task result, either success or failure"""
-        # first, relay result to client
-        engine = idents[0]
-        client = idents[1]
-        # swap_ids for XREP-XREP mirror
-        raw_msg[:2] = [client,engine]
-        # print (map(str, raw_msg[:4]))
-        self.client_stream.send_multipart(raw_msg, copy=False)
-        # now, update our data structures
-        msg_id = parent['msg_id']
-        self.blacklist.pop(msg_id, None)
-        self.pending[engine].pop(msg_id)
-        if success:
-            self.completed[engine].add(msg_id)
-            self.all_completed.add(msg_id)
-        else:
-            self.failed[engine].add(msg_id)
-            self.all_failed.add(msg_id)
-        self.all_done.add(msg_id)
-        self.destinations[msg_id] = engine
-        
-        self.update_graph(msg_id, success)
-        
-    @logged
-    def handle_unmet_dependency(self, idents, parent):
-        """handle an unmet dependency"""
-        engine = idents[0]
-        msg_id = parent['msg_id']
-        
-        if msg_id not in self.blacklist:
-            self.blacklist[msg_id] = set()
-        self.blacklist[msg_id].add(engine)
-        
-        args = self.pending[engine].pop(msg_id)
-        raw,targets,after,follow,timeout = args
-        
-        if self.blacklist[msg_id] == targets:
-            self.depending[msg_id] = args
-            self.fail_unreachable(msg_id)
-        elif not self.maybe_run(msg_id, *args):
-            # resubmit failed, put it back in our dependency tree
-            self.save_unmet(msg_id, *args)
-        
-        if self.hwm:
-            idx = self.targets.index(engine)
-            if self.loads[idx] == self.hwm-1:
-                self.update_graph(None)
-        
-        
-    
-    @logged
-    def update_graph(self, dep_id=None, success=True):
-        """dep_id just finished. Update our dependency
-        graph and submit any jobs that just became runable.
-        
-        Called with dep_id=None to update graph for hwm, but without finishing
-        a task.
-        """
-        # print ("\n\n***********")
-        # pprint (dep_id)
-        # pprint (self.graph)
-        # pprint (self.depending)
-        # pprint (self.all_completed)
-        # pprint (self.all_failed)
-        # print ("\n\n***********\n\n")
-        # update any jobs that depended on the dependency
-        jobs = self.graph.pop(dep_id, [])
-        # if we have HWM and an engine just become no longer full
-        # recheck *all* jobs:
-        if self.hwm and any( [ load==self.hwm-1 for load in self.loads]):
-            jobs = self.depending.keys()
-        
-        for msg_id in jobs:
-            raw_msg, targets, after, follow, timeout = self.depending[msg_id]
-            
-            if after.unreachable(self.all_completed, self.all_failed) or follow.unreachable(self.all_completed, self.all_failed):
-                self.fail_unreachable(msg_id)
-            
-            elif after.check(self.all_completed, self.all_failed): # time deps met, maybe run
-                if self.maybe_run(msg_id, raw_msg, targets, MET, follow, timeout):
-                    
-                    self.depending.pop(msg_id)
-                    for mid in follow.union(after):
-                        if mid in self.graph:
-                            self.graph[mid].remove(msg_id)
-    
-    #----------------------------------------------------------------------
-    # methods to be overridden by subclasses
-    #----------------------------------------------------------------------
-    
-    def add_job(self, idx):
-        """Called after self.targets[idx] just got the job with header.
-        Override with subclasses.  The default ordering is simple LRU.
-        The default loads are the number of outstanding jobs."""
-        self.loads[idx] += 1
-        for lis in (self.targets, self.loads):
-            lis.append(lis.pop(idx))
-            
-    
-    def finish_job(self, idx):
-        """Called after self.targets[idx] just finished a job.
-        Override with subclasses."""
-        self.loads[idx] -= 1
-    
-
-
-def launch_scheduler(in_addr, out_addr, mon_addr, not_addr, config=None,logname='ZMQ', 
-                            log_addr=None, loglevel=logging.DEBUG, scheme='lru',
-                            identity=b'task'):
-    from zmq.eventloop import ioloop
-    from zmq.eventloop.zmqstream import ZMQStream
-    
-    if config:
-        # unwrap dict back into Config
-        config = Config(config)
-
-    ctx = zmq.Context()
-    loop = ioloop.IOLoop()
-    ins = ZMQStream(ctx.socket(zmq.XREP),loop)
-    ins.setsockopt(zmq.IDENTITY, identity)
-    ins.bind(in_addr)
-    
-    outs = ZMQStream(ctx.socket(zmq.XREP),loop)
-    outs.setsockopt(zmq.IDENTITY, identity)
-    outs.bind(out_addr)
-    mons = ZMQStream(ctx.socket(zmq.PUB),loop)
-    mons.connect(mon_addr)
-    nots = ZMQStream(ctx.socket(zmq.SUB),loop)
-    nots.setsockopt(zmq.SUBSCRIBE, '')
-    nots.connect(not_addr)
-    
-    scheme = globals().get(scheme, None)
-    # setup logging
-    if log_addr:
-        connect_logger(logname, ctx, log_addr, root="scheduler", loglevel=loglevel)
-    else:
-        local_logger(logname, loglevel)
-    
-    scheduler = TaskScheduler(client_stream=ins, engine_stream=outs,
-                            mon_stream=mons, notifier_stream=nots,
-                            scheme=scheme, loop=loop, logname=logname,
-                            config=config)
-    scheduler.start()
-    try:
-        loop.start()
-    except KeyboardInterrupt:
-        print ("interrupted, exiting...", file=sys.__stderr__)
-
diff --git a/IPython/parallel/controller/sqlitedb.py b/IPython/parallel/controller/sqlitedb.py
deleted file mode 100644
index 0b738ffefbc..00000000000
--- a/IPython/parallel/controller/sqlitedb.py
+++ /dev/null
@@ -1,312 +0,0 @@
-"""A TaskRecord backend using sqlite3"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-import json
-import os
-import cPickle as pickle
-from datetime import datetime
-
-import sqlite3
-
-from zmq.eventloop import ioloop
-
-from IPython.utils.traitlets import CUnicode, CStr, Instance, List
-from .dictdb import BaseDB
-from IPython.parallel.util import ISO8601
-
-#-----------------------------------------------------------------------------
-# SQLite operators, adapters, and converters
-#-----------------------------------------------------------------------------
-
-operators = {
- '$lt' : "<",
- '$gt' : ">",
- # null is handled weird with ==,!=
- '$eq' : "IS",
- '$ne' : "IS NOT",
- '$lte': "<=",
- '$gte': ">=",
- '$in' : ('IS', ' OR '),
- '$nin': ('IS NOT', ' AND '),
- # '$all': None,
- # '$mod': None,
- # '$exists' : None
-}
-
-def _adapt_datetime(dt):
-    return dt.strftime(ISO8601)
-
-def _convert_datetime(ds):
-    if ds is None:
-        return ds
-    else:
-        return datetime.strptime(ds, ISO8601)
-
-def _adapt_dict(d):
-    return json.dumps(d)
-
-def _convert_dict(ds):
-    if ds is None:
-        return ds
-    else:
-        return json.loads(ds)
-
-def _adapt_bufs(bufs):
-    # this is *horrible*
-    # copy buffers into single list and pickle it:
-    if bufs and isinstance(bufs[0], (bytes, buffer)):
-        return sqlite3.Binary(pickle.dumps(map(bytes, bufs),-1))
-    elif bufs:
-        return bufs
-    else:
-        return None
-
-def _convert_bufs(bs):
-    if bs is None:
-        return []
-    else:
-        return pickle.loads(bytes(bs))
-
-#-----------------------------------------------------------------------------
-# SQLiteDB class
-#-----------------------------------------------------------------------------
-
-class SQLiteDB(BaseDB):
-    """SQLite3 TaskRecord backend."""
-    
-    filename = CUnicode('tasks.db', config=True)
-    location = CUnicode('', config=True)
-    table = CUnicode("", config=True)
-    
-    _db = Instance('sqlite3.Connection')
-    _keys = List(['msg_id' ,
-            'header' ,
-            'content',
-            'buffers',
-            'submitted',
-            'client_uuid' ,
-            'engine_uuid' ,
-            'started',
-            'completed',
-            'resubmitted',
-            'result_header' ,
-            'result_content' ,
-            'result_buffers' ,
-            'queue' ,
-            'pyin' ,
-            'pyout',
-            'pyerr',
-            'stdout',
-            'stderr',
-        ])
-    
-    def __init__(self, **kwargs):
-        super(SQLiteDB, self).__init__(**kwargs)
-        if not self.table:
-            # use session, and prefix _, since starting with # is illegal
-            self.table = '_'+self.session.replace('-','_')
-        if not self.location:
-            if hasattr(self.config.Global, 'cluster_dir'):
-                self.location = self.config.Global.cluster_dir
-            else:
-                self.location = '.'
-        self._init_db()
-        
-        # register db commit as 2s periodic callback
-        # to prevent clogging pipes
-        # assumes we are being run in a zmq ioloop app
-        loop = ioloop.IOLoop.instance()
-        pc = ioloop.PeriodicCallback(self._db.commit, 2000, loop)
-        pc.start()
-    
-    def _defaults(self, keys=None):
-        """create an empty record"""
-        d = {}
-        keys = self._keys if keys is None else keys
-        for key in keys:
-            d[key] = None
-        return d
-    
-    def _init_db(self):
-        """Connect to the database and get new session number."""
-        # register adapters
-        sqlite3.register_adapter(datetime, _adapt_datetime)
-        sqlite3.register_converter('datetime', _convert_datetime)
-        sqlite3.register_adapter(dict, _adapt_dict)
-        sqlite3.register_converter('dict', _convert_dict)
-        sqlite3.register_adapter(list, _adapt_bufs)
-        sqlite3.register_converter('bufs', _convert_bufs)
-        # connect to the db
-        dbfile = os.path.join(self.location, self.filename)
-        self._db = sqlite3.connect(dbfile, detect_types=sqlite3.PARSE_DECLTYPES, 
-            # isolation_level = None)#,
-             cached_statements=64)
-        # print dir(self._db)
-        
-        self._db.execute("""CREATE TABLE IF NOT EXISTS %s 
-                (msg_id text PRIMARY KEY,
-                header dict text,
-                content dict text,
-                buffers bufs blob,
-                submitted datetime text,
-                client_uuid text,
-                engine_uuid text,
-                started datetime text,
-                completed datetime text,
-                resubmitted datetime text,
-                result_header dict text,
-                result_content dict text,
-                result_buffers bufs blob,
-                queue text,
-                pyin text,
-                pyout text,
-                pyerr text,
-                stdout text,
-                stderr text)
-                """%self.table)
-        self._db.commit()
-    
-    def _dict_to_list(self, d):
-        """turn a mongodb-style record dict into a list."""
-        
-        return [ d[key] for key in self._keys ]
-    
-    def _list_to_dict(self, line, keys=None):
-        """Inverse of dict_to_list"""
-        keys = self._keys if keys is None else keys
-        d = self._defaults(keys)
-        for key,value in zip(keys, line):
-            d[key] = value
-        
-        return d
-    
-    def _render_expression(self, check):
-        """Turn a mongodb-style search dict into an SQL query."""
-        expressions = []
-        args = []
-        
-        skeys = set(check.keys())
-        skeys.difference_update(set(self._keys))
-        skeys.difference_update(set(['buffers', 'result_buffers']))
-        if skeys:
-            raise KeyError("Illegal testing key(s): %s"%skeys)
-        
-        for name,sub_check in check.iteritems():
-            if isinstance(sub_check, dict):
-                for test,value in sub_check.iteritems():
-                    try:
-                        op = operators[test]
-                    except KeyError:
-                        raise KeyError("Unsupported operator: %r"%test)
-                    if isinstance(op, tuple):
-                        op, join = op
-                    expr = "%s %s ?"%(name, op)
-                    if isinstance(value, (tuple,list)):
-                        expr = '( %s )'%( join.join([expr]*len(value)) )
-                        args.extend(value)
-                    else:
-                        args.append(value)
-                    expressions.append(expr)
-            else:
-                # it's an equality check
-                expressions.append("%s IS ?"%name)
-                args.append(sub_check)
-        
-        expr = " AND ".join(expressions)
-        return expr, args
-    
-    def add_record(self, msg_id, rec):
-        """Add a new Task Record, by msg_id."""
-        d = self._defaults()
-        d.update(rec)
-        d['msg_id'] = msg_id
-        line = self._dict_to_list(d)
-        tups = '(%s)'%(','.join(['?']*len(line)))
-        self._db.execute("INSERT INTO %s VALUES %s"%(self.table, tups), line)
-        # self._db.commit()
-    
-    def get_record(self, msg_id):
-        """Get a specific Task Record, by msg_id."""
-        cursor = self._db.execute("""SELECT * FROM %s WHERE msg_id==?"""%self.table, (msg_id,))
-        line = cursor.fetchone()
-        if line is None:
-            raise KeyError("No such msg: %r"%msg_id)
-        return self._list_to_dict(line)
-    
-    def update_record(self, msg_id, rec):
-        """Update the data in an existing record."""
-        query = "UPDATE %s SET "%self.table
-        sets = []
-        keys = sorted(rec.keys())
-        values = []
-        for key in keys:
-            sets.append('%s = ?'%key)
-            values.append(rec[key])
-        query += ', '.join(sets)
-        query += ' WHERE msg_id == ?'
-        values.append(msg_id)
-        self._db.execute(query, values)
-        # self._db.commit()
-    
-    def drop_record(self, msg_id):
-        """Remove a record from the DB."""
-        self._db.execute("""DELETE FROM %s WHERE msg_id==?"""%self.table, (msg_id,))
-        # self._db.commit()
-    
-    def drop_matching_records(self, check):
-        """Remove a record from the DB."""
-        expr,args = self._render_expression(check)
-        query = "DELETE FROM %s WHERE %s"%(self.table, expr)
-        self._db.execute(query,args)
-        # self._db.commit()
-        
-    def find_records(self, check, keys=None):
-        """Find records matching a query dict, optionally extracting subset of keys.
-        
-        Returns list of matching records.
-        
-        Parameters
-        ----------
-        
-        check: dict
-            mongodb-style query argument
-        keys: list of strs [optional]
-            if specified, the subset of keys to extract.  msg_id will *always* be
-            included.
-        """
-        if keys:
-            bad_keys = [ key for key in keys if key not in self._keys ]
-            if bad_keys:
-                raise KeyError("Bad record key(s): %s"%bad_keys)
-        
-        if keys:
-            # ensure msg_id is present and first:
-            if 'msg_id' in keys:
-                keys.remove('msg_id')
-            keys.insert(0, 'msg_id')
-            req = ', '.join(keys)
-        else:
-            req = '*'
-        expr,args = self._render_expression(check)
-        query = """SELECT %s FROM %s WHERE %s"""%(req, self.table, expr)
-        cursor = self._db.execute(query, args)
-        matches = cursor.fetchall()
-        records = []
-        for line in matches:
-            rec = self._list_to_dict(line, keys)
-            records.append(rec)
-        return records
-    
-    def get_history(self):
-        """get all msg_ids, ordered by time submitted."""
-        query = """SELECT msg_id FROM %s ORDER by submitted ASC"""%self.table
-        cursor = self._db.execute(query)
-        # will be a list of length 1 tuples
-        return [ tup[0] for tup in cursor.fetchall()]
-
-__all__ = ['SQLiteDB']
\ No newline at end of file
diff --git a/IPython/parallel/engine/__init__.py b/IPython/parallel/engine/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/parallel/engine/engine.py b/IPython/parallel/engine/engine.py
deleted file mode 100755
index 9bbf7a0b383..00000000000
--- a/IPython/parallel/engine/engine.py
+++ /dev/null
@@ -1,156 +0,0 @@
-#!/usr/bin/env python
-"""A simple engine that talks to a controller over 0MQ.
-it handles registration, etc. and launches a kernel
-connected to the Controller's Schedulers.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from __future__ import print_function
-
-import sys
-import time
-
-import zmq
-from zmq.eventloop import ioloop, zmqstream
-
-# internal
-from IPython.utils.traitlets import Instance, Str, Dict, Int, Type, CFloat
-# from IPython.utils.localinterfaces import LOCALHOST 
-
-from IPython.parallel.controller.heartmonitor import Heart
-from IPython.parallel.factory import RegistrationFactory
-from IPython.parallel.streamsession import Message
-from IPython.parallel.util import disambiguate_url
-
-from .streamkernel import Kernel
-
-class EngineFactory(RegistrationFactory):
-    """IPython engine"""
-    
-    # configurables:
-    user_ns=Dict(config=True)
-    out_stream_factory=Type('IPython.zmq.iostream.OutStream', config=True)
-    display_hook_factory=Type('IPython.zmq.displayhook.DisplayHook', config=True)
-    location=Str(config=True)
-    timeout=CFloat(2,config=True)
-    
-    # not configurable:
-    id=Int(allow_none=True)
-    registrar=Instance('zmq.eventloop.zmqstream.ZMQStream')
-    kernel=Instance(Kernel)
-    
-    
-    def __init__(self, **kwargs):
-        super(EngineFactory, self).__init__(**kwargs)
-        ctx = self.context
-        
-        reg = ctx.socket(zmq.XREQ)
-        reg.setsockopt(zmq.IDENTITY, self.ident)
-        reg.connect(self.url)
-        self.registrar = zmqstream.ZMQStream(reg, self.loop)
-        
-    def register(self):
-        """send the registration_request"""
-        
-        self.log.info("registering")
-        content = dict(queue=self.ident, heartbeat=self.ident, control=self.ident)
-        self.registrar.on_recv(self.complete_registration)
-        # print (self.session.key)
-        self.session.send(self.registrar, "registration_request",content=content)
-    
-    def complete_registration(self, msg):
-        # print msg
-        self._abort_dc.stop()
-        ctx = self.context
-        loop = self.loop
-        identity = self.ident
-        
-        idents,msg = self.session.feed_identities(msg)
-        msg = Message(self.session.unpack_message(msg))
-        
-        if msg.content.status == 'ok':
-            self.id = int(msg.content.id)
-            
-            # create Shell Streams (MUX, Task, etc.):
-            queue_addr = msg.content.mux
-            shell_addrs = [ str(queue_addr) ]
-            task_addr = msg.content.task
-            if task_addr:
-                shell_addrs.append(str(task_addr))
-            
-            # Uncomment this to go back to two-socket model
-            # shell_streams = []
-            # for addr in shell_addrs:
-            #     stream = zmqstream.ZMQStream(ctx.socket(zmq.XREP), loop)
-            #     stream.setsockopt(zmq.IDENTITY, identity)
-            #     stream.connect(disambiguate_url(addr, self.location))
-            #     shell_streams.append(stream)
-            
-            # Now use only one shell stream for mux and tasks
-            stream = zmqstream.ZMQStream(ctx.socket(zmq.XREP), loop)
-            stream.setsockopt(zmq.IDENTITY, identity)
-            shell_streams = [stream]
-            for addr in shell_addrs:
-                stream.connect(disambiguate_url(addr, self.location))
-            # end single stream-socket
-            
-            # control stream:
-            control_addr = str(msg.content.control)
-            control_stream = zmqstream.ZMQStream(ctx.socket(zmq.XREP), loop)
-            control_stream.setsockopt(zmq.IDENTITY, identity)
-            control_stream.connect(disambiguate_url(control_addr, self.location))
-            
-            # create iopub stream:
-            iopub_addr = msg.content.iopub
-            iopub_stream = zmqstream.ZMQStream(ctx.socket(zmq.PUB), loop)
-            iopub_stream.setsockopt(zmq.IDENTITY, identity)
-            iopub_stream.connect(disambiguate_url(iopub_addr, self.location))
-            
-            # launch heartbeat
-            hb_addrs = msg.content.heartbeat
-            # print (hb_addrs)
-            
-            # # Redirect input streams and set a display hook.
-            if self.out_stream_factory:
-                sys.stdout = self.out_stream_factory(self.session, iopub_stream, u'stdout')
-                sys.stdout.topic = 'engine.%i.stdout'%self.id
-                sys.stderr = self.out_stream_factory(self.session, iopub_stream, u'stderr')
-                sys.stderr.topic = 'engine.%i.stderr'%self.id
-            if self.display_hook_factory:
-                sys.displayhook = self.display_hook_factory(self.session, iopub_stream)
-                sys.displayhook.topic = 'engine.%i.pyout'%self.id
-            
-            self.kernel = Kernel(config=self.config, int_id=self.id, ident=self.ident, session=self.session, 
-                    control_stream=control_stream, shell_streams=shell_streams, iopub_stream=iopub_stream, 
-                    loop=loop, user_ns = self.user_ns, logname=self.log.name)
-            self.kernel.start()
-            hb_addrs = [ disambiguate_url(addr, self.location) for addr in hb_addrs ]
-            heart = Heart(*map(str, hb_addrs), heart_id=identity)
-            # ioloop.DelayedCallback(heart.start, 1000, self.loop).start()
-            heart.start()
-            
-            
-        else:
-            self.log.fatal("Registration Failed: %s"%msg)
-            raise Exception("Registration Failed: %s"%msg)
-        
-        self.log.info("Completed registration with id %i"%self.id)
-    
-    
-    def abort(self):
-        self.log.fatal("Registration timed out")
-        self.session.send(self.registrar, "unregistration_request", content=dict(id=self.id))
-        time.sleep(1)
-        sys.exit(255)
-    
-    def start(self):
-        dc = ioloop.DelayedCallback(self.register, 0, self.loop)
-        dc.start()
-        self._abort_dc = ioloop.DelayedCallback(self.abort, self.timeout*1000, self.loop)
-        self._abort_dc.start()
-
diff --git a/IPython/parallel/engine/kernelstarter.py b/IPython/parallel/engine/kernelstarter.py
deleted file mode 100644
index 3395e4f8297..00000000000
--- a/IPython/parallel/engine/kernelstarter.py
+++ /dev/null
@@ -1,225 +0,0 @@
-"""KernelStarter class that intercepts Control Queue messages, and handles process management."""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-from zmq.eventloop import ioloop
-
-from IPython.parallel.streamsession import StreamSession
-
-class KernelStarter(object):
-    """Object for resetting/killing the Kernel."""
-    
-    
-    def __init__(self, session, upstream, downstream, *kernel_args, **kernel_kwargs):
-        self.session = session
-        self.upstream = upstream
-        self.downstream = downstream
-        self.kernel_args = kernel_args
-        self.kernel_kwargs = kernel_kwargs
-        self.handlers = {}
-        for method in 'shutdown_request shutdown_reply'.split():
-            self.handlers[method] = getattr(self, method)
-    
-    def start(self):
-        self.upstream.on_recv(self.dispatch_request)
-        self.downstream.on_recv(self.dispatch_reply)
-        
-    #--------------------------------------------------------------------------
-    # Dispatch methods
-    #--------------------------------------------------------------------------
-    
-    def dispatch_request(self, raw_msg):
-        idents, msg = self.session.feed_identities()
-        try:
-            msg = self.session.unpack_message(msg, content=False)
-        except:
-            print ("bad msg: %s"%msg)
-        
-        msgtype = msg['msg_type']
-        handler = self.handlers.get(msgtype, None)
-        if handler is None:
-            self.downstream.send_multipart(raw_msg, copy=False)
-        else:
-            handler(msg)
-        
-    def dispatch_reply(self, raw_msg):
-        idents, msg = self.session.feed_identities()
-        try:
-            msg = self.session.unpack_message(msg, content=False)
-        except:
-            print ("bad msg: %s"%msg)
-        
-        msgtype = msg['msg_type']
-        handler = self.handlers.get(msgtype, None)
-        if handler is None:
-            self.upstream.send_multipart(raw_msg, copy=False)
-        else:
-            handler(msg)
-    
-    #--------------------------------------------------------------------------
-    # Handlers
-    #--------------------------------------------------------------------------
-    
-    def shutdown_request(self, msg):
-        """"""
-        self.downstream.send_multipart(msg)
-    
-    #--------------------------------------------------------------------------
-    # Kernel process management methods, from KernelManager:
-    #--------------------------------------------------------------------------
-    
-    def _check_local(addr):
-        if isinstance(addr, tuple):
-            addr = addr[0]
-        return addr in LOCAL_IPS
-    
-    def start_kernel(self, **kw):
-        """Starts a kernel process and configures the manager to use it.
-
-        If random ports (port=0) are being used, this method must be called
-        before the channels are created.
-
-        Parameters:
-        -----------
-        ipython : bool, optional (default True)
-             Whether to use an IPython kernel instead of a plain Python kernel.
-        """
-        self.kernel = Process(target=make_kernel, args=self.kernel_args,
-                                            kwargs=self.kernel_kwargs)
-
-    def shutdown_kernel(self, restart=False):
-        """ Attempts to the stop the kernel process cleanly. If the kernel
-        cannot be stopped, it is killed, if possible.
-        """
-        # FIXME: Shutdown does not work on Windows due to ZMQ errors!
-        if sys.platform == 'win32':
-            self.kill_kernel()
-            return
-
-        # Don't send any additional kernel kill messages immediately, to give
-        # the kernel a chance to properly execute shutdown actions. Wait for at
-        # most 1s, checking every 0.1s.
-        self.xreq_channel.shutdown(restart=restart)
-        for i in range(10):
-            if self.is_alive:
-                time.sleep(0.1)
-            else:
-                break
-        else:
-            # OK, we've waited long enough.
-            if self.has_kernel:
-                self.kill_kernel()
-    
-    def restart_kernel(self, now=False):
-        """Restarts a kernel with the same arguments that were used to launch
-        it. If the old kernel was launched with random ports, the same ports
-        will be used for the new kernel.
-
-        Parameters
-        ----------
-        now : bool, optional
-          If True, the kernel is forcefully restarted *immediately*, without
-          having a chance to do any cleanup action.  Otherwise the kernel is
-          given 1s to clean up before a forceful restart is issued.
-
-          In all cases the kernel is restarted, the only difference is whether
-          it is given a chance to perform a clean shutdown or not.
-        """
-        if self._launch_args is None:
-            raise RuntimeError("Cannot restart the kernel. "
-                               "No previous call to 'start_kernel'.")
-        else:
-            if self.has_kernel:
-                if now:
-                    self.kill_kernel()
-                else:
-                    self.shutdown_kernel(restart=True)
-            self.start_kernel(**self._launch_args)
-
-            # FIXME: Messages get dropped in Windows due to probable ZMQ bug
-            # unless there is some delay here.
-            if sys.platform == 'win32':
-                time.sleep(0.2)
-
-    @property
-    def has_kernel(self):
-        """Returns whether a kernel process has been specified for the kernel
-        manager.
-        """
-        return self.kernel is not None
-
-    def kill_kernel(self):
-        """ Kill the running kernel. """
-        if self.has_kernel:
-            # Pause the heart beat channel if it exists.
-            if self._hb_channel is not None:
-                self._hb_channel.pause()
-
-            # Attempt to kill the kernel.
-            try:
-                self.kernel.kill()
-            except OSError, e:
-                # In Windows, we will get an Access Denied error if the process
-                # has already terminated. Ignore it.
-                if not (sys.platform == 'win32' and e.winerror == 5):
-                    raise
-            self.kernel = None
-        else:
-            raise RuntimeError("Cannot kill kernel. No kernel is running!")
-
-    def interrupt_kernel(self):
-        """ Interrupts the kernel. Unlike ``signal_kernel``, this operation is
-        well supported on all platforms.
-        """
-        if self.has_kernel:
-            if sys.platform == 'win32':
-                from parentpoller import ParentPollerWindows as Poller
-                Poller.send_interrupt(self.kernel.win32_interrupt_event)
-            else:
-                self.kernel.send_signal(signal.SIGINT)
-        else:
-            raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
-
-    def signal_kernel(self, signum):
-        """ Sends a signal to the kernel. Note that since only SIGTERM is
-        supported on Windows, this function is only useful on Unix systems.
-        """
-        if self.has_kernel:
-            self.kernel.send_signal(signum)
-        else:
-            raise RuntimeError("Cannot signal kernel. No kernel is running!")
-
-    @property
-    def is_alive(self):
-        """Is the kernel process still running?"""
-        # FIXME: not using a heartbeat means this method is broken for any
-        # remote kernel, it's only capable of handling local kernels.
-        if self.has_kernel:
-            if self.kernel.poll() is None:
-                return True
-            else:
-                return False
-        else:
-            # We didn't start the kernel with this KernelManager so we don't
-            # know if it is running. We should use a heartbeat for this case.
-            return True
-
-
-def make_starter(up_addr, down_addr, *args, **kwargs):
-    """entry point function for launching a kernelstarter in a subprocess"""
-    loop = ioloop.IOLoop.instance()
-    ctx = zmq.Context()
-    session = StreamSession()
-    upstream = zmqstream.ZMQStream(ctx.socket(zmq.XREQ),loop)
-    upstream.connect(up_addr)
-    downstream = zmqstream.ZMQStream(ctx.socket(zmq.XREQ),loop)
-    downstream.connect(down_addr)
-    
-    starter = KernelStarter(session, upstream, downstream, *args, **kwargs)
-    starter.start()
-    loop.start()
-    
\ No newline at end of file
diff --git a/IPython/parallel/engine/streamkernel.py b/IPython/parallel/engine/streamkernel.py
deleted file mode 100755
index 6c03e0673dc..00000000000
--- a/IPython/parallel/engine/streamkernel.py
+++ /dev/null
@@ -1,431 +0,0 @@
-#!/usr/bin/env python
-"""
-Kernel adapted from kernel.py to use ZMQ Streams
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports.
-from __future__ import print_function
-
-import sys
-import time
-
-from code import CommandCompiler
-from datetime import datetime
-from pprint import pprint
-
-# System library imports.
-import zmq
-from zmq.eventloop import ioloop, zmqstream
-
-# Local imports.
-from IPython.utils.traitlets import Instance, List, Int, Dict, Set, Str
-from IPython.zmq.completer import KernelCompleter
-
-from IPython.parallel.error import wrap_exception
-from IPython.parallel.factory import SessionFactory
-from IPython.parallel.util import serialize_object, unpack_apply_message, ISO8601
-
-def printer(*args):
-    pprint(args, stream=sys.__stdout__)
-
-
-class _Passer(zmqstream.ZMQStream):
-    """Empty class that implements `send()` that does nothing.
-    
-    Subclass ZMQStream for StreamSession typechecking
-    
-    """
-    def __init__(self, *args, **kwargs):
-        pass
-    
-    def send(self, *args, **kwargs):
-        pass
-    send_multipart = send
-    
-
-#-----------------------------------------------------------------------------
-# Main kernel class
-#-----------------------------------------------------------------------------
-
-class Kernel(SessionFactory):
-
-    #---------------------------------------------------------------------------
-    # Kernel interface
-    #---------------------------------------------------------------------------
-    
-    # kwargs:
-    int_id = Int(-1, config=True)
-    user_ns = Dict(config=True)
-    exec_lines = List(config=True)
-    
-    control_stream = Instance(zmqstream.ZMQStream)
-    task_stream = Instance(zmqstream.ZMQStream)
-    iopub_stream = Instance(zmqstream.ZMQStream)
-    client = Instance('IPython.parallel.Client')
-    
-    # internals
-    shell_streams = List()
-    compiler = Instance(CommandCompiler, (), {})
-    completer = Instance(KernelCompleter)
-    
-    aborted = Set()
-    shell_handlers = Dict()
-    control_handlers = Dict()
-    
-    def _set_prefix(self):
-        self.prefix = "engine.%s"%self.int_id
-    
-    def _connect_completer(self):
-        self.completer = KernelCompleter(self.user_ns)
-    
-    def __init__(self, **kwargs):
-        super(Kernel, self).__init__(**kwargs)
-        self._set_prefix()
-        self._connect_completer()
-        
-        self.on_trait_change(self._set_prefix, 'id')
-        self.on_trait_change(self._connect_completer, 'user_ns')
-        
-        # Build dict of handlers for message types
-        for msg_type in ['execute_request', 'complete_request', 'apply_request', 
-                'clear_request']:
-            self.shell_handlers[msg_type] = getattr(self, msg_type)
-        
-        for msg_type in ['shutdown_request', 'abort_request']+self.shell_handlers.keys():
-            self.control_handlers[msg_type] = getattr(self, msg_type)
-        
-        self._initial_exec_lines()
-    
-    def _wrap_exception(self, method=None):
-        e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method=method)
-        content=wrap_exception(e_info)
-        return content
-    
-    def _initial_exec_lines(self):
-        s = _Passer()
-        content = dict(silent=True, user_variable=[],user_expressions=[])
-        for line in self.exec_lines:
-            self.log.debug("executing initialization: %s"%line)
-            content.update({'code':line})
-            msg = self.session.msg('execute_request', content)
-            self.execute_request(s, [], msg)
-        
-        
-    #-------------------- control handlers -----------------------------
-    def abort_queues(self):
-        for stream in self.shell_streams:
-            if stream:
-                self.abort_queue(stream)
-    
-    def abort_queue(self, stream):
-        while True:
-            try:
-                msg = self.session.recv(stream, zmq.NOBLOCK,content=True)
-            except zmq.ZMQError as e:
-                if e.errno == zmq.EAGAIN:
-                    break
-                else:
-                    return
-            else:
-                if msg is None:
-                    return
-                else:
-                    idents,msg = msg
-                
-                # assert self.reply_socketly_socket.rcvmore(), "Unexpected missing message part."
-                # msg = self.reply_socket.recv_json()
-            self.log.info("Aborting:")
-            self.log.info(str(msg))
-            msg_type = msg['msg_type']
-            reply_type = msg_type.split('_')[0] + '_reply'
-            # reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
-            # self.reply_socket.send(ident,zmq.SNDMORE)
-            # self.reply_socket.send_json(reply_msg)
-            reply_msg = self.session.send(stream, reply_type, 
-                        content={'status' : 'aborted'}, parent=msg, ident=idents)[0]
-            self.log.debug(str(reply_msg))
-            # We need to wait a bit for requests to come in. This can probably
-            # be set shorter for true asynchronous clients.
-            time.sleep(0.05)
-    
-    def abort_request(self, stream, ident, parent):
-        """abort a specifig msg by id"""
-        msg_ids = parent['content'].get('msg_ids', None)
-        if isinstance(msg_ids, basestring):
-            msg_ids = [msg_ids]
-        if not msg_ids:
-            self.abort_queues()
-        for mid in msg_ids:
-            self.aborted.add(str(mid))
-        
-        content = dict(status='ok')
-        reply_msg = self.session.send(stream, 'abort_reply', content=content, 
-                parent=parent, ident=ident)
-        self.log.debug(str(reply_msg))
-    
-    def shutdown_request(self, stream, ident, parent):
-        """kill ourself.  This should really be handled in an external process"""
-        try:
-            self.abort_queues()
-        except:
-            content = self._wrap_exception('shutdown')
-        else:
-            content = dict(parent['content'])
-            content['status'] = 'ok'
-        msg = self.session.send(stream, 'shutdown_reply',
-                                content=content, parent=parent, ident=ident)
-        self.log.debug(str(msg))
-        dc = ioloop.DelayedCallback(lambda : sys.exit(0), 1000, self.loop)
-        dc.start()
-    
-    def dispatch_control(self, msg):
-        idents,msg = self.session.feed_identities(msg, copy=False)
-        try:
-            msg = self.session.unpack_message(msg, content=True, copy=False)
-        except:
-            self.log.error("Invalid Message", exc_info=True)
-            return
-        
-        header = msg['header']
-        msg_id = header['msg_id']
-        
-        handler = self.control_handlers.get(msg['msg_type'], None)
-        if handler is None:
-            self.log.error("UNKNOWN CONTROL MESSAGE TYPE: %r"%msg['msg_type'])
-        else:
-            handler(self.control_stream, idents, msg)
-    
-
-    #-------------------- queue helpers ------------------------------
-    
-    def check_dependencies(self, dependencies):
-        if not dependencies:
-            return True
-        if len(dependencies) == 2 and dependencies[0] in 'any all'.split():
-            anyorall = dependencies[0]
-            dependencies = dependencies[1]
-        else:
-            anyorall = 'all'
-        results = self.client.get_results(dependencies,status_only=True)
-        if results['status'] != 'ok':
-            return False
-        
-        if anyorall == 'any':
-            if not results['completed']:
-                return False
-        else:
-            if results['pending']:
-                return False
-        
-        return True
-    
-    def check_aborted(self, msg_id):
-        return msg_id in self.aborted
-    
-    #-------------------- queue handlers -----------------------------
-    
-    def clear_request(self, stream, idents, parent):
-        """Clear our namespace."""
-        self.user_ns = {}
-        msg = self.session.send(stream, 'clear_reply', ident=idents, parent=parent, 
-                content = dict(status='ok'))
-        self._initial_exec_lines()
-    
-    def execute_request(self, stream, ident, parent):
-        self.log.debug('execute request %s'%parent)
-        try:
-            code = parent[u'content'][u'code']
-        except:
-            self.log.error("Got bad msg: %s"%parent, exc_info=True)
-            return
-        self.session.send(self.iopub_stream, u'pyin', {u'code':code},parent=parent,
-                            ident='%s.pyin'%self.prefix)
-        started = datetime.now().strftime(ISO8601)
-        try:
-            comp_code = self.compiler(code, '<zmq-kernel>')
-            # allow for not overriding displayhook
-            if hasattr(sys.displayhook, 'set_parent'):
-                sys.displayhook.set_parent(parent)
-                sys.stdout.set_parent(parent)
-                sys.stderr.set_parent(parent)
-            exec comp_code in self.user_ns, self.user_ns
-        except:
-            exc_content = self._wrap_exception('execute')
-            # exc_msg = self.session.msg(u'pyerr', exc_content, parent)
-            self.session.send(self.iopub_stream, u'pyerr', exc_content, parent=parent,
-                            ident='%s.pyerr'%self.prefix)
-            reply_content = exc_content
-        else:
-            reply_content = {'status' : 'ok'}
-        
-        reply_msg = self.session.send(stream, u'execute_reply', reply_content, parent=parent, 
-                    ident=ident, subheader = dict(started=started))
-        self.log.debug(str(reply_msg))
-        if reply_msg['content']['status'] == u'error':
-            self.abort_queues()
-
-    def complete_request(self, stream, ident, parent):
-        matches = {'matches' : self.complete(parent),
-                   'status' : 'ok'}
-        completion_msg = self.session.send(stream, 'complete_reply',
-                                           matches, parent, ident)
-        # print >> sys.__stdout__, completion_msg
-
-    def complete(self, msg):
-        return self.completer.complete(msg.content.line, msg.content.text)
-    
-    def apply_request(self, stream, ident, parent):
-        # flush previous reply, so this request won't block it
-        stream.flush(zmq.POLLOUT)
-        
-        try:
-            content = parent[u'content']
-            bufs = parent[u'buffers']
-            msg_id = parent['header']['msg_id']
-            # bound = parent['header'].get('bound', False)
-        except:
-            self.log.error("Got bad msg: %s"%parent, exc_info=True)
-            return
-        # pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
-        # self.iopub_stream.send(pyin_msg)
-        # self.session.send(self.iopub_stream, u'pyin', {u'code':code},parent=parent)
-        sub = {'dependencies_met' : True, 'engine' : self.ident,
-                'started': datetime.now().strftime(ISO8601)}
-        try:
-            # allow for not overriding displayhook
-            if hasattr(sys.displayhook, 'set_parent'):
-                sys.displayhook.set_parent(parent)
-                sys.stdout.set_parent(parent)
-                sys.stderr.set_parent(parent)
-            # exec "f(*args,**kwargs)" in self.user_ns, self.user_ns
-            working = self.user_ns
-            # suffix = 
-            prefix = "_"+str(msg_id).replace("-","")+"_"
-            
-            f,args,kwargs = unpack_apply_message(bufs, working, copy=False)
-            # if bound:
-            #     bound_ns = Namespace(working)
-            #     args = [bound_ns]+list(args)
-
-            fname = getattr(f, '__name__', 'f')
-            
-            fname = prefix+"f"
-            argname = prefix+"args"
-            kwargname = prefix+"kwargs"
-            resultname = prefix+"result"
-            
-            ns = { fname : f, argname : args, kwargname : kwargs , resultname : None }
-            # print ns
-            working.update(ns)
-            code = "%s=%s(*%s,**%s)"%(resultname, fname, argname, kwargname)
-            try:
-                exec code in working,working
-                result = working.get(resultname)
-            finally:
-                for key in ns.iterkeys():
-                    working.pop(key)
-            # if bound:
-            #     working.update(bound_ns)
-            
-            packed_result,buf = serialize_object(result)
-            result_buf = [packed_result]+buf
-        except:
-            exc_content = self._wrap_exception('apply')
-            # exc_msg = self.session.msg(u'pyerr', exc_content, parent)
-            self.session.send(self.iopub_stream, u'pyerr', exc_content, parent=parent,
-                                ident='%s.pyerr'%self.prefix)
-            reply_content = exc_content
-            result_buf = []
-            
-            if exc_content['ename'] == 'UnmetDependency':
-                sub['dependencies_met'] = False
-        else:
-            reply_content = {'status' : 'ok'}
-        
-        # put 'ok'/'error' status in header, for scheduler introspection:
-        sub['status'] = reply_content['status']
-        
-        reply_msg = self.session.send(stream, u'apply_reply', reply_content, 
-                    parent=parent, ident=ident,buffers=result_buf, subheader=sub)
-        
-        # flush i/o
-        # should this be before reply_msg is sent, like in the single-kernel code, 
-        # or should nothing get in the way of real results?
-        sys.stdout.flush()
-        sys.stderr.flush()
-    
-    def dispatch_queue(self, stream, msg):
-        self.control_stream.flush()
-        idents,msg = self.session.feed_identities(msg, copy=False)
-        try:
-            msg = self.session.unpack_message(msg, content=True, copy=False)
-        except:
-            self.log.error("Invalid Message", exc_info=True)
-            return
-            
-        
-        header = msg['header']
-        msg_id = header['msg_id']
-        if self.check_aborted(msg_id):
-            self.aborted.remove(msg_id)
-            # is it safe to assume a msg_id will not be resubmitted?
-            reply_type = msg['msg_type'].split('_')[0] + '_reply'
-            status = {'status' : 'aborted'}
-            reply_msg = self.session.send(stream, reply_type, subheader=status,
-                        content=status, parent=msg, ident=idents)
-            return
-        handler = self.shell_handlers.get(msg['msg_type'], None)
-        if handler is None:
-            self.log.error("UNKNOWN MESSAGE TYPE: %r"%msg['msg_type'])
-        else:
-            handler(stream, idents, msg)
-    
-    def start(self):
-        #### stream mode:
-        if self.control_stream:
-            self.control_stream.on_recv(self.dispatch_control, copy=False)
-            self.control_stream.on_err(printer)
-        
-        def make_dispatcher(stream):
-            def dispatcher(msg):
-                return self.dispatch_queue(stream, msg)
-            return dispatcher
-        
-        for s in self.shell_streams:
-            s.on_recv(make_dispatcher(s), copy=False)
-            s.on_err(printer)
-        
-        if self.iopub_stream:
-            self.iopub_stream.on_err(printer)
-        
-        #### while True mode:
-        # while True:
-        #     idle = True
-        #     try:
-        #         msg = self.shell_stream.socket.recv_multipart(
-        #                     zmq.NOBLOCK, copy=False)
-        #     except zmq.ZMQError, e:
-        #         if e.errno != zmq.EAGAIN:
-        #             raise e
-        #     else:
-        #         idle=False
-        #         self.dispatch_queue(self.shell_stream, msg)
-        #             
-        #     if not self.task_stream.empty():
-        #         idle=False
-        #         msg = self.task_stream.recv_multipart()
-        #         self.dispatch_queue(self.task_stream, msg)
-        #     if idle:
-        #         # don't busywait
-        #         time.sleep(1e-3)
-
diff --git a/IPython/parallel/error.py b/IPython/parallel/error.py
deleted file mode 100644
index 5acf8d55841..00000000000
--- a/IPython/parallel/error.py
+++ /dev/null
@@ -1,313 +0,0 @@
-# encoding: utf-8
-
-"""Classes and functions for kernel related errors and exceptions."""
-from __future__ import print_function
-
-import sys
-import traceback
-
-__docformat__ = "restructuredtext en"
-
-# Tell nose to skip this module
-__test__ = {}
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Error classes
-#-------------------------------------------------------------------------------
-class IPythonError(Exception):
-    """Base exception that all of our exceptions inherit from.
-
-    This can be raised by code that doesn't have any more specific
-    information."""
-
-    pass
-
-# Exceptions associated with the controller objects
-class ControllerError(IPythonError): pass
-
-class ControllerCreationError(ControllerError): pass
-
-
-# Exceptions associated with the Engines
-class EngineError(IPythonError): pass
-
-class EngineCreationError(EngineError): pass
-
-class KernelError(IPythonError):
-    pass
-
-class NotDefined(KernelError):
-    def __init__(self, name):
-        self.name = name
-        self.args = (name,)
-
-    def __repr__(self):
-        return '<NotDefined: %s>' % self.name
-    
-    __str__ = __repr__
-
-
-class QueueCleared(KernelError):
-    pass
-
-
-class IdInUse(KernelError):
-    pass
-
-
-class ProtocolError(KernelError):
-    pass
-
-
-class ConnectionError(KernelError):
-    pass
-
-
-class InvalidEngineID(KernelError):
-    pass
-
-
-class NoEnginesRegistered(KernelError):
-    pass
-
-
-class InvalidClientID(KernelError):
-    pass
-
-
-class InvalidDeferredID(KernelError):
-    pass
-
-
-class SerializationError(KernelError):
-    pass
-
-
-class MessageSizeError(KernelError):
-    pass
-
-
-class PBMessageSizeError(MessageSizeError):
-    pass
-
-
-class ResultNotCompleted(KernelError):
-    pass
-
-
-class ResultAlreadyRetrieved(KernelError):
-    pass
-
-class ClientError(KernelError):
-    pass
-
-
-class TaskAborted(KernelError):
-    pass
-
-
-class TaskTimeout(KernelError):
-    pass
-
-
-class NotAPendingResult(KernelError):
-    pass
-
-
-class UnpickleableException(KernelError):
-    pass
-
-
-class AbortedPendingDeferredError(KernelError):
-    pass
-
-
-class InvalidProperty(KernelError):
-    pass
-
-
-class MissingBlockArgument(KernelError):
-    pass
-
-
-class StopLocalExecution(KernelError):
-    pass
-
-
-class SecurityError(KernelError):
-    pass
-
-
-class FileTimeoutError(KernelError):
-    pass
-
-class TimeoutError(KernelError):
-    pass
-
-class UnmetDependency(KernelError):
-    pass
-
-class ImpossibleDependency(UnmetDependency):
-    pass
-
-class DependencyTimeout(ImpossibleDependency):
-    pass
-
-class InvalidDependency(ImpossibleDependency):
-    pass
-
-class RemoteError(KernelError):
-    """Error raised elsewhere"""
-    ename=None
-    evalue=None
-    traceback=None
-    engine_info=None
-    
-    def __init__(self, ename, evalue, traceback, engine_info=None):
-        self.ename=ename
-        self.evalue=evalue
-        self.traceback=traceback
-        self.engine_info=engine_info or {}
-        self.args=(ename, evalue)
-    
-    def __repr__(self):
-        engineid = self.engine_info.get('engine_id', ' ')
-        return "<Remote[%s]:%s(%s)>"%(engineid, self.ename, self.evalue)
-        
-    def __str__(self):
-        sig = "%s(%s)"%(self.ename, self.evalue)
-        if self.traceback:
-            return sig + '\n' + self.traceback
-        else:
-            return sig
-    
-
-class TaskRejectError(KernelError):
-    """Exception to raise when a task should be rejected by an engine.
-    
-    This exception can be used to allow a task running on an engine to test
-    if the engine (or the user's namespace on the engine) has the needed
-    task dependencies.  If not, the task should raise this exception.  For
-    the task to be retried on another engine, the task should be created
-    with the `retries` argument > 1.
-    
-    The advantage of this approach over our older properties system is that
-    tasks have full access to the user's namespace on the engines and the
-    properties don't have to be managed or tested by the controller.
-    """
-
-
-class CompositeError(RemoteError):
-    """Error for representing possibly multiple errors on engines"""
-    def __init__(self, message, elist):
-        Exception.__init__(self, *(message, elist))
-        # Don't use pack_exception because it will conflict with the .message
-        # attribute that is being deprecated in 2.6 and beyond.
-        self.msg = message
-        self.elist = elist
-        self.args = [ e[0] for e in elist ]
-
-    def _get_engine_str(self, ei):
-        if not ei:
-            return '[Engine Exception]'
-        else:
-            return '[%s:%s]: ' % (ei['engine_id'], ei['method'])
-
-    def _get_traceback(self, ev):
-        try:
-            tb = ev._ipython_traceback_text
-        except AttributeError:
-            return 'No traceback available'
-        else:
-            return tb
-
-    def __str__(self):
-        s = str(self.msg)
-        for en, ev, etb, ei in self.elist:
-            engine_str = self._get_engine_str(ei)
-            s = s + '\n' + engine_str + en + ': ' + str(ev)
-        return s
-    
-    def __repr__(self):
-        return "CompositeError(%i)"%len(self.elist)
-
-    def print_tracebacks(self, excid=None):
-        if excid is None:
-            for (en,ev,etb,ei) in self.elist:
-                print (self._get_engine_str(ei))
-                print (etb or 'No traceback available')
-                print ()
-        else:
-            try:
-                en,ev,etb,ei = self.elist[excid]
-            except:
-                raise IndexError("an exception with index %i does not exist"%excid)
-            else:
-                print (self._get_engine_str(ei))
-                print (etb or 'No traceback available')
-    
-    def raise_exception(self, excid=0):
-        try:
-            en,ev,etb,ei = self.elist[excid]
-        except:
-            raise IndexError("an exception with index %i does not exist"%excid)
-        else:
-            raise RemoteError(en, ev, etb, ei)
-
-
-def collect_exceptions(rdict_or_list, method='unspecified'):
-    """check a result dict for errors, and raise CompositeError if any exist.
-    Passthrough otherwise."""
-    elist = []
-    if isinstance(rdict_or_list, dict):
-        rlist = rdict_or_list.values()
-    else:
-        rlist = rdict_or_list
-    for r in rlist:
-        if isinstance(r, RemoteError):
-            en, ev, etb, ei = r.ename, r.evalue, r.traceback, r.engine_info
-            # Sometimes we could have CompositeError in our list.  Just take
-            # the errors out of them and put them in our new list.  This 
-            # has the effect of flattening lists of CompositeErrors into one
-            # CompositeError
-            if en=='CompositeError':
-                for e in ev.elist:
-                    elist.append(e)
-            else:
-                elist.append((en, ev, etb, ei))
-    if len(elist)==0:
-        return rdict_or_list
-    else:
-        msg = "one or more exceptions from call to method: %s" % (method)
-        # This silliness is needed so the debugger has access to the exception
-        # instance (e in this case)
-        try:
-            raise CompositeError(msg, elist)
-        except CompositeError as e:
-            raise e
-
-def wrap_exception(engine_info={}):
-    etype, evalue, tb = sys.exc_info()
-    stb = traceback.format_exception(etype, evalue, tb)
-    exc_content = {
-        'status' : 'error',
-        'traceback' : stb,
-        'ename' : unicode(etype.__name__),
-        'evalue' : unicode(evalue),
-        'engine_info' : engine_info
-    }
-    return exc_content
-
-def unwrap_exception(content):
-    err = RemoteError(content['ename'], content['evalue'], 
-                ''.join(content['traceback']),
-                content.get('engine_info', {}))
-    return err
-
diff --git a/IPython/parallel/factory.py b/IPython/parallel/factory.py
deleted file mode 100644
index 4cd1ffcb67f..00000000000
--- a/IPython/parallel/factory.py
+++ /dev/null
@@ -1,152 +0,0 @@
-"""Base config factories."""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-import logging
-import os
-import uuid
-
-from zmq.eventloop.ioloop import IOLoop
-
-from IPython.config.configurable import Configurable
-from IPython.utils.importstring import import_item
-from IPython.utils.traitlets import Str,Int,Instance, CUnicode, CStr
-
-import IPython.parallel.streamsession as ss
-from IPython.parallel.util import select_random_ports
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-class LoggingFactory(Configurable):
-    """A most basic class, that has a `log` (type:`Logger`) attribute, set via a `logname` Trait."""
-    log = Instance('logging.Logger', ('ZMQ', logging.WARN))
-    logname = CUnicode('ZMQ')
-    def _logname_changed(self, name, old, new):
-        self.log = logging.getLogger(new)
-    
-
-class SessionFactory(LoggingFactory):
-    """The Base factory from which every factory in IPython.parallel inherits"""
-    
-    packer = Str('',config=True)
-    unpacker = Str('',config=True)
-    ident = CStr('',config=True)
-    def _ident_default(self):
-        return str(uuid.uuid4())
-    username = CUnicode(os.environ.get('USER','username'),config=True)
-    exec_key = CUnicode('',config=True)
-    # not configurable:
-    context = Instance('zmq.Context', (), {})
-    session = Instance('IPython.parallel.streamsession.StreamSession')
-    loop = Instance('zmq.eventloop.ioloop.IOLoop', allow_none=False)
-    def _loop_default(self):
-        return IOLoop.instance()
-    
-    
-    def __init__(self, **kwargs):
-        super(SessionFactory, self).__init__(**kwargs)
-        exec_key = self.exec_key or None
-        # set the packers:
-        if not self.packer:
-            packer_f = unpacker_f = None
-        elif self.packer.lower() == 'json':
-            packer_f = ss.json_packer
-            unpacker_f = ss.json_unpacker
-        elif self.packer.lower() == 'pickle':
-            packer_f = ss.pickle_packer
-            unpacker_f = ss.pickle_unpacker
-        else:
-            packer_f = import_item(self.packer)
-            unpacker_f = import_item(self.unpacker)
-        
-        # construct the session
-        self.session = ss.StreamSession(self.username, self.ident, packer=packer_f, unpacker=unpacker_f, key=exec_key)
-    
-
-class RegistrationFactory(SessionFactory):
-    """The Base Configurable for objects that involve registration."""
-    
-    url = Str('', config=True) # url takes precedence over ip,regport,transport
-    transport = Str('tcp', config=True)
-    ip = Str('127.0.0.1', config=True)
-    regport = Instance(int, config=True)
-    def _regport_default(self):
-        # return 10101
-        return select_random_ports(1)[0]
-    
-    def __init__(self, **kwargs):
-        super(RegistrationFactory, self).__init__(**kwargs)
-        self._propagate_url()
-        self._rebuild_url()
-        self.on_trait_change(self._propagate_url, 'url')
-        self.on_trait_change(self._rebuild_url, 'ip')
-        self.on_trait_change(self._rebuild_url, 'transport')
-        self.on_trait_change(self._rebuild_url, 'regport')
-    
-    def _rebuild_url(self):
-        self.url = "%s://%s:%i"%(self.transport, self.ip, self.regport)
-        
-    def _propagate_url(self):
-        """Ensure self.url contains full transport://interface:port"""
-        if self.url:
-            iface = self.url.split('://',1)
-            if len(iface) == 2:
-                self.transport,iface = iface
-            iface = iface.split(':')
-            self.ip = iface[0]
-            if iface[1]:
-                self.regport = int(iface[1])
-
-#-----------------------------------------------------------------------------
-# argparse argument extenders
-#-----------------------------------------------------------------------------
-
-
-def add_session_arguments(parser):
-    paa = parser.add_argument
-    paa('--ident',
-        type=str, dest='SessionFactory.ident', 
-        help='set the ZMQ and session identity [default: random uuid]',
-        metavar='identity')
-    # paa('--execkey',
-    #     type=str, dest='SessionFactory.exec_key', 
-    #     help='path to a file containing an execution key.',
-    #     metavar='execkey')
-    paa('--packer',
-        type=str, dest='SessionFactory.packer', 
-        help='method to serialize messages: {json,pickle} [default: json]',
-        metavar='packer')
-    paa('--unpacker',
-        type=str, dest='SessionFactory.unpacker', 
-        help='inverse function of `packer`.  Only necessary when using something other than json|pickle',
-        metavar='packer')
-
-def add_registration_arguments(parser):
-    paa = parser.add_argument
-    paa('--ip',
-        type=str, dest='RegistrationFactory.ip',
-        help="The IP used for registration [default: localhost]",
-        metavar='ip')
-    paa('--transport',
-        type=str, dest='RegistrationFactory.transport',
-        help="The ZeroMQ transport used for registration [default: tcp]",
-        metavar='transport')
-    paa('--url',
-        type=str, dest='RegistrationFactory.url', 
-        help='set transport,ip,regport in one go, e.g. tcp://127.0.0.1:10101',
-        metavar='url')
-    paa('--regport',
-        type=int, dest='RegistrationFactory.regport',
-        help="The port used for registration [default: 10101]",
-        metavar='ip')
diff --git a/IPython/parallel/scripts/__init__.py b/IPython/parallel/scripts/__init__.py
deleted file mode 100644
index 4e7767247c2..00000000000
--- a/IPython/parallel/scripts/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-""""""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/IPython/parallel/scripts/ipcluster b/IPython/parallel/scripts/ipcluster
deleted file mode 100755
index 066a3434ca8..00000000000
--- a/IPython/parallel/scripts/ipcluster
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-from IPython.parallel.apps.ipclusterapp import launch_new_instance
-
-launch_new_instance()
diff --git a/IPython/parallel/scripts/ipcontroller b/IPython/parallel/scripts/ipcontroller
deleted file mode 100755
index 1939d960ecc..00000000000
--- a/IPython/parallel/scripts/ipcontroller
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-from IPython.parallel.apps.ipcontrollerapp import launch_new_instance
-
-launch_new_instance()
diff --git a/IPython/parallel/scripts/ipengine b/IPython/parallel/scripts/ipengine
deleted file mode 100755
index 9c178a48501..00000000000
--- a/IPython/parallel/scripts/ipengine
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-from IPython.parallel.apps.ipengineapp import launch_new_instance
-
-launch_new_instance()
-
-
diff --git a/IPython/parallel/scripts/iplogger b/IPython/parallel/scripts/iplogger
deleted file mode 100755
index 1ae833a91bc..00000000000
--- a/IPython/parallel/scripts/iplogger
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-from IPython.parallel.apps.iploggerapp import launch_new_instance
-
-launch_new_instance()
-
-
diff --git a/IPython/parallel/streamsession.py b/IPython/parallel/streamsession.py
deleted file mode 100644
index e5e8bd49b2f..00000000000
--- a/IPython/parallel/streamsession.py
+++ /dev/null
@@ -1,410 +0,0 @@
-#!/usr/bin/env python
-"""edited session.py to work with streams, and move msg_type to the header
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-
-import os
-import pprint
-import uuid
-from datetime import datetime
-
-try:
-    import cPickle
-    pickle = cPickle
-except:
-    cPickle = None
-    import pickle
-
-import zmq
-from zmq.utils import jsonapi
-from zmq.eventloop.zmqstream import ZMQStream
-
-from .util import ISO8601
-
-def squash_unicode(obj):
-    """coerce unicode back to bytestrings."""
-    if isinstance(obj,dict):
-        for key in obj.keys():
-            obj[key] = squash_unicode(obj[key])
-            if isinstance(key, unicode):
-                obj[squash_unicode(key)] = obj.pop(key)
-    elif isinstance(obj, list):
-        for i,v in enumerate(obj):
-            obj[i] = squash_unicode(v)
-    elif isinstance(obj, unicode):
-        obj = obj.encode('utf8')
-    return obj
-
-def _date_default(obj):
-    if isinstance(obj, datetime):
-        return obj.strftime(ISO8601)
-    else:
-        raise TypeError("%r is not JSON serializable"%obj)
-
-_default_key = 'on_unknown' if jsonapi.jsonmod.__name__ == 'jsonlib' else 'default'
-json_packer = lambda obj: jsonapi.dumps(obj, **{_default_key:_date_default})
-json_unpacker = lambda s: squash_unicode(jsonapi.loads(s))
-
-pickle_packer = lambda o: pickle.dumps(o,-1)
-pickle_unpacker = pickle.loads
-
-default_packer = json_packer
-default_unpacker = json_unpacker
-
-
-DELIM="<IDS|MSG>"
-
-class Message(object):
-    """A simple message object that maps dict keys to attributes.
-
-    A Message can be created from a dict and a dict from a Message instance
-    simply by calling dict(msg_obj)."""
-    
-    def __init__(self, msg_dict):
-        dct = self.__dict__
-        for k, v in dict(msg_dict).iteritems():
-            if isinstance(v, dict):
-                v = Message(v)
-            dct[k] = v
-
-    # Having this iterator lets dict(msg_obj) work out of the box.
-    def __iter__(self):
-        return iter(self.__dict__.iteritems())
-    
-    def __repr__(self):
-        return repr(self.__dict__)
-
-    def __str__(self):
-        return pprint.pformat(self.__dict__)
-
-    def __contains__(self, k):
-        return k in self.__dict__
-
-    def __getitem__(self, k):
-        return self.__dict__[k]
-
-
-def msg_header(msg_id, msg_type, username, session):
-    date=datetime.now().strftime(ISO8601)
-    return locals()
-
-def extract_header(msg_or_header):
-    """Given a message or header, return the header."""
-    if not msg_or_header:
-        return {}
-    try:
-        # See if msg_or_header is the entire message.
-        h = msg_or_header['header']
-    except KeyError:
-        try:
-            # See if msg_or_header is just the header
-            h = msg_or_header['msg_id']
-        except KeyError:
-            raise
-        else:
-            h = msg_or_header
-    if not isinstance(h, dict):
-        h = dict(h)
-    return h
-
-class StreamSession(object):
-    """tweaked version of IPython.zmq.session.Session, for development in Parallel"""
-    debug=False
-    key=None
-    
-    def __init__(self, username=None, session=None, packer=None, unpacker=None, key=None, keyfile=None):
-        if username is None:
-            username = os.environ.get('USER','username')
-        self.username = username
-        if session is None:
-            self.session = str(uuid.uuid4())
-        else:
-            self.session = session
-        self.msg_id = str(uuid.uuid4())
-        if packer is None:
-            self.pack = default_packer
-        else:
-            if not callable(packer):
-                raise TypeError("packer must be callable, not %s"%type(packer))
-            self.pack = packer
-        
-        if unpacker is None:
-            self.unpack = default_unpacker
-        else:
-            if not callable(unpacker):
-                raise TypeError("unpacker must be callable, not %s"%type(unpacker))
-            self.unpack = unpacker
-        
-        if key is not None and keyfile is not None:
-            raise TypeError("Must specify key OR keyfile, not both")
-        if keyfile is not None:
-            with open(keyfile) as f:
-                self.key = f.read().strip()
-        else:
-            self.key = key
-        if isinstance(self.key, unicode):
-            self.key = self.key.encode('utf8')
-        # print key, keyfile, self.key
-        self.none = self.pack({})
-            
-    def msg_header(self, msg_type):
-        h = msg_header(self.msg_id, msg_type, self.username, self.session)
-        self.msg_id = str(uuid.uuid4())
-        return h
-
-    def msg(self, msg_type, content=None, parent=None, subheader=None):
-        msg = {}
-        msg['header'] = self.msg_header(msg_type)
-        msg['msg_id'] = msg['header']['msg_id']
-        msg['parent_header'] = {} if parent is None else extract_header(parent)
-        msg['msg_type'] = msg_type
-        msg['content'] = {} if content is None else content
-        sub = {} if subheader is None else subheader
-        msg['header'].update(sub)
-        return msg
-
-    def check_key(self, msg_or_header):
-        """Check that a message's header has the right key"""
-        if self.key is None:
-            return True
-        header = extract_header(msg_or_header)
-        return header.get('key', None) == self.key
-            
-        
-    def send(self, stream, msg_or_type, content=None, buffers=None, parent=None, subheader=None, ident=None, track=False):
-        """Build and send a message via stream or socket.
-        
-        Parameters
-        ----------
-        
-        stream : zmq.Socket or ZMQStream
-            the socket-like object used to send the data
-        msg_or_type : str or Message/dict
-            Normally, msg_or_type will be a msg_type unless a message is being sent more
-            than once.
-        
-        content : dict or None
-            the content of the message (ignored if msg_or_type is a message)
-        buffers : list or None
-            the already-serialized buffers to be appended to the message
-        parent : Message or dict or None
-            the parent or parent header describing the parent of this message
-        subheader : dict or None
-            extra header keys for this message's header
-        ident : bytes or list of bytes
-            the zmq.IDENTITY routing path
-        track : bool
-            whether to track.  Only for use with Sockets, because ZMQStream objects cannot track messages.
-        
-        Returns
-        -------
-        msg : message dict
-            the constructed message
-        (msg,tracker) : (message dict, MessageTracker)
-            if track=True, then a 2-tuple will be returned, the first element being the constructed
-            message, and the second being the MessageTracker
-            
-        """
-
-        if not isinstance(stream, (zmq.Socket, ZMQStream)):
-            raise TypeError("stream must be Socket or ZMQStream, not %r"%type(stream))
-        elif track and isinstance(stream, ZMQStream):
-            raise TypeError("ZMQStream cannot track messages")
-        
-        if isinstance(msg_or_type, (Message, dict)):
-            # we got a Message, not a msg_type
-            # don't build a new Message
-            msg = msg_or_type
-            content = msg['content']
-        else:
-            msg = self.msg(msg_or_type, content, parent, subheader)
-        
-        buffers = [] if buffers is None else buffers
-        to_send = []
-        if isinstance(ident, list):
-            # accept list of idents
-            to_send.extend(ident)
-        elif ident is not None:
-            to_send.append(ident)
-        to_send.append(DELIM)
-        if self.key is not None:
-            to_send.append(self.key)
-        to_send.append(self.pack(msg['header']))
-        to_send.append(self.pack(msg['parent_header']))
-        
-        if content is None:
-            content = self.none
-        elif isinstance(content, dict):
-            content = self.pack(content)
-        elif isinstance(content, bytes):
-            # content is already packed, as in a relayed message
-            pass
-        else:
-            raise TypeError("Content incorrect type: %s"%type(content))
-        to_send.append(content)
-        flag = 0
-        if buffers:
-            flag = zmq.SNDMORE
-            _track = False
-        else:
-            _track=track
-        if track:
-            tracker = stream.send_multipart(to_send, flag, copy=False, track=_track)
-        else:
-            tracker = stream.send_multipart(to_send, flag, copy=False)
-        for b in buffers[:-1]:
-            stream.send(b, flag, copy=False)
-        if buffers:
-            if track:
-                tracker = stream.send(buffers[-1], copy=False, track=track)
-            else:
-                tracker = stream.send(buffers[-1], copy=False)
-                
-        # omsg = Message(msg)
-        if self.debug:
-            pprint.pprint(msg)
-            pprint.pprint(to_send)
-            pprint.pprint(buffers)
-        
-        msg['tracker'] = tracker
-        
-        return msg
-    
-    def send_raw(self, stream, msg, flags=0, copy=True, ident=None):
-        """Send a raw message via ident path.
-        
-        Parameters
-        ----------
-        msg : list of sendable buffers"""
-        to_send = []
-        if isinstance(ident, bytes):
-            ident = [ident]
-        if ident is not None:
-            to_send.extend(ident)
-        to_send.append(DELIM)
-        if self.key is not None:
-            to_send.append(self.key)
-        to_send.extend(msg)
-        stream.send_multipart(msg, flags, copy=copy)
-    
-    def recv(self, socket, mode=zmq.NOBLOCK, content=True, copy=True):
-        """receives and unpacks a message
-        returns [idents], msg"""
-        if isinstance(socket, ZMQStream):
-            socket = socket.socket
-        try:
-            msg = socket.recv_multipart(mode)
-        except zmq.ZMQError as e:
-            if e.errno == zmq.EAGAIN:
-                # We can convert EAGAIN to None as we know in this case
-                # recv_multipart won't return None.
-                return None
-            else:
-                raise
-        # return an actual Message object
-        # determine the number of idents by trying to unpack them.
-        # this is terrible:
-        idents, msg = self.feed_identities(msg, copy)
-        try:
-            return idents, self.unpack_message(msg, content=content, copy=copy)
-        except Exception as e:
-            print (idents, msg)
-            # TODO: handle it
-            raise e
-    
-    def feed_identities(self, msg, copy=True):
-        """feed until DELIM is reached, then return the prefix as idents and remainder as
-        msg. This is easily broken by setting an IDENT to DELIM, but that would be silly.
-        
-        Parameters
-        ----------
-        msg : a list of Message or bytes objects
-            the message to be split
-        copy : bool
-            flag determining whether the arguments are bytes or Messages
-        
-        Returns
-        -------
-        (idents,msg) : two lists
-            idents will always be a list of bytes - the indentity prefix
-            msg will be a list of bytes or Messages, unchanged from input
-            msg should be unpackable via self.unpack_message at this point.
-        """
-        ikey = int(self.key is not None)
-        minlen = 3 + ikey
-        msg = list(msg)
-        idents = []
-        while len(msg) > minlen:
-            if copy:
-                s = msg[0]
-            else:
-                s = msg[0].bytes
-            if s == DELIM:
-                msg.pop(0)
-                break
-            else:
-                idents.append(s)
-                msg.pop(0)
-                
-        return idents, msg
-    
-    def unpack_message(self, msg, content=True, copy=True):
-        """Return a message object from the format
-        sent by self.send.
-        
-        Parameters:
-        -----------
-        
-        content : bool (True)
-            whether to unpack the content dict (True), 
-            or leave it serialized (False)
-        
-        copy : bool (True)
-            whether to return the bytes (True), 
-            or the non-copying Message object in each place (False)
-        
-        """
-        ikey = int(self.key is not None)
-        minlen = 3 + ikey
-        message = {}
-        if not copy:
-            for i in range(minlen):
-                msg[i] = msg[i].bytes
-        if ikey:
-            if not self.key == msg[0]:
-                raise KeyError("Invalid Session Key: %s"%msg[0])
-        if not len(msg) >= minlen:
-            raise TypeError("malformed message, must have at least %i elements"%minlen)
-        message['header'] = self.unpack(msg[ikey+0])
-        message['msg_type'] = message['header']['msg_type']
-        message['parent_header'] = self.unpack(msg[ikey+1])
-        if content:
-            message['content'] = self.unpack(msg[ikey+2])
-        else:
-            message['content'] = msg[ikey+2]
-        
-        message['buffers'] = msg[ikey+3:]# [ m.buffer for m in msg[3:] ]
-        return message
-        
-
-def test_msg2obj():
-    am = dict(x=1)
-    ao = Message(am)
-    assert ao.x == am['x']
-
-    am['y'] = dict(z=1)
-    ao = Message(am)
-    assert ao.y.z == am['y']['z']
-    
-    k1, k2 = 'y', 'z'
-    assert ao[k1][k2] == am[k1][k2]
-    
-    am2 = dict(ao)
-    assert am['x'] == am2['x']
-    assert am['y']['z'] == am2['y']['z']
diff --git a/IPython/parallel/tests/__init__.py b/IPython/parallel/tests/__init__.py
deleted file mode 100644
index 0b1e0132b19..00000000000
--- a/IPython/parallel/tests/__init__.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""toplevel setup/teardown for parallel tests."""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import os
-import tempfile
-import time
-from subprocess import Popen
-
-from IPython.utils.path import get_ipython_dir
-from IPython.parallel import Client
-from IPython.parallel.apps.launcher import (LocalProcessLauncher,
-                                                  ipengine_cmd_argv,
-                                                  ipcontroller_cmd_argv,
-                                                  SIGKILL)
-
-# globals
-launchers = []
-blackhole = open(os.devnull, 'w')
-
-# Launcher class
-class TestProcessLauncher(LocalProcessLauncher):
-    """subclass LocalProcessLauncher, to prevent extra sockets and threads being created on Windows"""
-    def start(self):
-        if self.state == 'before':
-            self.process = Popen(self.args,
-                stdout=blackhole, stderr=blackhole,
-                env=os.environ,
-                cwd=self.work_dir
-            )
-            self.notify_start(self.process.pid)
-            self.poll = self.process.poll
-        else:
-            s = 'The process was already started and has state: %r' % self.state
-            raise ProcessStateError(s)
-
-# nose setup/teardown
-
-def setup():
-    cp = TestProcessLauncher()
-    cp.cmd_and_args = ipcontroller_cmd_argv + \
-                ['--profile', 'iptest', '--log-level', '99', '-r', '--usethreads']
-    cp.start()
-    launchers.append(cp)
-    cluster_dir = os.path.join(get_ipython_dir(), 'cluster_iptest')
-    engine_json = os.path.join(cluster_dir, 'security', 'ipcontroller-engine.json')
-    client_json = os.path.join(cluster_dir, 'security', 'ipcontroller-client.json')
-    tic = time.time()
-    while not os.path.exists(engine_json) or not os.path.exists(client_json):
-        if cp.poll() is not None:
-            print cp.poll()
-            raise RuntimeError("The test controller failed to start.")
-        elif time.time()-tic > 10:
-            raise RuntimeError("Timeout waiting for the test controller to start.")
-        time.sleep(0.1)
-    add_engines(1)
-
-def add_engines(n=1, profile='iptest'):
-    rc = Client(profile=profile)
-    base = len(rc)
-    eps = []
-    for i in range(n):
-        ep = TestProcessLauncher()
-        ep.cmd_and_args = ipengine_cmd_argv + ['--profile', profile, '--log-level', '99']
-        ep.start()
-        launchers.append(ep)
-        eps.append(ep)
-    tic = time.time()
-    while len(rc) < base+n:
-        if any([ ep.poll() is not None for ep in eps ]):
-            raise RuntimeError("A test engine failed to start.")
-        elif time.time()-tic > 10:
-            raise RuntimeError("Timeout waiting for engines to connect.")
-        time.sleep(.1)
-        rc.spin()
-    rc.close()
-    return eps
-
-def teardown():
-    time.sleep(1)
-    while launchers:
-        p = launchers.pop()
-        if p.poll() is None:
-            try:
-                p.stop()
-            except Exception, e:
-                print e
-                pass
-        if p.poll() is None:
-            time.sleep(.25)
-        if p.poll() is None:
-            try:
-                print 'cleaning up test process...'
-                p.signal(SIGKILL)
-            except:
-                print "couldn't shutdown process: ", p
-    blackhole.close()
-    
diff --git a/IPython/parallel/tests/clienttest.py b/IPython/parallel/tests/clienttest.py
deleted file mode 100644
index b6c2ed01404..00000000000
--- a/IPython/parallel/tests/clienttest.py
+++ /dev/null
@@ -1,129 +0,0 @@
-"""base class for parallel client tests"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-import sys
-import tempfile
-import time
-
-from nose import SkipTest
-
-import zmq
-from zmq.tests import BaseZMQTestCase
-
-from IPython.external.decorator import decorator
-
-from IPython.parallel import error
-from IPython.parallel import Client
-
-from IPython.parallel.tests import launchers, add_engines
-
-# simple tasks for use in apply tests
-
-def segfault():
-    """this will segfault"""
-    import ctypes
-    ctypes.memset(-1,0,1)
-
-def crash():
-    """from stdlib crashers in the test suite"""
-    import types
-    if sys.platform.startswith('win'):
-        import ctypes
-        ctypes.windll.kernel32.SetErrorMode(0x0002);
-
-    co = types.CodeType(0, 0, 0, 0, b'\x04\x71\x00\x00',
-                             (), (), (), '', '', 1, b'')
-    exec(co)
-
-def wait(n):
-    """sleep for a time"""
-    import time
-    time.sleep(n)
-    return n
-
-def raiser(eclass):
-    """raise an exception"""
-    raise eclass()
-
-# test decorator for skipping tests when libraries are unavailable
-def skip_without(*names):
-    """skip a test if some names are not importable"""
-    @decorator
-    def skip_without_names(f, *args, **kwargs):
-        """decorator to skip tests in the absence of numpy."""
-        for name in names:
-            try:
-                __import__(name)
-            except ImportError:
-                raise SkipTest
-        return f(*args, **kwargs)
-    return skip_without_names
-
-class ClusterTestCase(BaseZMQTestCase):
-    
-    def add_engines(self, n=1, block=True):
-        """add multiple engines to our cluster"""
-        self.engines.extend(add_engines(n))
-        if block:
-            self.wait_on_engines()
-    
-    def wait_on_engines(self, timeout=5):
-        """wait for our engines to connect."""
-        n = len(self.engines)+self.base_engine_count
-        tic = time.time()
-        while time.time()-tic < timeout and len(self.client.ids) < n:
-            time.sleep(0.1)
-        
-        assert not len(self.client.ids) < n, "waiting for engines timed out"
-    
-    def connect_client(self):
-        """connect a client with my Context, and track its sockets for cleanup"""
-        c = Client(profile='iptest', context=self.context)
-        for name in filter(lambda n:n.endswith('socket'), dir(c)):
-            s = getattr(c, name)
-            s.setsockopt(zmq.LINGER, 0)
-            self.sockets.append(s)
-        return c
-    
-    def assertRaisesRemote(self, etype, f, *args, **kwargs):
-        try:
-            try:
-                f(*args, **kwargs)
-            except error.CompositeError as e:
-                e.raise_exception()
-        except error.RemoteError as e:
-            self.assertEquals(etype.__name__, e.ename, "Should have raised %r, but raised %r"%(etype.__name__, e.ename))
-        else:
-            self.fail("should have raised a RemoteError")
-            
-    def setUp(self):
-        BaseZMQTestCase.setUp(self)
-        self.client = self.connect_client()
-        # start every test with clean engine namespaces:
-        self.client.clear(block=True)
-        self.base_engine_count=len(self.client.ids)
-        self.engines=[]
-    
-    def tearDown(self):
-        # self.client.clear(block=True)
-        # close fds:
-        for e in filter(lambda e: e.poll() is not None, launchers):
-            launchers.remove(e)
-        
-        # allow flushing of incoming messages to prevent crash on socket close
-        self.client.wait(timeout=2)
-        # time.sleep(2)
-        self.client.spin()
-        self.client.close()
-        BaseZMQTestCase.tearDown(self)
-        # this will be redundant when pyzmq merges PR #88
-        # self.context.term()
-        # print tempfile.TemporaryFile().fileno(),
-        # sys.stdout.flush()
-        
\ No newline at end of file
diff --git a/IPython/parallel/tests/test_asyncresult.py b/IPython/parallel/tests/test_asyncresult.py
deleted file mode 100644
index 9457033df7c..00000000000
--- a/IPython/parallel/tests/test_asyncresult.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""Tests for asyncresult.py"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-
-from IPython.parallel.error import TimeoutError
-
-from IPython.parallel.tests import add_engines
-from .clienttest import ClusterTestCase
-
-def setup():
-    add_engines(2)
-
-def wait(n):
-    import time
-    time.sleep(n)
-    return n
-
-class AsyncResultTest(ClusterTestCase):
-
-    def test_single_result(self):
-        eid = self.client.ids[-1]
-        ar = self.client[eid].apply_async(lambda : 42)
-        self.assertEquals(ar.get(), 42)
-        ar = self.client[[eid]].apply_async(lambda : 42)
-        self.assertEquals(ar.get(), [42])
-        ar = self.client[-1:].apply_async(lambda : 42)
-        self.assertEquals(ar.get(), [42])
-
-    def test_get_after_done(self):
-        ar = self.client[-1].apply_async(lambda : 42)
-        ar.wait()
-        self.assertTrue(ar.ready())
-        self.assertEquals(ar.get(), 42)
-        self.assertEquals(ar.get(), 42)
-
-    def test_get_before_done(self):
-        ar = self.client[-1].apply_async(wait, 0.1)
-        self.assertRaises(TimeoutError, ar.get, 0)
-        ar.wait(0)
-        self.assertFalse(ar.ready())
-        self.assertEquals(ar.get(), 0.1)
-
-    def test_get_after_error(self):
-        ar = self.client[-1].apply_async(lambda : 1/0)
-        ar.wait()
-        self.assertRaisesRemote(ZeroDivisionError, ar.get)
-        self.assertRaisesRemote(ZeroDivisionError, ar.get)
-        self.assertRaisesRemote(ZeroDivisionError, ar.get_dict)
-    
-    def test_get_dict(self):
-        n = len(self.client)
-        ar = self.client[:].apply_async(lambda : 5)
-        self.assertEquals(ar.get(), [5]*n)
-        d = ar.get_dict()
-        self.assertEquals(sorted(d.keys()), sorted(self.client.ids))
-        for eid,r in d.iteritems():
-            self.assertEquals(r, 5)
-
diff --git a/IPython/parallel/tests/test_client.py b/IPython/parallel/tests/test_client.py
deleted file mode 100644
index ba8c372b833..00000000000
--- a/IPython/parallel/tests/test_client.py
+++ /dev/null
@@ -1,214 +0,0 @@
-"""Tests for parallel client.py"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import time
-from datetime import datetime
-from tempfile import mktemp
-
-import zmq
-
-from IPython.parallel.client import client as clientmod
-from IPython.parallel import error
-from IPython.parallel import AsyncResult, AsyncHubResult
-from IPython.parallel import LoadBalancedView, DirectView
-
-from clienttest import ClusterTestCase, segfault, wait, add_engines
-
-def setup():
-    add_engines(4)
-
-class TestClient(ClusterTestCase):
-    
-    def test_ids(self):
-        n = len(self.client.ids)
-        self.add_engines(3)
-        self.assertEquals(len(self.client.ids), n+3)
-    
-    def test_view_indexing(self):
-        """test index access for views"""
-        self.add_engines(2)
-        targets = self.client._build_targets('all')[-1]
-        v = self.client[:]
-        self.assertEquals(v.targets, targets)
-        t = self.client.ids[2]
-        v = self.client[t]
-        self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, t)
-        t = self.client.ids[2:4]
-        v = self.client[t]
-        self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, t)
-        v = self.client[::2]
-        self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[::2])
-        v = self.client[1::3]
-        self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[1::3])
-        v = self.client[:-3]
-        self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[:-3])
-        v = self.client[-1]
-        self.assert_(isinstance(v, DirectView))
-        self.assertEquals(v.targets, targets[-1])
-        self.assertRaises(TypeError, lambda : self.client[None])
-    
-    def test_lbview_targets(self):
-        """test load_balanced_view targets"""
-        v = self.client.load_balanced_view()
-        self.assertEquals(v.targets, None)
-        v = self.client.load_balanced_view(-1)
-        self.assertEquals(v.targets, [self.client.ids[-1]])
-        v = self.client.load_balanced_view('all')
-        self.assertEquals(v.targets, self.client.ids)
-    
-    def test_targets(self):
-        """test various valid targets arguments"""
-        build = self.client._build_targets
-        ids = self.client.ids
-        idents,targets = build(None)
-        self.assertEquals(ids, targets)
-    
-    def test_clear(self):
-        """test clear behavior"""
-        # self.add_engines(2)
-        v = self.client[:]
-        v.block=True
-        v.push(dict(a=5))
-        v.pull('a')
-        id0 = self.client.ids[-1]
-        self.client.clear(targets=id0, block=True)
-        a = self.client[:-1].get('a')
-        self.assertRaisesRemote(NameError, self.client[id0].get, 'a')
-        self.client.clear(block=True)
-        for i in self.client.ids:
-            # print i
-            self.assertRaisesRemote(NameError, self.client[i].get, 'a')
-    
-    def test_get_result(self):
-        """test getting results from the Hub."""
-        c = clientmod.Client(profile='iptest')
-        # self.add_engines(1)
-        t = c.ids[-1]
-        ar = c[t].apply_async(wait, 1)
-        # give the monitor time to notice the message
-        time.sleep(.25)
-        ahr = self.client.get_result(ar.msg_ids)
-        self.assertTrue(isinstance(ahr, AsyncHubResult))
-        self.assertEquals(ahr.get(), ar.get())
-        ar2 = self.client.get_result(ar.msg_ids)
-        self.assertFalse(isinstance(ar2, AsyncHubResult))
-        c.close()
-    
-    def test_ids_list(self):
-        """test client.ids"""
-        # self.add_engines(2)
-        ids = self.client.ids
-        self.assertEquals(ids, self.client._ids)
-        self.assertFalse(ids is self.client._ids)
-        ids.remove(ids[-1])
-        self.assertNotEquals(ids, self.client._ids)
-    
-    def test_queue_status(self):
-        # self.addEngine(4)
-        ids = self.client.ids
-        id0 = ids[0]
-        qs = self.client.queue_status(targets=id0)
-        self.assertTrue(isinstance(qs, dict))
-        self.assertEquals(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
-        allqs = self.client.queue_status()
-        self.assertTrue(isinstance(allqs, dict))
-        self.assertEquals(sorted(allqs.keys()), sorted(self.client.ids + ['unassigned']))
-        unassigned = allqs.pop('unassigned')
-        for eid,qs in allqs.items():
-            self.assertTrue(isinstance(qs, dict))
-            self.assertEquals(sorted(qs.keys()), ['completed', 'queue', 'tasks'])
-
-    def test_shutdown(self):
-        # self.addEngine(4)
-        ids = self.client.ids
-        id0 = ids[0]
-        self.client.shutdown(id0, block=True)
-        while id0 in self.client.ids:
-            time.sleep(0.1)
-            self.client.spin()
-        
-        self.assertRaises(IndexError, lambda : self.client[id0])
-        
-    def test_result_status(self):
-        pass
-        # to be written
-    
-    def test_db_query_dt(self):
-        """test db query by date"""
-        hist = self.client.hub_history()
-        middle = self.client.db_query({'msg_id' : hist[len(hist)/2]})[0]
-        tic = middle['submitted']
-        before = self.client.db_query({'submitted' : {'$lt' : tic}})
-        after = self.client.db_query({'submitted' : {'$gte' : tic}})
-        self.assertEquals(len(before)+len(after),len(hist))
-        for b in before:
-            self.assertTrue(b['submitted'] < tic)
-        for a in after:
-            self.assertTrue(a['submitted'] >= tic)
-        same = self.client.db_query({'submitted' : tic})
-        for s in same:
-            self.assertTrue(s['submitted'] == tic)
-    
-    def test_db_query_keys(self):
-        """test extracting subset of record keys"""
-        found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
-        for rec in found:
-            self.assertEquals(set(rec.keys()), set(['msg_id', 'submitted', 'completed']))
-    
-    def test_db_query_msg_id(self):
-        """ensure msg_id is always in db queries"""
-        found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
-        for rec in found:
-            self.assertTrue('msg_id' in rec.keys())
-        found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['submitted'])
-        for rec in found:
-            self.assertTrue('msg_id' in rec.keys())
-        found = self.client.db_query({'msg_id': {'$ne' : ''}},keys=['msg_id'])
-        for rec in found:
-            self.assertTrue('msg_id' in rec.keys())
-    
-    def test_db_query_in(self):
-        """test db query with '$in','$nin' operators"""
-        hist = self.client.hub_history()
-        even = hist[::2]
-        odd = hist[1::2]
-        recs = self.client.db_query({ 'msg_id' : {'$in' : even}})
-        found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(even), set(found))
-        recs = self.client.db_query({ 'msg_id' : {'$nin' : even}})
-        found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(odd), set(found))
-    
-    def test_hub_history(self):
-        hist = self.client.hub_history()
-        recs = self.client.db_query({ 'msg_id' : {"$ne":''}})
-        recdict = {}
-        for rec in recs:
-            recdict[rec['msg_id']] = rec
-        
-        latest = datetime(1984,1,1)
-        for msg_id in hist:
-            rec = recdict[msg_id]
-            newt = rec['submitted']
-            self.assertTrue(newt >= latest)
-            latest = newt
-        ar = self.client[-1].apply_async(lambda : 1)
-        ar.get()
-        time.sleep(0.25)
-        self.assertEquals(self.client.hub_history()[-1:],ar.msg_ids)
-    
diff --git a/IPython/parallel/tests/test_db.py b/IPython/parallel/tests/test_db.py
deleted file mode 100644
index e1dae1c0641..00000000000
--- a/IPython/parallel/tests/test_db.py
+++ /dev/null
@@ -1,182 +0,0 @@
-"""Tests for db backends"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-
-import tempfile
-import time
-
-import uuid
-
-from datetime import datetime, timedelta
-from random import choice, randint
-from unittest import TestCase
-
-from nose import SkipTest
-
-from IPython.parallel import error, streamsession as ss
-from IPython.parallel.controller.dictdb import DictDB
-from IPython.parallel.controller.sqlitedb import SQLiteDB
-from IPython.parallel.controller.hub import init_record, empty_record
-
-#-------------------------------------------------------------------------------
-# TestCases
-#-------------------------------------------------------------------------------
-
-class TestDictBackend(TestCase):
-    def setUp(self):
-        self.session = ss.StreamSession()
-        self.db = self.create_db()
-        self.load_records(16)
-    
-    def create_db(self):
-        return DictDB()
-    
-    def load_records(self, n=1):
-        """load n records for testing"""
-        #sleep 1/10 s, to ensure timestamp is different to previous calls
-        time.sleep(0.1)
-        msg_ids = []
-        for i in range(n):
-            msg = self.session.msg('apply_request', content=dict(a=5))
-            msg['buffers'] = []
-            rec = init_record(msg)
-            msg_ids.append(msg['msg_id'])
-            self.db.add_record(msg['msg_id'], rec)
-        return msg_ids
-    
-    def test_add_record(self):
-        before = self.db.get_history()
-        self.load_records(5)
-        after = self.db.get_history()
-        self.assertEquals(len(after), len(before)+5)
-        self.assertEquals(after[:-5],before)
-        
-    def test_drop_record(self):
-        msg_id = self.load_records()[-1]
-        rec = self.db.get_record(msg_id)
-        self.db.drop_record(msg_id)
-        self.assertRaises(KeyError,self.db.get_record, msg_id)
-    
-    def _round_to_millisecond(self, dt):
-        """necessary because mongodb rounds microseconds"""
-        micro = dt.microsecond
-        extra = int(str(micro)[-3:])
-        return dt - timedelta(microseconds=extra)
-    
-    def test_update_record(self):
-        now = self._round_to_millisecond(datetime.now())
-        # 
-        msg_id = self.db.get_history()[-1]
-        rec1 = self.db.get_record(msg_id)
-        data = {'stdout': 'hello there', 'completed' : now}
-        self.db.update_record(msg_id, data)
-        rec2 = self.db.get_record(msg_id)
-        self.assertEquals(rec2['stdout'], 'hello there')
-        self.assertEquals(rec2['completed'], now)
-        rec1.update(data)
-        self.assertEquals(rec1, rec2)
-    
-    # def test_update_record_bad(self):
-    #     """test updating nonexistant records"""
-    #     msg_id = str(uuid.uuid4())
-    #     data = {'stdout': 'hello there'}
-    #     self.assertRaises(KeyError, self.db.update_record, msg_id, data)
-
-    def test_find_records_dt(self):
-        """test finding records by date"""
-        hist = self.db.get_history()
-        middle = self.db.get_record(hist[len(hist)/2])
-        tic = middle['submitted']
-        before = self.db.find_records({'submitted' : {'$lt' : tic}})
-        after = self.db.find_records({'submitted' : {'$gte' : tic}})
-        self.assertEquals(len(before)+len(after),len(hist))
-        for b in before:
-            self.assertTrue(b['submitted'] < tic)
-        for a in after:
-            self.assertTrue(a['submitted'] >= tic)
-        same = self.db.find_records({'submitted' : tic})
-        for s in same:
-            self.assertTrue(s['submitted'] == tic)
-    
-    def test_find_records_keys(self):
-        """test extracting subset of record keys"""
-        found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
-        for rec in found:
-            self.assertEquals(set(rec.keys()), set(['msg_id', 'submitted', 'completed']))
-    
-    def test_find_records_msg_id(self):
-        """ensure msg_id is always in found records"""
-        found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['submitted', 'completed'])
-        for rec in found:
-            self.assertTrue('msg_id' in rec.keys())
-        found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['submitted'])
-        for rec in found:
-            self.assertTrue('msg_id' in rec.keys())
-        found = self.db.find_records({'msg_id': {'$ne' : ''}},keys=['msg_id'])
-        for rec in found:
-            self.assertTrue('msg_id' in rec.keys())
-    
-    def test_find_records_in(self):
-        """test finding records with '$in','$nin' operators"""
-        hist = self.db.get_history()
-        even = hist[::2]
-        odd = hist[1::2]
-        recs = self.db.find_records({ 'msg_id' : {'$in' : even}})
-        found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(even), set(found))
-        recs = self.db.find_records({ 'msg_id' : {'$nin' : even}})
-        found = [ r['msg_id'] for r in recs ]
-        self.assertEquals(set(odd), set(found))
-    
-    def test_get_history(self):
-        msg_ids = self.db.get_history()
-        latest = datetime(1984,1,1)
-        for msg_id in msg_ids:
-            rec = self.db.get_record(msg_id)
-            newt = rec['submitted']
-            self.assertTrue(newt >= latest)
-            latest = newt
-        msg_id = self.load_records(1)[-1]
-        self.assertEquals(self.db.get_history()[-1],msg_id)
-    
-    def test_datetime(self):
-        """get/set timestamps with datetime objects"""
-        msg_id = self.db.get_history()[-1]
-        rec = self.db.get_record(msg_id)
-        self.assertTrue(isinstance(rec['submitted'], datetime))
-        self.db.update_record(msg_id, dict(completed=datetime.now()))
-        rec = self.db.get_record(msg_id)
-        self.assertTrue(isinstance(rec['completed'], datetime))
-            
-class TestSQLiteBackend(TestDictBackend):
-    def create_db(self):
-        return SQLiteDB(location=tempfile.gettempdir())
-    
-    def tearDown(self):
-        self.db._db.close()
-
-# optional MongoDB test
-try:
-    from IPython.parallel.controller.mongodb import MongoDB
-except ImportError:
-    pass
-else:
-    class TestMongoBackend(TestDictBackend):
-        def create_db(self):
-            try:
-                return MongoDB(database='iptestdb')
-            except Exception:
-                raise SkipTest("Couldn't connect to mongodb instance")
-            
-        def tearDown(self):
-            self.db._connection.drop_database('iptestdb')
diff --git a/IPython/parallel/tests/test_dependency.py b/IPython/parallel/tests/test_dependency.py
deleted file mode 100644
index 9fe1604fb64..00000000000
--- a/IPython/parallel/tests/test_dependency.py
+++ /dev/null
@@ -1,101 +0,0 @@
-"""Tests for dependency.py"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-# import
-import os
-
-from IPython.utils.pickleutil import can, uncan
-
-import IPython.parallel as pmod
-from IPython.parallel.util import interactive
-
-from IPython.parallel.tests import add_engines
-from .clienttest import ClusterTestCase
-
-def setup():
-    add_engines(1)
-
-@pmod.require('time')
-def wait(n):
-    time.sleep(n)
-    return n
-
-mixed = map(str, range(10))
-completed = map(str, range(0,10,2))
-failed = map(str, range(1,10,2))
-
-class DependencyTest(ClusterTestCase):
-    
-    def setUp(self):
-        ClusterTestCase.setUp(self)
-        self.user_ns = {'__builtins__' : __builtins__}
-        self.view = self.client.load_balanced_view()
-        self.dview = self.client[-1]
-        self.succeeded = set(map(str, range(0,25,2)))
-        self.failed = set(map(str, range(1,25,2)))
-    
-    def assertMet(self, dep):
-        self.assertTrue(dep.check(self.succeeded, self.failed), "Dependency should be met")
-        
-    def assertUnmet(self, dep):
-        self.assertFalse(dep.check(self.succeeded, self.failed), "Dependency should not be met")
-        
-    def assertUnreachable(self, dep):
-        self.assertTrue(dep.unreachable(self.succeeded, self.failed), "Dependency should be unreachable")
-    
-    def assertReachable(self, dep):
-        self.assertFalse(dep.unreachable(self.succeeded, self.failed), "Dependency should be reachable")
-    
-    def cancan(self, f):
-        """decorator to pass through canning into self.user_ns"""
-        return uncan(can(f), self.user_ns)
-    
-    def test_require_imports(self):
-        """test that @require imports names"""
-        @self.cancan
-        @pmod.require('urllib')
-        @interactive
-        def encode(dikt):
-            return urllib.urlencode(dikt)
-        # must pass through canning to properly connect namespaces
-        self.assertEquals(encode(dict(a=5)), 'a=5')
-    
-    def test_success_only(self):
-        dep = pmod.Dependency(mixed, success=True, failure=False)
-        self.assertUnmet(dep)
-        self.assertUnreachable(dep)
-        dep.all=False
-        self.assertMet(dep)
-        self.assertReachable(dep)
-        dep = pmod.Dependency(completed, success=True, failure=False)
-        self.assertMet(dep)
-        self.assertReachable(dep)
-        dep.all=False
-        self.assertMet(dep)
-        self.assertReachable(dep)
-
-    def test_failure_only(self):
-        dep = pmod.Dependency(mixed, success=False, failure=True)
-        self.assertUnmet(dep)
-        self.assertUnreachable(dep)
-        dep.all=False
-        self.assertMet(dep)
-        self.assertReachable(dep)
-        dep = pmod.Dependency(completed, success=False, failure=True)
-        self.assertUnmet(dep)
-        self.assertUnreachable(dep)
-        dep.all=False
-        self.assertUnmet(dep)
-        self.assertUnreachable(dep)
diff --git a/IPython/parallel/tests/test_newserialized.py b/IPython/parallel/tests/test_newserialized.py
deleted file mode 100644
index 3c3e5e6cf93..00000000000
--- a/IPython/parallel/tests/test_newserialized.py
+++ /dev/null
@@ -1,108 +0,0 @@
-"""test serialization with newserialized"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-from unittest import TestCase
-
-from IPython.testing.decorators import parametric
-from IPython.utils import newserialized as ns
-from IPython.utils.pickleutil import can, uncan, CannedObject, CannedFunction
-from IPython.parallel.tests.clienttest import skip_without
-
-
-class CanningTestCase(TestCase):
-    def test_canning(self):
-        d = dict(a=5,b=6)
-        cd = can(d)
-        self.assertTrue(isinstance(cd, dict))
-
-    def test_canned_function(self):
-        f = lambda : 7
-        cf = can(f)
-        self.assertTrue(isinstance(cf, CannedFunction))
-    
-    @parametric
-    def test_can_roundtrip(cls):
-        objs = [
-            dict(),
-            set(),
-            list(),
-            ['a',1,['a',1],u'e'],
-        ]
-        return map(cls.run_roundtrip, objs)
-    
-    @classmethod
-    def run_roundtrip(self, obj):
-        o = uncan(can(obj))
-        assert o == obj, "failed assertion: %r == %r"%(o,obj)
-    
-    def test_serialized_interfaces(self):
-
-        us = {'a':10, 'b':range(10)}
-        s = ns.serialize(us)
-        uus = ns.unserialize(s)
-        self.assertTrue(isinstance(s, ns.SerializeIt))
-        self.assertEquals(uus, us)
-
-    def test_pickle_serialized(self):
-        obj = {'a':1.45345, 'b':'asdfsdf', 'c':10000L}
-        original = ns.UnSerialized(obj)
-        originalSer = ns.SerializeIt(original)
-        firstData = originalSer.getData()
-        firstTD = originalSer.getTypeDescriptor()
-        firstMD = originalSer.getMetadata()
-        self.assertEquals(firstTD, 'pickle')
-        self.assertEquals(firstMD, {})
-        unSerialized = ns.UnSerializeIt(originalSer)
-        secondObj = unSerialized.getObject()
-        for k, v in secondObj.iteritems():
-            self.assertEquals(obj[k], v)
-        secondSer = ns.SerializeIt(ns.UnSerialized(secondObj))
-        self.assertEquals(firstData, secondSer.getData())
-        self.assertEquals(firstTD, secondSer.getTypeDescriptor() )
-        self.assertEquals(firstMD, secondSer.getMetadata())
-    
-    @skip_without('numpy')
-    def test_ndarray_serialized(self):
-        import numpy
-        a = numpy.linspace(0.0, 1.0, 1000)
-        unSer1 = ns.UnSerialized(a)
-        ser1 = ns.SerializeIt(unSer1)
-        td = ser1.getTypeDescriptor()
-        self.assertEquals(td, 'ndarray')
-        md = ser1.getMetadata()
-        self.assertEquals(md['shape'], a.shape)
-        self.assertEquals(md['dtype'], a.dtype.str)
-        buff = ser1.getData()
-        self.assertEquals(buff, numpy.getbuffer(a))
-        s = ns.Serialized(buff, td, md)
-        final = ns.unserialize(s)
-        self.assertEquals(numpy.getbuffer(a), numpy.getbuffer(final))
-        self.assertTrue((a==final).all())
-        self.assertEquals(a.dtype.str, final.dtype.str)
-        self.assertEquals(a.shape, final.shape)
-        # test non-copying:
-        a[2] = 1e9
-        self.assertTrue((a==final).all())
-    
-    def test_uncan_function_globals(self):
-        """test that uncanning a module function restores it into its module"""
-        from re import search
-        cf = can(search)
-        csearch = uncan(cf)
-        self.assertEqual(csearch.__module__, search.__module__)
-        self.assertNotEqual(csearch('asd', 'asdf'), None)
-        csearch = uncan(cf, dict(a=5))
-        self.assertEqual(csearch.__module__, search.__module__)
-        self.assertNotEqual(csearch('asd', 'asdf'), None)
-        
-        
\ No newline at end of file
diff --git a/IPython/parallel/tests/test_streamsession.py b/IPython/parallel/tests/test_streamsession.py
deleted file mode 100644
index 891afe04e80..00000000000
--- a/IPython/parallel/tests/test_streamsession.py
+++ /dev/null
@@ -1,111 +0,0 @@
-"""test building messages with streamsession"""
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import os
-import uuid
-import zmq
-
-from zmq.tests import BaseZMQTestCase
-from zmq.eventloop.zmqstream import ZMQStream
-# from IPython.zmq.tests import SessionTestCase
-from IPython.parallel import streamsession as ss
-
-class SessionTestCase(BaseZMQTestCase):
-    
-    def setUp(self):
-        BaseZMQTestCase.setUp(self)
-        self.session = ss.StreamSession()
-
-class TestSession(SessionTestCase):
-    
-    def test_msg(self):
-        """message format"""
-        msg = self.session.msg('execute')
-        thekeys = set('header msg_id parent_header msg_type content'.split())
-        s = set(msg.keys())
-        self.assertEquals(s, thekeys)
-        self.assertTrue(isinstance(msg['content'],dict))
-        self.assertTrue(isinstance(msg['header'],dict))
-        self.assertTrue(isinstance(msg['parent_header'],dict))
-        self.assertEquals(msg['msg_type'], 'execute')
-        
-            
-    
-    def test_args(self):
-        """initialization arguments for StreamSession"""
-        s = self.session
-        self.assertTrue(s.pack is ss.default_packer)
-        self.assertTrue(s.unpack is ss.default_unpacker)
-        self.assertEquals(s.username, os.environ.get('USER', 'username'))
-        
-        s = ss.StreamSession(username=None)
-        self.assertEquals(s.username, os.environ.get('USER', 'username'))
-        
-        self.assertRaises(TypeError, ss.StreamSession, packer='hi')
-        self.assertRaises(TypeError, ss.StreamSession, unpacker='hi')
-        u = str(uuid.uuid4())
-        s = ss.StreamSession(username='carrot', session=u)
-        self.assertEquals(s.session, u)
-        self.assertEquals(s.username, 'carrot')
-        
-    def test_tracking(self):
-        """test tracking messages"""
-        a,b = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
-        s = self.session
-        stream = ZMQStream(a)
-        msg = s.send(a, 'hello', track=False)
-        self.assertTrue(msg['tracker'] is None)
-        msg = s.send(a, 'hello', track=True)
-        self.assertTrue(isinstance(msg['tracker'], zmq.MessageTracker))
-        M = zmq.Message(b'hi there', track=True)
-        msg = s.send(a, 'hello', buffers=[M], track=True)
-        t = msg['tracker']
-        self.assertTrue(isinstance(t, zmq.MessageTracker))
-        self.assertRaises(zmq.NotDone, t.wait, .1)
-        del M
-        t.wait(1) # this will raise
-        
-        
-    # def test_rekey(self):
-    #     """rekeying dict around json str keys"""
-    #     d = {'0': uuid.uuid4(), 0:uuid.uuid4()}
-    #     self.assertRaises(KeyError, ss.rekey, d)
-    #     
-    #     d = {'0': uuid.uuid4(), 1:uuid.uuid4(), 'asdf':uuid.uuid4()}
-    #     d2 = {0:d['0'],1:d[1],'asdf':d['asdf']}
-    #     rd = ss.rekey(d)
-    #     self.assertEquals(d2,rd)
-    #     
-    #     d = {'1.5':uuid.uuid4(),'1':uuid.uuid4()}
-    #     d2 = {1.5:d['1.5'],1:d['1']}
-    #     rd = ss.rekey(d)
-    #     self.assertEquals(d2,rd)
-    #     
-    #     d = {'1.0':uuid.uuid4(),'1':uuid.uuid4()}
-    #     self.assertRaises(KeyError, ss.rekey, d)
-    # 
-    def test_unique_msg_ids(self):
-        """test that messages receive unique ids"""
-        ids = set()
-        for i in range(2**12):
-            h = self.session.msg_header('test')
-            msg_id = h['msg_id']
-            self.assertTrue(msg_id not in ids)
-            ids.add(msg_id)
-    
-    def test_feed_identities(self):
-        """scrub the front for zmq IDENTITIES"""
-        theids = "engine client other".split()
-        content = dict(code='whoda',stuff=object())
-        themsg = self.session.msg('execute',content=content)
-        pmsg = theids
diff --git a/IPython/parallel/tests/test_view.py b/IPython/parallel/tests/test_view.py
deleted file mode 100644
index 8d0f3f7443e..00000000000
--- a/IPython/parallel/tests/test_view.py
+++ /dev/null
@@ -1,452 +0,0 @@
-"""test View objects"""
-# -*- coding: utf-8 -*-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import sys
-import time
-from tempfile import mktemp
-from StringIO import StringIO
-
-import zmq
-
-from IPython import parallel  as pmod
-from IPython.parallel import error
-from IPython.parallel import AsyncResult, AsyncHubResult, AsyncMapResult
-from IPython.parallel import LoadBalancedView, DirectView
-from IPython.parallel.util import interactive
-
-from IPython.parallel.tests import add_engines
-
-from .clienttest import ClusterTestCase, crash, wait, skip_without
-
-def setup():
-    add_engines(3)
-
-class TestView(ClusterTestCase):
-    
-    def test_z_crash_task(self):
-        """test graceful handling of engine death (balanced)"""
-        # self.add_engines(1)
-        ar = self.client[-1].apply_async(crash)
-        self.assertRaisesRemote(error.EngineError, ar.get)
-        eid = ar.engine_id
-        tic = time.time()
-        while eid in self.client.ids and time.time()-tic < 5:
-            time.sleep(.01)
-            self.client.spin()
-        self.assertFalse(eid in self.client.ids, "Engine should have died")
-    
-    def test_z_crash_mux(self):
-        """test graceful handling of engine death (direct)"""
-        # self.add_engines(1)
-        eid = self.client.ids[-1]
-        ar = self.client[eid].apply_async(crash)
-        self.assertRaisesRemote(error.EngineError, ar.get)
-        eid = ar.engine_id
-        tic = time.time()
-        while eid in self.client.ids and time.time()-tic < 5:
-            time.sleep(.01)
-            self.client.spin()
-        self.assertFalse(eid in self.client.ids, "Engine should have died")
-    
-    def test_push_pull(self):
-        """test pushing and pulling"""
-        data = dict(a=10, b=1.05, c=range(10), d={'e':(1,2),'f':'hi'})
-        t = self.client.ids[-1]
-        v = self.client[t]
-        push = v.push
-        pull = v.pull
-        v.block=True
-        nengines = len(self.client)
-        push({'data':data})
-        d = pull('data')
-        self.assertEquals(d, data)
-        self.client[:].push({'data':data})
-        d = self.client[:].pull('data', block=True)
-        self.assertEquals(d, nengines*[data])
-        ar = push({'data':data}, block=False)
-        self.assertTrue(isinstance(ar, AsyncResult))
-        r = ar.get()
-        ar = self.client[:].pull('data', block=False)
-        self.assertTrue(isinstance(ar, AsyncResult))
-        r = ar.get()
-        self.assertEquals(r, nengines*[data])
-        self.client[:].push(dict(a=10,b=20))
-        r = self.client[:].pull(('a','b'), block=True)
-        self.assertEquals(r, nengines*[[10,20]])
-    
-    def test_push_pull_function(self):
-        "test pushing and pulling functions"
-        def testf(x):
-            return 2.0*x
-        
-        t = self.client.ids[-1]
-        v = self.client[t]
-        v.block=True
-        push = v.push
-        pull = v.pull
-        execute = v.execute
-        push({'testf':testf})
-        r = pull('testf')
-        self.assertEqual(r(1.0), testf(1.0))
-        execute('r = testf(10)')
-        r = pull('r')
-        self.assertEquals(r, testf(10))
-        ar = self.client[:].push({'testf':testf}, block=False)
-        ar.get()
-        ar = self.client[:].pull('testf', block=False)
-        rlist = ar.get()
-        for r in rlist:
-            self.assertEqual(r(1.0), testf(1.0))
-        execute("def g(x): return x*x")
-        r = pull(('testf','g'))
-        self.assertEquals((r[0](10),r[1](10)), (testf(10), 100))
-    
-    def test_push_function_globals(self):
-        """test that pushed functions have access to globals"""
-        @interactive
-        def geta():
-            return a
-        # self.add_engines(1)
-        v = self.client[-1]
-        v.block=True
-        v['f'] = geta
-        self.assertRaisesRemote(NameError, v.execute, 'b=f()')
-        v.execute('a=5')
-        v.execute('b=f()')
-        self.assertEquals(v['b'], 5)
-    
-    def test_push_function_defaults(self):
-        """test that pushed functions preserve default args"""
-        def echo(a=10):
-            return a
-        v = self.client[-1]
-        v.block=True
-        v['f'] = echo
-        v.execute('b=f()')
-        self.assertEquals(v['b'], 10)
-
-    def test_get_result(self):
-        """test getting results from the Hub."""
-        c = pmod.Client(profile='iptest')
-        # self.add_engines(1)
-        t = c.ids[-1]
-        v = c[t]
-        v2 = self.client[t]
-        ar = v.apply_async(wait, 1)
-        # give the monitor time to notice the message
-        time.sleep(.25)
-        ahr = v2.get_result(ar.msg_ids)
-        self.assertTrue(isinstance(ahr, AsyncHubResult))
-        self.assertEquals(ahr.get(), ar.get())
-        ar2 = v2.get_result(ar.msg_ids)
-        self.assertFalse(isinstance(ar2, AsyncHubResult))
-        c.spin()
-        c.close()
-    
-    def test_run_newline(self):
-        """test that run appends newline to files"""
-        tmpfile = mktemp()
-        with open(tmpfile, 'w') as f:
-            f.write("""def g():
-                return 5
-                """)
-        v = self.client[-1]
-        v.run(tmpfile, block=True)
-        self.assertEquals(v.apply_sync(lambda f: f(), pmod.Reference('g')), 5)
-
-    def test_apply_tracked(self):
-        """test tracking for apply"""
-        # self.add_engines(1)
-        t = self.client.ids[-1]
-        v = self.client[t]
-        v.block=False
-        def echo(n=1024*1024, **kwargs):
-            with v.temp_flags(**kwargs):
-                return v.apply(lambda x: x, 'x'*n)
-        ar = echo(1, track=False)
-        self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertTrue(ar.sent)
-        ar = echo(track=True)
-        self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertEquals(ar.sent, ar._tracker.done)
-        ar._tracker.wait()
-        self.assertTrue(ar.sent)
-        
-    def test_push_tracked(self):
-        t = self.client.ids[-1]
-        ns = dict(x='x'*1024*1024)
-        v = self.client[t]
-        ar = v.push(ns, block=False, track=False)
-        self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertTrue(ar.sent)
-        
-        ar = v.push(ns, block=False, track=True)
-        self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertEquals(ar.sent, ar._tracker.done)
-        ar._tracker.wait()
-        self.assertTrue(ar.sent)
-        ar.get()
-        
-    def test_scatter_tracked(self):
-        t = self.client.ids
-        x='x'*1024*1024
-        ar = self.client[t].scatter('x', x, block=False, track=False)
-        self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertTrue(ar.sent)
-        
-        ar = self.client[t].scatter('x', x, block=False, track=True)
-        self.assertTrue(isinstance(ar._tracker, zmq.MessageTracker))
-        self.assertEquals(ar.sent, ar._tracker.done)
-        ar._tracker.wait()
-        self.assertTrue(ar.sent)
-        ar.get()
-    
-    def test_remote_reference(self):
-        v = self.client[-1]
-        v['a'] = 123
-        ra = pmod.Reference('a')
-        b = v.apply_sync(lambda x: x, ra)
-        self.assertEquals(b, 123)
-
-
-    def test_scatter_gather(self):
-        view = self.client[:]
-        seq1 = range(16)
-        view.scatter('a', seq1)
-        seq2 = view.gather('a', block=True)
-        self.assertEquals(seq2, seq1)
-        self.assertRaisesRemote(NameError, view.gather, 'asdf', block=True)
-    
-    @skip_without('numpy')
-    def test_scatter_gather_numpy(self):
-        import numpy
-        from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
-        view = self.client[:]
-        a = numpy.arange(64)
-        view.scatter('a', a)
-        b = view.gather('a', block=True)
-        assert_array_equal(b, a)
-    
-    def test_map(self):
-        view = self.client[:]
-        def f(x):
-            return x**2
-        data = range(16)
-        r = view.map_sync(f, data)
-        self.assertEquals(r, map(f, data))
-    
-    def test_scatterGatherNonblocking(self):
-        data = range(16)
-        view = self.client[:]
-        view.scatter('a', data, block=False)
-        ar = view.gather('a', block=False)
-        self.assertEquals(ar.get(), data)
-    
-    @skip_without('numpy')
-    def test_scatter_gather_numpy_nonblocking(self):
-        import numpy
-        from numpy.testing.utils import assert_array_equal, assert_array_almost_equal
-        a = numpy.arange(64)
-        view = self.client[:]
-        ar = view.scatter('a', a, block=False)
-        self.assertTrue(isinstance(ar, AsyncResult))
-        amr = view.gather('a', block=False)
-        self.assertTrue(isinstance(amr, AsyncMapResult))
-        assert_array_equal(amr.get(), a)
-
-    def test_execute(self):
-        view = self.client[:]
-        # self.client.debug=True
-        execute = view.execute
-        ar = execute('c=30', block=False)
-        self.assertTrue(isinstance(ar, AsyncResult))
-        ar = execute('d=[0,1,2]', block=False)
-        self.client.wait(ar, 1)
-        self.assertEquals(len(ar.get()), len(self.client))
-        for c in view['c']:
-            self.assertEquals(c, 30)
-    
-    def test_abort(self):
-        view = self.client[-1]
-        ar = view.execute('import time; time.sleep(0.25)', block=False)
-        ar2 = view.apply_async(lambda : 2)
-        ar3 = view.apply_async(lambda : 3)
-        view.abort(ar2)
-        view.abort(ar3.msg_ids)
-        self.assertRaises(error.TaskAborted, ar2.get)
-        self.assertRaises(error.TaskAborted, ar3.get)
-        
-    def test_temp_flags(self):
-        view = self.client[-1]
-        view.block=True
-        with view.temp_flags(block=False):
-            self.assertFalse(view.block)
-        self.assertTrue(view.block)
-    
-    def test_importer(self):
-        view = self.client[-1]
-        view.clear(block=True)
-        with view.importer:
-            import re
-        
-        @interactive
-        def findall(pat, s):
-            # this globals() step isn't necessary in real code
-            # only to prevent a closure in the test
-            re = globals()['re']
-            return re.findall(pat, s)
-        
-        self.assertEquals(view.apply_sync(findall, '\w+', 'hello world'), 'hello world'.split())
-    
-    # parallel magic tests
-    
-    def test_magic_px_blocking(self):
-        ip = get_ipython()
-        v = self.client[-1]
-        v.activate()
-        v.block=True
-
-        ip.magic_px('a=5')
-        self.assertEquals(v['a'], 5)
-        ip.magic_px('a=10')
-        self.assertEquals(v['a'], 10)
-        sio = StringIO()
-        savestdout = sys.stdout
-        sys.stdout = sio
-        ip.magic_px('print a')
-        sys.stdout = savestdout
-        sio.read()
-        self.assertTrue('[stdout:%i]'%v.targets in sio.buf)
-        self.assertRaisesRemote(ZeroDivisionError, ip.magic_px, '1/0')
-
-    def test_magic_px_nonblocking(self):
-        ip = get_ipython()
-        v = self.client[-1]
-        v.activate()
-        v.block=False
-
-        ip.magic_px('a=5')
-        self.assertEquals(v['a'], 5)
-        ip.magic_px('a=10')
-        self.assertEquals(v['a'], 10)
-        sio = StringIO()
-        savestdout = sys.stdout
-        sys.stdout = sio
-        ip.magic_px('print a')
-        sys.stdout = savestdout
-        sio.read()
-        self.assertFalse('[stdout:%i]'%v.targets in sio.buf)
-        ip.magic_px('1/0')
-        ar = v.get_result(-1)
-        self.assertRaisesRemote(ZeroDivisionError, ar.get)
-    
-    def test_magic_autopx_blocking(self):
-        ip = get_ipython()
-        v = self.client[-1]
-        v.activate()
-        v.block=True
-
-        sio = StringIO()
-        savestdout = sys.stdout
-        sys.stdout = sio
-        ip.magic_autopx()
-        ip.run_cell('\n'.join(('a=5','b=10','c=0')))
-        ip.run_cell('print b')
-        ip.run_cell("b/c")
-        ip.run_code(compile('b*=2', '', 'single'))
-        ip.magic_autopx()
-        sys.stdout = savestdout
-        sio.read()
-        output = sio.buf.strip()
-        self.assertTrue(output.startswith('%autopx enabled'))
-        self.assertTrue(output.endswith('%autopx disabled'))
-        self.assertTrue('RemoteError: ZeroDivisionError' in output)
-        ar = v.get_result(-2)
-        self.assertEquals(v['a'], 5)
-        self.assertEquals(v['b'], 20)
-        self.assertRaisesRemote(ZeroDivisionError, ar.get)
-
-    def test_magic_autopx_nonblocking(self):
-        ip = get_ipython()
-        v = self.client[-1]
-        v.activate()
-        v.block=False
-
-        sio = StringIO()
-        savestdout = sys.stdout
-        sys.stdout = sio
-        ip.magic_autopx()
-        ip.run_cell('\n'.join(('a=5','b=10','c=0')))
-        ip.run_cell('print b')
-        ip.run_cell("b/c")
-        ip.run_code(compile('b*=2', '', 'single'))
-        ip.magic_autopx()
-        sys.stdout = savestdout
-        sio.read()
-        output = sio.buf.strip()
-        self.assertTrue(output.startswith('%autopx enabled'))
-        self.assertTrue(output.endswith('%autopx disabled'))
-        self.assertFalse('ZeroDivisionError' in output)
-        ar = v.get_result(-2)
-        self.assertEquals(v['a'], 5)
-        self.assertEquals(v['b'], 20)
-        self.assertRaisesRemote(ZeroDivisionError, ar.get)
-    
-    def test_magic_result(self):
-        ip = get_ipython()
-        v = self.client[-1]
-        v.activate()
-        v['a'] = 111
-        ra = v['a']
-        
-        ar = ip.magic_result()
-        self.assertEquals(ar.msg_ids, [v.history[-1]])
-        self.assertEquals(ar.get(), 111)
-        ar = ip.magic_result('-2')
-        self.assertEquals(ar.msg_ids, [v.history[-2]])
-    
-    def test_unicode_execute(self):
-        """test executing unicode strings"""
-        v = self.client[-1]
-        v.block=True
-        code=u"a=u'é'"
-        v.execute(code)
-        self.assertEquals(v['a'], u'é')
-        
-    def test_unicode_apply_result(self):
-        """test unicode apply results"""
-        v = self.client[-1]
-        r = v.apply_sync(lambda : u'é')
-        self.assertEquals(r, u'é')
-    
-    def test_unicode_apply_arg(self):
-        """test passing unicode arguments to apply"""
-        v = self.client[-1]
-        
-        @interactive
-        def check_unicode(a, check):
-            assert isinstance(a, unicode), "%r is not unicode"%a
-            assert isinstance(check, bytes), "%r is not bytes"%check
-            assert a.encode('utf8') == check, "%s != %s"%(a,check)
-        
-        for s in [ u'é', u'ßø®∫','asdf'.decode() ]:
-            try:
-                v.apply_sync(check_unicode, s, s.encode('utf8'))
-            except error.RemoteError as e:
-                if e.ename == 'AssertionError':
-                    self.fail(e.evalue)
-                else:
-                    raise e
-        
-
-
diff --git a/IPython/parallel/util.py b/IPython/parallel/util.py
deleted file mode 100644
index 9bac6d1f49d..00000000000
--- a/IPython/parallel/util.py
+++ /dev/null
@@ -1,477 +0,0 @@
-"""some generic utilities for dealing with classes, urls, and serialization"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports.
-import logging
-import os
-import re
-import stat
-import socket
-import sys
-from datetime import datetime
-from signal import signal, SIGINT, SIGABRT, SIGTERM
-try:
-    from signal import SIGKILL
-except ImportError:
-    SIGKILL=None
-
-try:
-    import cPickle
-    pickle = cPickle
-except:
-    cPickle = None
-    import pickle
-
-# System library imports
-import zmq
-from zmq.log import handlers
-
-# IPython imports
-from IPython.utils.pickleutil import can, uncan, canSequence, uncanSequence
-from IPython.utils.newserialized import serialize, unserialize
-from IPython.zmq.log import EnginePUBHandler
-
-# globals
-ISO8601="%Y-%m-%dT%H:%M:%S.%f"
-ISO8601_RE=re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+$")
-
-#-----------------------------------------------------------------------------
-# Classes
-#-----------------------------------------------------------------------------
-
-class Namespace(dict):
-    """Subclass of dict for attribute access to keys."""
-    
-    def __getattr__(self, key):
-        """getattr aliased to getitem"""
-        if key in self.iterkeys():
-            return self[key]
-        else:
-            raise NameError(key)
-
-    def __setattr__(self, key, value):
-        """setattr aliased to setitem, with strict"""
-        if hasattr(dict, key):
-            raise KeyError("Cannot override dict keys %r"%key)
-        self[key] = value
-    
-
-class ReverseDict(dict):
-    """simple double-keyed subset of dict methods."""
-    
-    def __init__(self, *args, **kwargs):
-        dict.__init__(self, *args, **kwargs)
-        self._reverse = dict()
-        for key, value in self.iteritems():
-            self._reverse[value] = key
-    
-    def __getitem__(self, key):
-        try:
-            return dict.__getitem__(self, key)
-        except KeyError:
-            return self._reverse[key]
-    
-    def __setitem__(self, key, value):
-        if key in self._reverse:
-            raise KeyError("Can't have key %r on both sides!"%key)
-        dict.__setitem__(self, key, value)
-        self._reverse[value] = key
-    
-    def pop(self, key):
-        value = dict.pop(self, key)
-        self._reverse.pop(value)
-        return value
-    
-    def get(self, key, default=None):
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-def extract_dates(obj):
-    """extract ISO8601 dates from unpacked JSON"""
-    if isinstance(obj, dict):
-        for k,v in obj.iteritems():
-            obj[k] = extract_dates(v)
-    elif isinstance(obj, list):
-        obj = [ extract_dates(o) for o in obj ]
-    elif isinstance(obj, basestring):
-        if ISO8601_RE.match(obj):
-            obj = datetime.strptime(obj, ISO8601)
-    return obj
-
-def validate_url(url):
-    """validate a url for zeromq"""
-    if not isinstance(url, basestring):
-        raise TypeError("url must be a string, not %r"%type(url))
-    url = url.lower()
-    
-    proto_addr = url.split('://')
-    assert len(proto_addr) == 2, 'Invalid url: %r'%url
-    proto, addr = proto_addr
-    assert proto in ['tcp','pgm','epgm','ipc','inproc'], "Invalid protocol: %r"%proto
-    
-    # domain pattern adapted from http://www.regexlib.com/REDetails.aspx?regexp_id=391
-    # author: Remi Sabourin
-    pat = re.compile(r'^([\w\d]([\w\d\-]{0,61}[\w\d])?\.)*[\w\d]([\w\d\-]{0,61}[\w\d])?$')
-    
-    if proto == 'tcp':
-        lis = addr.split(':')
-        assert len(lis) == 2, 'Invalid url: %r'%url
-        addr,s_port = lis
-        try:
-            port = int(s_port)
-        except ValueError:
-            raise AssertionError("Invalid port %r in url: %r"%(port, url))
-        
-        assert addr == '*' or pat.match(addr) is not None, 'Invalid url: %r'%url
-        
-    else:
-        # only validate tcp urls currently
-        pass
-    
-    return True
-
-
-def validate_url_container(container):
-    """validate a potentially nested collection of urls."""
-    if isinstance(container, basestring):
-        url = container
-        return validate_url(url)
-    elif isinstance(container, dict):
-        container = container.itervalues()
-    
-    for element in container:
-        validate_url_container(element)
-
-
-def split_url(url):
-    """split a zmq url (tcp://ip:port) into ('tcp','ip','port')."""
-    proto_addr = url.split('://')
-    assert len(proto_addr) == 2, 'Invalid url: %r'%url
-    proto, addr = proto_addr
-    lis = addr.split(':')
-    assert len(lis) == 2, 'Invalid url: %r'%url
-    addr,s_port = lis
-    return proto,addr,s_port
-    
-def disambiguate_ip_address(ip, location=None):
-    """turn multi-ip interfaces '0.0.0.0' and '*' into connectable
-    ones, based on the location (default interpretation of location is localhost)."""
-    if ip in ('0.0.0.0', '*'):
-        external_ips = socket.gethostbyname_ex(socket.gethostname())[2]
-        if location is None or location in external_ips:
-            ip='127.0.0.1'
-        elif location:
-            return location
-    return ip
-
-def disambiguate_url(url, location=None):
-    """turn multi-ip interfaces '0.0.0.0' and '*' into connectable
-    ones, based on the location (default interpretation is localhost).
-    
-    This is for zeromq urls, such as tcp://*:10101."""
-    try:
-        proto,ip,port = split_url(url)
-    except AssertionError:
-        # probably not tcp url; could be ipc, etc.
-        return url
-    
-    ip = disambiguate_ip_address(ip,location)
-    
-    return "%s://%s:%s"%(proto,ip,port)
-
-
-def rekey(dikt):
-    """Rekey a dict that has been forced to use str keys where there should be
-    ints by json.  This belongs in the jsonutil added by fperez."""
-    for k in dikt.iterkeys():
-        if isinstance(k, str):
-            ik=fk=None
-            try:
-                ik = int(k)
-            except ValueError:
-                try:
-                    fk = float(k)
-                except ValueError:
-                    continue
-            if ik is not None:
-                nk = ik
-            else:
-                nk = fk
-            if nk in dikt:
-                raise KeyError("already have key %r"%nk)
-            dikt[nk] = dikt.pop(k)
-    return dikt
-
-def serialize_object(obj, threshold=64e-6):
-    """Serialize an object into a list of sendable buffers.
-    
-    Parameters
-    ----------
-    
-    obj : object
-        The object to be serialized
-    threshold : float
-        The threshold for not double-pickling the content.
-        
-    
-    Returns
-    -------
-    ('pmd', [bufs]) :
-        where pmd is the pickled metadata wrapper,
-        bufs is a list of data buffers
-    """
-    databuffers = []
-    if isinstance(obj, (list, tuple)):
-        clist = canSequence(obj)
-        slist = map(serialize, clist)
-        for s in slist:
-            if s.typeDescriptor in ('buffer', 'ndarray') or s.getDataSize() > threshold:
-                databuffers.append(s.getData())
-                s.data = None
-        return pickle.dumps(slist,-1), databuffers
-    elif isinstance(obj, dict):
-        sobj = {}
-        for k in sorted(obj.iterkeys()):
-            s = serialize(can(obj[k]))
-            if s.typeDescriptor in ('buffer', 'ndarray') or s.getDataSize() > threshold:
-                databuffers.append(s.getData())
-                s.data = None
-            sobj[k] = s
-        return pickle.dumps(sobj,-1),databuffers
-    else:
-        s = serialize(can(obj))
-        if s.typeDescriptor in ('buffer', 'ndarray') or s.getDataSize() > threshold:
-            databuffers.append(s.getData())
-            s.data = None
-        return pickle.dumps(s,-1),databuffers
-            
-        
-def unserialize_object(bufs):
-    """reconstruct an object serialized by serialize_object from data buffers."""
-    bufs = list(bufs)
-    sobj = pickle.loads(bufs.pop(0))
-    if isinstance(sobj, (list, tuple)):
-        for s in sobj:
-            if s.data is None:
-                s.data = bufs.pop(0)
-        return uncanSequence(map(unserialize, sobj)), bufs
-    elif isinstance(sobj, dict):
-        newobj = {}
-        for k in sorted(sobj.iterkeys()):
-            s = sobj[k]
-            if s.data is None:
-                s.data = bufs.pop(0)
-            newobj[k] = uncan(unserialize(s))
-        return newobj, bufs
-    else:
-        if sobj.data is None:
-            sobj.data = bufs.pop(0)
-        return uncan(unserialize(sobj)), bufs
-
-def pack_apply_message(f, args, kwargs, threshold=64e-6):
-    """pack up a function, args, and kwargs to be sent over the wire
-    as a series of buffers. Any object whose data is larger than `threshold`
-    will not have their data copied (currently only numpy arrays support zero-copy)"""
-    msg = [pickle.dumps(can(f),-1)]
-    databuffers = [] # for large objects
-    sargs, bufs = serialize_object(args,threshold)
-    msg.append(sargs)
-    databuffers.extend(bufs)
-    skwargs, bufs = serialize_object(kwargs,threshold)
-    msg.append(skwargs)
-    databuffers.extend(bufs)
-    msg.extend(databuffers)
-    return msg
-
-def unpack_apply_message(bufs, g=None, copy=True):
-    """unpack f,args,kwargs from buffers packed by pack_apply_message()
-    Returns: original f,args,kwargs"""
-    bufs = list(bufs) # allow us to pop
-    assert len(bufs) >= 3, "not enough buffers!"
-    if not copy:
-        for i in range(3):
-            bufs[i] = bufs[i].bytes
-    cf = pickle.loads(bufs.pop(0))
-    sargs = list(pickle.loads(bufs.pop(0)))
-    skwargs = dict(pickle.loads(bufs.pop(0)))
-    # print sargs, skwargs
-    f = uncan(cf, g)
-    for sa in sargs:
-        if sa.data is None:
-            m = bufs.pop(0)
-            if sa.getTypeDescriptor() in ('buffer', 'ndarray'):
-                if copy:
-                    sa.data = buffer(m)
-                else:
-                    sa.data = m.buffer
-            else:
-                if copy:
-                    sa.data = m
-                else:
-                    sa.data = m.bytes
-    
-    args = uncanSequence(map(unserialize, sargs), g)
-    kwargs = {}
-    for k in sorted(skwargs.iterkeys()):
-        sa = skwargs[k]
-        if sa.data is None:
-            m = bufs.pop(0)
-            if sa.getTypeDescriptor() in ('buffer', 'ndarray'):
-                if copy:
-                    sa.data = buffer(m)
-                else:
-                    sa.data = m.buffer
-            else:
-                if copy:
-                    sa.data = m
-                else:
-                    sa.data = m.bytes
-
-        kwargs[k] = uncan(unserialize(sa), g)
-    
-    return f,args,kwargs
-
-#--------------------------------------------------------------------------
-# helpers for implementing old MEC API via view.apply
-#--------------------------------------------------------------------------
-
-def interactive(f):
-    """decorator for making functions appear as interactively defined.
-    This results in the function being linked to the user_ns as globals()
-    instead of the module globals().
-    """
-    f.__module__ = '__main__'
-    return f
-
-@interactive
-def _push(ns):
-    """helper method for implementing `client.push` via `client.apply`"""
-    globals().update(ns)
-
-@interactive
-def _pull(keys):
-    """helper method for implementing `client.pull` via `client.apply`"""
-    user_ns = globals()
-    if isinstance(keys, (list,tuple, set)):
-        for key in keys:
-            if not user_ns.has_key(key):
-                raise NameError("name '%s' is not defined"%key)
-        return map(user_ns.get, keys)
-    else:
-        if not user_ns.has_key(keys):
-            raise NameError("name '%s' is not defined"%keys)
-        return user_ns.get(keys)
-
-@interactive
-def _execute(code):
-    """helper method for implementing `client.execute` via `client.apply`"""
-    exec code in globals()
-
-#--------------------------------------------------------------------------
-# extra process management utilities
-#--------------------------------------------------------------------------
-
-_random_ports = set()
-
-def select_random_ports(n):
-    """Selects and return n random ports that are available."""
-    ports = []
-    for i in xrange(n):
-        sock = socket.socket()
-        sock.bind(('', 0))
-        while sock.getsockname()[1] in _random_ports:
-            sock.close()
-            sock = socket.socket()
-            sock.bind(('', 0))
-        ports.append(sock)
-    for i, sock in enumerate(ports):
-        port = sock.getsockname()[1]
-        sock.close()
-        ports[i] = port
-        _random_ports.add(port)
-    return ports
-
-def signal_children(children):
-    """Relay interupt/term signals to children, for more solid process cleanup."""
-    def terminate_children(sig, frame):
-        logging.critical("Got signal %i, terminating children..."%sig)
-        for child in children:
-            child.terminate()
-        
-        sys.exit(sig != SIGINT)
-        # sys.exit(sig)
-    for sig in (SIGINT, SIGABRT, SIGTERM):
-        signal(sig, terminate_children)
-
-def generate_exec_key(keyfile):
-    import uuid
-    newkey = str(uuid.uuid4())
-    with open(keyfile, 'w') as f:
-        # f.write('ipython-key ')
-        f.write(newkey+'\n')
-    # set user-only RW permissions (0600)
-    # this will have no effect on Windows
-    os.chmod(keyfile, stat.S_IRUSR|stat.S_IWUSR)
-
-
-def integer_loglevel(loglevel):
-    try:
-        loglevel = int(loglevel)
-    except ValueError:
-        if isinstance(loglevel, str):
-            loglevel = getattr(logging, loglevel)
-    return loglevel
-
-def connect_logger(logname, context, iface, root="ip", loglevel=logging.DEBUG):
-    logger = logging.getLogger(logname)
-    if any([isinstance(h, handlers.PUBHandler) for h in logger.handlers]):
-        # don't add a second PUBHandler
-        return
-    loglevel = integer_loglevel(loglevel)
-    lsock = context.socket(zmq.PUB)
-    lsock.connect(iface)
-    handler = handlers.PUBHandler(lsock)
-    handler.setLevel(loglevel)
-    handler.root_topic = root
-    logger.addHandler(handler)
-    logger.setLevel(loglevel)
-
-def connect_engine_logger(context, iface, engine, loglevel=logging.DEBUG):
-    logger = logging.getLogger()
-    if any([isinstance(h, handlers.PUBHandler) for h in logger.handlers]):
-        # don't add a second PUBHandler
-        return
-    loglevel = integer_loglevel(loglevel)
-    lsock = context.socket(zmq.PUB)
-    lsock.connect(iface)
-    handler = EnginePUBHandler(engine, lsock)
-    handler.setLevel(loglevel)
-    logger.addHandler(handler)
-    logger.setLevel(loglevel)
-
-def local_logger(logname, loglevel=logging.DEBUG):
-    loglevel = integer_loglevel(loglevel)
-    logger = logging.getLogger(logname)
-    if any([isinstance(h, logging.StreamHandler) for h in logger.handlers]):
-        # don't add a second StreamHandler
-        return
-    handler = logging.StreamHandler()
-    handler.setLevel(loglevel)
-    logger.addHandler(handler)
-    logger.setLevel(loglevel)
-
diff --git a/IPython/paths.py b/IPython/paths.py
new file mode 100644
index 00000000000..1afb31e5cd4
--- /dev/null
+++ b/IPython/paths.py
@@ -0,0 +1,122 @@
+"""Find files and directories which IPython uses.
+"""
+import os.path
+import tempfile
+from warnings import warn
+
+import IPython
+from IPython.utils.importstring import import_item
+from IPython.utils.path import (
+    get_home_dir,
+    get_xdg_dir,
+    get_xdg_cache_dir,
+    compress_user,
+    _writable_dir,
+    ensure_dir_exists,
+)
+
+
+def get_ipython_dir() -> str:
+    """Get the IPython directory for this platform and user.
+
+    This uses the logic in `get_home_dir` to find the home directory
+    and then adds .ipython to the end of the path.
+    """
+
+    env = os.environ
+    pjoin = os.path.join
+
+
+    ipdir_def = '.ipython'
+
+    home_dir = get_home_dir()
+    xdg_dir = get_xdg_dir()
+
+    ipdir = env.get("IPYTHONDIR", None)
+    if ipdir is None:
+        # not set explicitly, use ~/.ipython
+        ipdir = pjoin(home_dir, ipdir_def)
+        if xdg_dir:
+            # Several IPython versions (up to 1.x) defaulted to .config/ipython
+            # on Linux. We have decided to go back to using .ipython everywhere
+            xdg_ipdir = pjoin(xdg_dir, 'ipython')
+
+            if _writable_dir(xdg_ipdir):
+                cu = compress_user
+                if os.path.exists(ipdir):
+                    warn(('Ignoring {0} in favour of {1}. Remove {0} to '
+                        'get rid of this message').format(cu(xdg_ipdir), cu(ipdir)))
+                elif os.path.islink(xdg_ipdir):
+                    warn(('{0} is deprecated. Move link to {1} to '
+                        'get rid of this message').format(cu(xdg_ipdir), cu(ipdir)))
+                else:
+                    ipdir = xdg_ipdir
+
+    ipdir = os.path.normpath(os.path.expanduser(ipdir))
+
+    if os.path.exists(ipdir) and not _writable_dir(ipdir):
+        # ipdir exists, but is not writable
+        warn("IPython dir '{0}' is not a writable location,"
+                " using a temp directory.".format(ipdir))
+        ipdir = tempfile.mkdtemp()
+    elif not os.path.exists(ipdir):
+        parent = os.path.dirname(ipdir)
+        if not _writable_dir(parent):
+            # ipdir does not exist and parent isn't writable
+            warn("IPython parent '{0}' is not a writable location,"
+                    " using a temp directory.".format(parent))
+            ipdir = tempfile.mkdtemp()
+        else:
+            os.makedirs(ipdir, exist_ok=True)
+    assert isinstance(ipdir, str), "all path manipulation should be str(unicode), but are not."
+    return ipdir
+
+
+def get_ipython_cache_dir() -> str:
+    """Get the cache directory it is created if it does not exist."""
+    xdgdir = get_xdg_cache_dir()
+    if xdgdir is None:
+        return get_ipython_dir()
+    ipdir = os.path.join(xdgdir, "ipython")
+    if not os.path.exists(ipdir) and _writable_dir(xdgdir):
+        ensure_dir_exists(ipdir)
+    elif not _writable_dir(xdgdir):
+        return get_ipython_dir()
+
+    return ipdir
+
+
+def get_ipython_package_dir() -> str:
+    """Get the base directory where IPython itself is installed."""
+    ipdir = os.path.dirname(IPython.__file__)
+    assert isinstance(ipdir, str)
+    return ipdir
+
+
+def get_ipython_module_path(module_str):
+    """Find the path to an IPython module in this version of IPython.
+
+    This will always find the version of the module that is in this importable
+    IPython package. This will always return the path to the ``.py``
+    version of the module.
+    """
+    if module_str == 'IPython':
+        return os.path.join(get_ipython_package_dir(), '__init__.py')
+    mod = import_item(module_str)
+    the_path = mod.__file__.replace('.pyc', '.py')
+    the_path = the_path.replace('.pyo', '.py')
+    return the_path
+
+
+def locate_profile(profile='default'):
+    """Find the path to the folder associated with a given profile.
+
+    I.e. find $IPYTHONDIR/profile_whatever.
+    """
+    from IPython.core.profiledir import ProfileDir, ProfileDirError
+    try:
+        pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
+    except ProfileDirError as e:
+        # IOError makes more sense when people are expecting a path
+        raise IOError("Couldn't find profile %r" % profile) from e
+    return pd.location
diff --git a/IPython/config/profile/__init__.py b/IPython/py.typed
similarity index 100%
rename from IPython/config/profile/__init__.py
rename to IPython/py.typed
diff --git a/IPython/quarantine/InterpreterExec.py b/IPython/quarantine/InterpreterExec.py
deleted file mode 100644
index 9faba796d43..00000000000
--- a/IPython/quarantine/InterpreterExec.py
+++ /dev/null
@@ -1,253 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Modified input prompt for executing files.
-
-We define a special input line filter to allow typing lines which begin with
-'~', '/' or '.'. If one of those strings is encountered, it is automatically
-executed.
-"""
-
-#*****************************************************************************
-#       Copyright (C) 2004 W.J. van der Laan <gnufnork@hetdigitalegat.nl>
-#       Copyright (C) 2004-2006 Fernando Perez <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-
-def prefilter_shell(self,line,continuation):
-    """Alternate prefilter, modified for shell-like functionality.
-
-    - Execute all lines beginning with '~', '/' or '.'
-    - $var=cmd <=> %sc var=cmd
-    - $$var=cmd <=> %sc -l var=cmd
-    """
-
-    if line:
-        l0 = line[0]
-        if l0 in '~/.':
-            return self._prefilter("!%s"%line,continuation)
-        elif l0=='$':
-            lrest = line[1:]
-            if lrest.startswith('$'):
-                # $$var=cmd <=> %sc -l var=cmd
-                return self._prefilter("%ssc -l %s" % (self.ESC_MAGIC,lrest[1:]),
-                                       continuation)
-            else:
-                # $var=cmd <=> %sc var=cmd
-                return self._prefilter("%ssc %s" % (self.ESC_MAGIC,lrest),
-                                       continuation)
-        else:
-            return self._prefilter(line,continuation)
-    else:
-        return self._prefilter(line,continuation)
-
-# Rebind this to be the new IPython prefilter:
-from IPython.core.iplib import InteractiveShell
-InteractiveShell.prefilter = prefilter_shell
-# Clean up the namespace.
-del InteractiveShell,prefilter_shell
-
-# Provide pysh and further shell-oriented services
-import os,sys,shutil
-from IPython.utils.process import system,shell,getoutput,getoutputerror
-
-# Short aliases for getting shell output as a string and a list
-sout = getoutput
-lout = lambda cmd: getoutput(cmd,split=1)
-
-# Empty function, meant as a docstring holder so help(pysh) works.
-def pysh():
-    """Pysh is a set of modules and extensions to IPython which make shell-like
-    usage with Python syntax more convenient.  Keep in mind that pysh is NOT a
-    full-blown shell, so don't try to make it your /etc/passwd entry!
-    
-    In particular, it has no job control, so if you type Ctrl-Z (under Unix),
-    you'll suspend pysh itself, not the process you just started.
-
-    Since pysh is really nothing but a customized IPython, you should
-    familiarize yourself with IPython's features.  This brief help mainly
-    documents areas in which pysh differs from the normal IPython.
-
-    ALIASES
-    -------
-    All of your $PATH has been loaded as IPython aliases, so you should be
-    able to type any normal system command and have it executed.  See %alias? 
-    and %unalias? for details on the alias facilities.
-
-    SPECIAL SYNTAX
-    --------------
-    Any lines which begin with '~', '/' and '.' will be executed as shell
-    commands instead of as Python code. The special escapes below are also
-    recognized.  !cmd is valid in single or multi-line input, all others are
-    only valid in single-line input:
-
-    !cmd      - pass 'cmd' directly to the shell
-    !!cmd     - execute 'cmd' and return output as a list (split on '\\n')
-    $var=cmd  - capture output of cmd into var, as a string
-    $$var=cmd - capture output of cmd into var, as a list (split on '\\n')
-
-    The $/$$ syntaxes make Python variables from system output, which you can
-    later use for further scripting.  The converse is also possible: when
-    executing an alias or calling to the system via !/!!, you can expand any
-    python variable or expression by prepending it with $.  Full details of
-    the allowed syntax can be found in Python's PEP 215.
-
-    A few brief examples will illustrate these:
-
-        fperez[~/test]|3> !ls *s.py
-        scopes.py  strings.py
-
-    ls is an internal alias, so there's no need to use !:
-        fperez[~/test]|4> ls *s.py
-        scopes.py*  strings.py
-
-    !!ls will return the output into a Python variable:
-        fperez[~/test]|5> !!ls *s.py
-                      <5> ['scopes.py', 'strings.py']
-        fperez[~/test]|6> print _5
-        ['scopes.py', 'strings.py']
-
-    $ and $$ allow direct capture to named variables:
-        fperez[~/test]|7> $astr = ls *s.py
-        fperez[~/test]|8> astr
-                      <8> 'scopes.py\\nstrings.py'
-
-        fperez[~/test]|9> $$alist = ls *s.py
-        fperez[~/test]|10> alist
-                      <10> ['scopes.py', 'strings.py']
-
-    alist is now a normal python list you can loop over.  Using $ will expand
-    back the python values when alias calls are made:
-        fperez[~/test]|11> for f in alist:
-                      |..>     print 'file',f,
-                      |..>     wc -l $f
-                      |..>
-        file scopes.py     13 scopes.py
-        file strings.py      4 strings.py
-
-    Note that you may need to protect your variables with braces if you want
-    to append strings to their names.  To copy all files in alist to .bak
-    extensions, you must use:
-        fperez[~/test]|12> for f in alist:
-                      |..>     cp $f ${f}.bak
-
-    If you try using $f.bak, you'll get an AttributeError exception saying
-    that your string object doesn't have a .bak attribute.  This is because
-    the $ expansion mechanism allows you to expand full Python expressions:
-        fperez[~/test]|13> echo "sys.platform is: $sys.platform"
-        sys.platform is: linux2
-
-    IPython's input history handling is still active, which allows you to
-    rerun a single block of multi-line input by simply using exec:    
-        fperez[~/test]|14> $$alist = ls *.eps
-        fperez[~/test]|15> exec _i11
-        file image2.eps    921 image2.eps
-        file image.eps    921 image.eps
-
-    While these are new special-case syntaxes, they are designed to allow very
-    efficient use of the shell with minimal typing.  At an interactive shell
-    prompt, conciseness of expression wins over readability.
-
-    USEFUL FUNCTIONS AND MODULES
-    ----------------------------
-    The os, sys and shutil modules from the Python standard library are
-    automatically loaded.  Some additional functions, useful for shell usage,
-    are listed below.  You can request more help about them with '?'.
-
-    shell   - execute a command in the underlying system shell    
-    system  - like shell(), but return the exit status of the command
-    sout    - capture the output of a command as a string
-    lout    - capture the output of a command as a list (split on '\\n')
-    getoutputerror - capture (output,error) of a shell command
-
-    sout/lout are the functional equivalents of $/$$.  They are provided to
-    allow you to capture system output in the middle of true python code,
-    function definitions, etc (where $ and $$ are invalid).
-
-    DIRECTORY MANAGEMENT
-    --------------------
-    Since each command passed by pysh to the underlying system is executed in
-    a subshell which exits immediately, you can NOT use !cd to navigate the
-    filesystem.
-
-    Pysh provides its own builtin '%cd' magic command to move in the
-    filesystem (the % is not required with automagic on).  It also maintains a
-    list of visited directories (use %dhist to see it) and allows direct
-    switching to any of them.  Type 'cd?' for more details.
-
-    %pushd, %popd and %dirs are provided for directory stack handling.
-
-    PROMPT CUSTOMIZATION
-    --------------------
-    
-    The supplied ipythonrc-pysh profile comes with an example of a very
-    colored and detailed prompt, mainly to serve as an illustration.  The
-    valid escape sequences, besides color names, are:
-
-        \\#  - Prompt number.
-        \\D  - Dots, as many as there are digits in \\# (so they align).
-        \\w  - Current working directory (cwd).
-        \\W  - Basename of current working directory.
-        \\XN - Where N=0..5. N terms of the cwd, with $HOME written as ~.
-        \\YN - Where N=0..5. Like XN, but if ~ is term N+1 it's also shown.
-        \\u  - Username.
-        \\H  - Full hostname.
-        \\h  - Hostname up to first '.'
-        \\$  - Root symbol ($ or #).
-        \\t  - Current time, in H:M:S format.
-        \\v  - IPython release version.
-        \\n  - Newline.
-        \\r  - Carriage return.
-        \\\\ - An explicitly escaped '\\'.
-
-    You can configure your prompt colors using any ANSI color escape.  Each
-    color escape sets the color for any subsequent text, until another escape
-    comes in and changes things.  The valid color escapes are:
-
-        \\C_Black
-        \\C_Blue
-        \\C_Brown
-        \\C_Cyan
-        \\C_DarkGray
-        \\C_Green
-        \\C_LightBlue
-        \\C_LightCyan
-        \\C_LightGray
-        \\C_LightGreen
-        \\C_LightPurple
-        \\C_LightRed
-        \\C_Purple
-        \\C_Red
-        \\C_White
-        \\C_Yellow
-        \\C_Normal - Stop coloring, defaults to your terminal settings.
-    """
-    pass
-
-# Configure a few things.  Much of this is fairly hackish, since IPython
-# doesn't really expose a clean API for it.  Be careful if you start making
-# many modifications here.
-
-
-#  Set the 'cd' command to quiet mode, a more shell-like behavior
-__IPYTHON__.default_option('cd','-q')
-
-# This is redundant, ipy_user_conf.py will determine this
-# Load all of $PATH as aliases
-__IPYTHON__.magic_rehashx()
-
-# Remove %sc,%sx if present as aliases
-__IPYTHON__.magic_unalias('sc')
-__IPYTHON__.magic_unalias('sx')
-
-# We need different criteria for line-splitting, so that aliases such as
-# 'gnome-terminal' are interpreted as a single alias instead of variable
-# 'gnome' minus variable 'terminal'.
-import re
-__IPYTHON__.line_split = re.compile(r'^([\s*,;/])'
-                                    r'([\?\w\.\-\+]+\w*\s*)'
-                                    r'(\(?.*$)')
-
-# Namespace cleanup
-del re
diff --git a/IPython/quarantine/__init__.py b/IPython/quarantine/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/quarantine/clearcmd.py b/IPython/quarantine/clearcmd.py
deleted file mode 100644
index aa838352c76..00000000000
--- a/IPython/quarantine/clearcmd.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-""" IPython extension: add %clear magic """
-
-from IPython.core import ipapi
-import gc
-ip = ipapi.get()
-
-def clear_f(self,arg):
-    """ Clear various data (e.g. stored history data)
-    
-    %clear in  - clear input history
-    %clear out - clear output history
-    %clear shadow_compress - Compresses shadow history (to speed up ipython)
-    %clear shadow_nuke - permanently erase all entries in shadow history
-    %clear dhist - clear dir history
-    %clear array - clear only variables that are NumPy arrays
-    
-    Examples:
-
-    In [1]: clear in
-    Flushing input history
-
-    In [2]: clear shadow_compress
-    Compressing shadow history
-
-    In [3]: clear shadow_nuke
-    Erased all keys from shadow history
-
-    In [4]: clear dhist
-    Clearing directory history
-    """
-    
-    api = self.getapi()
-    user_ns = self.user_ns  # local lookup, heavily used
-        
-    
-    for target in arg.split():
-
-        if target == 'out':
-            print "Flushing output cache (%d entries)" % len(user_ns['_oh'])
-            self.outputcache.flush()
-
-        elif target == 'in':
-            print "Flushing input history"
-            pc = self.outputcache.prompt_count + 1
-            for n in range(1, pc):
-                key = '_i'+`n`
-                user_ns.pop(key,None)
-                try:
-                    del user_ns[key]
-                except: pass
-            # must be done in-place
-            self.history_manager.input_hist_parsed[:] = ['\n'] * pc 
-            self.history_manager.input_hist_raw[:] = ['\n'] * pc
-
-        elif target == 'array':
-            # Support cleaning up numpy arrays
-            try:
-                from numpy import ndarray
-                # This must be done with items and not iteritems because we're
-                # going to modify the dict in-place.
-                for x,val in user_ns.items():
-                    if isinstance(val,ndarray):
-                        del user_ns[x]
-            except AttributeError:
-                print "Clear array only works if Numpy is available."
-
-        elif target == 'shadow_compress':
-            print "Compressing shadow history"
-            api.db.hcompress('shadowhist')
-            
-        elif target == 'shadow_nuke':
-            print "Erased all keys from shadow history "
-            for k in ip.db.keys('shadowhist/*'):
-                del ip.db[k]
-
-        elif target == 'dhist':
-            print "Clearing directory history"
-            del user_ns['_dh'][:]
-
-    gc.collect()        
-
-# Activate the extension
-ip.define_magic("clear",clear_f)
-import ipy_completers
-ipy_completers.quick_completer(
-    '%clear','in out shadow_nuke shadow_compress dhist')
diff --git a/IPython/quarantine/envpersist.py b/IPython/quarantine/envpersist.py
deleted file mode 100644
index 2144c782834..00000000000
--- a/IPython/quarantine/envpersist.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# -*- coding: utf-8 -*-
-""" %env magic command for storing environment variables persistently
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-
-ip = ipapi.get()
-
-import os,sys
-
-def restore_env(self):    
-    ip = self.getapi()
-    env = ip.db.get('stored_env', {'set' : {}, 'add' : [], 'pre' : []})
-    for k,v in env['set'].items():
-        os.environ[k] = v
-    for k,v in env['add']:
-        os.environ[k] = os.environ.get(k,"") + v
-    for k,v in env['pre']:
-        os.environ[k] = v + os.environ.get(k,"")
-    raise TryNext
-  
-ip.set_hook('late_startup_hook', restore_env)
-
-def persist_env(self, parameter_s=''):
-    """ Store environment variables persistently
-    
-    IPython remembers the values across sessions, which is handy to avoid 
-    editing startup files.
-    
-    %env - Show all environment variables
-    %env VISUAL=jed  - set VISUAL to jed
-    %env PATH+=;/foo - append ;foo to PATH
-    %env PATH+=;/bar - also append ;bar to PATH
-    %env PATH-=/wbin; - prepend /wbin; to PATH
-    %env -d VISUAL   - forget VISUAL persistent val
-    %env -p          - print all persistent env modifications 
-    """
-    
-    if not parameter_s.strip():
-        return os.environ.data
-    
-    ip = self.getapi()
-    db = ip.db
-    env = ip.db.get('stored_env', {'set' : {}, 'add' : [], 'pre' : []})
-
-    if parameter_s.startswith('-p'):
-        return env
-        
-    elif parameter_s.startswith('-d'):
-        parts = (parameter_s.split()[1], '<del>')
-        
-    else:
-        parts = parameter_s.strip().split('=')    
-    
-    if len(parts) == 2:
-        k,v = [p.strip() for p in parts]
-    
-    if v == '<del>':
-        if k in env['set']:
-            del env['set'][k]
-        env['add'] = [el for el in env['add'] if el[0] != k]
-        env['pre'] = [el for el in env['pre'] if el[0] != k]
-        
-        print "Forgot '%s' (for next session)" % k
-        
-    elif k.endswith('+'):
-        k = k[:-1]
-        env['add'].append((k,v))
-        os.environ[k] += v
-        print k,"after append =",os.environ[k]
-    elif k.endswith('-'):
-        k = k[:-1]
-        env['pre'].append((k,v))
-        os.environ[k] = v + os.environ.get(k,"")
-        print k,"after prepend =",os.environ[k]
-        
-        
-    else:
-        env['set'][k] = v
-        print "Setting",k,"to",v
-        os.environ[k] = v
-        
-    db['stored_env'] = env
-
-def env_completer(self,event):
-    """ Custom completer that lists all env vars """
-    return os.environ.keys()
-
-ip.define_magic('env', persist_env)
-ip.set_hook('complete_command',env_completer, str_key = '%env')
-
diff --git a/IPython/quarantine/ext_rescapture.py b/IPython/quarantine/ext_rescapture.py
deleted file mode 100644
index eb0c3910a6e..00000000000
--- a/IPython/quarantine/ext_rescapture.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# -*- coding: utf-8 -*-
-""" IPython extension: new prefilters for output grabbing 
-
-Provides 
-
-var = %magic blah blah
-
-var = !ls
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-from IPython.utils.text import make_quoted_expr
-from IPython.utils.genutils import *
-
-ip = ipapi.get()
-
-import re
-
-def hnd_magic(line,mo):
-    """ Handle a = %mymagic blah blah """
-    var = mo.group('varname')
-    cmd = mo.group('cmd')
-    expr = make_quoted_expr(cmd)
-    return itpl('$var = get_ipython().magic($expr)')
-
-def hnd_syscmd(line,mo):
-    """ Handle a = !ls """
-    var = mo.group('varname')
-    cmd = mo.group('cmd')
-    expr = make_quoted_expr(itpl("sc -l =$cmd"))
-    return itpl('$var = get_ipython().magic($expr)')
-
-def install_re_handler(pat, hnd):
-    ip.meta.re_prefilters.append((re.compile(pat), hnd))
-
-def init_handlers():
-
-    ip.meta.re_prefilters = []
-
-    install_re_handler('(?P<varname>[\w\.]+)\s*=\s*%(?P<cmd>.*)',
-                       hnd_magic
-                       )
-    
-    install_re_handler('(?P<varname>[\w\.]+)\s*=\s*!(?P<cmd>.*)',
-                       hnd_syscmd
-                       )
-
-init_handlers()
-
-def regex_prefilter_f(self,line):
-    for pat, handler in ip.meta.re_prefilters:
-        mo = pat.match(line)
-        if mo:
-            return handler(line,mo)
-    
-    raise TryNext
-
-ip.set_hook('input_prefilter', regex_prefilter_f)     
diff --git a/IPython/quarantine/ipy_app_completers.py b/IPython/quarantine/ipy_app_completers.py
deleted file mode 100644
index 3a89b5442e7..00000000000
--- a/IPython/quarantine/ipy_app_completers.py
+++ /dev/null
@@ -1,19 +0,0 @@
-""" Install various IPython completers
-
-IPython extension that installs the completers related to external apps.
-
-The actual implementations are in extensions/ipy_completers.py
-
-"""
-from IPython.core import ipapi
-
-ip = ipapi.get()
-
-from ipy_completers import *
-
-ip.set_hook('complete_command', apt_completer, re_key = '.*apt-get')
-ip.set_hook('complete_command', svn_completer, str_key = 'svn')
-ip.set_hook('complete_command', hg_completer, str_key = 'hg')
-
-# the old bzr completer is deprecated, we recommend ipy_bzr
-#ip.set_hook('complete_command', bzr_completer, str_key = 'bzr')
diff --git a/IPython/quarantine/ipy_autoreload.py b/IPython/quarantine/ipy_autoreload.py
deleted file mode 100644
index 397655192b2..00000000000
--- a/IPython/quarantine/ipy_autoreload.py
+++ /dev/null
@@ -1,350 +0,0 @@
-"""
-IPython extension: autoreload modules before executing the next line
-
-Try::
-
-    %autoreload?
-
-for documentation.
-"""
-
-# Pauli Virtanen <pav@iki.fi>, 2008.
-# Thomas Heller, 2000.
-#
-# This IPython module is written by Pauli Virtanen, based on the autoreload
-# code by Thomas Heller.
-
-#------------------------------------------------------------------------------
-# Autoreload functionality
-#------------------------------------------------------------------------------
-
-import time, os, threading, sys, types, imp, inspect, traceback, atexit
-import weakref
-
-def _get_compiled_ext():
-    """Official way to get the extension of compiled files (.pyc or .pyo)"""
-    for ext, mode, typ in imp.get_suffixes():
-        if typ == imp.PY_COMPILED:
-            return ext
-
-PY_COMPILED_EXT = _get_compiled_ext()
-
-class ModuleReloader(object):
-    failed = {}
-    """Modules that failed to reload: {module: mtime-on-failed-reload, ...}"""
-
-    modules = {}
-    """Modules specially marked as autoreloadable."""
-
-    skip_modules = {}
-    """Modules specially marked as not autoreloadable."""
-
-    check_all = True
-    """Autoreload all modules, not just those listed in 'modules'"""
-
-    old_objects = {}
-    """(module-name, name) -> weakref, for replacing old code objects"""
-
-    def check(self, check_all=False):
-        """Check whether some modules need to be reloaded."""
-
-        if check_all or self.check_all:
-            modules = sys.modules.keys()
-        else:
-            modules = self.modules.keys()
-
-        for modname in modules:
-            m = sys.modules.get(modname, None)
-
-            if modname in self.skip_modules:
-                continue
-
-            if not hasattr(m, '__file__'):
-                continue
-
-            if m.__name__ == '__main__':
-                # we cannot reload(__main__)
-                continue
-
-            filename = m.__file__
-            dirname = os.path.dirname(filename)
-            path, ext = os.path.splitext(filename)
-
-            if ext.lower() == '.py':
-                ext = PY_COMPILED_EXT
-                filename = os.path.join(dirname, path + PY_COMPILED_EXT)
-
-            if ext != PY_COMPILED_EXT:
-                continue
-
-            try:
-                pymtime = os.stat(filename[:-1]).st_mtime
-                if pymtime <= os.stat(filename).st_mtime:
-                    continue
-                if self.failed.get(filename[:-1], None) == pymtime:
-                    continue
-            except OSError:
-                continue
-
-            try:
-                superreload(m, reload, self.old_objects)
-                if filename[:-1] in self.failed:
-                    del self.failed[filename[:-1]]
-            except:
-                print >> sys.stderr, "[autoreload of %s failed: %s]" % (
-                        modname, traceback.format_exc(1))
-                self.failed[filename[:-1]] = pymtime
-
-#------------------------------------------------------------------------------
-# superreload
-#------------------------------------------------------------------------------
-
-def update_function(old, new):
-    """Upgrade the code object of a function"""
-    for name in ['func_code', 'func_defaults', 'func_doc',
-                 'func_closure', 'func_globals', 'func_dict']:
-        try:
-            setattr(old, name, getattr(new, name))
-        except (AttributeError, TypeError):
-            pass
-
-def update_class(old, new):
-    """Replace stuff in the __dict__ of a class, and upgrade
-    method code objects"""
-    for key in old.__dict__.keys():
-        old_obj = getattr(old, key)
-
-        try:
-            new_obj = getattr(new, key)
-        except AttributeError:
-            # obsolete attribute: remove it
-            try:
-                delattr(old, key)
-            except (AttributeError, TypeError):
-                pass
-            continue
-
-        if update_generic(old_obj, new_obj): continue
-
-        try:
-            setattr(old, key, getattr(new, key))
-        except (AttributeError, TypeError):
-            pass # skip non-writable attributes
-
-def update_property(old, new):
-    """Replace get/set/del functions of a property"""
-    update_generic(old.fdel, new.fdel)
-    update_generic(old.fget, new.fget)
-    update_generic(old.fset, new.fset)
-
-def isinstance2(a, b, typ):
-    return isinstance(a, typ) and isinstance(b, typ)
-
-UPDATE_RULES = [
-    (lambda a, b: isinstance2(a, b, types.ClassType),
-     update_class),
-    (lambda a, b: isinstance2(a, b, types.TypeType),
-     update_class),
-    (lambda a, b: isinstance2(a, b, types.FunctionType),
-     update_function),
-    (lambda a, b: isinstance2(a, b, property),
-     update_property),
-    (lambda a, b: isinstance2(a, b, types.MethodType),
-     lambda a, b: update_function(a.im_func, b.im_func)),
-]
-
-def update_generic(a, b):
-    for type_check, update in UPDATE_RULES:
-        if type_check(a, b):
-            update(a, b)
-            return True
-    return False
-
-class StrongRef(object):
-    def __init__(self, obj):
-        self.obj = obj
-    def __call__(self):
-        return self.obj
-
-def superreload(module, reload=reload, old_objects={}):
-    """Enhanced version of the builtin reload function.
-
-    superreload remembers objects previously in the module, and
-
-    - upgrades the class dictionary of every old class in the module
-    - upgrades the code object of every old function and method
-    - clears the module's namespace before reloading
-
-    """
-
-    # collect old objects in the module
-    for name, obj in module.__dict__.items():
-        if not hasattr(obj, '__module__') or obj.__module__ != module.__name__:
-            continue
-        key = (module.__name__, name)
-        try:
-            old_objects.setdefault(key, []).append(weakref.ref(obj))
-        except TypeError:
-            # weakref doesn't work for all types;
-            # create strong references for 'important' cases
-            if isinstance(obj, types.ClassType):
-                old_objects.setdefault(key, []).append(StrongRef(obj))
-
-    # reload module
-    try:
-        # clear namespace first from old cruft
-        old_name = module.__name__
-        module.__dict__.clear()
-        module.__dict__['__name__'] = old_name
-    except (TypeError, AttributeError, KeyError):
-        pass
-    module = reload(module)
-
-    # iterate over all objects and update functions & classes
-    for name, new_obj in module.__dict__.items():
-        key = (module.__name__, name)
-        if key not in old_objects: continue
-
-        new_refs = []
-        for old_ref in old_objects[key]:
-            old_obj = old_ref()
-            if old_obj is None: continue
-            new_refs.append(old_ref)
-            update_generic(old_obj, new_obj)
-
-        if new_refs:
-            old_objects[key] = new_refs
-        else:
-            del old_objects[key]
-
-    return module
-
-reloader = ModuleReloader()
-
-#------------------------------------------------------------------------------
-# IPython connectivity
-#------------------------------------------------------------------------------
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-
-ip = ipapi.get()
-
-autoreload_enabled = False
-
-def runcode_hook(self):
-    if not autoreload_enabled:
-        raise TryNext
-    try:
-        reloader.check()
-    except:
-        pass
-
-def enable_autoreload():
-    global autoreload_enabled
-    autoreload_enabled = True
-
-def disable_autoreload():
-    global autoreload_enabled
-    autoreload_enabled = False
-
-def autoreload_f(self, parameter_s=''):
-    r""" %autoreload => Reload modules automatically
-
-    %autoreload
-    Reload all modules (except those excluded by %aimport) automatically now.
-
-    %autoreload 0
-    Disable automatic reloading.
-
-    %autoreload 1
-    Reload all modules imported with %aimport every time before executing
-    the Python code typed.
-
-    %autoreload 2
-    Reload all modules (except those excluded by %aimport) every time
-    before executing the Python code typed.
-
-    Reloading Python modules in a reliable way is in general
-    difficult, and unexpected things may occur. %autoreload tries to
-    work around common pitfalls by replacing function code objects and
-    parts of classes previously in the module with new versions. This
-    makes the following things to work:
-
-    - Functions and classes imported via 'from xxx import foo' are upgraded
-      to new versions when 'xxx' is reloaded.
-
-    - Methods and properties of classes are upgraded on reload, so that
-      calling 'c.foo()' on an object 'c' created before the reload causes
-      the new code for 'foo' to be executed.
-
-    Some of the known remaining caveats are:
-
-    - Replacing code objects does not always succeed: changing a @property
-      in a class to an ordinary method or a method to a member variable
-      can cause problems (but in old objects only).
-
-    - Functions that are removed (eg. via monkey-patching) from a module
-      before it is reloaded are not upgraded.
-
-    - C extension modules cannot be reloaded, and so cannot be
-      autoreloaded.
-
-    """
-    if parameter_s == '':
-        reloader.check(True)
-    elif parameter_s == '0':
-        disable_autoreload()
-    elif parameter_s == '1':
-        reloader.check_all = False
-        enable_autoreload()
-    elif parameter_s == '2':
-        reloader.check_all = True
-        enable_autoreload()
-
-def aimport_f(self, parameter_s=''):
-    """%aimport => Import modules for automatic reloading.
-
-    %aimport
-    List modules to automatically import and not to import.
-
-    %aimport foo
-    Import module 'foo' and mark it to be autoreloaded for %autoreload 1
-
-    %aimport -foo
-    Mark module 'foo' to not be autoreloaded for %autoreload 1
-
-    """
-
-    modname = parameter_s
-    if not modname:
-        to_reload = reloader.modules.keys()
-        to_reload.sort()
-        to_skip = reloader.skip_modules.keys()
-        to_skip.sort()
-        if reloader.check_all:
-            print "Modules to reload:\nall-expect-skipped"
-        else:
-            print "Modules to reload:\n%s" % ' '.join(to_reload)
-        print "\nModules to skip:\n%s" % ' '.join(to_skip)
-    elif modname.startswith('-'):
-        modname = modname[1:]
-        try: del reloader.modules[modname]
-        except KeyError: pass
-        reloader.skip_modules[modname] = True
-    else:
-        try: del reloader.skip_modules[modname]
-        except KeyError: pass
-        reloader.modules[modname] = True
-
-        # Inject module to user namespace; handle also submodules properly
-        __import__(modname)
-        basename = modname.split('.')[0]
-        mod = sys.modules[basename]
-        ip.push({basename: mod})
-
-def init():
-    ip.define_magic('autoreload', autoreload_f)
-    ip.define_magic('aimport', aimport_f)
-    ip.set_hook('pre_runcode_hook', runcode_hook)
-
-init()
diff --git a/IPython/quarantine/ipy_completers.py b/IPython/quarantine/ipy_completers.py
deleted file mode 100644
index 2542568ff7f..00000000000
--- a/IPython/quarantine/ipy_completers.py
+++ /dev/null
@@ -1,138 +0,0 @@
-""" Implementations for various useful completers
-
-See extensions/ipy_stock_completers.py on examples of how to enable a completer,
-but the basic idea is to do:
-
-ip.set_hook('complete_command', svn_completer, str_key = 'svn')
-
-NOTE: some of the completers that used to be here, the ones used always by
-default (loaded before by ipy_stock_completers) have been moved into
-core.completerlib, where they will be further cleaned up and maintained.  The
-rest of this file would need to be well commented, cleaned up and tested for
-inclusion into the core.
-"""
-
-import glob,os,shlex,sys
-import inspect
-from time import time
-from zipimport import zipimporter
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-ip = ipapi.get()
-
-def vcs_completer(commands, event):
-    """ utility to make writing typical version control app completers easier
-
-    VCS command line apps typically have the format:
-
-    [sudo ]PROGNAME [help] [command] file file...
-
-    """
-
-
-    cmd_param = event.line.split()
-    if event.line.endswith(' '):
-        cmd_param.append('')
-
-    if cmd_param[0] == 'sudo':
-        cmd_param = cmd_param[1:]
-
-    if len(cmd_param) == 2 or 'help' in cmd_param:
-        return commands.split()
-
-    return ip.Completer.file_matches(event.symbol)
-
-
-svn_commands = """\
-add blame praise annotate ann cat checkout co cleanup commit ci copy
-cp delete del remove rm diff di export help ? h import info list ls
-lock log merge mkdir move mv rename ren propdel pdel pd propedit pedit
-pe propget pget pg proplist plist pl propset pset ps resolved revert
-status stat st switch sw unlock update
-"""
-
-def svn_completer(self,event):
-    return vcs_completer(svn_commands, event)
-
-
-hg_commands = """
-add addremove annotate archive backout branch branches bundle cat
-clone commit copy diff export grep heads help identify import incoming
-init locate log manifest merge outgoing parents paths pull push
-qapplied qclone qcommit qdelete qdiff qfold qguard qheader qimport
-qinit qnew qnext qpop qprev qpush qrefresh qrename qrestore qsave
-qselect qseries qtop qunapplied recover remove rename revert rollback
-root serve showconfig status strip tag tags tip unbundle update verify
-version
-"""
-
-def hg_completer(self,event):
-    """ Completer for mercurial commands """
-
-    return vcs_completer(hg_commands, event)
-
-
-
-__bzr_commands = None
-
-def bzr_commands():
-    global __bzr_commands
-    if __bzr_commands is not None:
-        return __bzr_commands
-    out = os.popen('bzr help commands')
-    __bzr_commands = [l.split()[0] for l in out]
-    return __bzr_commands                
-
-def bzr_completer(self,event):
-    """ Completer for bazaar commands """
-    cmd_param = event.line.split()
-    if event.line.endswith(' '):
-        cmd_param.append('')
-
-    if len(cmd_param) > 2:
-        cmd = cmd_param[1]
-        param = cmd_param[-1]
-        output_file = (param == '--output=')
-        if cmd == 'help':
-            return bzr_commands()
-        elif cmd in ['bundle-revisions','conflicts',
-                     'deleted','nick','register-branch',
-                     'serve','unbind','upgrade','version',
-                     'whoami'] and not output_file:
-            return []
-        else:
-            # the rest are probably file names
-            return ip.Completer.file_matches(event.symbol)
-
-    return bzr_commands()
-
-
-def apt_get_packages(prefix):
-    out = os.popen('apt-cache pkgnames')
-    for p in out:
-        if p.startswith(prefix):
-            yield p.rstrip()
-    
-    
-apt_commands = """\
-update upgrade install remove purge source build-dep dist-upgrade
-dselect-upgrade clean autoclean check"""
-
-def apt_completer(self, event):
-    """ Completer for apt-get (uses apt-cache internally)
-
-    """
-
-
-    cmd_param = event.line.split()
-    if event.line.endswith(' '):
-        cmd_param.append('')
-
-    if cmd_param[0] == 'sudo':
-        cmd_param = cmd_param[1:]
-
-    if len(cmd_param) == 2 or 'help' in cmd_param:
-        return apt_commands.split()
-
-    return list(apt_get_packages(event.symbol))
diff --git a/IPython/quarantine/ipy_editors.py b/IPython/quarantine/ipy_editors.py
deleted file mode 100644
index 5ff34a2831f..00000000000
--- a/IPython/quarantine/ipy_editors.py
+++ /dev/null
@@ -1,89 +0,0 @@
-""" 'editor' hooks for common editors that work well with ipython
-
-They should honor the line number argument, at least.
-
-Contributions are *very* welcome.
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-ip = ipapi.get()
-
-from IPython.external.Itpl import itplns
-import os
-
-def install_editor(run_template, wait = False):
-    """ Gets a template in format "myeditor bah bah $file bah bah $line"
-    
-    $file will be replaced by file name, $line by line number (or 0).
-    Installs the editor that is called by IPython, instead of the default
-    notepad or vi.
-    
-    If wait is true, wait until the user presses enter before returning,
-    to facilitate non-blocking editors that exit immediately after
-    the call.
-    """
-    
-    def call_editor(self, file, line=0):
-        if line is None:
-            line = 0
-        cmd = itplns(run_template, locals())
-        print ">",cmd
-        if os.system(cmd) != 0:
-            raise TryNext()
-        if wait:
-            raw_input("Press Enter when done editing:")
-
-    ip.set_hook('editor',call_editor)
-
-
-# in these, exe is always the path/name of the executable. Useful
-# if you don't have the editor directory in your path
-
-def komodo(exe = 'komodo'):
-    """ Activestate Komodo [Edit] """
-    install_editor(exe + ' -l $line "$file"', wait = True)
-
-def scite(exe = "scite"):
-    """ SciTE or Sc1 """
-    install_editor(exe + ' "$file" -goto:$line')
-
-def notepadplusplus(exe = 'notepad++'):
-    """ Notepad++ http://notepad-plus.sourceforge.net """
-    install_editor(exe + ' -n$line "$file"')
-    
-def jed(exe = 'jed'):
-    """ JED, the lightweight emacsish editor """
-    install_editor(exe + ' +$line "$file"')
-
-def idle(exe = None):
-    """ Idle, the editor bundled with python
-    
-    Should be pretty smart about finding the executable.
-    """
-    if exe is None:
-        import idlelib
-        p = os.path.dirname(idlelib.__file__)
-        exe = p + '/idle.py'
-    install_editor(exe + ' "$file"')
-
-def mate(exe = 'mate'):
-    """ TextMate, the missing editor"""
-    install_editor(exe + ' -w -l $line "$file"')
-
-# these are untested, report any problems
-
-def emacs(exe = 'emacs'):
-    install_editor(exe + ' +$line "$file"')
-
-def gnuclient(exe= 'gnuclient'):
-    install_editor(exe + ' -nw +$line "$file"')
-
-def crimson_editor(exe = 'cedt.exe'):
-    install_editor(exe + ' /L:$line "$file"')
-    
-def kate(exe = 'kate'):
-    install_editor(exe + ' -u -l $line "$file"')
-    
-   
-    
\ No newline at end of file
diff --git a/IPython/quarantine/ipy_exportdb.py b/IPython/quarantine/ipy_exportdb.py
deleted file mode 100644
index b6b3e6ad4bd..00000000000
--- a/IPython/quarantine/ipy_exportdb.py
+++ /dev/null
@@ -1,77 +0,0 @@
-from IPython.core import ipapi
-from IPython.core import macro
-ip = ipapi.get()
-
-import os,pprint
-
-def export(filename = None):
-
-    lines = ['import IPython.core.ipapi', 'ip = IPython.core.ipapi.get()','']
-
-    vars = ip.db.keys('autorestore/*')
-    vars.sort()
-    varstomove = []
-    get = ip.db.get
-    
-    macros = []
-    variables = []
-    
-    for var in vars:
-        k = os.path.basename(var)
-        v = get(var)
-
-        if k.startswith('_'):
-            continue
-        if isinstance(v, macro.Macro):
-            macros.append((k,v))
-        if type(v) in [int, str, float]:
-            variables.append((k,v))
-            
-            
-
-    if macros:
-        lines.extend(['# === Macros ===' ,''])
-    for k,v in macros:
-        lines.append("ip.defmacro('%s'," % k)
-        for line in v.value.splitlines():
-            lines.append(' ' + repr(line+'\n'))
-        lines.extend([')', ''])
-        
-    if variables:
-        lines.extend(['','# === Variables ===',''])
-        for k,v in variables:
-            varstomove.append(k)
-            lines.append('%s = %s' % (k,repr(v)))
-                
-        lines.append('ip.push("%s")' % (' '.join(varstomove)))
-    
-    bkms = ip.db.get('bookmarks',{})
-    
-    if bkms:
-        lines.extend(['','# === Bookmarks ===',''])
-        lines.append("ip.db['bookmarks'] = %s " % pprint.pformat(bkms, indent = 2) )
-        
-    aliases = ip.db.get('stored_aliases', {} )
-    
-    if aliases:
-        lines.extend(['','# === Alias definitions ===',''])
-        for k,v in aliases.items():
-            try:
-                lines.append("ip.define_alias('%s', %s)" % (k, repr(v[1])))
-            except (AttributeError, TypeError):
-                pass
-
-    env = ip.db.get('stored_env')
-    if env:
-        lines.extend(['','# === Stored env vars ===',''])
-        lines.append("ip.db['stored_env'] = %s " % pprint.pformat(env, indent = 2) )
-        
-    
-    
-    out = '\n'.join(lines)
-    
-    if filename:
-        open(filename,'w').write(out)
-    else:
-        print out
-    
diff --git a/IPython/quarantine/ipy_extutil.py b/IPython/quarantine/ipy_extutil.py
deleted file mode 100644
index e899e55e770..00000000000
--- a/IPython/quarantine/ipy_extutil.py
+++ /dev/null
@@ -1,44 +0,0 @@
-""" IPython extension management tools.
-
-After installation, you'll have the 'extutil' object in your namespace.
-to.
-"""
-
-# for the purposes of this module, every module that has the name 'ip' globally
-# installed as below is an IPython extension
-
-from IPython.core import ipapi
-ip = ipapi.get()
-from IPython.core.iplib import InteractiveShell
-
-import sys,textwrap,inspect
-
-def indent(s, ind= '    '):
-    return '\n'.join([ind +l for l in s.splitlines()])
-
-class ExtUtil:
-    """ IPython extensios (ipy_* etc.) management utilities """
-    
-    def describe(self):
-        for n,mod in self._active():
-            doc = inspect.getdoc(mod)
-            if doc:
-                print '== %s ==' % n
-                print indent(doc)
-            
-            
-    def ls(self):
-        """ Show list of installed extensions. """
-        for n,m in self._active():
-            print '%-20s %s' % (n,m.__file__.replace('\\','/'))
-    def _active(self):
-        act = []
-        for mname,m in sys.modules.items():
-            o = getattr(m, 'ip', None)
-            if isinstance(o, InteractiveShell):
-                act.append((mname,m))
-        act.sort()                
-        return act
-
-extutil = ExtUtil()                
-ip.push('extutil')
diff --git a/IPython/quarantine/ipy_fsops.py b/IPython/quarantine/ipy_fsops.py
deleted file mode 100644
index 9121a584d64..00000000000
--- a/IPython/quarantine/ipy_fsops.py
+++ /dev/null
@@ -1,246 +0,0 @@
-""" File system operations
-
-Contains: Simple variants of normal unix shell commands (icp, imv, irm,
-imkdir, igrep).
-
-Some "otherwise handy" utils ('collect' for gathering files to
-~/_ipython/collect, 'inote' for collecting single note lines to
-~/_ipython/note.txt)
-
-Mostly of use for bare windows installations where cygwin/equivalent is not
-installed and you would otherwise need to deal with dos versions of the
-commands (that e.g. don't understand / as path separator). These can
-do some useful tricks on their own, though (like use 'mglob' patterns).
-
-Not to be confused with ipipe commands (ils etc.) that also start with i.
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-ip = ipapi.get()
-
-import shutil,os,shlex
-from IPython.external import mglob
-from IPython.external.path import path
-from IPython.core.error import UsageError
-import IPython.utils.generics
-
-def parse_args(args):
-    """ Given arg string 'CMD files... target', return ([files], target) """
-    
-    tup = args.split(None, 1)
-    if len(tup) == 1:
-        raise UsageError("Expected arguments for " + tup[0])
-    
-    tup2 = shlex.split(tup[1])
-    
-    flist, trg = mglob.expand(tup2[0:-1]), tup2[-1]
-    if not flist:
-        raise UsageError("No files found:" + str(tup2[0:-1]))
-    return flist, trg
-    
-def icp(ip,arg):
-    """ icp files... targetdir
-    
-    Copy all files to target, creating dirs for target if necessary
-    
-    icp srcdir dstdir
-    
-    Copy srcdir to distdir
-    
-    """
-    import distutils.dir_util
-    
-    fs, targetdir = parse_args(arg)
-    if not os.path.isdir(targetdir) and len(fs) > 1:
-        distutils.dir_util.mkpath(targetdir,verbose =1)
-    for f in fs:
-        if os.path.isdir(f):
-            shutil.copytree(f, targetdir)
-        else:
-            shutil.copy2(f,targetdir)
-    return fs
-ip.define_alias("icp",icp)
-
-def imv(ip,arg):
-    """ imv src tgt
-    
-    Move source to target.
-    """
-    
-    fs, target = parse_args(arg)
-    if len(fs) > 1:
-        assert os.path.isdir(target)
-    for f in fs:        
-        shutil.move(f, target)
-    return fs
-ip.define_alias("imv",imv)        
-
-def irm(ip,arg):
-    """ irm path[s]...
-    
-    Remove file[s] or dir[s] path. Dirs are deleted recursively.
-    """
-    try:
-        paths = mglob.expand(arg.split(None,1)[1])
-    except IndexError:
-        raise UsageError("%irm paths...")
-    import distutils.dir_util
-    for p in paths:
-        print "rm",p
-        if os.path.isdir(p):
-            distutils.dir_util.remove_tree(p, verbose = 1)
-        else:
-            os.remove(p)
-
-ip.define_alias("irm",irm)
-
-def imkdir(ip,arg):
-    """ imkdir path
-    
-    Creates dir path, and all dirs on the road
-    """
-    import distutils.dir_util
-    targetdir = arg.split(None,1)[1]
-    distutils.dir_util.mkpath(targetdir,verbose =1)    
-
-ip.define_alias("imkdir",imkdir)    
-
-def igrep(ip,arg):
-    """ igrep PAT files...
-    
-    Very dumb file scan, case-insensitive.
-    
-    e.g.
-    
-    igrep "test this" rec:*.py
-    
-    """
-    elems = shlex.split(arg)
-    dummy, pat, fs = elems[0], elems[1], mglob.expand(elems[2:])
-    res = []
-    for f in fs:
-        found = False
-        for l in open(f):
-            if pat.lower() in l.lower():
-                if not found:
-                    print "[[",f,"]]"
-                    found = True
-                    res.append(f)
-                print l.rstrip()
-    return res
-
-ip.define_alias("igrep",igrep)    
-
-def collect(ip,arg):
-    """ collect foo/a.txt rec:bar=*.py
-    
-    Copies foo/a.txt to ~/_ipython/collect/foo/a.txt and *.py from bar,
-    likewise
-    
-    Without args, try to open ~/_ipython/collect dir (in win32 at least).
-    """
-    from IPython.external.path import path
-    basedir = path(ip.ipython_dir + '/collect')
-    try:    
-        fs = mglob.expand(arg.split(None,1)[1])
-    except IndexError:
-        os.startfile(basedir)
-        return
-    for f in fs:
-        f = path(f)
-        trg = basedir / f.splitdrive()[1].lstrip('/\\')
-        if f.isdir():
-            print "mkdir",trg
-            trg.makedirs()
-            continue
-        dname = trg.dirname()
-        if not dname.isdir():
-            dname.makedirs()
-        print f,"=>",trg
-        shutil.copy2(f,trg)
-
-ip.define_alias("collect",collect)            
-
-def inote(ip,arg):
-    """ inote Hello world
-    
-    Adds timestamp and Hello world to ~/_ipython/notes.txt
-    
-    Without args, opens notes.txt for editing.
-    """
-    import time
-    fname = ip.ipython_dir + '/notes.txt'
-    
-    try:
-        entry = " === " + time.asctime() + ': ===\n' + arg.split(None,1)[1] + '\n'
-        f= open(fname, 'a').write(entry)    
-    except IndexError:
-        ip.hooks.editor(fname)        
-
-ip.define_alias("inote",inote)
-
-def pathobj_mangle(p):
-    return p.replace(' ', '__').replace('.','DOT')
-def pathobj_unmangle(s):
-    return s.replace('__',' ').replace('DOT','.')
-
-
-    
-class PathObj(path):
-    def __init__(self,p):
-        self.path = p
-        if p != '.':
-            self.ents = [pathobj_mangle(ent) for ent in os.listdir(p)]
-        else:
-            self.ents = None
-    def __complete__(self):
-        if self.path != '.':
-            return self.ents
-        self.ents = [pathobj_mangle(ent) for ent in os.listdir('.')]
-        return self.ents
-    def __getattr__(self,name):
-        if name in self.ents:
-            if self.path.endswith('/'):
-                sep = ''
-            else:
-                sep = '/'
-                
-            tgt = self.path + sep + pathobj_unmangle(name)
-            #print "tgt",tgt
-            if os.path.isdir(tgt):
-                return PathObj(tgt)
-            if os.path.isfile(tgt):
-                return path(tgt)
-
-        raise AttributeError, name  # <<< DON'T FORGET THIS LINE !!
-    def __str__(self):
-        return self.path
-        
-    def __repr__(self):
-        return "<PathObj to %s>" % self.path
-    
-    def __call__(self):
-        print "cd:",self.path
-        os.chdir(self.path)
-        
-def complete_pathobj(obj, prev_completions):    
-    if hasattr(obj,'__complete__'):
-        res = obj.__complete__()
-        if res:
-            return res
-    # just return normal attributes of 'path' object if the dir is empty
-    raise TryNext
-
-complete_pathobj = IPython.utils.generics.complete_object.when_type(PathObj)(complete_pathobj)
-
-def test_pathobj():
-    #p = PathObj('c:/prj')
-    #p2 = p.cgi
-    #print p,p2
-    rootdir = PathObj("/")
-    startmenu = PathObj("d:/Documents and Settings/All Users/Start Menu/Programs")
-    cwd = PathObj('.')
-    ip.push("rootdir startmenu cwd")
-    
-#test_pathobj()
\ No newline at end of file
diff --git a/IPython/quarantine/ipy_gnuglobal.py b/IPython/quarantine/ipy_gnuglobal.py
deleted file mode 100644
index 93e27bccaae..00000000000
--- a/IPython/quarantine/ipy_gnuglobal.py
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/usr/bin/env python
-
-
-"""
-Add %global magic for GNU Global usage.
-
-http://www.gnu.org/software/global/
-
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-import os
-
-# alter to your liking
-global_bin = 'd:/opt/global/bin/global'
-
-def global_f(self,cmdline):
-    simple = 0
-    if '-' not in cmdline:
-        cmdline  = '-rx ' + cmdline
-        simple = 1
-        
-    lines = [l.rstrip() for l in os.popen( global_bin + ' ' + cmdline ).readlines()]
-    
-    if simple:
-        parts = [l.split(None,3) for l in lines]
-        lines = ['%s [%s]\n%s' % (p[2].rjust(70),p[1],p[3].rstrip()) for p in parts]
-    print "\n".join(lines)
-
-ip.define_magic('global', global_f)
-
-def global_completer(self,event):
-    compl = [l.rstrip() for l in os.popen(global_bin + ' -c ' + event.symbol).readlines()]
-    return compl    
-
-ip.set_hook('complete_command', global_completer, str_key = '%global')
-
diff --git a/IPython/quarantine/ipy_greedycompleter.py b/IPython/quarantine/ipy_greedycompleter.py
deleted file mode 100644
index 1804338a14f..00000000000
--- a/IPython/quarantine/ipy_greedycompleter.py
+++ /dev/null
@@ -1,77 +0,0 @@
-""" Greedy completer extension for IPython
-
-Normal tab completer refuses to evaluate nonsafe stuff. This will evaluate
-everything, so you need to consider the consequences of pressing tab 
-yourself!
-
-Note that this extension simplifies readline interaction by setting
-only whitespace as completer delimiter. If this works well, we will
-do the same in default completer.
-
-"""
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-from IPython.utils import generics
-from IPython.utils.dir2 import dir2
-
-def attr_matches(self, text):
-    """Compute matches when text contains a dot.
-
-    MONKEYPATCHED VERSION (ipy_greedycompleter.py)
-    
-    Assuming the text is of the form NAME.NAME....[NAME], and is
-    evaluatable in self.namespace or self.global_namespace, it will be
-    evaluated and its attributes (as revealed by dir()) are used as
-    possible completions.  (For class instances, class members are are
-    also considered.)
-
-    WARNING: this can still invoke arbitrary C code, if an object
-    with a __getattr__ hook is evaluated.
-
-    """
-    import re
-
-    force_complete = 1
-    # Another option, seems to work great. Catches things like ''.<tab>
-    m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
-
-    if m:
-        expr, attr = m.group(1, 3)
-    else:
-        # force match - eval anything that ends with colon
-        if not force_complete:
-            return []
-                
-        m2 = re.match(r"(.+)\.(\w*)$", self.lbuf)
-        if not m2:
-            return []
-        expr, attr = m2.group(1,2)
-        
-            
-    try:        
-        obj = eval(expr, self.namespace)
-    except:
-        try:
-            obj = eval(expr, self.global_namespace)
-        except:
-            return []
-
-    words = dir2(obj)
-    
-    try:
-        words = generics.complete_object(obj, words)
-    except TryNext:
-        pass
-    # Build match list to return
-    n = len(attr)
-    res = ["%s.%s" % (expr, w) for w in words if w[:n] == attr ]
-    return res
-
-def main():
-    import IPython.utils.rlineimpl as readline
-    readline.set_completer_delims(" \n\t")
-    # monkeypatch - the code will be folded to normal completer later on
-    import IPython.core.completer
-    IPython.core.completer.Completer.attr_matches = attr_matches
-
-main()
\ No newline at end of file
diff --git a/IPython/quarantine/ipy_jot.py b/IPython/quarantine/ipy_jot.py
deleted file mode 100644
index a64e3ecbc2a..00000000000
--- a/IPython/quarantine/ipy_jot.py
+++ /dev/null
@@ -1,312 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-%jot magic for lightweight persistence.
-
-Stores variables in Struct with some notes in PicleShare database
-
-
-"""
-
-from datetime import datetime 
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import pickleshare
-
-import inspect,pickle,os,sys,textwrap
-from IPython.core.fakemodule import FakeModule
-from IPython.utils.ipstruct import Struct 
-from IPython.utils.warn import error
-
-
-def refresh_variables(ip, key=None):
-    db = ip.db
-    if key is None:
-        keys = db.keys('jot/*')
-    else:
-        keys = db.keys('jot/'+key)
-    for key in keys:
-        # strip autorestore
-        justkey = os.path.basename(key)
-        print "Restoring from", justkey, "..."
-        try:
-            obj = db[key]
-        except KeyError:
-            print "Unable to restore variable '%s', ignoring (use %%jot -d to forget!)" % justkey
-            print "The error was:",sys.exc_info()[0]
-        else:
-            #print "restored",justkey,"=",obj #dbg
-            try:
-                origname = obj.name
-            except:
-                ip.user_ns[justkey] = obj
-                print "Restored", justkey
-            else:
-                ip.user_ns[origname] = obj['val']
-                print "Restored", origname 
-
-def read_variables(ip, key=None):
-    db = ip.db
-    if key is None:
-        return None
-    else:
-        keys = db.keys('jot/'+key)
-    for key in keys:
-        # strip autorestore
-        justkey = os.path.basename(key)
-        print "restoring from ", justkey 
-        try:
-            obj = db[key]
-        except KeyError:
-            print "Unable to read variable '%s', ignoring (use %%jot -d to forget!)" % justkey
-            print "The error was:",sys.exc_info()[0]
-        else:
-            return obj
-
-
-def detail_variables(ip, key=None):
-    db, get = ip.db, ip.db.get
- 
-    if key is None:
-        keys = db.keys('jot/*')
-    else:
-        keys = db.keys('jot/'+key)
-    if keys:
-        size = max(map(len,keys))
-    else:
-        size = 0
-
-    fmthead = '%-'+str(size)+'s [%s]'
-    fmtbody = 'Comment:\n %s'
-    fmtdata = 'Data:\n %s, %s'
-    for key in keys:
-        v = get(key,'<unavailable>')
-        justkey = os.path.basename(key)
-        try: 
-            print fmthead % (justkey, datetime.ctime(v.get('time','<unavailable>')))
-            print fmtbody % (v.get('comment','<unavailable>'))
-            d = v.get('val','unavailable')
-            print fmtdata % (repr(type(d)), '')
-            print repr(d)[0:200]
-            print
-            print
-        except AttributeError:
-            print fmt % (justkey, '<unavailable>', '<unavailable>', repr(v)[:50])
-
-
-def intm(n):
-    try:
-        return int(n)
-    except:
-        return 0
-
-def jot_obj(self, obj, name, comment=''):
-    """
-    write obj data to the note database, with whatever that should be noted.
-    """
-    had = self.db.keys('jot/'+name+'*')
-    # if it the same name but a later version, we stupidly add a number to the 
-    # so the name doesn't collide. Any better idea?
-    suffix = ''
-    if len(had)>0:
-        pre = os.path.commonprefix(had)
-        suf = [n.split(pre)[1] for n in had]
-        versions = map(intm, suf)
-        suffix = str(max(versions)+1)
-
-    uname = 'jot/'+name+suffix
-
-    # which one works better? 
-    #all = ip.shadowhist.all()
-    all = ip.shell.history_manager.input_hist_parsed
-
-    # We may actually want to make snapshot of files that are run-ned.
-
-    # get the comment 
-    try:
-        comment = ip.magic_edit('-x').strip()
-    except:
-        print "No comment is recorded."
-        comment = ''
-
-    self.db[uname] = Struct({'val':obj, 
-                'time'  :   datetime.now(), 
-                'hist'  :   all,
-                'name'  :   name,
-                'comment' : comment,})
-
-    print "Jotted down notes for '%s' (%s)" % (uname, obj.__class__.__name__)
-
-    
-
-def magic_jot(self, parameter_s=''):
-    """Lightweight persistence for python variables.
-
-    Example:
-    
-    ville@badger[~]|1> A = ['hello',10,'world']\\
-    ville@badger[~]|2> %jot A\\
-    ville@badger[~]|3> Exit
-    
-    (IPython session is closed and started again...)
-    
-    ville@badger:~$ ipython -p pysh\\
-    ville@badger[~]|1> print A
-    
-    ['hello', 10, 'world']
-    
-    Usage:
-    
-    %jot          - Show list of all variables and their current values\\
-    %jot -l       - Show list of all variables and their current values in detail\\
-    %jot -l <var> - Show one variable and its current values in detail\\
-    %jot <var>    - Store the *current* value of the variable to disk\\
-    %jot -d <var> - Remove the variable and its value from storage\\
-    %jot -z       - Remove all variables from storage (disabled)\\
-    %jot -r <var> - Refresh/Load variable from jot (delete current vals)\\
-    %jot foo >a.txt  - Store value of foo to new file a.txt\\
-    %jot foo >>a.txt - Append value of foo to file a.txt\\   
-    
-    It should be noted that if you change the value of a variable, you
-    need to %note it again if you want to persist the new value.
-    
-    Note also that the variables will need to be pickleable; most basic
-    python types can be safely %stored.
-    
-    """
-    
-    opts,argsl = self.parse_options(parameter_s,'drzl',mode='string')
-    args = argsl.split(None,1)
-    ip = self.getapi()
-    db = ip.db
-    # delete
-    if opts.has_key('d'):
-        try:
-            todel = args[0]
-        except IndexError:
-            error('You must provide the variable to forget')
-        else:
-            try:
-                del db['jot/' + todel]
-            except:
-                error("Can't delete variable '%s'" % todel)
-    # reset the whole database
-    elif opts.has_key('z'):
-        print "reseting the whole database has been disabled."
-        #for k in db.keys('autorestore/*'):
-        #    del db[k]
-
-    elif opts.has_key('r'):
-        try:
-            toret = args[0]
-        except:
-            print "restoring all the variables jotted down..."
-            refresh_variables(ip)
-        else:
-            refresh_variables(ip, toret)
-
-    elif opts.has_key('l'):
-        try:
-            tolist = args[0]
-        except:
-            print "List details for all the items."
-            detail_variables(ip)
-        else:
-            print "Details for", tolist, ":"
-            detail_variables(ip, tolist)
-    
-    # run without arguments -> list noted variables & notes 
-    elif not args:
-        vars = self.db.keys('jot/*')
-        vars.sort()            
-        if vars:
-            size = max(map(len,vars)) - 4 
-        else:
-            size = 0
-            
-        print 'Variables and their in-db values:'
-        fmt = '%-'+str(size)+'s [%s] -> %s'
-        get = db.get
-        for var in vars:
-            justkey = os.path.basename(var)
-            v = get(var,'<unavailable>')
-            try: 
-                print fmt % (justkey,\
-                    datetime.ctime(v.get('time','<unavailable>')),\
-                    v.get('comment','<unavailable>')[:70].replace('\n',' '),)
-            except AttributeError:
-                print fmt % (justkey, '<unavailable>', '<unavailable>', repr(v)[:50])
-
-    
-    # default action - store the variable
-    else:
-        # %store foo >file.txt or >>file.txt
-        if len(args) > 1 and args[1].startswith('>'):
-            fnam = os.path.expanduser(args[1].lstrip('>').lstrip())
-            if args[1].startswith('>>'):
-                fil = open(fnam,'a')
-            else:
-                fil = open(fnam,'w')
-            obj = ip.ev(args[0])
-            print "Writing '%s' (%s) to file '%s'." % (args[0],
-              obj.__class__.__name__, fnam)
-
-            
-            if not isinstance (obj,basestring):
-                from pprint import pprint
-                pprint(obj,fil)
-            else:
-                fil.write(obj)
-                if not obj.endswith('\n'):
-                    fil.write('\n')
-            
-            fil.close()
-            return
-        
-        # %note foo
-        try:
-            obj = ip.user_ns[args[0]]
-        except KeyError:
-            # this should not be alias, for aliases, use %store
-            print
-            print "Error: %s doesn't exist." % args[0]
-            print 
-            print "Use %note -r <var> to retrieve variables. This should not be used " +\
-                  "to store alias, for saving aliases, use %store" 
-            return
-        else:
-            if isinstance(inspect.getmodule(obj), FakeModule):
-                print textwrap.dedent("""\
-                Warning:%s is %s 
-                Proper storage of interactively declared classes (or instances
-                of those classes) is not possible! Only instances
-                of classes in real modules on file system can be %%store'd.
-                """ % (args[0], obj) ) 
-                return
-            #pickled = pickle.dumps(obj)
-            #self.db[ 'jot/' + args[0] ] = obj
-            jot_obj(self, obj, args[0])
-
-
-def magic_read(self, parameter_s=''):
-    """    
-    %read <var> - Load variable from data that is jotted down.\\
-    
-    """
-    
-    opts,argsl = self.parse_options(parameter_s,'drzl',mode='string')
-    args = argsl.split(None,1)
-    ip = self.getapi()
-    db = ip.db
-    #if opts.has_key('r'):
-    try:
-        toret = args[0]
-    except:
-        print "which record do you want to read out?"
-        return
-    else:
-        return read_variables(ip, toret)
-
-
-ip.define_magic('jot',magic_jot)
-ip.define_magic('read',magic_read)
diff --git a/IPython/quarantine/ipy_lookfor.py b/IPython/quarantine/ipy_lookfor.py
deleted file mode 100644
index 98738c37c2c..00000000000
--- a/IPython/quarantine/ipy_lookfor.py
+++ /dev/null
@@ -1,234 +0,0 @@
-"""
-IPython extension: %lookfor command for searching docstrings
-
-"""
-# Pauli Virtanen <pav@iki.fi>, 2008.
-
-import re, inspect, pkgutil, pydoc
-
-#------------------------------------------------------------------------------
-# Lookfor functionality
-#------------------------------------------------------------------------------
-
-# Cache for lookfor: {id(module): {name: (docstring, kind, index), ...}...}
-# where kind: "func", "class", "module", "object"
-# and index: index in breadth-first namespace traversal
-_lookfor_caches = {}
-
-# regexp whose match indicates that the string may contain a function signature
-_function_signature_re = re.compile(r"[a-z_]+\(.*[,=].*\)", re.I)
-
-def lookfor(what, modules=None, import_modules=True, regenerate=False):
-    """
-    Search for objects whose documentation contains all given words.
-    Shows a summary of matching objects, sorted roughly by relevance.
-
-    Parameters
-    ----------
-    what : str
-        String containing words to look for.
-
-    module : str, module
-        Module whose docstrings to go through.
-    import_modules : bool
-        Whether to import sub-modules in packages.
-        Will import only modules in __all__
-    regenerate: bool
-        Re-generate the docstring cache
-
-    """
-    # Cache
-    cache = {}
-    for module in modules:
-        try:
-            c = _lookfor_generate_cache(module, import_modules, regenerate)
-            cache.update(c)
-        except ImportError:
-            pass
-    
-    # Search
-    # XXX: maybe using a real stemming search engine would be better?
-    found = []
-    whats = str(what).lower().split()
-    if not whats: return
-
-    for name, (docstring, kind, index) in cache.iteritems():
-        if kind in ('module', 'object'): 
-            # don't show modules or objects
-            continue
-        ok = True
-        doc = docstring.lower()
-        for w in whats:
-            if w not in doc:
-                ok = False
-                break
-        if ok:
-            found.append(name)
-
-    # Relevance sort
-    # XXX: this is full Harrison-Stetson heuristics now,
-    # XXX: it probably could be improved
-
-    kind_relevance = {'func': 1000, 'class': 1000, 
-                      'module': -1000, 'object': -1000}
-
-    def relevance(name, docstr, kind, index):
-        r = 0
-        # do the keywords occur within the start of the docstring?
-        first_doc = "\n".join(docstr.lower().strip().split("\n")[:3])
-        r += sum([200 for w in whats if w in first_doc])
-        # do the keywords occur in the function name?
-        r += sum([30 for w in whats if w in name])
-        # is the full name long?
-        r += -len(name) * 5
-        # is the object of bad type?
-        r += kind_relevance.get(kind, -1000)
-        # is the object deep in namespace hierarchy?
-        r += -name.count('.') * 10
-        r += max(-index / 100, -100)
-        return r
-
-    def relevance_sort(a, b):
-        dr = relevance(b, *cache[b]) - relevance(a, *cache[a])
-        if dr != 0: return dr
-        else: return cmp(a, b)
-    found.sort(relevance_sort)
-
-    # Pretty-print
-    s = "Search results for '%s'" % (' '.join(whats))
-    help_text = [s, "-"*len(s)]
-    for name in found:
-        doc, kind, ix = cache[name]
-
-        doclines = [line.strip() for line in doc.strip().split("\n")
-                    if line.strip()]
-
-        # find a suitable short description
-        try:
-            first_doc = doclines[0].strip()
-            if _function_signature_re.search(first_doc):
-                first_doc = doclines[1].strip()
-        except IndexError:
-            first_doc = ""
-        help_text.append("%s\n    %s" % (name, first_doc))
-
-    # Output
-    if len(help_text) > 10:
-        pager = pydoc.getpager()
-        pager("\n".join(help_text))
-    else:
-        print "\n".join(help_text)
-
-def _lookfor_generate_cache(module, import_modules, regenerate):
-    """
-    Generate docstring cache for given module.
-
-    Parameters
-    ----------
-    module : str, None, module
-        Module for which to generate docstring cache
-    import_modules : bool
-        Whether to import sub-modules in packages.
-        Will import only modules in __all__
-    regenerate: bool
-        Re-generate the docstring cache
-
-    Returns
-    -------
-    cache : dict {obj_full_name: (docstring, kind, index), ...}
-        Docstring cache for the module, either cached one (regenerate=False)
-        or newly generated.
-        
-    """
-    global _lookfor_caches
-
-    if module is None:
-        module = "numpy"
-
-    if isinstance(module, str):
-        module = __import__(module)
-
-    if id(module) in _lookfor_caches and not regenerate:
-        return _lookfor_caches[id(module)]
-
-    # walk items and collect docstrings
-    cache = {}
-    _lookfor_caches[id(module)] = cache
-    seen = {}
-    index = 0
-    stack = [(module.__name__, module)]
-    while stack:
-        name, item = stack.pop(0)
-        if id(item) in seen: continue
-        seen[id(item)] = True
-
-        index += 1
-        kind = "object"
-       
-        if inspect.ismodule(item):
-            kind = "module"
-            try:
-                _all = item.__all__
-            except AttributeError:
-                _all = None
-            # import sub-packages
-            if import_modules and hasattr(item, '__path__'):
-                for m in pkgutil.iter_modules(item.__path__):
-                    if _all is not None and m[1] not in _all:
-                        continue
-                    try:
-                        __import__("%s.%s" % (name, m[1]))
-                    except ImportError:
-                        continue
-            for n, v in inspect.getmembers(item):
-                if _all is not None and n not in _all:
-                    continue
-                stack.append(("%s.%s" % (name, n), v))
-        elif inspect.isclass(item):
-            kind = "class"
-            for n, v in inspect.getmembers(item):
-                stack.append(("%s.%s" % (name, n), v))
-        elif callable(item):
-            kind = "func"
-        
-        doc = inspect.getdoc(item)
-        if doc is not None:
-            cache[name] = (doc, kind, index)
-
-    return cache
-
-#------------------------------------------------------------------------------
-# IPython connectivity
-#------------------------------------------------------------------------------
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-_lookfor_modules = ['numpy', 'scipy']
-
-def lookfor_f(self, arg=''):
-    r"""
-    Search for objects whose documentation contains all given words.
-    Shows a summary of matching objects, sorted roughly by relevance.
-
-    Usage
-    -----
-    %lookfor +numpy  some words
-    Search module 'numpy'
-
-    %lookfor_modules numpy scipy
-    Set default modules whose docstrings to search
-
-    """
-    lookfor(arg, modules=_lookfor_modules)
-
-def lookfor_modules_f(self, arg=''):
-    global _lookfor_modules
-    if not arg:
-        print "Modules included in %lookfor search:", _lookfor_modules
-    else:
-        _lookfor_modules = arg.split()
-
-ip.define_magic('lookfor', lookfor_f)
-ip.define_magic('lookfor_modules', lookfor_modules_f)
-
diff --git a/IPython/quarantine/ipy_profile_doctest.py b/IPython/quarantine/ipy_profile_doctest.py
deleted file mode 100644
index d1e4f7506d6..00000000000
--- a/IPython/quarantine/ipy_profile_doctest.py
+++ /dev/null
@@ -1,46 +0,0 @@
-"""Config file for 'doctest' profile.
-
-This profile modifies the prompts to be the standard Python ones, so that you
-can generate easily doctests from an IPython session.
-
-But more importantly, it enables pasting of code with '>>>' prompts and
-arbitrary initial whitespace, as is typical of doctests in reST files and
-docstrings.  This allows you to easily re-run existing doctests and iteratively
-work on them as part of your development workflow.
-
-The exception mode is also set to 'plain' so the generated exceptions are as
-similar as possible to the default Python ones, for inclusion in doctests."""
-
-# get various stuff that are there for historical / familiarity reasons
-import ipy_legacy
-
-from IPython.core import ipapi
-
-from IPython.extensions import InterpreterPasteInput
-
-def main():    
-    ip = ipapi.get()
-    o = ip.options
-
-    # Set the prompts similar to the defaults
-    o.prompt_in1 = '>>> '
-    o.prompt_in2 = '... '
-    o.prompt_out = ''
-
-    # Add a blank line before each new set of inputs.  This is needed by
-    # doctest to distinguish each test from the next.
-    o.separate_in = '\n'
-    o.separate_out = ''
-    o.separate_out2 = ''
-
-    # Disable pprint, so that outputs are printed as similarly to standard
-    # python as possible
-    o.pprint = False
-    
-    # Use plain exceptions, to also resemble normal pyhton.
-    o.xmode = 'plain'
-
-    # Store the activity flag in the metadata bag from the running shell
-    ip.meta.doctest_mode = True
-
-main()
diff --git a/IPython/quarantine/ipy_pydb.py b/IPython/quarantine/ipy_pydb.py
deleted file mode 100644
index 67b45f0915d..00000000000
--- a/IPython/quarantine/ipy_pydb.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import inspect
-from IPython.core import ipapi
-from IPython.utils.process import arg_split
-ip = ipapi.get()
-
-from IPython.core import debugger
-
-def call_pydb(self, args):
-    """Invoke pydb with the supplied parameters."""
-    try:
-        import pydb
-    except ImportError:
-        raise ImportError("pydb doesn't seem to be installed.")
-
-    if not hasattr(pydb.pydb, "runv"):
-        raise ImportError("You need pydb version 1.19 or later installed.")
-
-    argl = arg_split(args)
-    # print argl # dbg
-    if len(inspect.getargspec(pydb.runv)[0]) == 2:
-        pdb = debugger.Pdb(color_scheme=self.colors)
-        ip.history_saving_wrapper( lambda : pydb.runv(argl, pdb) )()
-    else:
-        ip.history_saving_wrapper( lambda : pydb.runv(argl) )()
-
-    
-ip.define_magic("pydb",call_pydb)    
-
-    
-    
-    
diff --git a/IPython/quarantine/ipy_rehashdir.py b/IPython/quarantine/ipy_rehashdir.py
deleted file mode 100644
index 7250470851d..00000000000
--- a/IPython/quarantine/ipy_rehashdir.py
+++ /dev/null
@@ -1,140 +0,0 @@
-# -*- coding: utf-8 -*-
-""" IPython extension: add %rehashdir magic
-
-Usage:
-
-%rehashdir c:/bin c:/tools
-  - Add all executables under c:/bin and c:/tools to alias table, in 
-  order to make them directly executable from any directory.
-  
-This also serves as an example on how to extend ipython
-with new magic functions.
-
-Unlike rest of ipython, this requires Python 2.4 (optional
-extensions are allowed to do that).
-
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-
-import os,re,fnmatch,sys
-
-def selflaunch(ip,line):
-    """ Launch python script with 'this' interpreter
-    
-    e.g. d:\foo\ipykit.exe a.py
-    
-    """
-    
-    tup = line.split(None,1)
-    if len(tup) == 1:
-        print "Launching nested ipython session"
-        os.system(sys.executable)
-        return
-        
-    cmd = sys.executable + ' ' + tup[1]
-    print ">",cmd
-    os.system(cmd)
-
-class PyLauncher:
-    """ Invoke selflanucher on the specified script
-    
-    This is mostly useful for associating with scripts using::
-        _ip.define_alias('foo',PyLauncher('foo_script.py'))
-    
-    """
-    def __init__(self,script):
-        self.script = os.path.abspath(script)
-    def __call__(self, ip, line):
-        if self.script.endswith('.ipy'):
-            ip.runlines(open(self.script).read())
-        else:
-            # first word is the script/alias name itself, strip it
-            tup = line.split(None,1)
-            if len(tup) == 2:
-                tail = ' ' + tup[1]
-            else:
-                tail = ''
-                
-            selflaunch(ip,"py " + self.script + tail)
-    def __repr__(self):
-        return 'PyLauncher("%s")' % self.script
-
-def rehashdir_f(self,arg):
-    """ Add executables in all specified dirs to alias table
-     
-    Usage:
-
-    %rehashdir c:/bin;c:/tools
-      - Add all executables under c:/bin and c:/tools to alias table, in 
-      order to make them directly executable from any directory.
-        
-      Without arguments, add all executables in current directory.
-      
-    """
-
-    # most of the code copied from Magic.magic_rehashx
-
-    def isjunk(fname):
-        junk = ['*~']
-        for j in junk:
-            if fnmatch.fnmatch(fname, j):
-                return True
-        return False
-    
-    created = []
-    if not arg:
-        arg = '.'
-    path = map(os.path.abspath,arg.split(';'))
-    alias_table = self.shell.alias_manager.alias_table
-        
-    if os.name == 'posix':
-        isexec = lambda fname:os.path.isfile(fname) and \
-                 os.access(fname,os.X_OK)
-    else:
-
-        try:
-            winext = os.environ['pathext'].replace(';','|').replace('.','')
-        except KeyError:
-            winext = 'exe|com|bat|py'
-        if 'py' not in winext:
-            winext += '|py'
-            
-        execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
-        isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
-    savedir = os.getcwd()
-    try:
-        # write the whole loop for posix/Windows so we don't have an if in
-        # the innermost part
-        if os.name == 'posix':
-            for pdir in path:
-                os.chdir(pdir)
-                for ff in os.listdir(pdir):
-                    if isexec(ff) and not isjunk(ff):
-                        # each entry in the alias table must be (N,name),
-                        # where N is the number of positional arguments of the
-                        # alias.
-                        src,tgt = os.path.splitext(ff)[0], os.path.abspath(ff)
-                        created.append(src)                        
-                        alias_table[src] = (0,tgt)
-        else:
-            for pdir in path:
-                os.chdir(pdir)
-                for ff in os.listdir(pdir):
-                    if isexec(ff) and not isjunk(ff):
-                        src, tgt = execre.sub(r'\1',ff), os.path.abspath(ff)
-                        src = src.lower()
-                        created.append(src)                                                
-                        alias_table[src] = (0,tgt)
-        # Make sure the alias table doesn't contain keywords or builtins
-        self.shell.alias_table_validate()
-        # Call again init_auto_alias() so we get 'rm -i' and other
-        # modified aliases since %rehashx will probably clobber them
-        # self.shell.init_auto_alias()
-    finally:
-        os.chdir(savedir)
-    return created
-
-ip.define_magic("rehashdir",rehashdir_f)
diff --git a/IPython/quarantine/ipy_render.py b/IPython/quarantine/ipy_render.py
deleted file mode 100644
index 8aa1b72d124..00000000000
--- a/IPython/quarantine/ipy_render.py
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/env python
-
-""" IPython extension: Render templates from variables and paste to clipbard """
-
-from IPython.core import ipapi
-
-ip = ipapi.get()
-
-from string import Template
-import sys,os
-
-from IPython.external.Itpl import itplns
-
-def toclip_w32(s):
-    """ Places contents of s to clipboard
-    
-    Needs pyvin32 to work:
-    http://sourceforge.net/projects/pywin32/
-    """
-    import win32clipboard as cl
-    import win32con
-    cl.OpenClipboard()
-    cl.EmptyClipboard()
-    cl.SetClipboardText( s.replace('\n','\r\n' ))
-    cl.CloseClipboard()
-
-try:
-    import win32clipboard    
-    toclip = toclip_w32
-except ImportError:
-    def toclip(s): pass
-    
-
-def render(tmpl):
-    """ Render a template (Itpl format) from ipython variables
-
-    Example:
-    
-    $ import ipy_render
-    $ my_name = 'Bob'  # %store this for convenience
-    $ t_submission_form = "Submission report, author: $my_name"  # %store also
-    $ render t_submission_form
-    
-    => returns "Submission report, author: Bob" and copies to clipboard on win32
-
-    # if template exist as a file, read it. Note: ;f hei vaan => f("hei vaan")
-    $ ;render c:/templates/greeting.txt  
-    
-    Template examples (Ka-Ping Yee's Itpl library):
-    
-    Here is a $string.
-    Here is a $module.member.
-    Here is an $object.member.
-    Here is a $functioncall(with, arguments).
-    Here is an ${arbitrary + expression}.
-    Here is an $array[3] member.
-    Here is a $dictionary['member'].
-    """
-    
-    if os.path.isfile(tmpl):
-        tmpl = open(tmpl).read()
-        
-    res = itplns(tmpl, ip.user_ns)
-    toclip(res)
-    return res
-
-ip.push('render')
-    
\ No newline at end of file
diff --git a/IPython/quarantine/ipy_server.py b/IPython/quarantine/ipy_server.py
deleted file mode 100644
index a409942010e..00000000000
--- a/IPython/quarantine/ipy_server.py
+++ /dev/null
@@ -1,38 +0,0 @@
-""" Simple TCP socket server that executes statements in IPython instance.
-
-Usage:
-
-import ipy_server
-ipy_server.serve_thread(16455)
-
-Now, to execute the statements in this ipython instance, open a TCP socket
-(port 16455), write out the statements, and close the socket. 
-You can use e.g. "telnet localhost 16455" or a script to do this.
-
-This is a bit like 'M-x server-start" or gnuserv in the emacs world.
-
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import SocketServer
-
-# user-accessible port
-PORT = 8099
-
-class IPythonRequestHandler(SocketServer.StreamRequestHandler):
-    def handle(self):
-        #print "connection from", self.client_address
-        inp = self.rfile.read().replace('\r\n','\n')
-        #print "Execute",inp
-        ip.runlines(inp)
-
-def serve(port = PORT):
-    server = SocketServer.TCPServer(("", port), IPythonRequestHandler)
-    print "ipy_server on TCP port", port
-    server.serve_forever()
-
-def serve_thread(port = PORT):
-    import thread
-    thread.start_new_thread(serve, (port,))
\ No newline at end of file
diff --git a/IPython/quarantine/ipy_signals.py b/IPython/quarantine/ipy_signals.py
deleted file mode 100644
index 3d7f072b1af..00000000000
--- a/IPython/quarantine/ipy_signals.py
+++ /dev/null
@@ -1,62 +0,0 @@
-""" Advanced signal (e.g. ctrl+C) handling for IPython
-
-So far, this only ignores ctrl + C in IPython file a subprocess
-is executing, to get closer to how a "proper" shell behaves.
-
-Other signal processing may be implemented later on.
-
-If _ip.options.verbose is true, show exit status if nonzero
-
-"""
-
-import signal,os,sys
-from IPython.core import ipapi
-import subprocess
-
-ip = ipapi.get()
-
-def new_ipsystem_posix(cmd):
-    """ ctrl+c ignoring replacement for system() command in iplib.
-    
-    Ignore ctrl + c in IPython process during the command execution. 
-    The subprocess will still get the ctrl + c signal.
-    
-    posix implementation
-    """
-    
-    p =  subprocess.Popen(cmd, shell = True)
-    
-    old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
-    pid,status = os.waitpid(p.pid,0)
-    signal.signal(signal.SIGINT, old_handler)
-    if status and ip.options.verbose:
-        print "[exit status: %d]" % status
-    
-def new_ipsystem_win32(cmd):    
-    """ ctrl+c ignoring replacement for system() command in iplib.
-    
-    Ignore ctrl + c in IPython process during the command execution. 
-    The subprocess will still get the ctrl + c signal.
-    
-    win32 implementation
-    """
-    old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
-    status = os.system(cmd)
-    signal.signal(signal.SIGINT, old_handler)
-    if status and ip.options.verbose:
-        print "[exit status: %d]" % status
-    
-    
-def init():
-    o = ip.options
-    try:
-        o.verbose
-    except AttributeError:
-        o.allow_new_attr (True )
-        o.verbose = 0
-        
-    ip.system = (sys.platform == 'win32' and new_ipsystem_win32 or 
-                    new_ipsystem_posix)
-    
-init()
-    
\ No newline at end of file
diff --git a/IPython/quarantine/ipy_synchronize_with.py b/IPython/quarantine/ipy_synchronize_with.py
deleted file mode 100644
index 51fe1f54601..00000000000
--- a/IPython/quarantine/ipy_synchronize_with.py
+++ /dev/null
@@ -1,242 +0,0 @@
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import win32api
-import win32ui
-import win32console
-import dde
-import os
-import scitedirector
-
-# test to write.
-
-def set_hook(synchronize_with_editor):
-    """Set the synchronize with editor hook with a callable object.
-    
-    The callable object will be called with the following arguments when
-    IPython wants to synchronize with you favorite editor:
-    
-     - ip: a running IPython instance.
-     
-     - filename: the path of the file the editor is supposed to display.
-     
-     - lineno : the line number of the line the editor is supposed to
-     highlight.
-     
-     - columnno : the column number of the character the editor is supposed
-     to highlight.
-    """
-    ip.set_hook("synchronize_with_editor", synchronize_with_editor)
-
-
-def find_filename(filename):
-    """Return the filename to synchronize with based on """
-    filename = os.path.splitext(filename)
-    if filename[1] == ".pyc":
-        filename = (filename[0], ".py")
-    filename = "".join(filename)
-
-    if not os.path.isabs(filename):
-        filename = os.path.join(os.getcwd(), filename)
-
-    if os.path.isfile(filename):
-        return filename
-
-    return ""
-
-
-def run_command(path, command, arguments, asynchronous = True):
-    """Run a shell command and return the exit code of the command"""
-    # This is a thin wrapper around os.system that:
-    #  - Let you run command asynchronously.
-    #  - Accept spaces in command path.
-    #  - Dont throw exception if the command don't exist.
-    line = ''
-    if asynchronous:
-        line += 'start '
-        
-    try:
-        line += win32api.GetShortPathName(os.path.join(path, command) + ".exe") + " "
-    except:
-        print 'could not find: "%s"' % (os.path.join(path, command) + ".exe")
-        return -1
-        
-    line += arguments
-    r = os.system(line)
-    return r
-
-
-def sleep(milliseconds):
-    """Wait some milliseconds."""
-    # This is used to make sure the editor did its job before we reset the focus on the console.
-    win32api.Sleep(milliseconds)
-
-
-def restore_console_focus():
-    """Restore the focus to the IPython console."""
-    h = win32console.GetConsoleWindow()
-    console_window = win32ui.CreateWindowFromHandle(h)
-    console_window.SetForegroundWindow()
-    
-
-# This is the most simple example of hook:
-class GVimHook:
-    def __init__(self, path, wakeup_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        run_command(self.path, 'gvim', '--remote-silent +%d "%s"' % (lineno, filename))
-
-        sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def gvim(path = r"C:\Program Files\vim\vim71", wakeup_duration = 100):
-    synchronize_with_editor = GVimHook(path, wakeup_duration)
-    set_hook(synchronize_with_editor)
-
-
-class EmacsHook:
-    def __init__(self, path, wakeup_duration, start_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-        self.start_duration = start_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        r = run_command(self.path, "emacsclient", '-n +%d:%d "%s" 2>nul' % (lineno, columnno, filename), False)
-        if r != 0:
-            run_command(self.path, 'runemacs', '--quick -f server-start +%d:%d "%s"' % (lineno, columnno, filename))
-            sleep(self.start_duration)
-        else:
-            sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def emacs(path = r"C:\Program Files\emacs\bin", wakeup_duration = 100, start_duration = 2000):
-    synchronize_with_editor = EmacsHook(path, wakeup_duration, start_duration)
-    set_hook(synchronize_with_editor)
-
-
-class SciteHook:
-    def __init__(self, path, wakeup_duration, start_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-        self.start_duration = start_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        scites = scitedirector.findWindows()
-        if not scites:
-            run_command(self.path, "scite", '"-open:%s" -goto:%d' % (filename.replace("\\", "/"), lineno))
-
-            sleep(self.start_duration)
-            restore_console_focus()
-        else:
-            scite = scites[0]
-            scitedirector.sendCommand(scite, 'open:%s' % filename.replace("\\", "/"))
-            scitedirector.sendCommand(scite, "goto:%d" % lineno)
-
-
-def scite(path = r"C:\Program Files\SciTE Source Code Editor", wakeup_duration = 100, start_duration = 500):
-    synchronize_with_editor = SciteHook(path, wakeup_duration, start_duration)
-    set_hook(synchronize_with_editor)
-
-
-class NodePadPlusPlusHook:
-    def __init__(self, path, wakeup_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        run_command(self.path, "notepad++", '"%s" -n%d' % (filename, lineno))
-
-        sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def notepadplusplus(path = r"C:\Program Files\Notepad++", wakeup_duration = 100):
-    synchronize_with_editor = NodePadPlusPlusHook(path, wakeup_duration)
-    set_hook(synchronize_with_editor)
-
-
-class PsPadHook:
-    def __init__(self, path, wakeup_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        run_command(self.path, "pspad", '"%s" -%d' % (filename, lineno))
-
-        sleep(self.wakeup_duration)
-
-        restore_console_focus()
-
-
-def pspad(path = r"C:\Program Files\PSPad editor", wakeup_duration = 100):
-    synchronize_with_editor = PsPadHook(path, wakeup_duration)
-    set_hook(synchronize_with_editor)
-
-
-# This is an example of DDE hook:
-class UltraEditHook:
-    def __init__(self, path, wakeup_duration, start_duration):
-        self.path = path
-        self.wakeup_duration = wakeup_duration
-        self.start_duration = start_duration
-
-    def __call__(self, ip, filename, lineno, columnno):
-        filename = find_filename(filename)
-
-        if not filename:
-            return
-
-        server = dde.CreateServer()
-        server.Create("myddeserver")
-        conversation = dde.CreateConversation(server)
-        try:
-            conversation.ConnectTo("uedit32", "System")
-            conversation.Exec(r'[open("%s/%d"])' % (filename, lineno))
-            
-            sleep(self.wakeup_duration)
-        except:
-            run_command(self.path, 'uedit32', '"%s/%d"' % (filename, lineno))
-            
-            sleep(self.start_duration)
-
-        server.Shutdown()
-
-        restore_console_focus()
-
-
-def ultraedit(path = r"C:\Program Files\IDM Computer Solutions\UltraEdit-32", wakeup_duration = 10, start_duration = 2000):
-    synchronize_with_editor = UltraEditHook(path, wakeup_duration, start_duration)
-    set_hook(synchronize_with_editor)
-    
\ No newline at end of file
diff --git a/IPython/quarantine/ipy_system_conf.py b/IPython/quarantine/ipy_system_conf.py
deleted file mode 100644
index 539650dd637..00000000000
--- a/IPython/quarantine/ipy_system_conf.py
+++ /dev/null
@@ -1,24 +0,0 @@
-""" System wide configuration file for IPython.
-
-This will be imported by ipython for all users.
-
-After this ipy_user_conf.py is imported, user specific configuration
-should reside there. 
-
- """
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-# add system wide configuration information, import extensions etc. here.
-# nothing here is essential 
-
-import sys
-
-import ext_rescapture # var = !ls and var = %magic
-import pspersistence # %store magic
-import clearcmd # %clear
-
-import ipy_stock_completers
-
-ip.load('IPython.core.history')
diff --git a/IPython/quarantine/ipy_which.py b/IPython/quarantine/ipy_which.py
deleted file mode 100644
index efe7449728e..00000000000
--- a/IPython/quarantine/ipy_which.py
+++ /dev/null
@@ -1,76 +0,0 @@
-r""" %which magic command
-
-%which <cmd> => search PATH for files matching PATH. Also scans aliases
-
-"""
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import os,sys
-from fnmatch import fnmatch
-def which(fname):
-    fullpath = filter(os.path.isdir,os.environ['PATH'].split(os.pathsep))
-    
-    if '.' not in fullpath:
-        fullpath = ['.'] + fullpath
-    fn = fname
-    for p in fullpath:
-        for f in os.listdir(p):
-            head, ext = os.path.splitext(f)
-            if f == fn or fnmatch(head, fn):
-                yield os.path.join(p,f)
-    return
-
-def which_alias(fname):
-    for al, tgt in ip.alias_table.items():
-        if not (al == fname or fnmatch(al, fname)):
-            continue
-        if callable(tgt):
-            print "Callable alias",tgt
-            d = tgt.__doc__
-            if d:
-                print "Docstring:\n",d
-                continue
-        trg = tgt[1]
-        
-        trans = ip.expand_alias(trg)
-        cmd = trans.split(None,1)[0]
-        print al,"->",trans
-        for realcmd in which(cmd):
-            print "  ==",realcmd
-        
-def which_f(self, arg):
-    r""" %which <cmd> => search PATH for files matching cmd. Also scans aliases.
-
-    Traverses PATH and prints all files (not just executables!) that match the
-    pattern on command line. Probably more useful in finding stuff
-    interactively than 'which', which only prints the first matching item.
-    
-    Also discovers and expands aliases, so you'll see what will be executed
-    when you call an alias.
-    
-    Example:
-    
-    [~]|62> %which d
-    d -> ls -F --color=auto
-      == c:\cygwin\bin\ls.exe
-    c:\cygwin\bin\d.exe
-    
-    [~]|64> %which diff*
-    diff3 -> diff3
-      == c:\cygwin\bin\diff3.exe
-    diff -> diff
-      == c:\cygwin\bin\diff.exe
-    c:\cygwin\bin\diff.exe
-    c:\cygwin\bin\diff3.exe
-
-    """
-    
-    which_alias(arg)
-
-    for e in which(arg):
-        print e
-    
-ip.define_magic("which",which_f)        
-        
diff --git a/IPython/quarantine/ipy_winpdb.py b/IPython/quarantine/ipy_winpdb.py
deleted file mode 100644
index 2150b17d6de..00000000000
--- a/IPython/quarantine/ipy_winpdb.py
+++ /dev/null
@@ -1,84 +0,0 @@
-""" Debug a script (like %run -d) in IPython process, Using WinPdb
-
-Usage:
-
-%wdb test.py
-    run test.py, with a winpdb breakpoint at start of the file 
-    
-%wdb pass
-    Change the password (e.g. if you have forgotten the old one)
-
-
-Notes
------
-
-**WARNING**: As of March 2009 (IPython 0.10), WinPdb has a known bug, which
-causes PyTables to become impossible to import if winpdb is loaded.  Therefore,
-if you need PyTables, do *not* use this extension.
-
-For more details: https://bugs.launchpad.net/ipython/+bug/249036
-"""
-
-import os
-
-from IPython.core import ipapi
-from IPython.core.error import UsageError
-import rpdb2
-
-ip = ipapi.get()
-
-rpdb_started = False
-
-def wdb_f(self, arg):
-    """ Debug a script (like %run -d) in IPython process, Using WinPdb
-    
-    Usage:
-    
-    %wdb test.py
-        run test.py, with a winpdb breakpoint at start of the file 
-        
-    %wdb pass
-        Change the password (e.g. if you have forgotten the old one)
-        
-    Note that after the script has been run, you need to do "Go" (f5) 
-    in WinPdb to resume normal IPython operation.
-    """
-
-    global rpdb_started
-    if not arg.strip():
-        print __doc__
-        return
-        
-    if arg.strip() == 'pass':
-        passwd = raw_input('Enter new winpdb session password: ')
-        ip.db['winpdb_pass'] = passwd
-        print "Winpdb password changed"
-        if rpdb_started:
-            print "You need to restart IPython to use the new password"
-        return 
-    
-    path = os.path.abspath(arg)
-    if not os.path.isfile(path):
-        raise UsageError("%%wdb: file %s does not exist" % path)
-    if not rpdb_started:
-        passwd = ip.db.get('winpdb_pass', None)
-        if passwd is None:
-            import textwrap
-            print textwrap.dedent("""\
-            Winpdb sessions need a password that you use for attaching the external
-            winpdb session. IPython will remember this. You can change the password later 
-            by '%wpdb pass'
-            """)
-            passwd = raw_input('Enter new winpdb session password: ')
-            ip.db['winpdb_pass'] = passwd
-            
-        print "Starting rpdb2 in IPython process"
-        rpdb2.start_embedded_debugger(passwd, timeout = 0)
-        rpdb_started = True
-        
-    rpdb2.set_temp_breakpoint(path)
-    print 'It is time to attach with WinPdb (launch WinPdb if needed, File -> Attach)'
-    ip.magic('%run ' + arg)
-    
-
-ip.define_magic('wdb', wdb_f)
diff --git a/IPython/quarantine/ipy_workdir.py b/IPython/quarantine/ipy_workdir.py
deleted file mode 100644
index 53d91055523..00000000000
--- a/IPython/quarantine/ipy_workdir.py
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/usr/bin/env python
-
-from IPython.core import ipapi
-ip = ipapi.get()
-
-import os, subprocess
-
-workdir = None
-def workdir_f(ip,line):
-    """ Exceute commands residing in cwd elsewhere 
-    
-    Example::
-      
-      workdir /myfiles
-      cd bin
-      workdir myscript.py 
-      
-    executes myscript.py (stored in bin, but not in path) in /myfiles
-    """
-    global workdir
-    dummy,cmd  = line.split(None,1)
-    if os.path.isdir(cmd):
-        workdir = os.path.abspath(cmd)
-        print "Set workdir",workdir
-    elif workdir is None:
-        print "Please set workdir first by doing e.g. 'workdir q:/'"
-    else:
-        sp = cmd.split(None,1)
-        if len(sp) == 1:
-            head, tail = cmd, ''
-        else:
-            head, tail = sp
-        if os.path.isfile(head):
-            cmd = os.path.abspath(head) + ' ' + tail
-        print "Execute command '" + cmd+ "' in",workdir
-        olddir = os.getcwd()
-        os.chdir(workdir)
-        try:
-            os.system(cmd)
-        finally:
-            os.chdir(olddir)
-
-ip.define_alias("workdir",workdir_f)
diff --git a/IPython/quarantine/jobctrl.py b/IPython/quarantine/jobctrl.py
deleted file mode 100644
index 7518a5288f3..00000000000
--- a/IPython/quarantine/jobctrl.py
+++ /dev/null
@@ -1,242 +0,0 @@
-""" Preliminary "job control" extensions for IPython 
-
-requires python 2.4 (or separate 'subprocess' module
-
-This provides 2 features, launching background jobs and killing foreground jobs from another IPython instance.
-
-Launching background jobs:
-
-    Usage:
-
-    [ipython]|2> import jobctrl
-    [ipython]|3> &ls
-             <3> <jobctrl.IpyPopen object at 0x00D87FD0>
-    [ipython]|4> _3.go
-    -----------> _3.go()
-    ChangeLog
-    IPython
-    MANIFEST.in
-    README
-    README_Windows.txt
-
-    ...
-
-Killing foreground tasks:
-
-Launch IPython instance, run a blocking command:
-
-    [Q:/ipython]|1> import jobctrl
-    [Q:/ipython]|2> cat
-
-Now launch a new IPython prompt and kill the process:
-
-    IPython 0.8.3.svn.r2919   [on Py 2.5]
-    [Q:/ipython]|1> import jobctrl
-    [Q:/ipython]|2> %tasks
-    6020: 'cat ' (Q:\ipython)
-    [Q:/ipython]|3> %kill
-    SUCCESS: The process with PID 6020 has been terminated.
-    [Q:/ipython]|4>
-
-(you don't need to specify PID for %kill if only one task is running)
-"""                     
-
-from subprocess import *
-import os,shlex,sys,time
-import threading,Queue
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext
-from IPython.utils.text import make_quoted_expr
-
-if os.name == 'nt':
-    def kill_process(pid):
-        os.system('taskkill /F /PID %d' % pid)
-else:
-    def kill_process(pid):
-        os.system('kill -9 %d' % pid)
-    
-    
-
-class IpyPopen(Popen):
-    def go(self):
-        print self.communicate()[0]
-    def __repr__(self):
-        return '<IPython job "%s" PID=%d>' % (self.line, self.pid)
-
-    def kill(self):
-        kill_process(self.pid)
-                  
-def startjob(job):
-    p = IpyPopen(shlex.split(job), stdout=PIPE, shell = False)
-    p.line = job
-    return p
-
-class AsyncJobQ(threading.Thread):
-    def __init__(self):
-        threading.Thread.__init__(self)
-        self.q = Queue.Queue()
-        self.output = []
-        self.stop = False
-    def run(self):
-        while 1:
-            cmd,cwd = self.q.get()
-            if self.stop:
-                self.output.append("** Discarding: '%s' - %s" % (cmd,cwd))
-                continue
-            self.output.append("** Task started: '%s' - %s" % (cmd,cwd))
-            
-            p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd = cwd)
-            out = p.stdout.read()
-            self.output.append("** Task complete: '%s'\n" % cmd)
-            self.output.append(out)
-
-    def add(self,cmd):
-        self.q.put_nowait((cmd, os.getcwd()))
-        
-    def dumpoutput(self):
-        while self.output:
-            item = self.output.pop(0)
-            print item            
-
-_jobq = None
-
-def jobqueue_f(self, line):
-     
-    global _jobq
-    if not _jobq:
-        print "Starting jobqueue - do '&some_long_lasting_system_command' to enqueue"
-        _jobq = AsyncJobQ()
-        _jobq.setDaemon(True)
-        _jobq.start()
-        ip.jobq = _jobq.add
-        return
-    if line.strip() == 'stop':
-        print "Stopping and clearing jobqueue, %jobqueue start to start again"
-        _jobq.stop = True
-        return
-    if line.strip() == 'start':
-        _jobq.stop = False
-        return
-        
-def jobctrl_prefilter_f(self,line):    
-    if line.startswith('&'):
-        pre,fn,rest = self.split_user_input(line[1:])
-        
-        line = ip.expand_aliases(fn,rest)
-        if not _jobq:
-            return 'get_ipython().startjob(%s)' % make_quoted_expr(line)
-        return 'get_ipython().jobq(%s)' % make_quoted_expr(line)
-
-    raise TryNext
-
-def jobq_output_hook(self):
-    if not _jobq:
-        return
-    _jobq.dumpoutput()
-
-
-
-def job_list(ip):
-    keys = ip.db.keys('tasks/*')
-    ents = [ip.db[k] for k in keys]
-    return ents
-
-def magic_tasks(self,line):
-    """ Show a list of tasks.
-
-    A 'task' is a process that has been started in IPython when 'jobctrl' extension is enabled.
-    Tasks can be killed with %kill.
-    
-    '%tasks clear' clears the task list (from stale tasks)
-    """
-    ip = self.getapi()
-    if line.strip() == 'clear':
-        for k in ip.db.keys('tasks/*'):
-            print "Clearing",ip.db[k]
-            del ip.db[k]
-        return
-        
-    ents = job_list(ip)
-    if not ents:
-        print "No tasks running"
-    for pid,cmd,cwd,t in ents:
-        dur = int(time.time()-t)
-        print "%d: '%s' (%s) %d:%02d" % (pid,cmd,cwd, dur / 60,dur%60)
-
-def magic_kill(self,line):
-    """ Kill a task
-
-    Without args, either kill one task (if only one running) or show list (if many)
-    With arg, assume it's the process id.
-
-    %kill is typically (much) more powerful than trying to terminate a process with ctrl+C.
-    """
-    ip = self.getapi()
-    jobs  = job_list(ip)
-
-    if not line.strip():
-        if len(jobs) == 1:
-            kill_process(jobs[0][0])
-        else:
-            magic_tasks(self,line)
-        return
-        
-    try:
-        pid = int(line)
-        kill_process(pid)
-    except ValueError:
-        magic_tasks(self,line)
-        
-if sys.platform == 'win32':
-    shell_internal_commands = 'break chcp cls copy ctty date del erase dir md mkdir path prompt rd rmdir start time type ver vol'.split()
-    PopenExc = WindowsError
-else:
-    # todo linux commands
-    shell_internal_commands = [] 
-    PopenExc = OSError
-
-
-def jobctrl_shellcmd(ip,cmd):
-    """ os.system replacement that stores process info to db['tasks/t1234'] """
-    cmd = cmd.strip()
-    cmdname = cmd.split(None,1)[0]
-    if cmdname in shell_internal_commands or '|' in cmd or '>' in cmd or '<' in cmd:
-        use_shell = True
-    else:
-        use_shell = False
-
-    jobentry = None
-    try:
-        try:
-            p = Popen(cmd,shell = use_shell)
-        except PopenExc :
-            if use_shell:
-                # try with os.system
-                os.system(cmd)
-                return
-            else:
-                # have to go via shell, sucks
-                p = Popen(cmd,shell = True)
-            
-        jobentry = 'tasks/t' + str(p.pid)
-        ip.db[jobentry] = (p.pid,cmd,os.getcwd(),time.time())
-        p.communicate()        
-
-    finally:
-        if jobentry:
-            del ip.db[jobentry]
-
-
-def install():
-    global ip
-    ip = ipapi.get()
-    # needed to make startjob visible as _ip.startjob('blah')
-    ip.startjob = startjob
-    ip.set_hook('input_prefilter', jobctrl_prefilter_f)
-    ip.set_hook('shell_hook', jobctrl_shellcmd)
-    ip.define_magic('kill',magic_kill)
-    ip.define_magic('tasks',magic_tasks)
-    ip.define_magic('jobqueue',jobqueue_f)
-    ip.set_hook('pre_prompt_hook', jobq_output_hook) 
-install()
diff --git a/IPython/quarantine/ledit.py b/IPython/quarantine/ledit.py
deleted file mode 100644
index fa309b1a10c..00000000000
--- a/IPython/quarantine/ledit.py
+++ /dev/null
@@ -1,98 +0,0 @@
-""" Fun magic line editor for ipython 
-
-Use this to easily edit lists of strings gradually without crafting long 
-list comprehensions.
-
-'l' is the magic variable name for every line (array element). Save the current 
-result (or more exactly, retrieve the last ipython computation result into
-%led work area) by running '%led s'. Just run '%led' to show the current work
-area data.
-
-Example use:
-
-[ipython]|25> setups = !ls *setup*.py
- ==
-['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
-[ipython]|26> setups
-         <26> ['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
-[ipython]|27> %led s
-Data set from last result (_)
-         <27> ['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
-[ipython]|28> %led upper
-cmd translated => l.upper()
-         <28> ['EGGSETUP.PY', 'SETUP.PY', 'SETUP_BDIST_EGG.PY']
-[ipython]|29> %led
-Magic line editor (for lists of strings)
-current data is:
-['eggsetup.py', 'setup.py', 'setup_bdist_egg.py']
-[ipython]|30> %led upper
-cmd translated => l.upper()
-         <30> ['EGGSETUP.PY', 'SETUP.PY', 'SETUP_BDIST_EGG.PY']
-[ipython]|31> %led s
-Data set from last result (_)
-         <31> ['EGGSETUP.PY', 'SETUP.PY', 'SETUP_BDIST_EGG.PY']
-[ipython]|32> %led "n:" + l
-         <32> ['n:EGGSETUP.PY', 'n:SETUP.PY', 'n:SETUP_BDIST_EGG.PY']
-[ipython]|33> %led s
-Data set from last result (_)
-         <33> ['n:EGGSETUP.PY', 'n:SETUP.PY', 'n:SETUP_BDIST_EGG.PY']
-[ipython]|34> %led l.
-l.__add__          l.__gt__           l.__reduce_ex__    l.endswith         l.join             l.rstrip
-l.__class__        l.__hash__         l.__repr__         l.expandtabs       l.ljust            l.split
-
-... (completions for string variable shown ) ...
-
-"""
-from IPython.core import ipapi
-import pprint
-ip = ipapi.get()
-
-curdata = []
-
-def line_edit_f(self, cmd ):
-    global curdata
-    
-    if not cmd:
-        
-        print "Magic line editor (for lists of strings)"
-        if curdata:
-            print "current data is:"
-            pprint.pprint(curdata)
-        else:
-            print "No current data, you should set it by running '%led s'"
-            print "When you have your data in _ (result of last computation)."
-        return
-        
-    if cmd == 's':
-        curdata = ip.ev('_')
-        print "Data set from last result (_)"
-        newlines = curdata
-        
-    else:
-        # simple method call, e.g. upper
-        if cmd.isalpha():
-            cmd = 'l.' + cmd + '()'
-            print "cmd translated =>",cmd
-
-        newlines = []
-        for l in curdata:
-            try:
-                l2 = eval(cmd)
-            except Exception,e:
-                print "Dropping exception",e,"on line:",l
-                continue
-            newlines.append(l2)
-
-    
-    return newlines
-
-def line_edit_complete_f(self,event):
-    """ Show all string methods in completions """
-    if event.symbol.startswith('l.'):
-        return ['l.' + func for func in dir('')]
-    
-    return dir('') + ['l.' + func for func in dir('')]
-
-ip.set_hook('complete_command', line_edit_complete_f , str_key = '%led')
-        
-ip.define_magic('led', line_edit_f)
\ No newline at end of file
diff --git a/IPython/quarantine/pspersistence.py b/IPython/quarantine/pspersistence.py
deleted file mode 100644
index dbba9169c7a..00000000000
--- a/IPython/quarantine/pspersistence.py
+++ /dev/null
@@ -1,183 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-%store magic for lightweight persistence.
-
-Stores variables, aliases etc. in PickleShare database.
-"""
-
-from IPython.core import ipapi
-from IPython.core.error import TryNext, UsageError
-ip = ipapi.get()
-
-import pickleshare
-
-import inspect,pickle,os,sys,textwrap
-from IPython.core.fakemodule import FakeModule
-
-def restore_aliases(self):
-    ip = self.getapi()
-    staliases = ip.db.get('stored_aliases', {})
-    for k,v in staliases.items():
-        #print "restore alias",k,v # dbg
-        #self.alias_table[k] = v
-        ip.define_alias(k,v)
-
-
-def refresh_variables(ip):
-    db = ip.db
-    for key in db.keys('autorestore/*'):
-        # strip autorestore
-        justkey = os.path.basename(key)
-        try:
-            obj = db[key]
-        except KeyError:
-            print "Unable to restore variable '%s', ignoring (use %%store -d to forget!)" % justkey
-            print "The error was:",sys.exc_info()[0]
-        else:
-            #print "restored",justkey,"=",obj #dbg
-            ip.user_ns[justkey] = obj
-    
-
-def restore_dhist(ip):
-    db = ip.db
-    ip.user_ns['_dh'] = db.get('dhist',[])
-    
-def restore_data(self):
-    ip = self.getapi()
-    refresh_variables(ip)
-    restore_aliases(self)
-    restore_dhist(self)
-    raise TryNext
-    
-ip.set_hook('late_startup_hook', restore_data)
-
-def magic_store(self, parameter_s=''):
-    """Lightweight persistence for python variables.
-
-    Example:
-    
-    ville@badger[~]|1> A = ['hello',10,'world']\\
-    ville@badger[~]|2> %store A\\
-    ville@badger[~]|3> Exit
-    
-    (IPython session is closed and started again...)
-    
-    ville@badger:~$ ipython -p pysh\\
-    ville@badger[~]|1> print A
-    
-    ['hello', 10, 'world']
-    
-    Usage:
-    
-    %store          - Show list of all variables and their current values\\
-    %store <var>    - Store the *current* value of the variable to disk\\
-    %store -d <var> - Remove the variable and its value from storage\\
-    %store -z       - Remove all variables from storage\\
-    %store -r       - Refresh all variables from store (delete current vals)\\
-    %store foo >a.txt  - Store value of foo to new file a.txt\\
-    %store foo >>a.txt - Append value of foo to file a.txt\\   
-    
-    It should be noted that if you change the value of a variable, you
-    need to %store it again if you want to persist the new value.
-    
-    Note also that the variables will need to be pickleable; most basic
-    python types can be safely %stored.
-    
-    Also aliases can be %store'd across sessions.
-    """
-    
-    opts,argsl = self.parse_options(parameter_s,'drz',mode='string')
-    args = argsl.split(None,1)
-    ip = self.getapi()
-    db = ip.db
-    # delete
-    if opts.has_key('d'):
-        try:
-            todel = args[0]
-        except IndexError:
-            raise UsageError('You must provide the variable to forget')
-        else:
-            try:
-                del db['autorestore/' + todel]
-            except:
-                raise UsageError("Can't delete variable '%s'" % todel)
-    # reset
-    elif opts.has_key('z'):
-        for k in db.keys('autorestore/*'):
-            del db[k]
-
-    elif opts.has_key('r'):
-        refresh_variables(ip)
-
-    
-    # run without arguments -> list variables & values
-    elif not args:
-        vars = self.db.keys('autorestore/*')
-        vars.sort()            
-        if vars:
-            size = max(map(len,vars))
-        else:
-            size = 0
-            
-        print 'Stored variables and their in-db values:'
-        fmt = '%-'+str(size)+'s -> %s'
-        get = db.get
-        for var in vars:
-            justkey = os.path.basename(var)
-            # print 30 first characters from every var
-            print fmt % (justkey,repr(get(var,'<unavailable>'))[:50])
-    
-    # default action - store the variable
-    else:
-        # %store foo >file.txt or >>file.txt
-        if len(args) > 1 and args[1].startswith('>'):
-            fnam = os.path.expanduser(args[1].lstrip('>').lstrip())
-            if args[1].startswith('>>'):
-                fil = open(fnam,'a')
-            else:
-                fil = open(fnam,'w')
-            obj = ip.ev(args[0])
-            print "Writing '%s' (%s) to file '%s'." % (args[0],
-              obj.__class__.__name__, fnam)
-
-            
-            if not isinstance (obj,basestring):
-                from pprint import pprint
-                pprint(obj,fil)
-            else:
-                fil.write(obj)
-                if not obj.endswith('\n'):
-                    fil.write('\n')
-            
-            fil.close()
-            return
-        
-        # %store foo
-        try:
-            obj = ip.user_ns[args[0]]
-        except KeyError:
-            # it might be an alias
-            # This needs to be refactored to use the new AliasManager stuff.
-            if args[0] in self.alias_table:
-                staliases = db.get('stored_aliases',{})
-                staliases[ args[0] ] = self.alias_table[ args[0] ]
-                db['stored_aliases'] = staliases                
-                print "Alias stored:", args[0], self.alias_table[ args[0] ]
-                return
-            else:
-                raise UsageError("Unknown variable '%s'" % args[0])
-            
-        else:
-            if isinstance(inspect.getmodule(obj), FakeModule):
-                print textwrap.dedent("""\
-                Warning:%s is %s 
-                Proper storage of interactively declared classes (or instances
-                of those classes) is not possible! Only instances
-                of classes in real modules on file system can be %%store'd.
-                """ % (args[0], obj) ) 
-                return
-            #pickled = pickle.dumps(obj)
-            self.db[ 'autorestore/' + args[0] ] = obj
-            print "Stored '%s' (%s)" % (args[0], obj.__class__.__name__)
-
-ip.define_magic('store',magic_store)
diff --git a/IPython/quarantine/tests/__init__.py b/IPython/quarantine/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/quarantine/win32clip.py b/IPython/quarantine/win32clip.py
deleted file mode 100644
index 8c836a037db..00000000000
--- a/IPython/quarantine/win32clip.py
+++ /dev/null
@@ -1,45 +0,0 @@
-from IPython.core import ipapi
-
-ip = ipapi.get()
-
-def clip_f( self, parameter_s = '' ):
-    """Save a set of lines to the clipboard.
-
-    Usage:\\
-      %clip n1-n2 n3-n4 ... n5 .. n6 ...
-
-    This function uses the same syntax as %macro for line extraction, but
-    instead of creating a macro it saves the resulting string to the
-    clipboard.
-    
-    When used without arguments, this returns the text contents of the clipboard. 
-    E.g.
-    
-    mytext = %clip
-    
-    """
-
-    import win32clipboard as cl
-    import win32con
-    args = parameter_s.split()
-    cl.OpenClipboard()
-    if len( args ) == 0:
-        data = cl.GetClipboardData( win32con.CF_TEXT )
-        cl.CloseClipboard()
-        return data
-    api = self.getapi()
-    
-    if parameter_s.lstrip().startswith('='):
-        rest = parameter_s[parameter_s.index('=')+1:].strip()
-        val = str(api.ev(rest))
-    else:
-        ranges = args[0:]
-        val = ''.join( self.extract_input_slices( ranges ) )
-
-    cl.EmptyClipboard()
-    cl.SetClipboardText( val )
-    cl.CloseClipboard()
-    print 'The following text was written to the clipboard'
-    print val
-    
-ip.define_magic( "clip", clip_f )
diff --git a/IPython/scripts/__init__.py b/IPython/scripts/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/scripts/iptest b/IPython/scripts/iptest
deleted file mode 100755
index 9d4b6da6450..00000000000
--- a/IPython/scripts/iptest
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""IPython Test Suite Runner.
-"""
-
-# The tests can't even run if nose isn't available, so might as well  give the
-# user a civilized error message in that case.
-
-try:
-    import nose
-except ImportError:
-    error = """\
-ERROR: The IPython test suite requires nose to run.
-
-Please install nose on your system first and try again.
-For information on installing nose, see:
-http://somethingaboutorange.com/mrl/projects/nose
-
-Exiting."""
-    import sys
-    print >> sys.stderr, error
-else:
-    from IPython.testing import iptest
-    iptest.main()
diff --git a/IPython/scripts/ipython b/IPython/scripts/ipython
deleted file mode 100755
index 20095a8ba41..00000000000
--- a/IPython/scripts/ipython
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env python
-"""Terminal-based IPython entry point.
-
-Note: this is identical to IPython/frontend/terminal/scripts/ipython for now.
-Once 0.11 is closer to release, we will likely need to reorganize the script
-entry points."""
-
-from IPython.frontend.terminal.ipapp import launch_new_instance
-
-launch_new_instance()
diff --git a/IPython/scripts/ipython-qtconsole b/IPython/scripts/ipython-qtconsole
deleted file mode 100755
index b2970cd4f06..00000000000
--- a/IPython/scripts/ipython-qtconsole
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from IPython.frontend.qt.console.ipythonqt import main
-
-main()
diff --git a/IPython/scripts/irunner b/IPython/scripts/irunner
deleted file mode 100755
index 9406e27ef5b..00000000000
--- a/IPython/scripts/irunner
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/usr/bin/env python
-
-"""Thin wrapper around the IPython irunner module.
-
-Run with --help for details, or see the irunner source."""
-
-from IPython.lib import irunner
-
-irunner.main()
diff --git a/IPython/scripts/pycolor b/IPython/scripts/pycolor
deleted file mode 100755
index 8ad2267563e..00000000000
--- a/IPython/scripts/pycolor
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""Simple wrapper around PyColorize, which colorizes python sources."""
-
-import IPython.utils.PyColorize
-IPython.utils.PyColorize.main()
diff --git a/IPython/config/tests/__init__.py b/IPython/sphinxext/__init__.py
similarity index 100%
rename from IPython/config/tests/__init__.py
rename to IPython/sphinxext/__init__.py
diff --git a/IPython/sphinxext/custom_doctests.py b/IPython/sphinxext/custom_doctests.py
new file mode 100644
index 00000000000..f0ea034a6db
--- /dev/null
+++ b/IPython/sphinxext/custom_doctests.py
@@ -0,0 +1,155 @@
+"""
+Handlers for IPythonDirective's @doctest pseudo-decorator.
+
+The Sphinx extension that provides support for embedded IPython code provides
+a pseudo-decorator @doctest, which treats the input/output block as a
+doctest, raising a RuntimeError during doc generation if the actual output
+(after running the input) does not match the expected output.
+
+An example usage is:
+
+.. code-block:: rst
+
+   .. ipython::
+
+        In [1]: x = 1
+
+        @doctest
+        In [2]: x + 2
+        Out[3]: 3
+
+One can also provide arguments to the decorator. The first argument should be
+the name of a custom handler. The specification of any other arguments is
+determined by the handler. For example,
+
+.. code-block:: rst
+
+      .. ipython::
+
+         @doctest float
+         In [154]: 0.1 + 0.2
+         Out[154]: 0.3
+
+allows the actual output ``0.30000000000000004`` to match the expected output
+due to a comparison with `np.allclose`.
+
+This module contains handlers for the @doctest pseudo-decorator. Handlers
+should have the following function signature::
+
+    handler(sphinx_shell, args, input_lines, found, submitted)
+
+where `sphinx_shell` is the embedded Sphinx shell, `args` contains the list
+of arguments that follow: '@doctest handler_name', `input_lines` contains
+a list of the lines relevant to the current doctest, `found` is a string
+containing the output from the IPython shell, and `submitted` is a string
+containing the expected output from the IPython shell.
+
+Handlers must be registered in the `doctests` dict at the end of this module.
+
+"""
+
+def str_to_array(s):
+    """
+    Simplistic converter of strings from repr to float NumPy arrays.
+
+    If the repr representation has ellipsis in it, then this will fail.
+
+    Parameters
+    ----------
+    s : str
+        The repr version of a NumPy array.
+
+    Examples
+    --------
+    >>> s = "array([ 0.3,  inf,  nan])"
+    >>> a = str_to_array(s)
+
+    """
+    import numpy as np
+
+    # Need to make sure eval() knows about inf and nan.
+    # This also assumes default printoptions for NumPy.
+    from numpy import inf, nan
+
+    if s.startswith(u'array'):
+        # Remove array( and )
+        s = s[6:-1]
+
+    if s.startswith(u'['):
+        a = np.array(eval(s), dtype=float)
+    else:
+        # Assume its a regular float. Force 1D so we can index into it.
+        a = np.atleast_1d(float(s))
+    return a
+
+def float_doctest(sphinx_shell, args, input_lines, found, submitted):
+    """
+    Doctest which allow the submitted output to vary slightly from the input.
+
+    Here is how it might appear in an rst file:
+
+    .. code-block:: rst
+
+       .. ipython::
+
+          @doctest float
+          In [1]: 0.1 + 0.2
+          Out[1]: 0.3
+
+    """
+    import numpy as np
+
+    if len(args) == 2:
+        rtol = 1e-05
+        atol = 1e-08
+    else:
+        # Both must be specified if any are specified.
+        try:
+            rtol = float(args[2])
+            atol = float(args[3])
+        except IndexError:
+            e = ("Both `rtol` and `atol` must be specified "
+                 "if either are specified: {0}".format(args))
+            raise IndexError(e) from e
+
+    try:
+        submitted = str_to_array(submitted)
+        found = str_to_array(found)
+    except:
+        # For example, if the array is huge and there are ellipsis in it.
+        error = True
+    else:
+        found_isnan = np.isnan(found)
+        submitted_isnan = np.isnan(submitted)
+        error = not np.allclose(found_isnan, submitted_isnan)
+        error |= not np.allclose(found[~found_isnan],
+                                 submitted[~submitted_isnan],
+                                 rtol=rtol, atol=atol)
+
+    TAB = ' ' * 4
+    directive = sphinx_shell.directive
+    if directive is None:
+        source = 'Unavailable'
+        content = 'Unavailable'
+    else:
+        source = directive.state.document.current_source
+        # Add tabs and make into a single string.
+        content = '\n'.join([TAB + line for line in directive.content])
+
+    if error:
+
+        e = ('doctest float comparison failure\n\n'
+             'Document source: {0}\n\n'
+             'Raw content: \n{1}\n\n'
+             'On input line(s):\n{TAB}{2}\n\n'
+             'we found output:\n{TAB}{3}\n\n'
+             'instead of the expected:\n{TAB}{4}\n\n')
+        e = e.format(source, content, '\n'.join(input_lines), repr(found),
+                     repr(submitted), TAB=TAB)
+        raise RuntimeError(e)
+
+# dict of allowable doctest handlers. The key represents the first argument
+# that must be given to @doctest in order to activate the handler.
+doctests = {
+    'float': float_doctest,
+}
diff --git a/IPython/sphinxext/ipython_console_highlighting.py b/IPython/sphinxext/ipython_console_highlighting.py
new file mode 100644
index 00000000000..b046467f5fc
--- /dev/null
+++ b/IPython/sphinxext/ipython_console_highlighting.py
@@ -0,0 +1,28 @@
+"""
+reST directive for syntax-highlighting ipython interactive sessions.
+
+"""
+
+from sphinx import highlighting
+from ipython_pygments_lexers import IPyLexer
+
+
+def setup(app):
+    """Setup as a sphinx extension."""
+
+    # This is only a lexer, so adding it below to pygments appears sufficient.
+    # But if somebody knows what the right API usage should be to do that via
+    # sphinx, by all means fix it here.  At least having this setup.py
+    # suppresses the sphinx warning we'd get without it.
+    metadata = {"parallel_read_safe": True, "parallel_write_safe": True}
+    return metadata
+
+
+# Register the extension as a valid pygments lexer.
+# Alternatively, we could register the lexer with pygments instead. This would
+# require using setuptools entrypoints: http://pygments.org/docs/plugins
+
+ipy3 = IPyLexer()
+
+highlighting.lexers["ipython"] = ipy3
+highlighting.lexers["ipython3"] = ipy3
diff --git a/IPython/sphinxext/ipython_directive.py b/IPython/sphinxext/ipython_directive.py
new file mode 100644
index 00000000000..0fdc70cab5c
--- /dev/null
+++ b/IPython/sphinxext/ipython_directive.py
@@ -0,0 +1,1278 @@
+# -*- coding: utf-8 -*-
+"""
+Sphinx directive to support embedded IPython code.
+
+IPython provides an extension for `Sphinx <http://www.sphinx-doc.org/>`_ to
+highlight and run code.
+
+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. 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.
+
+Here is an example of how the IPython directive can
+**run** python code, at build time.
+
+.. ipython::
+
+   In [1]: 1+1
+
+   In [1]: import datetime
+      ...: datetime.date.fromisoformat('2022-02-22')
+
+It supports IPython construct that plain
+Python does not understand (like magics):
+
+.. ipython::
+
+   In [0]: import time
+
+   In [0]: %pdoc time.sleep
+
+This will also support top-level async when using IPython 7.0+
+
+.. ipython::
+
+   In [2]: import asyncio
+      ...: print('before')
+      ...: await asyncio.sleep(1)
+      ...: print('after')
+
+
+The namespace will persist across multiple code chucks, Let's define a variable:
+
+.. ipython::
+
+   In [0]: who = "World"
+
+And now say hello:
+
+.. ipython::
+
+   In [0]: print('Hello,', who)
+
+If the current section raises an exception, you can add the ``:okexcept:`` flag
+to the current block, otherwise the build will fail.
+
+.. ipython::
+   :okexcept:
+
+   In [1]: 1/0
+
+IPython Sphinx directive module
+===============================
+
+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). For example, to enable syntax highlighting
+and the IPython directive::
+
+    extensions = ['IPython.sphinxext.ipython_console_highlighting',
+                  'IPython.sphinxext.ipython_directive']
+
+The IPython directive outputs code-blocks with the language 'ipython'. So
+if you do not have the syntax highlighting extension enabled as well, then
+all rendered code-blocks will be uncolored. By default this directive assumes
+that your prompts are unchanged IPython ones, 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_warning_is_error: [default to True]
+    Fail the build if something unexpected happen, for example if a block raise
+    an exception but does not have the `:okexcept:` flag. The exact behavior of
+    what is considered strict, may change between the sphinx directive version.
+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.
+ipython_mplbackend:
+    The string which specifies if the embedded Sphinx shell should import
+    Matplotlib and set the backend. The value specifies a backend that is
+    passed to `matplotlib.use()` before any lines in `ipython_execlines` are
+    executed. If not specified in conf.py, then the default value of 'agg' is
+    used. To use the IPython directive without matplotlib as a dependency, set
+    the value to `None`. It may end up that matplotlib is still imported
+    if the user specifies so in `ipython_execlines` or makes use of the
+    @savefig pseudo decorator.
+ipython_execlines:
+    A list of strings to be exec'd in the embedded Sphinx shell. Typical
+    usage is to make certain packages always available. Set this to an empty
+    list if you wish to have no imports always available. If specified in
+    ``conf.py`` as `None`, then it has the effect of making no imports available.
+    If omitted from conf.py altogether, then the default value of
+    ['import numpy as np', 'import matplotlib.pyplot as plt'] is used.
+ipython_holdcount
+    When the @suppress pseudo-decorator is used, the execution count can be
+    incremented or not. The default behavior is to hold the execution count,
+    corresponding to a value of `True`. Set this to `False` to increment
+    the execution count after each suppressed command.
+
+As an example, to use the IPython directive when `matplotlib` is not available,
+one sets the backend to `None`::
+
+    ipython_mplbackend = None
+
+An example usage of the directive is:
+
+.. code-block:: rst
+
+    .. ipython::
+
+        In [1]: x = 1
+
+        In [2]: y = x**2
+
+        In [3]: print(y)
+
+See http://matplotlib.org/sampledoc/ipython_directive.html for additional
+documentation.
+
+Pseudo-Decorators
+=================
+
+Note: Only one decorator is supported per input. If more than one decorator
+is specified, then only the last one is used.
+
+In addition to the Pseudo-Decorators/options described at the above link,
+several enhancements have been made. The directive will emit a message to the
+console at build-time if code-execution resulted in an exception or warning.
+You can suppress these on a per-block basis by specifying the :okexcept:
+or :okwarning: options:
+
+.. code-block:: rst
+
+    .. ipython::
+        :okexcept:
+        :okwarning:
+
+        In [1]: 1/0
+        In [2]: # raise warning.
+
+To Do
+=====
+
+- Turn the ad-hoc test() function into a real test suite.
+- Break up ipython-specific functionality from matplotlib stuff into better
+  separated code.
+
+"""
+
+# Authors
+# =======
+#
+# - John D Hunter: original 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
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib
+import atexit
+import errno
+import os
+import pathlib
+import re
+import sys
+import tempfile
+import ast
+import warnings
+import shutil
+from io import StringIO
+from typing import Any, Dict, Set
+
+# Third-party
+from docutils.parsers.rst import directives
+from docutils.parsers.rst import Directive
+from sphinx.util import logging
+
+# Our own
+from traitlets.config import Config
+from IPython import InteractiveShell
+from IPython.core.profiledir import ProfileDir
+
+use_matplotlib = False
+try:
+    import matplotlib
+    use_matplotlib = True
+except Exception:
+    pass
+
+#-----------------------------------------------------------------------------
+# Globals
+#-----------------------------------------------------------------------------
+# for tokenizing blocks
+COMMENT, INPUT, OUTPUT =  range(3)
+
+PSEUDO_DECORATORS = ["suppress", "verbatim", "savefig", "doctest"]
+
+#-----------------------------------------------------------------------------
+# Functions and class declarations
+#-----------------------------------------------------------------------------
+
+def block_parser(part, rgxin, rgxout, fmtin, fmtout):
+    """
+    part is a string of ipython text, comprised of at most one
+    input, one output, comments, and blank lines.  The block parser
+    parses the text into a list of::
+
+      blocks = [ (TOKEN0, data0), (TOKEN1, data1), ...]
+
+    where TOKEN is one of [COMMENT | INPUT | OUTPUT ] and
+    data is, depending on the type of token::
+
+      COMMENT : the comment string
+
+      INPUT: the (DECORATOR, INPUT_LINE, REST) where
+         DECORATOR: the input decorator (or None)
+         INPUT_LINE: the input as string (possibly multi-line)
+         REST : any stdout generated by the input line (not OUTPUT)
+
+      OUTPUT: the output string, possibly multi-line
+
+    """
+    block = []
+    lines = part.split('\n')
+    N = len(lines)
+    i = 0
+    decorator = None
+    while 1:
+
+        if i==N:
+            # nothing left to parse -- the last line
+            break
+
+        line = lines[i]
+        i += 1
+        line_stripped = line.strip()
+        if line_stripped.startswith('#'):
+            block.append((COMMENT, line))
+            continue
+
+        if any(
+            line_stripped.startswith("@" + pseudo_decorator)
+            for pseudo_decorator in PSEUDO_DECORATORS
+        ):
+            if decorator:
+                raise RuntimeError(
+                    "Applying multiple pseudo-decorators on one line is not supported"
+                )
+            else:
+                decorator = line_stripped
+                continue
+
+        # does this look like an input line?
+        matchin = rgxin.match(line)
+        if matchin:
+            lineno, inputline = int(matchin.group(1)), matchin.group(2)
+
+            # the ....: continuation string
+            continuation = '   %s:'%''.join(['.']*(len(str(lineno))+2))
+            Nc = len(continuation)
+            # input lines can continue on for more than one line, if
+            # we have a '\' line continuation char or a function call
+            # echo line 'print'.  The input line can only be
+            # terminated by the end of the block or an output line, so
+            # we parse out the rest of the input line if it is
+            # multiline as well as any echo text
+
+            rest = []
+            while i<N:
+
+                # look ahead; if the next line is blank, or a comment, or
+                # an output line, we're done
+
+                nextline = lines[i]
+                matchout = rgxout.match(nextline)
+                # print("nextline=%s, continuation=%s, starts=%s"%(nextline, continuation, nextline.startswith(continuation)))
+                if matchout or nextline.startswith('#'):
+                    break
+                elif nextline.startswith(continuation):
+                    # The default ipython_rgx* treat the space following the colon as optional.
+                    # However, If the space is there we must consume it or code
+                    # employing the cython_magic extension will fail to execute.
+                    #
+                    # This works with the default ipython_rgx* patterns,
+                    # If you modify them, YMMV.
+                    nextline = nextline[Nc:]
+                    if nextline and nextline[0] == ' ':
+                        nextline = nextline[1:]
+
+                    inputline += '\n' +  nextline
+                else:
+                    rest.append(nextline)
+                i+= 1
+
+            block.append((INPUT, (decorator, inputline, '\n'.join(rest))))
+            continue
+
+        # if it looks like an output line grab all the text to the end
+        # of the block
+        matchout = rgxout.match(line)
+        if matchout:
+            lineno, output = int(matchout.group(1)), matchout.group(2)
+            if i<N-1:
+                output = '\n'.join([output] + lines[i:])
+
+            block.append((OUTPUT, output))
+            break
+
+    return block
+
+
+class EmbeddedSphinxShell:
+    """An embedded IPython instance to run inside Sphinx"""
+
+    def __init__(self, exec_lines=None):
+
+        self.cout = StringIO()
+
+        if exec_lines is None:
+            exec_lines = []
+
+        # Create config object for IPython
+        config = Config()
+        config.HistoryManager.hist_file = ':memory:'
+        config.InteractiveShell.autocall = False
+        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 global ipython, but don't start its mainloop.
+        # This will persist across different EmbeddedSphinxShell instances.
+        IP = InteractiveShell.instance(config=config, profile_dir=profile)
+        atexit.register(self.cleanup)
+
+        # 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 = ''
+        self.tmp_profile_dir = tmp_profile_dir
+
+        self.is_verbatim = False
+        self.is_doctest = False
+        self.is_suppress = False
+
+        # Optionally, provide more detailed information to shell.
+        # this is assigned by the SetUp method of IPythonDirective
+        # to point at itself.
+        #
+        # So, you can access handy things at self.directive.state
+        self.directive = None
+
+        # on the first call to the savefig decorator, we'll import
+        # pyplot as plt so we can make a call to the plt.gcf().savefig
+        self._pyplot_imported = False
+
+        # Prepopulate the namespace.
+        for line in exec_lines:
+            self.process_input_line(line, store_history=False)
+
+    def cleanup(self):
+        shutil.rmtree(self.tmp_profile_dir, ignore_errors=True)
+
+    def clear_cout(self):
+        self.cout.seek(0)
+        self.cout.truncate(0)
+
+    def process_input_line(self, line, store_history):
+        return self.process_input_lines([line], store_history=store_history)
+
+    def process_input_lines(self, lines, store_history=True):
+        """process the input, capturing stdout"""
+        stdout = sys.stdout
+        source_raw = '\n'.join(lines)
+        try:
+            sys.stdout = self.cout
+            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
+        # as absolute path for Sphinx
+        # sphinx expects a posix path, even on Windows
+        path = pathlib.Path(savefig_dir, filename)
+        outfile = '/' + path.relative_to(source_dir).as_posix()
+
+        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
+
+        is_verbatim = decorator=='@verbatim' or self.is_verbatim
+        is_doctest = (decorator is not None and \
+                     decorator.startswith('@doctest')) or self.is_doctest
+        is_suppress = decorator=='@suppress' or self.is_suppress
+        is_okexcept = decorator=='@okexcept' or self.is_okexcept
+        is_okwarning = decorator=='@okwarning' or self.is_okwarning
+        is_savefig = decorator is not None and \
+                     decorator.startswith('@savefig')
+
+        input_lines = input.split('\n')
+        if len(input_lines) > 1:
+            if input_lines[-1] != "":
+                input_lines.append('') # make sure there's a blank line
+                                       # so splitter buffer gets reset
+
+        continuation = '   %s:'%''.join(['.']*(len(str(lineno))+2))
+
+        if is_savefig:
+            image_file, image_directive = self.process_image(decorator)
+
+        ret = []
+        is_semicolon = False
+
+        # Hold the execution count, if requested to do so.
+        if is_suppress and self.hold_count:
+            store_history = False
+        else:
+            store_history = True
+
+        # Note: catch_warnings is not thread safe
+        with warnings.catch_warnings(record=True) as ws:
+            if input_lines[0].endswith(';'):
+                is_semicolon = True
+            #for i, line in enumerate(input_lines):
+
+            # process the first input line
+            if is_verbatim:
+                self.process_input_lines([''])
+                self.IP.execution_count += 1 # increment it anyway
+            else:
+                # only submit the line in non-verbatim mode
+                self.process_input_lines(input_lines, store_history=store_history)
+
+        if not is_suppress:
+            for i, line in enumerate(input_lines):
+                if i == 0:
+                    formatted_line = '%s %s'%(input_prompt, line)
+                else:
+                    formatted_line = '%s %s'%(continuation, line)
+                ret.append(formatted_line)
+
+        if not is_suppress and len(rest.strip()) and is_verbatim:
+            # The "rest" is the standard output of the input. This needs to be
+            # added when in verbatim mode. If there is no "rest", then we don't
+            # add it, as the new line will be added by the processed output.
+            ret.append(rest)
+
+        # Fetch the processed output. (This is not the submitted output.)
+        self.cout.seek(0)
+        processed_output = self.cout.read()
+        if not is_suppress and not is_semicolon:
+            #
+            # In IPythonDirective.run, the elements of `ret` are eventually
+            # combined such that '' entries correspond to newlines. So if
+            # `processed_output` is equal to '', then the adding it to `ret`
+            # ensures that there is a blank line between consecutive inputs
+            # that have no outputs, as in:
+            #
+            #    In [1]: x = 4
+            #
+            #    In [2]: x = 5
+            #
+            # When there is processed output, it has a '\n' at the tail end. So
+            # adding the output to `ret` will provide the necessary spacing
+            # between consecutive input/output blocks, as in:
+            #
+            #   In [1]: x
+            #   Out[1]: 5
+            #
+            #   In [2]: x
+            #   Out[2]: 5
+            #
+            # When there is stdout from the input, it also has a '\n' at the
+            # tail end, and so this ensures proper spacing as well. E.g.:
+            #
+            #   In [1]: print(x)
+            #   5
+            #
+            #   In [2]: x = 5
+            #
+            # When in verbatim mode, `processed_output` is empty (because
+            # nothing was passed to IP. Sometimes the submitted code block has
+            # an Out[] portion and sometimes it does not. When it does not, we
+            # need to ensure proper spacing, so we have to add '' to `ret`.
+            # However, if there is an Out[] in the submitted code, then we do
+            # not want to add a newline as `process_output` has stuff to add.
+            # The difficulty is that `process_input` doesn't know if
+            # `process_output` will be called---so it doesn't know if there is
+            # Out[] in the code block. The requires that we include a hack in
+            # `process_block`. See the comments there.
+            #
+            ret.append(processed_output)
+        elif is_semicolon:
+            # Make sure there is a newline after the semicolon.
+            ret.append('')
+
+        # context information
+        filename = "Unknown"
+        lineno = 0
+        if self.directive.state:
+            filename = self.directive.state.document.current_source
+            lineno = self.directive.state.document.current_line
+
+        # Use sphinx logger for warnings
+        logger = logging.getLogger(__name__)
+
+        # output any exceptions raised during execution to stdout
+        # unless :okexcept: has been specified.
+        if not is_okexcept and (
+            ("Traceback" in processed_output) or ("SyntaxError" in processed_output)
+        ):
+            s = "\n>>>" + ("-" * 73) + "\n"
+            s += "Exception in %s at block ending on line %s\n" % (filename, lineno)
+            s += "Specify :okexcept: as an option in the ipython:: block to suppress this message\n"
+            s += processed_output + "\n"
+            s += "<<<" + ("-" * 73)
+            logger.warning(s)
+            if self.warning_is_error:
+                raise RuntimeError(
+                    "Unexpected exception in `{}` line {}".format(filename, lineno)
+                )
+
+        # output any warning raised during execution to stdout
+        # unless :okwarning: has been specified.
+        if not is_okwarning:
+            for w in ws:
+                s = "\n>>>" + ("-" * 73) + "\n"
+                s += "Warning in %s at block ending on line %s\n" % (filename, lineno)
+                s += "Specify :okwarning: as an option in the ipython:: block to suppress this message\n"
+                s += ("-" * 76) + "\n"
+                s += warnings.formatwarning(
+                    w.message, w.category, w.filename, w.lineno, w.line
+                )
+                s += "<<<" + ("-" * 73)
+                logger.warning(s)
+                if self.warning_is_error:
+                    raise RuntimeError(
+                        "Unexpected warning in `{}` line {}".format(filename, lineno)
+                    )
+
+        self.clear_cout()
+        return (ret, input_lines, processed_output,
+                is_doctest, decorator, image_file, image_directive)
+
+
+    def process_output(self, data, output_prompt, input_lines, output,
+                       is_doctest, decorator, image_file):
+        """
+        Process data block for OUTPUT token.
+
+        """
+        # Recall: `data` is the submitted output, and `output` is the processed
+        # output from `input_lines`.
+
+        TAB = ' ' * 4
+
+        if is_doctest and output is not None:
+
+            found = output # This is the processed output
+            found = found.strip()
+            submitted = data.strip()
+
+            if self.directive is None:
+                source = 'Unavailable'
+                content = 'Unavailable'
+            else:
+                source = self.directive.state.document.current_source
+                content = self.directive.content
+                # Add tabs and join into a single string.
+                content = '\n'.join([TAB + line for line in content])
+
+            # Make sure the output contains the output prompt.
+            ind = found.find(output_prompt)
+            if ind < 0:
+                e = ('output does not contain output prompt\n\n'
+                     'Document source: {0}\n\n'
+                     'Raw content: \n{1}\n\n'
+                     'Input line(s):\n{TAB}{2}\n\n'
+                     'Output line(s):\n{TAB}{3}\n\n')
+                e = e.format(source, content, '\n'.join(input_lines),
+                             repr(found), TAB=TAB)
+                raise RuntimeError(e)
+            found = found[len(output_prompt):].strip()
+
+            # Handle the actual doctest comparison.
+            if decorator.strip() == '@doctest':
+                # Standard doctest
+                if found != submitted:
+                    e = ('doctest failure\n\n'
+                         'Document source: {0}\n\n'
+                         'Raw content: \n{1}\n\n'
+                         'On input line(s):\n{TAB}{2}\n\n'
+                         'we found output:\n{TAB}{3}\n\n'
+                         'instead of the expected:\n{TAB}{4}\n\n')
+                    e = e.format(source, content, '\n'.join(input_lines),
+                                 repr(found), repr(submitted), TAB=TAB)
+                    raise RuntimeError(e)
+            else:
+                self.custom_doctest(decorator, input_lines, found, submitted)
+
+        # When in verbatim mode, this holds additional submitted output
+        # to be written in the final Sphinx output.
+        # https://github.com/ipython/ipython/issues/5776
+        out_data = []
+
+        is_verbatim = decorator=='@verbatim' or self.is_verbatim
+        if is_verbatim and data.strip():
+            # Note that `ret` in `process_block` has '' as its last element if
+            # the code block was in verbatim mode. So if there is no submitted
+            # output, then we will have proper spacing only if we do not add
+            # an additional '' to `out_data`. This is why we condition on
+            # `and data.strip()`.
+
+            # The submitted output has no output prompt. If we want the
+            # prompt and the code to appear, we need to join them now
+            # instead of adding them separately---as this would create an
+            # undesired newline. How we do this ultimately depends on the
+            # format of the output regex. I'll do what works for the default
+            # prompt for now, and we might have to adjust if it doesn't work
+            # in other cases. Finally, the submitted output does not have
+            # a trailing newline, so we must add it manually.
+            out_data.append("{0} {1}\n".format(output_prompt, data))
+
+        return out_data
+
+    def process_comment(self, data):
+        """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
+
+        input_prompt = self.promptin % lineno
+        output_prompt = self.promptout % lineno
+        image_file = None
+        image_directive = None
+
+        found_input = False
+        for token, data in block:
+            if token == COMMENT:
+                out_data = self.process_comment(data)
+            elif token == INPUT:
+                found_input = True
+                (out_data, input_lines, output, is_doctest,
+                 decorator, image_file, image_directive) = \
+                          self.process_input(data, input_prompt, lineno)
+            elif token == OUTPUT:
+                if not found_input:
+
+                    TAB = ' ' * 4
+                    linenumber = 0
+                    source = 'Unavailable'
+                    content = 'Unavailable'
+                    if self.directive:
+                        linenumber = self.directive.state.document.current_line
+                        source = self.directive.state.document.current_source
+                        content = self.directive.content
+                        # Add tabs and join into a single string.
+                        content = '\n'.join([TAB + line for line in content])
+
+                    e = ('\n\nInvalid block: Block contains an output prompt '
+                         'without an input prompt.\n\n'
+                         'Document source: {0}\n\n'
+                         'Content begins at line {1}: \n\n{2}\n\n'
+                         'Problematic block within content: \n\n{TAB}{3}\n\n')
+                    e = e.format(source, linenumber, content, block, TAB=TAB)
+
+                    # Write, rather than include in exception, since Sphinx
+                    # will truncate tracebacks.
+                    sys.stdout.write(e)
+                    raise RuntimeError('An invalid block was detected.')
+                out_data = \
+                    self.process_output(data, output_prompt, input_lines,
+                                        output, is_doctest, decorator,
+                                        image_file)
+                if out_data:
+                    # Then there was user submitted output in verbatim mode.
+                    # We need to remove the last element of `ret` that was
+                    # added in `process_input`, as it is '' and would introduce
+                    # an undesirable newline.
+                    assert(ret[-1] == '')
+                    del ret[-1]
+
+            if out_data:
+                ret.extend(out_data)
+
+        # save the image files
+        if image_file is not None:
+            self.save_image(image_file)
+
+        return ret, image_directive
+
+    def ensure_pyplot(self):
+        """
+        Ensures that pyplot has been imported into the embedded IPython shell.
+
+        Also, makes sure to set the backend appropriately if not set already.
+
+        """
+        # We are here if the @figure pseudo decorator was used. Thus, it's
+        # possible that we could be here even if python_mplbackend were set to
+        # `None`. That's also strange and perhaps worthy of raising an
+        # exception, but for now, we just set the backend to 'agg'.
+
+        if not self._pyplot_imported:
+            if 'matplotlib.backends' not in sys.modules:
+                # Then ipython_matplotlib was set to None but there was a
+                # call to the @figure decorator (and ipython_execlines did
+                # not set a backend).
+                #raise Exception("No backend was set, but @figure was used!")
+                import matplotlib
+                matplotlib.use('agg')
+
+            # Always import pyplot into embedded shell.
+            self.process_input_line('import matplotlib.pyplot as plt',
+                                    store_history=False)
+            self._pyplot_imported = True
+
+    def process_pure_python(self, content):
+        """
+        content is a list of strings. it is unedited directive content
+
+        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
+        multiline_start = None
+        fmtin = self.promptin
+
+        ct = 0
+
+        for lineno, line in enumerate(content):
+
+            line_stripped = line.strip()
+            if not len(line):
+                output.append(line)
+                continue
+
+            # handle pseudo-decorators, whilst ensuring real python decorators are treated as input
+            if any(
+                line_stripped.startswith("@" + pseudo_decorator)
+                for pseudo_decorator in PSEUDO_DECORATORS
+            ):
+                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 lines checking for multiline
+            continuation  = u'   %s:'% ''.join(['.']*(len(str(ct))+2))
+            if not multiline:
+                modified = u"%s %s" % (fmtin % ct, line_stripped)
+                output.append(modified)
+                ct += 1
+                try:
+                    ast.parse(line_stripped)
+                    output.append(u'')
+                except Exception: # on a multiline
+                    multiline = True
+                    multiline_start = lineno
+            else: # still on a multiline
+                modified = u'%s %s' % (continuation, line)
+                output.append(modified)
+
+                # if the next line is indented, it should be part of multiline
+                if len(content) > lineno + 1:
+                    nextline = content[lineno + 1]
+                    if len(nextline) - len(nextline.lstrip()) > 3:
+                        continue
+                try:
+                    mod = ast.parse(
+                            '\n'.join(content[multiline_start:lineno+1]))
+                    if isinstance(mod.body[0], ast.FunctionDef):
+                        # check to see if we have the whole function
+                        for element in mod.body[0].body:
+                            if isinstance(element, ast.Return):
+                                multiline = False
+                    else:
+                        output.append(u'')
+                        multiline = False
+                except Exception:
+                    pass
+
+            if savefig: # clear figure if plotted
+                self.ensure_pyplot()
+                self.process_input_line('plt.clf()', store_history=False)
+                self.clear_cout()
+                savefig = False
+
+        return output
+
+    def custom_doctest(self, decorator, input_lines, found, submitted):
+        """
+        Perform a specialized doctest.
+
+        """
+        from .custom_doctests import doctests
+
+        args = decorator.split()
+        doctest_type = args[1]
+        if doctest_type in doctests:
+            doctests[doctest_type](self, args, input_lines, found, submitted)
+        else:
+            e = "Invalid option to @doctest: {0}".format(doctest_type)
+            raise Exception(e)
+
+
+class IPythonDirective(Directive):
+
+    has_content: bool = True
+    required_arguments: int = 0
+    optional_arguments: int = 4  # python, suppress, verbatim, doctest
+    final_argumuent_whitespace: bool = True
+    option_spec: Dict[str, Any] = {
+        "python": directives.unchanged,
+        "suppress": directives.flag,
+        "verbatim": directives.flag,
+        "doctest": directives.flag,
+        "okexcept": directives.flag,
+        "okwarning": directives.flag,
+    }
+
+    shell = None
+
+    seen_docs: Set = set()
+
+    def get_config_options(self):
+        # contains sphinx configuration variables
+        config = self.state.document.settings.env.config
+
+        # get config variables to set figure output directory
+        savefig_dir = config.ipython_savefig_dir
+        source_dir = self.state.document.settings.env.srcdir
+        savefig_dir = os.path.join(source_dir, savefig_dir)
+
+        # get regex and prompt stuff
+        rgxin      = config.ipython_rgxin
+        rgxout     = config.ipython_rgxout
+        warning_is_error= config.ipython_warning_is_error
+        promptin   = config.ipython_promptin
+        promptout  = config.ipython_promptout
+        mplbackend = config.ipython_mplbackend
+        exec_lines = config.ipython_execlines
+        hold_count = config.ipython_holdcount
+
+        return (savefig_dir, source_dir, rgxin, rgxout,
+                promptin, promptout, mplbackend, exec_lines, hold_count, warning_is_error)
+
+    def setup(self):
+        # Get configuration values.
+        (savefig_dir, source_dir, rgxin, rgxout, promptin, promptout,
+         mplbackend, exec_lines, hold_count, warning_is_error) = self.get_config_options()
+
+        try:
+            os.makedirs(savefig_dir)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        if self.shell is None:
+            # We will be here many times.  However, when the
+            # EmbeddedSphinxShell is created, its interactive shell member
+            # is the same for each instance.
+
+            if mplbackend and 'matplotlib.backends' not in sys.modules and use_matplotlib:
+                import matplotlib
+                matplotlib.use(mplbackend)
+
+            # Must be called after (potentially) importing matplotlib and
+            # setting its backend since exec_lines might import pylab.
+            self.shell = EmbeddedSphinxShell(exec_lines)
+
+            # Store IPython directive to enable better error messages
+            self.shell.directive = self
+
+        # reset the execution count if we haven't processed this doc
+        #NOTE: this may be borked if there are multiple seen_doc tmp files
+        #check time stamp?
+        if self.state.document.current_source not in self.seen_docs:
+            self.shell.IP.history_manager.reset()
+            self.shell.IP.execution_count = 1
+            self.seen_docs.add(self.state.document.current_source)
+
+        # 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
+        self.shell.hold_count = hold_count
+        self.shell.warning_is_error = warning_is_error
+
+        # setup bookmark for saving figures directory
+        self.shell.process_input_line(
+            'bookmark ipy_savedir "%s"' % savefig_dir, store_history=False
+        )
+        self.shell.clear_cout()
+
+        return rgxin, rgxout, promptin, promptout
+
+    def teardown(self):
+        # delete last bookmark
+        self.shell.process_input_line('bookmark -d ipy_savedir',
+                                      store_history=False)
+        self.shell.clear_cout()
+
+    def run(self):
+        debug = False
+
+        #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()
+
+        options = self.options
+        self.shell.is_suppress = 'suppress' in options
+        self.shell.is_doctest = 'doctest' in options
+        self.shell.is_verbatim = 'verbatim' in options
+        self.shell.is_okexcept = 'okexcept' in options
+        self.shell.is_okwarning = 'okwarning' in options
+
+        # handle pure python code
+        if 'python' in self.arguments:
+            content = self.content
+            self.content = self.shell.process_pure_python(content)
+
+        # parts consists of all text within the ipython-block.
+        # Each part is an input/output block.
+        parts = '\n'.join(self.content).split('\n\n')
+
+        lines = ['.. code-block:: ipython', '']
+        figures = []
+
+        # Use sphinx logger for warnings
+        logger = logging.getLogger(__name__)
+
+        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(['   {0}'.format(line)
+                                  for line in row.split('\n')])
+
+                if figure is not None:
+                    figures.append(figure)
+            else:
+                message = 'Code input with no code at {}, line {}'\
+                            .format(
+                                self.state.document.current_source,
+                                self.state.document.current_line)
+                if self.shell.warning_is_error:
+                    raise RuntimeError(message)
+                else:
+                    logger.warning(message)
+
+        for figure in figures:
+            lines.append('')
+            lines.extend(figure.split('\n'))
+            lines.append('')
+
+        if len(lines) > 2:
+            if debug:
+                print('\n'.join(lines))
+            else:
+                # This has to do with input, not output. But if we comment
+                # these lines out, then no IPython code will appear in the
+                # final output.
+                self.state_machine.insert_input(
+                    lines, self.state_machine.input_lines.source(0))
+
+        # cleanup
+        self.teardown()
+
+        return []
+
+# Enable as a proper Sphinx directive
+def setup(app):
+    setup.app = app
+
+    app.add_directive('ipython', IPythonDirective)
+    app.add_config_value('ipython_savefig_dir', 'savefig', 'env')
+    app.add_config_value('ipython_warning_is_error', True, 'env')
+    app.add_config_value('ipython_rgxin',
+                         re.compile(r'In \[(\d+)\]:\s?(.*)\s*'), 'env')
+    app.add_config_value('ipython_rgxout',
+                         re.compile(r'Out\[(\d+)\]:\s?(.*)\s*'), 'env')
+    app.add_config_value('ipython_promptin', 'In [%d]:', 'env')
+    app.add_config_value('ipython_promptout', 'Out[%d]:', 'env')
+
+    # We could just let matplotlib pick whatever is specified as the default
+    # backend in the matplotlibrc file, but this would cause issues if the
+    # backend didn't work in headless environments. For this reason, 'agg'
+    # is a good default backend choice.
+    app.add_config_value('ipython_mplbackend', 'agg', 'env')
+
+    # If the user sets this config value to `None`, then EmbeddedSphinxShell's
+    # __init__ method will treat it as [].
+    execlines = ['import numpy as np']
+    if use_matplotlib:
+        execlines.append('import matplotlib.pyplot as plt')
+    app.add_config_value('ipython_execlines', execlines, 'env')
+
+    app.add_config_value('ipython_holdcount', True, 'env')
+
+    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
+    return metadata
+
+# Simple smoke test, needs to be converted to a proper automatic test.
+def test():
+
+    examples = [
+        r"""
+In [9]: pwd
+Out[9]: '/home/jdhunter/py4science/book'
+
+In [10]: cd bookdata/
+/home/jdhunter/py4science/book/bookdata
+
+In [2]: from pylab import *
+
+In [2]: ion()
+
+In [3]: im = imread('stinkbug.png')
+
+@savefig mystinkbug.png width=4in
+In [4]: imshow(im)
+Out[4]: <matplotlib.image.AxesImage object at 0x39ea850>
+
+""",
+        r"""
+
+In [1]: x = 'hello world'
+
+# string methods can be
+# used to alter the string
+@doctest
+In [2]: x.upper()
+Out[2]: 'HELLO WORLD'
+
+@verbatim
+In [3]: x.st<TAB>
+x.startswith  x.strip
+""",
+    r"""
+
+In [130]: url = 'http://ichart.finance.yahoo.com/table.csv?s=CROX\
+   .....: &d=9&e=22&f=2009&g=d&a=1&br=8&c=2006&ignore=.csv'
+
+In [131]: print url.split('&')
+['http://ichart.finance.yahoo.com/table.csv?s=CROX', 'd=9', 'e=22', 'f=2009', 'g=d', 'a=1', 'b=8', 'c=2006', 'ignore=.csv']
+
+In [60]: import urllib
+
+""",
+    r"""\
+
+In [133]: import numpy.random
+
+@suppress
+In [134]: numpy.random.seed(2358)
+
+@doctest
+In [135]: numpy.random.rand(10,2)
+Out[135]:
+array([[ 0.64524308,  0.59943846],
+       [ 0.47102322,  0.8715456 ],
+       [ 0.29370834,  0.74776844],
+       [ 0.99539577,  0.1313423 ],
+       [ 0.16250302,  0.21103583],
+       [ 0.81626524,  0.1312433 ],
+       [ 0.67338089,  0.72302393],
+       [ 0.7566368 ,  0.07033696],
+       [ 0.22591016,  0.77731835],
+       [ 0.0072729 ,  0.34273127]])
+
+""",
+
+    r"""
+In [106]: print x
+jdh
+
+In [109]: for i in range(10):
+   .....:     print i
+   .....:
+   .....:
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+""",
+
+        r"""
+
+In [144]: from pylab import *
+
+In [145]: ion()
+
+# use a semicolon to suppress the output
+@savefig test_hist.png width=4in
+In [151]: hist(np.random.randn(10000), 100);
+
+
+@savefig test_plot.png width=4in
+In [151]: plot(np.random.randn(10000), 'o');
+   """,
+
+        r"""
+# use a semicolon to suppress the output
+In [151]: plt.clf()
+
+@savefig plot_simple.png width=4in
+In [151]: plot([1,2,3])
+
+@savefig hist_simple.png width=4in
+In [151]: hist(np.random.randn(10000), 100);
+
+""",
+     r"""
+# update the current fig
+In [151]: ylabel('number')
+
+In [152]: title('normal distribution')
+
+
+@savefig hist_with_text.png
+In [153]: grid(True)
+
+@doctest float
+In [154]: 0.1 + 0.2
+Out[154]: 0.3
+
+@doctest float
+In [155]: np.arange(16).reshape(4,4)
+Out[155]:
+array([[ 0,  1,  2,  3],
+       [ 4,  5,  6,  7],
+       [ 8,  9, 10, 11],
+       [12, 13, 14, 15]])
+
+In [1]: x = np.arange(16, dtype=float).reshape(4,4)
+
+In [2]: x[0,0] = np.inf
+
+In [3]: x[0,1] = np.nan
+
+@doctest float
+In [4]: x
+Out[4]:
+array([[ inf,  nan,   2.,   3.],
+       [  4.,   5.,   6.,   7.],
+       [  8.,   9.,  10.,  11.],
+       [ 12.,  13.,  14.,  15.]])
+
+
+        """,
+        ]
+    # skip local-file depending first example:
+    examples = examples[1:]
+
+    #ipython_directive.DEBUG = True  # dbg
+    #options = dict(suppress=True)  # dbg
+    options = {}
+    for example in examples:
+        content = example.split('\n')
+        IPythonDirective('debug', arguments=None, options=options,
+                          content=content, lineno=0,
+                          content_offset=None, block_text=None,
+                          state=None, state_machine=None,
+                          )
+
+# Run test suite as a script
+if __name__=='__main__':
+    if not os.path.isdir('_static'):
+        os.mkdir('_static')
+    test()
+    print('All OK? Check figures in _static/')
diff --git a/IPython/core/tests/__init__.py b/IPython/terminal/__init__.py
similarity index 100%
rename from IPython/core/tests/__init__.py
rename to IPython/terminal/__init__.py
diff --git a/IPython/terminal/debugger.py b/IPython/terminal/debugger.py
new file mode 100644
index 00000000000..85cd3242c0c
--- /dev/null
+++ b/IPython/terminal/debugger.py
@@ -0,0 +1,181 @@
+import asyncio
+import os
+import sys
+
+from IPython.core.debugger import Pdb
+from IPython.core.completer import IPCompleter
+from .ptutils import IPythonPTCompleter
+from .shortcuts import create_ipython_shortcuts
+from . import embed
+
+from pathlib import Path
+from pygments.token import Token
+from prompt_toolkit.application import create_app_session
+from prompt_toolkit.shortcuts.prompt import PromptSession
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.formatted_text import PygmentsTokens
+from prompt_toolkit.history import InMemoryHistory, FileHistory
+from concurrent.futures import ThreadPoolExecutor
+
+# we want to avoid ptk as much as possible when using subprocesses
+# as it uses cursor positioning requests, deletes color ....
+_use_simple_prompt = "IPY_TEST_SIMPLE_PROMPT" in os.environ
+
+
+class TerminalPdb(Pdb):
+    """Standalone IPython debugger."""
+
+    def __init__(self, *args, pt_session_options=None, **kwargs):
+        Pdb.__init__(self, *args, **kwargs)
+        self._ptcomp = None
+        self.pt_init(pt_session_options)
+        self.thread_executor = ThreadPoolExecutor(1)
+
+    def pt_init(self, pt_session_options=None):
+        """Initialize the prompt session and the prompt loop
+        and store them in self.pt_app and self.pt_loop.
+
+        Additional keyword arguments for the PromptSession class
+        can be specified in pt_session_options.
+        """
+        if pt_session_options is None:
+            pt_session_options = {}
+
+        def get_prompt_tokens():
+            return [(Token.Prompt, self.prompt)]
+
+        if self._ptcomp is None:
+            compl = IPCompleter(
+                shell=self.shell, namespace={}, global_namespace={}, parent=self.shell
+            )
+            # add a completer for all the do_ methods
+            methods_names = [m[3:] for m in dir(self) if m.startswith("do_")]
+
+            def gen_comp(self, text):
+                return [m for m in methods_names if m.startswith(text)]
+            import types
+            newcomp = types.MethodType(gen_comp, compl)
+            compl.custom_matchers.insert(0, newcomp)
+            # end add completer.
+
+            self._ptcomp = IPythonPTCompleter(compl)
+
+        # setup history only when we start pdb
+        if self.shell.debugger_history is None:
+            if self.shell.debugger_history_file is not None:
+                p = Path(self.shell.debugger_history_file).expanduser()
+                if not p.exists():
+                    p.touch()
+                self.debugger_history = FileHistory(os.path.expanduser(str(p)))
+            else:
+                self.debugger_history = InMemoryHistory()
+        else:
+            self.debugger_history = self.shell.debugger_history
+
+        options = dict(
+            message=(lambda: PygmentsTokens(get_prompt_tokens())),
+            editing_mode=getattr(EditingMode, self.shell.editing_mode.upper()),
+            key_bindings=create_ipython_shortcuts(self.shell),
+            history=self.debugger_history,
+            completer=self._ptcomp,
+            enable_history_search=True,
+            mouse_support=self.shell.mouse_support,
+            complete_style=self.shell.pt_complete_style,
+            style=getattr(self.shell, "style", None),
+            color_depth=self.shell.color_depth,
+        )
+
+        options.update(pt_session_options)
+        if not _use_simple_prompt:
+            self.pt_loop = asyncio.new_event_loop()
+            self.pt_app = PromptSession(**options)
+
+    def _prompt(self):
+        """
+        In case other prompt_toolkit apps have to run in parallel to this one (e.g. in madbg),
+        create_app_session must be used to prevent mixing up between them. According to the prompt_toolkit docs:
+
+        > If you need multiple applications running at the same time, you have to create a separate
+        > `AppSession` using a `with create_app_session():` block.
+        """
+        with create_app_session():
+            return self.pt_app.prompt()
+
+    def cmdloop(self, intro=None):
+        """Repeatedly issue a prompt, accept input, parse an initial prefix
+        off the received input, and dispatch to action methods, passing them
+        the remainder of the line as argument.
+
+        override the same methods from cmd.Cmd to provide prompt toolkit replacement.
+        """
+        if not self.use_rawinput:
+            raise ValueError('Sorry ipdb does not support use_rawinput=False')
+
+        # In order to make sure that prompt, which uses asyncio doesn't
+        # interfere with applications in which it's used, we always run the
+        # prompt itself in a different thread (we can't start an event loop
+        # within an event loop). This new thread won't have any event loop
+        # running, and here we run our prompt-loop.
+        self.preloop()
+
+        try:
+            if intro is not None:
+                self.intro = intro
+            if self.intro:
+                print(self.intro, file=self.stdout)
+            stop = None
+            while not stop:
+                if self.cmdqueue:
+                    line = self.cmdqueue.pop(0)
+                else:
+                    self._ptcomp.ipy_completer.namespace = self.curframe_locals
+                    self._ptcomp.ipy_completer.global_namespace = self.curframe.f_globals
+
+                    # Run the prompt in a different thread.
+                    if not _use_simple_prompt:
+                        try:
+                            line = self.thread_executor.submit(self._prompt).result()
+                        except EOFError:
+                            line = "EOF"
+                    else:
+                        line = input("ipdb> ")
+
+                line = self.precmd(line)
+                stop = self.onecmd(line)
+                stop = self.postcmd(stop, line)
+            self.postloop()
+        except Exception:
+            raise
+
+    def do_interact(self, arg):
+        ipshell = embed.InteractiveShellEmbed(
+            config=self.shell.config,
+            banner1="*interactive*",
+            exit_msg="*exiting interactive console...*",
+        )
+        global_ns = self.curframe.f_globals
+        ipshell(
+            module=sys.modules.get(global_ns["__name__"], None),
+            local_ns=self.curframe_locals,
+        )
+
+
+def set_trace(frame=None):
+    """
+    Start debugging from `frame`.
+
+    If frame is not specified, debugging starts from caller's frame.
+    """
+    TerminalPdb().set_trace(frame or sys._getframe().f_back)
+
+
+if __name__ == '__main__':
+    import pdb
+    # IPython.core.debugger.Pdb.trace_dispatch shall not catch
+    # bdb.BdbQuit. When started through __main__ and an exception
+    # happened after hitting "c", this is needed in order to
+    # be able to quit the debugging session (see #9950).
+    old_trace_dispatch = pdb.Pdb.trace_dispatch
+    pdb.Pdb = TerminalPdb  # type: ignore
+    pdb.Pdb.trace_dispatch = old_trace_dispatch  # type: ignore
+    pdb.main()
diff --git a/IPython/terminal/embed.py b/IPython/terminal/embed.py
new file mode 100644
index 00000000000..85acd3c115c
--- /dev/null
+++ b/IPython/terminal/embed.py
@@ -0,0 +1,436 @@
+# encoding: utf-8
+"""
+An embedded IPython shell.
+"""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import sys
+import warnings
+
+from IPython.core import ultratb, compilerop
+from IPython.core import magic_arguments
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.core.interactiveshell import InteractiveShell, make_main_module_type
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
+from IPython.terminal.ipapp import load_default_config
+
+from traitlets import Bool, CBool, Unicode
+from IPython.utils.io import ask_yes_no
+
+from typing import Set
+
+class KillEmbedded(Exception):pass
+
+# kept for backward compatibility as IPython 6 was released with
+# the typo. See https://github.com/ipython/ipython/pull/10706
+KillEmbeded = KillEmbedded
+
+# This is an additional magic that is exposed in embedded shells.
+@magics_class
+class EmbeddedMagics(Magics):
+
+    @line_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument('-i', '--instance', action='store_true',
+                              help='Kill instance instead of call location')
+    @magic_arguments.argument('-x', '--exit', action='store_true',
+                              help='Also exit the current session')
+    @magic_arguments.argument('-y', '--yes', action='store_true',
+                              help='Do not ask confirmation')
+    def kill_embedded(self, parameter_s=''):
+        """%kill_embedded : deactivate for good the current embedded IPython
+
+        This function (after asking for confirmation) sets an internal flag so
+        that an embedded IPython will never activate again for the given call
+        location. This is useful to permanently disable a shell that is being
+        called inside a loop: once you've figured out what you needed from it,
+        you may then kill it and the program will then continue to run without
+        the interactive shell interfering again.
+
+        Kill Instance Option:
+
+            If for some reasons you need to kill the location where the instance
+            is created and not called, for example if you create a single
+            instance in one place and debug in many locations, you can use the
+            ``--instance`` option to kill this specific instance. Like for the
+            ``call location`` killing an "instance" should work even if it is
+            recreated within a loop.
+
+        .. note::
+
+            This was the default behavior before IPython 5.2
+
+        """
+
+        args = magic_arguments.parse_argstring(self.kill_embedded, parameter_s)
+        print(args)
+        if args.instance:
+            # let no ask
+            if not args.yes:
+                kill = ask_yes_no(
+                    "Are you sure you want to kill this embedded instance? [y/N] ", 'n')
+            else:
+                kill = True
+            if kill:
+                self.shell._disable_init_location()
+                print("This embedded IPython instance will not reactivate anymore "
+                      "once you exit.")
+        else:
+            if not args.yes:
+                kill = ask_yes_no(
+                    "Are you sure you want to kill this embedded call_location? [y/N] ", 'n')
+            else:
+                kill = True
+            if kill:
+                self.shell.embedded_active = False
+                print("This embedded IPython  call location will not reactivate anymore "
+                      "once you exit.")
+
+        if args.exit:
+            # Ask-exit does not really ask, it just set internals flags to exit
+            # on next loop.
+            self.shell.ask_exit()
+
+
+    @line_magic
+    def exit_raise(self, parameter_s=''):
+        """%exit_raise Make the current embedded kernel exit and raise and exception.
+
+        This function sets an internal flag so that an embedded IPython will
+        raise a `IPython.terminal.embed.KillEmbedded` Exception on exit, and then exit the current I. This is
+        useful to permanently exit a loop that create IPython embed instance.
+        """
+
+        self.shell.should_raise = True
+        self.shell.ask_exit()
+
+
+class _Sentinel:
+    def __init__(self, repr):
+        assert isinstance(repr, str)
+        self.repr = repr
+
+    def __repr__(self):
+        return repr
+
+
+class InteractiveShellEmbed(TerminalInteractiveShell):
+
+    dummy_mode = Bool(False)
+    exit_msg = Unicode('')
+    embedded = CBool(True)
+    should_raise = CBool(False)
+    # Like the base class display_banner is not configurable, but here it
+    # is True by default.
+    display_banner = CBool(True)
+    exit_msg = Unicode()
+
+    # When embedding, by default we don't change the terminal title
+    term_title = Bool(False,
+        help="Automatically set the terminal title"
+    ).tag(config=True)
+
+    _inactive_locations: Set[str] = set()
+
+    def _disable_init_location(self):
+        """Disable the current Instance creation location"""
+        InteractiveShellEmbed._inactive_locations.add(self._init_location_id)
+
+    @property
+    def embedded_active(self):
+        return (self._call_location_id not in InteractiveShellEmbed._inactive_locations)\
+            and (self._init_location_id not in InteractiveShellEmbed._inactive_locations)
+
+    @embedded_active.setter
+    def embedded_active(self, value):
+        if value:
+            InteractiveShellEmbed._inactive_locations.discard(
+                self._call_location_id)
+            InteractiveShellEmbed._inactive_locations.discard(
+                self._init_location_id)
+        else:
+            InteractiveShellEmbed._inactive_locations.add(
+                self._call_location_id)
+
+    def __init__(self, **kw):
+        assert (
+            "user_global_ns" not in kw
+        ), "Key word argument `user_global_ns` has been replaced by `user_module` since IPython 4.0."
+        # temporary fix for https://github.com/ipython/ipython/issues/14164
+        cls = type(self)
+        if cls._instance is None:
+            for subclass in cls._walk_mro():
+                subclass._instance = self
+            cls._instance = self
+
+        clid = kw.pop('_init_location_id', None)
+        if not clid:
+            frame = sys._getframe(1)
+            clid = '%s:%s' % (frame.f_code.co_filename, frame.f_lineno)
+        self._init_location_id = clid
+
+        super(InteractiveShellEmbed,self).__init__(**kw)
+
+        # don't use the ipython crash handler so that user exceptions aren't
+        # trapped
+        sys.excepthook = ultratb.FormattedTB(
+            theme_name=self.colors,
+            mode=self.xmode,
+            call_pdb=self.pdb,
+        )
+
+    def init_sys_modules(self):
+        """
+        Explicitly overwrite :mod:`IPython.core.interactiveshell` to do nothing.
+        """
+        pass
+
+    def init_magics(self):
+        super(InteractiveShellEmbed, self).init_magics()
+        self.register_magics(EmbeddedMagics)
+
+    def __call__(
+        self,
+        header="",
+        local_ns=None,
+        module=None,
+        dummy=None,
+        stack_depth=1,
+        compile_flags=None,
+        **kw,
+    ):
+        """Activate the interactive interpreter.
+
+        __call__(self,header='',local_ns=None,module=None,dummy=None) -> Start
+        the interpreter shell with the given local and global namespaces, and
+        optionally print a header string at startup.
+
+        The shell can be globally activated/deactivated using the
+        dummy_mode attribute. This allows you to turn off a shell used
+        for debugging globally.
+
+        However, *each* time you call the shell you can override the current
+        state of dummy_mode with the optional keyword parameter 'dummy'. For
+        example, if you set dummy mode on with IPShell.dummy_mode = True, you
+        can still have a specific call work by making it as IPShell(dummy=False).
+        """
+
+        # we are called, set the underlying interactiveshell not to exit.
+        self.keep_running = True
+
+        # If the user has turned it off, go away
+        clid = kw.pop('_call_location_id', None)
+        if not clid:
+            frame = sys._getframe(1)
+            clid = '%s:%s' % (frame.f_code.co_filename, frame.f_lineno)
+        self._call_location_id = clid
+
+        if not self.embedded_active:
+            return
+
+        # Normal exits from interactive mode set this flag, so the shell can't
+        # re-enter (it checks this variable at the start of interactive mode).
+        self.exit_now = False
+
+        # Allow the dummy parameter to override the global __dummy_mode
+        if dummy or (dummy != 0 and self.dummy_mode):
+            return
+
+        # self.banner is auto computed
+        if header:
+            self.old_banner2 = self.banner2
+            self.banner2 = self.banner2 + '\n' + header + '\n'
+        else:
+            self.old_banner2 = ''
+
+        if self.display_banner:
+            self.show_banner()
+
+        # Call the embedding code with a stack depth of 1 so it can skip over
+        # our call and get the original caller's namespaces.
+        self.mainloop(
+            local_ns, module, stack_depth=stack_depth, compile_flags=compile_flags
+        )
+
+        self.banner2 = self.old_banner2
+
+        if self.exit_msg is not None:
+            print(self.exit_msg)
+
+        if self.should_raise:
+            raise KillEmbedded('Embedded IPython raising error, as user requested.')
+
+    def mainloop(
+        self,
+        local_ns=None,
+        module=None,
+        stack_depth=0,
+        compile_flags=None,
+    ):
+        """Embeds IPython into a running python program.
+
+        Parameters
+        ----------
+        local_ns, module
+            Working local namespace (a dict) and module (a module or similar
+            object). If given as None, they are automatically taken from the scope
+            where the shell was called, so that program variables become visible.
+        stack_depth : int
+            How many levels in the stack to go to looking for namespaces (when
+            local_ns or module is None). This allows an intermediate caller to
+            make sure that this function gets the namespace from the intended
+            level in the stack. By default (0) it will get its locals and globals
+            from the immediate caller.
+        compile_flags
+            A bit field identifying the __future__ features
+            that are enabled, as passed to the builtin :func:`compile` function.
+            If given as None, they are automatically taken from the scope where
+            the shell was called.
+
+        """
+        
+        # Get locals and globals from caller
+        if ((local_ns is None or module is None or compile_flags is None)
+            and self.default_user_namespaces):
+            call_frame = sys._getframe(stack_depth).f_back
+
+            if local_ns is None:
+                local_ns = call_frame.f_locals
+            if module is None:
+                global_ns = call_frame.f_globals
+                try:
+                    module = sys.modules[global_ns['__name__']]
+                except KeyError:
+                    warnings.warn("Failed to get module %s" % \
+                        global_ns.get('__name__', 'unknown module')
+                    )
+                    module = make_main_module_type(global_ns)()
+            if compile_flags is None:
+                compile_flags = (call_frame.f_code.co_flags &
+                                 compilerop.PyCF_MASK)
+        
+        # Save original namespace and module so we can restore them after 
+        # embedding; otherwise the shell doesn't shut down correctly.
+        orig_user_module = self.user_module
+        orig_user_ns = self.user_ns
+        orig_compile_flags = self.compile.flags
+        
+        # Update namespaces and fire up interpreter
+        
+        # The global one is easy, we can just throw it in
+        if module is not None:
+            self.user_module = module
+
+        # But the user/local one is tricky: ipython needs it to store internal
+        # data, but we also need the locals. We'll throw our hidden variables
+        # like _ih and get_ipython() into the local namespace, but delete them
+        # later.
+        if local_ns is not None:
+            reentrant_local_ns = {k: v for (k, v) in local_ns.items() if k not in self.user_ns_hidden.keys()}
+            self.user_ns = reentrant_local_ns
+            self.init_user_ns()
+
+        # Compiler flags
+        if compile_flags is not None:
+            self.compile.flags = compile_flags
+
+        # make sure the tab-completer has the correct frame information, so it
+        # actually completes using the frame's locals/globals
+        self.set_completer_frame()
+
+        with self.builtin_trap, self.display_trap:
+            self.interact()
+        
+        # now, purge out the local namespace of IPython's hidden variables.
+        if local_ns is not None:
+            local_ns.update({k: v for (k, v) in self.user_ns.items() if k not in self.user_ns_hidden.keys()})
+
+        
+        # Restore original namespace so shell can shut down when we exit.
+        self.user_module = orig_user_module
+        self.user_ns = orig_user_ns
+        self.compile.flags = orig_compile_flags
+
+
+def embed(*, header="", compile_flags=None, **kwargs):
+    """Call this to embed IPython at the current point in your program.
+
+    The first invocation of this will create a :class:`terminal.embed.InteractiveShellEmbed`
+    instance and then call it.  Consecutive calls just call the already
+    created instance.
+
+    If you don't want the kernel to initialize the namespace
+    from the scope of the surrounding function,
+    and/or you want to load full IPython configuration,
+    you probably want `IPython.start_ipython()` instead.
+
+    Here is a simple example::
+
+        from IPython import embed
+        a = 10
+        b = 20
+        embed(header='First time')
+        c = 30
+        d = 40
+        embed()
+
+    Parameters
+    ----------
+
+    header : str
+        Optional header string to print at startup.
+    compile_flags
+        Passed to the `compile_flags` parameter of :py:meth:`terminal.embed.InteractiveShellEmbed.mainloop()`,
+        which is called when the :class:`terminal.embed.InteractiveShellEmbed` instance is called.
+    **kwargs : various, optional
+        Any other kwargs will be passed to the :class:`terminal.embed.InteractiveShellEmbed` constructor.
+        Full customization can be done by passing a traitlets :class:`Config` in as the
+        `config` argument (see :ref:`configure_start_ipython` and :ref:`terminal_options`).
+    """
+    config = kwargs.get('config')
+    if config is None:
+        config = load_default_config()
+        config.InteractiveShellEmbed = config.TerminalInteractiveShell
+        kwargs["config"] = config
+    using = kwargs.get("using", "sync")
+    colors = kwargs.pop("colors", "nocolor")
+    if using:
+        kwargs["config"].update(
+            {
+                "TerminalInteractiveShell": {
+                    "loop_runner": using,
+                    "colors": colors,
+                    "autoawait": using != "sync",
+                }
+            }
+        )
+    # save ps1/ps2 if defined
+    ps1 = None
+    ps2 = None
+    try:
+        ps1 = sys.ps1
+        ps2 = sys.ps2
+    except AttributeError:
+        pass
+    #save previous instance
+    saved_shell_instance = InteractiveShell._instance
+    if saved_shell_instance is not None:
+        cls = type(saved_shell_instance)
+        cls.clear_instance()
+    frame = sys._getframe(1)
+    shell = InteractiveShellEmbed.instance(_init_location_id='%s:%s' % (
+        frame.f_code.co_filename, frame.f_lineno), **kwargs)
+    shell(header=header, stack_depth=2, compile_flags=compile_flags,
+        _call_location_id='%s:%s' % (frame.f_code.co_filename, frame.f_lineno))
+    InteractiveShellEmbed.clear_instance()
+    #restore previous instance
+    if saved_shell_instance is not None:
+        cls = type(saved_shell_instance)
+        cls.clear_instance()
+        for subclass in cls._walk_mro():
+            subclass._instance = saved_shell_instance
+    if ps1 is not None:
+        sys.ps1 = ps1
+        sys.ps2 = ps2
diff --git a/IPython/terminal/interactiveshell.py b/IPython/terminal/interactiveshell.py
new file mode 100644
index 00000000000..b7a95578950
--- /dev/null
+++ b/IPython/terminal/interactiveshell.py
@@ -0,0 +1,1127 @@
+"""IPython terminal interface using prompt_toolkit"""
+
+import os
+import sys
+import inspect
+from warnings import warn
+from typing import Union as UnionType, Optional
+
+from IPython.core.async_helpers import get_asyncio_loop
+from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
+from IPython.utils.py3compat import input
+from IPython.utils.PyColorize import theme_table
+from IPython.utils.terminal import toggle_set_term_title, set_term_title, restore_term_title
+from IPython.utils.process import abbrev_cwd
+from traitlets import (
+    Any,
+    Bool,
+    Dict,
+    Enum,
+    Float,
+    Instance,
+    Integer,
+    List,
+    Type,
+    Unicode,
+    Union,
+    default,
+    observe,
+    validate,
+    DottedObjectName,
+)
+from traitlets.utils.importstring import import_item
+
+
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.enums import DEFAULT_BUFFER, EditingMode
+from prompt_toolkit.filters import HasFocus, Condition, IsDone
+from prompt_toolkit.formatted_text import PygmentsTokens
+from prompt_toolkit.history import History
+from prompt_toolkit.layout.processors import ConditionalProcessor, HighlightMatchingBracketProcessor
+from prompt_toolkit.output import ColorDepth
+from prompt_toolkit.patch_stdout import patch_stdout
+from prompt_toolkit.shortcuts import PromptSession, CompleteStyle, print_formatted_text
+from prompt_toolkit.styles import DynamicStyle, merge_styles
+from prompt_toolkit.styles.pygments import style_from_pygments_cls, style_from_pygments_dict
+from pygments.styles import get_style_by_name
+from pygments.style import Style
+
+from .debugger import TerminalPdb, Pdb
+from .magics import TerminalMagics
+from .pt_inputhooks import get_inputhook_name_and_func
+from .prompts import Prompts, ClassicPrompts, RichPromptDisplayHook
+from .ptutils import IPythonPTCompleter, IPythonPTLexer
+from .shortcuts import (
+    KEY_BINDINGS,
+    UNASSIGNED_ALLOWED_COMMANDS,
+    create_ipython_shortcuts,
+    create_identifier,
+    RuntimeBinding,
+    add_binding,
+)
+from .shortcuts.filters import KEYBINDING_FILTERS, filter_from_string
+from .shortcuts.auto_suggest import (
+    NavigableAutoSuggestFromHistory,
+    AppendAutoSuggestionInAnyLine,
+)
+
+
+class _NoStyle(Style):
+    pass
+
+
+
+def _backward_compat_continuation_prompt_tokens(
+    method, width: int, *, lineno: int, wrap_count: int
+):
+    """
+    Sagemath use custom prompt and we broke them in 8.19.
+
+    make sure to pass only width if method only support width
+    """
+    sig = inspect.signature(method)
+    extra = {}
+    params = inspect.signature(method).parameters
+    if "lineno" in inspect.signature(method).parameters or any(
+        [p.kind == p.VAR_KEYWORD for p in sig.parameters.values()]
+    ):
+        extra["lineno"] = lineno
+    if "line_number" in inspect.signature(method).parameters or any(
+        [p.kind == p.VAR_KEYWORD for p in sig.parameters.values()]
+    ):
+        extra["line_number"] = lineno
+
+    if "wrap_count" in inspect.signature(method).parameters or any(
+        [p.kind == p.VAR_KEYWORD for p in sig.parameters.values()]
+    ):
+        extra["wrap_count"] = wrap_count
+    return method(width, **extra)
+
+
+def get_default_editor():
+    try:
+        return os.environ['EDITOR']
+    except KeyError:
+        pass
+    except UnicodeError:
+        warn("$EDITOR environment variable is not pure ASCII. Using platform "
+             "default editor.")
+
+    if os.name == 'posix':
+        return 'vi'  # the only one guaranteed to be there!
+    else:
+        return "notepad"  # same in Windows!
+
+
+# conservatively check for tty
+# overridden streams can result in things like:
+# - sys.stdin = None
+# - no isatty method
+for _name in ('stdin', 'stdout', 'stderr'):
+    _stream = getattr(sys, _name)
+    try:
+        if not _stream or not hasattr(_stream, "isatty") or not _stream.isatty():
+            _is_tty = False
+            break
+    except ValueError:
+        # stream is closed
+        _is_tty = False
+        break
+else:
+    _is_tty = True
+
+
+_use_simple_prompt = ('IPY_TEST_SIMPLE_PROMPT' in os.environ) or (not _is_tty)
+
+def black_reformat_handler(text_before_cursor):
+    """
+    We do not need to protect against error,
+    this is taken care at a higher level where any reformat error is ignored.
+    Indeed we may call reformatting on incomplete code.
+    """
+    import black
+
+    formatted_text = black.format_str(text_before_cursor, mode=black.FileMode())
+    if not text_before_cursor.endswith("\n") and formatted_text.endswith("\n"):
+        formatted_text = formatted_text[:-1]
+    return formatted_text
+
+
+def yapf_reformat_handler(text_before_cursor):
+    from yapf.yapflib import file_resources
+    from yapf.yapflib import yapf_api
+
+    style_config = file_resources.GetDefaultStyleForDir(os.getcwd())
+    formatted_text, was_formatted = yapf_api.FormatCode(
+        text_before_cursor, style_config=style_config
+    )
+    if was_formatted:
+        if not text_before_cursor.endswith("\n") and formatted_text.endswith("\n"):
+            formatted_text = formatted_text[:-1]
+        return formatted_text
+    else:
+        return text_before_cursor
+
+
+class PtkHistoryAdapter(History):
+    """
+    Prompt toolkit has it's own way of handling history, Where it assumes it can
+    Push/pull from history.
+
+    """
+
+    def __init__(self, shell):
+        super().__init__()
+        self.shell = shell
+        self._refresh()
+
+    def append_string(self, string):
+        # we rely on sql for that.
+        self._loaded = False
+        self._refresh()
+
+    def _refresh(self):
+        if not self._loaded:
+            self._loaded_strings = list(self.load_history_strings())
+
+    def load_history_strings(self):
+        last_cell = ""
+        res = []
+        for __, ___, cell in self.shell.history_manager.get_tail(
+            self.shell.history_load_length, include_latest=True
+        ):
+            # Ignore blank lines and consecutive duplicates
+            cell = cell.rstrip()
+            if cell and (cell != last_cell):
+                res.append(cell)
+                last_cell = cell
+        yield from res[::-1]
+
+    def store_string(self, string: str) -> None:
+        pass
+
+class TerminalInteractiveShell(InteractiveShell):
+    mime_renderers = Dict().tag(config=True)
+
+    min_elide = Integer(
+        30, help="minimum characters for filling with ellipsis in file completions"
+    ).tag(config=True)
+    space_for_menu = Integer(
+        6,
+        help="Number of line at the bottom of the screen "
+        "to reserve for the tab completion menu, "
+        "search history, ...etc, the height of "
+        "these menus will at most this value. "
+        "Increase it is you prefer long and skinny "
+        "menus, decrease for short and wide.",
+    ).tag(config=True)
+
+    pt_app: UnionType[PromptSession, None] = None
+    auto_suggest: UnionType[
+        AutoSuggestFromHistory,
+        NavigableAutoSuggestFromHistory,
+        None,
+    ] = None
+    debugger_history = None
+
+    debugger_history_file = Unicode(
+        "~/.pdbhistory", help="File in which to store and read history"
+    ).tag(config=True)
+
+    simple_prompt = Bool(_use_simple_prompt,
+        help="""Use `raw_input` for the REPL, without completion and prompt colors.
+
+            Useful when controlling IPython as a subprocess, and piping
+            STDIN/OUT/ERR. Known usage are: IPython's own testing machinery,
+            and emacs' inferior-python subprocess (assuming you have set
+            `python-shell-interpreter` to "ipython") available through the
+            built-in `M-x run-python` and third party packages such as elpy.
+
+            This mode default to `True` if the `IPY_TEST_SIMPLE_PROMPT`
+            environment variable is set, or the current terminal is not a tty.
+            Thus the Default value reported in --help-all, or config will often
+            be incorrectly reported.
+            """,
+    ).tag(config=True)
+
+    @property
+    def debugger_cls(self):
+        return Pdb if self.simple_prompt else TerminalPdb
+
+    confirm_exit = Bool(True,
+        help="""
+        Set to confirm when you try to exit IPython with an EOF (Control-D
+        in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
+        you can force a direct exit without any confirmation.""",
+    ).tag(config=True)
+
+    editing_mode = Unicode('emacs',
+        help="Shortcut style to use at the prompt. 'vi' or 'emacs'.",
+    ).tag(config=True)
+
+    emacs_bindings_in_vi_insert_mode = Bool(
+        True,
+        help="Add shortcuts from 'emacs' insert mode to 'vi' insert mode.",
+    ).tag(config=True)
+
+    modal_cursor = Bool(
+        True,
+        help="""
+       Cursor shape changes depending on vi mode: beam in vi insert mode,
+       block in nav mode, underscore in replace mode.""",
+    ).tag(config=True)
+
+    ttimeoutlen = Float(
+        0.01,
+        help="""The time in milliseconds that is waited for a key code
+       to complete.""",
+    ).tag(config=True)
+
+    timeoutlen = Float(
+        0.5,
+        help="""The time in milliseconds that is waited for a mapped key
+       sequence to complete.""",
+    ).tag(config=True)
+
+    autoformatter = Unicode(
+        None,
+        help="Autoformatter to reformat Terminal code. Can be `'black'`, `'yapf'` or `None`",
+        allow_none=True
+    ).tag(config=True)
+
+    auto_match = Bool(
+        False,
+        help="""
+        Automatically add/delete closing bracket or quote when opening bracket or quote is entered/deleted.
+        Brackets: (), [], {}
+        Quotes: '', \"\"
+        """,
+    ).tag(config=True)
+
+    mouse_support = Bool(False,
+        help="Enable mouse support in the prompt\n(Note: prevents selecting text with the mouse)"
+    ).tag(config=True)
+
+    # We don't load the list of styles for the help string, because loading
+    # Pygments plugins takes time and can cause unexpected errors.
+    highlighting_style = Union(
+        [Unicode("legacy"), Type(klass=Style)],
+        help="""Deprecated, and has not effect, use IPython themes
+
+        The name or class of a Pygments style to use for syntax
+        highlighting. To see available styles, run `pygmentize -L styles`.""",
+    ).tag(config=True)
+
+    @validate('editing_mode')
+    def _validate_editing_mode(self, proposal):
+        if proposal['value'].lower() == 'vim':
+            proposal['value']= 'vi'
+        elif proposal['value'].lower() == 'default':
+            proposal['value']= 'emacs'
+
+        if hasattr(EditingMode, proposal['value'].upper()):
+            return proposal['value'].lower()
+
+        return self.editing_mode
+
+    @observe('editing_mode')
+    def _editing_mode(self, change):
+        if self.pt_app:
+            self.pt_app.editing_mode = getattr(EditingMode, change.new.upper())
+
+    def _set_formatter(self, formatter):
+        if formatter is None:
+            self.reformat_handler = lambda x:x
+        elif formatter == 'black':
+            self.reformat_handler = black_reformat_handler
+        elif formatter == "yapf":
+            self.reformat_handler = yapf_reformat_handler
+        else:
+            raise ValueError
+
+    @observe("autoformatter")
+    def _autoformatter_changed(self, change):
+        formatter = change.new
+        self._set_formatter(formatter)
+
+    @observe('highlighting_style')
+    @observe('colors')
+    def _highlighting_style_changed(self, change):
+        assert change.new == change.new.lower()
+        if change.new != "legacy":
+            warn(
+                "highlighting_style is deprecated since 9.0 and have no effect, use themeing."
+            )
+            return
+
+    def refresh_style(self):
+        self._style = self._make_style_from_name_or_cls("legacy")
+
+    # TODO: deprecate this
+    highlighting_style_overrides = Dict(
+        help="Override highlighting format for specific tokens"
+    ).tag(config=True)
+
+    true_color = Bool(False,
+        help="""Use 24bit colors instead of 256 colors in prompt highlighting.
+        If your terminal supports true color, the following command should
+        print ``TRUECOLOR`` in orange::
+
+            printf \"\\x1b[38;2;255;100;0mTRUECOLOR\\x1b[0m\\n\"
+        """,
+    ).tag(config=True)
+
+    editor = Unicode(get_default_editor(),
+        help="Set the editor used by IPython (default to $EDITOR/vi/notepad)."
+    ).tag(config=True)
+
+    prompts_class = Type(Prompts, help='Class used to generate Prompt token for prompt_toolkit').tag(config=True)
+
+    prompts = Instance(Prompts)
+
+    @default('prompts')
+    def _prompts_default(self):
+        return self.prompts_class(self)
+
+#    @observe('prompts')
+#    def _(self, change):
+#        self._update_layout()
+
+    @default('displayhook_class')
+    def _displayhook_class_default(self):
+        return RichPromptDisplayHook
+
+    term_title = Bool(True,
+        help="Automatically set the terminal title"
+    ).tag(config=True)
+
+    term_title_format = Unicode("IPython: {cwd}",
+        help="Customize the terminal title format.  This is a python format string. " +
+             "Available substitutions are: {cwd}."
+    ).tag(config=True)
+
+    display_completions = Enum(('column', 'multicolumn','readlinelike'),
+        help= ( "Options for displaying tab completions, 'column', 'multicolumn', and "
+                "'readlinelike'. These options are for `prompt_toolkit`, see "
+                "`prompt_toolkit` documentation for more information."
+                ),
+        default_value='multicolumn').tag(config=True)
+
+    highlight_matching_brackets = Bool(True,
+        help="Highlight matching brackets.",
+    ).tag(config=True)
+
+    extra_open_editor_shortcuts = Bool(False,
+        help="Enable vi (v) or Emacs (C-X C-E) shortcuts to open an external editor. "
+             "This is in addition to the F2 binding, which is always enabled."
+    ).tag(config=True)
+
+    handle_return = Any(None,
+        help="Provide an alternative handler to be called when the user presses "
+             "Return. This is an advanced option intended for debugging, which "
+             "may be changed or removed in later releases."
+    ).tag(config=True)
+
+    enable_history_search = Bool(True,
+        help="Allows to enable/disable the prompt toolkit history search"
+    ).tag(config=True)
+
+    autosuggestions_provider = Unicode(
+        "NavigableAutoSuggestFromHistory",
+        help="Specifies from which source automatic suggestions are provided. "
+        "Can be set to ``'NavigableAutoSuggestFromHistory'`` (:kbd:`up` and "
+        ":kbd:`down` swap suggestions), ``'AutoSuggestFromHistory'``, "
+        " or ``None`` to disable automatic suggestions. "
+        "Default is `'NavigableAutoSuggestFromHistory`'.",
+        allow_none=True,
+    ).tag(config=True)
+    _autosuggestions_provider: Any
+
+    llm_constructor_kwargs = Dict(
+        {},
+        help="""
+        Extra arguments to pass to `llm_provider_class` constructor.
+
+        This is used to – for example – set the `model_id`""",
+    ).tag(config=True)
+
+    llm_prefix_from_history = DottedObjectName(
+        "input_history",
+        help="""\
+    Fully Qualifed name of a function that takes an IPython history manager and
+    return a prefix to pass the llm provider in addition to the current buffer
+    text.
+
+    You can use:
+
+     - no_prefix
+     - input_history
+
+    As default value. `input_history` (default),  will use all the input history
+    of current IPython session
+
+    """,
+    ).tag(config=True)
+    _llm_prefix_from_history: Any
+
+    @observe("llm_prefix_from_history")
+    def _llm_prefix_from_history_changed(self, change):
+        name = change.new
+        self._llm_prefix_from_history = name
+        self._set_autosuggestions()
+
+    llm_provider_class = DottedObjectName(
+        None,
+        allow_none=True,
+        help="""\
+        Provisional:
+            This is a provisional API in IPython 8.32, before stabilisation
+            in 9.0, it may change without warnings.
+
+        class to use for the `NavigableAutoSuggestFromHistory` to request
+        completions from a LLM, this should inherit from
+        `jupyter_ai_magics:BaseProvider` and implement
+        `stream_inline_completions`
+    """,
+    ).tag(config=True)
+    _llm_provider_class: Any = None
+
+    @observe("llm_provider_class")
+    def _llm_provider_class_changed(self, change):
+        provider_class = change.new
+        self._llm_provider_class = provider_class
+        self._set_autosuggestions()
+
+    def _set_autosuggestions(self, provider=None):
+        if provider is None:
+            provider = self.autosuggestions_provider
+        # disconnect old handler
+        if self.auto_suggest and isinstance(
+            self.auto_suggest, NavigableAutoSuggestFromHistory
+        ):
+            self.auto_suggest.disconnect()
+        if provider is None:
+            self.auto_suggest = None
+        elif provider == "AutoSuggestFromHistory":
+            self.auto_suggest = AutoSuggestFromHistory()
+        elif provider == "NavigableAutoSuggestFromHistory":
+            # LLM stuff are all Provisional in 8.32
+            if self._llm_provider_class:
+
+                def init_llm_provider():
+                    llm_provider_constructor = import_item(self._llm_provider_class)
+                    return llm_provider_constructor(**self.llm_constructor_kwargs)
+
+            else:
+                init_llm_provider = None
+            self.auto_suggest = NavigableAutoSuggestFromHistory()
+            # Provisinal in 8.32
+            self.auto_suggest._init_llm_provider = init_llm_provider
+
+            name = self.llm_prefix_from_history
+
+            if name == "no_prefix":
+
+                def no_prefix(history_manager):
+                    return ""
+
+                fun = no_prefix
+
+            elif name == "input_history":
+
+                def input_history(history_manager):
+                    return "\n".join([s[2] for s in history_manager.get_range()]) + "\n"
+
+                fun = input_history
+
+            else:
+                fun = import_item(name)
+            self.auto_suggest._llm_prefixer = fun
+        else:
+            raise ValueError("No valid provider.")
+        if self.pt_app:
+            self.pt_app.auto_suggest = self.auto_suggest
+
+    @observe("autosuggestions_provider")
+    def _autosuggestions_provider_changed(self, change):
+        provider = change.new
+        self._set_autosuggestions(provider)
+
+    shortcuts = List(
+        trait=Dict(
+            key_trait=Enum(
+                [
+                    "command",
+                    "match_keys",
+                    "match_filter",
+                    "new_keys",
+                    "new_filter",
+                    "create",
+                ]
+            ),
+            per_key_traits={
+                "command": Unicode(),
+                "match_keys": List(Unicode()),
+                "match_filter": Unicode(),
+                "new_keys": List(Unicode()),
+                "new_filter": Unicode(),
+                "create": Bool(False),
+            },
+        ),
+        help="""
+        Add, disable or modifying shortcuts.
+
+        Each entry on the list should be a dictionary with ``command`` key
+        identifying the target function executed by the shortcut and at least
+        one of the following:
+
+          - ``match_keys``: list of keys used to match an existing shortcut,
+          - ``match_filter``: shortcut filter used to match an existing shortcut,
+          - ``new_keys``: list of keys to set,
+          - ``new_filter``: a new shortcut filter to set
+
+        The filters have to be composed of pre-defined verbs and joined by one
+        of the following conjunctions: ``&`` (and), ``|`` (or), ``~`` (not).
+        The pre-defined verbs are:
+
+        {filters}
+
+        To disable a shortcut set ``new_keys`` to an empty list.
+        To add a shortcut add key ``create`` with value ``True``.
+
+        When modifying/disabling shortcuts, ``match_keys``/``match_filter`` can
+        be omitted if the provided specification uniquely identifies a shortcut
+        to be modified/disabled. When modifying a shortcut ``new_filter`` or
+        ``new_keys`` can be omitted which will result in reuse of the existing
+        filter/keys.
+
+        Only shortcuts defined in IPython (and not default prompt-toolkit
+        shortcuts) can be modified or disabled. The full list of shortcuts,
+        command identifiers and filters is available under
+        :ref:`terminal-shortcuts-list`.
+
+        Here is an example:
+
+        .. code::
+
+            c.TerminalInteractiveShell.shortcuts = [
+               {{
+                   "new_keys": ["c-q"],
+                   "command": "prompt_toolkit:named_commands.capitalize_word",
+                   "create": True,
+               }},
+               {{
+                   "new_keys": ["c-j"],
+                   "command": "prompt_toolkit:named_commands.beginning_of_line",
+                   "create": True,
+               }},
+            ]
+
+
+        """.format(
+            filters="\n        ".join([f"  - ``{k}``" for k in KEYBINDING_FILTERS])
+        ),
+    ).tag(config=True)
+
+    @observe("shortcuts")
+    def _shortcuts_changed(self, change):
+        if self.pt_app:
+            self.pt_app.key_bindings = self._merge_shortcuts(user_shortcuts=change.new)
+
+    def _merge_shortcuts(self, user_shortcuts):
+        # rebuild the bindings list from scratch
+        key_bindings = create_ipython_shortcuts(self)
+
+        # for now we only allow adding shortcuts for a specific set of
+        # commands; this is a security precution.
+        allowed_commands = {
+            create_identifier(binding.command): binding.command
+            for binding in KEY_BINDINGS
+        }
+        allowed_commands.update(
+            {
+                create_identifier(command): command
+                for command in UNASSIGNED_ALLOWED_COMMANDS
+            }
+        )
+        shortcuts_to_skip = []
+        shortcuts_to_add = []
+
+        for shortcut in user_shortcuts:
+            command_id = shortcut["command"]
+            if command_id not in allowed_commands:
+                allowed_commands = "\n - ".join(allowed_commands)
+                raise ValueError(
+                    f"{command_id} is not a known shortcut command."
+                    f" Allowed commands are: \n - {allowed_commands}"
+                )
+            old_keys = shortcut.get("match_keys", None)
+            old_filter = (
+                filter_from_string(shortcut["match_filter"])
+                if "match_filter" in shortcut
+                else None
+            )
+            matching = [
+                binding
+                for binding in KEY_BINDINGS
+                if (
+                    (old_filter is None or binding.filter == old_filter)
+                    and (old_keys is None or [k for k in binding.keys] == old_keys)
+                    and create_identifier(binding.command) == command_id
+                )
+            ]
+
+            new_keys = shortcut.get("new_keys", None)
+            new_filter = shortcut.get("new_filter", None)
+
+            command = allowed_commands[command_id]
+
+            creating_new = shortcut.get("create", False)
+            modifying_existing = not creating_new and (
+                new_keys is not None or new_filter
+            )
+
+            if creating_new and new_keys == []:
+                raise ValueError("Cannot add a shortcut without keys")
+
+            if modifying_existing:
+                specification = {
+                    key: shortcut[key]
+                    for key in ["command", "filter"]
+                    if key in shortcut
+                }
+                if len(matching) == 0:
+                    raise ValueError(
+                        f"No shortcuts matching {specification} found in {KEY_BINDINGS}"
+                    )
+                elif len(matching) > 1:
+                    raise ValueError(
+                        f"Multiple shortcuts matching {specification} found,"
+                        f" please add keys/filter to select one of: {matching}"
+                    )
+
+                matched = matching[0]
+                old_filter = matched.filter
+                old_keys = list(matched.keys)
+                shortcuts_to_skip.append(
+                    RuntimeBinding(
+                        command,
+                        keys=old_keys,
+                        filter=old_filter,
+                    )
+                )
+
+            if new_keys != []:
+                shortcuts_to_add.append(
+                    RuntimeBinding(
+                        command,
+                        keys=new_keys or old_keys,
+                        filter=(
+                            filter_from_string(new_filter)
+                            if new_filter is not None
+                            else (
+                                old_filter
+                                if old_filter is not None
+                                else filter_from_string("always")
+                            )
+                        ),
+                    )
+                )
+
+        # rebuild the bindings list from scratch
+        key_bindings = create_ipython_shortcuts(self, skip=shortcuts_to_skip)
+        for binding in shortcuts_to_add:
+            add_binding(key_bindings, binding)
+
+        return key_bindings
+
+    prompt_includes_vi_mode = Bool(True,
+        help="Display the current vi mode (when using vi editing mode)."
+    ).tag(config=True)
+
+    prompt_line_number_format = Unicode(
+        "",
+        help="The format for line numbering, will be passed `line` (int, 1 based)"
+        " the current line number and `rel_line` the relative line number."
+        " for example to display both you can use the following template string :"
+        " c.TerminalInteractiveShell.prompt_line_number_format='{line: 4d}/{rel_line:+03d} | '"
+        " This will display the current line number, with leading space and a width of at least 4"
+        " character, as well as the relative line number 0 padded and always with a + or - sign."
+        " Note that when using Emacs mode the prompt of the first line may not update.",
+    ).tag(config=True)
+
+    @observe('term_title')
+    def init_term_title(self, change=None):
+        # Enable or disable the terminal title.
+        if self.term_title and _is_tty:
+            toggle_set_term_title(True)
+            set_term_title(self.term_title_format.format(cwd=abbrev_cwd()))
+        else:
+            toggle_set_term_title(False)
+
+    def restore_term_title(self):
+        if self.term_title and _is_tty:
+            restore_term_title()
+
+    def init_display_formatter(self):
+        super(TerminalInteractiveShell, self).init_display_formatter()
+        # terminal only supports plain text if not explicitly configured
+        config = self.display_formatter._trait_values["config"]
+        if not (
+            "DisplayFormatter" in config
+            and "active_types" in config["DisplayFormatter"]
+        ):
+            self.display_formatter.active_types = ["text/plain"]
+
+    def init_prompt_toolkit_cli(self):
+        if self.simple_prompt:
+            # Fall back to plain non-interactive output for tests.
+            # This is very limited.
+            def prompt():
+                prompt_text = "".join(x[1] for x in self.prompts.in_prompt_tokens())
+                lines = [input(prompt_text)]
+                prompt_continuation = "".join(
+                    x[1] for x in self.prompts.continuation_prompt_tokens()
+                )
+                while self.check_complete("\n".join(lines))[0] == "incomplete":
+                    lines.append(input(prompt_continuation))
+                return "\n".join(lines)
+
+            self.prompt_for_code = prompt
+            return
+
+        # Set up keyboard shortcuts
+        key_bindings = self._merge_shortcuts(user_shortcuts=self.shortcuts)
+
+        # Pre-populate history from IPython's history database
+        history = PtkHistoryAdapter(self)
+
+        self.refresh_style()
+        ptk_s = DynamicStyle(lambda: self._style)
+
+        editing_mode = getattr(EditingMode, self.editing_mode.upper())
+
+        self._use_asyncio_inputhook = False
+        self.pt_app = PromptSession(
+            auto_suggest=self.auto_suggest,
+            editing_mode=editing_mode,
+            key_bindings=key_bindings,
+            history=history,
+            completer=IPythonPTCompleter(shell=self),
+            enable_history_search=self.enable_history_search,
+            style=ptk_s,
+            include_default_pygments_style=False,
+            mouse_support=self.mouse_support,
+            enable_open_in_editor=self.extra_open_editor_shortcuts,
+            color_depth=self.color_depth,
+            tempfile_suffix=".py",
+            **self._extra_prompt_options(),
+        )
+        if isinstance(self.auto_suggest, NavigableAutoSuggestFromHistory):
+            self.auto_suggest.connect(self.pt_app)
+
+    def _make_style_from_name_or_cls(self, name_or_cls):
+        """
+        Small wrapper that make an IPython compatible style from a style name
+
+        We need that to add style for prompt ... etc.
+        """
+        assert name_or_cls == "legacy"
+        legacy = self.colors.lower()
+
+        theme = theme_table.get(legacy, None)
+        assert theme is not None, legacy
+
+        if legacy == "nocolor":
+            style_overrides = {}
+            style_cls = _NoStyle
+        else:
+            style_overrides = {**theme.extra_style, **self.highlighting_style_overrides}
+            if theme.base is not None:
+                style_cls = get_style_by_name(theme.base)
+            else:
+                style_cls = _NoStyle
+
+        style = merge_styles(
+            [
+                style_from_pygments_cls(style_cls),
+                style_from_pygments_dict(style_overrides),
+            ]
+        )
+
+        return style
+
+    @property
+    def pt_complete_style(self):
+        return {
+            'multicolumn': CompleteStyle.MULTI_COLUMN,
+            'column': CompleteStyle.COLUMN,
+            'readlinelike': CompleteStyle.READLINE_LIKE,
+        }[self.display_completions]
+
+    @property
+    def color_depth(self):
+        return (ColorDepth.TRUE_COLOR if self.true_color else None)
+
+    def _ptk_prompt_cont(self, width: int, line_number: int, wrap_count: int):
+        return PygmentsTokens(
+            _backward_compat_continuation_prompt_tokens(
+                self.prompts.continuation_prompt_tokens,
+                width,
+                lineno=line_number,
+                wrap_count=wrap_count,
+            )
+        )
+
+    def _extra_prompt_options(self):
+        """
+        Return the current layout option for the current Terminal InteractiveShell
+        """
+        def get_message():
+            return PygmentsTokens(self.prompts.in_prompt_tokens())
+
+        if self.editing_mode == "emacs" and self.prompt_line_number_format == "":
+            # with emacs mode the prompt is (usually) static, so we call only
+            # the function once. With VI mode it can toggle between [ins] and
+            # [nor] so we can't precompute.
+            # here I'm going to favor the default keybinding which almost
+            # everybody uses to decrease CPU usage.
+            # if we have issues with users with custom Prompts we can see how to
+            # work around this.
+            get_message = get_message()
+
+        options = {
+            "complete_in_thread": False,
+            "lexer": IPythonPTLexer(),
+            "reserve_space_for_menu": self.space_for_menu,
+            "message": get_message,
+            "prompt_continuation": self._ptk_prompt_cont,
+            "multiline": True,
+            "complete_style": self.pt_complete_style,
+            "input_processors": [
+                # Highlight matching brackets, but only when this setting is
+                # enabled, and only when the DEFAULT_BUFFER has the focus.
+                ConditionalProcessor(
+                    processor=HighlightMatchingBracketProcessor(chars="[](){}"),
+                    filter=HasFocus(DEFAULT_BUFFER)
+                    & ~IsDone()
+                    & Condition(lambda: self.highlight_matching_brackets),
+                ),
+                # Show auto-suggestion in lines other than the last line.
+                ConditionalProcessor(
+                    processor=AppendAutoSuggestionInAnyLine(),
+                    filter=HasFocus(DEFAULT_BUFFER)
+                    & ~IsDone()
+                    & Condition(
+                        lambda: isinstance(
+                            self.auto_suggest,
+                            NavigableAutoSuggestFromHistory,
+                        )
+                    ),
+                ),
+            ],
+        }
+
+        return options
+
+    def prompt_for_code(self):
+        if self.rl_next_input:
+            default = self.rl_next_input
+            self.rl_next_input = None
+        else:
+            default = ''
+
+        # In order to make sure that asyncio code written in the
+        # interactive shell doesn't interfere with the prompt, we run the
+        # prompt in a different event loop.
+        # If we don't do this, people could spawn coroutine with a
+        # while/true inside which will freeze the prompt.
+
+        with patch_stdout(raw=True):
+            if self._use_asyncio_inputhook:
+                # When we integrate the asyncio event loop, run the UI in the
+                # same event loop as the rest of the code. don't use an actual
+                # input hook. (Asyncio is not made for nesting event loops.)
+                asyncio_loop = get_asyncio_loop()
+                text = asyncio_loop.run_until_complete(
+                    self.pt_app.prompt_async(
+                        default=default, **self._extra_prompt_options()
+                    )
+                )
+            else:
+                text = self.pt_app.prompt(
+                    default=default,
+                    inputhook=self._inputhook,
+                    **self._extra_prompt_options(),
+                )
+
+        return text
+
+    def init_io(self):
+        if sys.platform not in {'win32', 'cli'}:
+            return
+
+        import colorama
+        colorama.init()
+
+    def init_magics(self):
+        super(TerminalInteractiveShell, self).init_magics()
+        self.register_magics(TerminalMagics)
+
+    def init_alias(self):
+        # The parent class defines aliases that can be safely used with any
+        # frontend.
+        super(TerminalInteractiveShell, self).init_alias()
+
+        # Now define aliases that only make sense on the terminal, because they
+        # need direct access to the console in a way that we can't emulate in
+        # GUI or web frontend
+        if os.name == 'posix':
+            for cmd in ('clear', 'more', 'less', 'man'):
+                self.alias_manager.soft_define_alias(cmd, cmd)
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._set_autosuggestions(self.autosuggestions_provider)
+        self.init_prompt_toolkit_cli()
+        self.init_term_title()
+        self.keep_running = True
+        self._set_formatter(self.autoformatter)
+
+    def ask_exit(self):
+        self.keep_running = False
+
+    rl_next_input = None
+
+    def interact(self):
+        self.keep_running = True
+        while self.keep_running:
+            print(self.separate_in, end='')
+
+            try:
+                code = self.prompt_for_code()
+            except EOFError:
+                if (not self.confirm_exit) \
+                        or self.ask_yes_no('Do you really want to exit ([y]/n)?','y','n'):
+                    self.ask_exit()
+
+            else:
+                if code:
+                    self.run_cell(code, store_history=True)
+
+    def mainloop(self):
+        # An extra layer of protection in case someone mashing Ctrl-C breaks
+        # out of our internal code.
+        while True:
+            try:
+                self.interact()
+                break
+            except KeyboardInterrupt as e:
+                print("\n%s escaped interact()\n" % type(e).__name__)
+            finally:
+                # An interrupt during the eventloop will mess up the
+                # internal state of the prompt_toolkit library.
+                # Stopping the eventloop fixes this, see
+                # https://github.com/ipython/ipython/pull/9867
+                if hasattr(self, '_eventloop'):
+                    self._eventloop.stop()
+
+                self.restore_term_title()
+
+        # try to call some at-exit operation optimistically as some things can't
+        # be done during interpreter shutdown. this is technically inaccurate as
+        # this make mainlool not re-callable, but that should be a rare if not
+        # in existent use case.
+
+        self._atexit_once()
+
+    _inputhook = None
+    def inputhook(self, context):
+        warn(
+            "inputkook seem unused, and marked for deprecation/Removal as of IPython 9.0. "
+            "Please open an issue if you are using it.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        if self._inputhook is not None:
+            self._inputhook(context)
+
+    active_eventloop: Optional[str] = None
+
+    def enable_gui(self, gui: Optional[str] = None) -> None:
+        if gui:
+            from ..core.pylabtools import _convert_gui_from_matplotlib
+
+            gui = _convert_gui_from_matplotlib(gui)
+
+        if self.simple_prompt is True and gui is not None:
+            print(
+                f'Cannot install event loop hook for "{gui}" when running with `--simple-prompt`.'
+            )
+            print(
+                "NOTE: Tk is supported natively; use Tk apps and Tk backends with `--simple-prompt`."
+            )
+            return
+
+        if self._inputhook is None and gui is None:
+            print("No event loop hook running.")
+            return
+
+        if self._inputhook is not None and gui is not None:
+            newev, newinhook = get_inputhook_name_and_func(gui)
+            if self._inputhook == newinhook:
+                # same inputhook, do nothing
+                self.log.info(
+                    f"Shell is already running the {self.active_eventloop} eventloop. Doing nothing"
+                )
+                return
+            self.log.warning(
+                f"Shell is already running a different gui event loop for {self.active_eventloop}. "
+                "Call with no arguments to disable the current loop."
+            )
+            return
+        if self._inputhook is not None and gui is None:
+            self.active_eventloop = self._inputhook = None
+
+        if gui and (gui not in {None, "webagg"}):
+            # This hook runs with each cycle of the `prompt_toolkit`'s event loop.
+            self.active_eventloop, self._inputhook = get_inputhook_name_and_func(gui)
+        else:
+            self.active_eventloop = self._inputhook = None
+
+        self._use_asyncio_inputhook = gui == "asyncio"
+
+    # Run !system commands directly, not through pipes, so terminal programs
+    # work correctly.
+    system = InteractiveShell.system_raw
+
+    def auto_rewrite_input(self, cmd):
+        """Overridden from the parent class to use fancy rewriting prompt"""
+        if not self.show_rewritten_input:
+            return
+
+        tokens = self.prompts.rewrite_prompt_tokens()
+        if self.pt_app:
+            print_formatted_text(PygmentsTokens(tokens), end='',
+                                 style=self.pt_app.app.style)
+            print(cmd)
+        else:
+            prompt = ''.join(s for t, s in tokens)
+            print(prompt, cmd, sep='')
+
+    _prompts_before = None
+    def switch_doctest_mode(self, mode):
+        """Switch prompts to classic for %doctest_mode"""
+        if mode:
+            self._prompts_before = self.prompts
+            self.prompts = ClassicPrompts(self)
+        elif self._prompts_before:
+            self.prompts = self._prompts_before
+            self._prompts_before = None
+#        self._update_layout()
+
+
+InteractiveShellABC.register(TerminalInteractiveShell)
+
+if __name__ == '__main__':
+    TerminalInteractiveShell.instance().interact()
diff --git a/IPython/terminal/ipapp.py b/IPython/terminal/ipapp.py
new file mode 100755
index 00000000000..baef253c94f
--- /dev/null
+++ b/IPython/terminal/ipapp.py
@@ -0,0 +1,346 @@
+# encoding: utf-8
+"""
+The :class:`~traitlets.config.application.Application` object for the command
+line :command:`ipython` program.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import logging
+import os
+import sys
+import warnings
+
+from traitlets.config.loader import Config
+from traitlets.config.application import boolean_flag, catch_config_error
+from IPython.core import release
+from IPython.core import usage
+from IPython.core.completer import IPCompleter
+from IPython.core.crashhandler import CrashHandler
+from IPython.core.formatters import PlainTextFormatter
+from IPython.core.history import HistoryManager
+from IPython.core.application import (
+    ProfileDir, BaseIPythonApplication, base_flags, base_aliases
+)
+from IPython.core.magic import MagicsManager
+from IPython.core.magics import (
+    ScriptMagics, LoggingMagics
+)
+from IPython.core.shellapp import (
+    InteractiveShellApp, shell_flags, shell_aliases
+)
+from IPython.extensions.storemagic import StoreMagics
+from .interactiveshell import TerminalInteractiveShell
+from IPython.paths import get_ipython_dir
+from traitlets import (
+    Bool, List, default, observe, Type
+)
+
+#-----------------------------------------------------------------------------
+# Globals, utilities and helpers
+#-----------------------------------------------------------------------------
+
+_examples = """
+ipython --matplotlib       # enable matplotlib integration
+ipython --matplotlib=qt    # enable matplotlib integration with qt4 backend
+
+ipython --log-level=DEBUG  # set logging to DEBUG
+ipython --profile=foo      # start with profile foo
+
+ipython profile create foo # create profile foo w/ default config files
+ipython help profile       # show the help for the profile subcmd
+
+ipython locate             # print the path to the IPython directory
+ipython locate profile foo # print the path to the directory for profile `foo`
+"""
+
+#-----------------------------------------------------------------------------
+# Crash handler for this application
+#-----------------------------------------------------------------------------
+
+class IPAppCrashHandler(CrashHandler):
+    """sys.excepthook for IPython itself, leaves a detailed report on disk."""
+
+    def __init__(self, app):
+        contact_name = release.author
+        contact_email = release.author_email
+        bug_tracker = 'https://github.com/ipython/ipython/issues'
+        super(IPAppCrashHandler,self).__init__(
+            app, contact_name, contact_email, bug_tracker
+        )
+
+    def make_report(self,traceback):
+        """Return a string containing a crash report."""
+
+        sec_sep = self.section_sep
+        # Start with parent report
+        report = [super(IPAppCrashHandler, self).make_report(traceback)]
+        # Add interactive-specific info we may have
+        rpt_add = report.append
+        try:
+            rpt_add(sec_sep+"History of session input:")
+            for line in self.app.shell.user_ns['_ih']:
+                rpt_add(line)
+            rpt_add('\n*** Last line of input (may not be in above history):\n')
+            rpt_add(self.app.shell._last_input_line+'\n')
+        except:
+            pass
+
+        return ''.join(report)
+
+#-----------------------------------------------------------------------------
+# Aliases and Flags
+#-----------------------------------------------------------------------------
+flags = dict(base_flags)
+flags.update(shell_flags)
+frontend_flags = {}
+addflag = lambda *args: frontend_flags.update(boolean_flag(*args))
+addflag('autoedit-syntax', 'TerminalInteractiveShell.autoedit_syntax',
+        'Turn on auto editing of files with syntax errors.',
+        'Turn off auto editing of files with syntax errors.'
+)
+addflag('simple-prompt', 'TerminalInteractiveShell.simple_prompt',
+        "Force simple minimal prompt using `raw_input`",
+        "Use a rich interactive prompt with prompt_toolkit",
+)
+
+addflag('banner', 'TerminalIPythonApp.display_banner',
+        "Display a banner upon starting IPython.",
+        "Don't display a banner upon starting IPython."
+)
+addflag('confirm-exit', 'TerminalInteractiveShell.confirm_exit',
+    """Set to confirm when you try to exit IPython with an EOF (Control-D
+    in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
+    you can force a direct exit without any confirmation.""",
+    "Don't prompt the user when exiting."
+)
+addflag(
+    "tip",
+    "TerminalInteractiveShell.enable_tip",
+    """Shows a tip when IPython starts.""",
+    "Don't show tip when IPython starts.",
+)
+addflag('term-title', 'TerminalInteractiveShell.term_title',
+    "Enable auto setting the terminal title.",
+    "Disable auto setting the terminal title."
+)
+classic_config = Config()
+classic_config.InteractiveShell.cache_size = 0
+classic_config.PlainTextFormatter.pprint = False
+classic_config.TerminalInteractiveShell.prompts_class = (
+    "IPython.terminal.prompts.ClassicPrompts"
+)
+classic_config.InteractiveShell.separate_in = ""
+classic_config.InteractiveShell.separate_out = ""
+classic_config.InteractiveShell.separate_out2 = ""
+classic_config.InteractiveShell.colors = "nocolor"
+classic_config.InteractiveShell.xmode = "Plain"
+
+frontend_flags['classic']=(
+    classic_config,
+    "Gives IPython a similar feel to the classic Python prompt."
+)
+# # log doesn't make so much sense this way anymore
+# paa('--log','-l',
+#     action='store_true', dest='InteractiveShell.logstart',
+#     help="Start logging to the default log file (./ipython_log.py).")
+#
+# # quick is harder to implement
+frontend_flags['quick']=(
+    {'TerminalIPythonApp' : {'quick' : True}},
+    "Enable quick startup with no config files."
+)
+
+frontend_flags['i'] = (
+    {'TerminalIPythonApp' : {'force_interact' : True}},
+    """If running code from the command line, become interactive afterwards.
+    It is often useful to follow this with `--` to treat remaining flags as
+    script arguments.
+    """
+)
+flags.update(frontend_flags)
+
+aliases = dict(base_aliases)
+aliases.update(shell_aliases)  # type: ignore[arg-type]
+
+#-----------------------------------------------------------------------------
+# Main classes and functions
+#-----------------------------------------------------------------------------
+
+
+class LocateIPythonApp(BaseIPythonApplication):
+    description = """print the path to the IPython dir"""
+    subcommands = dict(
+        profile=('IPython.core.profileapp.ProfileLocate',
+            "print the path to an IPython profile directory",
+        ),
+    )
+    def start(self):
+        if self.subapp is not None:
+            return self.subapp.start()
+        else:
+            print(self.ipython_dir)
+
+
+class TerminalIPythonApp(BaseIPythonApplication, InteractiveShellApp):
+    name = "ipython"
+    description = usage.cl_usage
+    crash_handler_class = IPAppCrashHandler  # typing: ignore[assignment]
+    examples = _examples
+
+    flags = flags
+    aliases = aliases
+    classes = List()
+
+    interactive_shell_class = Type(
+        klass=object,   # use default_value otherwise which only allow subclasses.
+        default_value=TerminalInteractiveShell,
+        help="Class to use to instantiate the TerminalInteractiveShell object. Useful for custom Frontends"
+    ).tag(config=True)
+
+    @default('classes')
+    def _classes_default(self):
+        """This has to be in a method, for TerminalIPythonApp to be available."""
+        return [
+            InteractiveShellApp,  # ShellApp comes before TerminalApp, because
+            self.__class__,      # it will also affect subclasses (e.g. QtConsole)
+            TerminalInteractiveShell,
+            HistoryManager,
+            MagicsManager,
+            ProfileDir,
+            PlainTextFormatter,
+            IPCompleter,
+            ScriptMagics,
+            LoggingMagics,
+            StoreMagics,
+        ]
+
+    subcommands = dict(
+        profile = ("IPython.core.profileapp.ProfileApp",
+            "Create and manage IPython profiles."
+        ),
+        kernel = ("ipykernel.kernelapp.IPKernelApp",
+            "Start a kernel without an attached frontend."
+        ),
+        locate=('IPython.terminal.ipapp.LocateIPythonApp',
+            LocateIPythonApp.description
+        ),
+        history=('IPython.core.historyapp.HistoryApp',
+            "Manage the IPython history database."
+        ),
+    )
+
+    # *do* autocreate requested profile, but don't create the config file.
+    auto_create = Bool(True).tag(config=True)
+
+    # configurables
+    quick = Bool(False,
+        help="""Start IPython quickly by skipping the loading of config files."""
+    ).tag(config=True)
+    @observe('quick')
+    def _quick_changed(self, change):
+        if change['new']:
+            self.load_config_file = lambda *a, **kw: None
+
+    display_banner = Bool(True,
+        help="Whether to display a banner upon starting IPython."
+    ).tag(config=True)
+
+    # if there is code of files to run from the cmd line, don't interact
+    # unless the --i flag (App.force_interact) is true.
+    force_interact = Bool(False,
+        help="""If a command or file is given via the command-line,
+        e.g. 'ipython foo.py', start an interactive shell after executing the
+        file or command."""
+    ).tag(config=True)
+    @observe('force_interact')
+    def _force_interact_changed(self, change):
+        if change['new']:
+            self.interact = True
+
+    @observe('file_to_run', 'code_to_run', 'module_to_run')
+    def _file_to_run_changed(self, change):
+        new = change['new']
+        if new:
+            self.something_to_run = True
+        if new and not self.force_interact:
+                self.interact = False
+
+    # internal, not-configurable
+    something_to_run=Bool(False)
+
+    @catch_config_error
+    def initialize(self, argv=None):
+        """Do actions after construct, but before starting the app."""
+        super(TerminalIPythonApp, self).initialize(argv)
+        if self.subapp is not None:
+            # don't bother initializing further, starting subapp
+            return
+        # print(self.extra_args)
+        if self.extra_args and not self.something_to_run:
+            self.file_to_run = self.extra_args[0]
+        self.init_path()
+        # create the shell
+        self.init_shell()
+        # and draw the banner
+        self.init_banner()
+        # Now a variety of things that happen after the banner is printed.
+        self.init_gui_pylab()
+        self.init_extensions()
+        self.init_code()
+
+    def init_shell(self):
+        """initialize the InteractiveShell instance"""
+        # Create an InteractiveShell instance.
+        # shell.display_banner should always be False for the terminal
+        # based app, because we call shell.show_banner() by hand below
+        # so the banner shows *before* all extension loading stuff.
+        self.shell = self.interactive_shell_class.instance(parent=self,
+                        profile_dir=self.profile_dir,
+                        ipython_dir=self.ipython_dir, user_ns=self.user_ns)
+        self.shell.configurables.append(self)
+
+    def init_banner(self):
+        """optionally display the banner"""
+        if self.display_banner and self.interact:
+            self.shell.show_banner()
+        # Make sure there is a space below the banner.
+        if self.log_level <= logging.INFO: print()
+
+    def _pylab_changed(self, name, old, new):
+        """Replace --pylab='inline' with --pylab='auto'"""
+        if new == 'inline':
+            warnings.warn("'inline' not available as pylab backend, "
+                      "using 'auto' instead.")
+            self.pylab = 'auto'
+
+    def start(self):
+        if self.subapp is not None:
+            return self.subapp.start()
+        # perform any prexec steps:
+        if self.interact:
+            self.log.debug("Starting IPython's mainloop...")
+            self.shell.mainloop()
+        else:
+            self.log.debug("IPython not interactive...")
+            self.shell.restore_term_title()
+            if not self.shell.last_execution_succeeded:
+                sys.exit(1)
+
+def load_default_config(ipython_dir=None):
+    """Load the default config file from the default ipython_dir.
+
+    This is useful for embedded shells.
+    """
+    if ipython_dir is None:
+        ipython_dir = get_ipython_dir()
+
+    profile_dir = os.path.join(ipython_dir, 'profile_default')
+    app = TerminalIPythonApp()
+    app.config_file_paths.append(profile_dir)
+    app.load_config_file()
+    return app.config
+
+launch_new_instance = TerminalIPythonApp.launch_instance
diff --git a/IPython/terminal/magics.py b/IPython/terminal/magics.py
new file mode 100644
index 00000000000..cea53e4a248
--- /dev/null
+++ b/IPython/terminal/magics.py
@@ -0,0 +1,214 @@
+"""Extra magics for terminal use."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+from logging import error
+import os
+import sys
+
+from IPython.core.error import TryNext, UsageError
+from IPython.core.magic import Magics, magics_class, line_magic
+from IPython.lib.clipboard import ClipboardEmpty
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.text import SList, strip_email_quotes
+from IPython.utils import py3compat
+
+def get_pasted_lines(sentinel, l_input=py3compat.input, quiet=False):
+    """ Yield pasted lines until the user enters the given sentinel value.
+    """
+    if not quiet:
+        print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
+              % sentinel)
+        prompt = ":"
+    else:
+        prompt = ""
+    while True:
+        try:
+            l = l_input(prompt)
+            if l == sentinel:
+                return
+            else:
+                yield l
+        except EOFError:
+            print('<EOF>')
+            return
+
+
+@magics_class
+class TerminalMagics(Magics):
+    def __init__(self, shell):
+        super(TerminalMagics, self).__init__(shell)
+
+    def store_or_execute(self, block, name, store_history=False):
+        """ Execute a block, or store it in a variable, per the user's request.
+        """
+        if name:
+            # If storing it for further editing
+            self.shell.user_ns[name] = SList(block.splitlines())
+            print("Block assigned to '%s'" % name)
+        else:
+            b = self.preclean_input(block)
+            self.shell.user_ns['pasted_block'] = b
+            self.shell.using_paste_magics = True
+            try:
+                self.shell.run_cell(b, store_history)
+            finally:
+                self.shell.using_paste_magics = False
+
+    def preclean_input(self, block):
+        lines = block.splitlines()
+        while lines and not lines[0].strip():
+            lines = lines[1:]
+        return strip_email_quotes('\n'.join(lines))
+
+    def rerun_pasted(self, name='pasted_block'):
+        """ Rerun a previously pasted command.
+        """
+        b = self.shell.user_ns.get(name)
+
+        # Sanity checks
+        if b is None:
+            raise UsageError('No previous pasted block available')
+        if not isinstance(b, str):
+            raise UsageError(
+                "Variable 'pasted_block' is not a string, can't execute")
+
+        print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
+        self.shell.run_cell(b)
+
+    @line_magic
+    def autoindent(self, parameter_s = ''):
+        """Toggle autoindent on/off (deprecated)"""
+        self.shell.set_autoindent()
+        print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
+
+    @skip_doctest
+    @line_magic
+    def cpaste(self, parameter_s=''):
+        """Paste & execute a pre-formatted code block from clipboard.
+
+        You must terminate the block with '--' (two minus-signs) or Ctrl-D
+        alone on the line. You can also provide your own sentinel with '%paste
+        -s %%' ('%%' is the new sentinel for this operation).
+
+        The block is dedented prior to execution to enable execution of method
+        definitions. '>' and '+' characters at the beginning of a line are
+        ignored, to allow pasting directly from e-mails, diff files and
+        doctests (the '...' continuation prompt is also stripped).  The
+        executed block is also assigned to variable named 'pasted_block' for
+        later editing with '%edit pasted_block'.
+
+        You can also pass a variable name as an argument, e.g. '%cpaste foo'.
+        This assigns the pasted block to variable 'foo' as string, without
+        dedenting or executing it (preceding >>> and + is still stripped)
+
+        '%cpaste -r' re-executes the block previously entered by cpaste.
+        '%cpaste -q' suppresses any additional output messages.
+
+        Do not be alarmed by garbled output on Windows (it's a readline bug).
+        Just press enter and type -- (and press enter again) and the block
+        will be what was just pasted.
+
+        Shell escapes are not supported (yet).
+
+        See Also
+        --------
+        paste : automatically pull code from clipboard.
+
+        Examples
+        --------
+        ::
+
+          In [8]: %cpaste
+          Pasting code; enter '--' alone on the line to stop.
+          :>>> a = ["world!", "Hello"]
+          :>>> print(" ".join(sorted(a)))
+          :--
+          Hello world!
+
+        ::
+          In [8]: %cpaste
+          Pasting code; enter '--' alone on the line to stop.
+          :>>> %alias_magic t timeit
+          :>>> %t -n1 pass
+          :--
+          Created `%t` as an alias for `%timeit`.
+          Created `%%t` as an alias for `%%timeit`.
+          354 ns ± 224 ns per loop (mean ± std. dev. of 7 runs, 1 loop each)
+        """
+        opts, name = self.parse_options(parameter_s, 'rqs:', mode='string')
+        if 'r' in opts:
+            self.rerun_pasted()
+            return
+
+        quiet = ('q' in opts)
+
+        sentinel = opts.get('s', u'--')
+        block = '\n'.join(get_pasted_lines(sentinel, quiet=quiet))
+        self.store_or_execute(block, name, store_history=True)
+
+    @line_magic
+    def paste(self, parameter_s=''):
+        """Paste & execute a pre-formatted code block from clipboard.
+
+        The text is pulled directly from the clipboard without user
+        intervention and printed back on the screen before execution (unless
+        the -q flag is given to force quiet mode).
+
+        The block is dedented prior to execution to enable execution of method
+        definitions. '>' and '+' characters at the beginning of a line are
+        ignored, to allow pasting directly from e-mails, diff files and
+        doctests (the '...' continuation prompt is also stripped).  The
+        executed block is also assigned to variable named 'pasted_block' for
+        later editing with '%edit pasted_block'.
+
+        You can also pass a variable name as an argument, e.g. '%paste foo'.
+        This assigns the pasted block to variable 'foo' as string, without
+        executing it (preceding >>> and + is still stripped).
+
+        Options:
+
+          -r: re-executes the block previously entered by cpaste.
+
+          -q: quiet mode: do not echo the pasted text back to the terminal.
+
+        IPython statements (magics, shell escapes) are not supported (yet).
+
+        See Also
+        --------
+        cpaste : manually paste code into terminal until you mark its end.
+        """
+        opts, name = self.parse_options(parameter_s, 'rq', mode='string')
+        if 'r' in opts:
+            self.rerun_pasted()
+            return
+        try:
+            block = self.shell.hooks.clipboard_get()
+        except TryNext as clipboard_exc:
+            message = getattr(clipboard_exc, 'args')
+            if message:
+                error(message[0])
+            else:
+                error('Could not get text from the clipboard.')
+            return
+        except ClipboardEmpty as e:
+            raise UsageError("The clipboard appears to be empty") from e
+
+        # By default, echo back to terminal unless quiet mode is requested
+        if 'q' not in opts:
+            sys.stdout.write(self.shell.pycolorize(block))
+            if not block.endswith("\n"):
+                sys.stdout.write("\n")
+            sys.stdout.write("## -- End pasted text --\n")
+
+        self.store_or_execute(block, name, store_history=True)
+
+    # Class-level: add a '%cls' magic only on Windows
+    if sys.platform == 'win32':
+        @line_magic
+        def cls(self, s):
+            """Clear screen.
+            """
+            os.system("cls")
diff --git a/IPython/terminal/prompts.py b/IPython/terminal/prompts.py
new file mode 100644
index 00000000000..1de6cf235db
--- /dev/null
+++ b/IPython/terminal/prompts.py
@@ -0,0 +1,141 @@
+"""Terminal input and output prompts."""
+
+from pygments.token import Token
+import sys
+
+from IPython.core.displayhook import DisplayHook
+
+from prompt_toolkit.formatted_text import fragment_list_width, PygmentsTokens
+from prompt_toolkit.shortcuts import print_formatted_text
+from prompt_toolkit.enums import EditingMode
+
+
+class Prompts:
+    def __init__(self, shell):
+        self.shell = shell
+
+    def vi_mode(self):
+        if (getattr(self.shell.pt_app, 'editing_mode', None) == EditingMode.VI
+                and self.shell.prompt_includes_vi_mode):
+            mode = str(self.shell.pt_app.app.vi_state.input_mode)
+            if mode.startswith('InputMode.'):
+                mode = mode[10:13].lower()
+            elif mode.startswith('vi-'):
+                mode = mode[3:6]
+            return '['+mode+'] '
+        return ''
+
+    def current_line(self) -> int:
+        if self.shell.pt_app is not None:
+            return self.shell.pt_app.default_buffer.document.cursor_position_row or 0
+        return 0
+
+    def in_prompt_tokens(self):
+        return [
+            (Token.Prompt.Mode, self.vi_mode()),
+            (
+                Token.Prompt.LineNumber,
+                self.shell.prompt_line_number_format.format(
+                    line=1, rel_line=-self.current_line()
+                ),
+            ),
+            (Token.Prompt, "In ["),
+            (Token.PromptNum, str(self.shell.execution_count)),
+            (Token.Prompt, ']: '),
+        ]
+
+    def _width(self):
+        return fragment_list_width(self.in_prompt_tokens())
+
+    def continuation_prompt_tokens(
+        self,
+        width: int | None = None,
+        *,
+        lineno: int | None = None,
+        wrap_count: int | None = None,
+    ):
+        if width is None:
+            width = self._width()
+        line = lineno + 1 if lineno is not None else 0
+        if wrap_count:
+            return [
+                (
+                    Token.Prompt.Wrap,
+                    # (" " * (width - 2)) + "\N{HORIZONTAL ELLIPSIS} ",
+                    (" " * (width - 2)) + "\N{VERTICAL ELLIPSIS} ",
+                ),
+            ]
+        prefix = " " * len(
+            self.vi_mode()
+        ) + self.shell.prompt_line_number_format.format(
+            line=line, rel_line=line - self.current_line() - 1
+        )
+        return [
+            (
+                getattr(Token.Prompt.Continuation, f"L{lineno}"),
+                prefix + (" " * (width - len(prefix) - 5)) + "...:",
+            ),
+            (Token.Prompt.Padding, " "),
+        ]
+
+    def rewrite_prompt_tokens(self):
+        width = self._width()
+        return [
+            (Token.Prompt, ('-' * (width - 2)) + '> '),
+        ]
+
+    def out_prompt_tokens(self):
+        return [
+            (Token.OutPrompt, 'Out['),
+            (Token.OutPromptNum, str(self.shell.execution_count - 1)),
+            (Token.OutPrompt, ']: '),
+        ]
+
+class ClassicPrompts(Prompts):
+    def in_prompt_tokens(self):
+        return [
+            (Token.Prompt, '>>> '),
+        ]
+
+    def continuation_prompt_tokens(self, width=None):
+        return [(Token.Prompt.Continuation, "... ")]
+
+    def rewrite_prompt_tokens(self):
+        return []
+
+    def out_prompt_tokens(self):
+        return []
+
+class RichPromptDisplayHook(DisplayHook):
+    """Subclass of base display hook using coloured prompt"""
+    def write_output_prompt(self):
+        sys.stdout.write(self.shell.separate_out)
+        # If we're not displaying a prompt, it effectively ends with a newline,
+        # because the output will be left-aligned.
+        self.prompt_end_newline = True
+
+        if self.do_full_cache:
+            tokens = self.shell.prompts.out_prompt_tokens()
+            prompt_txt = "".join(s for _, s in tokens)
+            if prompt_txt and not prompt_txt.endswith("\n"):
+                # Ask for a newline before multiline output
+                self.prompt_end_newline = False
+
+            if self.shell.pt_app:
+                print_formatted_text(PygmentsTokens(tokens),
+                    style=self.shell.pt_app.app.style, end='',
+                )
+            else:
+                sys.stdout.write(prompt_txt)
+
+    def write_format_data(self, format_dict, md_dict=None) -> None:
+        assert self.shell is not None
+        if self.shell.mime_renderers:
+
+            for mime, handler in self.shell.mime_renderers.items():
+                if mime in format_dict:
+                    handler(format_dict[mime], None)
+                    return
+                
+        super().write_format_data(format_dict, md_dict)
+
diff --git a/IPython/terminal/pt_inputhooks/__init__.py b/IPython/terminal/pt_inputhooks/__init__.py
new file mode 100644
index 00000000000..d99ebfe1f5e
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/__init__.py
@@ -0,0 +1,140 @@
+import importlib
+import os
+from typing import Tuple
+from collections.abc import Callable
+
+aliases = {
+    'qt4': 'qt',
+    'gtk2': 'gtk',
+}
+
+backends = [
+    "qt",
+    "qt5",
+    "qt6",
+    "gtk",
+    "gtk2",
+    "gtk3",
+    "gtk4",
+    "tk",
+    "wx",
+    "pyglet",
+    "glut",
+    "osx",
+    "asyncio",
+]
+
+registered = {}
+
+def register(name, inputhook):
+    """Register the function *inputhook* as an event loop integration."""
+    registered[name] = inputhook
+
+
+class UnknownBackend(KeyError):
+    def __init__(self, name):
+        self.name = name
+
+    def __str__(self):
+        return ("No event loop integration for {!r}. "
+                "Supported event loops are: {}").format(self.name,
+                                    ', '.join(backends + sorted(registered)))
+
+
+def set_qt_api(gui):
+    """Sets the `QT_API` environment variable if it isn't already set."""
+
+    qt_api = os.environ.get("QT_API", None)
+
+    from IPython.external.qt_loaders import (
+        QT_API_PYQT,
+        QT_API_PYQT5,
+        QT_API_PYQT6,
+        QT_API_PYSIDE,
+        QT_API_PYSIDE2,
+        QT_API_PYSIDE6,
+        QT_API_PYQTv1,
+        loaded_api,
+    )
+
+    loaded = loaded_api()
+
+    qt_env2gui = {
+        QT_API_PYSIDE: "qt4",
+        QT_API_PYQTv1: "qt4",
+        QT_API_PYQT: "qt4",
+        QT_API_PYSIDE2: "qt5",
+        QT_API_PYQT5: "qt5",
+        QT_API_PYSIDE6: "qt6",
+        QT_API_PYQT6: "qt6",
+    }
+    if loaded is not None and gui != "qt":
+        if qt_env2gui[loaded] != gui:
+            print(
+                f"Cannot switch Qt versions for this session; will use {qt_env2gui[loaded]}."
+            )
+            return qt_env2gui[loaded]
+
+    if qt_api is not None and gui != "qt":
+        if qt_env2gui[qt_api] != gui:
+            print(
+                f'Request for "{gui}" will be ignored because `QT_API` '
+                f'environment variable is set to "{qt_api}"'
+            )
+            return qt_env2gui[qt_api]
+    else:
+        if gui == "qt5":
+            try:
+                import PyQt5  # noqa
+
+                os.environ["QT_API"] = "pyqt5"
+            except ImportError:
+                try:
+                    import PySide2  # noqa
+
+                    os.environ["QT_API"] = "pyside2"
+                except ImportError:
+                    os.environ["QT_API"] = "pyqt5"
+        elif gui == "qt6":
+            try:
+                import PyQt6  # noqa
+
+                os.environ["QT_API"] = "pyqt6"
+            except ImportError:
+                try:
+                    import PySide6  # noqa
+
+                    os.environ["QT_API"] = "pyside6"
+                except ImportError:
+                    os.environ["QT_API"] = "pyqt6"
+        elif gui == "qt":
+            # Don't set QT_API; let IPython logic choose the version.
+            if "QT_API" in os.environ.keys():
+                del os.environ["QT_API"]
+        else:
+            print(f'Unrecognized Qt version: {gui}. Should be "qt5", "qt6", or "qt".')
+            return
+
+        # Import it now so we can figure out which version it is.
+        from IPython.external.qt_for_kernel import QT_API
+
+        return qt_env2gui[QT_API]
+
+
+def get_inputhook_name_and_func(gui: str) -> Tuple[str, Callable]:
+    if gui in registered:
+        return gui, registered[gui]
+
+    if gui not in backends:
+        raise UnknownBackend(gui)
+
+    if gui in aliases:
+        return get_inputhook_name_and_func(aliases[gui])
+
+    gui_mod = gui
+    if gui.startswith("qt"):
+        gui = set_qt_api(gui)
+        gui_mod = "qt"
+
+    mod = importlib.import_module("IPython.terminal.pt_inputhooks." + gui_mod)
+    return gui, mod.inputhook
diff --git a/IPython/terminal/pt_inputhooks/asyncio.py b/IPython/terminal/pt_inputhooks/asyncio.py
new file mode 100644
index 00000000000..f6ab6e00d18
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/asyncio.py
@@ -0,0 +1,40 @@
+"""
+Inputhook for running the original asyncio event loop while we're waiting for
+input.
+
+By default, in IPython, we run the prompt with a different asyncio event loop,
+because otherwise we risk that people are freezing the prompt by scheduling bad
+coroutines. E.g., a coroutine that does a while/true and never yield back
+control to the loop. We can't cancel that.
+
+However, sometimes we want the asyncio loop to keep running while waiting for
+a prompt.
+
+The following example will print the numbers from 1 to 10 above the prompt,
+while we are waiting for input. (This works also because we use
+prompt_toolkit`s `patch_stdout`)::
+
+    In [1]: import asyncio
+
+    In [2]: %gui asyncio
+
+    In [3]: async def f():
+       ...:     for i in range(10):
+       ...:         await asyncio.sleep(1)
+       ...:         print(i)
+
+
+    In [4]: asyncio.ensure_future(f())
+
+"""
+
+
+def inputhook(context):
+    """
+    Inputhook for asyncio event loop integration.
+    """
+    # For prompt_toolkit 3.0, this input hook literally doesn't do anything.
+    # The event loop integration here is implemented in `interactiveshell.py`
+    # by running the prompt itself in the current asyncio loop. The main reason
+    # for this is that nesting asyncio event loops is unreliable.
+    return
diff --git a/IPython/terminal/pt_inputhooks/glut.py b/IPython/terminal/pt_inputhooks/glut.py
new file mode 100644
index 00000000000..63d020b314f
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/glut.py
@@ -0,0 +1,140 @@
+"""GLUT Input hook for interactive use with prompt_toolkit
+"""
+
+
+# GLUT is quite an old library and it is difficult to ensure proper
+# integration within IPython since original GLUT does not allow to handle
+# events one by one. Instead, it requires for the mainloop to be entered
+# and never returned (there is not even a function to exit he
+# mainloop). Fortunately, there are alternatives such as freeglut
+# (available for linux and windows) and the OSX implementation gives
+# access to a glutCheckLoop() function that blocks itself until a new
+# event is received. This means we have to setup the idle callback to
+# ensure we got at least one event that will unblock the function.
+#
+# Furthermore, it is not possible to install these handlers without a window
+# being first created. We choose to make this window invisible. This means that
+# display mode options are set at this level and user won't be able to change
+# them later without modifying the code. This should probably be made available
+# via IPython options system.
+
+import sys
+import time
+import signal
+import OpenGL.GLUT as glut
+import OpenGL.platform as platform
+from timeit import default_timer as clock
+
+# Frame per second : 60
+# Should probably be an IPython option
+glut_fps = 60
+
+# Display mode : double buffeed + rgba + depth
+# Should probably be an IPython option
+glut_display_mode = (glut.GLUT_DOUBLE |
+                     glut.GLUT_RGBA   |
+                     glut.GLUT_DEPTH)
+
+glutMainLoopEvent = None
+if sys.platform == 'darwin':
+    try:
+        glutCheckLoop = platform.createBaseFunction(
+            'glutCheckLoop', dll=platform.GLUT, resultType=None,
+            argTypes=[],
+            doc='glutCheckLoop(  ) -> None',
+            argNames=(),
+            )
+    except AttributeError as e:
+        raise RuntimeError(
+            '''Your glut implementation does not allow interactive sessions. '''
+            '''Consider installing freeglut.''') from e
+    glutMainLoopEvent = glutCheckLoop
+elif glut.HAVE_FREEGLUT:
+    glutMainLoopEvent = glut.glutMainLoopEvent
+else:
+    raise RuntimeError(
+        '''Your glut implementation does not allow interactive sessions. '''
+        '''Consider installing freeglut.''')
+
+
+def glut_display():
+    # Dummy display function
+    pass
+
+def glut_idle():
+    # Dummy idle function
+    pass
+
+def glut_close():
+    # Close function only hides the current window
+    glut.glutHideWindow()
+    glutMainLoopEvent()
+
+def glut_int_handler(signum, frame):
+    # Catch sigint and print the defaultipyt   message
+    signal.signal(signal.SIGINT, signal.default_int_handler)
+    print('\nKeyboardInterrupt')
+    # Need to reprint the prompt at this stage
+
+# Initialisation code
+glut.glutInit( sys.argv )
+glut.glutInitDisplayMode( glut_display_mode )
+# This is specific to freeglut
+if bool(glut.glutSetOption):
+    glut.glutSetOption( glut.GLUT_ACTION_ON_WINDOW_CLOSE,
+                        glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS )
+glut.glutCreateWindow( b'ipython' )
+glut.glutReshapeWindow( 1, 1 )
+glut.glutHideWindow( )
+glut.glutWMCloseFunc( glut_close )
+glut.glutDisplayFunc( glut_display )
+glut.glutIdleFunc( glut_idle )
+
+
+def inputhook(context):
+    """Run the pyglet event loop by processing pending events only.
+
+    This keeps processing pending events until stdin is ready.  After
+    processing all pending events, a call to time.sleep is inserted.  This is
+    needed, otherwise, CPU usage is at 100%.  This sleep time should be tuned
+    though for best performance.
+    """
+    # We need to protect against a user pressing Control-C when IPython is
+    # idle and this is running. We trap KeyboardInterrupt and pass.
+
+    signal.signal(signal.SIGINT, glut_int_handler)
+
+    try:
+        t = clock()
+
+        # Make sure the default window is set after a window has been closed
+        if glut.glutGetWindow() == 0:
+            glut.glutSetWindow( 1 )
+            glutMainLoopEvent()
+            return 0
+
+        while not context.input_is_ready():
+            glutMainLoopEvent()
+            # We need to sleep at this point to keep the idle CPU load
+            # low.  However, if sleep to long, GUI response is poor.  As
+            # a compromise, we watch how often GUI events are being processed
+            # and switch between a short and long sleep time.  Here are some
+            # stats useful in helping to tune this.
+            # time    CPU load
+            # 0.001   13%
+            # 0.005   3%
+            # 0.01    1.5%
+            # 0.05    0.5%
+            used_time = clock() - t
+            if used_time > 10.0:
+                # print('Sleep for 1 s')  # dbg
+                time.sleep(1.0)
+            elif used_time > 0.1:
+                # Few GUI events coming in, so we can sleep longer
+                # print('Sleep for 0.05 s')  # dbg
+                time.sleep(0.05)
+            else:
+                # Many GUI events coming in, so sleep only very little
+                time.sleep(0.001)
+    except KeyboardInterrupt:
+        pass
diff --git a/IPython/terminal/pt_inputhooks/gtk.py b/IPython/terminal/pt_inputhooks/gtk.py
new file mode 100644
index 00000000000..5c201b65d75
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/gtk.py
@@ -0,0 +1,60 @@
+# Code borrowed from python-prompt-toolkit examples
+# https://github.com/jonathanslenders/python-prompt-toolkit/blob/77cdcfbc7f4b4c34a9d2f9a34d422d7152f16209/examples/inputhook.py
+
+# Copyright (c) 2014, Jonathan Slenders
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# * Neither the name of the {organization} nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+PyGTK input hook for prompt_toolkit.
+
+Listens on the pipe prompt_toolkit sets up for a notification that it should
+return control to the terminal event loop.
+"""
+
+import gtk, gobject
+
+# Enable threading in GTK. (Otherwise, GTK will keep the GIL.)
+gtk.gdk.threads_init()
+
+
+def inputhook(context):
+    """
+    When the eventloop of prompt-toolkit is idle, call this inputhook.
+
+    This will run the GTK main loop until the file descriptor
+    `context.fileno()` becomes ready.
+
+    :param context: An `InputHookContext` instance.
+    """
+
+    def _main_quit(*a, **kw):
+        gtk.main_quit()
+        return False
+
+    gobject.io_add_watch(context.fileno(), gobject.IO_IN, _main_quit)
+    gtk.main()
diff --git a/IPython/terminal/pt_inputhooks/gtk3.py b/IPython/terminal/pt_inputhooks/gtk3.py
new file mode 100644
index 00000000000..63678bdbb84
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/gtk3.py
@@ -0,0 +1,13 @@
+"""prompt_toolkit input hook for GTK 3"""
+
+from gi.repository import Gtk, GLib
+
+
+def _main_quit(*args, **kwargs):
+    Gtk.main_quit()
+    return False
+
+
+def inputhook(context):
+    GLib.io_add_watch(context.fileno(), GLib.PRIORITY_DEFAULT, GLib.IO_IN, _main_quit)
+    Gtk.main()
diff --git a/IPython/terminal/pt_inputhooks/gtk4.py b/IPython/terminal/pt_inputhooks/gtk4.py
new file mode 100644
index 00000000000..009fbf12126
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/gtk4.py
@@ -0,0 +1,27 @@
+"""
+prompt_toolkit input hook for GTK 4.
+"""
+
+from gi.repository import GLib
+
+
+class _InputHook:
+    def __init__(self, context):
+        self._quit = False
+        GLib.io_add_watch(
+            context.fileno(), GLib.PRIORITY_DEFAULT, GLib.IO_IN, self.quit
+        )
+
+    def quit(self, *args, **kwargs):
+        self._quit = True
+        return False
+
+    def run(self):
+        context = GLib.MainContext.default()
+        while not self._quit:
+            context.iteration(True)
+
+
+def inputhook(context):
+    hook = _InputHook(context)
+    hook.run()
diff --git a/IPython/terminal/pt_inputhooks/osx.py b/IPython/terminal/pt_inputhooks/osx.py
new file mode 100644
index 00000000000..9b8a0cd98e2
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/osx.py
@@ -0,0 +1,147 @@
+"""Inputhook for OS X
+
+Calls NSApp / CoreFoundation APIs via ctypes.
+"""
+
+# obj-c boilerplate from appnope, used under BSD 2-clause
+
+import ctypes
+import ctypes.util
+from threading import Event
+
+objc = ctypes.cdll.LoadLibrary(ctypes.util.find_library("objc"))  # type: ignore
+
+void_p = ctypes.c_void_p
+
+objc.objc_getClass.restype = void_p
+objc.sel_registerName.restype = void_p
+objc.objc_msgSend.restype = void_p
+objc.objc_msgSend.argtypes = [void_p, void_p]
+
+msg = objc.objc_msgSend
+
+def _utf8(s):
+    """ensure utf8 bytes"""
+    if not isinstance(s, bytes):
+        s = s.encode('utf8')
+    return s
+
+def n(name):
+    """create a selector name (for ObjC methods)"""
+    return objc.sel_registerName(_utf8(name))
+
+def C(classname):
+    """get an ObjC Class by name"""
+    return objc.objc_getClass(_utf8(classname))
+
+# end obj-c boilerplate from appnope
+
+# CoreFoundation C-API calls we will use:
+CoreFoundation = ctypes.cdll.LoadLibrary(ctypes.util.find_library("CoreFoundation"))  # type: ignore
+
+CFFileDescriptorCreate = CoreFoundation.CFFileDescriptorCreate
+CFFileDescriptorCreate.restype = void_p
+CFFileDescriptorCreate.argtypes = [void_p, ctypes.c_int, ctypes.c_bool, void_p, void_p]
+
+CFFileDescriptorGetNativeDescriptor = CoreFoundation.CFFileDescriptorGetNativeDescriptor
+CFFileDescriptorGetNativeDescriptor.restype = ctypes.c_int
+CFFileDescriptorGetNativeDescriptor.argtypes = [void_p]
+
+CFFileDescriptorEnableCallBacks = CoreFoundation.CFFileDescriptorEnableCallBacks
+CFFileDescriptorEnableCallBacks.restype = None
+CFFileDescriptorEnableCallBacks.argtypes = [void_p, ctypes.c_ulong]
+
+CFFileDescriptorCreateRunLoopSource = CoreFoundation.CFFileDescriptorCreateRunLoopSource
+CFFileDescriptorCreateRunLoopSource.restype = void_p
+CFFileDescriptorCreateRunLoopSource.argtypes = [void_p, void_p, void_p]
+
+CFRunLoopGetCurrent = CoreFoundation.CFRunLoopGetCurrent
+CFRunLoopGetCurrent.restype = void_p
+
+CFRunLoopAddSource = CoreFoundation.CFRunLoopAddSource
+CFRunLoopAddSource.restype = None
+CFRunLoopAddSource.argtypes = [void_p, void_p, void_p]
+
+CFRelease = CoreFoundation.CFRelease
+CFRelease.restype = None
+CFRelease.argtypes = [void_p]
+
+CFFileDescriptorInvalidate = CoreFoundation.CFFileDescriptorInvalidate
+CFFileDescriptorInvalidate.restype = None
+CFFileDescriptorInvalidate.argtypes = [void_p]
+
+# From CFFileDescriptor.h
+kCFFileDescriptorReadCallBack = 1
+kCFRunLoopCommonModes = void_p.in_dll(CoreFoundation, 'kCFRunLoopCommonModes')
+
+
+def _NSApp():
+    """Return the global NSApplication instance (NSApp)"""
+    objc.objc_msgSend.argtypes = [void_p, void_p]
+    return msg(C('NSApplication'), n('sharedApplication'))
+
+
+def _wake(NSApp):
+    """Wake the Application"""
+    objc.objc_msgSend.argtypes = [
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+        void_p,
+    ]
+    event = msg(
+        C("NSEvent"),
+        n(
+            "otherEventWithType:location:modifierFlags:"
+            "timestamp:windowNumber:context:subtype:data1:data2:"
+        ),
+        15,  # Type
+        0,  # location
+        0,  # flags
+        0,  # timestamp
+        0,  # window
+        None,  # context
+        0,  # subtype
+        0,  # data1
+        0,  # data2
+    )
+    objc.objc_msgSend.argtypes = [void_p, void_p, void_p, void_p]
+    msg(NSApp, n('postEvent:atStart:'), void_p(event), True)
+
+
+def _input_callback(fdref, flags, info):
+    """Callback to fire when there's input to be read"""
+    CFFileDescriptorInvalidate(fdref)
+    CFRelease(fdref)
+    NSApp = _NSApp()
+    objc.objc_msgSend.argtypes = [void_p, void_p, void_p]
+    msg(NSApp, n('stop:'), NSApp)
+    _wake(NSApp)
+
+_c_callback_func_type = ctypes.CFUNCTYPE(None, void_p, void_p, void_p)
+_c_input_callback = _c_callback_func_type(_input_callback)
+
+
+def _stop_on_read(fd):
+    """Register callback to stop eventloop when there's data on fd"""
+    fdref = CFFileDescriptorCreate(None, fd, False, _c_input_callback, None)
+    CFFileDescriptorEnableCallBacks(fdref, kCFFileDescriptorReadCallBack)
+    source = CFFileDescriptorCreateRunLoopSource(None, fdref, 0)
+    loop = CFRunLoopGetCurrent()
+    CFRunLoopAddSource(loop, source, kCFRunLoopCommonModes)
+    CFRelease(source)
+
+
+def inputhook(context):
+    """Inputhook for Cocoa (NSApp)"""
+    NSApp = _NSApp()
+    _stop_on_read(context.fileno())
+    objc.objc_msgSend.argtypes = [void_p, void_p]
+    msg(NSApp, n('run'))
diff --git a/IPython/terminal/pt_inputhooks/pyglet.py b/IPython/terminal/pt_inputhooks/pyglet.py
new file mode 100644
index 00000000000..d7283adb612
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/pyglet.py
@@ -0,0 +1,67 @@
+"""Enable pyglet to be used interactively with prompt_toolkit"""
+
+import sys
+import time
+from timeit import default_timer as clock
+import pyglet
+
+# On linux only, window.flip() has a bug that causes an AttributeError on
+# window close.  For details, see:
+# http://groups.google.com/group/pyglet-users/browse_thread/thread/47c1aab9aa4a3d23/c22f9e819826799e?#c22f9e819826799e
+
+if sys.platform.startswith("linux"):
+
+    def flip(window):
+        try:
+            window.flip()
+        except AttributeError:
+            pass
+else:
+
+    def flip(window):
+        window.flip()
+
+
+def inputhook(context):
+    """Run the pyglet event loop by processing pending events only.
+
+    This keeps processing pending events until stdin is ready.  After
+    processing all pending events, a call to time.sleep is inserted.  This is
+    needed, otherwise, CPU usage is at 100%.  This sleep time should be tuned
+    though for best performance.
+    """
+    # We need to protect against a user pressing Control-C when IPython is
+    # idle and this is running. We trap KeyboardInterrupt and pass.
+    try:
+        t = clock()
+        while not context.input_is_ready():
+            pyglet.clock.tick()
+            for window in pyglet.app.windows:
+                window.switch_to()
+                window.dispatch_events()
+                window.dispatch_event("on_draw")
+                flip(window)
+
+            # We need to sleep at this point to keep the idle CPU load
+            # low.  However, if sleep to long, GUI response is poor.  As
+            # a compromise, we watch how often GUI events are being processed
+            # and switch between a short and long sleep time.  Here are some
+            # stats useful in helping to tune this.
+            # time    CPU load
+            # 0.001   13%
+            # 0.005   3%
+            # 0.01    1.5%
+            # 0.05    0.5%
+            used_time = clock() - t
+            if used_time > 10.0:
+                # print('Sleep for 1 s')  # dbg
+                time.sleep(1.0)
+            elif used_time > 0.1:
+                # Few GUI events coming in, so we can sleep longer
+                # print('Sleep for 0.05 s')  # dbg
+                time.sleep(0.05)
+            else:
+                # Many GUI events coming in, so sleep only very little
+                time.sleep(0.001)
+    except KeyboardInterrupt:
+        pass
diff --git a/IPython/terminal/pt_inputhooks/qt.py b/IPython/terminal/pt_inputhooks/qt.py
new file mode 100644
index 00000000000..49629cb88fd
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/qt.py
@@ -0,0 +1,90 @@
+import sys
+import os
+from IPython.external.qt_for_kernel import QtCore, QtGui, enum_helper
+from IPython import get_ipython
+
+# If we create a QApplication, QEventLoop, or a QTimer, keep a reference to them
+# so that they don't get garbage collected or leak memory when created multiple times.
+_appref = None
+_eventloop = None
+_timer = None
+_already_warned = False
+
+
+def _exec(obj):
+    # exec on PyQt6, exec_ elsewhere.
+    obj.exec() if hasattr(obj, "exec") else obj.exec_()
+
+
+def _reclaim_excepthook():
+    shell = get_ipython()
+    if shell is not None:
+        sys.excepthook = shell.excepthook
+
+
+def inputhook(context):
+    global _appref, _eventloop, _timer
+    app = QtCore.QCoreApplication.instance()
+    if not app:
+        if sys.platform == 'linux':
+            if not os.environ.get('DISPLAY') \
+                    and not os.environ.get('WAYLAND_DISPLAY'):
+                import warnings
+                global _already_warned
+                if not _already_warned:
+                    _already_warned = True
+                    warnings.warn(
+                        'The DISPLAY or WAYLAND_DISPLAY environment variable is '
+                        'not set or empty and Qt5 requires this environment '
+                        'variable. Deactivate Qt5 code.'
+                    )
+                return
+        try:
+            QtCore.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
+        except AttributeError:  # Only for Qt>=5.6, <6.
+            pass
+        try:
+            QtCore.QApplication.setHighDpiScaleFactorRoundingPolicy(
+                QtCore.Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
+            )
+        except AttributeError:  # Only for Qt>=5.14.
+            pass
+        _appref = app = QtGui.QApplication([" "])
+
+        # "reclaim" IPython sys.excepthook after event loop starts
+        # without this, it defaults back to BaseIPythonApplication.excepthook
+        # and exceptions in the Qt event loop are rendered without traceback
+        # formatting and look like "bug in IPython".
+        QtCore.QTimer.singleShot(0, _reclaim_excepthook)
+
+    if _eventloop is None:
+        _eventloop = QtCore.QEventLoop(app)
+
+    if sys.platform == 'win32':
+        # The QSocketNotifier method doesn't appear to work on Windows.
+        # Use polling instead.
+        if _timer is None:
+            _timer = QtCore.QTimer()
+            _timer.timeout.connect(_eventloop.quit)
+        while not context.input_is_ready():
+            # NOTE: run the event loop, and after 10 ms, call `quit` to exit it.
+            _timer.start(10)  # 10 ms
+            _exec(_eventloop)
+            _timer.stop()
+    else:
+        # On POSIX platforms, we can use a file descriptor to quit the event
+        # loop when there is input ready to read.
+        notifier = QtCore.QSocketNotifier(
+            context.fileno(), enum_helper("QtCore.QSocketNotifier.Type").Read
+        )
+        try:
+            # connect the callback we care about before we turn it on
+            # lambda is necessary as PyQT inspect the function signature to know
+            # what arguments to pass to. See https://github.com/ipython/ipython/pull/12355
+            notifier.activated.connect(lambda: _eventloop.exit())
+            notifier.setEnabled(True)
+            # only start the event loop we are not already flipped
+            if not context.input_is_ready():
+                _exec(_eventloop)
+        finally:
+            notifier.setEnabled(False)
diff --git a/IPython/terminal/pt_inputhooks/tk.py b/IPython/terminal/pt_inputhooks/tk.py
new file mode 100644
index 00000000000..daab113f48f
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/tk.py
@@ -0,0 +1,93 @@
+# Code borrowed from ptpython
+# https://github.com/jonathanslenders/ptpython/blob/86b71a89626114b18898a0af463978bdb32eeb70/ptpython/eventloop.py
+
+# Copyright (c) 2015, Jonathan Slenders
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# * Neither the name of the {organization} nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Wrapper around the eventloop that gives some time to the Tkinter GUI to process
+events when it's loaded and while we are waiting for input at the REPL. This
+way we don't block the UI of for instance ``turtle`` and other Tk libraries.
+
+(Normally Tkinter registers it's callbacks in ``PyOS_InputHook`` to integrate
+in readline. ``prompt-toolkit`` doesn't understand that input hook, but this
+will fix it for Tk.)
+"""
+
+import time
+
+import _tkinter
+import tkinter
+
+
+def inputhook(inputhook_context):
+    """
+    Inputhook for Tk.
+    Run the Tk eventloop until prompt-toolkit needs to process the next input.
+    """
+    # Get the current TK application.
+    root = tkinter._default_root
+
+    def wait_using_filehandler():
+        """
+        Run the TK eventloop until the file handler that we got from the
+        inputhook becomes readable.
+        """
+        # Add a handler that sets the stop flag when `prompt-toolkit` has input
+        # to process.
+        stop = [False]
+
+        def done(*a):
+            stop[0] = True
+
+        root.createfilehandler(inputhook_context.fileno(), _tkinter.READABLE, done)
+
+        # Run the TK event loop as long as we don't receive input.
+        while root.dooneevent(_tkinter.ALL_EVENTS):
+            if stop[0]:
+                break
+
+        root.deletefilehandler(inputhook_context.fileno())
+
+    def wait_using_polling():
+        """
+        Windows TK doesn't support 'createfilehandler'.
+        So, run the TK eventloop and poll until input is ready.
+        """
+        while not inputhook_context.input_is_ready():
+            while root.dooneevent(_tkinter.ALL_EVENTS | _tkinter.DONT_WAIT):
+                pass
+            # Sleep to make the CPU idle, but not too long, so that the UI
+            # stays responsive.
+            time.sleep(0.01)
+
+    if root is not None:
+        if hasattr(root, "createfilehandler"):
+            wait_using_filehandler()
+        else:
+            wait_using_polling()
diff --git a/IPython/terminal/pt_inputhooks/wx.py b/IPython/terminal/pt_inputhooks/wx.py
new file mode 100644
index 00000000000..7f07c9052a4
--- /dev/null
+++ b/IPython/terminal/pt_inputhooks/wx.py
@@ -0,0 +1,219 @@
+"""Enable wxPython to be used interactively in prompt_toolkit
+"""
+
+import sys
+import signal
+import time
+from timeit import default_timer as clock
+import wx
+
+
+def ignore_keyboardinterrupts(func):
+    """Decorator which causes KeyboardInterrupt exceptions to be ignored during
+    execution of the decorated function.
+
+    This is used by the inputhook functions to handle the event where the user
+    presses CTRL+C while IPython is idle, and the inputhook loop is running. In
+    this case, we want to ignore interrupts.
+    """
+    def wrapper(*args, **kwargs):
+        try:
+            func(*args, **kwargs)
+        except KeyboardInterrupt:
+            pass
+    return wrapper
+
+
+@ignore_keyboardinterrupts
+def inputhook_wx1(context):
+    """Run the wx event loop by processing pending events only.
+
+    This approach seems to work, but its performance is not great as it
+    relies on having PyOS_InputHook called regularly.
+    """
+    app = wx.GetApp()
+    if app is not None:
+        assert wx.Thread_IsMain()
+
+        # Make a temporary event loop and process system events until
+        # there are no more waiting, then allow idle events (which
+        # will also deal with pending or posted wx events.)
+        evtloop = wx.EventLoop()
+        ea = wx.EventLoopActivator(evtloop)
+        while evtloop.Pending():
+            evtloop.Dispatch()
+        app.ProcessIdle()
+        del ea
+    return 0
+
+
+class EventLoopTimer(wx.Timer):
+
+    def __init__(self, func):
+        self.func = func
+        wx.Timer.__init__(self)
+
+    def Notify(self):
+        self.func()
+
+
+class EventLoopRunner:
+
+    def Run(self, time, input_is_ready):
+        self.input_is_ready = input_is_ready
+        self.evtloop = wx.EventLoop()
+        self.timer = EventLoopTimer(self.check_stdin)
+        self.timer.Start(time)
+        self.evtloop.Run()
+
+    def check_stdin(self):
+        if self.input_is_ready():
+            self.timer.Stop()
+            self.evtloop.Exit()
+
+
+@ignore_keyboardinterrupts
+def inputhook_wx2(context):
+    """Run the wx event loop, polling for stdin.
+
+    This version runs the wx eventloop for an undetermined amount of time,
+    during which it periodically checks to see if anything is ready on
+    stdin.  If anything is ready on stdin, the event loop exits.
+
+    The argument to elr.Run controls how often the event loop looks at stdin.
+    This determines the responsiveness at the keyboard.  A setting of 1000
+    enables a user to type at most 1 char per second.  I have found that a
+    setting of 10 gives good keyboard response.  We can shorten it further,
+    but eventually performance would suffer from calling select/kbhit too
+    often.
+    """
+    app = wx.GetApp()
+    if app is not None:
+        assert wx.Thread_IsMain()
+        elr = EventLoopRunner()
+        # As this time is made shorter, keyboard response improves, but idle
+        # CPU load goes up.  10 ms seems like a good compromise.
+        elr.Run(time=10,  # CHANGE time here to control polling interval
+                input_is_ready=context.input_is_ready)
+    return 0
+
+
+@ignore_keyboardinterrupts
+def inputhook_wx3(context):
+    """Run the wx event loop by processing pending events only.
+
+    This is like inputhook_wx1, but it keeps processing pending events
+    until stdin is ready.  After processing all pending events, a call to
+    time.sleep is inserted.  This is needed, otherwise, CPU usage is at 100%.
+    This sleep time should be tuned though for best performance.
+    """
+    app = wx.GetApp()
+    if app is not None:
+        assert wx.Thread_IsMain()
+
+        # The import of wx on Linux sets the handler for signal.SIGINT
+        # to 0.  This is a bug in wx or gtk.  We fix by just setting it
+        # back to the Python default.
+        if not callable(signal.getsignal(signal.SIGINT)):
+            signal.signal(signal.SIGINT, signal.default_int_handler)
+
+        evtloop = wx.EventLoop()
+        ea = wx.EventLoopActivator(evtloop)
+        t = clock()
+        while not context.input_is_ready():
+            while evtloop.Pending():
+                t = clock()
+                evtloop.Dispatch()
+            app.ProcessIdle()
+            # We need to sleep at this point to keep the idle CPU load
+            # low.  However, if sleep to long, GUI response is poor.  As
+            # a compromise, we watch how often GUI events are being processed
+            # and switch between a short and long sleep time.  Here are some
+            # stats useful in helping to tune this.
+            # time    CPU load
+            # 0.001   13%
+            # 0.005   3%
+            # 0.01    1.5%
+            # 0.05    0.5%
+            used_time = clock() - t
+            if used_time > 10.0:
+                # print('Sleep for 1 s')  # dbg
+                time.sleep(1.0)
+            elif used_time > 0.1:
+                # Few GUI events coming in, so we can sleep longer
+                # print('Sleep for 0.05 s')  # dbg
+                time.sleep(0.05)
+            else:
+                # Many GUI events coming in, so sleep only very little
+                time.sleep(0.001)
+        del ea
+    return 0
+
+
+@ignore_keyboardinterrupts
+def inputhook_wxphoenix(context):
+    """Run the wx event loop until the user provides more input.
+
+    This input hook is suitable for use with wxPython >= 4 (a.k.a. Phoenix).
+
+    It uses the same approach to that used in
+    ipykernel.eventloops.loop_wx. The wx.MainLoop is executed, and a wx.Timer
+    is used to periodically poll the context for input. As soon as input is
+    ready, the wx.MainLoop is stopped.
+    """
+
+    app = wx.GetApp()
+
+    if app is None:
+        return
+
+    if context.input_is_ready():
+        return
+
+    assert wx.IsMainThread()
+
+    # Wx uses milliseconds
+    poll_interval = 100
+
+    # Use a wx.Timer to periodically check whether input is ready - as soon as
+    # it is, we exit the main loop
+    timer = wx.Timer()
+
+    def poll(ev):
+        if context.input_is_ready():
+            timer.Stop()
+            app.ExitMainLoop()
+
+    timer.Start(poll_interval)
+    timer.Bind(wx.EVT_TIMER, poll)
+
+    # The import of wx on Linux sets the handler for signal.SIGINT to 0.  This
+    # is a bug in wx or gtk.  We fix by just setting it back to the Python
+    # default.
+    if not callable(signal.getsignal(signal.SIGINT)):
+        signal.signal(signal.SIGINT, signal.default_int_handler)
+
+    # The SetExitOnFrameDelete call allows us to run the wx mainloop without
+    # having a frame open.
+    app.SetExitOnFrameDelete(False)
+    app.MainLoop()
+
+
+# Get the major wx version number to figure out what input hook we should use.
+major_version = 3
+
+try:
+    major_version = int(wx.__version__[0])
+except Exception:
+    pass
+
+# Use the phoenix hook on all platforms for wxpython >= 4
+if major_version >= 4:
+    inputhook = inputhook_wxphoenix
+# On OSX, evtloop.Pending() always returns True, regardless of there being
+# any events pending. As such we can't use implementations 1 or 3 of the
+# inputhook as those depend on a pending/dispatch loop.
+elif sys.platform == 'darwin':
+    inputhook = inputhook_wx2
+else:
+    inputhook = inputhook_wx3
diff --git a/IPython/terminal/ptutils.py b/IPython/terminal/ptutils.py
new file mode 100644
index 00000000000..b2518d011bc
--- /dev/null
+++ b/IPython/terminal/ptutils.py
@@ -0,0 +1,230 @@
+"""prompt-toolkit utilities
+
+Everything in this module is a private API,
+not to be used outside IPython.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import unicodedata
+from wcwidth import wcwidth
+
+from IPython.core.completer import (
+    provisionalcompleter, cursor_to_position,
+    _deduplicate_completions)
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.lexers import Lexer
+from prompt_toolkit.lexers import PygmentsLexer
+from prompt_toolkit.patch_stdout import patch_stdout
+from IPython.core.getipython import get_ipython
+
+
+import pygments.lexers as pygments_lexers
+import os
+import sys
+import traceback
+
+_completion_sentinel = object()
+
+
+def _elide_point(string: str, *, min_elide) -> str:
+    """
+    If a string is long enough, and has at least 3 dots,
+    replace the middle part with ellipses.
+
+    If a string naming a file is long enough, and has at least 3 slashes,
+    replace the middle part with ellipses.
+
+    If three consecutive dots, or two consecutive dots are encountered these are
+    replaced by the equivalents HORIZONTAL ELLIPSIS or TWO DOT LEADER unicode
+    equivalents
+    """
+    string = string.replace('...','\N{HORIZONTAL ELLIPSIS}')
+    string = string.replace('..','\N{TWO DOT LEADER}')
+    if len(string) < min_elide:
+        return string
+
+    object_parts = string.split('.')
+    file_parts = string.split(os.sep)
+    if file_parts[-1] == '':
+        file_parts.pop()
+
+    if len(object_parts) > 3:
+        return "{}.{}\N{HORIZONTAL ELLIPSIS}{}.{}".format(
+            object_parts[0],
+            object_parts[1][:1],
+            object_parts[-2][-1:],
+            object_parts[-1],
+        )
+
+    elif len(file_parts) > 3:
+        return ("{}" + os.sep + "{}\N{HORIZONTAL ELLIPSIS}{}" + os.sep + "{}").format(
+            file_parts[0], file_parts[1][:1], file_parts[-2][-1:], file_parts[-1]
+        )
+
+    return string
+
+
+def _elide_typed(string: str, typed: str, *, min_elide: int) -> str:
+    """
+    Elide the middle of a long string if the beginning has already been typed.
+    """
+
+    if len(string) < min_elide:
+        return string
+    cut_how_much = len(typed)-3
+    if cut_how_much < 7:
+        return string
+    if string.startswith(typed) and len(string)> len(typed):
+        return f"{string[:3]}\N{HORIZONTAL ELLIPSIS}{string[cut_how_much:]}"
+    return string
+
+
+def _elide(string: str, typed: str, min_elide) -> str:
+    return _elide_typed(
+        _elide_point(string, min_elide=min_elide),
+        typed, min_elide=min_elide)
+
+
+
+def _adjust_completion_text_based_on_context(text, body, offset):
+    if text.endswith('=') and len(body) > offset and body[offset] == '=':
+        return text[:-1]
+    else:
+        return text
+
+
+class IPythonPTCompleter(Completer):
+    """Adaptor to provide IPython completions to prompt_toolkit"""
+    def __init__(self, ipy_completer=None, shell=None):
+        if shell is None and ipy_completer is None:
+            raise TypeError("Please pass shell=an InteractiveShell instance.")
+        self._ipy_completer = ipy_completer
+        self.shell = shell
+
+    @property
+    def ipy_completer(self):
+        if self._ipy_completer:
+            return self._ipy_completer
+        else:
+            return self.shell.Completer
+
+    def get_completions(self, document, complete_event):
+        if not document.current_line.strip():
+            return
+        # Some bits of our completion system may print stuff (e.g. if a module
+        # is imported). This context manager ensures that doesn't interfere with
+        # the prompt.
+
+        with patch_stdout(), provisionalcompleter():
+            body = document.text
+            cursor_row = document.cursor_position_row
+            cursor_col = document.cursor_position_col
+            cursor_position = document.cursor_position
+            offset = cursor_to_position(body, cursor_row, cursor_col)
+            try:
+                yield from self._get_completions(body, offset, cursor_position, self.ipy_completer)
+            except Exception as e:
+                try:
+                    exc_type, exc_value, exc_tb = sys.exc_info()
+                    traceback.print_exception(exc_type, exc_value, exc_tb)
+                except AttributeError:
+                    print('Unrecoverable Error in completions')
+
+    def _get_completions(self, body, offset, cursor_position, ipyc):
+        """
+        Private equivalent of get_completions() use only for unit_testing.
+        """
+        debug = getattr(ipyc, 'debug', False)
+        completions = _deduplicate_completions(
+            body, ipyc.completions(body, offset))
+        for c in completions:
+            if not c.text:
+                # Guard against completion machinery giving us an empty string.
+                continue
+            text = unicodedata.normalize('NFC', c.text)
+            # When the first character of the completion has a zero length,
+            # then it's probably a decomposed unicode character. E.g. caused by
+            # the "\dot" completion. Try to compose again with the previous
+            # character.
+            if wcwidth(text[0]) == 0:
+                if cursor_position + c.start > 0:
+                    char_before = body[c.start - 1]
+                    fixed_text = unicodedata.normalize(
+                        'NFC', char_before + text)
+
+                    # Yield the modified completion instead, if this worked.
+                    if wcwidth(text[0:1]) == 1:
+                        yield Completion(fixed_text, start_position=c.start - offset - 1)
+                        continue
+
+            # TODO: Use Jedi to determine meta_text
+            # (Jedi currently has a bug that results in incorrect information.)
+            # meta_text = ''
+            # yield Completion(m, start_position=start_pos,
+            #                  display_meta=meta_text)
+            display_text = c.text
+
+            adjusted_text = _adjust_completion_text_based_on_context(
+                c.text, body, offset
+            )
+            min_elide = 30 if self.shell is None else self.shell.min_elide
+            if c.type == "function":
+                yield Completion(
+                    adjusted_text,
+                    start_position=c.start - offset,
+                    display=_elide(
+                        display_text + "()",
+                        body[c.start : c.end],
+                        min_elide=min_elide,
+                    ),
+                    display_meta=c.type + c.signature,
+                )
+            else:
+                yield Completion(
+                    adjusted_text,
+                    start_position=c.start - offset,
+                    display=_elide(
+                        display_text,
+                        body[c.start : c.end],
+                        min_elide=min_elide,
+                    ),
+                    display_meta=c.type,
+                )
+
+
+class IPythonPTLexer(Lexer):
+    """
+    Wrapper around PythonLexer and BashLexer.
+    """
+    def __init__(self):
+        l = pygments_lexers
+        self.python_lexer = PygmentsLexer(l.Python3Lexer)
+        self.shell_lexer = PygmentsLexer(l.BashLexer)
+
+        self.magic_lexers = {
+            'HTML': PygmentsLexer(l.HtmlLexer),
+            'html': PygmentsLexer(l.HtmlLexer),
+            'javascript': PygmentsLexer(l.JavascriptLexer),
+            'js': PygmentsLexer(l.JavascriptLexer),
+            'perl': PygmentsLexer(l.PerlLexer),
+            'ruby': PygmentsLexer(l.RubyLexer),
+            'latex': PygmentsLexer(l.TexLexer),
+        }
+
+    def lex_document(self, document):
+        text = document.text.lstrip()
+
+        lexer = self.python_lexer
+
+        if text.startswith('!') or text.startswith('%%bash'):
+            lexer = self.shell_lexer
+
+        elif text.startswith('%%'):
+            for magic, l in self.magic_lexers.items():
+                if text.startswith('%%' + magic):
+                    lexer = l
+                    break
+
+        return lexer.lex_document(document)
diff --git a/IPython/terminal/shortcuts/__init__.py b/IPython/terminal/shortcuts/__init__.py
new file mode 100644
index 00000000000..519d474c598
--- /dev/null
+++ b/IPython/terminal/shortcuts/__init__.py
@@ -0,0 +1,639 @@
+"""
+Module to define and register Terminal IPython shortcuts with
+:mod:`prompt_toolkit`
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import signal
+import sys
+import warnings
+from dataclasses import dataclass
+from typing import Any, Optional, List
+from collections.abc import Callable
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.key_binding.bindings import named_commands as nc
+from prompt_toolkit.key_binding.bindings.completion import (
+    display_completions_like_readline,
+)
+from prompt_toolkit.key_binding.vi_state import InputMode, ViState
+from prompt_toolkit.filters import Condition
+
+from IPython.core.getipython import get_ipython
+from . import auto_match as match
+from . import auto_suggest
+from .filters import filter_from_string
+from IPython.utils.decorators import undoc
+
+from prompt_toolkit.enums import DEFAULT_BUFFER
+
+__all__ = ["create_ipython_shortcuts"]
+
+
+@dataclass
+class BaseBinding:
+    command: Callable[[KeyPressEvent], Any]
+    keys: List[str]
+
+
+@dataclass
+class RuntimeBinding(BaseBinding):
+    filter: Condition
+
+
+@dataclass
+class Binding(BaseBinding):
+    # while filter could be created by referencing variables directly (rather
+    # than created from strings), by using strings we ensure that users will
+    # be able to create filters in configuration (e.g. JSON) files too, which
+    # also benefits the documentation by enforcing human-readable filter names.
+    condition: Optional[str] = None
+
+    def __post_init__(self):
+        if self.condition:
+            self.filter = filter_from_string(self.condition)
+        else:
+            self.filter = None
+
+
+def create_identifier(handler: Callable):
+    parts = handler.__module__.split(".")
+    name = handler.__name__
+    package = parts[0]
+    if len(parts) > 1:
+        final_module = parts[-1]
+        return f"{package}:{final_module}.{name}"
+    else:
+        return f"{package}:{name}"
+
+
+AUTO_MATCH_BINDINGS = [
+    *[
+        Binding(
+            cmd, [key], "focused_insert & auto_match & followed_by_closing_paren_or_end"
+        )
+        for key, cmd in match.auto_match_parens.items()
+    ],
+    *[
+        # raw string
+        Binding(cmd, [key], "focused_insert & auto_match & preceded_by_raw_str_prefix")
+        for key, cmd in match.auto_match_parens_raw_string.items()
+    ],
+    Binding(
+        match.double_quote,
+        ['"'],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_paired_double_quotes"
+        " & followed_by_closing_paren_or_end",
+    ),
+    Binding(
+        match.single_quote,
+        ["'"],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_paired_single_quotes"
+        " & followed_by_closing_paren_or_end",
+    ),
+    Binding(
+        match.docstring_double_quotes,
+        ['"'],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_two_double_quotes",
+    ),
+    Binding(
+        match.docstring_single_quotes,
+        ["'"],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_two_single_quotes",
+    ),
+    Binding(
+        match.skip_over,
+        [")"],
+        "focused_insert & auto_match & followed_by_closing_round_paren",
+    ),
+    Binding(
+        match.skip_over,
+        ["]"],
+        "focused_insert & auto_match & followed_by_closing_bracket",
+    ),
+    Binding(
+        match.skip_over,
+        ["}"],
+        "focused_insert & auto_match & followed_by_closing_brace",
+    ),
+    Binding(
+        match.skip_over, ['"'], "focused_insert & auto_match & followed_by_double_quote"
+    ),
+    Binding(
+        match.skip_over, ["'"], "focused_insert & auto_match & followed_by_single_quote"
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_opening_round_paren"
+        " & auto_match"
+        " & followed_by_closing_round_paren",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_opening_bracket"
+        " & auto_match"
+        " & followed_by_closing_bracket",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_opening_brace"
+        " & auto_match"
+        " & followed_by_closing_brace",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_double_quote"
+        " & auto_match"
+        " & followed_by_double_quote",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_single_quote"
+        " & auto_match"
+        " & followed_by_single_quote",
+    ),
+]
+
+AUTO_SUGGEST_BINDINGS = [
+    # there are two reasons for re-defining bindings defined upstream:
+    # 1) prompt-toolkit does not execute autosuggestion bindings in vi mode,
+    # 2) prompt-toolkit checks if we are at the end of text, not end of line
+    #    hence it does not work in multi-line mode of navigable provider
+    Binding(
+        auto_suggest.accept_or_jump_to_end,
+        ["end"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_or_jump_to_end,
+        ["c-e"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept,
+        ["c-f"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept,
+        ["right"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode & is_cursor_at_the_end_of_line",
+    ),
+    Binding(
+        auto_suggest.accept_word,
+        ["escape", "f"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_token,
+        ["c-right"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.discard,
+        ["escape"],
+        # note this one is using `emacs_insert_mode`, not `emacs_like_insert_mode`
+        # as in `vi_insert_mode` we do not want `escape` to be shadowed (ever).
+        "has_suggestion & default_buffer_focused & emacs_insert_mode",
+    ),
+    Binding(
+        auto_suggest.discard,
+        ["delete"],
+        "has_suggestion & default_buffer_focused & emacs_insert_mode",
+    ),
+    Binding(
+        auto_suggest.swap_autosuggestion_up,
+        ["c-up"],
+        "navigable_suggestions"
+        " & ~has_line_above"
+        " & has_suggestion"
+        " & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.swap_autosuggestion_down,
+        ["c-down"],
+        "navigable_suggestions"
+        " & ~has_line_below"
+        " & has_suggestion"
+        " & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.up_and_update_hint,
+        ["c-up"],
+        "has_line_above & navigable_suggestions & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.down_and_update_hint,
+        ["c-down"],
+        "has_line_below & navigable_suggestions & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.accept_character,
+        ["escape", "right"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_and_move_cursor_left,
+        ["c-left"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_and_keep_cursor,
+        ["escape", "down"],
+        "has_suggestion & default_buffer_focused & emacs_insert_mode",
+    ),
+    Binding(
+        auto_suggest.backspace_and_resume_hint,
+        ["backspace"],
+        # no `has_suggestion` here to allow resuming if no suggestion
+        "default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.resume_hinting,
+        ["right"],
+        "is_cursor_at_the_end_of_line"
+        " & default_buffer_focused"
+        " & emacs_like_insert_mode"
+        " & pass_through",
+    ),
+]
+
+
+SIMPLE_CONTROL_BINDINGS = [
+    Binding(cmd, [key], "vi_insert_mode & default_buffer_focused & ebivim")
+    for key, cmd in {
+        "c-a": nc.beginning_of_line,
+        "c-b": nc.backward_char,
+        "c-k": nc.kill_line,
+        "c-w": nc.backward_kill_word,
+        "c-y": nc.yank,
+        "c-_": nc.undo,
+    }.items()
+]
+
+
+ALT_AND_COMOBO_CONTROL_BINDINGS = [
+    Binding(cmd, list(keys), "vi_insert_mode & default_buffer_focused & ebivim")
+    for keys, cmd in {
+        # Control Combos
+        ("c-x", "c-e"): nc.edit_and_execute,
+        ("c-x", "e"): nc.edit_and_execute,
+        # Alt
+        ("escape", "b"): nc.backward_word,
+        ("escape", "c"): nc.capitalize_word,
+        ("escape", "d"): nc.kill_word,
+        ("escape", "h"): nc.backward_kill_word,
+        ("escape", "l"): nc.downcase_word,
+        ("escape", "u"): nc.uppercase_word,
+        ("escape", "y"): nc.yank_pop,
+        ("escape", "."): nc.yank_last_arg,
+    }.items()
+]
+
+
+def add_binding(bindings: KeyBindings, binding: Binding):
+    bindings.add(
+        *binding.keys,
+        **({"filter": binding.filter} if binding.filter is not None else {}),
+    )(binding.command)
+
+
+def create_ipython_shortcuts(shell, skip=None) -> KeyBindings:
+    """Set up the prompt_toolkit keyboard shortcuts for IPython.
+
+    Parameters
+    ----------
+    shell: InteractiveShell
+        The current IPython shell Instance
+    skip: List[Binding]
+        Bindings to skip.
+
+    Returns
+    -------
+    KeyBindings
+        the keybinding instance for prompt toolkit.
+
+    """
+    kb = KeyBindings()
+    skip = skip or []
+    for binding in KEY_BINDINGS:
+        skip_this_one = False
+        for to_skip in skip:
+            if (
+                to_skip.command == binding.command
+                and to_skip.filter == binding.filter
+                and to_skip.keys == binding.keys
+            ):
+                skip_this_one = True
+                break
+        if skip_this_one:
+            continue
+        add_binding(kb, binding)
+
+    def get_input_mode(self):
+        app = get_app()
+        app.ttimeoutlen = shell.ttimeoutlen
+        app.timeoutlen = shell.timeoutlen
+
+        return self._input_mode
+
+    def set_input_mode(self, mode):
+        shape = {InputMode.NAVIGATION: 2, InputMode.REPLACE: 4}.get(mode, 6)
+        cursor = "\x1b[{} q".format(shape)
+
+        sys.stdout.write(cursor)
+        sys.stdout.flush()
+
+        self._input_mode = mode
+
+    if shell.editing_mode == "vi" and shell.modal_cursor:
+        ViState._input_mode = InputMode.INSERT  # type: ignore
+        ViState.input_mode = property(get_input_mode, set_input_mode)  # type: ignore
+
+    return kb
+
+
+def reformat_and_execute(event):
+    """Reformat code and execute it"""
+    shell = get_ipython()
+    reformat_text_before_cursor(
+        event.current_buffer, event.current_buffer.document, shell
+    )
+    event.current_buffer.validate_and_handle()
+
+
+def reformat_text_before_cursor(buffer, document, shell):
+    text = buffer.delete_before_cursor(len(document.text[: document.cursor_position]))
+    try:
+        formatted_text = shell.reformat_handler(text)
+        buffer.insert_text(formatted_text)
+    except Exception as e:
+        buffer.insert_text(text)
+
+
+def handle_return_or_newline_or_execute(event):
+    shell = get_ipython()
+    if getattr(shell, "handle_return", None):
+        return shell.handle_return(shell)(event)
+    else:
+        return newline_or_execute_outer(shell)(event)
+
+
+def newline_or_execute_outer(shell):
+    def newline_or_execute(event):
+        """When the user presses return, insert a newline or execute the code."""
+        b = event.current_buffer
+        d = b.document
+
+        if b.complete_state:
+            cc = b.complete_state.current_completion
+            if cc:
+                b.apply_completion(cc)
+            else:
+                b.cancel_completion()
+            return
+
+        # If there's only one line, treat it as if the cursor is at the end.
+        # See https://github.com/ipython/ipython/issues/10425
+        if d.line_count == 1:
+            check_text = d.text
+        else:
+            check_text = d.text[: d.cursor_position]
+        status, indent = shell.check_complete(check_text)
+
+        # if all we have after the cursor is whitespace: reformat current text
+        # before cursor
+        after_cursor = d.text[d.cursor_position :]
+        reformatted = False
+        if not after_cursor.strip():
+            reformat_text_before_cursor(b, d, shell)
+            reformatted = True
+        if not (
+            d.on_last_line
+            or d.cursor_position_row >= d.line_count - d.empty_line_count_at_the_end()
+        ):
+            if shell.autoindent:
+                b.insert_text("\n" + indent)
+            else:
+                b.insert_text("\n")
+            return
+
+        if (status != "incomplete") and b.accept_handler:
+            if not reformatted:
+                reformat_text_before_cursor(b, d, shell)
+            b.validate_and_handle()
+        else:
+            if shell.autoindent:
+                b.insert_text("\n" + indent)
+            else:
+                b.insert_text("\n")
+
+    return newline_or_execute
+
+
+def previous_history_or_previous_completion(event):
+    """
+    Control-P in vi edit mode on readline is history next, unlike default prompt toolkit.
+
+    If completer is open this still select previous completion.
+    """
+    event.current_buffer.auto_up()
+
+
+def next_history_or_next_completion(event):
+    """
+    Control-N in vi edit mode on readline is history previous, unlike default prompt toolkit.
+
+    If completer is open this still select next completion.
+    """
+    event.current_buffer.auto_down()
+
+
+def dismiss_completion(event):
+    """Dismiss completion"""
+    b = event.current_buffer
+    if b.complete_state:
+        b.cancel_completion()
+
+
+def reset_buffer(event):
+    """Reset buffer"""
+    b = event.current_buffer
+    if b.complete_state:
+        b.cancel_completion()
+    else:
+        b.reset()
+
+
+def reset_search_buffer(event):
+    """Reset search buffer"""
+    if event.current_buffer.document.text:
+        event.current_buffer.reset()
+    else:
+        event.app.layout.focus(DEFAULT_BUFFER)
+
+
+def suspend_to_bg(event):
+    """Suspend to background"""
+    event.app.suspend_to_background()
+
+
+def quit(event):
+    """
+    Quit application with ``SIGQUIT`` if supported or ``sys.exit`` otherwise.
+
+    On platforms that support SIGQUIT, send SIGQUIT to the current process.
+    On other platforms, just exit the process with a message.
+    """
+    sigquit = getattr(signal, "SIGQUIT", None)
+    if sigquit is not None:
+        os.kill(0, signal.SIGQUIT)
+    else:
+        sys.exit("Quit")
+
+
+def indent_buffer(event):
+    """Indent buffer"""
+    event.current_buffer.insert_text(" " * 4)
+
+
+def newline_autoindent(event):
+    """Insert a newline after the cursor indented appropriately.
+
+    Fancier version of former ``newline_with_copy_margin`` which should
+    compute the correct indentation of the inserted line. That is to say, indent
+    by 4 extra space after a function definition, class definition, context
+    manager... And dedent by 4 space after ``pass``, ``return``, ``raise ...``.
+    """
+    shell = get_ipython()
+    inputsplitter = shell.input_transformer_manager
+    b = event.current_buffer
+    d = b.document
+
+    if b.complete_state:
+        b.cancel_completion()
+    text = d.text[: d.cursor_position] + "\n"
+    _, indent = inputsplitter.check_complete(text)
+    b.insert_text("\n" + (" " * (indent or 0)), move_cursor=False)
+
+
+def open_input_in_editor(event):
+    """Open code from input in external editor"""
+    event.app.current_buffer.open_in_editor()
+
+
+if sys.platform == "win32":
+    from IPython.core.error import TryNext
+    from IPython.lib.clipboard import (
+        ClipboardEmpty,
+        tkinter_clipboard_get,
+        win32_clipboard_get,
+    )
+
+    @undoc
+    def win_paste(event):
+        try:
+            text = win32_clipboard_get()
+        except TryNext:
+            try:
+                text = tkinter_clipboard_get()
+            except (TryNext, ClipboardEmpty):
+                return
+        except ClipboardEmpty:
+            return
+        event.current_buffer.insert_text(text.replace("\t", " " * 4))
+
+else:
+
+    @undoc
+    def win_paste(event):
+        """Stub used on other platforms"""
+        pass
+
+
+KEY_BINDINGS = [
+    Binding(
+        handle_return_or_newline_or_execute,
+        ["enter"],
+        "default_buffer_focused & ~has_selection & insert_mode",
+    ),
+    Binding(
+        reformat_and_execute,
+        ["escape", "enter"],
+        "default_buffer_focused & ~has_selection & insert_mode & ebivim",
+    ),
+    Binding(quit, ["c-\\"]),
+    Binding(
+        previous_history_or_previous_completion,
+        ["c-p"],
+        "vi_insert_mode & default_buffer_focused",
+    ),
+    Binding(
+        next_history_or_next_completion,
+        ["c-n"],
+        "vi_insert_mode & default_buffer_focused",
+    ),
+    Binding(dismiss_completion, ["c-g"], "default_buffer_focused & has_completions"),
+    Binding(reset_buffer, ["c-c"], "default_buffer_focused"),
+    Binding(reset_search_buffer, ["c-c"], "search_buffer_focused"),
+    Binding(suspend_to_bg, ["c-z"], "supports_suspend"),
+    Binding(
+        indent_buffer,
+        ["tab"],  # Ctrl+I == Tab
+        "default_buffer_focused & ~has_selection & insert_mode & cursor_in_leading_ws",
+    ),
+    Binding(newline_autoindent, ["c-o"], "default_buffer_focused & emacs_insert_mode"),
+    Binding(open_input_in_editor, ["f2"], "default_buffer_focused"),
+    *AUTO_MATCH_BINDINGS,
+    *AUTO_SUGGEST_BINDINGS,
+    Binding(
+        display_completions_like_readline,
+        ["c-i"],
+        "readline_like_completions"
+        " & default_buffer_focused"
+        " & ~has_selection"
+        " & insert_mode"
+        " & ~cursor_in_leading_ws",
+    ),
+    Binding(win_paste, ["c-v"], "default_buffer_focused & ~vi_mode & is_windows_os"),
+    *SIMPLE_CONTROL_BINDINGS,
+    *ALT_AND_COMOBO_CONTROL_BINDINGS,
+]
+
+UNASSIGNED_ALLOWED_COMMANDS = [
+    auto_suggest.llm_autosuggestion,
+    nc.beginning_of_buffer,
+    nc.end_of_buffer,
+    nc.end_of_line,
+    nc.forward_char,
+    nc.forward_word,
+    nc.unix_line_discard,
+    nc.unix_word_rubout,
+]
diff --git a/IPython/terminal/shortcuts/auto_match.py b/IPython/terminal/shortcuts/auto_match.py
new file mode 100644
index 00000000000..6095558bbf9
--- /dev/null
+++ b/IPython/terminal/shortcuts/auto_match.py
@@ -0,0 +1,105 @@
+"""
+Utilities function for keybinding with prompt toolkit.
+
+This will be bound to specific key press and filter modes,
+like whether we are in edit mode, and whether the completer is open.
+"""
+
+import re
+from prompt_toolkit.key_binding import KeyPressEvent
+
+
+def parenthesis(event: KeyPressEvent):
+    """Auto-close parenthesis"""
+    event.current_buffer.insert_text("()")
+    event.current_buffer.cursor_left()
+
+
+def brackets(event: KeyPressEvent):
+    """Auto-close brackets"""
+    event.current_buffer.insert_text("[]")
+    event.current_buffer.cursor_left()
+
+
+def braces(event: KeyPressEvent):
+    """Auto-close braces"""
+    event.current_buffer.insert_text("{}")
+    event.current_buffer.cursor_left()
+
+
+def double_quote(event: KeyPressEvent):
+    """Auto-close double quotes"""
+    event.current_buffer.insert_text('""')
+    event.current_buffer.cursor_left()
+
+
+def single_quote(event: KeyPressEvent):
+    """Auto-close single quotes"""
+    event.current_buffer.insert_text("''")
+    event.current_buffer.cursor_left()
+
+
+def docstring_double_quotes(event: KeyPressEvent):
+    """Auto-close docstring (double quotes)"""
+    event.current_buffer.insert_text('""""')
+    event.current_buffer.cursor_left(3)
+
+
+def docstring_single_quotes(event: KeyPressEvent):
+    """Auto-close docstring (single quotes)"""
+    event.current_buffer.insert_text("''''")
+    event.current_buffer.cursor_left(3)
+
+
+def raw_string_parenthesis(event: KeyPressEvent):
+    """Auto-close parenthesis in raw strings"""
+    matches = re.match(
+        r".*(r|R)[\"'](-*)",
+        event.current_buffer.document.current_line_before_cursor,
+    )
+    dashes = matches.group(2) if matches else ""
+    event.current_buffer.insert_text("()" + dashes)
+    event.current_buffer.cursor_left(len(dashes) + 1)
+
+
+def raw_string_bracket(event: KeyPressEvent):
+    """Auto-close bracker in raw strings"""
+    matches = re.match(
+        r".*(r|R)[\"'](-*)",
+        event.current_buffer.document.current_line_before_cursor,
+    )
+    dashes = matches.group(2) if matches else ""
+    event.current_buffer.insert_text("[]" + dashes)
+    event.current_buffer.cursor_left(len(dashes) + 1)
+
+
+def raw_string_braces(event: KeyPressEvent):
+    """Auto-close braces in raw strings"""
+    matches = re.match(
+        r".*(r|R)[\"'](-*)",
+        event.current_buffer.document.current_line_before_cursor,
+    )
+    dashes = matches.group(2) if matches else ""
+    event.current_buffer.insert_text("{}" + dashes)
+    event.current_buffer.cursor_left(len(dashes) + 1)
+
+
+def skip_over(event: KeyPressEvent):
+    """Skip over automatically added parenthesis/quote.
+
+    (rather than adding another parenthesis/quote)"""
+    event.current_buffer.cursor_right()
+
+
+def delete_pair(event: KeyPressEvent):
+    """Delete auto-closed parenthesis"""
+    event.current_buffer.delete()
+    event.current_buffer.delete_before_cursor()
+
+
+auto_match_parens = {"(": parenthesis, "[": brackets, "{": braces}
+auto_match_parens_raw_string = {
+    "(": raw_string_parenthesis,
+    "[": raw_string_bracket,
+    "{": raw_string_braces,
+}
diff --git a/IPython/terminal/shortcuts/auto_suggest.py b/IPython/terminal/shortcuts/auto_suggest.py
new file mode 100644
index 00000000000..91d238329ca
--- /dev/null
+++ b/IPython/terminal/shortcuts/auto_suggest.py
@@ -0,0 +1,658 @@
+import re
+import asyncio
+import tokenize
+from io import StringIO
+from typing import List, Optional, Union, Tuple, ClassVar, Any
+from collections.abc import Callable, Generator
+import warnings
+
+import prompt_toolkit
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.key_binding import KeyPressEvent
+from prompt_toolkit.key_binding.bindings import named_commands as nc
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory, Suggestion
+from prompt_toolkit.document import Document
+from prompt_toolkit.history import History
+from prompt_toolkit.shortcuts import PromptSession
+from prompt_toolkit.layout.processors import (
+    Processor,
+    Transformation,
+    TransformationInput,
+)
+
+from IPython.core.getipython import get_ipython
+from IPython.utils.tokenutil import generate_tokens
+
+from .filters import pass_through
+
+
+def _get_query(document: Document):
+    return document.lines[document.cursor_position_row]
+
+
+class AppendAutoSuggestionInAnyLine(Processor):
+    """
+    Append the auto suggestion to lines other than the last (appending to the
+    last line is natively supported by the prompt toolkit).
+
+    This has a private `_debug` attribute that can be set to True to display
+    debug information as virtual suggestion on the end of any line. You can do
+    so with:
+
+        >>> from IPython.terminal.shortcuts.auto_suggest import AppendAutoSuggestionInAnyLine
+        >>> AppendAutoSuggestionInAnyLine._debug = True
+
+    """
+
+    _debug: ClassVar[bool] = False
+
+    def __init__(self, style: str = "class:auto-suggestion") -> None:
+        self.style = style
+
+    def apply_transformation(self, ti: TransformationInput) -> Transformation:
+        """
+         Apply transformation to the line that is currently being edited.
+
+         This is a variation of the original implementation in prompt toolkit
+         that allows to not only append suggestions to any line, but also to show
+         multi-line suggestions.
+
+         As transformation are applied on a line-by-line basis; we need to trick
+         a bit, and elide any line that is after the line we are currently
+         editing, until we run out of completions. We cannot shift the existing
+         lines
+
+         There are multiple cases to handle:
+
+         The completions ends before the end of the buffer:
+             We can resume showing the normal line, and say that some code may
+             be hidden.
+
+        The completions ends at the end of the buffer
+             We can just say that some code may be hidden.
+
+         And separately:
+
+         The completions ends beyond the end of the buffer
+             We need to both say that some code may be hidden, and that some
+             lines are not shown.
+
+        """
+        last_line_number = ti.document.line_count - 1
+        is_last_line = ti.lineno == last_line_number
+
+        noop = lambda text: Transformation(
+            fragments=ti.fragments + [(self.style, " " + text if self._debug else "")]
+        )
+        if ti.document.line_count == 1:
+            return noop("noop:oneline")
+        if ti.document.cursor_position_row == last_line_number and is_last_line:
+            # prompt toolkit already appends something; just leave it be
+            return noop("noop:last line and cursor")
+
+        # first everything before the current line is unchanged.
+        if ti.lineno < ti.document.cursor_position_row:
+            return noop("noop:before cursor")
+
+        buffer = ti.buffer_control.buffer
+        if not buffer.suggestion or not ti.document.is_cursor_at_the_end_of_line:
+            return noop("noop:not eol")
+
+        delta = ti.lineno - ti.document.cursor_position_row
+        suggestions = buffer.suggestion.text.splitlines()
+
+        if len(suggestions) == 0:
+            return noop("noop: no suggestions")
+
+        if prompt_toolkit.VERSION < (3, 0, 49):
+            if len(suggestions) > 1 and prompt_toolkit.VERSION < (3, 0, 49):
+                if ti.lineno == ti.document.cursor_position_row:
+                    return Transformation(
+                        fragments=ti.fragments
+                        + [
+                            (
+                                "red",
+                                "(Cannot show multiline suggestion; requires prompt_toolkit > 3.0.49)",
+                            )
+                        ]
+                    )
+                else:
+                    return Transformation(fragments=ti.fragments)
+            elif len(suggestions) == 1:
+                if ti.lineno == ti.document.cursor_position_row:
+                    return Transformation(
+                        fragments=ti.fragments + [(self.style, suggestions[0])]
+                    )
+            return Transformation(fragments=ti.fragments)
+
+        if delta == 0:
+            suggestion = suggestions[0]
+            return Transformation(fragments=ti.fragments + [(self.style, suggestion)])
+        if is_last_line:
+            if delta < len(suggestions):
+                suggestion = f"… rest of suggestion ({len(suggestions) - delta} lines) and code hidden"
+                return Transformation([(self.style, suggestion)])
+
+            n_elided = len(suggestions)
+            for i in range(len(suggestions)):
+                ll = ti.get_line(last_line_number - i)
+                el = "".join(l[1] for l in ll).strip()
+                if el:
+                    break
+                else:
+                    n_elided -= 1
+            if n_elided:
+                return Transformation([(self.style, f"… {n_elided} line(s) hidden")])
+            else:
+                return Transformation(
+                    ti.get_line(last_line_number - len(suggestions) + 1)
+                    + ([(self.style, "shift-last-line")] if self._debug else [])
+                )
+
+        elif delta < len(suggestions):
+            suggestion = suggestions[delta]
+            return Transformation([(self.style, suggestion)])
+        else:
+            shift = ti.lineno - len(suggestions) + 1
+            return Transformation(ti.get_line(shift))
+
+
+class NavigableAutoSuggestFromHistory(AutoSuggestFromHistory):
+    """
+    A subclass of AutoSuggestFromHistory that allow navigation to next/previous
+    suggestion from history. To do so it remembers the current position, but it
+    state need to carefully be cleared on the right events.
+    """
+
+    skip_lines: int
+    _connected_apps: list[PromptSession]
+
+    # handle to the currently running llm task that appends suggestions to the
+    # current buffer; we keep a handle to it in order to cancel it when there is a cursor movement, or
+    # another request.
+    _llm_task: asyncio.Task | None = None
+
+    # This is the constructor of the LLM provider from jupyter-ai
+    # to which we forward the request to generate inline completions.
+    _init_llm_provider: Callable | None
+
+    _llm_provider_instance: Any | None
+    _llm_prefixer: Callable = lambda self, x: "wrong"
+
+    def __init__(self):
+        super().__init__()
+        self.skip_lines = 0
+        self._connected_apps = []
+        self._llm_provider_instance = None
+        self._init_llm_provider = None
+        self._request_number = 0
+
+    def reset_history_position(self, _: Buffer) -> None:
+        self.skip_lines = 0
+
+    def disconnect(self) -> None:
+        self._cancel_running_llm_task()
+        for pt_app in self._connected_apps:
+            text_insert_event = pt_app.default_buffer.on_text_insert
+            text_insert_event.remove_handler(self.reset_history_position)
+
+    def connect(self, pt_app: PromptSession) -> None:
+        self._connected_apps.append(pt_app)
+        # note: `on_text_changed` could be used for a bit different behaviour
+        # on character deletion (i.e. resetting history position on backspace)
+        pt_app.default_buffer.on_text_insert.add_handler(self.reset_history_position)
+        pt_app.default_buffer.on_cursor_position_changed.add_handler(self._dismiss)
+
+    def get_suggestion(
+        self, buffer: Buffer, document: Document
+    ) -> Optional[Suggestion]:
+        text = _get_query(document)
+
+        if text.strip():
+            for suggestion, _ in self._find_next_match(
+                text, self.skip_lines, buffer.history
+            ):
+                return Suggestion(suggestion)
+
+        return None
+
+    def _dismiss(self, buffer, *args, **kwargs) -> None:
+        self._cancel_running_llm_task()
+        buffer.suggestion = None
+
+    def _find_match(
+        self, text: str, skip_lines: float, history: History, previous: bool
+    ) -> Generator[Tuple[str, float], None, None]:
+        """
+        text : str
+            Text content to find a match for, the user cursor is most of the
+            time at the end of this text.
+        skip_lines : float
+            number of items to skip in the search, this is used to indicate how
+            far in the list the user has navigated by pressing up or down.
+            The float type is used as the base value is +inf
+        history : History
+            prompt_toolkit History instance to fetch previous entries from.
+        previous : bool
+            Direction of the search, whether we are looking previous match
+            (True), or next match (False).
+
+        Yields
+        ------
+        Tuple with:
+        str:
+            current suggestion.
+        float:
+            will actually yield only ints, which is passed back via skip_lines,
+            which may be a +inf (float)
+
+
+        """
+        line_number = -1
+        for string in reversed(list(history.get_strings())):
+            for line in reversed(string.splitlines()):
+                line_number += 1
+                if not previous and line_number < skip_lines:
+                    continue
+                # do not return empty suggestions as these
+                # close the auto-suggestion overlay (and are useless)
+                if line.startswith(text) and len(line) > len(text):
+                    yield line[len(text) :], line_number
+                if previous and line_number >= skip_lines:
+                    return
+
+    def _find_next_match(
+        self, text: str, skip_lines: float, history: History
+    ) -> Generator[Tuple[str, float], None, None]:
+        return self._find_match(text, skip_lines, history, previous=False)
+
+    def _find_previous_match(self, text: str, skip_lines: float, history: History):
+        return reversed(
+            list(self._find_match(text, skip_lines, history, previous=True))
+        )
+
+    def up(self, query: str, other_than: str, history: History) -> None:
+        self._cancel_running_llm_task()
+        for suggestion, line_number in self._find_next_match(
+            query, self.skip_lines, history
+        ):
+            # if user has history ['very.a', 'very', 'very.b'] and typed 'very'
+            # we want to switch from 'very.b' to 'very.a' because a) if the
+            # suggestion equals current text, prompt-toolkit aborts suggesting
+            # b) user likely would not be interested in 'very' anyways (they
+            # already typed it).
+            if query + suggestion != other_than:
+                self.skip_lines = line_number
+                break
+        else:
+            # no matches found, cycle back to beginning
+            self.skip_lines = 0
+
+    def down(self, query: str, other_than: str, history: History) -> None:
+        self._cancel_running_llm_task()
+        for suggestion, line_number in self._find_previous_match(
+            query, self.skip_lines, history
+        ):
+            if query + suggestion != other_than:
+                self.skip_lines = line_number
+                break
+        else:
+            # no matches found, cycle to end
+            for suggestion, line_number in self._find_previous_match(
+                query, float("Inf"), history
+            ):
+                if query + suggestion != other_than:
+                    self.skip_lines = line_number
+                    break
+
+    def _cancel_running_llm_task(self) -> None:
+        """
+        Try to cancel the currently running llm_task if exists, and set it to None.
+        """
+        if self._llm_task is not None:
+            if self._llm_task.done():
+                self._llm_task = None
+                return
+            cancelled = self._llm_task.cancel()
+            if cancelled:
+                self._llm_task = None
+            if not cancelled:
+                warnings.warn(
+                    "LLM task not cancelled, does your provider support cancellation?"
+                )
+
+    @property
+    def _llm_provider(self):
+        """Lazy-initialized instance of the LLM provider.
+
+        Do not use in the constructor, as `_init_llm_provider` can trigger slow side-effects.
+        """
+        if self._llm_provider_instance is None and self._init_llm_provider:
+            self._llm_provider_instance = self._init_llm_provider()
+        return self._llm_provider_instance
+
+    async def _trigger_llm(self, buffer) -> None:
+        """
+        This will ask the current llm provider a suggestion for the current buffer.
+
+        If there is a currently running llm task, it will cancel it.
+        """
+        # we likely want to store the current cursor position, and cancel if the cursor has moved.
+        try:
+            import jupyter_ai_magics
+        except ModuleNotFoundError:
+            jupyter_ai_magics = None
+        if not self._llm_provider:
+            warnings.warn("No LLM provider found, cannot trigger LLM completions")
+            return
+        if jupyter_ai_magics is None:
+            warnings.warn("LLM Completion requires `jupyter_ai_magics` to be installed")
+
+        self._cancel_running_llm_task()
+
+        async def error_catcher(buffer):
+            """
+            This catches and log any errors, as otherwise this is just
+            lost in the void of the future running task.
+            """
+            try:
+                await self._trigger_llm_core(buffer)
+            except Exception as e:
+                get_ipython().log.error("error %s", e)
+                raise
+
+        # here we need a cancellable task so we can't just await the error caught
+        self._llm_task = asyncio.create_task(error_catcher(buffer))
+        await self._llm_task
+
+    async def _trigger_llm_core(self, buffer: Buffer):
+        """
+        This is the core of the current llm request.
+
+        Here we build a compatible `InlineCompletionRequest` and ask the llm
+        provider to stream it's response back to us iteratively setting it as
+        the suggestion on the current buffer.
+
+        Unlike with JupyterAi, as we do not have multiple cells, the cell id
+        is always set to `None`.
+
+        We set the prefix to the current cell content, but could also insert the
+        rest of the history or even just the non-fail history.
+
+        In the same way, we do not have cell id.
+
+        LLM provider may return multiple suggestion stream, but for the time
+        being we only support one.
+
+        Here we make the assumption that the provider will have
+        stream_inline_completions, I'm not sure it is the case for all
+        providers.
+        """
+        try:
+            import jupyter_ai.completions.models as jai_models
+        except ModuleNotFoundError:
+            jai_models = None
+
+        if not jai_models:
+            raise ValueError("jupyter-ai is not installed")
+
+        if not self._llm_provider:
+            raise ValueError("No LLM provider found, cannot trigger LLM completions")
+
+        hm = buffer.history.shell.history_manager
+        prefix = self._llm_prefixer(hm)
+        get_ipython().log.debug("prefix: %s", prefix)
+
+        self._request_number += 1
+        request_number = self._request_number
+
+        request = jai_models.InlineCompletionRequest(
+            number=request_number,
+            prefix=prefix + buffer.document.text_before_cursor,
+            suffix=buffer.document.text_after_cursor,
+            mime="text/x-python",
+            stream=True,
+            path=None,
+            language="python",
+            cell_id=None,
+        )
+
+        async for reply_and_chunks in self._llm_provider.stream_inline_completions(
+            request
+        ):
+            if self._request_number != request_number:
+                # If a new suggestion was requested, skip processing this one.
+                return
+            if isinstance(reply_and_chunks, jai_models.InlineCompletionReply):
+                if len(reply_and_chunks.list.items) > 1:
+                    raise ValueError(
+                        "Terminal IPython cannot deal with multiple LLM suggestions at once"
+                    )
+                buffer.suggestion = Suggestion(
+                    reply_and_chunks.list.items[0].insertText
+                )
+                buffer.on_suggestion_set.fire()
+            elif isinstance(reply_and_chunks, jai_models.InlineCompletionStreamChunk):
+                buffer.suggestion = Suggestion(reply_and_chunks.response.insertText)
+                buffer.on_suggestion_set.fire()
+        return
+
+
+async def llm_autosuggestion(event: KeyPressEvent):
+    """
+    Ask the AutoSuggester from history to delegate to ask an LLM for completion
+
+    This will first make sure that the current buffer have _MIN_LINES (7)
+    available lines to insert the LLM completion
+
+    Provisional as of 8.32, may change without warnings
+
+    """
+    _MIN_LINES = 5
+    provider = get_ipython().auto_suggest
+    if not isinstance(provider, NavigableAutoSuggestFromHistory):
+        return
+    doc = event.current_buffer.document
+    lines_to_insert = max(0, _MIN_LINES - doc.line_count + doc.cursor_position_row)
+    for _ in range(lines_to_insert):
+        event.current_buffer.insert_text("\n", move_cursor=False, fire_event=False)
+
+    await provider._trigger_llm(event.current_buffer)
+
+
+def accept_or_jump_to_end(event: KeyPressEvent):
+    """Apply autosuggestion or jump to end of line."""
+    buffer = event.current_buffer
+    d = buffer.document
+    after_cursor = d.text[d.cursor_position :]
+    lines = after_cursor.split("\n")
+    end_of_current_line = lines[0].strip()
+    suggestion = buffer.suggestion
+    if (suggestion is not None) and (suggestion.text) and (end_of_current_line == ""):
+        buffer.insert_text(suggestion.text)
+    else:
+        nc.end_of_line(event)
+
+
+def accept(event: KeyPressEvent):
+    """Accept autosuggestion"""
+    buffer = event.current_buffer
+    suggestion = buffer.suggestion
+    if suggestion:
+        buffer.insert_text(suggestion.text)
+    else:
+        nc.forward_char(event)
+
+
+def discard(event: KeyPressEvent):
+    """Discard autosuggestion"""
+    buffer = event.current_buffer
+    buffer.suggestion = None
+
+
+def accept_word(event: KeyPressEvent):
+    """Fill partial autosuggestion by word"""
+    buffer = event.current_buffer
+    suggestion = buffer.suggestion
+    if suggestion:
+        t = re.split(r"(\S+\s+)", suggestion.text)
+        buffer.insert_text(next((x for x in t if x), ""))
+    else:
+        nc.forward_word(event)
+
+
+def accept_character(event: KeyPressEvent):
+    """Fill partial autosuggestion by character"""
+    b = event.current_buffer
+    suggestion = b.suggestion
+    if suggestion and suggestion.text:
+        b.insert_text(suggestion.text[0])
+
+
+def accept_and_keep_cursor(event: KeyPressEvent):
+    """Accept autosuggestion and keep cursor in place"""
+    buffer = event.current_buffer
+    old_position = buffer.cursor_position
+    suggestion = buffer.suggestion
+    if suggestion:
+        buffer.insert_text(suggestion.text)
+        buffer.cursor_position = old_position
+
+
+def accept_and_move_cursor_left(event: KeyPressEvent):
+    """Accept autosuggestion and move cursor left in place"""
+    accept_and_keep_cursor(event)
+    nc.backward_char(event)
+
+
+def _update_hint(buffer: Buffer):
+    if buffer.auto_suggest:
+        suggestion = buffer.auto_suggest.get_suggestion(buffer, buffer.document)
+        buffer.suggestion = suggestion
+
+
+def backspace_and_resume_hint(event: KeyPressEvent):
+    """Resume autosuggestions after deleting last character"""
+    nc.backward_delete_char(event)
+    _update_hint(event.current_buffer)
+
+
+def resume_hinting(event: KeyPressEvent):
+    """Resume autosuggestions"""
+    pass_through.reply(event)
+    # Order matters: if update happened first and event reply second, the
+    # suggestion would be auto-accepted if both actions are bound to same key.
+    _update_hint(event.current_buffer)
+
+
+def up_and_update_hint(event: KeyPressEvent):
+    """Go up and update hint"""
+    current_buffer = event.current_buffer
+
+    current_buffer.auto_up(count=event.arg)
+    _update_hint(current_buffer)
+
+
+def down_and_update_hint(event: KeyPressEvent):
+    """Go down and update hint"""
+    current_buffer = event.current_buffer
+
+    current_buffer.auto_down(count=event.arg)
+    _update_hint(current_buffer)
+
+
+def accept_token(event: KeyPressEvent):
+    """Fill partial autosuggestion by token"""
+    b = event.current_buffer
+    suggestion = b.suggestion
+
+    if suggestion:
+        prefix = _get_query(b.document)
+        text = prefix + suggestion.text
+
+        tokens: List[Optional[str]] = [None, None, None]
+        substrings = [""]
+        i = 0
+
+        for token in generate_tokens(StringIO(text).readline):
+            if token.type == tokenize.NEWLINE:
+                index = len(text)
+            else:
+                index = text.index(token[1], len(substrings[-1]))
+            substrings.append(text[:index])
+            tokenized_so_far = substrings[-1]
+            if tokenized_so_far.startswith(prefix):
+                if i == 0 and len(tokenized_so_far) > len(prefix):
+                    tokens[0] = tokenized_so_far[len(prefix) :]
+                    substrings.append(tokenized_so_far)
+                    i += 1
+                tokens[i] = token[1]
+                if i == 2:
+                    break
+                i += 1
+
+        if tokens[0]:
+            to_insert: str
+            insert_text = substrings[-2]
+            if tokens[1] and len(tokens[1]) == 1:
+                insert_text = substrings[-1]
+            to_insert = insert_text[len(prefix) :]
+            b.insert_text(to_insert)
+            return
+
+    nc.forward_word(event)
+
+
+Provider = Union[AutoSuggestFromHistory, NavigableAutoSuggestFromHistory, None]
+
+
+def _swap_autosuggestion(
+    buffer: Buffer,
+    provider: NavigableAutoSuggestFromHistory,
+    direction_method: Callable,
+):
+    """
+    We skip most recent history entry (in either direction) if it equals the
+    current autosuggestion because if user cycles when auto-suggestion is shown
+    they most likely want something else than what was suggested (otherwise
+    they would have accepted the suggestion).
+    """
+    suggestion = buffer.suggestion
+    if not suggestion:
+        return
+
+    query = _get_query(buffer.document)
+    current = query + suggestion.text
+
+    direction_method(query=query, other_than=current, history=buffer.history)
+
+    new_suggestion = provider.get_suggestion(buffer, buffer.document)
+    buffer.suggestion = new_suggestion
+
+
+def swap_autosuggestion_up(event: KeyPressEvent):
+    """Get next autosuggestion from history."""
+    shell = get_ipython()
+    provider = shell.auto_suggest
+
+    if not isinstance(provider, NavigableAutoSuggestFromHistory):
+        return
+
+    return _swap_autosuggestion(
+        buffer=event.current_buffer, provider=provider, direction_method=provider.up
+    )
+
+
+def swap_autosuggestion_down(event: KeyPressEvent):
+    """Get previous autosuggestion from history."""
+    shell = get_ipython()
+    provider = shell.auto_suggest
+
+    if not isinstance(provider, NavigableAutoSuggestFromHistory):
+        return
+
+    return _swap_autosuggestion(
+        buffer=event.current_buffer,
+        provider=provider,
+        direction_method=provider.down,
+    )
diff --git a/IPython/terminal/shortcuts/filters.py b/IPython/terminal/shortcuts/filters.py
new file mode 100644
index 00000000000..013bbeaecfc
--- /dev/null
+++ b/IPython/terminal/shortcuts/filters.py
@@ -0,0 +1,323 @@
+"""
+Filters restricting scope of IPython Terminal shortcuts.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import ast
+import re
+import signal
+import sys
+from typing import Dict, Union
+from collections.abc import Callable
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER
+from prompt_toolkit.key_binding import KeyPressEvent
+from prompt_toolkit.filters import Condition, Filter, emacs_insert_mode, has_completions
+from prompt_toolkit.filters import has_focus as has_focus_impl
+from prompt_toolkit.filters import (
+    Always,
+    Never,
+    has_selection,
+    has_suggestion,
+    vi_insert_mode,
+    vi_mode,
+)
+from prompt_toolkit.layout.layout import FocusableElement
+
+from IPython.core.getipython import get_ipython
+from IPython.core.guarded_eval import _find_dunder, BINARY_OP_DUNDERS, UNARY_OP_DUNDERS
+from IPython.terminal.shortcuts import auto_suggest
+from IPython.utils.decorators import undoc
+
+
+@undoc
+@Condition
+def cursor_in_leading_ws():
+    before = get_app().current_buffer.document.current_line_before_cursor
+    return (not before) or before.isspace()
+
+
+def has_focus(value: FocusableElement):
+    """Wrapper around has_focus adding a nice `__name__` to tester function"""
+    tester = has_focus_impl(value).func
+    tester.__name__ = f"is_focused({value})"
+    return Condition(tester)
+
+
+@undoc
+@Condition
+def has_line_below() -> bool:
+    document = get_app().current_buffer.document
+    return document.cursor_position_row < len(document.lines) - 1
+
+
+@undoc
+@Condition
+def is_cursor_at_the_end_of_line() -> bool:
+    document = get_app().current_buffer.document
+    return document.is_cursor_at_the_end_of_line
+
+
+@undoc
+@Condition
+def has_line_above() -> bool:
+    document = get_app().current_buffer.document
+    return document.cursor_position_row != 0
+
+
+@Condition
+def ebivim():
+    shell = get_ipython()
+    return shell.emacs_bindings_in_vi_insert_mode
+
+
+@Condition
+def supports_suspend():
+    return hasattr(signal, "SIGTSTP")
+
+
+@Condition
+def auto_match():
+    shell = get_ipython()
+    return shell.auto_match
+
+
+def all_quotes_paired(quote, buf):
+    paired = True
+    i = 0
+    while i < len(buf):
+        c = buf[i]
+        if c == quote:
+            paired = not paired
+        elif c == "\\":
+            i += 1
+        i += 1
+    return paired
+
+
+_preceding_text_cache: Dict[Union[str, Callable], Condition] = {}
+_following_text_cache: Dict[Union[str, Callable], Condition] = {}
+
+
+def preceding_text(pattern: Union[str, Callable]):
+    if pattern in _preceding_text_cache:
+        return _preceding_text_cache[pattern]
+
+    if callable(pattern):
+
+        def _preceding_text():
+            app = get_app()
+            before_cursor = app.current_buffer.document.current_line_before_cursor
+            # mypy can't infer if(callable): https://github.com/python/mypy/issues/3603
+            return bool(pattern(before_cursor))  # type: ignore[operator]
+
+    else:
+        m = re.compile(pattern)
+
+        def _preceding_text():
+            app = get_app()
+            before_cursor = app.current_buffer.document.current_line_before_cursor
+            return bool(m.match(before_cursor))
+
+        _preceding_text.__name__ = f"preceding_text({pattern!r})"
+
+    condition = Condition(_preceding_text)
+    _preceding_text_cache[pattern] = condition
+    return condition
+
+
+def following_text(pattern):
+    try:
+        return _following_text_cache[pattern]
+    except KeyError:
+        pass
+    m = re.compile(pattern)
+
+    def _following_text():
+        app = get_app()
+        return bool(m.match(app.current_buffer.document.current_line_after_cursor))
+
+    _following_text.__name__ = f"following_text({pattern!r})"
+
+    condition = Condition(_following_text)
+    _following_text_cache[pattern] = condition
+    return condition
+
+
+@Condition
+def not_inside_unclosed_string():
+    app = get_app()
+    s = app.current_buffer.document.text_before_cursor
+    # remove escaped quotes
+    s = s.replace('\\"', "").replace("\\'", "")
+    # remove triple-quoted string literals
+    s = re.sub(r"(?:\"\"\"[\s\S]*\"\"\"|'''[\s\S]*''')", "", s)
+    # remove single-quoted string literals
+    s = re.sub(r"""(?:"[^"]*["\n]|'[^']*['\n])""", "", s)
+    return not ('"' in s or "'" in s)
+
+
+@Condition
+def navigable_suggestions():
+    shell = get_ipython()
+    return isinstance(shell.auto_suggest, auto_suggest.NavigableAutoSuggestFromHistory)
+
+
+@Condition
+def readline_like_completions():
+    shell = get_ipython()
+    return shell.display_completions == "readlinelike"
+
+
+@Condition
+def is_windows_os():
+    return sys.platform == "win32"
+
+
+class PassThrough(Filter):
+    """A filter allowing to implement pass-through behaviour of keybindings.
+
+    Prompt toolkit key processor dispatches only one event per binding match,
+    which means that adding a new shortcut will suppress the old shortcut
+    if the keybindings are the same (unless one is filtered out).
+
+    To stop a shortcut binding from suppressing other shortcuts:
+    - add the `pass_through` filter to list of filter, and
+    - call `pass_through.reply(event)` in the shortcut handler.
+    """
+
+    def __init__(self):
+        self._is_replying = False
+
+    def reply(self, event: KeyPressEvent):
+        self._is_replying = True
+        try:
+            event.key_processor.reset()
+            event.key_processor.feed_multiple(event.key_sequence)
+            event.key_processor.process_keys()
+        finally:
+            self._is_replying = False
+
+    def __call__(self):
+        return not self._is_replying
+
+
+pass_through = PassThrough()
+
+# these one is callable and re-used multiple times hence needs to be
+# only defined once beforehand so that transforming back to human-readable
+# names works well in the documentation.
+default_buffer_focused = has_focus(DEFAULT_BUFFER)
+
+KEYBINDING_FILTERS = {
+    "always": Always(),
+    # never is used for exposing commands which have no default keybindings
+    "never": Never(),
+    "has_line_below": has_line_below,
+    "has_line_above": has_line_above,
+    "is_cursor_at_the_end_of_line": is_cursor_at_the_end_of_line,
+    "has_selection": has_selection,
+    "has_suggestion": has_suggestion,
+    "vi_mode": vi_mode,
+    "vi_insert_mode": vi_insert_mode,
+    "emacs_insert_mode": emacs_insert_mode,
+    # https://github.com/ipython/ipython/pull/12603 argued for inclusion of
+    # emacs key bindings with a configurable `emacs_bindings_in_vi_insert_mode`
+    # toggle; when the toggle is on user can access keybindigns like `ctrl + e`
+    # in vi insert mode. Because some of the emacs bindings involve `escape`
+    # followed by another key, e.g. `escape` followed by `f`, prompt-toolkit
+    # needs to wait to see if there will be another character typed in before
+    # executing pure `escape` keybinding; in vi insert mode `escape` switches to
+    # command mode which is common and performance critical action for vi users.
+    # To avoid the delay users employ a workaround:
+    # https://github.com/ipython/ipython/issues/13443#issuecomment-1032753703
+    # which involves switching `emacs_bindings_in_vi_insert_mode` off.
+    #
+    # For the workaround to work:
+    # 1) end users need to toggle `emacs_bindings_in_vi_insert_mode` off
+    # 2) all keybindings which would involve `escape` need to respect that
+    #    toggle by including either:
+    #      - `vi_insert_mode & ebivim` for actions which have emacs keybindings
+    #        predefined upstream in prompt-toolkit, or
+    #      - `emacs_like_insert_mode` for actions which do not have existing
+    #        emacs keybindings predefined upstream (or need overriding of the
+    #        upstream bindings to modify behaviour), defined below.
+    "emacs_like_insert_mode": (vi_insert_mode & ebivim) | emacs_insert_mode,
+    "has_completions": has_completions,
+    "insert_mode": vi_insert_mode | emacs_insert_mode,
+    "default_buffer_focused": default_buffer_focused,
+    "search_buffer_focused": has_focus(SEARCH_BUFFER),
+    # `ebivim` stands for emacs bindings in vi insert mode
+    "ebivim": ebivim,
+    "supports_suspend": supports_suspend,
+    "is_windows_os": is_windows_os,
+    "auto_match": auto_match,
+    "focused_insert": (vi_insert_mode | emacs_insert_mode) & default_buffer_focused,
+    "not_inside_unclosed_string": not_inside_unclosed_string,
+    "readline_like_completions": readline_like_completions,
+    "preceded_by_paired_double_quotes": preceding_text(
+        lambda line: all_quotes_paired('"', line)
+    ),
+    "preceded_by_paired_single_quotes": preceding_text(
+        lambda line: all_quotes_paired("'", line)
+    ),
+    "preceded_by_raw_str_prefix": preceding_text(r".*(r|R)[\"'](-*)$"),
+    "preceded_by_two_double_quotes": preceding_text(r'^.*""$'),
+    "preceded_by_two_single_quotes": preceding_text(r"^.*''$"),
+    "followed_by_closing_paren_or_end": following_text(r"[,)}\]]|$"),
+    "preceded_by_opening_round_paren": preceding_text(r".*\($"),
+    "preceded_by_opening_bracket": preceding_text(r".*\[$"),
+    "preceded_by_opening_brace": preceding_text(r".*\{$"),
+    "preceded_by_double_quote": preceding_text('.*"$'),
+    "preceded_by_single_quote": preceding_text(r".*'$"),
+    "followed_by_closing_round_paren": following_text(r"^\)"),
+    "followed_by_closing_bracket": following_text(r"^\]"),
+    "followed_by_closing_brace": following_text(r"^\}"),
+    "followed_by_double_quote": following_text('^"'),
+    "followed_by_single_quote": following_text("^'"),
+    "navigable_suggestions": navigable_suggestions,
+    "cursor_in_leading_ws": cursor_in_leading_ws,
+    "pass_through": pass_through,
+}
+
+
+def eval_node(node: Union[ast.AST, None]):
+    if node is None:
+        return None
+    if isinstance(node, ast.Expression):
+        return eval_node(node.body)
+    if isinstance(node, ast.BinOp):
+        left = eval_node(node.left)
+        right = eval_node(node.right)
+        dunders = _find_dunder(node.op, BINARY_OP_DUNDERS)
+        if dunders:
+            return getattr(left, dunders[0])(right)
+        raise ValueError(f"Unknown binary operation: {node.op}")
+    if isinstance(node, ast.UnaryOp):
+        value = eval_node(node.operand)
+        dunders = _find_dunder(node.op, UNARY_OP_DUNDERS)
+        if dunders:
+            return getattr(value, dunders[0])()
+        raise ValueError(f"Unknown unary operation: {node.op}")
+    if isinstance(node, ast.Name):
+        if node.id in KEYBINDING_FILTERS:
+            return KEYBINDING_FILTERS[node.id]
+        else:
+            sep = "\n  - "
+            known_filters = sep.join(sorted(KEYBINDING_FILTERS))
+            raise NameError(
+                f"{node.id} is not a known shortcut filter."
+                f" Known filters are: {sep}{known_filters}."
+            )
+    raise ValueError("Unhandled node", ast.dump(node))
+
+
+def filter_from_string(code: str):
+    expression = ast.parse(code, mode="eval")
+    return eval_node(expression)
+
+
+__all__ = ["KEYBINDING_FILTERS", "filter_from_string"]
diff --git a/IPython/testing/__init__.py b/IPython/testing/__init__.py
index ea70b450199..8fcd65ea41a 100644
--- a/IPython/testing/__init__.py
+++ b/IPython/testing/__init__.py
@@ -2,28 +2,19 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
+#  Copyright (C) 2009-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-# User-level entry point for testing
-def test():
-    """Run the entire IPython test suite.
 
-    For fine-grained control, you should use the :file:`iptest` script supplied
-    with the IPython installation."""
+import os
 
-    # Do the import internally, so that this function doesn't increase total
-    # import time
-    from iptest import run_iptestall
-    run_iptestall()
+#-----------------------------------------------------------------------------
+# Constants
+#-----------------------------------------------------------------------------
 
-# So nose doesn't try to run this as a test itself and we end up with an
-# infinite test loop
-test.__test__ = False
+# We scale all timeouts via this factor, slow machines can increase it
+IPYTHON_TESTING_TIMEOUT_SCALE = float(os.getenv(
+                                    'IPYTHON_TESTING_TIMEOUT_SCALE', 1))
diff --git a/IPython/testing/_paramtestpy2.py b/IPython/testing/_paramtestpy2.py
deleted file mode 100644
index d9a05d92032..00000000000
--- a/IPython/testing/_paramtestpy2.py
+++ /dev/null
@@ -1,96 +0,0 @@
-"""Implementation of the parametric test support for Python 2.x
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import unittest
-from compiler.consts import CO_GENERATOR
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-def isgenerator(func):
-    try:
-        return func.func_code.co_flags & CO_GENERATOR != 0
-    except AttributeError:
-        return False
-
-class ParametricTestCase(unittest.TestCase):
-    """Write parametric tests in normal unittest testcase form.
-
-    Limitations: the last iteration misses printing out a newline when running
-    in verbose mode.
-    """
-    def run_parametric(self, result, testMethod):
-        # But if we have a test generator, we iterate it ourselves
-        testgen = testMethod()
-        while True:
-            try:
-                # Initialize test
-                result.startTest(self)
-
-                # SetUp
-                try:
-                    self.setUp()
-                except KeyboardInterrupt:
-                    raise
-                except:
-                    result.addError(self, self._exc_info())
-                    return
-                # Test execution
-                ok = False
-                try:
-                    testgen.next()
-                    ok = True
-                except StopIteration:
-                    # We stop the loop
-                    break
-                except self.failureException:
-                    result.addFailure(self, self._exc_info())
-                except KeyboardInterrupt:
-                    raise
-                except:
-                    result.addError(self, self._exc_info())
-                # TearDown
-                try:
-                    self.tearDown()
-                except KeyboardInterrupt:
-                    raise
-                except:
-                    result.addError(self, self._exc_info())
-                    ok = False
-                if ok: result.addSuccess(self)
-
-            finally:
-                result.stopTest(self)
-
-    def run(self, result=None):
-        if result is None:
-            result = self.defaultTestResult()
-        testMethod = getattr(self, self._testMethodName)
-        # For normal tests, we just call the base class and return that
-        if isgenerator(testMethod):
-            return self.run_parametric(result, testMethod)
-        else:
-            return super(ParametricTestCase, self).run(result)
-
-
-def parametric(func):
-    """Decorator to make a simple function into a normal test via unittest."""
-
-    class Tester(ParametricTestCase):
-        test = staticmethod(func)
-
-    Tester.__name__ = func.__name__
-
-    return Tester
diff --git a/IPython/testing/_paramtestpy3.py b/IPython/testing/_paramtestpy3.py
deleted file mode 100644
index 200ca0dffec..00000000000
--- a/IPython/testing/_paramtestpy3.py
+++ /dev/null
@@ -1,69 +0,0 @@
-"""Implementation of the parametric test support for Python 3.x.
-
-Thanks for the py3 version to Robert Collins, from the Testing in Python
-mailing list.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import unittest
-from unittest import TestSuite
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-
-def isgenerator(func):
-    return hasattr(func,'_generator')
-
-
-class IterCallableSuite(TestSuite):
-   def __init__(self, iterator, adapter):
-       self._iter = iterator
-       self._adapter = adapter
-   def __iter__(self):
-       yield self._adapter(self._iter.__next__)
-
-class ParametricTestCase(unittest.TestCase):
-   """Write parametric tests in normal unittest testcase form.
-
-   Limitations: the last iteration misses printing out a newline when
-   running in verbose mode.
-   """
-
-   def run(self, result=None):
-       testMethod = getattr(self, self._testMethodName)
-       # For normal tests, we just call the base class and return that
-       if isgenerator(testMethod):
-           def adapter(next_test):
-               return unittest.FunctionTestCase(next_test,
-                                                self.setUp,
-                                                self.tearDown)
-
-           return IterCallableSuite(testMethod(),adapter).run(result)
-       else:
-           return super(ParametricTestCase, self).run(result)
-
-
-def parametric(func):
-   """Decorator to make a simple function into a normal test via
-unittest."""
-   # Hack, until I figure out how to write isgenerator() for python3!!
-   func._generator = True
-
-   class Tester(ParametricTestCase):
-       test = staticmethod(func)
-
-   Tester.__name__ = func.__name__
-
-   return Tester
diff --git a/IPython/testing/decorators.py b/IPython/testing/decorators.py
index de3051db8d1..1b2ed16b995 100644
--- a/IPython/testing/decorators.py
+++ b/IPython/testing/decorators.py
@@ -1,249 +1,43 @@
-"""Decorators for labeling test objects.
-
-Decorators that merely return a modified version of the original function
-object are straightforward.  Decorators that return a new function object need
-to use nose.tools.make_decorator(original_function)(decorator) in returning the
-decorator, in order to preserve metadata such as function name, setup and
-teardown functions and so on - see nose.tools for more information.
-
-This module provides a set of useful decorators meant to be ready to use in
-your own tests.  See the bottom of the file for the ready-made ones, and if you
-find yourself writing a new one that may be of generic use, add it here.
-
-Included decorators:
-
-
-Lightweight testing that remains unittest-compatible.
-
-- @parametric, for parametric test support that is vastly easier to use than
-  nose's for debugging. With ours, if a test fails, the stack under inspection
-  is that of the test and not that of the test framework.
-
-- An @as_unittest decorator can be used to tag any normal parameter-less
-  function as a unittest TestCase.  Then, both nose and normal unittest will
-  recognize it as such.  This will make it easier to migrate away from Nose if
-  we ever need/want to while maintaining very lightweight tests.
-
-NOTE: This file contains IPython-specific decorators. Using the machinery in
-IPython.external.decorators, we import either numpy.testing.decorators if numpy is
-available, OR use equivalent code in IPython.external._decorators, which
-we've copied verbatim from numpy.
-
-Authors
--------
-
-- Fernando Perez <Fernando.Perez@berkeley.edu>
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Stdlib imports
-import inspect
+import os
+import shutil
 import sys
-import unittest
+import tempfile
+from importlib import import_module
 
-# Third-party imports
-
-# This is Michele Simionato's decorator module, kept verbatim.
-from IPython.external.decorator import decorator, update_wrapper
-
-# We already have python3-compliant code for parametric tests
-if sys.version[0]=='2':
-    from _paramtestpy2 import parametric, ParametricTestCase
-else:
-    from _paramtestpy3 import parametric, ParametricTestCase
+import pytest
 
 # Expose the unittest-driven decorators
-from ipunittest import ipdoctest, ipdocstring
-
-# Grab the numpy-specific decorators which we keep in a file that we
-# occasionally update from upstream: decorators.py is a copy of
-# numpy.testing.decorators, we expose all of it here.
-from IPython.external.decorators import *
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-# Simple example of the basic idea
-def as_unittest(func):
-    """Decorator to make a simple function into a normal test via unittest."""
-    class Tester(unittest.TestCase):
-        def test(self):
-            func()
-
-    Tester.__name__ = func.__name__
-
-    return Tester
-
-# Utility functions
-
-def apply_wrapper(wrapper,func):
-    """Apply a wrapper to a function for decoration.
-
-    This mixes Michele Simionato's decorator tool with nose's make_decorator,
-    to apply a wrapper in a decorator so that all nose attributes, as well as
-    function signature and other properties, survive the decoration cleanly.
-    This will ensure that wrapped functions can still be well introspected via
-    IPython, for example.
-    """
-    import nose.tools
+from .ipunittest import ipdoctest, ipdocstring
 
-    return decorator(wrapper,nose.tools.make_decorator(func)(wrapper))
-
-
-def make_label_dec(label,ds=None):
-    """Factory function to create a decorator that applies one or more labels.
+def skipif(skip_condition, msg=None):
+    """Make function raise SkipTest exception if skip_condition is true
 
     Parameters
     ----------
-      label : string or sequence
-      One or more labels that will be applied by the decorator to the functions
-    it decorates.  Labels are attributes of the decorated function with their
-    value set to True.
 
-      ds : string
-      An optional docstring for the resulting decorator.  If not given, a
-      default docstring is auto-generated.
+    skip_condition : bool or callable
+      Flag to determine whether to skip test. If the condition is a
+      callable, it is used at runtime to dynamically make the decision. This
+      is useful for tests that may require costly imports, to delay the cost
+      until the test suite is actually executed.
+    msg : string
+      Message to give on raising a SkipTest exception.
 
     Returns
     -------
-      A decorator.
-
-    Examples
-    --------
-
-    A simple labeling decorator:
-    >>> slow = make_label_dec('slow')
-    >>> print slow.__doc__
-    Labels a test as 'slow'.
-
-    And one that uses multiple labels and a custom docstring:
-    >>> rare = make_label_dec(['slow','hard'],
-    ... "Mix labels 'slow' and 'hard' for rare tests.")
-    >>> print rare.__doc__
-    Mix labels 'slow' and 'hard' for rare tests.
-
-    Now, let's test using this one:
-    >>> @rare
-    ... def f(): pass
-    ...
-    >>>
-    >>> f.slow
-    True
-    >>> f.hard
-    True
+    decorator : function
+      Decorator, which, when applied to a function, causes SkipTest
+      to be raised when the skip_condition was True, and the function
+      to be called normally otherwise.
     """
+    if msg is None:
+        msg = "Test skipped due to test condition."
 
-    if isinstance(label,basestring):
-        labels = [label]
-    else:
-        labels = label
-        
-    # Validate that the given label(s) are OK for use in setattr() by doing a
-    # dry run on a dummy function.
-    tmp = lambda : None
-    for label in labels:
-        setattr(tmp,label,True)
-
-    # This is the actual decorator we'll return
-    def decor(f):
-        for label in labels:
-            setattr(f,label,True)
-        return f
-    
-    # Apply the user's docstring, or autogenerate a basic one
-    if ds is None:
-        ds = "Labels a test as %r." % label
-    decor.__doc__ = ds
-    
-    return decor
-
-
-# Inspired by numpy's skipif, but uses the full apply_wrapper utility to
-# preserve function metadata better and allows the skip condition to be a
-# callable.
-def skipif(skip_condition, msg=None):
-    ''' Make function raise SkipTest exception if skip_condition is true
+    assert isinstance(skip_condition, bool)
+    return pytest.mark.skipif(skip_condition, reason=msg)
 
-    Parameters
-    ----------
-    skip_condition : bool or callable. 
-    Flag to determine whether to skip test.  If the condition is a 
-    callable, it is used at runtime to dynamically make the decision.  This 
-    is useful for tests that may require costly imports, to delay the cost 
-    until the test suite is actually executed.        
-    msg : string
-        Message to give on raising a SkipTest exception
-
-   Returns
-   -------
-   decorator : function
-       Decorator, which, when applied to a function, causes SkipTest
-       to be raised when the skip_condition was True, and the function
-       to be called normally otherwise.
-
-    Notes
-    -----
-    You will see from the code that we had to further decorate the
-    decorator with the nose.tools.make_decorator function in order to
-    transmit function name, and various other metadata.
-    '''
-
-    def skip_decorator(f):
-        # Local import to avoid a hard nose dependency and only incur the 
-        # import time overhead at actual test-time. 
-        import nose
-
-        # Allow for both boolean or callable skip conditions.
-        if callable(skip_condition):
-            skip_val = skip_condition
-        else:
-            skip_val = lambda : skip_condition
-
-        def get_msg(func,msg=None):
-            """Skip message with information about function being skipped."""
-            if msg is None: out = 'Test skipped due to test condition.'
-            else: out = msg
-            return "Skipping test: %s. %s" % (func.__name__,out)
-
-        # We need to define *two* skippers because Python doesn't allow both
-        # return with value and yield inside the same function.
-        def skipper_func(*args, **kwargs):
-            """Skipper for normal test functions."""
-            if skip_val():
-                raise nose.SkipTest(get_msg(f,msg))
-            else:
-                return f(*args, **kwargs) 
-
-        def skipper_gen(*args, **kwargs):
-            """Skipper for test generators."""
-            if skip_val():
-                raise nose.SkipTest(get_msg(f,msg))
-            else:
-                for x in f(*args, **kwargs):
-                    yield x
-
-        # Choose the right skipper to use when building the actual generator.
-        if nose.util.isgenerator(f):
-            skipper = skipper_gen
-        else:
-            skipper = skipper_func
-            
-        return nose.tools.make_decorator(f)(skipper)
-
-    return skip_decorator
-
-# A version with the condition set to true, common case just to attacha message
+
+# A version with the condition set to true, common case just to attach a message
 # to a skip decorator
 def skip(msg=None):
     """Decorator factory - mark a test function for skipping from test suite.
@@ -258,22 +52,22 @@ def skip(msg=None):
        decorator : function
          Decorator, which, when applied to a function, causes SkipTest
          to be raised, with the optional message added.
-      """
-
-    return skipif(True,msg)
+    """
+    if msg and not isinstance(msg, str):
+        raise ValueError(
+            "invalid object passed to `@skip` decorator, did you "
+            "meant `@skip()` with brackets ?"
+        )
+    return skipif(True, msg)
 
 
 def onlyif(condition, msg):
     """The reverse from skipif, see skipif for details."""
 
-    if callable(condition):
-        skip_condition = lambda : not condition()
-    else:
-        skip_condition = lambda : not condition
+    return skipif(not condition, msg)
 
-    return skipif(skip_condition, msg)
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Utility functions for decorators
 def module_not_available(module):
     """Can module be imported?  Returns true if module does NOT import.
@@ -282,46 +76,75 @@ def module_not_available(module):
     available, but delay the 'import numpy' to test execution time.
     """
     try:
-        mod = __import__(module)
+        mod = import_module(module)
         mod_not_avail = False
-    except ImportError:
+    except Exception:
+        # Catch all exceptions, not just ImportError, since modules can fail
+        # to import for various reasons (e.g., compatibility issues with newer
+        # Python versions causing TypeError, AttributeError, etc.)
         mod_not_avail = True
 
     return mod_not_avail
 
-#-----------------------------------------------------------------------------
-# Decorators for public use
-
-skip_doctest = make_label_dec('skip_doctest',
-    """Decorator - mark a function or method for skipping its doctest.
 
-    This decorator allows you to mark a function whose docstring you wish to
-    omit from testing, while preserving the docstring for introspection, help,
-    etc.""")                              
+# -----------------------------------------------------------------------------
+# Decorators for public use
 
 # Decorators to skip certain tests on specific platforms.
-skip_win32 = skipif(sys.platform == 'win32',
-                    "This test does not run under Windows")
-skip_linux = skipif(sys.platform == 'linux2',
-                    "This test does not run under Linux")
-skip_osx = skipif(sys.platform == 'darwin',"This test does not run under OS X")
+skip_win32 = skipif(sys.platform == "win32", "This test does not run under Windows")
 
 
 # Decorators to skip tests if not on specific platforms.
-skip_if_not_win32 = skipif(sys.platform != 'win32',
-                           "This test only runs under Windows")
-skip_if_not_linux = skipif(sys.platform != 'linux2',
-                           "This test only runs under Linux")
-skip_if_not_osx = skipif(sys.platform != 'darwin',
-                         "This test only runs under OSX")
+skip_if_not_win32 = skipif(sys.platform != "win32", "This test only runs under Windows")
+skip_if_not_osx = skipif(
+    not sys.platform.startswith("darwin"), "This test only runs under macOS"
+)
+
+_x11_skip_cond = (
+    sys.platform not in ("darwin", "win32") and os.environ.get("DISPLAY", "") == ""
+)
+_x11_skip_msg = "Skipped under *nix when X11/XOrg not available"
+
+skip_if_no_x11 = skipif(_x11_skip_cond, _x11_skip_msg)
 
 # Other skip decorators
-skipif_not_numpy = skipif(module_not_available('numpy'),"This test requires numpy")
 
-skipif_not_sympy = skipif(module_not_available('sympy'),"This test requires sympy")
+# generic skip without module
+skip_without = lambda mod: skipif(
+    module_not_available(mod), "This test requires %s" % mod
+)
+
+skipif_not_numpy = skip_without("numpy")
 
-skip_known_failure = knownfailureif(True,'This test is known to fail')
+skipif_not_matplotlib = skip_without("matplotlib")
 
 # A null 'decorator', useful to make more readable code that needs to pick
 # between different decorators based on OS or other conditions
 null_deco = lambda f: f
+
+# Some tests only run where we can use unicode paths. Note that we can't just
+# check os.path.supports_unicode_filenames, which is always False on Linux.
+try:
+    f = tempfile.NamedTemporaryFile(prefix="tmp€")
+except UnicodeEncodeError:
+    unicode_paths = False
+# TODO: should this be finnally ?
+else:
+    unicode_paths = True
+    f.close()
+
+onlyif_unicode_paths = onlyif(
+    unicode_paths,
+    ("This test is only applicable where we can use unicode in filenames."),
+)
+
+
+def onlyif_cmds_exist(*commands):
+    """
+    Decorator to skip test when at least one of `commands` is not found.
+    """
+    for cmd in commands:
+        reason = f"This test runs only if command '{cmd}' is installed"
+        if not shutil.which(cmd):
+            return pytest.mark.skip(reason=reason)
+    return null_deco
diff --git a/IPython/testing/globalipapp.py b/IPython/testing/globalipapp.py
index 162dba9a966..3a699e07d61 100644
--- a/IPython/testing/globalipapp.py
+++ b/IPython/testing/globalipapp.py
@@ -5,133 +5,21 @@
 into a fit.  This code should be considered a gross hack, but it gets the job
 done.
 """
-from __future__ import absolute_import
-from __future__ import print_function
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# stdlib
-import __builtin__
-import os
-import sys
-from types import MethodType
-
-# our own
-from . import tools
-
-from IPython.utils import io
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
-
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-class StreamProxy(io.IOStream):
-    """Proxy for sys.stdout/err.  This will request the stream *at call time*
-    allowing for nose's Capture plugin's redirection of sys.stdout/err.
-    
-    Parameters
-    ----------
-    name : str
-        The name of the stream. This will be requested anew at every call
-    """
-    
-    def __init__(self, name):
-        self.name=name
-    
-    @property
-    def stream(self):
-        return getattr(sys, self.name)
-    
-    def flush(self):
-        self.stream.flush()
-
-# Hack to modify the %run command so we can sync the user's namespace with the
-# test globals.  Once we move over to a clean magic system, this will be done
-# with much less ugliness.
-
-class py_file_finder(object):
-    def __init__(self,test_filename):
-        self.test_filename = test_filename
-        
-    def __call__(self,name):
-        from IPython.utils.path import get_py_filename
-        try:
-            return get_py_filename(name)
-        except IOError:
-            test_dir = os.path.dirname(self.test_filename)
-            new_path = os.path.join(test_dir,name)
-            return get_py_filename(new_path)
-    
 
-def _run_ns_sync(self,arg_s,runner=None):
-    """Modified version of %run that syncs testing namespaces.
-
-    This is strictly needed for running doctests that call %run.
-    """
-    #print('in run_ns_sync', arg_s, file=sys.stderr)  # dbg
-    finder = py_file_finder(arg_s)
-    return get_ipython().magic_run_ori(arg_s, runner, finder)
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
+import builtins as builtin_mod
+import sys
+import types
 
-class ipnsdict(dict):
-    """A special subclass of dict for use as an IPython namespace in doctests.
+from pathlib import Path
 
-    This subclass adds a simple checkpointing capability so that when testing
-    machinery clears it (we use it as the test execution context), it doesn't
-    get completely destroyed.
+from . import tools
 
-    In addition, it can handle the presence of the '_' key in a special manner,
-    which is needed because of how Python's doctest machinery operates with
-    '_'.  See constructor and :meth:`update` for details.
-    """
-    
-    def __init__(self,*a):
-        dict.__init__(self,*a)
-        self._savedict = {}
-        # If this flag is True, the .update() method will unconditionally
-        # remove a key named '_'.  This is so that such a dict can be used as a
-        # namespace in doctests that call '_'.
-        self.protect_underscore = False
-        
-    def clear(self):
-        dict.clear(self)
-        self.update(self._savedict)
-        
-    def _checkpoint(self):
-        self._savedict.clear()
-        self._savedict.update(self)
-
-    def update(self,other):
-        self._checkpoint()
-        dict.update(self,other)
-
-        if self.protect_underscore:
-            # If '_' is in the namespace, python won't set it when executing
-            # code *in doctests*, and we have multiple doctests that use '_'.
-            # So we ensure that the namespace is always 'clean' of it before
-            # it's used for test code execution.
-            # This flag is only turned on by the doctest machinery, so that
-            # normal test code can assume the _ key is updated like any other
-            # key and can test for its presence after cell executions.
-            self.pop('_', None)
-
-        # The builtins namespace must *always* be the real __builtin__ module,
-        # else weird stuff happens.  The main ipython code does have provisions
-        # to ensure this after %run, but since in this class we do some
-        # aggressive low-level cleaning of the execution namespace, we need to
-        # correct for that ourselves, to ensure consitency with the 'real'
-        # ipython.
-        self['__builtins__'] = __builtin__
+from IPython.core import page
+from IPython.utils import io
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
 
 
 def get_ipython():
@@ -148,7 +36,7 @@ def xsys(self, cmd):
     """
     # We use getoutput, but we need to strip it because pexpect captures
     # the trailing newline differently from commands.getoutput
-    print(self.getoutput(cmd, split=False).rstrip(), end='', file=sys.stdout)
+    print(self.getoutput(cmd, split=False, depth=1).rstrip(), end='', file=sys.stdout)
     sys.stdout.flush()
 
 
@@ -167,7 +55,7 @@ def start_ipython():
     if hasattr(start_ipython, 'already_called'):
         return
     start_ipython.already_called = True
-    
+
     # Store certain global objects that IPython modifies
     _displayhook = sys.displayhook
     _excepthook = sys.excepthook
@@ -175,15 +63,17 @@ def start_ipython():
 
     # Create custom argv and namespaces for our IPython to be test-friendly
     config = tools.default_config()
+    config.TerminalInteractiveShell.simple_prompt = True
 
     # Create and initialize our test-friendly IPython instance.
-    shell = TerminalInteractiveShell.instance(config=config, 
-                                              user_ns=ipnsdict(),
-                                              user_global_ns={}
+    shell = TerminalInteractiveShell.instance(config=config,
                                               )
 
     # A few more tweaks needed for playing nicely with doctests...
-    
+
+    # remove history file
+    shell.tempfiles.append(Path(config.HistoryManager.hist_file))
+
     # These traps are normally only active for interactive use, set them
     # permanently since we'll be mocking interactive sessions.
     shell.builtin_trap.activate()
@@ -191,14 +81,12 @@ def start_ipython():
     # Modify the IPython system call with one that uses getoutput, so that we
     # can capture subcommands and print them to Python's stdout, otherwise the
     # doctest machinery would miss them.
-    shell.system = MethodType(xsys, shell, TerminalInteractiveShell)
-                       
+    shell.system = types.MethodType(xsys, shell)
 
-    shell._showtraceback = MethodType(_showtraceback, shell,
-                                      TerminalInteractiveShell)
+    shell._showtraceback = types.MethodType(_showtraceback, shell)
 
     # IPython is ready, now clean up some global state...
-    
+
     # Deactivate the various python system hooks added by ipython for
     # interactive convenience so we don't confuse the doctest system
     sys.modules['__main__'] = _main
@@ -210,11 +98,17 @@ def start_ipython():
     # now return this without recursively calling here again.
     _ip = shell
     get_ipython = _ip.get_ipython
-    __builtin__._ip = _ip
-    __builtin__.get_ipython = get_ipython
+    builtin_mod._ip = _ip
+    builtin_mod.ip = _ip
+    builtin_mod.get_ipython = get_ipython
+
+    # Override paging, so we don't require user interaction during the tests.
+    def nopage(strng, start=0, screen_lines=0, pager_cmd=None):
+        if isinstance(strng, dict):
+           strng = strng.get('text/plain', '')
+        print(strng)
     
-    # To avoid extra IPython messages during testing, suppress io.stdout/stderr
-    io.stdout = StreamProxy('stdout')
-    io.stderr = StreamProxy('stderr')
+    page.orig_page = page.pager_page
+    page.pager_page = nopage
 
     return _ip
diff --git a/IPython/testing/iptest.py b/IPython/testing/iptest.py
deleted file mode 100644
index ba7e2f7c412..00000000000
--- a/IPython/testing/iptest.py
+++ /dev/null
@@ -1,440 +0,0 @@
-# -*- coding: utf-8 -*-
-"""IPython Test Suite Runner.
-
-This module provides a main entry point to a user script to test IPython
-itself from the command line. There are two ways of running this script:
-
-1. With the syntax `iptest all`.  This runs our entire test suite by
-   calling this script (with different arguments) recursively.  This
-   causes modules and package to be tested in different processes, using nose
-   or trial where appropriate.
-2. With the regular nose syntax, like `iptest -vvs IPython`.  In this form
-   the script simply calls nose, but with special command line flags and
-   plugins loaded.
-
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Stdlib
-import os
-import os.path as path
-import signal
-import sys
-import subprocess
-import tempfile
-import time
-import warnings
-
-# Note: monkeypatch!
-# We need to monkeypatch a small problem in nose itself first, before importing
-# it for actual use.  This should get into nose upstream, but its release cycle
-# is slow and we need it for our parametric tests to work correctly.
-from IPython.testing import nosepatch
-# Now, proceed to import nose itself
-import nose.plugins.builtin
-from nose.core import TestProgram
-
-# Our own imports
-from IPython.utils.path import get_ipython_module_path
-from IPython.utils.process import find_cmd, pycmd2argv
-from IPython.utils.sysinfo import sys_info
-
-from IPython.testing import globalipapp
-from IPython.testing.plugin.ipdoctest import IPythonDoctest
-from IPython.external.decorators import KnownFailure
-
-pjoin = path.join
-
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-
-#-----------------------------------------------------------------------------
-# Warnings control
-#-----------------------------------------------------------------------------
-
-# Twisted generates annoying warnings with Python 2.6, as will do other code
-# that imports 'sets' as of today
-warnings.filterwarnings('ignore', 'the sets module is deprecated',
-                        DeprecationWarning )
-
-# This one also comes from Twisted
-warnings.filterwarnings('ignore', 'the sha module is deprecated',
-                        DeprecationWarning)
-
-# Wx on Fedora11 spits these out
-warnings.filterwarnings('ignore', 'wxPython/wxWidgets release number mismatch',
-                        UserWarning)
-
-#-----------------------------------------------------------------------------
-# Logic for skipping doctests
-#-----------------------------------------------------------------------------
-
-def test_for(mod, min_version=None):
-    """Test to see if mod is importable."""
-    try:
-        __import__(mod)
-    except (ImportError, RuntimeError):
-        # GTK reports Runtime error if it can't be initialized even if  it's
-        # importable.
-        return False
-    else:
-        if min_version:
-            return sys.modules[mod].__version__ >= min_version
-        else:
-            return True
-
-# Global dict where we can store information on what we have and what we don't
-# have available at test run time
-have = {}
-
-have['curses'] = test_for('_curses')
-have['matplotlib'] = test_for('matplotlib')
-have['pexpect'] = test_for('pexpect')
-have['pymongo'] = test_for('pymongo')
-have['wx'] = test_for('wx')
-have['wx.aui'] = test_for('wx.aui')
-if os.name == 'nt':
-    have['zmq'] = test_for('zmq', '2.1dev')
-else:
-    have['zmq'] = test_for('zmq', '2.1.4')
-have['qt'] = test_for('IPython.external.qt')
-
-#-----------------------------------------------------------------------------
-# Functions and classes
-#-----------------------------------------------------------------------------
-
-def report():
-    """Return a string with a summary report of test-related variables."""
-
-    out = [ sys_info(), '\n']
-
-    avail = []
-    not_avail = []
-    
-    for k, is_avail in have.items():
-        if is_avail:
-            avail.append(k)
-        else:
-            not_avail.append(k)
-
-    if avail:
-        out.append('\nTools and libraries available at test time:\n')
-        avail.sort()
-        out.append('   ' + ' '.join(avail)+'\n')
-
-    if not_avail:
-        out.append('\nTools and libraries NOT available at test time:\n')
-        not_avail.sort()
-        out.append('   ' + ' '.join(not_avail)+'\n')
-        
-    return ''.join(out)
-
-
-def make_exclude():
-    """Make patterns of modules and packages to exclude from testing.
-
-    For the IPythonDoctest plugin, we need to exclude certain patterns that
-    cause testing problems.  We should strive to minimize the number of
-    skipped modules, since this means untested code.
-
-    These modules and packages will NOT get scanned by nose at all for tests.
-    """
-    # Simple utility to make IPython paths more readably, we need a lot of
-    # these below
-    ipjoin = lambda *paths: pjoin('IPython', *paths)
-    
-    exclusions = [ipjoin('external'),
-                  pjoin('IPython_doctest_plugin'),
-                  ipjoin('quarantine'),
-                  ipjoin('deathrow'),
-                  ipjoin('testing', 'attic'),
-                  # This guy is probably attic material
-                  ipjoin('testing', 'mkdoctests'),
-                  # Testing inputhook will need a lot of thought, to figure out
-                  # how to have tests that don't lock up with the gui event
-                  # loops in the picture
-                  ipjoin('lib', 'inputhook'),
-                  # Config files aren't really importable stand-alone
-                  ipjoin('config', 'default'),
-                  ipjoin('config', 'profile'),
-                  ]
-
-    if not have['wx']:
-        exclusions.append(ipjoin('lib', 'inputhookwx'))
-        
-    # We do this unconditionally, so that the test suite doesn't import
-    # gtk, changing the default encoding and masking some unicode bugs.
-    exclusions.append(ipjoin('lib', 'inputhookgtk'))
-
-    # These have to be skipped on win32 because the use echo, rm, cd, etc.
-    # See ticket https://bugs.launchpad.net/bugs/366982
-    if sys.platform == 'win32':
-        exclusions.append(ipjoin('testing', 'plugin', 'test_exampleip'))
-        exclusions.append(ipjoin('testing', 'plugin', 'dtexample'))
-
-    if not have['pexpect']:
-        exclusions.extend([ipjoin('scripts', 'irunner'),
-                           ipjoin('lib', 'irunner'),
-                           ipjoin('lib', 'tests', 'test_irunner')])
-
-    if not have['zmq']:
-        exclusions.append(ipjoin('zmq'))
-        exclusions.append(ipjoin('frontend', 'qt'))
-        exclusions.append(ipjoin('parallel'))
-    elif not have['qt']:
-        exclusions.append(ipjoin('frontend', 'qt'))
-    
-    if not have['pymongo']:
-        exclusions.append(ipjoin('parallel', 'controller', 'mongodb'))
-
-    if not have['matplotlib']:
-        exclusions.extend([ipjoin('lib', 'pylabtools'),
-                           ipjoin('lib', 'tests', 'test_pylabtools')])
-
-    # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
-    if sys.platform == 'win32':
-        exclusions = [s.replace('\\','\\\\') for s in exclusions]
-
-    return exclusions
-
-
-class IPTester(object):
-    """Call that calls iptest or trial in a subprocess.
-    """
-    #: string, name of test runner that will be called
-    runner = None
-    #: list, parameters for test runner
-    params = None
-    #: list, arguments of system call to be made to call test runner
-    call_args = None
-    #: list, process ids of subprocesses we start (for cleanup)
-    pids = None
-    
-    def __init__(self, runner='iptest', params=None):
-        """Create new test runner."""
-        p = os.path
-        if runner == 'iptest':
-            iptest_app = get_ipython_module_path('IPython.testing.iptest')
-            self.runner = pycmd2argv(iptest_app) + sys.argv[1:]
-        else:
-            raise Exception('Not a valid test runner: %s' % repr(runner))
-        if params is None:
-            params = []
-        if isinstance(params, str):
-            params = [params]
-        self.params = params
-
-        # Assemble call
-        self.call_args = self.runner+self.params
-
-        # Store pids of anything we start to clean up on deletion, if possible
-        # (on posix only, since win32 has no os.kill)
-        self.pids = []
-
-    if sys.platform == 'win32':
-        def _run_cmd(self):
-            # On Windows, use os.system instead of subprocess.call, because I
-            # was having problems with subprocess and I just don't know enough
-            # about win32 to debug this reliably.  Os.system may be the 'old
-            # fashioned' way to do it, but it works just fine.  If someone
-            # later can clean this up that's fine, as long as the tests run
-            # reliably in win32.
-            # What types of problems are you having. They may be related to
-            # running Python in unboffered mode. BG.
-            return os.system(' '.join(self.call_args))
-    else:
-        def _run_cmd(self):
-            # print >> sys.stderr, '*** CMD:', ' '.join(self.call_args) # dbg
-            subp = subprocess.Popen(self.call_args)
-            self.pids.append(subp.pid)
-            # If this fails, the pid will be left in self.pids and cleaned up
-            # later, but if the wait call succeeds, then we can clear the
-            # stored pid.
-            retcode = subp.wait()
-            self.pids.pop()
-            return retcode
-        
-    def run(self):
-        """Run the stored commands"""
-        try:
-            return self._run_cmd()
-        except:
-            import traceback
-            traceback.print_exc()
-            return 1  # signal failure
-
-    def __del__(self):
-        """Cleanup on exit by killing any leftover processes."""
-
-        if not hasattr(os, 'kill'):
-            return
-        
-        for pid in self.pids:
-            try:
-                print 'Cleaning stale PID:', pid
-                os.kill(pid, signal.SIGKILL)
-            except OSError:
-                # This is just a best effort, if we fail or the process was
-                # really gone, ignore it.
-                pass     
-
-
-def make_runners():
-    """Define the top-level packages that need to be tested.
-    """
-
-    # Packages to be tested via nose, that only depend on the stdlib
-    nose_pkg_names = ['config', 'core', 'extensions', 'frontend', 'lib',
-                     'scripts', 'testing', 'utils' ]
-    
-    if have['zmq']:
-        nose_pkg_names.append('parallel')
-    
-    # For debugging this code, only load quick stuff
-    #nose_pkg_names = ['core', 'extensions']  # dbg
-
-    # Make fully qualified package names prepending 'IPython.' to our name lists
-    nose_packages = ['IPython.%s' % m for m in nose_pkg_names ]
-
-    # Make runners
-    runners = [ (v, IPTester('iptest', params=v)) for v in nose_packages ]
-    
-    return runners
-
-
-def run_iptest():
-    """Run the IPython test suite using nose.
-    
-    This function is called when this script is **not** called with the form
-    `iptest all`.  It simply calls nose with appropriate command line flags
-    and accepts all of the standard nose arguments.
-    """
-
-    warnings.filterwarnings('ignore', 
-        'This will be removed soon.  Use IPython.testing.util instead')
-
-    argv = sys.argv + [ '--detailed-errors',  # extra info in tracebacks
-                                                
-                        # Loading ipdoctest causes problems with Twisted, but
-                        # our test suite runner now separates things and runs
-                        # all Twisted tests with trial.
-                        '--with-ipdoctest',
-                        '--ipdoctest-tests','--ipdoctest-extension=txt',
-                        
-                        # We add --exe because of setuptools' imbecility (it
-                        # blindly does chmod +x on ALL files).  Nose does the
-                        # right thing and it tries to avoid executables,
-                        # setuptools unfortunately forces our hand here.  This
-                        # has been discussed on the distutils list and the
-                        # setuptools devs refuse to fix this problem!
-                        '--exe',
-                        ]
-
-    if nose.__version__ >= '0.11':
-        # I don't fully understand why we need this one, but depending on what
-        # directory the test suite is run from, if we don't give it, 0 tests
-        # get run.  Specifically, if the test suite is run from the source dir
-        # with an argument (like 'iptest.py IPython.core', 0 tests are run,
-        # even if the same call done in this directory works fine).  It appears
-        # that if the requested package is in the current dir, nose bails early
-        # by default.  Since it's otherwise harmless, leave it in by default
-        # for nose >= 0.11, though unfortunately nose 0.10 doesn't support it.
-        argv.append('--traverse-namespace')
-
-    # Construct list of plugins, omitting the existing doctest plugin, which
-    # ours replaces (and extends).
-    plugins = [IPythonDoctest(make_exclude()), KnownFailure()]
-    for p in nose.plugins.builtin.plugins:
-        plug = p()
-        if plug.name == 'doctest':
-            continue
-        plugins.append(plug)
-
-    # We need a global ipython running in this process
-    globalipapp.start_ipython()
-    # Now nose can run
-    TestProgram(argv=argv, plugins=plugins)
-
-
-def run_iptestall():
-    """Run the entire IPython test suite by calling nose and trial.
-    
-    This function constructs :class:`IPTester` instances for all IPython
-    modules and package and then runs each of them.  This causes the modules
-    and packages of IPython to be tested each in their own subprocess using
-    nose or twisted.trial appropriately.
-    """
-
-    runners = make_runners()
-
-    # Run the test runners in a temporary dir so we can nuke it when finished
-    # to clean up any junk files left over by accident.  This also makes it
-    # robust against being run in non-writeable directories by mistake, as the
-    # temp dir will always be user-writeable.
-    curdir = os.getcwd()
-    testdir = tempfile.gettempdir()
-    os.chdir(testdir)
-
-    # Run all test runners, tracking execution time
-    failed = []
-    t_start = time.time()
-    try:
-        for (name, runner) in runners:
-            print '*'*70
-            print 'IPython test group:',name
-            res = runner.run()
-            if res:
-                failed.append( (name, runner) )
-    finally:
-        os.chdir(curdir)
-    t_end = time.time()
-    t_tests = t_end - t_start
-    nrunners = len(runners)
-    nfail = len(failed)
-    # summarize results
-    print
-    print '*'*70
-    print 'Test suite completed for system with the following information:'
-    print report()
-    print 'Ran %s test groups in %.3fs' % (nrunners, t_tests)
-    print
-    print 'Status:'
-    if not failed:
-        print 'OK'
-    else:
-        # If anything went wrong, point out what command to rerun manually to
-        # see the actual errors and individual summary
-        print 'ERROR - %s out of %s test groups failed.' % (nfail, nrunners)
-        for name, failed_runner in failed:
-            print '-'*40
-            print 'Runner failed:',name
-            print 'You may wish to rerun this one individually, with:'
-            print ' '.join(failed_runner.call_args)
-            print
-
-
-def main():
-    for arg in sys.argv[1:]:
-        if arg.startswith('IPython'):
-            # This is in-process
-            run_iptest()
-    else:
-        # This starts subprocesses
-        run_iptestall()
-
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/testing/ipunittest.py b/IPython/testing/ipunittest.py
index 952c5e6b485..2ce77a44edf 100644
--- a/IPython/testing/ipunittest.py
+++ b/IPython/testing/ipunittest.py
@@ -22,10 +22,9 @@
 - Fernando Perez <Fernando.Perez@berkeley.edu>
 """
 
-from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
+#  Copyright (C) 2009-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -39,13 +38,9 @@
 import re
 import sys
 import unittest
+import builtins
 from doctest import DocTestFinder, DocTestRunner, TestResults
-
-# We already have python3-compliant code for parametric tests
-if sys.version[0]=='2':
-    from ._paramtestpy2 import ParametricTestCase
-else:
-    from ._paramtestpy3 import ParametricTestCase
+from IPython.terminal.interactiveshell import InteractiveShell
 
 #-----------------------------------------------------------------------------
 # Classes and functions
@@ -56,14 +51,21 @@ def count_failures(runner):
 
     Code modeled after the summarize() method in doctest.
     """
-    return [TestResults(f, t) for f, t in runner._name2ft.values() if f > 0 ]
+    if sys.version_info < (3, 13):
+        return [TestResults(f, t) for f, t in runner._name2ft.values() if f > 0]
+    else:
+        return [
+            TestResults(failure, try_)
+            for failure, try_, skip in runner._stats.values()
+            if failure > 0
+        ]
 
 
-class IPython2PythonConverter(object):
+class IPython2PythonConverter:
     """Convert IPython 'syntax' to valid Python.
 
     Eventually this code may grow to be the full IPython syntax conversion
-    implementation, but for now it only does prompt convertion."""
+    implementation, but for now it only does prompt conversion."""
     
     def __init__(self):
         self.rps1 = re.compile(r'In\ \[\d+\]: ')
@@ -71,8 +73,8 @@ def __init__(self):
         self.rout = re.compile(r'Out\[\d+\]: \s*?\n?')
         self.pyps1 = '>>> '
         self.pyps2 = '... '
-        self.rpyps1 = re.compile ('(\s*%s)(.*)$' % self.pyps1)
-        self.rpyps2 = re.compile ('(\s*%s)(.*)$' % self.pyps2)
+        self.rpyps1 = re.compile (r'(\s*%s)(.*)$' % self.pyps1)
+        self.rpyps2 = re.compile (r'(\s*%s)(.*)$' % self.pyps2)
 
     def __call__(self, ds):
         """Convert IPython prompts to python ones in a string."""
@@ -86,7 +88,7 @@ def __call__(self, ds):
         dnew = self.rps1.sub(pyps1, dnew)
         dnew = self.rps2.sub(pyps2, dnew)
         dnew = self.rout.sub(pyout, dnew)
-        ip = globalipapp.get_ipython()
+        ip = InteractiveShell.instance()
 
         # Convert input IPython source into valid Python.
         out = []
@@ -107,13 +109,13 @@ def __call__(self, ds):
             
             newline(line)
         newline('')  # ensure a closing newline, needed by doctest
-        #print "PYSRC:", '\n'.join(out)  # dbg
+        # print("PYSRC:", '\n'.join(out))  # dbg
         return '\n'.join(out)
 
     #return dnew
 
 
-class Doc2UnitTester(object):
+class Doc2UnitTester:
     """Class whose instances act as a decorator for docstring testing.
 
     In practice we're only likely to need one instance ever, made below (though
@@ -154,14 +156,15 @@ class Tester(unittest.TestCase):
             def test(self):
                 # Make a new runner per function to be tested
                 runner = DocTestRunner(verbose=d2u.verbose)
-                map(runner.run, d2u.finder.find(func, func.__name__))
+                for the_test in d2u.finder.find(func, func.__name__):
+                    runner.run(the_test)
                 failed = count_failures(runner)
                 if failed:
                     # Since we only looked at a single function's docstring,
                     # failed should contain at most one item.  More than that
                     # is a case we can't handle and should error out on
                     if len(failed) > 1:
-                        err = "Invalid number of test results:" % failed
+                        err = "Invalid number of test results: %s" % failed
                         raise ValueError(err)
                     # Report a normal failure.
                     self.fail('failed doctests: %s' % str(failed[0]))
diff --git a/IPython/testing/mkdoctests.py b/IPython/testing/mkdoctests.py
deleted file mode 100644
index bfec99ed29c..00000000000
--- a/IPython/testing/mkdoctests.py
+++ /dev/null
@@ -1,244 +0,0 @@
-#!/usr/bin/env python
-"""Utility for making a doctest file out of Python or IPython input.
-
-  %prog [options] input_file [output_file]
-
-This script is a convenient generator of doctest files that uses IPython's
-irunner script to execute valid Python or IPython input in a separate process,
-capture all of the output, and write it to an output file.
-
-It can be used in one of two ways:
-
-1. With a plain Python or IPython input file (denoted by extensions '.py' or
-   '.ipy'.  In this case, the output is an auto-generated reST file with a
-   basic header, and the captured Python input and output contained in an
-   indented code block.
-
-   If no output filename is given, the input name is used, with the extension
-   replaced by '.txt'.
-
-2. With an input template file.  Template files are simply plain text files
-   with special directives of the form
-
-   %run filename
-
-   to include the named file at that point.
-
-   If no output filename is given and the input filename is of the form
-   'base.tpl.txt', the output will be automatically named 'base.txt'.
-"""
-
-# Standard library imports
-
-import optparse
-import os
-import re
-import sys
-import tempfile
-
-# IPython-specific libraries
-from IPython.lib import irunner
-from IPython.utils.warn import fatal
-
-class IndentOut(object):
-    """A simple output stream that indents all output by a fixed amount.
-
-    Instances of this class trap output to a given stream and first reformat it
-    to indent every input line."""
-    
-    def __init__(self,out=sys.stdout,indent=4):
-        """Create an indented writer.
-
-        :Keywords:
-
-        - `out` : stream (sys.stdout)
-          Output stream to actually write to after indenting.
-
-        - `indent` : int
-          Number of spaces to indent every input line by.
-        """
-        
-        self.indent_text = ' '*indent
-        self.indent = re.compile('^',re.MULTILINE).sub
-        self.out = out
-        self._write = out.write
-        self.buffer = []
-        self._closed = False
-
-    def write(self,data):
-        """Write a string to the output stream."""
-
-        if self._closed:
-            raise ValueError('I/O operation on closed file')
-        self.buffer.append(data)
-
-    def flush(self):
-        if self.buffer:
-            data = ''.join(self.buffer)
-            self.buffer[:] = []
-            self._write(self.indent(self.indent_text,data))
-        
-    def close(self):
-        self.flush()
-        self._closed = True
-
-class RunnerFactory(object):
-    """Code runner factory.
-
-    This class provides an IPython code runner, but enforces that only one
-    runner is every instantiated.  The runner is created based on the extension
-    of the first file to run, and it raises an exception if a runner is later
-    requested for a different extension type.
-
-    This ensures that we don't generate example files for doctest with a mix of
-    python and ipython syntax.
-    """
-
-    def __init__(self,out=sys.stdout):
-        """Instantiate a code runner."""
-        
-        self.out = out
-        self.runner = None
-        self.runnerClass = None
-
-    def _makeRunner(self,runnerClass):
-        self.runnerClass = runnerClass
-        self.runner = runnerClass(out=self.out)
-        return self.runner
-          
-    def __call__(self,fname):
-        """Return a runner for the given filename."""
-
-        if fname.endswith('.py'):
-            runnerClass = irunner.PythonRunner
-        elif fname.endswith('.ipy'):
-            runnerClass = irunner.IPythonRunner
-        else:
-            raise ValueError('Unknown file type for Runner: %r' % fname)
-
-        if self.runner is None:
-            return self._makeRunner(runnerClass)
-        else:
-            if runnerClass==self.runnerClass:
-                return self.runner
-            else:
-                e='A runner of type %r can not run file %r' % \
-                   (self.runnerClass,fname)
-                raise ValueError(e)
-
-TPL = """
-=========================
- Auto-generated doctests
-=========================
-
-This file was auto-generated by IPython in its entirety.  If you need finer
-control over the contents, simply make a manual template.  See the
-mkdoctests.py script for details.
-
-%%run %s
-"""
-
-def main():
-    """Run as a script."""
-
-    # Parse options and arguments.
-    parser = optparse.OptionParser(usage=__doc__)
-    newopt = parser.add_option
-    newopt('-f','--force',action='store_true',dest='force',default=False,
-           help='Force overwriting of the output file.')
-    newopt('-s','--stdout',action='store_true',dest='stdout',default=False,
-           help='Use stdout instead of a file for output.')
-
-    opts,args = parser.parse_args()
-    if len(args) < 1:
-        parser.error("incorrect number of arguments")
-
-    # Input filename
-    fname = args[0]
-
-    # We auto-generate the output file based on a trivial template to make it
-    # really easy to create simple doctests.
-
-    auto_gen_output = False
-    try:
-        outfname = args[1]
-    except IndexError:
-        outfname = None
-
-    if fname.endswith('.tpl.txt') and outfname is None:
-        outfname = fname.replace('.tpl.txt','.txt')
-    else:
-        bname, ext = os.path.splitext(fname)
-        if ext in ['.py','.ipy']:
-            auto_gen_output = True
-        if outfname is None:
-            outfname = bname+'.txt'
-
-    # Open input file
-
-    # In auto-gen mode, we actually change the name of the input file to be our
-    # auto-generated template
-    if auto_gen_output:
-        infile = tempfile.TemporaryFile()
-        infile.write(TPL % fname)
-        infile.flush()
-        infile.seek(0)
-    else:
-        infile = open(fname)
-
-    # Now open the output file.  If opts.stdout was given, this overrides any
-    # explicit choice of output filename and just directs all output to
-    # stdout.
-    if opts.stdout:
-        outfile = sys.stdout
-    else:
-        # Argument processing finished, start main code
-        if os.path.isfile(outfname) and not opts.force:
-            fatal("Output file %r exists, use --force (-f) to overwrite."
-                  % outfname)
-        outfile = open(outfname,'w')
-
-
-    # all output from included files will be indented 
-    indentOut = IndentOut(outfile,4)
-    getRunner = RunnerFactory(indentOut)
-
-    # Marker in reST for transition lines
-    rst_transition = '\n'+'-'*76+'\n\n'
-
-    # local shorthand for loop
-    write = outfile.write
-
-    # Process input, simply writing back out all normal lines and executing the
-    # files in lines marked as '%run filename'.
-    for line in infile:
-        if line.startswith('%run '):
-            # We don't support files with spaces in their names.
-            incfname = line.split()[1]
-
-            # We make the output of the included file appear bracketed between
-            # clear reST transition marks, and indent it so that if anyone
-            # makes an HTML or PDF out of the file, all doctest input and
-            # output appears in proper literal blocks.
-            write(rst_transition)
-            write('Begin included file %s::\n\n' % incfname)
-
-            # I deliberately do NOT trap any exceptions here, so that if
-            # there's any problem, the user running this at the command line
-            # finds out immediately by the code blowing up, rather than ending
-            # up silently with an incomplete or incorrect file.
-            getRunner(incfname).run_file(incfname)
-
-            write('\nEnd included file %s\n' % incfname)
-            write(rst_transition)
-        else:
-            # The rest of the input file is just written out
-            write(line)
-    infile.close()
-
-    # Don't close sys.stdout!!!
-    if outfile is not sys.stdout:
-        outfile.close()
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/testing/nosepatch.py b/IPython/testing/nosepatch.py
deleted file mode 100644
index 2458e394cf1..00000000000
--- a/IPython/testing/nosepatch.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""Monkeypatch nose to accept any callable as a method.
-
-By default, nose's ismethod() fails for static methods.
-Once this is fixed in upstream nose we can disable it.
-
-Note: merely importing this module causes the monkeypatch to be applied."""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import unittest
-import nose.loader
-from inspect import ismethod, isfunction
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-def getTestCaseNames(self, testCaseClass):
-    """Override to select with selector, unless
-    config.getTestCaseNamesCompat is True
-    """
-    if self.config.getTestCaseNamesCompat:
-        return unittest.TestLoader.getTestCaseNames(self, testCaseClass)
-
-    def wanted(attr, cls=testCaseClass, sel=self.selector):
-        item = getattr(cls, attr, None)
-        # MONKEYPATCH: replace this:
-        #if not ismethod(item):
-        #    return False
-        # return sel.wantMethod(item)
-        # With:
-        if ismethod(item):
-            return sel.wantMethod(item)
-        # static method or something. If this is a static method, we
-        # can't get the class information, and we have to treat it
-        # as a function.  Thus, we will miss things like class
-        # attributes for test selection
-        if isfunction(item):
-            return sel.wantFunction(item)
-        return False
-        # END MONKEYPATCH
-    
-    cases = filter(wanted, dir(testCaseClass))
-    for base in testCaseClass.__bases__:
-        for case in self.getTestCaseNames(base):
-            if case not in cases:
-                cases.append(case)
-    # add runTest if nothing else picked
-    if not cases and hasattr(testCaseClass, 'runTest'):
-        cases = ['runTest']
-    if self.sortTestMethodsUsing:
-        cases.sort(self.sortTestMethodsUsing)
-    return cases
-
-
-##########################################################################
-# Apply monkeypatch here
-nose.loader.TestLoader.getTestCaseNames = getTestCaseNames
-##########################################################################
diff --git a/IPython/testing/plugin/Makefile b/IPython/testing/plugin/Makefile
index 6f999a38fd3..c626da4e3c0 100644
--- a/IPython/testing/plugin/Makefile
+++ b/IPython/testing/plugin/Makefile
@@ -67,7 +67,7 @@ all: base ipython
 
 # Main plugin and cleanup
 IPython_doctest_plugin.egg-info: $(SRC)
-	python setup.py install --prefix=$(PREFIX)
+	pip install . --prefix=$(PREFIX)
 	touch $@
 
 clean:
diff --git a/IPython/testing/plugin/README.txt b/IPython/testing/plugin/README.txt
deleted file mode 100644
index 6b34f9e5e10..00000000000
--- a/IPython/testing/plugin/README.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-=======================================================
- Nose plugin with IPython and extension module support
-=======================================================
-
-This directory provides the key functionality for test support that IPython
-needs as a nose plugin, which can be installed for use in projects other than
-IPython.
-
-The presence of a Makefile here is mostly for development and debugging
-purposes as it only provides a few shorthand commands.  You can manually
-install the plugin by using standard Python procedures (``setup.py install``
-with appropriate arguments).
-
-To install the plugin using the Makefile, edit its first line to reflect where
-you'd like the installation.  If you want it system-wide, you may want to edit
-the install line in the plugin target to use sudo and no prefix::
-
-  sudo python setup.py install
-
-instead of the code using `--prefix` that's in there.
-
-Once you've set the prefix, simply build/install the plugin with::
-
-  make
-
-and run the tests with::
-
-  make test
-
-You should see output similar to::
-
-  maqroll[plugin]> make test
-  nosetests -s --with-ipdoctest --doctest-tests dtexample.py
-  ..
-  ----------------------------------------------------------------------
-  Ran 2 tests in 0.016s
-
-  OK
-
diff --git a/IPython/testing/plugin/dtexample.py b/IPython/testing/plugin/dtexample.py
index 453aac39f9b..68f7016e34d 100644
--- a/IPython/testing/plugin/dtexample.py
+++ b/IPython/testing/plugin/dtexample.py
@@ -4,6 +4,9 @@
 All tests should be loaded by nose.
 """
 
+import os
+
+
 def pyfunc():
     """Some pure python tests...
 
@@ -16,14 +19,13 @@ def pyfunc():
     5
 
     >>> for i in range(3):
-    ...     print i,
-    ...     print i+1,
+    ...     print(i, end=' ')
+    ...     print(i+1, end=' ')
     ...
-    0 1 1 2 2 3
+    0 1 1 2 2 3 
     """
     return 'pyfunc'
 
-
 def ipfunc():
     """Some ipython tests...
 
@@ -33,24 +35,12 @@ def ipfunc():
     Out[3]: 5
 
     In [26]: for i in range(3):
-       ....:     print i,
-       ....:     print i+1,
+       ....:     print(i, end=' ')
+       ....:     print(i+1, end=' ')
        ....:
     0 1 1 2 2 3
 
 
-    Examples that access the operating system work:
-
-    In [1]: !echo hello
-    hello
-
-    In [2]: !echo hello > /tmp/foo
-
-    In [3]: !cat /tmp/foo
-    hello
-
-    In [4]: rm -f /tmp/foo
-
     It's OK to use '_' for the last result, but do NOT try to use IPython's
     numbered history of _NN outputs, since those won't exist under the
     doctest environment:
@@ -58,9 +48,9 @@ def ipfunc():
     In [7]: 'hi'
     Out[7]: 'hi'
 
-    In [8]: print repr(_)
+    In [8]: print(repr(_))
     'hi'
-    
+
     In [7]: 3+4
     Out[7]: 7
 
@@ -70,7 +60,26 @@ def ipfunc():
     In [9]: ipfunc()
     Out[9]: 'ipfunc'
     """
-    return 'ipfunc'
+    return "ipfunc"
+
+
+def ipos():
+    """Examples that access the operating system work:
+
+    In [1]: !echo hello
+    hello
+
+    In [2]: !echo hello > /tmp/foo_iptest
+
+    In [3]: !cat /tmp/foo_iptest
+    hello
+
+    In [4]: rm -f /tmp/foo_iptest
+    """
+    pass
+
+
+ipos.__skip_doctest__ = os.name == "nt"
 
 
 def ranfunc():
@@ -127,14 +136,13 @@ def random_all():
     """
     pass
 
-
 def iprand():
     """Some ipython tests with random output.
 
     In [7]: 3+4
     Out[7]: 7
 
-    In [8]: print 'hello'
+    In [8]: print('hello')
     world  # random
 
     In [9]: iprand()
@@ -142,7 +150,6 @@ def iprand():
     """
     return 'iprand'
 
-
 def iprand_all():
     """Some ipython tests with fully random output.
 
@@ -151,12 +158,10 @@ def iprand_all():
     In [7]: 1
     Out[7]: 99
 
-    In [8]: print 'hello'
+    In [8]: print('hello')
     world
 
     In [9]: iprand_all()
     Out[9]: 'junk'
     """
     return 'iprand_all'
-
-
diff --git a/IPython/testing/plugin/ipdoctest.py b/IPython/testing/plugin/ipdoctest.py
index f2b2c75d6e9..5c23373fba2 100644
--- a/IPython/testing/plugin/ipdoctest.py
+++ b/IPython/testing/plugin/ipdoctest.py
@@ -3,9 +3,9 @@
 Limitations:
 
 - When generating examples for use as doctests, make sure that you have
-  pretty-printing OFF.  This can be done either by starting ipython with the
-  flag '--nopprint', by setting pprint to 0 in your ipythonrc file, or by
-  interactively disabling it with %Pprint.  This is required so that IPython
+  pretty-printing OFF.  This can be done either by setting the
+  ``PlainTextFormatter.pprint`` option in your configuration file to  False, or
+  by interactively disabling it with  %Pprint.  This is required so that IPython
   output matches that of normal Python, which is used by doctest for internal
   execution.
 
@@ -19,33 +19,11 @@
 # Module imports
 
 # From the standard library
-import __builtin__
-import commands
 import doctest
-import inspect
 import logging
-import os
 import re
-import sys
-import traceback
-import unittest
 
-from inspect import getmodule
-from StringIO import StringIO
-
-# We are overriding the default doctest runner, so we need to import a few
-# things from doctest directly
-from doctest import (REPORTING_FLAGS, REPORT_ONLY_FIRST_FAILURE,
-                     _unittest_reportflags, DocTestRunner,
-                     _extract_future_flags, pdb, _OutputRedirectingPdb,
-                     _exception_traceback,
-                     linecache)
-
-# Third-party modules
-import nose.core
-
-from nose.plugins import doctests, Plugin
-from nose.util import anyp, getpackage, test_address, resolve_name, tolist
+from testpath import modified_env
 
 #-----------------------------------------------------------------------------
 # Module globals and other constants
@@ -58,121 +36,27 @@
 # Classes and functions
 #-----------------------------------------------------------------------------
 
-def is_extension_module(filename):
-    """Return whether the given filename is an extension module.
-
-    This simply checks that the extension is either .so or .pyd.
-    """
-    return os.path.splitext(filename)[1].lower() in ('.so','.pyd')
-
-
-class DocTestSkip(object):
-    """Object wrapper for doctests to be skipped."""
-    
-    ds_skip = """Doctest to skip.
-    >>> 1 #doctest: +SKIP
-    """
-
-    def __init__(self,obj):
-        self.obj = obj
-
-    def __getattribute__(self,key):
-        if key == '__doc__':
-            return DocTestSkip.ds_skip
-        else:
-            return getattr(object.__getattribute__(self,'obj'),key)
 
-# Modified version of the one in the stdlib, that fixes a python bug (doctests
-# not found in extension modules, http://bugs.python.org/issue3158)
 class DocTestFinder(doctest.DocTestFinder):
+    def _get_test(self, obj, name, module, globs, source_lines):
+        test = super()._get_test(obj, name, module, globs, source_lines)
 
-    def _from_module(self, module, object):
-        """
-        Return true if the given object is defined in the given
-        module.
-        """
-        if module is None:
-            return True
-        elif inspect.isfunction(object):
-            return module.__dict__ is object.func_globals
-        elif inspect.isbuiltin(object):
-            return module.__name__ == object.__module__
-        elif inspect.isclass(object):
-            return module.__name__ == object.__module__
-        elif inspect.ismethod(object):
-            # This one may be a bug in cython that fails to correctly set the
-            # __module__ attribute of methods, but since the same error is easy
-            # to make by extension code writers, having this safety in place
-            # isn't such a bad idea
-            return module.__name__ == object.im_class.__module__
-        elif inspect.getmodule(object) is not None:
-            return module is inspect.getmodule(object)
-        elif hasattr(object, '__module__'):
-            return module.__name__ == object.__module__
-        elif isinstance(object, property):
-            return True # [XX] no way not be sure.
-        else:
-            raise ValueError("object must be a class or function")
+        if bool(getattr(obj, "__skip_doctest__", False)) and test is not None:
+            for example in test.examples:
+                example.options[doctest.SKIP] = True
 
-    def _find(self, tests, obj, name, module, source_lines, globs, seen):
-        """
-        Find tests for the given object and any contained objects, and
-        add them to `tests`.
-        """
-        #print '_find for:', obj, name, module  # dbg
-        if hasattr(obj,"skip_doctest"):
-            #print 'SKIPPING DOCTEST FOR:',obj  # dbg
-            obj = DocTestSkip(obj)
-
-        doctest.DocTestFinder._find(self,tests, obj, name, module,
-                                    source_lines, globs, seen)
-
-        # Below we re-run pieces of the above method with manual modifications,
-        # because the original code is buggy and fails to correctly identify
-        # doctests in extension modules.
-
-        # Local shorthands
-        from inspect import isroutine, isclass, ismodule
-
-        # Look for tests in a module's contained objects.
-        if inspect.ismodule(obj) and self._recurse:
-            for valname, val in obj.__dict__.items():
-                valname1 = '%s.%s' % (name, valname)
-                if ( (isroutine(val) or isclass(val))
-                     and self._from_module(module, val) ):
-
-                    self._find(tests, val, valname1, module, source_lines,
-                               globs, seen)
-
-        # Look for tests in a class's contained objects.
-        if inspect.isclass(obj) and self._recurse:
-            #print 'RECURSE into class:',obj  # dbg
-            for valname, val in obj.__dict__.items():
-                # Special handling for staticmethod/classmethod.
-                if isinstance(val, staticmethod):
-                    val = getattr(obj, valname)
-                if isinstance(val, classmethod):
-                    val = getattr(obj, valname).im_func
-
-                # Recurse to methods, properties, and nested classes.
-                if ((inspect.isfunction(val) or inspect.isclass(val) or
-                     inspect.ismethod(val) or
-                      isinstance(val, property)) and
-                      self._from_module(module, val)):
-                    valname = '%s.%s' % (name, valname)
-                    self._find(tests, val, valname, module, source_lines,
-                               globs, seen)
+        return test
 
 
 class IPDoctestOutputChecker(doctest.OutputChecker):
     """Second-chance checker with support for random tests.
-    
+
     If the default comparison doesn't pass, this checker looks in the expected
     output string for flags that tell us to ignore the output.
     """
 
     random_re = re.compile(r'#\s*random\s+')
-    
+
     def check_output(self, want, got, optionflags):
         """Check output, accepting special markers embedded in the output.
 
@@ -184,151 +68,17 @@ def check_output(self, want, got, optionflags):
         ret = doctest.OutputChecker.check_output(self, want, got,
                                                  optionflags)
         if not ret and self.random_re.search(want):
-            #print >> sys.stderr, 'RANDOM OK:',want  # dbg
+            # print('RANDOM OK:',want, file=sys.stderr)  # dbg
             return True
 
         return ret
 
 
-class DocTestCase(doctests.DocTestCase):
-    """Proxy for DocTestCase: provides an address() method that
-    returns the correct address for the doctest case. Otherwise
-    acts as a proxy to the test case. To provide hints for address(),
-    an obj may also be passed -- this will be used as the test object
-    for purposes of determining the test address, if it is provided.
-    """
-
-    # Note: this method was taken from numpy's nosetester module.
-
-    # Subclass nose.plugins.doctests.DocTestCase to work around a bug in
-    # its constructor that blocks non-default arguments from being passed
-    # down into doctest.DocTestCase
-
-    def __init__(self, test, optionflags=0, setUp=None, tearDown=None,
-                 checker=None, obj=None, result_var='_'):
-        self._result_var = result_var
-        doctests.DocTestCase.__init__(self, test,
-                                      optionflags=optionflags,
-                                      setUp=setUp, tearDown=tearDown,
-                                      checker=checker)
-        # Now we must actually copy the original constructor from the stdlib
-        # doctest class, because we can't call it directly and a bug in nose
-        # means it never gets passed the right arguments.
-
-        self._dt_optionflags = optionflags
-        self._dt_checker = checker
-        self._dt_test = test
-        self._dt_test_globs_ori = test.globs
-        self._dt_setUp = setUp
-        self._dt_tearDown = tearDown
-
-        # XXX - store this runner once in the object!
-        runner = IPDocTestRunner(optionflags=optionflags,
-                                 checker=checker, verbose=False)
-        self._dt_runner = runner
-
-
-        # Each doctest should remember the directory it was loaded from, so
-        # things like %run work without too many contortions
-        self._ori_dir = os.path.dirname(test.filename)
-
-    # Modified runTest from the default stdlib
-    def runTest(self):
-        test = self._dt_test
-        runner = self._dt_runner
-        
-        old = sys.stdout
-        new = StringIO()
-        optionflags = self._dt_optionflags
-
-        if not (optionflags & REPORTING_FLAGS):
-            # The option flags don't include any reporting flags,
-            # so add the default reporting flags
-            optionflags |= _unittest_reportflags
-
-        try:
-            # Save our current directory and switch out to the one where the
-            # test was originally created, in case another doctest did a
-            # directory change.  We'll restore this in the finally clause.
-            curdir = os.getcwd()
-            #print 'runTest in dir:', self._ori_dir  # dbg
-            os.chdir(self._ori_dir)
-
-            runner.DIVIDER = "-"*70
-            failures, tries = runner.run(test,out=new.write,
-                                         clear_globs=False)
-        finally:
-            sys.stdout = old
-            os.chdir(curdir)
-
-        if failures:
-            raise self.failureException(self.format_failure(new.getvalue()))
-
-    def setUp(self):
-        """Modified test setup that syncs with ipython namespace"""
-        #print "setUp test", self._dt_test.examples # dbg
-        if isinstance(self._dt_test.examples[0],IPExample):
-            # for IPython examples *only*, we swap the globals with the ipython
-            # namespace, after updating it with the globals (which doctest
-            # fills with the necessary info from the module being tested).
-            _ip.user_ns.update(self._dt_test.globs)
-            self._dt_test.globs = _ip.user_ns
-            # IPython must protect the _ key in the namespace (it can't exist)
-            # so that Python's doctest code sets it naturally, so we enable
-            # this feature of our testing namespace.
-            _ip.user_ns.protect_underscore = True
-
-        super(DocTestCase, self).setUp()
-
-    def tearDown(self):
-
-        # Undo the test.globs reassignment we made, so that the parent class
-        # teardown doesn't destroy the ipython namespace
-        if isinstance(self._dt_test.examples[0],IPExample):
-            self._dt_test.globs = self._dt_test_globs_ori
-            # Restore the behavior of the '_' key in the user namespace to
-            # normal after each doctest, so that unittests behave normally
-            _ip.user_ns.protect_underscore = False
-            
-        # XXX - fperez: I am not sure if this is truly a bug in nose 0.11, but
-        # it does look like one to me: its tearDown method tries to run
-        #
-        # delattr(__builtin__, self._result_var)
-        #
-        # without checking that the attribute really is there; it implicitly
-        # assumes it should have been set via displayhook.  But if the
-        # displayhook was never called, this doesn't necessarily happen.  I
-        # haven't been able to find a little self-contained example outside of
-        # ipython that would show the problem so I can report it to the nose
-        # team, but it does happen a lot in our code.
-        #
-        # So here, we just protect as narrowly as possible by trapping an
-        # attribute error whose message would be the name of self._result_var,
-        # and letting any other error propagate.
-        try:
-            super(DocTestCase, self).tearDown()
-        except AttributeError, exc:
-            if exc.args[0] != self._result_var:
-                raise
-
-
 # A simple subclassing of the original with a different class name, so we can
 # distinguish and treat differently IPython examples from pure python ones.
 class IPExample(doctest.Example): pass
 
 
-class IPExternalExample(doctest.Example):
-    """Doctest examples to be run in an external process."""
-
-    def __init__(self, source, want, exc_msg=None, lineno=0, indent=0,
-                 options=None):
-        # Parent constructor
-        doctest.Example.__init__(self,source,want,exc_msg,lineno,indent,options)
-
-        # An EXTRA newline is needed to prevent pexpect hangs
-        self.source += '\n'
-
-
 class IPDocTestParser(doctest.DocTestParser):
     """
     A class used to parse strings containing doctest examples.
@@ -374,22 +124,13 @@ class IPDocTestParser(doctest.DocTestParser):
     # we don't need to modify any other code.
     _RANDOM_TEST = re.compile(r'#\s*all-random\s+')
 
-    # Mark tests to be executed in an external process - currently unsupported.
-    _EXTERNAL_IP = re.compile(r'#\s*ipdoctest:\s*EXTERNAL')
-    
     def ip2py(self,source):
         """Convert input IPython source into valid Python."""
-        out = []
-        newline = out.append
-        #print 'IPSRC:\n',source,'\n###'  # dbg
-        # The input source must be first stripped of all bracketing whitespace
-        # and turned into lines, so it looks to the parser like regular user
-        # input
-        for lnum,line in enumerate(source.strip().splitlines()):
-            newline(_ip.prefilter(line,lnum>0))
-        newline('')  # ensure a closing newline, needed by doctest
-        #print "PYSRC:", '\n'.join(out)  # dbg
-        return '\n'.join(out)
+        block = _ip.input_transformer_manager.transform_cell(source)
+        if len(block.splitlines()) == 1:
+            return _ip.prefilter(block)
+        else:
+            return block
 
     def parse(self, string, name='<string>'):
         """
@@ -400,7 +141,7 @@ def parse(self, string, name='<string>'):
         used for error messages.
         """
 
-        #print 'Parse string:\n',string # dbg
+        # print('Parse string:\n',string)  # dbg
 
         string = string.expandtabs()
         # If all lines begin with the same indentation, then strip it.
@@ -425,27 +166,12 @@ def parse(self, string, name='<string>'):
         terms = list(self._EXAMPLE_RE_PY.finditer(string))
         if terms:
             # Normal Python example
-            #print '-'*70  # dbg
-            #print 'PyExample, Source:\n',string  # dbg
-            #print '-'*70  # dbg
             Example = doctest.Example
         else:
-            # It's an ipython example.  Note that IPExamples are run
-            # in-process, so their syntax must be turned into valid python.
-            # IPExternalExamples are run out-of-process (via pexpect) so they
-            # don't need any filtering (a real ipython will be executing them).
+            # It's an ipython example.
             terms = list(self._EXAMPLE_RE_IP.finditer(string))
-            if self._EXTERNAL_IP.search(string):
-                #print '-'*70  # dbg
-                #print 'IPExternalExample, Source:\n',string  # dbg
-                #print '-'*70  # dbg
-                Example = IPExternalExample
-            else:
-                #print '-'*70  # dbg
-                #print 'IPExample, Source:\n',string  # dbg
-                #print '-'*70  # dbg
-                Example = IPExample
-                ip2py = True
+            Example = IPExample
+            ip2py = True
 
         for m in terms:
             # Add the pre-example text to `output`.
@@ -459,10 +185,6 @@ def parse(self, string, name='<string>'):
             # Append the random-output marker (it defaults to empty in most
             # cases, it's only non-empty for 'all-random' tests):
             want += random_marker
-                
-            if Example is IPExternalExample:
-                options[doctest.NORMALIZE_WHITESPACE] = True
-                want += '\n'
 
             # Create an Example, and add it to the list.
             if not self._IS_BLANK_OR_COMMENT(source):
@@ -566,228 +288,12 @@ def _check_prompt_blank(self, lines, indent, name, lineno, ps1_len):
 SKIP = doctest.register_optionflag('SKIP')
 
 
-class IPDocTestRunner(doctest.DocTestRunner,object):
+class IPDocTestRunner(doctest.DocTestRunner):
     """Test runner that synchronizes the IPython namespace with test globals.
     """
-    
-    def run(self, test, compileflags=None, out=None, clear_globs=True):
-
-        # Hack: ipython needs access to the execution context of the example,
-        # so that it can propagate user variables loaded by %run into
-        # test.globs.  We put them here into our modified %run as a function
-        # attribute.  Our new %run will then only make the namespace update
-        # when called (rather than unconconditionally updating test.globs here
-        # for all examples, most of which won't be calling %run anyway).
-        #_ip._ipdoctest_test_globs = test.globs
-        #_ip._ipdoctest_test_filename = test.filename
-
-        test.globs.update(_ip.user_ns)
-        
-        return super(IPDocTestRunner,self).run(test,
-                                               compileflags,out,clear_globs)
-
-
-class DocFileCase(doctest.DocFileCase):
-    """Overrides to provide filename
-    """
-    def address(self):
-        return (self._dt_test.filename, None, None)
-
-
-class ExtensionDoctest(doctests.Doctest):
-    """Nose Plugin that supports doctests in extension modules.
-    """
-    name = 'extdoctest'   # call nosetests with --with-extdoctest
-    enabled = True
-
-    def __init__(self,exclude_patterns=None):
-        """Create a new ExtensionDoctest plugin.
-
-        Parameters
-        ----------
-
-        exclude_patterns : sequence of strings, optional
-          These patterns are compiled as regular expressions, subsequently used
-          to exclude any filename which matches them from inclusion in the test
-          suite (using pattern.search(), NOT pattern.match() ).
-        """
-
-        if exclude_patterns is None:
-            exclude_patterns = []
-        self.exclude_patterns = map(re.compile,exclude_patterns)
-        doctests.Doctest.__init__(self)
-
-    def options(self, parser, env=os.environ):
-        Plugin.options(self, parser, env)
-        parser.add_option('--doctest-tests', action='store_true',
-                          dest='doctest_tests',
-                          default=env.get('NOSE_DOCTEST_TESTS',True),
-                          help="Also look for doctests in test modules. "
-                          "Note that classes, methods and functions should "
-                          "have either doctests or non-doctest tests, "
-                          "not both. [NOSE_DOCTEST_TESTS]")
-        parser.add_option('--doctest-extension', action="append",
-                          dest="doctestExtension",
-                          help="Also look for doctests in files with "
-                          "this extension [NOSE_DOCTEST_EXTENSION]")
-        # Set the default as a list, if given in env; otherwise
-        # an additional value set on the command line will cause
-        # an error.
-        env_setting = env.get('NOSE_DOCTEST_EXTENSION')
-        if env_setting is not None:
-            parser.set_defaults(doctestExtension=tolist(env_setting))
-
-
-    def configure(self, options, config):
-        Plugin.configure(self, options, config)
-        self.doctest_tests = options.doctest_tests
-        self.extension = tolist(options.doctestExtension)
-
-        self.parser = doctest.DocTestParser()
-        self.finder = DocTestFinder()
-        self.checker = IPDoctestOutputChecker()
-        self.globs = None
-        self.extraglobs = None
-
-
-    def loadTestsFromExtensionModule(self,filename):
-        bpath,mod = os.path.split(filename)
-        modname = os.path.splitext(mod)[0]
-        try:
-            sys.path.append(bpath)
-            module = __import__(modname)
-            tests = list(self.loadTestsFromModule(module))
-        finally:
-            sys.path.pop()
-        return tests
-
-    # NOTE: the method below is almost a copy of the original one in nose, with
-    # a  few modifications to control output checking.
-
-    def loadTestsFromModule(self, module):
-        #print '*** ipdoctest - lTM',module  # dbg
-        
-        if not self.matches(module.__name__):
-            log.debug("Doctest doesn't want module %s", module)
-            return
-
-        tests = self.finder.find(module,globs=self.globs,
-                                 extraglobs=self.extraglobs)
-        if not tests:
-            return
-
-        # always use whitespace and ellipsis options
-        optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
-
-        tests.sort()
-        module_file = module.__file__
-        if module_file[-4:] in ('.pyc', '.pyo'):
-            module_file = module_file[:-1]
-        for test in tests:
-            if not test.examples:
-                continue
-            if not test.filename:
-                test.filename = module_file
-            
-            yield DocTestCase(test,
-                              optionflags=optionflags,
-                              checker=self.checker)
-
-
-    def loadTestsFromFile(self, filename):
-        #print "ipdoctest - from file", filename # dbg
-        if is_extension_module(filename):
-            for t in self.loadTestsFromExtensionModule(filename):
-                yield t
-        else:
-            if self.extension and anyp(filename.endswith, self.extension):
-                name = os.path.basename(filename)
-                dh = open(filename)
-                try:
-                    doc = dh.read()
-                finally:
-                    dh.close()
-                test = self.parser.get_doctest(
-                    doc, globs={'__file__': filename}, name=name,
-                    filename=filename, lineno=0)
-                if test.examples:
-                    #print 'FileCase:',test.examples  # dbg
-                    yield DocFileCase(test)
-                else:
-                    yield False # no tests to load
-
-    def wantFile(self,filename):
-        """Return whether the given filename should be scanned for tests.
-
-        Modified version that accepts extension modules as valid containers for
-        doctests.
-        """
-        #print '*** ipdoctest- wantFile:',filename  # dbg
-
-        for pat in self.exclude_patterns:
-            if pat.search(filename):
-                # print '###>>> SKIP:',filename  # dbg
-                return False
-
-        if is_extension_module(filename):
-            return True
-        else:
-            return doctests.Doctest.wantFile(self,filename)
-
-
-class IPythonDoctest(ExtensionDoctest):
-    """Nose Plugin that supports doctests in extension modules.
-    """
-    name = 'ipdoctest'   # call nosetests with --with-ipdoctest
-    enabled = True
 
-    def makeTest(self, obj, parent):
-        """Look for doctests in the given object, which will be a
-        function, method or class.
-        """
-        #print 'Plugin analyzing:', obj, parent  # dbg
-        # always use whitespace and ellipsis options
-        optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
-
-        doctests = self.finder.find(obj, module=getmodule(parent))
-        if doctests:
-            for test in doctests:
-                if len(test.examples) == 0:
-                    continue
-
-                yield DocTestCase(test, obj=obj,
-                                  optionflags=optionflags,
-                                  checker=self.checker)
-
-    def options(self, parser, env=os.environ):
-        #print "Options for nose plugin:", self.name # dbg
-        Plugin.options(self, parser, env)
-        parser.add_option('--ipdoctest-tests', action='store_true',
-                          dest='ipdoctest_tests',
-                          default=env.get('NOSE_IPDOCTEST_TESTS',True),
-                          help="Also look for doctests in test modules. "
-                          "Note that classes, methods and functions should "
-                          "have either doctests or non-doctest tests, "
-                          "not both. [NOSE_IPDOCTEST_TESTS]")
-        parser.add_option('--ipdoctest-extension', action="append",
-                          dest="ipdoctest_extension",
-                          help="Also look for doctests in files with "
-                          "this extension [NOSE_IPDOCTEST_EXTENSION]")
-        # Set the default as a list, if given in env; otherwise
-        # an additional value set on the command line will cause
-        # an error.
-        env_setting = env.get('NOSE_IPDOCTEST_EXTENSION')
-        if env_setting is not None:
-            parser.set_defaults(ipdoctest_extension=tolist(env_setting))
-
-    def configure(self, options, config):
-        #print "Configuring nose plugin:", self.name # dbg
-        Plugin.configure(self, options, config)
-        self.doctest_tests = options.ipdoctest_tests
-        self.extension = tolist(options.ipdoctest_extension)
-
-        self.parser = IPDocTestParser()
-        self.finder = DocTestFinder(parser=self.parser)
-        self.checker = IPDoctestOutputChecker()
-        self.globs = None
-        self.extraglobs = None
+    def run(self, test, compileflags=None, out=None, clear_globs=True):
+        # Override terminal size to standardise traceback format
+        with modified_env({'COLUMNS': '80', 'LINES': '24'}):
+            return super(IPDocTestRunner,self).run(test,
+                                                   compileflags,out,clear_globs)
diff --git a/IPython/testing/plugin/iptest.py b/IPython/testing/plugin/iptest.py
deleted file mode 100755
index 390c42244bf..00000000000
--- a/IPython/testing/plugin/iptest.py
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env python
-"""Nose-based test runner.
-"""
-
-from nose.core import main
-from nose.plugins.builtin import plugins
-from nose.plugins.doctests import Doctest
-
-import ipdoctest
-from ipdoctest import IPDocTestRunner
-
-if __name__ == '__main__':
-    print 'WARNING: this code is incomplete!'
-    print
-
-    pp = [x() for x in plugins]  # activate all builtin plugins first
-    main(testRunner=IPDocTestRunner(),
-         plugins=pp+[ipdoctest.IPythonDoctest(),Doctest()])
diff --git a/IPython/testing/plugin/pytest_ipdoctest.py b/IPython/testing/plugin/pytest_ipdoctest.py
new file mode 100644
index 00000000000..2c35c6fe108
--- /dev/null
+++ b/IPython/testing/plugin/pytest_ipdoctest.py
@@ -0,0 +1,877 @@
+# Based on Pytest doctest.py
+# Original license:
+# The MIT License (MIT)
+#
+# Copyright (c) 2004-2021 Holger Krekel and others
+"""Discover and run ipdoctests in modules and test files."""
+
+import bdb
+import builtins
+import inspect
+import os
+import platform
+import sys
+import traceback
+import types
+import warnings
+from contextlib import contextmanager
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+from re import Pattern
+from collections.abc import Callable, Generator, Iterable, Sequence
+
+import pytest
+from _pytest import outcomes
+from _pytest._code.code import ExceptionInfo, ReprFileLocation, TerminalRepr
+from _pytest._io import TerminalWriter
+from _pytest.compat import safe_getattr
+from _pytest.config import Config
+from _pytest.config.argparsing import Parser
+
+try:
+    from _pytest.fixtures import TopRequest as FixtureRequest
+except ImportError:
+    from _pytest.fixtures import FixtureRequest
+from _pytest.nodes import Collector
+from _pytest.outcomes import OutcomeException
+from _pytest.pathlib import fnmatch_ex, import_path
+from _pytest.python_api import approx
+from _pytest.warning_types import PytestWarning
+
+if TYPE_CHECKING:
+    import doctest
+
+    from .ipdoctest import IPDoctestOutputChecker
+
+DOCTEST_REPORT_CHOICE_NONE = "none"
+DOCTEST_REPORT_CHOICE_CDIFF = "cdiff"
+DOCTEST_REPORT_CHOICE_NDIFF = "ndiff"
+DOCTEST_REPORT_CHOICE_UDIFF = "udiff"
+DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE = "only_first_failure"
+
+DOCTEST_REPORT_CHOICES = (
+    DOCTEST_REPORT_CHOICE_NONE,
+    DOCTEST_REPORT_CHOICE_CDIFF,
+    DOCTEST_REPORT_CHOICE_NDIFF,
+    DOCTEST_REPORT_CHOICE_UDIFF,
+    DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE,
+)
+
+# Lazy definition of runner class
+RUNNER_CLASS = None
+# Lazy definition of output checker class
+CHECKER_CLASS: Optional[Type["IPDoctestOutputChecker"]] = None
+
+pytest_version = tuple([int(part) for part in pytest.__version__.split(".")])
+
+
+def pytest_addoption(parser: Parser) -> None:
+    parser.addini(
+        "ipdoctest_optionflags",
+        "option flags for ipdoctests",
+        type="args",
+        default=["ELLIPSIS"],
+    )
+    parser.addini(
+        "ipdoctest_encoding", "encoding used for ipdoctest files", default="utf-8"
+    )
+    group = parser.getgroup("collect")
+    group.addoption(
+        "--ipdoctest-modules",
+        action="store_true",
+        default=False,
+        help="run ipdoctests in all .py modules",
+        dest="ipdoctestmodules",
+    )
+    group.addoption(
+        "--ipdoctest-report",
+        type=str.lower,
+        default="udiff",
+        help="choose another output format for diffs on ipdoctest failure",
+        choices=DOCTEST_REPORT_CHOICES,
+        dest="ipdoctestreport",
+    )
+    group.addoption(
+        "--ipdoctest-glob",
+        action="append",
+        default=[],
+        metavar="pat",
+        help="ipdoctests file matching pattern, default: test*.txt",
+        dest="ipdoctestglob",
+    )
+    group.addoption(
+        "--ipdoctest-ignore-import-errors",
+        action="store_true",
+        default=False,
+        help="ignore ipdoctest ImportErrors",
+        dest="ipdoctest_ignore_import_errors",
+    )
+    group.addoption(
+        "--ipdoctest-continue-on-failure",
+        action="store_true",
+        default=False,
+        help="for a given ipdoctest, continue to run after the first failure",
+        dest="ipdoctest_continue_on_failure",
+    )
+
+
+def pytest_unconfigure() -> None:
+    global RUNNER_CLASS
+
+    RUNNER_CLASS = None
+
+
+def pytest_collect_file(
+    file_path: Path,
+    parent: Collector,
+) -> Optional[Union["IPDoctestModule", "IPDoctestTextfile"]]:
+    config = parent.config
+    if file_path.suffix == ".py":
+        if config.option.ipdoctestmodules and not any(
+            (_is_setup_py(file_path), _is_main_py(file_path))
+        ):
+            mod: IPDoctestModule = IPDoctestModule.from_parent(parent, path=file_path)
+            return mod
+    elif _is_ipdoctest(config, file_path, parent):
+        txt: IPDoctestTextfile = IPDoctestTextfile.from_parent(parent, path=file_path)
+        return txt
+    return None
+
+
+if pytest_version[0] < 7:
+    _collect_file = pytest_collect_file
+
+    def pytest_collect_file(
+        path,
+        parent: Collector,
+    ) -> Optional[Union["IPDoctestModule", "IPDoctestTextfile"]]:
+        return _collect_file(Path(path), parent)
+
+    _import_path = import_path
+
+    def import_path(path, root):
+        import py.path
+
+        return _import_path(py.path.local(path))
+
+
+def _is_setup_py(path: Path) -> bool:
+    if path.name != "setup.py":
+        return False
+    contents = path.read_bytes()
+    return b"setuptools" in contents or b"distutils" in contents
+
+
+def _is_ipdoctest(config: Config, path: Path, parent: Collector) -> bool:
+    if path.suffix in (".txt", ".rst") and parent.session.isinitpath(path):
+        return True
+    globs = config.getoption("ipdoctestglob") or ["test*.txt"]
+    return any(fnmatch_ex(glob, path) for glob in globs)
+
+
+def _is_main_py(path: Path) -> bool:
+    return path.name == "__main__.py"
+
+
+class ReprFailDoctest(TerminalRepr):
+    def __init__(
+        self, reprlocation_lines: Sequence[Tuple[ReprFileLocation, Sequence[str]]]
+    ) -> None:
+        self.reprlocation_lines = reprlocation_lines
+
+    def toterminal(self, tw: TerminalWriter) -> None:
+        for reprlocation, lines in self.reprlocation_lines:
+            for line in lines:
+                tw.line(line)
+            reprlocation.toterminal(tw)
+
+
+class MultipleDoctestFailures(Exception):
+    def __init__(self, failures: Sequence["doctest.DocTestFailure"]) -> None:
+        super().__init__()
+        self.failures = failures
+
+
+def _init_runner_class() -> Type["IPDocTestRunner"]:
+    import doctest
+    from .ipdoctest import IPDocTestRunner
+
+    class PytestDoctestRunner(IPDocTestRunner):
+        """Runner to collect failures.
+
+        Note that the out variable in this case is a list instead of a
+        stdout-like object.
+        """
+
+        def __init__(
+            self,
+            checker: Optional["IPDoctestOutputChecker"] = None,
+            verbose: Optional[bool] = None,
+            optionflags: int = 0,
+            continue_on_failure: bool = True,
+        ) -> None:
+            super().__init__(checker=checker, verbose=verbose, optionflags=optionflags)
+            self.continue_on_failure = continue_on_failure
+
+        def report_failure(
+            self,
+            out,
+            test: "doctest.DocTest",
+            example: "doctest.Example",
+            got: str,
+        ) -> None:
+            failure = doctest.DocTestFailure(test, example, got)
+            if self.continue_on_failure:
+                out.append(failure)
+            else:
+                raise failure
+
+        def report_unexpected_exception(
+            self,
+            out,
+            test: "doctest.DocTest",
+            example: "doctest.Example",
+            exc_info: Tuple[Type[BaseException], BaseException, types.TracebackType],
+        ) -> None:
+            if isinstance(exc_info[1], OutcomeException):
+                raise exc_info[1]
+            if isinstance(exc_info[1], bdb.BdbQuit):
+                outcomes.exit("Quitting debugger")
+            failure = doctest.UnexpectedException(test, example, exc_info)
+            if self.continue_on_failure:
+                out.append(failure)
+            else:
+                raise failure
+
+    return PytestDoctestRunner
+
+
+def _get_runner(
+    checker: Optional["IPDoctestOutputChecker"] = None,
+    verbose: Optional[bool] = None,
+    optionflags: int = 0,
+    continue_on_failure: bool = True,
+) -> "IPDocTestRunner":
+    # We need this in order to do a lazy import on doctest
+    global RUNNER_CLASS
+    if RUNNER_CLASS is None:
+        RUNNER_CLASS = _init_runner_class()
+    # Type ignored because the continue_on_failure argument is only defined on
+    # PytestDoctestRunner, which is lazily defined so can't be used as a type.
+    return RUNNER_CLASS(  # type: ignore
+        checker=checker,
+        verbose=verbose,
+        optionflags=optionflags,
+        continue_on_failure=continue_on_failure,
+    )
+
+
+class IPDoctestItem(pytest.Item):
+    _user_ns_orig: Dict[str, Any]
+
+    def __init__(
+        self,
+        name: str,
+        parent: "Union[IPDoctestTextfile, IPDoctestModule]",
+        runner: Optional["IPDocTestRunner"] = None,
+        dtest: Optional["doctest.DocTest"] = None,
+    ) -> None:
+        super().__init__(name, parent)
+        self.runner = runner
+        self.dtest = dtest
+        self.obj = None
+        self.fixture_request: Optional[FixtureRequest] = None
+        self._user_ns_orig = {}
+
+    @classmethod
+    def from_parent(  # type: ignore
+        cls,
+        parent: "Union[IPDoctestTextfile, IPDoctestModule]",
+        *,
+        name: str,
+        runner: "IPDocTestRunner",
+        dtest: "doctest.DocTest",
+    ):
+        # incompatible signature due to imposed limits on subclass
+        """The public named constructor."""
+        return super().from_parent(name=name, parent=parent, runner=runner, dtest=dtest)
+
+    def setup(self) -> None:
+        if self.dtest is not None:
+            self.fixture_request = _setup_fixtures(self)
+            globs = dict(getfixture=self.fixture_request.getfixturevalue)
+            for name, value in self.fixture_request.getfixturevalue(
+                "ipdoctest_namespace"
+            ).items():
+                globs[name] = value
+            self.dtest.globs.update(globs)
+
+            from .ipdoctest import IPExample
+
+            if isinstance(self.dtest.examples[0], IPExample):
+                # for IPython examples *only*, we swap the globals with the ipython
+                # namespace, after updating it with the globals (which doctest
+                # fills with the necessary info from the module being tested).
+                self._user_ns_orig = {}
+                self._user_ns_orig.update(_ip.user_ns)
+                _ip.user_ns.update(self.dtest.globs)
+                # We must remove the _ key in the namespace, so that Python's
+                # doctest code sets it naturally
+                _ip.user_ns.pop("_", None)
+                _ip.user_ns["__builtins__"] = builtins
+                self.dtest.globs = _ip.user_ns
+
+    def teardown(self) -> None:
+        from .ipdoctest import IPExample
+
+        # Undo the test.globs reassignment we made
+        if isinstance(self.dtest.examples[0], IPExample):
+            self.dtest.globs = {}
+            _ip.user_ns.clear()
+            _ip.user_ns.update(self._user_ns_orig)
+            del self._user_ns_orig
+
+        self.dtest.globs.clear()
+
+    def runtest(self) -> None:
+        assert self.dtest is not None
+        assert self.runner is not None
+        _check_all_skipped(self.dtest)
+        self._disable_output_capturing_for_darwin()
+        failures: List[doctest.DocTestFailure] = []
+
+        # exec(compile(..., "single", ...), ...) puts result in builtins._
+        had_underscore_value = hasattr(builtins, "_")
+        underscore_original_value = getattr(builtins, "_", None)
+
+        # Save our current directory and switch out to the one where the
+        # test was originally created, in case another doctest did a
+        # directory change.  We'll restore this in the finally clause.
+        curdir = os.getcwd()
+        os.chdir(self.fspath.dirname)
+        try:
+            # Type ignored because we change the type of `out` from what
+            # ipdoctest expects.
+            self.runner.run(self.dtest, out=failures, clear_globs=False)  # type: ignore[arg-type]
+        finally:
+            os.chdir(curdir)
+            if had_underscore_value:
+                setattr(builtins, "_", underscore_original_value)
+            elif hasattr(builtins, "_"):
+                delattr(builtins, "_")
+
+        if failures:
+            raise MultipleDoctestFailures(failures)
+
+    def _disable_output_capturing_for_darwin(self) -> None:
+        """Disable output capturing. Otherwise, stdout is lost to ipdoctest (pytest#985)."""
+        if platform.system() != "Darwin":
+            return
+        capman = self.config.pluginmanager.getplugin("capturemanager")
+        if capman:
+            capman.suspend_global_capture(in_=True)
+            out, err = capman.read_global_capture()
+            sys.stdout.write(out)
+            sys.stderr.write(err)
+
+    # TODO: Type ignored -- breaks Liskov Substitution.
+    def repr_failure(  # type: ignore[override]
+        self,
+        excinfo: ExceptionInfo[BaseException],
+    ) -> Union[str, TerminalRepr]:
+        import doctest
+
+        failures: Optional[
+            Sequence[Union[doctest.DocTestFailure, doctest.UnexpectedException]]
+        ] = None
+        if isinstance(
+            excinfo.value, (doctest.DocTestFailure, doctest.UnexpectedException)
+        ):
+            failures = [excinfo.value]
+        elif isinstance(excinfo.value, MultipleDoctestFailures):
+            failures = excinfo.value.failures
+
+        if failures is None:
+            return super().repr_failure(excinfo)
+
+        reprlocation_lines = []
+        for failure in failures:
+            example = failure.example
+            test = failure.test
+            filename = test.filename
+            if test.lineno is None:
+                lineno = None
+            else:
+                lineno = test.lineno + example.lineno + 1
+            message = type(failure).__name__
+            # TODO: ReprFileLocation doesn't expect a None lineno.
+            reprlocation = ReprFileLocation(filename, lineno, message)  # type: ignore[arg-type]
+            checker = _get_checker()
+            report_choice = _get_report_choice(self.config.getoption("ipdoctestreport"))
+            if lineno is not None:
+                assert failure.test.docstring is not None
+                lines = failure.test.docstring.splitlines(False)
+                # add line numbers to the left of the error message
+                assert test.lineno is not None
+                lines = [
+                    "%03d %s" % (i + test.lineno + 1, x) for (i, x) in enumerate(lines)
+                ]
+                # trim docstring error lines to 10
+                lines = lines[max(example.lineno - 9, 0) : example.lineno + 1]
+            else:
+                lines = [
+                    "EXAMPLE LOCATION UNKNOWN, not showing all tests of that example"
+                ]
+                indent = ">>>"
+                for line in example.source.splitlines():
+                    lines.append(f"??? {indent} {line}")
+                    indent = "..."
+            if isinstance(failure, doctest.DocTestFailure):
+                lines += checker.output_difference(
+                    example, failure.got, report_choice
+                ).split("\n")
+            else:
+                inner_excinfo = ExceptionInfo.from_exc_info(failure.exc_info)
+                lines += ["UNEXPECTED EXCEPTION: %s" % repr(inner_excinfo.value)]
+                lines += [
+                    x.strip("\n") for x in traceback.format_exception(*failure.exc_info)
+                ]
+            reprlocation_lines.append((reprlocation, lines))
+        return ReprFailDoctest(reprlocation_lines)
+
+    def reportinfo(self) -> Tuple[Union["os.PathLike[str]", str], Optional[int], str]:
+        assert self.dtest is not None
+        return self.path, self.dtest.lineno, "[ipdoctest] %s" % self.name
+
+    if pytest_version[0] < 7:
+
+        @property
+        def path(self) -> Path:
+            return Path(self.fspath)
+
+
+def _get_flag_lookup() -> Dict[str, int]:
+    import doctest
+
+    return dict(
+        DONT_ACCEPT_TRUE_FOR_1=doctest.DONT_ACCEPT_TRUE_FOR_1,
+        DONT_ACCEPT_BLANKLINE=doctest.DONT_ACCEPT_BLANKLINE,
+        NORMALIZE_WHITESPACE=doctest.NORMALIZE_WHITESPACE,
+        ELLIPSIS=doctest.ELLIPSIS,
+        IGNORE_EXCEPTION_DETAIL=doctest.IGNORE_EXCEPTION_DETAIL,
+        COMPARISON_FLAGS=doctest.COMPARISON_FLAGS,
+        ALLOW_UNICODE=_get_allow_unicode_flag(),
+        ALLOW_BYTES=_get_allow_bytes_flag(),
+        NUMBER=_get_number_flag(),
+    )
+
+
+def get_optionflags(parent):
+    optionflags_str = parent.config.getini("ipdoctest_optionflags")
+    flag_lookup_table = _get_flag_lookup()
+    flag_acc = 0
+    for flag in optionflags_str:
+        flag_acc |= flag_lookup_table[flag]
+    return flag_acc
+
+
+def _get_continue_on_failure(config):
+    continue_on_failure = config.getvalue("ipdoctest_continue_on_failure")
+    if continue_on_failure:
+        # We need to turn off this if we use pdb since we should stop at
+        # the first failure.
+        if config.getvalue("usepdb"):
+            continue_on_failure = False
+    return continue_on_failure
+
+
+class IPDoctestTextfile(pytest.Module):
+    obj = None
+
+    def collect(self) -> Iterable[IPDoctestItem]:
+        import doctest
+        from .ipdoctest import IPDocTestParser
+
+        # Inspired by doctest.testfile; ideally we would use it directly,
+        # but it doesn't support passing a custom checker.
+        encoding = self.config.getini("ipdoctest_encoding")
+        text = self.path.read_text(encoding)
+        filename = str(self.path)
+        name = self.path.name
+        globs = {"__name__": "__main__"}
+
+        optionflags = get_optionflags(self)
+
+        runner = _get_runner(
+            verbose=False,
+            optionflags=optionflags,
+            checker=_get_checker(),
+            continue_on_failure=_get_continue_on_failure(self.config),
+        )
+
+        parser = IPDocTestParser()
+        test = parser.get_doctest(text, globs, name, filename, 0)
+        if test.examples:
+            yield IPDoctestItem.from_parent(
+                self, name=test.name, runner=runner, dtest=test
+            )
+
+    if pytest_version[0] < 7:
+
+        @property
+        def path(self) -> Path:
+            return Path(self.fspath)
+
+        @classmethod
+        def from_parent(
+            cls,
+            parent,
+            *,
+            fspath=None,
+            path: Optional[Path] = None,
+            **kw,
+        ):
+            if path is not None:
+                import py.path
+
+                fspath = py.path.local(path)
+            return super().from_parent(parent=parent, fspath=fspath, **kw)
+
+
+def _check_all_skipped(test: "doctest.DocTest") -> None:
+    """Raise pytest.skip() if all examples in the given DocTest have the SKIP
+    option set."""
+    import doctest
+
+    all_skipped = all(x.options.get(doctest.SKIP, False) for x in test.examples)
+    if all_skipped:
+        pytest.skip("all docstests skipped by +SKIP option")
+
+
+def _is_mocked(obj: object) -> bool:
+    """Return if an object is possibly a mock object by checking the
+    existence of a highly improbable attribute."""
+    return (
+        safe_getattr(obj, "pytest_mock_example_attribute_that_shouldnt_exist", None)
+        is not None
+    )
+
+
+@contextmanager
+def _patch_unwrap_mock_aware() -> Generator[None, None, None]:
+    """Context manager which replaces ``inspect.unwrap`` with a version
+    that's aware of mock objects and doesn't recurse into them."""
+    real_unwrap = inspect.unwrap
+
+    def _mock_aware_unwrap(
+        func: Callable[..., Any], *, stop: Optional[Callable[[Any], Any]] = None
+    ) -> Any:
+        try:
+            if stop is None or stop is _is_mocked:
+                return real_unwrap(func, stop=_is_mocked)
+            _stop = stop
+            return real_unwrap(func, stop=lambda obj: _is_mocked(obj) or _stop(func))
+        except Exception as e:
+            warnings.warn(
+                "Got %r when unwrapping %r.  This is usually caused "
+                "by a violation of Python's object protocol; see e.g. "
+                "https://github.com/pytest-dev/pytest/issues/5080" % (e, func),
+                PytestWarning,
+            )
+            raise
+
+    inspect.unwrap = _mock_aware_unwrap
+    try:
+        yield
+    finally:
+        inspect.unwrap = real_unwrap
+
+
+class IPDoctestModule(pytest.Module):
+    def collect(self) -> Iterable[IPDoctestItem]:
+        import doctest
+        from .ipdoctest import DocTestFinder, IPDocTestParser
+
+        class MockAwareDocTestFinder(DocTestFinder):
+            """A hackish ipdoctest finder that overrides stdlib internals to fix a stdlib bug.
+
+            https://github.com/pytest-dev/pytest/issues/3456
+            https://bugs.python.org/issue25532
+            """
+
+            def _find_lineno(self, obj, source_lines):
+                """Doctest code does not take into account `@property`, this
+                is a hackish way to fix it. https://bugs.python.org/issue17446
+
+                Wrapped Doctests will need to be unwrapped so the correct
+                line number is returned. This will be reported upstream. #8796
+                """
+                if isinstance(obj, property):
+                    obj = getattr(obj, "fget", obj)
+
+                if hasattr(obj, "__wrapped__"):
+                    # Get the main obj in case of it being wrapped
+                    obj = inspect.unwrap(obj)
+
+                # Type ignored because this is a private function.
+                return super()._find_lineno(  # type:ignore[misc]
+                    obj,
+                    source_lines,
+                )
+
+            def _find(
+                self, tests, obj, name, module, source_lines, globs, seen
+            ) -> None:
+                if _is_mocked(obj):
+                    return
+                with _patch_unwrap_mock_aware():
+                    # Type ignored because this is a private function.
+                    super()._find(  # type:ignore[misc]
+                        tests, obj, name, module, source_lines, globs, seen
+                    )
+
+        if self.path.name == "conftest.py":
+            if pytest_version[0] < 7:
+                module = self.config.pluginmanager._importconftest(
+                    self.path,
+                    self.config.getoption("importmode"),
+                )
+            else:
+                kwargs = {"rootpath": self.config.rootpath}
+                if pytest_version >= (8, 1):
+                    kwargs["consider_namespace_packages"] = False
+                module = self.config.pluginmanager._importconftest(
+                    self.path,
+                    self.config.getoption("importmode"),
+                    **kwargs,
+                )
+        else:
+            try:
+                kwargs = {"root": self.config.rootpath}
+                if pytest_version >= (8, 1):
+                    kwargs["consider_namespace_packages"] = False
+                module = import_path(self.path, **kwargs)
+            except ImportError:
+                if self.config.getvalue("ipdoctest_ignore_import_errors"):
+                    pytest.skip("unable to import module %r" % self.path)
+                else:
+                    raise
+        # Uses internal doctest module parsing mechanism.
+        finder = MockAwareDocTestFinder(parser=IPDocTestParser())
+        optionflags = get_optionflags(self)
+        runner = _get_runner(
+            verbose=False,
+            optionflags=optionflags,
+            checker=_get_checker(),
+            continue_on_failure=_get_continue_on_failure(self.config),
+        )
+
+        for test in finder.find(module, module.__name__):
+            if test.examples:  # skip empty ipdoctests
+                yield IPDoctestItem.from_parent(
+                    self, name=test.name, runner=runner, dtest=test
+                )
+
+    if pytest_version[0] < 7:
+
+        @property
+        def path(self) -> Path:
+            return Path(self.fspath)
+
+        @classmethod
+        def from_parent(
+            cls,
+            parent,
+            *,
+            fspath=None,
+            path: Optional[Path] = None,
+            **kw,
+        ):
+            if path is not None:
+                import py.path
+
+                fspath = py.path.local(path)
+            return super().from_parent(parent=parent, fspath=fspath, **kw)
+
+
+def _setup_fixtures(doctest_item: IPDoctestItem) -> FixtureRequest:
+    """Used by IPDoctestTextfile and IPDoctestItem to setup fixture information."""
+
+    def func() -> None:
+        pass
+
+    doctest_item.funcargs = {}  # type: ignore[attr-defined]
+    fm = doctest_item.session._fixturemanager
+    kwargs = {"node": doctest_item, "func": func, "cls": None}
+    if pytest_version <= (8, 0):
+        kwargs["funcargs"] = False
+    doctest_item._fixtureinfo = fm.getfixtureinfo(  # type: ignore[attr-defined]
+        **kwargs
+    )
+    fixture_request = FixtureRequest(doctest_item, _ispytest=True)
+    if pytest_version <= (8, 0):
+        fixture_request._fillfixtures()
+    return fixture_request
+
+
+def _init_checker_class() -> Type["IPDoctestOutputChecker"]:
+    import doctest
+    import re
+    from .ipdoctest import IPDoctestOutputChecker
+
+    class LiteralsOutputChecker(IPDoctestOutputChecker):
+        # Based on doctest_nose_plugin.py from the nltk project
+        # (https://github.com/nltk/nltk) and on the "numtest" doctest extension
+        # by Sebastien Boisgerault (https://github.com/boisgera/numtest).
+
+        _unicode_literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE)
+        _bytes_literal_re = re.compile(r"(\W|^)[bB]([rR]?[\'\"])", re.UNICODE)
+        _number_re = re.compile(
+            r"""
+            (?P<number>
+              (?P<mantissa>
+                (?P<integer1> [+-]?\d*)\.(?P<fraction>\d+)
+                |
+                (?P<integer2> [+-]?\d+)\.
+              )
+              (?:
+                [Ee]
+                (?P<exponent1> [+-]?\d+)
+              )?
+              |
+              (?P<integer3> [+-]?\d+)
+              (?:
+                [Ee]
+                (?P<exponent2> [+-]?\d+)
+              )
+            )
+            """,
+            re.VERBOSE,
+        )
+
+        def check_output(self, want: str, got: str, optionflags: int) -> bool:
+            if super().check_output(want, got, optionflags):
+                return True
+
+            allow_unicode = optionflags & _get_allow_unicode_flag()
+            allow_bytes = optionflags & _get_allow_bytes_flag()
+            allow_number = optionflags & _get_number_flag()
+
+            if not allow_unicode and not allow_bytes and not allow_number:
+                return False
+
+            def remove_prefixes(regex: Pattern[str], txt: str) -> str:
+                return re.sub(regex, r"\1\2", txt)
+
+            if allow_unicode:
+                want = remove_prefixes(self._unicode_literal_re, want)
+                got = remove_prefixes(self._unicode_literal_re, got)
+
+            if allow_bytes:
+                want = remove_prefixes(self._bytes_literal_re, want)
+                got = remove_prefixes(self._bytes_literal_re, got)
+
+            if allow_number:
+                got = self._remove_unwanted_precision(want, got)
+
+            return super().check_output(want, got, optionflags)
+
+        def _remove_unwanted_precision(self, want: str, got: str) -> str:
+            wants = list(self._number_re.finditer(want))
+            gots = list(self._number_re.finditer(got))
+            if len(wants) != len(gots):
+                return got
+            offset = 0
+            for w, g in zip(wants, gots):
+                fraction: Optional[str] = w.group("fraction")
+                exponent: Optional[str] = w.group("exponent1")
+                if exponent is None:
+                    exponent = w.group("exponent2")
+                precision = 0 if fraction is None else len(fraction)
+                if exponent is not None:
+                    precision -= int(exponent)
+                if float(w.group()) == approx(float(g.group()), abs=10**-precision):
+                    # They're close enough. Replace the text we actually
+                    # got with the text we want, so that it will match when we
+                    # check the string literally.
+                    got = (
+                        got[: g.start() + offset] + w.group() + got[g.end() + offset :]
+                    )
+                    offset += w.end() - w.start() - (g.end() - g.start())
+            return got
+
+    return LiteralsOutputChecker
+
+
+def _get_checker() -> "IPDoctestOutputChecker":
+    """Return a IPDoctestOutputChecker subclass that supports some
+    additional options:
+
+    * ALLOW_UNICODE and ALLOW_BYTES options to ignore u'' and b''
+      prefixes (respectively) in string literals. Useful when the same
+      ipdoctest should run in Python 2 and Python 3.
+
+    * NUMBER to ignore floating-point differences smaller than the
+      precision of the literal number in the ipdoctest.
+
+    An inner class is used to avoid importing "ipdoctest" at the module
+    level.
+    """
+    global CHECKER_CLASS
+    if CHECKER_CLASS is None:
+        CHECKER_CLASS = _init_checker_class()
+    return CHECKER_CLASS()
+
+
+def _get_allow_unicode_flag() -> int:
+    """Register and return the ALLOW_UNICODE flag."""
+    import doctest
+
+    return doctest.register_optionflag("ALLOW_UNICODE")
+
+
+def _get_allow_bytes_flag() -> int:
+    """Register and return the ALLOW_BYTES flag."""
+    import doctest
+
+    return doctest.register_optionflag("ALLOW_BYTES")
+
+
+def _get_number_flag() -> int:
+    """Register and return the NUMBER flag."""
+    import doctest
+
+    return doctest.register_optionflag("NUMBER")
+
+
+def _get_report_choice(key: str) -> int:
+    """Return the actual `ipdoctest` module flag value.
+
+    We want to do it as late as possible to avoid importing `ipdoctest` and all
+    its dependencies when parsing options, as it adds overhead and breaks tests.
+    """
+    import doctest
+
+    return {
+        DOCTEST_REPORT_CHOICE_UDIFF: doctest.REPORT_UDIFF,
+        DOCTEST_REPORT_CHOICE_CDIFF: doctest.REPORT_CDIFF,
+        DOCTEST_REPORT_CHOICE_NDIFF: doctest.REPORT_NDIFF,
+        DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE: doctest.REPORT_ONLY_FIRST_FAILURE,
+        DOCTEST_REPORT_CHOICE_NONE: 0,
+    }[key]
+
+
+@pytest.fixture(scope="session")
+def ipdoctest_namespace() -> Dict[str, Any]:
+    """Fixture that returns a :py:class:`dict` that will be injected into the
+    namespace of ipdoctests."""
+    return dict()
diff --git a/IPython/testing/plugin/show_refs.py b/IPython/testing/plugin/show_refs.py
deleted file mode 100644
index d829644d7d0..00000000000
--- a/IPython/testing/plugin/show_refs.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""Simple script to show reference holding behavior.
-
-This is used by a companion test case.
-"""
-
-import gc
-
-class C(object):
-   def __del__(self):
-      pass
-      #print 'deleting object...'  # dbg
-
-if __name__ == '__main__':
-   c = C()
-
-   c_refs = gc.get_referrers(c)
-   ref_ids = map(id,c_refs)
-
-   print 'c referrers:',map(type,c_refs)
diff --git a/IPython/testing/plugin/simple.py b/IPython/testing/plugin/simple.py
index e3482d67372..79c9e0d21cc 100644
--- a/IPython/testing/plugin/simple.py
+++ b/IPython/testing/plugin/simple.py
@@ -1,9 +1,10 @@
 """Simple example using doctests.
 
 This file just contains doctests both using plain python and IPython prompts.
-All tests should be loaded by nose.
+All tests should be loaded by Pytest.
 """
 
+
 def pyfunc():
     """Some pure python tests...
 
@@ -16,18 +17,29 @@ def pyfunc():
     5
 
     >>> for i in range(3):
-    ...     print i,
-    ...     print i+1,
+    ...     print(i, end=' ')
+    ...     print(i+1, end=' ')
     ...
     0 1 1 2 2 3
     """
-    return 'pyfunc'
+    return "pyfunc"
 
 
-def ipyfunc2():
-    """Some pure python tests...
+def ipyfunc():
+    """Some IPython tests...
+
+    In [1]: ipyfunc()
+    Out[1]: 'ipyfunc'
+
+    In [2]: import os
+
+    In [3]: 2+3
+    Out[3]: 5
 
-    >>> 1+1
-    2
+    In [4]: for i in range(3):
+       ...:     print(i, end=' ')
+       ...:     print(i+1, end=' ')
+       ...:
+    Out[4]: 0 1 1 2 2 3
     """
-    return 'pyfunc2'
+    return "ipyfunc"
diff --git a/IPython/testing/plugin/simplevars.py b/IPython/testing/plugin/simplevars.py
index b9286c72678..82a5edb028d 100644
--- a/IPython/testing/plugin/simplevars.py
+++ b/IPython/testing/plugin/simplevars.py
@@ -1,2 +1,2 @@
 x = 1
-print 'x is:',x
+print("x is:", x)
diff --git a/IPython/testing/plugin/test_example.txt b/IPython/testing/plugin/test_example.txt
index d8bc6fd38f7..f8b681eb4ff 100644
--- a/IPython/testing/plugin/test_example.txt
+++ b/IPython/testing/plugin/test_example.txt
@@ -9,7 +9,7 @@ as a test::
 
     >>> 1+1
     2
-    >>> print "hello"
+    >>> print ("hello")
     hello
 
 More than one example works::
diff --git a/IPython/testing/plugin/test_exampleip.txt b/IPython/testing/plugin/test_exampleip.txt
index 8afcbfdf7d8..96b1eae19f0 100644
--- a/IPython/testing/plugin/test_exampleip.txt
+++ b/IPython/testing/plugin/test_exampleip.txt
@@ -21,7 +21,7 @@ Another example::
 
 Just like in IPython docstrings, you can use all IPython syntax and features::
 
-    In [9]: !echo "hello"
+    In [9]: !echo hello
     hello
 
     In [10]: a='hi'
diff --git a/IPython/testing/plugin/test_ipdoctest.py b/IPython/testing/plugin/test_ipdoctest.py
index 6d04b92bdb5..2686172bb29 100644
--- a/IPython/testing/plugin/test_ipdoctest.py
+++ b/IPython/testing/plugin/test_ipdoctest.py
@@ -13,21 +13,22 @@ def doctest_simple():
     In [1]: 1
     Out[1]: 1
 
-    In [2]: print 1
+    In [2]: print(1)
     1
     """
 
-
 def doctest_multiline1():
     """The ipdoctest machinery must handle multiline examples gracefully.
 
-    In [2]: for i in range(10):
-       ...:     print i,
+    In [2]: for i in range(4):
+       ...:     print(i)
        ...:      
-    0 1 2 3 4 5 6 7 8 9
+    0
+    1
+    2
+    3
     """
 
-    
 def doctest_multiline2():
     """Multiline examples that define functions and print output.
 
@@ -39,7 +40,7 @@ def doctest_multiline2():
     Out[8]: 2
 
     In [9]: def g(x):
-       ...:     print 'x is:',x
+       ...:     print('x is:',x)
        ...:      
 
     In [10]: g(1)
@@ -73,3 +74,19 @@ def doctest_multiline3():
     In [15]: h(0)
     Out[15]: -1
    """
+
+
+def doctest_builtin_underscore():
+    """Defining builtins._ should not break anything outside the doctest
+    while also should be working as expected inside the doctest.
+
+    In [1]: import builtins
+
+    In [2]: builtins._ = 42
+
+    In [3]: builtins._
+    Out[3]: 42
+
+    In [4]: _
+    Out[4]: 42
+    """
diff --git a/IPython/testing/plugin/test_refs.py b/IPython/testing/plugin/test_refs.py
index 599bdcc6909..b92448be074 100644
--- a/IPython/testing/plugin/test_refs.py
+++ b/IPython/testing/plugin/test_refs.py
@@ -5,7 +5,6 @@
 import inspect
 
 # Our own
-from IPython.testing import decorators as dec
 
 #-----------------------------------------------------------------------------
 # Testing functions
@@ -20,9 +19,9 @@ def doctest_run():
     In [13]: run simplevars.py
     x is: 1
     """
-    
+
 def doctest_runvars():
-    """Test that variables defined in scripts get loaded correcly via %run.
+    """Test that variables defined in scripts get loaded correctly via %run.
 
     In [13]: run simplevars.py
     x is: 1
@@ -38,11 +37,3 @@ def doctest_ivars():
     In [6]: zz
     Out[6]: 1
     """
-    
-#@dec.skip_doctest
-def doctest_refs():
-    """DocTest reference holding issues when running scripts.
-
-    In [32]: run show_refs.py
-    c referrers: [<type 'dict'>]
-    """
diff --git a/IPython/testing/skipdoctest.py b/IPython/testing/skipdoctest.py
new file mode 100644
index 00000000000..f440ea14b27
--- /dev/null
+++ b/IPython/testing/skipdoctest.py
@@ -0,0 +1,19 @@
+"""Decorators marks that a doctest should be skipped.
+
+The IPython.testing.decorators module triggers various extra imports, including
+numpy and sympy if they're present. Since this decorator is used in core parts
+of IPython, it's in a separate module so that running IPython doesn't trigger
+those imports."""
+
+# Copyright (C) IPython Development Team
+# Distributed under the terms of the Modified BSD License.
+
+
+def skip_doctest(f):
+    """Decorator - mark a function or method for skipping its doctest.
+
+    This decorator allows you to mark a function whose docstring you wish to
+    omit from testing, while preserving the docstring for introspection, help,
+    etc."""
+    f.__skip_doctest__ = True
+    return f
diff --git a/IPython/testing/tests/__init__.py b/IPython/testing/tests/__init__.py
deleted file mode 100644
index f751f68a9de..00000000000
--- a/IPython/testing/tests/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# encoding: utf-8
-__docformat__ = "restructuredtext en"
-#-------------------------------------------------------------------------------
-#       Copyright (C) 2005  Fernando Perez <fperez@colorado.edu>
-#                           Brian E Granger <ellisonbg@gmail.com>
-#                           Benjamin Ragan-Kelley <benjaminrk@gmail.com>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
diff --git a/IPython/testing/tests/test_decorators.py b/IPython/testing/tests/test_decorators.py
deleted file mode 100644
index 90c5578dd3e..00000000000
--- a/IPython/testing/tests/test_decorators.py
+++ /dev/null
@@ -1,187 +0,0 @@
-"""Tests for the decorators we've created for IPython.
-"""
-
-# Module imports
-# Std lib
-import inspect
-import sys
-import unittest
-
-# Third party
-import nose.tools as nt
-
-# Our own
-from IPython.testing import decorators as dec
-from IPython.testing.ipunittest import ParametricTestCase
-
-#-----------------------------------------------------------------------------
-# Utilities
-
-# Note: copied from OInspect, kept here so the testing stuff doesn't create
-# circular dependencies and is easier to reuse.
-def getargspec(obj):
-    """Get the names and default values of a function's arguments.
-
-    A tuple of four things is returned: (args, varargs, varkw, defaults).
-    'args' is a list of the argument names (it may contain nested lists).
-    'varargs' and 'varkw' are the names of the * and ** arguments or None.
-    'defaults' is an n-tuple of the default values of the last n arguments.
-
-    Modified version of inspect.getargspec from the Python Standard
-    Library."""
-
-    if inspect.isfunction(obj):
-        func_obj = obj
-    elif inspect.ismethod(obj):
-        func_obj = obj.im_func
-    else:
-        raise TypeError, 'arg is not a Python function'
-    args, varargs, varkw = inspect.getargs(func_obj.func_code)
-    return args, varargs, varkw, func_obj.func_defaults
-
-#-----------------------------------------------------------------------------
-# Testing functions
-
-@dec.as_unittest
-def trivial():
-    """A trivial test"""
-    pass
-
-# Some examples of parametric tests.
-
-def is_smaller(i,j):
-    assert i<j,"%s !< %s" % (i,j)
-
-class Tester(ParametricTestCase):
-
-    def test_parametric(self):
-        yield is_smaller(3, 4)
-        x, y = 1, 2
-        yield is_smaller(x, y)
-
-@dec.parametric
-def test_par_standalone():
-    yield is_smaller(3, 4)
-    x, y = 1, 2
-    yield is_smaller(x, y)
-
-
-@dec.skip
-def test_deliberately_broken():
-    """A deliberately broken test - we want to skip this one."""
-    1/0
-
-@dec.skip('Testing the skip decorator')
-def test_deliberately_broken2():
-    """Another deliberately broken test - we want to skip this one."""
-    1/0
-
-
-# Verify that we can correctly skip the doctest for a function at will, but
-# that the docstring itself is NOT destroyed by the decorator.
-@dec.skip_doctest
-def doctest_bad(x,y=1,**k):
-    """A function whose doctest we need to skip.
-
-    >>> 1+1
-    3
-    """
-    print 'x:',x
-    print 'y:',y
-    print 'k:',k
-
-
-def call_doctest_bad():
-    """Check that we can still call the decorated functions.
-    
-    >>> doctest_bad(3,y=4)
-    x: 3
-    y: 4
-    k: {}
-    """
-    pass
-
-
-def test_skip_dt_decorator():
-    """Doctest-skipping decorator should preserve the docstring.
-    """
-    # Careful: 'check' must be a *verbatim* copy of the doctest_bad docstring!
-    check = """A function whose doctest we need to skip.
-
-    >>> 1+1
-    3
-    """
-    # Fetch the docstring from doctest_bad after decoration.
-    val = doctest_bad.__doc__
-    
-    nt.assert_equal(check,val,"doctest_bad docstrings don't match")
-
-
-# Doctest skipping should work for class methods too
-class FooClass(object):
-    """FooClass
-
-    Example:
-
-    >>> 1+1
-    2
-    """
-
-    @dec.skip_doctest
-    def __init__(self,x):
-        """Make a FooClass.
-
-        Example:
-
-        >>> f = FooClass(3)
-        junk
-        """
-        print 'Making a FooClass.'
-        self.x = x
-        
-    @dec.skip_doctest
-    def bar(self,y):
-        """Example:
-
-        >>> ff = FooClass(3)
-        >>> ff.bar(0)
-        boom!
-        >>> 1/0
-        bam!
-        """
-        return 1/y
-
-    def baz(self,y):
-        """Example:
-
-        >>> ff2 = FooClass(3)
-        Making a FooClass.
-        >>> ff2.baz(3)
-        True
-        """
-        return self.x==y
-
-
-def test_skip_dt_decorator2():
-    """Doctest-skipping decorator should preserve function signature.
-    """
-    # Hardcoded correct answer
-    dtargs = (['x', 'y'], None, 'k', (1,))
-    # Introspect out the value
-    dtargsr = getargspec(doctest_bad)
-    assert dtargsr==dtargs, \
-           "Incorrectly reconstructed args for doctest_bad: %s" % (dtargsr,)
-
-
-@dec.skip_linux
-def test_linux():
-    nt.assert_not_equals(sys.platform,'linux2',"This test can't run under linux")
-
-@dec.skip_win32
-def test_win32():
-    nt.assert_not_equals(sys.platform,'win32',"This test can't run under windows")
-
-@dec.skip_osx
-def test_osx():
-    nt.assert_not_equals(sys.platform,'darwin',"This test can't run under osx")
-
diff --git a/IPython/testing/tests/test_ipunittest.py b/IPython/testing/tests/test_ipunittest.py
deleted file mode 100644
index 487386a2cb9..00000000000
--- a/IPython/testing/tests/test_ipunittest.py
+++ /dev/null
@@ -1,122 +0,0 @@
-"""Tests for IPython's test support utilities.
-
-These are decorators that allow standalone functions and docstrings to be seen
-as tests by unittest, replicating some of nose's functionality.  Additionally,
-IPython-syntax docstrings can be auto-converted to '>>>' so that ipython
-sessions can be copy-pasted as tests.
-
-This file can be run as a script, and it will call unittest.main().  We must
-check that it works with unittest as well as with nose...
-
-
-Notes:
-
-- Using nosetests --with-doctest --doctest-tests testfile.py
-  will find docstrings as tests wherever they are, even in methods.  But
-  if we use ipython syntax in the docstrings, they must be decorated with
-  @ipdocstring.  This is OK for test-only code, but not for user-facing
-  docstrings where we want to keep the ipython syntax.
-
-- Using nosetests --with-doctest file.py
-  also finds doctests if the file name doesn't have 'test' in it, because it is
-  treated like a normal module.  But if nose treats the file like a test file,
-  then for normal classes to be doctested the extra --doctest-tests is
-  necessary.
-
-- running this script with python (it has a __main__ section at the end) misses
-  one docstring test, the one embedded in the Foo object method.  Since our
-  approach relies on using decorators that create standalone TestCase
-  instances, it can only be used for functions, not for methods of objects.  
-Authors
--------
-
-- Fernando Perez <Fernando.Perez@berkeley.edu>
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from IPython.testing.ipunittest import ipdoctest, ipdocstring
-
-#-----------------------------------------------------------------------------
-# Test classes and functions
-#-----------------------------------------------------------------------------
-@ipdoctest
-def simple_dt():
-    """
-    >>> print 1+1
-    2
-    """
-
-
-@ipdoctest
-def ipdt_flush():
-    """
-In [20]: print 1
-1
-
-In [26]: for i in range(10):
-   ....:     print i,
-   ....:     
-   ....:     
-0 1 2 3 4 5 6 7 8 9
-
-In [27]: 3+4
-Out[27]: 7
-"""
-
-
-@ipdoctest
-def ipdt_indented_test():
-    """
-    In [20]: print 1
-    1
-
-    In [26]: for i in range(10):
-       ....:     print i,
-       ....:     
-       ....:     
-    0 1 2 3 4 5 6 7 8 9
-
-    In [27]: 3+4
-    Out[27]: 7
-    """
-
-
-class Foo(object):
-    """For methods, the normal decorator doesn't work.
-
-    But rewriting the docstring with ip2py does, *but only if using nose
-    --with-doctest*.  Do we want to have that as a dependency?
-    """
-
-    @ipdocstring
-    def ipdt_method(self):
-        """
-        In [20]: print 1
-        1
-
-        In [26]: for i in range(10):
-           ....:     print i,
-           ....:     
-           ....:     
-        0 1 2 3 4 5 6 7 8 9
-
-        In [27]: 3+4
-        Out[27]: 7
-        """
-
-    def normaldt_method(self):
-        """
-        >>> print 1+1
-        2
-        """
diff --git a/IPython/testing/tests/test_tools.py b/IPython/testing/tests/test_tools.py
deleted file mode 100644
index cc40a99d282..00000000000
--- a/IPython/testing/tests/test_tools.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Tests for testing.tools
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import with_statement
-
-import os
-import sys
-
-import nose.tools as nt
-
-from IPython.testing import decorators as dec
-from IPython.testing import tools as tt
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-@dec.skip_win32
-def test_full_path_posix():
-    spath = '/foo/bar.py'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['/foo/a.txt', '/foo/b.txt'])
-    spath = '/foo'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['/a.txt', '/b.txt'])
-    result = tt.full_path(spath,'a.txt')
-    nt.assert_equal(result, ['/a.txt'])
-
-
-@dec.skip_if_not_win32
-def test_full_path_win32():
-    spath = 'c:\\foo\\bar.py'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['c:\\foo\\a.txt', 'c:\\foo\\b.txt'])
-    spath = 'c:\\foo'
-    result = tt.full_path(spath,['a.txt','b.txt'])
-    nt.assert_equal(result, ['c:\\a.txt', 'c:\\b.txt'])
-    result = tt.full_path(spath,'a.txt')
-    nt.assert_equal(result, ['c:\\a.txt'])
-
-    
-@dec.parametric
-def test_parser():
-    err = ("FAILED (errors=1)", 1, 0)
-    fail = ("FAILED (failures=1)", 0, 1)
-    both = ("FAILED (errors=1, failures=1)", 1, 1)
-    for txt, nerr, nfail in [err, fail, both]:
-        nerr1, nfail1 = tt.parse_test_output(txt)
-        yield nt.assert_equal(nerr, nerr1)
-        yield nt.assert_equal(nfail, nfail1)
-
-        
-@dec.parametric
-def test_temp_pyfile():
-    src = 'pass\n'
-    fname, fh = tt.temp_pyfile(src)
-    yield nt.assert_true(os.path.isfile(fname))
-    fh.close()
-    with open(fname) as fh2:
-        src2 = fh2.read()
-    yield nt.assert_equal(src2, src)
diff --git a/IPython/testing/tools.py b/IPython/testing/tools.py
index 278de6e1c27..d596a000f8f 100644
--- a/IPython/testing/tools.py
+++ b/IPython/testing/tools.py
@@ -1,93 +1,56 @@
-"""Generic testing tools that do NOT depend on Twisted.
-
-In particular, this module exposes a set of top-level assert* functions that
-can be used in place of nose.tools.assert* in method generators (the ones in
-nose can not, at least as of nose 0.10.4).
-
-Note: our testing package contains testing.util, which does depend on Twisted
-and provides utilities for tests that manage Deferreds.  All testing support
-tools that only depend on nose, IPython or the standard library should go here
-instead.
-
+"""Generic testing tools.
 
 Authors
 -------
 - Fernando Perez <Fernando.Perez@berkeley.edu>
 """
 
-from __future__ import absolute_import
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import os
+from pathlib import Path
 import re
 import sys
+import tempfile
+import unittest
+
+from contextlib import contextmanager
+from io import StringIO
+from subprocess import Popen, PIPE
+from unittest.mock import patch
 
-try:
-    # These tools are used by parts of the runtime, so we make the nose
-    # dependency optional at this point.  Nose is a hard dependency to run the
-    # test suite, but NOT to use ipython itself.
-    import nose.tools as nt
-    has_nose = True
-except ImportError:
-    has_nose = False
-
-from IPython.config.loader import Config
-from IPython.utils.process import find_cmd, getoutputerror
+from traitlets.config.loader import Config
+from IPython.utils.process import get_output_error_code
 from IPython.utils.text import list_strings
-from IPython.utils.io import temp_pyfile
+from IPython.utils.io import temp_pyfile, Tee
+from IPython.utils import py3compat
 
 from . import decorators as dec
+from . import skipdoctest
 
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# Make a bunch of nose.tools assert wrappers that can be used in test
-# generators.  This will expose an assert* function for each one in nose.tools.
-
-_tpl = """
-def %(name)s(*a,**kw):
-    return nt.%(name)s(*a,**kw)
-"""
-
-if has_nose:
-    for _x in [a for a in dir(nt) if a.startswith('assert')]:
-        exec _tpl % dict(name=_x)
-
-#-----------------------------------------------------------------------------
-# Functions and classes
-#-----------------------------------------------------------------------------
 
 # The docstring for full_path doctests differently on win32 (different path
 # separator) so just skip the doctest there.  The example remains informative.
-doctest_deco = dec.skip_doctest if sys.platform == 'win32' else dec.null_deco
+doctest_deco = skipdoctest.skip_doctest if sys.platform == 'win32' else dec.null_deco
 
 @doctest_deco
-def full_path(startPath,files):
+def full_path(startPath: str, files: list[str]) -> list[str]:
     """Make full paths for all the listed files, based on startPath.
 
     Only the base part of startPath is kept, since this routine is typically
-    used with a script's __file__ variable as startPath.  The base of startPath
+    used with a script's ``__file__`` variable as startPath. The base of startPath
     is then prepended to all the listed files, forming the output list.
 
     Parameters
     ----------
-      startPath : string
-        Initial path to use as the base for the results.  This path is split
+    startPath : string
+      Initial path to use as the base for the results.  This path is split
       using os.path.split() and only its first component is kept.
 
-      files : string or list
-        One or more files.
+    files : list
+      One or more files.
 
     Examples
     --------
@@ -98,12 +61,8 @@ def full_path(startPath,files):
     >>> full_path('/foo',['a.txt','b.txt'])
     ['/a.txt', '/b.txt']
 
-    If a single file is given, the output is still a list:
-    >>> full_path('/foo','a.txt')
-    ['/a.txt']
     """
-
-    files = list_strings(files)
+    assert isinstance(files, list)
     base = os.path.split(startPath)[0]
     return [ os.path.join(base,f) for f in files ]
 
@@ -116,13 +75,15 @@ def parse_test_output(txt):
     txt : str
       Text output of a test run, assumed to contain a line of one of the
       following forms::
+
         'FAILED (errors=1)'
         'FAILED (failures=1)'
         'FAILED (errors=1, failures=1)'
 
     Returns
     -------
-    nerr, nfail: number of errors and failures.
+    nerr, nfail
+      number of errors and failures.
     """
 
     err_m = re.search(r'^FAILED \(errors=(\d+)\)', txt, re.MULTILINE)
@@ -130,7 +91,7 @@ def parse_test_output(txt):
         nerr = int(err_m.group(1))
         nfail = 0
         return  nerr, nfail
-    
+
     fail_m = re.search(r'^FAILED \(failures=(\d+)\)', txt, re.MULTILINE)
     if fail_m:
         nerr = 0
@@ -143,7 +104,7 @@ def parse_test_output(txt):
         nerr = int(both_m.group(1))
         nfail = int(both_m.group(2))
         return  nerr, nfail
-    
+
     # If the input didn't match any of these forms, assume no error/failures
     return 0, 0
 
@@ -155,63 +116,107 @@ def parse_test_output(txt):
 def default_argv():
     """Return a valid default argv for creating testing instances of ipython"""
 
-    return ['--quick', # so no config file is loaded
-            # Other defaults to minimize side effects on stdout
-            '--colors=NoColor', '--no-term-title','--no-banner',
-            '--autocall=0']
+    return [
+        "--quick",  # so no config file is loaded
+        # Other defaults to minimize side effects on stdout
+        "--colors=nocolor",
+        "--no-term-title",
+        "--no-banner",
+        "--autocall=0",
+    ]
 
 
 def default_config():
     """Return a config object with good defaults for testing."""
     config = Config()
-    config.TerminalInteractiveShell.colors = 'NoColor'
-    config.TerminalTerminalInteractiveShell.term_title = False,
+    config.TerminalInteractiveShell.colors = "nocolor"
+    config.TerminalTerminalInteractiveShell.term_title = (False,)
     config.TerminalInteractiveShell.autocall = 0
-    config.HistoryManager.hist_file = u'test_hist.sqlite'
+    f = tempfile.NamedTemporaryFile(suffix="test_hist.sqlite", delete=False)
+    config.HistoryManager.hist_file = Path(f.name)
+    f.close()
     config.HistoryManager.db_cache_size = 10000
     return config
 
 
-def ipexec(fname, options=None):
+def get_ipython_cmd(as_string=False):
+    """
+    Return appropriate IPython command line name. By default, this will return
+    a list that can be used with subprocess.Popen, for example, but passing
+    `as_string=True` allows for returning the IPython command as a string.
+
+    Parameters
+    ----------
+    as_string: bool
+        Flag to allow to return the command as a string.
+    """
+    ipython_cmd = [sys.executable, "-m", "IPython"]
+
+    if as_string:
+        ipython_cmd = " ".join(ipython_cmd)
+
+    return ipython_cmd
+
+def ipexec(fname, options=None, commands=()):
     """Utility to call 'ipython filename'.
 
-    Starts IPython witha minimal and safe configuration to make startup as fast
+    Starts IPython with a minimal and safe configuration to make startup as fast
     as possible.
 
     Note that this starts IPython in a subprocess!
 
     Parameters
     ----------
-    fname : str
+    fname : str, Path
       Name of file to be executed (should have .py or .ipy extension).
 
     options : optional, list
       Extra command-line flags to be passed to IPython.
 
+    commands : optional, list
+      Commands to send in on stdin
+
     Returns
     -------
-    (stdout, stderr) of ipython subprocess.
+    ``(stdout, stderr)`` of ipython subprocess.
     """
-    if options is None: options = []
-    
-    # For these subprocess calls, eliminate all prompt printing so we only see
-    # output from script execution
-    prompt_opts = ['--prompt-in1=""', '--prompt-in2=""', '--prompt-out=""']
-    cmdargs = ' '.join(default_argv() + prompt_opts + options)
-    
-    _ip = get_ipython()
+    __tracebackhide__ = True
+
+    if options is None:
+        options = []
+
+    cmdargs = default_argv() + options
+
     test_dir = os.path.dirname(__file__)
 
-    ipython_cmd = find_cmd('ipython')
+    ipython_cmd = get_ipython_cmd()
     # Absolute path for filename
     full_fname = os.path.join(test_dir, fname)
-    full_cmd = '%s %s %s' % (ipython_cmd, cmdargs, full_fname)
-    #print >> sys.stderr, 'FULL CMD:', full_cmd # dbg
-    return getoutputerror(full_cmd)
+    full_cmd = ipython_cmd + cmdargs + ['--', full_fname]
+    env = os.environ.copy()
+    # FIXME: ignore all warnings in ipexec while we have shims
+    # should we keep suppressing warnings here, even after removing shims?
+    env['PYTHONWARNINGS'] = 'ignore'
+    # env.pop('PYTHONWARNINGS', None)  # Avoid extraneous warnings appearing on stderr
+    # Prevent coloring under PyCharm ("\x1b[0m" at the end of the stdout)
+    env.pop("PYCHARM_HOSTED", None)
+    for k, v in env.items():
+        # Debug a bizarre failure we've seen on Windows:
+        # TypeError: environment can only contain strings
+        if not isinstance(v, str):
+            print(k, v)
+    p = Popen(full_cmd, stdout=PIPE, stderr=PIPE, stdin=PIPE, env=env)
+    out, err = p.communicate(input=py3compat.encode('\n'.join(commands)) or None)
+    out, err = py3compat.decode(out), py3compat.decode(err)
+    # `import readline` causes 'ESC[?1034h' to be output sometimes,
+    # so strip that out before doing comparisons
+    if out:
+        out = re.sub(r'\x1b\[[^h]+h', '', out)
+    return out, err
 
 
 def ipexec_validate(fname, expected_out, expected_err='',
-                    options=None):
+                    options=None, commands=()):
     """Utility to call 'ipython filename' and validate output/error.
 
     This function raises an AssertionError if the validation fails.
@@ -220,7 +225,7 @@ def ipexec_validate(fname, expected_out, expected_err='',
 
     Parameters
     ----------
-    fname : str
+    fname : str, Path
       Name of the file to be executed (should have .py or .ipy extension).
 
     expected_out : str
@@ -236,44 +241,194 @@ def ipexec_validate(fname, expected_out, expected_err='',
     -------
     None
     """
+    __tracebackhide__ = True
 
-    import nose.tools as nt
-    
-    out, err = ipexec(fname)
-    #print 'OUT', out  # dbg
-    #print 'ERR', err  # dbg
-    # If there are any errors, we must check those befor stdout, as they may be
+    out, err = ipexec(fname, options, commands)
+    # print('OUT', out)  # dbg
+    # print('ERR', err)  # dbg
+    # If there are any errors, we must check those before stdout, as they may be
     # more informative than simply having an empty stdout.
     if err:
         if expected_err:
-            nt.assert_equals(err.strip(), expected_err.strip())
+            assert "\n".join(err.strip().splitlines()) == "\n".join(
+                expected_err.strip().splitlines()
+            )
         else:
             raise ValueError('Running file %r produced error: %r' %
                              (fname, err))
     # If no errors or output on stderr was expected, match stdout
-    nt.assert_equals(out.strip(), expected_out.strip())
+    assert "\n".join(out.strip().splitlines()) == "\n".join(
+        expected_out.strip().splitlines()
+    )
 
 
-class TempFileMixin(object):
+class TempFileMixin(unittest.TestCase):
     """Utility class to create temporary Python/IPython files.
 
     Meant as a mixin class for test cases."""
-    
+
     def mktmp(self, src, ext='.py'):
         """Make a valid python temp file."""
-        fname, f = temp_pyfile(src, ext)
-        self.tmpfile = f
+        fname = temp_pyfile(src, ext)
+        if not hasattr(self, 'tmps'):
+            self.tmps=[]
+        self.tmps.append(fname)
         self.fname = fname
 
     def tearDown(self):
-        if hasattr(self, 'tmpfile'):
-            # If the tmpfile wasn't made because of skipped tests, like in
-            # win32, there's nothing to cleanup.
-            self.tmpfile.close()
-            try:
-                os.unlink(self.fname)
-            except:
-                # On Windows, even though we close the file, we still can't
-                # delete it.  I have no clue why
-                pass
+        # If the tmpfile wasn't made because of skipped tests, like in
+        # win32, there's nothing to cleanup.
+        if hasattr(self, 'tmps'):
+            for fname in self.tmps:
+                # If the tmpfile wasn't made because of skipped tests, like in
+                # win32, there's nothing to cleanup.
+                try:
+                    os.unlink(fname)
+                except:
+                    # On Windows, even though we close the file, we still can't
+                    # delete it.  I have no clue why
+                    pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.tearDown()
+
+
+MyStringIO = StringIO
+
+_re_type = type(re.compile(r''))
+
+notprinted_msg = """Did not find {0!r} in printed output (on {1}):
+-------
+{2!s}
+-------
+"""
+
+class AssertPrints:
+    """Context manager for testing that code prints certain text.
+
+    Examples
+    --------
+    >>> with AssertPrints("abc", suppress=False):
+    ...     print("abcd")
+    ...     print("def")
+    ...
+    abcd
+    def
+    """
+    def __init__(self, s, channel='stdout', suppress=True):
+        self.s = s
+        if isinstance(self.s, (str, _re_type)):
+            self.s = [self.s]
+        self.channel = channel
+        self.suppress = suppress
+
+    def __enter__(self):
+        self.orig_stream = getattr(sys, self.channel)
+        self.buffer = MyStringIO()
+        self.tee = Tee(self.buffer, channel=self.channel)
+        setattr(sys, self.channel, self.buffer if self.suppress else self.tee)
+
+    def __exit__(self, etype, value, traceback):
+        __tracebackhide__ = True
+
+        try:
+            if value is not None:
+                # If an error was raised, don't check anything else
+                return False
+            self.tee.flush()
+            setattr(sys, self.channel, self.orig_stream)
+            printed = self.buffer.getvalue()
+            for s in self.s:
+                if isinstance(s, _re_type):
+                    assert s.search(printed), notprinted_msg.format(s.pattern, self.channel, printed)
+                else:
+                    assert s in printed, notprinted_msg.format(s, self.channel, printed)
+            return False
+        finally:
+            self.tee.close()
+
+printed_msg = """Found {0!r} in printed output (on {1}):
+-------
+{2!s}
+-------
+"""
+
+class AssertNotPrints(AssertPrints):
+    """Context manager for checking that certain output *isn't* produced.
+
+    Counterpart of AssertPrints"""
+    def __exit__(self, etype, value, traceback):
+        __tracebackhide__ = True
+
+        try:
+            if value is not None:
+                # If an error was raised, don't check anything else
+                self.tee.close()
+                return False
+            self.tee.flush()
+            setattr(sys, self.channel, self.orig_stream)
+            printed = self.buffer.getvalue()
+            for s in self.s:
+                if isinstance(s, _re_type):
+                    assert not s.search(printed),printed_msg.format(
+                        s.pattern, self.channel, printed)
+                else:
+                    assert s not in printed, printed_msg.format(
+                        s, self.channel, printed)
+            return False
+        finally:
+            self.tee.close()
+
+@contextmanager
+def make_tempfile(name):
+    """Create an empty, named, temporary file for the duration of the context."""
+    open(name, "w", encoding="utf-8").close()
+    try:
+        yield
+    finally:
+        os.unlink(name)
+
+def fake_input(inputs):
+    """Temporarily replace the input() function to return the given values
+
+    Use as a context manager:
+
+    with fake_input(['result1', 'result2']):
+        ...
+
+    Values are returned in order. If input() is called again after the last value
+    was used, EOFError is raised.
+    """
+    it = iter(inputs)
+    def mock_input(prompt=''):
+        try:
+            return next(it)
+        except StopIteration as e:
+            raise EOFError('No more inputs given') from e
+
+    return patch('builtins.input', mock_input)
+
+def help_output_test(subcommand=''):
+    """test that `ipython [subcommand] -h` works"""
+    cmd = get_ipython_cmd() + [subcommand, '-h']
+    out, err, rc = get_output_error_code(cmd)
+    assert rc == 0, err
+    assert "Traceback" not in err
+    assert "Options" in out
+    assert "--help-all" in out
+    return out, err
+
+
+def help_all_output_test(subcommand=''):
+    """test that `ipython [subcommand] --help-all` works"""
+    cmd = get_ipython_cmd() + [subcommand, '--help-all']
+    out, err, rc = get_output_error_code(cmd)
+    assert rc == 0, err
+    assert "Traceback" not in err
+    assert "Options" in out
+    assert "Class" in out
+    return out, err
 
diff --git a/IPython/utils/PyColorize.py b/IPython/utils/PyColorize.py
index ddf3f7a975a..76415d01b02 100644
--- a/IPython/utils/PyColorize.py
+++ b/IPython/utils/PyColorize.py
@@ -1,303 +1,577 @@
-# -*- coding: utf-8 -*-
-"""
-Class and program to colorize python source code for ANSI terminals.
+import keyword
+import os
+import sys
+import token
+import tokenize
+import warnings
+from io import StringIO
+from typing import Any, Type, TypeAlias
 
-Based on an HTML code highlighter by Jurgen Hermann found at:
-http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52298
+import pygments
+from pygments.formatters.terminal256 import Terminal256Formatter
+from pygments.style import Style
+from pygments.styles import get_style_by_name
+from pygments.token import Token, _TokenType
+from functools import cache
 
-Modifications by Fernando Perez (fperez@colorado.edu).
+from typing import TypedDict
 
-Information on the original HTML highlighter follows:
 
-MoinMoin - Python Source Parser
+TokenStream: TypeAlias = list[tuple[_TokenType, str]]
 
-Title: Colorize Python source using the built-in tokenizer
 
-Submitter: Jurgen Hermann
-Last Updated:2001/04/06
+__all__ = ["Parser", "Theme"]
 
-Version no:1.2
 
-Description:
+class Symbols(TypedDict):
+    top_line: str
+    arrow_body: str
+    arrow_head: str
 
-This code is part of MoinMoin (http://moin.sourceforge.net/) and converts
-Python source code to HTML markup, rendering comments, keywords,
-operators, numeric and string literals in different colors.
 
-It shows how to use the built-in keyword, token and tokenize modules to
-scan Python source code and re-emit it with no changes to its original
-formatting (which is the hard part).
-"""
+_default_symbols: Symbols = Symbols(
+    top_line="-",
+    arrow_body="-",
+    arrow_head=">",
+)
 
-__all__ = ['ANSICodeColors','Parser']
 
-_scheme_default = 'Linux'
+class Theme:
+    name: str
+    base: str | None
+    extra_style: dict[_TokenType, str]
+    symbols: Symbols
 
-# Imports
-import cStringIO
-import keyword
-import os
-import optparse
-import sys
-import token
-import tokenize
+    def __init__(
+        self,
+        name: str,
+        base: str | None,
+        extra_style: dict[_TokenType, str],
+        *,
+        symbols: Symbols | None = None,
+    ) -> None:
+        self.name = name
+        self.base = base
+        self.extra_style = extra_style
+        s: Symbols = symbols if symbols is not None else _default_symbols
+        self.symbols = {**_default_symbols, **s}
+        self._formatter = Terminal256Formatter(style=self.as_pygments_style())
+
+    @cache
+    def as_pygments_style(self) -> Type[Style]:
+        if self.base is not None:
+            base_styles = get_style_by_name(self.base).styles
+        else:
+            base_styles = {}
+
+        class MyStyle(Style):
+            styles = {**base_styles, **self.extra_style}
+
+        return MyStyle
+
+    def format(self, stream: TokenStream) -> str:
+        return pygments.format(stream, self._formatter)
+
+    def make_arrow(self, width: int) -> str:
+        """generate the leading arrow in front of traceback or debugger"""
+        if width >= 2:
+            return (
+                self.symbols["arrow_body"] * (width - 2)
+                + self.symbols["arrow_head"]
+                + " "
+            )
+        elif width == 1:
+            return self.symbols["arrow_head"]
+        return ""
+
+
+generate_tokens = tokenize.generate_tokens
 
-from IPython.utils.coloransi import *
 
 #############################################################################
-### Python Source Parser (does Hilighting)
+### Python Source Parser (does Highlighting)
 #############################################################################
 
 _KEYWORD = token.NT_OFFSET + 1
-_TEXT    = token.NT_OFFSET + 2
-
-#****************************************************************************
-# Builtin color schemes
-
-Colors = TermColors  # just a shorthand
-
-# Build a few color schemes
-NoColor = ColorScheme(
-    'NoColor',{
-    token.NUMBER     : Colors.NoColor,
-    token.OP         : Colors.NoColor,
-    token.STRING     : Colors.NoColor,
-    tokenize.COMMENT : Colors.NoColor,
-    token.NAME       : Colors.NoColor,
-    token.ERRORTOKEN : Colors.NoColor,
-
-    _KEYWORD         : Colors.NoColor,
-    _TEXT            : Colors.NoColor,
-
-    'normal'         : Colors.NoColor  # color off (usu. Colors.Normal)
-    }  )
-
-LinuxColors = ColorScheme(
-    'Linux',{
-    token.NUMBER     : Colors.LightCyan,
-    token.OP         : Colors.Yellow,
-    token.STRING     : Colors.LightBlue,
-    tokenize.COMMENT : Colors.LightRed,
-    token.NAME       : Colors.White,
-    token.ERRORTOKEN : Colors.Red,
-
-    _KEYWORD         : Colors.LightGreen,
-    _TEXT            : Colors.Yellow,
-
-    'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
-    } )
-
-LightBGColors = ColorScheme(
-    'LightBG',{
-    token.NUMBER     : Colors.Cyan,
-    token.OP         : Colors.Blue,
-    token.STRING     : Colors.Blue,
-    tokenize.COMMENT : Colors.Red,
-    token.NAME       : Colors.Black,
-    token.ERRORTOKEN : Colors.Red,
-
-    _KEYWORD         : Colors.Green,
-    _TEXT            : Colors.Blue,
-
-    'normal'         : Colors.Normal  # color off (usu. Colors.Normal)
-    }  )
-
-# Build table of color schemes (needed by the parser)
-ANSICodeColors = ColorSchemeTable([NoColor,LinuxColors,LightBGColors],
-                                  _scheme_default)
+_TEXT = token.NT_OFFSET + 2
+
+# ****************************************************************************
+
+_pygment_token_mapping: dict[int, _TokenType] = {
+    token.NUMBER: Token.Literal.Number,
+    token.OP: Token.Operator,
+    token.STRING: Token.Literal.String,
+    token.COMMENT: Token.Comment,
+    token.NAME: Token.Name,
+    token.ERRORTOKEN: Token.Error,
+    _KEYWORD: Token.Keyword,
+    _TEXT: Token.Text,
+}
+
+# technically BW is not nocolor, we should have a no-style, style
+nocolors_theme = Theme("nocolor", None, {})
+
+
+linux_theme = Theme(
+    "linux",
+    "monokai",
+    {
+        Token.Header: "ansibrightred",
+        Token.LinenoEm: "ansibrightgreen",
+        Token.Lineno: "ansigreen",
+        Token.ValEm: "ansibrightblue",
+        Token.VName: "ansicyan",
+        Token.Caret: "",
+        Token.Filename: "ansibrightgreen",
+        Token.ExcName: "ansibrightred",
+        Token.Topline: "ansibrightred",
+        Token.FilenameEm: "ansigreen",
+        Token.Normal: "",
+        Token.NormalEm: "ansibrightcyan",
+        Token.Line: "ansiyellow",
+        Token.TB.Name: "ansimagenta",
+        Token.TB.NameEm: "ansibrightmagenta",
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: "ansibrightred",
+        Token.Breakpoint.Disabled: "ansired",
+        Token.Prompt: "ansibrightgreen",
+        Token.PromptNum: "ansigreen bold",
+        Token.OutPrompt: "ansibrightred",
+        Token.OutPromptNum: "ansired bold",
+    },
+)
+
+neutral_pygments_equiv = {
+    Token.Header: "ansired",
+    Token.LinenoEm: "ansigreen",
+    Token.Lineno: "ansibrightgreen",
+    Token.ValEm: "ansiblue",
+    Token.VName: "ansicyan",
+    Token.Caret: "",
+    Token.Filename: "ansibrightgreen",
+    Token.FilenameEm: "ansigreen",
+    Token.ExcName: "ansired",
+    Token.Topline: "ansired",
+    Token.Normal: "",
+    Token.NormalEm: "ansicyan",
+    Token.Line: "ansired",
+    Token.TB.Name: "ansibrightmagenta",
+    Token.TB.NameEm: "ansimagenta",
+    Token.Breakpoint: "",
+    Token.Breakpoint.Enabled: "ansibrightred",
+    Token.Breakpoint.Disabled: "ansired",
+    ## specific override of pygments defaults for visibility
+    Token.Number: "ansigreen",
+    Token.Operator: "noinherit",
+    Token.String: "ansiyellow",
+    Token.Name.Function: "ansiblue",
+    Token.Name.Class: "bold ansiblue",
+    Token.Name.Namespace: "bold ansiblue",
+    Token.Name.Variable.Magic: "ansiblue",
+    Token.Prompt: "ansigreen",
+    Token.OutPrompt: "ansired",
+}
+
+
+neutral_pygments_nt = {
+    **neutral_pygments_equiv,
+    Token.PromptNum: "ansigreen bold",
+    Token.OutPromptNum: "ansired bold",
+}
+neutral_pygments_posix = {
+    **neutral_pygments_equiv,
+    Token.PromptNum: "ansibrightgreen bold",
+    Token.OutPromptNum: "ansibrightred bold",
+}
+
+
+neutral_nt = Theme("neutral:nt", "default", neutral_pygments_nt)
+neutral_posix = Theme("neutral:posix", "default", neutral_pygments_posix)
+
+
+# Hack: the 'neutral' colours are not very visible on a dark background on
+# Windows. Since Windows command prompts have a dark background by default, and
+# relatively few users are likely to alter that, we will use the 'Linux' colours,
+# designed for a dark background, as the default on Windows. Changing it here
+# avoids affecting the prompt colours rendered by prompt_toolkit, where the
+# neutral defaults do work OK.
+if os.name == "nt":
+    neutral_theme = neutral_nt
+else:
+    neutral_theme = neutral_posix
+
+
+lightbg_theme = Theme(
+    "lightbg",
+    "pastie",
+    {
+        Token.Header: "ansired",
+        Token.LinenoEm: "ansigreen",
+        Token.Lineno: "ansibrightgreen",
+        Token.ValEm: "ansiblue",
+        Token.VName: "ansicyan",
+        Token.Caret: "",
+        Token.Filename: "ansigreen",
+        Token.FilenameEm: "ansibrightgreen",
+        Token.ExcName: "ansired",
+        Token.Topline: "ansired",
+        Token.Normal: "",
+        Token.NormalEm: "ansicyan",
+        Token.Line: "ansired",
+        Token.TB.Name: "ansibrightmagenta",
+        Token.TB.NameEm: "ansimagenta",
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: "ansibrightred",
+        Token.Breakpoint.Disabled: "ansired",
+        Token.Prompt: "ansibrightblue",
+        Token.PromptNum: "ansiblue bold",
+        Token.OutPrompt: "ansibrightred",
+        Token.OutPromptNum: "ansired bold",
+    },
+)
+
+PRIDE_RED = "#E40303"
+PRIDE_ORANGE = "#FF8C00"
+PRIDE_YELLOW = "#FFED00"
+PRIDE_GREEN = "#008026"
+PRIDE_INDIGO = "#004CFF"
+PRIDE_VIOLET = "#732982"
+pride_theme = Theme(
+    "pride",
+    "pastie",
+    {
+        Token.Header: PRIDE_INDIGO,
+        Token.LinenoEm: f"{PRIDE_GREEN} italic",
+        Token.Lineno: f"{PRIDE_GREEN} bold",
+        Token.ValEm: f"{PRIDE_INDIGO} italic",
+        Token.VName: "ansicyan",
+        Token.Caret: "",
+        Token.Filename: f"{PRIDE_YELLOW}",
+        Token.FilenameEm: f"bg:{PRIDE_VIOLET}",
+        Token.ExcName: f"{PRIDE_ORANGE}",
+        Token.Topline: f"{PRIDE_RED}",
+        Token.Normal: "",
+        Token.NormalEm: "bold",
+        Token.Line: "ansired",
+        Token.TB.Name: "ansibrightmagenta",
+        Token.TB.NameEm: "ansimagenta",
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: "ansibrightred",
+        Token.Breakpoint.Disabled: "ansired",
+        Token.Prompt: "ansibrightblue",
+        Token.Prompt.Continuation.L1: f"ansiwhite bg:{PRIDE_RED}",
+        Token.Prompt.Continuation.L2: f"ansiwhite bg:{PRIDE_ORANGE}",
+        Token.Prompt.Continuation.L3: f"ansiblack bg:{PRIDE_YELLOW}",
+        Token.Prompt.Continuation.L4: f"ansiwhite bg:{PRIDE_GREEN}",
+        Token.Prompt.Continuation.L5: f"ansiwhite bg:{PRIDE_INDIGO}",
+        Token.Prompt.Continuation.L6: f"ansiwhite bg:{PRIDE_VIOLET}",
+        Token.PromptNum: "ansiblue bold",
+        Token.OutPrompt: "ansibrightred",
+        Token.OutPromptNum: "ansired bold",
+    },
+    symbols={"arrow_body": "\u2500", "arrow_head": "\u25b6", "top_line": "\u2500"},
+)
+
+
+C1 = "#D52D00"
+C2 = "#EF7627"
+C3 = "#FF9A56"
+White = "#FFFFFF"
+C5 = "#D162A4"
+C6 = "#B55690"
+C7 = "#A30262"
+
+pl = {
+    # Token.Whitespace: "#bbbbbb",
+    Token.Comment: "#888888",
+    Token.String: C5,
+    Token.String.Escape: C1,
+    Token.Keyword: f"italic {C2}",
+    Token.Name.Class: C2,
+    Token.Name.Exception: C1,
+    Token.Name.Builtin: C3,
+    Token.Name.Variable: C6,
+    Token.Name.Constant: C7,
+    Token.Name.Decorator: C2,
+    Token.Number: C7,
+    Token.Generic.Deleted: f"bg:{C1} #000000",
+    Token.Generic.Emph: "italic",
+    Token.Generic.Strong: "bold",
+    Token.Generic.EmphStrong: "bold italic",
+}
+
+pridel_theme = Theme(
+    "pride:l",
+    None,
+    {
+        Token.Header: C3,
+        Token.LinenoEm: C3,
+        Token.Lineno: C2,
+        Token.ValEm: C2,
+        Token.VName: C2,
+        Token.Caret: "",
+        Token.Filename: C2,
+        Token.FilenameEm: C3,
+        Token.ExcName: C1,
+        Token.Topline: C1,
+        Token.Normal: "",
+        Token.NormalEm: "bold",
+        Token.Line: C2,
+        Token.TB.Name: C6,
+        Token.TB.NameEm: C7,
+        Token.Breakpoint: "",
+        Token.Breakpoint.Enabled: C1,
+        Token.Breakpoint.Disabled: C7,
+        Token.Prompt: C1,
+        Token.PromptNum: C2,
+        Token.Prompt.Continuation: C7,
+        Token.Prompt.Continuation.L1: C2,
+        Token.Prompt.Continuation.L2: C3,
+        Token.Prompt.Continuation.L3: White,
+        Token.Prompt.Continuation.L4: C5,
+        Token.Prompt.Continuation.L5: C6,
+        Token.Prompt.Continuation.L6: C7,
+        Token.OutPrompt: C6,
+        Token.OutPromptNum: C5,
+        **pl,
+    },
+    symbols={"arrow_body": "\u2500", "arrow_head": "\u25b6", "top_line": "\u2500"},
+)
+
+GRUVBOX_VAL_EM = "#D79921"
+GRUVBOX_V_NAME = "#83A598"
+GRUVBOX_FILENAME = "#FBF1C7"
+GRUVBOX_EXCEPTION_NAME = "#FB4934"
+GRUVBOX_TOPLINE = "#CC241D"
+GRUVBOX_BREAKPOINT_ENABLED = "#FB4934"
+GRUVBOX_BREAKPOINT_DISABLED = "#CC241D"
+GRUVBOX_PROMPT = "#689D6A"
+GRUVBOX_PROMPT_NUM = "#8EC07C"
+GRUVBOX_OUT_PROMPT = "#B16286"
+GRUVBOX_OUT_PROMPT_NUM = "#D3869B"
+gruvbox_dark_theme = Theme(
+    "gruvbox-dark",
+    "gruvbox-dark",
+    {
+        Token.Lineno: GRUVBOX_PROMPT_NUM,
+        Token.LinenoEm: f"{GRUVBOX_PROMPT_NUM} bold",
+        Token.ValEm: f"{GRUVBOX_VAL_EM} bold",
+        Token.VName: GRUVBOX_V_NAME,
+        Token.Caret: "",
+        Token.Filename: GRUVBOX_FILENAME,
+        Token.FilenameEm: f"{GRUVBOX_FILENAME} bold",
+        Token.ExcName: f"{GRUVBOX_EXCEPTION_NAME} bold",
+        Token.Topline: GRUVBOX_TOPLINE,
+        Token.Breakpoint.Enabled: GRUVBOX_BREAKPOINT_ENABLED,
+        Token.Breakpoint.Disabled: GRUVBOX_BREAKPOINT_DISABLED,
+        Token.Prompt: GRUVBOX_PROMPT,
+        Token.PromptNum: f"{GRUVBOX_PROMPT_NUM} bold",
+        Token.OutPrompt: GRUVBOX_OUT_PROMPT,
+        Token.OutPromptNum: f"{GRUVBOX_OUT_PROMPT_NUM} bold",
+    },
+    symbols={"arrow_body": "\u2500", "arrow_head": "\u25b6", "top_line": "\u2500"},
+)
+
+theme_table: dict[str, Theme] = {
+    "nocolor": nocolors_theme,
+    "linux": linux_theme,
+    "neutral": neutral_theme,
+    "neutral:nt": neutral_nt,
+    "neutral:posix": neutral_posix,
+    "lightbg": lightbg_theme,
+    "pride": pride_theme,
+    "pride:l": pridel_theme,
+    "gruvbox-dark": gruvbox_dark_theme,
+}
+
 
 class Parser:
-    """ Format colored Python source.
-    """
+    """Format colored Python source."""
 
-    def __init__(self, color_table=None,out = sys.stdout):
-        """ Create a parser with a specified color table and output channel.
+    _theme_name: str
+    out: Any
+    pos: int
+    lines: list[int]
+    raw: str
+
+    def __init__(self, out: Any = sys.stdout, *, theme_name: str | None = None) -> None:
+        """Create a parser with a specified color table and output channel.
 
         Call format() to process code.
         """
-        self.color_table = color_table and color_table or ANSICodeColors
-        self.out = out
-
-    def format(self, raw, out = None, scheme = ''):
-        return self.format2(raw, out, scheme)[0]
 
-    def format2(self, raw, out = None, scheme = ''):
-        """ Parse and send the colored source.
+        assert theme_name is not None
 
-        If out and scheme are not specified, the defaults (given to
-        constructor) are used.
+        self.out = out
+        self.pos = 0
+        self.lines = []
+        self.raw = ""
+        if theme_name is not None:
+            if theme_name in ["Linux", "LightBG", "Neutral", "NoColor"]:
+                warnings.warn(
+                    f"Theme names and color schemes are lowercase in IPython 9.0 use {theme_name.lower()} instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                theme_name = theme_name.lower()
+        if not theme_name:
+            self.theme_name = "nocolor"
+        else:
+            self.theme_name = theme_name
+
+    @property
+    def theme_name(self) -> str:
+        return self._theme_name
+
+    @theme_name.setter
+    def theme_name(self, value: str) -> None:
+        assert value == value.lower()
+        self._theme_name = value
+
+    @property
+    def style(self) -> str:
+        assert False
+        return self._theme_name
+
+    @style.setter
+    def style(self, val: str) -> None:
+        assert False
+        assert val == val.lower()
+        self._theme_name = val
+
+    def format(self, raw: str, out: Any = None) -> str | None:
+        return self.format2(raw, out)[0]
+
+    def format2(self, raw: str, out: Any = None) -> tuple[str | None, bool]:
+        """Parse and send the colored source.
+
+        If out is not specified, the defaults (given to constructor) are used.
 
         out should be a file-type object. Optionally, out can be given as the
         string 'str' and the parser will automatically return the output in a
         string."""
-        
+
         string_output = 0
-        if out == 'str' or self.out == 'str' or \
-           isinstance(self.out,cStringIO.OutputType):
+        if out == "str" or self.out == "str" or isinstance(self.out, StringIO):
             # XXX - I don't really like this state handling logic, but at this
             # point I don't want to make major changes, so adding the
             # isinstance() check is the simplest I can do to ensure correct
             # behavior.
             out_old = self.out
-            self.out = cStringIO.StringIO()
+            self.out = StringIO()
             string_output = 1
         elif out is not None:
             self.out = out
-
-        # Fast return of the unmodified input for NoColor scheme
-        if scheme == 'NoColor':
+        else:
+            raise ValueError(
+                '`out` or `self.out` should be file-like or the value `"str"`'
+            )
+
+        # Fast return of the unmodified input for nocolor scheme
+        # TODO:
+        if self.theme_name == "nocolor":
             error = False
             self.out.write(raw)
             if string_output:
-                return raw,error
-            else:
-                return None,error
-        
+                return raw, error
+            return None, error
+
         # local shorthands
-        colors = self.color_table[scheme].colors
-        self.colors = colors # put in object so __call__ sees it
 
         # Remove trailing whitespace and normalize tabs
         self.raw = raw.expandtabs().rstrip()
-        
+
         # store line offsets in self.lines
         self.lines = [0, 0]
         pos = 0
         raw_find = self.raw.find
         lines_append = self.lines.append
-        while 1:
-            pos = raw_find('\n', pos) + 1
-            if not pos: break
+        while True:
+            pos = raw_find("\n", pos) + 1
+            if not pos:
+                break
             lines_append(pos)
         lines_append(len(self.raw))
 
         # parse the source and write it
         self.pos = 0
-        text = cStringIO.StringIO(self.raw)
+        text = StringIO(self.raw)
 
         error = False
         try:
-            tokenize.tokenize(text.readline, self)
-        except tokenize.TokenError, ex:
-            msg = ex[0]
-            line = ex[1][0]
-            self.out.write("%s\n\n*** ERROR: %s%s%s\n" %
-                           (colors[token.ERRORTOKEN],
-                            msg, self.raw[self.lines[line]:],
-                            colors.normal)
-                           )
+            for atoken in generate_tokens(text.readline):
+                self(*atoken)
+        except tokenize.TokenError as ex:
+            msg = ex.args[0]
+            line = ex.args[1][0]
+            self.out.write(
+                theme_table[self.theme_name].format(
+                    [
+                        (Token, "\n\n"),
+                        (
+                            Token.Error,
+                            f"*** ERROR: {msg}{self.raw[self.lines[line] :]}",
+                        ),
+                        (Token, "\n"),
+                    ]
+                )
+            )
             error = True
-        self.out.write(colors.normal+'\n')
+        self.out.write(
+            theme_table[self.theme_name].format(
+                [
+                    (Token, "\n"),
+                ]
+            )
+        )
+
         if string_output:
             output = self.out.getvalue()
             self.out = out_old
             return (output, error)
         return (None, error)
 
-    def __call__(self, toktype, toktext, (srow,scol), (erow,ecol), line):
-        """ Token handler, with syntax highlighting."""
-
-        # local shorthands
-        colors = self.colors
-        owrite = self.out.write
-
-        # line separator, so this works across platforms
-        linesep = os.linesep
+    def _inner_call_(
+        self, toktype: int, toktext: str, start_pos: tuple[int, int]
+    ) -> str:
+        """like call but write to a temporary buffer"""
+        srow, scol = start_pos
 
         # calculate new positions
         oldpos = self.pos
         newpos = self.lines[srow] + scol
         self.pos = newpos + len(toktext)
 
-        # handle newlines
-        if toktype in [token.NEWLINE, tokenize.NL]:
-            owrite(linesep)
-            return
-
         # send the original whitespace, if needed
         if newpos > oldpos:
-            owrite(self.raw[oldpos:newpos])
+            acc = self.raw[oldpos:newpos]
+        else:
+            acc = ""
 
         # skip indenting tokens
         if toktype in [token.INDENT, token.DEDENT]:
             self.pos = newpos
-            return
+            return acc
 
         # map token type to a color group
-        if token.LPAR <= toktype and toktype <= token.OP:
+        if token.LPAR <= toktype <= token.OP:
             toktype = token.OP
         elif toktype == token.NAME and keyword.iskeyword(toktext):
             toktype = _KEYWORD
-        color = colors.get(toktype, colors[_TEXT])
-
-        #print '<%s>' % toktext,    # dbg
-
-        # Triple quoted strings must be handled carefully so that backtracking
-        # in pagers works correctly. We need color terminators on _each_ line.
-        if linesep in toktext:
-            toktext = toktext.replace(linesep, '%s%s%s' %
-                                      (colors.normal,linesep,color))
-
-        # send text
-        owrite('%s%s%s' % (color,toktext,colors.normal))
-            
-def main(argv=None):
-    """Run as a command-line script: colorize a python file or stdin using ANSI
-    color escapes and print to stdout.
-
-    Inputs:
-
-      - argv(None): a list of strings like sys.argv[1:] giving the command-line
-        arguments. If None, use sys.argv[1:].
-    """
-
-    usage_msg = """%prog [options] [filename]
-
-Colorize a python file or stdin using ANSI color escapes and print to stdout.
-If no filename is given, or if filename is -, read standard input."""
-
-    parser = optparse.OptionParser(usage=usage_msg)
-    newopt = parser.add_option
-    newopt('-s','--scheme',metavar='NAME',dest='scheme_name',action='store',
-           choices=['Linux','LightBG','NoColor'],default=_scheme_default,
-           help="give the color scheme to use. Currently only 'Linux'\
- (default) and 'LightBG' and 'NoColor' are implemented (give without\
- quotes)")
-
-    opts,args = parser.parse_args(argv)
-
-    if len(args) > 1:
-        parser.error("you must give at most one filename.")
-
-    if len(args) == 0:
-        fname = '-' # no filename given; setup to read from stdin
-    else:
-        fname = args[0]
-
-    if fname == '-':
-        stream = sys.stdin
-    else:
-        try:
-            stream = file(fname)
-        except IOError,msg:
-            print >> sys.stderr, msg
-            sys.exit(1)
-
-    parser = Parser()
-
-    # we need nested try blocks because pre-2.5 python doesn't support unified
-    # try-except-finally
-    try:
-        try:
-            # write colorized version to stdout
-            parser.format(stream.read(),scheme=opts.scheme_name)
-        except IOError,msg:
-            # if user reads through a pager and quits, don't print traceback
-            if msg.args != (32,'Broken pipe'):
-                raise
-    finally:
-        if stream is not sys.stdin:
-            stream.close() # in case a non-handled exception happened above
-
-if __name__ == "__main__":
-    main()
+        pyg_tok_type = _pygment_token_mapping.get(toktype, Token.Text)
+
+        # send text, pygments should take care of splitting on newline and resending
+        # the correct self.colors after the new line, which is necessary for pagers
+        acc += theme_table[self.theme_name].format([(pyg_tok_type, toktext)])
+        return acc
+
+    def __call__(
+        self,
+        toktype: int,
+        toktext: str,
+        start_pos: tuple[int, int],
+        end_pos: tuple[int, int],
+        line: str,
+    ) -> None:
+        """Token handler, with syntax highlighting."""
+        self.out.write(self._inner_call_(toktype, toktext, start_pos))
diff --git a/IPython/utils/_process_cli.py b/IPython/utils/_process_cli.py
new file mode 100644
index 00000000000..045dc50bbeb
--- /dev/null
+++ b/IPython/utils/_process_cli.py
@@ -0,0 +1,71 @@
+"""cli-specific implementation of process utilities.
+
+cli - Common Language Infrastructure for IronPython. Code
+      can run on any operating system. Check os.name for os-
+      specific settings.
+
+This file is only meant to be imported by process.py, not by end-users.
+
+This file is largely untested. To become a full drop-in process
+interface for IronPython will probably require you to help fill
+in the details.
+"""
+
+# Import cli libraries:
+import clr
+import System
+
+# Import Python libraries:
+import os
+
+# Import IPython libraries:
+from ._process_common import arg_split
+
+
+def system(cmd):
+    """
+    system(cmd) should work in a cli environment on Mac OSX, Linux,
+    and Windows
+    """
+    psi = System.Diagnostics.ProcessStartInfo(cmd)
+    psi.RedirectStandardOutput = True
+    psi.RedirectStandardError = True
+    psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal
+    psi.UseShellExecute = False
+    # Start up process:
+    reg = System.Diagnostics.Process.Start(psi)
+
+
+def getoutput(cmd):
+    """
+    getoutput(cmd) should work in a cli environment on Mac OSX, Linux,
+    and Windows
+    """
+    psi = System.Diagnostics.ProcessStartInfo(cmd)
+    psi.RedirectStandardOutput = True
+    psi.RedirectStandardError = True
+    psi.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal
+    psi.UseShellExecute = False
+    # Start up process:
+    reg = System.Diagnostics.Process.Start(psi)
+    myOutput = reg.StandardOutput
+    output = myOutput.ReadToEnd()
+    myError = reg.StandardError
+    error = myError.ReadToEnd()
+    return output
+
+
+def check_pid(pid):
+    """
+    Check if a process with the given PID (pid) exists
+    """
+    try:
+        System.Diagnostics.Process.GetProcessById(pid)
+        # process with given pid is running
+        return True
+    except System.InvalidOperationException:
+        # process wasn't started by this object (but is running)
+        return True
+    except System.ArgumentException:
+        # process with given pid isn't running
+        return False
diff --git a/IPython/utils/_process_common.py b/IPython/utils/_process_common.py
index a4a0fd8b79f..77305853cf8 100644
--- a/IPython/utils/_process_common.py
+++ b/IPython/utils/_process_common.py
@@ -5,7 +5,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
+#  Copyright (C) 2010-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -14,14 +14,20 @@
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
+import os
+import shlex
 import subprocess
 import sys
+from typing import IO, Any, List, Union
+from collections.abc import Callable
+
+from IPython.utils import py3compat
 
 #-----------------------------------------------------------------------------
 # Function definitions
 #-----------------------------------------------------------------------------
 
-def read_no_interrupt(p):
+def read_no_interrupt(stream: IO[Any]) -> bytes:
     """Read from a pipe ignoring EINTR errors.
 
     This is necessary because when reading from pipes with GUI event loops
@@ -30,13 +36,17 @@ def read_no_interrupt(p):
     import errno
 
     try:
-        return p.read()
-    except IOError, err:
+        return stream.read()
+    except IOError as err:
         if err.errno != errno.EINTR:
             raise
 
 
-def process_handler(cmd, callback, stderr=subprocess.PIPE):
+def process_handler(
+    cmd: Union[str, List[str]],
+    callback: Callable[[subprocess.Popen], int | str | bytes],
+    stderr=subprocess.PIPE,
+) -> int | str | bytes:
     """Open a command in a shell subprocess and execute a callback.
 
     This function provides common scaffolding for creating subprocess.Popen()
@@ -44,18 +54,17 @@ def process_handler(cmd, callback, stderr=subprocess.PIPE):
 
     Parameters
     ----------
-    cmd : str
-      A string to be executed with the underlying system shell (by calling
-    :func:`Popen` with ``shell=True``.
-
+    cmd : str or list
+        A command to be executed by the system, using :class:`subprocess.Popen`.
+        If a string is passed, it will be run in the system shell. If a list is
+        passed, it will be used directly as arguments.
     callback : callable
-      A one-argument function that will be called with the Popen object.
-
+        A one-argument function that will be called with the Popen object.
     stderr : file descriptor number, optional
-      By default this is set to ``subprocess.PIPE``, but you can also pass the
-      value ``subprocess.STDOUT`` to force the subprocess' stderr to go into
-      the same file descriptor as its stdout.  This is useful to read stdout
-      and stderr combined in the order they are generated.
+        By default this is set to ``subprocess.PIPE``, but you can also pass the
+        value ``subprocess.STDOUT`` to force the subprocess' stderr to go into
+        the same file descriptor as its stdout.  This is useful to read stdout
+        and stderr combined in the order they are generated.
 
     Returns
     -------
@@ -64,8 +73,18 @@ def process_handler(cmd, callback, stderr=subprocess.PIPE):
     sys.stdout.flush()
     sys.stderr.flush()
     # On win32, close_fds can't be true when using pipes for stdin/out/err
-    close_fds = sys.platform != 'win32'
-    p = subprocess.Popen(cmd, shell=True,
+    if sys.platform == "win32" and stderr != subprocess.PIPE:
+        close_fds = False
+    else:
+        close_fds = True
+    # Determine if cmd should be run with system shell.
+    shell = isinstance(cmd, str)
+    # On POSIX systems run shell commands with user-preferred shell.
+    executable = None
+    if shell and os.name == 'posix' and 'SHELL' in os.environ:
+        executable = os.environ['SHELL']
+    p = subprocess.Popen(cmd, shell=shell,
+                         executable=executable,
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=stderr,
@@ -100,24 +119,26 @@ def process_handler(cmd, callback, stderr=subprocess.PIPE):
 
 
 def getoutput(cmd):
-    """Return standard output of executing cmd in a shell.
-
-    Accepts the same arguments as os.system().
+    """Run a command and return its stdout/stderr as a string.
 
     Parameters
     ----------
-    cmd : str
-      A command to be executed in the system shell.
+    cmd : str or list
+        A command to be executed in the system shell.
 
     Returns
     -------
-    stdout : str
+    output : str
+        A string containing the combination of stdout and stderr from the
+    subprocess, in whatever order the subprocess originally wrote to its
+    file descriptors (so the order of the information in this string is the
+    correct order as would be seen if running the command in a terminal).
     """
-
     out = process_handler(cmd, lambda p: p.communicate()[0], subprocess.STDOUT)
     if out is None:
-        out = ''
-    return out
+        return ''
+    assert isinstance(out, bytes)
+    return py3compat.decode(out)
 
 
 def getoutputerror(cmd):
@@ -127,16 +148,73 @@ def getoutputerror(cmd):
 
     Parameters
     ----------
-    cmd : str
-      A command to be executed in the system shell.
+    cmd : str or list
+        A command to be executed in the system shell.
 
     Returns
     -------
     stdout : str
     stderr : str
     """
+    return get_output_error_code(cmd)[:2]
+
+def get_output_error_code(cmd):
+    """Return (standard output, standard error, return code) of executing cmd
+    in a shell.
+
+    Accepts the same arguments as os.system().
 
-    out_err = process_handler(cmd, lambda p: p.communicate())
+    Parameters
+    ----------
+    cmd : str or list
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    stdout : str
+    stderr : str
+    returncode: int
+    """
+
+    out_err, p = process_handler(cmd, lambda p: (p.communicate(), p))
     if out_err is None:
-        out_err = '', ''
-    return out_err
+        return '', '', p.returncode
+    out, err = out_err
+    return py3compat.decode(out), py3compat.decode(err), p.returncode
+
+def arg_split(s, posix=False, strict=True):
+    """Split a command line's arguments in a shell-like manner.
+
+    This is a modified version of the standard library's shlex.split()
+    function, but with a default of posix=False for splitting, so that quotes
+    in inputs are respected.
+
+    if strict=False, then any errors shlex.split would raise will result in the
+    unparsed remainder being the last element of the list, rather than raising.
+    This is because we sometimes use arg_split to parse things other than
+    command-line args.
+    """
+
+    lex = shlex.shlex(s, posix=posix)
+    lex.whitespace_split = True
+    # Extract tokens, ensuring that things like leaving open quotes
+    # does not cause this to raise.  This is important, because we
+    # sometimes pass Python source through this (e.g. %timeit f(" ")),
+    # and it shouldn't raise an exception.
+    # It may be a bad idea to parse things that are not command-line args
+    # through this function, but we do, so let's be safe about it.
+    lex.commenters='' #fix for GH-1269
+    tokens = []
+    while True:
+        try:
+            tokens.append(next(lex))
+        except StopIteration:
+            break
+        except ValueError:
+            if strict:
+                raise
+            # couldn't parse, get remaining blob as last token
+            tokens.append(lex.token)
+            break
+
+    return tokens
diff --git a/IPython/utils/_process_emscripten.py b/IPython/utils/_process_emscripten.py
new file mode 100644
index 00000000000..bfc25184623
--- /dev/null
+++ b/IPython/utils/_process_emscripten.py
@@ -0,0 +1,22 @@
+"""Emscripten-specific implementation of process utilities.
+
+This file is only meant to be imported by process.py, not by end-users.
+"""
+
+from ._process_common import arg_split
+
+
+def system(cmd):
+    raise OSError("Not available")
+
+
+def getoutput(cmd):
+    raise OSError("Not available")
+
+
+def check_pid(cmd):
+    raise OSError("Not available")
+
+
+# `arg_split` is still used by magics regardless of whether we are on a posix/windows/emscipten
+__all__ = ["system", "getoutput", "check_pid", "arg_split"]
diff --git a/IPython/utils/_process_posix.py b/IPython/utils/_process_posix.py
index e10945abc4b..da3f00dc975 100644
--- a/IPython/utils/_process_posix.py
+++ b/IPython/utils/_process_posix.py
@@ -3,161 +3,132 @@
 This file is only meant to be imported by process.py, not by end-users.
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-from __future__ import print_function
 
 # Stdlib
+import errno
+import os
 import subprocess as sp
 import sys
 
-# Third-party
-# We ship our own copy of pexpect (it's a single file) to minimize dependencies
-# for users, but it's only used if we don't find the system copy.
-try:
-    import pexpect
-except ImportError:
-    from IPython.external import pexpect
-
 # Our own
-from .autoattr import auto_attr
-from ._process_common import getoutput
+from ._process_common import getoutput as getoutput, arg_split
+from IPython.utils.encoding import DEFAULT_ENCODING
+
+__all__ = ["getoutput", "arg_split", "system", "check_pid"]
 
 #-----------------------------------------------------------------------------
 # Function definitions
 #-----------------------------------------------------------------------------
 
-def _find_cmd(cmd):
-    """Find the full path to a command using which."""
-
-    return sp.Popen(['/usr/bin/env', 'which', cmd],
-                    stdout=sp.PIPE).communicate()[0]
-
-
-class ProcessHandler(object):
+class ProcessHandler:
     """Execute subprocesses under the control of pexpect.
     """
     # Timeout in seconds to wait on each reading of the subprocess' output.
     # This should not be set too low to avoid cpu overusage from our side,
     # since we read in a loop whose period is controlled by this timeout.
-    read_timeout = 0.05
+    read_timeout: float = 0.05
 
     # Timeout to give a process if we receive SIGINT, between sending the
     # SIGINT to the process and forcefully terminating it.
-    terminate_timeout = 0.2
+    terminate_timeout: float = 0.2
 
     # File object where stdout and stderr of the subprocess will be written
     logfile = None
 
     # Shell to call for subprocesses to execute
-    sh = None
+    _sh: str | None = None
 
-    @auto_attr
-    def sh(self):
-        sh = pexpect.which('sh')
-        if sh is None:
-            raise OSError('"sh" shell not found')
-        return sh
+    @property
+    def sh(self) -> str | None:
+        if self._sh is None:
+            import pexpect
+            shell_name = os.environ.get("SHELL", "sh")
+            self._sh = pexpect.which(shell_name)
+            if self._sh is None:
+                raise OSError('"{}" shell not found'.format(shell_name))
 
-    def __init__(self, logfile=None, read_timeout=None, terminate_timeout=None):
-        """Arguments are used for pexpect calls."""
-        self.read_timeout = (ProcessHandler.read_timeout if read_timeout is
-                             None else read_timeout)
-        self.terminate_timeout = (ProcessHandler.terminate_timeout if
-                                  terminate_timeout is None else
-                                  terminate_timeout)
-        self.logfile = sys.stdout if logfile is None else logfile
-
-    def getoutput(self, cmd):
-        """Run a command and return its stdout/stderr as a string.
+        return self._sh
 
-        Parameters
-        ----------
-        cmd : str
-          A command to be executed in the system shell.
-
-        Returns
-        -------
-        output : str
-          A string containing the combination of stdout and stderr from the
-        subprocess, in whatever order the subprocess originally wrote to its
-        file descriptors (so the order of the information in this string is the
-        correct order as would be seen if running the command in a terminal).
-        """
-        pcmd = self._make_cmd(cmd)
-        try:
-            return pexpect.run(pcmd).replace('\r\n', '\n')
-        except KeyboardInterrupt:
-            print('^C', file=sys.stderr, end='')
+    def __init__(self) -> None:
+        """Arguments are used for pexpect calls."""
+        self.logfile = sys.stdout
 
-    def getoutput_pexpect(self, cmd):
+    def getoutput(self, cmd: str) -> str | None:
         """Run a command and return its stdout/stderr as a string.
 
         Parameters
         ----------
         cmd : str
-          A command to be executed in the system shell.
+            A command to be executed in the system shell.
 
         Returns
         -------
         output : str
-          A string containing the combination of stdout and stderr from the
+            A string containing the combination of stdout and stderr from the
         subprocess, in whatever order the subprocess originally wrote to its
         file descriptors (so the order of the information in this string is the
         correct order as would be seen if running the command in a terminal).
         """
-        pcmd = self._make_cmd(cmd)
+        import pexpect
+
+        assert self.sh is not None
         try:
-            return pexpect.run(pcmd).replace('\r\n', '\n')
+            res = pexpect.run(self.sh, args=["-c", cmd])
+            assert isinstance(res, str)
+            return res.replace("\r\n", "\n")
         except KeyboardInterrupt:
             print('^C', file=sys.stderr, end='')
+        return None
 
-    def system(self, cmd):
+    def system(self, cmd: str) -> int:
         """Execute a command in a subshell.
 
         Parameters
         ----------
         cmd : str
-          A command to be executed in the system shell.
+            A command to be executed in the system shell.
 
         Returns
         -------
-        None : we explicitly do NOT return the subprocess status code, as this
-        utility is meant to be used extensively in IPython, where any return
-        value would trigger :func:`sys.displayhook` calls.
+        int : child's exitstatus
         """
-        pcmd = self._make_cmd(cmd)
+        import pexpect
+
+        # Get likely encoding for the output.
+        enc = DEFAULT_ENCODING
+        
         # Patterns to match on the output, for pexpect.  We read input and
         # allow either a short timeout or EOF
         patterns = [pexpect.TIMEOUT, pexpect.EOF]
         # the index of the EOF pattern in the list.
-        EOF_index = 1  # Fix this index if you change the list!!
+        # even though we know it's 1, this call means we don't have to worry if
+        # we change the above list, and forget to change this value:
+        EOF_index = patterns.index(pexpect.EOF)
         # The size of the output stored so far in the process output buffer.
         # Since pexpect only appends to this buffer, each time we print we
         # record how far we've printed, so that next time we only print *new*
         # content from the buffer.
         out_size = 0
+        assert self.sh is not None
         try:
             # Since we're not really searching the buffer for text patterns, we
             # can set pexpect's search window to be tiny and it won't matter.
             # We only search for the 'patterns' timeout or EOF, which aren't in
             # the text itself.
             #child = pexpect.spawn(pcmd, searchwindowsize=1)
-            child = pexpect.spawn(pcmd)
+            if hasattr(pexpect, 'spawnb'):
+                child = pexpect.spawnb(self.sh, args=['-c', cmd]) # Pexpect-U
+            else:
+                child = pexpect.spawn(self.sh, args=['-c', cmd])  # Vanilla Pexpect
             flush = sys.stdout.flush
             while True:
                 # res is the index of the pattern that caused the match, so we
                 # know whether we've finished (if we matched EOF) or not
                 res_idx = child.expect_list(patterns, self.read_timeout)
-                print(child.before[out_size:], end='')
+                print(child.before[out_size:].decode(enc, 'replace'), end='')
                 flush()
                 if res_idx==EOF_index:
                     break
@@ -173,7 +144,7 @@ def system(self, cmd):
             try:
                 out_size = len(child.before)
                 child.expect_list(patterns, self.terminate_timeout)
-                print(child.before[out_size:], end='')
+                print(child.before[out_size:].decode(enc, 'replace'), end='')
                 sys.stdout.flush()
             except KeyboardInterrupt:
                 # Impatient users tend to type it multiple times
@@ -181,9 +152,24 @@ def system(self, cmd):
             finally:
                 # Ensure the subprocess really is terminated
                 child.terminate(force=True)
-
-    def _make_cmd(self, cmd):
-        return '%s -c "%s"' % (self.sh, cmd)
+        # add isalive check, to ensure exitstatus is set:
+        child.isalive()
+
+        # We follow the subprocess pattern, returning either the exit status
+        # as a positive number, or the terminating signal as a negative
+        # number.
+        # on Linux, sh returns 128+n for signals terminating child processes on Linux
+        # on BSD (OS X), the signal code is set instead
+        if child.exitstatus is None:
+            # on WIFSIGNALED, pexpect sets signalstatus, leaving exitstatus=None
+            if child.signalstatus is None:
+                # this condition may never occur,
+                # but let's be certain we always return an integer.
+                return 0
+            return -child.signalstatus
+        if child.exitstatus > 128:
+            return -(child.exitstatus - 128)
+        return child.exitstatus
 
 
 # Make system() with a functional interface for outside use.  Note that we use
@@ -192,3 +178,17 @@ def _make_cmd(self, cmd):
 # programs think they are talking to a tty and produce highly formatted output
 # (ls is a good example) that makes them hard.
 system = ProcessHandler().system
+
+
+def check_pid(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except OSError as err:
+        if err.errno == errno.ESRCH:
+            return False
+        elif err.errno == errno.EPERM:
+            # Don't have permission to signal the process - probably means it exists
+            return True
+        raise
+    else:
+        return True
diff --git a/IPython/utils/_process_win32.py b/IPython/utils/_process_win32.py
index 1d8bd94063a..0600b1ee14c 100644
--- a/IPython/utils/_process_win32.py
+++ b/IPython/utils/_process_win32.py
@@ -3,32 +3,26 @@
 This file is only meant to be imported by process.py, not by end-users.
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# stdlib
+import ctypes
 import os
+import subprocess
 import sys
-
+import time
+from ctypes import POINTER, c_int
+from ctypes.wintypes import HLOCAL, LPCWSTR
 from subprocess import STDOUT
+from threading import Thread
+from types import TracebackType
+from typing import List, Optional
+
+from . import py3compat
+from ._process_common import arg_split as py_arg_split
 
-# our own imports
-from ._process_common import read_no_interrupt, process_handler
+from ._process_common import process_handler, read_no_interrupt
+from .encoding import DEFAULT_ENCODING
 
-#-----------------------------------------------------------------------------
-# Function definitions
-#-----------------------------------------------------------------------------
 
-class AvoidUNCPath(object):
+class AvoidUNCPath:
     """A context manager to protect command execution from UNC paths.
 
     In the Win32 API, commands can't be invoked with the cwd being a UNC path.
@@ -39,8 +33,8 @@ class AvoidUNCPath(object):
     change and None otherwise, so that users can apply the necessary adjustment
     to their system calls in the event of a change.
 
-    Example
-    -------
+    Examples
+    --------
     ::
         cmd = 'dir'
         with AvoidUNCPath() as path:
@@ -48,7 +42,8 @@ class AvoidUNCPath(object):
                 cmd = '"pushd %s &&"%s' % (path, cmd)
             os.system(cmd)
     """
-    def __enter__(self):
+
+    def __enter__(self) -> Optional[str]:
         self.path = os.getcwd()
         self.is_unc_path = self.path.startswith(r"\\")
         if self.is_unc_path:
@@ -60,74 +55,101 @@ def __enter__(self):
             # directory
             return None
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: TracebackType,
+    ) -> None:
         if self.is_unc_path:
             os.chdir(self.path)
 
 
-def _find_cmd(cmd):
-    """Find the full path to a .bat or .exe using the win32api module."""
-    try:
-        from win32api import SearchPath
-    except ImportError:
-        raise ImportError('you need to have pywin32 installed for this to work')
-    else:
-        PATH = os.environ['PATH']
-        extensions = ['.exe', '.com', '.bat', '.py']
-        path = None
-        for ext in extensions:
-            try:
-                path = SearchPath(PATH, cmd + ext)[0]
-            except:
-                pass
-        if path is None:
-            raise OSError("command %r not found" % cmd)
+def _system_body(p: subprocess.Popen) -> int:
+    """Callback for _system."""
+    enc = DEFAULT_ENCODING
+
+    # Dec 2024: in both of these functions, I'm not sure why we .splitlines()
+    # the bytes and then decode each line individually instead of just decoding
+    # the whole thing at once.
+    def stdout_read() -> None:
+        try:
+            assert p.stdout is not None
+            for byte_line in read_no_interrupt(p.stdout).splitlines():
+                line = byte_line.decode(enc, "replace")
+                print(line, file=sys.stdout)
+        except Exception as e:
+            print(f"Error reading stdout: {e}", file=sys.stderr)
+
+    def stderr_read() -> None:
+        try:
+            assert p.stderr is not None
+            for byte_line in read_no_interrupt(p.stderr).splitlines():
+                line = byte_line.decode(enc, "replace")
+                print(line, file=sys.stderr)
+        except Exception as e:
+            print(f"Error reading stderr: {e}", file=sys.stderr)
+
+    stdout_thread = Thread(target=stdout_read)
+    stderr_thread = Thread(target=stderr_read)
+
+    stdout_thread.start()
+    stderr_thread.start()
+
+    # Wait to finish for returncode. Unfortunately, Python has a bug where
+    # wait() isn't interruptible (https://bugs.python.org/issue28168) so poll in
+    # a loop instead of just doing `return p.wait()`
+    while True:
+        result = p.poll()
+        if result is None:
+            time.sleep(0.01)
         else:
-            return path
+            break
 
+    # Join the threads to ensure they complete before returning
+    stdout_thread.join()
+    stderr_thread.join()
 
-def _system_body(p):
-    """Callback for _system."""
-    enc = sys.stdin.encoding or sys.getdefaultencoding()
-    for line in read_no_interrupt(p.stdout).splitlines():
-        line = line.decode(enc, 'replace')
-        print(line, file=sys.stdout)
-    for line in read_no_interrupt(p.stderr).splitlines():
-        line = line.decode(enc, 'replace')
-        print(line, file=sys.stderr)
+    return result
 
 
-def system(cmd):
+def system(cmd: str) -> Optional[int]:
     """Win32 version of os.system() that works with network shares.
 
     Note that this implementation returns None, as meant for use in IPython.
 
     Parameters
     ----------
-    cmd : str
-      A command to be executed in the system shell.
+    cmd : str or list
+        A command to be executed in the system shell.
 
     Returns
     -------
-    None : we explicitly do NOT return the subprocess status code, as this
-    utility is meant to be used extensively in IPython, where any return value
-    would trigger :func:`sys.displayhook` calls.
+    int : child process' exit code.
     """
+    # The controller provides interactivity with both
+    # stdin and stdout
+    # import _process_win32_controller
+    # _process_win32_controller.system(cmd)
+
     with AvoidUNCPath() as path:
         if path is not None:
             cmd = '"pushd %s &&"%s' % (path, cmd)
-        process_handler(cmd, _system_body)
+        res = process_handler(cmd, _system_body)
+        assert isinstance(res, int | type(None))
+        return res
+    return None
 
 
-def getoutput(cmd):
+def getoutput(cmd: str) -> str:
     """Return standard output of executing cmd in a shell.
 
     Accepts the same arguments as os.system().
 
     Parameters
     ----------
-    cmd : str
-      A command to be executed in the system shell.
+    cmd : str or list
+        A command to be executed in the system shell.
 
     Returns
     -------
@@ -140,5 +162,55 @@ def getoutput(cmd):
         out = process_handler(cmd, lambda p: p.communicate()[0], STDOUT)
 
     if out is None:
-        out = ''
-    return out
+        out = b""
+    return py3compat.decode(out)
+
+
+try:
+    windll = ctypes.windll  # type: ignore [attr-defined]
+    CommandLineToArgvW = windll.shell32.CommandLineToArgvW
+    CommandLineToArgvW.arg_types = [LPCWSTR, POINTER(c_int)]
+    CommandLineToArgvW.restype = POINTER(LPCWSTR)
+    LocalFree = windll.kernel32.LocalFree
+    LocalFree.res_type = HLOCAL
+    LocalFree.arg_types = [HLOCAL]
+
+    def arg_split(
+        commandline: str, posix: bool = False, strict: bool = True
+    ) -> List[str]:
+        """Split a command line's arguments in a shell-like manner.
+
+        This is a special version for windows that use a ctypes call to CommandLineToArgvW
+        to do the argv splitting. The posix parameter is ignored.
+
+        If strict=False, process_common.arg_split(...strict=False) is used instead.
+        """
+        # CommandLineToArgvW returns path to executable if called with empty string.
+        if commandline.strip() == "":
+            return []
+        if not strict:
+            # not really a cl-arg, fallback on _process_common
+            return py_arg_split(commandline, posix=posix, strict=strict)
+        argvn = c_int()
+        result_pointer = CommandLineToArgvW(commandline.lstrip(), ctypes.byref(argvn))
+        try:
+            result_array_type = LPCWSTR * argvn.value
+            result = [
+                arg
+                for arg in result_array_type.from_address(
+                    ctypes.addressof(result_pointer.contents)
+                )
+                if arg is not None
+            ]
+        finally:
+            # for side effects
+            _ = LocalFree(result_pointer)
+        return result
+except AttributeError:
+    arg_split = py_arg_split
+
+
+def check_pid(pid: int) -> bool:
+    # OpenProcess returns 0 if no such process (of ours) exists
+    # positive int otherwise
+    return bool(windll.kernel32.OpenProcess(1, 0, pid))
diff --git a/IPython/utils/_process_win32_controller.py b/IPython/utils/_process_win32_controller.py
new file mode 100644
index 00000000000..a62968814a7
--- /dev/null
+++ b/IPython/utils/_process_win32_controller.py
@@ -0,0 +1,574 @@
+"""Windows-specific implementation of process utilities with direct WinAPI.
+
+This file is meant to be used by process.py
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2010-2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+
+# stdlib
+import os, sys, threading
+import ctypes, msvcrt
+
+# Win32 API types needed for the API calls
+from ctypes import POINTER
+from ctypes.wintypes import HANDLE, HLOCAL, LPVOID, WORD, DWORD, BOOL, \
+        ULONG, LPCWSTR
+LPDWORD = POINTER(DWORD)
+LPHANDLE = POINTER(HANDLE)
+ULONG_PTR = POINTER(ULONG)
+class SECURITY_ATTRIBUTES(ctypes.Structure):
+    _fields_ = [("nLength", DWORD),
+                ("lpSecurityDescriptor", LPVOID),
+                ("bInheritHandle", BOOL)]
+LPSECURITY_ATTRIBUTES = POINTER(SECURITY_ATTRIBUTES)
+class STARTUPINFO(ctypes.Structure):
+    _fields_ = [("cb", DWORD),
+                ("lpReserved", LPCWSTR),
+                ("lpDesktop", LPCWSTR),
+                ("lpTitle", LPCWSTR),
+                ("dwX", DWORD),
+                ("dwY", DWORD),
+                ("dwXSize", DWORD),
+                ("dwYSize", DWORD),
+                ("dwXCountChars", DWORD),
+                ("dwYCountChars", DWORD),
+                ("dwFillAttribute", DWORD),
+                ("dwFlags", DWORD),
+                ("wShowWindow", WORD),
+                ("cbReserved2", WORD),
+                ("lpReserved2", LPVOID),
+                ("hStdInput", HANDLE),
+                ("hStdOutput", HANDLE),
+                ("hStdError", HANDLE)]
+LPSTARTUPINFO = POINTER(STARTUPINFO)
+class PROCESS_INFORMATION(ctypes.Structure):
+    _fields_ = [("hProcess", HANDLE),
+                ("hThread", HANDLE),
+                ("dwProcessId", DWORD),
+                ("dwThreadId", DWORD)]
+LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION)
+
+# Win32 API constants needed
+ERROR_HANDLE_EOF = 38
+ERROR_BROKEN_PIPE = 109
+ERROR_NO_DATA = 232
+HANDLE_FLAG_INHERIT = 0x0001
+STARTF_USESTDHANDLES = 0x0100
+CREATE_SUSPENDED = 0x0004
+CREATE_NEW_CONSOLE = 0x0010
+CREATE_NO_WINDOW = 0x08000000
+STILL_ACTIVE = 259
+WAIT_TIMEOUT = 0x0102
+WAIT_FAILED = 0xFFFFFFFF
+INFINITE = 0xFFFFFFFF
+DUPLICATE_SAME_ACCESS = 0x00000002
+ENABLE_ECHO_INPUT = 0x0004
+ENABLE_LINE_INPUT = 0x0002
+ENABLE_PROCESSED_INPUT = 0x0001
+
+# Win32 API functions needed
+GetLastError = ctypes.windll.kernel32.GetLastError
+GetLastError.argtypes = []
+GetLastError.restype = DWORD
+
+CreateFile = ctypes.windll.kernel32.CreateFileW
+CreateFile.argtypes = [LPCWSTR, DWORD, DWORD, LPVOID, DWORD, DWORD, HANDLE]
+CreateFile.restype = HANDLE
+
+CreatePipe = ctypes.windll.kernel32.CreatePipe
+CreatePipe.argtypes = [POINTER(HANDLE), POINTER(HANDLE),
+        LPSECURITY_ATTRIBUTES, DWORD]
+CreatePipe.restype = BOOL
+
+CreateProcess = ctypes.windll.kernel32.CreateProcessW
+CreateProcess.argtypes = [LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES,
+        LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO,
+        LPPROCESS_INFORMATION]
+CreateProcess.restype = BOOL
+
+GetExitCodeProcess = ctypes.windll.kernel32.GetExitCodeProcess
+GetExitCodeProcess.argtypes = [HANDLE, LPDWORD]
+GetExitCodeProcess.restype = BOOL
+
+GetCurrentProcess = ctypes.windll.kernel32.GetCurrentProcess
+GetCurrentProcess.argtypes = []
+GetCurrentProcess.restype = HANDLE
+
+ResumeThread = ctypes.windll.kernel32.ResumeThread
+ResumeThread.argtypes = [HANDLE]
+ResumeThread.restype = DWORD
+
+ReadFile = ctypes.windll.kernel32.ReadFile
+ReadFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID]
+ReadFile.restype = BOOL
+
+WriteFile = ctypes.windll.kernel32.WriteFile
+WriteFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID]
+WriteFile.restype = BOOL
+
+GetConsoleMode = ctypes.windll.kernel32.GetConsoleMode
+GetConsoleMode.argtypes = [HANDLE, LPDWORD]
+GetConsoleMode.restype = BOOL
+
+SetConsoleMode = ctypes.windll.kernel32.SetConsoleMode
+SetConsoleMode.argtypes = [HANDLE, DWORD]
+SetConsoleMode.restype = BOOL
+
+FlushConsoleInputBuffer = ctypes.windll.kernel32.FlushConsoleInputBuffer
+FlushConsoleInputBuffer.argtypes = [HANDLE]
+FlushConsoleInputBuffer.restype = BOOL
+
+WaitForSingleObject = ctypes.windll.kernel32.WaitForSingleObject
+WaitForSingleObject.argtypes = [HANDLE, DWORD]
+WaitForSingleObject.restype = DWORD
+
+DuplicateHandle = ctypes.windll.kernel32.DuplicateHandle
+DuplicateHandle.argtypes = [HANDLE, HANDLE, HANDLE, LPHANDLE,
+        DWORD, BOOL, DWORD]
+DuplicateHandle.restype = BOOL
+
+SetHandleInformation = ctypes.windll.kernel32.SetHandleInformation
+SetHandleInformation.argtypes = [HANDLE, DWORD, DWORD]
+SetHandleInformation.restype = BOOL
+
+CloseHandle = ctypes.windll.kernel32.CloseHandle
+CloseHandle.argtypes = [HANDLE]
+CloseHandle.restype = BOOL
+
+CommandLineToArgvW = ctypes.windll.shell32.CommandLineToArgvW
+CommandLineToArgvW.argtypes = [LPCWSTR, POINTER(ctypes.c_int)]
+CommandLineToArgvW.restype = POINTER(LPCWSTR)
+
+LocalFree = ctypes.windll.kernel32.LocalFree
+LocalFree.argtypes = [HLOCAL]
+LocalFree.restype = HLOCAL
+
+class AvoidUNCPath:
+    """A context manager to protect command execution from UNC paths.
+
+    In the Win32 API, commands can't be invoked with the cwd being a UNC path.
+    This context manager temporarily changes directory to the 'C:' drive on
+    entering, and restores the original working directory on exit.
+
+    The context manager returns the starting working directory *if* it made a
+    change and None otherwise, so that users can apply the necessary adjustment
+    to their system calls in the event of a change.
+
+    Examples
+    --------
+    ::
+        cmd = 'dir'
+        with AvoidUNCPath() as path:
+            if path is not None:
+                cmd = '"pushd %s &&"%s' % (path, cmd)
+            os.system(cmd)
+    """
+
+    def __enter__(self) -> None:
+        self.path = os.getcwd()
+        self.is_unc_path = self.path.startswith(r"\\")
+        if self.is_unc_path:
+            # change to c drive (as cmd.exe cannot handle UNC addresses)
+            os.chdir("C:")
+            return self.path
+        else:
+            # We return None to signal that there was no change in the working
+            # directory
+            return None
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        if self.is_unc_path:
+            os.chdir(self.path)
+
+
+class Win32ShellCommandController:
+    """Runs a shell command in a 'with' context.
+
+    This implementation is Win32-specific.
+
+    Example:
+        # Runs the command interactively with default console stdin/stdout
+        with ShellCommandController('python -i') as scc:
+            scc.run()
+
+        # Runs the command using the provided functions for stdin/stdout
+        def my_stdout_func(s):
+            # print or save the string 's'
+            write_to_stdout(s)
+        def my_stdin_func():
+            # If input is available, return it as a string.
+            if input_available():
+                return get_input()
+            # If no input available, return None after a short delay to
+            # keep from blocking.
+            else:
+                time.sleep(0.01)
+                return None
+      
+        with ShellCommandController('python -i') as scc:
+            scc.run(my_stdout_func, my_stdin_func)
+    """
+
+    def __init__(self, cmd, mergeout = True):
+        """Initializes the shell command controller.
+
+        The cmd is the program to execute, and mergeout is
+        whether to blend stdout and stderr into one output
+        in stdout. Merging them together in this fashion more
+        reliably keeps stdout and stderr in the correct order
+        especially for interactive shell usage.
+        """
+        self.cmd = cmd
+        self.mergeout = mergeout
+
+    def __enter__(self):
+        cmd = self.cmd
+        mergeout = self.mergeout
+
+        self.hstdout, self.hstdin, self.hstderr = None, None, None
+        self.piProcInfo = None
+        try:
+            p_hstdout, c_hstdout, p_hstderr, \
+                    c_hstderr, p_hstdin, c_hstdin = [None]*6
+
+            # SECURITY_ATTRIBUTES with inherit handle set to True
+            saAttr = SECURITY_ATTRIBUTES()
+            saAttr.nLength = ctypes.sizeof(saAttr)
+            saAttr.bInheritHandle = True
+            saAttr.lpSecurityDescriptor = None
+
+            def create_pipe(uninherit):
+                """Creates a Windows pipe, which consists of two handles.
+
+                The 'uninherit' parameter controls which handle is not
+                inherited by the child process.
+                """
+                handles = HANDLE(), HANDLE()
+                if not CreatePipe(ctypes.byref(handles[0]),
+                            ctypes.byref(handles[1]), ctypes.byref(saAttr), 0):
+                    raise ctypes.WinError()
+                if not SetHandleInformation(handles[uninherit],
+                            HANDLE_FLAG_INHERIT, 0):
+                    raise ctypes.WinError()
+                return handles[0].value, handles[1].value
+
+            p_hstdout, c_hstdout = create_pipe(uninherit=0)
+            # 'mergeout' signals that stdout and stderr should be merged.
+            # We do that by using one pipe for both of them.
+            if mergeout:
+                c_hstderr = HANDLE()
+                if not DuplicateHandle(GetCurrentProcess(), c_hstdout,
+                                GetCurrentProcess(), ctypes.byref(c_hstderr),
+                                0, True, DUPLICATE_SAME_ACCESS):
+                    raise ctypes.WinError()
+            else:
+                p_hstderr, c_hstderr = create_pipe(uninherit=0)
+            c_hstdin,  p_hstdin  = create_pipe(uninherit=1)
+
+            # Create the process object
+            piProcInfo = PROCESS_INFORMATION()
+            siStartInfo = STARTUPINFO()
+            siStartInfo.cb = ctypes.sizeof(siStartInfo)
+            siStartInfo.hStdInput = c_hstdin
+            siStartInfo.hStdOutput = c_hstdout
+            siStartInfo.hStdError = c_hstderr
+            siStartInfo.dwFlags = STARTF_USESTDHANDLES
+            dwCreationFlags = CREATE_SUSPENDED | CREATE_NO_WINDOW # | CREATE_NEW_CONSOLE
+
+            if not CreateProcess(None,
+                    u"cmd.exe /c " + cmd,
+                    None, None, True, dwCreationFlags,
+                    None, None, ctypes.byref(siStartInfo),
+                    ctypes.byref(piProcInfo)):
+                raise ctypes.WinError()
+
+            # Close this process's versions of the child handles
+            CloseHandle(c_hstdin)
+            c_hstdin = None
+            CloseHandle(c_hstdout)
+            c_hstdout = None
+            if c_hstderr is not None:
+                CloseHandle(c_hstderr)
+                c_hstderr = None
+
+            # Transfer ownership of the parent handles to the object
+            self.hstdin = p_hstdin
+            p_hstdin = None
+            self.hstdout = p_hstdout
+            p_hstdout = None
+            if not mergeout:
+                self.hstderr = p_hstderr
+                p_hstderr = None
+            self.piProcInfo = piProcInfo
+
+        finally:
+            if p_hstdin:
+                CloseHandle(p_hstdin)
+            if c_hstdin:
+                CloseHandle(c_hstdin)
+            if p_hstdout:
+                CloseHandle(p_hstdout)
+            if c_hstdout:
+                CloseHandle(c_hstdout)
+            if p_hstderr:
+                CloseHandle(p_hstderr)
+            if c_hstderr:
+                CloseHandle(c_hstderr)
+
+        return self
+
+    def _stdin_thread(self, handle, hprocess, func, stdout_func):
+        exitCode = DWORD()
+        bytesWritten = DWORD(0)
+        while True:
+            #print("stdin thread loop start")
+            # Get the input string (may be bytes or unicode)
+            data = func()
+
+            # None signals to poll whether the process has exited
+            if data is None:
+                #print("checking for process completion")
+                if not GetExitCodeProcess(hprocess, ctypes.byref(exitCode)):
+                    raise ctypes.WinError()
+                if exitCode.value != STILL_ACTIVE:
+                    return
+                # TESTING: Does zero-sized writefile help?
+                if not WriteFile(handle, "", 0,
+                        ctypes.byref(bytesWritten), None):
+                    raise ctypes.WinError()
+                continue
+            #print("\nGot str %s\n" % repr(data), file=sys.stderr)
+
+            # Encode the string to the console encoding
+            if isinstance(data, unicode): #FIXME: Python3
+                data = data.encode('utf_8')
+
+            # What we have now must be a string of bytes
+            if not isinstance(data, str): #FIXME: Python3
+                raise RuntimeError("internal stdin function string error")
+
+            # An empty string signals EOF
+            if len(data) == 0:
+                return
+
+            # In a windows console, sometimes the input is echoed,
+            # but sometimes not. How do we determine when to do this?
+            stdout_func(data)
+            # WriteFile may not accept all the data at once.
+            # Loop until everything is processed
+            while len(data) != 0:
+                #print("Calling writefile")
+                if not WriteFile(handle, data, len(data),
+                        ctypes.byref(bytesWritten), None):
+                    # This occurs at exit
+                    if GetLastError() == ERROR_NO_DATA:
+                        return
+                    raise ctypes.WinError()
+                #print("Called writefile")
+                data = data[bytesWritten.value:]
+
+    def _stdout_thread(self, handle, func):
+        # Allocate the output buffer
+        data = ctypes.create_string_buffer(4096)
+        while True:
+            bytesRead = DWORD(0)
+            if not ReadFile(handle, data, 4096,
+                        ctypes.byref(bytesRead), None):
+                le = GetLastError()
+                if le == ERROR_BROKEN_PIPE:
+                    return
+                else:
+                    raise ctypes.WinError()
+            # FIXME: Python3
+            s = data.value[0:bytesRead.value]
+            #print("\nv: %s" % repr(s), file=sys.stderr)
+            func(s.decode('utf_8', 'replace'))
+
+    def run(self, stdout_func = None, stdin_func = None, stderr_func = None):
+        """Runs the process, using the provided functions for I/O.
+
+        The function stdin_func should return strings whenever a
+        character or characters become available.
+        The functions stdout_func and stderr_func are called whenever
+        something is printed to stdout or stderr, respectively.
+        These functions are called from different threads (but not
+        concurrently, because of the GIL).
+        """
+        if stdout_func is None and stdin_func is None and stderr_func is None:
+            return self._run_stdio()
+
+        if stderr_func is not None and self.mergeout:
+            raise RuntimeError("Shell command was initiated with "
+                    "merged stdin/stdout, but a separate stderr_func "
+                    "was provided to the run() method")
+
+        # Create a thread for each input/output handle
+        stdin_thread = None
+        threads = []
+        if stdin_func:
+            stdin_thread = threading.Thread(target=self._stdin_thread,
+                                args=(self.hstdin, self.piProcInfo.hProcess,
+                                stdin_func, stdout_func))
+        threads.append(threading.Thread(target=self._stdout_thread,
+                                    args=(self.hstdout, stdout_func)))
+        if not self.mergeout:
+            if stderr_func is None:
+                stderr_func = stdout_func
+            threads.append(threading.Thread(target=self._stdout_thread,
+                                        args=(self.hstderr, stderr_func)))
+        # Start the I/O threads and the process
+        if ResumeThread(self.piProcInfo.hThread) == 0xFFFFFFFF:
+            raise ctypes.WinError()
+        if stdin_thread is not None:
+            stdin_thread.start()
+        for thread in threads:
+            thread.start()
+        # Wait for the process to complete
+        if WaitForSingleObject(self.piProcInfo.hProcess, INFINITE) == \
+                    WAIT_FAILED:
+            raise ctypes.WinError()
+        # Wait for the I/O threads to complete
+        for thread in threads:
+            thread.join()
+
+        # Wait for the stdin thread to complete
+        if stdin_thread is not None:
+            stdin_thread.join()
+
+    def _stdin_raw_nonblock(self):
+        """Use the raw Win32 handle of sys.stdin to do non-blocking reads"""
+        # WARNING: This is experimental, and produces inconsistent results.
+        #          It's possible for the handle not to be appropriate for use
+        #          with WaitForSingleObject, among other things.
+        handle = msvcrt.get_osfhandle(sys.stdin.fileno())
+        result = WaitForSingleObject(handle, 100)
+        if result == WAIT_FAILED:
+            raise ctypes.WinError()
+        elif result == WAIT_TIMEOUT:
+            print(".", end='')
+            return None
+        else:
+            data = ctypes.create_string_buffer(256)
+            bytesRead = DWORD(0)
+            print('?', end='')
+
+            if not ReadFile(handle, data, 256,
+                        ctypes.byref(bytesRead), None):
+                raise ctypes.WinError()
+            # This ensures the non-blocking works with an actual console
+            # Not checking the error, so the processing will still work with
+            # other handle types
+            FlushConsoleInputBuffer(handle)
+
+            data = data.value
+            data = data.replace('\r\n', '\n')
+            data = data.replace('\r', '\n')
+            print(repr(data) + " ", end='')
+            return data
+
+    def _stdin_raw_block(self):
+        """Use a blocking stdin read"""
+        # The big problem with the blocking read is that it doesn't
+        # exit when it's supposed to in all contexts. An extra
+        # key-press may be required to trigger the exit.
+        try:
+            data = sys.stdin.read(1)
+            data = data.replace('\r', '\n')
+            return data
+        except WindowsError as we:
+            if we.winerror == ERROR_NO_DATA:
+                # This error occurs when the pipe is closed
+                return None
+            else:
+                # Otherwise let the error propagate
+                raise we
+
+    def _stdout_raw(self, s):
+        """Writes the string to stdout"""
+        print(s, end='', file=sys.stdout)
+        sys.stdout.flush()
+
+    def _stderr_raw(self, s):
+        """Writes the string to stdout"""
+        print(s, end='', file=sys.stderr)
+        sys.stderr.flush()
+
+    def _run_stdio(self):
+        """Runs the process using the system standard I/O.
+
+        IMPORTANT: stdin needs to be asynchronous, so the Python
+                   sys.stdin object is not used. Instead,
+                   msvcrt.kbhit/getwch are used asynchronously.
+        """
+        # Disable Line and Echo mode
+        #lpMode = DWORD()
+        #handle = msvcrt.get_osfhandle(sys.stdin.fileno())
+        #if GetConsoleMode(handle, ctypes.byref(lpMode)):
+        #    set_console_mode = True
+        #    if not SetConsoleMode(handle, lpMode.value &
+        #            ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT)):
+        #        raise ctypes.WinError()
+
+        if self.mergeout:
+            return self.run(stdout_func = self._stdout_raw,
+                    stdin_func = self._stdin_raw_block)
+        else:
+            return self.run(stdout_func = self._stdout_raw,
+                    stdin_func = self._stdin_raw_block,
+                    stderr_func = self._stderr_raw)
+
+        # Restore the previous console mode
+        #if set_console_mode:
+        #    if not SetConsoleMode(handle, lpMode.value):
+        #        raise ctypes.WinError()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.hstdin:
+            CloseHandle(self.hstdin)
+            self.hstdin = None
+        if self.hstdout:
+            CloseHandle(self.hstdout)
+            self.hstdout = None
+        if self.hstderr:
+            CloseHandle(self.hstderr)
+            self.hstderr = None
+        if self.piProcInfo is not None:
+            CloseHandle(self.piProcInfo.hProcess)
+            CloseHandle(self.piProcInfo.hThread)
+            self.piProcInfo = None
+
+
+def system(cmd: str) -> None:
+    """Win32 version of os.system() that works with network shares.
+
+    Note that this implementation returns None, as meant for use in IPython.
+
+    Parameters
+    ----------
+    cmd : str
+        A command to be executed in the system shell.
+
+    Returns
+    -------
+    None : we explicitly do NOT return the subprocess status code, as this
+    utility is meant to be used extensively in IPython, where any return value
+    would trigger : func:`sys.displayhook` calls.
+    """
+    with AvoidUNCPath() as path:
+        if path is not None:
+            cmd = '"pushd %s &&"%s' % (path, cmd)
+        with Win32ShellCommandController(cmd) as scc:
+            scc.run()
+
+
+if __name__ == "__main__":
+    print("Test starting!")
+    #system("cmd")
+    system("python -i")
+    print("Test finished!")
diff --git a/IPython/utils/_sysinfo.py b/IPython/utils/_sysinfo.py
new file mode 100644
index 00000000000..2e58242d561
--- /dev/null
+++ b/IPython/utils/_sysinfo.py
@@ -0,0 +1,2 @@
+# GENERATED BY setup.py
+commit = ""
diff --git a/IPython/utils/attic.py b/IPython/utils/attic.py
deleted file mode 100644
index 5af351a142f..00000000000
--- a/IPython/utils/attic.py
+++ /dev/null
@@ -1,167 +0,0 @@
-# encoding: utf-8
-"""
-Older utilities that are not being used.
-
-WARNING: IF YOU NEED TO USE ONE OF THESE FUNCTIONS, PLEASE FIRST MOVE IT
-TO ANOTHER APPROPRIATE MODULE IN IPython.utils.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-import warnings
-
-from IPython.utils.warn import warn
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-def mutex_opts(dict,ex_op):
-    """Check for presence of mutually exclusive keys in a dict.
-
-    Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
-    for op1,op2 in ex_op:
-        if op1 in dict and op2 in dict:
-            raise ValueError,'\n*** ERROR in Arguments *** '\
-                  'Options '+op1+' and '+op2+' are mutually exclusive.'
-
-
-class EvalDict:
-    """
-    Emulate a dict which evaluates its contents in the caller's frame.
-
-    Usage:
-    >>> number = 19
-
-    >>> text = "python"
-
-    >>> print "%(text.capitalize())s %(number/9.0).1f rules!" % EvalDict()
-    Python 2.1 rules!
-    """
-
-    # This version is due to sismex01@hebmex.com on c.l.py, and is basically a
-    # modified (shorter) version of:
-    # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66018 by
-    # Skip Montanaro (skip@pobox.com).
-
-    def __getitem__(self, name):
-        frame = sys._getframe(1)
-        return eval(name, frame.f_globals, frame.f_locals)
-
-EvalString = EvalDict  # for backwards compatibility
-
-
-def all_belong(candidates,checklist):
-    """Check whether a list of items ALL appear in a given list of options.
-
-    Returns a single 1 or 0 value."""
-
-    return 1-(0 in [x in checklist for x in candidates])
-
-
-def belong(candidates,checklist):
-    """Check whether a list of items appear in a given list of options.
-
-    Returns a list of 1 and 0, one for each candidate given."""
-
-    return [x in checklist for x in candidates]
-
-
-def with_obj(object, **args):
-    """Set multiple attributes for an object, similar to Pascal's with.
-
-    Example:
-    with_obj(jim,
-             born = 1960,
-             haircolour = 'Brown',
-             eyecolour = 'Green')
-
-    Credit: Greg Ewing, in
-    http://mail.python.org/pipermail/python-list/2001-May/040703.html.
-
-    NOTE: up until IPython 0.7.2, this was called simply 'with', but 'with'
-    has become a keyword for Python 2.5, so we had to rename it."""
-
-    object.__dict__.update(args)
-
-
-def map_method(method,object_list,*argseq,**kw):
-    """map_method(method,object_list,*args,**kw) -> list
-
-    Return a list of the results of applying the methods to the items of the
-    argument sequence(s).  If more than one sequence is given, the method is
-    called with an argument list consisting of the corresponding item of each
-    sequence. All sequences must be of the same length.
-
-    Keyword arguments are passed verbatim to all objects called.
-
-    This is Python code, so it's not nearly as fast as the builtin map()."""
-
-    out_list = []
-    idx = 0
-    for object in object_list:
-        try:
-            handler = getattr(object, method)
-        except AttributeError:
-            out_list.append(None)
-        else:
-            if argseq:
-                args = map(lambda lst:lst[idx],argseq)
-                #print 'ob',object,'hand',handler,'ar',args # dbg
-                out_list.append(handler(args,**kw))
-            else:
-                out_list.append(handler(**kw))
-        idx += 1
-    return out_list
-
-
-def import_fail_info(mod_name,fns=None):
-    """Inform load failure for a module."""
-
-    if fns == None:
-        warn("Loading of %s failed.\n" % (mod_name,))
-    else:
-        warn("Loading of %s from %s failed.\n" % (fns,mod_name))
-
-
-class NotGiven: pass
-
-def popkey(dct,key,default=NotGiven):
-    """Return dct[key] and delete dct[key].
-
-    If default is given, return it if dct[key] doesn't exist, otherwise raise
-    KeyError.  """
-
-    try:
-        val = dct[key]
-    except KeyError:
-        if default is NotGiven:
-            raise
-        else:
-            return default
-    else:
-        del dct[key]
-        return val
-
-
-def wrap_deprecated(func, suggest = '<nothing>'):
-    def newFunc(*args, **kwargs):
-        warnings.warn("Call to deprecated function %s, use %s instead" %
-                      ( func.__name__, suggest),
-                      category=DeprecationWarning,
-                      stacklevel = 2)
-        return func(*args, **kwargs)
-    return newFunc
-
-
diff --git a/IPython/utils/autoattr.py b/IPython/utils/autoattr.py
deleted file mode 100644
index 0536d988a0f..00000000000
--- a/IPython/utils/autoattr.py
+++ /dev/null
@@ -1,164 +0,0 @@
-"""Descriptor utilities.
-
-Utilities to support special Python descriptors [1,2], in particular the use of
-a useful pattern for properties we call 'one time properties'.  These are
-object attributes which are declared as properties, but become regular
-attributes once they've been read the first time.  They can thus be evaluated
-later in the object's life cycle, but once evaluated they become normal, static
-attributes with no function call overhead on access or any other constraints.
-
-A special ResetMixin class is provided to add a .reset() method to users who
-may want to have their objects capable of resetting these computed properties
-to their 'untriggered' state.
-
-References
-----------
-[1] How-To Guide for Descriptors, Raymond
-Hettinger. http://users.rcn.com/python/download/Descriptor.htm
-
-[2] Python data model, http://docs.python.org/reference/datamodel.html
-
-Notes
------
-This module is taken from the NiPy project 
-(http://neuroimaging.scipy.org/site/index.html), and is BSD licensed.
-
-Authors
--------
-- Fernando Perez.
-"""
-
-#-----------------------------------------------------------------------------
-# Classes and Functions
-#-----------------------------------------------------------------------------
-
-class ResetMixin(object):
-   """A Mixin class to add a .reset() method to users of OneTimeProperty.
-
-   By default, auto attributes once computed, become static.  If they happen to
-   depend on other parts of an object and those parts change, their values may
-   now be invalid.
-
-   This class offers a .reset() method that users can call *explicitly* when
-   they know the state of their objects may have changed and they want to
-   ensure that *all* their special attributes should be invalidated.  Once
-   reset() is called, all their auto attributes are reset to their
-   OneTimeProperty descriptors, and their accessor functions will be triggered
-   again.
-
-   Example
-   -------
-
-   >>> class A(ResetMixin):
-   ...     def __init__(self,x=1.0):
-   ...         self.x = x
-   ...
-   ...     @auto_attr
-   ...     def y(self):
-   ...         print '*** y computation executed ***'
-   ...         return self.x / 2.0
-   ... 
-
-   >>> a = A(10)
-
-   About to access y twice, the second time no computation is done:
-   >>> a.y
-   *** y computation executed ***
-   5.0
-   >>> a.y
-   5.0
-
-   Changing x
-   >>> a.x = 20
-   
-   a.y doesn't change to 10, since it is a static attribute:
-   >>> a.y
-   5.0
-
-   We now reset a, and this will then force all auto attributes to recompute
-   the next time we access them:
-   >>> a.reset()
-
-   About to access y twice again after reset():
-   >>> a.y
-   *** y computation executed ***
-   10.0
-   >>> a.y
-   10.0
-   """
-
-   def reset(self):
-      """Reset all OneTimeProperty attributes that may have fired already."""
-      instdict = self.__dict__
-      classdict = self.__class__.__dict__
-      # To reset them, we simply remove them from the instance dict.  At that
-      # point, it's as if they had never been computed.  On the next access,
-      # the accessor function from the parent class will be called, simply
-      # because that's how the python descriptor protocol works.
-      for mname, mval in classdict.items():
-         if mname in instdict and isinstance(mval, OneTimeProperty):
-            delattr(self, mname)
-
-
-class OneTimeProperty(object):
-   """A descriptor to make special properties that become normal attributes.
-
-   This is meant to be used mostly by the auto_attr decorator in this module.
-   """
-   def __init__(self,func):
-       """Create a OneTimeProperty instance.
-
-        Parameters
-        ----------
-          func : method
-          
-            The method that will be called the first time to compute a value.
-            Afterwards, the method's name will be a standard attribute holding
-            the value of this computation.
-            """
-       self.getter = func
-       self.name = func.func_name
-
-   def __get__(self,obj,type=None):
-       """This will be called on attribute access on the class or instance. """
-
-       if obj is None:
-           # Being called on the class, return the original function. This way,
-           # introspection works on the class.
-           #return func
-           return self.getter
-
-       val = self.getter(obj)
-       #print "** auto_attr - loading '%s'" % self.name  # dbg
-       setattr(obj, self.name, val)
-       return val
-
-
-def auto_attr(func):
-    """Decorator to create OneTimeProperty attributes.
-
-    Parameters
-    ----------
-      func : method
-        The method that will be called the first time to compute a value.
-        Afterwards, the method's name will be a standard attribute holding the
-        value of this computation.
-
-    Examples
-    --------
-    >>> class MagicProp(object):
-    ...     @auto_attr
-    ...     def a(self):
-    ...         return 99
-    ...     
-    >>> x = MagicProp()
-    >>> 'a' in x.__dict__
-    False
-    >>> x.a
-    99
-    >>> 'a' in x.__dict__
-    True
-    """
-    return OneTimeProperty(func)
-
-
diff --git a/IPython/utils/capture.py b/IPython/utils/capture.py
new file mode 100644
index 00000000000..39ce9ca55f7
--- /dev/null
+++ b/IPython/utils/capture.py
@@ -0,0 +1,170 @@
+# encoding: utf-8
+"""IO capturing utilities."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import sys
+from io import StringIO
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+class RichOutput:
+    def __init__(self, data=None, metadata=None, transient=None, update=False):
+        self.data = data or {}
+        self.metadata = metadata or {}
+        self.transient = transient or {}
+        self.update = update
+
+    def display(self):
+        from IPython.display import publish_display_data
+        publish_display_data(data=self.data, metadata=self.metadata,
+                             transient=self.transient, update=self.update)
+
+    def _repr_mime_(self, mime):
+        if mime not in self.data:
+            return
+        data = self.data[mime]
+        if mime in self.metadata:
+            return data, self.metadata[mime]
+        else:
+            return data
+
+    def _repr_mimebundle_(self, include=None, exclude=None):
+        return self.data, self.metadata
+
+    def _repr_html_(self):
+        return self._repr_mime_("text/html")
+
+    def _repr_latex_(self):
+        return self._repr_mime_("text/latex")
+
+    def _repr_json_(self):
+        return self._repr_mime_("application/json")
+
+    def _repr_javascript_(self):
+        return self._repr_mime_("application/javascript")
+
+    def _repr_png_(self):
+        return self._repr_mime_("image/png")
+
+    def _repr_jpeg_(self):
+        return self._repr_mime_("image/jpeg")
+
+    def _repr_svg_(self):
+        return self._repr_mime_("image/svg+xml")
+
+
+class CapturedIO:
+    """Simple object for containing captured stdout/err and rich display StringIO objects
+
+    Each instance `c` has three attributes:
+
+    - ``c.stdout`` : standard output as a string
+    - ``c.stderr`` : standard error as a string
+    - ``c.outputs``: a list of rich display outputs
+
+    Additionally, there's a ``c.show()`` method which will print all of the
+    above in the same order, and can be invoked simply via ``c()``.
+    """
+
+    def __init__(self, stdout, stderr, outputs=None):
+        self._stdout = stdout
+        self._stderr = stderr
+        if outputs is None:
+            outputs = []
+        self._outputs = outputs
+
+    def __str__(self):
+        return self.stdout
+
+    @property
+    def stdout(self):
+        "Captured standard output"
+        if not self._stdout:
+            return ''
+        return self._stdout.getvalue()
+
+    @property
+    def stderr(self):
+        "Captured standard error"
+        if not self._stderr:
+            return ''
+        return self._stderr.getvalue()
+
+    @property
+    def outputs(self):
+        """A list of the captured rich display outputs, if any.
+
+        If you have a CapturedIO object ``c``, these can be displayed in IPython
+        using::
+
+            from IPython.display import display
+            for o in c.outputs:
+                display(o)
+        """
+        return [ RichOutput(**kargs) for kargs in self._outputs ]
+
+    def show(self):
+        """write my output to sys.stdout/err as appropriate"""
+        sys.stdout.write(self.stdout)
+        sys.stderr.write(self.stderr)
+        sys.stdout.flush()
+        sys.stderr.flush()
+        for kargs in self._outputs:
+            RichOutput(**kargs).display()
+
+    __call__ = show
+
+
+class capture_output:
+    """context manager for capturing stdout/err"""
+    stdout = True
+    stderr = True
+    display = True
+
+    def __init__(self, stdout=True, stderr=True, display=True):
+        self.stdout = stdout
+        self.stderr = stderr
+        self.display = display
+        self.shell = None
+
+    def __enter__(self):
+        from IPython.core.getipython import get_ipython
+        from IPython.core.displaypub import CapturingDisplayPublisher
+        from IPython.core.displayhook import CapturingDisplayHook
+
+        self.sys_stdout = sys.stdout
+        self.sys_stderr = sys.stderr
+
+        if self.display:
+            self.shell = get_ipython()
+            if self.shell is None:
+                self.save_display_pub = None
+                self.display = False
+
+        stdout = stderr = outputs = None
+        if self.stdout:
+            stdout = sys.stdout = StringIO()
+        if self.stderr:
+            stderr = sys.stderr = StringIO()
+        if self.display:
+            self.save_display_pub = self.shell.display_pub
+            self.shell.display_pub = CapturingDisplayPublisher()
+            outputs = self.shell.display_pub.outputs
+            self.save_display_hook = sys.displayhook
+            sys.displayhook = CapturingDisplayHook(shell=self.shell,
+                                                   outputs=outputs)
+
+        return CapturedIO(stdout, stderr, outputs)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        sys.stdout = self.sys_stdout
+        sys.stderr = self.sys_stderr
+        if self.display and self.shell:
+            self.shell.display_pub = self.save_display_pub
+            sys.displayhook = self.save_display_hook
diff --git a/IPython/utils/codeutil.py b/IPython/utils/codeutil.py
deleted file mode 100644
index 31e03615a15..00000000000
--- a/IPython/utils/codeutil.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-"""Utilities to enable code objects to be pickled.
-
-Any process that import this module will be able to pickle code objects.  This
-includes the func_code attribute of any function.  Once unpickled, new 
-functions can be built using new.function(code, globals()).  Eventually
-we need to automate all of this so that functions themselves can be pickled.
-
-Reference: A. Tremols, P Cogolo, "Python Cookbook," p 302-305
-"""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import new, types, copy_reg
-
-def code_ctor(*args):
-    return new.code(*args)
-    
-def reduce_code(co):
-    if co.co_freevars or co.co_cellvars:
-        raise ValueError("Sorry, cannot pickle code objects with closures")
-    return code_ctor, (co.co_argcount, co.co_nlocals, co.co_stacksize,
-        co.co_flags, co.co_code, co.co_consts, co.co_names,
-        co.co_varnames, co.co_filename, co.co_name, co.co_firstlineno,
-        co.co_lnotab)
-
-copy_reg.pickle(types.CodeType, reduce_code)
\ No newline at end of file
diff --git a/IPython/utils/coloransi.py b/IPython/utils/coloransi.py
index cdc5a68c163..4d50d65d361 100644
--- a/IPython/utils/coloransi.py
+++ b/IPython/utils/coloransi.py
@@ -1,177 +1,9 @@
-# -*- coding: utf-8 -*-
-"""Tools for coloring text in ANSI terminals.
-"""
+# Deprecated/should be removed, but we break older version of ipyparallel
+# https://github.com/ipython/ipyparallel/pull/924
 
-#*****************************************************************************
-#       Copyright (C) 2002-2006 Fernando Perez. <fperez@colorado.edu>
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#*****************************************************************************
-
-__all__ = ['TermColors','InputTermColors','ColorScheme','ColorSchemeTable']
-
-import os
-
-from IPython.utils.ipstruct import Struct
-
-def make_color_table(in_class):
-    """Build a set of color attributes in a class.
-
-    Helper function for building the *TermColors classes."""
-    
-    color_templates = (
-        # Dark colors
-        ("Black"       , "0;30"),
-        ("Red"         , "0;31"),
-        ("Green"       , "0;32"),
-        ("Brown"       , "0;33"),
-        ("Blue"        , "0;34"),
-        ("Purple"      , "0;35"),
-        ("Cyan"        , "0;36"),
-        ("LightGray"   , "0;37"),
-        # Light colors
-        ("DarkGray"    , "1;30"),
-        ("LightRed"    , "1;31"),
-        ("LightGreen"  , "1;32"),
-        ("Yellow"      , "1;33"),
-        ("LightBlue"   , "1;34"),
-        ("LightPurple" , "1;35"),
-        ("LightCyan"   , "1;36"),
-        ("White"       , "1;37"),  
-        # Blinking colors.  Probably should not be used in anything serious.
-        ("BlinkBlack"  , "5;30"),
-        ("BlinkRed"    , "5;31"),
-        ("BlinkGreen"  , "5;32"),
-        ("BlinkYellow" , "5;33"),
-        ("BlinkBlue"   , "5;34"),
-        ("BlinkPurple" , "5;35"),
-        ("BlinkCyan"   , "5;36"),
-        ("BlinkLightGray", "5;37"),
-        )
-
-    for name,value in color_templates:
-        setattr(in_class,name,in_class._base % value)
 
+# minimal subset of TermColors, removed from IPython
+# not for public consumption, beyond ipyparallel.
 class TermColors:
-    """Color escape sequences.
-
-    This class defines the escape sequences for all the standard (ANSI?) 
-    colors in terminals. Also defines a NoColor escape which is just the null
-    string, suitable for defining 'dummy' color schemes in terminals which get
-    confused by color escapes.
-
-    This class should be used as a mixin for building color schemes."""
-    
-    NoColor = ''  # for color schemes in color-less terminals.
-    Normal = '\033[0m'   # Reset normal coloring
-    _base  = '\033[%sm'  # Template for all other colors
-
-# Build the actual color table as a set of class attributes:
-make_color_table(TermColors)
-
-class InputTermColors:
-    """Color escape sequences for input prompts.
-
-    This class is similar to TermColors, but the escapes are wrapped in \001
-    and \002 so that readline can properly know the length of each line and
-    can wrap lines accordingly.  Use this class for any colored text which
-    needs to be used in input prompts, such as in calls to raw_input().
-
-    This class defines the escape sequences for all the standard (ANSI?) 
-    colors in terminals. Also defines a NoColor escape which is just the null
-    string, suitable for defining 'dummy' color schemes in terminals which get
-    confused by color escapes.
-
-    This class should be used as a mixin for building color schemes."""
-    
-    NoColor = ''  # for color schemes in color-less terminals.
-
-    if os.name == 'nt' and os.environ.get('TERM','dumb') == 'emacs':
-        # (X)emacs on W32 gets confused with \001 and \002 so we remove them
-        Normal = '\033[0m'   # Reset normal coloring
-        _base  = '\033[%sm'  # Template for all other colors
-    else:
-        Normal = '\001\033[0m\002'   # Reset normal coloring
-        _base  = '\001\033[%sm\002'  # Template for all other colors
-
-# Build the actual color table as a set of class attributes:
-make_color_table(InputTermColors)
-
-class ColorScheme:
-    """Generic color scheme class. Just a name and a Struct."""
-    def __init__(self,__scheme_name_,colordict=None,**colormap):
-        self.name = __scheme_name_
-        if colordict is None:
-            self.colors = Struct(**colormap)
-        else:
-            self.colors = Struct(colordict)
-
-    def copy(self,name=None):
-        """Return a full copy of the object, optionally renaming it."""
-        if name is None:
-            name = self.name
-        return ColorScheme(name, self.colors.dict())
-        
-class ColorSchemeTable(dict):
-    """General class to handle tables of color schemes.
-
-    It's basically a dict of color schemes with a couple of shorthand
-    attributes and some convenient methods.
-    
-    active_scheme_name -> obvious
-    active_colors -> actual color table of the active scheme"""
-
-    def __init__(self,scheme_list=None,default_scheme=''):
-        """Create a table of color schemes.
-
-        The table can be created empty and manually filled or it can be
-        created with a list of valid color schemes AND the specification for
-        the default active scheme.
-        """
-        
-        # create object attributes to be set later
-        self.active_scheme_name = ''
-        self.active_colors = None
-        
-        if scheme_list:
-            if default_scheme == '':
-                raise ValueError,'you must specify the default color scheme'
-            for scheme in scheme_list:
-                self.add_scheme(scheme)
-            self.set_active_scheme(default_scheme)
-
-    def copy(self):
-        """Return full copy of object"""
-        return ColorSchemeTable(self.values(),self.active_scheme_name)
-
-    def add_scheme(self,new_scheme):
-        """Add a new color scheme to the table."""
-        if not isinstance(new_scheme,ColorScheme):
-            raise ValueError,'ColorSchemeTable only accepts ColorScheme instances'
-        self[new_scheme.name] = new_scheme
-        
-    def set_active_scheme(self,scheme,case_sensitive=0):
-        """Set the currently active scheme.
-
-        Names are by default compared in a case-insensitive way, but this can
-        be changed by setting the parameter case_sensitive to true."""
-
-        scheme_names = self.keys()
-        if case_sensitive:
-            valid_schemes = scheme_names
-            scheme_test = scheme
-        else:
-            valid_schemes = [s.lower() for s in scheme_names]
-            scheme_test = scheme.lower()
-        try:
-            scheme_idx = valid_schemes.index(scheme_test)
-        except ValueError:
-            raise ValueError,'Unrecognized color scheme: ' + scheme + \
-                  '\nValid schemes: '+str(scheme_names).replace("'', ",'')
-        else:
-            active = scheme_names[scheme_idx]
-            self.active_scheme_name = active
-            self.active_colors = self[active].colors
-            # Now allow using '' as an index for the current active scheme
-            self[''] = self[active]
+    Normal = "\033[0m"
+    Red = "\033[0;31m"
diff --git a/IPython/utils/contexts.py b/IPython/utils/contexts.py
new file mode 100644
index 00000000000..24e54b3e934
--- /dev/null
+++ b/IPython/utils/contexts.py
@@ -0,0 +1,60 @@
+# encoding: utf-8
+"""Miscellaneous context managers."""
+
+import warnings
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+class preserve_keys:
+    """Preserve a set of keys in a dictionary.
+
+    Upon entering the context manager the current values of the keys
+    will be saved. Upon exiting, the dictionary will be updated to
+    restore the original value of the preserved keys. Preserved keys
+    which did not exist when entering the context manager will be
+    deleted.
+
+    Examples
+    --------
+
+    >>> d = {'a': 1, 'b': 2, 'c': 3}
+    >>> with preserve_keys(d, 'b', 'c', 'd'):
+    ...     del d['a']
+    ...     del d['b']      # will be reset to 2
+    ...     d['c'] = None   # will be reset to 3
+    ...     d['d'] = 4      # will be deleted
+    ...     d['e'] = 5
+    ...     print(sorted(d.items()))
+    ...
+    [('c', None), ('d', 4), ('e', 5)]
+    >>> print(sorted(d.items()))
+    [('b', 2), ('c', 3), ('e', 5)]
+    """
+
+    def __init__(self, dictionary, *keys):
+        self.dictionary = dictionary
+        self.keys = keys
+
+    def __enter__(self):
+        # Actions to perform upon exiting.
+        to_delete = []
+        to_update = {}
+
+        d = self.dictionary
+        for k in self.keys:
+            if k in d:
+                to_update[k] = d[k]
+            else:
+                to_delete.append(k)
+
+        self.to_delete = to_delete
+        self.to_update = to_update
+
+    def __exit__(self, *exc_info):
+        d = self.dictionary
+
+        for k in self.to_delete:
+            d.pop(k, None)
+        d.update(self.to_update)
diff --git a/IPython/utils/cursesimport.py b/IPython/utils/cursesimport.py
deleted file mode 100644
index 94311208c26..00000000000
--- a/IPython/utils/cursesimport.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# encoding: utf-8
-"""
-See if we have curses.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-# Curses and termios are Unix-only modules
-try:
-    import curses
-    # We need termios as well, so if its import happens to raise, we bail on
-    # using curses altogether.
-    import termios
-except ImportError:
-    use_curses = False
-else:
-    # Curses on Solaris may not be complete, so we can't use it there
-    use_curses = hasattr(curses,'initscr')
\ No newline at end of file
diff --git a/IPython/utils/data.py b/IPython/utils/data.py
index ad6a8a5eb39..ab8ebb62026 100644
--- a/IPython/utils/data.py
+++ b/IPython/utils/data.py
@@ -3,104 +3,48 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+import warnings
+from collections.abc import Iterable, Sequence
+from typing import TypeVar
 
-import types
 
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
+T = TypeVar("T")
 
-def uniq_stable(elems):
+
+def uniq_stable(elems: Iterable[T]) -> list[T]:
     """uniq_stable(elems) -> list
 
+    .. deprecated:: 9.8
+        This function is deprecated and will be removed in a future version.
+        It is not used within IPython and was never part of the public API.
+
     Return from an iterable, a list of all the unique elements in the input,
     but maintaining the order in which they first appear.
 
-    A naive solution to this problem which just makes a dictionary with the
-    elements as keys fails to respect the stability condition, since
-    dictionaries are unsorted by nature.
-
-    Note: All elements in the input must be valid dictionary keys for this
-    routine to work, as it internally uses a dictionary for efficiency
-    reasons."""
-
-    unique = []
-    unique_dict = {}
-    for nn in elems:
-        if nn not in unique_dict:
-            unique.append(nn)
-            unique_dict[nn] = None
-    return unique
-
-
-def sort_compare(lst1, lst2, inplace=1):
-    """Sort and compare two lists.
-
-    By default it does it in place, thus modifying the lists. Use inplace = 0
-    to avoid that (at the cost of temporary copy creation)."""
-    if not inplace:
-        lst1 = lst1[:]
-        lst2 = lst2[:]
-    lst1.sort(); lst2.sort()
-    return lst1 == lst2
-
-
-def list2dict(lst):
-    """Takes a list of (key,value) pairs and turns it into a dict."""
-
-    dic = {}
-    for k,v in lst: dic[k] = v
-    return dic
-
-
-def list2dict2(lst, default=''):
-    """Takes a list and turns it into a dict.
-    Much slower than list2dict, but more versatile. This version can take
-    lists with sublists of arbitrary length (including sclars)."""
-
-    dic = {}
-    for elem in lst:
-        if type(elem) in (types.ListType,types.TupleType):
-            size = len(elem)
-            if  size == 0:
-                pass
-            elif size == 1:
-                dic[elem] = default
-            else:
-                k,v = elem[0], elem[1:]
-                if len(v) == 1: v = v[0]
-                dic[k] = v
-        else:
-            dic[elem] = default
-    return dic
-
-
-def flatten(seq):
-    """Flatten a list of lists (NOT recursive, only works for 2d lists)."""
-
-    return [x for subseq in seq for x in subseq]
-
-
-def get_slice(seq, start=0, stop=None, step=1):
-    """Get a slice of a sequence with variable step. Specify start,stop,step."""
-    if stop == None:
-        stop = len(seq)
-    item = lambda i: seq[i]
-    return map(item,xrange(start,stop,step))
-
-
-def chop(seq, size):
+    Note: All elements in the input must be hashable for this routine
+    to work, as it internally uses a set for efficiency reasons.
+    """
+    warnings.warn(
+        "uniq_stable is deprecated since IPython 9.8 and will be removed in a future version. "
+        "It was never part of the public API.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    seen: set[T] = set()
+    result: list[T] = []
+    for x in elems:
+        if x not in seen:
+            seen.add(x)
+            result.append(x)
+    return result
+
+
+def chop(seq: Sequence[T], size: int) -> list[Sequence[T]]:
     """Chop a sequence into chunks of the given size."""
-    chunk = lambda i: seq[i:i+size]
-    return map(chunk,xrange(0,len(seq),size))
-
-
+    return [seq[i : i + size] for i in range(0, len(seq), size)]
diff --git a/IPython/utils/decorators.py b/IPython/utils/decorators.py
index d468aa5e70b..3b685c5e46e 100644
--- a/IPython/utils/decorators.py
+++ b/IPython/utils/decorators.py
@@ -2,12 +2,12 @@
 """Decorators that don't go anywhere else.
 
 This module contains misc. decorators that don't really go with another module
-in :mod:`IPython.utils`. Beore putting something here please see if it should
+in :mod:`IPython.utils`. Before putting something here please see if it should
 go into another topical module in :mod:`IPython.utils`.
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -16,6 +16,10 @@
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
+from collections.abc import Sequence
+
+from IPython.utils.docs import GENERATING_DOCUMENTATION
+
 
 #-----------------------------------------------------------------------------
 # Code
@@ -33,6 +37,10 @@ def flag_calls(func):
 
     Testing for truth in wrapper.called allows you to determine if a call to
     func() was attempted and succeeded."""
+    
+    # don't wrap twice
+    if hasattr(func, 'called'):
+        return func
 
     def wrapper(*args,**kw):
         wrapper.called = False
@@ -44,3 +52,32 @@ def wrapper(*args,**kw):
     wrapper.__doc__ = func.__doc__
     return wrapper
 
+
+def undoc(func):
+    """Mark a function or class as undocumented.
+
+    This is found by inspecting the AST, so for now it must be used directly
+    as @undoc, not as e.g. @decorators.undoc
+    """
+    return func
+
+
+def sphinx_options(
+    show_inheritance: bool = True,
+    show_inherited_members: bool = False,
+    exclude_inherited_from: Sequence[str] = tuple(),
+):
+    """Set sphinx options"""
+
+    def wrapper(func):
+        if not GENERATING_DOCUMENTATION:
+            return func
+
+        func._sphinx_options = dict(
+            show_inheritance=show_inheritance,
+            show_inherited_members=show_inherited_members,
+            exclude_inherited_from=exclude_inherited_from,
+        )
+        return func
+
+    return wrapper
diff --git a/IPython/utils/dir2.py b/IPython/utils/dir2.py
index 363e579e414..de3730ed3a7 100644
--- a/IPython/utils/dir2.py
+++ b/IPython/utils/dir2.py
@@ -1,36 +1,29 @@
 # encoding: utf-8
-"""A fancy version of Python's builtin :func:`dir` function.
-"""
+"""A fancy version of Python's builtin :func:`dir` function."""
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+import inspect
+import types
 
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
 
-def get_class_members(cls):
-    ret = dir(cls)
-    if hasattr(cls,'__bases__'):
-        for base in cls.__bases__:
-            ret.extend(get_class_members(base))
-    return ret
+def safe_hasattr(obj, attr):
+    """In recent versions of Python, hasattr() only catches AttributeError.
+    This catches all errors.
+    """
+    try:
+        getattr(obj, attr)
+        return True
+    except:
+        return False
 
 
 def dir2(obj):
     """dir2(obj) -> list of strings
 
     Extended version of the Python builtin dir(), which does a few extra
-    checks, and supports common objects with unusual internals that confuse
-    dir(), such as Traits and PyCrust.
+    checks.
 
     This version is guaranteed to return only a list of true strings, whereas
     dir() returns anything that objects inject into themselves, even if they
@@ -40,43 +33,51 @@ def dir2(obj):
 
     # Start building the attribute list via dir(), and then complete it
     # with a few extra special-purpose calls.
-    words = dir(obj)
-
-    if hasattr(obj,'__class__'):
-        words.append('__class__')
-        words.extend(get_class_members(obj.__class__))
-    #if '__base__' in words: 1/0
-
-    # Some libraries (such as traits) may introduce duplicates, we want to
-    # track and clean this up if it happens
-    may_have_dupes = False
-
-    # this is the 'dir' function for objects with Enthought's traits
-    if hasattr(obj, 'trait_names'):
-        try:
-            words.extend(obj.trait_names())
-            may_have_dupes = True
-        except TypeError:
-            # This will happen if `obj` is a class and not an instance.
-            pass
-
-    # Support for PyCrust-style _getAttributeNames magic method.
-    if hasattr(obj, '_getAttributeNames'):
-        try:
-            words.extend(obj._getAttributeNames())
-            may_have_dupes = True
-        except TypeError:
-            # `obj` is a class and not an instance.  Ignore
-            # this error.
-            pass
-
-    if may_have_dupes:
-        # eliminate possible duplicates, as some traits may also
-        # appear as normal attributes in the dir() call.
-        words = list(set(words))
-        words.sort()
+
+    try:
+        words = set(dir(obj))
+    except Exception:
+        # TypeError: dir(obj) does not return a list
+        words = set()
+
+    if safe_hasattr(obj, "__class__"):
+        words |= set(dir(obj.__class__))
 
     # filter out non-string attributes which may be stuffed by dir() calls
     # and poor coding in third-party modules
-    return [w for w in words if isinstance(w, basestring)]
 
+    words = [w for w in words if isinstance(w, str)]
+    return sorted(words)
+
+
+def get_real_method(obj, name):
+    """Like getattr, but with a few extra sanity checks:
+
+    - If obj is a class, ignore everything except class methods
+    - Check if obj is a proxy that claims to have all attributes
+    - Catch attribute access failing with any exception
+    - Check that the attribute is a callable object
+
+    Returns the method or None.
+    """
+    try:
+        canary = getattr(obj, "_ipython_canary_method_should_not_exist_", None)
+    except Exception:
+        return None
+
+    if canary is not None:
+        # It claimed to have an attribute it should never have
+        return None
+
+    try:
+        m = getattr(obj, name, None)
+    except Exception:
+        return None
+
+    if inspect.isclass(obj) and not isinstance(m, types.MethodType):
+        return None
+
+    if callable(m):
+        return m
+
+    return None
diff --git a/IPython/utils/docs.py b/IPython/utils/docs.py
new file mode 100644
index 00000000000..6a97815cdc7
--- /dev/null
+++ b/IPython/utils/docs.py
@@ -0,0 +1,3 @@
+import os
+
+GENERATING_DOCUMENTATION = os.environ.get("IN_SPHINX_RUN", None) == "True"
diff --git a/IPython/utils/doctestreload.py b/IPython/utils/doctestreload.py
deleted file mode 100644
index b9fd7643a73..00000000000
--- a/IPython/utils/doctestreload.py
+++ /dev/null
@@ -1,75 +0,0 @@
-# encoding: utf-8
-"""
-A utility for handling the reloading of doctest.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-def dhook_wrap(func,*a,**k):
-    """Wrap a function call in a sys.displayhook controller.
-
-    Returns a wrapper around func which calls func, with all its arguments and
-    keywords unmodified, using the default sys.displayhook.  Since IPython
-    modifies sys.displayhook, it breaks the behavior of certain systems that
-    rely on the default behavior, notably doctest.
-    """
-
-    def f(*a,**k):
-
-        dhook_s = sys.displayhook
-        sys.displayhook = sys.__displayhook__
-        try:
-            out = func(*a,**k)
-        finally:
-            sys.displayhook = dhook_s
-
-        return out
-
-    f.__doc__ = func.__doc__
-    return f
-
-
-def doctest_reload():
-    """Properly reload doctest to reuse it interactively.
-
-    This routine:
-
-      - imports doctest but does NOT reload it (see below).
-
-      - resets its global 'master' attribute to None, so that multiple uses of
-      the module interactively don't produce cumulative reports.
-
-      - Monkeypatches its core test runner method to protect it from IPython's
-      modified displayhook.  Doctest expects the default displayhook behavior
-      deep down, so our modification breaks it completely.  For this reason, a
-      hard monkeypatch seems like a reasonable solution rather than asking
-      users to manually use a different doctest runner when under IPython.
-
-    Notes
-    -----
-
-    This function *used to* reload doctest, but this has been disabled because
-    reloading doctest unconditionally can cause massive breakage of other
-    doctest-dependent modules already in memory, such as those for IPython's
-    own testing system.  The name wasn't changed to avoid breaking people's
-    code, but the reload call isn't actually made anymore."""
-
-    import doctest
-    doctest.master = None
-    doctest.DocTestRunner.run = dhook_wrap(doctest.DocTestRunner.run)
-
diff --git a/IPython/utils/encoding.py b/IPython/utils/encoding.py
new file mode 100644
index 00000000000..d7f02bbddec
--- /dev/null
+++ b/IPython/utils/encoding.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+"""
+Utilities for dealing with text encodings
+"""
+
+from __future__ import annotations
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2008-2012  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import sys
+import locale
+import warnings
+from typing import Any, Literal
+
+
+# to deal with the possibility of sys.std* not being a stream at all
+def get_stream_enc(stream: Any, default: str | None = None) -> str | None:
+    """Return the given stream's encoding or a default.
+
+    There are cases where ``sys.std*`` might not actually be a stream, so
+    check for the encoding attribute prior to returning it, and return
+    a default if it doesn't exist or evaluates as False. ``default``
+    is None if not provided.
+    """
+    if not hasattr(stream, "encoding") or not stream.encoding:
+        return default
+    else:
+        return stream.encoding
+
+
+_sentinel: object = object()
+
+
+# Less conservative replacement for sys.getdefaultencoding, that will try
+# to match the environment.
+# Defined here as central function, so if we find better choices, we
+# won't need to make changes all over IPython.
+def getdefaultencoding(prefer_stream: object | bool = _sentinel) -> str:
+    """Return IPython's guess for the default encoding for bytes as text.
+
+    If prefer_stream is True (default), asks for stdin.encoding first,
+    to match the calling Terminal, but that is often None for subprocesses.
+
+    Then fall back on locale.getpreferredencoding(),
+    which should be a sensible platform default (that respects LANG environment),
+    and finally to sys.getdefaultencoding() which is the most conservative option,
+    and usually UTF8 as of Python 3.
+    """
+    if prefer_stream is not _sentinel:
+        warnings.warn(
+            "getpreferredencoding(prefer_stream=) argument is deprecated since "
+            "IPython 9.0, getdefaultencoding() will take no argument in the "
+            "future. If you rely on `prefer_stream`, please open an issue on "
+            "the IPython repo.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        prefer_stream = True
+    enc: str | None = None
+    if prefer_stream:
+        enc = get_stream_enc(sys.stdin)
+    if not enc or enc == "ascii":
+        try:
+            # There are reports of getpreferredencoding raising errors
+            # in some cases, which may well be fixed, but let's be conservative here.
+            enc = locale.getpreferredencoding()
+        except Exception:
+            pass
+    enc = enc or sys.getdefaultencoding()
+    # On windows `cp0` can be returned to indicate that there is no code page.
+    # Since cp0 is an invalid encoding return instead cp1252 which is the
+    # Western European default.
+    if enc == "cp0":
+        warnings.warn(
+            "Invalid code page cp0 detected - using cp1252 instead."
+            "If cp1252 is incorrect please ensure a valid code page "
+            "is defined for the process.",
+            RuntimeWarning,
+        )
+        return "cp1252"
+    return enc
+
+
+DEFAULT_ENCODING = getdefaultencoding()
diff --git a/IPython/utils/eventful.py b/IPython/utils/eventful.py
new file mode 100644
index 00000000000..837c6e03442
--- /dev/null
+++ b/IPython/utils/eventful.py
@@ -0,0 +1,5 @@
+from warnings import warn
+
+warn("IPython.utils.eventful has moved to traitlets.eventful", stacklevel=2)
+
+from traitlets.eventful import *
diff --git a/IPython/utils/frame.py b/IPython/utils/frame.py
index 9a077fec3de..3d0c1b71897 100644
--- a/IPython/utils/frame.py
+++ b/IPython/utils/frame.py
@@ -4,7 +4,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -15,6 +15,7 @@
 #-----------------------------------------------------------------------------
 
 import sys
+from typing import Any
 
 #-----------------------------------------------------------------------------
 # Code
@@ -23,38 +24,39 @@
 def extract_vars(*names,**kw):
     """Extract a set of variables by name from another frame.
 
-    :Parameters:
-      - `*names`: strings
+    Parameters
+    ----------
+    *names : str
         One or more variable names which will be extracted from the caller's
-    frame.
-
-    :Keywords:
-      - `depth`: integer (0)
+        frame.
+    **kw : integer, optional
         How many frames in the stack to walk when looking for your variables.
+        The default is 0, which will use the frame where the call was made.
 
-
-    Examples:
+    Examples
+    --------
+    ::
 
         In [2]: def func(x):
            ...:     y = 1
-           ...:     print extract_vars('x','y')
+           ...:     print(sorted(extract_vars('x','y').items()))
            ...:
 
         In [3]: func('hello')
-        {'y': 1, 'x': 'hello'}
+        [('x', 'hello'), ('y', 1)]
     """
 
     depth = kw.get('depth',0)
-    
+
     callerNS = sys._getframe(depth+1).f_locals
     return dict((k,callerNS[k]) for k in names)
 
 
-def extract_vars_above(*names):
+def extract_vars_above(*names: list[str]):
     """Extract a set of variables by name from another frame.
 
     Similar to extractVars(), but with a specified depth of 1, so that names
-    are exctracted exactly from above the caller.
+    are extracted exactly from above the caller.
 
     This is simply a convenience function so that the very common case (for us)
     of skipping exactly 1 frame doesn't have to construct a special dict for
@@ -64,7 +66,7 @@ def extract_vars_above(*names):
     return dict((k,callerNS[k]) for k in names)
 
 
-def debugx(expr,pre_msg=''):
+def debugx(expr: str, pre_msg: str = ""):
     """Print the value of an expression from the caller's frame.
 
     Takes an expression, evaluates it in the caller's frame and prints both
@@ -76,10 +78,17 @@ def debugx(expr,pre_msg=''):
     expr->value pair."""
 
     cf = sys._getframe(1)
-    print '[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
-                                   eval(expr,cf.f_globals,cf.f_locals))
+    print('[DBG:%s] %s%s -> %r' % (cf.f_code.co_name,pre_msg,expr,
+                                   eval(expr,cf.f_globals,cf.f_locals)))
 
 
 # deactivate it by uncommenting the following line, which makes it a no-op
 #def debugx(expr,pre_msg=''): pass
 
+
+def extract_module_locals(depth: int = 0) -> tuple[Any, Any]:
+    """Returns (module, locals) of the function `depth` frames away from the caller"""
+    f = sys._getframe(depth + 1)
+    global_ns = f.f_globals
+    module = sys.modules[global_ns['__name__']]
+    return (module, f.f_locals)
diff --git a/IPython/utils/generics.py b/IPython/utils/generics.py
index a482d498ca2..7680dce716d 100644
--- a/IPython/utils/generics.py
+++ b/IPython/utils/generics.py
@@ -1,36 +1,22 @@
 # encoding: utf-8
-"""Generic functions for extending IPython.
+"""Generic functions for extending IPython."""
 
-See http://cheeseshop.python.org/pypi/simplegeneric.
-"""
+from __future__ import annotations
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+from typing import Any
 
 from IPython.core.error import TryNext
-from IPython.external.simplegeneric import generic
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+from functools import singledispatch
 
 
-@generic
-def inspect_object(obj):
+@singledispatch
+def inspect_object(obj: Any) -> None:
     """Called when you do obj?"""
     raise TryNext
 
 
-@generic
-def complete_object(obj, prev_completions):
+@singledispatch
+def complete_object(obj: Any, prev_completions: list[str]) -> list[str]:
     """Custom completer dispatching for python objects.
 
     Parameters
@@ -39,11 +25,8 @@ def complete_object(obj, prev_completions):
         The object to complete.
     prev_completions : list
         List of attributes discovered so far.
-
     This should return the list of attributes in obj. If you only wish to
-    add to the attributes already discovered normally, return 
+    add to the attributes already discovered normally, return
     own_attrs + prev_completions.
     """
     raise TryNext
-
-
diff --git a/IPython/utils/growl.py b/IPython/utils/growl.py
deleted file mode 100644
index 71822b7a63b..00000000000
--- a/IPython/utils/growl.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# encoding: utf-8
-"""
-Utilities using Growl on OS X for notifications.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-class IPythonGrowlError(Exception):
-    pass
-
-class Notifier(object):
-
-    def __init__(self, app_name):
-        try:
-            import Growl
-        except ImportError:
-            self.g_notifier = None
-        else:
-            self.g_notifier =  Growl.GrowlNotifier(app_name, ['kernel', 'core'])
-            self.g_notifier.register()
-
-    def _notify(self, title, msg):
-        if self.g_notifier is not None:
-            self.g_notifier.notify('core', title, msg)        
-
-    def notify(self, title, msg):
-        self._notify(title, msg)
-
-    def notify_deferred(self, r, msg):
-        title = "Deferred Result"
-        msg = msg + '\n' + repr(r)
-        self._notify(title, msg)
-        return r
-
-_notifier = None
-
-def notify(title, msg):
-    pass
-
-def notify_deferred(r, msg):
-    return r
-
-def start(app_name):
-    global _notifier, notify, notify_deferred
-    if _notifier is not None:
-        raise IPythonGrowlError("this process is already registered with Growl")
-    else:
-        _notifier = Notifier(app_name)
-        notify = _notifier.notify
-        notify_deferred = _notifier.notify_deferred
-
-
diff --git a/IPython/utils/importstring.py b/IPython/utils/importstring.py
index e7e1da285db..6ff369cd308 100644
--- a/IPython/utils/importstring.py
+++ b/IPython/utils/importstring.py
@@ -1,43 +1,41 @@
 # encoding: utf-8
 """
 A simple utility to import something by its string name.
+"""
 
-Authors:
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-* Brian Granger
-"""
+from typing import Any
+
+
+def import_item(name: str) -> Any:
+    """Import and return ``bar`` given the string ``foo.bar``.
+
+    Calling ``bar = import_item("foo.bar")`` is the functional equivalent of
+    executing the code ``from foo import bar``.
+
+    Parameters
+    ----------
+    name : string
+        The fully qualified name of the module/package being imported.
+
+    Returns
+    -------
+    mod : module object
+        The module that was imported.
+    """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Functions and classes
-#-----------------------------------------------------------------------------
-
-def import_item(name):
-    """Import and return bar given the string foo.bar."""
-    package = '.'.join(name.split('.')[0:-1])
-    obj = name.split('.')[-1]
-    
-    # Note: the original code for this was the following.  We've left it
-    # visible for now in case the new implementation shows any problems down
-    # the road, to make it easier on anyone looking for a problem.  This code
-    # should be removed once we're comfortable we didn't break anything.
-    
-    ## execString = 'from %s import %s' % (package, obj)
-    ## try:
-    ##     exec execString
-    ## except SyntaxError:
-    ##     raise ImportError("Invalid class specification: %s" % name)
-    ## exec 'temp = %s' % obj
-    ## return temp
-
-    if package:
-        module = __import__(package,fromlist=[obj])
-        return module.__dict__[obj]
+    parts = name.rsplit(".", 1)
+    if len(parts) == 2:
+        # called with 'foo.bar....'
+        package, obj = parts
+        module = __import__(package, fromlist=[obj])
+        try:
+            pak = getattr(module, obj)
+        except AttributeError as e:
+            raise ImportError("No module named %s" % obj) from e
+        return pak
     else:
-        return __import__(obj)
+        # called with un-dotted string
+        return __import__(parts[0])
diff --git a/IPython/utils/io.py b/IPython/utils/io.py
index 1775b01d660..05889aba0cc 100644
--- a/IPython/utils/io.py
+++ b/IPython/utils/io.py
@@ -3,98 +3,23 @@
 IO related utilities.
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-import sys
-import tempfile
-
-from IPython.external.Itpl import itpl, printpl
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-class IOStream:
-
-    def __init__(self,stream, fallback=None):
-        if not hasattr(stream,'write') or not hasattr(stream,'flush'):
-            if fallback is not None:
-                stream = fallback
-            else:
-                raise ValueError("fallback required, but not specified")
-        self.stream = stream
-        self._swrite = stream.write
-        
-        # clone all methods not overridden:
-        def clone(meth):
-            return not hasattr(self, meth) and not meth.startswith('_')
-        for meth in filter(clone, dir(stream)):
-            setattr(self, meth, getattr(stream, meth))
-    
-    def write(self,data):
-        try:
-            self._swrite(data)
-        except:
-            try:
-                # print handles some unicode issues which may trip a plain
-                # write() call.  Emulate write() by using an empty end
-                # argument.
-                print(data, end='', file=self.stream)
-            except:
-                # if we get here, something is seriously broken.
-                print('ERROR - failed to write data to stream:', self.stream,
-                      file=sys.stderr)
-    
-    def writelines(self, lines):
-        if isinstance(lines, basestring):
-            lines = [lines]
-        for line in lines:
-            self.write(line)
-
-    # This class used to have a writeln method, but regular files and streams
-    # in Python don't have this method. We need to keep this completely
-    # compatible so we removed it.
-
-    @property
-    def closed(self):
-        return self.stream.closed
-    
-    def close(self):
-        pass
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 
-class IOTerm:
-    """ Term holds the file or file-like objects for handling I/O operations.
 
-    These are normally just sys.stdin, sys.stdout and sys.stderr but for
-    Windows they can can replaced to allow editing the strings before they are
-    displayed."""
-
-    # In the future, having IPython channel all its I/O operations through
-    # this class will make it easier to embed it into other environments which
-    # are not a normal terminal (such as a GUI-based shell)
-    def __init__(self, stdin=None, stdout=None, stderr=None):
-        self.stdin  = IOStream(stdin, sys.stdin)
-        self.stdout = IOStream(stdout, sys.stdout)
-        self.stderr = IOStream(stderr, sys.stderr)
+import atexit
+import os
+import sys
+import tempfile
+from pathlib import Path
+from warnings import warn
 
-# setup stdin/stdout/stderr to sys.stdin/sys.stdout/sys.stderr
-stdin = IOStream(sys.stdin)
-stdout = IOStream(sys.stdout)
-stderr = IOStream(sys.stderr)
+from IPython.utils.decorators import undoc
+from .capture import CapturedIO, capture_output
 
 
-class Tee(object):
+class Tee:
     """A class to duplicate an output stream to stdout/err.
 
     This works in a manner very similar to the Unix 'tee' command.
@@ -105,26 +30,25 @@ class Tee(object):
     # Inspired by:
     # http://mail.python.org/pipermail/python-list/2007-May/442737.html
 
-    def __init__(self, file_or_name, mode=None, channel='stdout'):
+    def __init__(self, file_or_name, mode="w", channel='stdout'):
         """Construct a new Tee object.
 
         Parameters
         ----------
         file_or_name : filename or open filehandle (writable)
-          File that will be duplicated
-
+            File that will be duplicated
         mode : optional, valid mode for open().
-          If a filename was give, open with this mode.
-
-        channel : str, one of ['stdout', 'stderr']  
+            If a filename was give, open with this mode.
+        channel : str, one of ['stdout', 'stderr']
         """
         if channel not in ['stdout', 'stderr']:
             raise ValueError('Invalid channel spec %s' % channel)
-        
-        if hasattr(file, 'write') and hasattr(file, 'seek'):
+
+        if hasattr(file_or_name, 'write') and hasattr(file_or_name, 'seek'):
             self.file = file_or_name
         else:
-            self.file = open(file_or_name, mode)
+            encoding = None if "b" in mode else "utf-8"
+            self.file = open(file_or_name, mode, encoding=encoding)
         self.channel = channel
         self.ostream = getattr(sys, channel)
         setattr(sys, channel, self)
@@ -152,70 +76,16 @@ def __del__(self):
         if not self._closed:
             self.close()
 
+    def isatty(self):
+        return False
 
-def file_read(filename):
-    """Read a file and close it.  Returns the file source."""
-    fobj = open(filename,'r');
-    source = fobj.read();
-    fobj.close()
-    return source
-
-
-def file_readlines(filename):
-    """Read a file and close it.  Returns the file source using readlines()."""
-    fobj = open(filename,'r');
-    lines = fobj.readlines();
-    fobj.close()
-    return lines
-
-
-def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'):
-    """Take multiple lines of input.
-
-    A list with each line of input as a separate element is returned when a
-    termination string is entered (defaults to a single '.'). Input can also
-    terminate via EOF (^D in Unix, ^Z-RET in Windows).
-
-    Lines of input which end in \\ are joined into single entries (and a
-    secondary continuation prompt is issued as long as the user terminates
-    lines with \\). This allows entering very long strings which are still
-    meant to be treated as single entities.
-    """
-
-    try:
-        if header:
-            header += '\n'
-        lines = [raw_input(header + ps1)]
-    except EOFError:
-        return []
-    terminate = [terminate_str]
-    try:
-        while lines[-1:] != terminate:
-            new_line = raw_input(ps1)
-            while new_line.endswith('\\'):
-                new_line = new_line[:-1] + raw_input(ps2)
-            lines.append(new_line)
-
-        return lines[:-1]  # don't return the termination command
-    except EOFError:
-        print
-        return lines
-
-
-def raw_input_ext(prompt='',  ps2='... '):
-    """Similar to raw_input(), but accepts extended lines if input ends with \\."""
-
-    line = raw_input(prompt)
-    while line.endswith('\\'):
-        line = line[:-1] + raw_input(ps2)
-    return line
-
-
-def ask_yes_no(prompt,default=None):
+def ask_yes_no(prompt, default=None, interrupt=None):
     """Asks a question and returns a boolean (y/n) answer.
 
     If default is given (one of 'y','n'), it is used if the user input is
-    empty. Otherwise the question is repeated until an answer is given.
+    empty. If interrupt is given (one of 'y','n'), it is used if the user
+    presses Ctrl-C. Otherwise the question is repeated until an answer is
+    given.
 
     An EOF is treated as the default answer.  If there is no default, an
     exception is raised to prevent infinite loops.
@@ -226,97 +96,40 @@ def ask_yes_no(prompt,default=None):
     ans = None
     while ans not in answers.keys():
         try:
-            ans = raw_input(prompt+' ').lower()
+            ans = input(prompt+' ').lower()
             if not ans:  # response was an empty string
                 ans = default
         except KeyboardInterrupt:
-            pass
+            if interrupt:
+                ans = interrupt
+            print("\r")
         except EOFError:
             if default in answers.keys():
                 ans = default
-                print
+                print()
             else:
                 raise
 
     return answers[ans]
 
 
-class NLprinter:
-    """Print an arbitrarily nested list, indicating index numbers.
-
-    An instance of this class called nlprint is available and callable as a
-    function.
-
-    nlprint(list,indent=' ',sep=': ') -> prints indenting each level by 'indent'
-    and using 'sep' to separate the index from the value. """
-
-    def __init__(self):
-        self.depth = 0
-
-    def __call__(self,lst,pos='',**kw):
-        """Prints the nested list numbering levels."""
-        kw.setdefault('indent',' ')
-        kw.setdefault('sep',': ')
-        kw.setdefault('start',0)
-        kw.setdefault('stop',len(lst))
-        # we need to remove start and stop from kw so they don't propagate
-        # into a recursive call for a nested list.
-        start = kw['start']; del kw['start']
-        stop = kw['stop']; del kw['stop']
-        if self.depth == 0 and 'header' in kw.keys():
-            print(kw['header'])
-
-        for idx in range(start,stop):
-            elem = lst[idx]
-            if type(elem)==type([]):
-                self.depth += 1
-                self.__call__(elem,itpl('$pos$idx,'),**kw)
-                self.depth -= 1
-            else:
-                printpl(kw['indent']*self.depth+'$pos$idx$kw["sep"]$elem')
-
-nlprint = NLprinter()
-
-
 def temp_pyfile(src, ext='.py'):
     """Make a temporary python file, return filename and filehandle.
 
     Parameters
     ----------
     src : string or list of strings (no need for ending newlines if list)
-      Source code to be written to the file.
-
+        Source code to be written to the file.
     ext : optional, string
-      Extension for the generated file.
+        Extension for the generated file.
 
     Returns
     -------
     (filename, open filehandle)
-      It is the caller's responsibility to close the open file and unlink it.
+        It is the caller's responsibility to close the open file and unlink it.
     """
     fname = tempfile.mkstemp(ext)[1]
-    f = open(fname,'w')
-    f.write(src)
-    f.flush()
-    return fname, f
-
-
-def raw_print(*args, **kw):
-    """Raw print to sys.__stdout__, otherwise identical interface to print()."""
-    
-    print(*args, sep=kw.get('sep', ' '), end=kw.get('end', '\n'),
-          file=sys.__stdout__)
-    sys.__stdout__.flush()
-
-
-def raw_print_err(*args, **kw):
-    """Raw print to sys.__stderr__, otherwise identical interface to print()."""
-    
-    print(*args, sep=kw.get('sep', ' '), end=kw.get('end', '\n'),
-          file=sys.__stderr__)
-    sys.__stderr__.flush()
-
-
-# Short aliases for quick debugging, do NOT use these in production code.
-rprint = raw_print
-rprinte = raw_print_err
+    with open(Path(fname), "w", encoding="utf-8") as f:
+        f.write(src)
+        f.flush()
+    return fname
diff --git a/IPython/utils/ipstruct.py b/IPython/utils/ipstruct.py
index e9898b1b653..ed112101a36 100644
--- a/IPython/utils/ipstruct.py
+++ b/IPython/utils/ipstruct.py
@@ -1,15 +1,14 @@
-#!/usr/bin/env python
 # encoding: utf-8
 """A dict subclass that supports attribute style access.
 
-Authors:  
+Authors:
 
 * Fernando Perez (original)
 * Brian Granger (refactoring to a dict subclass)
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -19,8 +18,6 @@
 # Imports
 #-----------------------------------------------------------------------------
 
-from IPython.utils.data import list2dict2
-
 __all__ = ['Struct']
 
 #-----------------------------------------------------------------------------
@@ -46,22 +43,21 @@ def __init__(self, *args, **kw):
 
         Parameters
         ----------
-        args : dict, Struct
+        *args : dict, Struct
             Initialize with one dict or Struct
-        kw : dict
+        **kw : dict
             Initialize with key, value pairs.
 
         Examples
         --------
-
         >>> s = Struct(a=10,b=30)
         >>> s.a
         10
         >>> s.b
         30
         >>> s2 = Struct(s,c=30)
-        >>> s2.keys()
-        ['a', 'c', 'b']
+        >>> sorted(s2.keys())
+        ['a', 'b', 'c']
         """
         object.__setattr__(self, '_allownew', True)
         dict.__init__(self, *args, **kw)
@@ -71,7 +67,6 @@ def __setitem__(self, key, value):
 
         Examples
         --------
-
         >>> s = Struct()
         >>> s['a'] = 10
         >>> s.allow_new_attr(False)
@@ -81,11 +76,11 @@ def __setitem__(self, key, value):
         >>> try:
         ...     s['b'] = 20
         ... except KeyError:
-        ...     print 'this is not allowed'
-        ...     
+        ...     print('this is not allowed')
+        ...
         this is not allowed
         """
-        if not self._allownew and not self.has_key(key):
+        if not self._allownew and key not in self:
             raise KeyError(
                 "can't create new attribute %s when allow_new_attr(False)" % key)
         dict.__setitem__(self, key, value)
@@ -93,12 +88,11 @@ def __setitem__(self, key, value):
     def __setattr__(self, key, value):
         """Set an attr with protection of class members.
 
-        This calls :meth:`self.__setitem__` but convert :exc:`KeyError` to 
+        This calls :meth:`self.__setitem__` but convert :exc:`KeyError` to
         :exc:`AttributeError`.
 
         Examples
         --------
-
         >>> s = Struct()
         >>> s.a = 10
         >>> s.a
@@ -106,14 +100,14 @@ def __setattr__(self, key, value):
         >>> try:
         ...     s.get = 10
         ... except AttributeError:
-        ...     print "you can't set a class member"
-        ...     
+        ...     print("you can't set a class member")
+        ...
         you can't set a class member
         """
         # If key is an str it might be a class member or instance var
         if isinstance(key, str):
             # I can't simply call hasattr here because it calls getattr, which
-            # calls self.__getattr__, which returns True for keys in 
+            # calls self.__getattr__, which returns True for keys in
             # self._data.  But I only want keys in the class and in
             # self.__dict__
             if key in self.__dict__ or hasattr(Struct, key):
@@ -122,63 +116,60 @@ def __setattr__(self, key, value):
                 )
         try:
             self.__setitem__(key, value)
-        except KeyError, e:
-            raise AttributeError(e)
+        except KeyError as e:
+            raise AttributeError(e) from e
 
     def __getattr__(self, key):
         """Get an attr by calling :meth:`dict.__getitem__`.
 
-        Like :meth:`__setattr__`, this method converts :exc:`KeyError` to 
+        Like :meth:`__setattr__`, this method converts :exc:`KeyError` to
         :exc:`AttributeError`.
 
         Examples
         --------
-
         >>> s = Struct(a=10)
         >>> s.a
         10
         >>> type(s.get)
-        <type 'builtin_function_or_method'>
+        <...method'>
         >>> try:
         ...     s.b
         ... except AttributeError:
-        ...     print "I don't have that key"
-        ...     
+        ...     print("I don't have that key")
+        ...
         I don't have that key
         """
         try:
             result = self[key]
-        except KeyError:
-            raise AttributeError(key)
+        except KeyError as e:
+            raise AttributeError(key) from e
         else:
             return result
 
     def __iadd__(self, other):
         """s += s2 is a shorthand for s.merge(s2).
-        
+
         Examples
         --------
-        
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s += s2
-        >>> s
-        {'a': 10, 'c': 40, 'b': 30}
+        >>> sorted(s.keys())
+        ['a', 'b', 'c']
         """
         self.merge(other)
         return self
 
     def __add__(self,other):
         """s + s2 -> New Struct made from s.merge(s2).
-        
+
         Examples
         --------
-        
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s = s1 + s2
-        >>> s
-        {'a': 10, 'c': 40, 'b': 30}
+        >>> sorted(s.keys())
+        ['a', 'b', 'c']
         """
         sout = self.copy()
         sout.merge(other)
@@ -186,10 +177,9 @@ def __add__(self,other):
 
     def __sub__(self,other):
         """s1 - s2 -> remove keys in s2 from s1.
-        
+
         Examples
         --------
-        
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=40)
         >>> s = s1 - s2
@@ -202,10 +192,9 @@ def __sub__(self,other):
 
     def __isub__(self,other):
         """Inplace remove keys from self that are in other.
-        
+
         Examples
         --------
-        
         >>> s1 = Struct(a=10,b=30)
         >>> s2 = Struct(a=40)
         >>> s1 -= s2
@@ -213,14 +202,14 @@ def __isub__(self,other):
         {'b': 30}
         """
         for k in other.keys():
-            if self.has_key(k):
+            if k in self:
                 del self[k]
         return self
 
     def __dict_invert(self, data):
-        """Helper function for merge. 
+        """Helper function for merge.
 
-        Takes a dictionary whose values are lists and returns a dict with 
+        Takes a dictionary whose values are lists and returns a dict with
         the elements of each list as keys and the original keys as values.
         """
         outdict = {}
@@ -236,16 +225,13 @@ def dict(self):
 
     def copy(self):
         """Return a copy as a Struct.
-        
+
         Examples
         --------
-        
         >>> s = Struct(a=10,b=30)
         >>> s2 = s.copy()
-        >>> s2
-        {'a': 10, 'b': 30}
-        >>> type(s2).__name__
-        'Struct'
+        >>> type(s2) is Struct
+        True
         """
         return Struct(dict.copy(self))
 
@@ -256,7 +242,6 @@ def hasattr(self, key):
 
         Examples
         --------
-
         >>> s = Struct(a=10)
         >>> s.hasattr('a')
         True
@@ -265,7 +250,7 @@ def hasattr(self, key):
         >>> s.hasattr('get')
         False
         """
-        return self.has_key(key)
+        return key in self
 
     def allow_new_attr(self, allow = True):
         """Set whether new attributes can be created in this Struct.
@@ -289,7 +274,7 @@ def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
 
         Parameters
         ----------
-        __loc_data : dict, Struct
+        __loc_data__ : dict, Struct
             The data to merge into self
         __conflict_solve : dict
             The conflict policy dict.  The keys are binary functions used to
@@ -297,22 +282,21 @@ def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
             the keys the conflict resolution function applies to.  Instead of
             a list of strings a space separated string can be used, like
             'a b c'.
-        kw : dict
+        **kw : dict
             Additional key, value pairs to merge in
 
         Notes
         -----
-
         The `__conflict_solve` dict is a dictionary of binary functions which will be used to
         solve key conflicts.  Here is an example::
-        
+
             __conflict_solve = dict(
                 func1=['a','b','c'],
                 func2=['d','e']
             )
-        
+
         In this case, the function :func:`func1` will be used to resolve
-        keys 'a', 'b' and 'c' and the function :func:`func2` will be used for 
+        keys 'a', 'b' and 'c' and the function :func:`func2` will be used for
         keys 'd' and 'e'.  This could also be written as::
 
             __conflict_solve = dict(func1='a b c',func2='d e')
@@ -343,23 +327,22 @@ def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
 
         Examples
         --------
-
         This show the default policy:
-        
+
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,c=40)
         >>> s.merge(s2)
-        >>> s
-        {'a': 10, 'c': 40, 'b': 30}
-        
+        >>> sorted(s.items())
+        [('a', 10), ('b', 30), ('c', 40)]
+
         Now, show how to specify a conflict dict:
-        
+
         >>> s = Struct(a=10,b=30)
         >>> s2 = Struct(a=20,b=40)
         >>> conflict = {'update':'a','add':'b'}
         >>> s.merge(s2,conflict)
-        >>> s
-        {'a': 20, 'b': 70}
+        >>> sorted(s.items())
+        [('a', 20), ('b', 70)]
         """
 
         data_dict = dict(__loc_data__,**kw)
@@ -373,7 +356,7 @@ def merge(self, __loc_data__=None, __conflict_solve=None, **kw):
         add_s    = lambda old,new: old + ' ' + new
 
         # default policy is to keep current keys when there's a conflict
-        conflict_solve = list2dict2(self.keys(), default = preserve)
+        conflict_solve = dict.fromkeys(self, preserve)
 
         # the conflict_solve dictionary is given by the user 'inverted': we
         # need a name-function mapping, it comes as a function -> names
diff --git a/IPython/utils/jsonutil.py b/IPython/utils/jsonutil.py
index f7b1f76407e..2672e09e169 100644
--- a/IPython/utils/jsonutil.py
+++ b/IPython/utils/jsonutil.py
@@ -1,90 +1,5 @@
-"""Utilities to manipulate JSON objects.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING.txt, distributed as part of this software.
-#-----------------------------------------------------------------------------
+from warnings import warn
 
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-# stdlib
-import types
+warn("IPython.utils.jsonutil has moved to jupyter_client.jsonutil", stacklevel=2)
 
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-def json_clean(obj):
-    """Clean an object to ensure it's safe to encode in JSON.
-    
-    Atomic, immutable objects are returned unmodified.  Sets and tuples are
-    converted to lists, lists are copied and dicts are also copied.
-
-    Note: dicts whose keys could cause collisions upon encoding (such as a dict
-    with both the number 1 and the string '1' as keys) will cause a ValueError
-    to be raised.
-
-    Parameters
-    ----------
-    obj : any python object
-
-    Returns
-    -------
-    out : object
-    
-      A version of the input which will not cause an encoding error when
-      encoded as JSON.  Note that this function does not *encode* its inputs,
-      it simply sanitizes it so that there will be no encoding errors later.
-
-    Examples
-    --------
-    >>> json_clean(4)
-    4
-    >>> json_clean(range(10))
-    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-    >>> json_clean(dict(x=1, y=2))
-    {'y': 2, 'x': 1}
-    >>> json_clean(dict(x=1, y=2, z=[1,2,3]))
-    {'y': 2, 'x': 1, 'z': [1, 2, 3]}
-    >>> json_clean(True)
-    True
-    """
-    # types that are 'atomic' and ok in json as-is.  bool doesn't need to be
-    # listed explicitly because bools pass as int instances
-    atomic_ok = (basestring, int, float, types.NoneType)
-    
-    # containers that we need to convert into lists
-    container_to_list = (tuple, set, types.GeneratorType)
-    
-    if isinstance(obj, atomic_ok):
-        return obj
-
-    if isinstance(obj, container_to_list) or (
-        hasattr(obj, '__iter__') and hasattr(obj, 'next')):
-        obj = list(obj)
-        
-    if isinstance(obj, list):
-        return [json_clean(x) for x in obj]
-
-    if isinstance(obj, dict):
-        # First, validate that the dict won't lose data in conversion due to
-        # key collisions after stringification.  This can happen with keys like
-        # True and 'true' or 1 and '1', which collide in JSON.
-        nkeys = len(obj)
-        nkeys_collapsed = len(set(map(str, obj)))
-        if nkeys != nkeys_collapsed:
-            raise ValueError('dict can not be safely converted to JSON: '
-                             'key collision would lead to dropped values')
-        # If all OK, proceed by making the new dict that will be json-safe
-        out = {}
-        for k,v in obj.iteritems():
-            out[str(k)] = json_clean(v)
-        return out
-
-    # If we get here, we don't know how to handle the object, so we just get
-    # its repr and return that.  This will catch lambdas, open sockets, class
-    # objects, and any other complicated contraption that json can't encode
-    return repr(obj)
+from jupyter_client.jsonutil import *
diff --git a/IPython/utils/localinterfaces.py b/IPython/utils/localinterfaces.py
deleted file mode 100644
index 49452231923..00000000000
--- a/IPython/utils/localinterfaces.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""Simple utility for building a list of local IPs using the socket module.
-This module defines two constants:
-
-LOCALHOST : The loopback interface, or the first interface that points to this 
-            machine.  It will *almost* always be '127.0.0.1'
-
-LOCAL_IPS : A list of IP addresses, loopback first, that point to this machine.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import socket
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-LOCAL_IPS = []
-try:
-    LOCAL_IPS = socket.gethostbyname_ex('localhost')[2]
-except socket.gaierror:
-    pass
-
-try:
-    LOCAL_IPS.extend(socket.gethostbyname_ex(socket.gethostname())[2])
-except socket.gaierror:
-    pass
-
-# include all-interface aliases: 0.0.0.0 and ''
-LOCAL_IPS.extend(['0.0.0.0', ''])
-
-LOCALHOST = LOCAL_IPS[0]
diff --git a/IPython/utils/log.py b/IPython/utils/log.py
new file mode 100644
index 00000000000..f9dea91ce90
--- /dev/null
+++ b/IPython/utils/log.py
@@ -0,0 +1,5 @@
+from warnings import warn
+
+warn("IPython.utils.log has moved to traitlets.log", stacklevel=2)
+
+from traitlets.log import *
diff --git a/IPython/utils/module_paths.py b/IPython/utils/module_paths.py
new file mode 100644
index 00000000000..1e43457e3ed
--- /dev/null
+++ b/IPython/utils/module_paths.py
@@ -0,0 +1,78 @@
+"""Utility functions for finding modules
+
+Utility functions for finding modules on sys.path.
+
+"""
+from __future__ import annotations
+
+#-----------------------------------------------------------------------------
+# Copyright (c) 2011, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib imports
+import importlib
+import importlib.abc
+import importlib.util
+import sys
+
+# Third-party imports
+
+# Our own imports
+
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Local utilities
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+def find_mod(module_name: str) -> str | None | importlib.abc.Loader:
+    """
+    Find module `module_name` on sys.path, and return the path to module `module_name`.
+
+    * If `module_name` refers to a module directory, then return path to `__init__` file.
+        * If `module_name` is a directory without an __init__file, return None.
+
+    * If module is missing or does not have a `.py` or `.pyw` extension, return None.
+        * Note that we are not interested in running bytecode.
+
+    * Otherwise, return the fill path of the module.
+
+    Parameters
+    ----------
+    module_name : str
+
+    Returns
+    -------
+    module_path : str
+        Path to module `module_name`, its __init__.py, or None,
+        depending on above conditions.
+    """
+    spec = importlib.util.find_spec(module_name)
+    if spec is None:
+        return None
+    module_path = spec.origin
+    if module_path is None:
+        if spec.loader is not None and spec.loader in sys.meta_path:
+            return spec.loader
+        return None
+    else:
+        split_path = module_path.split(".")
+        if split_path[-1] in ["py", "pyw"]:
+            return module_path
+        else:
+            return None
diff --git a/IPython/utils/newserialized.py b/IPython/utils/newserialized.py
deleted file mode 100644
index 8fcab1fafdf..00000000000
--- a/IPython/utils/newserialized.py
+++ /dev/null
@@ -1,169 +0,0 @@
-# encoding: utf-8
-# -*- test-case-name: IPython.kernel.test.test_newserialized -*-
-
-"""Refactored serialization classes and interfaces."""
-
-__docformat__ = "restructuredtext en"
-
-# Tell nose to skip this module
-__test__ = {}
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import cPickle as pickle
-
-try:
-    import numpy
-except ImportError:
-    pass
-
-class SerializationError(Exception):
-    pass
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class ISerialized:
-    
-    def getData():
-        """"""
-
-    def getDataSize(units=10.0**6):
-        """"""
-
-    def getTypeDescriptor():
-        """"""
-
-    def getMetadata():
-        """"""
-        
-        
-class IUnSerialized:
-    
-    def getObject():
-        """"""
-        
-class Serialized(object):
-    
-    # implements(ISerialized)
-    
-    def __init__(self, data, typeDescriptor, metadata={}):
-        self.data = data
-        self.typeDescriptor = typeDescriptor
-        self.metadata = metadata
-        
-    def getData(self):
-        return self.data
-        
-    def getDataSize(self, units=10.0**6):
-        return len(self.data)/units
-        
-    def getTypeDescriptor(self):
-        return self.typeDescriptor
-        
-    def getMetadata(self):
-        return self.metadata
-
-        
-class UnSerialized(object):
-    
-    # implements(IUnSerialized)
-        
-    def __init__(self, obj):
-        self.obj = obj
-        
-    def getObject(self):
-        return self.obj
-
-        
-class SerializeIt(object):
-    
-    # implements(ISerialized)
-    
-    def __init__(self, unSerialized):
-        self.data = None
-        self.obj = unSerialized.getObject()
-        if globals().has_key('numpy') and isinstance(self.obj, numpy.ndarray):
-            if len(self.obj.shape) == 0: # length 0 arrays are just pickled
-                self.typeDescriptor = 'pickle'
-                self.metadata = {}
-            else:
-                self.obj = numpy.ascontiguousarray(self.obj, dtype=None)
-                self.typeDescriptor = 'ndarray'
-                self.metadata = {'shape':self.obj.shape,
-                                 'dtype':self.obj.dtype.str}
-        elif isinstance(self.obj, str):
-            self.typeDescriptor = 'bytes'
-            self.metadata = {}
-        elif isinstance(self.obj, buffer):
-            self.typeDescriptor = 'buffer'
-            self.metadata = {}
-        else:
-            self.typeDescriptor = 'pickle'
-            self.metadata = {}
-        self._generateData()
-    
-    def _generateData(self):
-        if self.typeDescriptor == 'ndarray':
-            self.data = numpy.getbuffer(self.obj)
-        elif self.typeDescriptor in ('bytes', 'buffer'):
-            self.data = self.obj
-        elif self.typeDescriptor == 'pickle':
-            self.data = pickle.dumps(self.obj, -1)
-        else:
-            raise SerializationError("Really wierd serialization error.")
-        del self.obj
-        
-    def getData(self):
-        return self.data
-        
-    def getDataSize(self, units=10.0**6):
-        return 1.0*len(self.data)/units
-        
-    def getTypeDescriptor(self):
-        return self.typeDescriptor
-        
-    def getMetadata(self):
-        return self.metadata
-
-
-class UnSerializeIt(UnSerialized):
-    
-    # implements(IUnSerialized)
-    
-    def __init__(self, serialized):
-        self.serialized = serialized
-        
-    def getObject(self):
-        typeDescriptor = self.serialized.getTypeDescriptor()
-        if globals().has_key('numpy') and typeDescriptor == 'ndarray':
-                buf = self.serialized.getData()
-                if isinstance(buf, (str, buffer)):
-                    result = numpy.frombuffer(buf, dtype = self.serialized.metadata['dtype'])
-                else:
-                    # memoryview
-                    result = numpy.array(buf, dtype = self.serialized.metadata['dtype'])
-                result.shape = self.serialized.metadata['shape']
-        elif typeDescriptor == 'pickle':
-            result = pickle.loads(self.serialized.getData())
-        elif typeDescriptor in ('bytes', 'buffer'):
-            result = self.serialized.getData()
-        else:
-            raise SerializationError("Really wierd serialization error.")
-        return result
-
-def serialize(obj):
-    return SerializeIt(UnSerialized(obj))
-    
-def unserialize(serialized):
-    return UnSerializeIt(serialized).getObject()
diff --git a/IPython/utils/notification.py b/IPython/utils/notification.py
deleted file mode 100644
index ef15111b039..00000000000
--- a/IPython/utils/notification.py
+++ /dev/null
@@ -1,143 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-The IPython Core Notification Center.
-
-See docs/source/development/notification_blueprint.txt for an overview of the
-notification module.
-
-Authors:
-
-* Barry Wark
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-class NotificationError(Exception):
-    pass
-
-
-class NotificationCenter(object):
-    """Synchronous notification center.
-    
-    Examples
-    --------
-    Here is a simple example of how to use this::
-
-        import IPython.util.notification as notification
-        def callback(ntype, theSender, args={}):
-            print ntype,theSender,args
-
-        notification.sharedCenter.add_observer(callback, 'NOTIFICATION_TYPE', None)
-        notification.sharedCenter.post_notification('NOTIFICATION_TYPE', object()) # doctest:+ELLIPSIS
-        NOTIFICATION_TYPE ...
-    """
-    def __init__(self):
-        super(NotificationCenter, self).__init__()
-        self._init_observers()
-
-    def _init_observers(self):
-        """Initialize observer storage"""
-
-        self.registered_types = set() #set of types that are observed
-        self.registered_senders = set() #set of senders that are observed
-        self.observers = {} #map (type,sender) => callback (callable)
-
-    def post_notification(self, ntype, sender, *args, **kwargs):
-        """Post notification to all registered observers.
-
-        The registered callback will be called as::
-
-            callback(ntype, sender, *args, **kwargs)
-
-        Parameters
-        ----------
-        ntype : hashable
-            The notification type.
-        sender : hashable
-            The object sending the notification.
-        *args : tuple
-            The positional arguments to be passed to the callback.
-        **kwargs : dict
-            The keyword argument to be passed to the callback.
-
-        Notes
-        -----
-        * If no registered observers, performance is O(1).
-        * Notificaiton order is undefined.
-        * Notifications are posted synchronously.
-        """
-
-        if(ntype==None or sender==None):
-            raise NotificationError(
-                "Notification type and sender are required.")
-
-        # If there are no registered observers for the type/sender pair
-        if((ntype not in self.registered_types and 
-                None not in self.registered_types) or
-            (sender not in self.registered_senders and 
-                None not in self.registered_senders)):
-            return
-
-        for o in self._observers_for_notification(ntype, sender):
-            o(ntype, sender, *args, **kwargs)
-
-    def _observers_for_notification(self, ntype, sender):
-        """Find all registered observers that should recieve notification"""
-
-        keys = (
-                   (ntype,sender),
-                   (ntype, None),
-                   (None, sender),
-                   (None,None)
-               )
-
-        obs = set()
-        for k in keys:
-            obs.update(self.observers.get(k, set()))
-
-        return obs
-
-    def add_observer(self, callback, ntype, sender):
-        """Add an observer callback to this notification center.
-        
-        The given callback will be called upon posting of notifications of
-        the given type/sender and will receive any additional arguments passed
-        to post_notification.
-        
-        Parameters
-        ----------
-        callback : callable
-            The callable that will be called by :meth:`post_notification`
-            as ``callback(ntype, sender, *args, **kwargs)
-        ntype : hashable
-            The notification type. If None, all notifications from sender
-            will be posted.
-        sender : hashable
-            The notification sender. If None, all notifications of ntype
-            will be posted.
-        """
-        assert(callback != None)
-        self.registered_types.add(ntype)
-        self.registered_senders.add(sender)
-        self.observers.setdefault((ntype,sender), set()).add(callback)
-    
-    def remove_all_observers(self):
-        """Removes all observers from this notification center"""
-        
-        self._init_observers()
-    
-
-
-shared_center = NotificationCenter()
diff --git a/IPython/utils/openpy.py b/IPython/utils/openpy.py
new file mode 100644
index 00000000000..7876a1a4988
--- /dev/null
+++ b/IPython/utils/openpy.py
@@ -0,0 +1,104 @@
+"""
+Tools to open .py files as Unicode, using the encoding specified within the file,
+as per PEP 263.
+
+Much of the code is taken from the tokenize module in Python 3.2.
+"""
+
+import io
+from io import TextIOWrapper, BytesIO
+from pathlib import Path
+import re
+from tokenize import open, detect_encoding
+
+cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)", re.UNICODE)
+cookie_comment_re = re.compile(r"^\s*#.*coding[:=]\s*([-\w.]+)", re.UNICODE)
+
+def source_to_unicode(txt, errors='replace', skip_encoding_cookie=True):
+    """Converts a bytes string with python source code to unicode.
+
+    Unicode strings are passed through unchanged. Byte strings are checked
+    for the python source file encoding cookie to determine encoding.
+    txt can be either a bytes buffer or a string containing the source
+    code.
+    """
+    if isinstance(txt, str):
+        return txt
+    if isinstance(txt, bytes):
+        buffer = BytesIO(txt)
+    else:
+        buffer = txt
+    try:
+        encoding, _ = detect_encoding(buffer.readline)
+    except SyntaxError:
+        encoding = "ascii"
+    buffer.seek(0)
+    with TextIOWrapper(buffer, encoding, errors=errors, line_buffering=True) as text:
+        text.mode = 'r'
+        if skip_encoding_cookie:
+            return u"".join(strip_encoding_cookie(text))
+        else:
+            return text.read()
+
+def strip_encoding_cookie(filelike):
+    """Generator to pull lines from a text-mode file, skipping the encoding
+    cookie if it is found in the first two lines.
+    """
+    it = iter(filelike)
+    try:
+        first = next(it)
+        if not cookie_comment_re.match(first):
+            yield first
+        second = next(it)
+        if not cookie_comment_re.match(second):
+            yield second
+    except StopIteration:
+        return
+    
+    yield from it
+
+def read_py_file(filename, skip_encoding_cookie=True):
+    """Read a Python file, using the encoding declared inside the file.
+
+    Parameters
+    ----------
+    filename : str
+        The path to the file to read.
+    skip_encoding_cookie : bool
+        If True (the default), and the encoding declaration is found in the first
+        two lines, that line will be excluded from the output.
+
+    Returns
+    -------
+    A unicode string containing the contents of the file.
+    """
+    filepath = Path(filename)
+    with open(filepath) as f:  # the open function defined in this module.
+        if skip_encoding_cookie:
+            return "".join(strip_encoding_cookie(f))
+        else:
+            return f.read()
+
+def read_py_url(url, errors='replace', skip_encoding_cookie=True):
+    """Read a Python file from a URL, using the encoding declared inside the file.
+
+    Parameters
+    ----------
+    url : str
+        The URL from which to fetch the file.
+    errors : str
+        How to handle decoding errors in the file. Options are the same as for
+        bytes.decode(), but here 'replace' is the default.
+    skip_encoding_cookie : bool
+        If True (the default), and the encoding declaration is found in the first
+        two lines, that line will be excluded from the output.
+
+    Returns
+    -------
+    A unicode string containing the contents of the file.
+    """
+    # Deferred import for faster start
+    from urllib.request import urlopen 
+    response = urlopen(url)
+    buffer = io.BytesIO(response.read())
+    return source_to_unicode(buffer, errors, skip_encoding_cookie)
diff --git a/IPython/utils/path.py b/IPython/utils/path.py
index ddae611057d..2e93d6976f6 100644
--- a/IPython/utils/path.py
+++ b/IPython/utils/path.py
@@ -3,41 +3,27 @@
 Utilities for path handling.
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import os
 import sys
+import errno
+import shutil
+import random
+import glob
+import warnings
 
-import IPython
 from IPython.utils.process import system
-from IPython.utils.importstring import import_item
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
-
 fs_encoding = sys.getfilesystemencoding()
 
-def _cast_unicode(s, enc=None):
-    """Turn 8-bit strings into unicode."""
-    if isinstance(s, bytes):
-        enc = enc or sys.getdefaultencoding()
-        return s.decode(enc)
-    return s
-
-
-def _get_long_path_name(path):
-    """Dummy no-op."""
-    return path
+def _writable_dir(path):
+    """Whether `path` is a directory, to which the user has write access."""
+    return os.path.isdir(path) and os.access(path, os.W_OK)
 
 if sys.platform == 'win32':
     def _get_long_path_name(path):
@@ -46,14 +32,14 @@ def _get_long_path_name(path):
         Examples
         --------
 
-        >>> get_long_path_name('c:\\docume~1')
-        u'c:\\\\Documents and Settings'
+        >>> get_long_path_name('c:\\\\docume~1')
+        'c:\\\\Documents and Settings'
 
         """
         try:
             import ctypes
-        except ImportError:
-            raise ImportError('you need to have ctypes installed for this to work')
+        except ImportError as e: 
+            raise ImportError('you need to have ctypes installed for this to work') from e
         _GetLongPathName = ctypes.windll.kernel32.GetLongPathNameW
         _GetLongPathName.argtypes = [ctypes.c_wchar_p, ctypes.c_wchar_p,
             ctypes.c_uint ]
@@ -64,6 +50,11 @@ def _get_long_path_name(path):
             return path
         else:
             return buf.value
+else:
+    def _get_long_path_name(path):
+        """Dummy no-op."""
+        return path
+
 
 
 def get_long_path_name(path):
@@ -75,26 +66,35 @@ def get_long_path_name(path):
     return _get_long_path_name(path)
 
 
+def compress_user(path: str) -> str:
+    """Reverse of :func:`os.path.expanduser`"""
+    home = os.path.expanduser("~")
+    if path.startswith(home):
+        path =  "~" + path[len(home):]
+    return path
+
 def get_py_filename(name):
     """Return a valid python filename in the current directory.
 
     If the given name is not a file, it adds '.py' and searches again.
-    Raises IOError with an informative message if the file isn't found."""
+    Raises IOError with an informative message if the file isn't found.
+    """
 
     name = os.path.expanduser(name)
-    if not os.path.isfile(name) and not name.endswith('.py'):
-        name += '.py'
     if os.path.isfile(name):
         return name
-    else:
-        raise IOError,'File `%s` not found.' % name
+    if not name.endswith(".py"):
+        py_name = name + ".py"
+        if os.path.isfile(py_name):
+            return py_name
+    raise IOError("File `%r` not found." % name)
 
 
-def filefind(filename, path_dirs=None):
+def filefind(filename: str, path_dirs=None) -> str:
     """Find a file by looking through a sequence of paths.
 
     This iterates through a sequence of paths looking for a file and returns
-    the full, absolute path of the first occurence of the file.  If no set of
+    the full, absolute path of the first occurrence of the file.  If no set of
     path dirs is given, the filename is tested as is, after running through
     :func:`expandvars` and :func:`expanduser`.  Thus a simple call::
 
@@ -106,7 +106,7 @@ def filefind(filename, path_dirs=None):
 
     Will find the file in the users home directory.  This function does not
     automatically try any paths, such as the cwd or the user's home directory.
-    
+
     Parameters
     ----------
     filename : str
@@ -117,30 +117,35 @@ def filefind(filename, path_dirs=None):
         put into a sequence and the searched.  If a sequence, walk through
         each element and join with ``filename``, calling :func:`expandvars`
         and :func:`expanduser` before testing for existence.
-        
+
     Returns
     -------
-    Raises :exc:`IOError` or returns absolute path to file.
+    path : str
+        returns absolute path to file.
+
+    Raises
+    ------
+    IOError
     """
-    
+
     # If paths are quoted, abspath gets confused, strip them...
     filename = filename.strip('"').strip("'")
     # If the input is an absolute path, just check it exists
     if os.path.isabs(filename) and os.path.isfile(filename):
         return filename
-        
+
     if path_dirs is None:
         path_dirs = ("",)
-    elif isinstance(path_dirs, basestring):
+    elif isinstance(path_dirs, str):
         path_dirs = (path_dirs,)
-        
+
     for path in path_dirs:
         if path == '.': path = os.getcwd()
         testname = expand_path(os.path.join(path, filename))
         if os.path.isfile(testname):
             return os.path.abspath(testname)
-        
-    raise IOError("File %r does not exist in any of the search paths: %r" % 
+
+    raise IOError("File %r does not exist in any of the search paths: %r" %
                   (filename, path_dirs) )
 
 
@@ -148,204 +153,92 @@ class HomeDirError(Exception):
     pass
 
 
-def get_home_dir():
-    """Return the closest possible equivalent to a 'home' directory.
-
-    * On POSIX, we try $HOME.
-    * On Windows we try:
-      - %HOMESHARE%
-      - %HOMEDRIVE\%HOMEPATH%
-      - %USERPROFILE%
-      - Registry hack for My Documents
-      - %HOME%: rare, but some people with unix-like setups may have defined it
-    * On Dos C:\
- 
-    Currently only Posix and NT are implemented, a HomeDirError exception is
-    raised for all other OSes.
-    """
+def get_home_dir(require_writable=False) -> str:
+    """Return the 'home' directory, as a unicode string.
 
-    isdir = os.path.isdir
-    env = os.environ
+    Uses os.path.expanduser('~'), and checks for writability.
 
-    # first, check py2exe distribution root directory for _ipython.
-    # This overrides all. Normally does not exist.
-
-    if hasattr(sys, "frozen"): #Is frozen by py2exe
-        if '\\library.zip\\' in IPython.__file__.lower():#libraries compressed to zip-file
-            root, rest = IPython.__file__.lower().split('library.zip')
-        else: 
-            root=os.path.join(os.path.split(IPython.__file__)[0],"../../")
-        root=os.path.abspath(root).rstrip('\\')
-        if isdir(os.path.join(root, '_ipython')):
-            os.environ["IPYKITROOT"] = root
-        return _cast_unicode(root, fs_encoding)
-
-    if os.name == 'posix':
-        # Linux, Unix, AIX, OS X
-        try:
-            homedir = env['HOME']
-        except KeyError:
-            # Last-ditch attempt at finding a suitable $HOME, on systems where
-            # it may not be defined in the environment but the system shell
-            # still knows it - reported once as:
-            # https://github.com/ipython/ipython/issues/154
-            from subprocess import Popen, PIPE
-            homedir = Popen('echo $HOME', shell=True, 
-                            stdout=PIPE).communicate()[0].strip()
-            if homedir:
-                return _cast_unicode(homedir, fs_encoding)
-            else:
-                raise HomeDirError('Undefined $HOME, IPython cannot proceed.')
-        else:
-            return _cast_unicode(homedir, fs_encoding)
-    elif os.name == 'nt':
-        # Now for win9x, XP, Vista, 7?
-        # For some strange reason all of these return 'nt' for os.name.
-        # First look for a network home directory. This will return the UNC
-        # path (\\server\\Users\%username%) not the mapped path (Z:\). This
-        # is needed when running IPython on cluster where all paths have to 
-        # be UNC.
-        try:
-            homedir = env['HOMESHARE']
-        except KeyError:
-            pass
-        else:
-            if isdir(homedir):
-                return _cast_unicode(homedir, fs_encoding)
+    See stdlib docs for how this is determined.
+    For Python <3.8, $HOME is first priority on *ALL* platforms.
+    For Python >=3.8 on Windows, %HOME% is no longer considered.
 
-        # Now look for a local home directory
-        try:
-            homedir = os.path.join(env['HOMEDRIVE'],env['HOMEPATH'])
-        except KeyError:
-            pass
-        else:
-            if isdir(homedir):
-                return _cast_unicode(homedir, fs_encoding)
+    Parameters
+    ----------
+    require_writable : bool [default: False]
+        if True:
+            guarantees the return value is a writable directory, otherwise
+            raises HomeDirError
+        if False:
+            The path is resolved, but it is not guaranteed to exist or be writable.
+    """
 
-        # Now the users profile directory
-        try:
-            homedir = os.path.join(env['USERPROFILE'])
-        except KeyError:
-            pass
-        else:
-            if isdir(homedir):
-                return _cast_unicode(homedir, fs_encoding)
+    homedir = os.path.expanduser('~')
+    # Next line will make things work even when /home/ is a symlink to
+    # /usr/home as it is on FreeBSD, for example
+    homedir = os.path.realpath(homedir)
 
-        # Use the registry to get the 'My Documents' folder.
+    if not _writable_dir(homedir) and os.name == 'nt':
+        # expanduser failed, use the registry to get the 'My Documents' folder.
         try:
-            import _winreg as wreg
-            key = wreg.OpenKey(
+            import winreg as wreg
+            with wreg.OpenKey(
                 wreg.HKEY_CURRENT_USER,
-                "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
-            )
-            homedir = wreg.QueryValueEx(key,'Personal')[0]
-            key.Close()
+                r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+            ) as key:
+                homedir = wreg.QueryValueEx(key,'Personal')[0]
         except:
             pass
-        else:
-            if isdir(homedir):
-                return _cast_unicode(homedir, fs_encoding)
 
-        # A user with a lot of unix tools in win32 may have defined $HOME.
-        # Try this as a last ditch option.
-        try:
-            homedir = env['HOME']
-        except KeyError:
-            pass
-        else:
-            if isdir(homedir):
-                return _cast_unicode(homedir, fs_encoding)
-
-        # If all else fails, raise HomeDirError
-        raise HomeDirError('No valid home directory could be found')
-    elif os.name == 'dos':
-        # Desperate, may do absurd things in classic MacOS. May work under DOS.
-        return u'C:\\'
+    if (not require_writable) or _writable_dir(homedir):
+        assert isinstance(homedir, str), "Homedir should be unicode not bytes"
+        return homedir
     else:
-        raise HomeDirError('No valid home directory could be found for your OS')
+        raise HomeDirError('%s is not a writable dir, '
+                'set $HOME environment variable to override' % homedir)
 
 def get_xdg_dir():
     """Return the XDG_CONFIG_HOME, if it is defined and exists, else None.
-    
-    This is only for posix (Linux,Unix,OS X, etc) systems.
+
+    This is only for non-OS X posix (Linux,Unix,etc.) systems.
     """
 
-    isdir = os.path.isdir
     env = os.environ
-    
-    if os.name == 'posix':
-        # Linux, Unix, AIX, OS X
-        # use ~/.config if not set OR empty
+
+    if os.name == "posix":
+        # Linux, Unix, AIX, etc.
+        # use ~/.config if empty OR not set
         xdg = env.get("XDG_CONFIG_HOME", None) or os.path.join(get_home_dir(), '.config')
-        if xdg and isdir(xdg):
-            return _cast_unicode(xdg, fs_encoding)
-    
+        if xdg and _writable_dir(xdg):
+            assert isinstance(xdg, str)
+            return xdg
+
     return None
-    
 
-def get_ipython_dir():
-    """Get the IPython directory for this platform and user.
-    
-    This uses the logic in `get_home_dir` to find the home directory
-    and the adds .ipython to the end of the path.
+
+def get_xdg_cache_dir():
+    """Return the XDG_CACHE_HOME, if it is defined and exists, else None.
+
+    This is only for non-OS X posix (Linux,Unix,etc.) systems.
     """
-    
+
     env = os.environ
-    pjoin = os.path.join
-    exists = os.path.exists
-    
-    ipdir_def = '.ipython'
-    xdg_def = 'ipython'
-    
-    home_dir = get_home_dir()
-    xdg_dir = get_xdg_dir()
-    # import pdb; pdb.set_trace()  # dbg
-    ipdir = env.get('IPYTHON_DIR', env.get('IPYTHONDIR', None))
-    if ipdir is None:
-        # not set explicitly, use XDG_CONFIG_HOME or HOME
-        home_ipdir = pjoin(home_dir, ipdir_def)
-        if xdg_dir:
-            # use XDG, as long as the user isn't already
-            # using $HOME/.ipython and *not* XDG/ipython
-            
-            xdg_ipdir = pjoin(xdg_dir, xdg_def)
-        
-            if exists(xdg_ipdir) or not exists(home_ipdir):
-                ipdir = xdg_ipdir
-        
-        if ipdir is None:
-            # not using XDG
-            ipdir = home_ipdir
-
-    return _cast_unicode(ipdir, fs_encoding)
-
-
-def get_ipython_package_dir():
-    """Get the base directory where IPython itself is installed."""
-    ipdir = os.path.dirname(IPython.__file__)
-    return _cast_unicode(ipdir, fs_encoding)
-
-
-def get_ipython_module_path(module_str):
-    """Find the path to an IPython module in this version of IPython.
-
-    This will always find the version of the module that is in this importable
-    IPython package. This will always return the path to the ``.py``
-    version of the module.
-    """
-    if module_str == 'IPython':
-        return os.path.join(get_ipython_package_dir(), '__init__.py')
-    mod = import_item(module_str)
-    the_path = mod.__file__.replace('.pyc', '.py')
-    the_path = the_path.replace('.pyo', '.py')
-    return _cast_unicode(the_path, fs_encoding)
+
+    if os.name == "posix":
+        # Linux, Unix, AIX, etc.
+        # use ~/.cache if empty OR not set
+        xdg = env.get("XDG_CACHE_HOME", None) or os.path.join(get_home_dir(), '.cache')
+        if xdg and _writable_dir(xdg):
+            assert isinstance(xdg, str)
+            return xdg
+
+    return None
 
 
 def expand_path(s):
     """Expand $VARS and ~names in a string, like a shell
 
     :Examples:
-    
+
        In [2]: os.environ['FOO']='test'
 
        In [3]: expand_path('variable FOO is $FOO')
@@ -364,38 +257,98 @@ def expand_path(s):
     return s
 
 
-def target_outdated(target,deps):
-    """Determine whether a target is out of date.
+def unescape_glob(string):
+    """Unescape glob pattern in `string`."""
+    def unescape(s):
+        for pattern in '*[]!?':
+            s = s.replace(r'\{0}'.format(pattern), pattern)
+        return s
+    return '\\'.join(map(unescape, string.split('\\\\')))
+
+
+def shellglob(args):
+    """
+    Do glob expansion for each element in `args` and return a flattened list.
+
+    Unmatched glob pattern will remain as-is in the returned list.
+
+    """
+    expanded = []
+    # Do not unescape backslash in Windows as it is interpreted as
+    # path separator:
+    unescape = unescape_glob if sys.platform != 'win32' else lambda x: x
+    for a in args:
+        expanded.extend(glob.glob(a) or [unescape(a)])
+    return expanded
 
-    target_outdated(target,deps) -> 1/0
+ENOLINK = 1998
 
-    deps: list of filenames which MUST exist.
-    target: single filename which may or may not exist.
+def link(src, dst):
+    """Hard links ``src`` to ``dst``, returning 0 or errno.
 
-    If target doesn't exist or is older than any file listed in deps, return
-    true, otherwise return false.
+    Note that the special errno ``ENOLINK`` will be returned if ``os.link`` isn't
+    supported by the operating system.
     """
+
+    if not hasattr(os, "link"):
+        return ENOLINK
+    link_errno = 0
     try:
-        target_time = os.path.getmtime(target)
-    except os.error:
-        return 1
-    for dep in deps:
-        dep_time = os.path.getmtime(dep)
-        if dep_time > target_time:
-            #print "For target",target,"Dep failed:",dep # dbg
-            #print "times (dep,tar):",dep_time,target_time # dbg
-            return 1
-    return 0
+        os.link(src, dst)
+    except OSError as e:
+        link_errno = e.errno
+    return link_errno
 
 
-def target_update(target,deps,cmd):
-    """Update a target with a given command given a list of dependencies.
+def link_or_copy(src, dst):
+    """Attempts to hardlink ``src`` to ``dst``, copying if the link fails.
 
-    target_update(target,deps,cmd) -> runs cmd if target is outdated.
+    Attempts to maintain the semantics of ``shutil.copy``.
+
+    Because ``os.link`` does not overwrite files, a unique temporary file
+    will be used if the target already exists, then that file will be moved
+    into place.
+    """
 
-    This is just a wrapper around target_outdated() which calls the given
-    command if target is outdated."""
+    if os.path.isdir(dst):
+        dst = os.path.join(dst, os.path.basename(src))
 
-    if target_outdated(target,deps):
-        system(cmd)
+    link_errno = link(src, dst)
+    if link_errno == errno.EEXIST:
+        if os.stat(src).st_ino == os.stat(dst).st_ino:
+            # dst is already a hard link to the correct file, so we don't need
+            # to do anything else. If we try to link and rename the file
+            # anyway, we get duplicate files - see http://bugs.python.org/issue21876
+            return
 
+        new_dst = dst + "-temp-%04X" %(random.randint(1, 16**4), )
+        try:
+            link_or_copy(src, new_dst)
+        except:
+            try:
+                os.remove(new_dst)
+            except OSError:
+                pass
+            raise
+        os.rename(new_dst, dst)
+    elif link_errno != 0:
+        # Either link isn't supported, or the filesystem doesn't support
+        # linking, or 'src' and 'dst' are on different filesystems.
+        shutil.copy(src, dst)
+
+def ensure_dir_exists(path, mode=0o755):
+    """ensure that a directory exists
+
+    If it doesn't exist, try to create it and protect against a race condition
+    if another process is doing the same.
+
+    The default permissions are 755, which differ from os.makedirs default of 777.
+    """
+    if not os.path.exists(path):
+        try:
+            os.makedirs(path, mode=mode)
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+    elif not os.path.isdir(path):
+        raise IOError("%r exists but is not a directory" % path)
diff --git a/IPython/utils/pickleshare.py b/IPython/utils/pickleshare.py
deleted file mode 100755
index 9ac7cb0fb6c..00000000000
--- a/IPython/utils/pickleshare.py
+++ /dev/null
@@ -1,356 +0,0 @@
-#!/usr/bin/env python
-
-""" PickleShare - a small 'shelve' like datastore with concurrency support
-
-Like shelve, a PickleShareDB object acts like a normal dictionary. Unlike 
-shelve, many processes can access the database simultaneously. Changing a 
-value in database is immediately visible to other processes accessing the 
-same database.
-
-Concurrency is possible because the values are stored in separate files. Hence
-the "database" is a directory where *all* files are governed by PickleShare.
-
-Example usage::
-    
-    from pickleshare import *
-    db = PickleShareDB('~/testpickleshare')
-    db.clear()
-    print "Should be empty:",db.items()
-    db['hello'] = 15
-    db['aku ankka'] = [1,2,313]
-    db['paths/are/ok/key'] = [1,(5,46)]
-    print db.keys()
-    del db['aku ankka']
-
-This module is certainly not ZODB, but can be used for low-load 
-(non-mission-critical) situations where tiny code size trumps the 
-advanced features of a "real" object database.
-
-Installation guide: easy_install pickleshare
-
-Author: Ville Vainio <vivainio@gmail.com>
-License: MIT open source license.
-
-"""
-
-from IPython.external.path import path as Path
-import os,stat,time
-import cPickle as pickle
-import UserDict
-import glob
-
-def gethashfile(key):
-    return ("%02x" % abs(hash(key) % 256))[-2:]
-
-_sentinel = object()
-
-class PickleShareDB(UserDict.DictMixin):
-    """ The main 'connection' object for PickleShare database """
-    def __init__(self,root):
-        """ Return a db object that will manage the specied directory"""
-        self.root = Path(root).expanduser().abspath()
-        if not self.root.isdir():
-            self.root.makedirs()
-        # cache has { 'key' : (obj, orig_mod_time) }
-        self.cache = {}
-        
-
-    def __getitem__(self,key):
-        """ db['key'] reading """
-        fil = self.root / key
-        try:
-            mtime = (fil.stat()[stat.ST_MTIME])
-        except OSError:
-            raise KeyError(key)
-
-        if fil in self.cache and mtime == self.cache[fil][1]:
-            return self.cache[fil][0]
-        try:
-            # The cached item has expired, need to read
-            obj = pickle.load(fil.open())
-        except:
-            raise KeyError(key)
-            
-        self.cache[fil] = (obj,mtime)
-        return obj
-    
-    def __setitem__(self,key,value):
-        """ db['key'] = 5 """
-        fil = self.root / key
-        parent = fil.parent
-        if parent and not parent.isdir():
-            parent.makedirs()
-        pickled = pickle.dump(value,fil.open('w'))
-        try:
-            self.cache[fil] = (value,fil.mtime)
-        except OSError,e:
-            if e.errno != 2:
-                raise
-    
-    def hset(self, hashroot, key, value):
-        """ hashed set """
-        hroot = self.root / hashroot
-        if not hroot.isdir():
-            hroot.makedirs()
-        hfile = hroot / gethashfile(key)
-        d = self.get(hfile, {})
-        d.update( {key : value})
-        self[hfile] = d                
-
-    
-    
-    def hget(self, hashroot, key, default = _sentinel, fast_only = True):
-        """ hashed get """
-        hroot = self.root / hashroot
-        hfile = hroot / gethashfile(key)
-        
-        d = self.get(hfile, _sentinel )
-        #print "got dict",d,"from",hfile
-        if d is _sentinel:
-            if fast_only:
-                if default is _sentinel:
-                    raise KeyError(key)
-                    
-                return default
-            
-            # slow mode ok, works even after hcompress()
-            d = self.hdict(hashroot)
-        
-        return d.get(key, default)
-
-    def hdict(self, hashroot):
-        """ Get all data contained in hashed category 'hashroot' as dict """
-        hfiles = self.keys(hashroot + "/*")
-        hfiles.sort()
-        last = len(hfiles) and hfiles[-1] or ''
-        if last.endswith('xx'):
-            # print "using xx"
-            hfiles = [last] + hfiles[:-1]
-            
-        all = {}
-        
-        for f in hfiles:
-            # print "using",f
-            try:
-                all.update(self[f])
-            except KeyError:
-                print "Corrupt",f,"deleted - hset is not threadsafe!"
-                del self[f]
-                
-            self.uncache(f)
-        
-        return all
-    
-    def hcompress(self, hashroot):
-        """ Compress category 'hashroot', so hset is fast again
-        
-        hget will fail if fast_only is True for compressed items (that were
-        hset before hcompress).
-        
-        """
-        hfiles = self.keys(hashroot + "/*")
-        all = {}
-        for f in hfiles:
-            # print "using",f
-            all.update(self[f])
-            self.uncache(f)
-            
-        self[hashroot + '/xx'] = all
-        for f in hfiles:
-            p = self.root / f
-            if p.basename() == 'xx':
-                continue
-            p.remove()
-            
-            
-        
-    def __delitem__(self,key):
-        """ del db["key"] """
-        fil = self.root / key
-        self.cache.pop(fil,None)
-        try:
-            fil.remove()
-        except OSError:
-            # notfound and permission denied are ok - we
-            # lost, the other process wins the conflict
-            pass
-        
-    def _normalized(self, p):
-        """ Make a key suitable for user's eyes """
-        return str(self.root.relpathto(p)).replace('\\','/')
-    
-    def keys(self, globpat = None):
-        """ All keys in DB, or all keys matching a glob"""
-        
-        if globpat is None:
-            files = self.root.walkfiles()
-        else:
-            files = [Path(p) for p in glob.glob(self.root/globpat)]
-        return [self._normalized(p) for p in files if p.isfile()]
-
-    def uncache(self,*items):
-        """ Removes all, or specified items from cache
-        
-        Use this after reading a large amount of large objects
-        to free up memory, when you won't be needing the objects
-        for a while.
-         
-        """
-        if not items:
-            self.cache = {}
-        for it in items:
-            self.cache.pop(it,None)
-            
-    def waitget(self,key, maxwaittime = 60 ):
-        """ Wait (poll) for a key to get a value
-        
-        Will wait for `maxwaittime` seconds before raising a KeyError.
-        The call exits normally if the `key` field in db gets a value
-        within the timeout period.
-        
-        Use this for synchronizing different processes or for ensuring
-        that an unfortunately timed "db['key'] = newvalue" operation 
-        in another process (which causes all 'get' operation to cause a 
-        KeyError for the duration of pickling) won't screw up your program 
-        logic. 
-        """
-        
-        wtimes = [0.2] * 3 + [0.5] * 2 + [1]
-        tries = 0
-        waited = 0
-        while 1:
-            try:
-                val = self[key]
-                return val
-            except KeyError:
-                pass
-            
-            if waited > maxwaittime:
-                raise KeyError(key)
-            
-            time.sleep(wtimes[tries])
-            waited+=wtimes[tries]
-            if tries < len(wtimes) -1:
-                tries+=1
-    
-    def getlink(self,folder):
-        """ Get a convenient link for accessing items  """
-        return PickleShareLink(self, folder)
-    
-    def __repr__(self):
-        return "PickleShareDB('%s')" % self.root
-        
-        
-                
-class PickleShareLink:
-    """ A shortdand for accessing nested PickleShare data conveniently.
-
-    Created through PickleShareDB.getlink(), example::
-
-        lnk = db.getlink('myobjects/test')
-        lnk.foo = 2
-        lnk.bar = lnk.foo + 5
-    
-    """
-    def __init__(self, db, keydir ):    
-        self.__dict__.update(locals())
-        
-    def __getattr__(self,key):
-        return self.__dict__['db'][self.__dict__['keydir']+'/' + key]
-    def __setattr__(self,key,val):
-        self.db[self.keydir+'/' + key] = val
-    def __repr__(self):
-        db = self.__dict__['db']
-        keys = db.keys( self.__dict__['keydir'] +"/*")
-        return "<PickleShareLink '%s': %s>" % (
-            self.__dict__['keydir'],
-            ";".join([Path(k).basename() for k in keys]))
-            
-        
-def test():
-    db = PickleShareDB('~/testpickleshare')
-    db.clear()
-    print "Should be empty:",db.items()
-    db['hello'] = 15
-    db['aku ankka'] = [1,2,313]
-    db['paths/nest/ok/keyname'] = [1,(5,46)]
-    db.hset('hash', 'aku', 12)
-    db.hset('hash', 'ankka', 313)
-    print "12 =",db.hget('hash','aku')
-    print "313 =",db.hget('hash','ankka')
-    print "all hashed",db.hdict('hash')
-    print db.keys()
-    print db.keys('paths/nest/ok/k*')
-    print dict(db) # snapsot of whole db
-    db.uncache() # frees memory, causes re-reads later
-
-    # shorthand for accessing deeply nested files
-    lnk = db.getlink('myobjects/test')
-    lnk.foo = 2
-    lnk.bar = lnk.foo + 5
-    print lnk.bar # 7
-
-def stress():
-    db = PickleShareDB('~/fsdbtest')
-    import time,sys
-    for i in range(1000):
-        for j in range(1000):
-            if i % 15 == 0 and i < 200:
-                if str(j) in db:
-                    del db[str(j)]
-                continue
-
-            if j%33 == 0:
-                time.sleep(0.02)
-            
-            db[str(j)] = db.get(str(j), []) + [(i,j,"proc %d" % os.getpid())]
-            db.hset('hash',j, db.hget('hash',j,15) + 1 )
-            
-        print i,
-        sys.stdout.flush()
-        if i % 10 == 0:
-            db.uncache()
-    
-def main():
-    import textwrap
-    usage = textwrap.dedent("""\
-    pickleshare - manage PickleShare databases 
-    
-    Usage:
-        
-        pickleshare dump /path/to/db > dump.txt
-        pickleshare load /path/to/db < dump.txt
-        pickleshare test /path/to/db
-    """)
-    DB = PickleShareDB
-    import sys
-    if len(sys.argv) < 2:
-        print usage
-        return
-        
-    cmd = sys.argv[1]
-    args = sys.argv[2:]
-    if cmd == 'dump':
-        if not args: args= ['.']
-        db = DB(args[0])
-        import pprint
-        pprint.pprint(db.items())
-    elif cmd == 'load':
-        cont = sys.stdin.read()
-        db = DB(args[0])
-        data = eval(cont)
-        db.clear()
-        for k,v in db.items():
-            db[k] = v
-    elif cmd == 'testwait':
-        db = DB(args[0])
-        db.clear()
-        print db.waitget('250')
-    elif cmd == 'test':
-        test()
-        stress()
-    
-if __name__== "__main__":
-    main()
-    
-    
diff --git a/IPython/utils/pickleutil.py b/IPython/utils/pickleutil.py
deleted file mode 100644
index 881496a7aee..00000000000
--- a/IPython/utils/pickleutil.py
+++ /dev/null
@@ -1,153 +0,0 @@
-# encoding: utf-8
-
-"""Pickle related utilities. Perhaps this should be called 'can'."""
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import copy
-import sys
-from types import FunctionType
-
-import codeutil
-
-#-------------------------------------------------------------------------------
-# Classes
-#-------------------------------------------------------------------------------
-
-
-class CannedObject(object):
-    def __init__(self, obj, keys=[]):
-        self.keys = keys
-        self.obj = copy.copy(obj)
-        for key in keys:
-            setattr(self.obj, key, can(getattr(obj, key)))
-            
-    
-    def getObject(self, g=None):
-        if g is None:
-            g = globals()
-        for key in self.keys:
-            setattr(self.obj, key, uncan(getattr(self.obj, key), g))
-        return self.obj
-
-class Reference(CannedObject):
-    """object for wrapping a remote reference by name."""
-    def __init__(self, name):
-        if not isinstance(name, basestring):
-            raise TypeError("illegal name: %r"%name)
-        self.name = name
-    
-    def __repr__(self):
-        return "<Reference: %r>"%self.name
-    
-    def getObject(self, g=None):
-        if g is None:
-            g = globals()
-        try:
-            return g[self.name]
-        except KeyError:
-            raise NameError("name %r is not defined"%self.name)
-    
-
-class CannedFunction(CannedObject):
-    
-    def __init__(self, f):
-        self._checkType(f)    
-        self.code = f.func_code
-        self.defaults = f.func_defaults
-        self.module = f.__module__ or '__main__'
-        self.__name__ = f.__name__
-    
-    def _checkType(self, obj):
-        assert isinstance(obj, FunctionType), "Not a function type"
-    
-    def getObject(self, g=None):
-        # try to load function back into its module:
-        if not self.module.startswith('__'):
-            try:
-                __import__(self.module)
-            except ImportError:
-                pass
-            else:
-                g = sys.modules[self.module].__dict__
-            
-        if g is None:
-            g = globals()
-        newFunc = FunctionType(self.code, g, self.__name__, self.defaults)
-        return newFunc
-
-#-------------------------------------------------------------------------------
-# Functions
-#-------------------------------------------------------------------------------
-
-def can(obj):
-    # import here to prevent module-level circular imports
-    from IPython.parallel import dependent
-    if isinstance(obj, dependent):
-        keys = ('f','df')
-        return CannedObject(obj, keys=keys)
-    elif isinstance(obj, FunctionType):
-        return CannedFunction(obj)
-    elif isinstance(obj,dict):
-        return canDict(obj)
-    elif isinstance(obj, (list,tuple)):
-        return canSequence(obj)
-    else:
-        return obj
-
-def canDict(obj):
-    if isinstance(obj, dict):
-        newobj = {}
-        for k, v in obj.iteritems():
-            newobj[k] = can(v)
-        return newobj
-    else:
-        return obj
-
-def canSequence(obj):
-    if isinstance(obj, (list, tuple)):
-        t = type(obj)
-        return t([can(i) for i in obj])
-    else:
-        return obj
-
-def uncan(obj, g=None):
-    if isinstance(obj, CannedObject):
-        return obj.getObject(g)
-    elif isinstance(obj,dict):
-        return uncanDict(obj, g)
-    elif isinstance(obj, (list,tuple)):
-        return uncanSequence(obj, g)
-    else:
-        return obj
-
-def uncanDict(obj, g=None):
-    if isinstance(obj, dict):
-        newobj = {}
-        for k, v in obj.iteritems():
-            newobj[k] = uncan(v,g)
-        return newobj
-    else:
-        return obj
-
-def uncanSequence(obj, g=None):
-    if isinstance(obj, (list, tuple)):
-        t = type(obj)
-        return t([uncan(i,g) for i in obj])
-    else:
-        return obj
-
-
-def rebindFunctionGlobals(f, glbls):
-    return FunctionType(f.func_code, glbls)
diff --git a/IPython/utils/process.py b/IPython/utils/process.py
index 2017395c7b0..f50cf9ba223 100644
--- a/IPython/utils/process.py
+++ b/IPython/utils/process.py
@@ -3,34 +3,24 @@
 Utilities for working with external processes.
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Stdlib
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
 import os
+import shutil
 import sys
-import shlex
 
-# Our own
 if sys.platform == 'win32':
-    from ._process_win32 import _find_cmd, system, getoutput, AvoidUNCPath
+    from ._process_win32 import system, getoutput, arg_split, check_pid
+elif sys.platform == 'cli':
+    from ._process_cli import system, getoutput, arg_split, check_pid
+elif sys.platform == "emscripten":
+    from ._process_emscripten import system, getoutput, arg_split, check_pid
 else:
-    from ._process_posix import _find_cmd, system, getoutput
+    from ._process_posix import system, getoutput, arg_split, check_pid
 
-from ._process_common import getoutputerror
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
+from ._process_common import getoutputerror, get_output_error_code, process_handler
 
 
 class FindCmdError(Exception):
@@ -39,92 +29,27 @@ class FindCmdError(Exception):
 
 def find_cmd(cmd):
     """Find absolute path to executable cmd in a cross platform manner.
-    
+
     This function tries to determine the full path to a command line program
     using `which` on Unix/Linux/OS X and `win32api` on Windows.  Most of the
-    time it will use the version that is first on the users `PATH`.  If
-    cmd is `python` return `sys.executable`.
+    time it will use the version that is first on the users `PATH`.
 
     Warning, don't use this to find IPython command line programs as there
     is a risk you will find the wrong one.  Instead find those using the
     following code and looking for the application itself::
-    
-        from IPython.utils.path import get_ipython_module_path
-        from IPython.utils.process import pycmd2argv
-        argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
+
+        import sys
+        argv = [sys.executable, '-m', 'IPython']
 
     Parameters
     ----------
     cmd : str
         The command line program to look for.
     """
-    if cmd == 'python':
-        return os.path.abspath(sys.executable)
-    try:
-        path = _find_cmd(cmd).rstrip()
-    except OSError:
-        raise FindCmdError('command could not be found: %s' % cmd)
-    # which returns empty if not found
-    if path == '':
+    path = shutil.which(cmd)
+    if path is None:
         raise FindCmdError('command could not be found: %s' % cmd)
-    return os.path.abspath(path)
-
-
-def pycmd2argv(cmd):
-    r"""Take the path of a python command and return a list (argv-style).
-
-    This only works on Python based command line programs and will find the
-    location of the ``python`` executable using ``sys.executable`` to make
-    sure the right version is used.
-
-    For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
-    .com or .bat, and [, cmd] otherwise.  
-
-    Parameters
-    ----------
-    cmd : string
-      The path of the command.
-
-    Returns
-    -------
-    argv-style list.
-    """
-    ext = os.path.splitext(cmd)[1]
-    if ext in ['.exe', '.com', '.bat']:
-        return [cmd]
-    else:
-        if sys.platform == 'win32':
-            # The -u option here turns on unbuffered output, which is required
-            # on Win32 to prevent wierd conflict and problems with Twisted.
-            # Also, use sys.executable to make sure we are picking up the 
-            # right python exe.
-            return [sys.executable, '-u', cmd]
-        else:
-            return [sys.executable, cmd]
-
-
-def arg_split(s, posix=False):
-    """Split a command line's arguments in a shell-like manner.
-
-    This is a modified version of the standard library's shlex.split()
-    function, but with a default of posix=False for splitting, so that quotes
-    in inputs are respected."""
-
-    # Unfortunately, python's shlex module is buggy with unicode input:
-    # http://bugs.python.org/issue1170
-    # At least encoding the input when it's unicode seems to help, but there
-    # may be more problems lurking.  Apparently this is fixed in python3.
-    is_unicode = False
-    if isinstance(s, unicode):
-        is_unicode = True
-        s = s.encode('utf-8')
-    lex = shlex.shlex(s, posix=posix)
-    lex.whitespace_split = True
-    tokens = list(lex)
-    if is_unicode:
-        # Convert the tokens back to unicode.
-        tokens = [x.decode('utf-8') for x in tokens]
-    return tokens
+    return path
 
 
 def abbrev_cwd():
diff --git a/IPython/utils/py3compat.py b/IPython/utils/py3compat.py
new file mode 100644
index 00000000000..4f953214737
--- /dev/null
+++ b/IPython/utils/py3compat.py
@@ -0,0 +1,59 @@
+# coding: utf-8
+"""Compatibility tricks for Python 3. Mainly to do with unicode.
+
+This file is deprecated and will be removed in a future version.
+"""
+
+import platform
+import builtins as builtin_mod
+
+from .encoding import DEFAULT_ENCODING
+
+
+def decode(s, encoding=None):
+    encoding = encoding or DEFAULT_ENCODING
+    return s.decode(encoding, "replace")
+
+
+def encode(u, encoding=None):
+    encoding = encoding or DEFAULT_ENCODING
+    return u.encode(encoding, "replace")
+
+
+def cast_unicode(s, encoding=None):
+    if isinstance(s, bytes):
+        return decode(s, encoding)
+    return s
+
+
+def safe_unicode(e):
+    """unicode(e) with various fallbacks. Used for exceptions, which may not be
+    safe to call unicode() on.
+    """
+    try:
+        return str(e)
+    except UnicodeError:
+        pass
+
+    try:
+        return repr(e)
+    except UnicodeError:
+        pass
+
+    return "Unrecoverably corrupt evalue"
+
+
+# keep reference to builtin_mod because the kernel overrides that value
+# to forward requests to a frontend.
+def input(prompt=""):
+    return builtin_mod.input(prompt)
+
+
+def execfile(fname, glob, loc=None, compiler=None):
+    loc = loc if (loc is not None) else glob
+    with open(fname, "rb") as f:
+        compiler = compiler or compile
+        exec(compiler(f.read(), fname, "exec"), glob, loc)
+
+
+PYPY = platform.python_implementation() == "PyPy"
diff --git a/IPython/utils/rlineimpl.py b/IPython/utils/rlineimpl.py
deleted file mode 100644
index 042b560c0a3..00000000000
--- a/IPython/utils/rlineimpl.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -*-
-""" Imports and provides the 'correct' version of readline for the platform.
-
-Readline is used throughout IPython as::
-
-    import IPython.utils.rlineimpl as readline
-
-In addition to normal readline stuff, this module provides have_readline
-boolean and _outputfile variable used in IPython.utils.
-"""
-
-import sys
-import warnings
-
-try:
-    from readline import *
-    import readline as _rl
-    have_readline = True
-except ImportError:
-    try:
-        from pyreadline import *
-        import pyreadline as _rl
-        have_readline = True
-    except ImportError:
-        have_readline = False
-
-if have_readline and hasattr(_rl, 'rlmain'):
-    # patch add_history to allow for strings in pyreadline <= 1.5:
-    # fix copied from pyreadline 1.6
-    import pyreadline
-    if pyreadline.release.version <= '1.5':
-        def add_history(line):
-            """add a line to the history buffer."""
-            from pyreadline import lineobj
-            if not isinstance(line, lineobj.TextLine):
-                line = lineobj.TextLine(line)
-            return _rl.add_history(line)
-
-if sys.platform == 'win32' and have_readline:
-    try:
-        _outputfile=_rl.GetOutputFile()
-    except AttributeError:
-        print "Failed GetOutputFile"
-        have_readline = False
-
-# Test to see if libedit is being used instead of GNU readline.
-# Thanks to Boyd Waters for this patch.
-uses_libedit = False
-if sys.platform == 'darwin' and have_readline:
-    import commands
-    # Boyd's patch had a 'while True' here, I'm always a little worried about
-    # infinite loops with such code, so for now I'm taking a more conservative
-    # approach. See https://bugs.launchpad.net/ipython/+bug/411599.
-    for i in range(10):
-        try:
-            (status, result) = commands.getstatusoutput( "otool -L %s | grep libedit" % _rl.__file__ )
-            break
-        except IOError, (errno, strerror):
-            if errno == 4:
-                continue
-            else:
-                break
-
-    if status == 0 and len(result) > 0:
-        # we are bound to libedit - new in Leopard
-        _rl.parse_and_bind("bind ^I rl_complete")
-        warnings.warn("Leopard libedit detected - readline will not be well behaved "
-            "including some crashes on tab completion, and incorrect history navigation. "
-            "It is highly recommended that you install readline, "
-            "which is easy_installable with: 'easy_install readline'",
-            RuntimeWarning)
-        uses_libedit = True
-
-
-# the clear_history() function was only introduced in Python 2.4 and is
-# actually optional in the readline API, so we must explicitly check for its
-# existence.  Some known platforms actually don't have it.  This thread:
-# http://mail.python.org/pipermail/python-dev/2003-August/037845.html
-# has the original discussion.
-
-if have_readline:
-    try:
-        _rl.clear_history
-    except AttributeError:
-        def clear_history(): pass
-        _rl.clear_history = clear_history
diff --git a/IPython/utils/sentinel.py b/IPython/utils/sentinel.py
new file mode 100644
index 00000000000..623c41fb77b
--- /dev/null
+++ b/IPython/utils/sentinel.py
@@ -0,0 +1,15 @@
+"""Sentinel class for constants with useful reprs"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+class Sentinel:
+    def __init__(self, name: str, module: str, docstring: str | None = None) -> None:
+        self.name = name
+        self.module = module
+        if docstring:
+            self.__doc__ = docstring
+
+    def __repr__(self) -> str:
+        return str(self.module) + "." + self.name
diff --git a/IPython/utils/strdispatch.py b/IPython/utils/strdispatch.py
index c03c28279f2..bbaabe5af64 100644
--- a/IPython/utils/strdispatch.py
+++ b/IPython/utils/strdispatch.py
@@ -8,7 +8,7 @@
 from IPython.core.hooks import CommandChainDispatcher
 
 # Code begins
-class StrDispatch(object):
+class StrDispatch:
     """Dispatch (lookup) a set of strings / regexps for match.
 
     Example:
@@ -17,24 +17,24 @@ class StrDispatch(object):
     >>> dis.add_s('hei',34, priority = 4)
     >>> dis.add_s('hei',123, priority = 2)
     >>> dis.add_re('h.i', 686)
-    >>> print list(dis.flat_matches('hei'))
+    >>> print(list(dis.flat_matches('hei')))
     [123, 34, 686]
     """
-    
+
     def __init__(self):
         self.strs = {}
         self.regexs = {}
 
     def add_s(self, s, obj, priority= 0 ):
         """ Adds a target 'string' for dispatching """
-        
+
         chain = self.strs.get(s, CommandChainDispatcher())
         chain.add(obj,priority)
         self.strs[s] = chain
 
     def add_re(self, regex, obj, priority= 0 ):
         """ Adds a target regexp for dispatching """
-        
+
         chain = self.regexs.get(regex, CommandChainDispatcher())
         chain.add(obj,priority)
         self.regexs[regex] = chain
@@ -43,23 +43,23 @@ def dispatch(self, key):
         """ Get a seq of Commandchain objects that match key """
         if key in self.strs:
             yield self.strs[key]
-        
+
         for r, obj in self.regexs.items():
             if re.match(r, key):
                 yield obj
-            else: 
-                #print "nomatch",key  # dbg
+            else:
+                # print("nomatch",key)  # dbg
                 pass
 
     def __repr__(self):
         return "<Strdispatch %s, %s>" % (self.strs, self.regexs)
-    
+
     def s_matches(self, key):
         if key not in self.strs:
              return
         for el in self.strs[key]:
             yield el[1]
-        
+
     def flat_matches(self, key):
         """ Yield all 'value' targets, without priority """
         for val in self.dispatch(key):
diff --git a/IPython/utils/sysinfo.py b/IPython/utils/sysinfo.py
index 7aa707791d5..8240ea54e3a 100644
--- a/IPython/utils/sysinfo.py
+++ b/IPython/utils/sysinfo.py
@@ -4,7 +4,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -20,84 +20,65 @@
 import sys
 import subprocess
 
-from ConfigParser import ConfigParser
+from pathlib import Path
 
 from IPython.core import release
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-COMMIT_INFO_FNAME = '.git_commit_info.ini'
+from IPython.utils import _sysinfo, encoding
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
-def pkg_commit_hash(pkg_path):
+def pkg_commit_hash(pkg_path: str) -> tuple[str, str]:
     """Get short form of commit hash given directory `pkg_path`
 
-    There should be a file called 'COMMIT_INFO.txt' in `pkg_path`.  This is a
-    file in INI file format, with at least one section: ``commit hash``, and two
-    variables ``archive_subst_hash`` and ``install_hash``.  The first has a
-    substitution pattern in it which may have been filled by the execution of
-    ``git archive`` if this is an archive generated that way.  The second is
-    filled in by the installation, if the installation is from a git archive.
-
     We get the commit hash from (in order of preference):
 
-    * A substituted value in ``archive_subst_hash``
-    * A written commit hash value in ``install_hash`
+    * IPython.utils._sysinfo.commit
     * git output, if we are in a git repository
 
-    If all these fail, we return a not-found placeholder tuple
+    If these fail, we return a not-found placeholder tuple
 
     Parameters
     ----------
     pkg_path : str
-       directory containing package
+        directory containing package
+        only used for getting commit from active repo
 
     Returns
     -------
     hash_from : str
-       Where we got the hash from - description
+        Where we got the hash from - description
     hash_str : str
-       short form of hash
+        short form of hash
     """
     # Try and get commit from written commit text file
-    pth = os.path.join(pkg_path, COMMIT_INFO_FNAME)
-    if not os.path.isfile(pth):
-        raise IOError('Missing commit info file %s' % pth)
-    cfg_parser = ConfigParser()
-    cfg_parser.read(pth)
-    archive_subst = cfg_parser.get('commit hash', 'archive_subst_hash')
-    if not archive_subst.startswith('$Format'): # it has been substituted
-        return 'archive substitution', archive_subst
-    install_subst = cfg_parser.get('commit hash', 'install_hash')
-    if install_subst != '':
-        return 'installation', install_subst
+    if _sysinfo.commit:
+        return "installation", _sysinfo.commit
+
     # maybe we are in a repository
-    proc = subprocess.Popen('git rev-parse --short HEAD',
+    proc = subprocess.Popen('git rev-parse --short HEAD'.split(' '),
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE,
-                            cwd=pkg_path, shell=True)
+                            cwd=pkg_path)
     repo_commit, _ = proc.communicate()
     if repo_commit:
-        return 'repository', repo_commit.strip()
+        return 'repository', repo_commit.strip().decode('ascii')
     return '(none found)', '<not found>'
 
 
-def pkg_info(pkg_path):
+def pkg_info(pkg_path: str) -> dict:
     """Return dict describing the context of this package
 
     Parameters
     ----------
     pkg_path : str
-       path containing __init__.py for package
+        path containing __init__.py for package
 
     Returns
     -------
     context : dict
-       with named parameters of interest
+        with named parameters of interest
     """
     src, hsh = pkg_commit_hash(pkg_path)
     return dict(
@@ -110,76 +91,30 @@ def pkg_info(pkg_path):
         sys_platform=sys.platform,
         platform=platform.platform(),
         os_name=os.name,
+        default_encoding=encoding.DEFAULT_ENCODING,
         )
 
+def get_sys_info() -> dict:
+    """Return useful information about IPython and the system, as a dict."""
+    path = Path(__file__, "..").resolve().parent
+    return pkg_info(str(path))
 
-def sys_info():
+def sys_info() -> str:
     """Return useful information about IPython and the system, as a string.
 
-    Example
-    -------
-    In [2]: print sys_info()
-    {'commit_hash': '144fdae',      # random
-     'commit_source': 'repository',
-     'ipython_path': '/home/fperez/usr/lib/python2.6/site-packages/IPython',
-     'ipython_version': '0.11.dev',
-     'os_name': 'posix',
-     'platform': 'Linux-2.6.35-22-generic-i686-with-Ubuntu-10.10-maverick',
-     'sys_executable': '/usr/bin/python',
-     'sys_platform': 'linux2',
-     'sys_version': '2.6.6 (r266:84292, Sep 15 2010, 15:52:39) \\n[GCC 4.4.5]'}
-   """
-    p = os.path
-    path = p.dirname(p.abspath(p.join(__file__, '..')))
-    return pprint.pformat(pkg_info(path))
-
-
-def _num_cpus_unix():
-    """Return the number of active CPUs on a Unix system."""
-    return os.sysconf("SC_NPROCESSORS_ONLN")
-
-
-def _num_cpus_darwin():
-    """Return the number of active CPUs on a Darwin system."""
-    p = subprocess.Popen(['sysctl','-n','hw.ncpu'],stdout=subprocess.PIPE)
-    return p.stdout.read()
-
-
-def _num_cpus_windows():
-    """Return the number of active CPUs on a Windows system."""
-    return os.environ.get("NUMBER_OF_PROCESSORS")
-
-
-def num_cpus():
-   """Return the effective number of CPUs in the system as an integer.
-
-   This cross-platform function makes an attempt at finding the total number of
-   available CPUs in the system, as returned by various underlying system and
-   python calls.
-
-   If it can't find a sensible answer, it returns 1 (though an error *may* make
-   it return a large positive number that's actually incorrect).
-   """
-
-   # Many thanks to the Parallel Python project (http://www.parallelpython.com)
-   # for the names of the keys we needed to look up for this function.  This
-   # code was inspired by their equivalent function.
-
-   ncpufuncs = {'Linux':_num_cpus_unix,
-                'Darwin':_num_cpus_darwin,
-                'Windows':_num_cpus_windows,
-                # On Vista, python < 2.5.2 has a bug and returns 'Microsoft'
-                # See http://bugs.python.org/issue1082 for details.
-                'Microsoft':_num_cpus_windows,
-                }
-
-   ncpufunc = ncpufuncs.get(platform.system(),
-                            # default to unix version (Solaris, AIX, etc)
-                            _num_cpus_unix)
-
-   try:
-       ncpus = max(1,int(ncpufunc()))
-   except:
-       ncpus = 1
-   return ncpus
-
+    Examples
+    --------
+    ::
+    
+        In [2]: print(sys_info())
+        {'commit_hash': '144fdae',      # random
+         'commit_source': 'repository',
+         'ipython_path': '/home/fperez/usr/lib/python2.6/site-packages/IPython',
+         'ipython_version': '0.11.dev',
+         'os_name': 'posix',
+         'platform': 'Linux-2.6.35-22-generic-i686-with-Ubuntu-10.10-maverick',
+         'sys_executable': '/usr/bin/python',
+         'sys_platform': 'linux2',
+         'sys_version': '2.6.6 (r266:84292, Sep 15 2010, 15:52:39) \\n[GCC 4.4.5]'}
+    """
+    return pprint.pformat(get_sys_info())
diff --git a/IPython/utils/syspathcontext.py b/IPython/utils/syspathcontext.py
index e282a25e0c8..dcc7a634ac5 100644
--- a/IPython/utils/syspathcontext.py
+++ b/IPython/utils/syspathcontext.py
@@ -1,66 +1,36 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Context managers for adding things to sys.path temporarily.
-
-Authors:
-
-* Brian Granger
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+from __future__ import annotations
 
 import sys
+from types import TracebackType
+from typing import Literal, Self
 
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-class appended_to_syspath(object):
-    """A context for appending a directory to sys.path for a second."""
+import warnings
 
-    def __init__(self, dir):
-        self.dir = dir
-
-    def __enter__(self):
-        if self.dir not in sys.path:
-            sys.path.append(self.dir)
-            self.added = True
-        else:
-            self.added = False
 
-    def __exit__(self, type, value, traceback):
-        if self.added:
-            try:
-                sys.path.remove(self.dir)
-            except ValueError:
-                pass
-        # Returning False causes any exceptions to be re-raised.
-        return False
-
-class prepended_to_syspath(object):
+class prepended_to_syspath:
     """A context for prepending a directory to sys.path for a second."""
 
-    def __init__(self, dir):
+    dir: str
+    added: bool
+
+    def __init__(self, dir: str) -> None:
         self.dir = dir
+        self.added = False
 
-    def __enter__(self):
+    def __enter__(self) -> Self:
         if self.dir not in sys.path:
-            sys.path.insert(0,self.dir)
+            sys.path.insert(0, self.dir)
             self.added = True
         else:
             self.added = False
-
-    def __exit__(self, type, value, traceback):
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> Literal[False]:
         if self.added:
             try:
                 sys.path.remove(self.dir)
diff --git a/IPython/utils/tempdir.py b/IPython/utils/tempdir.py
index 57f02fc98d6..0efdeb1067a 100644
--- a/IPython/utils/tempdir.py
+++ b/IPython/utils/tempdir.py
@@ -1,76 +1,59 @@
-"""TemporaryDirectory class, copied from Python 3.2.
+"""This module contains classes - NamedFileInTemporaryDirectory, TemporaryWorkingDirectory.
 
-This is copied from the stdlib and will be standard in Python 3.2 and onwards.
+These classes add extra features such as creating a named file in temporary directory and
+creating a context manager for the working directory which is also temporary.
 """
 
-# This code should only be used in Python versions < 3.2, since after that we
-# can rely on the stdlib itself.
-try:
-    from tempfile import TemporaryDirectory
+import os as _os
+from pathlib import Path
+from tempfile import TemporaryDirectory
 
-except ImportError:
-    
-    import os as _os
-    from tempfile import mkdtemp, template
 
-    class TemporaryDirectory(object):
-        """Create and return a temporary directory.  This has the same
-        behavior as mkdtemp but can be used as a context manager.  For
-        example:
+class NamedFileInTemporaryDirectory:
+    def __init__(self, filename, mode, bufsize=-1, add_to_syspath=False, **kwds):
+        """
+        Open a file named `filename` in a temporary directory.
+
+        This context manager is preferred over `NamedTemporaryFile` in
+        stdlib `tempfile` when one needs to reopen the file.
 
-            with TemporaryDirectory() as tmpdir:
-                ...
+        Arguments `mode` and `bufsize` are passed to `open`.
+        Rest of the arguments are passed to `TemporaryDirectory`.
 
-        Upon exiting the context, the directory and everthing contained
-        in it are removed.
         """
+        self._tmpdir = TemporaryDirectory(**kwds)
+        path = Path(self._tmpdir.name) / filename
+        encoding = None if "b" in mode else "utf-8"
+        self.file = open(path, mode, bufsize, encoding=encoding)
+
+    def cleanup(self):
+        self.file.close()
+        self._tmpdir.cleanup()
+
+    __del__ = cleanup
+
+    def __enter__(self):
+        return self.file
+
+    def __exit__(self, type, value, traceback):
+        self.cleanup()
+
+
+class TemporaryWorkingDirectory(TemporaryDirectory):
+    """
+    Creates a temporary directory and sets the cwd to that directory.
+    Automatically reverts to previous cwd upon cleanup.
+    Usage example:
+
+        with TemporaryWorkingDirectory() as tmpdir:
+            ...
+    """
+
+    def __enter__(self):
+        self.old_wd = Path.cwd()
+        _os.chdir(self.name)
+        return super(TemporaryWorkingDirectory, self).__enter__()
 
-        def __init__(self, suffix="", prefix=template, dir=None):
-            self.name = mkdtemp(suffix, prefix, dir)
-            self._closed = False
-
-        def __enter__(self):
-            return self.name
-
-        def cleanup(self):
-            if not self._closed:
-                self._rmtree(self.name)
-                self._closed = True
-
-        def __exit__(self, exc, value, tb):
-            self.cleanup()
-
-        __del__ = cleanup
-
-
-        # XXX (ncoghlan): The following code attempts to make
-        # this class tolerant of the module nulling out process
-        # that happens during CPython interpreter shutdown
-        # Alas, it doesn't actually manage it. See issue #10188
-        _listdir = staticmethod(_os.listdir)
-        _path_join = staticmethod(_os.path.join)
-        _isdir = staticmethod(_os.path.isdir)
-        _remove = staticmethod(_os.remove)
-        _rmdir = staticmethod(_os.rmdir)
-        _os_error = _os.error
-
-        def _rmtree(self, path):
-            # Essentially a stripped down version of shutil.rmtree.  We can't
-            # use globals because they may be None'ed out at shutdown.
-            for name in self._listdir(path):
-                fullname = self._path_join(path, name)
-                try:
-                    isdir = self._isdir(fullname)
-                except self._os_error:
-                    isdir = False
-                if isdir:
-                    self._rmtree(fullname)
-                else:
-                    try:
-                        self._remove(fullname)
-                    except self._os_error:
-                        pass
-            try:
-                self._rmdir(path)
-            except self._os_error:
-                pass
+    def __exit__(self, exc, value, tb):
+        _os.chdir(self.old_wd)
+        return super(TemporaryWorkingDirectory, self).__exit__(exc, value, tb)
diff --git a/IPython/utils/terminal.py b/IPython/utils/terminal.py
index 062f53248e1..14ab7a7ce9c 100644
--- a/IPython/utils/terminal.py
+++ b/IPython/utils/terminal.py
@@ -9,47 +9,30 @@
 * Alexander Belchenko (e-mail: bialix AT ukr.net)
 """
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
 import os
-import struct
 import sys
 import warnings
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
+from shutil import get_terminal_size as _get_terminal_size
 
 # This variable is part of the expected API of the module:
 ignore_termtitle = True
 
 
-def _term_clear():
-    pass
-
 
 if os.name == 'posix':
     def _term_clear():
         os.system('clear')
-
-
-if sys.platform == 'win32':
+elif sys.platform == 'win32':
     def _term_clear():
         os.system('cls')
+else:
+    def _term_clear():
+        pass
 
 
-def term_clear():
-    _term_clear()
-
 
 def toggle_set_term_title(val):
     """Control whether set_term_title is active or not.
@@ -62,7 +45,7 @@ def toggle_set_term_title(val):
 
     Parameters
     ----------
-      val : bool
+    val : bool
         If True, set_term_title() actually writes to the terminal (using the
         appropriate platform-specific module).  If False, it is a no-op.
     """
@@ -75,41 +58,53 @@ def _set_term_title(*args,**kw):
     pass
 
 
+def _restore_term_title():
+    pass
+
+
+_xterm_term_title_saved = False
+
+
 def _set_term_title_xterm(title):
     """ Change virtual terminal title in xterm-workalikes """
+    global _xterm_term_title_saved
+    # Only save the title the first time we set, otherwise restore will only
+    # go back one title (probably undoing a %cd title change).
+    if not _xterm_term_title_saved:
+        # save the current title to the xterm "stack"
+        sys.stdout.write("\033[22;0t")
+        _xterm_term_title_saved = True
     sys.stdout.write('\033]0;%s\007' % title)
 
+
+def _restore_term_title_xterm():
+    # Make sure the restore has at least one accompanying set.
+    global _xterm_term_title_saved
+    if not _xterm_term_title_saved:
+        warnings.warn(
+            "Expecting xterm_term_title_saved to be True, but is not; will not restore terminal title.",
+            stacklevel=1,
+        )
+        return
+
+    sys.stdout.write('\033[23;0t') 
+    _xterm_term_title_saved = False
+
+
 if os.name == 'posix':
     TERM = os.environ.get('TERM','')
-    if (TERM == 'xterm') or (TERM == 'xterm-color'):
+    if TERM.startswith('xterm'):
         _set_term_title = _set_term_title_xterm
+        _restore_term_title = _restore_term_title_xterm
+elif sys.platform == 'win32':
+    import ctypes
 
+    SetConsoleTitleW = ctypes.windll.kernel32.SetConsoleTitleW
+    SetConsoleTitleW.argtypes = [ctypes.c_wchar_p]
 
-if sys.platform == 'win32':
-    try:
-        import ctypes
-
-        SetConsoleTitleW = ctypes.windll.kernel32.SetConsoleTitleW
-        SetConsoleTitleW.argtypes = [ctypes.c_wchar_p]
-    
-        def _set_term_title(title):
-            """Set terminal title using ctypes to access the Win32 APIs."""
-            SetConsoleTitleW(title)
-    except ImportError:
-        def _set_term_title(title):
-            """Set terminal title using the 'title' command."""
-            global ignore_termtitle
-
-            try:
-                # Cannot be on network share when issuing system commands
-                curr = os.getcwd()
-                os.chdir("C:")
-                ret = os.system("title " + title)
-            finally:
-                os.chdir(curr)
-            if ret:
-                # non-zero return code signals error, don't try again
-                ignore_termtitle = True
+    def _set_term_title(title):
+        """Set terminal title using ctypes to access the Win32 APIs."""
+        SetConsoleTitleW(title)
 
 
 def set_term_title(title):
@@ -119,44 +114,12 @@ def set_term_title(title):
     _set_term_title(title)
 
 
-def freeze_term_title():
-    warnings.warn("This function is deprecated, use toggle_set_term_title()")
-    global ignore_termtitle
-    ignore_termtitle = True
-
-
-def get_terminal_size(defaultx=80, defaulty=25):
-    return defaultx, defaulty
-
-
-if sys.platform == 'win32':
-    def get_terminal_size(defaultx=80, defaulty=25):
-        """Return size of current terminal console.
-
-        This function try to determine actual size of current working
-        console window and return tuple (sizex, sizey) if success,
-        or default size (defaultx, defaulty) otherwise.
-
-        Dependencies: ctypes should be installed.
-
-        Author: Alexander Belchenko (e-mail: bialix AT ukr.net)
-        """
-        try:
-            import ctypes
-        except ImportError:
-            return defaultx, defaulty
-
-        h = ctypes.windll.kernel32.GetStdHandle(-11)
-        csbi = ctypes.create_string_buffer(22)
-        res = ctypes.windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
+def restore_term_title():
+    """Restore, if possible, terminal title to the original state"""
+    if ignore_termtitle:
+        return
+    _restore_term_title()
 
-        if res:
-            (bufx, bufy, curx, cury, wattr,
-             left, top, right, bottom, maxx, maxy) = struct.unpack(
-                "hhhhHhhhhhh", csbi.raw)
-            sizex = right - left + 1
-            sizey = bottom - top + 1
-            return (sizex, sizey)
-        else:
-            return (defaultx, defaulty)
 
+def get_terminal_size(defaultx: int = 80, defaulty: int = 25) -> tuple[int, int]:
+    return _get_terminal_size((defaultx, defaulty))
diff --git a/IPython/utils/tests/__init__.py b/IPython/utils/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/utils/tests/test_imports.py b/IPython/utils/tests/test_imports.py
deleted file mode 100644
index aa6ed48d590..00000000000
--- a/IPython/utils/tests/test_imports.py
+++ /dev/null
@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-def test_import_coloransi():
-    from IPython.utils import coloransi
-
-def test_import_generics():
-    from IPython.utils import generics
-
-def test_import_ipstruct():
-    from IPython.utils import ipstruct
-
-def test_import_PyColorize():
-    from IPython.utils import PyColorize
-
-def test_import_rlineimpl():
-    from IPython.utils import rlineimpl
-
-def test_import_strdispatch():
-    from IPython.utils import strdispatch
-
-def test_import_upgradedir():
-    from IPython.utils import upgradedir
-
-def test_import_wildcard():
-    from IPython.utils import wildcard
-
diff --git a/IPython/utils/tests/test_io.py b/IPython/utils/tests/test_io.py
deleted file mode 100644
index 59fdfc503e6..00000000000
--- a/IPython/utils/tests/test_io.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# encoding: utf-8
-"""Tests for io.py"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-
-from cStringIO import StringIO
-from subprocess import Popen, PIPE
-
-import nose.tools as nt
-
-from IPython.testing import decorators as dec
-from IPython.utils.io import Tee
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-
-def test_tee_simple():
-    "Very simple check with stdout only"
-    chan = StringIO()
-    text = 'Hello'
-    tee = Tee(chan, channel='stdout')
-    print >> chan, text,
-    nt.assert_equal(chan.getvalue(), text)
-
-
-class TeeTestCase(dec.ParametricTestCase):
-
-    def tchan(self, channel, check='close'):
-        trap = StringIO()
-        chan = StringIO()
-        text = 'Hello'
-        
-        std_ori = getattr(sys, channel)
-        setattr(sys, channel, trap)
-
-        tee = Tee(chan, channel=channel)
-        print >> chan, text,
-        setattr(sys, channel, std_ori)
-        trap_val = trap.getvalue()
-        nt.assert_equals(chan.getvalue(), text)
-        if check=='close':
-            tee.close()
-        else:
-            del tee
-
-    def test(self):
-        for chan in ['stdout', 'stderr']:
-            for check in ['close', 'del']:
-                yield self.tchan(chan, check)
-
-def test_io_init():
-    """Test that io.stdin/out/err exist at startup"""
-    for name in ('stdin', 'stdout', 'stderr'):
-        p = Popen([sys.executable, '-c', "from IPython.utils import io;print io.%s.__class__"%name],
-                    stdout=PIPE)
-        p.wait()
-        classname = p.stdout.read().strip()
-        nt.assert_equals(classname, 'IPython.utils.io.IOStream')
diff --git a/IPython/utils/tests/test_jsonutil.py b/IPython/utils/tests/test_jsonutil.py
deleted file mode 100644
index d81eafc0bb4..00000000000
--- a/IPython/utils/tests/test_jsonutil.py
+++ /dev/null
@@ -1,71 +0,0 @@
-"""Test suite for our JSON utilities.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING.txt, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-# stdlib
-import json
-
-# third party
-import nose.tools as nt
-
-# our own
-from ..jsonutil import json_clean
-
-#-----------------------------------------------------------------------------
-# Test functions
-#-----------------------------------------------------------------------------
-
-def test():
-    # list of input/expected output.  Use None for the expected output if it
-    # can be the same as the input.
-    pairs = [(1, None), # start with scalars
-             (1.0, None),
-             ('a', None),
-             (True, None),
-             (False, None),
-             (None, None),
-             # complex numbers for now just go to strings, as otherwise they
-             # are unserializable
-             (1j, '1j'),
-             # Containers
-             ([1, 2], None),
-             ((1, 2), [1, 2]),
-             (set([1, 2]), [1, 2]),
-             (dict(x=1), None),
-             ({'x': 1, 'y':[1,2,3], '1':'int'}, None),
-             # More exotic objects
-             ((x for x in range(3)), [0, 1, 2]),
-             (iter([1, 2]), [1, 2]),
-             ]
-    
-    for val, jval in pairs:
-        if jval is None:
-            jval = val
-        out = json_clean(val)
-        # validate our cleanup
-        nt.assert_equal(out, jval)
-        # and ensure that what we return, indeed encodes cleanly
-        json.loads(json.dumps(out))
-
-
-def test_lambda():
-    jc = json_clean(lambda : 1)
-    nt.assert_true(jc.startswith('<function <lambda> at '))
-    json.dumps(jc)
-
-
-def test_exception():
-    bad_dicts = [{1:'number', '1':'string'},
-                 {True:'bool', 'True':'string'},
-                 ]
-    for d in bad_dicts:
-        nt.assert_raises(ValueError, json_clean, d)
-    
diff --git a/IPython/utils/tests/test_notification.py b/IPython/utils/tests/test_notification.py
deleted file mode 100644
index 76d3c2f0ef4..00000000000
--- a/IPython/utils/tests/test_notification.py
+++ /dev/null
@@ -1,150 +0,0 @@
-# encoding: utf-8
-
-"""This file contains unittests for the notification.py module."""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is
-#  in the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import unittest
-
-from IPython.utils.notification import shared_center
-
-#-----------------------------------------------------------------------------
-# Support Classes
-#-----------------------------------------------------------------------------
-
-
-class Observer(object):
-
-    def __init__(self, expected_ntype, expected_sender, 
-                    center=shared_center, *args, **kwargs):
-        super(Observer, self).__init__()
-        self.expected_ntype = expected_ntype
-        self.expected_sender = expected_sender
-        self.expected_args = args
-        self.expected_kwargs = kwargs
-        self.recieved = False
-        center.add_observer(self.callback, 
-                            self.expected_ntype, 
-                            self.expected_sender)
-    
-    def callback(self, ntype, sender, *args, **kwargs):
-        assert(ntype == self.expected_ntype or
-                self.expected_ntype == None)
-        assert(sender == self.expected_sender or
-                self.expected_sender == None)
-        assert(args == self.expected_args)
-        assert(kwargs == self.expected_kwargs)
-        self.recieved = True
-    
-    def verify(self):
-        assert(self.recieved)
-    
-    def reset(self):
-        self.recieved = False
-
-
-class Notifier(object):
-
-    def __init__(self, ntype, **kwargs):
-        super(Notifier, self).__init__()
-        self.ntype = ntype
-        self.kwargs = kwargs
-
-    def post(self, center=shared_center):
-
-        center.post_notification(self.ntype, self,
-            **self.kwargs)
-
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-
-class NotificationTests(unittest.TestCase):
-
-    def tearDown(self):
-        shared_center.remove_all_observers()
-    
-    def test_notification_delivered(self):
-        """Test that notifications are delivered"""
-
-        expected_ntype = 'EXPECTED_TYPE'
-        sender = Notifier(expected_ntype)
-        observer = Observer(expected_ntype, sender)
-
-        sender.post()
-        observer.verify()
-
-    def test_type_specificity(self):
-        """Test that observers are registered by type"""
-
-        expected_ntype = 1
-        unexpected_ntype = "UNEXPECTED_TYPE"
-        sender = Notifier(expected_ntype)
-        unexpected_sender = Notifier(unexpected_ntype)
-        observer = Observer(expected_ntype, sender)
-
-        sender.post()
-        unexpected_sender.post()
-        observer.verify()
-
-    def test_sender_specificity(self):
-        """Test that observers are registered by sender"""
-        
-        expected_ntype = "EXPECTED_TYPE"
-        sender1 = Notifier(expected_ntype)
-        sender2 = Notifier(expected_ntype)
-        observer = Observer(expected_ntype, sender1)
-
-        sender1.post()
-        sender2.post()
-
-        observer.verify()
-
-    def test_remove_all_observers(self):
-        """White-box test for remove_all_observers"""
-
-        for i in xrange(10):
-            Observer('TYPE', None, center=shared_center)
-
-        self.assert_(len(shared_center.observers[('TYPE',None)]) >= 10, 
-            "observers registered")
-
-        shared_center.remove_all_observers()
-        self.assert_(len(shared_center.observers) == 0, "observers removed")
-
-    def test_any_sender(self):
-        expected_ntype = "EXPECTED_TYPE"
-        sender1 = Notifier(expected_ntype)
-        sender2 = Notifier(expected_ntype)
-        observer = Observer(expected_ntype, None)
-
-        sender1.post()
-        observer.verify()
-
-        observer.reset()
-        sender2.post()
-        observer.verify()
-
-    def test_post_performance(self):
-        """Test that post_notification, even with many registered irrelevant
-        observers is fast"""
-        
-        for i in xrange(10):
-            Observer("UNRELATED_TYPE", None)
-
-        o = Observer('EXPECTED_TYPE', None)
-        shared_center.post_notification('EXPECTED_TYPE', self)
-        o.verify()
-
-
diff --git a/IPython/utils/tests/test_path.py b/IPython/utils/tests/test_path.py
deleted file mode 100644
index 1d5ab859c86..00000000000
--- a/IPython/utils/tests/test_path.py
+++ /dev/null
@@ -1,359 +0,0 @@
-# encoding: utf-8
-"""Tests for IPython.utils.path.py"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import os
-import shutil
-import sys
-import tempfile
-
-from os.path import join, abspath, split
-
-import nose.tools as nt
-
-from nose import with_setup
-
-import IPython
-from IPython.testing import decorators as dec
-from IPython.testing.decorators import skip_if_not_win32, skip_win32
-from IPython.utils import path
-
-# Platform-dependent imports
-try:
-    import _winreg as wreg
-except ImportError:
-    #Fake _winreg module on none windows platforms
-    import new
-    sys.modules["_winreg"] = new.module("_winreg")
-    import _winreg as wreg
-    #Add entries that needs to be stubbed by the testing code
-    (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-env = os.environ
-TEST_FILE_PATH = split(abspath(__file__))[0]
-TMP_TEST_DIR = tempfile.mkdtemp()
-HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
-XDG_TEST_DIR = join(HOME_TEST_DIR, "xdg_test_dir")
-IP_TEST_DIR = join(HOME_TEST_DIR,'.ipython')
-#
-# Setup/teardown functions/decorators
-#
-
-def setup():
-    """Setup testenvironment for the module:
-    
-            - Adds dummy home dir tree
-    """
-    # Do not mask exceptions here.  In particular, catching WindowsError is a
-    # problem because that exception is only defined on Windows...
-    os.makedirs(IP_TEST_DIR)
-    os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython'))
-
-
-def teardown():
-    """Teardown testenvironment for the module:
-    
-            - Remove dummy home dir tree
-    """
-    # Note: we remove the parent test dir, which is the root of all test
-    # subdirs we may have created.  Use shutil instead of os.removedirs, so
-    # that non-empty directories are all recursively removed.
-    shutil.rmtree(TMP_TEST_DIR)
-
-
-def setup_environment():
-    """Setup testenvironment for some functions that are tested 
-    in this module. In particular this functions stores attributes
-    and other things that we need to stub in some test functions.
-    This needs to be done on a function level and not module level because 
-    each testfunction needs a pristine environment.
-    """
-    global oldstuff, platformstuff
-    oldstuff = (env.copy(), os.name, path.get_home_dir, IPython.__file__)
-
-    if os.name == 'nt':
-        platformstuff = (wreg.OpenKey, wreg.QueryValueEx,)
-
-
-def teardown_environment():
-    """Restore things that were remebered by the setup_environment function
-    """
-    (oldenv, os.name, get_home_dir, IPython.__file__,) = oldstuff
-        
-    for key in env.keys():
-        if key not in oldenv:
-            del env[key]
-    env.update(oldenv)
-    if hasattr(sys, 'frozen'):
-        del sys.frozen
-    if os.name == 'nt':
-        (wreg.OpenKey, wreg.QueryValueEx,) = platformstuff
-
-# Build decorator that uses the setup_environment/setup_environment
-with_environment = with_setup(setup_environment, teardown_environment)
-
-
-@skip_if_not_win32
-@with_environment
-def test_get_home_dir_1():
-    """Testcase for py2exe logic, un-compressed lib
-    """
-    sys.frozen = True
-    
-    #fake filename for IPython.__init__
-    IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
-    
-    home_dir = path.get_home_dir()
-    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
-
-
-@skip_if_not_win32
-@with_environment
-def test_get_home_dir_2():
-    """Testcase for py2exe logic, compressed lib
-    """
-    sys.frozen = True
-    #fake filename for IPython.__init__
-    IPython.__file__ = abspath(join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")).lower()
-    
-    home_dir = path.get_home_dir()
-    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR).lower())
-
-
-@with_environment
-@skip_win32
-def test_get_home_dir_3():
-    """Testcase $HOME is set, then use its value as home directory."""
-    env["HOME"] = HOME_TEST_DIR
-    home_dir = path.get_home_dir()
-    nt.assert_equal(home_dir, env["HOME"])
-
-
-@with_environment
-def test_get_home_dir_4():
-    """Testcase $HOME is not set, os=='posix'. 
-    This should fail with HomeDirError"""
-    
-    os.name = 'posix'
-    if 'HOME' in env: del env['HOME']
-    nt.assert_raises(path.HomeDirError, path.get_home_dir)
-
-
-@skip_if_not_win32
-@with_environment
-def test_get_home_dir_5():
-    """Using HOMEDRIVE + HOMEPATH, os=='nt'.
-
-    HOMESHARE is missing.
-    """
-
-    os.name = 'nt'
-    env.pop('HOMESHARE', None)
-    env['HOMEDRIVE'], env['HOMEPATH'] = os.path.splitdrive(HOME_TEST_DIR)
-    home_dir = path.get_home_dir()
-    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
-
-
-@skip_if_not_win32
-@with_environment
-def test_get_home_dir_6():
-    """Using USERPROFILE, os=='nt'.
-
-    HOMESHARE, HOMEDRIVE, HOMEPATH are missing.
-    """
-
-    os.name = 'nt'
-    env.pop('HOMESHARE', None)
-    env.pop('HOMEDRIVE', None)
-    env.pop('HOMEPATH', None)
-    env["USERPROFILE"] = abspath(HOME_TEST_DIR)
-    home_dir = path.get_home_dir()
-    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
-
-
-@skip_if_not_win32
-@with_environment
-def test_get_home_dir_7():
-    """Using HOMESHARE, os=='nt'."""
-
-    os.name = 'nt'
-    env["HOMESHARE"] = abspath(HOME_TEST_DIR)
-    home_dir = path.get_home_dir()
-    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
-
-    
-# Should we stub wreg fully so we can run the test on all platforms?
-@skip_if_not_win32
-@with_environment
-def test_get_home_dir_8():
-    """Using registry hack for 'My Documents', os=='nt'
-    
-    HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
-    """
-    os.name = 'nt'
-    # Remove from stub environment all keys that may be set
-    for key in ['HOME', 'HOMESHARE', 'HOMEDRIVE', 'HOMEPATH', 'USERPROFILE']:
-        env.pop(key, None)
-
-    #Stub windows registry functions
-    def OpenKey(x, y):
-        class key:
-            def Close(self):
-                pass
-        return key()
-    def QueryValueEx(x, y):
-        return [abspath(HOME_TEST_DIR)]
-
-    wreg.OpenKey = OpenKey
-    wreg.QueryValueEx = QueryValueEx
-
-    home_dir = path.get_home_dir()
-    nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
-
-
-@with_environment
-def test_get_ipython_dir_1():
-    """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
-    env['IPYTHON_DIR'] = "someplace/.ipython"
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, "someplace/.ipython")
-
-
-@with_environment
-def test_get_ipython_dir_2():
-    """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
-    path.get_home_dir = lambda : "someplace"
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    env.pop('XDG_CONFIG_HOME', None)
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
-
-@with_environment
-def test_get_ipython_dir_3():
-    """test_get_ipython_dir_3, use XDG if defined, and .ipython doesn't exist."""
-    path.get_home_dir = lambda : "someplace"
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, os.path.join(XDG_TEST_DIR, "ipython"))
-
-@with_environment
-def test_get_ipython_dir_4():
-    """test_get_ipython_dir_4, use XDG if both exist."""
-    path.get_home_dir = lambda : HOME_TEST_DIR
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
-    xdg_ipdir = os.path.join(XDG_TEST_DIR, "ipython")
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, xdg_ipdir)
-
-@with_environment
-def test_get_ipython_dir_5():
-    """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
-    os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython'))
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, IP_TEST_DIR)
-
-@with_environment
-def test_get_ipython_dir_6():
-    """test_get_ipython_dir_6, use XDG if defined and neither exist."""
-    path.get_home_dir = lambda : 'somehome'
-    path.get_xdg_dir = lambda : 'somexdg'
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    xdg_ipdir = os.path.join("somexdg", "ipython")
-    ipdir = path.get_ipython_dir()
-    nt.assert_equal(ipdir, xdg_ipdir)
-
-@with_environment
-def test_get_xdg_dir_1():
-    """test_get_xdg_dir_1, check xdg_dir"""
-    reload(path)
-    path.get_home_dir = lambda : 'somewhere'
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    env.pop('XDG_CONFIG_HOME', None)
-    
-    nt.assert_equal(path.get_xdg_dir(), os.path.join('somewhere', '.config'))
-
-
-@with_environment
-def test_get_xdg_dir_1():
-    """test_get_xdg_dir_1, check nonexistant xdg_dir"""
-    reload(path)
-    path.get_home_dir = lambda : HOME_TEST_DIR
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    env.pop('XDG_CONFIG_HOME', None)
-    nt.assert_equal(path.get_xdg_dir(), None)
-
-@with_environment
-def test_get_xdg_dir_2():
-    """test_get_xdg_dir_2, check xdg_dir default to ~/.config"""
-    reload(path)
-    path.get_home_dir = lambda : HOME_TEST_DIR
-    os.name = "posix"
-    env.pop('IPYTHON_DIR', None)
-    env.pop('IPYTHONDIR', None)
-    env.pop('XDG_CONFIG_HOME', None)
-    cfgdir=os.path.join(path.get_home_dir(), '.config')
-    os.makedirs(cfgdir)
-    
-    nt.assert_equal(path.get_xdg_dir(), cfgdir)
-
-def test_filefind():
-    """Various tests for filefind"""
-    f = tempfile.NamedTemporaryFile()
-    # print 'fname:',f.name
-    alt_dirs = path.get_ipython_dir()
-    t = path.filefind(f.name, alt_dirs)
-    # print 'found:',t
-
-
-def test_get_ipython_package_dir():
-    ipdir = path.get_ipython_package_dir()
-    nt.assert_true(os.path.isdir(ipdir))
-
-
-def test_get_ipython_module_path():
-    ipapp_path = path.get_ipython_module_path('IPython.frontend.terminal.ipapp')
-    nt.assert_true(os.path.isfile(ipapp_path))
-
-
-@dec.skip_if_not_win32
-def test_get_long_path_name_win32():
-    p = path.get_long_path_name('c:\\docume~1')
-    nt.assert_equals(p,u'c:\\Documents and Settings') 
-
-
-@dec.skip_win32
-def test_get_long_path_name():
-    p = path.get_long_path_name('/usr/local')
-    nt.assert_equals(p,'/usr/local')
-
diff --git a/IPython/utils/tests/test_process.py b/IPython/utils/tests/test_process.py
deleted file mode 100644
index cbde4276d16..00000000000
--- a/IPython/utils/tests/test_process.py
+++ /dev/null
@@ -1,98 +0,0 @@
-# encoding: utf-8
-"""
-Tests for platutils.py
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-from unittest import TestCase
-
-import nose.tools as nt
-
-from IPython.utils.process import (find_cmd, FindCmdError, arg_split,
-                                   system, getoutput, getoutputerror)
-from IPython.testing import decorators as dec
-from IPython.testing import tools as tt
-
-#-----------------------------------------------------------------------------
-# Tests
-#-----------------------------------------------------------------------------
-
-def test_find_cmd_python():
-    """Make sure we find sys.exectable for python."""
-    nt.assert_equals(find_cmd('python'), sys.executable)
-
-    
-@dec.skip_win32
-def test_find_cmd_ls():
-    """Make sure we can find the full path to ls."""
-    path = find_cmd('ls')
-    nt.assert_true(path.endswith('ls'))
-
-    
-def has_pywin32():
-    try:
-        import win32api
-    except ImportError:
-        return False
-    return True
-
-
-@dec.onlyif(has_pywin32, "This test requires win32api to run")
-def test_find_cmd_pythonw():
-    """Try to find pythonw on Windows."""
-    path = find_cmd('pythonw')
-    nt.assert_true(path.endswith('pythonw.exe'))
-
-
-@dec.onlyif(lambda : sys.platform != 'win32' or has_pywin32(),
-            "This test runs on posix or in win32 with win32api installed")
-def test_find_cmd_fail():
-    """Make sure that FindCmdError is raised if we can't find the cmd."""
-    nt.assert_raises(FindCmdError,find_cmd,'asdfasdf')
-
-    
-def test_arg_split():
-    """Ensure that argument lines are correctly split like in a shell."""
-    tests = [['hi', ['hi']],
-             [u'hi', [u'hi']],
-             ['hello there', ['hello', 'there']],
-             [u'h\N{LATIN SMALL LETTER A WITH CARON}llo', [u'h\N{LATIN SMALL LETTER A WITH CARON}llo']],
-             ['something "with quotes"', ['something', '"with quotes"']],
-             ]
-    for argstr, argv in tests:
-        nt.assert_equal(arg_split(argstr), argv)
-
-
-class SubProcessTestCase(TestCase, tt.TempFileMixin):
-    def setUp(self):
-        """Make a valid python temp file."""
-        lines = ["from __future__ import print_function",
-                 "import sys",
-                 "print('on stdout', end='', file=sys.stdout)",
-                 "print('on stderr', end='', file=sys.stderr)",
-                 "sys.stdout.flush()",
-                 "sys.stderr.flush()"]
-        self.mktmp('\n'.join(lines))
-
-    def test_system(self):
-        system('python "%s"' % self.fname)
-
-    def test_getoutput(self):
-        out = getoutput('python "%s"' % self.fname)
-        self.assertEquals(out, 'on stdout')
-
-    def test_getoutput(self):
-        out, err = getoutputerror('python "%s"' % self.fname)
-        self.assertEquals(out, 'on stdout')
-        self.assertEquals(err, 'on stderr')
diff --git a/IPython/utils/tests/test_traitlets.py b/IPython/utils/tests/test_traitlets.py
deleted file mode 100755
index 724d631a750..00000000000
--- a/IPython/utils/tests/test_traitlets.py
+++ /dev/null
@@ -1,741 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-Tests for IPython.utils.traitlets.
-
-Authors:
-
-* Brian Granger
-* Enthought, Inc.  Some of the code in this file comes from enthought.traits
-  and is licensed under the BSD license.  Also, many of the ideas also come
-  from enthought.traits even though our implementation is very different.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-from unittest import TestCase
-
-from IPython.utils.traitlets import (
-    HasTraits, MetaHasTraits, TraitType, Any,
-    Int, Long, Float, Complex, Str, Unicode, TraitError,
-    Undefined, Type, This, Instance, TCPAddress
-)
-
-
-#-----------------------------------------------------------------------------
-# Helper classes for testing
-#-----------------------------------------------------------------------------
-
-
-class HasTraitsStub(HasTraits):
-
-    def _notify_trait(self, name, old, new):
-        self._notify_name = name
-        self._notify_old = old
-        self._notify_new = new
-
-
-#-----------------------------------------------------------------------------
-# Test classes
-#-----------------------------------------------------------------------------
-
-
-class TestTraitType(TestCase):
-
-    def test_get_undefined(self):
-        class A(HasTraits):
-            a = TraitType
-        a = A()
-        self.assertEquals(a.a, Undefined)
-
-    def test_set(self):
-        class A(HasTraitsStub):
-            a = TraitType
-
-        a = A()
-        a.a = 10
-        self.assertEquals(a.a, 10)
-        self.assertEquals(a._notify_name, 'a')
-        self.assertEquals(a._notify_old, Undefined)
-        self.assertEquals(a._notify_new, 10)
-
-    def test_validate(self):
-        class MyTT(TraitType):
-            def validate(self, inst, value):
-                return -1
-        class A(HasTraitsStub):
-            tt = MyTT
-        
-        a = A()
-        a.tt = 10
-        self.assertEquals(a.tt, -1)
-
-    def test_default_validate(self):
-        class MyIntTT(TraitType):
-            def validate(self, obj, value):
-                if isinstance(value, int):
-                    return value
-                self.error(obj, value)
-        class A(HasTraits):
-            tt = MyIntTT(10)
-        a = A()
-        self.assertEquals(a.tt, 10)
-
-        # Defaults are validated when the HasTraits is instantiated
-        class B(HasTraits):
-            tt = MyIntTT('bad default')
-        self.assertRaises(TraitError, B)
-
-    def test_is_valid_for(self):
-        class MyTT(TraitType):
-            def is_valid_for(self, value):
-                return True
-        class A(HasTraits):
-            tt = MyTT
-
-        a = A()
-        a.tt = 10
-        self.assertEquals(a.tt, 10)
-
-    def test_value_for(self):
-        class MyTT(TraitType):
-            def value_for(self, value):
-                return 20
-        class A(HasTraits):
-            tt = MyTT
-
-        a = A()
-        a.tt = 10
-        self.assertEquals(a.tt, 20)
-
-    def test_info(self):
-        class A(HasTraits):
-            tt = TraitType
-        a = A()
-        self.assertEquals(A.tt.info(), 'any value')
-
-    def test_error(self):
-        class A(HasTraits):
-            tt = TraitType
-        a = A()
-        self.assertRaises(TraitError, A.tt.error, a, 10)
-
-    def test_dynamic_initializer(self):
-        class A(HasTraits):
-            x = Int(10)
-            def _x_default(self):
-                return 11
-        class B(A):
-            x = Int(20)
-        class C(A):
-            def _x_default(self):
-                return 21
-
-        a = A()
-        self.assertEquals(a._trait_values, {})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(a.x, 11)
-        self.assertEquals(a._trait_values, {'x': 11})
-        b = B()
-        self.assertEquals(b._trait_values, {'x': 20})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(b.x, 20)
-        c = C()
-        self.assertEquals(c._trait_values, {})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(c.x, 21)
-        self.assertEquals(c._trait_values, {'x': 21})
-        # Ensure that the base class remains unmolested when the _default
-        # initializer gets overridden in a subclass.
-        a = A()
-        c = C()
-        self.assertEquals(a._trait_values, {})
-        self.assertEquals(a._trait_dyn_inits.keys(), ['x'])
-        self.assertEquals(a.x, 11)
-        self.assertEquals(a._trait_values, {'x': 11})
-
-
-
-class TestHasTraitsMeta(TestCase):
-
-    def test_metaclass(self):
-        self.assertEquals(type(HasTraits), MetaHasTraits)
-
-        class A(HasTraits):
-            a = Int
-
-        a = A()
-        self.assertEquals(type(a.__class__), MetaHasTraits)
-        self.assertEquals(a.a,0)
-        a.a = 10
-        self.assertEquals(a.a,10)
-
-        class B(HasTraits):
-            b = Int()
-
-        b = B()
-        self.assertEquals(b.b,0)
-        b.b = 10
-        self.assertEquals(b.b,10)
-
-        class C(HasTraits):
-            c = Int(30)
-
-        c = C()
-        self.assertEquals(c.c,30)
-        c.c = 10
-        self.assertEquals(c.c,10)
-
-    def test_this_class(self):
-        class A(HasTraits):
-            t = This()
-            tt = This()
-        class B(A):
-            tt = This()
-            ttt = This()
-        self.assertEquals(A.t.this_class, A)
-        self.assertEquals(B.t.this_class, A)
-        self.assertEquals(B.tt.this_class, B)
-        self.assertEquals(B.ttt.this_class, B)
-
-class TestHasTraitsNotify(TestCase):
-
-    def setUp(self):
-        self._notify1 = []
-        self._notify2 = []
-
-    def notify1(self, name, old, new):
-        self._notify1.append((name, old, new))
-
-    def notify2(self, name, old, new):
-        self._notify2.append((name, old, new))
-
-    def test_notify_all(self):
-
-        class A(HasTraits):
-            a = Int
-            b = Float
-
-        a = A()
-        a.on_trait_change(self.notify1)
-        a.a = 0
-        self.assertEquals(len(self._notify1),0)
-        a.b = 0.0
-        self.assertEquals(len(self._notify1),0)
-        a.a = 10
-        self.assert_(('a',0,10) in self._notify1)
-        a.b = 10.0
-        self.assert_(('b',0.0,10.0) in self._notify1)
-        self.assertRaises(TraitError,setattr,a,'a','bad string')
-        self.assertRaises(TraitError,setattr,a,'b','bad string')
-        self._notify1 = []
-        a.on_trait_change(self.notify1,remove=True)
-        a.a = 20
-        a.b = 20.0
-        self.assertEquals(len(self._notify1),0)
-
-    def test_notify_one(self):
-
-        class A(HasTraits):
-            a = Int
-            b = Float
-
-        a = A()
-        a.on_trait_change(self.notify1, 'a')
-        a.a = 0
-        self.assertEquals(len(self._notify1),0)
-        a.a = 10
-        self.assert_(('a',0,10) in self._notify1)
-        self.assertRaises(TraitError,setattr,a,'a','bad string')
-
-    def test_subclass(self):
-
-        class A(HasTraits):
-            a = Int
-
-        class B(A):
-            b = Float
-
-        b = B()
-        self.assertEquals(b.a,0)
-        self.assertEquals(b.b,0.0)
-        b.a = 100
-        b.b = 100.0
-        self.assertEquals(b.a,100)
-        self.assertEquals(b.b,100.0)
-
-    def test_notify_subclass(self):
-
-        class A(HasTraits):
-            a = Int
-
-        class B(A):
-            b = Float
-
-        b = B()
-        b.on_trait_change(self.notify1, 'a')
-        b.on_trait_change(self.notify2, 'b')
-        b.a = 0
-        b.b = 0.0
-        self.assertEquals(len(self._notify1),0)
-        self.assertEquals(len(self._notify2),0)
-        b.a = 10
-        b.b = 10.0
-        self.assert_(('a',0,10) in self._notify1)
-        self.assert_(('b',0.0,10.0) in self._notify2)
-
-    def test_static_notify(self):
-
-        class A(HasTraits):
-            a = Int
-            _notify1 = []
-            def _a_changed(self, name, old, new):
-                self._notify1.append((name, old, new))
-
-        a = A()
-        a.a = 0
-        # This is broken!!!
-        self.assertEquals(len(a._notify1),0)
-        a.a = 10
-        self.assert_(('a',0,10) in a._notify1)
-
-        class B(A):
-            b = Float
-            _notify2 = []
-            def _b_changed(self, name, old, new):
-                self._notify2.append((name, old, new))
-
-        b = B()
-        b.a = 10
-        b.b = 10.0
-        self.assert_(('a',0,10) in b._notify1)
-        self.assert_(('b',0.0,10.0) in b._notify2)
-
-    def test_notify_args(self):
-
-        def callback0():
-            self.cb = ()
-        def callback1(name):
-            self.cb = (name,)
-        def callback2(name, new):
-            self.cb = (name, new)
-        def callback3(name, old, new):
-            self.cb = (name, old, new)
-
-        class A(HasTraits):
-            a = Int
-
-        a = A()
-        a.on_trait_change(callback0, 'a')
-        a.a = 10
-        self.assertEquals(self.cb,())
-        a.on_trait_change(callback0, 'a', remove=True)
-
-        a.on_trait_change(callback1, 'a')
-        a.a = 100
-        self.assertEquals(self.cb,('a',))
-        a.on_trait_change(callback1, 'a', remove=True)
-
-        a.on_trait_change(callback2, 'a')
-        a.a = 1000
-        self.assertEquals(self.cb,('a',1000))
-        a.on_trait_change(callback2, 'a', remove=True)
-
-        a.on_trait_change(callback3, 'a')
-        a.a = 10000
-        self.assertEquals(self.cb,('a',1000,10000))
-        a.on_trait_change(callback3, 'a', remove=True)
-
-        self.assertEquals(len(a._trait_notifiers['a']),0)
-
-
-class TestHasTraits(TestCase):
-
-    def test_trait_names(self):
-        class A(HasTraits):
-            i = Int
-            f = Float
-        a = A()
-        self.assertEquals(a.trait_names(),['i','f'])
-
-    def test_trait_metadata(self):
-        class A(HasTraits):
-            i = Int(config_key='MY_VALUE')
-        a = A()
-        self.assertEquals(a.trait_metadata('i','config_key'), 'MY_VALUE')
-
-    def test_traits(self):
-        class A(HasTraits):
-            i = Int
-            f = Float
-        a = A()
-        self.assertEquals(a.traits(), dict(i=A.i, f=A.f))
-
-    def test_traits_metadata(self):
-        class A(HasTraits):
-            i = Int(config_key='VALUE1', other_thing='VALUE2')
-            f = Float(config_key='VALUE3', other_thing='VALUE2')
-            j = Int(0)
-        a = A()
-        self.assertEquals(a.traits(), dict(i=A.i, f=A.f, j=A.j))
-        traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
-        self.assertEquals(traits, dict(i=A.i))
-
-        # This passes, but it shouldn't because I am replicating a bug in 
-        # traits.
-        traits = a.traits(config_key=lambda v: True)
-        self.assertEquals(traits, dict(i=A.i, f=A.f, j=A.j))
-
-    def test_init(self):
-        class A(HasTraits):
-            i = Int()
-            x = Float()
-        a = A(i=1, x=10.0)
-        self.assertEquals(a.i, 1)
-        self.assertEquals(a.x, 10.0)
-
-#-----------------------------------------------------------------------------
-# Tests for specific trait types
-#-----------------------------------------------------------------------------
-
-
-class TestType(TestCase):
-
-    def test_default(self):
-
-        class B(object): pass
-        class A(HasTraits):
-            klass = Type
-
-        a = A()
-        self.assertEquals(a.klass, None)
-
-        a.klass = B
-        self.assertEquals(a.klass, B)
-        self.assertRaises(TraitError, setattr, a, 'klass', 10)
-
-    def test_value(self):
-
-        class B(object): pass
-        class C(object): pass
-        class A(HasTraits):
-            klass = Type(B)
-        
-        a = A()
-        self.assertEquals(a.klass, B)
-        self.assertRaises(TraitError, setattr, a, 'klass', C)
-        self.assertRaises(TraitError, setattr, a, 'klass', object)
-        a.klass = B
-
-    def test_allow_none(self):
-
-        class B(object): pass
-        class C(B): pass
-        class A(HasTraits):
-            klass = Type(B, allow_none=False)
-
-        a = A()
-        self.assertEquals(a.klass, B)
-        self.assertRaises(TraitError, setattr, a, 'klass', None)
-        a.klass = C
-        self.assertEquals(a.klass, C)
-
-    def test_validate_klass(self):
-
-        class A(HasTraits):
-            klass = Type('no strings allowed')
-
-        self.assertRaises(ImportError, A)
-
-        class A(HasTraits):
-            klass = Type('rub.adub.Duck')
-
-        self.assertRaises(ImportError, A)
-
-    def test_validate_default(self):
-
-        class B(object): pass
-        class A(HasTraits):
-            klass = Type('bad default', B)
-
-        self.assertRaises(ImportError, A)
-
-        class C(HasTraits):
-            klass = Type(None, B, allow_none=False)
-
-        self.assertRaises(TraitError, C)
-
-    def test_str_klass(self):
-
-        class A(HasTraits):
-            klass = Type('IPython.utils.ipstruct.Struct')
-
-        from IPython.utils.ipstruct import Struct
-        a = A()
-        a.klass = Struct
-        self.assertEquals(a.klass, Struct)
-        
-        self.assertRaises(TraitError, setattr, a, 'klass', 10)
-
-class TestInstance(TestCase):
-
-    def test_basic(self):
-        class Foo(object): pass
-        class Bar(Foo): pass
-        class Bah(object): pass
-        
-        class A(HasTraits):
-            inst = Instance(Foo)
-
-        a = A()
-        self.assert_(a.inst is None)
-        a.inst = Foo()
-        self.assert_(isinstance(a.inst, Foo))
-        a.inst = Bar()
-        self.assert_(isinstance(a.inst, Foo))
-        self.assertRaises(TraitError, setattr, a, 'inst', Foo)
-        self.assertRaises(TraitError, setattr, a, 'inst', Bar)
-        self.assertRaises(TraitError, setattr, a, 'inst', Bah())
-
-    def test_unique_default_value(self):
-        class Foo(object): pass
-        class A(HasTraits):
-            inst = Instance(Foo,(),{})
-
-        a = A()
-        b = A()
-        self.assert_(a.inst is not b.inst)
-
-    def test_args_kw(self):
-        class Foo(object):
-            def __init__(self, c): self.c = c
-        class Bar(object): pass
-        class Bah(object):
-            def __init__(self, c, d):
-                self.c = c; self.d = d
-
-        class A(HasTraits):
-            inst = Instance(Foo, (10,))
-        a = A()
-        self.assertEquals(a.inst.c, 10)
-
-        class B(HasTraits):
-            inst = Instance(Bah, args=(10,), kw=dict(d=20))
-        b = B()
-        self.assertEquals(b.inst.c, 10)
-        self.assertEquals(b.inst.d, 20)
-
-        class C(HasTraits):
-            inst = Instance(Foo)
-        c = C()
-        self.assert_(c.inst is None)
-
-    def test_bad_default(self):
-        class Foo(object): pass
-
-        class A(HasTraits):
-            inst = Instance(Foo, allow_none=False)
-        
-        self.assertRaises(TraitError, A)
-
-    def test_instance(self):
-        class Foo(object): pass
-
-        def inner():
-            class A(HasTraits):
-                inst = Instance(Foo())
-        
-        self.assertRaises(TraitError, inner)
-
-
-class TestThis(TestCase):
-
-    def test_this_class(self):
-        class Foo(HasTraits):
-            this = This
-
-        f = Foo()
-        self.assertEquals(f.this, None)
-        g = Foo()
-        f.this = g
-        self.assertEquals(f.this, g)
-        self.assertRaises(TraitError, setattr, f, 'this', 10)
-
-    def test_this_inst(self):
-        class Foo(HasTraits):
-            this = This()
-        
-        f = Foo()
-        f.this = Foo()
-        self.assert_(isinstance(f.this, Foo))
-
-    def test_subclass(self):
-        class Foo(HasTraits):
-            t = This()
-        class Bar(Foo):
-            pass
-        f = Foo()
-        b = Bar()
-        f.t = b
-        b.t = f
-        self.assertEquals(f.t, b)
-        self.assertEquals(b.t, f)
-
-    def test_subclass_override(self):
-        class Foo(HasTraits):
-            t = This()
-        class Bar(Foo):
-            t = This()
-        f = Foo()
-        b = Bar()
-        f.t = b
-        self.assertEquals(f.t, b)
-        self.assertRaises(TraitError, setattr, b, 't', f)
-
-class TraitTestBase(TestCase):
-    """A best testing class for basic trait types."""
-
-    def assign(self, value):
-        self.obj.value = value
-
-    def coerce(self, value):
-        return value
-
-    def test_good_values(self):
-        if hasattr(self, '_good_values'):
-            for value in self._good_values:
-                self.assign(value)
-                self.assertEquals(self.obj.value, self.coerce(value))
-
-    def test_bad_values(self):
-        if hasattr(self, '_bad_values'):
-            for value in self._bad_values:
-                self.assertRaises(TraitError, self.assign, value)
-
-    def test_default_value(self):
-        if hasattr(self, '_default_value'):
-            self.assertEquals(self._default_value, self.obj.value)
-
-
-class AnyTrait(HasTraits):
-
-    value = Any
-
-class AnyTraitTest(TraitTestBase):
-
-    obj = AnyTrait()
-
-    _default_value = None
-    _good_values   = [10.0, 'ten', u'ten', [10], {'ten': 10},(10,), None, 1j]
-    _bad_values    = []
-
-
-class IntTrait(HasTraits):
-
-    value = Int(99)
-
-class TestInt(TraitTestBase):
-
-    obj = IntTrait()
-    _default_value = 99
-    _good_values   = [10, -10]
-    _bad_values    = ['ten', u'ten', [10], {'ten': 10},(10,), None, 1j, 10L,
-                      -10L, 10.1, -10.1, '10L', '-10L', '10.1', '-10.1', u'10L',
-                      u'-10L', u'10.1', u'-10.1',  '10', '-10', u'10', u'-10']
-
-
-class LongTrait(HasTraits):
-
-    value = Long(99L)
-
-class TestLong(TraitTestBase):
-
-    obj = LongTrait()
-
-    _default_value = 99L
-    _good_values   = [10, -10, 10L, -10L]
-    _bad_values    = ['ten', u'ten', [10], [10l], {'ten': 10},(10,),(10L,),
-                      None, 1j, 10.1, -10.1, '10', '-10', '10L', '-10L', '10.1',
-                      '-10.1', u'10', u'-10', u'10L', u'-10L', u'10.1',
-                      u'-10.1']
-
-
-class FloatTrait(HasTraits):
-
-    value = Float(99.0)
-
-class TestFloat(TraitTestBase):
-
-    obj = FloatTrait()
-
-    _default_value = 99.0
-    _good_values   = [10, -10, 10.1, -10.1]
-    _bad_values    = [10L, -10L, 'ten', u'ten', [10], {'ten': 10},(10,), None,
-                      1j, '10', '-10', '10L', '-10L', '10.1', '-10.1', u'10',
-                      u'-10', u'10L', u'-10L', u'10.1', u'-10.1']
-
-
-class ComplexTrait(HasTraits):
-
-    value = Complex(99.0-99.0j)
-
-class TestComplex(TraitTestBase):
-
-    obj = ComplexTrait()
-
-    _default_value = 99.0-99.0j
-    _good_values   = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j, 
-                      10.1j, 10.1+10.1j, 10.1-10.1j]
-    _bad_values    = [10L, -10L, u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
-
-
-class StringTrait(HasTraits):
-
-    value = Str('string')
-
-class TestString(TraitTestBase):
-
-    obj = StringTrait()
-
-    _default_value = 'string'
-    _good_values   = ['10', '-10', '10L',
-                      '-10L', '10.1', '-10.1', 'string']
-    _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j, [10],
-                      ['ten'],{'ten': 10},(10,), None,  u'string']
-
-
-class UnicodeTrait(HasTraits):
-
-    value = Unicode(u'unicode')
-
-class TestUnicode(TraitTestBase):
-
-    obj = UnicodeTrait()
-
-    _default_value = u'unicode'
-    _good_values   = ['10', '-10', '10L', '-10L', '10.1', 
-                      '-10.1', '', u'', 'string', u'string', ]
-    _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j,
-                      [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]
-
-
-class TCPAddressTrait(HasTraits):
-
-    value = TCPAddress()
-
-class TestTCPAddress(TraitTestBase):
-
-    obj = TCPAddressTrait()
-
-    _default_value = ('127.0.0.1',0)
-    _good_values = [('localhost',0),('192.168.0.1',1000),('www.google.com',80)]
-    _bad_values = [(0,0),('localhost',10.0),('localhost',-1)]
diff --git a/IPython/utils/tests/test_wildcard.py b/IPython/utils/tests/test_wildcard.py
deleted file mode 100644
index 7c5cff54cd2..00000000000
--- a/IPython/utils/tests/test_wildcard.py
+++ /dev/null
@@ -1,148 +0,0 @@
-"""Some tests for the wildcard utilities."""
-
-#-----------------------------------------------------------------------------
-# Library imports
-#-----------------------------------------------------------------------------
-# Stdlib
-import sys
-import unittest
-
-# Our own
-from IPython.utils import wildcard
-
-#-----------------------------------------------------------------------------
-# Globals for test
-#-----------------------------------------------------------------------------
-
-class obj_t(object):
-    pass
-
-root = obj_t()
-l = ["arna","abel","ABEL","active","bob","bark","abbot"]
-q = ["kate","loop","arne","vito","lucifer","koppel"]
-for x in l:
-    o = obj_t()
-    setattr(root,x,o)
-    for y in q:
-        p = obj_t()
-        setattr(o,y,p)
-root._apan = obj_t()
-root._apan.a = 10
-root._apan._a = 20
-root._apan.__a = 20
-root.__anka = obj_t()
-root.__anka.a = 10
-root.__anka._a = 20
-root.__anka.__a = 20
-
-root._APAN = obj_t()
-root._APAN.a = 10
-root._APAN._a = 20
-root._APAN.__a = 20
-root.__ANKA = obj_t()
-root.__ANKA.a = 10
-root.__ANKA._a = 20
-root.__ANKA.__a = 20
-
-#-----------------------------------------------------------------------------
-# Test cases
-#-----------------------------------------------------------------------------
-
-class Tests (unittest.TestCase):
-    def test_case(self):
-        ns=root.__dict__
-        tests=[
-         ("a*",     ["abbot","abel","active","arna",]),
-         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop",]),
-         ("_a*",    []),
-         ("_*anka", ["__anka",]),
-         ("_*a*",   ["__anka",]),
-        ]
-        for pat,res in tests:
-            res.sort()
-            a=wildcard.list_namespace(ns,"all",pat,ignore_case=False,
-                                      show_all=False).keys()
-            a.sort()
-            self.assertEqual(a,res)
-
-    def test_case_showall(self):
-        ns=root.__dict__
-        tests=[
-         ("a*",     ["abbot","abel","active","arna",]),
-         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop",]),
-         ("_a*",    ["_apan"]),
-         ("_*anka", ["__anka",]),
-         ("_*a*",   ["__anka","_apan",]),
-        ]
-        for pat,res in tests:
-            res.sort()
-            a=wildcard.list_namespace(ns,"all",pat,ignore_case=False,
-                                      show_all=True).keys()
-            a.sort()
-            self.assertEqual(a,res)
-
-
-    def test_nocase(self):
-        ns=root.__dict__
-        tests=[
-         ("a*",     ["abbot","abel","ABEL","active","arna",]),
-         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop",
-                     "ABEL.koppel","ABEL.loop",]),
-         ("_a*",    []),
-         ("_*anka", ["__anka","__ANKA",]),
-         ("_*a*",   ["__anka","__ANKA",]),
-        ]
-        for pat,res in tests:
-            res.sort()
-            a=wildcard.list_namespace(ns,"all",pat,ignore_case=True,
-                                      show_all=False).keys()
-            a.sort()
-            self.assertEqual(a,res)
-
-    def test_nocase_showall(self):
-        ns=root.__dict__
-        tests=[
-         ("a*",     ["abbot","abel","ABEL","active","arna",]),
-         ("?b*.?o*",["abbot.koppel","abbot.loop","abel.koppel","abel.loop",
-                     "ABEL.koppel","ABEL.loop",]),
-         ("_a*",    ["_apan","_APAN"]),
-         ("_*anka", ["__anka","__ANKA",]),
-         ("_*a*",   ["__anka","__ANKA","_apan","_APAN"]),
-        ]
-        for pat,res in tests:
-            res.sort()
-            a=wildcard.list_namespace(ns,"all",pat,ignore_case=True,
-                                      show_all=True).keys()
-            a.sort()
-            self.assertEqual(a,res)
-            
-    def test_dict_attributes(self):
-        """Dictionaries should be indexed by attributes, not by keys. This was
-        causing Github issue 129."""
-        ns = {"az":{"king":55}, "pq":{1:0}}
-        tests = [
-          ("a*", ["az"]),
-          ("az.k*", ["az.keys"]),
-          ("pq.k*", ["pq.keys"])
-        ]
-        for pat, res in tests:
-            res.sort()
-            a = wildcard.list_namespace(ns, "all", pat, ignore_case=False,
-                                        show_all=True).keys()
-            a.sort()
-            self.assertEqual(a, res)
-    
-    def test_dict_dir(self):
-        class A(object):
-            def __init__(self):
-                self.a = 1
-                self.b = 2
-            def __getattribute__(self, name):
-                if name=="a":
-                    raise AttributeError
-                return object.__getattribute__(self, name)
-                
-        a = A()
-        adict = wildcard.dict_dir(a)
-        assert "a" not in adict # change to assertNotIn method in >= 2.7
-        self.assertEqual(adict["b"], 2)
diff --git a/IPython/utils/text.py b/IPython/utils/text.py
index e00266cd726..cd907f7782e 100644
--- a/IPython/utils/text.py
+++ b/IPython/utils/text.py
@@ -1,45 +1,34 @@
-# encoding: utf-8
 """
 Utilities for working with strings and text.
-"""
 
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
+Inheritance diagram:
 
-import __main__
+.. inheritance-diagram:: IPython.utils.text
+   :parts: 3
+"""
 
 import os
 import re
-import shutil
-
-from IPython.external.path import path
-
-from IPython.utils.io import nlprint
-from IPython.utils.data import flatten
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-def unquote_ends(istr):
-    """Remove a single pair of quotes from the endpoints of a string."""
-
-    if not istr:
-        return istr
-    if (istr[0]=="'" and istr[-1]=="'") or \
-       (istr[0]=='"' and istr[-1]=='"'):
-        return istr[1:-1]
-    else:
-        return istr
+import string
+import sys
+import textwrap
+import warnings
+from string import Formatter
+from pathlib import Path
+
+from typing import (
+    List,
+    Dict,
+    Tuple,
+    Optional,
+    cast,
+    Any,
+    Union,
+    TypeVar,
+)
+from collections.abc import Sequence, Mapping, Callable, Iterator
+
+from typing import Self
 
 
 class LSString(str):
@@ -50,7 +39,7 @@ class LSString(str):
         .l (or .list) : value as list (split on newlines).
         .n (or .nlstr): original value (the string itself).
         .s (or .spstr): value as whitespace-separated string.
-        .p (or .paths): list of path objects
+        .p (or .paths): list of path objects (requires path.py package)
 
     Any values which require transformations are computed only once and
     cached.
@@ -58,7 +47,11 @@ class LSString(str):
     Such strings are very useful to efficiently interact with the shell, which
     typically only understands whitespace-separated options for commands."""
 
-    def get_list(self):
+    __list: List[str]
+    __spstr: str
+    __paths: List[Path]
+
+    def get_list(self) -> List[str]:
         try:
             return self.__list
         except AttributeError:
@@ -67,7 +60,7 @@ def get_list(self):
 
     l = list = property(get_list)
 
-    def get_spstr(self):
+    def get_spstr(self) -> str:
         try:
             return self.__spstr
         except AttributeError:
@@ -76,16 +69,16 @@ def get_spstr(self):
 
     s = spstr = property(get_spstr)
 
-    def get_nlstr(self):
+    def get_nlstr(self) -> Self:
         return self
 
     n = nlstr = property(get_nlstr)
 
-    def get_paths(self):
+    def get_paths(self) -> List[Path]:
         try:
             return self.__paths
         except AttributeError:
-            self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
+            self.__paths = [Path(p) for p in self.split('\n') if os.path.exists(p)]
             return self.__paths
 
     p = paths = property(get_paths)
@@ -96,32 +89,36 @@ def get_paths(self):
 
 # def print_lsstring(arg):
 #     """ Prettier (non-repr-like) and more informative printer for LSString """
-#     print "LSString (.p, .n, .l, .s available). Value:"
-#     print arg
-# 
-# 
-# print_lsstring = result_display.when_type(LSString)(print_lsstring)
+#     print("LSString (.p, .n, .l, .s available). Value:")
+#     print(arg)
+#
+#
+# print_lsstring = result_display.register(LSString)(print_lsstring)
 
 
-class SList(list):
+class SList(list[Any]):
     """List derivative with a special access attributes.
 
     These are normal lists, but with the special attributes:
 
-        .l (or .list) : value as list (the list itself).
-        .n (or .nlstr): value as a string, joined on newlines.
-        .s (or .spstr): value as a string, joined on spaces.
-        .p (or .paths): list of path objects
+    * .l (or .list) : value as list (the list itself).
+    * .n (or .nlstr): value as a string, joined on newlines.
+    * .s (or .spstr): value as a string, joined on spaces.
+    * .p (or .paths): list of path objects (requires path.py package)
 
     Any values which require transformations are computed only once and
     cached."""
 
-    def get_list(self):
+    __spstr: str
+    __nlstr: str
+    __paths: List[Path]
+
+    def get_list(self) -> Self:
         return self
 
     l = list = property(get_list)
 
-    def get_spstr(self):
+    def get_spstr(self) -> str:
         try:
             return self.__spstr
         except AttributeError:
@@ -130,7 +127,7 @@ def get_spstr(self):
 
     s = spstr = property(get_spstr)
 
-    def get_nlstr(self):
+    def get_nlstr(self) -> str:
         try:
             return self.__nlstr
         except AttributeError:
@@ -139,17 +136,22 @@ def get_nlstr(self):
 
     n = nlstr = property(get_nlstr)
 
-    def get_paths(self):
+    def get_paths(self) -> List[Path]:
         try:
             return self.__paths
         except AttributeError:
-            self.__paths = [path(p) for p in self if os.path.exists(p)]
+            self.__paths = [Path(p) for p in self if os.path.exists(p)]
             return self.__paths
 
     p = paths = property(get_paths)
 
-    def grep(self, pattern, prune = False, field = None):
-        """ Return all strings matching 'pattern' (a regex or callable)
+    def grep(
+        self,
+        pattern: Union[str, Callable[[Any], re.Match[str] | None]],
+        prune: bool = False,
+        field: Optional[int] = None,
+    ) -> Self:
+        """Return all strings matching 'pattern' (a regex or callable)
 
         This is case-insensitive. If prune is true, return all items
         NOT matching the pattern.
@@ -164,7 +166,7 @@ def grep(self, pattern, prune = False, field = None):
             a.grep('chm', field=-1)
         """
 
-        def match_target(s):
+        def match_target(s: str) -> str:
             if field is None:
                 return s
             parts = s.split()
@@ -174,28 +176,29 @@ def match_target(s):
             except IndexError:
                 return ""
 
-        if isinstance(pattern, basestring):
+        if isinstance(pattern, str):
             pred = lambda x : re.search(pattern, x, re.IGNORECASE)
         else:
             pred = pattern
         if not prune:
-            return SList([el for el in self if pred(match_target(el))])
+            return type(self)([el for el in self if pred(match_target(el))])  # type: ignore [no-untyped-call]
         else:
-            return SList([el for el in self if not pred(match_target(el))])
+            return type(self)([el for el in self if not pred(match_target(el))])  # type: ignore [no-untyped-call]
 
-    def fields(self, *fields):
-        """ Collect whitespace-separated fields from string list
+    def fields(self, *fields: List[str]) -> List[List[str]]:
+        """Collect whitespace-separated fields from string list
 
         Allows quick awk-like usage of string lists.
 
         Example data (in var a, created by 'a = !ls -l')::
+
             -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog
             drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython
 
-        a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
-        a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
-        (note the joining by space).
-        a.fields(-1) is ['ChangeLog', 'IPython']
+        * ``a.fields(0)`` is ``['-rwxrwxrwx', 'drwxrwxrwx+']``
+        * ``a.fields(1,0)`` is ``['1 -rwxrwxrwx', '6 drwxrwxrwx+']``
+          (note the joining by space).
+        * ``a.fields(-1)`` is ``['ChangeLog', 'IPython']``
 
         IndexErrors are ignored.
 
@@ -218,10 +221,15 @@ def fields(self, *fields):
 
         return res
 
-    def sort(self,field= None,  nums = False):
-        """ sort by specified fields (see fields())
+    def sort(  # type:ignore[override]
+        self,
+        field: Optional[List[str]] = None,
+        nums: bool = False,
+    ) -> Self:
+        """sort by specified fields (see fields())
 
         Example::
+
             a.sort(1, nums = True)
 
         Sorts a by second field, in numerical order (so that 21 > 3)
@@ -239,259 +247,402 @@ def sort(self,field= None,  nums = False):
                 try:
                     n = int(numstr)
                 except ValueError:
-                    n = 0;
+                    n = 0
                 dsu[i][0] = n
 
 
         dsu.sort()
-        return SList([t[1] for t in dsu])
+        return type(self)([t[1] for t in dsu])
 
 
-# FIXME: We need to reimplement type specific displayhook and then add this
-# back as a custom printer. This should also be moved outside utils into the
-# core.
+def indent(instr: str, nspaces: int = 4, ntabs: int = 0, flatten: bool = False) -> str:
+    """Indent a string a given number of spaces or tabstops.
 
-# def print_slist(arg):
-#     """ Prettier (non-repr-like) and more informative printer for SList """
-#     print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
-#     if hasattr(arg,  'hideonce') and arg.hideonce:
-#         arg.hideonce = False
-#         return
-# 
-#     nlprint(arg)
-# 
-# print_slist = result_display.when_type(SList)(print_slist)
+    indent(str, nspaces=4, ntabs=0) -> indent str by ntabs+nspaces.
+
+    Parameters
+    ----------
+    instr : basestring
+        The string to be indented.
+    nspaces : int (default: 4)
+        The number of spaces to be indented.
+    ntabs : int (default: 0)
+        The number of tabs to be indented.
+    flatten : bool (default: False)
+        Whether to scrub existing indentation.  If True, all lines will be
+        aligned to the same indentation.  If False, existing indentation will
+        be strictly increased.
+
+    Returns
+    -------
+    str : string indented by ntabs and nspaces.
 
+    """
+    ind = "\t" * ntabs + " " * nspaces
+    if flatten:
+        pat = re.compile(r'^\s*', re.MULTILINE)
+    else:
+        pat = re.compile(r'^', re.MULTILINE)
+    outstr = re.sub(pat, ind, instr)
+    if outstr.endswith(os.linesep+ind):
+        return outstr[:-len(ind)]
+    else:
+        return outstr
 
-def esc_quotes(strng):
-    """Return the input string with single and double quotes escaped out"""
 
-    return strng.replace('"','\\"').replace("'","\\'")
+def list_strings(arg: Union[str, List[str]]) -> List[str]:
+    """Always return a list of strings, given a string or list of strings
+    as input.
 
+    Examples
+    --------
+    ::
 
-def make_quoted_expr(s):
-    """Return string s in appropriate quotes, using raw string if possible.
+        In [7]: list_strings('A single string')
+        Out[7]: ['A single string']
 
-    XXX - example removed because it caused encoding errors in documentation
-    generation.  We need a new example that doesn't contain invalid chars.
+        In [8]: list_strings(['A single string in a list'])
+        Out[8]: ['A single string in a list']
 
-    Note the use of raw string and padding at the end to allow trailing
-    backslash.
+        In [9]: list_strings(['A','list','of','strings'])
+        Out[9]: ['A', 'list', 'of', 'strings']
     """
 
-    tail = ''
-    tailpadding = ''
-    raw  = ''
-    ucode = 'u'
-    if "\\" in s:
-        raw = 'r'
-        if s.endswith('\\'):
-            tail = '[:-1]'
-            tailpadding = '_'
-    if '"' not in s:
-        quote = '"'
-    elif "'" not in s:
-        quote = "'"
-    elif '"""' not in s and not s.endswith('"'):
-        quote = '"""'
-    elif "'''" not in s and not s.endswith("'"):
-        quote = "'''"
+    if isinstance(arg, str):
+        return [arg]
     else:
-        # give up, backslash-escaped string will do
-        return '"%s"' % esc_quotes(s)
-    res = ucode + raw + quote + s + tailpadding + quote + tail
-    return res
-
+        return arg
 
-def qw(words,flat=0,sep=None,maxsplit=-1):
-    """Similar to Perl's qw() operator, but with some more options.
 
-    qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
+def marquee(txt: str = "", width: int = 78, mark: str = "*") -> str:
+    """Return the input string centered in a 'marquee'.
 
-    words can also be a list itself, and with flat=1, the output will be
-    recursively flattened.
+    Examples
+    --------
+    ::
 
-    Examples:
+        In [16]: marquee('A test',40)
+        Out[16]: '**************** A test ****************'
 
-    >>> qw('1 2')
-    ['1', '2']
+        In [17]: marquee('A test',40,'-')
+        Out[17]: '---------------- A test ----------------'
 
-    >>> qw(['a b','1 2',['m n','p q']])
-    [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
+        In [18]: marquee('A test',40,' ')
+        Out[18]: '                 A test                 '
 
-    >>> qw(['a b','1 2',['m n','p q']],flat=1)
-    ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']
     """
-
-    if isinstance(words, basestring):
-        return [word.strip() for word in words.split(sep,maxsplit)
-                if word and not word.isspace() ]
-    if flat:
-        return flatten(map(qw,words,[1]*len(words)))
-    return map(qw,words)
-
-
-def qwflat(words,sep=None,maxsplit=-1):
-    """Calls qw(words) in flat mode. It's just a convenient shorthand."""
-    return qw(words,1,sep,maxsplit)
+    if not txt:
+        return (mark*width)[:width]
+    nmark = (width-len(txt)-2)//len(mark)//2
+    if nmark < 0: nmark =0
+    marks = mark*nmark
+    return '%s %s %s' % (marks,txt,marks)
 
 
-def qw_lol(indata):
-    """qw_lol('a b') -> [['a','b']],
-    otherwise it's just a call to qw().
+def format_screen(strng: str) -> str:
+    """Format a string for screen printing.
 
-    We need this to make sure the modules_some keys *always* end up as a
-    list of lists."""
+    This removes some latex-type format codes."""
+    # Paragraph continue
+    par_re = re.compile(r'\\$',re.MULTILINE)
+    strng = par_re.sub('',strng)
+    return strng
 
-    if isinstance(indata, basestring):
-        return [qw(indata)]
-    else:
-        return qw(indata)
 
+def dedent(text: str) -> str:
+    """Equivalent of textwrap.dedent that ignores unindented first line.
 
-def grep(pat,list,case=1):
-    """Simple minded grep-like function.
-    grep(pat,list) returns occurrences of pat in list, None on failure.
+    This means it will still dedent strings like:
+    '''foo
+    is a bar
+    '''
 
-    It only does simple string matching, with no support for regexps. Use the
-    option case=0 for case-insensitive matching."""
+    For use in wrap_paragraphs.
+    """
 
-    # This is pretty crude. At least it should implement copying only references
-    # to the original data in case it's big. Now it copies the data for output.
-    out=[]
-    if case:
-        for term in list:
-            if term.find(pat)>-1: out.append(term)
-    else:
-        lpat=pat.lower()
-        for term in list:
-            if term.lower().find(lpat)>-1: out.append(term)
+    if text.startswith('\n'):
+        # text starts with blank line, don't ignore the first line
+        return textwrap.dedent(text)
 
-    if len(out): return out
-    else: return None
+    # split first line
+    splits = text.split('\n',1)
+    if len(splits) == 1:
+        # only one line
+        return textwrap.dedent(text)
 
+    first, rest = splits
+    # dedent everything but the first line
+    rest = textwrap.dedent(rest)
+    return '\n'.join([first, rest])
 
-def dgrep(pat,*opts):
-    """Return grep() on dir()+dir(__builtins__).
 
-    A very common use of grep() when working interactively."""
+def strip_email_quotes(text: str) -> str:
+    """Strip leading email quotation characters ('>').
 
-    return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
+    Removes any combination of leading '>' interspersed with whitespace that
+    appears *identically* in all lines of the input text.
 
+    Parameters
+    ----------
+    text : str
 
-def idgrep(pat):
-    """Case-insensitive dgrep()"""
+    Examples
+    --------
 
-    return dgrep(pat,0)
+    Simple uses::
 
+        In [2]: strip_email_quotes('> > text')
+        Out[2]: 'text'
 
-def igrep(pat,list):
-    """Synonym for case-insensitive grep."""
+        In [3]: strip_email_quotes('> > text\\n> > more')
+        Out[3]: 'text\\nmore'
 
-    return grep(pat,list,case=0)
+    Note how only the common prefix that appears in all lines is stripped::
 
+        In [4]: strip_email_quotes('> > text\\n> > more\\n> more...')
+        Out[4]: '> text\\n> more\\nmore...'
 
-def indent(str,nspaces=4,ntabs=0):
-    """Indent a string a given number of spaces or tabstops.
+    So if any line has no quote marks ('>'), then none are stripped from any
+    of them ::
 
-    indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
+        In [5]: strip_email_quotes('> > text\\n> > more\\nlast different')
+        Out[5]: '> > text\\n> > more\\nlast different'
     """
-    if str is None:
-        return
-    ind = '\t'*ntabs+' '*nspaces
-    outstr = '%s%s' % (ind,str.replace(os.linesep,os.linesep+ind))
-    if outstr.endswith(os.linesep+ind):
-        return outstr[:-len(ind)]
-    else:
-        return outstr
+    lines = text.splitlines()
+    strip_len = 0
 
-def native_line_ends(filename,backup=1):
-    """Convert (in-place) a file to line-ends native to the current OS.
+    for characters in zip(*lines):
+        # Check if all characters in this position are the same
+        if len(set(characters)) > 1:
+            break
+        prefix_char = characters[0]
 
-    If the optional backup argument is given as false, no backup of the
-    original file is left.  """
+        if prefix_char in string.whitespace or prefix_char == ">":
+            strip_len += 1
+        else:
+            break
 
-    backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
+    text = "\n".join([ln[strip_len:] for ln in lines])
+    return text
 
-    bak_filename = filename + backup_suffixes[os.name]
 
-    original = open(filename).read()
-    shutil.copy2(filename,bak_filename)
-    try:
-        new = open(filename,'wb')
-        new.write(os.linesep.join(original.splitlines()))
-        new.write(os.linesep) # ALWAYS put an eol at the end of the file
-        new.close()
-    except:
-        os.rename(bak_filename,filename)
-    if not backup:
-        try:
-            os.remove(bak_filename)
-        except:
-            pass
+class EvalFormatter(Formatter):
+    """A String Formatter that allows evaluation of simple expressions.
 
+    Note that this version interprets a `:`  as specifying a format string (as per
+    standard string formatting), so if slicing is required, you must explicitly
+    create a slice.
 
-def list_strings(arg):
-    """Always return a list of strings, given a string or list of strings
-    as input.
+    Note that on Python 3.14+ this version interprets `[]` as indexing operator
+    so you need to use generators instead of list comprehensions, for example:
+    `list(i for i in range(10))`.
 
-    :Examples:
+    This is to be used in templating cases, such as the parallel batch
+    script templates, where simple arithmetic on arguments is useful.
 
-        In [7]: list_strings('A single string')
-        Out[7]: ['A single string']
+    Examples
+    --------
+    ::
 
-        In [8]: list_strings(['A single string in a list'])
-        Out[8]: ['A single string in a list']
+        In [1]: f = EvalFormatter()
+        In [2]: f.format('{n//4}', n=8)
+        Out[2]: '2'
 
-        In [9]: list_strings(['A','list','of','strings'])
-        Out[9]: ['A', 'list', 'of', 'strings']
+        In [3]: f.format("{greeting[slice(2,4)]}", greeting="Hello")
+        Out[3]: 'll'
     """
 
-    if isinstance(arg,basestring): return [arg]
-    else: return arg
-
-
-def marquee(txt='',width=78,mark='*'):
-    """Return the input string centered in a 'marquee'.
+    def get_field(self, name: str, args: Any, kwargs: Any) -> Tuple[Any, str]:
+        v = eval(name, kwargs, kwargs)
+        return v, name
+
+#XXX: As of Python 3.4, the format string parsing no longer splits on a colon
+# inside [], so EvalFormatter can handle slicing. Once we only support 3.4 and
+# above, it should be possible to remove FullEvalFormatter.
+
+class FullEvalFormatter(Formatter):
+    """A String Formatter that allows evaluation of simple expressions.
+    
+    Any time a format key is not found in the kwargs,
+    it will be tried as an expression in the kwargs namespace.
+    
+    Note that this version allows slicing using [1:2], so you cannot specify
+    a format string. Use :class:`EvalFormatter` to permit format strings.
+    
+    Examples
+    --------
+    ::
+
+        In [1]: f = FullEvalFormatter()
+        In [2]: f.format('{n//4}', n=8)
+        Out[2]: '2'
+
+        In [3]: f.format('{list(range(5))[2:4]}')
+        Out[3]: '[2, 3]'
+
+        In [4]: f.format('{3*2}')
+        Out[4]: '6'
+    """
+    # copied from Formatter._vformat with minor changes to allow eval
+    # and replace the format_spec code with slicing
+    def vformat(
+        self, format_string: str, args: Sequence[Any], kwargs: Mapping[str, Any]
+    ) -> str:
+        result = []
+        conversion: Optional[str]
+        for literal_text, field_name, format_spec, conversion in self.parse(
+            format_string
+        ):
+            # output the literal text
+            if literal_text:
+                result.append(literal_text)
+
+            # if there's a field, output it
+            if field_name is not None:
+                # this is some markup, find the object and do
+                # the formatting
+
+                if format_spec:
+                    # override format spec, to allow slicing:
+                    field_name = ':'.join([field_name, format_spec])
+
+                # eval the contents of the field for the object
+                # to be formatted
+                obj = eval(field_name, dict(kwargs))
+
+                # do any conversion on the resulting object
+                # type issue in typeshed, fined in https://github.com/python/typeshed/pull/11377
+                obj = self.convert_field(obj, conversion)
+
+                # format the object and append to the result
+                result.append(self.format_field(obj, ''))
+
+        return ''.join(result)
+
+
+class DollarFormatter(FullEvalFormatter):
+    """Formatter allowing Itpl style $foo replacement, for names and attribute
+    access only. Standard {foo} replacement also works, and allows full
+    evaluation of its arguments.
+
+    Examples
+    --------
+    ::
+
+        In [1]: f = DollarFormatter()
+        In [2]: f.format('{n//4}', n=8)
+        Out[2]: '2'
+
+        In [3]: f.format('23 * 76 is $result', result=23*76)
+        Out[3]: '23 * 76 is 1748'
+
+        In [4]: f.format('$a or {b}', a=1, b=2)
+        Out[4]: '1 or 2'
+    """
 
-    :Examples:
+    _dollar_pattern_ignore_single_quote = re.compile(
+        r"(.*?)\$(\$?[\w\.]+)(?=([^']*'[^']*')*[^']*$)"
+    )
+
+    def parse(self, fmt_string: str) -> Iterator[Tuple[Any, Any, Any, Any]]:
+        for literal_txt, field_name, format_spec, conversion in Formatter.parse(
+            self, fmt_string
+        ):
+            # Find $foo patterns in the literal text.
+            continue_from = 0
+            txt = ""
+            for m in self._dollar_pattern_ignore_single_quote.finditer(literal_txt):
+                new_txt, new_field = m.group(1,2)
+                # $$foo --> $foo
+                if new_field.startswith("$"):
+                    txt += new_txt + new_field
+                else:
+                    yield (txt + new_txt, new_field, "", None)
+                    txt = ""
+                continue_from = m.end()
+            
+            # Re-yield the {foo} style pattern
+            yield (txt + literal_txt[continue_from:], field_name, format_spec, conversion)
+
+    def __repr__(self) -> str:
+        return "<DollarFormatter>"
 
-        In [16]: marquee('A test',40)
-        Out[16]: '**************** A test ****************'
-
-        In [17]: marquee('A test',40,'-')
-        Out[17]: '---------------- A test ----------------'
+#-----------------------------------------------------------------------------
+# Utils to columnize a list of string
+#-----------------------------------------------------------------------------
 
-        In [18]: marquee('A test',40,' ')
-        Out[18]: '                 A test                 '
 
-    """
-    if not txt:
-        return (mark*width)[:width]
-    nmark = (width-len(txt)-2)/len(mark)/2
-    if nmark < 0: nmark =0
-    marks = mark*nmark
-    return '%s %s %s' % (marks,txt,marks)
+def _col_chunks(
+    l: List[int], max_rows: int, row_first: bool = False
+) -> Iterator[List[int]]:
+    """Yield successive max_rows-sized column chunks from l."""
+    if row_first:
+        ncols = (len(l) // max_rows) + (len(l) % max_rows > 0)
+        for i in range(ncols):
+            yield [l[j] for j in range(i, len(l), ncols)]
+    else:
+        for i in range(0, len(l), max_rows):
+            yield l[i:(i + max_rows)]
 
 
-ini_spaces_re = re.compile(r'^(\s+)')
+def _find_optimal(
+    rlist: List[int], row_first: bool, separator_size: int, displaywidth: int
+) -> Dict[str, Any]:
+    """Calculate optimal info to columnize a list of string"""
+    for max_rows in range(1, len(rlist) + 1):
+        col_widths = list(map(max, _col_chunks(rlist, max_rows, row_first)))
+        sumlength = sum(col_widths)
+        ncols = len(col_widths)
+        if sumlength + separator_size * (ncols - 1) <= displaywidth:
+            break
+    return {'num_columns': ncols,
+            'optimal_separator_width': (displaywidth - sumlength) // (ncols - 1) if (ncols - 1) else 0,
+            'max_rows': max_rows,
+            'column_widths': col_widths
+            }
 
-def num_ini_spaces(strng):
-    """Return the number of initial spaces in a string"""
 
-    ini_spaces = ini_spaces_re.match(strng)
-    if ini_spaces:
-        return ini_spaces.end()
-    else:
-        return 0
+T = TypeVar("T")
 
 
-def format_screen(strng):
-    """Format a string for screen printing.
+def _get_or_default(mylist: List[T], i: int, default: T) -> T:
+    """return list item number, or default if don't exist"""
+    if i >= len(mylist):
+        return default
+    else :
+        return mylist[i]
 
-    This removes some latex-type format codes."""
-    # Paragraph continue
-    par_re = re.compile(r'\\$',re.MULTILINE)
-    strng = par_re.sub('',strng)
-    return strng
 
+def get_text_list(
+    list_: List[str], last_sep: str = " and ", sep: str = ", ", wrap_item_with: str = ""
+) -> str:
+    """
+    Return a string with a natural enumeration of items
+
+    >>> get_text_list(['a', 'b', 'c', 'd'])
+    'a, b, c and d'
+    >>> get_text_list(['a', 'b', 'c'], ' or ')
+    'a, b or c'
+    >>> get_text_list(['a', 'b', 'c'], ', ')
+    'a, b, c'
+    >>> get_text_list(['a', 'b'], ' or ')
+    'a or b'
+    >>> get_text_list(['a'])
+    'a'
+    >>> get_text_list([])
+    ''
+    >>> get_text_list(['a', 'b'], wrap_item_with="`")
+    '`a` and `b`'
+    >>> get_text_list(['a', 'b', 'c', 'd'], " = ", sep=" + ")
+    'a + b + c = d'
+    """
+    if len(list_) == 0:
+        return ''
+    if wrap_item_with:
+        list_ = ['%s%s%s' % (wrap_item_with, item, wrap_item_with) for
+                 item in list_]
+    if len(list_) == 1:
+        return list_[0]
+    return '%s%s%s' % (
+        sep.join(i for i in list_[:-1]),
+        last_sep, list_[-1])
diff --git a/IPython/utils/timing.py b/IPython/utils/timing.py
index 581a335d634..d87e5fa8ef5 100644
--- a/IPython/utils/timing.py
+++ b/IPython/utils/timing.py
@@ -4,7 +4,7 @@
 """
 
 #-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
+#  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
@@ -23,6 +23,11 @@
 # If possible (Unix), use the resource module instead of time.clock()
 try:
     import resource
+except ModuleNotFoundError:
+    resource = None  # type: ignore [assignment]
+
+# Some implementations (like jyputerlite) don't have getrusage
+if resource is not None and hasattr(resource, "getrusage"):
     def clocku():
         """clocku() -> floating point number
 
@@ -56,15 +61,17 @@ def clock2():
 
         Similar to clock(), but return a tuple of user/system times."""
         return resource.getrusage(resource.RUSAGE_SELF)[:2]
-except ImportError:
+
+else:
     # There is no distinction of user/system time under windows, so we just use
-    # time.clock() for everything...
-    clocku = clocks = clock = time.clock
+    # time.process_time() for everything...
+    clocku = clocks = clock = time.process_time
+
     def clock2():
         """Under windows, system CPU time can't be measured.
 
-        This just returns clock() and zero."""
-        return time.clock(),0.0
+        This just returns process_time() and zero."""
+        return time.process_time(), 0.0
 
     
 def timings_out(reps,func,*args,**kw):
@@ -87,7 +94,7 @@ def timings_out(reps,func,*args,**kw):
         out = func(*args,**kw)
         tot_time = clock()-start
     else:
-        rng = xrange(reps-1) # the last time is executed separately to store output
+        rng = range(reps-1) # the last time is executed separately to store output
         start = clock()
         for dummy in rng: func(*args,**kw)
         out = func(*args,**kw)  # one last time
diff --git a/IPython/utils/tokenutil.py b/IPython/utils/tokenutil.py
new file mode 100644
index 00000000000..0024b807fda
--- /dev/null
+++ b/IPython/utils/tokenutil.py
@@ -0,0 +1,200 @@
+"""Token-related utilities"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+from __future__ import annotations
+
+import itertools
+import tokenize
+from io import StringIO
+from keyword import iskeyword
+from tokenize import TokenInfo
+from typing import NamedTuple
+from collections.abc import Generator
+
+
+class Token(NamedTuple):
+    token: int
+    text: str
+    start: int
+    end: int
+    line: str
+
+
+def generate_tokens(readline) -> Generator[TokenInfo, None, None]:
+    """wrap generate_tkens to catch EOF errors"""
+    try:
+        yield from tokenize.generate_tokens(readline)
+    except tokenize.TokenError:
+        # catch EOF error
+        return
+
+
+def generate_tokens_catch_errors(
+    readline, extra_errors_to_catch: list[str] | None = None
+):
+    default_errors_to_catch = [
+        "unterminated string literal",
+        "invalid non-printable character",
+        "after line continuation character",
+    ]
+    assert extra_errors_to_catch is None or isinstance(extra_errors_to_catch, list)
+    errors_to_catch = default_errors_to_catch + (extra_errors_to_catch or [])
+
+    tokens: list[TokenInfo] = []
+    try:
+        for token in tokenize.generate_tokens(readline):
+            tokens.append(token)
+            yield token
+    except tokenize.TokenError as exc:
+        if any(error in exc.args[0] for error in errors_to_catch):
+            if tokens:
+                start = tokens[-1].start[0], tokens[-1].end[0]
+                end = start
+                line = tokens[-1].line
+            else:
+                start = end = (1, 0)
+                line = ""
+            yield TokenInfo(tokenize.ERRORTOKEN, "", start, end, line)
+        else:
+            # Catch EOF
+            raise
+
+
+def line_at_cursor(cell: str, cursor_pos: int = 0) -> tuple[str, int]:
+    """Return the line in a cell at a given cursor position
+
+    Used for calling line-based APIs that don't support multi-line input, yet.
+
+    Parameters
+    ----------
+    cell : str
+        multiline block of text
+    cursor_pos : integer
+        the cursor position
+
+    Returns
+    -------
+    (line, offset): (string, integer)
+        The line with the current cursor, and the character offset of the start of the line.
+    """
+    offset = 0
+    lines = cell.splitlines(True)
+    for line in lines:
+        next_offset = offset + len(line)
+        if not line.endswith("\n"):
+            # If the last line doesn't have a trailing newline, treat it as if
+            # it does so that the cursor at the end of the line still counts
+            # as being on that line.
+            next_offset += 1
+        if next_offset > cursor_pos:
+            break
+        offset = next_offset
+    else:
+        line = ""
+    return line, offset
+
+
+def token_at_cursor(cell: str, cursor_pos: int = 0) -> str:
+    """Get the token at a given cursor
+
+    Used for introspection.
+
+    Function calls are prioritized, so the token for the callable will be returned
+    if the cursor is anywhere inside the call.
+
+    Parameters
+    ----------
+    cell : str
+        A block of Python code
+    cursor_pos : int
+        The location of the cursor in the block where the token should be found
+    """
+    names: list[str] = []
+    call_names: list[str] = []
+    closing_call_name: str | None = None
+    most_recent_outer_name: str | None = None
+
+    offsets = {1: 0}  # lines start at 1
+    intersects_with_cursor = False
+    cur_token_is_name = False
+    tokens: list[Token | None] = [
+        Token(*tup) for tup in generate_tokens(StringIO(cell).readline)
+    ]
+    if not tokens:
+        return ""
+    for prev_tok, (tok, next_tok) in zip(
+        [None] + tokens, itertools.pairwise(tokens + [None])
+    ):
+        # token, text, start, end, line = tup
+        start_line, start_col = tok.start
+        end_line, end_col = tok.end
+        if end_line + 1 not in offsets:
+            # keep track of offsets for each line
+            lines = tok.line.splitlines(True)
+            for lineno, line in enumerate(lines, start_line + 1):
+                if lineno not in offsets:
+                    offsets[lineno] = offsets[lineno - 1] + len(line)
+
+        closing_call_name = None
+
+        offset = offsets[start_line]
+        if offset + start_col > cursor_pos:
+            # current token starts after the cursor,
+            # don't consume it
+            break
+
+        if cur_token_is_name := tok.token == tokenize.NAME and not iskeyword(tok.text):
+            if (
+                names
+                and prev_tok
+                and prev_tok.token == tokenize.OP
+                and prev_tok.text == "."
+            ):
+                names[-1] = "%s.%s" % (names[-1], tok.text)
+            else:
+                names.append(tok.text)
+            if (
+                next_tok is not None
+                and next_tok.token == tokenize.OP
+                and next_tok.text == "="
+            ):
+                # don't inspect the lhs of an assignment
+                names.pop(-1)
+                cur_token_is_name = False
+            if not call_names:
+                most_recent_outer_name = names[-1] if names else None
+        elif tok.token == tokenize.OP:
+            if tok.text == "(" and names:
+                # if we are inside a function call, inspect the function
+                call_names.append(names[-1])
+            elif tok.text == ")" and call_names:
+                # keep track of the most recently popped call_name from the stack
+                closing_call_name = call_names.pop(-1)
+
+        if offsets[end_line] + end_col > cursor_pos:
+            # we found the cursor, stop reading
+            # if the current token intersects directly, use it instead of the call token
+            intersects_with_cursor = offsets[start_line] + start_col <= cursor_pos
+            break
+
+    if cur_token_is_name and intersects_with_cursor:
+        return names[-1]
+    # if the cursor isn't directly over a name token, use the most recent
+    # call name if we can find one
+    elif closing_call_name:
+        # if we're on a ")", use the most recently popped call name
+        return closing_call_name
+    elif call_names:
+        # otherwise, look for the most recent call name in the stack
+        return call_names[-1]
+    elif most_recent_outer_name:
+        # if we've popped all the call names, use the most recently-seen
+        # outer name
+        return most_recent_outer_name
+    elif names:
+        # failing that, use the most recently seen name
+        return names[-1]
+    else:
+        # give up
+        return ""
diff --git a/IPython/utils/traitlets.py b/IPython/utils/traitlets.py
deleted file mode 100644
index f570c62f38a..00000000000
--- a/IPython/utils/traitlets.py
+++ /dev/null
@@ -1,1095 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-"""
-A lightweight Traits like module.
-
-This is designed to provide a lightweight, simple, pure Python version of
-many of the capabilities of enthought.traits.  This includes:
-
-* Validation
-* Type specification with defaults
-* Static and dynamic notification
-* Basic predefined types
-* An API that is similar to enthought.traits
-
-We don't support:
-
-* Delegation
-* Automatic GUI generation
-* A full set of trait types.  Most importantly, we don't provide container
-  traits (list, dict, tuple) that can trigger notifications if their
-  contents change.
-* API compatibility with enthought.traits
-
-There are also some important difference in our design:
-
-* enthought.traits does not validate default values.  We do.
-
-We choose to create this module because we need these capabilities, but
-we need them to be pure Python so they work in all Python implementations,
-including Jython and IronPython.
-
-Authors:
-
-* Brian Granger
-* Enthought, Inc.  Some of the code in this file comes from enthought.traits
-  and is licensed under the BSD license.  Also, many of the ideas also come
-  from enthought.traits even though our implementation is very different.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-
-import inspect
-import sys
-import types
-from types import (
-    InstanceType, ClassType, FunctionType,
-    ListType, TupleType
-)
-from .importstring import import_item
-
-ClassTypes = (ClassType, type)
-
-SequenceTypes = (ListType, TupleType, set, frozenset)
-
-#-----------------------------------------------------------------------------
-# Basic classes
-#-----------------------------------------------------------------------------
-
-
-class NoDefaultSpecified ( object ): pass
-NoDefaultSpecified = NoDefaultSpecified()
-
-
-class Undefined ( object ): pass
-Undefined = Undefined()
-
-class TraitError(Exception):
-    pass
-
-#-----------------------------------------------------------------------------
-# Utilities
-#-----------------------------------------------------------------------------
-
-
-def class_of ( object ):
-    """ Returns a string containing the class name of an object with the
-    correct indefinite article ('a' or 'an') preceding it (e.g., 'an Image',
-    'a PlotValue').
-    """
-    if isinstance( object, basestring ):
-        return add_article( object )
-
-    return add_article( object.__class__.__name__ )
-
-
-def add_article ( name ):
-    """ Returns a string containing the correct indefinite article ('a' or 'an')
-    prefixed to the specified string.
-    """
-    if name[:1].lower() in 'aeiou':
-       return 'an ' + name
-
-    return 'a ' + name
-
-
-def repr_type(obj):
-    """ Return a string representation of a value and its type for readable
-    error messages.
-    """
-    the_type = type(obj)
-    if the_type is InstanceType:
-        # Old-style class.
-        the_type = obj.__class__
-    msg = '%r %r' % (obj, the_type)
-    return msg
-
-
-def parse_notifier_name(name):
-    """Convert the name argument to a list of names.
-    
-    Examples
-    --------
-    
-    >>> parse_notifier_name('a')
-    ['a']
-    >>> parse_notifier_name(['a','b'])
-    ['a', 'b']
-    >>> parse_notifier_name(None)
-    ['anytrait']
-    """
-    if isinstance(name, str):
-        return [name]
-    elif name is None:
-        return ['anytrait']
-    elif isinstance(name, (list, tuple)):
-        for n in name:
-            assert isinstance(n, str), "names must be strings"
-        return name
-
-
-class _SimpleTest:
-    def __init__ ( self, value ): self.value = value
-    def __call__ ( self, test  ):
-        return test == self.value
-    def __repr__(self):
-        return "<SimpleTest(%r)" % self.value
-    def __str__(self):
-        return self.__repr__()
-
-
-def getmembers(object, predicate=None):
-    """A safe version of inspect.getmembers that handles missing attributes.
-
-    This is useful when there are descriptor based attributes that for 
-    some reason raise AttributeError even though they exist.  This happens
-    in zope.inteface with the __provides__ attribute.
-    """
-    results = []
-    for key in dir(object):
-        try:
-            value = getattr(object, key)
-        except AttributeError:
-            pass
-        else:
-            if not predicate or predicate(value):
-                results.append((key, value))
-    results.sort()
-    return results
-
-
-#-----------------------------------------------------------------------------
-# Base TraitType for all traits
-#-----------------------------------------------------------------------------
-
-
-class TraitType(object):
-    """A base class for all trait descriptors.
-
-    Notes
-    -----
-    Our implementation of traits is based on Python's descriptor
-    prototol.  This class is the base class for all such descriptors.  The
-    only magic we use is a custom metaclass for the main :class:`HasTraits`
-    class that does the following:
-
-    1. Sets the :attr:`name` attribute of every :class:`TraitType`
-       instance in the class dict to the name of the attribute.
-    2. Sets the :attr:`this_class` attribute of every :class:`TraitType`
-       instance in the class dict to the *class* that declared the trait.
-       This is used by the :class:`This` trait to allow subclasses to
-       accept superclasses for :class:`This` values.
-    """
-    
-
-    metadata = {}
-    default_value = Undefined
-    info_text = 'any value'
-
-    def __init__(self, default_value=NoDefaultSpecified, **metadata):
-        """Create a TraitType.
-        """
-        if default_value is not NoDefaultSpecified:
-            self.default_value = default_value
-
-        if len(metadata) > 0:
-            if len(self.metadata) > 0:
-                self._metadata = self.metadata.copy()
-                self._metadata.update(metadata)
-            else:
-                self._metadata = metadata
-        else:
-            self._metadata = self.metadata
-
-        self.init()
-
-    def init(self):
-        pass
-
-    def get_default_value(self):
-        """Create a new instance of the default value."""
-        return self.default_value
-
-    def instance_init(self, obj):
-        """This is called by :meth:`HasTraits.__new__` to finish init'ing.
-
-        Some stages of initialization must be delayed until the parent
-        :class:`HasTraits` instance has been created.  This method is
-        called in :meth:`HasTraits.__new__` after the instance has been
-        created.
-
-        This method trigger the creation and validation of default values
-        and also things like the resolution of str given class names in 
-        :class:`Type` and :class`Instance`.
-
-        Parameters
-        ----------
-        obj : :class:`HasTraits` instance
-            The parent :class:`HasTraits` instance that has just been
-            created.
-        """
-        self.set_default_value(obj)
-
-    def set_default_value(self, obj):
-        """Set the default value on a per instance basis.
-
-        This method is called by :meth:`instance_init` to create and
-        validate the default value.  The creation and validation of 
-        default values must be delayed until the parent :class:`HasTraits`
-        class has been instantiated.
-        """
-        # Check for a deferred initializer defined in the same class as the
-        # trait declaration or above.
-        mro = type(obj).mro()
-        meth_name = '_%s_default' % self.name
-        for cls in mro[:mro.index(self.this_class)+1]:
-            if meth_name in cls.__dict__:
-                break
-        else:
-            # We didn't find one. Do static initialization.
-            dv = self.get_default_value()
-            newdv = self._validate(obj, dv)
-            obj._trait_values[self.name] = newdv
-            return
-        # Complete the dynamic initialization.
-        obj._trait_dyn_inits[self.name] = cls.__dict__[meth_name]
-
-    def __get__(self, obj, cls=None):
-        """Get the value of the trait by self.name for the instance.
-
-        Default values are instantiated when :meth:`HasTraits.__new__`
-        is called.  Thus by the time this method gets called either the 
-        default value or a user defined value (they called :meth:`__set__`)
-        is in the :class:`HasTraits` instance.
-        """
-        if obj is None:
-            return self
-        else:
-            try:
-                value = obj._trait_values[self.name]
-            except KeyError:
-                # Check for a dynamic initializer.
-                if self.name in obj._trait_dyn_inits:
-                    value = obj._trait_dyn_inits[self.name](obj)
-                    # FIXME: Do we really validate here?
-                    value = self._validate(obj, value)
-                    obj._trait_values[self.name] = value
-                    return value
-                else:
-                    raise TraitError('Unexpected error in TraitType: '
-                        'both default value and dynamic initializer are '
-                        'absent.')
-            except Exception:
-                # HasTraits should call set_default_value to populate
-                # this.  So this should never be reached.
-                raise TraitError('Unexpected error in TraitType: '
-                                    'default value not set properly')
-            else:
-                return value
-
-    def __set__(self, obj, value):
-        new_value = self._validate(obj, value)
-        old_value = self.__get__(obj)
-        if old_value != new_value:
-            obj._trait_values[self.name] = new_value
-            obj._notify_trait(self.name, old_value, new_value)
-
-    def _validate(self, obj, value):
-        if hasattr(self, 'validate'):
-            return self.validate(obj, value)
-        elif hasattr(self, 'is_valid_for'):
-            valid = self.is_valid_for(value)
-            if valid:
-                return value
-            else:
-                raise TraitError('invalid value for type: %r' % value)
-        elif hasattr(self, 'value_for'):
-            return self.value_for(value)
-        else:
-            return value
-
-    def info(self):
-        return self.info_text
-
-    def error(self, obj, value):
-        if obj is not None:
-            e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
-                % (self.name, class_of(obj),
-                   self.info(), repr_type(value))
-        else:
-            e = "The '%s' trait must be %s, but a value of %r was specified." \
-                % (self.name, self.info(), repr_type(value))            
-        raise TraitError(e)
-
-    def get_metadata(self, key):
-        return getattr(self, '_metadata', {}).get(key, None)
-
-    def set_metadata(self, key, value):
-        getattr(self, '_metadata', {})[key] = value
-
-
-#-----------------------------------------------------------------------------
-# The HasTraits implementation
-#-----------------------------------------------------------------------------
-
-
-class MetaHasTraits(type):
-    """A metaclass for HasTraits.
-    
-    This metaclass makes sure that any TraitType class attributes are
-    instantiated and sets their name attribute.
-    """
-    
-    def __new__(mcls, name, bases, classdict):
-        """Create the HasTraits class.
-        
-        This instantiates all TraitTypes in the class dict and sets their
-        :attr:`name` attribute.
-        """
-        # print "MetaHasTraitlets (mcls, name): ", mcls, name
-        # print "MetaHasTraitlets (bases): ", bases
-        # print "MetaHasTraitlets (classdict): ", classdict
-        for k,v in classdict.iteritems():
-            if isinstance(v, TraitType):
-                v.name = k
-            elif inspect.isclass(v):
-                if issubclass(v, TraitType):
-                    vinst = v()
-                    vinst.name = k
-                    classdict[k] = vinst
-        return super(MetaHasTraits, mcls).__new__(mcls, name, bases, classdict)
-
-    def __init__(cls, name, bases, classdict):
-        """Finish initializing the HasTraits class.
-        
-        This sets the :attr:`this_class` attribute of each TraitType in the
-        class dict to the newly created class ``cls``.
-        """
-        for k, v in classdict.iteritems():
-            if isinstance(v, TraitType):
-                v.this_class = cls
-        super(MetaHasTraits, cls).__init__(name, bases, classdict)
-
-class HasTraits(object):
-
-    __metaclass__ = MetaHasTraits
-
-    def __new__(cls, **kw):
-        # This is needed because in Python 2.6 object.__new__ only accepts
-        # the cls argument.
-        new_meth = super(HasTraits, cls).__new__
-        if new_meth is object.__new__:
-            inst = new_meth(cls)
-        else:
-            inst = new_meth(cls, **kw)
-        inst._trait_values = {}
-        inst._trait_notifiers = {}
-        inst._trait_dyn_inits = {}
-        # Here we tell all the TraitType instances to set their default
-        # values on the instance. 
-        for key in dir(cls):
-            # Some descriptors raise AttributeError like zope.interface's
-            # __provides__ attributes even though they exist.  This causes
-            # AttributeErrors even though they are listed in dir(cls).
-            try:
-                value = getattr(cls, key)
-            except AttributeError:
-                pass
-            else:
-                if isinstance(value, TraitType):
-                    value.instance_init(inst)
-
-        return inst
-
-    def __init__(self, **kw):
-        # Allow trait values to be set using keyword arguments.
-        # We need to use setattr for this to trigger validation and
-        # notifications.
-        for key, value in kw.iteritems():
-            setattr(self, key, value)
-
-    def _notify_trait(self, name, old_value, new_value):
-
-        # First dynamic ones
-        callables = self._trait_notifiers.get(name,[])
-        more_callables = self._trait_notifiers.get('anytrait',[])
-        callables.extend(more_callables)
-
-        # Now static ones
-        try:
-            cb = getattr(self, '_%s_changed' % name)
-        except:
-            pass
-        else:
-            callables.append(cb)
-
-        # Call them all now
-        for c in callables:
-            # Traits catches and logs errors here.  I allow them to raise
-            if callable(c):
-                argspec = inspect.getargspec(c)
-                nargs = len(argspec[0])
-                # Bound methods have an additional 'self' argument
-                # I don't know how to treat unbound methods, but they
-                # can't really be used for callbacks.
-                if isinstance(c, types.MethodType):
-                    offset = -1
-                else:
-                    offset = 0
-                if nargs + offset == 0:
-                    c()
-                elif nargs + offset == 1:
-                    c(name)
-                elif nargs + offset == 2:
-                    c(name, new_value)
-                elif nargs + offset == 3:
-                    c(name, old_value, new_value)
-                else:
-                    raise TraitError('a trait changed callback '
-                                        'must have 0-3 arguments.')
-            else:
-                raise TraitError('a trait changed callback '
-                                    'must be callable.')
-                
-
-    def _add_notifiers(self, handler, name):
-        if not self._trait_notifiers.has_key(name):
-            nlist = []
-            self._trait_notifiers[name] = nlist
-        else:
-            nlist = self._trait_notifiers[name]
-        if handler not in nlist:
-            nlist.append(handler)
-
-    def _remove_notifiers(self, handler, name):
-        if self._trait_notifiers.has_key(name):
-            nlist = self._trait_notifiers[name]
-            try:
-                index = nlist.index(handler)
-            except ValueError:
-                pass
-            else:
-                del nlist[index]
-
-    def on_trait_change(self, handler, name=None, remove=False):
-        """Setup a handler to be called when a trait changes.
-
-        This is used to setup dynamic notifications of trait changes.
-        
-        Static handlers can be created by creating methods on a HasTraits
-        subclass with the naming convention '_[traitname]_changed'.  Thus,
-        to create static handler for the trait 'a', create the method
-        _a_changed(self, name, old, new) (fewer arguments can be used, see
-        below).
-        
-        Parameters
-        ----------
-        handler : callable
-            A callable that is called when a trait changes.  Its 
-            signature can be handler(), handler(name), handler(name, new)
-            or handler(name, old, new).
-        name : list, str, None
-            If None, the handler will apply to all traits.  If a list
-            of str, handler will apply to all names in the list.  If a
-            str, the handler will apply just to that name.
-        remove : bool
-            If False (the default), then install the handler.  If True
-            then unintall it.
-        """
-        if remove:
-            names = parse_notifier_name(name)
-            for n in names:
-                self._remove_notifiers(handler, n)
-        else:
-            names = parse_notifier_name(name)
-            for n in names:
-                self._add_notifiers(handler, n)
-
-    def trait_names(self, **metadata):
-        """Get a list of all the names of this classes traits."""
-        return self.traits(**metadata).keys()
-
-    def traits(self, **metadata):
-        """Get a list of all the traits of this class.
-
-        The TraitTypes returned don't know anything about the values
-        that the various HasTrait's instances are holding.
-
-        This follows the same algorithm as traits does and does not allow
-        for any simple way of specifying merely that a metadata name
-        exists, but has any value.  This is because get_metadata returns
-        None if a metadata key doesn't exist.
-        """
-        traits = dict([memb for memb in getmembers(self.__class__) if \
-                     isinstance(memb[1], TraitType)])
-
-        if len(metadata) == 0:
-            return traits
-
-        for meta_name, meta_eval in metadata.items():
-            if type(meta_eval) is not FunctionType:
-                metadata[meta_name] = _SimpleTest(meta_eval)
-
-        result = {}
-        for name, trait in traits.items():
-            for meta_name, meta_eval in metadata.items():
-                if not meta_eval(trait.get_metadata(meta_name)):
-                    break
-            else:
-                result[name] = trait
-
-        return result
-
-    def trait_metadata(self, traitname, key):
-        """Get metadata values for trait by key."""
-        try:
-            trait = getattr(self.__class__, traitname)
-        except AttributeError:
-            raise TraitError("Class %s does not have a trait named %s" %
-                                (self.__class__.__name__, traitname))
-        else:
-            return trait.get_metadata(key)
-
-#-----------------------------------------------------------------------------
-# Actual TraitTypes implementations/subclasses
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# TraitTypes subclasses for handling classes and instances of classes
-#-----------------------------------------------------------------------------
-
-
-class ClassBasedTraitType(TraitType):
-    """A trait with error reporting for Type, Instance and This."""
-
-    def error(self, obj, value):
-        kind = type(value)
-        if kind is InstanceType:
-            msg = 'class %s' % value.__class__.__name__
-        else:
-            msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
-
-        super(ClassBasedTraitType, self).error(obj, msg)
-
-
-class Type(ClassBasedTraitType):
-    """A trait whose value must be a subclass of a specified class."""
-
-    def __init__ (self, default_value=None, klass=None, allow_none=True, **metadata ):
-        """Construct a Type trait
-
-        A Type trait specifies that its values must be subclasses of
-        a particular class.
-
-        If only ``default_value`` is given, it is used for the ``klass`` as
-        well.
-
-        Parameters
-        ----------
-        default_value : class, str or None
-            The default value must be a subclass of klass.  If an str,
-            the str must be a fully specified class name, like 'foo.bar.Bah'.
-            The string is resolved into real class, when the parent 
-            :class:`HasTraits` class is instantiated.
-        klass : class, str, None
-            Values of this trait must be a subclass of klass.  The klass
-            may be specified in a string like: 'foo.bar.MyClass'.
-            The string is resolved into real class, when the parent 
-            :class:`HasTraits` class is instantiated.
-        allow_none : boolean
-            Indicates whether None is allowed as an assignable value. Even if
-            ``False``, the default value may be ``None``.
-        """
-        if default_value is None:
-            if klass is None:
-                klass = object
-        elif klass is None:
-            klass = default_value
-
-        if not (inspect.isclass(klass) or isinstance(klass, basestring)):
-            raise TraitError("A Type trait must specify a class.")
-
-        self.klass       = klass
-        self._allow_none = allow_none
-
-        super(Type, self).__init__(default_value, **metadata)
-
-    def validate(self, obj, value):
-        """Validates that the value is a valid object instance."""
-        try:
-            if issubclass(value, self.klass):
-                return value
-        except:
-            if (value is None) and (self._allow_none):
-                return value
-
-        self.error(obj, value)
-
-    def info(self):
-        """ Returns a description of the trait."""
-        if isinstance(self.klass, basestring):
-            klass = self.klass
-        else:
-            klass = self.klass.__name__
-        result = 'a subclass of ' + klass
-        if self._allow_none:
-            return result + ' or None'
-        return result
-
-    def instance_init(self, obj):
-        self._resolve_classes()
-        super(Type, self).instance_init(obj)
-
-    def _resolve_classes(self):
-        if isinstance(self.klass, basestring):
-            self.klass = import_item(self.klass)
-        if isinstance(self.default_value, basestring):
-            self.default_value = import_item(self.default_value)
-
-    def get_default_value(self):
-        return self.default_value
-
-
-class DefaultValueGenerator(object):
-    """A class for generating new default value instances."""
-
-    def __init__(self, *args, **kw):
-        self.args = args
-        self.kw = kw
-
-    def generate(self, klass):
-        return klass(*self.args, **self.kw)
-
-
-class Instance(ClassBasedTraitType):
-    """A trait whose value must be an instance of a specified class.
-    
-    The value can also be an instance of a subclass of the specified class.
-    """
-
-    def __init__(self, klass=None, args=None, kw=None, 
-                 allow_none=True, **metadata ):
-        """Construct an Instance trait.
-
-        This trait allows values that are instances of a particular
-        class or its sublclasses.  Our implementation is quite different
-        from that of enthough.traits as we don't allow instances to be used
-        for klass and we handle the ``args`` and ``kw`` arguments differently.
-
-        Parameters
-        ----------
-        klass : class, str
-            The class that forms the basis for the trait.  Class names
-            can also be specified as strings, like 'foo.bar.Bar'.
-        args : tuple
-            Positional arguments for generating the default value.
-        kw : dict
-            Keyword arguments for generating the default value.
-        allow_none : bool
-            Indicates whether None is allowed as a value.
-
-        Default Value
-        -------------
-        If both ``args`` and ``kw`` are None, then the default value is None.
-        If ``args`` is a tuple and ``kw`` is a dict, then the default is
-        created as ``klass(*args, **kw)``.  If either ``args`` or ``kw`` is 
-        not (but not both), None is replace by ``()`` or ``{}``.
-        """
-
-        self._allow_none = allow_none
-
-        if (klass is None) or (not (inspect.isclass(klass) or isinstance(klass, basestring))):
-            raise TraitError('The klass argument must be a class'
-                                ' you gave: %r' % klass)
-        self.klass = klass
-        
-        # self.klass is a class, so handle default_value
-        if args is None and kw is None:
-            default_value = None
-        else:
-            if args is None:
-                # kw is not None
-                args = ()
-            elif kw is None:
-                # args is not None
-                kw = {}
-        
-            if not isinstance(kw, dict):
-                raise TraitError("The 'kw' argument must be a dict or None.")
-            if not isinstance(args, tuple):
-                raise TraitError("The 'args' argument must be a tuple or None.")
-            
-            default_value = DefaultValueGenerator(*args, **kw)
-
-        super(Instance, self).__init__(default_value, **metadata)
-
-    def validate(self, obj, value):
-        if value is None:
-            if self._allow_none:
-                return value
-            self.error(obj, value)
-
-        if isinstance(value, self.klass):
-            return value
-        else:
-            self.error(obj, value)
-
-    def info(self):
-        if isinstance(self.klass, basestring):
-            klass = self.klass
-        else:
-            klass = self.klass.__name__
-        result = class_of(klass)
-        if self._allow_none:
-            return result + ' or None'
-
-        return result
-
-    def instance_init(self, obj):
-        self._resolve_classes()
-        super(Instance, self).instance_init(obj)
-
-    def _resolve_classes(self):
-        if isinstance(self.klass, basestring):
-            self.klass = import_item(self.klass)
-
-    def get_default_value(self):
-        """Instantiate a default value instance.
-        
-        This is called when the containing HasTraits classes'
-        :meth:`__new__` method is called to ensure that a unique instance
-        is created for each HasTraits instance.
-        """
-        dv  = self.default_value
-        if isinstance(dv, DefaultValueGenerator):
-            return dv.generate(self.klass)
-        else:
-            return dv
-
-
-class This(ClassBasedTraitType):
-    """A trait for instances of the class containing this trait.
-
-    Because how how and when class bodies are executed, the ``This``
-    trait can only have a default value of None.  This, and because we 
-    always validate default values, ``allow_none`` is *always* true.
-    """
-
-    info_text = 'an instance of the same type as the receiver or None'
-
-    def __init__(self, **metadata):
-        super(This, self).__init__(None, **metadata)
-
-    def validate(self, obj, value):
-        # What if value is a superclass of obj.__class__?  This is
-        # complicated if it was the superclass that defined the This
-        # trait.
-        if isinstance(value, self.this_class) or (value is None):
-            return value
-        else:
-            self.error(obj, value)
-
-
-#-----------------------------------------------------------------------------
-# Basic TraitTypes implementations/subclasses
-#-----------------------------------------------------------------------------
-
-
-class Any(TraitType):
-    default_value = None
-    info_text = 'any value'
-
-
-class Int(TraitType):
-    """A integer trait."""
-
-    default_value = 0
-    info_text = 'an integer'
-
-    def validate(self, obj, value):
-        if isinstance(value, int):
-            return value
-        self.error(obj, value)
-
-class CInt(Int):
-    """A casting version of the int trait."""
-
-    def validate(self, obj, value):
-        try:
-            return int(value)
-        except:
-            self.error(obj, value)
-
-
-class Long(TraitType):
-    """A long integer trait."""
-
-    default_value = 0L
-    info_text = 'a long'
-
-    def validate(self, obj, value):
-        if isinstance(value, long):
-            return value
-        if isinstance(value, int):
-            return long(value)
-        self.error(obj, value)
-
-
-class CLong(Long):
-    """A casting version of the long integer trait."""
-
-    def validate(self, obj, value):
-        try:
-            return long(value)
-        except:
-            self.error(obj, value)
-
-
-class Float(TraitType):
-    """A float trait."""
-
-    default_value = 0.0
-    info_text = 'a float'
-
-    def validate(self, obj, value):
-        if isinstance(value, float):
-            return value
-        if isinstance(value, int):
-            return float(value)
-        self.error(obj, value)
-
-
-class CFloat(Float):
-    """A casting version of the float trait."""
-
-    def validate(self, obj, value):
-        try:
-            return float(value)
-        except:
-            self.error(obj, value)
-
-class Complex(TraitType):
-    """A trait for complex numbers."""
-
-    default_value = 0.0 + 0.0j
-    info_text = 'a complex number'
-
-    def validate(self, obj, value):
-        if isinstance(value, complex):
-            return value
-        if isinstance(value, (float, int)):
-            return complex(value)
-        self.error(obj, value)
-
-
-class CComplex(Complex):
-    """A casting version of the complex number trait."""
-
-    def validate (self, obj, value):
-        try:
-            return complex(value)
-        except:
-            self.error(obj, value)
-
-
-class Str(TraitType):
-    """A trait for strings."""
-
-    default_value = ''
-    info_text = 'a string'
-
-    def validate(self, obj, value):
-        if isinstance(value, str):
-            return value
-        self.error(obj, value)
-
-
-class CStr(Str):
-    """A casting version of the string trait."""
-
-    def validate(self, obj, value):
-        try:
-            return str(value)
-        except:
-            try:
-                return unicode(value)
-            except:
-                self.error(obj, value)
-
-
-class Unicode(TraitType):
-    """A trait for unicode strings."""
-
-    default_value = u''
-    info_text = 'a unicode string'
-
-    def validate(self, obj, value):
-        if isinstance(value, unicode):
-            return value
-        if isinstance(value, str):
-            return unicode(value)
-        self.error(obj, value)
-
-
-class CUnicode(Unicode):
-    """A casting version of the unicode trait."""
-
-    def validate(self, obj, value):
-        try:
-            return unicode(value)
-        except:
-            self.error(obj, value)
-
-
-class Bool(TraitType):
-    """A boolean (True, False) trait."""
-
-    default_value = False
-    info_text = 'a boolean'
-
-    def validate(self, obj, value):
-        if isinstance(value, bool):
-            return value
-        self.error(obj, value)
-
-
-class CBool(Bool):
-    """A casting version of the boolean trait."""
-
-    def validate(self, obj, value):
-        try:
-            return bool(value)
-        except:
-            self.error(obj, value)
-
-
-class Enum(TraitType):
-    """An enum that whose value must be in a given sequence."""
-
-    def __init__(self, values, default_value=None, allow_none=True, **metadata):
-        self.values = values
-        self._allow_none = allow_none
-        super(Enum, self).__init__(default_value, **metadata)
-
-    def validate(self, obj, value):
-        if value is None:
-            if self._allow_none:
-                return value
-
-        if value in self.values:
-                return value
-        self.error(obj, value)
-
-    def info(self):
-        """ Returns a description of the trait."""
-        result = 'any of ' + repr(self.values)
-        if self._allow_none:
-            return result + ' or None'
-        return result
-
-class CaselessStrEnum(Enum):
-    """An enum of strings that are caseless in validate."""
-
-    def validate(self, obj, value):
-        if value is None:
-            if self._allow_none:
-                return value
-
-        if not isinstance(value, str):
-            self.error(obj, value)
-
-        for v in self.values:
-            if v.lower() == value.lower():
-                return v
-        self.error(obj, value)
-
-
-class List(Instance):
-    """An instance of a Python list."""
-
-    def __init__(self, default_value=None, allow_none=True, **metadata):
-        """Create a list trait type from a list, set, or tuple.
-
-        The default value is created by doing ``list(default_value)``, 
-        which creates a copy of the ``default_value``.
-        """
-        if default_value is None:
-            args = ((),)
-        elif isinstance(default_value, SequenceTypes):
-            args = (default_value,)
-        else:
-            raise TypeError('default value of List was %s' % default_value)
-
-        super(List,self).__init__(klass=list, args=args, 
-                                  allow_none=allow_none, **metadata)
-
-
-class Set(Instance):
-    """An instance of a Python set."""
-
-    def __init__(self, default_value=None, allow_none=True, **metadata):
-        """Create a set trait type from a set, list, or tuple.
-
-        The default value is created by doing ``set(default_value)``, 
-        which creates a copy of the ``default_value``.
-        """
-        if default_value is None:
-            args = ((),)
-        elif isinstance(default_value, SequenceTypes):
-            args = (default_value,)
-        else:
-            raise TypeError('default value of Set was %s' % default_value)
-
-        super(Set,self).__init__(klass=set, args=args, 
-                                  allow_none=allow_none, **metadata)
-
-
-class Dict(Instance):
-    """An instance of a Python dict."""
-
-    def __init__(self, default_value=None, allow_none=True, **metadata):
-        """Create a dict trait type from a dict.
-
-        The default value is created by doing ``dict(default_value)``, 
-        which creates a copy of the ``default_value``.
-        """
-        if default_value is None:
-            args = ((),)
-        elif isinstance(default_value, dict):
-            args = (default_value,)
-        elif isinstance(default_value, SequenceTypes):
-            args = (default_value,)
-        else:
-            raise TypeError('default value of Dict was %s' % default_value)
-
-        super(Dict,self).__init__(klass=dict, args=args, 
-                                  allow_none=allow_none, **metadata)
-
-
-class TCPAddress(TraitType):
-    """A trait for an (ip, port) tuple.
-
-    This allows for both IPv4 IP addresses as well as hostnames.
-    """
-
-    default_value = ('127.0.0.1', 0)
-    info_text = 'an (ip, port) tuple'
-
-    def validate(self, obj, value):
-        if isinstance(value, tuple):
-            if len(value) == 2:
-                if isinstance(value[0], basestring) and isinstance(value[1], int):
-                    port = value[1]
-                    if port >= 0 and port <= 65535:
-                        return value
-        self.error(obj, value)
diff --git a/IPython/utils/upgradedir.py b/IPython/utils/upgradedir.py
deleted file mode 100644
index 8ca7e5133b1..00000000000
--- a/IPython/utils/upgradedir.py
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/usr/bin/env python
-""" A script/util to upgrade all files in a directory
-
-This is rather conservative in its approach, only copying/overwriting
-new and unedited files.
-
-To be used by "upgrade" feature.
-"""
-try:
-    from IPython.external.path import path
-except ImportError:
-    from path import path
-
-import hashlib, pickle
-
-def showdiff(old,new):
-    import difflib
-    d = difflib.Differ()
-    lines = d.compare(old.lines(),new.lines())
-    realdiff = False
-    for l in lines:
-        print l,
-        if not realdiff and not l[0].isspace():
-            realdiff = True
-    return realdiff
-
-def upgrade_dir(srcdir, tgtdir):
-    """ Copy over all files in srcdir to tgtdir w/ native line endings
-
-    Creates .upgrade_report in tgtdir that stores md5sums of all files
-    to notice changed files b/w upgrades.
-    """
-
-    def pr(s):
-        print s
-    junk = ['.svn','ipythonrc*','*.pyc', '*.pyo', '*~', '.hg']
-    
-    def ignorable(p):
-        for pat in junk:
-            if p.startswith(pat) or p.fnmatch(pat):
-                return True
-        return False
-
-    modded = []
-    files = [path(srcdir).relpathto(p) for p in path(srcdir).walkfiles()]
-    #print files
-    rep = tgtdir / '.upgrade_report'
-    try:
-        rpt = pickle.load(rep.open())
-    except:
-        rpt = {}
-
-    for f in files:
-        if ignorable(f):
-            continue
-        src = srcdir / f
-        tgt = tgtdir / f
-        if not tgt.isfile():
-            pr("Creating %s" % str(tgt))
-
-            tgt.write_text(src.text())
-            rpt[str(tgt)] = hashlib.md5(tgt.text()).hexdigest()
-        else:
-            cont = tgt.text()
-            sum = rpt.get(str(tgt), None)
-            #print sum
-            if sum and hashlib.md5(cont).hexdigest() == sum:
-                pr("%s: Unedited, installing new version" % tgt)
-                tgt.write_text(src.text())
-                rpt[str(tgt)] = hashlib.md5(tgt.text()).hexdigest()
-            else:
-                pr(' == Modified, skipping %s, diffs below == ' % tgt)
-                #rpt[str(tgt)] = hashlib.md5(tgt.bytes()).hexdigest()
-                real = showdiff(tgt,src)
-                pr('') # empty line
-                if not real:
-                    pr("(Ok, it was identical, only upgrading checksum)")
-                    rpt[str(tgt)] = hashlib.md5(tgt.text()).hexdigest()
-                else:
-                    modded.append(tgt)
-
-        #print rpt
-    pickle.dump(rpt, rep.open('w'))
-    if modded:
-        print "\n\nDelete the following files manually (and rerun %upgrade)\nif you need a full upgrade:"
-        for m in modded:
-            print m
-
-
-import sys
-if __name__ == "__main__":
-    upgrade_dir(path(sys.argv[1]), path(sys.argv[2]))
diff --git a/IPython/utils/warn.py b/IPython/utils/warn.py
deleted file mode 100644
index aabdbf7c364..00000000000
--- a/IPython/utils/warn.py
+++ /dev/null
@@ -1,66 +0,0 @@
-# encoding: utf-8
-"""
-Utilities for warnings.  Shoudn't we just use the built in warnings module.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2009  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-
-from IPython.utils import io
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-def warn(msg,level=2,exit_val=1):
-    """Standard warning printer. Gives formatting consistency.
-
-    Output is sent to io.stderr (sys.stderr by default).
-
-    Options:
-
-    -level(2): allows finer control:
-      0 -> Do nothing, dummy function.
-      1 -> Print message.
-      2 -> Print 'WARNING:' + message. (Default level).
-      3 -> Print 'ERROR:' + message.
-      4 -> Print 'FATAL ERROR:' + message and trigger a sys.exit(exit_val).
-
-    -exit_val (1): exit value returned by sys.exit() for a level 4
-    warning. Ignored for all other levels."""
-
-    if level>0:
-        header = ['','','WARNING: ','ERROR: ','FATAL ERROR: ']
-        print >> io.stderr, '%s%s' % (header[level],msg)
-        if level == 4:
-            print >> io.stderr,'Exiting.\n'
-            sys.exit(exit_val)
-
-            
-def info(msg):
-    """Equivalent to warn(msg,level=1)."""
-
-    warn(msg,level=1)
-
-    
-def error(msg):
-    """Equivalent to warn(msg,level=3)."""
-
-    warn(msg,level=3)
-
-    
-def fatal(msg,exit_val=1):
-    """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
-
-    warn(msg,exit_val=exit_val,level=4)
-
diff --git a/IPython/utils/wildcard.py b/IPython/utils/wildcard.py
index e0fd9b48dba..cbef8c5175b 100644
--- a/IPython/utils/wildcard.py
+++ b/IPython/utils/wildcard.py
@@ -24,7 +24,7 @@ def create_typestr2type_dicts(dont_include_in_type2typestr=["lambda"]):
     objects from the types package, and vice versa."""
     typenamelist = [tname for tname in dir(types) if tname.endswith("Type")]
     typestr2type, type2typestr = {}, {}
-    
+
     for tname in typenamelist:
         name = tname[:-4].lower()          # Cut 'Type' off the end of the name
         obj = getattr(types, tname)
@@ -36,14 +36,14 @@ def create_typestr2type_dicts(dont_include_in_type2typestr=["lambda"]):
 typestr2type, type2typestr = create_typestr2type_dicts()
 
 def is_type(obj, typestr_or_type):
-    """is_type(obj, typestr_or_type) verifies if obj is of a certain type. It 
+    """is_type(obj, typestr_or_type) verifies if obj is of a certain type. It
     can take strings or actual python types for the second argument, i.e.
     'tuple'<->TupleType. 'all' matches all types.
-    
+
     TODO: Should be extended for choosing more than one type."""
     if typestr_or_type == "all":
         return True
-    if type(typestr_or_type) == types.TypeType:
+    if type(typestr_or_type) == type:
         test_type = typestr_or_type
     else:
         test_type = typestr2type.get(typestr_or_type, False)
@@ -71,7 +71,7 @@ def dict_dir(obj):
        except AttributeError:
            pass
     return ns
-        
+
 def filter_ns(ns, name_pattern="*", type_pattern="all", ignore_case=True,
             show_all=True):
     """Filter a namespace dictionary by name pattern and item type."""
@@ -80,9 +80,9 @@ def filter_ns(ns, name_pattern="*", type_pattern="all", ignore_case=True,
         reg = re.compile(pattern+"$", re.I)
     else:
         reg = re.compile(pattern+"$")
-    
+
     # Check each one matches regex; shouldn't be hidden; of correct type.
-    return dict((key,obj) for key, obj in ns.iteritems() if reg.match(key) \
+    return dict((key,obj) for key, obj in ns.items() if reg.match(key) \
                                             and show_hidden(key, show_all) \
                                             and is_type(obj, type_pattern) )
 
@@ -102,10 +102,10 @@ def list_namespace(namespace, type_pattern, filter, ignore_case=False, show_all=
                             type_pattern="all",
                             ignore_case=ignore_case, show_all=show_all)
         results = {}
-        for name, obj in filtered.iteritems():
-            ns = list_namespace(dict_dir(obj), type_pattern, 
+        for name, obj in filtered.items():
+            ns = list_namespace(dict_dir(obj), type_pattern,
                                 ".".join(pattern_list[1:]),
                                 ignore_case=ignore_case, show_all=show_all)
-            for inner_name, inner_obj in ns.iteritems():
+            for inner_name, inner_obj in ns.items():
                 results["%s.%s"%(name,inner_name)] = inner_obj
         return results
diff --git a/IPython/zmq/__init__.py b/IPython/zmq/__init__.py
deleted file mode 100644
index 0063d45dd64..00000000000
--- a/IPython/zmq/__init__.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING.txt, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Verify zmq version dependency >= 2.0.10-1
-#-----------------------------------------------------------------------------
-
-minimum_pyzmq_version = "2.0.10-1"
-
-try:
-    import zmq
-except ImportError:
-    raise ImportError("IPython.zmq requires pyzmq >= %s"%minimum_pyzmq_version)
-
-pyzmq_version = zmq.__version__
-
-if pyzmq_version < minimum_pyzmq_version:
-    raise ImportError("IPython.zmq requires pyzmq >= %s, but you have %s"%(
-                    minimum_pyzmq_version, pyzmq_version))
-
-del pyzmq_version
diff --git a/IPython/zmq/blockingkernelmanager.py b/IPython/zmq/blockingkernelmanager.py
deleted file mode 100644
index 1895044f312..00000000000
--- a/IPython/zmq/blockingkernelmanager.py
+++ /dev/null
@@ -1,121 +0,0 @@
-"""Implement a fully blocking kernel manager.
-
-Useful for test suites and blocking terminal interfaces.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING.txt, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Stdlib
-from Queue import Queue, Empty
-
-# Our own
-from IPython.utils import io
-from IPython.utils.traitlets import Type
-
-from .kernelmanager import (KernelManager, SubSocketChannel, 
-                           XReqSocketChannel, RepSocketChannel, HBSocketChannel)
-
-#-----------------------------------------------------------------------------
-# Functions and classes
-#-----------------------------------------------------------------------------
-
-class BlockingSubSocketChannel(SubSocketChannel):
-
-    def __init__(self, context, session, address=None):
-        super(BlockingSubSocketChannel, self).__init__(context, session,
-                                                       address)
-        self._in_queue = Queue()
-
-    def call_handlers(self, msg):
-        #io.rprint('[[Sub]]', msg) # dbg
-        self._in_queue.put(msg)
-
-    def msg_ready(self):
-        """Is there a message that has been received?"""
-        if self._in_queue.qsize() == 0:
-            return False
-        else:
-            return True
-
-    def get_msg(self, block=True, timeout=None):
-        """Get a message if there is one that is ready."""
-        return self._in_queue.get(block, timeout)
-
-    def get_msgs(self):
-        """Get all messages that are currently ready."""
-        msgs = []
-        while True:
-            try:
-                msgs.append(self.get_msg(block=False))
-            except Empty:
-                break
-        return msgs
-
-
-class BlockingXReqSocketChannel(XReqSocketChannel):
-
-    def __init__(self, context, session, address=None):
-        super(BlockingXReqSocketChannel, self).__init__(context, session,
-                                                        address)
-        self._in_queue = Queue()
-
-    def call_handlers(self, msg):
-        #io.rprint('[[XReq]]', msg) # dbg
-        self._in_queue.put(msg)
-
-    def msg_ready(self):
-        """Is there a message that has been received?"""
-        if self._in_queue.qsize() == 0:
-            return False
-        else:
-            return True
-
-    def get_msg(self, block=True, timeout=None):
-        """Get a message if there is one that is ready."""
-        return self._in_queue.get(block, timeout)
-
-    def get_msgs(self):
-        """Get all messages that are currently ready."""
-        msgs = []
-        while True:
-            try:
-                msgs.append(self.get_msg(block=False))
-            except Empty:
-                break
-        return msgs
-    
-
-class BlockingRepSocketChannel(RepSocketChannel):
-    
-    def call_handlers(self, msg):
-        #io.rprint('[[Rep]]', msg) # dbg
-        pass
-
-
-class BlockingHBSocketChannel(HBSocketChannel):
-    
-    # This kernel needs rapid monitoring capabilities
-    time_to_dead = 0.2
-
-    def call_handlers(self, since_last_heartbeat):
-        #io.rprint('[[Heart]]', since_last_heartbeat) # dbg
-        pass
-
-
-class BlockingKernelManager(KernelManager):
-    
-    # The classes to use for the various channels.
-    xreq_channel_class = Type(BlockingXReqSocketChannel)
-    sub_channel_class = Type(BlockingSubSocketChannel)
-    rep_channel_class = Type(BlockingRepSocketChannel)
-    hb_channel_class = Type(BlockingHBSocketChannel)
-  
diff --git a/IPython/zmq/completer.py b/IPython/zmq/completer.py
deleted file mode 100644
index b775b8a1c5a..00000000000
--- a/IPython/zmq/completer.py
+++ /dev/null
@@ -1,87 +0,0 @@
-"""Tab-completion over zmq"""
-
-# Trying to get print statements to work during completion, not very
-# successfully...
-from __future__ import print_function
-
-import itertools
-import readline
-import rlcompleter
-import time
-
-import session
-
-class KernelCompleter(object):
-    """Kernel-side completion machinery."""
-    def __init__(self, namespace):
-        self.namespace = namespace
-        self.completer = rlcompleter.Completer(namespace)
-
-    def complete(self, line, text):
-        # We'll likely use linel later even if now it's not used for anything
-        matches = []
-        complete = self.completer.complete
-        for state in itertools.count():
-            comp = complete(text, state)
-            if comp is None:
-                break
-            matches.append(comp)
-        return matches
-    
-
-class ClientCompleter(object):
-    """Client-side completion machinery.
-
-    How it works: self.complete will be called multiple times, with
-    state=0,1,2,... When state=0 it should compute ALL the completion matches,
-    and then return them for each value of state."""
-    
-    def __init__(self, client, session, socket):
-         # ugly, but we get called asynchronously and need access to some
-         # client state, like backgrounded code
-        self.client = client
-        self.session = session
-        self.socket = socket
-        self.matches = []
-
-    def request_completion(self, text):
-        # Get full line to give to the kernel in case it wants more info.
-        line = readline.get_line_buffer()
-        # send completion request to kernel
-        msg = self.session.send(self.socket,
-                                'complete_request',
-                                dict(text=text, line=line))
-
-        # Give the kernel up to 0.5s to respond
-        for i in range(5):
-            ident,rep = self.session.recv(self.socket)
-            rep = Message(rep)
-            if rep is not None and rep.msg_type == 'complete_reply':
-                matches = rep.content.matches
-                break
-            time.sleep(0.1)
-        else:
-            # timeout
-            print ('TIMEOUT')  # Can't see this message...
-            matches = None
-        return matches
-    
-    def complete(self, text, state):
-        
-        if self.client.backgrounded > 0:
-            print("\n[Not completing, background tasks active]")
-            print(readline.get_line_buffer(), end='')
-            return None
-        
-        if state==0:
-            matches = self.request_completion(text)
-            if matches is None:
-                self.matches = []
-                print('WARNING: Kernel timeout on tab completion.')
-            else:
-                self.matches = matches
-
-        try:
-            return self.matches[state]
-        except IndexError:
-            return None
diff --git a/IPython/zmq/displayhook.py b/IPython/zmq/displayhook.py
deleted file mode 100644
index 905f1296793..00000000000
--- a/IPython/zmq/displayhook.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import __builtin__
-
-from session import extract_header
-
-class DisplayHook(object):
-
-    topic=None
-
-    def __init__(self, session, pub_socket):
-        self.session = session
-        self.pub_socket = pub_socket
-        self.parent_header = {}
-
-    def __call__(self, obj):
-        if obj is None:
-            return
-
-        __builtin__._ = obj
-        msg = self.session.send(self.pub_socket, u'pyout', {u'data':repr(obj)},
-                               parent=self.parent_header, ident=self.topic)
-
-    def set_parent(self, parent):
-        self.parent_header = extract_header(parent)
\ No newline at end of file
diff --git a/IPython/zmq/entry_point.py b/IPython/zmq/entry_point.py
deleted file mode 100644
index bfb29453164..00000000000
--- a/IPython/zmq/entry_point.py
+++ /dev/null
@@ -1,265 +0,0 @@
-""" Defines helper functions for creating kernel entry points and process
-launchers.
-"""
-
-# Standard library imports.
-import atexit
-import os
-import socket
-from subprocess import Popen, PIPE
-import sys
-
-# System library imports.
-import zmq
-
-# Local imports.
-from IPython.core.ultratb import FormattedTB
-from IPython.external.argparse import ArgumentParser
-from IPython.utils import io
-from IPython.utils.localinterfaces import LOCALHOST
-from displayhook import DisplayHook
-from heartbeat import Heartbeat
-from iostream import OutStream
-from parentpoller import ParentPollerUnix, ParentPollerWindows
-from session import Session
-
-def bind_port(socket, ip, port):
-    """ Binds the specified ZMQ socket. If the port is zero, a random port is
-    chosen. Returns the port that was bound.
-    """
-    connection = 'tcp://%s' % ip
-    if port <= 0:
-        port = socket.bind_to_random_port(connection)
-    else:
-        connection += ':%i' % port
-        socket.bind(connection)
-    return port
-
-
-def make_argument_parser():
-    """ Creates an ArgumentParser for the generic arguments supported by all 
-    kernel entry points.
-    """
-    parser = ArgumentParser()
-    parser.add_argument('--ip', type=str, default=LOCALHOST,
-                        help='set the kernel\'s IP address [default: local]')
-    parser.add_argument('--xrep', type=int, metavar='PORT', default=0,
-                        help='set the XREP channel port [default: random]')
-    parser.add_argument('--pub', type=int, metavar='PORT', default=0,
-                        help='set the PUB channel port [default: random]')
-    parser.add_argument('--req', type=int, metavar='PORT', default=0,
-                        help='set the REQ channel port [default: random]')
-    parser.add_argument('--hb', type=int, metavar='PORT', default=0,
-                        help='set the heartbeat port [default: random]')
-
-    if sys.platform == 'win32':
-        parser.add_argument('--interrupt', type=int, metavar='HANDLE', 
-                            default=0, help='interrupt this process when '
-                            'HANDLE is signaled')
-        parser.add_argument('--parent', type=int, metavar='HANDLE', 
-                            default=0, help='kill this process if the process '
-                            'with HANDLE dies')
-    else:
-        parser.add_argument('--parent', action='store_true', 
-                            help='kill this process if its parent dies')
-
-    return parser
-
-
-def make_kernel(namespace, kernel_factory, 
-                out_stream_factory=None, display_hook_factory=None):
-    """ Creates a kernel, redirects stdout/stderr, and installs a display hook
-    and exception handler.
-    """
-    # If running under pythonw.exe, the interpreter will crash if more than 4KB
-    # of data is written to stdout or stderr. This is a bug that has been with
-    # Python for a very long time; see http://bugs.python.org/issue706263.
-    if sys.executable.endswith('pythonw.exe'):
-        blackhole = file(os.devnull, 'w')
-        sys.stdout = sys.stderr = blackhole
-        sys.__stdout__ = sys.__stderr__ = blackhole 
-
-    # Install minimal exception handling
-    sys.excepthook = FormattedTB(mode='Verbose', color_scheme='NoColor', 
-                                 ostream=sys.__stdout__)
-
-    # Create a context, a session, and the kernel sockets.
-    io.raw_print("Starting the kernel at pid:", os.getpid())
-    context = zmq.Context()
-    # Uncomment this to try closing the context.
-    # atexit.register(context.close)
-    session = Session(username=u'kernel')
-
-    reply_socket = context.socket(zmq.XREP)
-    xrep_port = bind_port(reply_socket, namespace.ip, namespace.xrep)
-    io.raw_print("XREP Channel on port", xrep_port)
-
-    pub_socket = context.socket(zmq.PUB)
-    pub_port = bind_port(pub_socket, namespace.ip, namespace.pub)
-    io.raw_print("PUB Channel on port", pub_port)
-
-    req_socket = context.socket(zmq.XREQ)
-    req_port = bind_port(req_socket, namespace.ip, namespace.req)
-    io.raw_print("REQ Channel on port", req_port)
-
-    hb = Heartbeat(context, (namespace.ip, namespace.hb))
-    hb.start()
-    hb_port = hb.port
-    io.raw_print("Heartbeat REP Channel on port", hb_port)
-
-    # Helper to make it easier to connect to an existing kernel, until we have
-    # single-port connection negotiation fully implemented.
-    io.raw_print("To connect another client to this kernel, use:")
-    io.raw_print("-e --xreq {0} --sub {1} --rep {2} --hb {3}".format(
-        xrep_port, pub_port, req_port, hb_port))
-
-    # Redirect input streams and set a display hook.
-    if out_stream_factory:
-        sys.stdout = out_stream_factory(session, pub_socket, u'stdout')
-        sys.stderr = out_stream_factory(session, pub_socket, u'stderr')
-    if display_hook_factory:
-        sys.displayhook = display_hook_factory(session, pub_socket)
-
-    # Create the kernel.
-    kernel = kernel_factory(session=session, reply_socket=reply_socket, 
-                            pub_socket=pub_socket, req_socket=req_socket)
-    kernel.record_ports(xrep_port=xrep_port, pub_port=pub_port,
-                        req_port=req_port, hb_port=hb_port)
-    return kernel
-
-
-def start_kernel(namespace, kernel):
-    """ Starts a kernel.
-    """
-    # Configure this kernel process to poll the parent process, if necessary.
-    if sys.platform == 'win32':
-        if namespace.interrupt or namespace.parent:
-            poller = ParentPollerWindows(namespace.interrupt, namespace.parent)
-            poller.start()
-    elif namespace.parent:
-        poller = ParentPollerUnix()
-        poller.start()
-
-    # Start the kernel mainloop.
-    kernel.start()
-
-
-def make_default_main(kernel_factory):
-    """ Creates the simplest possible kernel entry point.
-    """
-    def main():
-        namespace = make_argument_parser().parse_args()
-        kernel = make_kernel(namespace, kernel_factory, OutStream, DisplayHook)
-        start_kernel(namespace, kernel)
-    return main
-
-
-def base_launch_kernel(code, xrep_port=0, pub_port=0, req_port=0, hb_port=0,
-                       executable=None, independent=False, extra_arguments=[]):
-    """ Launches a localhost kernel, binding to the specified ports.
-
-    Parameters
-    ----------
-    code : str,
-        A string of Python code that imports and executes a kernel entry point.
-
-    xrep_port : int, optional
-        The port to use for XREP channel.
-
-    pub_port : int, optional
-        The port to use for the SUB channel.
-
-    req_port : int, optional
-        The port to use for the REQ (raw input) channel.
-
-    hb_port : int, optional
-        The port to use for the hearbeat REP channel.
-
-    executable : str, optional (default sys.executable)
-        The Python executable to use for the kernel process.
-
-    independent : bool, optional (default False) 
-        If set, the kernel process is guaranteed to survive if this process
-        dies. If not set, an effort is made to ensure that the kernel is killed
-        when this process dies. Note that in this case it is still good practice
-        to kill kernels manually before exiting.
-
-    extra_arguments = list, optional
-        A list of extra arguments to pass when executing the launch code.
-
-    Returns
-    -------
-    A tuple of form:
-        (kernel_process, xrep_port, pub_port, req_port)
-    where kernel_process is a Popen object and the ports are integers.
-    """
-    # Find open ports as necessary.
-    ports = []
-    ports_needed = int(xrep_port <= 0) + int(pub_port <= 0) + \
-                   int(req_port <= 0) + int(hb_port <= 0)
-    for i in xrange(ports_needed):
-        sock = socket.socket()
-        sock.bind(('', 0))
-        ports.append(sock)
-    for i, sock in enumerate(ports):
-        port = sock.getsockname()[1]
-        sock.close()
-        ports[i] = port
-    if xrep_port <= 0:
-        xrep_port = ports.pop(0)
-    if pub_port <= 0:
-        pub_port = ports.pop(0)
-    if req_port <= 0:
-        req_port = ports.pop(0)
-    if hb_port <= 0:
-        hb_port = ports.pop(0)
-
-    # Build the kernel launch command.
-    if executable is None:
-        executable = sys.executable
-    arguments = [ executable, '-c', code, '--xrep', str(xrep_port), 
-                  '--pub', str(pub_port), '--req', str(req_port),
-                  '--hb', str(hb_port) ]
-    arguments.extend(extra_arguments)
-
-    # Spawn a kernel.
-    if sys.platform == 'win32':
-        # Create a Win32 event for interrupting the kernel.
-        interrupt_event = ParentPollerWindows.create_interrupt_event()
-        arguments += [ '--interrupt', str(int(interrupt_event)) ]
-
-        # If using pythonw, stdin, stdout, and stderr are invalid. Popen will
-        # fail unless they are suitably redirected. We don't read from the
-        # pipes, but they must exist.
-        redirect = PIPE if executable.endswith('pythonw.exe') else None
-
-        if independent:
-            proc = Popen(arguments, 
-                         creationflags=512, # CREATE_NEW_PROCESS_GROUP
-                         stdout=redirect, stderr=redirect, stdin=redirect)
-        else:
-            from _subprocess import DuplicateHandle, GetCurrentProcess, \
-                DUPLICATE_SAME_ACCESS
-            pid = GetCurrentProcess()
-            handle = DuplicateHandle(pid, pid, pid, 0, 
-                                     True, # Inheritable by new processes.
-                                     DUPLICATE_SAME_ACCESS)
-            proc = Popen(arguments + ['--parent', str(int(handle))],
-                         stdout=redirect, stderr=redirect, stdin=redirect)
-
-        # Attach the interrupt event to the Popen objet so it can be used later.
-        proc.win32_interrupt_event = interrupt_event
-
-        # Clean up pipes created to work around Popen bug.
-        if redirect is not None:
-            proc.stdout.close()
-            proc.stderr.close()
-            proc.stdin.close()
-
-    else:
-        if independent:
-            proc = Popen(arguments, preexec_fn=lambda: os.setsid())
-        else:
-            proc = Popen(arguments + ['--parent'])
-
-    return proc, xrep_port, pub_port, req_port, hb_port
diff --git a/IPython/zmq/frontend.py b/IPython/zmq/frontend.py
deleted file mode 100755
index 39eaffa9e3e..00000000000
--- a/IPython/zmq/frontend.py
+++ /dev/null
@@ -1,196 +0,0 @@
-#!/usr/bin/env python
-"""A simple interactive frontend that talks to a kernel over 0MQ.
-"""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-# stdlib
-import cPickle as pickle
-import code
-import readline
-import sys
-import time
-import uuid
-
-# our own
-import zmq
-import session
-import completer
-from IPython.utils.localinterfaces import LOCALHOST
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class Console(code.InteractiveConsole):
-
-    def __init__(self, locals=None, filename="<console>",
-                 session = session,
-                 request_socket=None,
-                 sub_socket=None):
-        code.InteractiveConsole.__init__(self, locals, filename)
-        self.session = session
-        self.request_socket = request_socket
-        self.sub_socket = sub_socket
-        self.backgrounded = 0
-        self.messages = {}
-
-        # Set tab completion
-        self.completer = completer.ClientCompleter(self, session, request_socket)
-        readline.parse_and_bind('tab: complete')
-        readline.parse_and_bind('set show-all-if-ambiguous on')
-        readline.set_completer(self.completer.complete)
-
-        # Set system prompts
-        sys.ps1 = 'Py>>> '
-        sys.ps2 = '  ... '
-        sys.ps3 = 'Out : '
-        # Build dict of handlers for message types
-        self.handlers = {}
-        for msg_type in ['pyin', 'pyout', 'pyerr', 'stream']:
-            self.handlers[msg_type] = getattr(self, 'handle_%s' % msg_type)
-
-    def handle_pyin(self, omsg):
-        if omsg.parent_header.session == self.session.session:
-            return
-        c = omsg.content.code.rstrip()
-        if c:
-            print '[IN from %s]' % omsg.parent_header.username
-            print c
-
-    def handle_pyout(self, omsg):
-        #print omsg # dbg
-        if omsg.parent_header.session == self.session.session:
-            print "%s%s" % (sys.ps3, omsg.content.data)
-        else:
-            print '[Out from %s]' % omsg.parent_header.username
-            print omsg.content.data
-
-    def print_pyerr(self, err):
-        print >> sys.stderr, err.etype,':', err.evalue
-        print >> sys.stderr, ''.join(err.traceback)       
-
-    def handle_pyerr(self, omsg):
-        if omsg.parent_header.session == self.session.session:
-            return
-        print >> sys.stderr, '[ERR from %s]' % omsg.parent_header.username
-        self.print_pyerr(omsg.content)
-        
-    def handle_stream(self, omsg):
-        if omsg.content.name == 'stdout':
-            outstream = sys.stdout
-        else:
-            outstream = sys.stderr
-            print >> outstream, '*ERR*',
-        print >> outstream, omsg.content.data,
-
-    def handle_output(self, omsg):
-        handler = self.handlers.get(omsg.msg_type, None)
-        if handler is not None:
-            handler(omsg)
-
-    def recv_output(self):
-        while True:
-            ident,msg = self.session.recv(self.sub_socket)
-            if msg is None:
-                break
-            self.handle_output(Message(msg))
-
-    def handle_reply(self, rep):
-        # Handle any side effects on output channels
-        self.recv_output()
-        # Now, dispatch on the possible reply types we must handle
-        if rep is None:
-            return
-        if rep.content.status == 'error':
-            self.print_pyerr(rep.content)            
-        elif rep.content.status == 'aborted':
-            print >> sys.stderr, "ERROR: ABORTED"
-            ab = self.messages[rep.parent_header.msg_id].content
-            if 'code' in ab:
-                print >> sys.stderr, ab.code
-            else:
-                print >> sys.stderr, ab
-
-    def recv_reply(self):
-        ident,rep = self.session.recv(self.request_socket)
-        mrep = Message(rep)
-        self.handle_reply(mrep)
-        return mrep
-
-    def runcode(self, code):
-        # We can't pickle code objects, so fetch the actual source
-        src = '\n'.join(self.buffer)
-
-        # for non-background inputs, if we do have previoiusly backgrounded
-        # jobs, check to see if they've produced results
-        if not src.endswith(';'):
-            while self.backgrounded > 0:
-                #print 'checking background'
-                rep = self.recv_reply()
-                if rep:
-                    self.backgrounded -= 1
-                time.sleep(0.05)
-
-        # Send code execution message to kernel
-        omsg = self.session.send(self.request_socket,
-                                 'execute_request', dict(code=src))
-        self.messages[omsg.header.msg_id] = omsg
-        
-        # Fake asynchronicity by letting the user put ';' at the end of the line
-        if src.endswith(';'):
-            self.backgrounded += 1
-            return
-
-        # For foreground jobs, wait for reply
-        while True:
-            rep = self.recv_reply()
-            if rep is not None:
-                break
-            self.recv_output()
-            time.sleep(0.05)
-        else:
-            # We exited without hearing back from the kernel!
-            print >> sys.stderr, 'ERROR!!! kernel never got back to us!!!'
-
-
-class InteractiveClient(object):
-    def __init__(self, session, request_socket, sub_socket):
-        self.session = session
-        self.request_socket = request_socket
-        self.sub_socket = sub_socket
-        self.console = Console(None, '<zmq-console>',
-                               session, request_socket, sub_socket)
-        
-    def interact(self):
-        self.console.interact()
-
-
-def main():
-    # Defaults
-    #ip = '192.168.2.109'
-    ip = LOCALHOST
-    #ip = '99.146.222.252'
-    port_base = 5575
-    connection = ('tcp://%s' % ip) + ':%i'
-    req_conn = connection % port_base
-    sub_conn = connection % (port_base+1)
-    
-    # Create initial sockets
-    c = zmq.Context()
-    request_socket = c.socket(zmq.XREQ)
-    request_socket.connect(req_conn)
-    
-    sub_socket = c.socket(zmq.SUB)
-    sub_socket.connect(sub_conn)
-    sub_socket.setsockopt(zmq.SUBSCRIBE, '')
-
-    # Make session and user-facing client
-    sess = session.Session()
-    client = InteractiveClient(sess, request_socket, sub_socket)
-    client.interact()
-
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/zmq/gui/__init__.py b/IPython/zmq/gui/__init__.py
deleted file mode 100644
index 91037ba1264..00000000000
--- a/IPython/zmq/gui/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-"""GUI support for the IPython ZeroMQ kernel.
-
-This package contains the various toolkit-dependent utilities we use to enable
-coordination between the IPython kernel and the event loops of the various GUI
-toolkits.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team.
-#
-#  Distributed under the terms of the BSD License.
-#
-#  The full license is in the file COPYING.txt, distributed as part of this
-#  software.
-#-----------------------------------------------------------------------------
diff --git a/IPython/zmq/gui/gtkembed.py b/IPython/zmq/gui/gtkembed.py
deleted file mode 100644
index 4d336638321..00000000000
--- a/IPython/zmq/gui/gtkembed.py
+++ /dev/null
@@ -1,86 +0,0 @@
-"""GUI support for the IPython ZeroMQ kernel - GTK toolkit support.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING.txt, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-# stdlib
-import sys
-
-# Third-party
-import gobject
-import gtk
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
-
-class GTKEmbed(object):
-    """A class to embed a kernel into the GTK main event loop.
-    """
-    def __init__(self, kernel):
-        self.kernel = kernel
-        # These two will later store the real gtk functions when we hijack them
-        self.gtk_main = None
-        self.gtk_main_quit = None
-
-    def start(self):
-        """Starts the GTK main event loop and sets our kernel startup routine.
-        """
-        # Register our function to initiate the kernel and start gtk
-        gobject.idle_add(self._wire_kernel)
-        gtk.main()
-
-    def _wire_kernel(self):
-        """Initializes the kernel inside GTK.
-        
-        This is meant to run only once at startup, so it does its job and
-        returns False to ensure it doesn't get run again by GTK.
-        """
-        self.gtk_main, self.gtk_main_quit = self._hijack_gtk()
-        gobject.timeout_add(int(1000*self.kernel._poll_interval),
-                            self.iterate_kernel)
-        return False
-        
-    def iterate_kernel(self):
-        """Run one iteration of the kernel and return True.
-
-        GTK timer functions must return True to be called again, so we make the
-        call to :meth:`do_one_iteration` and then return True for GTK.
-        """
-        self.kernel.do_one_iteration()
-        return True
-
-    def stop(self):
-        # FIXME: this one isn't getting called because we have no reliable
-        # kernel shutdown.  We need to fix that: once the kernel has a
-        # shutdown mechanism, it can call this.
-        self.gtk_main_quit()
-        sys.exit()
-
-    def _hijack_gtk(self):
-        """Hijack a few key functions in GTK for IPython integration.
-
-        Modifies pyGTK's main and main_quit with a dummy so user code does not
-        block IPython.  This allows us to use %run to run arbitrary pygtk
-        scripts from a long-lived IPython session, and when they attempt to
-        start or stop
-
-        Returns
-        -------
-        The original functions that have been hijacked:
-        - gtk.main
-        - gtk.main_quit
-        """
-        def dummy(*args, **kw):
-            pass
-        # save and trap main and main_quit from gtk
-        orig_main, gtk.main = gtk.main, dummy
-        orig_main_quit, gtk.main_quit = gtk.main_quit, dummy
-        return orig_main, orig_main_quit
diff --git a/IPython/zmq/heartbeat.py b/IPython/zmq/heartbeat.py
deleted file mode 100644
index 9ff2a4a0ad6..00000000000
--- a/IPython/zmq/heartbeat.py
+++ /dev/null
@@ -1,45 +0,0 @@
-"""The client and server for a basic ping-pong style heartbeat.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-from threading import Thread
-
-import zmq
-
-from IPython.utils.localinterfaces import LOCALHOST
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-
-class Heartbeat(Thread):
-    "A simple ping-pong style heartbeat that runs in a thread."
-
-    def __init__(self, context, addr=(LOCALHOST, 0)):
-        Thread.__init__(self)
-        self.context = context
-        self.addr = addr
-        self.ip = addr[0]
-        self.port = addr[1]
-        self.daemon = True
-
-    def run(self):
-        self.socket = self.context.socket(zmq.REP)
-        if self.port == 0:
-            self.port = self.socket.bind_to_random_port('tcp://%s' % self.ip)
-        else:
-            self.socket.bind('tcp://%s:%i' % self.addr)
-        zmq.device(zmq.FORWARDER, self.socket, self.socket)
-
diff --git a/IPython/zmq/iostream.py b/IPython/zmq/iostream.py
deleted file mode 100644
index a2e0c2c2836..00000000000
--- a/IPython/zmq/iostream.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import logging
-import sys
-import time
-from cStringIO import StringIO
-
-from session import extract_header, Message
-
-from IPython.utils import io
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# Module-level logger
-logger =  logging.getLogger(__name__)
-
-#-----------------------------------------------------------------------------
-# Stream classes
-#-----------------------------------------------------------------------------
-
-class OutStream(object):
-    """A file like object that publishes the stream to a 0MQ PUB socket."""
-
-    # The time interval between automatic flushes, in seconds.
-    flush_interval = 0.05
-    topic=None
-
-    def __init__(self, session, pub_socket, name):
-        self.session = session
-        self.pub_socket = pub_socket
-        self.name = name
-        self.parent_header = {}
-        self._new_buffer()
-
-    def set_parent(self, parent):
-        self.parent_header = extract_header(parent)
-
-    def close(self):
-        self.pub_socket = None
-
-    def flush(self):
-        #io.rprint('>>>flushing output buffer: %s<<<' % self.name)  # dbg
-        if self.pub_socket is None:
-            raise ValueError(u'I/O operation on closed file')
-        else:
-            data = self._buffer.getvalue()
-            if data:
-                # Make sure that we're handling unicode
-                if not isinstance(data, unicode):
-                    enc = sys.stdin.encoding or sys.getdefaultencoding()
-                    data = data.decode(enc, 'replace')
-                content = {u'name':self.name, u'data':data}
-                msg = self.session.send(self.pub_socket, u'stream', content=content,
-                                       parent=self.parent_header, ident=self.topic)
-                logger.debug(msg)
-
-                self._buffer.close()
-                self._new_buffer()
-
-    def isatty(self):
-        return False
-
-    def next(self):
-        raise IOError('Read not supported on a write only stream.')
-
-    def read(self, size=-1):
-        raise IOError('Read not supported on a write only stream.')
-
-    def readline(self, size=-1):
-        raise IOError('Read not supported on a write only stream.')
-
-    def write(self, string):
-        if self.pub_socket is None:
-            raise ValueError('I/O operation on closed file')
-        else:
-            # We can only send raw bytes, not unicode objects, so we encode
-            # into utf-8 for all frontends if we get unicode inputs.
-            if type(string) == unicode:
-                string = string.encode('utf-8')
-                
-            self._buffer.write(string)
-            current_time = time.time()
-            if self._start <= 0:
-                self._start = current_time
-            elif current_time - self._start > self.flush_interval:
-                self.flush()
-
-    def writelines(self, sequence):
-        if self.pub_socket is None:
-            raise ValueError('I/O operation on closed file')
-        else:
-            for string in sequence:
-                self.write(string)
-
-    def _new_buffer(self):
-        self._buffer = StringIO()
-        self._start = -1
diff --git a/IPython/zmq/ipkernel.py b/IPython/zmq/ipkernel.py
deleted file mode 100755
index 39013a1bb91..00000000000
--- a/IPython/zmq/ipkernel.py
+++ /dev/null
@@ -1,662 +0,0 @@
-#!/usr/bin/env python
-"""A simple interactive kernel that talks to a frontend over 0MQ.
-
-Things to do:
-
-* Implement `set_parent` logic. Right before doing exec, the Kernel should
-  call set_parent on all the PUB objects with the message about to be executed.
-* Implement random port and security key logic.
-* Implement control messages.
-* Implement event loop and poll version.
-"""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Standard library imports.
-import __builtin__
-import atexit
-import sys
-import time
-import traceback
-import logging
-# System library imports.
-import zmq
-
-# Local imports.
-from IPython.config.configurable import Configurable
-from IPython.utils import io
-from IPython.utils.jsonutil import json_clean
-from IPython.lib import pylabtools
-from IPython.utils.traitlets import Instance, Float
-from entry_point import (base_launch_kernel, make_argument_parser, make_kernel,
-                         start_kernel)
-from iostream import OutStream
-from session import Session, Message
-from zmqshell import ZMQInteractiveShell
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-# Module-level logger
-logger = logging.getLogger(__name__)
-
-# FIXME: this needs to be done more cleanly later, once we have proper
-# configuration support.  This is a library, so it shouldn't set a stream
-# handler, see:
-# http://docs.python.org/library/logging.html#configuring-logging-for-a-library
-# But this lets us at least do developer debugging for now by manually turning
-# it on/off.  And once we have full config support, the client entry points
-# will select their logging handlers, as well as passing to this library the
-# logging level.
-
-if 0:  # dbg - set to 1 to actually see the messages.
-    logger.addHandler(logging.StreamHandler())
-    logger.setLevel(logging.DEBUG)
-
-# /FIXME
-
-#-----------------------------------------------------------------------------
-# Main kernel class
-#-----------------------------------------------------------------------------
-
-class Kernel(Configurable):
-
-    #---------------------------------------------------------------------------
-    # Kernel interface
-    #---------------------------------------------------------------------------
-
-    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
-    session = Instance(Session)
-    reply_socket = Instance('zmq.Socket')
-    pub_socket = Instance('zmq.Socket')
-    req_socket = Instance('zmq.Socket')
-
-    # Private interface
-
-    # Time to sleep after flushing the stdout/err buffers in each execute
-    # cycle.  While this introduces a hard limit on the minimal latency of the
-    # execute cycle, it helps prevent output synchronization problems for
-    # clients.
-    # Units are in seconds.  The minimum zmq latency on local host is probably
-    # ~150 microseconds, set this to 500us for now.  We may need to increase it
-    # a little if it's not enough after more interactive testing.
-    _execute_sleep = Float(0.0005, config=True)
-
-    # Frequency of the kernel's event loop.
-    # Units are in seconds, kernel subclasses for GUI toolkits may need to
-    # adapt to milliseconds.
-    _poll_interval = Float(0.05, config=True)
-
-    # If the shutdown was requested over the network, we leave here the
-    # necessary reply message so it can be sent by our registered atexit
-    # handler.  This ensures that the reply is only sent to clients truly at
-    # the end of our shutdown process (which happens after the underlying
-    # IPython shell's own shutdown).
-    _shutdown_message = None
-
-    # This is a dict of port number that the kernel is listening on. It is set
-    # by record_ports and used by connect_request.
-    _recorded_ports = None
-
-
-    def __init__(self, **kwargs):
-        super(Kernel, self).__init__(**kwargs)
-
-        # Before we even start up the shell, register *first* our exit handlers
-        # so they come before the shell's
-        atexit.register(self._at_shutdown)
-
-        # Initialize the InteractiveShell subclass
-        self.shell = ZMQInteractiveShell.instance()
-        self.shell.displayhook.session = self.session
-        self.shell.displayhook.pub_socket = self.pub_socket
-        self.shell.display_pub.session = self.session
-        self.shell.display_pub.pub_socket = self.pub_socket
-
-        # TMP - hack while developing
-        self.shell._reply_content = None
-
-        # Build dict of handlers for message types
-        msg_types = [ 'execute_request', 'complete_request', 
-                      'object_info_request', 'history_tail_request',
-                      'connect_request', 'shutdown_request']
-        self.handlers = {}
-        for msg_type in msg_types:
-            self.handlers[msg_type] = getattr(self, msg_type)
-
-    def do_one_iteration(self):
-        """Do one iteration of the kernel's evaluation loop.
-        """
-        ident,msg = self.session.recv(self.reply_socket, zmq.NOBLOCK)
-        if msg is None:
-            return
-        
-        # This assert will raise in versions of zeromq 2.0.7 and lesser.
-        # We now require 2.0.8 or above, so we can uncomment for safety.
-        # print(ident,msg, file=sys.__stdout__)
-        assert ident is not None, "Missing message part."
-        
-        # Print some info about this message and leave a '--->' marker, so it's
-        # easier to trace visually the message chain when debugging.  Each
-        # handler prints its message at the end.
-        # Eventually we'll move these from stdout to a logger.
-        logger.debug('\n*** MESSAGE TYPE:'+str(msg['msg_type'])+'***')
-        logger.debug('   Content: '+str(msg['content'])+'\n   --->\n   ')
-
-        # Find and call actual handler for message
-        handler = self.handlers.get(msg['msg_type'], None)
-        if handler is None:
-            logger.error("UNKNOWN MESSAGE TYPE:" +str(msg))
-        else:
-            handler(ident, msg)
-            
-        # Check whether we should exit, in case the incoming message set the
-        # exit flag on
-        if self.shell.exit_now:
-            logger.debug('\nExiting IPython kernel...')
-            # We do a normal, clean exit, which allows any actions registered
-            # via atexit (such as history saving) to take place.
-            sys.exit(0)
-
-
-    def start(self):
-        """ Start the kernel main loop.
-        """
-        while True:
-            time.sleep(self._poll_interval)
-            self.do_one_iteration()
-
-    def record_ports(self, xrep_port, pub_port, req_port, hb_port):
-        """Record the ports that this kernel is using.
-
-        The creator of the Kernel instance must call this methods if they
-        want the :meth:`connect_request` method to return the port numbers.
-        """
-        self._recorded_ports = {
-            'xrep_port' : xrep_port,
-            'pub_port' : pub_port,
-            'req_port' : req_port,
-            'hb_port' : hb_port
-        }
-
-    #---------------------------------------------------------------------------
-    # Kernel request handlers
-    #---------------------------------------------------------------------------
-
-    def _publish_pyin(self, code, parent):
-        """Publish the code request on the pyin stream."""
-
-        pyin_msg = self.session.send(self.pub_socket, u'pyin',{u'code':code}, parent=parent)
-
-    def execute_request(self, ident, parent):
-        
-        status_msg = self.session.send(self.pub_socket,
-            u'status',
-            {u'execution_state':u'busy'},
-            parent=parent
-        )
-        
-        try:
-            content = parent[u'content']
-            code = content[u'code']
-            silent = content[u'silent'] 
-        except:
-            logger.error("Got bad msg: ")
-            logger.error(str(Message(parent)))
-            return
-
-        shell = self.shell # we'll need this a lot here
-
-        # Replace raw_input. Note that is not sufficient to replace 
-        # raw_input in the user namespace.
-        raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
-        __builtin__.raw_input = raw_input
-
-        # Set the parent message of the display hook and out streams.
-        shell.displayhook.set_parent(parent)
-        shell.display_pub.set_parent(parent)
-        sys.stdout.set_parent(parent)
-        sys.stderr.set_parent(parent)
-
-        # Re-broadcast our input for the benefit of listening clients, and
-        # start computing output
-        if not silent:
-            self._publish_pyin(code, parent)
-
-        reply_content = {}
-        try:
-            if silent:
-                # run_code uses 'exec' mode, so no displayhook will fire, and it
-                # doesn't call logging or history manipulations.  Print
-                # statements in that code will obviously still execute.
-                shell.run_code(code)
-            else:
-                # FIXME: the shell calls the exception handler itself.
-                shell._reply_content = None
-                shell.run_cell(code)
-        except:
-            status = u'error'
-            # FIXME: this code right now isn't being used yet by default,
-            # because the run_cell() call above directly fires off exception
-            # reporting.  This code, therefore, is only active in the scenario
-            # where runlines itself has an unhandled exception.  We need to
-            # uniformize this, for all exception construction to come from a
-            # single location in the codbase.
-            etype, evalue, tb = sys.exc_info()
-            tb_list = traceback.format_exception(etype, evalue, tb)
-            reply_content.update(shell._showtraceback(etype, evalue, tb_list))
-        else:
-            status = u'ok'
-
-        reply_content[u'status'] = status
-        
-        # Return the execution counter so clients can display prompts
-        reply_content['execution_count'] = shell.execution_count -1
-
-        # FIXME - fish exception info out of shell, possibly left there by
-        # runlines.  We'll need to clean up this logic later.
-        if shell._reply_content is not None:
-            reply_content.update(shell._reply_content)
-
-        # At this point, we can tell whether the main code execution succeeded
-        # or not.  If it did, we proceed to evaluate user_variables/expressions
-        if reply_content['status'] == 'ok':
-            reply_content[u'user_variables'] = \
-                         shell.user_variables(content[u'user_variables'])
-            reply_content[u'user_expressions'] = \
-                         shell.user_expressions(content[u'user_expressions'])
-        else:
-            # If there was an error, don't even try to compute variables or
-            # expressions
-            reply_content[u'user_variables'] = {}
-            reply_content[u'user_expressions'] = {}
-
-        # Payloads should be retrieved regardless of outcome, so we can both
-        # recover partial output (that could have been generated early in a
-        # block, before an error) and clear the payload system always.
-        reply_content[u'payload'] = shell.payload_manager.read_payload()
-        # Be agressive about clearing the payload because we don't want
-        # it to sit in memory until the next execute_request comes in.
-        shell.payload_manager.clear_payload()
-
-        # Flush output before sending the reply.
-        sys.stdout.flush()
-        sys.stderr.flush()
-        # FIXME: on rare occasions, the flush doesn't seem to make it to the
-        # clients... This seems to mitigate the problem, but we definitely need
-        # to better understand what's going on.
-        if self._execute_sleep:
-            time.sleep(self._execute_sleep)
-        
-        # Send the reply.
-        reply_msg = self.session.send(self.reply_socket, u'execute_reply',
-                                      reply_content, parent, ident=ident)
-        logger.debug(str(reply_msg))
-
-        if reply_msg['content']['status'] == u'error':
-            self._abort_queue()
-
-        status_msg = self.session.send(self.pub_socket,
-            u'status',
-            {u'execution_state':u'idle'},
-            parent=parent
-        )
-
-    def complete_request(self, ident, parent):
-        txt, matches = self._complete(parent)
-        matches = {'matches' : matches,
-                   'matched_text' : txt,
-                   'status' : 'ok'}
-        completion_msg = self.session.send(self.reply_socket, 'complete_reply',
-                                           matches, parent, ident)
-        logger.debug(str(completion_msg))
-
-    def object_info_request(self, ident, parent):
-        object_info = self.shell.object_inspect(parent['content']['oname'])
-        # Before we send this object over, we scrub it for JSON usage
-        oinfo = json_clean(object_info)
-        msg = self.session.send(self.reply_socket, 'object_info_reply',
-                                oinfo, parent, ident)
-        logger.debug(msg)
-
-    def history_tail_request(self, ident, parent):
-        # We need to pull these out, as passing **kwargs doesn't work with
-        # unicode keys before Python 2.6.5.
-        n = parent['content']['n']
-        raw = parent['content']['raw']
-        output = parent['content']['output']
-        hist = self.shell.history_manager.get_tail(n, raw=raw, output=output)
-        content = {'history' : list(hist)}
-        msg = self.session.send(self.reply_socket, 'history_tail_reply',
-                                content, parent, ident)
-        logger.debug(str(msg))
-
-    def connect_request(self, ident, parent):
-        if self._recorded_ports is not None:
-            content = self._recorded_ports.copy()
-        else:
-            content = {}
-        msg = self.session.send(self.reply_socket, 'connect_reply',
-                                content, parent, ident)
-        logger.debug(msg)
-
-    def shutdown_request(self, ident, parent):
-        self.shell.exit_now = True
-        self._shutdown_message = self.session.msg(u'shutdown_reply', parent['content'], parent)
-        sys.exit(0)
-
-    #---------------------------------------------------------------------------
-    # Protected interface
-    #---------------------------------------------------------------------------
-
-    def _abort_queue(self):
-        while True:
-            ident,msg = self.session.recv(self.reply_socket, zmq.NOBLOCK)
-            if msg is None:
-                break
-            else:
-                assert ident is not None, \
-                       "Unexpected missing message part."
-
-            logger.debug("Aborting:\n"+str(Message(msg)))
-            msg_type = msg['msg_type']
-            reply_type = msg_type.split('_')[0] + '_reply'
-            reply_msg = self.session.send(self.reply_socket, reply_type, 
-                    {'status' : 'aborted'}, msg, ident=ident)
-            logger.debug(reply_msg)
-            # We need to wait a bit for requests to come in. This can probably
-            # be set shorter for true asynchronous clients.
-            time.sleep(0.1)
-
-    def _raw_input(self, prompt, ident, parent):
-        # Flush output before making the request.
-        sys.stderr.flush()
-        sys.stdout.flush()
-
-        # Send the input request.
-        content = dict(prompt=prompt)
-        msg = self.session.send(self.req_socket, u'input_request', content, parent)
-
-        # Await a response.
-        ident, reply = self.session.recv(self.req_socket, 0)
-        try:
-            value = reply['content']['value']
-        except:
-            logger.error("Got bad raw_input reply: ")
-            logger.error(str(Message(parent)))
-            value = ''
-        return value
-    
-    def _complete(self, msg):
-        c = msg['content']
-        try:
-            cpos = int(c['cursor_pos'])
-        except:
-            # If we don't get something that we can convert to an integer, at
-            # least attempt the completion guessing the cursor is at the end of
-            # the text, if there's any, and otherwise of the line
-            cpos = len(c['text'])
-            if cpos==0:
-                cpos = len(c['line'])
-        return self.shell.complete(c['text'], c['line'], cpos)
-
-    def _object_info(self, context):
-        symbol, leftover = self._symbol_from_context(context)
-        if symbol is not None and not leftover:
-            doc = getattr(symbol, '__doc__', '')
-        else:
-            doc = ''
-        object_info = dict(docstring = doc)
-        return object_info
-
-    def _symbol_from_context(self, context):
-        if not context:
-            return None, context
-
-        base_symbol_string = context[0]
-        symbol = self.shell.user_ns.get(base_symbol_string, None)
-        if symbol is None:
-            symbol = __builtin__.__dict__.get(base_symbol_string, None)
-        if symbol is None:
-            return None, context
-
-        context = context[1:]
-        for i, name in enumerate(context):
-            new_symbol = getattr(symbol, name, None)
-            if new_symbol is None:
-                return symbol, context[i:]
-            else:
-                symbol = new_symbol
-
-        return symbol, []
-
-    def _at_shutdown(self):
-        """Actions taken at shutdown by the kernel, called by python's atexit.
-        """
-        # io.rprint("Kernel at_shutdown") # dbg
-        if self._shutdown_message is not None:
-            self.session.send(self.reply_socket, self._shutdown_message)
-            self.session.send(self.pub_socket, self._shutdown_message)
-            logger.debug(str(self._shutdown_message))
-            # A very short sleep to give zmq time to flush its message buffers
-            # before Python truly shuts down.
-            time.sleep(0.01)
-
-
-class QtKernel(Kernel):
-    """A Kernel subclass with Qt support."""
-
-    def start(self):
-        """Start a kernel with QtPy4 event loop integration."""
-
-        from PyQt4 import QtCore
-        from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
-
-        self.app = get_app_qt4([" "])
-        self.app.setQuitOnLastWindowClosed(False)
-        self.timer = QtCore.QTimer()
-        self.timer.timeout.connect(self.do_one_iteration)
-        # Units for the timer are in milliseconds
-        self.timer.start(1000*self._poll_interval)
-        start_event_loop_qt4(self.app)
-
-
-class WxKernel(Kernel):
-    """A Kernel subclass with Wx support."""
-
-    def start(self):
-        """Start a kernel with wx event loop support."""
-
-        import wx
-        from IPython.lib.guisupport import start_event_loop_wx
-
-        doi = self.do_one_iteration
-         # Wx uses milliseconds
-        poll_interval = int(1000*self._poll_interval)
-
-        # We have to put the wx.Timer in a wx.Frame for it to fire properly.
-        # We make the Frame hidden when we create it in the main app below.
-        class TimerFrame(wx.Frame):
-            def __init__(self, func):
-                wx.Frame.__init__(self, None, -1)
-                self.timer = wx.Timer(self)
-                # Units for the timer are in milliseconds
-                self.timer.Start(poll_interval)
-                self.Bind(wx.EVT_TIMER, self.on_timer)
-                self.func = func
-
-            def on_timer(self, event):
-                self.func()
-
-        # We need a custom wx.App to create our Frame subclass that has the
-        # wx.Timer to drive the ZMQ event loop.
-        class IPWxApp(wx.App):
-            def OnInit(self):
-                self.frame = TimerFrame(doi)
-                self.frame.Show(False)
-                return True
-
-        # The redirect=False here makes sure that wx doesn't replace
-        # sys.stdout/stderr with its own classes.
-        self.app = IPWxApp(redirect=False)
-        start_event_loop_wx(self.app)
-
-
-class TkKernel(Kernel):
-    """A Kernel subclass with Tk support."""
-
-    def start(self):
-        """Start a Tk enabled event loop."""
-
-        import Tkinter
-        doi = self.do_one_iteration
-        # Tk uses milliseconds
-        poll_interval = int(1000*self._poll_interval)
-        # For Tkinter, we create a Tk object and call its withdraw method.
-        class Timer(object):
-            def __init__(self, func):
-                self.app = Tkinter.Tk()
-                self.app.withdraw()
-                self.func = func
-                
-            def on_timer(self):
-                self.func()
-                self.app.after(poll_interval, self.on_timer)
-                
-            def start(self):
-                self.on_timer()  # Call it once to get things going.
-                self.app.mainloop()
-
-        self.timer = Timer(doi)
-        self.timer.start()
-
-
-class GTKKernel(Kernel):
-    """A Kernel subclass with GTK support."""
-    
-    def start(self):
-        """Start the kernel, coordinating with the GTK event loop"""
-        from .gui.gtkembed import GTKEmbed
-        
-        gtk_kernel = GTKEmbed(self)
-        gtk_kernel.start()
-
-
-#-----------------------------------------------------------------------------
-# Kernel main and launch functions
-#-----------------------------------------------------------------------------
-
-def launch_kernel(ip=None, xrep_port=0, pub_port=0, req_port=0, hb_port=0,
-                  executable=None, independent=False, pylab=False, colors=None):
-    """Launches a localhost kernel, binding to the specified ports.
-
-    Parameters
-    ----------
-    ip  : str, optional
-        The ip address the kernel will bind to.
-    
-    xrep_port : int, optional
-        The port to use for XREP channel.
-
-    pub_port : int, optional
-        The port to use for the SUB channel.
-
-    req_port : int, optional
-        The port to use for the REQ (raw input) channel.
-
-    hb_port : int, optional
-        The port to use for the hearbeat REP channel.
-
-    executable : str, optional (default sys.executable)
-        The Python executable to use for the kernel process.
-
-    independent : bool, optional (default False) 
-        If set, the kernel process is guaranteed to survive if this process
-        dies. If not set, an effort is made to ensure that the kernel is killed
-        when this process dies. Note that in this case it is still good practice
-        to kill kernels manually before exiting.
-
-    pylab : bool or string, optional (default False)
-        If not False, the kernel will be launched with pylab enabled. If a
-        string is passed, matplotlib will use the specified backend. Otherwise,
-        matplotlib's default backend will be used.
-
-    colors : None or string, optional (default None)
-        If not None, specify the color scheme. One of (NoColor, LightBG, Linux)
-
-    Returns
-    -------
-    A tuple of form:
-        (kernel_process, xrep_port, pub_port, req_port)
-    where kernel_process is a Popen object and the ports are integers.
-    """
-    extra_arguments = []
-    if pylab:
-        extra_arguments.append('--pylab')
-        if isinstance(pylab, basestring):
-            extra_arguments.append(pylab)
-    if ip is not None:
-        extra_arguments.append('--ip')
-        if isinstance(ip, basestring):
-            extra_arguments.append(ip)
-    if colors is not None:
-        extra_arguments.append('--colors')
-        extra_arguments.append(colors)
-    return base_launch_kernel('from IPython.zmq.ipkernel import main; main()',
-                              xrep_port, pub_port, req_port, hb_port, 
-                              executable, independent, extra_arguments)
-
-
-def main():
-    """ The IPython kernel main entry point.
-    """
-    parser = make_argument_parser()
-    parser.add_argument('--pylab', type=str, metavar='GUI', nargs='?', 
-                        const='auto', help = \
-"Pre-load matplotlib and numpy for interactive use. If GUI is not \
-given, the GUI backend is matplotlib's, otherwise use one of: \
-['tk', 'gtk', 'qt', 'wx', 'osx', 'inline'].")
-    parser.add_argument('--colors',
-        type=str, dest='colors',
-        help="Set the color scheme (NoColor, Linux, and LightBG).",
-        metavar='ZMQInteractiveShell.colors')
-    namespace = parser.parse_args()
-
-    kernel_class = Kernel
-
-    kernel_classes = {
-        'qt' : QtKernel,
-        'qt4': QtKernel,
-        'inline': Kernel,
-        'osx': TkKernel,
-        'wx' : WxKernel,
-        'tk' : TkKernel,
-        'gtk': GTKKernel,
-    }
-    if namespace.pylab:
-        if namespace.pylab == 'auto':
-            gui, backend = pylabtools.find_gui_and_backend()
-        else:
-            gui, backend = pylabtools.find_gui_and_backend(namespace.pylab)
-        kernel_class = kernel_classes.get(gui)
-        if kernel_class is None:
-            raise ValueError('GUI is not supported: %r' % gui)
-        pylabtools.activate_matplotlib(backend)
-    if namespace.colors:
-        ZMQInteractiveShell.colors=namespace.colors
-
-    kernel = make_kernel(namespace, kernel_class, OutStream)
-
-    if namespace.pylab:
-        pylabtools.import_pylab(kernel.shell.user_ns, backend,
-                                shell=kernel.shell)
-
-    start_kernel(namespace, kernel)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/zmq/kernelmanager.py b/IPython/zmq/kernelmanager.py
deleted file mode 100644
index a099f952c37..00000000000
--- a/IPython/zmq/kernelmanager.py
+++ /dev/null
@@ -1,920 +0,0 @@
-"""Base classes to manage the interaction with a running kernel.
-
-TODO
-* Create logger to handle debugging and console messages.
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2008-2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports.
-import atexit
-from Queue import Queue, Empty
-from subprocess import Popen
-import signal
-import sys
-from threading import Thread
-import time
-import logging
-
-# System library imports.
-import zmq
-from zmq import POLLIN, POLLOUT, POLLERR
-from zmq.eventloop import ioloop
-
-# Local imports.
-from IPython.utils import io
-from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
-from IPython.utils.traitlets import HasTraits, Any, Instance, Type, TCPAddress
-from session import Session, Message
-
-#-----------------------------------------------------------------------------
-# Constants and exceptions
-#-----------------------------------------------------------------------------
-
-class InvalidPortNumber(Exception):
-    pass
-
-#-----------------------------------------------------------------------------
-# Utility functions
-#-----------------------------------------------------------------------------
-
-# some utilities to validate message structure, these might get moved elsewhere
-# if they prove to have more generic utility
-
-def validate_string_list(lst):
-    """Validate that the input is a list of strings.
-
-    Raises ValueError if not."""
-    if not isinstance(lst, list):
-        raise ValueError('input %r must be a list' % lst)
-    for x in lst:
-        if not isinstance(x, basestring):
-            raise ValueError('element %r in list must be a string' % x)
-
-
-def validate_string_dict(dct):
-    """Validate that the input is a dict with string keys and values.
-
-    Raises ValueError if not."""
-    for k,v in dct.iteritems():
-        if not isinstance(k, basestring):
-            raise ValueError('key %r in dict must be a string' % k)
-        if not isinstance(v, basestring):
-            raise ValueError('value %r in dict must be a string' % v)
-
-
-#-----------------------------------------------------------------------------
-# ZMQ Socket Channel classes
-#-----------------------------------------------------------------------------
-
-class ZmqSocketChannel(Thread):
-    """The base class for the channels that use ZMQ sockets.
-    """
-    context = None
-    session = None
-    socket = None
-    ioloop = None
-    iostate = None
-    _address = None
-
-    def __init__(self, context, session, address):
-        """Create a channel
-
-        Parameters
-        ----------
-        context : :class:`zmq.Context`
-            The ZMQ context to use.
-        session : :class:`session.Session`
-            The session to use.
-        address : tuple
-            Standard (ip, port) tuple that the kernel is listening on.
-        """
-        super(ZmqSocketChannel, self).__init__()
-        self.daemon = True
-
-        self.context = context
-        self.session = session
-        if address[1] == 0:
-            message = 'The port number for a channel cannot be 0.'
-            raise InvalidPortNumber(message)
-        self._address = address
-
-    def stop(self):
-        """Stop the channel's activity.
-
-        This calls :method:`Thread.join` and returns when the thread
-        terminates. :class:`RuntimeError` will be raised if 
-        :method:`self.start` is called again.
-        """
-        self.join()
-
-    @property
-    def address(self):
-        """Get the channel's address as an (ip, port) tuple.
-        
-        By the default, the address is (localhost, 0), where 0 means a random
-        port.
-        """
-        return self._address
-
-    def add_io_state(self, state):
-        """Add IO state to the eventloop.
-
-        Parameters
-        ----------
-        state : zmq.POLLIN|zmq.POLLOUT|zmq.POLLERR
-            The IO state flag to set.
-
-        This is thread safe as it uses the thread safe IOLoop.add_callback.
-        """
-        def add_io_state_callback():
-            if not self.iostate & state:
-                self.iostate = self.iostate | state
-                self.ioloop.update_handler(self.socket, self.iostate)
-        self.ioloop.add_callback(add_io_state_callback)
-
-    def drop_io_state(self, state):
-        """Drop IO state from the eventloop.
-
-        Parameters
-        ----------
-        state : zmq.POLLIN|zmq.POLLOUT|zmq.POLLERR
-            The IO state flag to set.
-
-        This is thread safe as it uses the thread safe IOLoop.add_callback.
-        """
-        def drop_io_state_callback():
-            if self.iostate & state:
-                self.iostate = self.iostate & (~state)
-                self.ioloop.update_handler(self.socket, self.iostate)
-        self.ioloop.add_callback(drop_io_state_callback)
-
-
-class XReqSocketChannel(ZmqSocketChannel):
-    """The XREQ channel for issues request/replies to the kernel.
-    """
-
-    command_queue = None
-
-    def __init__(self, context, session, address):
-        super(XReqSocketChannel, self).__init__(context, session, address)
-        self.command_queue = Queue()
-        self.ioloop = ioloop.IOLoop()
-
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self.socket = self.context.socket(zmq.XREQ)
-        self.socket.setsockopt(zmq.IDENTITY, self.session.session)
-        self.socket.connect('tcp://%s:%i' % self.address)
-        self.iostate = POLLERR|POLLIN
-        self.ioloop.add_handler(self.socket, self._handle_events, 
-                                self.iostate)
-        self.ioloop.start()
-
-    def stop(self):
-        self.ioloop.stop()
-        super(XReqSocketChannel, self).stop()
-
-    def call_handlers(self, msg):
-        """This method is called in the ioloop thread when a message arrives.
-
-        Subclasses should override this method to handle incoming messages.
-        It is important to remember that this method is called in the thread
-        so that some logic must be done to ensure that the application leve
-        handlers are called in the application thread.
-        """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
-
-    def execute(self, code, silent=False,
-                user_variables=None, user_expressions=None):
-        """Execute code in the kernel.
-
-        Parameters
-        ----------
-        code : str
-            A string of Python code.
-            
-        silent : bool, optional (default False)
-            If set, the kernel will execute the code as quietly possible.
-
-        user_variables : list, optional
-            A list of variable names to pull from the user's namespace.  They
-            will come back as a dict with these names as keys and their
-            :func:`repr` as values.
-            
-        user_expressions : dict, optional
-            A dict with string keys and  to pull from the user's
-            namespace.  They will come back as a dict with these names as keys
-            and their :func:`repr` as values.
-
-        Returns
-        -------
-        The msg_id of the message sent.
-        """
-        if user_variables is None:
-            user_variables = []
-        if user_expressions is None:
-            user_expressions = {}
-            
-        # Don't waste network traffic if inputs are invalid
-        if not isinstance(code, basestring):
-            raise ValueError('code %r must be a string' % code)
-        validate_string_list(user_variables)
-        validate_string_dict(user_expressions)
-
-        # Create class for content/msg creation. Related to, but possibly
-        # not in Session.
-        content = dict(code=code, silent=silent,
-                       user_variables=user_variables,
-                       user_expressions=user_expressions)
-        msg = self.session.msg('execute_request', content)
-        self._queue_request(msg)
-        return msg['header']['msg_id']
-
-    def complete(self, text, line, cursor_pos, block=None):
-        """Tab complete text in the kernel's namespace.
-
-        Parameters
-        ----------
-        text : str
-            The text to complete.
-        line : str
-            The full line of text that is the surrounding context for the 
-            text to complete.
-        cursor_pos : int
-            The position of the cursor in the line where the completion was
-            requested.
-        block : str, optional
-            The full block of code in which the completion is being requested.
-
-        Returns
-        -------
-        The msg_id of the message sent.
-        """
-        content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)
-        msg = self.session.msg('complete_request', content)
-        self._queue_request(msg)
-        return msg['header']['msg_id']
-
-    def object_info(self, oname):
-        """Get metadata information about an object.
-
-        Parameters
-        ----------
-        oname : str
-            A string specifying the object name.
-        
-        Returns
-        -------
-        The msg_id of the message sent.
-        """
-        content = dict(oname=oname)
-        msg = self.session.msg('object_info_request', content)
-        self._queue_request(msg)
-        return msg['header']['msg_id']
-
-    def history_tail(self, n=10, raw=True, output=False):
-        """Get the history list.
-
-        Parameters
-        ----------
-        n : int
-            The number of lines of history to get.
-        raw : bool
-            If True, return the raw input.
-        output : bool
-            If True, then return the output as well.
-
-        Returns
-        -------
-        The msg_id of the message sent.
-        """
-        content = dict(n=n, raw=raw, output=output)
-        msg = self.session.msg('history_tail_request', content)
-        self._queue_request(msg)
-        return msg['header']['msg_id']
-
-    def shutdown(self, restart=False):
-        """Request an immediate kernel shutdown.
-
-        Upon receipt of the (empty) reply, client code can safely assume that
-        the kernel has shut down and it's safe to forcefully terminate it if
-        it's still alive.
-
-        The kernel will send the reply via a function registered with Python's
-        atexit module, ensuring it's truly done as the kernel is done with all
-        normal operation.
-        """
-        # Send quit message to kernel. Once we implement kernel-side setattr,
-        # this should probably be done that way, but for now this will do.
-        msg = self.session.msg('shutdown_request', {'restart':restart})
-        self._queue_request(msg)
-        return msg['header']['msg_id']
-
-    def _handle_events(self, socket, events):
-        if events & POLLERR:
-            self._handle_err()
-        if events & POLLOUT:
-            self._handle_send()
-        if events & POLLIN:
-            self._handle_recv()
-
-    def _handle_recv(self):
-        ident,msg = self.session.recv(self.socket, 0)
-        self.call_handlers(msg)
-
-    def _handle_send(self):
-        try:
-            msg = self.command_queue.get(False)
-        except Empty:
-            pass
-        else:
-            self.session.send(self.socket,msg)
-        if self.command_queue.empty():
-            self.drop_io_state(POLLOUT)
-
-    def _handle_err(self):
-        # We don't want to let this go silently, so eventually we should log.
-        raise zmq.ZMQError()
-
-    def _queue_request(self, msg):
-        self.command_queue.put(msg)
-        self.add_io_state(POLLOUT)
-
-
-class SubSocketChannel(ZmqSocketChannel):
-    """The SUB channel which listens for messages that the kernel publishes.
-    """
-
-    def __init__(self, context, session, address):
-        super(SubSocketChannel, self).__init__(context, session, address)
-        self.ioloop = ioloop.IOLoop()
-
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self.socket = self.context.socket(zmq.SUB)
-        self.socket.setsockopt(zmq.SUBSCRIBE,'')
-        self.socket.setsockopt(zmq.IDENTITY, self.session.session)
-        self.socket.connect('tcp://%s:%i' % self.address)
-        self.iostate = POLLIN|POLLERR
-        self.ioloop.add_handler(self.socket, self._handle_events, 
-                                self.iostate)
-        self.ioloop.start()
-
-    def stop(self):
-        self.ioloop.stop()
-        super(SubSocketChannel, self).stop()
-
-    def call_handlers(self, msg):
-        """This method is called in the ioloop thread when a message arrives.
-
-        Subclasses should override this method to handle incoming messages.
-        It is important to remember that this method is called in the thread
-        so that some logic must be done to ensure that the application leve
-        handlers are called in the application thread.
-        """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
-
-    def flush(self, timeout=1.0):
-        """Immediately processes all pending messages on the SUB channel.
-
-        Callers should use this method to ensure that :method:`call_handlers`
-        has been called for all messages that have been received on the
-        0MQ SUB socket of this channel.
-
-        This method is thread safe.
-
-        Parameters
-        ----------
-        timeout : float, optional
-            The maximum amount of time to spend flushing, in seconds. The
-            default is one second.
-        """
-        # We do the IOLoop callback process twice to ensure that the IOLoop
-        # gets to perform at least one full poll.
-        stop_time = time.time() + timeout
-        for i in xrange(2):
-            self._flushed = False
-            self.ioloop.add_callback(self._flush)
-            while not self._flushed and time.time() < stop_time:
-                time.sleep(0.01)
-
-    def _handle_events(self, socket, events):
-        # Turn on and off POLLOUT depending on if we have made a request
-        if events & POLLERR:
-            self._handle_err()
-        if events & POLLIN:
-            self._handle_recv()
-
-    def _handle_err(self):
-        # We don't want to let this go silently, so eventually we should log.
-        raise zmq.ZMQError()
-
-    def _handle_recv(self):
-        # Get all of the messages we can
-        while True:
-            try:
-                ident,msg = self.session.recv(self.socket)
-            except zmq.ZMQError:
-                # Check the errno?
-                # Will this trigger POLLERR?
-                break
-            else:
-                if msg is None:
-                    break
-                self.call_handlers(msg)
-
-    def _flush(self):
-        """Callback for :method:`self.flush`."""
-        self._flushed = True
-
-
-class RepSocketChannel(ZmqSocketChannel):
-    """A reply channel to handle raw_input requests that the kernel makes."""
-
-    msg_queue = None
-
-    def __init__(self, context, session, address):
-        super(RepSocketChannel, self).__init__(context, session, address)
-        self.ioloop = ioloop.IOLoop()
-        self.msg_queue = Queue()
-
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self.socket = self.context.socket(zmq.XREQ)
-        self.socket.setsockopt(zmq.IDENTITY, self.session.session)
-        self.socket.connect('tcp://%s:%i' % self.address)
-        self.iostate = POLLERR|POLLIN
-        self.ioloop.add_handler(self.socket, self._handle_events, 
-                                self.iostate)
-        self.ioloop.start()
-
-    def stop(self):
-        self.ioloop.stop()
-        super(RepSocketChannel, self).stop()
-
-    def call_handlers(self, msg):
-        """This method is called in the ioloop thread when a message arrives.
-
-        Subclasses should override this method to handle incoming messages.
-        It is important to remember that this method is called in the thread
-        so that some logic must be done to ensure that the application leve
-        handlers are called in the application thread.
-        """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
-
-    def input(self, string):
-        """Send a string of raw input to the kernel."""
-        content = dict(value=string)
-        msg = self.session.msg('input_reply', content)
-        self._queue_reply(msg)
-
-    def _handle_events(self, socket, events):
-        if events & POLLERR:
-            self._handle_err()
-        if events & POLLOUT:
-            self._handle_send()
-        if events & POLLIN:
-            self._handle_recv()
-
-    def _handle_recv(self):
-        ident,msg = self.session.recv(self.socket, 0)
-        self.call_handlers(msg)
-
-    def _handle_send(self):
-        try:
-            msg = self.msg_queue.get(False)
-        except Empty:
-            pass
-        else:
-            self.session.send(self.socket,msg)
-        if self.msg_queue.empty():
-            self.drop_io_state(POLLOUT)
-
-    def _handle_err(self):
-        # We don't want to let this go silently, so eventually we should log.
-        raise zmq.ZMQError()
-
-    def _queue_reply(self, msg):
-        self.msg_queue.put(msg)
-        self.add_io_state(POLLOUT)
-
-
-class HBSocketChannel(ZmqSocketChannel):
-    """The heartbeat channel which monitors the kernel heartbeat.
-
-    Note that the heartbeat channel is paused by default. As long as you start
-    this channel, the kernel manager will ensure that it is paused and un-paused
-    as appropriate.
-    """
-
-    time_to_dead = 3.0
-    socket = None
-    poller = None
-    _running = None
-    _pause = None
-
-    def __init__(self, context, session, address):
-        super(HBSocketChannel, self).__init__(context, session, address)
-        self._running = False
-        self._pause = True
-
-    def _create_socket(self):
-        self.socket = self.context.socket(zmq.REQ)
-        self.socket.setsockopt(zmq.IDENTITY, self.session.session)
-        self.socket.connect('tcp://%s:%i' % self.address)
-        self.poller = zmq.Poller()
-        self.poller.register(self.socket, zmq.POLLIN)
-
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self._create_socket()
-        self._running = True
-        while self._running:
-            if self._pause:
-                time.sleep(self.time_to_dead)
-            else:
-                since_last_heartbeat = 0.0
-                request_time = time.time()
-                try:
-                    #io.rprint('Ping from HB channel') # dbg
-                    self.socket.send(b'ping')
-                except zmq.ZMQError, e:
-                    #io.rprint('*** HB Error:', e) # dbg
-                    if e.errno == zmq.EFSM:
-                        #io.rprint('sleep...', self.time_to_dead) # dbg
-                        time.sleep(self.time_to_dead)
-                        self._create_socket()
-                    else:
-                        raise
-                else:
-                    while True:
-                        try:
-                            self.socket.recv(zmq.NOBLOCK)
-                        except zmq.ZMQError, e:
-                            #io.rprint('*** HB Error 2:', e) # dbg
-                            if e.errno == zmq.EAGAIN:
-                                before_poll = time.time()
-                                until_dead = self.time_to_dead - (before_poll -
-                                                                  request_time)
-
-                                # When the return value of poll() is an empty
-                                # list, that is when things have gone wrong
-                                # (zeromq bug). As long as it is not an empty
-                                # list, poll is working correctly even if it
-                                # returns quickly. Note: poll timeout is in
-                                # milliseconds.
-                                self.poller.poll(1000*until_dead)
-                            
-                                since_last_heartbeat = time.time()-request_time
-                                if since_last_heartbeat > self.time_to_dead:
-                                    self.call_handlers(since_last_heartbeat)
-                                    break
-                            else:
-                                # FIXME: We should probably log this instead.
-                                raise
-                        else:
-                            until_dead = self.time_to_dead - (time.time() -
-                                                              request_time)
-                            if until_dead > 0.0:
-                                #io.rprint('sleep...', self.time_to_dead) # dbg
-                                time.sleep(until_dead)
-                            break
-
-    def pause(self):
-        """Pause the heartbeat."""
-        self._pause = True
-
-    def unpause(self):
-        """Unpause the heartbeat."""
-        self._pause = False
-
-    def is_beating(self):
-        """Is the heartbeat running and not paused."""
-        if self.is_alive() and not self._pause:
-            return True
-        else:
-            return False
-
-    def stop(self):
-        self._running = False
-        super(HBSocketChannel, self).stop()
-
-    def call_handlers(self, since_last_heartbeat):
-        """This method is called in the ioloop thread when a message arrives.
-
-        Subclasses should override this method to handle incoming messages.
-        It is important to remember that this method is called in the thread
-        so that some logic must be done to ensure that the application leve
-        handlers are called in the application thread.
-        """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
-
-
-#-----------------------------------------------------------------------------
-# Main kernel manager class
-#-----------------------------------------------------------------------------
-
-class KernelManager(HasTraits):
-    """ Manages a kernel for a frontend.
-
-    The SUB channel is for the frontend to receive messages published by the
-    kernel.
-        
-    The REQ channel is for the frontend to make requests of the kernel.
-    
-    The REP channel is for the kernel to request stdin (raw_input) from the
-    frontend.
-    """
-    # The PyZMQ Context to use for communication with the kernel.
-    context = Instance(zmq.Context,(),{})
-
-    # The Session to use for communication with the kernel.
-    session = Instance(Session,(),{})
-
-    # The kernel process with which the KernelManager is communicating.
-    kernel = Instance(Popen)
-
-    # The addresses for the communication channels. 
-    xreq_address = TCPAddress((LOCALHOST, 0))
-    sub_address = TCPAddress((LOCALHOST, 0))
-    rep_address = TCPAddress((LOCALHOST, 0))
-    hb_address = TCPAddress((LOCALHOST, 0))
-
-    # The classes to use for the various channels.
-    xreq_channel_class = Type(XReqSocketChannel)
-    sub_channel_class = Type(SubSocketChannel)
-    rep_channel_class = Type(RepSocketChannel)
-    hb_channel_class = Type(HBSocketChannel)
-
-    # Protected traits.
-    _launch_args = Any
-    _xreq_channel = Any
-    _sub_channel = Any
-    _rep_channel = Any
-    _hb_channel = Any
-
-    def __init__(self, **kwargs):
-        super(KernelManager, self).__init__(**kwargs)
-        # Uncomment this to try closing the context.
-        # atexit.register(self.context.close)
-
-    #--------------------------------------------------------------------------
-    # Channel management methods:
-    #--------------------------------------------------------------------------
-
-    def start_channels(self, xreq=True, sub=True, rep=True, hb=True):
-        """Starts the channels for this kernel.
-
-        This will create the channels if they do not exist and then start
-        them. If port numbers of 0 are being used (random ports) then you
-        must first call :method:`start_kernel`. If the channels have been
-        stopped and you call this, :class:`RuntimeError` will be raised.
-        """
-        if xreq:
-            self.xreq_channel.start()
-        if sub:
-            self.sub_channel.start()
-        if rep:
-            self.rep_channel.start()
-        if hb:
-            self.hb_channel.start()
-
-    def stop_channels(self):
-        """Stops all the running channels for this kernel.
-        """
-        if self.xreq_channel.is_alive():
-            self.xreq_channel.stop()
-        if self.sub_channel.is_alive():
-            self.sub_channel.stop()
-        if self.rep_channel.is_alive():
-            self.rep_channel.stop()
-        if self.hb_channel.is_alive():
-            self.hb_channel.stop()
-
-    @property
-    def channels_running(self):
-        """Are any of the channels created and running?"""
-        return (self.xreq_channel.is_alive() or self.sub_channel.is_alive() or
-                self.rep_channel.is_alive() or self.hb_channel.is_alive())
-
-    #--------------------------------------------------------------------------
-    # Kernel process management methods:
-    #--------------------------------------------------------------------------
-
-    def start_kernel(self, **kw):
-        """Starts a kernel process and configures the manager to use it.
-
-        If random ports (port=0) are being used, this method must be called
-        before the channels are created.
-
-        Parameters:
-        -----------
-        ipython : bool, optional (default True)
-             Whether to use an IPython kernel instead of a plain Python kernel.
-
-        **kw : optional
-             See respective options for IPython and Python kernels.
-        """
-        xreq, sub, rep, hb = self.xreq_address, self.sub_address, \
-            self.rep_address, self.hb_address
-        if xreq[0] not in LOCAL_IPS or sub[0] not in LOCAL_IPS or \
-                rep[0] not in LOCAL_IPS or hb[0] not in LOCAL_IPS:
-            raise RuntimeError("Can only launch a kernel on a local interface. "
-                               "Make sure that the '*_address' attributes are "
-                               "configured properly. "
-                               "Currently valid addresses are: %s"%LOCAL_IPS
-                               )
-                    
-        self._launch_args = kw.copy()
-        if kw.pop('ipython', True):
-            from ipkernel import launch_kernel
-        else:
-            from pykernel import launch_kernel
-        self.kernel, xrep, pub, req, _hb = launch_kernel(
-            xrep_port=xreq[1], pub_port=sub[1], 
-            req_port=rep[1], hb_port=hb[1], **kw)
-        self.xreq_address = (xreq[0], xrep)
-        self.sub_address = (sub[0], pub)
-        self.rep_address = (rep[0], req)
-        self.hb_address = (hb[0], _hb)
-
-    def shutdown_kernel(self, restart=False):
-        """ Attempts to the stop the kernel process cleanly. If the kernel
-        cannot be stopped, it is killed, if possible.
-        """
-        # FIXME: Shutdown does not work on Windows due to ZMQ errors!
-        if sys.platform == 'win32':
-            self.kill_kernel()
-            return
-
-        # Pause the heart beat channel if it exists.
-        if self._hb_channel is not None:
-            self._hb_channel.pause()
-
-        # Don't send any additional kernel kill messages immediately, to give
-        # the kernel a chance to properly execute shutdown actions. Wait for at
-        # most 1s, checking every 0.1s.
-        self.xreq_channel.shutdown(restart=restart)
-        for i in range(10):
-            if self.is_alive:
-                time.sleep(0.1)
-            else:
-                break
-        else:
-            # OK, we've waited long enough.
-            if self.has_kernel:
-                self.kill_kernel()
-    
-    def restart_kernel(self, now=False, **kw):
-        """Restarts a kernel with the arguments that were used to launch it.
-        
-        If the old kernel was launched with random ports, the same ports will be
-        used for the new kernel.
-
-        Parameters
-        ----------
-        now : bool, optional
-            If True, the kernel is forcefully restarted *immediately*, without
-            having a chance to do any cleanup action.  Otherwise the kernel is
-            given 1s to clean up before a forceful restart is issued.
-
-            In all cases the kernel is restarted, the only difference is whether
-            it is given a chance to perform a clean shutdown or not.
-
-        **kw : optional
-            Any options specified here will replace those used to launch the
-            kernel.
-        """
-        if self._launch_args is None:
-            raise RuntimeError("Cannot restart the kernel. "
-                               "No previous call to 'start_kernel'.")
-        else:
-            # Stop currently running kernel.
-            if self.has_kernel:
-                if now:
-                    self.kill_kernel()
-                else:
-                    self.shutdown_kernel(restart=True)
-
-            # Start new kernel.
-            self._launch_args.update(kw)
-            self.start_kernel(**self._launch_args)
-
-            # FIXME: Messages get dropped in Windows due to probable ZMQ bug
-            # unless there is some delay here.
-            if sys.platform == 'win32':
-                time.sleep(0.2)
-
-    @property
-    def has_kernel(self):
-        """Returns whether a kernel process has been specified for the kernel
-        manager.
-        """
-        return self.kernel is not None
-
-    def kill_kernel(self):
-        """ Kill the running kernel. """
-        if self.has_kernel:
-            # Pause the heart beat channel if it exists.
-            if self._hb_channel is not None:
-                self._hb_channel.pause()
-
-            # Attempt to kill the kernel.
-            try:
-                self.kernel.kill()
-            except OSError, e:
-                # In Windows, we will get an Access Denied error if the process
-                # has already terminated. Ignore it.
-                if not (sys.platform == 'win32' and e.winerror == 5):
-                    raise
-            self.kernel = None
-        else:
-            raise RuntimeError("Cannot kill kernel. No kernel is running!")
-
-    def interrupt_kernel(self):
-        """ Interrupts the kernel. Unlike ``signal_kernel``, this operation is
-        well supported on all platforms.
-        """
-        if self.has_kernel:
-            if sys.platform == 'win32':
-                from parentpoller import ParentPollerWindows as Poller
-                Poller.send_interrupt(self.kernel.win32_interrupt_event)
-            else:
-                self.kernel.send_signal(signal.SIGINT)
-        else:
-            raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
-
-    def signal_kernel(self, signum):
-        """ Sends a signal to the kernel. Note that since only SIGTERM is
-        supported on Windows, this function is only useful on Unix systems.
-        """
-        if self.has_kernel:
-            self.kernel.send_signal(signum)
-        else:
-            raise RuntimeError("Cannot signal kernel. No kernel is running!")
-
-    @property
-    def is_alive(self):
-        """Is the kernel process still running?"""
-        # FIXME: not using a heartbeat means this method is broken for any
-        # remote kernel, it's only capable of handling local kernels.
-        if self.has_kernel:
-            if self.kernel.poll() is None:
-                return True
-            else:
-                return False
-        else:
-            # We didn't start the kernel with this KernelManager so we don't
-            # know if it is running. We should use a heartbeat for this case.
-            return True
-
-    #--------------------------------------------------------------------------
-    # Channels used for communication with the kernel:
-    #--------------------------------------------------------------------------
-
-    @property
-    def xreq_channel(self):
-        """Get the REQ socket channel object to make requests of the kernel."""
-        if self._xreq_channel is None:
-            self._xreq_channel = self.xreq_channel_class(self.context, 
-                                                         self.session,
-                                                         self.xreq_address)
-        return self._xreq_channel
-
-    @property
-    def sub_channel(self):
-        """Get the SUB socket channel object."""
-        if self._sub_channel is None:
-            self._sub_channel = self.sub_channel_class(self.context,
-                                                       self.session,
-                                                       self.sub_address)
-        return self._sub_channel
-
-    @property
-    def rep_channel(self):
-        """Get the REP socket channel object to handle stdin (raw_input)."""
-        if self._rep_channel is None:
-            self._rep_channel = self.rep_channel_class(self.context, 
-                                                       self.session,
-                                                       self.rep_address)
-        return self._rep_channel
-
-    @property
-    def hb_channel(self):
-        """Get the heartbeat socket channel object to check that the
-        kernel is alive."""
-        if self._hb_channel is None:
-            self._hb_channel = self.hb_channel_class(self.context, 
-                                                       self.session,
-                                                       self.hb_address)
-        return self._hb_channel
diff --git a/IPython/zmq/log.py b/IPython/zmq/log.py
deleted file mode 100644
index 6d372193e1d..00000000000
--- a/IPython/zmq/log.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import logging
-from logging import INFO, DEBUG, WARN, ERROR, FATAL
-
-import zmq
-from zmq.log.handlers import PUBHandler
-
-class EnginePUBHandler(PUBHandler):
-    """A simple PUBHandler subclass that sets root_topic"""
-    engine=None
-    
-    def __init__(self, engine, *args, **kwargs):
-        PUBHandler.__init__(self,*args, **kwargs)
-        self.engine = engine
-        
-    @property
-    def root_topic(self):
-        """this is a property, in case the handler is created
-        before the engine gets registered with an id"""
-        if isinstance(getattr(self.engine, 'id', None), int):
-            return "engine.%i"%self.engine.id
-        else:
-            return "engine"
-    
diff --git a/IPython/zmq/parentpoller.py b/IPython/zmq/parentpoller.py
deleted file mode 100644
index 5e0e009d516..00000000000
--- a/IPython/zmq/parentpoller.py
+++ /dev/null
@@ -1,125 +0,0 @@
-# Standard library imports.
-import ctypes
-import os
-import time
-from thread import interrupt_main
-from threading import Thread
-
-# Local imports.
-from IPython.utils.io import raw_print
-
-
-class ParentPollerUnix(Thread):
-    """ A Unix-specific daemon thread that terminates the program immediately 
-    when the parent process no longer exists.
-    """
-
-    def __init__(self):
-        super(ParentPollerUnix, self).__init__()
-        self.daemon = True
-    
-    def run(self):
-        # We cannot use os.waitpid because it works only for child processes.
-        from errno import EINTR
-        while True:
-            try:
-                if os.getppid() == 1:
-                    raw_print('Killed by parent poller!')
-                    os._exit(1)
-                time.sleep(1.0)
-            except OSError, e:
-                if e.errno == EINTR:
-                    continue
-                raise
-
-
-class ParentPollerWindows(Thread):
-    """ A Windows-specific daemon thread that listens for a special event that
-    signals an interrupt and, optionally, terminates the program immediately
-    when the parent process no longer exists.
-    """
-    
-    def __init__(self, interrupt_handle=None, parent_handle=None):
-        """ Create the poller. At least one of the optional parameters must be
-        provided.
-
-        Parameters:
-        -----------
-        interrupt_handle : HANDLE (int), optional
-            If provided, the program will generate a Ctrl+C event when this
-            handle is signaled.
-
-        parent_handle : HANDLE (int), optional
-            If provided, the program will terminate immediately when this 
-            handle is signaled.
-        """
-        assert(interrupt_handle or parent_handle)
-        super(ParentPollerWindows, self).__init__()
-        self.daemon = True
-        self.interrupt_handle = interrupt_handle
-        self.parent_handle = parent_handle
-
-    @staticmethod
-    def create_interrupt_event():
-        """ Create an interrupt event handle.
-
-        The parent process should use this static method for creating the
-        interrupt event that is passed to the child process. It should store
-        this handle and use it with ``send_interrupt`` to interrupt the child
-        process.
-        """
-        # Create a security attributes struct that permits inheritance of the
-        # handle by new processes.
-        # FIXME: We can clean up this mess by requiring pywin32 for IPython.
-        class SECURITY_ATTRIBUTES(ctypes.Structure):
-            _fields_ = [ ("nLength", ctypes.c_int), 
-                         ("lpSecurityDescriptor", ctypes.c_void_p), 
-                         ("bInheritHandle", ctypes.c_int) ]
-        sa = SECURITY_ATTRIBUTES()
-        sa_p = ctypes.pointer(sa)
-        sa.nLength = ctypes.sizeof(SECURITY_ATTRIBUTES)
-        sa.lpSecurityDescriptor = 0
-        sa.bInheritHandle = 1
-
-        return ctypes.windll.kernel32.CreateEventA(
-            sa_p,  # lpEventAttributes
-            False, # bManualReset
-            False, # bInitialState
-            '')    # lpName
-
-    @staticmethod
-    def send_interrupt(interrupt_handle):
-        """ Sends an interrupt event using the specified handle.
-        """
-        ctypes.windll.kernel32.SetEvent(interrupt_handle)
-
-    def run(self):
-        """ Run the poll loop. This method never returns.
-        """
-        from _subprocess import WAIT_OBJECT_0, INFINITE
-
-        # Build the list of handle to listen on.
-        handles = []
-        if self.interrupt_handle:
-            handles.append(self.interrupt_handle)
-        if self.parent_handle:
-            handles.append(self.parent_handle)
-
-        # Listen forever.
-        while True:
-            result = ctypes.windll.kernel32.WaitForMultipleObjects(
-                len(handles),                            # nCount
-                (ctypes.c_int * len(handles))(*handles), # lpHandles
-                False,                                   # bWaitAll
-                INFINITE)                                # dwMilliseconds
-
-            if WAIT_OBJECT_0 <= result < len(handles):
-                handle = handles[result - WAIT_OBJECT_0]
-
-                if handle == self.interrupt_handle:
-                    raw_print('Interrupted by parent poller!')
-                    interrupt_main()
-
-                elif handle == self.parent_handle:
-                    raw_print('Killed by parent poller!')
-                    os._exit(1)
diff --git a/IPython/zmq/pykernel.py b/IPython/zmq/pykernel.py
deleted file mode 100755
index b48e99d5a9b..00000000000
--- a/IPython/zmq/pykernel.py
+++ /dev/null
@@ -1,300 +0,0 @@
-#!/usr/bin/env python
-"""A simple interactive kernel that talks to a frontend over 0MQ.
-
-Things to do:
-
-* Implement `set_parent` logic. Right before doing exec, the Kernel should
-  call set_parent on all the PUB objects with the message about to be executed.
-* Implement random port and security key logic.
-* Implement control messages.
-* Implement event loop and poll version.
-"""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Standard library imports.
-import __builtin__
-from code import CommandCompiler
-import sys
-import time
-import traceback
-
-# System library imports.
-import zmq
-
-# Local imports.
-from IPython.utils.traitlets import HasTraits, Instance
-from completer import KernelCompleter
-from entry_point import base_launch_kernel, make_default_main
-from session import Session, Message
-
-#-----------------------------------------------------------------------------
-# Main kernel class
-#-----------------------------------------------------------------------------
-
-class Kernel(HasTraits):
-
-    # Private interface
-
-    # This is a dict of port number that the kernel is listening on. It is set
-    # by record_ports and used by connect_request.
-    _recorded_ports = None
-
-    #---------------------------------------------------------------------------
-    # Kernel interface
-    #---------------------------------------------------------------------------
-
-    session = Instance(Session)
-    reply_socket = Instance('zmq.Socket')
-    pub_socket = Instance('zmq.Socket')
-    req_socket = Instance('zmq.Socket')
-
-    def __init__(self, **kwargs):
-        super(Kernel, self).__init__(**kwargs)
-        self.user_ns = {}
-        self.history = []
-        self.compiler = CommandCompiler()
-        self.completer = KernelCompleter(self.user_ns)
-
-        # Build dict of handlers for message types
-        msg_types = [ 'execute_request', 'complete_request', 
-                      'object_info_request', 'shutdown_request' ]
-        self.handlers = {}
-        for msg_type in msg_types:
-            self.handlers[msg_type] = getattr(self, msg_type)
-
-    def start(self):
-        """ Start the kernel main loop.
-        """
-        while True:
-            ident,msg = self.session.recv(self.reply_socket,0)
-            assert ident is not None, "Missing message part."
-            omsg = Message(msg)
-            print>>sys.__stdout__
-            print>>sys.__stdout__, omsg
-            handler = self.handlers.get(omsg.msg_type, None)
-            if handler is None:
-                print >> sys.__stderr__, "UNKNOWN MESSAGE TYPE:", omsg
-            else:
-                handler(ident, omsg)
-
-    def record_ports(self, xrep_port, pub_port, req_port, hb_port):
-        """Record the ports that this kernel is using.
-
-        The creator of the Kernel instance must call this methods if they
-        want the :meth:`connect_request` method to return the port numbers.
-        """
-        self._recorded_ports = {
-            'xrep_port' : xrep_port,
-            'pub_port' : pub_port,
-            'req_port' : req_port,
-            'hb_port' : hb_port
-        }
-
-    #---------------------------------------------------------------------------
-    # Kernel request handlers
-    #---------------------------------------------------------------------------
-
-    def execute_request(self, ident, parent):
-        try:
-            code = parent[u'content'][u'code']
-        except:
-            print>>sys.__stderr__, "Got bad msg: "
-            print>>sys.__stderr__, Message(parent)
-            return
-        pyin_msg = self.session.send(self.pub_socket, u'pyin',{u'code':code}, parent=parent)
-
-        try:
-            comp_code = self.compiler(code, '<zmq-kernel>')
-
-            # Replace raw_input. Note that is not sufficient to replace 
-            # raw_input in the user namespace.
-            raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
-            __builtin__.raw_input = raw_input
-
-            # Set the parent message of the display hook and out streams.
-            sys.displayhook.set_parent(parent)
-            sys.stdout.set_parent(parent)
-            sys.stderr.set_parent(parent)
-
-            exec comp_code in self.user_ns, self.user_ns
-        except:
-            etype, evalue, tb = sys.exc_info()
-            tb = traceback.format_exception(etype, evalue, tb)
-            exc_content = {
-                u'status' : u'error',
-                u'traceback' : tb,
-                u'ename' : unicode(etype.__name__),
-                u'evalue' : unicode(evalue)
-            }
-            exc_msg = self.session.send(self.pub_socket, u'pyerr', exc_content, parent)
-            reply_content = exc_content
-        else:
-            reply_content = { 'status' : 'ok', 'payload' : {} }
-            
-        # Flush output before sending the reply.
-        sys.stderr.flush()
-        sys.stdout.flush()
-
-        # Send the reply.
-        reply_msg = self.session.send(self.reply_socket, u'execute_reply', reply_content, parent, ident=ident)
-        print>>sys.__stdout__, Message(reply_msg)
-        if reply_msg['content']['status'] == u'error':
-            self._abort_queue()
-
-    def complete_request(self, ident, parent):
-        matches = {'matches' : self._complete(parent),
-                   'status' : 'ok'}
-        completion_msg = self.session.send(self.reply_socket, 'complete_reply',
-                                           matches, parent, ident)
-        print >> sys.__stdout__, completion_msg
-
-    def object_info_request(self, ident, parent):
-        context = parent['content']['oname'].split('.')
-        object_info = self._object_info(context)
-        msg = self.session.send(self.reply_socket, 'object_info_reply',
-                                object_info, parent, ident)
-        print >> sys.__stdout__, msg
-
-    def shutdown_request(self, ident, parent):
-        content = dict(parent['content'])
-        msg = self.session.send(self.reply_socket, 'shutdown_reply',
-                                content, parent, ident)
-        msg = self.session.send(self.pub_socket, 'shutdown_reply',
-                                content, parent, ident)
-        print >> sys.__stdout__, msg
-        time.sleep(0.1)
-        sys.exit(0)
-
-    #---------------------------------------------------------------------------
-    # Protected interface
-    #---------------------------------------------------------------------------
-
-    def _abort_queue(self):
-        while True:
-            try:
-                ident,msg = self.session.recv(self.reply_socket, zmq.NOBLOCK)
-            except zmq.ZMQError, e:
-                if e.errno == zmq.EAGAIN:
-                    break
-            else:
-                assert ident is not None, "Missing message part."
-            print>>sys.__stdout__, "Aborting:"
-            print>>sys.__stdout__, Message(msg)
-            msg_type = msg['msg_type']
-            reply_type = msg_type.split('_')[0] + '_reply'
-            reply_msg = self.session.send(self.reply_socket, reply_type, {'status':'aborted'}, msg, ident=ident)
-            print>>sys.__stdout__, Message(reply_msg)
-            # We need to wait a bit for requests to come in. This can probably
-            # be set shorter for true asynchronous clients.
-            time.sleep(0.1)
-
-    def _raw_input(self, prompt, ident, parent):
-        # Flush output before making the request.
-        sys.stderr.flush()
-        sys.stdout.flush()
-
-        # Send the input request.
-        content = dict(prompt=prompt)
-        msg = self.session.send(self.req_socket, u'input_request', content, parent)
-
-        # Await a response.
-        ident,reply = self.session.recv(self.req_socket, 0)
-        try:
-            value = reply['content']['value']
-        except:
-            print>>sys.__stderr__, "Got bad raw_input reply: "
-            print>>sys.__stderr__, Message(parent)
-            value = ''
-        return value
-
-    def _complete(self, msg):
-        return self.completer.complete(msg.content.line, msg.content.text)
-
-    def _object_info(self, context):
-        symbol, leftover = self._symbol_from_context(context)
-        if symbol is not None and not leftover:
-            doc = getattr(symbol, '__doc__', '')
-        else:
-            doc = ''
-        object_info = dict(docstring = doc)
-        return object_info
-
-    def _symbol_from_context(self, context):
-        if not context:
-            return None, context
-
-        base_symbol_string = context[0]
-        symbol = self.user_ns.get(base_symbol_string, None)
-        if symbol is None:
-            symbol = __builtin__.__dict__.get(base_symbol_string, None)
-        if symbol is None:
-            return None, context
-
-        context = context[1:]
-        for i, name in enumerate(context):
-            new_symbol = getattr(symbol, name, None)
-            if new_symbol is None:
-                return symbol, context[i:]
-            else:
-                symbol = new_symbol
-
-        return symbol, []
-
-#-----------------------------------------------------------------------------
-# Kernel main and launch functions
-#-----------------------------------------------------------------------------
-
-def launch_kernel(ip=None, xrep_port=0, pub_port=0, req_port=0, hb_port=0,
-                  executable=None, independent=False):
-    """ Launches a localhost kernel, binding to the specified ports.
-
-    Parameters
-    ----------
-    ip  : str, optional
-        The ip address the kernel will bind to.
-    
-    xrep_port : int, optional
-        The port to use for XREP channel.
-
-    pub_port : int, optional
-        The port to use for the SUB channel.
-
-    req_port : int, optional
-        The port to use for the REQ (raw input) channel.
-
-    hb_port : int, optional
-        The port to use for the hearbeat REP channel.
-
-    executable : str, optional (default sys.executable)
-        The Python executable to use for the kernel process.
-
-    independent : bool, optional (default False) 
-        If set, the kernel process is guaranteed to survive if this process
-        dies. If not set, an effort is made to ensure that the kernel is killed
-        when this process dies. Note that in this case it is still good practice
-        to kill kernels manually before exiting.
-
-    Returns
-    -------
-    A tuple of form:
-        (kernel_process, xrep_port, pub_port, req_port)
-    where kernel_process is a Popen object and the ports are integers.
-    """
-    extra_arguments = []
-    if ip is not None:
-        extra_arguments.append('--ip')
-        if isinstance(ip, basestring):
-            extra_arguments.append(ip)
-    
-    return base_launch_kernel('from IPython.zmq.pykernel import main; main()',
-                              xrep_port, pub_port, req_port, hb_port,
-                              executable, independent,
-                              extra_arguments=extra_arguments)
-
-main = make_default_main(Kernel)
-
-if __name__ == '__main__':
-    main()
diff --git a/IPython/zmq/pylab/__init__.py b/IPython/zmq/pylab/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/zmq/pylab/backend_inline.py b/IPython/zmq/pylab/backend_inline.py
deleted file mode 100644
index 5eb90916ae2..00000000000
--- a/IPython/zmq/pylab/backend_inline.py
+++ /dev/null
@@ -1,81 +0,0 @@
-"""Produce SVG versions of active plots for display by the rich Qt frontend.
-"""
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Standard library imports
-import sys
-
-# Third-party imports
-import matplotlib
-from matplotlib.backends.backend_svg import new_figure_manager
-from matplotlib._pylab_helpers import Gcf
-
-# Local imports.
-from IPython.core.displaypub import publish_display_data
-from IPython.lib.pylabtools import figure_to_svg
-
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-
-def show(close=True):
-    """Show all figures as SVG payloads sent to the IPython clients.
-
-    Parameters
-    ----------
-    close : bool, optional
-      If true, a ``plt.close('all')`` call is automatically issued after
-      sending all the SVG figures. If this is set, the figures will entirely
-      removed from the internal list of figures.
-    """
-    for figure_manager in Gcf.get_all_fig_managers():
-        send_svg_figure(figure_manager.canvas.figure)
-    if close:
-        matplotlib.pyplot.close('all')
-
-
-# This flag will be reset by draw_if_interactive when called
-show._draw_called = False
-
-
-def draw_if_interactive():
-    """
-    Is called after every pylab drawing command
-    """
-    # We simply flag we were called and otherwise do nothing.  At the end of
-    # the code execution, a separate call to show_close() will act upon this.
-    show._draw_called = True
-
-
-def flush_svg():
-    """Call show, close all open figures, sending all SVG images.
-
-    This is meant to be called automatically and will call show() if, during
-    prior code execution, there had been any calls to draw_if_interactive.
-    """
-    if show._draw_called:
-        show()
-        show._draw_called = False
-
-
-def send_svg_figure(fig):
-    """Draw the current figure and send it as an SVG payload.
-    """
-    # For an empty figure, don't even bother calling figure_to_svg, to avoid
-    # big blank spaces in the qt console
-    if not fig.axes:
-        return
-
-    svg = figure_to_svg(fig)
-    # flush text streams before sending figures, helps a little with output
-    # synchronization in the console (though it's a bandaid, not a real sln)
-    sys.stdout.flush(); sys.stderr.flush()
-    publish_display_data(
-        'IPython.zmq.pylab.backend_inline.send_svg_figure',
-        'Matplotlib Plot',
-        {'image/svg+xml' : svg}
-    )
-
diff --git a/IPython/zmq/session.py b/IPython/zmq/session.py
deleted file mode 100644
index 0fcb1949ed4..00000000000
--- a/IPython/zmq/session.py
+++ /dev/null
@@ -1,184 +0,0 @@
-import os
-import uuid
-import pprint
-
-import zmq
-
-from zmq.utils import jsonapi as json
-
-class Message(object):
-    """A simple message object that maps dict keys to attributes.
-
-    A Message can be created from a dict and a dict from a Message instance
-    simply by calling dict(msg_obj)."""
-    
-    def __init__(self, msg_dict):
-        dct = self.__dict__
-        for k, v in msg_dict.iteritems():
-            if isinstance(v, dict):
-                v = Message(v)
-            dct[k] = v
-
-    # Having this iterator lets dict(msg_obj) work out of the box.
-    def __iter__(self):
-        return iter(self.__dict__.iteritems())
-    
-    def __repr__(self):
-        return repr(self.__dict__)
-
-    def __str__(self):
-        return pprint.pformat(self.__dict__)
-
-    def __contains__(self, k):
-        return k in self.__dict__
-
-    def __getitem__(self, k):
-        return self.__dict__[k]
-
-
-def msg_header(msg_id, username, session):
-    return {
-        'msg_id' : msg_id,
-        'username' : username,
-        'session' : session
-    }
-
-
-def extract_header(msg_or_header):
-    """Given a message or header, return the header."""
-    if not msg_or_header:
-        return {}
-    try:
-        # See if msg_or_header is the entire message.
-        h = msg_or_header['header']
-    except KeyError:
-        try:
-            # See if msg_or_header is just the header
-            h = msg_or_header['msg_id']
-        except KeyError:
-            raise
-        else:
-            h = msg_or_header
-    if not isinstance(h, dict):
-        h = dict(h)
-    return h
-
-
-class Session(object):
-
-    def __init__(self, username=os.environ.get('USER','username'), session=None):
-        self.username = username
-        if session is None:
-            self.session = str(uuid.uuid4())
-        else:
-            self.session = session
-        self.msg_id = 0
-
-    def msg_header(self):
-        h = msg_header(self.msg_id, self.username, self.session)
-        self.msg_id += 1
-        return h
-
-    def msg(self, msg_type, content=None, parent=None):
-        """Construct a standard-form message, with a given type, content, and parent.
-        
-        NOT to be called directly.
-        """
-        msg = {}
-        msg['header'] = self.msg_header()
-        msg['parent_header'] = {} if parent is None else extract_header(parent)
-        msg['msg_type'] = msg_type
-        msg['content'] = {} if content is None else content
-        return msg
-
-    def send(self, socket, msg_or_type, content=None, parent=None, ident=None):
-        """send a message via a socket, using a uniform message pattern.
-        
-        Parameters
-        ----------
-        socket : zmq.Socket
-            The socket on which to send.
-        msg_or_type : Message/dict or str
-            if str : then a new message will be constructed from content,parent
-            if Message/dict : then content and parent are ignored, and the message
-                is sent.  This is only for use when sending a Message for a second time.
-        content : dict, optional
-            The contents of the message
-        parent : dict, optional
-            The parent header, or parent message, of this message
-        ident : bytes, optional
-            The zmq.IDENTITY prefix of the destination.
-            Only for use on certain socket types.
-        
-        Returns
-        -------
-        msg : dict
-            The message, as constructed by self.msg(msg_type,content,parent)
-        """
-        if isinstance(msg_or_type, (Message, dict)):
-            msg = dict(msg_or_type)
-        else:
-            msg = self.msg(msg_or_type, content, parent)
-        if ident is not None:
-            socket.send(ident, zmq.SNDMORE)
-        socket.send_json(msg)
-        return msg
-    
-    def recv(self, socket, mode=zmq.NOBLOCK):
-        """recv a message on a socket.
-        
-        Receive an optionally identity-prefixed message, as sent via session.send().
-        
-        Parameters
-        ----------
-        
-        socket : zmq.Socket
-            The socket on which to recv a message.
-        mode : int, optional
-            the mode flag passed to socket.recv
-            default: zmq.NOBLOCK
-        
-        Returns
-        -------
-        (ident,msg) : tuple
-            always length 2. If no message received, then return is (None,None)
-        ident : bytes or None
-                the identity prefix is there was one, None otherwise.
-        msg : dict or None
-                The actual message.  If mode==zmq.NOBLOCK and no message was waiting,
-                it will be None.
-        """
-        try:
-            msg = socket.recv_multipart(mode)
-        except zmq.ZMQError, e:
-            if e.errno == zmq.EAGAIN:
-                # We can convert EAGAIN to None as we know in this case
-                # recv_json won't return None.
-                return None,None
-            else:
-                raise
-        if len(msg) == 1:
-            ident=None
-            msg = msg[0]
-        elif len(msg) == 2:
-            ident, msg = msg
-        else:
-            raise ValueError("Got message with length > 2, which is invalid")
-        
-        return ident, json.loads(msg)
-
-def test_msg2obj():
-    am = dict(x=1)
-    ao = Message(am)
-    assert ao.x == am['x']
-
-    am['y'] = dict(z=1)
-    ao = Message(am)
-    assert ao.y.z == am['y']['z']
-    
-    k1, k2 = 'y', 'z'
-    assert ao[k1][k2] == am[k1][k2]
-    
-    am2 = dict(ao)
-    assert am['x'] == am2['x']
-    assert am['y']['z'] == am2['y']['z']
diff --git a/IPython/zmq/tests/__init__.py b/IPython/zmq/tests/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/IPython/zmq/tests/test_message_spec.py b/IPython/zmq/tests/test_message_spec.py
deleted file mode 100644
index 817113fda59..00000000000
--- a/IPython/zmq/tests/test_message_spec.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""Test suite for our zeromq-based messaging specification.
-"""
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING.txt, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-import sys
-import time
-
-import nose.tools as nt
-
-from ..blockingkernelmanager import BlockingKernelManager
-
-from IPython.utils import io
-
-def setup():
-    global KM
-    KM = BlockingKernelManager()
-
-    KM.start_kernel()
-    KM.start_channels()
-    # Give the kernel a chance to come up.
-    time.sleep(1)
-
-def teardown():
-    io.rprint('Entering teardown...')  # dbg
-    io.rprint('Stopping channels and kernel...')  # dbg
-    KM.stop_channels()
-    KM.kill_kernel()
-
-
-# Actual tests
-
-def test_execute():
-    KM.xreq_channel.execute(code='x=1')
-    KM.xreq_channel.execute(code='print 1')
-    
diff --git a/IPython/zmq/zmqshell.py b/IPython/zmq/zmqshell.py
deleted file mode 100644
index 879344197eb..00000000000
--- a/IPython/zmq/zmqshell.py
+++ /dev/null
@@ -1,601 +0,0 @@
-"""A ZMQ-based subclass of InteractiveShell.
-
-This code is meant to ease the refactoring of the base InteractiveShell into
-something with a cleaner architecture for 2-process use, without actually
-breaking InteractiveShell itself.  So we're doing something a bit ugly, where
-we subclass and override what we want to fix.  Once this is working well, we
-can go back to the base class and refactor the code for a cleaner inheritance
-implementation that doesn't rely on so much monkeypatching.
-
-But this lets us maintain a fully working IPython as we develop the new
-machinery.  This should thus be thought of as scaffolding.
-"""
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# Stdlib
-import inspect
-import os
-
-# Our own
-from IPython.core.interactiveshell import (
-    InteractiveShell, InteractiveShellABC
-)
-from IPython.core import page
-from IPython.core.autocall import ZMQExitAutocall
-from IPython.core.displayhook import DisplayHook
-from IPython.core.displaypub import DisplayPublisher
-from IPython.core.macro import Macro
-from IPython.core.payloadpage import install_payload_page
-from IPython.utils import io
-from IPython.utils.path import get_py_filename
-from IPython.utils.traitlets import Instance, Type, Dict
-from IPython.utils.warn import warn
-from IPython.zmq.session import extract_header
-from session import Session
-
-#-----------------------------------------------------------------------------
-# Globals and side-effects
-#-----------------------------------------------------------------------------
-
-# Install the payload version of page.
-install_payload_page()
-
-#-----------------------------------------------------------------------------
-# Functions and classes
-#-----------------------------------------------------------------------------
-
-class ZMQDisplayHook(DisplayHook):
-    """A displayhook subclass that publishes data using ZeroMQ."""
-
-    session = Instance(Session)
-    pub_socket = Instance('zmq.Socket')
-    parent_header = Dict({})
-
-    def set_parent(self, parent):
-        """Set the parent for outbound messages."""
-        self.parent_header = extract_header(parent)
-
-    def start_displayhook(self):
-        self.msg = self.session.msg(u'pyout', {}, parent=self.parent_header)
-
-    def write_output_prompt(self):
-        """Write the output prompt."""
-        if self.do_full_cache:
-            self.msg['content']['execution_count'] = self.prompt_count
-
-    def write_format_data(self, format_dict):
-        self.msg['content']['data'] = format_dict
-
-    def finish_displayhook(self):
-        """Finish up all displayhook activities."""
-        self.session.send(self.pub_socket, self.msg)
-        self.msg = None
-
-
-class ZMQDisplayPublisher(DisplayPublisher):
-    """A display publisher that publishes data using a ZeroMQ PUB socket."""
-
-    session = Instance(Session)
-    pub_socket = Instance('zmq.Socket')
-    parent_header = Dict({})
-
-    def set_parent(self, parent):
-        """Set the parent for outbound messages."""
-        self.parent_header = extract_header(parent)
-
-    def publish(self, source, data, metadata=None):
-        if metadata is None:
-            metadata = {}
-        self._validate_data(source, data, metadata)
-        content = {}
-        content['source'] = source
-        content['data'] = data
-        content['metadata'] = metadata
-        self.session.send(
-            self.pub_socket, u'display_data', content,
-            parent=self.parent_header
-        )
-
-
-class ZMQInteractiveShell(InteractiveShell):
-    """A subclass of InteractiveShell for ZMQ."""
-
-    displayhook_class = Type(ZMQDisplayHook)
-    display_pub_class = Type(ZMQDisplayPublisher)
-    
-    exiter = Instance(ZMQExitAutocall)
-    def _exiter_default(self):
-        return ZMQExitAutocall(self)
-
-    keepkernel_on_exit = None
-
-    def init_environment(self):
-        """Configure the user's environment.
-
-        """
-        env = os.environ
-        # These two ensure 'ls' produces nice coloring on BSD-derived systems
-        env['TERM'] = 'xterm-color'
-        env['CLICOLOR'] = '1'
-        # Since normal pagers don't work at all (over pexpect we don't have
-        # single-key control of the subprocess), try to disable paging in
-        # subprocesses as much as possible.
-        env['PAGER'] = 'cat'
-        env['GIT_PAGER'] = 'cat'
-
-    def auto_rewrite_input(self, cmd):
-        """Called to show the auto-rewritten input for autocall and friends.
-
-        FIXME: this payload is currently not correctly processed by the
-        frontend.
-        """
-        new = self.displayhook.prompt1.auto_rewrite() + cmd
-        payload = dict(
-            source='IPython.zmq.zmqshell.ZMQInteractiveShell.auto_rewrite_input',
-            transformed_input=new,
-            )
-        self.payload_manager.write_payload(payload)
-        
-    def ask_exit(self):
-        """Engage the exit actions."""
-        payload = dict(
-            source='IPython.zmq.zmqshell.ZMQInteractiveShell.ask_exit',
-            exit=True,
-            keepkernel=self.keepkernel_on_exit,
-            )
-        self.payload_manager.write_payload(payload)
-
-    def _showtraceback(self, etype, evalue, stb):
-
-        exc_content = {
-            u'traceback' : stb,
-            u'ename' : unicode(etype.__name__),
-            u'evalue' : unicode(evalue)
-        }
-
-        dh = self.displayhook
-        # Send exception info over pub socket for other clients than the caller
-        # to pick up
-        exc_msg = dh.session.send(dh.pub_socket, u'pyerr', exc_content, dh.parent_header)
-
-        # FIXME - Hack: store exception info in shell object.  Right now, the
-        # caller is reading this info after the fact, we need to fix this logic
-        # to remove this hack.  Even uglier, we need to store the error status
-        # here, because in the main loop, the logic that sets it is being
-        # skipped because runlines swallows the exceptions.
-        exc_content[u'status'] = u'error'
-        self._reply_content = exc_content
-        # /FIXME
-        
-        return exc_content
-
-    #------------------------------------------------------------------------
-    # Magic overrides
-    #------------------------------------------------------------------------
-    # Once the base class stops inheriting from magic, this code needs to be
-    # moved into a separate machinery as well.  For now, at least isolate here
-    # the magics which this class needs to implement differently from the base
-    # class, or that are unique to it.
-
-    def magic_doctest_mode(self,parameter_s=''):
-        """Toggle doctest mode on and off.
-
-        This mode is intended to make IPython behave as much as possible like a
-        plain Python shell, from the perspective of how its prompts, exceptions
-        and output look.  This makes it easy to copy and paste parts of a
-        session into doctests.  It does so by:
-
-        - Changing the prompts to the classic ``>>>`` ones.
-        - Changing the exception reporting mode to 'Plain'.
-        - Disabling pretty-printing of output.
-
-        Note that IPython also supports the pasting of code snippets that have
-        leading '>>>' and '...' prompts in them.  This means that you can paste
-        doctests from files or docstrings (even if they have leading
-        whitespace), and the code will execute correctly.  You can then use
-        '%history -t' to see the translated history; this will give you the
-        input after removal of all the leading prompts and whitespace, which
-        can be pasted back into an editor.
-
-        With these features, you can switch into this mode easily whenever you
-        need to do testing and changes to doctests, without having to leave
-        your existing IPython session.
-        """
-
-        from IPython.utils.ipstruct import Struct
-
-        # Shorthands
-        shell = self.shell
-        disp_formatter = self.shell.display_formatter
-        ptformatter = disp_formatter.formatters['text/plain']
-        # dstore is a data store kept in the instance metadata bag to track any
-        # changes we make, so we can undo them later.
-        dstore = shell.meta.setdefault('doctest_mode', Struct())
-        save_dstore = dstore.setdefault
-
-        # save a few values we'll need to recover later
-        mode = save_dstore('mode', False)
-        save_dstore('rc_pprint', ptformatter.pprint)
-        save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
-        save_dstore('xmode', shell.InteractiveTB.mode)
-        
-        if mode == False:
-            # turn on
-            ptformatter.pprint = False
-            disp_formatter.plain_text_only = True
-            shell.magic_xmode('Plain')
-        else:
-            # turn off
-            ptformatter.pprint = dstore.rc_pprint
-            disp_formatter.plain_text_only = dstore.rc_plain_text_only
-            shell.magic_xmode(dstore.xmode)
-
-        # Store new mode and inform on console
-        dstore.mode = bool(1-int(mode))
-        mode_label = ['OFF','ON'][dstore.mode]
-        print('Doctest mode is:', mode_label)
-        
-        # Send the payload back so that clients can modify their prompt display
-        payload = dict(
-            source='IPython.zmq.zmqshell.ZMQInteractiveShell.magic_doctest_mode',
-            mode=dstore.mode)
-        self.payload_manager.write_payload(payload)
-
-    def magic_edit(self,parameter_s='',last_call=['','']):
-        """Bring up an editor and execute the resulting code.
-
-        Usage:
-          %edit [options] [args]
-
-        %edit runs IPython's editor hook.  The default version of this hook is
-        set to call the __IPYTHON__.rc.editor command.  This is read from your
-        environment variable $EDITOR.  If this isn't found, it will default to
-        vi under Linux/Unix and to notepad under Windows.  See the end of this
-        docstring for how to change the editor hook.
-
-        You can also set the value of this editor via the command line option
-        '-editor' or in your ipythonrc file. This is useful if you wish to use
-        specifically for IPython an editor different from your typical default
-        (and for Windows users who typically don't set environment variables).
-
-        This command allows you to conveniently edit multi-line code right in
-        your IPython session.
-        
-        If called without arguments, %edit opens up an empty editor with a
-        temporary file and will execute the contents of this file when you
-        close it (don't forget to save it!).
-
-
-        Options:
-
-        -n <number>: open the editor at a specified line number.  By default,
-        the IPython editor hook uses the unix syntax 'editor +N filename', but
-        you can configure this by providing your own modified hook if your
-        favorite editor supports line-number specifications with a different
-        syntax.
-        
-        -p: this will call the editor with the same data as the previous time
-        it was used, regardless of how long ago (in your current session) it
-        was.
-
-        -r: use 'raw' input.  This option only applies to input taken from the
-        user's history.  By default, the 'processed' history is used, so that
-        magics are loaded in their transformed version to valid Python.  If
-        this option is given, the raw input as typed as the command line is
-        used instead.  When you exit the editor, it will be executed by
-        IPython's own processor.
-        
-        -x: do not execute the edited code immediately upon exit. This is
-        mainly useful if you are editing programs which need to be called with
-        command line arguments, which you can then do using %run.
-
-
-        Arguments:
-
-        If arguments are given, the following possibilites exist:
-
-        - The arguments are numbers or pairs of colon-separated numbers (like
-        1 4:8 9). These are interpreted as lines of previous input to be
-        loaded into the editor. The syntax is the same of the %macro command.
-
-        - If the argument doesn't start with a number, it is evaluated as a
-        variable and its contents loaded into the editor. You can thus edit
-        any string which contains python code (including the result of
-        previous edits).
-
-        - If the argument is the name of an object (other than a string),
-        IPython will try to locate the file where it was defined and open the
-        editor at the point where it is defined. You can use `%edit function`
-        to load an editor exactly at the point where 'function' is defined,
-        edit it and have the file be executed automatically.
-
-        If the object is a macro (see %macro for details), this opens up your
-        specified editor with a temporary file containing the macro's data.
-        Upon exit, the macro is reloaded with the contents of the file.
-
-        Note: opening at an exact line is only supported under Unix, and some
-        editors (like kedit and gedit up to Gnome 2.8) do not understand the
-        '+NUMBER' parameter necessary for this feature. Good editors like
-        (X)Emacs, vi, jed, pico and joe all do.
-
-        - If the argument is not found as a variable, IPython will look for a
-        file with that name (adding .py if necessary) and load it into the
-        editor. It will execute its contents with execfile() when you exit,
-        loading any code in the file into your interactive namespace.
-
-        After executing your code, %edit will return as output the code you
-        typed in the editor (except when it was an existing file). This way
-        you can reload the code in further invocations of %edit as a variable,
-        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
-        the output.
-
-        Note that %edit is also available through the alias %ed.
-
-        This is an example of creating a simple function inside the editor and
-        then modifying it. First, start up the editor:
-
-        In [1]: ed
-        Editing... done. Executing edited code...
-        Out[1]: 'def foo():n    print "foo() was defined in an editing session"n'
-
-        We can then call the function foo():
-        
-        In [2]: foo()
-        foo() was defined in an editing session
-
-        Now we edit foo.  IPython automatically loads the editor with the
-        (temporary) file where foo() was previously defined:
-        
-        In [3]: ed foo
-        Editing... done. Executing edited code...
-
-        And if we call foo() again we get the modified version:
-        
-        In [4]: foo()
-        foo() has now been changed!
-
-        Here is an example of how to edit a code snippet successive
-        times. First we call the editor:
-
-        In [5]: ed
-        Editing... done. Executing edited code...
-        hello
-        Out[5]: "print 'hello'n"
-
-        Now we call it again with the previous output (stored in _):
-
-        In [6]: ed _
-        Editing... done. Executing edited code...
-        hello world
-        Out[6]: "print 'hello world'n"
-
-        Now we call it with the output #8 (stored in _8, also as Out[8]):
-
-        In [7]: ed _8
-        Editing... done. Executing edited code...
-        hello again
-        Out[7]: "print 'hello again'n"
-
-
-        Changing the default editor hook:
-
-        If you wish to write your own editor hook, you can put it in a
-        configuration file which you load at startup time.  The default hook
-        is defined in the IPython.core.hooks module, and you can use that as a
-        starting example for further modifications.  That file also has
-        general instructions on how to set a new hook for use once you've
-        defined it."""
-        
-        # FIXME: This function has become a convoluted mess.  It needs a
-        # ground-up rewrite with clean, simple logic.
-
-        def make_filename(arg):
-            "Make a filename from the given args"
-            try:
-                filename = get_py_filename(arg)
-            except IOError:
-                if args.endswith('.py'):
-                    filename = arg
-                else:
-                    filename = None
-            return filename
-
-        # custom exceptions
-        class DataIsObject(Exception): pass
-
-        opts,args = self.parse_options(parameter_s,'prn:')
-        # Set a few locals from the options for convenience:
-        opts_p = opts.has_key('p')
-        opts_r = opts.has_key('r')
-        
-        # Default line number value
-        lineno = opts.get('n',None)
-        if lineno is not None:
-            try:
-                lineno = int(lineno)
-            except:
-                warn("The -n argument must be an integer.")
-                return
-
-        if opts_p:
-            args = '_%s' % last_call[0]
-            if not self.shell.user_ns.has_key(args):
-                args = last_call[1]
-            
-        # use last_call to remember the state of the previous call, but don't
-        # let it be clobbered by successive '-p' calls.
-        try:
-            last_call[0] = self.shell.displayhook.prompt_count
-            if not opts_p:
-                last_call[1] = parameter_s
-        except:
-            pass
-
-        # by default this is done with temp files, except when the given
-        # arg is a filename
-        use_temp = True
-
-        data = ''
-        if args[0].isdigit():
-            # Mode where user specifies ranges of lines, like in %macro.
-            # This means that you can't edit files whose names begin with
-            # numbers this way. Tough.
-            ranges = args.split()
-            data = ''.join(self.extract_input_slices(ranges,opts_r))
-        elif args.endswith('.py'):
-            filename = make_filename(args)
-            use_temp = False
-        elif args:
-            try:
-                # Load the parameter given as a variable. If not a string,
-                # process it as an object instead (below)
-
-                #print '*** args',args,'type',type(args)  # dbg
-                data = eval(args, self.shell.user_ns)
-                if not isinstance(data, basestring):
-                    raise DataIsObject
-
-            except (NameError,SyntaxError):
-                # given argument is not a variable, try as a filename
-                filename = make_filename(args)
-                if filename is None:
-                    warn("Argument given (%s) can't be found as a variable "
-                         "or as a filename." % args)
-                    return
-                use_temp = False
-                
-            except DataIsObject:
-                # macros have a special edit function
-                if isinstance(data, Macro):
-                    self._edit_macro(args,data)
-                    return
-                                
-                # For objects, try to edit the file where they are defined
-                try:
-                    filename = inspect.getabsfile(data)
-                    if 'fakemodule' in filename.lower() and inspect.isclass(data):                     
-                        # class created by %edit? Try to find source
-                        # by looking for method definitions instead, the
-                        # __module__ in those classes is FakeModule.
-                        attrs = [getattr(data, aname) for aname in dir(data)]
-                        for attr in attrs:
-                            if not inspect.ismethod(attr):
-                                continue
-                            filename = inspect.getabsfile(attr)
-                            if filename and 'fakemodule' not in filename.lower():
-                                # change the attribute to be the edit target instead
-                                data = attr 
-                                break
-                    
-                    datafile = 1
-                except TypeError:
-                    filename = make_filename(args)
-                    datafile = 1
-                    warn('Could not find file where `%s` is defined.\n'
-                         'Opening a file named `%s`' % (args,filename))
-                # Now, make sure we can actually read the source (if it was in
-                # a temp file it's gone by now).
-                if datafile:
-                    try:
-                        if lineno is None:
-                            lineno = inspect.getsourcelines(data)[1]
-                    except IOError:
-                        filename = make_filename(args)
-                        if filename is None:
-                            warn('The file `%s` where `%s` was defined cannot '
-                                 'be read.' % (filename,data))
-                            return
-                use_temp = False
-
-        if use_temp:
-            filename = self.shell.mktempfile(data)
-            print('IPython will make a temporary file named:', filename)
-
-        # Make sure we send to the client an absolute path, in case the working
-        # directory of client and kernel don't match
-        filename = os.path.abspath(filename)
-
-        payload = {
-            'source' : 'IPython.zmq.zmqshell.ZMQInteractiveShell.edit_magic',
-            'filename' : filename,
-            'line_number' : lineno
-        }
-        self.payload_manager.write_payload(payload)
-
-    def magic_gui(self, *args, **kwargs):
-        raise NotImplementedError(
-            'GUI support must be enabled in command line options.')
-
-    def magic_pylab(self, *args, **kwargs):
-        raise NotImplementedError(
-            'pylab support must be enabled in command line options.')
-
-    # A few magics that are adapted to the specifics of using pexpect and a
-    # remote terminal
-
-    def magic_clear(self, arg_s):
-        """Clear the terminal."""
-        if os.name == 'posix':
-            self.shell.system("clear")
-        else:
-            self.shell.system("cls")
-
-    if os.name == 'nt':
-        # This is the usual name in windows
-        magic_cls = magic_clear
-
-    # Terminal pagers won't work over pexpect, but we do have our own pager
-    
-    def magic_less(self, arg_s):
-        """Show a file through the pager.
-
-        Files ending in .py are syntax-highlighted."""
-        cont = open(arg_s).read()
-        if arg_s.endswith('.py'):
-            cont = self.shell.pycolorize(cont)
-        page.page(cont)
-
-    magic_more = magic_less
-
-    # Man calls a pager, so we also need to redefine it
-    if os.name == 'posix':
-        def magic_man(self, arg_s):
-            """Find the man page for the given command and display in pager."""
-            page.page(self.shell.getoutput('man %s | col -b' % arg_s,
-                                           split=False))
-
-    # FIXME: this is specific to the GUI, so we should let the gui app load
-    # magics at startup that are only for the gui.  Once the gui app has proper
-    # profile and configuration management, we can have it initialize a kernel
-    # with a special config file that provides these.
-    def magic_guiref(self, arg_s):
-        """Show a basic reference about the GUI console."""
-        from IPython.core.usage import gui_reference
-        page.page(gui_reference, auto_html=True)
-
-    def magic_loadpy(self, arg_s):
-        """Load a .py python script into the GUI console.
-
-        This magic command can either take a local filename or a url::
-
-        %loadpy myscript.py
-        %loadpy http://www.example.com/myscript.py
-        """
-        if not arg_s.endswith('.py'):
-            raise ValueError('%%load only works with .py files: %s' % arg_s)
-        if arg_s.startswith('http'):
-            import urllib2
-            response = urllib2.urlopen(arg_s)
-            content = response.read()
-        else:
-            content = open(arg_s).read()
-        payload = dict(
-            source='IPython.zmq.zmqshell.ZMQInteractiveShell.magic_loadpy', 
-            text=content
-        )
-        self.payload_manager.write_payload(payload)
-
-InteractiveShellABC.register(ZMQInteractiveShell)
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000000..d4bb8d39dfe
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,33 @@
+BSD 3-Clause License
+
+- Copyright (c) 2008-Present, IPython Development Team
+- Copyright (c) 2001-2007, Fernando Perez <fernando.perez@colorado.edu>
+- Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
+- Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/MANIFEST.in b/MANIFEST.in
index 124c74bf7db..81ea21b5042 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,37 +1,48 @@
-include ipython.py
+include README.rst
 include setupbase.py
-include setupegg.py
+include _build_meta.py
+include MANIFEST.in
+include .mailmap
+include .flake8
+include .pre-commit-config.yaml
+include long_description.rst
 
-graft setupext
+recursive-include tests *
+
+recursive-exclude tools *
+
+exclude tools
+exclude CONTRIBUTING.md
+exclude .editorconfig
+exclude SECURITY.md
+exclude .readthedocs.yaml
 
 graft scripts
-graft IPython/kernel
-graft IPython/config
-graft IPython/core
-# graft IPython/deathrow
-graft IPython/external
-graft IPython/frontend
-graft IPython/gui
-graft IPython/lib
-graft IPython/quarantine
-graft IPython/scripts
-graft IPython/testing
-graft IPython/utils
-
-include IPython/.git_commit_info.ini
 
+# Load main dir but exclude things we don't want in the distro
+graft IPython
+
+# Documentation
 graft docs
 exclude docs/\#*
-exclude docs/man/*.1
+exclude docs/man/*.1.gz
+
+exclude .git-blame-ignore-revs
+
+# Examples
+graft examples
 
 # docs subdirs we want to skip
-prune docs/attic
 prune docs/build
+prune docs/gh-pages
+prune docs/dist
 
+# Patterns to exclude from any directory
 global-exclude *~
 global-exclude *.flc
+global-exclude *.yml
 global-exclude *.pyc
+global-exclude *.pyo
 global-exclude .dircopy.log
-global-exclude .svn
-global-exclude .bzr
-global-exclude .hgignore
+global-exclude .git
+global-exclude .ipynb_checkpoints
diff --git a/README.rst b/README.rst
index e9821eec3b6..9a9bc5830e8 100644
--- a/README.rst
+++ b/README.rst
@@ -1,33 +1,112 @@
-==============
-IPython README
-==============
+.. image:: https://codecov.io/github/ipython/ipython/coverage.svg?branch=main
+    :target: https://codecov.io/github/ipython/ipython?branch=main
+
+.. image:: https://img.shields.io/pypi/v/IPython.svg
+    :target: https://pypi.python.org/pypi/ipython
+
+.. image:: https://github.com/ipython/ipython/actions/workflows/test.yml/badge.svg
+    :target: https://github.com/ipython/ipython/actions/workflows/test.yml
+
+.. image:: https://www.codetriage.com/ipython/ipython/badges/users.svg
+    :target: https://www.codetriage.com/ipython/ipython/
+
+.. image:: https://raster.shields.io/badge/Follows-SPEC--0000-brightgreen.png
+    :target: https://scientific-python.org/specs/spec-0000/
+
+.. image:: https://tidelift.com/badges/package/pypi/ipython?style=flat
+    :target: https://tidelift.com/subscription/pkg/pypi-ipython
+
+
+===========================================
+ IPython: Productive Interactive Computing
+===========================================
 
 Overview
 ========
 
-Welcome to IPython. Our full documentation can be found in the ``docs/dist``
-subdirectory in ``.html`` and ``.pdf`` formats, also available online at our
-`docs repo <http://ipython.github.com/ipython-doc>`_.  The ``docs/source`` directory 
-contains the plaintext version of these manuals.
+Welcome to IPython.  Our full documentation is available on `ipython.readthedocs.io
+<https://ipython.readthedocs.io/en/stable/>`_ and contains information on how to install, use, and
+contribute to the project.
+IPython (Interactive Python) is a command shell for interactive computing in multiple programming languages, originally developed for the Python programming language, that offers introspection, rich media, shell syntax, tab completion, and history.
+
+**Python Support**
+
+Starting after IPython 8.16, we progressively transition to `Spec-0000 <https://scientific-python.org/specs/spec-0000/>`_.
+
+IPython requires Python 3.11 or newer.
+
+
+The Notebook, Qt console and a number of other pieces are now parts of *Jupyter*.
+See the `Jupyter installation docs <https://jupyter.readthedocs.io/en/latest/install.html>`__
+if you want to use these.
+
+Main features of IPython
+========================
+Comprehensive object introspection.
+
+Input history, persistent across sessions.
+
+Caching of output results during a session with automatically generated references.
+
+Extensible tab completion, with support by default for completion of python variables and keywords, filenames and function keywords.
 
+Extensible system of ‘magic’ commands for controlling the environment and performing many tasks related to IPython or the operating system.
 
-Dependencies and supported Python versions
-==========================================
+A rich configuration system with easy switching between different setups (simpler than changing $PYTHONSTARTUP environment variables every time).
 
-For full details, see the installation section of the manual.  The basic parts
-of IPython only need the Python standard library, but much of its more advanced
-functionality requires extra packages.
+Session logging and reloading.
 
-Officially, IPython requires Python version 2.6 or 2.7.  An experimental port
-of IPython to Python 3.x is being developed at
-http://github.com/ipython/ipython-py3k.
+Extensible syntax processing for special purpose situations.
 
-    
-Instant running
-===============
+Access to the system shell with user-extensible alias system.
+
+Easily embeddable in other Python programs and GUIs.
+
+Integrated access to the pdb debugger and the Python profiler.
+
+
+Development and Instant running
+===============================
+
+You can find the latest version of the development documentation on `readthedocs
+<https://ipython.readthedocs.io/en/latest/>`_.
 
 You can run IPython from this directory without even installing it system-wide
 by typing at the terminal::
 
-   $ python ipython.py
-   
+   $ python -m IPython
+
+Or see the `development installation docs
+<https://ipython.readthedocs.io/en/latest/install/install.html#installing-the-development-version>`_
+for the latest revision on read the docs.
+
+Documentation and installation instructions for older version of IPython can be
+found on the `IPython website <https://ipython.org/documentation.html>`_
+
+
+Alternatives to IPython
+=======================
+
+IPython may not be to your taste; if that's the case there might be similar
+project that you might want to use:
+
+- The classic Python REPL.
+- `bpython <https://bpython-interpreter.org/>`_
+- `mypython <https://www.asmeurer.com/mypython/>`_
+- `ptpython and ptipython <https://pypi.org/project/ptpython/>`_
+- `Xonsh <https://xon.sh/>`_
+
+Ignoring commits with git blame.ignoreRevsFile
+==============================================
+
+As of git 2.23, it is possible to make formatting changes without breaking
+``git blame``. See the `git documentation
+<https://git-scm.com/docs/git-config#Documentation/git-config.txt-blameignoreRevsFile>`_
+for more details.
+
+To use this feature you must:
+
+- Install git >= 2.23
+- Configure your local git repo by running:
+   - POSIX: ``tools\configure-git-blame-ignore-revs.sh``
+   - Windows:  ``tools\configure-git-blame-ignore-revs.bat``
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000000..b4935f73f79
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,10 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+All IPython and Jupyter security are handled via security@ipython.org.
+You can find more information on the Jupyter website. https://jupyter.org/security
+
+## Tidelift
+
+You can report security concerns for IPython via the [Tidelift platform](https://tidelift.com/security).
diff --git a/_build_meta.py b/_build_meta.py
new file mode 100644
index 00000000000..9573341805f
--- /dev/null
+++ b/_build_meta.py
@@ -0,0 +1,2 @@
+# See https://setuptools.pypa.io/en/latest/build_meta.html#dynamic-build-dependencies-and-other-build-meta-tweaks
+from setuptools.build_meta import *
diff --git a/codecov.yml b/codecov.yml
new file mode 100644
index 00000000000..7fb0e7621c1
--- /dev/null
+++ b/codecov.yml
@@ -0,0 +1,46 @@
+coverage:
+  status:
+    patch: off
+    project:
+      default: false
+      library:
+        target: auto
+        paths:
+          - '!**/tests/**'
+          - '!**/testing/**'
+        threshold: 0.1%
+      tests:
+        target: auto
+        paths:
+          - '**/tests/**'
+          - '**/testing/**'
+        threshold: 0.1%
+flag_management:
+  default_rules:
+    statuses:
+      - type: patch
+        target: auto%
+        threshold: 0.1%
+      - type: project
+        target: auto%
+        threshold: 0.1%
+  individual_flags:
+    - name: unit-tests
+      paths:
+        - '**/tests/**'
+        - '**/testing/**'
+    - name: library
+      paths:
+        - '!**/tests/**'
+        - '!**/testing/**'
+codecov:
+  require_ci_to_pass: false
+  branch: main
+
+ignore:
+  - IPython/kernel/*
+  - IPython/consoleapp.py
+  - IPython/lib/kernel.py
+  - IPython/utils/jsonutil.py
+  - IPython/utils/log.py
+  - IPython/utils/signatures.py
diff --git a/docs/Makefile b/docs/Makefile
index 31a9d216b21..049f7493d86 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -6,6 +6,8 @@ SPHINXOPTS    =
 SPHINXBUILD   = sphinx-build
 PAPER         =
 SRCDIR        = source
+BUILDDIR      = build
+PYTHON        = python3
 
 # Internal variables.
 PAPEROPT_a4     = -D latex_paper_size=a4
@@ -18,46 +20,76 @@ default: html
 
 help:
 	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html      to make standalone HTML files"
-	@echo "  pickle    to make pickle files (usable by e.g. sphinx-web)"
-	@echo "  htmlhelp  to make HTML files and a HTML help project"
-	@echo "  latex     to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-	@echo "  changes   to make an overview over all changed/added/deprecated items"
-	@echo "  linkcheck to check all external links for integrity"
+	@echo "  html        standalone HTML files"
+	@echo "  html_noapi  same as above, without the time consuming API docs"
+	@echo "  pickle      pickle files (usable by e.g. sphinx-web)"
+	@echo "  htmlhelp    HTML files and a HTML help project"
+	@echo "  latex       LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  texinfo     Texinfo files"
+	@echo "  info        Texinfo files and run them through makeinfo"
+	@echo "  changes     an overview over all changed/added/deprecated items"
+	@echo "  linkcheck   check all external links for integrity (takes a long time)"
 	@echo
 	@echo "Compound utility targets:"
 	@echo "pdf          latex and then runs the PDF generation"
 	@echo "all          html and pdf"
 	@echo "dist         all, and then puts the results in dist/"
-	@echo "gitwash-update update git workflow from source repo"
 
-clean:
-	-rm -rf build/* dist/* $(SRCDIR)/api/generated
+clean_api:
+	-rm -rf $(SRCDIR)/api/generated
+
+clean: clean_api
+	-rm -rf build/* dist/*
+	-rm -f $(SRCDIR)/config/options/config-generated.txt
+	-rm -f $(SRCDIR)/config/shortcuts/*.csv
+	-rm -f $(SRCDIR)/interactive/magics-generated.txt
 
 pdf: latex
 	cd build/latex && make all-pdf
 
 all: html pdf
 
-dist: all
-	mkdir -p dist
-	rm -rf dist/*
-	ln build/latex/ipython.pdf dist/
-	cp -al build/html dist/
-	@echo "Build finished.  Final docs are in dist/"
+# For final distribution, only build HTML (our pdf is now so large as to be
+# unusable, takes forever to build and just bloats the downloads).  We leave
+# them hardlinked at the top-level so users find them easily, though the
+# original build/html dir is left in-place (useful to reload builds while
+# testing).
+dist: html
+	rm -rf html
+	cp -al build/html .
+	@echo "Build finished.  Final docs are in html/"
+
+html: api autoconfig automagic autogen_shortcuts
+html_noapi: clean_api autoconfig automagic autogen_shortcuts
 
-html: api
+html html_noapi:
 	mkdir -p build/html build/doctrees
 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) build/html
 	@echo
 	@echo "Build finished. The HTML pages are in build/html."
 
+automagic: source/interactive/magics-generated.txt
+
+source/interactive/magics-generated.txt: autogen_magics.py
+	$(PYTHON) autogen_magics.py
+	@echo "Created docs for line & cell magics"
+
+autoconfig: source/config/options/config-generated.txt
+
+source/config/options/config-generated.txt: autogen_config.py
+	$(PYTHON) autogen_config.py
+	@echo "Created docs for config options"
+
 api: source/api/generated/gen.txt
 
 source/api/generated/gen.txt:
-	python autogen_api.py
+	$(PYTHON) autogen_api.py
 	@echo "Build API docs finished."
 
+autogen_shortcuts: autogen_shortcuts.py ../IPython/terminal/interactiveshell.py source/config/shortcuts/index.rst
+	$(PYTHON) autogen_shortcuts.py
+	@echo "Created docs for shortcuts"
+
 pickle:
 	mkdir -p build/pickle build/doctrees
 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) build/pickle
@@ -75,7 +107,7 @@ htmlhelp:
 	@echo "Build finished; now you can run HTML Help Workshop with the" \
 	      ".hhp project file in build/htmlhelp."
 
-latex: api
+latex: api autoconfig
 	mkdir -p build/latex build/doctrees
 	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) build/latex
 	@echo
@@ -94,14 +126,19 @@ linkcheck:
 	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) build/linkcheck
 	@echo
 	@echo "Link check complete; look for any errors in the above output " \
-	      "or in build/linkcheck/output.txt."
-
-gitwash-update:
-	python ../tools/gitwash_dumper.py source/development ipython
-	cd source/development/gitwash && rename 's/.rst/.txt/' *.rst
+	      "or in build/linkcheck/output.rst."
 
-nightly: dist
-	rsync -avH --delete dist/ ipython:www/doc/nightly
-
-gh-pages: html pdf
-	python gh-pages.py
+texinfo:
+	mkdir -p $(BUILDDIR)/texinfo
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+info:
+	mkdir -p $(BUILDDIR)/texinfo
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
diff --git a/docs/README.rst b/docs/README.rst
new file mode 100644
index 00000000000..ebdb17107e0
--- /dev/null
+++ b/docs/README.rst
@@ -0,0 +1,64 @@
+IPython Documentation
+---------------------
+
+This directory contains the majority of the documentation for IPython.
+
+
+Deploy docs
+-----------
+
+Documentation is automatically deployed on ReadTheDocs on every push or merged
+Pull requests.
+
+
+Requirements
+------------
+
+The documentation must be built using Python 3.
+
+In addition to :ref:`devinstall`,
+the following tools are needed to build the documentation:
+
+ - sphinx
+ - sphinx_rtd_theme
+ - docrepr
+
+In a conda environment, or a Python 3 ``venv``, you should be able to run::
+
+  cd ipython
+  pip install -U -r docs/requirements.txt
+
+
+Build Commands
+--------------
+
+The documentation gets built using ``make``, and comes in several flavors.
+
+``make html`` - build the API and narrative documentation web pages, this is
+the default ``make`` target, so running just ``make`` is equivalent to ``make
+html``.
+
+``make html_noapi`` - same as above, but without running the auto-generated API
+docs. When you are working on the narrative documentation, the most time
+consuming portion  of the build process is the processing and rendering of the
+API documentation. This build target skips that.
+
+``make pdf`` will compile a pdf from the documentation.
+
+You can run ``make help`` to see information on all possible make targets.
+
+To save time,
+the make targets above only process the files that have been changed since the
+previous docs build.
+To remove the previous docs build you can use ``make clean``.
+You can also combine ``clean`` with other `make` commands;
+for example,
+``make clean html`` will do a complete rebuild of the docs or ``make clean pdf`` will do a complete build of the pdf.
+
+
+Continuous Integration
+----------------------
+
+Documentation builds are included in the Travis-CI continuous integration process,
+so you can see the results of the docs build for any pull request at
+https://travis-ci.org/ipython/ipython/pull_requests.
diff --git a/docs/README.txt b/docs/README.txt
deleted file mode 100644
index 6a6745aa1b3..00000000000
--- a/docs/README.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-Current version information
----------------------------
-
-Please open manual.pdf for a PDF version of IPython's user manual, or go to
-the manual/ directory for an HTML version.
-
-
-Bugs and future developments
-----------------------------
-
-The new_design.pdf document is a description of the goals for IPython's future
-development.  It includes a TODO/bugs section listing all currently known bugs
-in IPython.  Please report any bug you encounter if it is not already listed
-there.
diff --git a/docs/README_Windows.txt b/docs/README_Windows.txt
deleted file mode 100644
index 0f90694fe09..00000000000
--- a/docs/README_Windows.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-Notes for Windows Users
-=======================
-
-These are just minimal notes.  The manual contains more detailed
-information.
-
-Requirements
-------------
-
-IPython runs under (as far as the Windows family is concerned):
-
-- Windows XP (I think WinNT/2000 are ok): works well.  It needs:
-
-  * Gary Bishop's readline from 
-    http://sourceforge.net/projects/uncpythontools.
-    
-  * This in turn requires Tomas Heller's ctypes from
-    http://starship.python.net/crew/theller/ctypes.
-
-- Windows 95/98/ME: I have no idea. It should work, but I can't test.
-
-- CygWin environments should work, they are basically Posix.
-
-It needs Python 2.2 or newer.
-
-
-Installation
-------------
-
-Double-click the supplied .exe installer file.  If all goes well, that's all
-you need to do. You should now have an IPython entry in your Start Menu.
-
-In case the automatic installer does not work for some reason, you can
-download the ipython-XXX.tar.gz file, which contains the full IPython source
-distribution (the popular WinZip can read .tar.gz files). After uncompressing
-the archive, you can install it at a command terminal just like any other
-Python module, by using python setup.py install'. After this completes, you
-can run the supplied win32_manual_post_install.py script which will add
-the relevant shortcuts to your startup menu.
diff --git a/docs/api_changes.txt b/docs/api_changes.txt
deleted file mode 100644
index dc81fceb11f..00000000000
--- a/docs/api_changes.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-=============
- API Changes
-=============
-
-.. contents::
-..
-    1  Purpose
-    2  Version 0.8.2
-
-
-Purpose
-=======
-
-This file documents backwards-incompatible changes to the IPython API,
-including user-visible changes of commands, magics, etc.
-
-It should be filled in reverse chronological order, with one section for each
-release (which means changes since the previous release).
-
-
-Version 0.8.2
-=============
-
-Changes made since version 0.8.1 was released:
-
-* %pushd/%popd behave differently; now "pushd /foo" pushes CURRENT directory 
-  and jumps to /foo. The current behaviour is closer to the documented 
-  behaviour, and should not trip anyone.
-  
-Version 0.8.3
-=============
-  
-* pydb is now disabled by default (due to %run -d problems). You can enable
-it by passing -pydb command line argument to IPython. Note that setting
-it in config file won't work.
\ No newline at end of file
diff --git a/docs/attic/COPYING b/docs/attic/COPYING
deleted file mode 100644
index 78bb2f489f0..00000000000
--- a/docs/attic/COPYING
+++ /dev/null
@@ -1,52 +0,0 @@
-IPython copyright and licensing notes
-=====================================
-
-Unless indicated otherwise, files in this project are covered by a BSD-type
-license, included below.
-
-Individual authors are the holders of the copyright for their code and are
-listed in each file.
-
-Some files (DPyGetOpt.py, for example) may be licensed under different
-conditions. Ultimately each file indicates clearly the conditions under which
-its author/authors have decided to publish the code.
-
-
-IPython license
----------------
-
-IPython is released under a BSD-type license.
-
-Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez <fperez@colorado.edu>.
-
-Copyright (c) 2001 Janko Hauser <jhauser@zscout.de> and Nathaniel Gray
-<n8gray@caltech.edu>.
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-  a. Redistributions of source code must retain the above copyright notice,
-     this list of conditions and the following disclaimer.
-
-  b. Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in the
-     documentation and/or other materials provided with the distribution.
-
-  c. Neither the name of the copyright holders nor the names of any
-     contributors to this software may be used to endorse or promote products
-     derived from this software without specific prior written permission.
-
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.
diff --git a/docs/attic/ChangeLog b/docs/attic/ChangeLog
deleted file mode 100644
index 7426e9d584c..00000000000
--- a/docs/attic/ChangeLog
+++ /dev/null
@@ -1,7683 +0,0 @@
-2008-06-09  Ville Vainio <vivainio@gmail.com>
-
-	* Extensions/ipy_autoreload.py: Apply Pauli Virtanen's patch
-	to autoreloading that also replaces the changed code objects 
-	with new versions
-
-	* pspersistence.py: report UsageError on %store -w w/o arg,
-	and other usage pattern errors. Bug report by Johann Cohen-Tanugi.
-	
-	
-2008-06-03  Ville Vainio <vivainio@gmail.com>
-
-	* ipython.rst, ipython.1: remove -twisted from man page,
-	add -pydb to both man page and manual.
-
-	* pspersistence.py: report UsageError on %store -w w/o arg,
-	and other usage pattern errors. Bug report by Johann Cohen-Tanugi.
-
-2008-06-02  Fernando Perez  <Fernando.Perez@berkeley.edu>
-
-	* IPython/Shell.py (MatplotlibShellBase._matplotlib_config): add
-	numpy/np/pyplot/plt imports according to new conventions we're
-	trying to standardize on.  This only affects the -pylab mode.
-
-2008-05-31  Fernando Perez  <Fernando.Perez@berkeley.edu>
-
-	* IPython/ipmaker.py (make_IPython): The -twisted option is fully
-	disabled.
-
-2008-05-31  *** Released version 0.8.4
-
-2008-05-31  Fernando Perez  <Fernando.Perez@berkeley.edu>
-
-	* IPython/ipmaker.py (make_IPython): The -twisted option is fully
-	disabled.
-
-	* IPython/Shell.py (_select_shell): completely disable -twisted.
-	This code is of dubious quality and  normal users should not
-	encounter it until we can clarify things further, even under
-	win32.  Since we need a quick emergency 0.8.4 release, it is now
-	disabled completely.  Users who want to run it can use the
-	following command (it's easy to put it in an alias or script):
-	
-	python -c"from IPython import twshell;twshell.IPShellTwisted().mainloop()"
-
-2008-05-30  Ville Vainio <vivainio@gmail.com>
-
-	* shell.py: disable -twisted on non-win32 platforms.
-	import sets module on python 2.3.
-
-	* ipy_profile_sh.py: disable ipy_signals. Now, ipython
-	is verified to work with python 2.3
-	
-	* Release.py: update version to 0.8.4 for quick point fix
-
-2008-05-28  *** Released version 0.8.3
-
-2008-05-28  Fernando Perez  <Fernando.Perez@berkeley.edu>
-
-	* ../win32_manual_post_install.py (run): Fix the windows installer
-	so the links to the docs are correct.
-
-	* IPython/ultraTB.py: flush stderr after writing to it to fix
-	problems with exception traceback ordering in some platforms.
-	Thanks to a report/fix by Jie Tang <jietang86-AT-gmail.com>.
-
-	* IPython/Magic.py (magic_cpaste): add stripping of continuation
-	prompts, feature requested by Stefan vdW.
-
-	* ../setup.py: updates to build and release tools in preparation
-	for 0.8.3 release.
-
-2008-05-27  Ville Vainio <vivainio@gmail.com>
-
-	* iplib.py, ipmaker.py: survive lack of doctest and site._Helper
-	for minimal environments (e.g. Maemo sdk python)
-
-	* Magic.py: cpaste strips whitespace before >>> (allow pasting
-	doctests)
-
-	* ipy_completers.py: cd completer now does recursive path expand
-	(old behaviour is buggy on some readline versions)
-
-2008-05-14  Ville Vainio <vivainio@gmail.com>
-
-	* Extensions/ipy_greedycompleter.py: 
-	New extension that enables a bit more "relaxed" tab 
-	completer that evaluates code without safety checks
-	(i.e. there can be side effects like function calls)
-
-2008-04-20  Ville Vainio <vivainio@gmail.com>
-
-	* Extensions/ipy_lookfor.py: add %lookfor magic command
-	(search docstrings for words) by Pauli Virtanen. Close #245.
-
-	* Extension/ipy_jot.py: %jot and %read magics, analogous
-	to %store but you can specify some notes. Not read 
-	in automatically on startup, you need %read.
-	Contributed by Yichun Wei.
-
-2008-04-18  Fernando Perez  <Fernando.Perez@berkeley.edu>
-
-	* IPython/genutils.py (page): apply workaround to curses bug that
-	can leave terminal corrupted after a call to initscr().
-
-2008-04-15  Ville Vainio <vivainio@gmail.com>
-
-	* genutils.py: SList.grep supports 'field' argument
-
-	* ipy_completers.py: module completer looks inside
-	.egg zip files (patch by mc). Close #196.
-
-2008-04-09  Ville Vainio <vivainio@gmail.com>
-
-	* deep_reload.py: do not crash on from __future__ import 
-	absolute_import. Close #244.
-
-2008-04-02  Ville Vainio <vivainio@gmail.com>
-
-	* ipy_winpdb.py: New extension for winpdb integration.  %wdb
-	test.py is winpdb equivalent of %run -d test.py.  winpdb is a
-	crossplatform remote GUI debugger based on wxpython.
-
-2008-03-29  Ville Vainio <vivainio@gmail.com>
-
-	* ipython.rst, do_sphinx.py: New documentation base, based on
-	reStucturedText and Sphinx (html/pdf generation).  The old Lyx
-	based documentation will not be updated anymore.
-
-	* jobctrl.py: Use shell in Popen for 'start' command (in windows).
-
-2008-03-24  Ville Vainio <vivainio@gmail.com>
-
-	* ipython.rst, do_sphinx.py: New documentation base, based on
-	reStucturedText and Sphinx (html/pdf generation).  The old Lyx
-	based documentation will not be updated anymore.
-
-	ipython.rst has up to date documentation on matters that were not
-	documented at all, and it also removes various
-	misdocumented/deprecated features.
-	
-2008-03-22  Ville Vainio <vivainio@gmail.com>
-
-	* Shell.py: Merge mtexp branch:
-	https://code.launchpad.net/~ipython/ipython/mtexp
-
-	Privides simpler and more robust MTInteractiveShell that won't
-	deadlock, even when the worker thread (GUI) stops doing runcode()
-	regularly. r71.
-
-2008-03-20  Ville Vainio <vivainio@gmail.com>
-
-	* twshell.py: New shell that runs IPython code in Twisted reactor.
-	Launch by doing ipython -twisted. r67.
-
-2008-03-19  Ville Vainio <vivainio@gmail.com>
-
-	* Magic.py: %rehashx works correctly when shadowed system commands
-	have upper case characters (e.g. Print.exe). r64.
-
-	* ipy_bzr.py, ipy_app_completers.py: new bzr completer that also
-	knows options to commands, based on bzrtools. Uses bzrlib
-	directly. r66.
-
-2008-03-16  Ville Vainio <vivainio@gmail.com>
-
-	* make_tarball.py: Fixed for bzr.
-
-	* ipapi.py: Better _ip.runlines() script cleanup. r56,r79.
-
-	 * ipy_vimserver.py, ipy.vim: New extension for vim server mode,
-	 by Erich Heine.
-
-2008-03-12  Ville Vainio <vivainio@gmail.com>
-
-	* ipmaker.py: Force (reload?) import of ipy_user_conf and
-	ipy_profile_foo, so that embedded instances can be relaunched and
-	configuration is still done. r50
-
-	* ipapi.py, test_embed.py: Allow specifying shell class in
-	launch_new_instance & make_new instance. Use this in
-	test_embed.py. r51.
-
-	test_embed.py is also a good and simple demo of embedding IPython.
-	
-
-2008-03-10  Ville Vainio <vivainio@gmail.com>
-
-	* tool/update_revnum.py: Change to bzr revisioning scheme in 
-	revision numbers.
-
-	* Shell.py: Threading improvements:
-
-	In multithreaded shells, do not hang on macros and o.autoexec
-	commands (or anything executed with _ip.runlines()) anymore. Allow
-	recursive execution of IPython code in
-	MTInteractiveShell.runsource by checking if we are already in
-	worker thread, and execute code directly if we are. r48.
-
-	MTInteractiveShell.runsource: execute code directly if worker
-	thread is not running yet (this is the case in config files). r49.
-
-2008-03-09  Ville Vainio <vivainio@gmail.com>
-
-	* ipy_profile_sh.py: You can now use $LA or LA() to refer to last
-	argument of previous command in sh profile. Similar to bash '!$'.
-	LA(3) or $LA(3) stands for last argument of input history command 
-	3.
-
-	* Shell.py: -pylab names don't clutter %whos listing.
-
-2008-03-07  Ville Vainio <vivainio@gmail.com>
-
-	* ipy_autoreload.py: new extension (by Pauli Virtanen) for 
-	autoreloading modules; try %autoreload and %aimport. Close #154.
-	Uses the new pre_runcode_hook.
-
-2008-02-24  Ville Vainio <vivainio@gmail.com>
-
-	* platutils_posix.py: freeze_term_title works
-
-2008-02-21  Ville Vainio <vivainio@gmail.com>
-
-	* Magic.py: %quickref does not crash with empty docstring
-
-2008-02-20  Ville Vainio <vivainio@gmail.com>
-
-	* completer.py: do not treat [](){} as protectable chars anymore,
-	close #233.
-
-	* completer.py: do not treat [](){} as protectable chars anymore
-	
-	* magic.py, test_cpaste.py: Allow different prefix for pasting 
-	from email
-
-2008-02-17  Ville Vainio <vivainio@gmail.com>
-
-	* Switched over to Launchpad/bzr as primary VCS.
-
-2008-02-14  Ville Vainio <vivainio@gmail.com>
-
-	* ipapi.py: _ip.runlines() is now much more liberal about 
-	indentation - it cleans up the scripts it gets
-	
-2008-02-14  Ville Vainio <vivainio@gmail.com>
-
-	* Extensions/ipy_leo.py: created 'ILeo' IPython-Leo bridge.
-	Changes to it (later on) are too numerous to list in ChangeLog
-	until it stabilizes
-	
-2008-02-07  Darren Dale <darren.dale@cornell.edu>
-
-	* IPython/Shell.py: Call QtCore.pyqtRemoveInputHook() when creating
-	an IPShellQt4. PyQt4-4.2.1 and later uses PyOS_InputHook to improve 
-	interaction in the interpreter (like Tkinter does), but it seems to 
-	partially interfere with the IPython implementation and exec_()
-	still seems to block. So we disable the PyQt implementation and
-	stick with the IPython one for now.
-
-2008-02-02  Walter Doerwald  <walter@livinglogic.de>
-
-	* ipipe.py: A new ipipe table has been added: ialias produces all
-	entries from IPython's alias table.
-	
-2008-02-01  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (MTInteractiveShell.runcode): Improve handling
-	of KBINT in threaded shells.  After code provided by Marc in #212.
-
-2008-01-30  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (MTInteractiveShell.__init__): Fixed deadlock
-	that could occur due to a race condition in threaded shells.
-	Thanks to code provided by Marc, as #210.
-
-2008-01-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_doctest_mode): respect the user's
-	settings for input separators rather than overriding them.  After
-	a report by Jeff Kowalczyk <jtk-AT-yahoo.com>
-
-	* IPython/history.py (magic_history): Add support for declaring an
-	output file directly from the history command.
-
-2008-01-21  Walter Doerwald  <walter@livinglogic.de>
-
-	* ipipe.py: Register ipipe's displayhooks via the generic function
-	generics.result_display() instead of using ipapi.set_hook().
-	
-2008-01-19  Walter Doerwald  <walter@livinglogic.de>
-
-	* ibrowse.py, igrid.py, ipipe.py:
-	The input object can now be passed to the constructor of the display classes.
-	This makes it possible to use them with objects that implement __or__.
-	Use this constructor in the displayhook instead of piping.
-
-	* ipipe.py: Importing astyle.py is done as late as possible to
-	avoid problems with circular imports.
-	
-2008-01-19 Ville Vainio  <vivainio@gmail.com>
-
-	* hooks.py, iplib.py: Added 'shell_hook' to customize how
-	IPython calls shell.
-
-	* hooks.py, iplib.py: Added 'show_in_pager' hook to specify
-	how IPython pages text (%page, %pycat, %pdoc etc.)
-
-	* Extensions/jobctrl.py: Use shell_hook. New magics: '%tasks'
-	and '%kill' to kill hanging processes that won't obey ctrl+C.
-
-2008-01-16 Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_completers.py: pyw extension support for %run completer.
-
-2008-01-11 Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py, ipmaker.py: new rc option - autoexec. It's a list 
-	of ipython commands to be run when IPython has started up
-	(just before running the scripts and -c arg on command line).
-	
-	* ipy_user_conf.py: Added an example on how to change term 
-	colors in config file (through using autoexec).
-
-	* completer.py, test_completer.py: Ability to specify custom
-	get_endidx to replace readline.get_endidx. For emacs users.
-	
-2008-01-10 Ville Vainio  <vivainio@gmail.com>
-
-	* Prompts.py (set_p_str): do not crash on illegal prompt strings
-
-2008-01-08 Ville Vainio  <vivainio@gmail.com>
-
-	* '%macro -r' (raw mode) is now default in sh profile.
-
-2007-12-31  Ville Vainio  <vivainio@gmail.com>
-
-	* completer.py: custom completer matching is now case sensitive
-	(#207).
-	
-	* ultraTB.py, iplib.py: Add some KeyboardInterrupt catching in
-	an attempt to prevent occasional crashes.
-	
-	* CrashHandler.py: Crash log dump now asks user to press enter
-	before exiting.
-	
-	* Store _ip in user_ns instead of __builtin__, enabling safer
-	coexistence of multiple IPython instances in the same python
-	interpreter (#197).
-	
-	* Debugger.py, ipmaker.py: Need to add '-pydb' command line
-	switch to enable pydb in post-mortem debugging and %run -d.
-
-2007-12-28  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_server.py: TCP socket server for "remote control" of an IPython 
-	instance.
-	
-	* Debugger.py: Change to PSF license
-	
-	* simplegeneric.py: Add license & author notes.
-	
-	* ipy_fsops.py: Added PathObj and FileObj, an object-oriented way 
-	to navigate file system with a custom completer. Run 
-	ipy_fsops.test_pathobj() to play with it.
-
-2007-12-28  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/dtutils.py: Add utilities for interactively running
-	doctests.  Still needs work to more easily handle the namespace of
-	the package one may be working on, but the basics are in place.
-
-2007-12-27  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_completers.py: Applied arno's patch to get proper list of 
-	packages in import completer. Closes #196.
-
-2007-12-20  Ville Vainio  <vivainio@gmail.com>
-
-	* completer.py, generics.py(complete_object): Allow 
-	custom complers based on python objects via simplegeneric.
-	See generics.py / my_demo_complete_object
-
-2007-12-13  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Prompts.py (BasePrompt.__nonzero__): add proper boolean
-	behavior to prompt objects, useful for display hooks to adjust
-	themselves depending on whether prompts will be there or not.
-
-2007-12-13  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py(raw_input): unix readline does not allow unicode in
-	history, encode to normal string. After patch by Tiago.
-	Close #201
-
-2007-12-12  Ville Vainio  <vivainio@gmail.com>
-
-	* genutils.py (abbrev_cwd): Terminal title now shows 2 levels of 
-	current directory.
-	
-2007-12-12  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (_select_shell): add support for controlling
-	the pylab threading mode directly at the command line, without
-	having to modify MPL config files.  Added unit tests for this
-	feature, though manual/docs update is still pending, will do later.
-
-2007-12-11  Ville Vainio  <vivainio@gmail.com>
-
-	* ext_rescapture.py: var = !cmd is no longer verbose (to facilitate
-	use in scripts)
-
-2007-12-07  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py, ipy_profile_sh.py: Do not escape # on command lines 
-	anymore (to \#) - even if it is a comment char that is implicitly 
-	escaped in some unix shells in interactive mode, it is ok to leave
-	it in IPython as such.
-
-
-2007-12-01  Robert Kern  <robert.kern@gmail.com>
-
-	* IPython/ultraTB.py (findsource): Improve the monkeypatch to
-	inspect.findsource(). It can now find source lines inside zipped
-	packages.
-	
-	* IPython/ultraTB.py: When constructing tracebacks, try to use __file__
-	in the frame's namespace before trusting the filename in the code object
-	which created the frame.
-
-2007-11-29  *** Released version 0.8.2
-
-2007-11-25  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Logger.py (Logger.logstop): add a proper logstop()
-	method to fully stop the logger, along with a corresponding
-	%logstop magic for interactive use.
-
-	* IPython/Extensions/ipy_host_completers.py: added new host
-	completers functionality, contributed by Gael Pasgrimaud
-	<gawel-AT-afpy.org>.
-
-2007-11-24  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/DPyGetOpt.py (ArgumentError): Apply patch by Paul Mueller
-	<gakusei-AT-dakotacom.net>, to fix deprecated string exceptions in
-	options handling.  Unicode fix in %whos (committed a while ago)
-	was also contributed by Paul.
-
-2007-11-23  Darren Dale <darren.dale@cornell.edu>
-        * ipy_traits_completer.py: let traits_completer respect the user's
-        readline_omit__names setting.
-
-2007-11-08  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_completers.py (import completer): assume 'xml' module exists.
-	Do not add every module twice anymore. Closes #196.
-
-	* ipy_completers.py, ipy_app_completers.py: Add proper apt-get
-	completer that uses apt-cache to search for existing packages.
-
-2007-11-06  Ville Vainio  <vivainio@gmail.com>
-
-	* Prompts.py: Do not update _oh and _123 when do_full_cache is not
-	true. Closes #194.
-
-2007-11-01  Brian Granger <ellisonbg@gmail.com>
-
-	* iplib.py, rlineimpl.py: Applied Body Water's patches to get IPython
-	working with OS X 10.5 libedit implementation of readline.
-
-2007-10-24  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py(user_setup): To route around buggy installations where
-	UserConfig is not available, create a minimal _ipython.
-
-	* iplib.py: Unicode fixes from Jorgen.
-
-	* genutils.py: Slist now has new method 'fields()' for extraction of
-	whitespace-separated fields from line-oriented data.
-
-2007-10-15  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/OInspect.py (Inspector.pinfo): fix bug that could arise
-	when querying objects with no __class__ attribute (such as
-	f2py-generated modules).
-
-2007-10-09  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_time): track compilation time and report
-	it if longer than 0.1s (fix done to %time and %timeit).  After a
-	SAGE bug report: http://trac.sagemath.org/sage_trac/ticket/632.
-
-2007-09-18  Ville Vainio  <vivainio@gmail.com>
-
-	* genutils.py(make_quoted_expr): Do not use Itpl, it does
-        not support unicode at the moment. Fixes (many) magic calls with
-        special characters.
-
-2007-09-14  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/genutils.py (doctest_reload): expose the doctest
-	reloader to the user so that people can easily reset doctest while
-	using it interactively.  Fixes a problem reported by Jorgen.
-
-	* IPython/iplib.py (InteractiveShell.__init__): protect the
-	FakeModule instances used for __main__ in %run calls from
-	deletion, so that user code defined in them isn't left with
-	dangling references due to the Python module deletion machinery.
-	This should fix the problems reported by Darren.
-
-2007-09-10  Darren Dale  <dd55@cornell.edu>
-
-        * Cleanup of IPShellQt and IPShellQt4
-
-2007-09-09  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/FakeModule.py (FakeModule.__init__): further fixes for
-	doctest support.  
-
-	* IPython/iplib.py (safe_execfile): minor docstring improvements.
-
-2007-09-08  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py (%pushd, %popd, %dirs): Fix dir stack - push *current*
-	directory, not the target directory.
-
-	* ipapi.py, Magic.py, iplib.py: Add ipapi.UsageError, a lighter weight
-	exception that won't print the tracebacks. Switched many magics to
-	raise them on error situations, also GetoptError is not printed
-	anymore.
-
-2007-09-07  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: do not auto-alias "dir", it screws up other dir auto
-        aliases.
-
-	* genutils.py: SList.grep() implemented.
-        
-	* ipy_editors.py, UserConfig/ipy_user_conf.py: Add some editors
-	for easy "out of the box" setup of several common editors, so that
-	e.g. '%edit os.path.isfile' will jump to the correct line
-	automatically. Contributions for command lines of your favourite
-	editors welcome.
-        
-2007-09-07  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/OInspect.py (Inspector.pinfo): fixed bug that was
-	preventing source display in certain cases.  In reality I think
-	the problem is with Ubuntu's Python build, but this change works
-	around the issue in some cases (not in all, unfortunately).  I'd
-	filed a Python bug on this with more details, but in the change of
-	bug trackers it seems to have been lost.
-
-	* IPython/Magic.py (magic_dhist): restore %dhist. No, cd -TAB is
-	not the same, it's not self-documenting, doesn't allow range
-	selection, and sorts alphabetically instead of numerically.
-	(magic_r): restore %r.  No, "up + enter. One char magic" is not
-	the same thing, since %r takes parameters to allow fast retrieval
-	of old commands.  I've received emails from users who use this a
-	LOT, so it stays.
-	(magic_automagic): restore %automagic.  "use _ip.option.automagic"
-	is not a valid replacement b/c it doesn't provide an complete
-	explanation (which the automagic docstring does).
-	(magic_autocall): restore %autocall, with improved docstring.
-	Same argument as for others, "use _ip.options.autocall" is not a
-	valid replacement.
-	(magic_pdef): restore %pdef & friends.  Used widely, mentioned in
-	tutorials and online docs.
-
-2007-09-06  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/usage.py (quick_reference): mention magics in quickref,
-	modified main banner to mention %quickref.
-
-	* IPython/FakeModule.py (FakeModule): fixes for doctest compatibility.
-
-2007-09-06  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_rehashdir.py, ipy_workdir.py, ipy_fsops.py, iplib.py:
-	Callable aliases now pass the _ip as first arg. This breaks 
-	compatibility with earlier 0.8.2.svn series! (though they should
-	not have been in use yet outside these few extensions)
-
-2007-09-05  Ville Vainio  <vivainio@gmail.com>
-
-	* external/mglob.py: expand('dirname') => ['dirname'], instead
-	of ['dirname/foo','dirname/bar', ...].
-        
-	* Extensions/ipy_fsops.py: added, has usefull shell utils for plain
-	win32 installations: icp, imv, imkdir, igrep, irm, collect (collect
-	is useful for others as well).
-
-	* iplib.py: on callable aliases (as opposed to old style aliases),
-	do var_expand() immediately, and use make_quoted_expr instead
-	of hardcoded r"""
-
-	* Extensions/ipy_profile_sh.py: Try to detect cygwin on win32,
-	if not available load ipy_fsops.py for cp, mv, etc. replacements
-
-	* OInspect.py, ipy_which.py: improve %which and obj? for callable
-	aliases
-        
-2007-09-04  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_profile_zope.py: add zope profile, by Stefan Eletzhofer.
-	Relicensed under BSD with the authors approval.
-        
-	* ipmaker.py, usage.py: Remove %magic from default banner, improve
-	%quickref        
-
-2007-09-03  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py: %time now passes expression through prefilter,
-	allowing IPython syntax.
-
-2007-09-01  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py: Always show full traceback when newstyle config fails
-
-2007-08-27  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py: fix %cd for nonexistent dir when dhist is empty, close #180
-
-2007-08-26  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py: Command line args have the highest priority again
-	
-	* iplib.py, ipmaker.py: -i command line argument now behaves as in
-	normal python, i.e. leaves the IPython session running after -c
-	command or running a batch file from command line.
-    
-2007-08-22  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: no extra empty (last) line in raw hist w/ multiline
-	statements
-	
-	* logger.py: Fix bug where blank lines in history were not
-	added until AFTER adding the current line; translated and raw
-	history should finally be in sync with prompt now.
-	
-	* ipy_completers.py: quick_completer now makes it easy to create
-	trivial custom completers
-	
-	* clearcmd.py: shadow history compression & erasing, fixed input hist
-	clearing.
-	
-	* envpersist.py, history.py: %env (sh profile only), %hist completers
-	
-	* genutils.py, Prompts.py, Magic.py: win32 - prompt (with \yDEPTH) and
-	term title now include the drive letter, and always use / instead of
-	os.sep (as per recommended approach for win32 ipython in general).
-	
-	* ipykit.py, ipy_kitcfg.py: special launcher for ipykit. Allows running
-	plain python scripts from ipykit command line by running
-	"py myscript.py", even w/o installed python.
-
-2007-08-21  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py: finding ipythonrc-PROF now skips ipy_profile_PROF.
-	(for backwards compatibility)
-	
-	* history.py: switch back to %hist -t from %hist -r as default.
-	At least until raw history is fixed for good.
-
-2007-08-20  Ville Vainio  <vivainio@gmail.com>
-
-	* ipapi.py, iplib.py: DebugTools accessible via _ip.dbg, to catch &
-	locate alias redeclarations etc. Also, avoid handling
-	_ip.IP.alias_table directly, prefer using _ip.defalias.
-	
-
-2007-08-15  Ville Vainio  <vivainio@gmail.com>
-
-	* prefilter.py: ! is now always served first
-
-2007-08-15  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (safe_execfile): fix the SystemExit
-	auto-suppression code to work in Python2.4 (the internal structure
-	of that exception changed and I'd only tested the code with 2.5).
-	Bug reported by a SciPy attendee.
-
-2007-08-13  Ville Vainio  <vivainio@gmail.com>
-
-	* prefilter.py: reverted !c:/bin/foo fix, made % in
-        multiline specials work again
-
-2007-08-13  Ville Vainio  <vivainio@gmail.com>
-
-	* prefilter.py: Take more care to special-case !, so that
-        !c:/bin/foo.exe works.
-        
-        * setup.py: if we are building eggs, strip all docs and
-        examples (it doesn't make sense to bytecompile examples,
-        and docs would be in an awkward place anyway).
-        
-        * Ryan Krauss' patch fixes start menu shortcuts when IPython
-        is installed into a directory that has spaces in the name.
-
-2007-08-13  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_doctest_mode): fix prompt separators in
-	doctest profile and %doctest_mode, so they actually generate the
-	blank lines needed by doctest to separate individual tests.
-
-	* IPython/iplib.py (safe_execfile): modify so that running code
-	which calls sys.exit(0) (or equivalently, raise SystemExit(0))
-	doesn't get a printed traceback.  Any other value in sys.exit(),
-	including the empty call, still generates a traceback.  This
-	enables use of %run without having to pass '-e' for codes that
-	correctly set the exit status flag.
-
-2007-08-12  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.post_config_initialization):
-	fix problems with doctests failing when run inside IPython due to
-	IPython's modifications of sys.displayhook.
-
-2007-8-9  Fernando Perez  <fperez@planck.colorado.edu>
-
-        * IPython/ipapi.py (to_user_ns): update to accept a dict as well as
-          a string with names.
-
-2007-08-09  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_doctest_mode): added new %doctest_mode
-	magic to toggle on/off the doctest pasting support without having
-	to leave a session to switch to a separate profile.
-
-2007-08-08  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Extensions/ipy_profile_doctest.py (main): fix prompt to
-	introduce a blank line between inputs, to conform to doctest
-	requirements.
-
-	* IPython/OInspect.py (Inspector.pinfo): fix another part where
-	auto-generated docstrings for new-style classes were showing up.
-
-2007-08-07  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* api_changes: Add new file to track backward-incompatible
-	user-visible changes.
-
-2007-08-06  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py: fix bug where user_config_ns didn't exist at all
-	before all the config files were handled.
-
-2007-08-04  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/irunner.py (RunnerFactory): Add new factory class for
-	creating reusable runners based on filenames.
-
-	* IPython/Extensions/ipy_profile_doctest.py: New profile for
-	doctest support.  It sets prompts/exceptions as similar to
-	standard Python as possible, so that ipython sessions in this
-	profile can be easily pasted as doctests with minimal
-	modifications.  It also enables pasting of doctests from external
-	sources (even if they have leading whitespace), so that you can
-	rerun doctests from existing sources.
-
-	* IPython/iplib.py (_prefilter): fix a buglet where after entering
-	some whitespace, the prompt would become a continuation prompt
-	with no way of exiting it other than Ctrl-C.  This fix brings us
-	into conformity with how the default python prompt works.
-
-	* IPython/Extensions/InterpreterPasteInput.py (prefilter_paste):
-	Add support for pasting not only lines that start with '>>>', but
-	also with ' >>>'.  That is, arbitrary whitespace can now precede
-	the prompts.  This makes the system useful for pasting doctests
-	from docstrings back into a normal session.
-
-2007-08-02  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellEmbed.__call__): fix bug introduced in
-	r1357, which had killed multiple invocations of an embedded
-	ipython (this means that example-embed has been broken for over 1
-	year!!!).  Rather than possibly breaking the batch stuff for which
-	the code in iplib.py/interact was introduced, I worked around the
-	problem in the embedding class in Shell.py.  We really need a
-	bloody test suite for this code, I'm sick of finding stuff that
-	used to work breaking left and right every time I use an old
-	feature I hadn't touched in a few months.
-	(kill_embedded): Add a new magic that only shows up in embedded
-	mode, to allow users to permanently deactivate an embedded instance.
-
-2007-08-01  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py, ipy_profile_sh.py (runlines): Fix the bug where raw
-        history gets out of sync on runlines (e.g. when running macros).
-
-2007-07-31  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_colors): fix win32-related error message
-	that could appear under *nix when readline was missing.  Patch by
-	Scott Jackson, closes #175.
-
-2007-07-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Extensions/ipy_traits_completer.py: Add a new custom
-	completer that it traits-aware, so that traits objects don't show
-	all of their internal attributes all the time.
-
-	* IPython/genutils.py (dir2): moved this code from inside
-	completer.py to expose it publicly, so I could use it in the
-	wildcards bugfix.
-
-	* IPython/wildcard.py (NameSpace.__init__): fix a bug reported by
-	Stefan with Traits.
-
-	* IPython/completer.py (Completer.attr_matches): change internal
-	var name from 'object' to 'obj', since 'object' is now a builtin
-	and this can lead to weird bugs if reusing this code elsewhere.
-
-2007-07-25  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/OInspect.py (Inspector.pinfo): fix small glitches in
-	'foo?' and update the code to prevent printing of default
-	docstrings that started appearing after I added support for
-	new-style classes.  The approach I'm using isn't ideal (I just
-	special-case those strings) but I'm not sure how to more robustly
-	differentiate between truly user-written strings and Python's
-	automatic ones.
-
-2007-07-09  Ville Vainio  <vivainio@gmail.com>
-
-	* completer.py: Applied Matthew Neeley's patch:
-        Dynamic attributes from trait_names and _getAttributeNames are added
-        to the list of tab completions, but when this happens, the attribute
-        list is turned into a set, so the attributes are unordered when
-        printed, which makes it hard to find the right completion. This patch
-        turns this set back into a list and sort it.
-
-2007-07-06  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/OInspect.py (Inspector.pinfo): Add support for new-style
-	classes in various inspector functions.
-
-2007-06-28  Ville Vainio  <vivainio@gmail.com>
-
-	* shadowns.py, iplib.py, ipapi.py, OInspect.py:
-        Implement "shadow" namespace, and callable aliases that reside there.
-        Use them by:
-        
-        _ip.defalias('foo',myfunc) # creates _sh.foo that points to myfunc
-        
-        foo hello world
-         (gets translated to:)
-        _sh.foo(r"""hello world""")
-
-        In practice, this kind of alias can take the role of a magic function        
-
-        * New generic inspect_object, called on obj? and obj??
-
-2007-06-15  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ultraTB.py (findsource): fix a problem with
-	inspect.getfile that can cause crashes during traceback construction.
-
-2007-06-14  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py (handle_auto): Try to use ascii for printing "--->"
-        autocall rewrite indication, becausesometimes unicode fails to print
-        properly (and you get ' - - - '). Use plain uncoloured ---> for
-        unicode.
-        
-        * shadow history. Usable through "%hist -g <pat>" and "%rep 0123".
-        
-        . pickleshare 'hash' commands (hget, hset, hcompress,
-        hdict) for efficient shadow history storage.
-
-2007-06-13  Ville Vainio  <vivainio@gmail.com>
-
-	* ipapi.py: _ip.to_user_ns(vars, interactive = True).
-        Added kw arg 'interactive', tell whether vars should be visible
-        with %whos.
-
-2007-06-11  Ville Vainio  <vivainio@gmail.com>
-
-	* pspersistence.py, Magic.py, iplib.py: directory history now saved 
-	to db
-    
-	* iplib.py: "ipython -c <cmd>" now passes the command through prefilter.
-	Also, it exits IPython immediately after evaluating the command (just like 
-	std python)
-
-2007-06-05  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: Added a new table icap, which executes a
-	Python string and captures the output. (Idea and original patch by
-	Stefan van der Walt)
-
-2007-06-01  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.text): update printing of
-	exception types for Python 2.5 (now all exceptions in the stdlib
-	are new-style classes).
-
-2007-05-31  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/igrid.py: Add new commands refresh and
-	refresh_timer (mapped to "R"/"F5" and to the menu) which restarts
-	the iterator once (refresh) or after every x seconds (refresh_timer).
-	Add a working implementation of "searchexpression", where the text
-	entered is not the text to search for, but an expression that must
-	be true. Added display of shortcuts to the menu. Added commands "pickinput"
-	and "pickinputattr" that put the object or attribute under the cursor
-	in the input line. Split the statusbar to be able to display the currently
-	active refresh interval. (Patch by Nik Tautenhahn)
-
-2007-05-29  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
-	
-	* fixing set_term_title to use ctypes as default
-
-	* fixing set_term_title fallback to work when curent dir 
-	  is on a windows network share
-
-2007-05-28  Ville Vainio  <vivainio@gmail.com>
-
-	* %cpaste: strip + with > from left (diffs).
-        
-        * iplib.py: Fix crash when readline not installed
-
-2007-05-26  Ville Vainio  <vivainio@gmail.com>
-
-	* generics.py: introduce easy to extend result_display generic
-        function (using simplegeneric.py).
-        
-        * Fixed the append functionality of %set.
-
-2007-05-25  Ville Vainio  <vivainio@gmail.com>
-
-	* New magic: %rep (fetch / run old commands from history)
-        
-        * New extension: mglob (%mglob magic), for powerful glob / find /filter
-        like functionality
-        
-        % maghistory.py: %hist -g PATTERM greps the history for pattern
-
-2007-05-24  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: Added a Table ihist that can be used to
-	browse the IPython input history
-
-	* IPython/Extensions/ibrowse.py: Added two command to ibrowse: pickinput
-	(mapped to "i") can be used to put the object under the curser in the input
-	line. pickinputattr (mapped to "I") does the same for the attribute under
-	the cursor.
-
-2007-05-24  Ville Vainio  <vivainio@gmail.com>
-
-	* Grand magic cleansing (changeset [2380]):
-        
-        * Introduce ipy_legacy.py where the following magics were
-        moved:
-        
-        pdef pdoc psource pfile rehash dhist Quit p r automagic autocall
-        
-        If you need them, either use default profile or "import ipy_legacy"
-        in your ipy_user_conf.py
-        
-        * Move sh and scipy profile to Extensions from UserConfig. this implies
-        you should not edit them, but you don't need to run %upgrade when
-        upgrading IPython anymore.
-        
-        * %hist/%history now operates in "raw" mode by default. To get the old
-        behaviour, run '%hist -n' (native mode).
-        
-        * split ipy_stock_completers.py to ipy_stock_completers.py and
-        ipy_app_completers.py. Stock completers (%cd, import, %run) are now
-        installed as default.
-        
-        * sh profile now installs ipy_signals.py, for (hopefully) better ctrl+c
-        handling.
-        
-        * iplib.py, ipapi.py: _ip.set_next_input(s) sets the next ("default")
-        input if readline is available.
-	
-2007-05-23  Ville Vainio  <vivainio@gmail.com>
-
-	* macro.py: %store uses __getstate__ properly
-	
-	* exesetup.py: added new setup script for creating
-	standalone IPython executables with py2exe (i.e.
-	no python installation required).
-	
-	* Removed ipythonrc-scipy, ipy_profile_scipy.py takes
-	its place.
-        
-        * rlineimpl.py, genutils.py (get_home_dir): py2exe support
-	
-2007-05-21  Ville Vainio  <vivainio@gmail.com>
-
-	* platutil_win32.py (set_term_title): handle
-	failure of 'title' system call properly.
-
-2007-05-17  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: Fix xrepr for ifiles.
-	(Bug detected by Paul Mueller).
-
-2007-05-16  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_profile_sci.py, ipython_win_post_install.py: Create
-	new "sci" profile, effectively a modern version of the old
-	"scipy" profile (which is now slated for deprecation).
-
-2007-05-15  Ville Vainio  <vivainio@gmail.com>
-
-	* pycolorize.py, pycolor.1: Paul Mueller's patches that
-	make pycolorize read input from stdin when run without arguments.
-	
-	* Magic.py: do not require 'PATH' in %rehash/%rehashx. Closes #155
-	
-	* ipy_rehashdir.py: rename ext_rehashdir to ipy_rehashdir, import
-	it in sh profile (instead of ipy_system_conf.py).
-
-	* Magic.py, ipy_rehashdir.py, ipy_profile_sh.py: System command
-	aliases are now lower case on windows (MyCommand.exe => mycommand).
-	
-	* macro.py, ipapi.py, iplib.py, Prompts.py: Macro system rehaul.
-	Macros are now callable objects that inherit from ipapi.IPyAutocall,
-	i.e. get autocalled regardless of system autocall setting.
-
-2007-05-10  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/rlineimpl.py: check for clear_history in readline and
-	make it a dummy no-op if not available.  This function isn't
-	guaranteed to be in the API and appeared in Python 2.4, so we need
-	to check it ourselves.  Also, clean up this file quite a bit.
-
-	* ipython.1: update man page and full manual with information
-	about threads (remove outdated warning).  Closes #151.
-
-2007-05-09  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Extensions/ipy_constants.py: Add Gael's constants module
-	in trunk (note that this made it into the 0.8.1 release already,
-	but the changelogs didn't get coordinated).  Many thanks to Gael
-	Varoquaux <gael.varoquaux-AT-normalesup.org>
-
-2007-05-09  *** Released version 0.8.1
-
-2007-05-10  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/igrid.py: Incorporate html help into
-	the module, so we don't have to search for the file.
-
-2007-05-02  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* test/test_irunner.py (RunnerTestCase._test_runner): Close #147.
-
-2007-04-30  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: (pre_config_initialization) Catch UnicodeDecodeError if the
-	user has illegal (non-ascii) home directory name
-
-2007-04-27  Ville Vainio  <vivainio@gmail.com>
-
-	* platutils_win32.py: implement set_term_title for windows
-	
-	* Update version number
-	
-	* ipy_profile_sh.py: more informative prompt (2 dir levels)
-
-2007-04-26  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/igrid.py: (igrid) Fix bug that surfaced
-	when the igrid input raised an exception. (Patch by Nik Tautenhahn,
-	bug discovered by Ville).
-
-2007-04-26  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_completers.py: Olivier's module completer now
-	saves the list of root modules if it takes > 4 secs on the first run.
-	
-	* Magic.py (%rehashx): %rehashx now clears the completer cache
-	
-
-2007-04-26  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* ipython.el: fix incorrect color scheme, reported by Stefan.
-	Closes #149.
-
-	* IPython/PyColorize.py (Parser.format2): fix state-handling
-	logic.  I still don't like how that code handles state, but at
-	least now it should be correct, if inelegant.  Closes #146.
-
-2007-04-25  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_which.py: added extension for %which magic, works
-	a lot like unix 'which' but also finds and expands aliases, and
-	allows wildcards.
-
-	* ipapi.py (expand_alias): Now actually *return* the expanded alias,
-	as opposed to returning nothing.
-	
-	* UserConfig/ipy_user_conf.py, ipy_profile_sh.py: do not import
-	ipy_stock_completers on default profile, do import on sh profile.
-
-2007-04-22  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
-
-	* Fix bug in iplib.py/safe_execfile when launching ipython with a script
-	like ipython.py foo.py which raised a IndexError.
-
-2007-04-21  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_extutil.py: added extension to manage other ipython
-	extensions. Now only supports 'ls' == list extensions.
-
-2007-04-20  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Debugger.py (BdbQuit_excepthook): fix small bug that
-	would prevent use of the exception system outside of a running
-	IPython instance.
-
-2007-04-20  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_render.py: added extension for easy
-	interactive text template rendering (to clipboard). Uses Ka-Ping Yee's
-	'Iptl' template notation, 
-	
-	* Extensions/ipy_completers.py: introduced Olivier Lauzanne's
-	safer & faster 'import' completer.
-	
-	* ipapi.py: Introduced new ipapi methods, _ip.defmacro(name, value)
-	and _ip.defalias(name, command).
-	
-	* Extensions/ipy_exportdb.py: New extension for exporting all the
-	%store'd data in a portable format (normal ipapi calls like
-	defmacro() etc.)
-	
-2007-04-19  Ville Vainio  <vivainio@gmail.com>
-
-	* upgrade_dir.py: skip junk files like *.pyc
-	
-	* Release.py: version number to 0.8.1
-
-2007-04-18  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py (safe_execfile): make "ipython foo.py" work with 2.5.1c1
-	and later on win32.
-
-2007-04-16  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py (showtraceback): Do not crash when running w/o readline.
-
-2007-04-12  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: (ils) Directoy listings are now
-	sorted (case sensitive with files and dirs mixed).
-
-2007-04-10  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Release.py (version): Open trunk for 0.8.1 development.
-
-2007-04-10  *** Released version 0.8.0
-
-2007-04-07  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* Tag 0.8.0 for release.
-	
-	* IPython/iplib.py (reloadhist): add API function to cleanly
-	reload the readline history, which was growing inappropriately on
-	every %run call.
-
-	* win32_manual_post_install.py (run): apply last part of Nicolas
-	Pernetty's patch (I'd accidentally applied it in a different
-	directory and this particular file didn't get patched).
-
-2007-04-05  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (MAIN_THREAD_ID): get rid of my stupid hack to
-	find the main thread id and use the proper API call.  Thanks to
-	Stefan for the fix.
-
-	* test/test_prefilter.py (esc_handler_tests): udpate one of Dan's
-	unit tests to reflect fixed ticket #52, and add more tests sent by
-	him.
-
-	* IPython/iplib.py (raw_input): restore the readline completer
-	state on every input, in case third-party code messed it up.
-	(_prefilter): revert recent addition of early-escape checks which
-	prevent many valid alias calls from working.
-
-	* IPython/Shell.py (MTInteractiveShell.runcode): add a tracking
-	flag for sigint handler so we don't run a full signal() call on
-	each runcode access.
-
-	* IPython/Magic.py (magic_whos): small improvement to diagnostic
-	message.
-
-2007-04-04  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (sigint_handler): I *THINK* I finally got
-	asynchronous exceptions working, i.e., Ctrl-C can actually
-	interrupt long-running code in the multithreaded shells.
-
-	This is using Tomer Filiba's great ctypes-based trick:
-	http://sebulba.wikispaces.com/recipe+thread2.  I'd already tried
-	this in the past, but hadn't been able to make it work before.  So
-	far it looks like it's actually running, but this needs more
-	testing.  If it really works, I'll be *very* happy, and we'll owe
-	a huge thank you to Tomer.  My current implementation is ugly,
-	hackish and uses nasty globals, but I don't want to try and clean
-	anything up until we know if it actually works.
-
-	NOTE: this feature needs ctypes to work.  ctypes is included in
-	Python2.5, but 2.4 users will need to manually install it.  This
-	feature makes multi-threaded shells so much more usable that it's
-	a minor price to pay (ctypes is very easy to install, already a
-	requirement for win32 and available in major linux distros).
-
-2007-04-04  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_completers.py, ipy_stock_completers.py:
-	Moved implementations of 'bundled' completers to ipy_completers.py,
-	they are only enabled in ipy_stock_completers.py.
-
-2007-04-04  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/PyColorize.py (Parser.format2): Fix identation of
-	colorzied output and return early if color scheme is NoColor, to
-	avoid unnecessary and expensive tokenization.  Closes #131.
-
-2007-04-03  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Debugger.py: disable the use of pydb version 1.17.  It
-	has a critical bug (a missing import that makes post-mortem not
-	work at all).  Unfortunately as of this time, this is the version
-	shipped with Ubuntu Edgy, so quite a few people have this one.  I
-	hope Edgy will update to a more recent package.
-
-2007-04-02  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (_prefilter): close #52, second part of a patch
-	set by Stefan (only the first part had been applied before).
-
-	* IPython/Extensions/ipy_stock_completers.py (module_completer):
-	remove usage of the dangerous pkgutil.walk_packages().  See
-	details in comments left in the code.
-
-	* IPython/Magic.py (magic_whos): add support for numpy arrays
-	similar to what we had for Numeric.
-
-	* IPython/completer.py (IPCompleter.complete): extend the
-	complete() call API to support completions by other mechanisms
-	than readline.  Closes #109.
-
-	* IPython/iplib.py (safe_execfile): add a safeguard under Win32 to
-	protect against a bug in Python's execfile().  Closes #123.
-
-2007-04-01  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (split_user_input): ensure that when splitting
-	user input, the part that can be treated as a python name is pure
-	ascii (Python identifiers MUST be pure ascii).  Part of the
-	ongoing Unicode support work.
-
-	* IPython/Prompts.py (prompt_specials_color): Add \N for the
-	actual prompt number, without any coloring.  This allows users to
-	produce numbered prompts with their own colors.  Added after a
-	report/request by Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
-
-2007-03-31  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/igrid.py: Map the return key
-	to enter() and shift-return to enterattr().
-
-2007-03-30  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_psearch): add unicode support by
-	encoding to ascii the input, since this routine also only deals
-	with valid Python names.  Fixes a bug reported by Stefan.
-
-2007-03-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (_inspect): convert unicode input into ascii
-	before trying to evaluate it as a Python identifier.  This fixes a
-	problem that the new unicode support had introduced when analyzing
-	long definition lines for functions.
-
-2007-03-24  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/igrid.py: Fix picking. Using
-	igrid with wxPython 2.6 and -wthread should work now.
-	igrid.display() simply tries to create a frame without
-	an application. Only if this fails an application is created.
-
-2007-03-23  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/path.py: Updated to version 2.2.
-
-2007-03-23  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: recursive alias expansion now works better, so that
-	cases like 'top' -> 'd:/cygwin/top' -> 'ls :/cygwin/top'
-	doesn't trip up the process, if 'd' has been aliased to 'ls'.
-	
-	* Extensions/ipy_gnuglobal.py added, provides %global magic
-	for users of http://www.gnu.org/software/global
-	
-	* iplib.py: '!command /?' now doesn't invoke IPython's help system.
-	Closes #52. Patch by Stefan van der Walt.
-
-2007-03-23  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/FakeModule.py (FakeModule.__init__): Small fix to
-	respect the __file__ attribute when using %run.  Thanks to a bug
-	report by Sebastian Rooks <sebastian.rooks-AT-free.fr>.
-
-2007-03-22  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (raw_input): Fix mishandling of unicode at
-	input.  Patch sent by Stefan.
-
-2007-03-20  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
-	* IPython/Extensions/ipy_stock_completer.py
-	shlex_split, fix bug in shlex_split. len function
-	call was missing an if statement. Caused shlex_split to
-	sometimes return "" as last element.
-
-2007-03-18  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/completer.py
-	(IPCompleter.file_matches.single_dir_expand): fix a problem
-	reported by Stefan, where directories containign a single subdir
-	would be completed too early.
-
-	* IPython/Shell.py (_load_pylab): Make the execution of 'from
-	pylab import *' when -pylab is given be optional.  A new flag,
-	pylab_import_all controls this behavior, the default is True for
-	backwards compatibility.
-
-	* IPython/ultraTB.py (_formatTracebackLines): Added (slightly
-	modified) R. Bernstein's patch for fully syntax highlighted
-	tracebacks.  The functionality is also available under ultraTB for
-	non-ipython users (someone using ultraTB but outside an ipython
-	session).  They can select the color scheme by setting the
-	module-level global DEFAULT_SCHEME.  The highlight functionality
-	also works when debugging.
-
-	* IPython/genutils.py (IOStream.close): small patch by
-	R. Bernstein for improved pydb support.
-
-	* IPython/Debugger.py (Pdb.format_stack_entry): Added patch by
-	DaveS <davls@telus.net> to improve support of debugging under
-	NTEmacs, including improved pydb behavior.
-
-	* IPython/Magic.py (magic_prun): Fix saving of profile info for
-	Python 2.5, where the stats object API changed a little.  Thanks
-	to a bug report by Paul Smith <paul.smith-AT-catugmt.com>.
-	
-	* IPython/ColorANSI.py (InputTermColors.Normal): applied Nicolas
-	Pernetty's patch to improve support for (X)Emacs under Win32.
-
-2007-03-17  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (hijack_wx): ipmort WX with current semantics
-	to quiet a deprecation warning that fires with Wx 2.8.  Thanks to
-	a report by Nik Tautenhahn.
-
-2007-03-16  Walter Doerwald  <walter@livinglogic.de>
-
-	* setup.py: Add the igrid help files to the list of data files
-	to be installed alongside igrid.
-	* IPython/Extensions/igrid.py: (Patch by Nik Tautenhahn)
-	Show the input object of the igrid browser as the window tile.
-	Show the object the cursor is on in the statusbar.
-
-2007-03-15  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_stock_completers.py: Fixed exception
-        on mismatching quotes in %run completer. Patch by
-        Jorgen Stenarson. Closes #127.
-
-2007-03-14  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ext_rehashdir.py: Do not do auto_alias
-        in %rehashdir, it clobbers %store'd aliases.
-        
-        * UserConfig/ipy_profile_sh.py: envpersist.py extension
-        (beefed up %env) imported for sh profile.
-
-2007-03-10  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: Prefer ibrowse over igrid
-	as the default browser.
-	* IPython/Extensions/igrid.py: Make a few igrid attributes private.
-	As igrid displays all attributes it ever encounters, fetch() (which has
-	been renamed to _fetch()) doesn't have to recalculate the display attributes
-	every time a new item is fetched. This should speed up scrolling.
-
-2007-03-10  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): fix for Alex
-	Schmolck's recently reported tab-completion bug (my previous one
-	had a problem).  Patch by Dan Milstein <danmil-AT-comcast.net>.
-
-2007-03-09  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/igrid.py: Patch by Nik Tautenhahn:
-	Close help window if exiting igrid.
-
-2007-03-02  Jorgen Stenarson  <jorgen.stenarson@bostream.nu>
-
-	* IPython/Extensions/ipy_defaults.py: Check if readline is available
-	before calling functions from readline.
-
-2007-03-02  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/igrid.py: Add Nik Tautenhahns igrid extension.
-	igrid is a wxPython-based display object for ipipe. If your system has
-	wx installed igrid will be the default display. Without wx ipipe falls
-	back to ibrowse (which needs curses). If no curses is installed ipipe
-	falls back to idump.
-
-2007-03-01  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (split_user_inputBROKEN): temporarily disable
-	my changes from yesterday, they introduced bugs.  Will reactivate
-	once I get a correct solution, which will be much easier thanks to
-	Dan Milstein's new prefilter test suite.
-
-2007-02-28  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (split_user_input): fix input splitting so we
-	don't attempt attribute accesses on things that can't possibly be
-	valid Python attributes.  After a bug report by Alex Schmolck.
-	(InteractiveShell.__init__): brown-paper bag fix; regexp broke
-	%magic with explicit % prefix.
-
-2007-02-27  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.mainloop): update threads calls to
-	avoid a DeprecationWarning from GTK.
-
-2007-02-22  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/genutils.py (clock): I modified clock() to return total
-	time, user+system.  This is a more commonly needed metric.  I also
-	introduced the new clocku/clocks to get only user/system time if
-	one wants those instead.
-	
-	***WARNING: API CHANGE*** clock() used to return only user time,
-	so if you want exactly the same results as before, use clocku
-	instead.
-
-2007-02-22  Ville Vainio  <vivainio@gmail.com>
-
-	* IPython/Extensions/ipy_p4.py: Extension for improved
-        p4 (perforce version control system) experience.
-        Adds %p4 magic with p4 command completion and
-        automatic -G argument (marshall output as python dict)
-
-2007-02-19  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/demo.py (Demo.re_stop): make dashes optional in demo
-	stop marks. 
-	(ClearingMixin): a simple mixin to easily make a Demo class clear
-	the screen in between blocks and have empty marquees. The
-	ClearDemo and ClearIPDemo classes that use it are included.
-
-2007-02-18  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/irunner.py (pexpect_monkeypatch): patch pexpect to
-	protect against exceptions at Python shutdown time.  Patch
-	sumbmitted to upstream.
-
-2007-02-14  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: If entering the first object level
-	(i.e. the object for which the browser has been started) fails,
-	now the error is raised directly (aborting the browser) instead of
-	running into an empty levels list later.
-
-2007-02-03  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: Add an xrepr implementation
-	for the noitem object.
-
-2007-01-31  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/completer.py (Completer.attr_matches): Fix small
-	tab-completion bug with Enthought Traits objects with units.
-	Thanks to a bug report by Tom Denniston
-	<tom.denniston-AT-alum.dartmouth.org>.
-
-2007-01-27  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Extensions/ipy_stock_completers.py (runlistpy): fix a
-	bug where only .ipy or .py would be completed.  Once the first
-	argument to %run has been given, all completions are valid because
-	they are the arguments to the script, which may well be non-python
-	filenames.
-
-	* IPython/irunner.py (InteractiveRunner.run_source): major updates
-	to irunner to allow it to correctly support real doctesting of
-	out-of-process ipython code.
-
-	* IPython/Magic.py (magic_cd): Make the setting of the terminal
-	title an option (-noterm_title) because it completely breaks
-	doctesting.
-
-	* IPython/demo.py: fix IPythonDemo class that was not actually working.
-
-2007-01-24  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/irunner.py (main): fix small bug where extensions were
-	not being correctly recognized.
-
-2007-01-23  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py (xiter): Make sure that iterating
-	a string containing a single line yields the string itself as the
-	only item.
-
-	* IPython/Extensions/ibrowse.py (ibrowse): Avoid entering an
-	object if it's the same as the one on the last level (This avoids
-	infinite recursion for one line strings).
-
-2007-01-17  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ultraTB.py (AutoFormattedTB.__call__): properly flush
-	all output streams before printing tracebacks.  This ensures that
-	user output doesn't end up interleaved with traceback output.
-
-2007-01-10  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/envpersist.py: Turbocharged %env that remembers
-	env vars across sessions; e.g. "%env PATH+=;/opt/scripts" or
-	"%env VISUAL=jed".
-
-2007-01-05  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (showtraceback): ensure that we correctly call
-	custom handlers in all cases (some with pdb were slipping through,
-	but I'm not exactly sure why).
-
-	* IPython/Debugger.py (Tracer.__init__): added new class to
-	support set_trace-like usage of IPython's enhanced debugger.
-
-2006-12-24  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py: more informative message when ipy_user_conf
-	import fails (suggest running %upgrade).
-	
-	* tools/run_ipy_in_profiler.py: Utility to see where
-	the time during IPython startup is spent.
-	
-2006-12-20  Ville Vainio  <vivainio@gmail.com>
-
-	* 0.7.3 is out - merge all from 0.7.3 branch to trunk
-
-	* ipapi.py: Add new ipapi method, expand_alias.
-	
-	* Release.py: Bump up version to 0.7.4.svn
-
-2006-12-17  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/jobctrl.py: Fixed &cmd arg arg... 
-	to work properly on posix too
-	
-	* Release.py: Update revnum (version is still just 0.7.3).
-
-2006-12-15  Ville Vainio  <vivainio@gmail.com>
-
-	* scripts/ipython_win_post_install: create ipython.py in
-	prefix + "/scripts".
-	
-	* Release.py: Update version to 0.7.3.
-    
-2006-12-14  Ville Vainio  <vivainio@gmail.com>
-
-	* scripts/ipython_win_post_install: Overwrite old shortcuts
-	if they already exist
-
-	* Release.py: release 0.7.3rc2
-    
-2006-12-13  Ville Vainio  <vivainio@gmail.com>
-
-	* Branch and update Release.py for 0.7.3rc1
-
-2006-12-13  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellWX): update for current WX naming
-	conventions, to avoid a deprecation warning with current WX
-	versions.  Thanks to a report by Danny Shevitz.
-
-2006-12-12  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py: apply david cournapeau's patch to make
-	import_some work properly even when ipythonrc does 
-	import_some on empty list (it was an old bug!).
-
-	* UserConfig/ipy_user_conf.py, UserConfig/ipythonrc:
-	Add deprecation note to ipythonrc and a url to wiki
-	in ipy_user_conf.py
-
-		 
-	* Magic.py (%run): %run myscript.ipy now runs myscript.ipy
-	as if it was typed on IPython command prompt, i.e.
-	as IPython script.
-	
-	* example-magic.py, magic_grepl.py: remove outdated examples
-
-2006-12-11  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-        * IPython/iplib.py (debugger): prevent a nasty traceback if %debug
-        is called before any exception has occurred.
-	
-2006-12-08  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_stock_completers.py: fix cd completer 
-	to translate /'s to \'s again.
-	
-	* completer.py: prevent traceback on file completions w/ 
-	backslash.
-	
-	* Release.py: Update release number to 0.7.3b3 for release
-
-2006-12-07  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipy_signals.py: Ignore ctrl+C in IPython process
-	while executing external code. Provides more shell-like behaviour
-	and overall better response to ctrl + C / ctrl + break.
-
-	* tools/make_tarball.py: new script to create tarball straight from svn
-	(setup.py sdist doesn't work on win32).
-
-	* Extensions/ipy_stock_completers.py: fix cd completer to give up
-	on dirnames with spaces and use the default completer instead.
-
-	* Revision.py: Change version to 0.7.3b2 for release.
-
-2006-12-05  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py, iplib.py, completer.py: Apply R. Bernstein's
-	pydb patch 4 (rm debug printing, py 2.5 checking)
-
-2006-11-30  Walter Doerwald  <walter@livinglogic.de>
-	* IPython/Extensions/ibrowse.py: Add two new commands to ibrowse:
-	"refresh" (mapped to "r") refreshes the screen by restarting the iterator.
-	"refreshfind" (mapped to "R") does the same but tries to go back to the same
-	object the cursor was on before the refresh. The command "markrange" is
-	mapped to "%" now.
-	* IPython/Extensions/ibrowse.py: Make igrpentry and ipwdentry comparable.
-
-2006-11-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_debug): new %debug magic to activate the
-	interactive debugger on the last traceback, without having to call
-	%pdb and rerun your code.  Made minor changes in various modules,
-	should automatically recognize pydb if available.
-
-2006-11-28  Ville Vainio  <vivainio@gmail.com>
-
-	* completer.py: If the text start with !, show file completions
-	properly. This helps when trying to complete command name
-	for shell escapes.
-
-2006-11-27  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_stock_completers.py: bzr completer submitted by Stefan van 
-	der Walt. Clean up svn and hg completers by using a common 
-	vcs_completer. 
-	
-2006-11-26  Ville Vainio  <vivainio@gmail.com>
-
-	* Remove ipconfig and %config; you should use _ip.options structure
-	directly instead!
-	
-	* genutils.py: add wrap_deprecated function for deprecating callables
-	
-	* iplib.py: deprecate ipmagic, ipsystem, ipalias. Use _ip.magic and
-	_ip.system instead. ipalias is redundant.
-	
-	* Magic.py: %rehashdir no longer aliases 'cmdname' to 'cmdname.exe' on 
-	win32, but just 'cmdname'. Other extensions (non-'exe') are still made 
-	explicit.
-
-	* ipy_stock_completers.py: 'hg' (mercurial VCS) now has a custom 
-	completer. Try it by entering 'hg ' and pressing tab.
-
-	* macro.py: Give Macro a useful __repr__ method
-	
-	* Magic.py: %whos abbreviates the typename of Macro for brevity.
-	
-2006-11-24  Walter Doerwald  <walter@livinglogic.de>
-	* IPython/Extensions/astyle.py: Do a relative import of ipipe, so that
-	we don't get a duplicate ipipe module, where registration of the xrepr
-	implementation for Text is useless.
-
-	* IPython/Extensions/ipipe.py: Fix __xrepr__() implementation for ils.
-
-	* IPython/Extensions/ibrowse.py: Fix keymapping for the enter command.
-
-2006-11-24  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py, manual_base.lyx: Kirill Smelkov patch: 
-	try to use "cProfile" instead of the slower pure python
-	"profile"
-
-2006-11-23  Ville Vainio  <vivainio@gmail.com>
-
-	* manual_base.lyx: Kirill Smelkov patch: Fix wrong 
-	Qt+IPython+Designer link in documentation.
-	
-	* Extensions/ipy_pydb.py: R. Bernstein's patch for passing 
-	correct Pdb object to %pydb.
-
-
-2006-11-22  Walter Doerwald  <walter@livinglogic.de>
-	* IPython/Extensions/astyle.py: Text needs it's own implemenation of the
-	generic xrepr(), otherwise the list implementation would kick in.
-
-2006-11-21  Ville Vainio  <vivainio@gmail.com>
-
-	* upgrade_dir.py: Now actually overwrites a nonmodified user file
-	with one from UserConfig.
-	
-	* ipy_profile_sh.py: Add dummy "depth" to var_expand lambda, 
-	it was missing which broke the sh profile.
-	
-	* completer.py: file completer now uses explicit '/' instead
-	of os.path.join, expansion of 'foo' was broken on win32 
-	if there was one directory with name 'foobar'. 
-
-	* A bunch of patches from Kirill Smelkov:
-	
-	* [patch 9/9] doc: point bug-tracker URL to IPythons trac-tickets.
-
-	* [patch 7/9] Implement %page -r (page in raw mode) - 
-
-	* [patch 5/9] ScientificPython webpage has moved
-
-	* [patch 4/9] The manual mentions %ds, should be %dhist
-
-	* [patch 3/9] Kill old bits from %prun doc.
-
-	* [patch 1/9] Fix typos here and there.
-
-2006-11-08  Ville Vainio  <vivainio@gmail.com>
-
-	* completer.py (attr_matches): catch all exceptions raised 
-	by eval of expr with dots.
-
-2006-11-07  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (runsource): Prepend an 'if 1:' to the user
-	input if it starts with whitespace.  This allows you to paste
-	indented input from any editor without manually having to type in
-	the 'if 1:', which is convenient when working interactively.
-	Slightly modifed version of a patch by Bo Peng
-	<bpeng-AT-rice.edu>.
-
-2006-11-03  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/irunner.py (main): modified irunner so it automatically
-	recognizes the right runner to use based on the extension (.py for
-	python, .ipy for ipython and .sage for sage).
-
-	* IPython/iplib.py (InteractiveShell.ipconfig): new builtin, also
-	visible in ipapi as ip.config(), to programatically control the
-	internal rc object.  There's an accompanying %config magic for
-	interactive use, which has been enhanced to match the
-	funtionality in ipconfig.
-
-	* IPython/Magic.py (magic_system_verbose): Change %system_verbose
-	so it's not just a toggle, it now takes an argument.  Add support
-	for a customizable header when making system calls, as the new
-	system_header variable in the ipythonrc file.
-
-2006-11-03  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: xrepr(), xiter() and xattrs() are now
-	generic functions (using Philip J. Eby's simplegeneric package).
-	This makes it possible to customize the display of third-party classes
-	without having to monkeypatch them. xiter() no longer supports a mode
-	argument and the XMode class has been removed. The same functionality can
-	be implemented via IterAttributeDescriptor and IterMethodDescriptor.
-	One consequence of the switch to generic functions is that xrepr() and
-	xattrs() implementation must define the default value for the mode
-	argument themselves and xattrs() implementations must return real
-	descriptors.
-
-	* IPython/external: This new subpackage will contain all third-party
-	packages that are bundled with IPython. (The first one is simplegeneric).
-
-	* IPython/Extensions/ipipe.py (ifile/ils): Readd output of the parent
-	directory which as been dropped in r1703.
-
-	* IPython/Extensions/ipipe.py (iless): Fixed.
-
-	* IPython/Extensions/ibrowse: Fixed sorting under Python 2.3.
-
-2006-11-03  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.var_expand): fix stack
-	handling in variable expansion so that shells and magics recognize
-	function local scopes correctly.  Bug reported by Brian.
-
-	* scripts/ipython: remove the very first entry in sys.path which
-	Python auto-inserts for scripts, so that sys.path under IPython is
-	as similar as possible to that under plain Python.
-
-	* IPython/completer.py (IPCompleter.file_matches): Fix
-	tab-completion so that quotes are not closed unless the completion
-	is unambiguous.  After a request by Stefan.  Minor cleanups in
-	ipy_stock_completers.
-
-2006-11-02  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_stock_completers.py: Add %run and %cd completers.
-	
-	* completer.py: Try running custom completer for both 
-	"foo" and "%foo" if the command is just "foo". Ignore case
-	when filtering possible completions.
-	
-	* UserConfig/ipy_user_conf.py: install stock completers as default	
-	
-	* iplib.py (history_saving_wrapper), debugger(), ipy_pydb.py:
-	simplified readline history save / restore through a wrapper 
-	function
-	
-	
-2006-10-31  Ville Vainio  <vivainio@gmail.com>
-
-	* strdispatch.py, completer.py, ipy_stock_completers.py:
-	Allow str_key ("command") in completer hooks. Implement 
-	trivial completer for 'import' (stdlib modules only). Rename 
-	ipy_linux_package_managers.py to ipy_stock_completers.py.
-	SVN completer.
-	
-	* Extensions/ledit.py: %magic line editor for easily and
-	incrementally manipulating lists of strings. The magic command
-	name is %led.
-
-2006-10-30  Ville Vainio  <vivainio@gmail.com>
-
-	* Debugger.py, iplib.py (debugger()): Add last set of Rocky 
-	Bernsteins's patches for pydb integration.
-	http://bashdb.sourceforge.net/pydb/
-	
-	* strdispatch.py, iplib.py, completer.py, IPython/__init__.py,
-	Extensions/ipy_linux_package_managers.py, hooks.py: Implement 
-	custom completer hook to allow the users to implement their own 
-	completers. See ipy_linux_package_managers.py for example. The 
-	hook name is 'complete_command'. 
-
-2006-10-28  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/UserConfig/ipythonrc-scipy: minor cleanups to remove old
-	Numeric leftovers.
-
-	* ipython.el (py-execute-region): apply Stefan's patch to fix
-	garbled results if the python shell hasn't been previously started.
-
-	* IPython/genutils.py (arg_split): moved to genutils, since it's a
-	pretty generic function and useful for other things.
-
-	* IPython/OInspect.py (getsource): Add customizable source
-	extractor.  After a request/patch form W. Stein (SAGE).
-
-	* IPython/irunner.py (InteractiveRunner.run_source): reset tty
-	window size to a more reasonable value from what pexpect does,
-	since their choice causes wrapping bugs with long input lines.
-
-2006-10-28  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py (%run): Save and restore the readline history from 
-	file around %run commands to prevent side effects from 
-	%runned programs that might use readline (e.g. pydb).
-
-	* extensions/ipy_pydb.py: Adds %pydb magic when imported, for 
-	invoking the pydb enhanced debugger.
-
-2006-10-23  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py (ifile): Remove all methods that
-	call the base class method and propagate the return value to
-	ifile. This is now done by path itself.
-
-2006-10-15  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ipapi.py (IPApi.__init__): Added new entry to public
-	api: set_crash_handler(), to expose the ability to change the
-	internal crash handler.
-
-	* IPython/CrashHandler.py (CrashHandler.__init__): abstract out
-	the various parameters of the crash handler so that apps using
-	IPython as their engine can customize crash handling.  Ipmlemented
-	at the request of SAGE.
-
-2006-10-14  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py, ipython.el: applied first "safe" part of Rocky 
-	Bernstein's patch set for pydb integration.
-
-	* Magic.py (%unalias, %alias): %store'd aliases can now be
-	removed with '%unalias'. %alias w/o args now shows most 
-	interesting (stored / manually defined) aliases last
-	where they catch the eye w/o scrolling.
-
-	* Magic.py (%rehashx), ext_rehashdir.py: files with
-	'py' extension are always considered executable, even
-	when not in PATHEXT environment variable.
-
-2006-10-12  Ville Vainio  <vivainio@gmail.com>
-
-	* jobctrl.py: Add new "jobctrl" extension for spawning background
-	processes with "&find /". 'import jobctrl' to try it out. Requires
-	'subprocess' module, standard in python 2.4+.
-	
-	* iplib.py (expand_aliases, handle_alias): Aliases expand transitively, 
-	so if foo -> bar and bar -> baz, then foo -> baz.
-
-2006-10-09  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (Magic.parse_options): add a new posix option
-	to allow parsing of input args in magics that doesn't strip quotes
-	(if posix=False).  This also closes %timeit bug reported by
-	Stefan.
-
-2006-10-03  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py (raw_input, interact): Return ValueError catching for 
-	raw_input. Fixes infinite loop for sys.stdin.close() or 
-	sys.stdout.close().
-
-2006-09-27  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/irunner.py (InteractiveRunner.run_source): small fixes
-	to help in handling doctests.  irunner is now pretty useful for
-	running standalone scripts and simulate a full interactive session
-	in a format that can be then pasted as a doctest.
-
-	* IPython/iplib.py (InteractiveShell.__init__): Install exit/quit
-	on top of the default (useless) ones.  This also fixes the nasty
-	way in which 2.5's Quitter() exits (reverted [1785]).
-
-	* IPython/Debugger.py (Pdb.__init__): Fix ipdb to work with python
-	2.5.
-
-	* IPython/ultraTB.py (TBTools.set_colors): Make sure that ipdb
-	color scheme is updated as well when color scheme is changed
-	interactively. 
-
-2006-09-27  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py (raw_input): python 2.5 closes stdin on quit -> avoid
-    infinite loop and just exit. It's a hack, but will do for a while.
-
-2006-08-25  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py (ils): Add arguments dirs and files to
-	the constructor, this makes it possible to get a list of only directories
-	or only files.
-
-2006-08-12  Ville Vainio  <vivainio@gmail.com>
-
-	* Fakemodule.py, OInspect.py: Reverted 2006-08-11 mods,
-	they broke unittest 
-
-2006-08-11  Ville Vainio  <vivainio@gmail.com>
-
-	* Fakemodule.py, OInspect.py: remove 2006-08-09 monkepatch
-	by resolving issue properly, i.e. by inheriting FakeModule
-	from types.ModuleType. Pickling ipython interactive data
-	should still work as usual (testing appreciated).
-
-2006-08-09  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/OInspect.py: monkeypatch inspect from the stdlib if
-	running under python 2.3 with code from 2.4 to fix a bug with
-	help().  Reported by the Debian maintainers, Norbert Tretkowski
-	<norbert-AT-tretkowski.de> and Alexandre Fayolle
-	<afayolle-AT-debian.org>.
-
-2006-08-04  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Fixed the help message in the footer
-	(which was displaying "quit" twice).
-
-2006-07-28  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: Fix isort.__iter__() (was still using
-	the mode argument).
-
-2006-07-27  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py: Fix getglobals() if we're
-	not running under IPython.
-
-	* IPython/Extensions/ipipe.py: Rename XAttr to AttributeDetail
-	and make it iterable (iterating over the attribute itself). Add two new
-	magic strings for __xattrs__(): If the string starts with "-", the attribute
-	will not be displayed in ibrowse's detail view (but it can still be
-	iterated over). This makes it possible to add attributes that are large
-	lists or generator methods to the detail view. Replace magic attribute names
-	and _attrname() and _getattr() with "descriptors": For each type of magic
-	attribute name there's a subclass of Descriptor: None -> SelfDescriptor();
-	"foo" -> AttributeDescriptor("foo"); "foo()" -> MethodDescriptor("foo");
-	"-foo" -> IterAttributeDescriptor("foo"); "-foo()" -> IterMethodDescriptor("foo");
-	foo() -> FunctionDescriptor(foo). Magic strings returned from __xattrs__()
-	are still supported.
-
-	* IPython/Extensions/ibrowse.py: If fetching the next row from the input
-	fails in ibrowse.fetch(), the exception object is added as the last item
-	and item fetching is canceled. This prevents ibrowse from aborting if e.g.
-	a generator throws an exception midway through execution.
-
-	* IPython/Extensions/ipipe.py: Turn ifile's properties mimetype and
-	encoding into methods.
-
-2006-07-26  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: history now stores multiline input as single
-	history entries. Patch by Jorgen Cederlof.
-
-2006-07-18  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Make cursor visible over
-	non existing attributes.
-
-2006-07-14  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py (ix): Use os.popen4() so that the
-	error output of the running command doesn't mess up the screen.
-
-2006-07-13  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py (isort): Make isort usable without
-	argument. This sorts the items themselves.
-
-2006-07-12  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ipipe.py (eval, ifilter, isort, ieval):
-	Compile expression strings into code objects. This should speed
-	up ifilter and friends somewhat.
-
-2006-07-08  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py: %cpaste now strips > from the beginning of lines
-	to ease pasting quoted code from emails. Contributed by 
-	Stefan van der Walt.
-
-2006-06-29  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py, Shell.py: qt4agg matplotlib backend support for pylab
-	mode, patch contributed by Darren Dale. NEEDS TESTING! 
-
-2006-06-28  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Give the ibrowse cursor row
-	a blue background. Fix fetching new display rows when the browser
-	scrolls more than a screenful (e.g. by using the goto command).
-
-2006-06-27  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py (_inspect, _ofind) Apply David Huard's 
-	patch for displaying the correct docstring for 'property' 
-	attributes.
-
-2006-06-23  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Put the documentation of the keyboard
-	commands into the methods implementing them.
-
-2006-06-22  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* ipython.el (ipython-indentation-hook): cleanup patch, submitted
-	by Kov Chai <tchaikov-AT-gmail.com>.  He notes that the original
-	autoindent support was authored by Jin Liu.
-
-2006-06-22  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Replace the plain dictionaries used
-	for keymaps with a custom class that simplifies handling.
-
-2006-06-19  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: ibrowse now properly handles terminal
-	resizing. This requires Python 2.5 to work.
-
-2006-06-16  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Add two new commands to
-	ibrowse: "hideattr" (mapped to "h") hides the attribute under
-	the cursor. "unhiderattrs" (mapped to "H") reveals all hidden
-	attributes again. Remapped the help command to "?". Display
-	keycodes in the range 0x01-0x1F as CTRL-xx. Add CTRL-a and CTRL-e
-	as keys for the "home" and "end" commands. Add three new commands
-	to the input mode for "find" and friends: "delend" (CTRL-K)
-	deletes to the end of line. "incsearchup" searches upwards in the
-	command history for an input that starts with the text before the cursor.
-	"incsearchdown" does the same downwards. Removed a bogus mapping of
-	the x key to "delete".
-
-2006-06-15  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py, hooks.py: Added new generate_prompt hook that can be
-	used to create prompts dynamically, instead of the "old" way of
-	assigning "magic" strings to prompt_in1 and prompt_in2. The old
-	way still works (it's invoked by the default hook), of course.
-	
-	* Prompts.py: added generate_output_prompt hook for altering output
-	prompt
-
-	* Release.py: Changed version string to 0.7.3.svn.
-	
-2006-06-15  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Change _BrowserLevel.moveto() so that
-	the call to fetch() always tries to fetch enough data for at least one
-	full screen. This makes it possible to simply call moveto(0,0,True) in
-	the constructor. Fix typos and removed the obsolete goto attribute.
-
-2006-06-12  Ville Vainio  <vivainio@gmail.com>
-
-	* ipy_profile_sh.py: applied Krisha Mohan Gundu's patch for
-	allowing $variable interpolation within multiline statements,
-	though so far only with "sh" profile for a testing period.
-	The patch also enables splitting long commands with \ but it
-	doesn't work properly yet.
-
-2006-06-12  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py (_dodisplay): Display the length of the
-	input history and the position of the cursor in the input history for
-	the find, findbackwards and goto command.
-
-2006-06-10  Walter Doerwald  <walter@livinglogic.de>
-
-	* IPython/Extensions/ibrowse.py: Add a class _CommandInput that
-	implements the basic functionality of browser commands that require
-	input. Reimplement the goto, find and findbackwards commands as
-	subclasses of _CommandInput. Add an input history and keymaps to those
-	commands. Add "\r" as a keyboard shortcut for the enterdefault and
-	execute commands.
-
-2006-06-07  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: ipython mybatch.ipy exits ipython immediately after
-	running the batch files instead of leaving the session open.
-
-2006-06-07  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): update BSD fix, as
-	the original fix was incomplete.  Patch submitted by W. Maier.
-
-2006-06-07  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py,Magic.py, ipmaker.py (magic_rehashx):
-	Confirmation prompts can be supressed by 'quiet' option.
-	_ip.options.quiet = 1 means "assume yes for all yes/no queries".
-
-2006-06-06  *** Released version 0.7.2
-
-2006-06-06  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Release.py (version): Made 0.7.2 final for release.
-	Repo tagged and release cut.
-
-2006-06-05  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py (magic_rehashx): Honor no_alias list earlier in
-	%rehashx, to avoid clobbering builtins in ipy_profile_sh.py
-	
-	* upgrade_dir.py: try import 'path' module a bit harder
-	(for %upgrade)
-
-2006-06-03  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/genutils.py (ask_yes_no): treat EOF as a default answer
-	instead of looping 20 times.
-
-	* IPython/ipmaker.py (make_IPython): honor -ipythondir flag
-	correctly at initialization time.  Bug reported by Krishna Mohan
-	Gundu <gkmohan-AT-gmail.com> on the user list.
-
-	* IPython/Release.py (version): Mark 0.7.2 version to start
-	testing for release on 06/06.
-
-2006-05-31  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* scripts/irunner: thin script interface so users don't have to
-	find the module and call it as an executable, since modules rarely
-	live in people's PATH.
-
-	* IPython/irunner.py (InteractiveRunner.__init__): added
-	delaybeforesend attribute to control delays with newer versions of
-	pexpect.  Thanks to detailed help from pexpect's author, Noah
-	Spurrier <noah-AT-noah.org>.  Noted how to use the SAGE runner
-	correctly (it works in NoColor mode).
-
-	* IPython/iplib.py (handle_normal): fix nasty crash reported on
-	SAGE list, from improper log() calls.
-
-2006-05-31  Ville Vainio  <vivainio@gmail.com>
-
-	* upgrade_dir.py, Magic.py (magic_upgrade): call upgrade_dir
-	with args in parens to work correctly with dirs that have spaces.
-
-2006-05-30  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Logger.py (Logger.logstart): add option to log raw input
-	instead of the processed one.  A -r flag was added to the
-	%logstart magic used for controlling logging.
-
-2006-05-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): add check for the
-	*BSDs to omit --color from all 'ls' aliases, since *BSD ls doesn't
-	recognize the option.  After a bug report by Will Maier.  This
-	closes #64 (will do it after confirmation from W. Maier).
-
-	* IPython/irunner.py: New module to run scripts as if manually
-	typed into an interactive environment, based on pexpect.  After a
-	submission by Ken Schutte <kschutte-AT-csail.mit.edu> on the
-	ipython-user list.  Simple unittests in the tests/ directory.
-
-	* tools/release: add Will Maier, OpenBSD port maintainer, to
-	recepients list.  We are now officially part of the OpenBSD ports:
-	http://www.openbsd.org/ports.html !  Many thanks to Will for the
-	work.
-
-2006-05-26  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): modify sys.argv fix (below)
-	so that it doesn't break tkinter apps.
-	
-	* IPython/iplib.py (_prefilter): fix bug where aliases would
-	shadow variables when autocall was fully off.  Reported by SAGE
-	author William Stein.
-
-	* IPython/OInspect.py (Inspector.__init__): add a flag to control
-	at what detail level strings are computed when foo? is requested.
-	This allows users to ask for example that the string form of an
-	object is only computed when foo?? is called, or even never, by
-	setting the object_info_string_level >= 2 in the configuration
-	file.  This new option has been added and documented.  After a
-	request by SAGE to be able to control the printing of very large
-	objects more easily.
-
-2006-05-25  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): remove the ipython call path
-	from sys.argv, to be 100% consistent with how Python itself works
-	(as seen for example with python -i file.py).  After a bug report
-	by Jeffrey Collins.
-
-	* IPython/Shell.py (MatplotlibShellBase._matplotlib_config): Fix
-	nasty bug which was preventing custom namespaces with -pylab,
-	reported by M. Foord.  Minor cleanup, remove old matplotlib.matlab
-	compatibility (long gone from mpl).
-
-	* IPython/ipapi.py (make_session): name change: create->make.  We
-	use make in other places (ipmaker,...), it's shorter and easier to
-	type and say, etc.  I'm trying to clean things before 0.7.2 so
-	that I can keep things stable wrt to ipapi in the chainsaw branch.
-
-	* ipython.el: fix the py-pdbtrack-input-prompt variable so that
-	python-mode recognizes our debugger mode.  Add support for
-	autoindent inside (X)emacs.  After a patch sent in by Jin Liu
-	<m.liu.jin-AT-gmail.com> originally written by
-	doxgen-AT-newsmth.net (with minor modifications for xemacs
-	compatibility)
-
-	* IPython/Debugger.py (Pdb.format_stack_entry): fix formatting of
-	tracebacks when walking the stack so that the stack tracking system
-	in emacs' python-mode can identify the frames correctly.
-
-	* IPython/ipmaker.py (make_IPython): make the internal (and
-	default config) autoedit_syntax value false by default.  Too many
-	users have complained to me (both on and off-list) about problems
-	with this option being on by default, so I'm making it default to
-	off.  It can still be enabled by anyone via the usual mechanisms.
-
-	* IPython/completer.py (Completer.attr_matches): add support for
-	PyCrust-style _getAttributeNames magic method.  Patch contributed
-	by <mscott-AT-goldenspud.com>.  Closes #50.
-
-	* IPython/iplib.py (InteractiveShell.__init__): remove the
-	deletion of exit/quit from __builtin__, which can break
-	third-party tools like the Zope debugging console.  The
-	%exit/%quit magics remain.  In general, it's probably a good idea
-	not to delete anything from __builtin__, since we never know what
-	that will break.  In any case, python now (for 2.5) will support
-	'real' exit/quit, so this issue is moot.  Closes #55.
-
-	* IPython/genutils.py (with_obj): rename the 'with' function to
-	'withobj' to avoid incompatibilities with Python 2.5, where 'with'
-	becomes a language keyword.  Closes #53.
-
-	* IPython/FakeModule.py (FakeModule.__init__): add a proper
-	__file__ attribute to this so it fools more things into thinking
-	it is a real module.  Closes #59.
-
-	* IPython/Magic.py (magic_edit): add -n option to open the editor
-	at a specific line number.  After a patch by Stefan van der Walt.
-
-2006-05-23  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (edit_syntax_error): fix crash when for some
-	reason the file could not be opened.  After automatic crash
-	reports sent by James Graham <jgraham-AT-ast.cam.ac.uk> and
-	Charles Dolan <charlespatrickdolan-AT-yahoo.com>.
-	(_should_recompile): Don't fire editor if using %bg, since there
-	is no file in the first place.  From the same report as above.
-	(raw_input): protect against faulty third-party prefilters.  After
-	an automatic crash report sent by Dirk Laurie <dirk-AT-sun.ac.za>
-	while running under SAGE.
-
-2006-05-23  Ville Vainio  <vivainio@gmail.com>
-
-	* ipapi.py: Stripped down ip.to_user_ns() to work only as
-	ip.to_user_ns("x1 y1"), which exposes vars x1 and y1. ipapi.get()
-	now returns None (again), unless dummy is specifically allowed by
-	ipapi.get(allow_dummy=True).
-
-2006-05-18  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython: remove all 2.2-compatibility objects and hacks from
-	everywhere, since we only support 2.3 at this point.  Docs
-	updated.
-
-	* IPython/ipapi.py (IPApi.__init__): Cleanup of all getters.
-	Anything requiring extra validation can be turned into a Python
-	property in the future.  I used a property for the db one b/c
-	there was a nasty circularity problem with the initialization
-	order, which right now I don't have time to clean up.
-
-	* IPython/Shell.py (MTInteractiveShell.runcode): Fix, I think,
-	another locking bug reported by Jorgen.  I'm not 100% sure though,
-	so more testing is needed...
-
-2006-05-17  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ipapi.py (IPApi.to_user_ns): New function to inject
-	local variables from any routine in user code (typically executed
-	with %run) directly into the interactive namespace.  Very useful
-	when doing complex debugging.
-	(IPythonNotRunning): Changed the default None object to a dummy
-	whose attributes can be queried as well as called without
-	exploding, to ease writing code which works transparently both in
-	and out of ipython and uses some of this API.
-
-2006-05-16  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/hooks.py (result_display): Fix the fact that our display
-	hook was using str() instead of repr(), as the default python
-	console does.  This had gone unnoticed b/c it only happened if
-	%Pprint was off, but the inconsistency was there.
-
-2006-05-15  Ville Vainio  <vivainio@gmail.com>
-
-	* Oinspect.py: Only show docstring for nonexisting/binary files
-	when doing object??, closing ticket #62
-
-2006-05-13  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (MTInteractiveShell.runsource): Fix threading
-	bug, closes http://www.scipy.net/roundup/ipython/issue55.  A lock
-	was being released in a routine which hadn't checked if it had
-	been the one to acquire it.
-
-2006-05-07  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Release.py (version): put out 0.7.2.rc1 for testing.
-
-2006-04-11  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py, ipmaker.py: .ipy extension now means "ipython batch file"
-	in command line. E.g. "ipython test.ipy" runs test.ipy with ipython
-	prefilters, allowing stuff like magics and aliases in the file.
-	
-	* Prompts.py, Extensions/clearcmd.py, ipy_system_conf.py: %clear magic
-	added. Supported now are "%clear in" and "%clear out" (clear input and
-	output history, respectively). Also fixed CachedOutput.flush to
-	properly flush the output cache.
-	
-	* Extensions/pspersistence.py: Fix %store to avoid "%store obj.attr"
-	half-success (and fail explicitly).
-
-2006-03-28  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: Fix quoting of aliases so that only argless ones
-	are quoted
-
-2006-03-28  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: Quote aliases with spaces in the name.
-	"c:\program files\blah\bin" is now legal alias target.
-	
-	* ext_rehashdir.py: Space no longer allowed as arg
-	separator, since space is legal in path names.
-	
-2006-03-16  Ville Vainio  <vivainio@gmail.com>
-
-	* upgrade_dir.py: Take path.py from Extensions, correcting
-	%upgrade magic
-	
-	* ipmaker.py: Suggest using %upgrade if ipy_user_conf.py isn't found.
-	
-	* hooks.py: Only enclose editor binary in quotes if legal and
-	necessary (space in the name, and is an existing file). Fixes a bug
-	reported by Zachary Pincus.
-
-2006-03-13  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* Manual: thanks to a tip on proper color handling for Emacs, by
-	Eric J Haywiser <ejh1-AT-MIT.EDU>.
-	
-	* ipython.el: close http://www.scipy.net/roundup/ipython/issue57
-	by applying the provided patch.  Thanks to Liu Jin
-	<m.liu.jin-AT-gmail.com> for the contribution.  No problems under
-	XEmacs/Linux, I'm trusting the submitter that it actually helps
-	under win32/GNU Emacs.  Will revisit if any problems are reported.
-
-2006-03-12  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Gnuplot2.py (_FileClass): update for current Gnuplot.py
-	from SVN, thanks to a patch by Ryan Woodard <rywo@bas.ac.uk>.
-
-2006-03-12  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py (magic_timeit): Added %timeit magic, contributed by
-	Torsten Marek.
-
-2006-03-12  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_macro): fix so that the n1-n2 syntax for
-	line ranges works again.
-
-2006-03-11  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (showtraceback): add back sys.last_traceback
-	and friends, after a discussion with Zach Pincus on ipython-user.
-	I'm not 100% sure, but after thinking about it quite a bit, it may
-	be OK.  Testing with the multithreaded shells didn't reveal any
-	problems, but let's keep an eye out.
-
-	In the process, I fixed a few things which were calling
-	self.InteractiveTB() directly (like safe_execfile), which is a
-	mistake: ALL exception reporting should be done by calling
-	self.showtraceback(), which handles state and tab-completion and
-	more.
-
-2006-03-01  Ville Vainio  <vivainio@gmail.com>
-
-	* Extensions/ipipe.py: Added Walter Doerwald's "ipipe" module.
-	To use, do "from ipipe import *".
-
-2006-02-24  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py, upgrade_dir.py: %upgrade magic added. Does things more
-	"cleanly" and safely than the older upgrade mechanism.
-
-2006-02-21  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py: %save works again.
-
-2006-02-15  Ville Vainio  <vivainio@gmail.com>
-
-	* Magic.py: %Pprint works again
-	
-	* Extensions/ipy_sane_defaults.py: Provide everything provided
-	in default ipythonrc, to make it possible to have a completely empty
-	ipythonrc (and thus completely rc-file free configuration)
-
-2006-02-11  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/hooks.py (editor): quote the call to the editor command,
-	to allow commands with spaces in them.  Problem noted by watching
-	Ian Oswald's video about textpad under win32 at
-	http://showmedo.com/videoListPage?listKey=PythonIPythonSeries
-
-	* IPython/UserConfig/ipythonrc: Replace @ signs with % when
-	describing magics (we haven't used @ for a loong time).
-
-	* IPython/ultraTB.py (VerboseTB.text.text_repr): Added patch
-	contributed by marienz to close
-	http://www.scipy.net/roundup/ipython/issue53.
-
-2006-02-10  Ville Vainio  <vivainio@gmail.com>
-
-	* genutils.py: getoutput now works in win32 too
-	
-	* completer.py: alias and magic completion only invoked
-	at the first "item" in the line, to avoid "cd %store"
-	nonsense.
-	
-2006-02-09  Ville Vainio  <vivainio@gmail.com>
-
-	* test/*: Added a unit testing framework (finally).
-	'%run runtests.py' to run test_*.
-	
-	* ipapi.py: Exposed runlines and set_custom_exc
-
-2006-02-07  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: don't split "f 1 2" to "f(1,2)" in autocall,
-	instead use "f(1 2)" as before.
-
-2006-02-05  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/demo.py (IPythonDemo): Add new classes to the demo
-	facilities, for demos processed by the IPython input filter
-	(IPythonDemo), and for running a script one-line-at-a-time as a
-	demo, both for pure Python (LineDemo) and for IPython-processed
-	input (IPythonLineDemo).  After a request by Dave Kohel, from the
-	SAGE team.
-	(Demo.edit): added an edit() method to the demo objects, to edit
-	the in-memory copy of the last executed block.
-
-	* IPython/Magic.py (magic_edit): add '-r' option for 'raw'
-	processing to %edit, %macro and %save.  These commands can now be
-	invoked on the unprocessed input as it was typed by the user
-	(without any prefilters applied).  After requests by the SAGE team
-	at SAGE days 2006: http://modular.ucsd.edu/sage/days1/schedule.html.
-
-2006-02-01  Ville Vainio  <vivainio@gmail.com>
-
-	* setup.py, eggsetup.py: easy_install ipython==dev works
-	correctly now (on Linux)
-	
-	* ipy_user_conf,ipmaker: user config changes, removed spurious
-	warnings
-	
-	* iplib: if rc.banner is string, use it as is.
-	
-	* Magic: %pycat accepts a string argument and pages it's contents.
-
-
-2006-01-30  Ville Vainio  <vivainio@gmail.com>
-
-	* pickleshare,pspersistence,ipapi,Magic: persistence overhaul.
-	Now %store and bookmarks work through PickleShare, meaning that
-	concurrent access is possible and all ipython sessions see the
-	same database situation all the time, instead of snapshot of
-	the situation when the session was started. Hence, %bookmark
-	results are immediately accessible from othes sessions. The database
-	is also available for use by user extensions. See:
-	http://www.python.org/pypi/pickleshare
-	
-	* hooks.py: Two new hooks, 'shutdown_hook' and 'late_startup_hook'.
-	
-	* aliases can now be %store'd
-	
-	* path.py moved to Extensions so that pickleshare does not need
-	IPython-specific import. Extensions added to pythonpath right
-	at __init__.
-	
-	* iplib.py: ipalias deprecated/redundant; aliases are converted and
-	called with _ip.system and the pre-transformed command string.
-
-2006-01-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (interact): Fix that we were not catching
-	KeyboardInterrupt exceptions properly.  I'm not quite sure why the
-	logic here had to change, but it's fixed now.
-
-2006-01-29  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: Try to import pyreadline on Windows.
-
-2006-01-27  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py: Expose ipapi as _ip in builtin namespace.
-	Makes ipmagic (-> _ip.magic), ipsystem (-> _ip.system)
-	and ip_set_hook (-> _ip.set_hook) redundant. % and !
-	syntax now produce _ip.* variant of the commands.
-	
-	* "_ip.options().autoedit_syntax = 2" automatically throws
-	user to editor for syntax error correction without prompting.
-
-2006-01-27  Ville Vainio  <vivainio@gmail.com>
-
-	* ipmaker.py: Give "realistic" sys.argv for scripts (without
-	'ipython' at argv[0]) executed through command line.
-	NOTE: this DEPRECATES calling ipython with multiple scripts
-	("ipython a.py b.py c.py")
-	
-	* iplib.py, hooks.py: Added configurable input prefilter,
-	named 'input_prefilter'. See ext_rescapture.py for example
-	usage.
-	
-	* ext_rescapture.py, Magic.py: Better system command output capture
-	through 'var = !ls' (deprecates user-visible %sc). Same notation
-	applies for magics, 'var = %alias' assigns alias list to var.
-	
-	* ipapi.py: added meta() for accessing extension-usable data store.
-	
-	* iplib.py: added InteractiveShell.getapi(). New magics should be
-	written doing self.getapi() instead of using the shell directly.
-	
-	* Magic.py: %store now allows doing %store foo > ~/myfoo.txt and
-	%store foo >> ~/myfoo.txt to store variables to files (in clean
-	textual form, not a restorable pickle).
-	
-	* ipmaker.py: now import ipy_profile_PROFILENAME automatically
-	
-	* usage.py, Magic.py: added %quickref
-	
-	* iplib.py: ESC_PAREN fixes: /f 1 2 -> f(1,2), not f(1 2).
-	
-	* GetoptErrors when invoking magics etc. with wrong args
-	are now more helpful:
-	GetoptError: option -l not recognized (allowed: "qb" )
-
-2006-01-25  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/demo.py (Demo.show): Flush stdout after each block, so
-	computationally intensive blocks don't appear to stall the demo.
-
-2006-01-24  Ville Vainio  <vivainio@gmail.com>
-
-	* iplib.py, hooks.py: 'result_display' hook can return a non-None
-	value to manipulate resulting history entry.
-	
-	* ipapi.py: Moved TryNext here from hooks.py. Moved functions
-	to instance methods of IPApi class, to make extending an embedded
-	IPython feasible. See ext_rehashdir.py for example usage.
-	
-	* Merged 1071-1076 from branches/0.7.1
-
-
-2006-01-23  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* tools/release (daystamp): Fix build tools to use the new
-	eggsetup.py script to build lightweight eggs.
-
-	* Applied changesets 1062 and 1064 before 0.7.1 release.
-	
-	* IPython/Magic.py (magic_history): Add '-r' option to %hist, to
-	see the raw input history (without conversions like %ls ->
-	ipmagic("ls")).  After a request from W. Stein, SAGE
-	(http://modular.ucsd.edu/sage) developer.  This information is
-	stored in the input_hist_raw attribute of the IPython instance, so
-	developers can access it if needed (it's an InputList instance).
-	
-	* Versionstring = 0.7.2.svn
-	
-	* eggsetup.py: A separate script for constructing eggs, creates
-	proper launch scripts even on Windows (an .exe file in
-	\python24\scripts).
-	
-	* ipapi.py: launch_new_instance, launch entry point needed for the
-	egg.
-
-2006-01-23  Ville Vainio  <vivainio@gmail.com>
-
-	* Added %cpaste magic for pasting python code
-
-2006-01-22  Ville Vainio  <vivainio@gmail.com>
-
-	* Merge from branches/0.7.1 into trunk, revs 1052-1057
-	
-	* Versionstring = 0.7.2.svn
-	
-	* eggsetup.py: A separate script for constructing eggs, creates
-	proper launch scripts even on Windows (an .exe file in
-	\python24\scripts).
-	
-	* ipapi.py: launch_new_instance, launch entry point needed for the
-	egg.
-
-2006-01-22  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/OInspect.py (Inspector.pinfo): fix bug where foo?? or
-	%pfile foo would print the file for foo even if it was a binary.
-	Now, extensions '.so' and '.dll' are skipped.
-
-	* IPython/Shell.py (MTInteractiveShell.__init__): Fix threading
-	bug, where macros would fail in all threaded modes.  I'm not 100%
-	sure, so I'm going to put out an rc instead of making a release
-	today, and wait for feedback for at least a few days.
-
-	* IPython/iplib.py (handle_normal): fix (finally? somehow I doubt
-	it...) the handling of pasting external code with autoindent on.
-	To get out of a multiline input, the rule will appear for most
-	users unchanged: two blank lines or change the indent level
-	proposed by IPython.  But there is a twist now: you can
-	add/subtract only *one or two spaces*.  If you add/subtract three
-	or more (unless you completely delete the line), IPython will
-	accept that line, and you'll need to enter a second one of pure
-	whitespace.  I know it sounds complicated, but I can't find a
-	different solution that covers all the cases, with the right
-	heuristics.  Hopefully in actual use, nobody will really notice
-	all these strange rules and things will 'just work'.
-
-2006-01-21  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (interact): catch exceptions which can be
-	triggered asynchronously by signal handlers.  Thanks to an
-	automatic crash report, submitted by Colin Kingsley
-	<tercel-AT-gentoo.org>.
-	
-2006-01-20  Ville Vainio  <vivainio@gmail.com>
-
-	* Ipython/Extensions/ext_rehashdir.py: Created a usable example
-	(%rehashdir, very useful, try it out) of how to extend ipython
-	with new magics. Also added Extensions dir to pythonpath to make
-	importing extensions easy.
-	
-	* %store now complains when trying to store interactively declared
-	classes / instances of those classes.
-	
-	* Extensions/ipy_system_conf.py, UserConfig/ipy_user_conf.py,
-	ipmaker.py: Config rehaul. Now ipy_..._conf.py are always imported
-	if they exist, and ipy_user_conf.py with some defaults is created for
-	the user.
-	
-	* Startup rehashing done by the config file, not InterpreterExec.
-	This means system commands are available even without selecting the
-	pysh profile. It's the sensible default after all.
-
-2006-01-20  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (raw_input): I _think_ I got the pasting of
-	multiline code with autoindent on working.  But I am really not
-	sure, so this needs more testing.  Will commit a debug-enabled
-	version for now, while I test it some more, so that Ville and
-	others may also catch any problems.  Also made
-	self.indent_current_str() a method, to ensure that there's no
-	chance of the indent space count and the corresponding string
-	falling out of sync.  All code needing the string should just call
-	the method.
-
-2006-01-18  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_edit): fix check for when users don't
-	save their output files, the try/except was in the wrong section.
-
-2006-01-17  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_run): fix __file__ global missing from
-	script's namespace when executed via %run.  After a report by
-	Vivian.
-
-	* IPython/Debugger.py (Pdb.__init__): Fix breakage with '%run -d'
-	when using python 2.4.  The parent constructor changed in 2.4, and
-	we need to track it directly (we can't call it, as it messes up
-	readline and tab-completion inside our pdb would stop working).
-	After a bug report by R. Bernstein <rocky-AT-panix.com>.
-
-2006-01-16  Ville Vainio  <vivainio@gmail.com>
-
-	* Ipython/magic.py: Reverted back to old %edit functionality
-	that returns file contents on exit.
-	
-	* IPython/path.py: Added Jason Orendorff's "path" module to
-	IPython tree, http://www.jorendorff.com/articles/python/path/.
-	You can get path objects conveniently through %sc, and !!, e.g.:
-	 sc files=ls
-	 for p in files.paths: # or files.p
-	     print p,p.mtime
-	
-	* Ipython/iplib.py:"," and ";" autoquoting-upon-autocall
-	now work again without considering the exclusion regexp -
-	hence, things like ',foo my/path' turn to 'foo("my/path")'
-	instead of syntax error.
-	
-
-2006-01-14  Ville Vainio  <vivainio@gmail.com>
-
-	* IPython/ipapi.py (ashook, asmagic, options): Added convenience
-	ipapi decorators for python 2.4 users, options() provides access to rc
-	data.
-	
-	* IPython/Magic.py (magic_cd): %cd now accepts backslashes
-	as path separators (even on Linux ;-). Space character after
-	backslash (as yielded by tab completer) is still space;
-	"%cd long\ name" works as expected.
-
-	* IPython/ipapi.py,hooks.py,iplib.py: Hooks now implemented
-	as "chain of command", with priority. API stays the same,
-	TryNext exception raised by a hook function signals that
-	current hook failed and next hook should try handling it, as
-	suggested by Walter Dörwald <walter@livinglogic.de>. Walter also
-	requested configurable display hook, which is now implemented.
-
-2006-01-13  Ville Vainio  <vivainio@gmail.com>
-
-	* IPython/platutils*.py: platform specific utility functions,
-	so far only set_term_title is implemented (change terminal
-	label in windowing systems). %cd now changes the title to
-	current dir.
-
-	* IPython/Release.py: Added myself to "authors" list,
-	had to create new files.
-	
-	* IPython/iplib.py (handle_shell_escape): fixed logical flaw in
-	shell escape; not a known bug but had potential to be one in the
-	future.
-
-	* IPython/ipapi.py (added),OInspect.py,iplib.py: "Public"
-	extension API for IPython! See the module for usage example. Fix
-	OInspect for docstring-less magic functions.
-	
-
-2006-01-13  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (raw_input): temporarily deactivate all
-	attempts at allowing pasting of code with autoindent on.  It
-	introduced bugs (reported by Prabhu) and I can't seem to find a
-	robust combination which works in all cases.  Will have to revisit
-	later.
-
-	* IPython/genutils.py: remove isspace() function.  We've dropped
-	2.2 compatibility, so it's OK to use the string method.
-
-2006-01-12  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): fix regexp
-	matching what NOT to autocall on, to include all python binary
-	operators (including things like 'and', 'or', 'is' and 'in').
-	Prompted by a bug report on 'foo & bar', but I realized we had
-	many more potential bug cases with other operators.  The regexp is
-	self.re_exclude_auto, it's fairly commented.
-
-2006-01-12  Ville Vainio  <vivainio@gmail.com>
-
-	* IPython/iplib.py (make_quoted_expr,handle_shell_escape):
-	Prettified and hardened string/backslash quoting with ipsystem(),
-	ipalias() and ipmagic(). Now even \ characters are passed to
-	%magics, !shell escapes and aliases exactly as they are in the
-	ipython command line. Should improve backslash experience,
-	particularly in Windows (path delimiter for some commands that
-	won't understand '/'), but Unix benefits as well (regexps). %cd
-	magic still doesn't support backslash path delimiters, though. Also
-	deleted all pretense of supporting multiline command strings in
-	!system or %magic commands. Thanks to Jerry McRae for suggestions.
-	
-	* doc/build_doc_instructions.txt added. Documentation on how to
-	use doc/update_manual.py, added yesterday. Both files contributed
-	by Jörgen Stenarson <jorgen.stenarson-AT-bostream.nu>. This slates
-	doc/*.sh for deprecation at a later date.
-	
-	* /ipython.py Added ipython.py to root directory for
-	zero-installation (tar xzvf ipython.tgz; cd ipython; python
-	ipython.py) and development convenience (no need to keep doing
-	"setup.py install" between changes).
-	
-	* Made ! and !! shell escapes work (again) in multiline expressions:
-	  if 1:
-	      !ls
-	      !!ls
-
-2006-01-12  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ipstruct.py (Struct): Rename IPython.Struct to
-	IPython.ipstruct, to avoid local shadowing of the stdlib 'struct'
-	module in case-insensitive installation.  Was causing crashes
-	under win32.  Closes http://www.scipy.net/roundup/ipython/issue49.
-
-	* IPython/Magic.py (magic_pycat): Fix pycat, patch by Marien Zwart
-	<marienz-AT-gentoo.org>, closes
-	http://www.scipy.net/roundup/ipython/issue51.
-
-2006-01-11  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.on_timer): Finally fix the
-	problem of excessive CPU usage under *nix and keyboard lag under
-	win32.
-
-2006-01-10  *** Released version 0.7.0
-
-2006-01-10  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Release.py (revision): tag version number to 0.7.0,
-	ready for release.
-
-	* IPython/Magic.py (magic_edit): Add print statement to %edit so
-	it informs the user of the name of the temp. file used.  This can
-	help if you decide later to reuse that same file, so you know
-	where to copy the info from.
-
-2006-01-09  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* setup_bdist_egg.py: little script to build an egg.  Added
-	support in the release tools as well.
-
-2006-01-08  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellWX.__init__): add support for WXPython
-	version selection (new -wxversion command line and ipythonrc
-	parameter).  Patch contributed by Arnd Baecker
-	<arnd.baecker-AT-web.de>.
-
-	* IPython/iplib.py (embed_mainloop): fix tab-completion in
-	embedded instances, for variables defined at the interactive
-	prompt of the embedded ipython.  Reported by Arnd.
-
-	* IPython/Magic.py (magic_autocall): Fix %autocall magic.  Now
-	it can be used as a (stateful) toggle, or with a direct parameter.
-
-	* IPython/ultraTB.py (_fixed_getinnerframes): remove debug assert which
-	could be triggered in certain cases and cause the traceback
-	printer not to work.
-
-2006-01-07  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (_should_recompile): Small fix, closes
-	http://www.scipy.net/roundup/ipython/issue48.  Patch by Scott.
-
-2006-01-04  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.mainloop): fix bug in the GTK
-	backend for matplotlib (100% cpu utiliziation).  Thanks to Charlie
-	Moad for help with tracking it down.
-
-	* IPython/iplib.py (handle_auto): fix autocall handling for
-	objects which support BOTH __getitem__ and __call__ (so that f [x]
-	is left alone, instead of becoming f([x]) automatically).
-
-	* IPython/Magic.py (magic_cd): fix crash when cd -b was used.
-	Ville's patch.
-
-2006-01-03  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (handle_auto): changed autocall semantics to
-	include 'smart' mode, where the autocall transformation is NOT
-	applied if there are no arguments on the line.  This allows you to
-	just type 'foo' if foo is a callable to see its internal form,
-	instead of having it called with no arguments (typically a
-	mistake).  The old 'full' autocall still exists: for that, you
-	need to set the 'autocall' parameter to 2 in your ipythonrc file.
-
-	* IPython/completer.py (Completer.attr_matches): add
-	tab-completion support for Enthoughts' traits.  After a report by
-	Arnd and a patch by Prabhu.
-
-2006-01-02  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ultraTB.py (_fixed_getinnerframes): added Alex
-	Schmolck's patch to fix inspect.getinnerframes().
-
-	* IPython/iplib.py (InteractiveShell.__init__): significant fixes
-	for embedded instances, regarding handling of namespaces and items
-	added to the __builtin__ one.  Multiple embedded instances and
-	recursive embeddings should work better now (though I'm not sure
-	I've got all the corner cases fixed, that code is a bit of a brain
-	twister).
-
-	* IPython/Magic.py (magic_edit): added support to edit in-memory
-	macros (automatically creates the necessary temp files).  %edit
-	also doesn't return the file contents anymore, it's just noise.
-
-	* IPython/completer.py (Completer.attr_matches): revert change to
-	complete only on attributes listed in __all__.  I realized it
-	cripples the tab-completion system as a tool for exploring the
-	internals of unknown libraries (it renders any non-__all__
-	attribute off-limits).  I got bit by this when trying to see
-	something inside the dis module.
-
-2005-12-31  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): add .meta
-	namespace for users and extension writers to hold data in.  This
-	follows the discussion in
-	http://projects.scipy.org/ipython/ipython/wiki/RefactoringIPython.
-
-	* IPython/completer.py (IPCompleter.complete): small patch to help
-	tab-completion under Emacs, after a suggestion by John Barnard
-	<barnarj-AT-ccf.org>.
-
-	* IPython/Magic.py (Magic.extract_input_slices): added support for
-	the slice notation in magics to use N-M to represent numbers N...M
-	(closed endpoints).  This is used by %macro and %save.
-
-	* IPython/completer.py (Completer.attr_matches): for modules which
-	define __all__, complete only on those.  After a patch by Jeffrey
-	Collins <jcollins_boulder-AT-earthlink.net>.  Also, clean up and
-	speed up this routine.
-
-	* IPython/Logger.py (Logger.log): fix a history handling bug.  I
-	don't know if this is the end of it, but the behavior now is
-	certainly much more correct.  Note that coupled with macros,
-	slightly surprising (at first) behavior may occur: a macro will in
-	general expand to multiple lines of input, so upon exiting, the
-	in/out counters will both be bumped by the corresponding amount
-	(as if the macro's contents had been typed interactively).  Typing
-	%hist will reveal the intermediate (silently processed) lines.
-
-	* IPython/Magic.py (magic_run): fix a subtle bug which could cause
-	pickle to fail (%run was overwriting __main__ and not restoring
-	it, but pickle relies on __main__ to operate).
-
-	* IPython/iplib.py (InteractiveShell): fix pdb calling: I'm now
-	using properties, but forgot to make the main InteractiveShell
-	class a new-style class.  Properties fail silently, and
-	mysteriously, with old-style class (getters work, but
-	setters don't do anything).
-
-2005-12-30  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_history): fix history reporting bug (I
-	know some nasties are still there, I just can't seem to find a
-	reproducible test case to track them down; the input history is
-	falling out of sync...)
-
-	* IPython/iplib.py (handle_shell_escape): fix bug where both
-	aliases and system accesses where broken for indented code (such
-	as loops).
-
-	* IPython/genutils.py (shell): fix small but critical bug for
-	win32 system access.
-
-2005-12-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (showtraceback): remove use of the
-	sys.last_{type/value/traceback} structures, which are non
-	thread-safe.
-	(_prefilter): change control flow to ensure that we NEVER
-	introspect objects when autocall is off.  This will guarantee that
-	having an input line of the form 'x.y', where access to attribute
-	'y' has side effects, doesn't trigger the side effect TWICE.  It
-	is important to note that, with autocall on, these side effects
-	can still happen.
-	(ipsystem): new builtin, to complete the ip{magic/alias/system}
-	trio.  IPython offers these three kinds of special calls which are
-	not python code, and it's a good thing to have their call method
-	be accessible as pure python functions (not just special syntax at
-	the command line).  It gives us a better internal implementation
-	structure, as well as exposing these for user scripting more
-	cleanly.
-
-	* IPython/macro.py (Macro.__init__): moved macros to a standalone
-	file.  Now that they'll be more likely to be used with the
-	persistance system (%store), I want to make sure their module path
-	doesn't change in the future, so that we don't break things for
-	users' persisted data.
-
-	* IPython/iplib.py (autoindent_update): move indentation
-	management into the _text_ processing loop, not the keyboard
-	interactive one.  This is necessary to correctly process non-typed
-	multiline input (such as macros).
-
-	* IPython/Magic.py (Magic.format_latex): patch by Stefan van der
-	Walt <stefan-AT-sun.ac.za> to fix latex formatting of docstrings,
-	which was producing problems in the resulting manual.
-	(magic_whos): improve reporting of instances (show their class,
-	instead of simply printing 'instance' which isn't terribly
-	informative).
-
-	* IPython/genutils.py (shell): commit Jorgen Stenarson's patch
-	(minor mods) to support network shares under win32.
-
-	* IPython/winconsole.py (get_console_size): add new winconsole
-	module and fixes to page_dumb() to improve its behavior under
-	win32.  Contributed by Alexander Belchenko <bialix-AT-ukr.net>.
-
-	* IPython/Magic.py (Macro): simplified Macro class to just
-	subclass list.  We've had only 2.2 compatibility for a very long
-	time, yet I was still avoiding subclassing the builtin types.  No
-	more (I'm also starting to use properties, though I won't shift to
-	2.3-specific features quite yet).
-	(magic_store): added Ville's patch for lightweight variable
-	persistence, after a request on the user list by Matt Wilkie
-	<maphew-AT-gmail.com>.  The new %store magic's docstring has full
-	details.
-
-	* IPython/iplib.py (InteractiveShell.post_config_initialization):
-	changed the default logfile name from 'ipython.log' to
-	'ipython_log.py'.  These logs are real python files, and now that
-	we have much better multiline support, people are more likely to
-	want to use them as such.  Might as well name them correctly.
-
-	* IPython/Magic.py: substantial cleanup.  While we can't stop
-	using magics as mixins, due to the existing customizations 'out
-	there' which rely on the mixin naming conventions, at least I
-	cleaned out all cross-class name usage.  So once we are OK with
-	breaking compatibility, the two systems can be separated.
-
-	* IPython/Logger.py: major cleanup.  This one is NOT a mixin
-	anymore, and the class is a fair bit less hideous as well.  New
-	features were also introduced: timestamping of input, and logging
-	of output results.  These are user-visible with the -t and -o
-	options to %logstart.  Closes
-	http://www.scipy.net/roundup/ipython/issue11 and a request by
-	William Stein (SAGE developer - http://modular.ucsd.edu/sage).
-
-2005-12-28  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (handle_shell_escape): add Ville's patch to
-	better handle backslashes in paths.  See the thread 'More Windows
-	questions part 2 - \/ characters revisited' on the iypthon user
-	list:
-	http://scipy.net/pipermail/ipython-user/2005-June/000907.html
-
-	(InteractiveShell.__init__): fix tab-completion bug in threaded shells.
-
-	(InteractiveShell.__init__): change threaded shells to not use the
-	ipython crash handler.  This was causing more problems than not,
-	as exceptions in the main thread (GUI code, typically) would
-	always show up as a 'crash', when they really weren't.
-
-	The colors and exception mode commands (%colors/%xmode) have been
-	synchronized to also take this into account, so users can get
-	verbose exceptions for their threaded code as well.  I also added
-	support for activating pdb inside this exception handler as well,
-	so now GUI authors can use IPython's enhanced pdb at runtime.
-
-	* IPython/ipmaker.py (make_IPython): make the autoedit_syntax flag
-	true by default, and add it to the shipped ipythonrc file.  Since
-	this asks the user before proceeding, I think it's OK to make it
-	true by default.
-
-	* IPython/Magic.py (magic_exit): make new exit/quit magics instead
-	of the previous special-casing of input in the eval loop.  I think
-	this is cleaner, as they really are commands and shouldn't have
-	a special role in the middle of the core code.
-
-2005-12-27  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (edit_syntax_error): added support for
-	automatically reopening the editor if the file had a syntax error
-	in it.  Thanks to scottt who provided the patch at:
-	http://www.scipy.net/roundup/ipython/issue36 (slightly modified
-	version committed).
-
-	* IPython/iplib.py (handle_normal): add suport for multi-line
-	input with emtpy lines.  This fixes
-	http://www.scipy.net/roundup/ipython/issue43 and a similar
-	discussion on the user list.
-
-	WARNING: a behavior change is necessarily introduced to support
-	blank lines: now a single blank line with whitespace does NOT
-	break the input loop, which means that when autoindent is on, by
-	default hitting return on the next (indented) line does NOT exit.
-
-	Instead, to exit a multiline input you can either have:
-
-	  - TWO whitespace lines (just hit return again), or
-	  - a single whitespace line of a different length than provided
-	by the autoindent (add or remove a space).
-
-	* IPython/completer.py (MagicCompleter.__init__): new 'completer'
-	module to better organize all readline-related functionality.
-	I've deleted FlexCompleter and put all completion clases here.
-
-	* IPython/iplib.py (raw_input): improve indentation management.
-	It is now possible to paste indented code with autoindent on, and
-	the code is interpreted correctly (though it still looks bad on
-	screen, due to the line-oriented nature of ipython).
-	(MagicCompleter.complete): change behavior so that a TAB key on an
-	otherwise empty line actually inserts a tab, instead of completing
-	on the entire global namespace.  This makes it easier to use the
-	TAB key for indentation.  After a request by Hans Meine
-	<hans_meine-AT-gmx.net>
-	(_prefilter): add support so that typing plain 'exit' or 'quit'
-	does a sensible thing.  Originally I tried to deviate as little as
-	possible from the default python behavior, but even that one may
-	change in this direction (thread on python-dev to that effect).
-	Regardless, ipython should do the right thing even if CPython's
-	'>>>' prompt doesn't.
-	(InteractiveShell): removed subclassing code.InteractiveConsole
-	class.  By now we'd overridden just about all of its methods: I've
-	copied the remaining two over, and now ipython is a standalone
-	class.  This will provide a clearer picture for the chainsaw
-	branch refactoring.
-
-2005-12-26  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.text): harden reporting against
-	failures for objects which break when dir() is called on them.
-
-	* IPython/FlexCompleter.py (Completer.__init__): Added support for
-	distinct local and global namespaces in the completer API.  This
-	change allows us to properly handle completion with distinct
-	scopes, including in embedded instances (this had never really
-	worked correctly).
-
-	Note: this introduces a change in the constructor for
-	MagicCompleter, as a new global_namespace parameter is now the
-	second argument (the others were bumped one position).
-
-2005-12-25  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (embed_mainloop): fix tab-completion in
-	embedded instances (which can be done now thanks to Vivian's
-	frame-handling fixes for pdb).
-	(InteractiveShell.__init__): Fix namespace handling problem in
-	embedded instances.  We were overwriting __main__ unconditionally,
-	and this should only be done for 'full' (non-embedded) IPython;
-	embedded instances must respect the caller's __main__.  Thanks to
-	a bug report by Yaroslav Bulatov <yaroslavvb-AT-gmail.com>
-
-2005-12-24  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* setup.py: added download_url to setup().  This registers the
-	download address at PyPI, which is not only useful to humans
-	browsing the site, but is also picked up by setuptools (the Eggs
-	machinery).  Thanks to Ville and R. Kern for the info/discussion
-	on this.
-
-2005-12-23  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Debugger.py (Pdb.__init__): Major pdb mode enhancements.
-	This brings a lot of nice functionality to the pdb mode, which now
-	has tab-completion, syntax highlighting, and better stack handling
-	than before.  Many thanks to Vivian De Smedt
-	<vivian-AT-vdesmedt.com> for the original patches.
-
-2005-12-08  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.mainloop): fix mainloop() calling
-	sequence to consistently accept the banner argument.  The
-	inconsistency was tripping SAGE, thanks to Gary Zablackis
-	<gzabl-AT-yahoo.com> for the report.
-
-2005-11-15  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.post_config_initialization):
-	Fix bug where a naked 'alias' call in the ipythonrc file would
-	cause a crash.  Bug reported by Jorgen Stenarson.
-
-2005-11-15  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): cleanups which should improve
-	startup time.
-
-	* IPython/iplib.py (runcode): my globals 'fix' for embedded
-	instances had introduced a bug with globals in normal code.  Now
-	it's working in all cases.
-
-	* IPython/Magic.py (magic_psearch): Finish wildcard cleanup and
-	API changes.  A new ipytonrc option, 'wildcards_case_sensitive'
-	has been introduced to set the default case sensitivity of the
-	searches.  Users can still select either mode at runtime on a
-	per-search basis.
-
-2005-11-13 Fernando Perez   <Fernando.Perez@colorado.edu>
-
-	* IPython/wildcard.py (NameSpace.__init__): fix resolution of
-	attributes in wildcard searches for subclasses.  Modified version
-	of a patch by Jorgen.
-
-2005-11-12 Fernando Perez   <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (embed_mainloop): Fix handling of globals for
-	embedded instances.  I added a user_global_ns attribute to the
-	InteractiveShell class to handle this.
-
-2005-10-31  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.mainloop): Change timeout_add to
-	idle_add, which fixes horrible keyboard lag problems under gtk 2.6
-	(reported under win32, but may happen also in other platforms).
-	Bug report and fix courtesy of Sean Moore <smm-AT-logic.bm>
-
-2005-10-15  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Magic.py (magic_psearch): new support for wildcard
-	patterns.  Now, typing ?a*b will list all names which begin with a
-	and end in b, for example.  The %psearch magic has full
-	docstrings.  Many thanks to Jörgen Stenarson
-	<jorgen.stenarson-AT-bostream.nu>, author of the patches
-	implementing this functionality.
-
-2005-09-27  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* Manual: fixed long-standing annoyance of double-dashes (as in
-	--prefix=~, for example) being stripped in the HTML version.  This
-	is a latex2html bug, but a workaround was provided.  Many thanks
-	to George K. Thiruvathukal <gthiruv-AT-luc.edu> for the detailed
-	help, and Michael Tobis <mtobis-AT-gmail.com> for getting the ball
-	rolling.  This seemingly small issue had tripped a number of users
-	when first installing, so I'm glad to see it gone.
-	
-2005-09-27  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Extensions/numeric_formats.py: fix missing import,
-	reported by Stephen Walton.
-
-2005-09-24  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/demo.py: finish demo module, fully documented now.
-
-	* IPython/genutils.py (file_read): simple little utility to read a
-	file and ensure it's closed afterwards.
-
-2005-09-23  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/demo.py (Demo.__init__): added support for individually
-	tagging blocks for automatic execution.
-
-	* IPython/Magic.py (magic_pycat): new %pycat magic for showing
-	syntax-highlighted python sources, requested by John.
-
-2005-09-22  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/demo.py (Demo.again): fix bug where again() blocks after
-	finishing.
-
-	* IPython/genutils.py (shlex_split): moved from Magic to here,
-	where all 2.2 compatibility stuff lives.  I needed it for demo.py.
-
-	* IPython/demo.py (Demo.__init__): added support for silent
-	blocks, improved marks as regexps, docstrings written.
-	(Demo.__init__): better docstring, added support for sys.argv.
-
-	* IPython/genutils.py (marquee): little utility used by the demo
-	code, handy in general.
-
-	* IPython/demo.py (Demo.__init__): new class for interactive
-	demos.  Not documented yet, I just wrote it in a hurry for
-	scipy'05.  Will docstring later.
-
-2005-09-20  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (sigint_handler): Drastic simplification which
-	also seems to make Ctrl-C work correctly across threads!  This is
-	so simple, that I can't beleive I'd missed it before.  Needs more
-	testing, though.
-	(KBINT): Never mind, revert changes.  I'm sure I'd tried something
-	like this before...
-
-	* IPython/genutils.py (get_home_dir): add protection against
-	non-dirs in win32 registry.
-
-	* IPython/iplib.py (InteractiveShell.alias_table_validate): fix
-	bug where dict was mutated while iterating (pysh crash).
-
-2005-09-06  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (handle_auto): Fix inconsistency arising from
-	spurious newlines added by this routine.  After a report by
-	F. Mantegazza.
-
-2005-09-05  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/Shell.py (hijack_gtk): remove pygtk.require("2.0")
-	calls.  These were a leftover from the GTK 1.x days, and can cause
-	problems in certain cases (after a report by John Hunter).
-
-	* IPython/iplib.py (InteractiveShell.__init__): Trap exception if
-	os.getcwd() fails at init time.  Thanks to patch from David Remahl
-	<chmod007-AT-mac.com>.
-	(InteractiveShell.__init__): prevent certain special magics from
-	being shadowed by aliases.  Closes
-	http://www.scipy.net/roundup/ipython/issue41.
-
-2005-08-31  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.complete): Added new
-	top-level completion method to expose the completion mechanism
-	beyond readline-based environments.
-
-2005-08-19  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* tools/ipsvnc (svnversion): fix svnversion capture.
-
-	* IPython/iplib.py (InteractiveShell.__init__): Add has_readline
-	attribute to self, which was missing.  Before, it was set by a
-	routine which in certain cases wasn't being called, so the
-	instance could end up missing the attribute.  This caused a crash.
-	Closes http://www.scipy.net/roundup/ipython/issue40.
-
-2005-08-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.text): don't crash if object
-	contains non-string attribute.  Closes
-	http://www.scipy.net/roundup/ipython/issue38.
-
-2005-08-14  Fernando Perez  <fperez@colorado.edu>
-
-	* tools/ipsvnc: Minor improvements, to add changeset info.
-
-2005-08-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (runsource): remove self.code_to_run_src
-	attribute.  I realized this is nothing more than
-	'\n'.join(self.buffer), and having the same data in two different
-	places is just asking for synchronization bugs.  This may impact
-	people who have custom exception handlers, so I need to warn
-	ipython-dev about it (F. Mantegazza may use them).
-
-2005-07-29  Fernando Perez  <Fernando.Perez@colorado.edu>
-
-	* IPython/genutils.py: fix 2.2 compatibility (generators)
-
-2005-07-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (get_home_dir): fix to help users with
-	invalid $HOME under win32.
-
-2005-07-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (str_safe): Make unicode-safe.  Also remove
-	some old hacks and clean up a bit other routines; code should be
-	simpler and a bit faster.
-
-	* IPython/iplib.py (interact): removed some last-resort attempts
-	to survive broken stdout/stderr.  That code was only making it
-	harder to abstract out the i/o (necessary for gui integration),
-	and the crashes it could prevent were extremely rare in practice
-	(besides being fully user-induced in a pretty violent manner).
-
-	* IPython/genutils.py (IOStream.__init__): Simplify the i/o stuff.
-	Nothing major yet, but the code is simpler to read; this should
-	make it easier to do more serious modifications in the future.
-
-	* IPython/Extensions/InterpreterExec.py: Fix auto-quoting in pysh,
-	which broke in .15 (thanks to a report by Ville).
-
-	* IPython/Itpl.py (Itpl.__init__): add unicode support (it may not
-	be quite correct, I know next to nothing about unicode).  This
-	will allow unicode strings to be used in prompts, amongst other
-	cases.  It also will prevent ipython from crashing when unicode
-	shows up unexpectedly in many places.  If ascii encoding fails, we
-	assume utf_8.  Currently the encoding is not a user-visible
-	setting, though it could be made so if there is demand for it.
-
-	* IPython/ipmaker.py (make_IPython): remove old 2.1-specific hack.
-
-	* IPython/Struct.py (Struct.merge): switch keys() to iterator.
-
-	* IPython/background_jobs.py: moved 2.2 compatibility to genutils.
-
-	* IPython/genutils.py: Add 2.2 compatibility here, so all other
-	code can work transparently for 2.2/2.3.
-
-2005-07-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (ExceptionColors): Make a global variable
-	out of the color scheme table used for coloring exception
-	tracebacks.  This allows user code to add new schemes at runtime.
-	This is a minimally modified version of the patch at
-	http://www.scipy.net/roundup/ipython/issue35, many thanks to pabw
-	for the contribution.
-
-	* IPython/FlexCompleter.py (Completer.attr_matches): Add a
-	slightly modified version of the patch in
-	http://www.scipy.net/roundup/ipython/issue34, which also allows me
-	to remove the previous try/except solution (which was costlier).
-	Thanks to Gaetan Lehmann <gaetan.lehmann-AT-jouy.inra.fr> for the fix.
-
-2005-06-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (write/write_err): Add methods to abstract all
-	I/O a bit more.
-
-	* IPython/Shell.py (IPShellGTK.mainloop): Fix GTK deprecation
-	warning, reported by Aric Hagberg, fix by JD Hunter.
-
-2005-06-02  *** Released version 0.6.15
-
-2005-06-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (MagicCompleter.file_matches): Fix
-	tab-completion of filenames within open-quoted strings.  Note that
-	this requires that in ~/.ipython/ipythonrc, users change the
-	readline delimiters configuration to read:
-
-	readline_remove_delims -/~
-	
-
-2005-05-31  *** Released version 0.6.14
-
-2005-05-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.text): Fix crash for tracebacks
-	with files not on the filesystem.  Reported by Eliyahu Sandler
-	<eli@gondolin.net>
-
-2005-05-22  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py: Fix a few crashes in the --upgrade option.
-	After an initial report by LUK ShunTim <shuntim.luk@polyu.edu.hk>.
-
-2005-05-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (safe_execfile): close a file which could be
-	left open (causing problems in win32, which locks open files).
-	Thanks to a bug report by D Brown <dbrown2@yahoo.com>.
-
-2005-05-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): pass all
-	keyword arguments correctly to safe_execfile().
-
-2005-05-13  Fernando Perez  <fperez@colorado.edu>
-
-	* ipython.1: Added info about Qt to manpage, and threads warning
-	to usage page (invoked with --help).
-
-	* IPython/iplib.py (MagicCompleter.python_func_kw_matches): Added
-	new matcher (it goes at the end of the priority list) to do
-	tab-completion on named function arguments.  Submitted by George
-	Sakkis <gsakkis-AT-eden.rutgers.edu>.  See the thread at
-	http://www.scipy.net/pipermail/ipython-dev/2005-April/000436.html
-	for more details.
-
-	* IPython/Magic.py (magic_run): Added new -e flag to ignore
-	SystemExit exceptions in the script being run.  Thanks to a report
-	by danny shevitz <danny_shevitz-AT-yahoo.com>, about this
-	producing very annoying behavior when running unit tests.
-
-2005-05-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (handle_auto): fixed auto-quoting and parens,
-	which I'd broken (again) due to a changed regexp.  In the process,
-	added ';' as an escape to auto-quote the whole line without
-	splitting its arguments.  Thanks to a report by Jerry McRae
-	<qrs0xyc02-AT-sneakemail.com>.
-
-	* IPython/ultraTB.py (VerboseTB.text): protect against rare but
-	possible crashes caused by a TokenError.  Reported by Ed Schofield
-	<schofield-AT-ftw.at>.
-	
-2005-05-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (hijack_wx): Fix to work with WX v.2.6.
-
-2005-04-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellQt): Thanks to Denis Rivière
-	<nudz-AT-free.fr>, Yann Cointepas <yann-AT-sapetnioc.org> and Benjamin
-	Thyreau <Benji2-AT-decideur.info>, we now have a -qthread option
-	which provides support for Qt interactive usage (similar to the
-	existing one for WX and GTK).  This had been often requested.
-
-2005-04-14  *** Released version 0.6.13
-
-2005-04-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic._ofind): remove docstring evaluation
-	from _ofind, which gets called on almost every input line.  Now,
-	we only try to get docstrings if they are actually going to be
-	used (the overhead of fetching unnecessary docstrings can be
-	noticeable for certain objects, such as Pyro proxies).
-
-	* IPython/iplib.py (MagicCompleter.python_matches): Change the API
-	for completers.  For some reason I had been passing them the state
-	variable, which completers never actually need, and was in
-	conflict with the rlcompleter API.  Custom completers ONLY need to
-	take the text parameter.
-
-	* IPython/Extensions/InterpreterExec.py: Fix regexp so that magics
-	work correctly in pysh.  I've also moved all the logic which used
-	to be in pysh.py here, which will prevent problems with future
-	upgrades.  However, this time I must warn users to update their
-	pysh profile to include the line
-
-	import_all IPython.Extensions.InterpreterExec
-
-	because otherwise things won't work for them.  They MUST also
-	delete pysh.py and the line
-
-	execfile pysh.py
-
-	from their ipythonrc-pysh.
-
-	* IPython/FlexCompleter.py (Completer.attr_matches): Make more
-	robust in the face of objects whose dir() returns non-strings
-	(which it shouldn't, but some broken libs like ITK do).  Thanks to
-	a patch by John Hunter (implemented differently, though).  Also
-	minor improvements by using .extend instead of + on lists.
-
-	* pysh.py: 
-
-2005-04-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): Make multi_line_specials on
-	by default, so that all users benefit from it.  Those who don't
-	want it can still turn it off.
-
-	* IPython/UserConfig/ipythonrc: Add multi_line_specials to the
-	config file, I'd forgotten about this, so users were getting it
-	off by default.
-
-	* IPython/iplib.py (ipmagic): big overhaul of the magic system for
-	consistency.  Now magics can be called in multiline statements,
-	and python variables can be expanded in magic calls via $var.
-	This makes the magic system behave just like aliases or !system
-	calls.
-
-2005-03-28  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (handle_auto): cleanup to use %s instead of
-	expensive string additions for building command.  Add support for
-	trailing ';' when autocall is used.
-
-2005-03-26  Fernando Perez  <fperez@colorado.edu>
-
-	* ipython.el: Fix http://www.scipy.net/roundup/ipython/issue31.
-	Bugfix by A. Schmolck, the ipython.el maintainer.  Also make
-	ipython.el robust against prompts with any number of spaces
-	(including 0) after the ':' character.
-
-	* IPython/Prompts.py (Prompt2.set_p_str): Fix spurious space in
-	continuation prompt, which misled users to think the line was
-	already indented.  Closes debian Bug#300847, reported to me by
-	Norbert Tretkowski <tretkowski-AT-inittab.de>.
-
-2005-03-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (Prompt1.__str__): Make sure that prompts are
-	properly aligned if they have embedded newlines.
-
-	* IPython/iplib.py (runlines): Add a public method to expose
-	IPython's code execution machinery, so that users can run strings
-	as if they had been typed at the prompt interactively.
-	(InteractiveShell.__init__): Added getoutput() to the __IPYTHON__
-	methods which can call the system shell, but with python variable
-	expansion.  The three such methods are: __IPYTHON__.system,
-	.getoutput and .getoutputerror.  These need to be documented in a
-	'public API' section (to be written) of the manual.
-
-2005-03-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.set_custom_exc): new system
-	for custom exception handling.  This is quite powerful, and it
-	allows for user-installable exception handlers which can trap
-	custom exceptions at runtime and treat them separately from
-	IPython's default mechanisms.  At the request of Frédéric
-	Mantegazza <mantegazza-AT-ill.fr>.
-	(InteractiveShell.set_custom_completer): public API function to
-	add new completers at runtime.
-
-2005-03-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/OInspect.py (getdoc): Add a call to obj.getdoc(), to
-	allow objects which provide their docstrings via non-standard
-	mechanisms (like Pyro proxies) to still be inspected by ipython's
-	? system.
-
-	* IPython/iplib.py (InteractiveShell.__init__): back off the _o/_e
-	automatic capture system.  I tried quite hard to make it work
-	reliably, and simply failed.  I tried many combinations with the
-	subprocess module, but eventually nothing worked in all needed
-	cases (not blocking stdin for the child, duplicating stdout
-	without blocking, etc).  The new %sc/%sx still do capture to these
-	magical list/string objects which make shell use much more
-	conveninent, so not all is lost.
-
-	XXX - FIX MANUAL for the change above!
-
-	(runsource): I copied code.py's runsource() into ipython to modify
-	it a bit.  Now the code object and source to be executed are
-	stored in ipython.  This makes this info accessible to third-party
-	tools, like custom exception handlers.  After a request by Frédéric
-	Mantegazza <mantegazza-AT-ill.fr>.
-
-	* IPython/UserConfig/ipythonrc: Add up/down arrow keys to
-	history-search via readline (like C-p/C-n).  I'd wanted this for a
-	long time, but only recently found out how to do it.  For users
-	who already have their ipythonrc files made and want this, just
-	add:
-
-	readline_parse_and_bind "\e[A": history-search-backward
-	readline_parse_and_bind "\e[B": history-search-forward
-
-2005-03-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (magic_sc): %sc and %sx now use the fancy
-	LSString and SList classes which allow transparent conversions
-	between list mode and whitespace-separated string.
-	(magic_r): Fix recursion problem in %r.
-
-	* IPython/genutils.py (LSString): New class to be used for
-	automatic storage of the results of all alias/system calls in _o
-	and _e (stdout/err).  These provide a .l/.list attribute which
-	does automatic splitting on newlines.  This means that for most
-	uses, you'll never need to do capturing of output with %sc/%sx
-	anymore, since ipython keeps this always done for you.  Note that
-	only the LAST results are stored, the _o/e variables are
-	overwritten on each call.  If you need to save their contents
-	further, simply bind them to any other name.
-
-2005-03-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (BasePrompt.cwd_filt): a few more fixes for
-	prompt namespace handling.
-
-2005-03-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (CachedOutput.__init__): Fix default and
-	classic prompts to be '>>> ' (final space was missing, and it
-	trips the emacs python mode).
-	(BasePrompt.__str__): Added safe support for dynamic prompt
-	strings.  Now you can set your prompt string to be '$x', and the
-	value of x will be printed from your interactive namespace.  The
-	interpolation syntax includes the full Itpl support, so
-	${foo()+x+bar()} is a valid prompt string now, and the function
-	calls will be made at runtime.
-
-2005-03-15  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (magic_history): renamed %hist to %history, to
-	avoid name clashes in pylab.  %hist still works, it just forwards
-	the call to %history.
-
-2005-03-02  *** Released version 0.6.12
-
-2005-03-02  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (handle_magic): log magic calls properly as
-	ipmagic() function calls.
-
-	* IPython/Magic.py (magic_time): Improved %time to support
-	statements and provide wall-clock as well as CPU time.
-
-2005-02-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/hooks.py: New hooks module, to expose user-modifiable
-	IPython functionality in a clean manner.  For now only the editor
-	hook is actually written, and other thigns which I intend to turn
-	into proper hooks aren't yet there.  The display and prefilter
-	stuff, for example, should be hooks.  But at least now the
-	framework is in place, and the rest can be moved here with more
-	time later.  IPython had had a .hooks variable for a long time for
-	this purpose, but I'd never actually used it for anything.
-
-2005-02-26  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): make the default ipython
-	directory be called _ipython under win32, to follow more the
-	naming peculiarities of that platform (where buggy software like
-	Visual Sourcesafe breaks with .named directories).  Reported by
-	Ville Vainio.
-
-2005-02-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): removed a few
-	auto_aliases for win32 which were causing problems.  Users can
-	define the ones they personally like.
-
-2005-02-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (magic_time): new magic to time execution of
-	expressions.  After a request by Charles Moad <cmoad-AT-indiana.edu>.
-
-2005-02-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ConfigLoader.py (ConfigLoader.load): Allow empty strings
-	into keys (for prompts, for example).
-
-	* IPython/Prompts.py (BasePrompt.set_p_str): Fix to allow empty
-	prompts in case users want them.  This introduces a small behavior
-	change: ipython does not automatically add a space to all prompts
-	anymore.  To get the old prompts with a space, users should add it
-	manually to their ipythonrc file, so for example prompt_in1 should
-	now read 'In [\#]: ' instead of 'In [\#]:'.
-	(BasePrompt.__init__): New option prompts_pad_left (only in rc
-	file) to control left-padding of secondary prompts.
-
-	* IPython/Magic.py (Magic.profile_missing_notice): Don't crash if
-	the profiler can't be imported.  Fix for Debian, which removed
-	profile.py because of License issues.  I applied a slightly
-	modified version of the original Debian patch at
-	http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=294500.
-
-2005-02-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (native_line_ends): Fix bug which would
-	cause improper line-ends under win32 b/c I was not opening files
-	in binary mode.  Bug report and fix thanks to Ville.
-
-	* IPython/iplib.py (handle_auto): Fix bug which I introduced when
-	trying to catch spurious foo[1] autocalls.  My fix actually broke
-	',/' autoquote/call with explicit escape (bad regexp).
-
-2005-02-15  *** Released version 0.6.11
-
-2005-02-14  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/background_jobs.py: New background job management
-	subsystem.  This is implemented via a new set of classes, and
-	IPython now provides a builtin 'jobs' object for background job
-	execution.  A convenience %bg magic serves as a lightweight
-	frontend for starting the more common type of calls.  This was
-	inspired by discussions with B. Granger and the BackgroundCommand
-	class described in the book Python Scripting for Computational
-	Science, by H. P. Langtangen: http://folk.uio.no/hpl/scripting
-	(although ultimately no code from this text was used, as IPython's
-	system is a separate implementation).
-
-	* IPython/iplib.py (MagicCompleter.python_matches): add new option
-	to control the completion of single/double underscore names
-	separately.  As documented in the example ipytonrc file, the
-	readline_omit__names variable can now be set to 2, to omit even
-	single underscore names.  Thanks to a patch by Brian Wong
-	<BrianWong-AT-AirgoNetworks.Com>.
-	(InteractiveShell.__init__): Fix bug which would cause foo[1] to
-	be autocalled as foo([1]) if foo were callable.  A problem for
-	things which are both callable and implement __getitem__.
-	(init_readline): Fix autoindentation for win32.  Thanks to a patch
-	by Vivian De Smedt <vivian-AT-vdesmedt.com>.
-
-2005-02-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): Disabled the stout traps
-	which I had written long ago to sort out user error messages which
-	may occur during startup.  This seemed like a good idea initially,
-	but it has proven a disaster in retrospect.  I don't want to
-	change much code for now, so my fix is to set the internal 'debug'
-	flag to true everywhere, whose only job was precisely to control
-	this subsystem.  This closes issue 28 (as well as avoiding all
-	sorts of strange hangups which occur from time to time).
-
-2005-02-07  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (magic_edit): Fix 'ed -p' not working when the
-	previous call produced a syntax error.
-
-	* IPython/OInspect.py (Inspector.pinfo): Fix crash when inspecting
-	classes without constructor.
-
-2005-02-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (MagicCompleter.complete): Extend the list of
-	completions with the results of each matcher, so we return results
-	to the user from all namespaces.  This breaks with ipython
-	tradition, but I think it's a nicer behavior.  Now you get all
-	possible completions listed, from all possible namespaces (python,
-	filesystem, magics...)  After a request by John Hunter
-	<jdhunter-AT-nitace.bsd.uchicago.edu>.
-
-2005-02-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (magic_prun): Fix bug where prun would fail if
-	the call had quote characters in it (the quotes were stripped).
-
-2005-01-31  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): reduce reliance on
-	Itpl.itpl() to make the code more robust against psyco
-	optimizations.
-
-	* IPython/Itpl.py (Itpl.__str__): Use a _getframe() call instead
-	of causing an exception.  Quicker, cleaner.
-
-2005-01-28  Fernando Perez  <fperez@colorado.edu>
-
-	* scripts/ipython_win_post_install.py (install): hardcode
-	sys.prefix+'python.exe' as the executable path.  It turns out that
-	during the post-installation run, sys.executable resolves to the
-	name of the binary installer!  I should report this as a distutils
-	bug, I think.  I updated the .10 release with this tiny fix, to
-	avoid annoying the lists further.
-
-2005-01-27  *** Released version 0.6.10
-
-2005-01-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py (norm): Added 'inf' as optional name for
-	L-infinity norm, included references to mathworld.com for vector
-	norm definitions.
-	(amin/amax): added amin/amax for array min/max.  Similar to what
-	pylab ships with after the recent reorganization of names.
-	(spike/spike_odd): removed deprecated spike/spike_odd functions.
-
-	* ipython.el: committed Alex's recent fixes and improvements.
-	Tested with python-mode from CVS, and it looks excellent.  Since
-	python-mode hasn't released anything in a while, I'm temporarily
-	putting a copy of today's CVS (v 4.70) of python-mode in:
-	  http://ipython.scipy.org/tmp/python-mode.el
-
-	* scripts/ipython_win_post_install.py (install): Win32 fix to use
-	sys.executable for the executable name, instead of assuming it's
-	called 'python.exe' (the post-installer would have produced broken
-	setups on systems with a differently named python binary).
-
-	* IPython/PyColorize.py (Parser.__call__): change explicit '\n'
-	references to os.linesep, to make the code more
-	platform-independent.  This is also part of the win32 coloring
-	fixes.
-
-	* IPython/genutils.py (page_dumb): Remove attempts to chop long
-	lines, which actually cause coloring bugs because the length of
-	the line is very difficult to correctly compute with embedded
-	escapes.  This was the source of all the coloring problems under
-	Win32.  I think that _finally_, Win32 users have a properly
-	working ipython in all respects.  This would never have happened
-	if not for Gary Bishop and Viktor Ransmayr's great help and work.
-
-2005-01-26  *** Released version 0.6.9
-
-2005-01-25  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py: finally, we have a true Windows installer, thanks to
-	the excellent work of Viktor Ransmayr
-	<viktor.ransmayr-AT-t-online.de>.  The docs have been updated for
-	Windows users.  The setup routine is quite a bit cleaner thanks to
-	this, and the post-install script uses the proper functions to
-	allow a clean de-installation using the standard Windows Control
-	Panel.
-	
-	* IPython/genutils.py (get_home_dir): changed to use the $HOME
-	environment variable under all OSes (including win32) if
-	available.  This will give consistency to win32 users who have set
-	this variable for any reason.  If os.environ['HOME'] fails, the
-	previous policy of using HOMEDRIVE\HOMEPATH kicks in.
-
-2005-01-24  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py (empty_like): add empty_like(), similar to
-	zeros_like() but taking advantage of the new empty() Numeric routine.
-
-2005-01-23  *** Released version 0.6.8
-
-2005-01-22  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): I removed the
-	automatic show() calls.  After discussing things with JDH, it
-	turns out there are too many corner cases where this can go wrong.
-	It's best not to try to be 'too smart', and simply have ipython
-	reproduce as much as possible the default behavior of a normal
-	python shell.
-
-	* IPython/iplib.py (InteractiveShell.__init__): Modified the
-	line-splitting regexp and _prefilter() to avoid calling getattr()
-	on assignments.  This closes
-	http://www.scipy.net/roundup/ipython/issue24.  Note that Python's
-	readline uses getattr(), so a simple <TAB> keypress is still
-	enough to trigger getattr() calls on an object.
-
-2005-01-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MatplotlibShellBase.magic_run): Fix the %run
-	docstring under pylab so it doesn't mask the original.
-
-2005-01-21  *** Released version 0.6.7
-
-2005-01-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MTInteractiveShell.runcode): Trap a crash with
-	signal handling for win32 users in multithreaded mode.
-
-2005-01-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/OInspect.py (Inspector.pinfo): Fix crash when inspecting
-	instances with no __init__.  After a crash report by Norbert Nemec
-	<Norbert-AT-nemec-online.de>.
-
-2005-01-14  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.text): Fix bug in reporting of
-	names for verbose exceptions, when multiple dotted names and the
-	'parent' object were present on the same line.
-
-2005-01-11  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (flag_calls): new utility to trap and flag
-	calls in functions.  I need it to clean up matplotlib support.
-	Also removed some deprecated code in genutils.
-
-	* IPython/Shell.py (MatplotlibShellBase.mplot_exec): small fix so
-	that matplotlib scripts called with %run, which don't call show()
-	themselves, still have their plotting windows open.
-
-2005-01-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.__init__): Patch by Andrew Straw
-	<astraw-AT-caltech.edu>, to fix gtk deprecation warnings.
-
-2004-12-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MTInteractiveShell.runcode): Get rid of
-	parent_runcode, which was an eyesore.  The same result can be
-	obtained with Python's regular superclass mechanisms.
-
-2004-12-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_sc): Fix quote stripping problem
-	reported by Prabhu.
-	(Magic.magic_sx): direct all errors to Term.cerr (defaults to
-	sys.stderr) instead of explicitly calling sys.stderr.  This helps
-	maintain our I/O abstractions clean, for future GUI embeddings.
-
-	* IPython/genutils.py (info): added new utility for sys.stderr
-	unified info message handling (thin wrapper around warn()).
-
-	* IPython/ultraTB.py (VerboseTB.text): Fix misreported global
-	composite (dotted) names on verbose exceptions.
-	(VerboseTB.nullrepr): harden against another kind of errors which
-	Python's inspect module can trigger, and which were crashing
-	IPython.  Thanks to a report by Marco Lombardi
-	<mlombard-AT-ma010192.hq.eso.org>.
-
-2004-12-13  *** Released version 0.6.6
-
-2004-12-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.mainloop): catch RuntimeErrors
-	generated by pygtk upon initialization if it was built without
-	threads (for matplotlib users).  After a crash reported by
-	Leguijt, Jaap J SIEP-EPT-RES <Jaap.Leguijt-AT-shell.com>.
-
-	* IPython/ipmaker.py (make_IPython): fix small bug in the
-	import_some parameter for multiple imports.
-
-	* IPython/iplib.py (ipmagic): simplified the interface of
-	ipmagic() to take a single string argument, just as it would be
-	typed at the IPython cmd line.
-	(ipalias): Added new ipalias() with an interface identical to
-	ipmagic().  This completes exposing a pure python interface to the
-	alias and magic system, which can be used in loops or more complex
-	code where IPython's automatic line mangling is not active.
-
-	* IPython/genutils.py (timing): changed interface of timing to
-	simply run code once, which is the most common case.  timings()
-	remains unchanged, for the cases where you want multiple runs.
-
-	* IPython/Shell.py (MatplotlibShellBase._matplotlib_config): Fix a
-	bug where Python2.2 crashes with exec'ing code which does not end
-	in a single newline.  Python 2.3 is OK, so I hadn't noticed this
-	before.
-
-2004-12-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_prun): changed name of option from
-	-t to -T, to accomodate the new -t flag in %run (the %run and
-	%prun options are kind of intermixed, and it's not easy to change
-	this with the limitations of python's getopt).
-
-	* IPython/Magic.py (Magic.magic_run): Added new -t option to time
-	the execution of scripts.  It's not as fine-tuned as timeit.py,
-	but it works from inside ipython (and under 2.2, which lacks
-	timeit.py).  Optionally a number of runs > 1 can be given for
-	timing very short-running code.
-
-	* IPython/genutils.py (uniq_stable): new routine which returns a
-	list of unique elements in any iterable, but in stable order of
-	appearance.  I needed this for the ultraTB fixes, and it's a handy
-	utility.
-
-	* IPython/ultraTB.py (VerboseTB.text): Fix proper reporting of
-	dotted names in Verbose exceptions.  This had been broken since
-	the very start, now x.y will properly be printed in a Verbose
-	traceback, instead of x being shown and y appearing always as an
-	'undefined global'.  Getting this to work was a bit tricky,
-	because by default python tokenizers are stateless.  Saved by
-	python's ability to easily add a bit of state to an arbitrary
-	function (without needing to build a full-blown callable object).
-
-	Also big cleanup of this code, which had horrendous runtime
-	lookups of zillions of attributes for colorization.  Moved all
-	this code into a few templates, which make it cleaner and quicker.
-
-	Printout quality was also improved for Verbose exceptions: one
-	variable per line, and memory addresses are printed (this can be
-	quite handy in nasty debugging situations, which is what Verbose
-	is for).
-
-	* IPython/ipmaker.py (make_IPython): Do NOT execute files named in
-	the command line as scripts to be loaded by embedded instances.
-	Doing so has the potential for an infinite recursion if there are
-	exceptions thrown in the process.  This fixes a strange crash
-	reported by Philippe MULLER <muller-AT-irit.fr>.
-
-2004-12-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MatplotlibShellBase.use): Change pylab support
-	to reflect new names in matplotlib, which now expose the
-	matlab-compatible interface via a pylab module instead of the
-	'matlab' name.  The new code is backwards compatible, so users of
-	all matplotlib versions are OK.  Patch by J. Hunter.
-
-	* IPython/OInspect.py (Inspector.pinfo): Add to object? printing
-	of __init__ docstrings for instances (class docstrings are already
-	automatically printed).  Instances with customized docstrings
-	(indep. of the class) are also recognized and all 3 separate
-	docstrings are printed (instance, class, constructor).  After some
-	comments/suggestions by J. Hunter.
-
-2004-12-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (MagicCompleter.complete): Remove annoying
-	warnings when tab-completion fails and triggers an exception.
-
-2004-12-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (magic_prun): Fix bug where an exception would
-	be triggered when using 'run -p'.  An incorrect option flag was
-	being set ('d' instead of 'D').
-	(manpage): fix missing escaped \- sign.
-
-2004-11-30  *** Released version 0.6.5
-
-2004-11-30  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_run): Fix bug in breakpoint
-	setting with -d option.
-
-	* setup.py (docfiles): Fix problem where the doc glob I was using
-	was COMPLETELY BROKEN.  It was giving the right files by pure
-	accident, but failed once I tried to include ipython.el.  Note:
-	glob() does NOT allow you to do exclusion on multiple endings!
-
-2004-11-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/usage.py (__doc__): cleaned up usage docstring, by using
-	the manpage as the source.  Better formatting & consistency.
-
-	* IPython/Magic.py (magic_run): Added new -d option, to run
-	scripts under the control of the python pdb debugger.  Note that
-	this required changing the %prun option -d to -D, to avoid a clash
-	(since %run must pass options to %prun, and getopt is too dumb to
-	handle options with string values with embedded spaces).  Thanks
-	to a suggestion by Matthew Arnison <maffew-AT-cat.org.au>.
-	(magic_who_ls): added type matching to %who and %whos, so that one
-	can filter their output to only include variables of certain
-	types.  Another suggestion by Matthew.
-	(magic_whos): Added memory summaries in kb and Mb for arrays.
-	(magic_who): Improve formatting (break lines every 9 vars).
-
-2004-11-28  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.log): Fix bug in syncing the input
-	cache when empty lines were present.
-
-2004-11-24  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/usage.py (__doc__): document the re-activated threading
-	options for WX and GTK.
-
-2004-11-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (start): Added Prabhu's big patch to reactivate
-	the -wthread and -gthread options, along with a new -tk one to try
-	and coordinate Tk threading with wx/gtk.  The tk support is very
-	platform dependent, since it seems to require Tcl and Tk to be
-	built with threads (Fedora1/2 appears NOT to have it, but in
-	Prabhu's Debian boxes it works OK).  But even with some Tk
-	limitations, this is a great improvement.
-
-	* IPython/Prompts.py (prompt_specials_color): Added \t for time
-	info in user prompts.  Patch by Prabhu.
-
-2004-11-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (ask_yes_no): Add check for a max of 20
-	EOFErrors and bail, to avoid infinite loops if a non-terminating
-	file is fed into ipython.  Patch submitted in issue 19 by user,
-	many thanks.
-
-	* IPython/iplib.py (InteractiveShell.handle_auto): do NOT trigger
-	autoquote/parens in continuation prompts, which can cause lots of
-	problems.  Closes roundup issue 20.
-
-2004-11-17  Fernando Perez  <fperez@colorado.edu>
-
-	* debian/control (Build-Depends-Indep): Fix dpatch dependency,
-	reported as debian bug #280505.  I'm not sure my local changelog
-	entry has the proper debian format (Jack?).
-
-2004-11-08  *** Released version 0.6.4
-
-2004-11-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (init_readline): Fix exit message for Windows
-	when readline is active.  Thanks to a report by Eric Jones
-	<eric-AT-enthought.com>.
-
-2004-11-07  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (page): Add a trap for OSError exceptions,
-	sometimes seen by win2k/cygwin users.
-
-2004-11-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (interact): Change the handling of %Exit from
-	trying to propagate a SystemExit to an internal ipython flag.
-	This is less elegant than using Python's exception mechanism, but
-	I can't get that to work reliably with threads, so under -pylab
-	%Exit was hanging IPython.  Cross-thread exception handling is
-	really a bitch.  Thaks to a bug report by Stephen Walton
-	<stephen.walton-AT-csun.edu>.
-
-2004-11-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (raw_input_original): store a pointer to the
-	true raw_input to harden against code which can modify it
-	(wx.py.PyShell does this and would otherwise crash ipython).
-	Thanks to a bug report by Jim Flowers <james.flowers-AT-lgx.com>.
-
-	* IPython/Shell.py (MTInteractiveShell.runsource): Cleaner fix for
-	Ctrl-C problem, which does not mess up the input line.
-
-2004-11-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Release.py: Changed licensing to BSD, in all files.
-	(name): lowercase name for tarball/RPM release.
-
-	* IPython/OInspect.py (getdoc): wrap inspect.getdoc() safely for
-	use throughout ipython.
-
-	* IPython/Magic.py (Magic._ofind): Switch to using the new
-	OInspect.getdoc() function.
-
-	* IPython/Shell.py (sigint_handler): Hack to ignore the execution
-	of the line currently being canceled via Ctrl-C.  It's extremely
-	ugly, but I don't know how to do it better (the problem is one of
-	handling cross-thread exceptions).
-
-2004-10-28  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (signal_handler): add signal handlers to trap
-	SIGINT and SIGSEGV in threaded code properly.  Thanks to a bug
-	report by Francesc Alted.
-
-2004-10-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Extensions/InterpreterExec.py (prefilter_shell): Fix @
-	to % for pysh syntax extensions.
-
-2004-10-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_whos): modify output of Numeric
-	arrays to print a more useful summary, without calling str(arr).
-	This avoids the problem of extremely lengthy computations which
-	occur if arr is large, and appear to the user as a system lockup
-	with 100% cpu activity.  After a suggestion by Kristian Sandberg
-	<Kristian.Sandberg@colorado.edu>.
-	(Magic.__init__): fix bug in global magic escapes not being
-	correctly set.
-
-2004-10-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (__license__): change to absolute imports of
-	ipython's own internal packages, to start adapting to the absolute
-	import requirement of PEP-328.
-
-	* IPython/genutils.py (__author__): Fix coding to utf-8 on all
-	files, and standardize author/license marks through the Release
-	module instead of having per/file stuff (except for files with
-	particular licenses, like the MIT/PSF-licensed codes).
-
-	* IPython/Debugger.py: remove dead code for python 2.1
-
-2004-10-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (ipmagic): New function for accessing magics
-	via a normal python function call.
-
-	* IPython/Magic.py (Magic.magic_magic): Change the magic escape
-	from '@' to '%', to accomodate the new @decorator syntax of python
-	2.4.
-
-2004-09-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MatplotlibShellBase.use): Added a wrapper to
-	matplotlib.use to prevent running scripts which try to switch
-	interactive backends from within ipython.  This will just crash
-	the python interpreter, so we can't allow it (but a detailed error
-	is given to the user).
-	
-2004-09-28  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (MatplotlibShellBase.mplot_exec):
-	matplotlib-related fixes so that using @run with non-matplotlib
-	scripts doesn't pop up spurious plot windows.  This requires
-	matplotlib >= 0.63, where I had to make some changes as well.
-
-	* IPython/ipmaker.py (make_IPython): update version requirement to
-	python 2.2.
-
-	* IPython/iplib.py (InteractiveShell.mainloop): Add an optional
-	banner arg for embedded customization.
-
-	* IPython/Magic.py (Magic.__init__): big cleanup to remove all
-	explicit uses of __IP as the IPython's instance name.  Now things
-	are properly handled via the shell.name value.  The actual code
-	is a bit ugly b/c I'm doing it via a global in Magic.py, but this
-	is much better than before.  I'll clean things completely when the
-	magic stuff gets a real overhaul.
-
-	* ipython.1: small fixes, sent in by Jack Moffit.  He also sent in
-	minor changes to debian dir.
-
-	* IPython/iplib.py (InteractiveShell.__init__): Fix adding a
-	pointer to the shell itself in the interactive namespace even when
-	a user-supplied dict is provided.  This is needed for embedding
-	purposes (found by tests with Michel Sanner).
-
-2004-09-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/UserConfig/ipythonrc: remove []{} from
-	readline_remove_delims, so that things like [modname.<TAB> do
-	proper completion.  This disables [].TAB, but that's a less common
-	case than module names in list comprehensions, for example.
-	Thanks to a report by Andrea Riciputi.
-
-2004-09-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellGTK.mainloop): reorder to avoid
-	blocking problems in win32 and osx.  Fix by John.
-
-2004-09-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellWX.OnInit): Fix output redirection bug
-	for Win32 and OSX.  Fix by John Hunter.
-
-2004-08-30  *** Released version 0.6.3
-
-2004-08-30  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (isfile): Add manpages to list of dependent files to be
-	updated.
-
-2004-08-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (start): I've disabled -wthread and -gthread
-	for now.  They don't really work with standalone WX/GTK code
-	(though matplotlib IS working fine with both of those backends).
-	This will neeed much more testing.  I disabled most things with
-	comments, so turning it back on later should be pretty easy.
-
-	* IPython/iplib.py (InteractiveShell.__init__): Fix accidental
-	autocalling of expressions like r'foo', by modifying the line
-	split regexp.  Closes
-	http://www.scipy.net/roundup/ipython/issue18, reported by Nicholas
-	Riley <ipythonbugs-AT-sabi.net>.
-	(InteractiveShell.mainloop): honor --nobanner with banner
-	extensions.
-
-	* IPython/Shell.py: Significant refactoring of all classes, so
-	that we can really support ALL matplotlib backends and threading
-	models (John spotted a bug with Tk which required this).  Now we
-	should support single-threaded, WX-threads and GTK-threads, both
-	for generic code and for matplotlib.
-
-	* IPython/ipmaker.py (__call__): Changed -mpthread option to
-	-pylab, to simplify things for users.  Will also remove the pylab
-	profile, since now all of matplotlib configuration is directly
-	handled here.  This also reduces startup time.
-
-	* IPython/Shell.py (IPShellGTK.run): Fixed bug where mainloop() of
-	shell wasn't being correctly called.  Also in IPShellWX.
-
-	* IPython/iplib.py (InteractiveShell.__init__): Added option to
-	fine-tune banner.
-
-	* IPython/numutils.py (spike): Deprecate these spike functions,
-	delete (long deprecated) gnuplot_exec handler.
-
-2004-08-26  Fernando Perez  <fperez@colorado.edu>
-
-	* ipython.1: Update for threading options, plus some others which
-	were missing.
-
-	* IPython/ipmaker.py (__call__): Added -wthread option for
-	wxpython thread handling.  Make sure threading options are only
-	valid at the command line.
-
-	* scripts/ipython: moved shell selection into a factory function
-	in Shell.py, to keep the starter script to a minimum.
-
-2004-08-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellWX.wxexit): fixes to WX threading, by
-	John.  Along with some recent changes he made to matplotlib, the
-	next versions of both systems should work very well together.
-
-2004-08-24  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_prun): cleanup some dead code.  I
-	tried to switch the profiling to using hotshot, but I'm getting
-	strange errors from prof.runctx() there.  I may be misreading the
-	docs, but it looks weird.  For now the profiling code will
-	continue to use the standard profiler.
-
-2004-08-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellWX.__init__): Improvements to the WX
-	threaded shell, by John Hunter.  It's not quite ready yet, but
-	close.
-
-2004-08-22  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.interact): tab cleanups, also
-	in Magic and ultraTB.
-
-	* ipython.1: document threading options in manpage.
-
-	* scripts/ipython: Changed name of -thread option to -gthread,
-	since this is GTK specific.  I want to leave the door open for a
-	-wthread option for WX, which will most likely be necessary.  This
-	change affects usage and ipmaker as well.
-
-	* IPython/Shell.py (matplotlib_shell): Add a factory function to
-	handle the matplotlib shell issues.  Code by John Hunter
-	<jdhunter-AT-nitace.bsd.uchicago.edu>.
-	(IPShellMatplotlibWX.__init__): Rudimentary WX support.  It's
-	broken (and disabled for end users) for now, but it puts the
-	infrastructure in place.
-
-2004-08-21  Fernando Perez  <fperez@colorado.edu>
-
-	* ipythonrc-pylab: Add matplotlib support.
-
-	* matplotlib_config.py: new files for matplotlib support, part of
-	the pylab profile.
-
-	* IPython/usage.py (__doc__): documented the threading options.
-
-2004-08-20  Fernando Perez  <fperez@colorado.edu>
-
-	* ipython: Modified the main calling routine to handle the -thread
-	and -mpthread options.  This needs to be done as a top-level hack,
-	because it determines which class to instantiate for IPython
-	itself.
-
-	* IPython/Shell.py (MTInteractiveShell.__init__): New set of
-	classes to support multithreaded GTK operation without blocking,
-	and matplotlib with all backends.  This is a lot of still very
-	experimental code, and threads are tricky.  So it may still have a
-	few rough edges...  This code owes a lot to
-	http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/65109, by
-	Brian # McErlean and John Finlay, to Antoon Pardon for fixes, and
-	to John Hunter for all the matplotlib work.
-
-	* IPython/ipmaker.py (__call__): Added -thread and -mpthread
-	options for gtk thread and matplotlib support.
-
-2004-08-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): don't trigger
-	autocall for things like p*q,p/q,p+q,p-q, when p is callable.  Bug
-	reported by Stephen Walton <stephen.walton-AT-csun.edu>.
-
-2004-08-11  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (isfile): Fix build so documentation gets updated for
-	rpms (it was only done for .tgz builds).
-
-2004-08-10  Fernando Perez  <fperez@colorado.edu>
-
-	* genutils.py (Term): Fix misspell of stdin stream (sin->cin).
-
-	* iplib.py : Silence syntax error exceptions in tab-completion.
-	
-2004-08-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (Prompt2.set_colors): Fix incorrectly set
-	'color off' mark for continuation prompts.  This was causing long
-	continuation lines to mis-wrap.
-
-2004-08-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): Allow the shell class used
-	for building ipython to be a parameter.  All this is necessary
-	right now to have a multithreaded version, but this insane
-	non-design will be cleaned up soon.  For now, it's a hack that
-	works.
-
-	* IPython/Shell.py (IPShell.__init__): Stop using mutable default
-	args in various places.  No bugs so far, but it's a dangerous
-	practice.
-
-2004-07-31  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (complete): ignore SyntaxError exceptions to
-	fix completion of files with dots in their names under most
-	profiles (pysh was OK because the completion order is different).
-
-2004-07-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): build dict of
-	keywords manually, b/c the one in keyword.py was removed in python
-	2.4.  Patch by Anakim Border <aborder-AT-users.sourceforge.net>.
-	This is NOT a bug under python 2.3 and earlier.
-
-2004-07-26  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.text): Add another
-	linecache.checkcache() call to try to prevent inspect.py from
-	crashing under python 2.3.  I think this fixes
-	http://www.scipy.net/roundup/ipython/issue17.
-
-2004-07-26  *** Released version 0.6.2
-
-2004-07-26  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_cd): Fix bug where 'cd -N' would
-	fail for any number.
-	(Magic.magic_bookmark): Fix bug where 'bookmark -l' would fail for
-	empty bookmarks.
-
-2004-07-26  *** Released version 0.6.1
-
-2004-07-26  Fernando Perez  <fperez@colorado.edu>
-
-	* ipython_win_post_install.py (run): Added pysh shortcut for Windows.
-
-	* IPython/iplib.py (protect_filename): Applied Ville's patch for
-	escaping '()[]{}' in filenames.
-
-	* IPython/Magic.py (shlex_split): Fix handling of '*' and '?' for
-	Python 2.2 users who lack a proper shlex.split.
-
-2004-07-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.init_readline): Add support
-	for reading readline's init file.  I follow the normal chain:
-	$INPUTRC is honored, otherwise ~/.inputrc is used.  Thanks to a
-	report by Mike Heeter.  This closes
-	http://www.scipy.net/roundup/ipython/issue16.
-
-2004-07-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (__init__): Add better handling of '\' under
-	Win32 for filenames.  After a patch by Ville.
-
-2004-07-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell._prefilter): fix bug where
-	autocalling would be triggered for 'foo is bar' if foo is
-	callable.  I also cleaned up the autocall detection code to use a
-	regexp, which is faster.  Bug reported by Alexander Schmolck.
-
-	* IPython/Magic.py (Magic.magic_pinfo): Fix bug where strings with
-	'?' in them would confuse the help system.  Reported by Alex
-	Schmolck.
-
-2004-07-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/GnuplotInteractive.py (__all__): added plot2.
-
-	* IPython/Gnuplot2.py (Gnuplot.plot2): added new function for
-	plotting dictionaries, lists or tuples of 1d arrays.
-
-	* IPython/Magic.py (Magic.magic_hist): small clenaups and
-	optimizations.
-
-	* IPython/iplib.py:Remove old Changelog info for cleanup.  This is
-	the information which was there from Janko's original IPP code:
-
-	03.05.99 20:53 porto.ifm.uni-kiel.de
-	--Started changelog.
-	--make clear do what it say it does
-	--added pretty output of lines from inputcache
-	--Made Logger a mixin class, simplifies handling of switches
-	--Added own completer class. .string<TAB> expands to last history
-	line which starts with string.  The new expansion is also present
-	with Ctrl-r from the readline library.  But this shows, who this
-	can be done for other cases.
-	--Added convention that all shell functions should accept a
-	parameter_string This opens the door for different behaviour for
-	each function. @cd is a good example of this.
-
-	04.05.99 12:12 porto.ifm.uni-kiel.de
-	--added logfile rotation
-	--added new mainloop method which freezes first the namespace
-
-	07.05.99 21:24 porto.ifm.uni-kiel.de
-	--added the docreader classes. Now there is a help system.
-	-This is only a first try. Currently it's not easy to put new
-	stuff in the indices. But this is the way to go. Info would be
-	better, but HTML is every where and not everybody has an info
-	system installed and it's not so easy to change html-docs to info.
-	--added global logfile option
-	--there is now a hook for object inspection method pinfo needs to
-	be provided for this. Can be reached by two '??'.
-
-	08.05.99 20:51 porto.ifm.uni-kiel.de
-	--added a README
-	--bug in rc file. Something has changed so functions in the rc
-	file need to reference the shell and not self. Not clear if it's a
-	bug or feature.
-	--changed rc file for new behavior
-
-2004-07-15  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.log): fixed recent bug where the input
-	cache was falling out of sync in bizarre manners when multi-line
-	input was present.  Minor optimizations and cleanup.
-
-	(Logger): Remove old Changelog info for cleanup.  This is the
-	information which was there from Janko's original code:
-
-	Changes to Logger: - made the default log filename a parameter
-
-	- put a check for lines beginning with !@? in log(). Needed
-	(even if the handlers properly log their lines) for mid-session
-	logging activation to work properly. Without this, lines logged
-	in mid session, which get read from the cache, would end up
-	'bare' (with !@? in the open) in the log. Now they are caught
-	and prepended with a #.
-
-	* IPython/iplib.py (InteractiveShell.init_readline): added check
-	in case MagicCompleter fails to be defined, so we don't crash.
-
-2004-07-13  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Gnuplot2.py (Gnuplot.hardcopy): add automatic generation
-	of EPS if the requested filename ends in '.eps'.
-
-2004-07-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.handle_shell_escape): Fix
-	escaping of quotes when calling the shell.
-
-2004-07-02  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (CachedOutput.update): Fix problem with
-	gettext not working because we were clobbering '_'.  Fixes
-	http://www.scipy.net/roundup/ipython/issue6.
-
-2004-07-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_cd): integrated bookmark handling
-	into @cd.  Patch by Ville.
-
-	* IPython/iplib.py (InteractiveShell.post_config_initialization):
-	new function to store things after ipmaker runs.  Patch by Ville.
-	Eventually this will go away once ipmaker is removed and the class
-	gets cleaned up, but for now it's ok.  Key functionality here is
-	the addition of the persistent storage mechanism, a dict for
-	keeping data across sessions (for now just bookmarks, but more can
-	be implemented later).
-
-	* IPython/Magic.py (Magic.magic_bookmark): New bookmark system,
-	persistent across sections.  Patch by Ville, I modified it
-	soemwhat to allow bookmarking arbitrary dirs other than CWD.  Also
-	added a '-l' option to list all bookmarks.
-
-	* IPython/iplib.py (InteractiveShell.atexit_operations): new
-	center for cleanup.  Registered with atexit.register().  I moved
-	here the old exit_cleanup().  After a patch by Ville.
-
-	* IPython/Magic.py (get_py_filename): added '~' to the accepted
-	characters in the hacked shlex_split for python 2.2.
-
-	* IPython/iplib.py (file_matches): more fixes to filenames with
-	whitespace in them.  It's not perfect, but limitations in python's
-	readline make it impossible to go further.
-
-2004-06-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (file_matches): escape whitespace correctly in
-	filename completions.  Bug reported by Ville.
-
-2004-06-28  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (__call__): Added per-profile histories.  Now
-	the history file will be called 'history-PROFNAME' (or just
-	'history' if no profile is loaded).  I was getting annoyed at
-	getting my Numerical work history clobbered by pysh sessions.
-
-	* IPython/iplib.py (InteractiveShell.__init__): Internal
-	getoutputerror() function so that we can honor the system_verbose
-	flag for _all_ system calls.  I also added escaping of #
-	characters here to avoid confusing Itpl.
-
-	* IPython/Magic.py (shlex_split): removed call to shell in
-	parse_options and replaced it with shlex.split().  The annoying
-	part was that in Python 2.2, shlex.split() doesn't exist, so I had
-	to backport it from 2.3, with several frail hacks (the shlex
-	module is rather limited in 2.2).  Thanks to a suggestion by Ville
-	Vainio <vivainio@kolumbus.fi>.  For Python 2.3 there should be no
-	problem.
-	
-	(Magic.magic_system_verbose): new toggle to print the actual
-	system calls made by ipython.  Mainly for debugging purposes.
-
-	* IPython/GnuplotRuntime.py (gnu_out): fix bug for cygwin, which
-	doesn't support persistence.  Reported (and fix suggested) by
-	Travis Caldwell <travis_caldwell2000@yahoo.com>.
-
-2004-06-26  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.log): fix to handle correctly empty
-	continue prompts.
-
-	* IPython/Extensions/InterpreterExec.py (pysh): moved the pysh()
-	function (basically a big docstring) and a few more things here to
-	speedup startup. pysh.py is now very lightweight.  We want because
-	it gets execfile'd, while InterpreterExec gets imported, so
-	byte-compilation saves time.
-
-2004-06-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_cd): Fixed to restore usage of 'cd
-	-NUM', which was recently broken.
-
-	* IPython/iplib.py (InteractiveShell.handle_shell_escape): allow !
-	in multi-line input (but not !!, which doesn't make sense there).
-
-	* IPython/UserConfig/ipythonrc: made autoindent on by default.
-	It's just too useful, and people can turn it off in the less
-	common cases where it's a problem.
-
-2004-06-24  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell._prefilter): big change -
-	special syntaxes (like alias calling) is now allied in multi-line
-	input.  This is still _very_ experimental, but it's necessary for
-	efficient shell usage combining python looping syntax with system
-	calls.  For now it's restricted to aliases, I don't think it
-	really even makes sense to have this for magics.
-
-2004-06-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Extensions/InterpreterExec.py (prefilter_shell): Added
-	$var=cmd <=> @sc var=cmd and  $$var=cmd <=> @sc -l var=cmd.
-
-	* IPython/Magic.py (Magic.magic_rehashx): modified to handle
-	extensions under Windows (after code sent by Gary Bishop).  The
-	extensions considered 'executable' are stored in IPython's rc
-	structure as win_exec_ext.
-
-	* IPython/genutils.py (shell): new function, like system() but
-	without return value.  Very useful for interactive shell work.
-
-	* IPython/Magic.py (Magic.magic_unalias): New @unalias function to
-	delete aliases.
-
-	* IPython/iplib.py (InteractiveShell.alias_table_update): make
-	sure that the alias table doesn't contain python keywords.
-
-2004-06-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_rehash): Fix crash when
-	non-existent items are found in $PATH.  Reported by Thorsten.
-
-2004-06-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (complete): modified the completer so that the
-	order of priorities can be easily changed at runtime.
-
-	* IPython/Extensions/InterpreterExec.py (prefilter_shell):
-	Modified to auto-execute all lines beginning with '~', '/' or '.'.
-
-	* IPython/Magic.py (Magic.magic_sx): modified @sc and @sx to
-	expand Python variables prepended with $ in all system calls.  The
-	same was done to InteractiveShell.handle_shell_escape.  Now all
-	system access mechanisms (!, !!, @sc, @sx and aliases) allow the
-	expansion of python variables and expressions according to the
-	syntax of PEP-215 - http://www.python.org/peps/pep-0215.html.
-
-	Though PEP-215 has been rejected, a similar (but simpler) one
-	seems like it will go into Python 2.4, PEP-292 -
-	http://www.python.org/peps/pep-0292.html.
-
-	I'll keep the full syntax of PEP-215, since IPython has since the
-	start used Ka-Ping Yee's reference implementation discussed there
-	(Itpl), and I actually like the powerful semantics it offers.
-
-	In order to access normal shell variables, the $ has to be escaped
-	via an extra $.  For example:
-
-	In [7]: PATH='a python variable'
-
-	In [8]: !echo $PATH
-	a python variable
-
-	In [9]: !echo $$PATH
-	/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
-
-	(Magic.parse_options): escape $ so the shell doesn't evaluate
-	things prematurely.
-
-	* IPython/iplib.py (InteractiveShell.call_alias): added the
-	ability for aliases to expand python variables via $.
-
-	* IPython/Magic.py (Magic.magic_rehash): based on the new alias
-	system, now there's a @rehash/@rehashx pair of magics.  These work
-	like the csh rehash command, and can be invoked at any time.  They
-	build a table of aliases to everything in the user's $PATH
-	(@rehash uses everything, @rehashx is slower but only adds
-	executable files).  With this, the pysh.py-based shell profile can
-	now simply call rehash upon startup, and full access to all
-	programs in the user's path is obtained.
-
-	* IPython/iplib.py (InteractiveShell.call_alias): The new alias
-	functionality is now fully in place.  I removed the old dynamic
-	code generation based approach, in favor of a much lighter one
-	based on a simple dict.  The advantage is that this allows me to
-	now have thousands of aliases with negligible cost (unthinkable
-	with the old system).
-
-2004-06-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (__init__): extended MagicCompleter class to
-	also complete (last in priority) on user aliases.
-
-	* IPython/Itpl.py (Itpl.__str__): fixed order of globals/locals in
-	call to eval.
-	(ItplNS.__init__): Added a new class which functions like Itpl,
-	but allows configuring the namespace for the evaluation to occur
-	in.
-
-2004-06-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.runcode): modify to print a
-	better message when 'exit' or 'quit' are typed (a common newbie
-	confusion).
-
-	* IPython/Magic.py (Magic.magic_colors): Added the runtime color
-	check for Windows users.
-
-	* IPython/iplib.py (InteractiveShell.user_setup): removed
-	disabling of colors for Windows.  I'll test at runtime and issue a
-	warning if Gary's readline isn't found, as to nudge users to
-	download it.
-
-2004-06-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (Stream.__init__): changed to print errors
-	to sys.stderr.  I had a circular dependency here.  Now it's
-	possible to run ipython as IDLE's shell (consider this pre-alpha,
-	since true stdout things end up in the starting terminal instead
-	of IDLE's out).
-
-	* IPython/Prompts.py (Prompt2.set_colors): prevent crashes for
-	users who haven't # updated their prompt_in2 definitions.  Remove
-	eventually.
-	(multiple_replace): added credit to original ASPN recipe.
-
-2004-06-15  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): add 'cp' to the
-	list of auto-defined aliases.
-
-2004-06-13  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (scriptfiles): Don't trigger win_post_install unless an
-	install was really requested (so setup.py can be used for other
-	things under Windows).
-
-2004-06-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.create_log): Manually remove any old
-	backup, since os.remove may fail under Windows.  Fixes bug
-	reported by Thorsten.
-
-2004-06-09  Fernando Perez  <fperez@colorado.edu>
-
-	* examples/example-embed.py: fixed all references to %n (replaced
-	with \\# for ps1/out prompts and with \\D for ps2 prompts).  Done
-	for all examples and the manual as well.
-
-2004-06-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (Prompt2.set_p_str): fixed all prompt
-	alignment and color management.  All 3 prompt subsystems now
-	inherit from BasePrompt.
-
-	* tools/release: updates for windows installer build and tag rpms
-	with python version (since paths are fixed).
-
-	* IPython/UserConfig/ipythonrc: modified to use \# instead of %n,
-	which will become eventually obsolete.  Also fixed the default
-	prompt_in2 to use \D, so at least new users start with the correct
-	defaults.
-	WARNING: Users with existing ipythonrc files will need to apply
-	this fix manually!
-
-	* setup.py: make windows installer (.exe).  This is finally the
-	integration of an old patch by Cory Dodt <dodt-AT-fcoe.k12.ca.us>,
-	which I hadn't included because it required Python 2.3 (or recent
-	distutils).
-
-	* IPython/usage.py (__doc__): update docs (and manpage) to reflect
-	usage of new '\D' escape.
-
-	* IPython/Prompts.py (ROOT_SYMBOL): Small fix for Windows (which
-	lacks os.getuid())
-	(CachedOutput.set_colors): Added the ability to turn coloring
-	on/off with @colors even for manually defined prompt colors.  It
-	uses a nasty global, but it works safely and via the generic color
-	handling mechanism.
-	(Prompt2.__init__): Introduced new escape '\D' for continuation
-	prompts. It represents the counter ('\#') as dots.
-	*** NOTE *** THIS IS A BACKWARDS-INCOMPATIBLE CHANGE.  Users will
-	need to update their ipythonrc files and replace '%n' with '\D' in
-	their prompt_in2 settings everywhere.  Sorry, but there's
-	otherwise no clean way to get all prompts to properly align.  The
-	ipythonrc shipped with IPython has been updated.
-
-2004-06-07  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (isfile): Pass local_icons option to latex2html, so the
-	resulting HTML file is self-contained.  Thanks to
-	dryice-AT-liu.com.cn for the tip.
-
-	* pysh.py: I created a new profile 'shell', which implements a
-	_rudimentary_ IPython-based shell.  This is in NO WAY a realy
-	system shell, nor will it become one anytime soon.  It's mainly
-	meant to illustrate the use of the new flexible bash-like prompts.
-	I guess it could be used by hardy souls for true shell management,
-	but it's no tcsh/bash...  pysh.py is loaded by the 'shell'
-	profile.  This uses the InterpreterExec extension provided by
-	W.J. van der Laan <gnufnork-AT-hetdigitalegat.nl>
-
-	* IPython/Prompts.py (PromptOut.__str__): now it will correctly
-	auto-align itself with the length of the previous input prompt
-	(taking into account the invisible color escapes).
-	(CachedOutput.__init__): Large restructuring of this class.  Now
-	all three prompts (primary1, primary2, output) are proper objects,
-	managed by the 'parent' CachedOutput class.  The code is still a
-	bit hackish (all prompts share state via a pointer to the cache),
-	but it's overall far cleaner than before.
-
-	* IPython/genutils.py (getoutputerror): modified to add verbose,
-	debug and header options.  This makes the interface of all getout*
-	functions uniform.
-	(SystemExec.getoutputerror): added getoutputerror to SystemExec.
-
-	* IPython/Magic.py (Magic.default_option): added a function to
-	allow registering default options for any magic command.  This
-	makes it easy to have profiles which customize the magics globally
-	for a certain use.  The values set through this function are
-	picked up by the parse_options() method, which all magics should
-	use to parse their options.
-
-	* IPython/genutils.py (warn): modified the warnings framework to
-	use the Term I/O class.  I'm trying to slowly unify all of
-	IPython's I/O operations to pass through Term.
-
-	* IPython/Prompts.py (Prompt2._str_other): Added functionality in
-	the secondary prompt to correctly match the length of the primary
-	one for any prompt.  Now multi-line code will properly line up
-	even for path dependent prompts, such as the new ones available
-	via the prompt_specials.
-
-2004-06-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (prompt_specials): Added the ability to have
-	bash-like special sequences in the prompts, which get
-	automatically expanded.  Things like hostname, current working
-	directory and username are implemented already, but it's easy to
-	add more in the future.  Thanks to a patch by W.J. van der Laan
-	<gnufnork-AT-hetdigitalegat.nl>
-	(prompt_specials): Added color support for prompt strings, so
-	users can define arbitrary color setups for their prompts.
-
-2004-06-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (Term.reopen_all): Added Windows-specific
-	code to load Gary Bishop's readline and configure it
-	automatically.  Thanks to Gary for help on this.
-
-2004-06-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.create_log): fix bug for logging
-	with no filename (previous fix was incomplete).
-
-2004-05-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.parse_options): fix bug where naked
-	parens would get passed to the shell.
-
-2004-05-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_prun): changed default profile
-	sort order to 'time' (the more common profiling need).
-
-	* IPython/OInspect.py (Inspector.pinfo): flush the inspect cache
-	so that source code shown is guaranteed in sync with the file on
-	disk (also changed in psource).  Similar fix to the one for
-	ultraTB on 2004-05-06.  Thanks to a bug report by Yann Le Du
-	<yann.ledu-AT-noos.fr>.
-	
-	* IPython/Magic.py (Magic.parse_options): Fixed bug where commands
-	with a single option would not be correctly parsed. Closes
-	http://www.scipy.net/roundup/ipython/issue14.  This bug had been
-	introduced in 0.6.0 (on 2004-05-06).
-
-2004-05-13  *** Released version 0.6.0
-
-2004-05-13  Fernando Perez  <fperez@colorado.edu>
-
-	* debian/: Added debian/ directory to CVS, so that debian support
-	is publicly accessible.  The debian package is maintained by Jack
-	Moffit <jack-AT-xiph.org>.
-
-	* Documentation: included the notes about an ipython-based system
-	shell (the hypothetical 'pysh') into the new_design.pdf document,
-	so that these ideas get distributed to users along with the
-	official documentation.
-
-2004-05-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.create_log): fix recently introduced
-	bug (misindented line) where logstart would fail when not given an
-	explicit filename.
-
-2004-05-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.parse_options): skip system call when
-	there are no options to look for.  Faster, cleaner for the common
-	case.
-
-	* Documentation: many updates to the manual: describing Windows
-	support better, Gnuplot updates, credits, misc small stuff.  Also
-	updated the new_design doc a bit.
-
-2004-05-06  *** Released version 0.6.0.rc1
-
-2004-05-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (ListTB.text): modified a ton of string +=
-	operations to use the vastly more efficient list/''.join() method.
-	(FormattedTB.text): Fix
-	http://www.scipy.net/roundup/ipython/issue12 - exception source
-	extract not updated after reload.  Thanks to Mike Salib
-	<msalib-AT-mit.edu> for pinning the source of the problem.
-	Fortunately, the solution works inside ipython and doesn't require
-	any changes to python proper.
-
-	* IPython/Magic.py (Magic.parse_options): Improved to process the
-	argument list as a true shell would (by actually using the
-	underlying system shell).  This way, all @magics automatically get
-	shell expansion for variables.  Thanks to a comment by Alex
-	Schmolck.
-
-2004-04-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.interact): Added a special
-	trap for a debugger quit exception, which is basically impossible
-	to handle by normal mechanisms, given what pdb does to the stack.
-	This fixes a crash reported by <fgibbons-AT-llama.med.harvard.edu>.
-
-2004-04-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (Term): Standardized the names of the Term
-	class streams to cin/cout/cerr, following C++ naming conventions
-	(I can't use in/out/err because 'in' is not a valid attribute
-	name).
-
-	* IPython/iplib.py (InteractiveShell.interact): don't increment
-	the prompt if there's no user input.  By Daniel 'Dang' Griffith
-	<pythondev-dang-AT-lazytwinacres.net>, after a suggestion from
-	Francois Pinard.
-
-2004-04-02  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (Stream.__init__): Modified to survive at
-	least importing in contexts where stdin/out/err aren't true file
-	objects, such as PyCrust (they lack fileno() and mode).  However,
-	the recovery facilities which rely on these things existing will
-	not work.
-
-2004-04-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_sx): modified (as well as @sc) to
-	use the new getoutputerror() function, so it properly
-	distinguishes stdout/err.
-
-	* IPython/genutils.py (getoutputerror): added a function to
-	capture separately the standard output and error of a command.
-	After a comment from dang on the mailing lists.  This code is
-	basically a modified version of commands.getstatusoutput(), from
-	the standard library.
-
-	* IPython/iplib.py (InteractiveShell.handle_shell_escape): added
-	'!!' as a special syntax (shorthand) to access @sx.
-
-	* IPython/Magic.py (Magic.magic_sx): new magic, to execute a shell
-	command and return its output as a list split on '\n'.
-
-2004-03-31  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/FakeModule.py (FakeModule.__init__): added __nonzero__
-	method to dictionaries used as FakeModule instances if they lack
-	it.  At least pydoc in python2.3 breaks for runtime-defined
-	functions without this hack.  At some point I need to _really_
-	understand what FakeModule is doing, because it's a gross hack.
-	But it solves Arnd's problem for now...
-
-2004-02-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.create_log): Fix bug where 'rotate'
-	mode would behave erratically.  Also increased the number of
-	possible logs in rotate mod to 999.  Thanks to Rod Holland
-	<rhh@StructureLABS.com> for the report and fixes.
-	
-2004-02-26  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (page): Check that the curses module really
-	has the initscr attribute before trying to use it.  For some
-	reason, the Solaris curses module is missing this.  I think this
-	should be considered a Solaris python bug, but I'm not sure.
-
-2004-01-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (Stream.__init__): Changes to try to make
-	ipython robust against stdin/out/err being closed by the user.
-	This is 'user error' (and blocks a normal python session, at least
-	the stdout case).  However, Ipython should be able to survive such
-	instances of abuse as gracefully as possible.  To simplify the
-	coding and maintain compatibility with Gary Bishop's Term
-	contributions, I've made use of classmethods for this.  I think
-	this introduces a dependency on python 2.2.
-
-2004-01-13  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py (exp_safe): simplified the code a bit and
-	removed the need for importing the kinds module altogether.
-
-2004-01-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_sc): Made the shell capture system
-	a magic function instead, after some community feedback.  No
-	special syntax will exist for it, but its name is deliberately
-	very short.
-
-2003-12-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.handle_shell_assign): Added
-	new functionality, to automagically assign the result of a shell
-	command to a variable.  I'll solicit some community feedback on
-	this before making it permanent.
-
-	* IPython/OInspect.py (Inspector.pinfo): Fix crash when info was
-	requested about callables for which inspect couldn't obtain a
-	proper argspec.  Thanks to a crash report sent by Etienne
-	Posthumus <etienne-AT-apple01.cs.vu.nl>.
-
-2003-12-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (page): patch for the pager to work across
-	various versions of Windows.  By Gary Bishop.
-
-2003-12-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Gnuplot2.py (PlotItems): Fixes for working with
-	Gnuplot.py version 1.7, whose internal names changed quite a bit.
-	While I tested this and it looks ok, there may still be corner
-	cases I've missed.
-
-2003-12-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell._prefilter): Fixed a bug
-	where a line like 'p,q=1,2' would fail because the automagic
-	system would be triggered for @p.
-
-	* IPython/DPyGetOpt.py (DPyGetOpt.processArguments): Tab-related
-	cleanups, code unmodified.
-
-	* IPython/genutils.py (Term): added a class for IPython to handle
-	output.  In most cases it will just be a proxy for stdout/err, but
-	having this allows modifications to be made for some platforms,
-	such as handling color escapes under Windows.  All of this code
-	was contributed by Gary Bishop, with minor modifications by me.
-	The actual changes affect many files.
-
-2003-11-30  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (file_matches): new completion code, courtesy
-	of Jeff Collins.  This enables filename completion again under
-	python 2.3, which disabled it at the C level.
-
-2003-11-11  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py (amap): Added amap() fn.  Simple shorthand
-	for Numeric.array(map(...)), but often convenient.
-
-2003-11-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py (frange): Changed a call from int() to
-	int(round()) to prevent a problem reported with arange() in the
-	numpy list.
-
-2003-10-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/DPyGetOpt.py (DPyGetOpt.processArguments): changed to
-	prevent crashes if sys lacks an argv attribute (it happens with
-	embedded interpreters which build a bare-bones sys module).
-	Thanks to a report/bugfix by Adam Hupp <hupp-AT-cs.wisc.edu>.
-
-2003-09-24  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic._ofind): blanket except around getattr()
-	to protect against poorly written user objects where __getattr__
-	raises exceptions other than AttributeError.  Thanks to a bug
-	report by Oliver Sander <osander-AT-gmx.de>.
-
-	* IPython/FakeModule.py (FakeModule.__repr__): this method was
-	missing.  Thanks to bug report by Ralf Schmitt <ralf-AT-brainbot.com>.
-
-2003-09-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell._prefilter): fix bug where
-	unpacking a list whith a callable as first element would
-	mistakenly trigger autocalling.  Thanks to a bug report by Jeffery
-	Collins.
-
-2003-08-25  *** Released version 0.5.0
-
-2003-08-22  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.linereader): Improved handling of
-	improperly defined user exceptions.  Thanks to feedback from Mark
-	Russell <mrussell-AT-verio.net>.
-	
-2003-08-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/OInspect.py (Inspector.pinfo): changed String Form
-	printing so that it would print multi-line string forms starting
-	with a new line.  This way the formatting is better respected for
-	objects which work hard to make nice string forms.
-
-	* IPython/iplib.py (InteractiveShell.handle_auto): Fix bug where
-	autocall would overtake data access for objects with both
-	__getitem__ and __call__.
-
-2003-08-19  *** Released version 0.5.0-rc1
-
-2003-08-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/deep_reload.py (load_tail): single tiny change here
-	seems to fix the long-standing bug of dreload() failing to work
-	for dotted names.  But this module is pretty tricky, so I may have
-	missed some subtlety.  Needs more testing!.
-
-	* IPython/ultraTB.py (VerboseTB.linereader): harden against user
-	exceptions which have badly implemented __str__ methods.
-	(VerboseTB.text): harden against inspect.getinnerframes crashing,
-	which I've been getting reports about from Python 2.3 users.  I
-	wish I had a simple test case to reproduce the problem, so I could
-	either write a cleaner workaround or file a bug report if
-	necessary.
-
-	* IPython/Magic.py (Magic.magic_edit): fixed bug where after
-	making a class 'foo', file 'foo.py' couldn't be edited.  Thanks to
-	a bug report by Tjabo Kloppenburg.
-
-	* IPython/ultraTB.py (VerboseTB.debugger): hardened against pdb
-	crashes.  Wrapped the pdb call in a blanket try/except, since pdb
-	seems rather unstable.  Thanks to a bug report by Tjabo
-	Kloppenburg <tjabo.kloppenburg-AT-unix-ag.uni-siegen.de>.
-
-	* IPython/Release.py (version): release 0.5.0-rc1.  I want to put
-	this out soon because of the critical fixes in the inner loop for
-	generators.
-
-	* IPython/Magic.py (Magic.getargspec): removed.  This (and
-	_get_def) have been obsoleted by OInspect for a long time, I
-	hadn't noticed that they were dead code.
-	(Magic._ofind): restored _ofind functionality for a few literals
-	(those in ["''",'""','[]','{}','()']).  But it won't work anymore
-	for things like "hello".capitalize?, since that would require a
-	potentially dangerous eval() again.
-
-	* IPython/iplib.py (InteractiveShell._prefilter): reorganized the
-	logic a bit more to clean up the escapes handling and minimize the
-	use of _ofind to only necessary cases.  The interactive 'feel' of
-	IPython should have improved quite a bit with the changes in
-	_prefilter and _ofind (besides being far safer than before).
-
-	* IPython/Magic.py (Magic.magic_edit): Fixed old bug (but rather
-	obscure, never reported).  Edit would fail to find the object to
-	edit under some circumstances.
-	(Magic._ofind): CRITICAL FIX.  Finally removed the eval() calls
-	which were causing double-calling of generators.  Those eval calls
-	were _very_ dangerous, since code with side effects could be
-	triggered.  As they say, 'eval is evil'...  These were the
-	nastiest evals in IPython.  Besides, _ofind is now far simpler,
-	and it should also be quite a bit faster.  Its use of inspect is
-	also safer, so perhaps some of the inspect-related crashes I've
-	seen lately with Python 2.3 might be taken care of.  That will
-	need more testing.
-
-2003-08-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell._prefilter): significant
-	simplifications to the logic for handling user escapes.  Faster
-	and simpler code.
-
-2003-08-14  Fernando Perez  <fperez@colorado.edu>
-
-        * IPython/numutils.py (sum_flat): rewrote to be non-recursive.
-        Now it requires O(N) storage (N=size(a)) for non-contiguous input,
-        but it should be quite a bit faster.  And the recursive version
-        generated O(log N) intermediate storage for all rank>1 arrays,
-        even if they were contiguous.
-        (l1norm): Added this function.
-        (norm):  Added this function for arbitrary norms (including
-        l-infinity).  l1 and l2 are still special cases for convenience
-        and speed.
-	
-2003-08-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_edit): Removed all remaining string
-	exceptions, which now raise PendingDeprecationWarnings in Python
-	2.3.  There were some in Magic and some in Gnuplot2.
-
-2003-06-30  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (page): modified to call curses only for
-	terminals where TERM=='xterm'.  After problems under many other
-	terminals were reported by Keith Beattie <KSBeattie-AT-lbl.gov>.
-
-	* IPython/iplib.py (complete): removed spurious 'print "IE"' which
-	would be triggered when readline was absent.  This was just an old
-	debugging statement I'd forgotten to take out.
-
-2003-06-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (clock): modified to return only user time
-	(not counting system time), after a discussion on scipy.  While
-	system time may be a useful quantity occasionally, it may much
-	more easily be skewed by occasional swapping or other similar
-	activity.
-
-2003-06-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py (identity): new function, for building
-	arbitrary rank Kronecker deltas (mostly backwards compatible with
-	Numeric.identity)
-
-2003-06-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.handle_magic): protect
-	arguments passed to magics with spaces, to allow trailing '\' to
-	work normally (mainly for Windows users).
-
-2003-05-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): Load site._Helper() as help
-	instead of pydoc.help.  This fixes a bizarre behavior where
-	printing '%s' % locals() would trigger the help system.  Now
-	ipython behaves like normal python does.  
-
-	Note that if one does 'from pydoc import help', the bizarre
-	behavior returns, but this will also happen in normal python, so
-	it's not an ipython bug anymore (it has to do with how pydoc.help
-	is implemented).
-
-2003-05-22  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/FlexCompleter.py (Completer.attr_matches): fixed to
-	return [] instead of None when nothing matches, also match to end
-	of line.  Patch by Gary Bishop.
-
-	* IPython/ipmaker.py (make_IPython): Added same sys.excepthook
-	protection as before, for files passed on the command line.  This
-	prevents the CrashHandler from kicking in if user files call into
-	sys.excepthook (such as PyQt and WxWindows have a nasty habit of
-	doing).  After a report by Kasper Souren <Kasper.Souren-AT-ircam.fr>
-
-2003-05-20  *** Released version 0.4.0
-
-2003-05-20  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py: added support for manpages.  It's a bit hackish b/c of
-	a bug in the way the bdist_rpm distutils target handles gzipped
-	manpages, but it works.  After a patch by Jack.
-
-2003-05-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py: added a mockup of the kinds module, since
-	it was recently removed from Numeric.  This way, numutils will
-	work for all users even if they are missing kinds.
-
-	* IPython/Magic.py (Magic._ofind): Harden against an inspect
-	failure, which can occur with SWIG-wrapped extensions.  After a
-	crash report from Prabhu.
-
-2003-05-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.excepthook): New method to
-	protect ipython from user code which may call directly
-	sys.excepthook (this looks like an ipython crash to the user, even
-	when it isn't).  After a patch by Gary Bishop <gb-AT-cs.unc.edu>.
-	This is especially important to help users of WxWindows, but may
-	also be useful in other cases.
-
-	* IPython/ultraTB.py (AutoFormattedTB.__call__): Changed to allow
-	an optional tb_offset to be specified, and to preserve exception
-	info if given.  After a patch by Gary Bishop <gb-AT-cs.unc.edu>.
-
-	* ipython.1 (Default): Thanks to Jack's work, we now have manpages!
-
-2003-05-15  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.user_setup): Fix crash when
-	installing for a new user under Windows.
-
-2003-05-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.handle_emacs): New line
-	handler for Emacs comint-based lines.  Currently it doesn't do
-	much (but importantly, it doesn't update the history cache).  In
-	the future it may be expanded if Alex needs more functionality
-	there.
-
-	* IPython/CrashHandler.py (CrashHandler.__call__): Added platform
-	info to crash reports.
-
-	* IPython/iplib.py (InteractiveShell.mainloop): Added -c option,
-	just like Python's -c.  Also fixed crash with invalid -color
-	option value at startup. Thanks to Will French
-	<wfrench-AT-bestweb.net> for the bug report.
-
-2003-05-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (EvalDict.__getitem__): Renamed EvalString
-	to EvalDict (it's a mapping, after all) and simplified its code
-	quite a bit, after a nice discussion on c.l.py where Gustavo
-	Córdova <gcordova-AT-sismex.com> suggested the new version.
-
-2003-04-30  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (timings_out): modified it to reduce its
-	overhead in the common reps==1 case.
-
-2003-04-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (timings_out): Modified to use the resource
-	module, which avoids the wraparound problems of time.clock().
-
-2003-04-17  *** Released version 0.2.15pre4
-
-2003-04-17  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (scriptfiles): Split windows-specific stuff over to a
-	separate file, in an attempt to have a Windows GUI installer.
-	That didn't work, but part of the groundwork is done.
-
-	* IPython/UserConfig/ipythonrc: Added M-i, M-o and M-I for
-	indent/unindent with 4 spaces.  Particularly useful in combination
-	with the new auto-indent option.
-
-2003-04-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py: various replacements of self.rc for
-	self.shell.rc.  A lot more remains to be done to fully disentangle
-	this class from the main Shell class.
-
-	* IPython/GnuplotRuntime.py: added checks for mouse support so
-	that we don't try to enable it if the current gnuplot doesn't
-	really support it.  Also added checks so that we don't try to
-	enable persist under Windows (where Gnuplot doesn't recognize the
-	option).
-
-	* IPython/iplib.py (InteractiveShell.interact): Added optional
-	auto-indenting code, after a patch by King C. Shu
-	<kingshu-AT-myrealbox.com>. It's off by default because it doesn't
-	get along well with pasting indented code.  If I ever figure out
-	how to make that part go well, it will become on by default.
-
-	* IPython/Prompts.py (Prompt1.auto_rewrite): Fixed bug which would
-	crash ipython if there was an unmatched '%' in the user's prompt
-	string.  Reported by Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
-	
-	* IPython/iplib.py (InteractiveShell.interact): removed the
-	ability to ask the user whether he wants to crash or not at the
-	'last line' exception handler.  Calling functions at that point
-	changes the stack, and the error reports would have incorrect
-	tracebacks.
-
-	* IPython/Magic.py (Magic.magic_page): Added new @page magic, to
-	pass through a peger a pretty-printed form of any object.  After a
-	contribution by Olivier Aubert <oaubert-AT-bat710.univ-lyon1.fr>
-
-2003-04-14  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.user_setup): Fixed bug where
-	all files in ~ would be modified at first install (instead of
-	~/.ipython).  This could be potentially disastrous, as the
-	modification (make line-endings native) could damage binary files.
-	
-2003-04-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.handle_help): Modified to
-	handle only lines which are invalid python.  This now means that
-	lines like 'x=1 #?' execute properly.  Thanks to Jeffery Collins
-	for the bug report.
-
-2003-04-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.showtraceback): Fixed bug
-	where failing to set sys.last_traceback would crash pdb.pm().
-	Thanks to Jeffery D. Collins <Jeff.Collins-AT-vexcel.com> for the bug
-	report.
-
-2003-03-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_prun): rstrip() output of profiler
-	before printing it (it had a lot of spurious blank lines at the
-	end).
-
-	* IPython/Gnuplot2.py (Gnuplot.hardcopy): fixed bug where lpr
-	output would be sent 21 times!  Obviously people don't use this
-	too often, or I would have heard about it.
-
-2003-03-24  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (scriptfiles): renamed the data_files parameter from
-	'base' to 'data' to fix rpm build issues.  Thanks to Ralf Ahlbrink
-	for the patch.
-
-2003-03-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (error): added error() and fatal()
-	functions.
-
-2003-03-18  *** Released version 0.2.15pre3
-
-2003-03-18  Fernando Perez  <fperez@colorado.edu>
-
-	* setupext/install_data_ext.py
-	(install_data_ext.initialize_options): Class contributed by Jack
-	Moffit for fixing the old distutils hack.  He is sending this to
-	the distutils folks so in the future we may not need it as a
-	private fix.
-
-	* MANIFEST.in: Extensive reorganization, based on Jack Moffit's
-	changes for Debian packaging.  See his patch for full details.
-	The old distutils hack of making the ipythonrc* files carry a
-	bogus .py extension is gone, at last.  Examples were moved to a
-	separate subdir under doc/, and the separate executable scripts
-	now live in their own directory.  Overall a great cleanup.  The
-	manual was updated to use the new files, and setup.py has been
-	fixed for this setup.
-
-	* IPython/PyColorize.py (Parser.usage): made non-executable and
-	created a pycolor wrapper around it to be included as a script.
-
-2003-03-12  *** Released version 0.2.15pre2
-
-2003-03-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ColorANSI.py (make_color_table): Finally fixed the
-	long-standing problem with garbage characters in some terminals.
-	The issue was really that the \001 and \002 escapes must _only_ be
-	passed to input prompts (which call readline), but _never_ to
-	normal text to be printed on screen.  I changed ColorANSI to have
-	two classes: TermColors and InputTermColors, each with the
-	appropriate escapes for input prompts or normal text.  The code in
-	Prompts.py got slightly more complicated, but this very old and
-	annoying bug is finally fixed.  
-
-	All the credit for nailing down the real origin of this problem
-	and the correct solution goes to Jack Moffit <jack-AT-xiph.org>.
-	*Many* thanks to him for spending quite a bit of effort on this.
-
-2003-03-05  *** Released version 0.2.15pre1
-
-2003-03-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/FakeModule.py: Moved the former _FakeModule to a
-	separate file, because it's also needed by Magic (to fix a similar
-	pickle-related issue in @run).
-
-2003-03-02  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_autocall): new magic to control
-	the autocall option at runtime.
-	(Magic.magic_dhist): changed self.user_ns to self.shell.user_ns
-	across Magic.py to start separating Magic from InteractiveShell.
-	(Magic._ofind): Fixed to return proper namespace for dotted
-	names. Before, a dotted name would always return 'not currently
-	defined', because it would find the 'parent'. s.x would be found,
-	but since 'x' isn't defined by itself, it would get confused.
-	(Magic.magic_run): Fixed pickling problems reported by Ralf
-	Ahlbrink <RAhlbrink-AT-RosenInspection.net>.  The fix was similar to
-	that I'd used when Mike Heeter reported similar issues at the
-	top-level, but now for @run.  It boils down to injecting the
-	namespace where code is being executed with something that looks
-	enough like a module to fool pickle.dump().  Since a pickle stores
-	a named reference to the importing module, we need this for
-	pickles to save something sensible.
-
-	* IPython/ipmaker.py (make_IPython): added an autocall option.
-
-	* IPython/iplib.py (InteractiveShell._prefilter): reordered all of
-	the auto-eval code.  Now autocalling is an option, and the code is
-	also vastly safer.  There is no more eval() involved at all.
-
-2003-03-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic._ofind): Changed interface to return a
-	dict with named keys instead of a tuple.
-
-	* IPython: Started using CVS for IPython as of 0.2.15pre1.
-
-	* setup.py (make_shortcut): Fixed message about directories
-	created during Windows installation (the directories were ok, just
-	the printed message was misleading).  Thanks to Chris Liechti
-	<cliechti-AT-gmx.net> for the heads up.
-
-2003-02-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell._prefilter): Fixed catching
-	of ValueError exception when checking for auto-execution.  This
-	one is raised by things like Numeric arrays arr.flat when the
-	array is non-contiguous.
-
-2003-01-31  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (SystemExec.bq): Fixed bug where bq would
-	not return any value at all (even though the command would get
-	executed).
-	(xsys): Flush stdout right after printing the command to ensure
-	proper ordering of commands and command output in the total
-	output.
-	(SystemExec/xsys/bq): Switched the names of xsys/bq and
-	system/getoutput as defaults.  The old ones are kept for
-	compatibility reasons, so no code which uses this library needs
-	changing.
-
-2003-01-27  *** Released version 0.2.14
-
-2003-01-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_edit): Fixed problem where
-	functions defined in previous edit sessions could not be re-edited
-	(because the temp files were immediately removed).  Now temp files
-	are removed only at IPython's exit.
-	(Magic.magic_run): Improved @run to perform shell-like expansions
-	on its arguments (~users and $VARS).  With this, @run becomes more
-	like a normal command-line.
-
-	* IPython/Shell.py (IPShellEmbed.__call__): Fixed a bunch of small
-	bugs related to embedding and cleaned up that code.  A fairly
-	important one was the impossibility to access the global namespace
-	through the embedded IPython (only local variables were visible).
-
-2003-01-14  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell._prefilter): Fixed
-	auto-calling to be a bit more conservative.  Now it doesn't get
-	triggered if any of '!=()<>' are in the rest of the input line, to
-	allow comparing callables.  Thanks to Alex for the heads up.
-
-2003-01-07  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (page): fixed estimation of the number of
-	lines in a string to be paged to simply count newlines. This
-	prevents over-guessing due to embedded escape sequences. A better
-	long-term solution would involve stripping out the control chars
-	for the count, but it's potentially so expensive I just don't
-	think it's worth doing.
-
-2002-12-19  *** Released version 0.2.14pre50
-
-2002-12-19  Fernando Perez  <fperez@colorado.edu>
-
-	* tools/release (version): Changed release scripts to inform
-	Andrea and build a NEWS file with a list of recent changes.
-
-	* IPython/ColorANSI.py (__all__): changed terminal detection
-	code. Seems to work better for xterms without breaking
-	konsole. Will need more testing to determine if WinXP and Mac OSX
-	also work ok.
-
-2002-12-18  *** Released version 0.2.14pre49
-
-2002-12-18  Fernando Perez  <fperez@colorado.edu>
-
-	* Docs: added new info about Mac OSX, from Andrea.
-
-	* IPython/Gnuplot2.py (String): Added a String PlotItem class to
-	allow direct plotting of python strings whose format is the same
-	of gnuplot data files.
-
-2002-12-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.interact): fixed default (y)
-	value of exit question to be acknowledged.
-
-2002-12-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py: removed generators, which had been added
-	by mistake in an earlier debugging run. This was causing trouble
-	to users of python 2.1.x. Thanks to Abel Daniel <abli-AT-freemail.hu>
-	for pointing this out.
-
-2002-11-17  Fernando Perez  <fperez@colorado.edu>
-
-	* Manual: updated the Gnuplot section.
-
-	* IPython/GnuplotRuntime.py: refactored a lot all this code, with
-	a much better split of what goes in Runtime and what goes in
-	Interactive.
-
-	* IPython/ipmaker.py: fixed bug where import_fail_info wasn't
-	being imported from iplib.
-
-	* IPython/GnuplotInteractive.py (magic_gpc): renamed @gp to @gpc
-	for command-passing. Now the global Gnuplot instance is called
-	'gp' instead of 'g', which was really a far too fragile and
-	common name.
-
-	* IPython/Gnuplot2.py (eps_fix_bbox): added this to fix broken
-	bounding boxes generated by Gnuplot for square plots.
-
-	* IPython/genutils.py (popkey): new function added. I should
-	suggest this on c.l.py as a dict method, it seems useful.
-
-	* IPython/Gnuplot2.py (Gnuplot.plot): Overhauled plot and replot
-	to transparently handle PostScript generation. MUCH better than
-	the previous plot_eps/replot_eps (which I removed now). The code
-	is also fairly clean and well documented now (including
-	docstrings).
-
-2002-11-13  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_edit): fixed docstring
-	(inconsistent with options).
-
-	* IPython/Gnuplot2.py (Gnuplot.hardcopy): hardcopy had been
-	manually disabled, I don't know why. Fixed it.
-	(Gnuplot._plot_eps): added new plot_eps/replot_eps to get directly
-	eps output.
-
-2002-11-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (ask_yes_no): trap EOF and ^C so that they
-	don't propagate up to caller. Fixes crash reported by François
-	Pinard.
-
-2002-11-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): fixed problem with writing
-	history file for new users.
-	(make_IPython): fixed bug where initial install would leave the
-	user running in the .ipython dir.
-	(make_IPython): fixed bug where config dir .ipython would be
-	created regardless of the given -ipythondir option. Thanks to Cory
-	Dodt <cdodt-AT-fcoe.k12.ca.us> for the bug report.
-
-	* IPython/genutils.py (ask_yes_no): new function for asking yes/no
-	type confirmations. Will need to use it in all of IPython's code
-	consistently.
-	
-	* IPython/CrashHandler.py (CrashHandler.__call__): changed the
-	context to print 31 lines instead of the default 5. This will make
-	the crash reports extremely detailed in case the problem is in
-	libraries I don't have access to.
-
-	* IPython/iplib.py (InteractiveShell.interact): changed the 'last
-	line of defense' code to still crash, but giving users fair
-	warning. I don't want internal errors to go unreported: if there's
-	an internal problem, IPython should crash and generate a full
-	report.
-
-2002-11-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.interact): added code to trap
-	otherwise uncaught exceptions which can appear if people set
-	sys.stdout to something badly broken. Thanks to a crash report
-	from henni-AT-mail.brainbot.com.
-
-2002-11-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.interact): added
-	__IPYTHON__active to the builtins. It's a flag which goes on when
-	the interaction starts and goes off again when it stops. This
-	allows embedding code to detect being inside IPython. Before this
-	was done via __IPYTHON__, but that only shows that an IPython
-	instance has been created.
-
-	* IPython/Magic.py (Magic.magic_env): I realized that in a
-	UserDict, instance.data holds the data as a normal dict. So I
-	modified @env to return os.environ.data instead of rebuilding a
-	dict by hand.
-
-2002-11-02  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (warn): changed so that level 1 prints no
-	header. Level 2 is now the default (with 'WARNING' header, as
-	before). I think I tracked all places where changes were needed in
-	IPython, but outside code using the old level numbering may have
-	broken.
-
-	* IPython/iplib.py (InteractiveShell.runcode): added this to
-	handle the tracebacks in SystemExit traps correctly. The previous
-	code (through interact) was printing more of the stack than
-	necessary, showing IPython internal code to the user.
-
-	* IPython/UserConfig/ipythonrc.py: Made confirm_exit 1 by
-	default. Now that the default at the confirmation prompt is yes,
-	it's not so intrusive. François' argument that ipython sessions
-	tend to be complex enough not to lose them from an accidental C-d,
-	is a valid one.
-
-	* IPython/iplib.py (InteractiveShell.interact): added a
-	showtraceback() call to the SystemExit trap, and modified the exit
-	confirmation to have yes as the default.
-
-	* IPython/UserConfig/ipythonrc.py: removed 'session' option from
-	this file. It's been gone from the code for a long time, this was
-	simply leftover junk.
-
-2002-11-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/UserConfig/ipythonrc.py: new confirm_exit option
-	added. If set, IPython now traps EOF and asks for
-	confirmation. After a request by François Pinard.
-
-	* IPython/Magic.py (Magic.magic_Exit): New @Exit and @Quit instead
-	of @abort, and with a new (better) mechanism for handling the
-	exceptions.
-
-2002-10-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/usage.py (__doc__): updated the --help information and
-	the ipythonrc file to indicate that -log generates
-	./ipython.log. Also fixed the corresponding info in @logstart.
-	This and several other fixes in the manuals thanks to reports by
-	François Pinard <pinard-AT-iro.umontreal.ca>.
-	
-	* IPython/Logger.py (Logger.switch_log): Fixed error message to
-	refer to @logstart (instead of @log, which doesn't exist).
-
-	* IPython/iplib.py (InteractiveShell._prefilter): fixed
-	AttributeError crash. Thanks to Christopher Armstrong
-	<radix-AT-twistedmatrix.com> for the report/fix. This bug had been
-	introduced recently (in 0.2.14pre37) with the fix to the eval
-	problem mentioned below.
-	
-2002-10-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ConfigLoader.py (ConfigLoader.load): Fixes for Windows
-	installation. Thanks to Leonardo Santagada <retype-AT-terra.com.br>.
-
-	* IPython/iplib.py (InteractiveShell._prefilter): Many changes to
-	this function to fix a problem reported by Alex Schmolck. He saw
-	it with list comprehensions and generators, which were getting
-	called twice. The real problem was an 'eval' call in testing for
-	automagic which was evaluating the input line silently. 
-
-	This is a potentially very nasty bug, if the input has side
-	effects which must not be repeated. The code is much cleaner now,
-	without any blanket 'except' left and with a regexp test for
-	actual function names. 
-
-	But an eval remains, which I'm not fully comfortable with. I just
-	don't know how to find out if an expression could be a callable in
-	the user's namespace without doing an eval on the string. However
-	that string is now much more strictly checked so that no code
-	slips by, so the eval should only happen for things that can
-	really be only function/method names.
-
-2002-10-15  Fernando Perez  <fperez@colorado.edu>
-
-	* Updated LyX to 1.2.1 so I can work on the docs again. Added Mac
-	OSX information to main manual, removed README_Mac_OSX file from
-	distribution. Also updated credits for recent additions.
-
-2002-10-10  Fernando Perez  <fperez@colorado.edu>
-
-	* README_Mac_OSX: Added a README for Mac OSX users for fixing
-	terminal-related issues. Many thanks to Andrea Riciputi
-	<andrea.riciputi-AT-libero.it> for writing it.
-
-	* IPython/UserConfig/ipythonrc.py: Fixes to various small issues,
-	thanks to Thorsten Kampe <thorsten-AT-thorstenkampe.de>.
-
-	* setup.py (make_shortcut): Fixes for Windows installation. Thanks
-	to Fredrik Kant <fredrik.kant-AT-front.com> and Syver Enstad
-	<syver-en-AT-online.no> who both submitted patches for this problem.
-
-	* IPython/iplib.py (InteractiveShell.embed_mainloop): Patch for
-	global embedding to make sure that things don't overwrite user
-	globals accidentally. Thanks to Richard <rxe-AT-renre-europe.com>
-
-	* IPython/Gnuplot2.py (gp): Patch for Gnuplot.py 1.6
-	compatibility. Thanks to Hayden Callow
-	<h.callow-AT-elec.canterbury.ac.nz>
-
-2002-10-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Gnuplot2.py (PlotItem): Added 'index' option for
-	Gnuplot.File objects.
-	      
-2002-07-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (timing): Added timings() and timing() for
-	quick access to the most commonly needed data, the execution
-	times. Old timing() renamed to timings_out().
-
-2002-07-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShellEmbed.restore_system_completer): fixed
-	bug with nested instances disrupting the parent's tab completion.
-
-	* IPython/iplib.py (all_completions): Added Alex Schmolck's
-	all_completions code to begin the emacs integration.
-
-	* IPython/Gnuplot2.py (zip_items): Added optional 'titles'
-	argument to allow titling individual arrays when plotting.
-
-2002-07-15  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (make_shortcut): changed to retrieve the value of
-	'Program Files' directory from the registry (this value changes in
-	non-english versions of Windows). Thanks to Thomas Fanslau
-	<tfanslau-AT-gmx.de> for the report.
-
-2002-07-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.debugger): enabled workaround for
-	a bug in pdb, which crashes if a line with only whitespace is
-	entered. Bug report submitted to sourceforge.
-
-2002-07-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.nullrepr): fixed rare crash when
-	reporting exceptions (it's a bug in inspect.py, I just set a
-	workaround).
-
-2002-07-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): fixed reference to
-	__IPYTHON__ in __builtins__ to show up in user_ns.
-
-2002-07-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/GnuplotInteractive.py (magic_gp_set_default): changed
-	name from @gp_set_instance to @gp_set_default.
-
-	* IPython/ipmaker.py (make_IPython): default editor value set to
-	'0' (a string), to match the rc file. Otherwise will crash when
-	.strip() is called on it.
-	
-
-2002-06-28  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.safe_execfile): fix importing
-	of files in current directory when a file is executed via
-	@run. Patch also by RA <ralf_ahlbrink-AT-web.de>.
-
-	* setup.py (manfiles): fix for rpm builds, submitted by RA
-	<ralf_ahlbrink-AT-web.de>. Now we have RPMs!
-
-	* IPython/ipmaker.py (make_IPython): fixed lookup of default
-	editor when set to '0'. Problem was, '0' evaluates to True (it's a
-	string!). A. Schmolck caught this one.
-
-2002-06-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): fixed bug when running user
-	defined files at the cmd line. __name__ wasn't being set to
-	__main__.
-
-	* IPython/Gnuplot2.py (zip_items): improved it so it can plot also
-	regular lists and tuples besides Numeric arrays.
-
-	* IPython/Prompts.py (CachedOutput.__call__): Added output
-	supression for input ending with ';'. Similar to Mathematica and
-	Matlab. The _* vars and Out[] list are still updated, just like
-	Mathematica behaves.
-
-2002-06-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ConfigLoader.py (ConfigLoader.load): fixed checking of
-	.ini extensions for profiels under Windows.
-
-	* IPython/OInspect.py (Inspector.pinfo): improved alignment of
-	string form. Fix contributed by Alexander Schmolck
-	<a.schmolck-AT-gmx.net>
-
-	* IPython/GnuplotRuntime.py (gp_new): new function. Returns a
-	pre-configured Gnuplot instance.
-
-2002-06-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py (exp_safe): new function, works around the
-	underflow problems in Numeric.
-	(log2): New fn. Safe log in base 2: returns exact integer answer
-	for exact integer powers of 2.
-
-	* IPython/Magic.py (get_py_filename): fixed it not expanding '~'
-	properly.
-
-2002-06-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (timing): new function like
-	Mathematica's. Similar to time_test, but returns more info.
-
-2002-06-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_save): modified @save and @r
-	according to Mike Heeter's suggestions.
-
-2002-06-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/GnuplotRuntime.py: Massive overhaul to the Gnuplot
-	system. GnuplotMagic is gone as a user-directory option. New files
-	make it easier to use all the gnuplot stuff both from external
-	programs as well as from IPython. Had to rewrite part of
-	hardcopy() b/c of a strange bug: often the ps files simply don't
-	get created, and require a repeat of the command (often several
-	times).
-
-	* IPython/ultraTB.py (AutoFormattedTB.__call__): changed to
-	resolve output channel at call time, so that if sys.stderr has
-	been redirected by user this gets honored.
-
-2002-06-13  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPShell.__init__): Changed IPythonShell to
-	IPShell. Kept a copy with the old names to avoid breaking people's
-	embedded code.
-
-	* IPython/ipython: simplified it to the bare minimum after
-	Holger's suggestions. Added info about how to use it in
-	PYTHONSTARTUP.
-
-	* IPython/Shell.py (IPythonShell): changed the options passing
-	from a string with funky %s replacements to a straight list. Maybe
-	a bit more typing, but it follows sys.argv conventions, so there's
-	less special-casing to remember.
-
-2002-06-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_r): new magic auto-repeat
-	command. Thanks to a suggestion by Mike Heeter.
-	(Magic.magic_pfile): added behavior to look at filenames if given
-	arg is not a defined object.
-	(Magic.magic_save): New @save function to save code snippets. Also
-	a Mike Heeter idea.
-
-	* IPython/UserConfig/GnuplotMagic.py (plot): Improvements to
-	plot() and replot(). Much more convenient now, especially for
-	interactive use.
-
-	* IPython/Magic.py (Magic.magic_run): Added .py automatically to
-	filenames.
-
-2002-06-02  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Struct.py (Struct.__init__): modified to admit
-	initialization via another struct.
-
-	* IPython/genutils.py (SystemExec.__init__): New stateful
-	interface to xsys and bq. Useful for writing system scripts.
-
-2002-05-30  Fernando Perez  <fperez@colorado.edu>
-
-	* MANIFEST.in: Changed docfile selection to exclude all the lyx
-	documents. This will make the user download smaller (it's getting
-	too big).
-
-2002-05-29  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (_FakeModule.__init__): New class introduced to
-	fix problems with shelve and pickle. Seems to work, but I don't
-	know if corner cases break it. Thanks to Mike Heeter
-	<korora-AT-SDF.LONESTAR.ORG> for the bug reports and test cases.
-
-2002-05-24  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Macro.__init__): fixed magics embedded in
-	macros having broken.
-
-2002-05-21  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_logstart): fixed recently
-	introduced logging bug: all history before logging started was
-	being written one character per line! This came from the redesign
-	of the input history as a special list which slices to strings,
-	not to lists.
-
-2002-05-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Prompts.py (CachedOutput.__init__): made the color table
-	be an attribute of all classes in this module. The design of these
-	classes needs some serious overhauling.
-
-	* IPython/DPyGetOpt.py (DPyGetOpt.setPosixCompliance): fixed bug
-	which was ignoring '_' in option names.
-
-	* IPython/ultraTB.py (FormattedTB.__init__): Changed
-	'Verbose_novars' to 'Context' and made it the new default. It's a
-	bit more readable and also safer than verbose.
-
-	* IPython/PyColorize.py (Parser.__call__): Fixed coloring of
-	triple-quoted strings.
-
-	* IPython/OInspect.py (__all__): new module exposing the object
-	introspection facilities. Now the corresponding magics are dummy
-	wrappers around this. Having this module will make it much easier
-	to put these functions into our modified pdb.
-	This new object inspector system uses the new colorizing module,
-	so source code and other things are nicely syntax highlighted.
-
-2002-05-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ColorANSI.py: Split the coloring tools into a separate
-	module so I can use them in other code easier (they were part of
-	ultraTB).
-
-2002-05-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/UserConfig/GnuplotMagic.py (magic_gp_set_instance):
-	fixed it to set the global 'g' also to the called instance, as
-	long as 'g' was still a gnuplot instance (so it doesn't overwrite
-	user's 'g' variables).
-
-	* IPython/iplib.py (InteractiveShell.__init__): Added In/Out
-	global variables (aliases to _ih,_oh) so that users which expect
-	In[5] or Out[7] to work aren't unpleasantly surprised.
-	(InputList.__getslice__): new class to allow executing slices of
-	input history directly. Very simple class, complements the use of
-	macros.
-
-2002-05-16  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py (docdirbase): make doc directory be just doc/IPython
-	without version numbers, it will reduce clutter for users.
-
-	* IPython/Magic.py (Magic.magic_run): Add explicit local dict to
-	execfile call to prevent possible memory leak. See for details:
-	http://mail.python.org/pipermail/python-list/2002-February/088476.html
-
-2002-05-15  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_psource): made the object
-	introspection names be more standard: pdoc, pdef, pfile and
-	psource. They all print/page their output, and it makes
-	remembering them easier. Kept old names for compatibility as
-	aliases.
-
-2002-05-14  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/UserConfig/GnuplotMagic.py: I think I finally understood
-	what the mouse problem was. The trick is to use gnuplot with temp
-	files and NOT with pipes (for data communication), because having
-	both pipes and the mouse on is bad news.
-
-2002-05-13  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic._ofind): fixed namespace order search
-	bug. Information would be reported about builtins even when
-	user-defined functions overrode them.
-
-2002-05-11  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/__init__.py (__all__): removed FlexCompleter from
-	__all__ so that things don't fail in platforms without readline.
-
-2002-05-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/__init__.py (__all__): removed numutils from __all__ b/c
-	it requires Numeric, effectively making Numeric a dependency for
-	IPython.
-
-	* Released 0.2.13
-
-	* IPython/Magic.py (Magic.magic_prun): big overhaul to the
-	profiler interface. Now all the major options from the profiler
-	module are directly supported in IPython, both for single
-	expressions (@prun) and for full programs (@run -p).
-
-2002-05-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_doc): fixed to show docstrings of
-	magic properly formatted for screen.
-
-	* setup.py (make_shortcut): Changed things to put pdf version in
-	doc/ instead of doc/manual (had to change lyxport a bit).
-
-	* IPython/Magic.py (Profile.string_stats): made profile runs go
-	through pager (they are long and a pager allows searching, saving,
-	etc.)
-
-2002-05-08  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.12
-
-2002-05-06  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_hist): small bug fixed (recently
-	introduced); 'hist n1 n2' was broken.
-	(Magic.magic_pdb): added optional on/off arguments to @pdb
-	(Magic.magic_run): added option -i to @run, which executes code in
-	the IPython namespace instead of a clean one. Also added @irun as
-	an alias to @run -i.
-
-	* IPython/UserConfig/GnuplotMagic.py (magic_gp_set_instance):
-	fixed (it didn't really do anything, the namespaces were wrong).
-
-	* IPython/Debugger.py (__init__): Added workaround for python 2.1
-
-	* IPython/__init__.py (__all__): Fixed package namespace, now
-	'import IPython' does give access to IPython.<all> as
-	expected. Also renamed __release__ to Release.
-
-	* IPython/Debugger.py (__license__): created new Pdb class which
-	functions like a drop-in for the normal pdb.Pdb but does NOT
-	import readline by default. This way it doesn't muck up IPython's
-	readline handling, and now tab-completion finally works in the
-	debugger -- sort of. It completes things globally visible, but the
-	completer doesn't track the stack as pdb walks it. That's a bit
-	tricky, and I'll have to implement it later.
-
-2002-05-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_oinfo): fixed formatting bug for
-	magic docstrings when printed via ? (explicit \'s were being
-	printed).
-
-	* IPython/ipmaker.py (make_IPython): fixed namespace
-	identification bug. Now variables loaded via logs or command-line
-	files are recognized in the interactive namespace by @who.
-
-	* IPython/iplib.py (InteractiveShell.safe_execfile): Fixed bug in
-	log replay system stemming from the string form of Structs.
-
-	* IPython/Magic.py (Macro.__init__): improved macros to properly
-	handle magic commands in them.
-	(Magic.magic_logstart): usernames are now expanded so 'logstart
-	~/mylog' now works.
-
-	* IPython/iplib.py (complete): fixed bug where paths starting with
-	'/' would be completed as magic names.
-
-2002-05-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_run): added options -p and -f to
-	allow running full programs under the profiler's control.
-
-	* IPython/ultraTB.py (FormattedTB.__init__): Added Verbose_novars
-	mode to report exceptions verbosely but without formatting
-	variables. This addresses the issue of ipython 'freezing' (it's
-	not frozen, but caught in an expensive formatting loop) when huge
-	variables are in the context of an exception.
-	(VerboseTB.text): Added '--->' markers at line where exception was
-	triggered. Much clearer to read, especially in NoColor modes.
-
-	* IPython/Magic.py (Magic.magic_run): bugfix: -n option had been
-	implemented in reverse when changing to the new parse_options().
-
-2002-05-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.parse_options): new function so that
-	magics can parse options easier.
-	(Magic.magic_prun): new function similar to profile.run(),
-	suggested by Chris Hart.
-	(Magic.magic_cd): fixed behavior so that it only changes if
-	directory actually is in history.
-
-	* IPython/usage.py (__doc__): added information about potential
-	slowness of Verbose exception mode when there are huge data
-	structures to be formatted (thanks to Archie Paulson).
-
-	* IPython/ipmaker.py (make_IPython): Changed default logging
-	(when simply called with -log) to use curr_dir/ipython.log in
-	rotate mode. Fixed crash which was occuring with -log before
-	(thanks to Jim Boyle).
-
-2002-05-01  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.11 for these fixes (mainly the ultraTB one which
-	was nasty -- though somewhat of a corner case).
-
-	* IPython/ultraTB.py (AutoFormattedTB.text): renamed __text to
-	text (was a bug).
-
-2002-04-30  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/UserConfig/GnuplotMagic.py (magic_gp): Minor fix to add
-	a print after ^D or ^C from the user so that the In[] prompt
-	doesn't over-run the gnuplot one.
-
-2002-04-29  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.10
-
-	* IPython/__release__.py (version): get date dynamically.
-
-	* Misc. documentation updates thanks to Arnd's comments. Also ran
-	a full spellcheck on the manual (hadn't been done in a while).
-
-2002-04-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_logstart): Fixed bug where
-	starting a log in mid-session would reset the input history list.
-
-2002-04-26  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.wait): Fixed bug where not
-	all files were being included in an update. Now anything in
-	UserConfig that matches [A-Za-z]*.py will go (this excludes
-	__init__.py)
-
-2002-04-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.__init__): Added __IPYTHON__
-	to __builtins__ so that any form of embedded or imported code can
-	test for being inside IPython.
-
-	* IPython/UserConfig/GnuplotMagic.py: (magic_gp_set_instance):
-	changed to GnuplotMagic because it's now an importable module,
-	this makes the name follow that of the standard Gnuplot module.
-	GnuplotMagic can now be loaded at any time in mid-session.
-
-2002-04-24  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/numutils.py: removed SIUnits. It doesn't properly set
-	the globals (IPython has its own namespace) and the
-	PhysicalQuantity stuff is much better anyway.
-
-	* IPython/UserConfig/example-gnuplot.py (g2): Added gnuplot
-	embedding example to standard user directory for
-	distribution. Also put it in the manual.
-
-	* IPython/numutils.py (gnuplot_exec): Changed to take a gnuplot
-	instance as first argument (so it doesn't rely on some obscure
-	hidden global).
-
-	* IPython/UserConfig/ipythonrc.py: put () back in accepted
-	delimiters. While it prevents ().TAB from working, it allows
-	completions in open (... expressions. This is by far a more common
-	case.
-
-2002-04-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Extensions/InterpreterPasteInput.py: new
-	syntax-processing module for pasting lines with >>> or ... at the
-	start.
-
-	* IPython/Extensions/PhysicalQ_Interactive.py
-	(PhysicalQuantityInteractive.__int__): fixed to work with either
-	Numeric or math.
-
-	* IPython/UserConfig/ipythonrc-numeric.py: reorganized the
-	provided profiles. Now we have:
-	-math -> math module as * and cmath with its own namespace.
-	-numeric -> Numeric as *, plus gnuplot & grace
-	-physics -> same as before
-
-	* IPython/Magic.py (Magic.magic_magic): Fixed bug where
-	user-defined magics wouldn't be found by @magic if they were
-	defined as class methods. Also cleaned up the namespace search
-	logic and the string building (to use %s instead of many repeated
-	string adds).
-
-	* IPython/UserConfig/example-magic.py (magic_foo): updated example
-	of user-defined magics to operate with class methods (cleaner, in
-	line with the gnuplot code).
-
-2002-04-22  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py: updated dependency list so that manual is updated when
-	all included files change.
-
-	* IPython/ipmaker.py (make_IPython): Fixed bug which was ignoring
-	the delimiter removal option (the fix is ugly right now).
-
-	* IPython/UserConfig/ipythonrc-physics.py: simplified not to load
-	all of the math profile (quicker loading, no conflict between
-	g-9.8 and g-gnuplot).
-
-	* IPython/CrashHandler.py (CrashHandler.__call__): changed default
-	name of post-mortem files to IPython_crash_report.txt.
-
-	* Cleanup/update of the docs. Added all the new readline info and
-	formatted all lists as 'real lists'.
-
-	* IPython/ipmaker.py (make_IPython): removed now-obsolete
-	tab-completion options, since the full readline parse_and_bind is
-	now accessible.
-
-	* IPython/iplib.py (InteractiveShell.init_readline): Changed
-	handling of readline options. Now users can specify any string to
-	be passed to parse_and_bind(), as well as the delimiters to be
-	removed.
-	(InteractiveShell.__init__): Added __name__ to the global
-	namespace so that things like Itpl which rely on its existence
-	don't crash.
-	(InteractiveShell._prefilter): Defined the default with a _ so
-	that prefilter() is easier to override, while the default one
-	remains available.
-
-2002-04-18  Fernando Perez  <fperez@colorado.edu>
-
-	* Added information about pdb in the docs.
-
-2002-04-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): added rc_override option to
-	allow passing config options at creation time which may override
-	anything set in the config files or command line. This is
-	particularly useful for configuring embedded instances.
-
-2002-04-15  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Logger.py (Logger.log): Fixed a nasty bug which could
-	crash embedded instances because of the input cache falling out of
-	sync with the output counter.
-
-	* IPython/Shell.py (IPythonShellEmbed.__init__): added a debug
-	mode which calls pdb after an uncaught exception in IPython itself.
-
-2002-04-14  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.showtraceback): pdb mucks up
-	readline, fix it back after each call.
-
-	* IPython/ultraTB.py (AutoFormattedTB.__text): made text a private
-	method to force all access via __call__(), which guarantees that
-	traceback references are properly deleted.
-
-	* IPython/Prompts.py (CachedOutput._display): minor fixes to
-	improve printing when pprint is in use.
-
-2002-04-13  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPythonShellEmbed.__call__): SystemExit
-	exceptions aren't caught anymore. If the user triggers one, he
-	should know why he's doing it and it should go all the way up,
-	just like any other exception. So now @abort will fully kill the
-	embedded interpreter and the embedding code (unless that happens
-	to catch SystemExit).
-
-	* IPython/ultraTB.py (VerboseTB.__init__): added a call_pdb flag
-	and a debugger() method to invoke the interactive pdb debugger
-	after printing exception information. Also added the corresponding
-	-pdb option and @pdb magic to control this feature, and updated
-	the docs. After a suggestion from Christopher Hart
-	(hart-AT-caltech.edu).
-
-2002-04-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPythonShellEmbed.__init__): modified to use
-	the exception handlers defined by the user (not the CrashHandler)
-	so that user exceptions don't trigger an ipython bug report.
-
-	* IPython/ultraTB.py (ColorTB.__init__): made the color scheme
-	configurable (it should have always been so).
-
-2002-03-26  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPythonShellEmbed.__call__): many changes here
-	and there to fix embedding namespace issues. This should all be
-	done in a more elegant way.
-
-2002-03-25  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (get_home_dir): Try to make it work under
-	win9x also.
-
-2002-03-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Shell.py (IPythonShellEmbed.__init__): leave
-	sys.displayhook untouched upon __init__.
-
-2002-03-19  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.9 (for embedding bug, basically).
-
-	* IPython/Shell.py (IPythonShellEmbed.__call__): Trap SystemExit
-	exceptions so that enclosing shell's state can be restored.
-
-	* Changed magic_gnuplot.py to magic-gnuplot.py to standardize
-	naming conventions in the .ipython/ dir.
-
-	* IPython/iplib.py (InteractiveShell.init_readline): removed '-'
-	from delimiters list so filenames with - in them get expanded.
-
-	* IPython/Shell.py (IPythonShellEmbed.__call__): fixed bug with
-	sys.displayhook not being properly restored after an embedded call.
-
- 2002-03-18  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.8
-
-	* IPython/iplib.py (InteractiveShell.user_setup): fixed bug where
-	some files weren't being included in a -upgrade.
-	(InteractiveShell.init_readline): Added 'set show-all-if-ambiguous
-	on' so that the first tab completes.
-	(InteractiveShell.handle_magic): fixed bug with spaces around
-	quotes breaking many magic commands.
-
-	* setup.py: added note about ignoring the syntax error messages at
-	installation.
-
-	* IPython/UserConfig/magic_gnuplot.py (magic_gp): finished
-	streamlining the gnuplot interface, now there's only one magic @gp.
-
-2002-03-17  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/UserConfig/magic_gnuplot.py: new name for the
-	example-magic_pm.py file. Much enhanced system, now with a shell
-	for communicating directly with gnuplot, one command at a time.
-
-	* IPython/Magic.py (Magic.magic_run): added option -n to prevent
-	setting __name__=='__main__'.
-
-	* IPython/UserConfig/example-magic_pm.py (magic_pm): Added
-	mini-shell for accessing gnuplot from inside ipython. Should
-	extend it later for grace access too. Inspired by Arnd's
-	suggestion.
-
-	* IPython/iplib.py (InteractiveShell.handle_magic): fixed bug when
-	calling magic functions with () in their arguments. Thanks to Arnd
-	Baecker for pointing this to me.
-
-	* IPython/numutils.py (sum_flat): fixed bug. Would recurse
-	infinitely for integer or complex arrays (only worked with floats).
-
-2002-03-16  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py: Merged setup and setup_windows into a single script
-	which properly handles things for windows users.
-
-2002-03-15  Fernando Perez  <fperez@colorado.edu>
-
-	* Big change to the manual: now the magics are all automatically
-	documented. This information is generated from their docstrings
-	and put in a latex file included by the manual lyx file. This way
-	we get always up to date information for the magics. The manual
-	now also has proper version information, also auto-synced.
-
-	For this to work, an undocumented --magic_docstrings option was added.
-
-2002-03-13  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (TermColors): fixed problem with dark colors
-	under CDE terminals. An explicit ;2 color reset is needed in the escapes.
-
-2002-03-12  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (TermColors): changed color escapes again to
-	fix the (old, reintroduced) line-wrapping bug. Basically, if
-	\001..\002 aren't given in the color escapes, lines get wrapped
-	weirdly. But giving those screws up old xterms and emacs terms. So
-	I added some logic for emacs terms to be ok, but I can't identify old
-	xterms separately ($TERM=='xterm' for many terminals, like konsole).
-
-2002-03-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/usage.py (__doc__): Various documentation cleanups and
-	updates, both in usage docstrings and in the manual.
-
-	* IPython/Prompts.py (CachedOutput.set_colors): cleanups for
-	handling of caching. Set minimum acceptabe value for having a
-	cache at 20 values.
-
-	* IPython/iplib.py (InteractiveShell.user_setup): moved the
-	install_first_time function to a method, renamed it and added an
-	'upgrade' mode. Now people can update their config directory with
-	a simple command line switch (-upgrade, also new).
-
-	* IPython/Magic.py (Magic.magic_pfile): Made @pfile an alias to
-	@file (convenient for automagic users under Python >= 2.2). 
-	Removed @files (it seemed more like a plural than an abbrev. of
-	'file show').
-
-	* IPython/iplib.py (install_first_time): Fixed crash if there were
-	backup files ('~') in .ipython/ install directory.
-
-	* IPython/ipmaker.py (make_IPython): fixes for new prompt
-	system. Things look fine, but these changes are fairly
-	intrusive. Test them for a few days.
-
-	* IPython/Prompts.py (CachedOutput.__init__): Massive rewrite of
-	the prompts system. Now all in/out prompt strings are user
-	controllable. This is particularly useful for embedding, as one
-	can tag embedded instances with particular prompts. 
-
-	Also removed global use of sys.ps1/2, which now allows nested
-	embeddings without any problems. Added command-line options for
-	the prompt strings.
-
-2002-03-08  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/UserConfig/example-embed-short.py (ipshell): added
-	example file with the bare minimum code for embedding.
-
-	* IPython/Shell.py (IPythonShellEmbed.set_dummy_mode): added
-	functionality for the embeddable shell to be activated/deactivated
-	either globally or at each call.
-
-	* IPython/Prompts.py (Prompt1.auto_rewrite): Fixes the problem of
-	rewriting the prompt with '--->' for auto-inputs with proper
-	coloring. Now the previous UGLY hack in handle_auto() is gone, and
-	this is handled by the prompts class itself, as it should.
-
-2002-03-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/Magic.py (Magic.magic_logstart): Changed @log to
-	@logstart to avoid name clashes with the math log function.
-
-	* Big updates to X/Emacs section of the manual.
-
-	* Removed ipython_emacs. Milan explained to me how to pass
-	arguments to ipython through Emacs. Some day I'm going to end up
-	learning some lisp...
-
-2002-03-04  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipython_emacs: Created script to be used as the
-	py-python-command Emacs variable so we can pass IPython
-	parameters. I can't figure out how to tell Emacs directly to pass
-	parameters to IPython, so a dummy shell script will do it.
-
-	Other enhancements made for things to work better under Emacs'
-	various types of terminals. Many thanks to Milan Zamazal
-	<pdm-AT-zamazal.org> for all the suggestions and pointers.
-
-2002-03-01  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ipmaker.py (make_IPython): added a --readline! option so
-	that loading of readline is now optional. This gives better
-	control to emacs users.
-
-	* IPython/ultraTB.py (__date__): Modified color escape sequences
-	and now things work fine under xterm and in Emacs' term buffers
-	(though not shell ones). Well,  in emacs you get colors, but all
-	seem to be 'light' colors (no difference between dark and light
-	ones). But the garbage chars are gone, and also in xterms. It
-	seems that now I'm using 'cleaner' ansi sequences.
-
-2002-02-21  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.7 (mainly to publish the scoping fix).
-	
-	* IPython/Logger.py (Logger.logstate): added. A corresponding
-	@logstate magic was created.
-
-	* IPython/Magic.py: fixed nested scoping problem under Python
-	2.1.x (automagic wasn't working).
-
-2002-02-20  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.6.
-
-	* IPython/OutputTrap.py (OutputTrap.__init__): added a 'quiet'
-	option so that logs can come out without any headers at all.
-
-	* IPython/UserConfig/ipythonrc-scipy.py: created a profile for
-	SciPy.
-
-	* IPython/iplib.py (InteractiveShell.embed_mainloop): Changed so
-	that embedded IPython calls don't require vars() to be explicitly
-	passed. Now they are extracted from the caller's frame (code
-	snatched from Eric Jones' weave). Added better documentation to
-	the section on embedding and the example file.
-
-	* IPython/genutils.py (page): Changed so that under emacs, it just
-	prints the string. You can then page up and down in the emacs
-	buffer itself. This is how the builtin help() works.
-
-	* IPython/Prompts.py (CachedOutput.__call__): Fixed issue with
-	macro scoping: macros need to be executed in the user's namespace
-	to work as if they had been typed by the user.
-
-	* IPython/Magic.py (Magic.magic_macro): Changed macros so they
-	execute automatically (no need to type 'exec...'). They then
-	behave like 'true macros'. The printing system was also modified
-	for this to work.
-
-2002-02-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (page_file): new function for paging files
-	in an OS-independent way. Also necessary for file viewing to work
-	well inside Emacs buffers.
-	(page): Added checks for being in an emacs buffer.
-	(page): fixed bug for Windows ($TERM isn't set in Windows). Fixed
-	same bug in iplib.
-
-2002-02-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.init_readline): modified use
-	of readline so that IPython can work inside an Emacs buffer.
-
-	* IPython/ultraTB.py (AutoFormattedTB.__call__): some fixes to
-	method signatures (they weren't really bugs, but it looks cleaner
-	and keeps PyChecker happy).
-
-	* IPython/ipmaker.py (make_IPython): added hooks Struct to __IP
-	for implementing various user-defined hooks. Currently only
-	display is done.
-
-	* IPython/Prompts.py (CachedOutput._display): changed display
-	functions so that they can be dynamically changed by users easily.
-
-	* IPython/Extensions/numeric_formats.py (num_display): added an
-	extension for printing NumPy arrays in flexible manners. It
-	doesn't do anything yet, but all the structure is in
-	place. Ultimately the plan is to implement output format control
-	like in Octave.
-
-	* IPython/Magic.py (Magic.lsmagic): changed so that bound magic
-	methods are found at run-time by all the automatic machinery.
-
-2002-02-17  Fernando Perez  <fperez@colorado.edu>
-
-	* setup_Windows.py (make_shortcut): documented. Cleaned up the
-	whole file a little.
-
-	* ToDo: closed this document. Now there's a new_design.lyx
-	document for all new ideas. Added making a pdf of it for the
-	end-user distro.
-
-	* IPython/Logger.py (Logger.switch_log): Created this to replace
-	logon() and logoff(). It also fixes a nasty crash reported by 
-	Philip Hisley <compsys-AT-starpower.net>. Many thanks to him.
-
-	* IPython/iplib.py (complete): got auto-completion to work with
-	automagic (I had wanted this for a long time).
-
-	* IPython/Magic.py (Magic.magic_files): Added @files as an alias
-	to @file, since file() is now a builtin and clashes with automagic
-	for @file.
-
-	* Made some new files: Prompts, CrashHandler, Magic, Logger. All
-	of this was previously in iplib, which had grown to more than 2000
-	lines, way too long. No new functionality, but it makes managing
-	the code a bit easier.
-
-	* IPython/iplib.py (IPythonCrashHandler.__call__): Added version
-	information to crash reports.
-
-2002-02-12  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.5.
-
-2002-02-11  Fernando Perez  <fperez@colorado.edu>
-
-	* Wrote a relatively complete Windows installer. It puts
-	everything in place, creates Start Menu entries and fixes the
-	color issues. Nothing fancy, but it works.
-
-2002-02-10  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.safe_execfile): added an
-	os.path.expanduser() call so that we can type @run ~/myfile.py and
-	have thigs work as expected.
-
-	* IPython/genutils.py (page): fixed exception handling so things
-	work both in Unix and Windows correctly. Quitting a pager triggers
-	an IOError/broken pipe in Unix, and in windows not finding a pager
-	is also an IOError, so I had to actually look at the return value
-	of the exception, not just the exception itself. Should be ok now.
-
-	* IPython/ultraTB.py (ColorSchemeTable.set_active_scheme):
-	modified to allow case-insensitive color scheme changes.
-
-2002-02-09  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/genutils.py (native_line_ends): new function to leave
-	user config files with os-native line-endings.
-
-	* README and manual updates.
-
-	* IPython/genutils.py: fixed unicode bug: use types.StringTypes
-	instead of StringType to catch Unicode strings.
-
-	* IPython/genutils.py (filefind): fixed bug for paths with
-	embedded spaces (very common in Windows).
-
-	* IPython/ipmaker.py (make_IPython): added a '.ini' to the rc
-	files under Windows, so that they get automatically associated
-	with a text editor. Windows makes it a pain to handle
-	extension-less files.
-
-	* IPython/iplib.py (InteractiveShell.init_readline): Made the
-	warning about readline only occur for Posix. In Windows there's no
-	way to get readline, so why bother with the warning.
-
-	* IPython/Struct.py (Struct.__str__): fixed to use self.__dict__
-	for __str__ instead of dir(self), since dir() changed in 2.2.
-
-	* Ported to Windows! Tested on XP, I suspect it should work fine
-	on NT/2000, but I don't think it will work on 98 et al. That
-	series of Windows is such a piece of junk anyway that I won't try
-	porting it there. The XP port was straightforward, showed a few
-	bugs here and there (fixed all), in particular some string
-	handling stuff which required considering Unicode strings (which
-	Windows uses). This is good, but hasn't been too tested :) No
-	fancy installer yet, I'll put a note in the manual so people at
-	least make manually a shortcut.
-
-	* IPython/iplib.py (Magic.magic_colors): Unified the color options
-	into a single one, "colors". This now controls both prompt and
-	exception color schemes, and can be changed both at startup
-	(either via command-line switches or via ipythonrc files) and at
-	runtime, with @colors.
-	(Magic.magic_run): renamed @prun to @run and removed the old
-	@run. The two were too similar to warrant keeping both.
-
-2002-02-03  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (install_first_time): Added comment on how to
-	configure the color options for first-time users. Put a <return>
-	request at the end so that small-terminal users get a chance to
-	read the startup info.
-
-2002-01-23  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (CachedOutput.update): Changed output memory
-	variable names from _o,_oo,_ooo,_o<n> to simply _,__,___,_<n>. For
-	input history we still use _i. Did this b/c these variable are
-	very commonly used in interactive work, so the less we need to
-	type the better off we are.
-	(Magic.magic_prun): updated @prun to better handle the namespaces
-	the file will run in, including a fix for __name__ not being set
-	before.
-
-2002-01-20  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/ultraTB.py (VerboseTB.linereader): Fixed printing of
-	extra garbage for Python 2.2. Need to look more carefully into
-	this later.
-
-2002-01-19  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.showtraceback): fixed to
-	display SyntaxError exceptions properly formatted when they occur
-	(they can be triggered by imported code).
-
-2002-01-18  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.safe_execfile): now
-	SyntaxError exceptions are reported nicely formatted, instead of
-	spitting out only offset information as before.
-	(Magic.magic_prun): Added the @prun function for executing
-	programs with command line args inside IPython.
-
-2002-01-16  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (Magic.magic_hist): Changed @hist and @dhist
-	to *not* include the last item given in a range. This brings their
-	behavior in line with Python's slicing: 
-	  a[n1:n2] -> a[n1]...a[n2-1]
-	It may be a bit less convenient, but I prefer to stick to Python's
-	conventions *everywhere*, so users never have to wonder.
-	(Magic.magic_macro): Added @macro function to ease the creation of
-	macros.
-
-2002-01-05  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.4.
-
-	* IPython/iplib.py (Magic.magic_pdef): 
-	(InteractiveShell.safe_execfile): report magic lines and error
-	lines without line numbers so one can easily copy/paste them for
-	re-execution.
-
-	* Updated manual with recent changes.
-
-	* IPython/iplib.py (Magic.magic_oinfo): added constructor
-	docstring printing when class? is called. Very handy for knowing
-	how to create class instances (as long as __init__ is well
-	documented, of course :)
-	(Magic.magic_doc): print both class and constructor docstrings.
-	(Magic.magic_pdef): give constructor info if passed a class and
-	__call__ info for callable object instances.
-
-2002-01-04  Fernando Perez  <fperez@colorado.edu>
-
-	* Made deep_reload() off by default. It doesn't always work
-	exactly as intended, so it's probably safer to have it off. It's
-	still available as dreload() anyway, so nothing is lost.
-
-2002-01-02  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.3 (contacted R.Singh at CU about biopython course,
-	so I wanted an updated release).
-
-2001-12-27  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython/iplib.py (InteractiveShell.interact): Added the original
-	code from 'code.py' for this module in order to change the
-	handling of a KeyboardInterrupt. This was necessary b/c otherwise
-	the history cache would break when the user hit Ctrl-C, and
-	interact() offers no way to add any hooks to it.
-
-2001-12-23  Fernando Perez  <fperez@colorado.edu>
-
-	* setup.py: added check for 'MANIFEST' before trying to remove
-	it. Thanks to Sean Reifschneider.
-
-2001-12-22  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.2.
-
-	* Finished (reasonably) writing the manual. Later will add the
-	python-standard navigation stylesheets, but for the time being
-	it's fairly complete. Distribution will include html and pdf
-	versions.
-
-	* Bugfix: '.' wasn't being added to sys.path. Thanks to Prabhu
-	(MayaVi author).
-
-2001-12-21  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.1. Barring any nasty bugs, this is it as far as a
-	good public release, I think (with the manual and the distutils
-	installer). The manual can use some work, but that can go
-	slowly. Otherwise I think it's quite nice for end users. Next
-	summer, rewrite the guts of it...
-
-	* Changed format of ipythonrc files to use whitespace as the
-	separator instead of an explicit '='. Cleaner.
-
-2001-12-20  Fernando Perez  <fperez@colorado.edu>
-
-	* Started a manual in LyX. For now it's just a quick merge of the
-	various internal docstrings and READMEs. Later it may grow into a
-	nice, full-blown manual.
-
-	* Set up a distutils based installer. Installation should now be
-	trivially simple for end-users.
-
-2001-12-11  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.2.0. First public release, announced it at
-	comp.lang.python. From now on, just bugfixes...
-
-	* Went through all the files, set copyright/license notices and
-	cleaned up things. Ready for release.
-
-2001-12-10  Fernando Perez  <fperez@colorado.edu>
-
-	* Changed the first-time installer not to use tarfiles. It's more
-	robust now and less unix-dependent. Also makes it easier for
-	people to later upgrade versions.
-
-	* Changed @exit to @abort to reflect the fact that it's pretty
-	brutal (a sys.exit()). The difference between @abort and Ctrl-D
-	becomes significant only when IPyhton is embedded: in that case,
-	C-D closes IPython only, but @abort kills the enclosing program
-	too (unless it had called IPython inside a try catching
-	SystemExit).
-
-	* Created Shell module which exposes the actuall IPython Shell
-	classes, currently the normal and the embeddable one. This at
-	least offers a stable interface we won't need to change when
-	(later) the internals are rewritten. That rewrite will be confined
-	to iplib and ipmaker, but the Shell interface should remain as is.
-
-	* Added embed module which offers an embeddable IPShell object,
-	useful to fire up IPython *inside* a running program. Great for
-	debugging or dynamical data analysis.
-
-2001-12-08  Fernando Perez  <fperez@colorado.edu>
-
-	* Fixed small bug preventing seeing info from methods of defined
-	objects (incorrect namespace in _ofind()).
-
-	* Documentation cleanup. Moved the main usage docstrings to a
-	separate file, usage.py (cleaner to maintain, and hopefully in the
-	future some perlpod-like way of producing interactive, man and
-	html docs out of it will be found).
-
-	* Added @profile to see your profile at any time.
-
-	* Added @p as an alias for 'print'. It's especially convenient if
-	using automagic ('p x' prints x).
-
-	* Small cleanups and fixes after a pychecker run.
-
-	* Changed the @cd command to handle @cd - and @cd -<n> for
-	visiting any directory in _dh.
-
-	* Introduced _dh, a history of visited directories. @dhist prints
-	it out with numbers.
-
-2001-12-07  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.1.22
-
-	* Made initialization a bit more robust against invalid color
-	options in user input (exit, not traceback-crash).
-
-	* Changed the bug crash reporter to write the report only in the
-	user's .ipython directory. That way IPython won't litter people's
-	hard disks with crash files all over the place. Also print on
-	screen the necessary mail command.
-
-	* With the new ultraTB, implemented LightBG color scheme for light
-	background terminals. A lot of people like white backgrounds, so I
-	guess we should at least give them something readable.
-
-2001-12-06  Fernando Perez  <fperez@colorado.edu>
-
-	* Modified the structure of ultraTB. Now there's a proper class
-	for tables of color schemes which allow adding schemes easily and
-	switching the active scheme without creating a new instance every
-	time (which was ridiculous). The syntax for creating new schemes
-	is also cleaner. I think ultraTB is finally done, with a clean
-	class structure. Names are also much cleaner (now there's proper
-	color tables, no need for every variable to also have 'color' in
-	its name).
-
-	* Broke down genutils into separate files. Now genutils only
-	contains utility functions, and classes have been moved to their
-	own files (they had enough independent functionality to warrant
-	it): ConfigLoader, OutputTrap, Struct.
-
-2001-12-05  Fernando Perez  <fperez@colorado.edu>
-
-	* IPython turns 21! Released version 0.1.21, as a candidate for
-	public consumption. If all goes well, release in a few days.
-
-	* Fixed path bug (files in Extensions/ directory wouldn't be found
-	unless IPython/ was explicitly in sys.path).
-
-	* Extended the FlexCompleter class as MagicCompleter to allow
-	completion of @-starting lines.
-
-	* Created __release__.py file as a central repository for release
-	info that other files can read from.
-
-	* Fixed small bug in logging: when logging was turned on in
-	mid-session, old lines with special meanings (!@?) were being
-	logged without the prepended comment, which is necessary since
-	they are not truly valid python syntax. This should make session
-	restores produce less errors.
-
-	* The namespace cleanup forced me to make a FlexCompleter class
-	which is nothing but a ripoff of rlcompleter, but with selectable
-	namespace (rlcompleter only works in __main__.__dict__). I'll try
-	to submit a note to the authors to see if this change can be
-	incorporated in future rlcompleter releases (Dec.6: done)
-
-	* More fixes to namespace handling. It was a mess! Now all
-	explicit references to __main__.__dict__ are gone (except when
-	really needed) and everything is handled through the namespace
-	dicts in the IPython instance. We seem to be getting somewhere
-	with this, finally...
-
-	* Small documentation updates.
-
-	* Created the Extensions directory under IPython (with an
-	__init__.py). Put the PhysicalQ stuff there. This directory should
-	be used for all special-purpose extensions.
-
-	* File renaming:
-	  ipythonlib --> ipmaker
-	  ipplib     --> iplib
-	This makes a bit more sense in terms of what these files actually do.
-
-	* Moved all the classes and functions in ipythonlib to ipplib, so
-	now ipythonlib only has make_IPython(). This will ease up its
-	splitting in smaller functional chunks later.
-
-	* Cleaned up (done, I think) output of @whos. Better column
-	formatting, and now shows str(var) for as much as it can, which is
-	typically what one gets with a 'print var'.
-
-2001-12-04  Fernando Perez  <fperez@colorado.edu>
-
-	* Fixed namespace problems. Now builtin/IPyhton/user names get
-	properly reported in their namespace. Internal namespace handling
-	is finally getting decent (not perfect yet, but much better than
-	the ad-hoc mess we had).
-
-	* Removed -exit option. If people just want to run a python
-	script, that's what the normal interpreter is for. Less
-	unnecessary options, less chances for bugs.
-
-	* Added a crash handler which generates a complete post-mortem if
-	IPython crashes. This will help a lot in tracking bugs down the
-	road.
-
-	* Fixed nasty bug in auto-evaluation part of prefilter(). Names
-	which were boud to functions being reassigned would bypass the
-	logger, breaking the sync of _il with the prompt counter. This
-	would then crash IPython later when a new line was logged.
-
-2001-12-02  Fernando Perez  <fperez@colorado.edu>
-
-	* Made IPython a package. This means people don't have to clutter
-	their sys.path with yet another directory. Changed the INSTALL
-	file accordingly.
-
-	* Cleaned up the output of @who_ls, @who and @whos. @who_ls now
-	sorts its output (so @who shows it sorted) and @whos formats the
-	table according to the width of the first column. Nicer, easier to
-	read. Todo: write a generic table_format() which takes a list of
-	lists and prints it nicely formatted, with optional row/column
-	separators and proper padding and justification. 
-
-	* Released 0.1.20
-
-	* Fixed bug in @log which would reverse the inputcache list (a
-	copy operation was missing).
-
-	* Code cleanup. @config was changed to use page(). Better, since
-	its output is always quite long.
-
-	* Itpl is back as a dependency. I was having too many problems
-	getting the parametric aliases to work reliably, and it's just
-	easier to code weird string operations with it than playing %()s
-	games. It's only ~6k, so I don't think it's too big a deal.
-
-	* Found (and fixed) a very nasty bug with history. !lines weren't
-	getting cached, and the out of sync caches would crash
-	IPython. Fixed it by reorganizing the prefilter/handlers/logger
-	division of labor a bit better. Bug fixed, cleaner structure.
-
-2001-12-01  Fernando Perez  <fperez@colorado.edu>
-
-	* Released 0.1.19
-
-	* Added option -n to @hist to prevent line number printing. Much
-	easier to copy/paste code this way.
-
-	* Created global _il to hold the input list. Allows easy
-	re-execution of blocks of code by slicing it (inspired by Janko's
-	comment on 'macros').
-
-	* Small fixes and doc updates.
-
-	* Rewrote @history function (was @h). Renamed it to @hist, @h is
-	much too fragile with automagic. Handles properly multi-line
-	statements and takes parameters.
-
-2001-11-30  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.18 released.
-
-	* Fixed nasty namespace bug in initial module imports.
-
-	* Added copyright/license notes to all code files (except
-	DPyGetOpt). For the time being, LGPL. That could change.
-
-	* Rewrote a much nicer README, updated INSTALL, cleaned up
-	ipythonrc-* samples.
-
-	* Overall code/documentation cleanup. Basically ready for
-	release. Only remaining thing: licence decision (LGPL?).
-
-	* Converted load_config to a class, ConfigLoader. Now recursion
-	control is better organized. Doesn't include the same file twice.
-
-2001-11-29  Fernando Perez  <fperez@colorado.edu>
-
-	* Got input history working. Changed output history variables from
-	_p to _o so that _i is for input and _o for output. Just cleaner
-	convention.
-
-	* Implemented parametric aliases. This pretty much allows the
-	alias system to offer full-blown shell convenience, I think.
-
-	* Version 0.1.17 released, 0.1.18 opened.
-
-	* dot_ipython/ipythonrc (alias): added documentation.
-	(xcolor): Fixed small bug (xcolors -> xcolor)
-
-	* Changed the alias system. Now alias is a magic command to define
-	aliases just like the shell. Rationale: the builtin magics should
-	be there for things deeply connected to IPython's
-	architecture. And this is a much lighter system for what I think
-	is the really important feature: allowing users to define quickly
-	magics that will do shell things for them, so they can customize
-	IPython easily to match their work habits. If someone is really
-	desperate to have another name for a builtin alias, they can
-	always use __IP.magic_newname = __IP.magic_oldname. Hackish but
-	works.
-
-2001-11-28  Fernando Perez  <fperez@colorado.edu>
-
-	* Changed @file so that it opens the source file at the proper
-	line. Since it uses less, if your EDITOR environment is
-	configured, typing v will immediately open your editor of choice
-	right at the line where the object is defined. Not as quick as
-	having a direct @edit command, but for all intents and purposes it
-	works. And I don't have to worry about writing @edit to deal with
-	all the editors, less does that.
-
-	* Version 0.1.16 released, 0.1.17 opened.
-
-	* Fixed some nasty bugs in the page/page_dumb combo that could
-	crash IPython.
-
-2001-11-27  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.15 released, 0.1.16 opened.
-
-	* Finally got ? and ?? to work for undefined things: now it's
-	possible to type {}.get? and get information about the get method
-	of dicts, or os.path? even if only os is defined (so technically
-	os.path isn't). Works at any level. For example, after import os,
-	os?, os.path?, os.path.abspath? all work. This is great, took some
-	work in _ofind.
-
-	* Fixed more bugs with logging. The sanest way to do it was to add
-	to @log a 'mode' parameter. Killed two in one shot (this mode
-	option was a request of Janko's). I think it's finally clean
-	(famous last words).
-
-	* Added a page_dumb() pager which does a decent job of paging on
-	screen, if better things (like less) aren't available. One less
-	unix dependency (someday maybe somebody will port this to
-	windows).
-
-	* Fixed problem in magic_log: would lock of logging out if log
-	creation failed (because it would still think it had succeeded).
-
-	* Improved the page() function using curses to auto-detect screen
-	size. Now it can make a much better decision on whether to print
-	or page a string. Option screen_length was modified: a value 0
-	means auto-detect, and that's the default now.
-
-	* Version 0.1.14 released, 0.1.15 opened. I think this is ready to
-	go out. I'll test it for a few days, then talk to Janko about
-	licences and announce it.
-
-	* Fixed the length of the auto-generated ---> prompt which appears
-	for auto-parens and auto-quotes. Getting this right isn't trivial,
-	with all the color escapes, different prompt types and optional
-	separators. But it seems to be working in all the combinations.
-
-2001-11-26  Fernando Perez  <fperez@colorado.edu>
-
-	* Wrote a regexp filter to get option types from the option names
-	string. This eliminates the need to manually keep two duplicate
-	lists.
-
-	* Removed the unneeded check_option_names. Now options are handled
-	in a much saner manner and it's easy to visually check that things
-	are ok.
-
-	* Updated version numbers on all files I modified to carry a
-	notice so Janko and Nathan have clear version markers.
-
-	* Updated docstring for ultraTB with my changes. I should send
-	this to Nathan.
-
-	* Lots of small fixes. Ran everything through pychecker again.
-
-	* Made loading of deep_reload an cmd line option. If it's not too
-	kosher, now people can just disable it. With -nodeep_reload it's
-	still available as dreload(), it just won't overwrite reload().
-
-	* Moved many options to the no| form (-opt and -noopt
-	accepted). Cleaner.
-
-	* Changed magic_log so that if called with no parameters, it uses
-	'rotate' mode. That way auto-generated logs aren't automatically
-	over-written. For normal logs, now a backup is made if it exists
-	(only 1 level of backups). A new 'backup' mode was added to the
-	Logger class to support this. This was a request by Janko.
-
-	* Added @logoff/@logon to stop/restart an active log.
-
-	* Fixed a lot of bugs in log saving/replay. It was pretty
-	broken. Now special lines (!@,/) appear properly in the command
-	history after a log replay.
-
-	* Tried and failed to implement full session saving via pickle. My
-	idea was to pickle __main__.__dict__, but modules can't be
-	pickled. This would be a better alternative to replaying logs, but
-	seems quite tricky to get to work. Changed -session to be called
-	-logplay, which more accurately reflects what it does. And if we
-	ever get real session saving working, -session is now available.
-
-	* Implemented color schemes for prompts also. As for tracebacks,
-	currently only NoColor and Linux are supported. But now the
-	infrastructure is in place, based on a generic ColorScheme
-	class. So writing and activating new schemes both for the prompts
-	and the tracebacks should be straightforward.
-
-	* Version 0.1.13 released, 0.1.14 opened.
-
-	* Changed handling of options for output cache. Now counter is
-	hardwired starting at 1 and one specifies the maximum number of
-	entries *in the outcache* (not the max prompt counter). This is
-	much better, since many statements won't increase the cache
-	count. It also eliminated some confusing options, now there's only
-	one: cache_size.
-
-	* Added 'alias' magic function and magic_alias option in the
-	ipythonrc file. Now the user can easily define whatever names he
-	wants for the magic functions without having to play weird
-	namespace games. This gives IPython a real shell-like feel.
-
-	* Fixed doc/?/?? for magics. Now all work, in all forms (explicit
-	@ or not).
-
-	This was one of the last remaining 'visible' bugs (that I know
-	of). I think if I can clean up the session loading so it works
-	100% I'll release a 0.2.0 version on c.p.l (talk to Janko first
-	about licensing).	
-
-2001-11-25  Fernando Perez  <fperez@colorado.edu>
-
-	* Rewrote somewhat oinfo (?/??). Nicer, now uses page() and
-	there's a cleaner distinction between what ? and ?? show.
-
-	* Added screen_length option. Now the user can define his own
-	screen size for page() operations.
-
-	* Implemented magic shell-like functions with automatic code
-	generation. Now adding another function is just a matter of adding
-	an entry to a dict, and the function is dynamically generated at
-	run-time. Python has some really cool features!
-
-	* Renamed many options to cleanup conventions a little. Now all
-	are lowercase, and only underscores where needed. Also in the code
-	option name tables are clearer.
-
-	* Changed prompts a little. Now input is 'In [n]:' instead of
-	'In[n]:='. This allows it the numbers to be aligned with the
-	Out[n] numbers, and removes usage of ':=' which doesn't exist in
-	Python (it was a Mathematica thing). The '...' continuation prompt
-	was also changed a little to align better.
-
-	* Fixed bug when flushing output cache. Not all _p<n> variables
-	exist, so their deletion needs to be wrapped in a try:
-
-	* Figured out how to properly use inspect.formatargspec() (it
-	requires the args preceded by *). So I removed all the code from
-	_get_pdef in Magic, which was just replicating that.
-
-	* Added test to prefilter to allow redefining magic function names
-	as variables. This is ok, since the @ form is always available,
-	but whe should allow the user to define a variable called 'ls' if
-	he needs it.
-
-	* Moved the ToDo information from README into a separate ToDo.
-
-	* General code cleanup and small bugfixes. I think it's close to a
-	state where it can be released, obviously with a big 'beta'
-	warning on it.
-
-	* Got the magic function split to work. Now all magics are defined
-	in a separate class. It just organizes things a bit, and now
-	Xemacs behaves nicer (it was choking on InteractiveShell b/c it
-	was too long).
-
-	* Changed @clear to @reset to avoid potential confusions with
-	the shell command clear. Also renamed @cl to @clear, which does
-	exactly what people expect it to from their shell experience.
-
-	Added a check to the @reset command (since it's so
-	destructive, it's probably a good idea to ask for confirmation).
-	But now reset only works for full namespace resetting. Since the
-	del keyword is already there for deleting a few specific
-	variables, I don't see the point of having a redundant magic
-	function for the same task.
-
-2001-11-24  Fernando Perez  <fperez@colorado.edu>
-
-	* Updated the builtin docs (esp. the ? ones).
-
-	* Ran all the code through pychecker. Not terribly impressed with
-	it: lots of spurious warnings and didn't really find anything of
-	substance (just a few modules being imported and not used).
-
-	* Implemented the new ultraTB functionality into IPython. New
-	option: xcolors. This chooses color scheme. xmode now only selects
-	between Plain and Verbose. Better orthogonality.
-
-	* Large rewrite of ultraTB. Much cleaner now, with a separation of
-	mode and color scheme for the exception handlers. Now it's
-	possible to have the verbose traceback with no coloring.
-
-2001-11-23  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.12 released, 0.1.13 opened.
-
-	* Removed option to set auto-quote and auto-paren escapes by
-	user. The chances of breaking valid syntax are just too high. If
-	someone *really* wants, they can always dig into the code.
-
-	* Made prompt separators configurable.
-
-2001-11-22  Fernando Perez  <fperez@colorado.edu>
-
-	* Small bugfixes in many places.
-
-	* Removed the MyCompleter class from ipplib. It seemed redundant
-	with the C-p,C-n history search functionality. Less code to
-	maintain.
-
-	* Moved all the original ipython.py code into ipythonlib.py. Right
-	now it's just one big dump into a function called make_IPython, so
-	no real modularity has been gained. But at least it makes the
-	wrapper script tiny, and since ipythonlib is a module, it gets
-	compiled and startup is much faster.
-
-	This is a reasobably 'deep' change, so we should test it for a
-	while without messing too much more with the code.
-
-2001-11-21  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.11 released, 0.1.12 opened for further work.
-
-	* Removed dependency on Itpl. It was only needed in one place. It
-	would be nice if this became part of python, though. It makes life
-	*a lot* easier in some cases.
-
-	* Simplified the prefilter code a bit. Now all handlers are
-	expected to explicitly return a value (at least a blank string).
-
-	* Heavy edits in ipplib. Removed the help system altogether. Now
-	obj?/?? is used for inspecting objects, a magic @doc prints
-	docstrings, and full-blown Python help is accessed via the 'help'
-	keyword. This cleans up a lot of code (less to maintain) and does
-	the job. Since 'help' is now a standard Python component, might as
-	well use it and remove duplicate functionality.
-
-	Also removed the option to use ipplib as a standalone program. By
-	now it's too dependent on other parts of IPython to function alone.
-
-	* Fixed bug in genutils.pager. It would crash if the pager was
-	exited immediately after opening (broken pipe).
-
-	* Trimmed down the VerboseTB reporting a little. The header is
-	much shorter now and the repeated exception arguments at the end
-	have been removed. For interactive use the old header seemed a bit
-	excessive.
-
-	* Fixed small bug in output of @whos for variables with multi-word
-	types (only first word was displayed).
-
-2001-11-17  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.10 released, 0.1.11 opened for further work.
-
-	* Modified dirs and friends. dirs now *returns* the stack (not
-	prints), so one can manipulate it as a variable. Convenient to
-	travel along many directories.
-
-	* Fixed bug in magic_pdef: would only work with functions with
-	arguments with default values.
-
-2001-11-14  Fernando Perez  <fperez@colorado.edu>
-
-	* Added the PhysicsInput stuff to dot_ipython so it ships as an
-	example with IPython. Various other minor fixes and cleanups.
-
-	* Version 0.1.9 released, 0.1.10 opened for further work.
-
-	* Added sys.path to the list of directories searched in the
-	execfile= option. It used to be the current directory and the
-	user's IPYTHONDIR only.
-
-2001-11-13  Fernando Perez  <fperez@colorado.edu>
-
-	* Reinstated the raw_input/prefilter separation that Janko had
-	initially. This gives a more convenient setup for extending the
-	pre-processor from the outside: raw_input always gets a string,
-	and prefilter has to process it. We can then redefine prefilter
-	from the outside and implement extensions for special
-	purposes.
-
-	Today I got one for inputting PhysicalQuantity objects
-	(from Scientific) without needing any function calls at
-	all. Extremely convenient, and it's all done as a user-level
-	extension (no IPython code was touched). Now instead of:
-		a = PhysicalQuantity(4.2,'m/s**2')
-	one can simply say
-		a = 4.2 m/s**2
-	or even
-		a = 4.2 m/s^2
-	
-	I use this, but it's also a proof of concept: IPython really is
-	fully user-extensible, even at the level of the parsing of the
-	command line. It's not trivial, but it's perfectly doable.
-
-	* Added 'add_flip' method to inclusion conflict resolver. Fixes
-	the problem of modules being loaded in the inverse order in which
-	they were defined in 
-
-	* Version 0.1.8 released, 0.1.9 opened for further work.
-
-	* Added magics pdef, source and file. They respectively show the
-	definition line ('prototype' in C), source code and full python
-	file for any callable object. The object inspector oinfo uses
-	these to show the same information.
-
-	* Version 0.1.7 released, 0.1.8 opened for further work.
-
-	* Separated all the magic functions into a class called Magic. The
-	InteractiveShell class was becoming too big for Xemacs to handle
-	(de-indenting a line would lock it up for 10 seconds while it
-	backtracked on the whole class!)
-
-	FIXME: didn't work. It can be done, but right now namespaces are
-	all messed up. Do it later (reverted it for now, so at least
-	everything works as before).
-
-	* Got the object introspection system (magic_oinfo) working! I
-	think this is pretty much ready for release to Janko, so he can
-	test it for a while and then announce it. Pretty much 100% of what
-	I wanted for the 'phase 1' release is ready. Happy, tired.
-
-2001-11-12  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.6 released, 0.1.7 opened for further work.
-
-	* Fixed bug in printing: it used to test for truth before
-	printing, so 0 wouldn't print. Now checks for None.
-
-	* Fixed bug where auto-execs increase the prompt counter by 2 (b/c
-	they have to call len(str(sys.ps1)) ). But the fix is ugly, it
-	reaches by hand into the outputcache. Think of a better way to do
-	this later.
-
-	* Various small fixes thanks to Nathan's comments.
-
-	* Changed magic_pprint to magic_Pprint. This way it doesn't
-	collide with pprint() and the name is consistent with the command
-	line option.
-
-	* Changed prompt counter behavior to be fully like
-	Mathematica's. That is, even input that doesn't return a result
-	raises the prompt counter. The old behavior was kind of confusing
-	(getting the same prompt number several times if the operation
-	didn't return a result).
-
-	* Fixed Nathan's last name in a couple of places (Gray, not Graham).
-
-	* Fixed -Classic mode (wasn't working anymore).
-
-	* Added colored prompts using Nathan's new code. Colors are
-	currently hardwired, they can be user-configurable. For
-	developers, they can be chosen in file ipythonlib.py, at the
-	beginning of the CachedOutput class def.
-
-2001-11-11  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.5 released, 0.1.6 opened for further work.
-
-	* Changed magic_env to *return* the environment as a dict (not to
-	print it). This way it prints, but it can also be processed.
-
-	* Added Verbose exception reporting to interactive
-	exceptions. Very nice, now even 1/0 at the prompt gives a verbose
-	traceback. Had to make some changes to the ultraTB file. This is
-	probably the last 'big' thing in my mental todo list.  This ties
-	in with the next entry:
-
-	* Changed -Xi and -Xf to a single -xmode option. Now all the user
-	has to specify is Plain, Color or Verbose for all exception
-	handling.
-
-	* Removed ShellServices option. All this can really be done via
-	the magic system. It's easier to extend, cleaner and has automatic
-	namespace protection and documentation.
-
-2001-11-09  Fernando Perez  <fperez@colorado.edu>
-
-	* Fixed bug in output cache flushing (missing parameter to
-	__init__). Other small bugs fixed (found using pychecker).
-
-	* Version 0.1.4 opened for bugfixing.
-
-2001-11-07  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.3 released, mainly because of the raw_input bug.
-
-	* Fixed NASTY bug in raw_input: input line wasn't properly parsed
-	and when testing for whether things were callable, a call could
-	actually be made to certain functions. They would get called again
-	once 'really' executed, with a resulting double call. A disaster
-	in many cases (list.reverse() would never work!).
-
-	* Removed prefilter() function, moved its code to raw_input (which
-	after all was just a near-empty caller for prefilter). This saves
-	a function call on every prompt, and simplifies the class a tiny bit.
-
-	* Fix _ip to __ip name in magic example file.
-
-	* Changed 'tar -x -f' to 'tar xvf' in auto-installer. This should
-	work with non-gnu versions of tar.
-
-2001-11-06  Fernando Perez  <fperez@colorado.edu>
-
-	* Version 0.1.2. Just to keep track of the recent changes.
-
-	* Fixed nasty bug in output prompt routine. It used to check 'if
-	arg != None...'. Problem is, this fails if arg implements a
-	special comparison (__cmp__) which disallows comparing to
-	None. Found it when trying to use the PhysicalQuantity module from
-	ScientificPython.
-
-2001-11-05  Fernando Perez  <fperez@colorado.edu>
-
-	* Also added dirs. Now the pushd/popd/dirs family functions
-	basically like the shell, with the added convenience of going home
-	when called with no args.
-
-	* pushd/popd slightly modified to mimic shell behavior more
-	closely.
-
-	* Added env,pushd,popd from ShellServices as magic functions. I
-	think the cleanest will be to port all desired functions from
-	ShellServices as magics and remove ShellServices altogether. This
-	will provide a single, clean way of adding functionality
-	(shell-type or otherwise) to IP.
-
-2001-11-04  Fernando Perez  <fperez@colorado.edu>
-
-	* Added .ipython/ directory to sys.path. This way users can keep
-	customizations there and access them via import.
-
-2001-11-03  Fernando Perez  <fperez@colorado.edu>
-
-	* Opened version 0.1.1 for new changes.
-
-	* Changed version number to 0.1.0: first 'public' release, sent to
-	Nathan and Janko.
-
-	* Lots of small fixes and tweaks.
-
-	* Minor changes to whos format. Now strings are shown, snipped if
-	too long.
-
-	* Changed ShellServices to work on __main__ so they show up in @who
-
-	* Help also works with ? at the end of a line:
-		?sin and sin?
-	both produce the same effect. This is nice, as often I use the
-	tab-complete to find the name of a method, but I used to then have
-	to go to the beginning of the line to put a ? if I wanted more
-	info. Now I can just add the ? and hit return. Convenient.
-
-2001-11-02  Fernando Perez  <fperez@colorado.edu>
-
-	* Python version check (>=2.1) added.
-
-	* Added LazyPython documentation. At this point the docs are quite
-	a mess. A cleanup is in order.
-
-	* Auto-installer created. For some bizarre reason, the zipfiles
-	module isn't working on my system. So I made a tar version
-	(hopefully the command line options in various systems won't kill
-	me).
-
-	* Fixes to Struct in genutils. Now all dictionary-like methods are
-	protected (reasonably).
-
-	* Added pager function to genutils and changed ? to print usage
-	note through it (it was too long).
-
-	* Added the LazyPython functionality. Works great! I changed the
-	auto-quote escape to ';', it's on home row and next to '. But
-	both auto-quote and auto-paren (still /) escapes are command-line
-	parameters.
-	
-
-2001-11-01  Fernando Perez  <fperez@colorado.edu>
-
-	* Version changed to 0.0.7. Fairly large change: configuration now
-	is all stored in a directory, by default .ipython. There, all
-	config files have normal looking names (not .names)
-
-	* Version 0.0.6 Released first to Lucas and Archie as a test
-	run. Since it's the first 'semi-public' release, change version to
-	> 0.0.6 for any changes now.
-
-	* Stuff I had put in the ipplib.py changelog:
-	
-	Changes to InteractiveShell:
-	
-	- Made the usage message a parameter.
-	
-	- Require the name of the shell variable to be given. It's a bit
-	of a hack, but allows the name 'shell' not to be hardwired in the
-	magic (@) handler, which is problematic b/c it requires
-	polluting the global namespace with 'shell'. This in turn is
-	fragile: if a user redefines a variable called shell, things
-	break.
-
-	- magic @: all functions available through @ need to be defined
-	as magic_<name>, even though they can be called simply as
-	@<name>. This allows the special command @magic to gather
-	information automatically about all existing magic functions,
-	even if they are run-time user extensions, by parsing the shell
-	instance __dict__ looking for special magic_ names.
-
-	- mainloop: added *two* local namespace parameters. This allows
-	the class to differentiate between parameters which were there
-	before and after command line initialization was processed. This
-	way, later @who can show things loaded at startup by the
-	user. This trick was necessary to make session saving/reloading
-	really work: ideally after saving/exiting/reloading a session,
-	*everything* should look the same, including the output of @who. I
-	was only able to make this work with this double namespace
-	trick.
-
-	- added a header to the logfile which allows (almost) full
-	session restoring.
-
-	- prepend lines beginning with @ or !, with a and log
-	them. Why?  !lines: may be useful to know what you did @lines:
-	they may affect session state. So when restoring a session, at
-	least inform the user of their presence. I couldn't quite get
-	them to properly re-execute, but at least the user is warned.
-
-	* Started ChangeLog.
diff --git a/docs/attic/ipnb_google_soc.lyx b/docs/attic/ipnb_google_soc.lyx
deleted file mode 100644
index f931c7c7685..00000000000
--- a/docs/attic/ipnb_google_soc.lyx
+++ /dev/null
@@ -1,645 +0,0 @@
-#LyX 1.3 created this file. For more info see http://www.lyx.org/
-\lyxformat 221
-\textclass article
-\begin_preamble
-\usepackage{hyperref}
-
-\usepackage{color}
-\definecolor{orange}{cmyk}{0,0.4,0.8,0.2}
-\definecolor{brown}{cmyk}{0,0.75,0.75,0.35}
-
-% Use and configure listings package for nicely formatted code
-\usepackage{listings}
-\lstset{
-  language=Python,
-  basicstyle=\small\ttfamily,
-  commentstyle=\ttfamily\color{blue},
-  stringstyle=\ttfamily\color{brown},
-  showstringspaces=false,
-  breaklines=true,
-  postbreak = \space\dots
-}
-\end_preamble
-\language english
-\inputencoding auto
-\fontscheme palatino
-\graphics default
-\paperfontsize 11
-\spacing single 
-\papersize Default
-\paperpackage a4
-\use_geometry 1
-\use_amsmath 0
-\use_natbib 0
-\use_numerical_citations 0
-\paperorientation portrait
-\leftmargin 1in
-\topmargin 0.9in
-\rightmargin 1in
-\bottommargin 0.9in
-\secnumdepth 3
-\tocdepth 3
-\paragraph_separation skip
-\defskip medskip
-\quotes_language english
-\quotes_times 2
-\papercolumns 1
-\papersides 1
-\paperpagestyle default
-
-\layout Title
-
-Interactive Notebooks for Python
-\newline 
-
-\size small 
-An IPython project for Google's Summer of Code 2005
-\layout Author
-
-Fernando P
-\begin_inset ERT
-status Collapsed
-
-\layout Standard
-
-\backslash 
-'{e}
-\end_inset 
-
-rez
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\family typewriter 
-\size small 
-Fernando.Perez@colorado.edu
-\end_inset 
-
-
-\layout Abstract
-
-This project aims to develop a file format and interactive support for documents
- which can combine Python code with rich text and embedded graphics.
- The initial requirements only aim at being able to edit such documents
- with a normal programming editor, with final rendering to PDF or HTML being
- done by calling an external program.
- The editing component would have to be integrated with IPython.
- 
-\layout Abstract
-
-This document was written by the IPython developer; it is made available
- to students looking for projects of interest and for inclusion in their
- application.
-\layout Section
-
-Project overview
-\layout Standard
-
-Python's interactive interpreter is one of the language's most appealing
- features for certain types of usage, yet the basic shell which ships with
- the language is very limited.
- Over the last few years, IPython
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://ipython.scipy.org}
-
-\end_inset 
-
-
-\end_inset 
-
- has become the de facto standard interactive shell in the scientific computing
- community, and it enjoys wide popularity with general audiences.
- All the major Linux distributions (Fedora Core via Extras, SUSE, Debian)
- and OS X (via fink) carry IPython, and Windows users report using it as
- a viable system shell.
-\layout Standard
-
-However, IPython is currently a command-line only application, based on
- the readline library and hence with single-line editing capabilities.
- While this kind of usage is sufficient for many contexts, there are usage
- cases where integration in a graphical user interface (GUI) is desirable.
- 
-\layout Standard
-
-In particular, we wish to have an interface where users can execute Python
- code, input regular text (neither code nor comments) and keep inline graphics,
- which we will call 
-\emph on 
-Python notebooks
-\emph default 
-.
- This kind of system is very popular in scientific computing; well known
- implementations can be found in Mathematica
-\begin_inset ERT
-status Collapsed
-
-\layout Standard
-
-\backslash 
-texttrademark
-\end_inset 
-
-\SpecialChar ~
-
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://www.wolfram.com/products/mathematica}
-
-\end_inset 
-
-
-\end_inset 
-
- and Maple
-\begin_inset ERT
-status Collapsed
-
-\layout Standard
-
-\backslash 
-texttrademark
-\end_inset 
-
-\SpecialChar ~
-
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://www.maplesoft.com}
-
-\end_inset 
-
-
-\end_inset 
-
-, among others.
- However, these are proprietary (and quite expensive) systems aimed at an
- audience of mathematicians, scientists and engineers.
-\layout Standard
-
-The full-blown implementation of a graphical shell supporting this kind
- of work model is probably too ambitious for a summer project.
- Simultaneous support for rich-text editing, embedded graphics and syntax-highli
-ghted code is extremely complex, and likely to require far more effort than
- can be mustered by an individual developer for a short-term project.
-\layout Standard
-
-This project will thus aim to build the necessary base infrastructure to
- be able to edit such documents from a plain text editor, and to render
- them to suitable formats for printing or online distribution, such as HTML,
- PDF or PostScript.
- This model follows that for the production of LaTeX documents, which can
- be edited with any text editor.
-\layout Standard
-
-Such documents would be extremely useful for many audiences beyond scientists:
- one can use them to produce additionally documented code, to explore a
- problem with Python and maintain all relevant information in the same place,
- as a way to distribute enhanced Python-based educational materials, etc.
-\layout Standard
-
-Demand for such a system exists, as evidenced by repeated requests made
- to me by IPython users over the last few years.
- Unfortunately IPython is only a spare-time project for me, and I have not
- had the time to devote to this, despite being convinced of its long term
- value and wide appeal.
-\layout Standard
-
-If this project is successful, the infrastructure laid out by it will be
- immediately useful for Python users wishing to maintain `literate' programs
- which include rich formatting.
- In addition, this will open the door for the future development of graphical
- shells which can render such documents in real time: this is exactly the
- development model successfully followed by the LyX
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://www.lyx.org}
-
-\end_inset 
-
-
-\end_inset 
-
- document processing system.
-\layout Section
-
-Implementation effort
-\layout Subsection
-
-Specific goals
-\layout Standard
-
-This is a brief outline of the main points of this project.
- The next section provides details on all of them.
- The student(s) working on the project would need to:
-\layout Enumerate
-
-Make design decisions for the internal file structure to enable valid Python
- notebooks.
- 
-\layout Enumerate
-
-Implement the rendering library, capable of processing an input notebook
- through reST or LaTeX and producing HTML or PDF output, as well as exporting
- a `pure-code' Python file stripped of all markup calls.
-\layout Enumerate
-
-Study existing programming editor widgets to find the most suitable one
- for extending with an IPython connector for interactive execution of the
- notebooks.
-\layout Subsection
-
-Complexity level
-\layout Standard
-
-This project is relatively complicated.
- While I will gladly assist the student with design and implementation issues,
- it will require a fair amount of thinking in terms of overall library architect
-ure.
- The actual implementation does not require any sophisticated concepts,
- but rather a reasonably broad knowledge of a wide set of topics (markup,
- interaction with external programs and libraries, namespace tricks to provide
- runtime changes in the effect of the markup calls, etc.)
-\layout Standard
-
-While raw novices are welcome to try, I suspect that it may be a bit too
- much for them.
- Students wanting to apply should keep in mind, if the money is an important
- consideration, that Google only gives the $4500 reward upon 
-\emph on 
-successful completion
-\emph default 
- of the project.
- So don't bite more than you can chew.
- Obviously if this doesn't matter, anyone is welcome to participate, since
- the project can be a very interesting learning experience, and it will
- provide a genuinely useful tool for many.
-\layout Section
-
-Technical details
-\layout Subsection
-
-The files
-\layout Standard
-
-A basic requirement of this project will be that the Python notebooks shall
- be valid Python source files, typically with a 
-\family typewriter 
-.py
-\family default 
- extension.
- A renderer program can be used to process the markup calls in them and
- generate output.
- If run at a regular command line, these files should execute like normal
- Python files.
- But when run via a special rendering script, the result should be a properly
- formatted file.
- Output formats could be PDF or HTML depending on user-supplied options.
-\layout Standard
-
-A reST markup mode should be implemented, as reST is already widely used
- in the Python community and is a very simple format to write.
- The following is a sketch of what such files could look like using reST
- markup:
-\layout Standard
-
-
-\begin_inset ERT
-status Open
-
-\layout Standard
-
-\backslash 
-lstinputlisting{nbexample.py}
-\end_inset 
-
-
-\layout Standard
-
-Additionally, a LaTeX markup mode should also be implemented.
- Here's a mockup example of what code using the LaTeX mode could look like.
-\layout Standard
-
-
-\begin_inset ERT
-status Open
-
-\layout Standard
-
-\backslash 
-lstinputlisting{nbexample_latex.py}
-\end_inset 
-
-
-\layout Standard
-
-At this point, it must be noted that the code above is simply a sketch of
- these ideas, not a finalized design.
- An important part of this project will be to think about what the best
- API and structure for this problem should be.
-\layout Subsection
-
-From notebooks to PDF, HTML or Python
-\layout Standard
-
-Once a clean API for markup has been specified, converters will be written
- to take a python source file which uses notebook constructs, and generate
- final output in printable formats, such as HTML or PDF.
- For example, if 
-\family typewriter 
-nbfile.py
-\family default 
- is a python notebook, then
-\layout LyX-Code
-
-$ pynb --export=pdf nbfile.py
-\layout Standard
-
-should produce 
-\family typewriter 
-nbfile.pdf
-\family default 
-, while
-\layout LyX-Code
-
-$ pynb --export=html nbfile.py
-\layout Standard
-
-would produce an HTML version.
- The actual rendering will be done by calling appropriate utilities, such
- as the reST toolchain or LaTeX, depending on the markup used by the file.
-\layout Standard
-
-Additionally, while the notebooks will be valid Python files, if executed
- on their own, all the markup calls will still return their results, which
- are not really needed when the file is being treated as pure code.
- For this reason, a module to execute these files turning the markup calls
- into no-ops should be written.
- Using Python 2.4's -m switch, one can then use something like
-\layout LyX-Code
-
-$ python -m notebook nbfile.py
-\layout Standard
-
-and the notebook file 
-\family typewriter 
-nbfile.py
-\family default 
- will be executed without any overhead introduced by the markup (other than
- making calls to functions which return immediately).
- Finally, an exporter to clean code can be trivially implemented, so that:
-\layout LyX-Code
-
-$ pynb --export=python nbfile.py nbcode.py
-\layout Standard
-
-would export only the code in 
-\family typewriter 
-nbfile.py
-\family default 
- to 
-\family typewriter 
-nbcode.py
-\family default 
-, removing the markup completely.
- This can be used to generate final production versions of large modules
- implemented as notebooks, if one wants to eliminate the markup overhead.
-\layout Subsection
-
-The editing environment
-\layout Standard
-
-The first and most important part of the project should be the definition
- of a clean API and the implementation of the exporter modules as indicated
- above.
- Ultimately, such files can be developed using any text editor, since they
- are nothing more than regular Python code.
-\layout Standard
-
-But once these goals are reached, further integration with an editor will
- be done, without the need for a full-blown GUI shell.
- In fact, already today the (X)Emacs editors can provide for interactive
- usage of such files.
- Using python-mode in (X)Emacs, one can pass highlighted regions of a file
- for execution to an underlying python process, and the results are printed
- in the python window.
- With recent versions of python-mode, IPython can be used instead of the
- plain python interpreter, so that IPython's extended interactive capabilities
- become available within (X)Emacs (improved tracebacks, automatic debugger
- integration, variable information, easy filesystem access to Python, etc).
-\layout Standard
-
-But even with IPython integration, the usage within (X)Emacs is not ideal
- for a notebook environment, since the python process buffer is separate
- from the python file.
- Therefore, the next stage of the project will be to enable tighter integration
- between the editing and execution environments.
- The basic idea is to provide an easy way to mark regions of the file to
- be executed interactively, and to have the output inserted automatically
- into the file.
- The following listing is a mockup of what the resulting file could look
- like
-\layout Standard
-
-
-\begin_inset ERT
-status Open
-
-\layout Standard
-
-\backslash 
-lstinputlisting{nbexample_output.py}
-\end_inset 
-
-
-\layout Standard
-
-Basically, the editor will execute 
-\family typewriter 
-add(2,3)
-\family default 
- and insert the string representation of the output into the file, so it
- can be used for rendering later.
- 
-\layout Section
-
-Available resources
-\layout Standard
-
-IPython currently has all the necessary infrastructure for code execution,
- albeit in a rather messy code base.
- Most I/O is already abstracted out, a necessary condition for embedding
- in a GUI (since you are not writing to stdout/err but to the GUI's text
- area).
- 
-\layout Standard
-
-For interaction with an editor, it will be necessary to identify a good
- programming editor with a Python-compatible license, which can be extended
- to communicate with the underlying IPython engine.
- IDLE, the Tk-based IDE which ships with Python, should obviously be considered.
- The Scintilla editing component
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://www.scintilla.org}
-
-\end_inset 
-
-
-\end_inset 
-
- may also be a viable candidate.
- 
-\layout Standard
-
-It will also be interesting to look at the LyX editor
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://www.lyx.org}
-
-\end_inset 
-
-
-\end_inset 
-
-, which already offers a Python client
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://wiki.lyx.org/Tools/PyClient}
-
-\end_inset 
-
-
-\end_inset 
-
-.
- Since LyX has very sophisticated LaTeX support, this is a very interesting
- direction to consider for the future (though LyX makes a poor programming
- editor).
-\layout Section
-
-Support offered to the students
-\layout Standard
-
-The IPython project already has an established Open Source infrastructure,
- including CVS repositories, a bug tracker and mailing lists.
- As the main author and sole maintainer of IPython, I will personally assist
- the student(s) funded with architectural and design guidance, preferably
- on the public development mailing list.
- I expect them to start working by submitting patches until they show, by
- the quality of their work, that they can be granted CVS write access.
- I expect most actual implementation work to be done by the students, though
- I will provide assistance if they need it with a specific technical issue.
-\layout Standard
-
-If more than one applicant is accepted to work on this project, there is
- more than enough work to be done which can be coordinated between them.
-\layout Section
-
-Licensing and copyright
-\layout Standard
-
-IPython is licensed under BSD terms, and copyright of all sources rests
- with the original authors of the core modules.
- Over the years, all external contributions have been small enough patches
- that they have been simply folded into the main source tree without additional
- copyright attributions, though explicit credit has always been given to
- all contributors.
-\layout Standard
-
-I expect the students participating in this project to contribute enough
- standalone code that they can retain the copyright to it if they so desire,
- as long as they accept all their work to be licensed under BSD terms.
-\layout Section
-
-Acknowledgements
-\layout Standard
-
-I'd like to thank John D.
- Hunter, the author of matplotlib
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://matplotlib.sf.net}
-
-\end_inset 
-
-
-\end_inset 
-
-, for lengthy discussions which helped clarify much of this project.
- In particular, the important decision of embedding the notebook markup
- calls in true Python functions instead of specially-tagged strings or comments
- was an idea I thank him for pushing hard enough to convince me of using.
- 
-\layout Standard
-
-My conversations with Brian Granger, the author of PyXG
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://hammonds.scu.edu/~classes/pyxg.html}
-
-\end_inset 
-
-
-\end_inset 
-
- and braid
-\begin_inset Foot
-collapsed true
-
-\layout Standard
-
-
-\begin_inset LatexCommand \htmlurl{http://hammonds.scu.edu/~classes/braid.html}
-
-\end_inset 
-
-
-\end_inset 
-
-, have also been very useful in clarifying details of the necessary underlying
- infrastructure and future evolution of IPython for this kind of system.
-\layout Standard
-
-Thank you also to the IPython users who have, in the past, discussed this
- topic with me either in private or on the IPython or Scipy lists.
-\the_end
diff --git a/docs/attic/nbexample.py b/docs/attic/nbexample.py
deleted file mode 100644
index 7bc272718d0..00000000000
--- a/docs/attic/nbexample.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from notebook.markup import rest
-
-rest.title('This is a Python Notebook')
-rest.heading(1,'A first-level heading')
-rest.text("""\
-Some plain text, without any special formatting.
-
-Below, we define a simple function to add two numbers.""")
-
-def add(x,y):
-    return x+y
diff --git a/docs/attic/nbexample_latex.py b/docs/attic/nbexample_latex.py
deleted file mode 100644
index 673cb4bc407..00000000000
--- a/docs/attic/nbexample_latex.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from notebook.markup import latex
-
-latex.document_class('article')
-latex.title('This is a Python Notebook')
-
-latex.section('A section title',label='sec:intro')
-
-latex.text(r"""Below, we define a simple function
-\begin{equation}
-f: (x,y) \rightarrow x+y^2
-\end{equation}""")
-
-def f(x,y):
-    return x+y**2
-
-# since the .text method passes directly to latex, all markup could be input
-# in that way if so desired
-latex.text(r"""
-\section{Another section}
-
-More text...
-
-And now a picture showing our important results...""")
-
-latex.include_graphic('foo.png')
diff --git a/docs/attic/nbexample_output.py b/docs/attic/nbexample_output.py
deleted file mode 100644
index 8dfe099df4c..00000000000
--- a/docs/attic/nbexample_output.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from notebook.markup import rest
-
-rest.title('This is a Python Notebook')
-rest.text("""\
-Some plain text, without any special formatting.
-
-Below, we define a simple function to add two numbers.""")
-
-def add(x,y):
-    return x+y
-
-rest.text("Let's use it with x=2,y=3:")
-# This simply means that all code until the next markup call is to be executed
-# as a single call.  The editing screen should mark the whole group of lines
-# with a single In[NN] tag (like IPython does, but with multi-line capabilities)
-rest.input()
-add(2,3)
-# This output would appear on-screen (in the editing window) simply marked
-# with an Out[NN] tag
-rest.output("5")
diff --git a/docs/attic/new_design.lyx b/docs/attic/new_design.lyx
deleted file mode 100644
index 6d503c688d9..00000000000
--- a/docs/attic/new_design.lyx
+++ /dev/null
@@ -1,1358 +0,0 @@
-#LyX 1.3 created this file. For more info see http://www.lyx.org/
-\lyxformat 221
-\textclass article
-\begin_preamble
-\usepackage{ae,aecompl}
-\usepackage{hyperref}
-\usepackage{html}
-\end_preamble
-\language english
-\inputencoding auto
-\fontscheme default
-\graphics default
-\paperfontsize default
-\spacing single 
-\papersize Default
-\paperpackage a4
-\use_geometry 1
-\use_amsmath 0
-\use_natbib 0
-\use_numerical_citations 0
-\paperorientation portrait
-\leftmargin 1.25in
-\topmargin 1in
-\rightmargin 1.25in
-\bottommargin 1in
-\secnumdepth 3
-\tocdepth 3
-\paragraph_separation skip
-\defskip medskip
-\quotes_language english
-\quotes_times 2
-\papercolumns 1
-\papersides 1
-\paperpagestyle default
-
-\layout Title
-
-IPython
-\newline 
-
-\size larger 
-New design notes
-\layout Author
-
-Fernando Pérez
-\layout Section
-
-Introduction
-\layout Standard
-
-This is a draft document with notes and ideas for the IPython rewrite.
- The section order and structure of this document roughly reflects in which
- order things should be done and what the dependencies are.
- This document is mainly a draft for developers, a pdf version is provided
- with the standard distribution in case regular users are interested and
- wish to contribute ideas.
-\layout Standard
-
-A tentative plan for the future:
-\layout Itemize
-
-0.6.x series: in practice, enough people are using IPython for real work that
- I think it warrants a higher number.
- This series will continue to evolve with bugfixes and incremental improvements.
-\layout Itemize
-
-0.7.x series: (maybe) If resources allow, there may be a branch for 'unstable'
- development, where the architectural rewrite may take place.
-\layout Standard
-
-However, I am starting to doubt it is feasible to keep two separate branches.
- I am leaning more towards a 
-\begin_inset ERT
-status Collapsed
-
-\layout Standard
-
-\backslash 
-LyX
-\end_inset 
-
--like approach, where the main branch slowly transforms and evolves.
- Having CVS support now makes this a reasonable alternative, as I don't
- have to make pre-releases as often.
- The active branch can remain the mainline of development, and users interested
- in the bleeding-edge stuff can always grab the CVS code.
-\layout Standard
-
-Ideally, IPython should have a clean class setup that would allow further
- extensions for special-purpose systems.
- I view IPython as a base system that provides a great interactive environment
- with full access to the Python language, and which could be used in many
- different contexts.
- The basic hooks are there: the magic extension syntax and the flexible
- system of recursive configuration files and profiles.
- But with a code as messy as the current one, nobody is going to touch it.
-\layout Section
-
-Immediate TODO and bug list
-\layout Standard
-
-Things that should be done for the current series, before starting major
- changes.
-\layout Itemize
-
-Fix any bugs reported at the online bug tracker.
-\layout Itemize
-
-History bug: I often see that, under certain circumstances, the input history
- is incorrect.
- The problem is that so far, I've failed to find a simple way to reproduce
- it consistently, so I can't easily track it down.
- It seems to me that it happens when output is generated multiple times
- for the same input (for i in range(10): i will do it).
- But even this isn't reliable...
- Ultimately the right solution for this is to cleanly separate the dataflow
- for input/output history management; right now that happens all over the
- place, which makes the code impossible to debug, and almost guaranteed
- to be buggy in the first place.
-\layout Itemize
-
-
-\series bold 
-Redesign the output traps.
-
-\series default 
- They cause problems when users try to execute code which relies on sys.stdout
- being the 'true' sys.stdout.
- They also prevent scripts which use raw_input() to work as command-line
- arguments.
-\newline 
-The best solution is probably to print the banner first, and then just execute
- all the user code straight with no output traps at all.
- Whatever comes out comes out.
- This makes the ipython code actually simpler, and eliminates the problem
- altogether.
-\newline 
-These things need to be ripped out, they cause no end of problems.
- For example, if user code requires acces to stdin during startup, the process
- just hangs indefinitely.
- For now I've just disabled them, and I'll live with the ugly error messages.
-\layout Itemize
-
-The prompt specials dictionary should be turned into a class which does
- proper namespace management, since the prompt specials need to be evaluated
- in a certain namespace.
- Currently it's just globals, which need to be managed manually by code
- below.
- 
-\layout Itemize
-
-Fix coloring of prompts: the pysh color strings don't have any effect on
- prompt numbers, b/c these are controlled by the global scheme.
- Make the prompts fully user-definable, colors and all.
- This is what I said to a user:
-\newline 
-As far as the green 
-\backslash 
-#, this is a minor bug of the coloring code due to the vagaries of history.
- While the color strings allow you to control the coloring of most elements,
- there are a few which are still controlled by the old ipython internal
- coloring code, which only accepts a global 'color scheme' choice.
- So basically the input/output numbers are hardwired to the choice in the
- color scheme, and there are only 'Linux', 'LightBG' and 'NoColor' schemes
- to choose from.
- 
-\layout Itemize
-
-Clean up FakeModule issues.
- Currently, unittesting with embedded ipython breaks because a FakeModule
- instance overwrites __main__.
- Maybe ipython should revert back to using __main__ directly as the user
- namespace? Handling a separate namespace is proving 
-\emph on 
-very
-\emph default 
- tricky in all corner cases.
-\layout Itemize
-
-Make the output cache depth independent of the input one.
- This way one can have say only the last 10 results stored and still have
- a long input history/cache.
-\layout Itemize
-
-Fix the fact that importing a shell for embedding screws up the command-line
- history.
- This can be done by not importing the history file when the shell is already
- inside ipython.
-\layout Itemize
-
-Lay out the class structure so that embedding into a gtk/wx/qt app is trivial,
- much like the multithreaded gui shells now provide command-line coexistence
- with the gui toolkits.
- See 
-\begin_inset LatexCommand \url{http://www.livejournal.com/users/glyf/32396.html}
-
-\end_inset 
-
-
-\layout Itemize
-
-Get Holger's completer in, once he adds filename completion.
-\layout Standard
-
-Lower priority stuff:
-\layout Itemize
-
-Add @showopt/@setopt (decide name) for viewing/setting all options.
- The existing option-setting magics should become aliases for setopt calls.
-\layout Itemize
-
-It would be nice to be able to continue with python stuff after an @ command.
- For instance "@run something; test_stuff()" in order to test stuff even
- faster.
- Suggestion by Kasper Souren <Kasper.Souren@ircam.fr>
-\layout Itemize
-
-Run a 'first time wizard' which configures a few things for the user, such
- as color_info, editor and the like.
-\layout Itemize
-
-Logging: @logstart and -log should start logfiles in ~.ipython, but with
- unique names in case of collisions.
- This would prevent ipython.log files all over while also allowing multiple
- sessions.
- Also the -log option should take an optional filename, instead of having
- a separate -logfile option.
-\newline 
-In general the logging system needs a serious cleanup.
- Many functions now in Magic should be moved to Logger, and the magic @s
- should be very simple wrappers to the Logger methods.
-\layout Section
-
-Lighten the code
-\layout Standard
-
-If we decide to base future versions of IPython on Python 2.3, which has
- the new Optik module (called optparse), it should be possible to drop DPyGetOpt.
- We should also remove the need for Itpl.
- Another area for trimming is the Gnuplot stuff: much of that could be merged
- into the mainline project.
-\layout Standard
-
-Double check whether we really need FlexCompleter.
- This was written as an enhanced rlcompleter, but my patches went in for
- python 2.2 (or 2.3, can't remember).
-\layout Standard
-
-With these changes we could shed a fair bit of code from the main trunk.
-\layout Section
-
-Unit testing
-\layout Standard
-
-All new code should use a testing framework.
- Python seems to have very good testing facilities, I just need to learn
- how to use them.
- I should also check out QMTest at 
-\begin_inset LatexCommand \htmlurl{http://www.codesourcery.com/qm/qmtest}
-
-\end_inset 
-
-, it sounds interesting (it's Python-based too).
-\layout Section
-
-Configuration system
-\layout Standard
-
-Move away from the current ipythonrc format to using standard python files
- for configuration.
- This will require users to be slightly more careful in their syntax, but
- reduces code in IPython, is more in line with Python's normal form (using
- the $PYTHONSTARTUP file) and allows much more flexibility.
- I also think it's more 'pythonic', in using a single language for everything.
-\layout Standard
-
-Options can be set up with a function call which takes keywords and updates
- the options Struct.
-\layout Standard
-
-In order to maintain the recursive inclusion system, write an 'include'
- function which is basically a wrapper around safe_execfile().
- Also for alias definitions an alias() function will do.
- All functionality which we want to have at startup time for the users can
- be wrapped in a small module so that config files look like:
-\layout Standard
-
-
-\family typewriter 
-from IPython.Startup import *
-\newline 
-...
-\newline 
-set_options(automagic=1,colors='NoColor',...)
-\newline 
-...
-\newline 
-include('mysetup.py')
-\newline 
-...
-\newline 
-alias('ls ls --color -l')
-\newline 
-...
- etc.
-\layout Standard
-
-Also, put 
-\series bold 
-all
-\series default 
- aliases in here, out of the core code.
-\layout Standard
-
-The new system should allow for more seamless upgrading, so that:
-\layout Itemize
-
-It automatically recognizes when the config files need updating and does
- the upgrade.
-\layout Itemize
-
-It simply adds the new options to the user's config file without overwriting
- it.
- The current system is annoying since users need to manually re-sync their
- configuration after every update.
-\layout Itemize
-
-It detects obsolete options and informs the user to remove them from his
- config file.
-\layout Standard
-
-Here's a copy of Arnd Baecker suggestions on the matter:
-\layout Standard
-
-1.) upgrade: it might be nice to have an "auto" upgrade procedure: i.e.
- imagine that IPython is installed system-wide and gets upgraded, how does
- a user know, that an upgrade of the stuff in ~/.ipython is necessary ? So
- maybe one has to a keep a version number in ~/.ipython and if there is a
- mismatch with the started ipython, then invoke the upgrade procedure.
-\layout Standard
-
-2.) upgrade: I find that replacing the old files in ~/.ipython (after copying
- them to .old not optimal (for example, after every update, I have to change
- my color settings (and some others) in ~/.ipython/ipthonrc).
- So somehow keeping the old files and merging the new features would be
- nice.
- (but how to distinguish changes from version to version with changes made
- by the user ?) For, example, I would have to change in GnuplotMagic.py gnuplot_m
-ouse to 1 after every upgrade ...
-\layout Standard
-
-This is surely a minor point - also things will change during the "BIG"
- rewrite, but maybe this is a point to keep in mind for this ?
-\layout Standard
-
-3.) upgrade: old, sometimes obsolete files stay in the ~/.ipython subdirectory.
- (hmm, maybe one could move all these into some subdirectory, but which
- name for that (via version-number ?) ?)
-\layout Subsection
-
-Command line options
-\layout Standard
-
-It would be great to design the command-line processing system so that it
- can be dynamically modified in some easy way.
- This would allow systems based on IPython to include their own command-line
- processing to either extend or fully replace IPython's.
- Probably moving to the new optparse library (also known as optik) will
- make this a lot easier.
-\layout Section
-
-OS-dependent code
-\layout Standard
-
-Options which are OS-dependent (such as colors and aliases) should be loaded
- via include files.
- That is, the general file will have:
-\layout Standard
-
-
-\family typewriter 
-if os.name == 'posix':
-\newline 
-include('ipythonrc-posix.py')
-\newline 
-elif os.name == 'nt':
-\newline 
-include('ipythonrc-nt.py')...
-\layout Standard
-
-In the 
-\family typewriter 
--posix
-\family default 
-, 
-\family typewriter 
--nt
-\family default 
-, etc.
- files we'll set all os-specific options.
-\layout Section
-
-Merging with other shell systems
-\layout Standard
-
-This is listed before the big design issues, as it is something which should
- be kept in mind when that design is made.
-\layout Standard
-
-The following shell systems are out there and I think the whole design of
- IPython should try to be modular enough to make it possible to integrate
- its features into these.
- In all cases IPython should exist as a stand-alone, terminal based program.
- But it would be great if users of these other shells (some of them which
- have very nice features of their own, especially the graphical ones) could
- keep their environment but gain IPython's features.
-\layout List
-\labelwidthstring 00.00.0000
-
-IDLE This is the standard, distributed as part of Python.
- 
-\layout List
-\labelwidthstring 00.00.0000
-
-pyrepl 
-\begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/mwh/hacks/pyrepl.html}
-
-\end_inset 
-
-.
- This is a text (curses-based) shell-like replacement which doesn't have
- some of IPython's features, but has a crucially useful (and hard to implement)
- one: full multi-line editing.
- This turns the interactive interpreter into a true code testing and development
- environment.
- 
-\layout List
-\labelwidthstring 00.00.0000
-
-PyCrust 
-\begin_inset LatexCommand \htmlurl{http://sourceforge.net/projects/pycrust}
-
-\end_inset 
-
-.
- Very nice, wxWindows based system.
-\layout List
-\labelwidthstring 00.00.0000
-
-PythonWin 
-\begin_inset LatexCommand \htmlurl{http://starship.python.net/crew/mhammond}
-
-\end_inset 
-
-.
- Similar to PyCrust in some respects, a very good and free Python development
- environment for Windows systems.
-\layout Section
-
-Class design
-\layout Standard
-
-This is the big one.
- Currently classes use each other in a very messy way, poking inside one
- another for data and methods.
- ipmaker() adds tons of stuff to the main __IP instance by hand, and the
- mix-ins used (Logger, Magic, etc) mean the final __IP instance has a million
- things in it.
- All that needs to be cleanly broken down with well defined interfaces amongst
- the different classes, and probably no mix-ins.
-\layout Standard
-
-The best approach is probably to have all the sub-systems which are currently
- mixins be fully independent classes which talk back only to the main instance
- (and 
-\series bold 
-not
-\series default 
- to each other).
- In the main instance there should be an object whose job is to handle communica
-tion with the sub-systems.
-\layout Standard
-
-I should probably learn a little UML and diagram this whole thing before
- I start coding.
-\layout Subsection
-
-Magic
-\layout Standard
-
-Now all methods which will become publicly available are called Magic.magic_name,
- the magic_ should go away.
- Then, Magic instead of being a mix-in should simply be an attribute of
- __IP:
-\layout Standard
-
-__IP.Magic = Magic()
-\layout Standard
-
-This will then give all the magic functions as __IP.Magic.name(), which is
- much cleaner.
- This will also force a better separation so that Magic doesn't poke inside
- __IP so much.
- In the constructor, Magic should get whatever information it needs to know
- about __IP (even if it means a pointer to __IP itself, but at least we'll
- know where it is.
- Right now since it's a mix-in, there's no way to know which variables belong
- to whom).
-\layout Standard
-
-Build a class MagicFunction so that adding new functions is a matter of:
-\layout Standard
-
-
-\family typewriter 
-my_magic = MagicFunction(category = 'System utilities')
-\newline 
-my_magic.__call__ = ...
-\layout Standard
-
-Features:
-\layout Itemize
-
-The class constructor should automatically register the functions and keep
- a table with category sections for easy sorting/viewing.
-\layout Itemize
-
-The object interface must allow automatic building of a GUI for them.
- This requires registering the options the command takes, the number of
- arguments, etc, in a formal way.
- The advantage of this approach is that it allows not only to add GUIs to
- the magics, but also for a much more intelligent building of docstrings,
- and better parsing of options and arguments.
-\layout Standard
-
-Also think through better an alias system for magics.
- Since the magic system is like a command shell inside ipython, the relation
- between these aliases and system aliases should be cleanly thought out.
-\layout Subsection
-
-Color schemes
-\layout Standard
-
-These should be loaded from some kind of resource file so they are easier
- to modify by the user.
-\layout Section
-
-Hooks
-\layout Standard
-
-IPython should have a modular system where functions can register themselves
- for certain tasks.
- Currently changing functionality requires overriding certain specific methods,
- there should be a clean API for this to be done.
-\layout Subsection
-
-whos hook
-\layout Standard
-
-This was a very nice suggestion from Alexander Schmolck <a.schmolck@gmx.net>:
-\layout Standard
-
-2.
- I think it would also be very helpful if there where some sort of hook
- for ``whos`` that let one customize display formaters depending on the
- object type.
-\layout Standard
-
-For example I'd rather have a whos that formats an array like:
-\layout Standard
-
-
-\family typewriter 
-Variable Type Data/Length
-\newline 
------------------------------- 
-\newline 
-a array size: 4x3 type: 'Float'
-\layout Standard
-
-than
-\layout Standard
-
-
-\family typewriter 
-Variable Type Data/Length 
-\newline 
-------------------------------
-\newline 
-a array [[ 0.
- 1.
- 2.
- 3<...> 8.
- 9.
- 10.
- 11.]]
-\layout Section
-
-Parallel support
-\layout Standard
-
-For integration with graphical shells and other systems, it will be best
- if ipython is split into a kernel/client model, much like Mathematica works.
- This simultaneously opens the door for support of interactive parallel
- computing.
- Currenlty %bg provides a threads-based proof of concept, and Brian Granger's
- XGrid project is a much more realistic such system.
- The new design should integrates ideas as core elements.
- Some notes from Brian on this topic:
-\layout Standard
-
-1.
- How should the remote python server/kernel be designed? Multithreaded?
- Blocking? Connected/disconnected modes? Load balancing?
-\layout Standard
-
-2.
- What APi/protocol should the server/kernel expose to clients?
-\layout Standard
-
-3.
- How should the client classes (which the user uses to interact with the
- cluster) be designed?
-\layout Standard
-
-4.
- What API should the client classes expose?
-\layout Standard
-
-5.
- How should the client API be wrapped in a few simple magic functions?
-\layout Standard
-
-6.
- How should security be handled?
-\layout Standard
-
-7.
- How to work around the issues of the GIL and threads?
-\layout Standard
-
-I think the most important things to work out are the client API (#4) the
- server/kernel API/protocol (#2) and the magic function API (#5).
- We should let these determine the design and architecture of the components.
-\layout Standard
-
-One other thing.
- What is your impression of twisted? I have been looking at it and it looks
- like a _very_ powerful set of tools for this type of stuff.
- I am wondering if it might make sense to think about using twisted for
- this project.
-\layout Section
-
-Manuals
-\layout Standard
-
-The documentation should be generated from docstrings for the command line
- args and all the magic commands.
- Look into one of the simple text markup systems to see if we can get latex
- (for reLyXing later) out of this.
- Part of the build command would then be to make an update of the docs based
- on this, thus giving more complete manual (and guaranteed to be in sync
- with the code docstrings).
-\layout Standard
-
-[PARTLY DONE] At least now all magics are auto-documented, works farily
- well.
- Limited Latex formatting yet.
-\layout Subsection
-
-Integration with pydoc-help
-\layout Standard
-
-It should be possible to have access to the manual via the pydoc help system
- somehow.
- This might require subclassing the pydoc help, or figuring out how to add
- the IPython docs in the right form so that help() finds them.
-\layout Standard
-
-Some comments from Arnd and my reply on this topic:
-\layout Standard
-
-> ((Generally I would like to have the nice documentation > more easily
- accessable from within ipython ...
- > Many people just don't read documentation, even if it is > as good as
- the one of IPython ))
-\layout Standard
-
-That's an excellent point.
- I've added a note to this effect in new_design.
- Basically I'd like help() to naturally access the IPython docs.
- Since they are already there in html for the user, it's probably a matter
- of playing a bit with pydoc to tell it where to find them.
- It would definitely make for a much cleaner system.
- Right now the information on IPython is:
-\layout Standard
-
--ipython --help at the command line: info on command line switches 
-\layout Standard
-
--? at the ipython prompt: overview of IPython 
-\layout Standard
-
--magic at the ipython prompt: overview of the magic system 
-\layout Standard
-
--external docs (html/pdf)
-\layout Standard
-
-All that should be better integrated seamlessly in the help() system, so
- that you can simply say:
-\layout Standard
-
-help ipython -> full documentation access 
-\layout Standard
-
-help magic -> magic overview 
-\layout Standard
-
-help profile -> help on current profile 
-\layout Standard
-
-help -> normal python help access.
-\layout Section
-
-Graphical object browsers
-\layout Standard
-
-I'd like a system for graphically browsing through objects.
- 
-\family typewriter 
-@obrowse
-\family default 
- should open a widged with all the things which 
-\family typewriter 
-@who
-\family default 
- lists, but cliking on each object would open a dedicated object viewer
- (also accessible as 
-\family typewriter 
-@oview <object>
-\family default 
-).
- This object viewer could show a summary of what 
-\family typewriter 
-<object>?
-\family default 
- currently shows, but also colorize source code and show it via an html
- browser, show all attributes and methods of a given object (themselves
- openable in their own viewers, since in Python everything is an object),
- links to the parent classes, etc.
-\layout Standard
-
-The object viewer widget should be extensible, so that one can add methods
- to view certain types of objects in a special way (for example, plotting
- Numeric arrays via grace or gnuplot).
- This would be very useful when using IPython as part of an interactive
- complex system for working with certain types of data.
-\layout Standard
-
-I should look at what PyCrust has to offer along these lines, at least as
- a starting point.
-\layout Section
-
-Miscellaneous small things
-\layout Itemize
-
-Collect whatever variables matter from the environment in some globals for
- __IP, so we're not testing for them constantly (like $HOME, $TERM, etc.)
-\layout Section
-
-Session restoring
-\layout Standard
-
-I've convinced myself that session restore by log replay is too fragile
- and tricky to ever work reliably.
- Plus it can be dog slow.
- I'd rather have a way of saving/restoring the *current* memory state of
- IPython.
- I tried with pickle but failed (can't pickle modules).
- This seems the right way to do it to me, but it will have to wait until
- someone tells me of a robust way of dumping/reloading *all* of the user
- namespace in a file.
-\layout Standard
-
-Probably the best approach will be to pickle as much as possible and record
- what can not be pickled for manual reload (such as modules).
- This is not trivial to get to work reliably, so it's best left for after
- the code restructuring.
-\layout Standard
-
-The following issues exist (old notes, see above paragraph for my current
- take on the issue):
-\layout Itemize
-
-magic lines aren't properly re-executed when a log file is reloaded (and
- some of them, like clear or run, may change the environment).
- So session restore isn't 100% perfect.
-\layout Itemize
-
-auto-quote/parens lines aren't replayed either.
- All this could be done, but it needs some work.
- Basically it requires re-running the log through IPython itself, not through
- python.
-\layout Itemize
-
-_p variables aren't restored with a session.
- Fix: same as above.
-\layout Section
-
-Tips system
-\layout Standard
-
-It would be nice to have a tip() function which gives tips to users in some
- situations, but keeps track of already-given tips so they aren't given
- every time.
- This could be done by pickling a dict of given tips to IPYTHONDIR.
-\layout Section
-
-TAB completer
-\layout Standard
-
-Some suggestions from Arnd Baecker:
-\layout Standard
-
-a) For file related commands (ls, cat, ...) it would be nice to be able to
- TAB complete the files in the current directory.
- (once you started typing something which is uniquely a file, this leads
- to this effect, apart from going through the list of possible completions
- ...).
- (I know that this point is in your documentation.)
-\layout Standard
-
-More general, this might lead to something like command specific completion
- ? 
-\layout Standard
-
-Here's John Hunter's suggestion:
-\layout Standard
-
-The *right way to do it* would be to make intelligent or customizable choices
- about which namespace to add to the completion list depending on the string
- match up to the prompt, eg programmed completions.
- In the simplest implementation, one would only complete on files and directorie
-s if the line preceding the tab press matched 'cd ' or 'run ' (eg you don't
- want callable showing up in 'cd ca<TAB>')
-\layout Standard
-
-In a more advanced scenario, you might imaging that functions supplied the
- TAB namespace, and the user could configure a dictionary that mapped regular
- expressions to namespace providing functions (with sensible defaults).
- Something like
-\layout Standard
-
-completed = {
-\newline 
-'^cd
-\backslash 
-s+(.*)' : complete_files_and_dirs,
-\newline 
-'^run
-\backslash 
-s+(.*)' : complete_files_and_dirs,
-\newline 
-'^run
-\backslash 
-s+(-.*)' : complete_run_options,
-\newline 
-}
-\layout Standard
-
-I don't know if this is feasible, but I really like programmed completions,
- which I use extensively in tcsh.
- My feeling is that something like this is eminently doable in ipython.
-\layout Standard
-
-/JDH
-\layout Standard
-
-For something like this to work cleanly, the magic command system needs
- also a clean options framework, so all valid options for a given magic
- can be extracted programatically.
-\layout Section
-
-Debugger
-\layout Standard
-
-Current system uses a minimally tweaked pdb.
- Fine-tune it a bit, to provide at least:
-\layout Itemize
-
-Tab-completion in each stack frame.
- See email to Chris Hart for details.
-\layout Itemize
-
-Object information via ? at least.
- Break up magic_oinfo a bit so that pdb can call it without loading all
- of IPython.
- If possible, also have the other magics for object study: doc, source,
- pdef and pfile.
-\layout Itemize
-
-Shell access via !
-\layout Itemize
-
-Syntax highlighting in listings.
- Use py2html code, implement color schemes.
-\layout Section
-
-A Python-based system shell - pysh?
-\layout Standard
-
-Note: as of IPython 0.6.1, most of this functionality has actually been implemente
-d.
-\layout Standard
-
-This section is meant as a working draft for discussions on the possibility
- of having a python-based system shell.
- It is the result of my own thinking about these issues as much of discussions
- on the ipython lists.
- I apologize in advance for not giving individual credit to the various
- contributions, but right now I don't have the time to track down each message
- from the archives.
- So please consider this as the result of a collective effort by the ipython
- user community.
-\layout Standard
-
-While IPyhton is (and will remain) a python shell first, it does offer a
- fair amount of system access functionality:
-\layout Standard
-
-- ! and !! for direct system access,
-\layout Standard
-
-- magic commands which wrap various system commands,
-\layout Standard
-
-- @sc and @sx, for shell output capture into python variables,
-\layout Standard
-
-- @alias, for aliasing system commands.
-\layout Standard
-
-This has prompted many users, over time, to ask for a way of extending ipython
- to the point where it could be used as a full-time replacement over typical
- user shells like bash, csh or tcsh.
- While my interest in ipython is such that I'll concentrate my personal
- efforts on other fronts (debugging, architecture, improvements for scientific
- use, gui access), I will be happy to do anything which could make such
- a development possible.
- It would be the responsibility of someone else to maintain the code, but
- I would do all necessary architectural changes to ipython for such an extension
- to be feasible.
-\layout Standard
-
-I'll try to outline here what I see as the key issues which need to be taken
- into account.
- This document should be considered an evolving draft.
- Feel free to submit comments/improvements, even in the form of patches.
-\layout Standard
-
-In what follows, I'll represent the hypothetical python-based shell ('pysh'
- for now) prompt with '>>'.
-\layout Subsection
-
-Basic design principles
-\layout Standard
-
-I think the basic design guideline should be the following: a hypothetical
- python system shell should behave, as much as possible, like a normal shell
- that users are familiar with (bash, tcsh, etc).
- This means:
-\layout Standard
-
-1.
- System commands can be issued directly at the prompt with no special syntax:
-\layout Standard
-
->> ls
-\layout Standard
-
->> xemacs
-\layout Standard
-
-should just work like a user expects.
-\layout Standard
-
-2.
- The facilities of the python language should always be available, like
- they are in ipython:
-\layout Standard
-
->> 3+4 
-\newline 
-7
-\layout Standard
-
-3.
- It should be possible to easily capture shell output into a variable.
- bash and friends use backquotes, I think using a command (@sc) like ipython
- currently does is an acceptable compromise.
-\layout Standard
-
-4.
- It should also be possible to expand python variables/commands in the middle
- of system commands.
- I thihk this will make it necessary to use $var for name expansions:
-\layout Standard
-
->> var='hello' # var is a Python variable 
-\newline 
->> print var hello # This is the result of a Python print command 
-\newline 
->> echo $var hello # This calls the echo command, expanding 'var'.
-\layout Standard
-
-5.
- The above capabilities should remain possible for multi-line commands.
- One of the most annoying things I find about tcsh, is that I never quite
- remember the syntactic details of looping.
- I often want to do something at the shell which involves a simple loop,
- but I can never remember how to do it in tcsh.
- This often means I just write a quick throwaway python script to do it
- (Perl is great for this kind of quick things, but I've forgotten most its
- syntax as well).
-\layout Standard
-
-It should be possible to write code like:
-\layout Standard
-
->> for ext in ['.jpg','.gif']: 
-\newline 
-..
- ls file$ext
-\layout Standard
-
-And have it work as 'ls file.jpg;ls file.gif'.
-\layout Subsection
-
-Smaller details 
-\layout Standard
-
-If the above are considered as valid guiding principles for how such a python
- system shell should behave, then some smaller considerations and comments
- to keep in mind are listed below.
-\layout Standard
-
-- it's ok for shell builtins (in this case this includes the python language)
- to override system commands on the path.
- See tcsh's 'time' vs '/usr/bin/time'.
- This settles the 'print' issue and related.
-\layout Standard
-
-- pysh should take
-\layout Standard
-
-foo args
-\layout Standard
-
-as a command if (foo args is NOT valid python) and (foo is in $PATH).
-\layout Standard
-
-If the user types
-\layout Standard
-
->> ./foo args
-\layout Standard
-
-it should be considered a system command always.
-\layout Standard
-
-- _, __ and ___ should automatically remember the previous 3 outputs captured
- from stdout.
- In parallel, there should be _e, __e and ___e for stderr.
- Whether capture is done as a single string or in list mode should be a
- user preference.
- If users have numbered prompts, ipython's full In/Out cache system should
- be available.
-\layout Standard
-
-But regardless of how variables are captured, the printout should be like
- that of a plain shell (without quotes or braces to indicate strings/lists).
- The everyday 'feel' of pysh should be more that of bash/tcsh than that
- of ipython.
-\layout Standard
-
-- filename completion first.
- Tab completion could work like in ipython, but with the order of priorities
- reversed: first files, then python names.
-\layout Standard
-
-- configuration via standard python files.
- Instead of 'setenv' you'd simply write into the os.environ[] dictionary.
- This assumes that IPython itself has been fixed to be configured via normal
- python files, instead of the current clunky ipythonrc format.
-\layout Standard
-
-- IPython can already configure the prompt in fairly generic ways.
- It should be able to generate almost any kind of prompt which bash/tcsh
- can (within reason).
-\layout Standard
-
-- Keep the Magics system.
- They provide a lightweight syntax for configuring and modifying the state
- of the user's session itself.
- Plus, they are an extensible system so why not give the users one more
- tool which is fairly flexible by nature? Finally, having the @magic optional
- syntax allows a user to always be able to access the shell's control system,
- regardless of name collisions with defined variables or system commands.
-\layout Standard
-
-But we need to move all magic functionality into a protected namespace,
- instead of the current messy name-mangling tricks (which don't scale well).
- 
-\layout Section
-
-Future improvements
-\layout Itemize
-
-When from <mod> import * is used, first check the existing namespace and
- at least issue a warning on screen if names are overwritten.
-\layout Itemize
-
-Auto indent? Done, for users with readline support.
-\layout Subsection
-
-Better completion a la zsh
-\layout Standard
-
-This was suggested by Arnd:
-\layout Standard
-
-> >\SpecialChar ~
-\SpecialChar ~
-\SpecialChar ~
- More general, this might lead to something like
-\layout Standard
-
-> >\SpecialChar ~
-\SpecialChar ~
-\SpecialChar ~
- command specific completion ?
-\layout Standard
-
->
-\layout Standard
-
-> I'm not sure what you mean here.
-\layout Standard
-
-\SpecialChar ~
-
-\layout Standard
-
-Sorry, that was not understandable, indeed ...
-\layout Standard
-
-I thought of something like
-\layout Standard
-
-\SpecialChar ~
-- cd and then use TAB to go through the list of directories
-\layout Standard
-
-\SpecialChar ~
-- ls and then TAB to consider all files and directories
-\layout Standard
-
-\SpecialChar ~
-- cat and TAB: only files (no directories ...)
-\layout Standard
-
-\SpecialChar ~
-
-\layout Standard
-
-For zsh things like this are established by defining in .zshrc
-\layout Standard
-
-\SpecialChar ~
-
-\layout Standard
-
-compctl -g '*.dvi' xdvi
-\layout Standard
-
-compctl -g '*.dvi' dvips
-\layout Standard
-
-compctl -g '*.tex' latex
-\layout Standard
-
-compctl -g '*.tex' tex
-\layout Standard
-
-...
-\layout Section
-
-Outline of steps
-\layout Standard
-
-Here's a rough outline of the order in which to start implementing the various
- parts of the redesign.
- The first 'test of success' should be a clean pychecker run (not the mess
- we get right now).
-\layout Itemize
-
-Make Logger and Magic not be mixins but attributes of the main class.
- 
-\begin_deeper 
-\layout Itemize
-
-Magic should have a pointer back to the main instance (even if this creates
- a recursive structure) so it can control it with minimal message-passing
- machinery.
- 
-\layout Itemize
-
-Logger can be a standalone object, simply with a nice, clean interface.
-\layout Itemize
-
-Logger currently handles part of the prompt caching, but other parts of
- that are in the prompts class itself.
- Clean up.
-\end_deeper 
-\layout Itemize
-
-Change to python-based config system.
-\layout Itemize
-
-Move make_IPython() into the main shell class, as part of the constructor.
- Do this 
-\emph on 
-after 
-\emph default 
-the config system has been changed, debugging will be a lot easier then.
-\layout Itemize
-
-Merge the embeddable class and the normal one into one.
- After all, the standard ipython script 
-\emph on 
-is
-\emph default 
- a python program with IPython embedded in it.
- There's no need for two separate classes (
-\emph on 
-maybe
-\emph default 
- keep the old one around for the sake of backwards compatibility).
-\layout Section
-
-Ville Vainio's suggestions
-\layout Standard
-
-Some notes sent in by Ville Vainio 
-\family typewriter 
-<vivainio@kolumbus.fi>
-\family default 
- on Tue, 29 Jun 2004.
- Keep here for reference, some of it replicates things already said above.
-\layout Standard
-
-Current ipython seems to "special case" lots of stuff - aliases, magics
- etc.
- It would seem to yield itself to a simpler and more extensible architecture,
- consisting of multple dictionaries, where just the order of search is determine
-d by profile/prefix.
- All the functionality would just be "pushed" to ipython core, i.e.
- the objects that represent the functionality are instantiated on "plugins"
- and they are registered with ipython core.
- i.e.
-\layout Standard
-
-def magic_f(options, args): pass
-\layout Standard
-
-m = MyMagic(magic_f) m.arghandler = stockhandlers.OptParseArgHandler m.options
- = ....
- # optparse options, for easy passing to magic_f and help display
-\layout Standard
-
-# note that arghandler takes a peek at the instance, sees options, and proceeds
- # accordingly.
- Various arg handlers can ask for arbitrary options.
- # some handler might optionally glob the filenames, search data folders
- for filenames etc.
-\layout Standard
-
-ipythonregistry.register(category = "magic", name = "mymagic", obj = m)
-\layout Standard
-
-I bet most of the current functionality could easily be added to such a
- registry by just instantiating e.g.
- "Magic" class and registering all the functions with some sensible default
- args.
- Supporting legacy stuff in general would be easy - just implement new handlers
- (arg and otherwise) for new stuff, and have the old handlers around forever
- / as long as is deemed appropriate.
- The 'python' namespace (locals() + globals()) should be special, of course.
-\layout Standard
-
-It should be easy to have arbitrary number of "categories" (like 'magic',
- 'shellcommand','projectspecific_myproject', 'projectspecific_otherproject').
- It would only influence the order in which the completions are suggested,
- and in case of name collision which one is selected.
- Also, I think all completions should be shown, even the ones in "later"
- categories in the case of a match in an "earlier" category.
-\layout Standard
-
-The "functionality object" might also have a callable object 'expandarg',
- and ipython would run it (with the arg index) when tab completion is attempted
- after typing the function name.
- It would return the possible completions for that particular command...
- or None to "revert to default file completions".
- Such functionality could be useful in making ipython an "operating console"
- of a sort.
- I'm talking about:
-\layout Standard
-
->> lscat reactor # list commands in category - reactor is "project specific"
- category
-\layout Standard
-
-r_operate
-\layout Standard
-
->> r_operate <tab> start shutdown notify_meltdown evacuate
-\layout Standard
-
->> r_operate shutdown <tab>
-\layout Standard
-
-1 2 5 6 # note that 3 and 4 are already shut down
-\layout Standard
-
->> r_operate shutdown 2
-\layout Standard
-
-Shutting down..
- ok.
-\layout Standard
-
->> r_operate start <tab>
-\layout Standard
-
-2 3 4 # 2 was shut down, can be started now
-\layout Standard
-
->> r_operate start 2
-\layout Standard
-
-Starting....
- ok.
-\layout Standard
-
-I'm talking about having a super-configurable man-machine language here!
- Like cmd.Cmd on steroids, as a free addition to ipython!
-\the_end
diff --git a/docs/autogen_api.py b/docs/autogen_api.py
index 7b5842f12d3..9263fa3d8ba 100755
--- a/docs/autogen_api.py
+++ b/docs/autogen_api.py
@@ -1,79 +1,69 @@
 #!/usr/bin/env python
 """Script to auto-generate our API docs.
 """
-# stdlib imports
+
 import os
 import sys
 
-# local imports
-sys.path.append(os.path.abspath('sphinxext'))
+pjoin = os.path.join
+
+here = os.path.abspath(os.path.dirname(__file__))
+sys.path.append(pjoin(os.path.abspath(here), 'sphinxext'))
+
 from apigen import ApiDocWriter
 
+source = pjoin(here, 'source')
+
 #*****************************************************************************
 if __name__ == '__main__':
-    pjoin = os.path.join
     package = 'IPython'
-    outdir = pjoin('source','api','generated')
-    docwriter = ApiDocWriter(package,rst_extension='.txt')
+    outdir = pjoin(source, 'api', 'generated')
+    docwriter = ApiDocWriter(package,rst_extension='.rst')
     # You have to escape the . here because . is a special char for regexps.
     # You must do make clean if you change this!
-    docwriter.package_skip_patterns += [r'\.fixes$',
-                                        r'\.external$',
+    docwriter.package_skip_patterns += [r'\.external$',
+                                        # Extensions are documented elsewhere.
                                         r'\.extensions',
-                                        r'\.kernel\.config',
-                                        r'\.attic',
-                                        r'\.quarantine',
-                                        r'\.deathrow',
-                                        r'\.config\.default',
-                                        r'\.config\.profile',
-                                        r'\.frontend',
-                                        r'\.gui',
-                                        # For now, the zmq code has
-                                        # unconditional top-level code so it's
-                                        # not import safe.  This needs fixing
-                                        # soon.
-                                        r'\.zmq',
+                                        # This isn't API
+                                        r'\.sphinxext',
+                                        # Shims
+                                        r'\.kernel',
+                                        r'\.terminal\.pt_inputhooks',
                                         ]
 
-    docwriter.module_skip_patterns += [ r'\.core\.fakemodule',
-                                        
-                                        # XXX These need fixing, disabling for
-                                        # now but we need to figure out why
-                                        # they are breaking.  Error from sphinx
-                                        # for each group copied below
-                                        
-                                        # AttributeError: __abstractmethods__
-                                        r'\.config\.configurable',
-                                        r'\.utils\.traitlets',
-        
-                                        # AttributeError: __provides__
-                                        r'\.kernel\.clusterdir',
-                                        r'\.kernel\.configobjfactory',
-                                        r'\.kernel\.fcutil',
-                                        r'\.kernel\.ipcontrollerapp',
-                                        r'\.kernel\.launcher',
-                                        r'\.kernel\.task',
-                                        r'\.kernel\.winhpcjob',
-                                        r'\.testing\.util',
-    
-                                        # Keeping these disabled is OK
-                                        r'\.cocoa',
-                                        r'\.ipdoctest',
-                                        r'\.Gnuplot',
-                                        r'\.frontend\.process\.winprocess',
-                                        r'\.Shell',
-                                        ]
-    
-    # If we don't have pexpect, we can't load irunner, so skip any code that
-    # depends on it
-    try:
-        import pexpect
-    except ImportError:
-        docwriter.module_skip_patterns += [r'\.lib\.irunner',
-                                           r'\.testing\.mkdoctests']
+    # The inputhook* modules often cause problems on import, such as trying to
+    # load incompatible Qt bindings. It's easiest to leave them all out. The
+    docwriter.module_skip_patterns += [
+        r"\.lib\.inputhook.+",
+        r"\.ipdoctest",
+        r"\.testing\.plugin",
+        # We document this manually.
+        r"\.utils\.py3compat",
+        # These are exposed in display
+        r"\.core\.display",
+        r"\.lib\.display",
+        r"\.utils\.version",
+        # Private APIs (there should be a lot more here)
+        r"\.terminal\.ptutils",
+    ]
+    # main API is in the inputhook module, which is documented.
+
+    # These modules import functions and classes from other places to expose
+    # them as part of the public API. They must have __all__ defined. The
+    # non-API modules they import from should be excluded by the skip patterns
+    # above.
+    docwriter.names_from__all__.update(
+        {
+            "IPython",
+            "IPython.display",
+        }
+    )
+
     # Now, generate the outputs
     docwriter.write_api_docs(outdir)
-    docwriter.write_index(outdir, 'gen',
-                          relative_to = pjoin('source','api')
+    # Write index with .txt extension - we can include it, but Sphinx won't try
+    # to compile it
+    docwriter.write_index(outdir, 'gen.txt',
+                          relative_to = pjoin(source, 'api')
                           )
-    print '%d files written' % len(docwriter.written_modules)
+    print ('%d files written' % len(docwriter.written_modules))
diff --git a/docs/autogen_config.py b/docs/autogen_config.py
new file mode 100755
index 00000000000..6d82aca52bf
--- /dev/null
+++ b/docs/autogen_config.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+
+import inspect
+from pathlib import Path
+from IPython.terminal.ipapp import TerminalIPythonApp
+from traitlets import Undefined
+from collections import defaultdict
+
+here = (Path(__file__)).parent
+options = here / "source" / "config" / "options"
+generated = options / "config-generated.txt"
+
+import textwrap
+indent = lambda text,n: textwrap.indent(text,n*' ')
+
+
+def interesting_default_value(dv):
+    if (dv is None) or (dv is Undefined):
+        return False
+    if isinstance(dv, (str, list, tuple, dict, set)):
+        return bool(dv)
+    return True
+
+def format_aliases(aliases):
+    fmted = []
+    for a in aliases:
+        dashes = '-' if len(a) == 1 else '--'
+        fmted.append('``%s%s``' % (dashes, a))
+    return ', '.join(fmted)
+
+def class_config_rst_doc(cls, trait_aliases):
+    """Generate rST documentation for this class' config options.
+
+    Excludes traits defined on parent classes.
+    """
+    lines = []
+    classname = cls.__name__
+    for k, trait in sorted(cls.class_traits(config=True).items()):
+        ttype = trait.__class__.__name__
+
+        fullname = classname + '.' + trait.name
+        lines += ['.. configtrait:: ' + fullname,
+                  ''
+                 ]
+
+        help = trait.help.rstrip() or 'No description'
+        lines.append(indent(inspect.cleandoc(help), 4) + '\n')
+
+        # Choices or type
+        if 'Enum' in ttype:
+            # include Enum choices
+            lines.append(indent(
+                ':options: ' + ', '.join('``%r``' % x for x in trait.values), 4))
+        else:
+            lines.append(indent(':trait type: ' + ttype, 4))
+
+        # Default value
+        # Ignore boring default values like None, [] or ''
+        if interesting_default_value(trait.default_value):
+            try:
+                dvr = trait.default_value_repr()
+            except Exception:
+                dvr = None  # ignore defaults we can't construct
+            if dvr is not None:
+                if len(dvr) > 64:
+                    dvr = dvr[:61] + '...'
+                # Double up backslashes, so they get to the rendered docs
+                dvr = dvr.replace('\\n', '\\\\n')
+                lines.append(indent(':default: ``%s``' % dvr, 4))
+
+        # Command line aliases
+        if trait_aliases[fullname]:
+            fmt_aliases = format_aliases(trait_aliases[fullname])
+            lines.append(indent(':CLI option: ' + fmt_aliases, 4))
+
+        # Blank line
+        lines.append('')
+
+    return '\n'.join(lines)
+
+def reverse_aliases(app):
+    """Produce a mapping of trait names to lists of command line aliases.
+    """
+    res = defaultdict(list)
+    for alias, trait in app.aliases.items():
+        res[trait].append(alias)
+
+    # Flags also often act as aliases for a boolean trait.
+    # Treat flags which set one trait to True as aliases.
+    for flag, (cfg, _) in app.flags.items():
+        if len(cfg) == 1:
+            classname = list(cfg)[0]
+            cls_cfg = cfg[classname]
+            if len(cls_cfg) == 1:
+                traitname = list(cls_cfg)[0]
+                if cls_cfg[traitname] is True:
+                    res[classname+'.'+traitname].append(flag)
+
+    return res
+
+def write_doc(name, title, app, preamble=None):
+    trait_aliases = reverse_aliases(app)
+    filename = options / (name + ".rst")
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write("\n")
+        if preamble is not None:
+            f.write(preamble + '\n\n')
+
+        for c in app._classes_inc_parents():
+            f.write(class_config_rst_doc(c, trait_aliases))
+            f.write('\n')
+
+
+if __name__ == '__main__':
+    # Touch this file for the make target
+    Path(generated).write_text("", encoding="utf-8")
+
+    write_doc('terminal', 'Terminal IPython options', TerminalIPythonApp())
diff --git a/docs/autogen_magics.py b/docs/autogen_magics.py
new file mode 100644
index 00000000000..6102d0950c6
--- /dev/null
+++ b/docs/autogen_magics.py
@@ -0,0 +1,66 @@
+from pathlib import Path
+from IPython.core.alias import Alias
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.magic import MagicAlias
+from IPython.utils.text import dedent, indent
+
+shell = InteractiveShell.instance()
+magics = shell.magics_manager.magics
+
+def _strip_underline(line):
+    chars = set(line.strip())
+    if len(chars) == 1 and ("-" in chars or "=" in chars):
+        return ""
+    else:
+        return line
+
+def format_docstring(func):
+    docstring = (func.__doc__ or "Undocumented").rstrip()
+    docstring = indent(dedent(docstring))
+    # Sphinx complains if indented bits have rst headings in, so strip out
+    # any underlines in the docstring.
+    lines = [_strip_underline(l) for l in docstring.splitlines()]
+    return "\n".join(lines)
+
+output = [
+"Line magics",
+"===========",
+"",
+]
+
+# Case insensitive sort by name
+def sortkey(s): return s[0].lower()
+
+for name, func in sorted(magics["line"].items(), key=sortkey):
+    if isinstance(func, Alias) or isinstance(func, MagicAlias):
+        # Aliases are magics, but shouldn't be documented here
+        # Also skip aliases to other magics
+        continue
+    output.extend([".. magic:: {}".format(name),
+                   "",
+                   format_docstring(func),
+                   ""])
+
+output.extend([
+"Cell magics",
+"===========",
+"",
+])
+
+for name, func in sorted(magics["cell"].items(), key=sortkey):
+    if name == "!":
+        # Special case - don't encourage people to use %%!
+        continue
+    if func == magics["line"].get(name, "QQQP"):
+        # Don't redocument line magics that double as cell magics
+        continue
+    if isinstance(func, MagicAlias):
+        continue
+    output.extend([".. cellmagic:: {}".format(name),
+                   "",
+                   format_docstring(func),
+                   ""])
+
+src_path = Path(__file__).parent
+dest = src_path.joinpath("source", "interactive", "magics-generated.txt")
+dest.write_text("\n".join(output), encoding="utf-8")
diff --git a/docs/autogen_shortcuts.py b/docs/autogen_shortcuts.py
new file mode 100755
index 00000000000..f0569c17509
--- /dev/null
+++ b/docs/autogen_shortcuts.py
@@ -0,0 +1,223 @@
+from dataclasses import dataclass
+from inspect import getsource
+from pathlib import Path
+from typing import cast, List, Union
+from html import escape as html_escape
+import re
+
+from prompt_toolkit.keys import KEY_ALIASES
+from prompt_toolkit.key_binding import KeyBindingsBase
+from prompt_toolkit.filters import Filter, Condition
+from prompt_toolkit.shortcuts import PromptSession
+
+from IPython.terminal.shortcuts import create_ipython_shortcuts, create_identifier
+from IPython.terminal.shortcuts.filters import KEYBINDING_FILTERS
+
+
+@dataclass
+class Shortcut:
+    #: a sequence of keys (each element on the list corresponds to pressing one or more keys)
+    keys_sequence: List[str]
+    filter: str
+
+
+@dataclass
+class Handler:
+    description: str
+    identifier: str
+
+
+@dataclass
+class Binding:
+    handler: Handler
+    shortcut: Shortcut
+
+
+class _NestedFilter(Filter):
+    """Protocol reflecting non-public prompt_toolkit's `_AndList` and `_OrList`."""
+
+    filters: List[Filter]
+
+
+class _Invert(Filter):
+    """Protocol reflecting non-public prompt_toolkit's `_Invert`."""
+
+    filter: Filter
+
+
+conjunctions_labels = {"_AndList": "&", "_OrList": "|"}
+
+ATOMIC_CLASSES = {"Never", "Always", "Condition"}
+
+
+HUMAN_NAMES_FOR_FILTERS = {
+    filter_: name for name, filter_ in KEYBINDING_FILTERS.items()
+}
+
+
+def format_filter(
+    filter_: Union[Filter, _NestedFilter, Condition, _Invert],
+    is_top_level=True,
+    skip=None,
+) -> str:
+    """Create easily readable description of the filter."""
+    s = filter_.__class__.__name__
+    if s == "Condition":
+        func = cast(Condition, filter_).func
+        if filter_ in HUMAN_NAMES_FOR_FILTERS:
+            return HUMAN_NAMES_FOR_FILTERS[filter_]
+        name = func.__name__
+        if name == "<lambda>":
+            source = getsource(func)
+            return source.split("=")[0].strip()
+        return func.__name__
+    elif s == "_Invert":
+        operand = cast(_Invert, filter_).filter
+        if operand.__class__.__name__ in ATOMIC_CLASSES:
+            return f"~{format_filter(operand, is_top_level=False)}"
+        return f"~({format_filter(operand, is_top_level=False)})"
+    elif s in conjunctions_labels:
+        filters = cast(_NestedFilter, filter_).filters
+        if filter_ in HUMAN_NAMES_FOR_FILTERS:
+            return HUMAN_NAMES_FOR_FILTERS[filter_]
+        conjunction = conjunctions_labels[s]
+        glue = f" {conjunction} "
+        result = glue.join(format_filter(x, is_top_level=False) for x in filters)
+        if len(filters) > 1 and not is_top_level:
+            result = f"({result})"
+        return result
+    elif s in ["Never", "Always"]:
+        return s.lower()
+    elif s == "PassThrough":
+        return "pass_through"
+    else:
+        raise ValueError(f"Unknown filter type: {filter_}")
+
+
+def sentencize(s) -> str:
+    """Extract first sentence"""
+    s = re.split(r"\.\W", s.replace("\n", " ").strip())
+    s = s[0] if len(s) else ""
+    if not s.endswith("."):
+        s += "."
+    try:
+        return " ".join(s.split())
+    except AttributeError:
+        return s
+
+
+class _DummyTerminal:
+    """Used as a buffer to get prompt_toolkit bindings"""
+
+    handle_return = None
+    input_transformer_manager = None
+    display_completions = None
+    editing_mode = "emacs"
+    auto_suggest = None
+
+
+def bindings_from_prompt_toolkit(prompt_bindings: KeyBindingsBase) -> List[Binding]:
+    """Collect bindings to a simple format that does not depend on prompt-toolkit internals"""
+    bindings: List[Binding] = []
+
+    for kb in prompt_bindings.bindings:
+        bindings.append(
+            Binding(
+                handler=Handler(
+                    description=kb.handler.__doc__ or "",
+                    identifier=create_identifier(kb.handler),
+                ),
+                shortcut=Shortcut(
+                    keys_sequence=[
+                        str(k.value) if hasattr(k, "value") else k for k in kb.keys
+                    ],
+                    filter=format_filter(kb.filter, skip={"has_focus_filter"}),
+                ),
+            )
+        )
+    return bindings
+
+
+INDISTINGUISHABLE_KEYS = {**KEY_ALIASES, **{v: k for k, v in KEY_ALIASES.items()}}
+
+
+def format_prompt_keys(keys: str, add_alternatives=True) -> str:
+    """Format prompt toolkit key with modifier into an RST representation."""
+
+    def to_rst(key):
+        escaped = key.replace("\\", "\\\\")
+        return f":kbd:`{escaped}`"
+
+    keys_to_press: List[str]
+
+    prefixes = {
+        "c-s-": [to_rst("ctrl"), to_rst("shift")],
+        "s-c-": [to_rst("ctrl"), to_rst("shift")],
+        "c-": [to_rst("ctrl")],
+        "s-": [to_rst("shift")],
+    }
+
+    for prefix, modifiers in prefixes.items():
+        if keys.startswith(prefix):
+            remainder = keys[len(prefix) :]
+            keys_to_press = [*modifiers, to_rst(remainder)]
+            break
+    else:
+        keys_to_press = [to_rst(keys)]
+
+    result = " + ".join(keys_to_press)
+
+    if keys in INDISTINGUISHABLE_KEYS and add_alternatives:
+        alternative = INDISTINGUISHABLE_KEYS[keys]
+
+        result = (
+            result
+            + " (or "
+            + format_prompt_keys(alternative, add_alternatives=False)
+            + ")"
+        )
+
+    return result
+
+
+if __name__ == "__main__":
+    here = Path(__file__).parent
+    dest = here / "source" / "config" / "shortcuts"
+
+    ipy_bindings = create_ipython_shortcuts(_DummyTerminal())
+
+    session = PromptSession(key_bindings=ipy_bindings)
+    prompt_bindings = session.app.key_bindings
+
+    assert prompt_bindings
+    # Ensure that we collected the default shortcuts
+    assert len(prompt_bindings.bindings) > len(ipy_bindings.bindings)
+
+    bindings = bindings_from_prompt_toolkit(prompt_bindings)
+
+    def sort_key(binding: Binding):
+        return binding.handler.identifier, binding.shortcut.filter
+
+    filters = []
+    with (dest / "table.tsv").open("w", encoding="utf-8") as csv:
+        for binding in sorted(bindings, key=sort_key):
+            sequence = ", ".join(
+                [format_prompt_keys(keys) for keys in binding.shortcut.keys_sequence]
+            )
+            if binding.shortcut.filter == "always":
+                condition_label = "-"
+            else:
+                # we cannot fit all the columns as the filters got too complex over time
+                condition_label = "ⓘ"
+
+            csv.write(
+                "\t".join(
+                    [
+                        sequence,
+                        sentencize(binding.handler.description)
+                        + f" :raw-html:`<br>` `{binding.handler.identifier}`",
+                        f':raw-html:`<span title="{html_escape(binding.shortcut.filter)}" style="cursor: help">{condition_label}</span>`',
+                    ]
+                )
+                + "\n"
+            )
diff --git a/docs/do_sphinx.py b/docs/do_sphinx.py
deleted file mode 100755
index ead5a580bc7..00000000000
--- a/docs/do_sphinx.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/env python
-"""Script to build documentation using Sphinx.
-"""
-
-import fileinput,os,sys
-
-def oscmd(c):
-    os.system(c)
-
-# html manual.
-oscmd('sphinx-build -d build/doctrees source build/html')
-
-if sys.platform != 'win32':
-    # LaTeX format.
-    oscmd('sphinx-build -b latex -d build/doctrees source build/latex')
-
-    # Produce pdf.
-    topdir = os.getcwd()
-    os.chdir('build/latex')
-
-    # Change chapter style to section style: allows chapters to start on 
-    # the current page.  Works much better for the short chapters we have.
-    # This must go in the class file rather than the preamble, so we modify 
-    # manual.cls at runtime.
-    chapter_cmds=r'''
-% Local changes.
-\renewcommand\chapter{
-    \thispagestyle{plain}
-    \global\@topnum\z@
-    \@afterindentfalse
-    \secdef\@chapter\@schapter
-}
-\def\@makechapterhead#1{
-    \vspace*{10\p@}
-    {\raggedright \reset@font \Huge \bfseries \thechapter \quad #1}
-    \par\nobreak
-    \hrulefill
-    \par\nobreak
-    \vspace*{10\p@}
-}
-\def\@makeschapterhead#1{
-    \vspace*{10\p@}
-    {\raggedright \reset@font \Huge \bfseries #1}
-    \par\nobreak
-    \hrulefill
-    \par\nobreak
-    \vspace*{10\p@}
-}
-'''
-
-    unmodified=True
-    for line in fileinput.FileInput('manual.cls',inplace=1):
-        if 'Support for module synopsis' in line and unmodified:
-            line=chapter_cmds+line
-        elif 'makechapterhead' in line:
-            # Already have altered manual.cls: don't need to again.
-            unmodified=False
-        print line,
-
-    # Copying the makefile produced by sphinx...
-    oscmd('pdflatex ipython.tex')
-    oscmd('pdflatex ipython.tex')
-    oscmd('pdflatex ipython.tex')
-    oscmd('makeindex -s python.ist ipython.idx')
-    oscmd('makeindex -s python.ist modipython.idx')
-    oscmd('pdflatex ipython.tex')
-    oscmd('pdflatex ipython.tex')
-
-    # Create a manual/ directory with final html/pdf output
-    os.chdir(topdir)
-    oscmd('rm -rf manual')
-    oscmd('mkdir manual')
-    oscmd('cp -r build/html/*.html build/html/_static manual/')
-    oscmd('cp build/latex/ipython.pdf manual/')
diff --git a/docs/emacs/ipython.el b/docs/emacs/ipython.el
deleted file mode 100644
index 795cba2cc02..00000000000
--- a/docs/emacs/ipython.el
+++ /dev/null
@@ -1,492 +0,0 @@
-;;; ipython.el --- Adds support for IPython to python-mode.el
-
-;; Copyright (C) 2002, 2003, 2004, 2005 Alexander Schmolck
-;; Author:        Alexander Schmolck
-;; Keywords:      ipython python languages oop
-;; URL:           http://ipython.scipy.org
-;; Compatibility: Emacs21, XEmacs21
-;; FIXME: #$@! INPUT RING
-(defconst ipython-version "0.11"
-  "Tied to IPython main version number.")
-
-;;; Commentary
-;; This library makes all the functionality python-mode has when running with
-;; the normal python-interpreter available for ipython, too. It also enables a
-;; persistent py-shell command history across sessions (if you exit python
-;; with C-d in py-shell) and defines the command `ipython-to-doctest', which
-;; can be used to convert bits of a ipython session into something that can be
-;; used for doctests. To install, put this file somewhere in your emacs
-;; `load-path' [1] and add the following line to your ~/.emacs file (the first
-;; line only needed if the default (``"ipython"``) is wrong)::
-;;
-;;   (setq ipython-command "/SOME-PATH/ipython")
-;;   (require 'ipython)
-;;
-;; Ipython will be set as the default python shell, but only if the ipython
-;; executable is in the path. For ipython sessions autocompletion with <tab>
-;; is also enabled (experimental feature!). Please also note that all the
-;; terminal functions in py-shell are handled by emacs's comint, **not** by
-;; (i)python, so importing readline etc. will have 0 effect.
-;;
-;; To start an interactive ipython session run `py-shell' with ``M-x py-shell``
-;; (or the default keybinding ``C-c C-!``).
-;;
-;; You can customize the arguments passed to the IPython instance at startup by
-;; setting the ``py-python-command-args`` variable.  For example, to start
-;; always in ``pylab`` mode with hardcoded light-background colors, you can
-;; use::
-;;
-;; (setq py-python-command-args '("-pylab" "--colors" "LightBG"))
-;;
-;;
-;; NOTE: This mode is currently somewhat alpha and although I hope that it
-;; will work fine for most cases, doing certain things (like the
-;; autocompletion and a decent scheme to switch between python interpreters)
-;; properly will also require changes to ipython that will likely have to wait
-;; for a larger rewrite scheduled some time in the future.
-;;
-;;
-;; Further note that I don't know whether this runs under windows or not and
-;; that if it doesn't I can't really help much, not being afflicted myself.
-;;
-;;
-;; Hints for effective usage
-;; -------------------------
-;;
-;; - IMO the best feature by far of the ipython/emacs combo is how much easier
-;;   it makes it to find and fix bugs thanks to the ``%pdb on or %debug``/
-;;   pdbtrack combo. Try it: first in the ipython to shell do ``%pdb on`` then
-;;   do something that will raise an exception (FIXME nice example), or type
-;;   ``%debug`` after the exception has been raised.  YOu'll be amazed at how
-;;   easy it is to inspect the live objects in each stack frames and to jump to
-;;   the corresponding sourcecode locations as you walk up and down the stack
-;;   trace (even without ``%pdb on`` you can always use ``C-c -``
-;;   (`py-up-exception') to jump to the corresponding source code locations).
-;;
-;; - emacs gives you much more powerful commandline editing and output searching
-;;   capabilities than ipython-standalone -- isearch is your friend if you
-;;   quickly want to print 'DEBUG ...' to stdout out etc.
-;;
-;; - This is not really specific to ipython, but for more convenient history
-;;   access you might want to add something like the following to *the beggining*
-;;   of your ``.emacs`` (if you want behavior that's more similar to stand-alone
-;;   ipython, you can change ``meta p`` etc. for ``control p``)::
-;;
-;;         (require 'comint)
-;;         (define-key comint-mode-map [(meta p)]
-;;           'comint-previous-matching-input-from-input)
-;;         (define-key comint-mode-map [(meta n)]
-;;           'comint-next-matching-input-from-input)
-;;         (define-key comint-mode-map [(control meta n)]
-;;            'comint-next-input)
-;;         (define-key comint-mode-map [(control meta p)]
-;;            'comint-previous-input)
-;;
-;; - Be aware that if you customize py-python-command previously, this value
-;;   will override what ipython.el does (because loading the customization
-;;   variables comes later).
-;;
-;; Please send comments and feedback to the ipython-list
-;; (<ipython-user@scipy.org>) where I (a.s.) or someone else will try to
-;; answer them (it helps if you specify your emacs version, OS etc;
-;; familiarity with <http://www.catb.org/~esr/faqs/smart-questions.html> might
-;; speed up things further).
-;;
-;; Footnotes:
-;;
-;;     [1] If you don't know what `load-path' is, C-h v load-path will tell
-;;     you; if required you can also add a new directory. So assuming that
-;;     ipython.el resides in ~/el/, put this in your emacs:
-;;
-;;
-;;           (add-to-list 'load-path "~/el")
-;;           (setq ipython-command "/some-path/ipython")
-;;           (require 'ipython)
-;;
-;;
-;;
-;;
-;; TODO:
-;;      - do autocompletion properly
-;;      - implement a proper switching between python interpreters
-;;
-;; BUGS:
-;;      - neither::
-;;
-;;         (py-shell "-c print 'FOOBAR'")
-;;
-;;        nor::
-;;
-;;         (let ((py-python-command-args (append py-python-command-args
-;;                                              '("-c" "print 'FOOBAR'"))))
-;;           (py-shell))
-;;
-;;        seem to print anything as they should
-;;
-;;      - look into init priority issues with `py-python-command' (if it's set
-;;        via custom)
-
-
-;;; Code
-(require 'cl)
-(require 'shell)
-(require 'executable)
-(require 'ansi-color)
-
-(defcustom ipython-command "ipython"
-  "*Shell command used to start ipython."
-  :type 'string
-  :group 'python)
-
-;; Users can set this to nil
-(defvar py-shell-initial-switch-buffers t
-  "If nil, don't switch to the *Python* buffer on the first call to
-  `py-shell'.")
-
-(defvar ipython-backup-of-py-python-command nil
-  "HACK")
-
-
-(defvar ipython-de-input-prompt-regexp "\\(?:
-In \\[[0-9]+\\]: *.*
-----+> \\(.*
-\\)[\n]?\\)\\|\\(?:
-In \\[[0-9]+\\]: *\\(.*
-\\)\\)\\|^[ ]\\{3\\}[.]\\{3,\\}: *\\(.*
-\\)"
-  "A regular expression to match the IPython input prompt and the python
-command after it. The first match group is for a command that is rewritten,
-the second for a 'normal' command, and the third for a multiline command.")
-(defvar ipython-de-output-prompt-regexp "^Out\\[[0-9]+\\]: "
-  "A regular expression to match the output prompt of IPython.")
-
-
-(if (not (executable-find ipython-command))
-    (message (format "Can't find executable %s - ipython.el *NOT* activated!!!"
-                     ipython-command))
-    ;; XXX load python-mode, so that we can screw around with its variables
-    ;; this has the disadvantage that python-mode is loaded even if no
-    ;; python-file is ever edited etc. but it means that `py-shell' works
-    ;; without loading a python-file first. Obviously screwing around with
-    ;; python-mode's variables like this is a mess, but well.
-    (require 'python-mode)
-    ;; turn on ansi colors for ipython and activate completion
-    (defun ipython-shell-hook ()
-      ;; the following is to synchronize dir-changes
-      (make-local-variable 'shell-dirstack)
-      (setq shell-dirstack nil)
-      (make-local-variable 'shell-last-dir)
-      (setq shell-last-dir nil)
-      (make-local-variable 'shell-dirtrackp)
-      (setq shell-dirtrackp t)
-      (add-hook 'comint-input-filter-functions 'shell-directory-tracker nil t)
-
-      (ansi-color-for-comint-mode-on)
-      (define-key py-shell-map [tab] 'ipython-complete)
-      ;; Add this so that tab-completion works both in X11 frames and inside
-      ;; terminals (such as when emacs is called with -nw).
-      (define-key py-shell-map "\t" 'ipython-complete)
-      ;;XXX this is really just a cheap hack, it only completes symbols in the
-      ;;interactive session -- useful nonetheless.
-      (define-key py-mode-map [(meta tab)] 'ipython-complete)
-
-      )
-    (add-hook 'py-shell-hook 'ipython-shell-hook)
-    ;; Regular expression that describes tracebacks for IPython in context and
-    ;; verbose mode.
-
-    ;;Adapt python-mode settings for ipython.
-    ;; (this works for %xmode 'verbose' or 'context')
-
-    ;; XXX putative regexps for syntax errors; unfortunately the
-    ;;     current python-mode traceback-line-re scheme is too primitive,
-    ;;     so it's either matching syntax errors, *or* everything else
-    ;;     (XXX: should ask Fernando for a change)
-    ;;"^   File \"\\(.*?\\)\", line \\([0-9]+\\).*\n.*\n.*\nSyntaxError:"
-    ;;^   File \"\\(.*?\\)\", line \\([0-9]+\\)"
-
-    (setq py-traceback-line-re
-          "\\(^[^\t >].+?\\.py\\).*\n   +[0-9]+[^\00]*?\n-+> \\([0-9]+\\)+")
-
-
-    ;; Recognize the ipython pdb, whose prompt is 'ipdb>' or  'ipydb>'
-    ;;instead of '(Pdb)'
-    (setq py-pdbtrack-input-prompt "\n[(<]*[Ii]?[Pp]y?db[>)]+ ")
-    (setq pydb-pydbtrack-input-prompt "\n[(]*ipydb[>)]+ ")
-
-    (setq py-shell-input-prompt-1-regexp "^In \\[[0-9]+\\]: *"
-          py-shell-input-prompt-2-regexp "^   [.][.][.]+: *" )
-    ;; select a suitable color-scheme
-    (unless (member "--colors" py-python-command-args)
-      (setq py-python-command-args
-            (nconc py-python-command-args
-                   (list "--colors"
-                         (cond
-                           ((eq frame-background-mode 'dark)
-                            "Linux")
-                           ((eq frame-background-mode 'light)
-                            "LightBG")
-                           (t ; default (backg-mode isn't always set by XEmacs)
-                            "LightBG"))))))
-    (unless (equal ipython-backup-of-py-python-command py-python-command)
-      (setq ipython-backup-of-py-python-command py-python-command))
-    (setq py-python-command ipython-command))
-
-
-;; MODIFY py-shell so that it loads the editing history
-(defadvice py-shell (around py-shell-with-history)
-  "Add persistent command-history support (in
-$PYTHONHISTORY (or \"~/.ipython/history\", if we use IPython)). Also, if
-`py-shell-initial-switch-buffers' is nil, it only switches to *Python* if that
-buffer already exists."
-  (if (comint-check-proc "*Python*")
-      ad-do-it
-    (setq comint-input-ring-file-name
-          (if (string-equal py-python-command ipython-command)
-              (concat (or (getenv "IPYTHONDIR") "~/.ipython") "/history")
-            (or (getenv "PYTHONHISTORY") "~/.python-history.py")))
-    (comint-read-input-ring t)
-    (let ((buf (current-buffer)))
-      ad-do-it
-      (unless py-shell-initial-switch-buffers
-        (switch-to-buffer-other-window buf)))))
-(ad-activate 'py-shell)
-;; (defadvice py-execute-region (before py-execute-buffer-ensure-process)
-;;   "HACK: test that ipython is already running before executing something.
-;;   Doing this properly seems not worth the bother (unless people actually
-;;   request it)."
-;; (unless (comint-check-proc "*Python*")
-;;     (error "Sorry you have to first do M-x py-shell to send something to ipython.")))
-;; (ad-activate 'py-execute-region)
-
-(defadvice py-execute-region (around py-execute-buffer-ensure-process)
-  "HACK: if `py-shell' is not active or ASYNC is explicitly desired, fall back
-  to python instead of ipython."
-  (let ((py-which-shell (if (and (comint-check-proc "*Python*") (not async))
-			    py-python-command
-			  ipython-backup-of-py-python-command)))
-    ad-do-it))
-(ad-activate 'py-execute-region)
-
-(defun ipython-to-doctest (start end)
-  "Transform a cut-and-pasted bit from an IPython session into something that
-looks like it came from a normal interactive python session, so that it can
-be used in doctests. Example:
-
-
-    In [1]: import sys
-
-    In [2]: sys.stdout.write 'Hi!\n'
-    ------> sys.stdout.write ('Hi!\n')
-    Hi!
-
-    In [3]: 3 + 4
-    Out[3]: 7
-
-gets converted to:
-
-    >>> import sys
-    >>> sys.stdout.write ('Hi!\n')
-    Hi!
-    >>> 3 + 4
-    7
-
-"
-  (interactive "*r\n")
-  ;(message (format "###DEBUG s:%de:%d" start end))
-  (save-excursion
-    (save-match-data
-      ;; replace ``In [3]: bla`` with ``>>> bla`` and
-      ;;         ``... :   bla`` with ``...    bla``
-      (goto-char start)
-      (while (re-search-forward ipython-de-input-prompt-regexp end t)
-        ;(message "finding 1")
-        (cond ((match-string 3)         ;continued
-               (replace-match "... \\3" t nil))
-              (t
-               (replace-match ">>> \\1\\2" t nil))))
-      ;; replace ``
-      (goto-char start)
-      (while (re-search-forward ipython-de-output-prompt-regexp end t)
-        (replace-match "" t nil)))))
-
-(defvar ipython-completion-command-string
-  "print(';'.join(get_ipython().Completer.all_completions('%s'))) #PYTHON-MODE SILENT\n"
-  "The string send to ipython to query for all possible completions")
-
-
-;; xemacs doesn't have `comint-preoutput-filter-functions' so we'll try the
-;; following wonderful hack to work around this case
-(if (featurep 'xemacs)
-    ;;xemacs
-    (defun ipython-complete ()
-      "Try to complete the python symbol before point. Only knows about the stuff
-in the current *Python* session."
-      (interactive)
-      (let* ((ugly-return nil)
-             (sep ";")
-             (python-process (or (get-buffer-process (current-buffer))
-                                 ;XXX hack for .py buffers
-                                 (get-process py-which-bufname)))
-             ;; XXX currently we go backwards to find the beginning of an
-             ;; expression part; a more powerful approach in the future might be
-             ;; to let ipython have the complete line, so that context can be used
-             ;; to do things like filename completion etc.
-             (beg (save-excursion (skip-chars-backward "a-z0-9A-Z_." (point-at-bol))
-                                  (point)))
-             (end (point))
-             (pattern (buffer-substring-no-properties beg end))
-             (completions nil)
-             (completion-table nil)
-             completion
-             (comint-output-filter-functions
-              (append comint-output-filter-functions
-                      '(ansi-color-filter-apply
-                        (lambda (string)
-                                        ;(message (format "DEBUG filtering: %s" string))
-                          (setq ugly-return (concat ugly-return string))
-                          (delete-region comint-last-output-start
-                                         (process-mark (get-buffer-process (current-buffer)))))))))
-	;(message (format "#DEBUG pattern: '%s'" pattern))
-        (process-send-string python-process
-                              (format ipython-completion-command-string pattern))
-        (accept-process-output python-process)
-	
-	;(message (format "DEBUG return: %s" ugly-return))
-        (setq completions
-              (split-string (substring ugly-return 0 (position ?\n ugly-return)) sep))
-        (setq completion-table (loop for str in completions
-                                     collect (list str nil)))
-        (setq completion (try-completion pattern completion-table))
-        (cond ((eq completion t))
-              ((null completion)
-               (message "Can't find completion for \"%s\"" pattern)
-               (ding))
-              ((not (string= pattern completion))
-               (delete-region beg end)
-               (insert completion))
-              (t
-               (message "Making completion list...")
-               (with-output-to-temp-buffer "*Python Completions*"
-                 (display-completion-list (all-completions pattern completion-table)))
-               (message "Making completion list...%s" "done")))))
-  ;; emacs
-  (defun ipython-complete ()
-    "Try to complete the python symbol before point. Only knows about the stuff
-in the current *Python* session."
-    (interactive)
-    (let* ((ugly-return nil)
-           (sep ";")
-           (python-process (or (get-buffer-process (current-buffer))
-                                        ;XXX hack for .py buffers
-                               (get-process py-which-bufname)))
-           ;; XXX currently we go backwards to find the beginning of an
-           ;; expression part; a more powerful approach in the future might be
-           ;; to let ipython have the complete line, so that context can be used
-           ;; to do things like filename completion etc.
-           (beg (save-excursion (skip-chars-backward "a-z0-9A-Z_./" (point-at-bol))
-                                (point)))
-           (end (point))
-           (pattern (buffer-substring-no-properties beg end))
-           (completions nil)
-           (completion-table nil)
-           completion
-         (comint-preoutput-filter-functions
-          (append comint-preoutput-filter-functions
-                  '(ansi-color-filter-apply
-                    (lambda (string)
-                      (setq ugly-return (concat ugly-return string))
-                      "")))))
-      (process-send-string python-process
-                            (format ipython-completion-command-string pattern))
-      (accept-process-output python-process)
-      (setq completions
-            (split-string (substring ugly-return 0 (position ?\n ugly-return)) sep))
-                                        ;(message (format "DEBUG completions: %S" completions))
-      (setq completion-table (loop for str in completions
-                                   collect (list str nil)))
-      (setq completion (try-completion pattern completion-table))
-      (cond ((eq completion t))
-            ((null completion)
-             (message "Can't find completion for \"%s\"" pattern)
-             (ding))
-            ((not (string= pattern completion))
-             (delete-region beg end)
-             (insert completion))
-            (t
-             (message "Making completion list...")
-             (with-output-to-temp-buffer "*IPython Completions*"
-               (display-completion-list (all-completions pattern completion-table)))
-             (message "Making completion list...%s" "done")))))
-)
-
-;;; autoindent support: patch sent in by Jin Liu <m.liu.jin@gmail.com>,
-;;; originally written by doxgen@newsmth.net
-;;; Minor modifications by fperez for xemacs compatibility.
-
-(defvar ipython-autoindent t
- "If non-nil, enable autoindent for IPython shell through python-mode.")
-
-(defvar ipython-indenting-buffer-name "*IPython Indentation Calculation*"
- "Temporary buffer for indenting multiline statement.")
-
-(defun ipython-get-indenting-buffer ()
- "Return a temporary buffer set in python-mode. Create one if necessary."
- (let ((buf (get-buffer-create ipython-indenting-buffer-name)))
-   (set-buffer buf)
-   (unless (eq major-mode 'python-mode)
-     (python-mode))
-   buf))
-
-(defvar ipython-indentation-string nil
- "Indentation for the next line in a multiline statement.")
-
-(defun ipython-send-and-indent ()
- "Send the current line to IPython, and calculate the indentation for
-the next line."
- (interactive)
- (if ipython-autoindent
-     (let ((line (buffer-substring (point-at-bol) (point)))
-           (after-prompt1)
-           (after-prompt2))
-       (save-excursion
-           (comint-bol t)
-           (if (looking-at py-shell-input-prompt-1-regexp)
-               (setq after-prompt1 t)
-             (setq after-prompt2 (looking-at py-shell-input-prompt-2-regexp)))
-           (with-current-buffer (ipython-get-indenting-buffer)
-             (when after-prompt1
-               (erase-buffer))
-             (when (or after-prompt1 after-prompt2)
-               (delete-region (point-at-bol) (point))
-               (insert line)
-               (newline-and-indent))))))
- ;; send input line to ipython interpreter
- (comint-send-input))
-
-(defun ipython-indentation-hook (string)
- "Insert indentation string if py-shell-input-prompt-2-regexp
-matches last process output."
- (let* ((start-marker (or comint-last-output-start
-                          (point-min-marker)))
-        (end-marker (process-mark (get-buffer-process (current-buffer))))
-        (text (ansi-color-filter-apply (buffer-substring start-marker end-marker))))
-   ;; XXX if `text' matches both pattern, it MUST be the last prompt-2
-   (when (and (string-match py-shell-input-prompt-2-regexp text)
-	      (not (string-match "\n$" text)))
-     (with-current-buffer (ipython-get-indenting-buffer)
-       (setq ipython-indentation-string
-	     (buffer-substring (point-at-bol) (point))))
-     (goto-char end-marker)
-     (insert ipython-indentation-string)
-     (setq ipython-indentation-string nil))))
-
-(add-hook 'py-shell-hook
-         (lambda ()
-           (add-hook 'comint-output-filter-functions
-                     'ipython-indentation-hook)))
-
-(define-key py-shell-map (kbd "RET") 'ipython-send-and-indent)
-;;; / end autoindent support
-
-(provide 'ipython)
diff --git a/docs/examples/core/demo-exercizer.py b/docs/examples/core/demo-exercizer.py
deleted file mode 100644
index 4085a03a4db..00000000000
--- a/docs/examples/core/demo-exercizer.py
+++ /dev/null
@@ -1,85 +0,0 @@
-"""This is meant to be run from the IPython prompt:
-
-%run demo-exercizer.py
-
-It will create demo objects of the example that is embedded in demo.py in a
-number of ways and allow you to see how they work, just follow the printed
-directions."""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# From std lib
-import StringIO
-import os
-import shutil
-import tempfile
-
-# From IPython
-from IPython.demo import (Demo, IPythonDemo, LineDemo, IPythonLineDemo,
-                          ClearDemo, ClearIPDemo)
-
-#-----------------------------------------------------------------------------
-# Demo code
-#-----------------------------------------------------------------------------
-
-example1 = """
-'''A simple interactive demo to illustrate the use of IPython's Demo class.'''
-
-print 'Hello, welcome to an interactive IPython demo.'
-
-# The mark below defines a block boundary, which is a point where IPython will
-# stop execution and return to the interactive prompt. The dashes are actually
-# optional and used only as a visual aid to clearly separate blocks while
-# editing the demo code.
-# <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!'
-"""
-fp = tempfile.mkdtemp(prefix = 'DemoTmp')
-fd, filename = tempfile.mkstemp(prefix = 'demoExample1File', suffix = '.py',
-                                dir = fp)
-f = os.fdopen(fd, 'wt')
-
-f.write(example1)
-f.close()
-
-my_d = Demo(filename)
-my_cd = ClearDemo(filename)
-
-fobj = StringIO.StringIO(example1)
-str_d = Demo(fobj, title='via stringio')
-
-print '''
-The example that is embeded in demo.py file has been used to create 
-the following 3 demos, and should now be available to use:
-   my_d()    -- created from a file
-   my_cd()   -- created from a file, a ClearDemo
-   str_d()   -- same as above, but created via a StringIO object 
-Call by typing their name, (with parentheses), at the 
-ipython prompt, interact with the block, then call again
-to run the next block.
-'''
diff --git a/docs/examples/core/example-demo.py b/docs/examples/core/example-demo.py
deleted file mode 100644
index 3bfd6b1a6fa..00000000000
--- a/docs/examples/core/example-demo.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""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=',z
-
-# <demo> --- stop ---
-# This is just another normal block.
-print 'z is now:', z
-
-print 'bye!'
diff --git a/docs/examples/core/example-embed-short.py b/docs/examples/core/example-embed-short.py
deleted file mode 100644
index 4b2e7358aad..00000000000
--- a/docs/examples/core/example-embed-short.py
+++ /dev/null
@@ -1,51 +0,0 @@
-"""Quick code snippets for embedding IPython into other programs.
-
-See example-embed.py for full details, this file has the bare minimum code for
-cut and paste use once you understand how to use the system."""
-
-#---------------------------------------------------------------------------
-# This code loads IPython but modifies a few things if it detects it's running
-# embedded in another IPython session (helps avoid confusion)
-
-try:
-    __IPYTHON__
-except NameError:
-    argv = ['']
-    banner = exit_msg = ''
-else:
-    # Command-line options for IPython (a list like sys.argv)
-    argv = ['-pi1','In <\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:']
-    banner = '*** Nested interpreter ***'
-    exit_msg = '*** Back in main IPython ***'
-
-# First import the embeddable shell class
-from IPython.Shell import IPShellEmbed
-# Now create the IPython shell instance. Put ipshell() anywhere in your code
-# where you want it to open.
-ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg)
-                            
-#---------------------------------------------------------------------------
-# This code will load an embeddable IPython shell always with no changes for
-# nested embededings.
-
-from IPython.Shell import IPShellEmbed
-ipshell = IPShellEmbed()
-# Now ipshell() will open IPython anywhere in the code.
-
-#---------------------------------------------------------------------------
-# This code loads an embeddable shell only if NOT running inside
-# IPython. Inside IPython, the embeddable shell variable ipshell is just a
-# dummy function.
-
-try:
-    __IPYTHON__
-except NameError:
-    from IPython.Shell import IPShellEmbed
-    ipshell = IPShellEmbed()
-    # Now ipshell() will open IPython anywhere in the code
-else:
-    # Define a dummy ipshell() so the same code doesn't crash inside an
-    # interactive IPython
-    def ipshell(): pass
-
-#******************* End of file <example-embed-short.py> ********************
diff --git a/docs/examples/core/example-embed.py b/docs/examples/core/example-embed.py
deleted file mode 100755
index 3c451efb84e..00000000000
--- a/docs/examples/core/example-embed.py
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-
-"""An example of how to embed an IPython shell into a running program.
-
-Please see the documentation in the IPython.Shell module for more details.
-
-The accompanying file example-embed-short.py has quick code fragments for
-embedding which you can cut and paste in your code once you understand how
-things work.
-
-The code in this file is deliberately extra-verbose, meant for learning."""
-
-# The basics to get you going:
-
-# IPython sets the __IPYTHON__ variable so you can know if you have nested
-# copies running.
-
-# Try running this code both at the command line and from inside IPython (with
-# %run example-embed.py)
-try:
-    __IPYTHON__
-except NameError:
-    nested = 0
-    args = ['']
-else:
-    print "Running nested copies of IPython."
-    print "The prompts for the nested copy have been modified"
-    nested = 1
-    # what the embedded instance will see as sys.argv:
-    args = ['-pi1','In <\\#>: ','-pi2','   .\\D.: ',
-            '-po','Out<\\#>: ','-nosep']
-
-# First import the embeddable shell class
-from IPython.core.shell import IPShellEmbed
-
-# Now create an instance of the embeddable shell. The first argument is a
-# string with options exactly as you would type them if you were starting
-# IPython at the system command line. Any parameters you want to define for
-# configuration can thus be specified here.
-ipshell = IPShellEmbed(args,
-                       banner = 'Dropping into IPython',
-                       exit_msg = 'Leaving Interpreter, back to program.')
-
-# Make a second instance, you can have as many as you want.
-if nested:
-    args[1] = 'In2<\\#>'
-else:
-    args = ['-pi1','In2<\\#>: ','-pi2','   .\\D.: ',
-            '-po','Out<\\#>: ','-nosep']
-ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.')
-
-print '\nHello. This is printed from the main controller program.\n'
-
-# You can then call ipshell() anywhere you need it (with an optional
-# message):
-ipshell('***Called from top level. '
-        'Hit Ctrl-D to exit interpreter and continue program.\n'
-        'Note that if you use %kill_embedded, you can fully deactivate\n'
-        'This embedded instance so it will never turn on again')
-
-print '\nBack in caller program, moving along...\n'
-
-#---------------------------------------------------------------------------
-# More details:
-
-# IPShellEmbed instances don't print the standard system banner and
-# messages. The IPython banner (which actually may contain initialization
-# messages) is available as <instance>.IP.BANNER in case you want it.
-
-# IPShellEmbed instances print the following information everytime they
-# start:
-
-# - A global startup banner.
-
-# - A call-specific header string, which you can use to indicate where in the
-# execution flow the shell is starting.
-
-# They also print an exit message every time they exit.
-
-# Both the startup banner and the exit message default to None, and can be set
-# either at the instance constructor or at any other time with the
-# set_banner() and set_exit_msg() methods.
-
-# The shell instance can be also put in 'dummy' mode globally or on a per-call
-# basis. This gives you fine control for debugging without having to change
-# code all over the place.
-
-# The code below illustrates all this.
-
-
-# This is how the global banner and exit_msg can be reset at any point
-ipshell.set_banner('Entering interpreter - New Banner')
-ipshell.set_exit_msg('Leaving interpreter - New exit_msg')
-
-def foo(m):
-    s = 'spam'
-    ipshell('***In foo(). Try @whos, or print s or m:')
-    print 'foo says m = ',m
-
-def bar(n):
-    s = 'eggs'
-    ipshell('***In bar(). Try @whos, or print s or n:')
-    print 'bar says n = ',n
-    
-# Some calls to the above functions which will trigger IPython:
-print 'Main program calling foo("eggs")\n'
-foo('eggs')
-
-# The shell can be put in 'dummy' mode where calls to it silently return. This
-# allows you, for example, to globally turn off debugging for a program with a
-# single call.
-ipshell.set_dummy_mode(1)
-print '\nTrying to call IPython which is now "dummy":'
-ipshell()
-print 'Nothing happened...'
-# The global 'dummy' mode can still be overridden for a single call
-print '\nOverriding dummy mode manually:'
-ipshell(dummy=0)
-
-# Reactivate the IPython shell
-ipshell.set_dummy_mode(0)
-
-print 'You can even have multiple embedded instances:'
-ipshell2()
-
-print '\nMain program calling bar("spam")\n'
-bar('spam')
-
-print 'Main program finished. Bye!'
-
-#********************** End of file <example-embed.py> ***********************
diff --git a/docs/examples/core/example-gnuplot.py b/docs/examples/core/example-gnuplot.py
deleted file mode 100755
index 37aa5b41d34..00000000000
--- a/docs/examples/core/example-gnuplot.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-"""
-Example code showing how to use Gnuplot and an embedded IPython shell.
-"""
-
-from Numeric import *
-from IPython.numutils import *
-from IPython.Shell import IPShellEmbed
-
-# Arguments to start IPython shell with. Load numeric profile.
-ipargs = ['-profile','numeric']
-ipshell = IPShellEmbed(ipargs)
-
-# Compute sin(x) over the 0..2pi range at 200 points
-x = frange(0,2*pi,npts=200)
-y = sin(x)
-
-# In the 'numeric' profile, IPython has an internal gnuplot instance:
-g = ipshell.IP.gnuplot
-
-# Change some defaults
-g('set style data lines')
-
-# Or also call a multi-line set of gnuplot commands on it:
-g("""
-set xrange [0:pi]     # Set the visible range to half the data only
-set title 'Half sine' # Global gnuplot labels
-set xlabel 'theta'
-set ylabel 'sin(theta)'
-""")
-
-# Now start an embedded ipython.
-ipshell('Starting the embedded IPython.\n'
-        'Try calling plot(x,y), or @gpc for direct access to Gnuplot"\n')
-
-#********************** End of file <example-gnuplot.py> *********************
diff --git a/docs/examples/core/ipy.vim b/docs/examples/core/ipy.vim
deleted file mode 100644
index bb9e623e9ec..00000000000
--- a/docs/examples/core/ipy.vim
+++ /dev/null
@@ -1,143 +0,0 @@
-if !exists("$IPY_SESSION")
-    finish
-endif
-
-" set up the python interpreter within vim, to have all the right modules
-" imported, as well as certain useful globals set
-python import socket
-python import os
-python import vim
-python from IPython.core.debugger import Pdb
-python IPYSERVER = None
-python reselect = True
-
-python << EOF
-# do we have a connection to the ipython instance?
-def check_server():
-    global IPYSERVER
-    if IPYSERVER:
-        return True
-    else:
-        return False
-
-# connect to the ipython server, if we need to
-def connect():
-    global IPYSERVER
-    if check_server():
-        return
-    try:
-        IPYSERVER = socket.socket(socket.AF_UNIX)
-        IPYSERVER.connect(os.environ.get('IPY_SERVER'))
-    except:
-        IPYSERVER = None
-
-def disconnect():
-    if IPYSERVER:
-        IPYSERVER.close()
-
-def send(cmd):
-    x = 0
-    while True:
-        x += IPYSERVER.send(cmd)
-        if x < len(cmd):
-            cmd = cmd[x:]
-        else:
-            break
-
-def run_this_file():
-    if check_server():
-        send('run %s' % (vim.current.buffer.name,))
-    else:
-        raise Exception, "Not connected to an IPython server"
-    print "\'run %s\' sent to ipython" % vim.current.buffer.name
-
-def run_this_line():
-    if check_server():
-        send(vim.current.line)
-        print "line \'%s\' sent to ipython"% vim.current.line
-    else:
-        raise Exception, "Not connected to an IPython server"
-
-def run_these_lines():
-    r = vim.current.range
-    if check_server():
-        #send(str((vim.current.range.start,vim.current.range.end)))
-        for l in vim.current.buffer[r.start:r.end+1]:
-            send(str(l)+'\n')
-            #send(str(vim.current.buffer[vim.current.range.start:vim.current.range.end]).join("\n"))
-        #print "lines %d-%d sent to ipython"% (r.start,r.end)
-    else:
-        raise Exception, "Not connected to an IPython server"
-    
-    #reselect the previously highlighted block
-    if reselect:
-        vim.command("normal gv")
-    #vim lines start with 1
-    print "lines %d-%d sent to ipython"% (r.start+1,r.end+1)
-
-def toggle_reselect():
-    global reselect
-    reselect=not reselect
-    print "F9 will%sreselect lines after sending to ipython"% (reselect and " " or " not ")
-
-def set_breakpoint():
-    if check_server():
-        send("__IP.InteractiveTB.pdb.set_break('%s',%d)" % (vim.current.buffer.name,
-                                                            vim.current.window.cursor[0]))
-        print "set breakpoint in %s:%d"% (vim.current.buffer.name, 
-                                          vim.current.window.cursor[0])
-    else:
-        raise Exception, "Not connected to an IPython server"
-    
-def clear_breakpoint():
-    if check_server():
-        send("__IP.InteractiveTB.pdb.clear_break('%s',%d)" % (vim.current.buffer.name,
-                                                              vim.current.window.cursor[0]))
-        print "clearing breakpoint in %s:%d" % (vim.current.buffer.name,
-                                                vim.current.window.cursor[0])
-    else:
-        raise Exception, "Not connected to an IPython server"
-
-def clear_all_breakpoints():
-    if check_server():
-        send("__IP.InteractiveTB.pdb.clear_all_breaks()");
-        print "clearing all breakpoints"
-    else:
-        raise Exception, "Not connected to an IPython server"
-
-def run_this_file_pdb():
-    if check_server():
-        send(' __IP.InteractiveTB.pdb.run(\'execfile("%s")\')' % (vim.current.buffer.name,))
-    else:
-        raise Exception, "Not connected to an IPython server"
-    print "\'run %s\' using pdb sent to ipython" % vim.current.buffer.name
-
-    #XXX: have IPYSERVER print the prompt (look at Leo example)
-EOF
-
-fun! <SID>toggle_send_on_save()
-    if exists("s:ssos") && s:ssos == 1
-        let s:ssos = 0
-        au! BufWritePost *.py :py run_this_file()
-        echo "Autosend Off"
-    else
-        let s:ssos = 1
-        au BufWritePost *.py :py run_this_file()
-        echo "Autowsend On"
-    endif
-endfun
-
-map <silent> <F5> :python run_this_file()<CR>
-map <silent> <S-F5> :python run_this_line()<CR>
-map <silent> <F9> :python run_these_lines()<CR>
-map <silent> <S-F9> :python toggle_reselect()<CR>
-map <silent> <C-F6> :python send('%pdb')<CR>
-map <silent> <F6> :python set_breakpoint()<CR>
-map <silent> <s-F6> :python clear_breakpoint()<CR>
-map <silent> <F7> :python run_this_file_pdb()<CR>
-map <silent> <s-F7> :python clear_all_breaks()<CR>
-imap <C-F5> <ESC><F5>a
-imap <S-F5> <ESC><S-F5>a
-imap <silent> <F5> <ESC><F5>a
-map <C-F5> :call <SID>toggle_send_on_save()<CR>
-py connect()
diff --git a/docs/examples/core/ipython-sh.desktop b/docs/examples/core/ipython-sh.desktop
deleted file mode 100644
index f0aabcd425a..00000000000
--- a/docs/examples/core/ipython-sh.desktop
+++ /dev/null
@@ -1,22 +0,0 @@
-# If you want ipython to appear in a linux app launcher ("start menu"), install this by doing:
-# sudo desktop-file-install ipython-sh.desktop
-
-[Desktop Entry]
-Comment=Perform shell-like tasks in interactive ipython session
-Exec=ipython -p sh
-GenericName[en_US]=IPython shell mode
-GenericName=IPython shell mode
-Icon=gnome-netstatus-idle
-MimeType=
-Name[en_US]=ipython-sh
-Name=ipython-sh
-Path=
-Categories=Development;Utility;
-StartupNotify=false
-Terminal=true
-TerminalOptions=
-Type=Application
-X-DBUS-ServiceName=
-X-DBUS-StartupType=none
-X-KDE-SubstituteUID=false
-X-KDE-Username=
diff --git a/docs/examples/core/ipython_here_shell_extension.reg b/docs/examples/core/ipython_here_shell_extension.reg
deleted file mode 100644
index 934a3ac21ff..00000000000
--- a/docs/examples/core/ipython_here_shell_extension.reg
+++ /dev/null
@@ -1,6 +0,0 @@
- Windows Registry Editor Version 5.00
-
-[HKEY_CLASSES_ROOT\Directory\shell\IPython here]
-
-[HKEY_CLASSES_ROOT\Directory\shell\IPython here\Command]
-@="cmd.exe /C ipython.py -p sh -i -c \"%cd %1\""
\ No newline at end of file
diff --git a/docs/examples/core/leo_bridge_demo.leo b/docs/examples/core/leo_bridge_demo.leo
deleted file mode 100644
index 052a93022cf..00000000000
--- a/docs/examples/core/leo_bridge_demo.leo
+++ /dev/null
@@ -1,552 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<?xml-stylesheet ekr_test?>
-<leo_file>
-<leo_header file_format="2" tnodes="0" max_tnode_index="0" clone_windows="0"/>
-<globals body_outline_ratio="0.307814992026">
-	<global_window_position top="257" left="131" height="627" width="1280"/>
-	<global_log_window_position top="0" left="0" height="0" width="0"/>
-</globals>
-<preferences/>
-<find_panel_settings/>
-<vnodes>
-<v t="vivainio.20080222193236" a="E"><vh>Documentation</vh>
-<v t="vivainio.20080223121915" tnodeList="vivainio.20080223121915,vivainio.20080222193236.1,vivainio.20080223133858,vivainio.20080223133922,vivainio.20080223133947,vivainio.20080223134018,vivainio.20080223134100,vivainio.20080223134118,vivainio.20080223134433,vivainio.20080223142207,vivainio.20080223134136"><vh>@nosent ILeo_doc.txt</vh>
-<v t="vivainio.20080222193236.1"><vh>Documentation</vh>
-<v t="vivainio.20080223133858"><vh>Introduction</vh></v>
-<v t="vivainio.20080223133922"><vh>Installation</vh></v>
-<v t="vivainio.20080223133947"><vh>Accessing IPython from Leo</vh></v>
-<v t="vivainio.20080223134018"><vh>Accessing Leo nodes from IPython</vh></v>
-<v t="vivainio.20080223134100"><vh>Cl definitions</vh></v>
-<v t="vivainio.20080223134118"><vh>Special node types</vh></v>
-<v t="vivainio.20080223134433"><vh>Custom push</vh></v>
-<v t="vivainio.20080223142207" a="E"><vh>Code snippets</vh></v>
-<v t="vivainio.20080223134136"><vh>Acknowledgements and history</vh></v>
-</v>
-</v>
-</v>
-<v t="vivainio.20080218184525"><vh>@chapters</vh></v>
-<v t="vivainio.20080223133721" a="E"><vh>@settings</vh>
-<v t="vivainio.20080316092617"><vh>@@string ipython_argv = ipython -pylab</vh></v>
-<v t="vivainio.20080223133721.1"><vh>@enabled-plugins</vh></v>
-</v>
-<v t="vivainio.20080218184540"><vh>@ipy-startup</vh>
-<v t="vivainio.20080218184613.1"><vh>b</vh></v>
-<v t="vivainio.20080218200031"><vh>Some classes P</vh>
-<v t="vivainio.20080218190816"><vh>File-like access</vh></v>
-<v t="vivainio.20080218200106"><vh>csv data</vh></v>
-<v t="vivainio.20080219225120"><vh>String list</vh></v>
-<v t="vivainio.20080219230342"><vh>slist to leo</vh></v>
-</v>
-</v>
-<v t="vivainio.20080218195413" a="E"><vh>Class tests</vh>
-<v t="vivainio.20080218200509"><vh>csvr</vh></v>
-<v t="vivainio.20080218191007"><vh>tempfile</vh></v>
-<v t="vivainio.20080218195413.1"><vh>rfile</vh></v>
-<v t="vivainio.20080219225804"><vh>strlist</vh></v>
-</v>
-<v t="vivainio.20080222201226" a="V"><vh>IPython script push tests</vh></v>
-<v t="vivainio.20080218201219" a="E"><vh>Direct variables</vh>
-<v t="vivainio.20080218201219.2"><vh>bar</vh></v>
-</v>
-<v t="vivainio.20080316144536" a="E"><vh>pylab tests</vh>
-<v t="vivainio.20080316145539.2"><vh>Generate testarr</vh></v>
-<v t="vivainio.20080316085925"><vh>testarr</vh></v>
-<v t="vivainio.20080316085950"><vh>Call plotter on testarr</vh></v>
-</v>
-<v t="vivainio.20080222202211"><vh>test stuff</vh></v>
-<v t="vivainio.20080223142403"><vh>@ipy-results</vh>
-<v t="vivainio.20080223142403.1"><vh>foo</vh></v>
-</v>
-<v t="vivainio.20080222202211.1" a="E"><vh>spam</vh></v>
-</vnodes>
-<tnodes>
-<t tx="vivainio.20080218184525">?</t>
-<t tx="vivainio.20080218184540">?Direct children of this node will be pushed at ipython bridge startup
-
-This node itself will *not* be pushed</t>
-<t tx="vivainio.20080218184613.1">print "world"</t>
-<t tx="vivainio.20080218190816">def rfile(body,n):
-    """ @cl rfile 
-
-    produces a StringIO (file like obj of the rest of the body) """
-
-    import StringIO
-    return StringIO.StringIO(body)
-
-def tmpfile(body,n):
-    """ @cl tmpfile
-
-    Produces a temporary file, with node body as contents
-
-    """
-    import tempfile
-    h, fname = tempfile.mkstemp()
-    f = open(fname,'w')
-    f.write(body)
-    f.close()
-    return fname
-</t>
-<t tx="vivainio.20080218191007">@cl tmpfile
-
-Hello</t>
-<t tx="vivainio.20080218195413">?</t>
-<t tx="vivainio.20080218195413.1">@cl rfile
-These
-lines
-should 
-be
-readable </t>
-<t tx="vivainio.20080218200031">@others</t>
-<t tx="vivainio.20080218200106">def csvdata(body,n):
-    import csv
-    d = csv.Sniffer().sniff(body)
-    reader = csv.reader(body.splitlines(), dialect = d)
-    return reader</t>
-<t tx="vivainio.20080218200509">@cl csvdata
-
-a,b,b
-1,2,2</t>
-<t tx="vivainio.20080218201219"></t>
-<t tx="vivainio.20080218201219.2">@cl
-"hello world"</t>
-<t tx="vivainio.20080219225120">import IPython.genutils
-def slist(body,n):
-    return IPython.genutils.SList(body.splitlines())
-</t>
-<t tx="vivainio.20080219225804">@cl slist
-hello
-world
-on
-many
-lines
-</t>
-<t tx="vivainio.20080219230342">import ipy_leo
-@ipy_leo.format_for_leo.when_type(IPython.genutils.SList)
-def format_slist(obj):
-    return "@cl slist\n" + obj.n
-</t>
-<t tx="vivainio.20080222193236">?</t>
-<t tx="vivainio.20080222193236.1">@wrap
-@nocolor</t>
-<t tx="vivainio.20080222201226"># test ipython script 'cleanup' with complex blocks
-1+2
-print "hello"
-3+4
-
-def f(x):
-    return x.upper()
-
-
-if 0:
-    print "foo"
-else:
-    print "bar"
-
-def g():
-    pass
-
-g()
-
-if 1:
-    if 1:
-        print "hello"
-
-        print "world"
-
-if 1:
-    print "hello"
-
-    print "word"
-else:
-    print "foo"
-
-    print "bar"
-    print "baz"
-
-try:
-    raise Exception
-except:
-    print "exc ok"</t>
-<t tx="vivainio.20080222202211"></t>
-<t tx="vivainio.20080222202211.1" ipython="7d71005506636f6f7264737101284b0c4bde747102732e">@cl rfile
-hello
-world
-and whatever</t>
-<t tx="vivainio.20080223121915">@others
-</t>
-<t tx="vivainio.20080223133721"></t>
-<t tx="vivainio.20080223133721.1">ipython.py</t>
-<t tx="vivainio.20080223133858">
-Introduction
-============
-
-The purpose of ILeo, or leo-ipython bridge, is being a two-way communication
-channel between Leo and IPython. The level of integration is much deeper than
-conventional integration in IDEs; most notably, you are able to store *data* in
-Leo nodes, in addition to mere program code. The possibilities of this are
-endless, and this degree of integration has not been seen previously in the python
-world.
-
-IPython users are accustomed to using things like %edit to produce non-trivial
-functions/classes (i.e. something that they don't want to enter directly on the
-interactive prompt, but creating a proper script/module involves too much
-overhead). In ILeo, this task consists just going to the Leo window, creating a node
-and writing the code there, and pressing alt+I (push-to-ipython).
-
-Obviously, you can save the Leo document as usual - this is a great advantage
-of ILeo over using %edit, you can save your experimental scripts all at one
-time, without having to organize them into script/module files (before you
-really want to, of course!)
-</t>
-<t tx="vivainio.20080223133922">
-Installation
-============
-
-You need at least Leo 4.4.7, and the development version of IPython (ILeo
-will be incorporated to IPython 0.8.3).
-
-You can get IPython from Launchpad by installing bzr and doing
-
-bzr branch lp:ipython
-
-and running "setup.py install".
-
-You need to enable the 'ipython.py' plugin in Leo: 
-
-- Help -&gt; Open LeoSettings.leo
-
-- Edit @settings--&gt;Plugins--&gt;@enabled-plugins, add/uncomment 'ipython.py'
-
-- Alternatively, you can add @settings--&gt;@enabled-plugins with body ipython.py to your leo document.
-
-- Restart Leo. Be sure that you have the console window open (start leo.py from console, or double-click leo.py on windows)
-
-- Press alt+5 OR alt-x start-ipython to launch IPython in the console that
-started leo. You can start entering IPython commands normally, and Leo will keep
-running at the same time.
-</t>
-<t tx="vivainio.20080223133947">
-Accessing IPython from Leo
-==========================
-
-IPython code
-------------
-
-Just enter IPython commands on a Leo node and press alt-I to execute
-push-to-ipython in order to execute the script in IPython. 'commands' is
-interpreted loosely here - you can enter function and class definitions, in
-addition to the things you would usually enter at IPython prompt - calculations,
-system commands etc.
-
-Everything that would be legal to enter on IPython prompt is legal to execute
-from ILeo.
-
-Results will be shows in Leo log window for convenience, in addition to the console.
-
-Suppose that a node had the following contents:
-{{{
-1+2
-print "hello"
-3+4
-
-def f(x):
-    return x.upper()
-
-f('hello world')
-}}}
-
-If you press alt+I on that node, you will see the following in Leo log window (IPython tab):
-
-{{{
-In: 1+2
-&lt;2&gt; 3
-In: 3+4
-&lt;4&gt; 7
-In: f('hello world')
-&lt;6&gt; 'HELLO WORLD'
-}}}
-
-(numbers like &lt;6&gt; mean IPython output history indices; the actual object can be
-referenced with _6 as usual in IPython).
-
-
-Plain Python code
------------------
-
-If the headline of the node ends with capital P, alt-I will not run the code
-through IPython translation mechanism but use the direct python 'exec' statement
-(in IPython user namespace) to execute the code. It wont be shown in IPython
-history, and sometimes it is safer (and more efficient) to execute things as
-plain Python statements. Large class definitions are good candidates for P
-nodes.
-</t>
-<t tx="vivainio.20080223134018">
-Accessing Leo nodes from IPython
-================================
-
-The real fun starts when you start entering text to leo nodes, and are using
-that as data (input/output) for your IPython work.
-
-Accessing Leo nodes happens through the variable 'wb' (short for "WorkBook")
-that exist in the IPython user namespace. Nodes that are directly accessible are
-the ones that have simple names which could also be Python variable names;
-'foo_1' will be accessible directly from IPython, whereas 'my scripts' will not.
-If you want to access a node with arbitrary headline, add a child node '@a foo'
-(@a stands for 'anchor'). Then, the parent of '@a foo' is accessible through
-'wb.foo'.
-
-You can see what nodes are accessible be entering (in IPython) wb.&lt;TAB&gt;. Example:
-
-[C:leo/src]|12&gt; wb.
-wb.b           wb.tempfile    wb.rfile       wb.NewHeadline
-wb.bar         wb.Docs        wb.strlist     wb.csvr    
-[C:leo/src]|12&gt; wb.tempfile
-           &lt;12&gt; &lt;ipy_leo.LeoNode object at 0x044B6D90&gt;
-
-So here, we meet the 'LeoNode' class that is your key to manipulating Leo
-content from IPython!
-
-LeoNode
--------
-
-Suppose that we had a node with headline 'spam' and body: 
-
-['12',2222+32]
-
-we can access it from IPython (or from scripts entered into other Leo nodes!) by doing:
-
-C:leo/src]|19&gt; wb.spam.v
-          &lt;19&gt; ['12', 2254]
-
-'v' attribute stands for 'value', which means the node contents will be run
-through 'eval' and everything you would be able to enter into IPython prompt
-will be converted to objects. This mechanism can be extended far beyond direct
-evaluation (see '@cl definitions').
-
-'v' attribute also has a setter, i.e. you can do:
-
-wb.spam.v = "mystring"
-
-Which will result in the node 'spam' having the following text:
-
-'mystring'
-
-What assignment to 'v' does can be configured through generic functions
-('simplegeneric' module, will be explained later).
-
-Besides v, you can set the body text directly through 
-
-wb.spam.b = "some\nstring", 
-
-headline by 
-
-wb.spam.h = 'new_headline' 
-
-(obviously you must access the node through wb.new_headline from that point
-onwards), and access the contents as string list (IPython SList) through
-'wb.spam.l'.
-
-If you do 'wb.foo.v = 12' when node named 'foo' does not exist, the node titled
-'foo' will be automatically created and assigned body 12.
-
-LeoNode also supports go() that focuses the node in the Leo window, and ipush()
-that simulates pressing alt+I on the node.
-
-You can access unknownAttributes by .uA property dictionary. Unknown attributes
-allow you to store arbitrary (pickleable) python objects in the Leo nodes; the
-attributes are stored when you save the .leo document, and recreated when you
-open the document again. The attributes are not visible anywhere, but can be
-used for domain-specific metatada. Example:
-
-    [C:leo/src]|12&gt; wb.spam.uA['coords'] = (12,222)
-    [C:leo/src]|13&gt; wb.spam.uA
-               &lt;13&gt; {'coords': (12, 222)}    
-
-Accessing children with iteration and dict notation
----------------------------------------------------
-
-Sometimes, you may want to treat a node as a 'database', where the nodes
-children represent elements in the database. You can create a new child node for
-node 'spam', with headline 'foo bar' like this:
-
-    wb.spam['foo bar'] = "Hello"
-
-And assign a new value for it by doing 
-
-    wb.spam['foo bar'].v = "Hello again"
-
-Note how you can't use .v when you first create the node - i.e. the node needs
-to be initialized by simple assignment, that will be interpreted as assignment
-to '.v'. This is a conscious design choice.
-
-If you try to do wb.spam['bar'] = 'Hello', ILeo will assign '@k bar' as the
-headline for the child instead, because 'bar' is a legal python name (and as
-such would be incorporated in the workbook namespace). This is done to avoid
-crowding the workbook namespace with extraneous items. The item will still be
-accessible as wb.spam['bar']
-
-LeoNodes are iterable, so to see the headlines of all the children of 'spam' do:
-
-    for n in wb.spam:
-        print n.h
-</t>
-<t tx="vivainio.20080223134100">
-@cl definitions
-===============
-
-If the first line in the body text is of the form '@cl sometext', IPython will
-evaluate 'sometext' and call the result with the rest of the body when you do
-'wb.foo.v'. An example is in place here. Suppose that we have defined a class (I
-use the term class in a non-python sense here)
-
-{{{
-def rfile(body,node):
-    """ @cl rfile 
-
-    produces a StringIO (file like obj) of the rest of the body """
-
-    import StringIO
-    return StringIO.StringIO(body)
-}}}
-
-(note that node is ignored here - but it could be used to access headline,
-children etc.),
-
-Now, let's say you have node 'spam' with text
-
-{{{
-@cl rfile
-hello
-world
-and whatever
-}}}
-
-Now, in IPython, we can do this:
-
-{{{    
-[C:leo/src]|22&gt; f = wb.spam.v
-[C:leo/src]|23&gt; f
-           &lt;23&gt; &lt;StringIO.StringIO instance at 0x04E7E490&gt;
-[C:leo/src]|24&gt; f.readline()
-           &lt;24&gt; u'hello\n'
-[C:leo/src]|25&gt; f.readline()
-           &lt;25&gt; u'world\n'
-[C:leo/src]|26&gt; f.readline()
-           &lt;26&gt; u'and whatever'
-[C:leo/src]|27&gt; f.readline()
-           &lt;27&gt; u''    
-}}} 
-
-You should declare new @cl types to make ILeo as convenient your problem domain
-as possible. For example, a "@cl etree" could return the elementtree object for
-xml content.
-</t>
-<t tx="vivainio.20080223134118">
-Special node types
-==================
-
-@ipy-startup
-------------
-
-If this node exist, the *direct children* of this will be pushed to IPython when
-ILeo is started (you press alt+5). Use it to push your own @cl definitions etc.
-The contents of of the node itself will be ignored.
-
-@ipy-results
-------------
-
-When you create a new node (wb.foo.v = 'stuff'), the node foo will be created as
-a child of this node. If @ipy-results does not exist, the new node will be created after the currently selected node.
-
-@a nodes
---------
-
-You can attach these as children of existing nodes to provide a way to access
-nodes with arbitrary headlines, or to provide aliases to other nodes. If
-multiple @a nodes are attached as children of a node, all the names can be used
-to access the same object.
-</t>
-<t tx="vivainio.20080223134136">
-Acknowledgements &amp; History
-==========================
-
-This idea got started when I (Ville) saw this post by Edward Ream (the author of
-Leo) on IPython developer mailing list:
-
-    http://lists.ipython.scipy.org/pipermail/ipython-dev/2008-January/003551.html
-
-I was using FreeMind as mind mapping software, and so I had an immediate use
-case for Leo (which, incidentally, is superior to FreeMind as mind mapper). The
-wheels started rolling, I got obsessed with the power of this concept
-(everything clicked together), and Edwards excitement paralleled mine.
-Everything was mind-bogglingly easy/trivial, something that is typical of all
-revolutionary technologies (think Python here).
-
-The discussion that "built" ILeo is here:
-    http://sourceforge.net/forum/forum.php?thread_id=1911662&amp;forum_id=10226    
-
-?</t>
-<t tx="vivainio.20080223134433">
-Declaring custom push-to-ipython handlers
-=========================================
-
-Sometimes, you might want to configure what alt+I on a node does. You can do
-that by creating your own push function and expose it using
-ipy_leo.expose_ileo_push(f, priority). The function should check whether the
-node should by handled by the function and raise IPython.ipapi.TryNext if it
-will not do the handling, giving the next function in the chain a chance to see
-whether it should handle the push.
-
-This example would print an uppercase version of node body if the node headline ends
-with U (yes, this is completely useless!):
-
-{{{
-def push_upcase(node):
-    if not node.h.endswith('U'):
-        raise TryNext
-    print node.b.upper()
-
-ipy_leo.expose_ileo_push(push_upcase, 12)
-}}}
-
-(the priority should be between 0-100 - typically, you don't need to care about
-it and can usually omit the argument altogether)
-</t>
-<t tx="vivainio.20080223142207">
-Example code snippets
-=====================
-
-Get list of all headlines of all the nodes in leo:
-
-    [node.h for node in wb]
-
-Create node with headline 'baz', empty body:
-    wb.baz
-
-Create 10 child nodes for baz, where i is headline and 'Hello ' + i is body:       
-
-    for i in range(10):
-        wb.baz[i] = 'Hello %d' % i
-
-
-</t>
-<t tx="vivainio.20080223142403"></t>
-<t tx="vivainio.20080223142403.1">12</t>
-<t tx="vivainio.20080316085925">array([[ 0,  1,  2],
-       [ 3,  4,  5],
-       [ 6,  7,  8],
-       [ 9, 10, 11]])</t>
-<t tx="vivainio.20080316085950"># press alt+i here to plot testarr
-
-plot(wb.testarr.v)</t>
-<t tx="vivainio.20080316092617"></t>
-<t tx="vivainio.20080316144536">Quickstart:
-    easy_install numpy    
-    easy_install matplotlib
-
-Make sure you have '@string ipython-argv = ipython -pylab' in @settings. We currently recommend using TkAgg as the backend (it's also the default)</t>
-<t tx="vivainio.20080316145539.2">#press alt+i here to generate an array for plotter
-
-wb.testarr.v = arange(12).reshape(4,3)</t>
-</tnodes>
-</leo_file>
diff --git a/docs/examples/core/new-embed.py b/docs/examples/core/new-embed.py
deleted file mode 100644
index f0eddf5bc6c..00000000000
--- a/docs/examples/core/new-embed.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# This shows how to use the new top-level embed function.  It is a simpler
-# API that manages the creation of the embedded shell.
-
-from IPython import embed
-
-a = 10
-b = 20
-
-embed('First time')
-
-c = 30
-d = 40
-
-try:
-    raise Exception('adsfasdf')
-except:
-    embed('The second time')
diff --git a/docs/examples/core/seteditor.py b/docs/examples/core/seteditor.py
deleted file mode 100755
index a2cde04b83a..00000000000
--- a/docs/examples/core/seteditor.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import os
-
-
-editor = r'q:/opt/np/notepad++.exe'
-
-
-e = os.environ
-
-e['EDITOR'] = editor
-e['VISUAL'] = editor
-
-
-
-
-
diff --git a/docs/examples/lib/gui-gtk.py b/docs/examples/lib/gui-gtk.py
deleted file mode 100755
index 6b45ef1dd18..00000000000
--- a/docs/examples/lib/gui-gtk.py
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/usr/bin/env python
-"""Simple GTK example to manually test event loop integration.
-
-This is meant to run tests manually in ipython as:
-
-In [5]: %gui gtk
-
-In [6]: %run gui-gtk.py
-"""
-
-
-import pygtk
-pygtk.require('2.0')
-import gtk
-
-
-def hello_world(wigdet, data=None):
-    print "Hello World"
-
-def delete_event(widget, event, data=None):
-    return False
-
-def destroy(widget, data=None):
-    gtk.main_quit()
-
-window = gtk.Window(gtk.WINDOW_TOPLEVEL)
-window.connect("delete_event", delete_event)
-window.connect("destroy", destroy)
-button = gtk.Button("Hello World")
-button.connect("clicked", hello_world, None)
-
-window.add(button)
-button.show()
-window.show()
-
-try:
-    from IPython.lib.inputhook import appstart_gtk
-    appstart_gtk()
-except ImportError:
-    gtk.main()
-
-
-
diff --git a/docs/examples/lib/gui-mpl.py b/docs/examples/lib/gui-mpl.py
deleted file mode 100644
index c77c70a5c3d..00000000000
--- a/docs/examples/lib/gui-mpl.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""Test the new %gui command.  Run this in ipython as
-
-In [1]: %gui [backend]
-
-In [2]: %run switchgui [backend]
-
-where the optional backend can be one of:  qt4, gtk, tk, wx.
-
-Because of subtle difference in how Matplotlib handles the different GUI 
-toolkits (in things like draw and show), minor modifications to this script
-have to be made for Tk to get it to work with the 0.99 and below releases
-of Matplotlib.  However, in the future, Matplotlib should be able to have 
-similar logic for all the toolkits, as they are all now using PyOS_InputHook.
-"""
-
-import sys
-import time
-
-from  IPython.lib import inputhook
-
-gui = inputhook.current_gui()
-if gui is None:
-    gui = 'qt4'
-    inputhook.enable_qt4(app=True)
-
-backends = dict(wx='wxagg', qt4='qt4agg', gtk='gtkagg', tk='tkagg')
-
-import matplotlib
-matplotlib.use(backends[gui])
-matplotlib.interactive(True)
-
-import matplotlib
-from matplotlib import pyplot as plt, mlab, pylab
-import numpy as np
-
-from numpy import *
-from matplotlib.pyplot import *
-
-x = np.linspace(0,pi,500)
-
-print "A plot has been created"
-line, = plot(x,sin(2*x))
-inputhook.spin() # This has to be removed for Tk
-
-
-print "Now, we will update the plot..."
-print
-for i in range(1,51):
-    print i, 
-    sys.stdout.flush()
-    line.set_data(x,sin(x*i))
-    plt.title('i=%d' % i)
-    plt.draw()
-    inputhook.spin() # This has to be removed for Tk
diff --git a/docs/examples/lib/gui-tk.py b/docs/examples/lib/gui-tk.py
deleted file mode 100644
index f7366aae6d7..00000000000
--- a/docs/examples/lib/gui-tk.py
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-"""Simple Tk example to manually test event loop integration.
-
-This is meant to run tests manually in ipython as:
-
-In [5]: %gui tk
-
-In [6]: %run gui-tk.py
-"""
-
-from Tkinter import *
-
-class MyApp:
-
-    def __init__(self, root):
-        frame = Frame(root)
-        frame.pack()
-
-        self.button = Button(frame, text="Hello", command=self.hello_world)
-        self.button.pack(side=LEFT)
-
-    def hello_world(self):
-        print "Hello World!"
-
-root = Tk()
-
-app = MyApp(root)
-
-try:
-    from IPython import appstart_tk; appstart_tk(root)
-except ImportError:
-    root.mainloop()
diff --git a/docs/examples/lib/gui-wx.py b/docs/examples/lib/gui-wx.py
deleted file mode 100644
index 1ddaf55fc4d..00000000000
--- a/docs/examples/lib/gui-wx.py
+++ /dev/null
@@ -1,109 +0,0 @@
-"""A Simple wx example to test IPython's event loop integration.
-
-To run this do:
-
-In [5]: %gui wx
-
-In [6]: %run gui-wx.py
-
-Ref: Modified from wxPython source code wxPython/samples/simple/simple.py
-
-This example can only be run once in a given IPython session because when 
-the frame is closed, wx goes through its shutdown sequence, killing further
-attempts.  I am sure someone who knows wx can fix this issue.
-
-Furthermore, once this example is run, the Wx event loop is mostly dead, so
-even other new uses of Wx may not work correctly.  If you know how to better
-handle this, please contact the ipython developers and let us know.
-
-Note however that we will work with the Matplotlib and Enthought developers so
-that the main interactive uses of Wx we are aware of, namely these tools, will
-continue to work well with IPython interactively.
-"""
-
-import wx
-
-
-class MyFrame(wx.Frame):
-    """
-    This is MyFrame.  It just shows a few controls on a wxPanel,
-    and has a simple menu.
-    """
-    def __init__(self, parent, title):
-        wx.Frame.__init__(self, parent, -1, title,
-                          pos=(150, 150), size=(350, 200))
-
-        # Create the menubar
-        menuBar = wx.MenuBar()
-
-        # and a menu 
-        menu = wx.Menu()
-
-        # add an item to the menu, using \tKeyName automatically
-        # creates an accelerator, the third param is some help text
-        # that will show up in the statusbar
-        menu.Append(wx.ID_EXIT, "E&xit\tAlt-X", "Exit this simple sample")
-
-        # bind the menu event to an event handler
-        self.Bind(wx.EVT_MENU, self.OnTimeToClose, id=wx.ID_EXIT)
-
-        # and put the menu on the menubar
-        menuBar.Append(menu, "&File")
-        self.SetMenuBar(menuBar)
-
-        self.CreateStatusBar()
-
-        # Now create the Panel to put the other controls on.
-        panel = wx.Panel(self)
-
-        # and a few controls
-        text = wx.StaticText(panel, -1, "Hello World!")
-        text.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
-        text.SetSize(text.GetBestSize())
-        btn = wx.Button(panel, -1, "Close")
-        funbtn = wx.Button(panel, -1, "Just for fun...")
-
-        # bind the button events to handlers
-        self.Bind(wx.EVT_BUTTON, self.OnTimeToClose, btn)
-        self.Bind(wx.EVT_BUTTON, self.OnFunButton, funbtn)
-
-        # Use a sizer to layout the controls, stacked vertically and with
-        # a 10 pixel border around each
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(text, 0, wx.ALL, 10)
-        sizer.Add(btn, 0, wx.ALL, 10)
-        sizer.Add(funbtn, 0, wx.ALL, 10)
-        panel.SetSizer(sizer)
-        panel.Layout()
-
-
-    def OnTimeToClose(self, evt):
-        """Event handler for the button click."""
-        print "See ya later!"
-        self.Close()
-
-    def OnFunButton(self, evt):
-        """Event handler for the button click."""
-        print "Having fun yet?"
-
-
-class MyApp(wx.App):
-    def OnInit(self):
-        frame = MyFrame(None, "Simple wxPython App")
-        self.SetTopWindow(frame)
-
-        print "Print statements go to this stdout window by default."
-
-        frame.Show(True)
-        return True
-
-app = wx.GetApp()
-if app is None:
-    app = MyApp(redirect=False, clearSigInt=False)
-
-try:
-    from IPython.lib.inputhook import appstart_wx
-    appstart_wx(app)
-except ImportError:
-    app.MainLoop()
-
diff --git a/docs/examples/newparallel/dagdeps.py b/docs/examples/newparallel/dagdeps.py
deleted file mode 100644
index edc6cb94500..00000000000
--- a/docs/examples/newparallel/dagdeps.py
+++ /dev/null
@@ -1,120 +0,0 @@
-"""Example for generating an arbitrary DAG as a dependency map.
-
-This demo uses networkx to generate the graph.
-
-Authors
--------
-* MinRK
-"""
-import networkx as nx
-from random import randint, random
-from IPython import parallel
-
-def randomwait():
-    import time
-    from random import random
-    time.sleep(random())
-    return time.time()
-
-
-def random_dag(nodes, edges):
-    """Generate a random Directed Acyclic Graph (DAG) with a given number of nodes and edges."""
-    G = nx.DiGraph()
-    for i in range(nodes):
-        G.add_node(i)
-    while edges > 0:
-        a = randint(0,nodes-1)
-        b=a
-        while b==a:
-            b = randint(0,nodes-1)
-        G.add_edge(a,b)
-        if nx.is_directed_acyclic_graph(G):
-            edges -= 1
-        else:
-            # we closed a loop!
-            G.remove_edge(a,b)
-    return G
-
-def add_children(G, parent, level, n=2):
-    """Add children recursively to a binary tree."""
-    if level == 0:
-        return
-    for i in range(n):
-        child = parent+str(i)
-        G.add_node(child)
-        G.add_edge(parent,child)
-        add_children(G, child, level-1, n)
-
-def make_bintree(levels):
-    """Make a symmetrical binary tree with @levels"""
-    G = nx.DiGraph()
-    root = '0'
-    G.add_node(root)
-    add_children(G, root, levels, 2)
-    return G
-
-def submit_jobs(view, G, jobs):
-    """Submit jobs via client where G describes the time dependencies."""
-    results = {}
-    for node in nx.topological_sort(G):
-        with view.temp_flags(after=[ results[n] for n in G.predecessors(node) ]):
-            results[node] = view.apply(jobs[node])
-    return results
-
-def validate_tree(G, results):
-    """Validate that jobs executed after their dependencies."""
-    for node in G:
-        started = results[node].metadata.started
-        for parent in G.predecessors(node):
-            finished = results[parent].metadata.completed
-            assert started > finished, "%s should have happened after %s"%(node, parent)
-
-def main(nodes, edges):
-    """Generate a random graph, submit jobs, then validate that the
-    dependency order was enforced.
-    Finally, plot the graph, with time on the x-axis, and
-    in-degree on the y (just for spread).  All arrows must
-    point at least slightly to the right if the graph is valid.
-    """
-    from matplotlib import pyplot as plt
-    from matplotlib.dates import date2num
-    from matplotlib.cm import gist_rainbow
-    print "building DAG"
-    G = random_dag(nodes, edges)
-    jobs = {}
-    pos = {}
-    colors = {}
-    for node in G:
-        jobs[node] = randomwait
-    
-    client = parallel.Client()
-    view = client.load_balanced_view()
-    print "submitting %i tasks with %i dependencies"%(nodes,edges)
-    results = submit_jobs(view, G, jobs)
-    print "waiting for results"
-    view.wait()
-    print "done"
-    for node in G:
-        md = results[node].metadata
-        start = date2num(md.started)
-        runtime = date2num(md.completed) - start
-        pos[node] = (start, runtime)
-        colors[node] = md.engine_id
-    validate_tree(G, results)
-    nx.draw(G, pos, node_list=colors.keys(), node_color=colors.values(), cmap=gist_rainbow,
-            with_labels=False)
-    x,y = zip(*pos.values())
-    xmin,ymin = map(min, (x,y))
-    xmax,ymax = map(max, (x,y))
-    xscale = xmax-xmin
-    yscale = ymax-ymin
-    plt.xlim(xmin-xscale*.1,xmax+xscale*.1)
-    plt.ylim(ymin-yscale*.1,ymax+yscale*.1)
-    return G,results
-
-if __name__ == '__main__':
-    from matplotlib import pyplot as plt
-    # main(5,10)
-    main(32,96)
-    plt.show()
-    
\ No newline at end of file
diff --git a/docs/examples/newparallel/davinci/pwordfreq.py b/docs/examples/newparallel/davinci/pwordfreq.py
deleted file mode 100644
index 8b9b02bbd44..00000000000
--- a/docs/examples/newparallel/davinci/pwordfreq.py
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/usr/bin/env python
-"""Parallel word frequency counter.
-
-This only works for a local cluster, because the filenames are local paths.
-"""
-
-
-import os
-import urllib
-
-from itertools import repeat
-
-from wordfreq import print_wordfreq, wordfreq
-
-from IPython.parallel import Client, Reference
-
-davinci_url = "http://www.gutenberg.org/cache/epub/5000/pg5000.txt"
-
-def pwordfreq(view, fnames):
-    """Parallel word frequency counter.
-    
-    view - An IPython DirectView
-    fnames - The filenames containing the split data.
-    """
-    assert len(fnames) == len(view.targets)
-    view.scatter('fname', fnames, flatten=True)
-    ar = view.apply(wordfreq, Reference('fname'))
-    freqs_list = ar.get()
-    word_set = set()
-    for f in freqs_list:
-        word_set.update(f.keys())
-    freqs = dict(zip(word_set, repeat(0)))
-    for f in freqs_list:
-        for word, count in f.iteritems():
-            freqs[word] += count
-    return freqs
-
-if __name__ == '__main__':
-    # Create a Client and View
-    rc = Client()
-    
-    view = rc[:]
-
-    if not os.path.exists('davinci.txt'):
-        # download from project gutenberg
-        print "Downloading Da Vinci's notebooks from Project Gutenberg"
-        urllib.urlretrieve(davinci_url, 'davinci.txt')
-        
-    # Run the serial version
-    print "Serial word frequency count:"
-    text = open('davinci.txt').read()
-    freqs = wordfreq(text)
-    print_wordfreq(freqs, 10)
-    
-    
-    # The parallel version
-    print "\nParallel word frequency count:"
-    # split the davinci.txt into one file per engine:
-    lines = text.splitlines()
-    nlines = len(lines)
-    n = len(rc)
-    block = nlines/n
-    for i in range(n):
-        chunk = lines[i*block:i*(block+1)]
-        with open('davinci%i.txt'%i, 'w') as f:
-            f.write('\n'.join(chunk))
-    
-    cwd = os.path.abspath(os.getcwd())
-    fnames = [ os.path.join(cwd, 'davinci%i.txt'%i) for i in range(n)]
-    pfreqs = pwordfreq(view,fnames)
-    print_wordfreq(freqs)
-    # cleanup split files
-    map(os.remove, fnames)
diff --git a/docs/examples/newparallel/davinci/wordfreq.py b/docs/examples/newparallel/davinci/wordfreq.py
deleted file mode 100644
index 8899751a6e4..00000000000
--- a/docs/examples/newparallel/davinci/wordfreq.py
+++ /dev/null
@@ -1,68 +0,0 @@
-"""Count the frequencies of words in a string"""
-
-from __future__ import division
-
-import cmath as math
-
-
-def wordfreq(text, is_filename=False):
-    """Return a dictionary of words and word counts in a string."""
-    if is_filename:
-        with open(text) as f:
-            text = f.read()
-    freqs = {}
-    for word in text.split():
-        lword = word.lower()
-        freqs[lword] = freqs.get(lword, 0) + 1
-    return freqs
-
-
-def print_wordfreq(freqs, n=10):
-    """Print the n most common words and counts in the freqs dict."""
-    
-    words, counts = freqs.keys(), freqs.values()
-    items = zip(counts, words)
-    items.sort(reverse=True)
-    for (count, word) in items[:n]:
-        print word, count
-
-
-def wordfreq_to_weightsize(worddict, minsize=25, maxsize=50, minalpha=0.5, maxalpha=1.0):
-    mincount = min(worddict.itervalues())
-    maxcount = max(worddict.itervalues())
-    weights = {}
-    for k, v in worddict.iteritems():
-        w = (v-mincount)/(maxcount-mincount)
-        alpha = minalpha + (maxalpha-minalpha)*w
-        size = minsize + (maxsize-minsize)*w
-        weights[k] = (alpha, size)
-    return weights
-
-
-def tagcloud(worddict, n=10, minsize=25, maxsize=50, minalpha=0.5, maxalpha=1.0):
-    from matplotlib import pyplot as plt
-    import random
-
-    worddict = wordfreq_to_weightsize(worddict, minsize, maxsize, minalpha, maxalpha)
-
-    fig = plt.figure()
-    ax = fig.add_subplot(111)
-    ax.set_position([0.0,0.0,1.0,1.0])
-    plt.xticks([])
-    plt.yticks([])
-
-    words = worddict.keys()
-    alphas = [v[0] for v in worddict.values()]
-    sizes = [v[1] for v in worddict.values()]
-    items = zip(alphas, sizes, words)
-    items.sort(reverse=True)
-    for alpha, size, word in items[:n]:
-        # xpos = random.normalvariate(0.5, 0.3)
-        # ypos = random.normalvariate(0.5, 0.3)
-        xpos = random.uniform(0.0,1.0)
-        ypos = random.uniform(0.0,1.0)
-        ax.text(xpos, ypos, word.lower(), alpha=alpha, fontsize=size)
-    ax.autoscale_view()
-    return ax
-    
-    
\ No newline at end of file
diff --git a/docs/examples/newparallel/demo/dependencies.py b/docs/examples/newparallel/demo/dependencies.py
deleted file mode 100644
index 3cf15662d0f..00000000000
--- a/docs/examples/newparallel/demo/dependencies.py
+++ /dev/null
@@ -1,128 +0,0 @@
-from IPython.parallel import *
-
-client = Client()
-
-# this will only run on machines that can import numpy:
-@require('numpy')
-def norm(A):
-    from numpy.linalg import norm
-    return norm(A,2)
-
-def checkpid(pid):
-    """return the pid of the engine"""
-    import os
-    return os.getpid() == pid
-
-def checkhostname(host):
-    import socket
-    return socket.gethostname() == host
-
-def getpid():
-    import os
-    return os.getpid()
-
-pid0 = client[0].apply_sync(getpid)
-
-# this will depend on the pid being that of target 0:
-@depend(checkpid, pid0)
-def getpid2():
-    import os
-    return os.getpid()
-
-view = client.load_balanced_view()
-view.block=True
-
-# will run on anything:
-pids1 = [ view.apply(getpid) for i in range(len(client.ids)) ]
-print pids1
-# will only run on e0:
-pids2 = [ view.apply(getpid2) for i in range(len(client.ids)) ]
-print pids2
-
-print "now test some dependency behaviors"
-
-def wait(t):
-    import time
-    time.sleep(t)
-    return t
-
-# fail after some time:
-def wait_and_fail(t):
-    import time
-    time.sleep(t)
-    return 1/0
-
-successes = [ view.apply_async(wait, 1).msg_ids[0] for i in range(len(client.ids)) ]
-failures = [ view.apply_async(wait_and_fail, 1).msg_ids[0] for i in range(len(client.ids)) ]
-
-mixed = [failures[0],successes[0]]
-d1a = Dependency(mixed, all=False, failure=True) # yes
-d1b = Dependency(mixed, all=False) # yes
-d2a = Dependency(mixed, all=True, failure=True) # yes after / no follow
-d2b = Dependency(mixed, all=True) # no
-d3 = Dependency(failures, all=False) # no
-d4 = Dependency(failures, all=False, failure=True) # yes
-d5 = Dependency(failures, all=True, failure=True) # yes after / no follow
-d6 = Dependency(successes, all=True, failure=True) # yes after / no follow
-
-view.block = False
-flags = view.temp_flags
-with flags(after=d1a):
-    r1a = view.apply(getpid)
-with flags(follow=d1b):
-    r1b = view.apply(getpid)
-with flags(after=d2b, follow=d2a):
-    r2a = view.apply(getpid)
-with flags(after=d2a, follow=d2b):
-    r2b = view.apply(getpid)
-with flags(after=d3):
-    r3 = view.apply(getpid)
-with flags(after=d4):
-    r4a = view.apply(getpid)
-with flags(follow=d4):
-    r4b = view.apply(getpid)
-with flags(after=d3, follow=d4):
-    r4c = view.apply(getpid)
-with flags(after=d5):
-    r5 = view.apply(getpid)
-with flags(follow=d5, after=d3):
-    r5b = view.apply(getpid)
-with flags(follow=d6):
-    r6 = view.apply(getpid)
-with flags(after=d6, follow=d2b):
-    r6b = view.apply(getpid)
-
-def should_fail(f):
-    try:
-        f()
-    except error.KernelError:
-        pass
-    else:
-        print 'should have raised'
-        # raise Exception("should have raised")
-
-# print r1a.msg_ids
-r1a.get()
-# print r1b.msg_ids
-r1b.get()
-# print r2a.msg_ids
-should_fail(r2a.get)
-# print r2b.msg_ids
-should_fail(r2b.get)
-# print r3.msg_ids
-should_fail(r3.get)
-# print r4a.msg_ids
-r4a.get()
-# print r4b.msg_ids
-r4b.get()
-# print r4c.msg_ids
-should_fail(r4c.get)
-# print r5.msg_ids
-r5.get()
-# print r5b.msg_ids
-should_fail(r5b.get)
-# print r6.msg_ids
-should_fail(r6.get) # assuming > 1 engine
-# print r6b.msg_ids
-should_fail(r6b.get)
-print 'done'
diff --git a/docs/examples/newparallel/demo/map.py b/docs/examples/newparallel/demo/map.py
deleted file mode 100644
index d0316d16d69..00000000000
--- a/docs/examples/newparallel/demo/map.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from IPython.parallel import *
-
-client = Client()
-view = client[:]
-
-@view.remote(block=True)
-def square(a):
-    """return square of a number"""
-    return a*a
-
-squares = map(square, range(42))
-
-# but that blocked between each result; not exactly useful
-
-square.block = False
-
-arlist = map(square, range(42))
-# submitted very fast
-
-# wait for the results:
-squares2 = [ r.get() for r in arlist ]
-
-# now the more convenient @parallel decorator, which has a map method:
-
-@view.parallel(block=False)
-def psquare(a):
-    """return square of a number"""
-    return a*a
-
-# this chunks the data into n-negines jobs, not 42 jobs:
-ar = psquare.map(range(42))
-
-# wait for the results to be done:
-squares3 = ar.get()
-
-print squares == squares2, squares3==squares
-# True
\ No newline at end of file
diff --git a/docs/examples/newparallel/demo/noncopying.py b/docs/examples/newparallel/demo/noncopying.py
deleted file mode 100644
index 6fe721796b0..00000000000
--- a/docs/examples/newparallel/demo/noncopying.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""non-copying sends"""
-import zmq
-import numpy
-
-n = 10
-iface = 'inproc://pub'
-
-ctx = zmq.Context()
-
-p = ctx.socket(zmq.PUB)
-p.bind(iface)
-
-# connect 2 subs
-s1 = ctx.socket(zmq.SUB)
-s1.connect(iface)
-s1.setsockopt(zmq.SUBSCRIBE, '')
-
-s2 = ctx.socket(zmq.SUB)
-s2.connect(iface)
-s2.setsockopt(zmq.SUBSCRIBE, '')
-
-A = numpy.random.random((1024,1024))
-
-# send
-p.send(A, copy=False)
-# recv on 1 non-copy
-msg1 = s1.recv(copy=False)
-B1 = numpy.frombuffer(msg1.buffer, dtype=A.dtype).reshape(A.shape)
-# recv on 2 copy
-msg2 = s2.recv(copy=False)
-B2 = numpy.frombuffer(buffer(msg2.bytes), dtype=A.dtype).reshape(A.shape)
-
-print (B1==B2).all()
-print (B1==A).all()
-A[0][0] += 10
-print "~"
-# after changing A in-place, B1 changes too, proving non-copying sends
-print (B1==A).all()
-# but B2 is fixed, since it called the msg.bytes attr, which copies
-print (B1==B2).all()
-
-
-
-
diff --git a/docs/examples/newparallel/demo/throughput.py b/docs/examples/newparallel/demo/throughput.py
deleted file mode 100644
index b9eaa08a2ae..00000000000
--- a/docs/examples/newparallel/demo/throughput.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import time
-import numpy as np
-from IPython import parallel
-
-nlist = map(int, np.logspace(2,9,16,base=2))
-nlist2 = map(int, np.logspace(2,8,15,base=2))
-tlist = map(int, np.logspace(7,22,16,base=2))
-nt = 16
-def wait(t=0):
-    import time
-    time.sleep(t)
-
-def echo(s=''):
-    return s
-
-def time_throughput(nmessages, t=0, f=wait):
-    client = parallel.Client()
-    view = client[None]
-    # do one ping before starting timing
-    if f is echo:
-        t = np.random.random(t/8)
-    view.apply_sync(echo, '')
-    client.spin()
-    tic = time.time()
-    for i in xrange(nmessages):
-        view.apply(f, t)
-    lap = time.time()
-    client.barrier()
-    toc = time.time()
-    return lap-tic, toc-tic
-
-def time_twisted(nmessages, t=0, f=wait):
-    from IPython.kernel import client as kc
-    client = kc.TaskClient()
-    if f is wait:
-        s = "import time; time.sleep(%f)"%t
-        task = kc.StringTask(s)
-    elif f is echo:
-        t = np.random.random(t/8)
-        s = "s=t"
-        task = kc.StringTask(s, push=dict(t=t), pull=['s'])
-    else:
-        raise
-    # do one ping before starting timing
-    client.barrier(client.run(task))
-    tic = time.time()
-    tids = []
-    for i in xrange(nmessages):
-        tids.append(client.run(task))
-    lap = time.time()
-    client.barrier(tids)
-    toc = time.time()
-    return lap-tic, toc-tic
-
-def do_runs(nlist,t=0,f=wait, trials=2, runner=time_throughput):
-    A = np.zeros((len(nlist),2))
-    for i,n in enumerate(nlist):
-        t1 = t2 = 0
-        for _ in range(trials):
-            time.sleep(.25)
-            ts = runner(n,t,f)
-            t1 += ts[0]
-            t2 += ts[1]
-        t1 /= trials
-        t2 /= trials
-        A[i] = (t1,t2)
-        A[i] = n/A[i]
-        print n,A[i]
-    return A
-
-def do_echo(n,tlist=[0],f=echo, trials=2, runner=time_throughput):
-    A = np.zeros((len(tlist),2))
-    for i,t in enumerate(tlist):
-        t1 = t2 = 0
-        for _ in range(trials):
-            time.sleep(.25)
-            ts = runner(n,t,f)
-            t1 += ts[0]
-            t2 += ts[1]
-        t1 /= trials
-        t2 /= trials
-        A[i] = (t1,t2)
-        A[i] = n/A[i]
-        print t,A[i]
-    return A
-    
\ No newline at end of file
diff --git a/docs/examples/newparallel/demo/views.py b/docs/examples/newparallel/demo/views.py
deleted file mode 100644
index 78f857fec70..00000000000
--- a/docs/examples/newparallel/demo/views.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from IPython.parallel import *
-
-client = Client()
-
-for id in client.ids:
-    client[id].push(dict(ids=id*id))
-
-v = client[0]
-v['a'] = 5
-
-print v['a']
-
-remotes = client[:]
-
-print remotes['ids']
\ No newline at end of file
diff --git a/docs/examples/newparallel/fetchparse.py b/docs/examples/newparallel/fetchparse.py
deleted file mode 100644
index 0d2d16202c8..00000000000
--- a/docs/examples/newparallel/fetchparse.py
+++ /dev/null
@@ -1,97 +0,0 @@
-"""
-An exceptionally lousy site spider
-Ken Kinder <ken@kenkinder.com>
-
-Updated for newparallel by Min Ragan-Kelley <benjaminrk@gmail.com>
-
-This module gives an example of how the task interface to the 
-IPython controller works.  Before running this script start the IPython controller
-and some engines using something like::
-
-    ipclusterz start -n 4
-"""
-import sys
-from IPython.parallel import Client, error
-import time
-import BeautifulSoup # this isn't necessary, but it helps throw the dependency error earlier
-
-def fetchAndParse(url, data=None):
-    import urllib2
-    import urlparse
-    import BeautifulSoup
-    links = []
-    try:
-        page = urllib2.urlopen(url, data=data)
-    except Exception:
-        return links
-    else:
-        if page.headers.type == 'text/html':
-            doc = BeautifulSoup.BeautifulSoup(page.read())
-            for node in doc.findAll('a'):
-                href = node.get('href', None)
-                if href:
-                    links.append(urlparse.urljoin(url, href))
-        return links
-
-class DistributedSpider(object):
-    
-    # Time to wait between polling for task results.
-    pollingDelay = 0.5
-    
-    def __init__(self, site):
-        self.client = Client()
-        self.view = self.client.load_balanced_view()
-        self.mux = self.client[:]
-        
-        self.allLinks = []
-        self.linksWorking = {}
-        self.linksDone = {}
-        
-        self.site = site
-        
-    def visitLink(self, url):
-        if url not in self.allLinks:
-            self.allLinks.append(url)
-            if url.startswith(self.site):
-                print '    ', url
-                self.linksWorking[url] = self.view.apply(fetchAndParse, url)
-        
-    def onVisitDone(self, links, url):
-        print url, ':'
-        self.linksDone[url] = None
-        del self.linksWorking[url]
-        for link in links:
-            self.visitLink(link)
-                
-    def run(self):
-        self.visitLink(self.site)
-        while self.linksWorking:
-            print len(self.linksWorking), 'pending...'
-            self.synchronize()
-            time.sleep(self.pollingDelay)
-    
-    def synchronize(self):
-        for url, ar in self.linksWorking.items():
-            # Calling get_task_result with block=False will return None if the
-            # task is not done yet.  This provides a simple way of polling.
-            try:
-                links = ar.get(0)
-            except error.TimeoutError:
-                continue
-            except Exception as e:
-                self.linksDone[url] = None
-                del self.linksWorking[url]
-                print url, ':', e.traceback
-            else:
-                self.onVisitDone(links, url)
-
-def main():
-    if len(sys.argv) > 1:
-        site = sys.argv[1]
-    else:
-        site = raw_input('Enter site to crawl: ')
-    distributedSpider = DistributedSpider(site)
-    distributedSpider.run()
-
-if __name__ == '__main__':
-    main()
diff --git a/docs/examples/newparallel/helloworld.py b/docs/examples/newparallel/helloworld.py
deleted file mode 100644
index 8b29f4d31f7..00000000000
--- a/docs/examples/newparallel/helloworld.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""
-A Distributed Hello world
-Ken Kinder <ken@kenkinder.com>
-"""
-from IPython.parallel import Client
-
-rc = Client()
-
-def sleep_and_echo(t, msg):
-    import time
-    time.sleep(t)
-    return msg
-    
-view = rc.load_balanced_view()
-
-world = view.apply_async(sleep_and_echo, 3, 'World!')
-hello = view.apply_async(sleep_and_echo, 2, 'Hello')
-print "Submitted tasks:", hello.msg_ids, world.msg_ids
-print hello.get(), world.get()
diff --git a/docs/examples/newparallel/interengine/communicator.py b/docs/examples/newparallel/interengine/communicator.py
deleted file mode 100644
index 959e30fa6ab..00000000000
--- a/docs/examples/newparallel/interengine/communicator.py
+++ /dev/null
@@ -1,77 +0,0 @@
-import socket
-
-import uuid
-import zmq
-
-from IPython.parallel.util import disambiguate_url
-
-class EngineCommunicator(object):
-    
-    def __init__(self, interface='tcp://*', identity=None):
-        self._ctx = zmq.Context()
-        self.socket = self._ctx.socket(zmq.XREP)
-        self.pub = self._ctx.socket(zmq.PUB)
-        self.sub = self._ctx.socket(zmq.SUB)
-        
-        # configure sockets
-        self.identity = identity or bytes(uuid.uuid4())
-        print self.identity
-        self.socket.setsockopt(zmq.IDENTITY, self.identity)
-        self.sub.setsockopt(zmq.SUBSCRIBE, b'')
-        
-        # bind to ports
-        port = self.socket.bind_to_random_port(interface)
-        pub_port = self.pub.bind_to_random_port(interface)
-        self.url = interface+":%i"%port
-        self.pub_url = interface+":%i"%pub_port
-        # guess first public IP from socket
-        self.location = socket.gethostbyname_ex(socket.gethostname())[-1][0]
-        self.peers = {}
-    
-    def __del__(self):
-        self.socket.close()
-        self.pub.close()
-        self.sub.close()
-        self._ctx.term()
-    
-    @property
-    def info(self):
-        """return the connection info for this object's sockets."""
-        return (self.identity, self.url, self.pub_url, self.location)
-    
-    def connect(self, peers):
-        """connect to peers.  `peers` will be a dict of 4-tuples, keyed by name.
-        {peer : (ident, addr, pub_addr, location)}
-        where peer is the name, ident is the XREP identity, addr,pub_addr are the
-        """
-        for peer, (ident, url, pub_url, location) in peers.items():
-            self.peers[peer] = ident
-            if ident != self.identity:
-                self.sub.connect(disambiguate_url(pub_url, location))
-            if ident > self.identity:
-                # prevent duplicate xrep, by only connecting
-                # engines to engines with higher IDENTITY
-                # a doubly-connected pair will crash
-                self.socket.connect(disambiguate_url(url, location))
-    
-    def send(self, peers, msg, flags=0, copy=True):
-        if not isinstance(peers, list):
-            peers = [peers]
-        if not isinstance(msg, list):
-            msg = [msg]
-        for p in peers:
-            ident = self.peers[p]
-            self.socket.send_multipart([ident]+msg, flags=flags, copy=copy)
-        
-    def recv(self, flags=0, copy=True):
-        return self.socket.recv_multipart(flags=flags, copy=copy)[1:]
-    
-    def publish(self, msg, flags=0, copy=True):
-        if not isinstance(msg, list):
-            msg = [msg]
-        self.pub.send_multipart(msg, copy=copy)
-
-    def consume(self, flags=0, copy=True):
-        return self.sub.recv_multipart(flags=flags, copy=copy)
-    
-
diff --git a/docs/examples/newparallel/interengine/interengine.py b/docs/examples/newparallel/interengine/interengine.py
deleted file mode 100644
index 865c80230e1..00000000000
--- a/docs/examples/newparallel/interengine/interengine.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import sys
-
-from IPython.parallel import Client
-
-
-rc = Client()
-rc.block=True
-view = rc[:]
-view.run('communicator.py')
-view.execute('com = EngineCommunicator()')
-
-# gather the connection information into a dict
-ar = view.apply_async(lambda : com.info)
-peers = ar.get_dict()
-# this is a dict, keyed by engine ID, of the connection info for the EngineCommunicators
-
-# connect the engines to each other:
-view.apply_sync(lambda pdict: com.connect(pdict), peers)
-
-# now all the engines are connected, and we can communicate between them:
-
-def broadcast(client, sender, msg_name, dest_name=None, block=None):
-    """broadcast a message from one engine to all others."""
-    dest_name = msg_name if dest_name is None else dest_name
-    client[sender].execute('com.publish(%s)'%msg_name, block=None)
-    targets = client.ids
-    targets.remove(sender)
-    return client[targets].execute('%s=com.consume()'%dest_name, block=None)
-
-def send(client, sender, targets, msg_name, dest_name=None, block=None):
-    """send a message from one to one-or-more engines."""
-    dest_name = msg_name if dest_name is None else dest_name
-    def _send(targets, m_name):
-        msg = globals()[m_name]
-        return com.send(targets, msg)
-        
-    client[sender].apply_async(_send, targets, msg_name)
-    
-    return client[targets].execute('%s=com.recv()'%dest_name, block=None)
-
-
-
-
diff --git a/docs/examples/newparallel/mcdriver.py b/docs/examples/newparallel/mcdriver.py
deleted file mode 100644
index c0e1abd5c30..00000000000
--- a/docs/examples/newparallel/mcdriver.py
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/usr/bin/env python
-"""Run a Monte-Carlo options pricer in parallel."""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-import time
-from IPython.parallel import Client
-import numpy as np
-from mcpricer import price_options
-from matplotlib import pyplot as plt
-
-#-----------------------------------------------------------------------------
-# Setup parameters for the run
-#-----------------------------------------------------------------------------
-
-def ask_question(text, the_type, default):
-    s = '%s [%r]: ' % (text, the_type(default))
-    result = raw_input(s)
-    if result:
-        return the_type(result)
-    else:
-        return the_type(default)
-
-cluster_profile = ask_question("Cluster profile", str, "default")
-price = ask_question("Initial price", float, 100.0)
-rate = ask_question("Interest rate", float, 0.05)
-days = ask_question("Days to expiration", int, 260)
-paths = ask_question("Number of MC paths", int, 10000)
-n_strikes = ask_question("Number of strike values", int, 5)
-min_strike = ask_question("Min strike price", float, 90.0)
-max_strike = ask_question("Max strike price", float, 110.0)
-n_sigmas = ask_question("Number of volatility values", int, 5)
-min_sigma = ask_question("Min volatility", float, 0.1)
-max_sigma = ask_question("Max volatility", float, 0.4)
-
-strike_vals = np.linspace(min_strike, max_strike, n_strikes)
-sigma_vals = np.linspace(min_sigma, max_sigma, n_sigmas)
-
-#-----------------------------------------------------------------------------
-# Setup for parallel calculation
-#-----------------------------------------------------------------------------
-
-# The Client is used to setup the calculation and works with all
-# engines.
-c = Client(profile=cluster_profile)
-
-# A LoadBalancedView is an interface to the engines that provides dynamic load 
-# balancing at the expense of not knowing which engine will execute the code.
-view = c.load_balanced_view()
-
-# Initialize the common code on the engines. This Python module has the
-# price_options function that prices the options.
-
-#-----------------------------------------------------------------------------
-# Perform parallel calculation
-#-----------------------------------------------------------------------------
-
-print "Running parallel calculation over strike prices and volatilities..."
-print "Strike prices: ", strike_vals
-print "Volatilities: ", sigma_vals
-sys.stdout.flush()
-
-# Submit tasks to the TaskClient for each (strike, sigma) pair as a MapTask.
-t1 = time.time()
-async_results = []
-for strike in strike_vals:
-    for sigma in sigma_vals:
-        ar = view.apply_async(price_options, price, strike, sigma, rate, days, paths)
-        async_results.append(ar)
-
-print "Submitted tasks: ", len(async_results)
-sys.stdout.flush()
-
-# Block until all tasks are completed.
-c.wait(async_results)
-t2 = time.time()
-t = t2-t1
-
-print "Parallel calculation completed, time = %s s" % t
-print "Collecting results..."
-
-# Get the results using TaskClient.get_task_result.
-results = [ar.get() for ar in async_results]
-
-# Assemble the result into a structured NumPy array.
-prices = np.empty(n_strikes*n_sigmas,
-    dtype=[('ecall',float),('eput',float),('acall',float),('aput',float)]
-)
-
-for i, price in enumerate(results):
-    prices[i] = tuple(price)
-    
-prices.shape = (n_strikes, n_sigmas)
-strike_mesh, sigma_mesh = np.meshgrid(strike_vals, sigma_vals)
-
-print "Results are available: strike_mesh, sigma_mesh, prices"
-print "To plot results type 'plot_options(sigma_mesh, strike_mesh, prices)'"
-
-#-----------------------------------------------------------------------------
-# Utilities
-#-----------------------------------------------------------------------------
-
-def plot_options(sigma_mesh, strike_mesh, prices):
-    """
-    Make a contour plot of the option price in (sigma, strike) space.
-    """
-    plt.figure(1)
-    
-    plt.subplot(221)
-    plt.contourf(sigma_mesh, strike_mesh, prices['ecall'])
-    plt.axis('tight')
-    plt.colorbar()
-    plt.title('European Call')
-    plt.ylabel("Strike Price")
-
-    plt.subplot(222)
-    plt.contourf(sigma_mesh, strike_mesh, prices['acall'])
-    plt.axis('tight')
-    plt.colorbar()
-    plt.title("Asian Call")
-
-    plt.subplot(223)
-    plt.contourf(sigma_mesh, strike_mesh, prices['eput'])
-    plt.axis('tight')
-    plt.colorbar()
-    plt.title("European Put")
-    plt.xlabel("Volatility")
-    plt.ylabel("Strike Price")
-
-    plt.subplot(224)
-    plt.contourf(sigma_mesh, strike_mesh, prices['aput'])
-    plt.axis('tight')
-    plt.colorbar()
-    plt.title("Asian Put")
-    plt.xlabel("Volatility")
-
-
-
-    
-
-
diff --git a/docs/examples/newparallel/mcpricer.py b/docs/examples/newparallel/mcpricer.py
deleted file mode 100644
index ec935b4d745..00000000000
--- a/docs/examples/newparallel/mcpricer.py
+++ /dev/null
@@ -1,45 +0,0 @@
-
-def price_options(S=100.0, K=100.0, sigma=0.25, r=0.05, days=260, paths=10000):
-    """
-    Price European and Asian options using a Monte Carlo method.
-
-    Parameters
-    ----------
-    S : float
-        The initial price of the stock.
-    K : float
-        The strike price of the option.
-    sigma : float
-        The volatility of the stock.
-    r : float
-        The risk free interest rate.
-    days : int
-        The number of days until the option expires.
-    paths : int
-        The number of Monte Carlo paths used to price the option.
-
-    Returns
-    -------
-    A tuple of (E. call, E. put, A. call, A. put) option prices.
-    """
-    import numpy as np
-    from math import exp,sqrt
-    
-    h = 1.0/days
-    const1 = exp((r-0.5*sigma**2)*h)
-    const2 = sigma*sqrt(h)
-    stock_price = S*np.ones(paths, dtype='float64')
-    stock_price_sum = np.zeros(paths, dtype='float64')
-    for j in range(days):
-        growth_factor = const1*np.exp(const2*np.random.standard_normal(paths))
-        stock_price = stock_price*growth_factor
-        stock_price_sum = stock_price_sum + stock_price
-    stock_price_avg = stock_price_sum/days
-    zeros = np.zeros(paths, dtype='float64')
-    r_factor = exp(-r*h*days)
-    euro_put = r_factor*np.mean(np.maximum(zeros, K-stock_price))
-    asian_put = r_factor*np.mean(np.maximum(zeros, K-stock_price_avg))
-    euro_call = r_factor*np.mean(np.maximum(zeros, stock_price-K))
-    asian_call = r_factor*np.mean(np.maximum(zeros, stock_price_avg-K))
-    return (euro_call, euro_put, asian_call, asian_put)
-
diff --git a/docs/examples/newparallel/multiengine1.ipy b/docs/examples/newparallel/multiengine1.ipy
deleted file mode 100644
index 746a1d1d9e3..00000000000
--- a/docs/examples/newparallel/multiengine1.ipy
+++ /dev/null
@@ -1,212 +0,0 @@
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import time
-import numpy
-
-# import IPython.kernel.magic
-from IPython.parallel import Client, Reference
-from IPython.parallel import error
-
-rc = Client()
-mux = rc[:]
-
-#-------------------------------------------------------------------------------
-# Setup
-#-------------------------------------------------------------------------------
-
-%load_ext parallelmagic
-
-mux.block = True
-mux.clear()
-mux.activate()
-
-n = len(rc)
-assert n >= 4, "Not Enough Engines: %i, 4 needed for this script"%n
-
-values = [
-    10,
-    1.0,
-    range(100),
-    ('asdf', 1000),
-    {'a': 10, 'b': 20}
-    ]
-
-keys = ['a','b','c','d','e']
-
-sequences = [
-    range(100),
-    numpy.arange(100)
-]
-
-#-------------------------------------------------------------------------------
-# Blocking execution
-#-------------------------------------------------------------------------------
-
-# Execute
-
-with mux.sync_imports():
-    import math
-    import numpy
-
-mux.execute('a = 2.0*math.pi')
-print mux['a']
-
-for id in mux.targets:
-    mux.execute('b=%d' % id, targets=id)
-
-
-try:
-    mux.execute('b = 10',targets=max(mux.targets)+1)
-except IndexError:
-    print "Caught invalid engine ID OK."
-
-try:
-    mux.apply(lambda : 1/0)
-except error.CompositeError:
-    print "Caught 1/0 correctly."
-
-
-
-%px print a, b
-
-try:
-    %px 1/0
-except error.CompositeError:
-    print "Caught 1/0 correctly."
-
-
-# %autopx
-
-%px a = numpy.random.random((4,4))
-%px a = a+a.transpose()
-# %autopx
-
-print mux.apply(numpy.linalg.eigvals, Reference('a'))
-
-
-
-mux.targets = [0,2]
-%px a = 5
-mux.targets = [1,3]
-%px a = 10
-mux.targets = rc.ids
-print mux['a']
-
-
-# Push/Pull
-
-mux.push(dict(a=10, b=30, c={'f':range(10)}))
-mux.pull(('a', 'b'))
-
-for id in mux.targets:
-    mux.push(dict(a=id), targets=id)
-
-
-for id in mux.targets:
-    mux.pull('a', targets=id)
-
-mux.pull('a')
-
-
-mux['a'] = 100
-mux['a']
-
-# get_result/reset/keys
-
-mux.get_result()
-%result
-mux.apply(lambda : globals().keys())
-mux.clear()
-mux.apply(lambda : globals().keys())
-
-try:
-    %result
-except error.CompositeError:
-    print "Caught IndexError ok."
-
-
-%px a = 5
-mux.get_result(-1)
-mux.apply(lambda : globals().keys())
-
-# Queue management methods
-
-%px import time
-ars = [mux.apply_async(time.sleep, 2.0) for x in range(5)]
-
-
-mux.queue_status()
-time.sleep(3.0)
-mux.abort(ars, block=True)
-mux.queue_status()
-time.sleep(2.0)
-mux.queue_status()
-
-mux.wait(ars)
-
-for ar in ars:
-    try:
-        ar.r
-    except error.CompositeError:
-        print "Caught QueueCleared OK."
-
-
-# scatter/gather
-
-mux.scatter('a', range(10))
-mux.gather('a')
-mux.scatter('b', numpy.arange(10))
-mux.gather('b')
-
-#-------------------------------------------------------------------------------
-# Non-Blocking execution
-#-------------------------------------------------------------------------------
-
-mux.block = False
-
-# execute
-
-ar1 = mux.execute('a=5')
-with mux.sync_imports():
-    import sets
-
-ar1.wait()
-
-ar1 = mux.execute('1/0')
-ar2 = mux.execute('c = sets.Set()')
-
-mux.wait((ar1, ar2))
-try:
-    ar1.r
-except error.CompositeError:
-    print "Caught ZeroDivisionError OK."
-
-ar = mux.execute("arint 'hi'")
-ar.r
-
-ar = mux.apply(lambda : 1/0)
-try:
-    ar.r
-except error.CompositeError:
-    print "Caught ZeroDivisionError OK."
-
-# Make sure we can reraise it!
-try:
-    ar.r
-except error.CompositeError:
-    print "Caught ZeroDivisionError OK."  
-
-# push/pull
-
-ar1 = mux.push(dict(a=10))
-ar1.get()
-ar2 = mux.pull('a')
-ar2.r
-
-
-# This is a command to make sure the end of the file is happy.
-
-print "The tests are done!"
-
diff --git a/docs/examples/newparallel/multiengine2.py b/docs/examples/newparallel/multiengine2.py
deleted file mode 100644
index a49f9701686..00000000000
--- a/docs/examples/newparallel/multiengine2.py
+++ /dev/null
@@ -1,28 +0,0 @@
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import time
-
-from IPython.parallel import Client
-
-#-------------------------------------------------------------------------------
-# Setup
-#-------------------------------------------------------------------------------
-
-mux = Client()[:]
-
-mux.clear()
-
-mux.block=False
-
-ar1 = mux.apply(time.sleep, 5)
-ar2 = mux.push(dict(a=10,b=30,c=range(20000),d='The dog went swimming.'))
-ar3 = mux.pull(('a','b','d'), block=False)
-
-print "Try a non-blocking get_result"
-ar4 = mux.get_result()
-
-print "Now wait for all the results"
-mux.wait([ar1,ar2,ar3,ar4])
-print "The last pull got:", ar4.r
diff --git a/docs/examples/newparallel/multienginemap.py b/docs/examples/newparallel/multienginemap.py
deleted file mode 100644
index 2fa8849974a..00000000000
--- a/docs/examples/newparallel/multienginemap.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from IPython.parallel import Client
-
-rc = Client()
-view = rc[:]
-result = view.map_sync(lambda x: 2*x, range(10))
-print "Simple, default map: ", result
-
-ar = view.map_async(lambda x: 2*x, range(10))
-print "Submitted map, got AsyncResult: ", ar
-result = ar.r
-print "Using map_async: ", result
-
-@view.parallel(block=True)
-def f(x): return 2*x
-
-result = f(range(10))
-print "Using a parallel function: ", result
\ No newline at end of file
diff --git a/docs/examples/newparallel/nwmerge.py b/docs/examples/newparallel/nwmerge.py
deleted file mode 100644
index 70382d31efd..00000000000
--- a/docs/examples/newparallel/nwmerge.py
+++ /dev/null
@@ -1,123 +0,0 @@
-"""Example showing how to merge multiple remote data streams.
-"""
-# Slightly modified version of:
-# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/511509
-
-import heapq
-from IPython.parallel.error import RemoteError
-
-def mergesort(list_of_lists, key=None):
-    """ Perform an N-way merge operation on sorted lists.
-
-    @param list_of_lists: (really iterable of iterable) of sorted elements
-    (either by naturally or by C{key})
-    @param key: specify sort key function (like C{sort()}, C{sorted()})
-
-    Yields tuples of the form C{(item, iterator)}, where the iterator is the
-    built-in list iterator or something you pass in, if you pre-generate the
-    iterators.
-
-    This is a stable merge; complexity O(N lg N)
-
-    Examples::
-
-    >>> print list(mergesort([[1,2,3,4],
-    ...                      [2,3.25,3.75,4.5,6,7],
-    ...                      [2.625,3.625,6.625,9]]))
-    [1, 2, 2, 2.625, 3, 3.25, 3.625, 3.75, 4, 4.5, 6, 6.625, 7, 9]
-
-    # note stability
-    >>> print list(mergesort([[1,2,3,4],
-    ...                      [2,3.25,3.75,4.5,6,7],
-    ...                      [2.625,3.625,6.625,9]],
-    ...                      key=int))
-    [1, 2, 2, 2.625, 3, 3.25, 3.75, 3.625, 4, 4.5, 6, 6.625, 7, 9]
-
-
-    >>> print list(mergesort([[4, 3, 2, 1],
-    ...                      [7, 6, 4.5, 3.75, 3.25, 2],
-    ...                      [9, 6.625, 3.625, 2.625]],
-    ...                      key=lambda x: -x))
-    [9, 7, 6.625, 6, 4.5, 4, 3.75, 3.625, 3.25, 3, 2.625, 2, 2, 1]
-    """
-
-    heap = []
-    for i, itr in enumerate(iter(pl) for pl in list_of_lists):
-        try:
-            item = itr.next()
-            if key:
-                toadd = (key(item), i, item, itr)
-            else:
-                toadd = (item, i, itr)
-            heap.append(toadd)
-        except StopIteration:
-            pass
-    heapq.heapify(heap)
-
-    if key:
-        while heap:
-            _, idx, item, itr = heap[0]
-            yield item
-            try:
-                item = itr.next()
-                heapq.heapreplace(heap, (key(item), idx, item, itr) )
-            except StopIteration:
-                heapq.heappop(heap)
-
-    else:
-        while heap:
-            item, idx, itr = heap[0]
-            yield item
-            try:
-                heapq.heapreplace(heap, (itr.next(), idx, itr))
-            except StopIteration:
-                heapq.heappop(heap)
-
-
-def remote_iterator(view,name):
-    """Return an iterator on an object living on a remote engine.
-    """
-    view.execute('it%s=iter(%s)'%(name,name), block=True)
-    while True:
-        try:
-            result = view.apply_sync(lambda x: x.next(), Reference('it'+name))
-        # This causes the StopIteration exception to be raised.
-        except RemoteError, e:
-            if e.ename == 'StopIteration':
-                raise StopIteration
-            else:
-                raise e
-        else:
-            yield result
-
-# Main, interactive testing
-if __name__ == '__main__':
-
-    from IPython.parallel import Client, Reference
-    rc = Client()
-    view = rc[:]
-    print 'Engine IDs:', rc.ids
-
-    # Make a set of 'sorted datasets'
-    a0 = range(5,20)
-    a1 = range(10)
-    a2 = range(15,25)
-
-    # Now, imagine these had been created in the remote engines by some long
-    # computation.  In this simple example, we just send them over into the
-    # remote engines.  They will all be called 'a' in each engine.
-    rc[0]['a'] = a0
-    rc[1]['a'] = a1
-    rc[2]['a'] = a2
-
-    # And we now make a local object which represents the remote iterator
-    aa0 = remote_iterator(rc[0],'a')
-    aa1 = remote_iterator(rc[1],'a')
-    aa2 = remote_iterator(rc[2],'a')
-
-    # Let's merge them, both locally and remotely:
-    print 'Merge the local datasets:'
-    print list(mergesort([a0,a1,a2]))
-    
-    print 'Locally merge the remote sets:'
-    print list(mergesort([aa0,aa1,aa2]))
diff --git a/docs/examples/newparallel/parallel_pylab.ipy b/docs/examples/newparallel/parallel_pylab.ipy
deleted file mode 100644
index f924d82bebe..00000000000
--- a/docs/examples/newparallel/parallel_pylab.ipy
+++ /dev/null
@@ -1,49 +0,0 @@
-"""Example of how to use pylab to plot parallel data.
-
-The idea here is to run matplotlib is the same IPython session
-as an ipython parallel Client.  That way matplotlib
-can be used to plot parallel data that is gathered using
-a DirectView.  
-
-To run this example, first start the IPython controller and 4
-engines::
-
-    ipcluster -n 4
-
-Then start ipython in pylab mode::
-
-    ipython -pylab
-    
-Then a simple "run parallel_pylab.ipy" in IPython will run the
-example. 
-"""
-
-import numpy as N
-from pylab import *
-from IPython.parallel import Client
-
-# load the parallel magic
-%load_ext parallelmagic
-
-# Get an IPython Client
-rc = Client()
-v = rc[:]
-v.activate()
-
-# Create random arrays on the engines
-# This is to simulate arrays that you have calculated in parallel
-# on the engines.
-# Anymore that length 10000 arrays, matplotlib starts to be slow
-%px import numpy as N
-%px x = N.random.standard_normal(10000)
-%px y = N.random.standard_normal(10000)
-
-print v.apply_async(lambda : x[0:10]).get_dict()
-print v.apply_async(lambda : y[0:10]).get_dict()
-
-# Bring back the data
-x_local = v.gather('x', block=True)
-y_local = v.gather('y', block=True)
-
-# Make a scatter plot of the gathered data
-plot(x_local, y_local,'ro')
diff --git a/docs/examples/newparallel/parallelpi.py b/docs/examples/newparallel/parallelpi.py
deleted file mode 100644
index dbdc7703bf1..00000000000
--- a/docs/examples/newparallel/parallelpi.py
+++ /dev/null
@@ -1,64 +0,0 @@
-"""Calculate statistics on the digits of pi in parallel.
-
-This program uses the functions in :file:`pidigits.py` to calculate
-the frequencies of 2 digit sequences in the digits of pi. The
-results are plotted using matplotlib.
-
-To run, text files from http://www.super-computing.org/
-must be installed in the working directory of the IPython engines.
-The actual filenames to be used can be set with the ``filestring``
-variable below.
-
-The dataset we have been using for this is the 200 million digit one here:
-ftp://pi.super-computing.org/.2/pi200m/
-
-and the files used will be downloaded if they are not in the working directory 
-of the IPython engines.
-""" 
-
-from IPython.parallel import Client
-from matplotlib import pyplot as plt
-import numpy as np
-from pidigits import *
-from timeit import default_timer as clock
-
-# Files with digits of pi (10m digits each)
-filestring = 'pi200m.ascii.%(i)02dof20'
-files = [filestring % {'i':i} for i in range(1,16)]
-
-# Connect to the IPython cluster
-c = Client()
-c[:].run('pidigits.py')
-
-# the number of engines
-n = len(c)
-id0 = c.ids[0]
-v = c[:]
-v.block=True
-# fetch the pi-files
-print "downloading %i files of pi"%n
-v.map(fetch_pi_file, files[:n])
-print "done"
-
-# Run 10m digits on 1 engine
-t1 = clock()
-freqs10m = c[id0].apply_sync(compute_two_digit_freqs, files[0])
-t2 = clock()
-digits_per_second1 = 10.0e6/(t2-t1)
-print "Digits per second (1 core, 10m digits):   ", digits_per_second1
-
-
-# Run n*10m digits on all engines
-t1 = clock()
-freqs_all = v.map(compute_two_digit_freqs, files[:n])
-freqs150m = reduce_freqs(freqs_all)
-t2 = clock()
-digits_per_second8 = n*10.0e6/(t2-t1)
-print "Digits per second (%i engines, %i0m digits): "%(n,n), digits_per_second8
-
-print "Speedup: ", digits_per_second8/digits_per_second1
-
-plot_two_digit_freqs(freqs150m)
-plt.title("2 digit sequences in %i0m digits of pi"%n)
-plt.show()
-
diff --git a/docs/examples/newparallel/phistogram.py b/docs/examples/newparallel/phistogram.py
deleted file mode 100644
index c2605bb8475..00000000000
--- a/docs/examples/newparallel/phistogram.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""Parallel histogram function"""
-import numpy
-from IPython.utils.pickleutil import Reference
-
-def phistogram(view, a, bins=10, rng=None, normed=False):
-    """Compute the histogram of a remote array a.
-    
-    Parameters
-    ----------
-        view
-            IPython DirectView instance
-        a : str
-            String name of the remote array
-        bins : int
-            Number of histogram bins
-        rng : (float, float)
-            Tuple of min, max of the range to histogram
-        normed : boolean
-            Should the histogram counts be normalized to 1
-    """
-    nengines = len(view.targets)
-    
-    # view.push(dict(bins=bins, rng=rng))
-    with view.sync_imports():
-        import numpy
-    rets = view.apply_sync(lambda a, b, rng: numpy.histogram(a,b,rng), Reference(a), bins, rng)
-    hists = [ r[0] for r in rets ]
-    lower_edges = [ r[1] for r in rets ]
-    # view.execute('hist, lower_edges = numpy.histogram(%s, bins, rng)' % a)
-    lower_edges = view.pull('lower_edges', targets=0)
-    hist_array = numpy.array(hists).reshape(nengines, -1)
-    # hist_array.shape = (nengines,-1)
-    total_hist = numpy.sum(hist_array, 0)
-    if normed:
-        total_hist = total_hist/numpy.sum(total_hist,dtype=float)
-    return total_hist, lower_edges
-
-
-    
-    
diff --git a/docs/examples/newparallel/pidigits.py b/docs/examples/newparallel/pidigits.py
deleted file mode 100644
index 6c58ae94a9d..00000000000
--- a/docs/examples/newparallel/pidigits.py
+++ /dev/null
@@ -1,157 +0,0 @@
-"""Compute statistics on the digits of pi.
-
-This uses precomputed digits of pi from the website
-of Professor Yasumasa Kanada at the University of 
-Tokoyo: http://www.super-computing.org/
-
-Currently, there are only functions to read the
-.txt (non-compressed, non-binary) files, but adding
-support for compression and binary files would be
-straightforward.
-
-This focuses on computing the number of times that
-all 1, 2, n digits sequences occur in the digits of pi.
-If the digits of pi are truly random, these frequencies
-should be equal.
-"""
-
-# Import statements
-from __future__ import division, with_statement
-
-import numpy as np
-from matplotlib import pyplot as plt
-
-# Top-level functions
-
-def fetch_pi_file(filename):
-    """This will download a segment of pi from super-computing.org
-    if the file is not already present.
-    """
-    import os, urllib
-    ftpdir="ftp://pi.super-computing.org/.2/pi200m/"
-    if os.path.exists(filename):
-        # we already have it
-        return
-    else:
-        # download it
-        urllib.urlretrieve(ftpdir+filename,filename)
-
-def compute_one_digit_freqs(filename):
-    """
-    Read digits of pi from a file and compute the 1 digit frequencies.
-    """
-    d = txt_file_to_digits(filename)
-    freqs = one_digit_freqs(d)
-    return freqs
-
-def compute_two_digit_freqs(filename):
-    """
-    Read digits of pi from a file and compute the 2 digit frequencies.
-    """
-    d = txt_file_to_digits(filename)
-    freqs = two_digit_freqs(d)
-    return freqs
-
-def reduce_freqs(freqlist):
-    """
-    Add up a list of freq counts to get the total counts.
-    """
-    allfreqs = np.zeros_like(freqlist[0])
-    for f in freqlist:
-        allfreqs += f
-    return allfreqs
-
-def compute_n_digit_freqs(filename, n):
-    """
-    Read digits of pi from a file and compute the n digit frequencies.
-    """
-    d = txt_file_to_digits(filename)
-    freqs = n_digit_freqs(d, n)
-    return freqs
-
-# Read digits from a txt file
-    
-def txt_file_to_digits(filename, the_type=str):
-    """
-    Yield the digits of pi read from a .txt file.
-    """
-    with open(filename, 'r') as f:
-        for line in f.readlines():
-            for c in line:
-                if c != '\n' and c!= ' ':
-                    yield the_type(c)
-
-# Actual counting functions                    
-
-def one_digit_freqs(digits, normalize=False):
-    """
-    Consume digits of pi and compute 1 digit freq. counts.
-    """
-    freqs = np.zeros(10, dtype='i4')
-    for d in digits:
-        freqs[int(d)] += 1
-    if normalize:
-        freqs = freqs/freqs.sum()
-    return freqs
-    
-def two_digit_freqs(digits, normalize=False):
-    """
-    Consume digits of pi and compute 2 digits freq. counts.
-    """
-    freqs = np.zeros(100, dtype='i4')
-    last = digits.next()
-    this = digits.next()
-    for d in digits:
-        index = int(last + this)
-        freqs[index] += 1
-        last = this
-        this = d
-    if normalize:
-        freqs = freqs/freqs.sum()
-    return freqs
-
-def n_digit_freqs(digits, n, normalize=False):
-    """
-    Consume digits of pi and compute n digits freq. counts.
-
-    This should only be used for 1-6 digits.
-    """
-    freqs = np.zeros(pow(10,n), dtype='i4')
-    current = np.zeros(n, dtype=int)
-    for i in range(n):
-        current[i] = digits.next()
-    for d in digits:
-        index = int(''.join(map(str, current)))
-        freqs[index] += 1
-        current[0:-1] = current[1:]
-        current[-1] = d
-    if normalize:
-        freqs = freqs/freqs.sum()
-    return freqs
-
-# Plotting functions
-
-def plot_two_digit_freqs(f2):
-    """
-    Plot two digits frequency counts using matplotlib.
-    """
-    f2_copy = f2.copy()
-    f2_copy.shape = (10,10)
-    ax = plt.matshow(f2_copy)
-    plt.colorbar()
-    for i in range(10):
-        for j in range(10):
-            plt.text(i-0.2, j+0.2, str(j)+str(i))
-    plt.ylabel('First digit')
-    plt.xlabel('Second digit')
-    return ax
-
-def plot_one_digit_freqs(f1):
-    """
-    Plot one digit frequency counts using matplotlib.
-    """
-    ax = plt.plot(f1,'bo-')
-    plt.title('Single digit counts in pi')
-    plt.xlabel('Digit')
-    plt.ylabel('Count')
-    return ax
diff --git a/docs/examples/newparallel/plotting/plotting_backend.py b/docs/examples/newparallel/plotting/plotting_backend.py
deleted file mode 100644
index 2dcfca4b17e..00000000000
--- a/docs/examples/newparallel/plotting/plotting_backend.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""An example of how to use IPython for plotting remote parallel data
-
-The two files plotting_frontend.py and plotting_backend.py go together.
-
-This file (plotting_backend.py) performs the actual computation.  For this 
-example, the computation just generates a set of random numbers that
-look like a distribution of particles with 2D position (x,y) and 
-momentum (px,py).  In a real situation, this file would do some time
-consuming and complicated calculation, and could possibly make calls
-to MPI.
-
-One important feature is that this script can also be run standalone without
-IPython.  This is nice as it allows it to be run in more traditional 
-settings where IPython isn't being used.
-
-When used with IPython.parallel, this code is run on the engines.  Because this
-code doesn't make any plots, the engines don't have to have any plotting
-packages installed.
-"""
-
-# Imports
-import numpy as N
-import time
-import random
-
-# Functions
-def compute_particles(number):
-    x = N.random.standard_normal(number)
-    y = N.random.standard_normal(number)
-    px = N.random.standard_normal(number)
-    py = N.random.standard_normal(number)
-    return x, y, px, py
-
-def downsample(array, k):
-    """Choose k random elements of array."""
-    length = array.shape[0]
-    indices = random.sample(xrange(length), k)
-    return array[indices]
-
-# Parameters of the run
-number = 100000
-d_number = 1000
-
-# The actual run
-
-time.sleep(0) # Pretend it took a while
-x, y, px, py = compute_particles(number)
-# Now downsample the data
-downx = downsample(x, d_number)
-downy = downsample(x, d_number)
-downpx = downsample(px, d_number)
-downpy = downsample(py, d_number)
-
-print "downx: ", downx[:10]
-print "downy: ", downy[:10]
-print "downpx: ", downpx[:10]
-print "downpy: ", downpy[:10]
\ No newline at end of file
diff --git a/docs/examples/newparallel/plotting/plotting_frontend.py b/docs/examples/newparallel/plotting/plotting_frontend.py
deleted file mode 100644
index 1ef02374f93..00000000000
--- a/docs/examples/newparallel/plotting/plotting_frontend.py
+++ /dev/null
@@ -1,60 +0,0 @@
-"""An example of how to use IPython1 for plotting remote parallel data
-
-The two files plotting_frontend.py and plotting_backend.py go together.
-
-To run this example, first start the IPython controller and 4
-engines::
-
-    ipclusterz start -n 4
-
-Then start ipython in pylab mode::
-
-    ipython -pylab
-    
-Then a simple "run plotting_frontend.py" in IPython will run the
-example.  When this is done, all the variables (such as number, downx, etc.)
-are available in IPython, so for example you can make additional plots.
-"""
-
-import numpy as N
-from pylab import *
-from IPython.parallel import Client
-
-# Connect to the cluster
-rc = Client()
-view = rc[:]
-
-# Run the simulation on all the engines
-view.run('plotting_backend.py')
-
-# Bring back the data. These are all AsyncResult objects
-number = view.pull('number')
-d_number = view.pull('d_number')
-downx = view.gather('downx')
-downy = view.gather('downy')
-downpx = view.gather('downpx')
-downpy = view.gather('downpy')
-
-# but we can still iterate through AsyncResults before they are done
-print "number: ", sum(number)
-print "downsampled number: ", sum(d_number)
-
-
-# Make a scatter plot of the gathered data
-# These calls to matplotlib could be replaced by calls to pygist or
-# another plotting package.
-figure(1)
-# wait for downx/y
-downx = downx.get()
-downy = downy.get()
-scatter(downx, downy)
-xlabel('x')
-ylabel('y')
-figure(2)
-# wait for downpx/y
-downpx = downpx.get()
-downpy = downpy.get()
-scatter(downpx, downpy)
-xlabel('px')
-ylabel('py')
-show()
\ No newline at end of file
diff --git a/docs/examples/newparallel/rmt/rmt.ipy b/docs/examples/newparallel/rmt/rmt.ipy
deleted file mode 100644
index d03142e95f6..00000000000
--- a/docs/examples/newparallel/rmt/rmt.ipy
+++ /dev/null
@@ -1,56 +0,0 @@
-#-------------------------------------------------------------------------------
-# Driver code that the client runs.
-#-------------------------------------------------------------------------------
-# To run this code start a controller and engines using:
-# ipcluster -n 2
-# Then run the scripts by doing irunner rmt.ipy or by starting ipython and
-# doing run rmt.ipy.
-
-from rmtkernel import *
-import numpy
-from IPython.parallel import Client
-
-
-def wignerDistribution(s):
-    """Returns (s, rho(s)) for the Wigner GOE distribution."""
-    return (numpy.pi*s/2.0) * numpy.exp(-numpy.pi*s**2/4.)
-
-
-def generateWignerData():
-    s = numpy.linspace(0.0,4.0,400)
-    rhos = wignerDistribution(s)
-    return s, rhos
-    
-
-def serialDiffs(num, N):
-    diffs = ensembleDiffs(num, N)
-    normalizedDiffs = normalizeDiffs(diffs)
-    return normalizedDiffs
-
-
-def parallelDiffs(rc, num, N):
-    nengines = len(rc.targets)
-    num_per_engine = num/nengines
-    print "Running with", num_per_engine, "per engine."
-    ar = rc.apply_async(ensembleDiffs, num_per_engine, N)
-    return numpy.array(ar.get()).flatten()
-
-
-# Main code
-if __name__ == '__main__':
-    rc = Client()
-    view = rc[:]
-    print "Distributing code to engines..."
-    view.run('rmtkernel.py')
-    view.block = False
-
-    # Simulation parameters
-    nmats = 100
-    matsize = 30
-    # tic = time.time()
-    %timeit -r1 -n1 serialDiffs(nmats,matsize)
-    %timeit -r1 -n1 parallelDiffs(view, nmats, matsize)
-
-    # Uncomment these to plot the histogram
-    # import pylab
-    # pylab.hist(parallelDiffs(rc,matsize,matsize))
diff --git a/docs/examples/newparallel/rmt/rmtkernel.py b/docs/examples/newparallel/rmt/rmtkernel.py
deleted file mode 100644
index 2c913e20d78..00000000000
--- a/docs/examples/newparallel/rmt/rmtkernel.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#-------------------------------------------------------------------------------
-# Core routines for computing properties of symmetric random matrices.
-#-------------------------------------------------------------------------------
-
-import numpy
-ra = numpy.random
-la = numpy.linalg
-
-def GOE(N):
-    """Creates an NxN element of the Gaussian Orthogonal Ensemble"""
-    m = ra.standard_normal((N,N))
-    m += m.T
-    return m
-
-
-def centerEigenvalueDiff(mat):
-    """Compute the eigvals of mat and then find the center eigval difference."""
-    N = len(mat)
-    evals = numpy.sort(la.eigvals(mat))
-    diff = evals[N/2] - evals[N/2-1]
-    return diff.real
-
-
-def ensembleDiffs(num, N):
-    """Return an array of num eigenvalue differences for the NxN GOE
-    ensemble."""
-    diffs = numpy.empty(num)
-    for i in xrange(num):
-        mat = GOE(N)
-        diffs[i] = centerEigenvalueDiff(mat)
-    return diffs
-
-
-def normalizeDiffs(diffs):
-    """Normalize an array of eigenvalue diffs."""
-    return diffs/diffs.mean()
-
-
-def normalizedEnsembleDiffs(num, N):
-    """Return an array of num *normalized eigenvalue differences for the NxN
-    GOE ensemble."""
-    diffs = ensembleDiffs(num, N)
-    return normalizeDiffs(diffs)
-
diff --git a/docs/examples/newparallel/task1.py b/docs/examples/newparallel/task1.py
deleted file mode 100644
index 96653f1530d..00000000000
--- a/docs/examples/newparallel/task1.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from IPython.parallel import Client
-
-rc = Client()
-v = rc.load_balanced_view()
-
-rc[:]['d'] = 30
-
-def task(a):
-    return a, 10*d, a*10*d
-
-ar = v.apply(task, 5)
-
-print "a, b, c: ", ar.get()
\ No newline at end of file
diff --git a/docs/examples/newparallel/task2.py b/docs/examples/newparallel/task2.py
deleted file mode 100755
index 64f5b13a056..00000000000
--- a/docs/examples/newparallel/task2.py
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-
-from IPython.parallel import Client
-import time
-import sys
-flush = sys.stdout.flush
-
-rc = Client()
-v = rc.load_balanced_view()
-mux = rc[:]
-
-
-for i in range(24):
-    v.apply(time.sleep, 1)
-
-for i in range(6):
-    time.sleep(1.0)
-    print "Queue status (vebose=False)"
-    print v.queue_status(verbose=False)
-    flush()
-    
-for i in range(24):
-    v.apply(time.sleep, 1)
-
-for i in range(6):
-    time.sleep(1.0)
-    print "Queue status (vebose=True)"
-    print v.queue_status(verbose=True)
-    flush()
-
-for i in range(12):
-    v.apply(time.sleep, 2)
-
-print "Queue status (vebose=True)"
-print v.queue_status(verbose=True)
-flush()
-
-# qs = v.queue_status(verbose=True)
-# queued = qs['scheduled']
-
-for msg_id in v.history[-4:]:
-    v.abort(msg_id)
-
-for i in range(6):
-    time.sleep(1.0)
-    print "Queue status (vebose=True)"
-    print v.queue_status(verbose=True)
-    flush()
-
diff --git a/docs/examples/newparallel/task_profiler.py b/docs/examples/newparallel/task_profiler.py
deleted file mode 100644
index b4f05babd4a..00000000000
--- a/docs/examples/newparallel/task_profiler.py
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/usr/bin/env python
-"""Test the performance of the task farming system.
-
-This script submits a set of tasks via a LoadBalancedView.  The tasks
-are basically just a time.sleep(t), where t is a random number between
-two limits that can be configured at the command line.  To run 
-the script there must first be an IPython controller and engines running::
-
-    ipclusterz start -n 16
-
-A good test to run with 16 engines is::
-
-    python task_profiler.py -n 128 -t 0.01 -T 1.0
-
-This should show a speedup of 13-14x.  The limitation here is that the 
-overhead of a single task is about 0.001-0.01 seconds.
-"""
-import random, sys
-from optparse import OptionParser
-
-from IPython.utils.timing import time
-from IPython.parallel import Client
-
-def main():
-    parser = OptionParser()
-    parser.set_defaults(n=100)
-    parser.set_defaults(tmin=1)
-    parser.set_defaults(tmax=60)
-    parser.set_defaults(profile='default')
-    
-    parser.add_option("-n", type='int', dest='n',
-        help='the number of tasks to run')
-    parser.add_option("-t", type='float', dest='tmin', 
-        help='the minimum task length in seconds')
-    parser.add_option("-T", type='float', dest='tmax',
-        help='the maximum task length in seconds')
-    parser.add_option("-p", '--profile', type='str', dest='profile',
-        help="the cluster profile [default: 'default']")
-    
-    (opts, args) = parser.parse_args()
-    assert opts.tmax >= opts.tmin, "tmax must not be smaller than tmin"
-    
-    rc = Client()
-    view = rc.load_balanced_view()
-    print view
-    rc.block=True
-    nengines = len(rc.ids)
-    rc[:].execute('from IPython.utils.timing import time')
-
-    # the jobs should take a random time within a range
-    times = [random.random()*(opts.tmax-opts.tmin)+opts.tmin for i in range(opts.n)]
-    stime = sum(times)
-    
-    print "executing %i tasks, totalling %.1f secs on %i engines"%(opts.n, stime, nengines)
-    time.sleep(1)
-    start = time.time()
-    amr = view.map(time.sleep, times)
-    amr.get()
-    stop = time.time()
-
-    ptime = stop-start
-    scale = stime/ptime
-    
-    print "executed %.1f secs in %.1f secs"%(stime, ptime)
-    print "%.3fx parallel performance on %i engines"%(scale, nengines)
-    print "%.1f%% of theoretical max"%(100*scale/nengines)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/docs/examples/newparallel/taskmap.py b/docs/examples/newparallel/taskmap.py
deleted file mode 100644
index 1e2b5552e85..00000000000
--- a/docs/examples/newparallel/taskmap.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from IPython.parallel import Client
-
-rc = Client()
-v = rc.load_balanced_view()
-
-result = v.map(lambda x: 2*x, range(10))
-print "Simple, default map: ", list(result)
-
-ar = v.map_async(lambda x: 2*x, range(10))
-print "Submitted tasks, got ids: ", ar.msg_ids
-result = ar.get()
-print "Using a mapper: ", result
-
-@v.parallel(block=True)
-def f(x): return 2*x
-
-result = f.map(range(10))
-print "Using a parallel function: ", result
\ No newline at end of file
diff --git a/docs/examples/newparallel/wave2D/RectPartitioner.py b/docs/examples/newparallel/wave2D/RectPartitioner.py
deleted file mode 100755
index 985659dea6f..00000000000
--- a/docs/examples/newparallel/wave2D/RectPartitioner.py
+++ /dev/null
@@ -1,491 +0,0 @@
-#!/usr/bin/env python
-"""A rectangular domain partitioner and associated communication
-functionality for solving PDEs in (1D,2D) using FDM
-written in the python language
-
-The global solution domain is assumed to be of rectangular shape,
-where the number of cells in each direction is stored in nx, ny, nz
-
-The numerical scheme is fully explicit
-
-Authors
--------
-
- * Xing Cai
- * Min Ragan-Kelley
-
-"""
-import time
-
-from numpy import zeros, ascontiguousarray, frombuffer
-try:
-    from mpi4py import MPI
-except ImportError:
-    pass
-else:
-    mpi = MPI.COMM_WORLD
-
-class RectPartitioner:
-    """
-    Responsible for a rectangular partitioning of a global domain,
-    which is expressed as the numbers of cells in the different
-    spatial directions. The partitioning info is expressed as an
-    array of integers, each indicating the number of subdomains in
-    one spatial direction.
-    """
-
-    def __init__(self, my_id=-1, num_procs=-1, \
-                 global_num_cells=[], num_parts=[]):
-        self.nsd = 0
-        self.my_id = my_id
-        self.num_procs = num_procs
-        self.redim (global_num_cells, num_parts)
-
-    def redim (self, global_num_cells, num_parts):
-        nsd_ = len(global_num_cells)
-#        print "Inside the redim function, nsd=%d" %nsd_
-
-        if nsd_<1 | nsd_>3 | nsd_!=len(num_parts):
-            print 'The input global_num_cells is not ok!'
-            return
-
-        self.nsd = nsd_
-        self.global_num_cells = global_num_cells
-        self.num_parts = num_parts
-
-    def prepare_communication (self):
-        """
-        Find the subdomain rank (tuple) for each processor and
-        determine the neighbor info.
-        """
-        
-        nsd_ = self.nsd
-        if nsd_<1:
-            print 'Number of space dimensions is %d, nothing to do' %nsd_
-            return
-        
-        self.subd_rank = [-1,-1,-1]
-        self.subd_lo_ix = [-1,-1,-1]
-        self.subd_hi_ix = [-1,-1,-1]
-        self.lower_neighbors = [-1,-1,-1]
-        self.upper_neighbors = [-1,-1,-1]
-
-        num_procs = self.num_procs
-        my_id = self.my_id
-
-        num_subds = 1
-        for i in range(nsd_):
-            num_subds = num_subds*self.num_parts[i]
-        if my_id==0:
-            print "# subds=", num_subds
-            # should check num_subds againt num_procs
-
-        offsets = [1, 0, 0]
-
-        # find the subdomain rank
-        self.subd_rank[0] = my_id%self.num_parts[0]
-        if nsd_>=2:
-            offsets[1] = self.num_parts[0]
-            self.subd_rank[1] = my_id/offsets[1]
-        if nsd_==3:
-            offsets[1] = self.num_parts[0]
-            offsets[2] = self.num_parts[0]*self.num_parts[1]
-            self.subd_rank[1] = (my_id%offsets[2])/self.num_parts[0]
-            self.subd_rank[2] = my_id/offsets[2]
-                    
-        print "my_id=%d, subd_rank: "%my_id, self.subd_rank
-        if my_id==0:
-            print "offsets=", offsets
-
-        # find the neighbor ids
-        for i in range(nsd_):
-            rank = self.subd_rank[i]
-            if rank>0:
-                self.lower_neighbors[i] = my_id-offsets[i]
-            if rank<self.num_parts[i]-1:
-                self.upper_neighbors[i] = my_id+offsets[i]
-                
-            k = self.global_num_cells[i]/self.num_parts[i]
-            m = self.global_num_cells[i]%self.num_parts[i]
-            
-            ix = rank*k+max(0,rank+m-self.num_parts[i])
-            self.subd_lo_ix[i] = ix
-            
-            ix = ix+k
-            if rank>=(self.num_parts[i]-m):
-                ix = ix+1  # load balancing
-            if rank<self.num_parts[i]-1:
-                ix = ix+1  # one cell of overlap
-            self.subd_hi_ix[i] = ix
-
-        print "subd_rank:",self.subd_rank,\
-              "lower_neig:", self.lower_neighbors, \
-              "upper_neig:", self.upper_neighbors
-        print "subd_rank:",self.subd_rank,"subd_lo_ix:", self.subd_lo_ix, \
-              "subd_hi_ix:", self.subd_hi_ix
-
-        
-class RectPartitioner1D(RectPartitioner):
-    """
-    Subclass of RectPartitioner, for 1D problems
-    """
-    def prepare_communication (self):
-        """
-        Prepare the buffers to be used for later communications
-        """
-        
-        RectPartitioner.prepare_communication (self)
-        
-        if self.lower_neighbors[0]>=0:
-            self.in_lower_buffers = [zeros(1, float)]
-            self.out_lower_buffers = [zeros(1, float)]
-        if self.upper_neighbors[0]>=0:
-            self.in_upper_buffers = [zeros(1, float)]
-            self.out_upper_buffers = [zeros(1, float)]
-
-    def get_num_loc_cells(self):
-        return [self.subd_hi_ix[0]-self.subd_lo_ix[0]]
-
-
-class RectPartitioner2D(RectPartitioner):
-    """
-    Subclass of RectPartitioner, for 2D problems
-    """
-    def prepare_communication (self):
-        """
-        Prepare the buffers to be used for later communications
-        """
-        
-        RectPartitioner.prepare_communication (self)
-        
-        self.in_lower_buffers = [[], []]
-        self.out_lower_buffers = [[], []]
-        self.in_upper_buffers = [[], []]
-        self.out_upper_buffers = [[], []]
-
-        size1 = self.subd_hi_ix[1]-self.subd_lo_ix[1]+1
-        if self.lower_neighbors[0]>=0:
-            self.in_lower_buffers[0] = zeros(size1, float)
-            self.out_lower_buffers[0] = zeros(size1, float)
-        if self.upper_neighbors[0]>=0:
-            self.in_upper_buffers[0] = zeros(size1, float)
-            self.out_upper_buffers[0] = zeros(size1, float)
-
-        size0 = self.subd_hi_ix[0]-self.subd_lo_ix[0]+1
-        if self.lower_neighbors[1]>=0:
-            self.in_lower_buffers[1] = zeros(size0, float)
-            self.out_lower_buffers[1] = zeros(size0, float)
-        if self.upper_neighbors[1]>=0:
-            self.in_upper_buffers[1] = zeros(size0, float)
-            self.out_upper_buffers[1] = zeros(size0, float)
-
-    def get_num_loc_cells(self):
-        return [self.subd_hi_ix[0]-self.subd_lo_ix[0],\
-                self.subd_hi_ix[1]-self.subd_lo_ix[1]]
-
-
-class MPIRectPartitioner2D(RectPartitioner2D):
-    """
-    Subclass of RectPartitioner2D, which uses MPI via mpi4py for communication
-    """
-    
-    def __init__(self, my_id=-1, num_procs=-1,
-                 global_num_cells=[], num_parts=[],
-                 slice_copy=True):
-        RectPartitioner.__init__(self, my_id, num_procs,
-                                 global_num_cells, num_parts)
-        self.slice_copy = slice_copy
-        
-    def update_internal_boundary (self, solution_array):
-        nsd_ = self.nsd
-        if nsd_!=len(self.in_lower_buffers) | nsd_!=len(self.out_lower_buffers):
-            print "Buffers for communicating with lower neighbors not ready"
-            return
-        if nsd_!=len(self.in_upper_buffers) | nsd_!=len(self.out_upper_buffers):
-            print "Buffers for communicating with upper neighbors not ready"
-            return
-
-        loc_nx = self.subd_hi_ix[0]-self.subd_lo_ix[0]
-        loc_ny = self.subd_hi_ix[1]-self.subd_lo_ix[1]
-
-        lower_x_neigh = self.lower_neighbors[0]
-        upper_x_neigh = self.upper_neighbors[0]
-        lower_y_neigh = self.lower_neighbors[1]
-        upper_y_neigh = self.upper_neighbors[1]
-
-        # communicate in the x-direction first
-        if lower_x_neigh>-1:
-            if self.slice_copy:
-                self.out_lower_buffers[0] = ascontiguousarray(solution_array[1,:])
-            else:
-                for i in xrange(0,loc_ny+1):
-                    self.out_lower_buffers[0][i] = solution_array[1,i]
-            mpi.Isend(self.out_lower_buffers[0], lower_x_neigh)
-            
-        if upper_x_neigh>-1:
-            mpi.Recv(self.in_upper_buffers[0], upper_x_neigh)
-            if self.slice_copy:
-                solution_array[loc_nx,:] = self.in_upper_buffers[0]
-                self.out_upper_buffers[0] = ascontiguousarray(solution_array[loc_nx-1,:])
-            else:
-                for i in xrange(0,loc_ny+1):
-                    solution_array[loc_nx,i] = self.in_upper_buffers[0][i]
-                    self.out_upper_buffers[0][i] = solution_array[loc_nx-1,i]
-            mpi.Isend(self.out_upper_buffers[0], upper_x_neigh)
-
-        if lower_x_neigh>-1:
-            mpi.Recv(self.in_lower_buffers[0], lower_x_neigh)
-            if self.slice_copy:
-                solution_array[0,:] = self.in_lower_buffers[0]
-            else:
-                for i in xrange(0,loc_ny+1):
-                    solution_array[0,i] = self.in_lower_buffers[0][i]
-
-        # communicate in the y-direction afterwards
-        if lower_y_neigh>-1:
-            if self.slice_copy:
-                self.out_lower_buffers[1] = ascontiguousarray(solution_array[:,1])
-            else:
-                for i in xrange(0,loc_nx+1):
-                    self.out_lower_buffers[1][i] = solution_array[i,1]
-            mpi.Isend(self.out_lower_buffers[1], lower_y_neigh)
-            
-        if upper_y_neigh>-1:
-            mpi.Recv(self.in_upper_buffers[1], upper_y_neigh)
-            if self.slice_copy:
-                solution_array[:,loc_ny] = self.in_upper_buffers[1]
-                self.out_upper_buffers[1] = ascontiguousarray(solution_array[:,loc_ny-1])
-            else:
-                for i in xrange(0,loc_nx+1):
-                    solution_array[i,loc_ny] = self.in_upper_buffers[1][i]
-                    self.out_upper_buffers[1][i] = solution_array[i,loc_ny-1]
-            mpi.Isend(self.out_upper_buffers[1], upper_y_neigh)
-            
-        if lower_y_neigh>-1:
-            mpi.Recv(self.in_lower_buffers[1], lower_y_neigh)
-            if self.slice_copy:
-                solution_array[:,0] = self.in_lower_buffers[1]
-            else:
-                for i in xrange(0,loc_nx+1):
-                    solution_array[i,0] = self.in_lower_buffers[1][i]
-
-class ZMQRectPartitioner2D(RectPartitioner2D):
-    """
-    Subclass of RectPartitioner2D, which uses 0MQ via pyzmq for communication
-    The first two arguments must be `comm`, an EngineCommunicator object,
-    and `addrs`, a dict of connection information for other EngineCommunicator
-    objects.
-    """
-
-    def __init__(self, comm, addrs, my_id=-1, num_procs=-1,
-                 global_num_cells=[], num_parts=[],
-                 slice_copy=True):
-        RectPartitioner.__init__(self, my_id, num_procs,
-                                 global_num_cells, num_parts)
-        self.slice_copy = slice_copy
-        self.comm = comm # an Engine
-        self.addrs = addrs
-    
-    def prepare_communication(self):
-        RectPartitioner2D.prepare_communication(self)
-        # connect west/south to east/north
-        west_id,south_id = self.lower_neighbors[:2]
-        west = self.addrs.get(west_id, None)
-        south = self.addrs.get(south_id, None)
-        self.comm.connect(south, west)
-    
-    def update_internal_boundary_x_y (self, solution_array):
-        """update the inner boundary with the same send/recv pattern as the MPIPartitioner"""
-        nsd_ = self.nsd
-        dtype = solution_array.dtype
-        if nsd_!=len(self.in_lower_buffers) | nsd_!=len(self.out_lower_buffers):
-            print "Buffers for communicating with lower neighbors not ready"
-            return
-        if nsd_!=len(self.in_upper_buffers) | nsd_!=len(self.out_upper_buffers):
-            print "Buffers for communicating with upper neighbors not ready"
-            return
-
-        loc_nx = self.subd_hi_ix[0]-self.subd_lo_ix[0]
-        loc_ny = self.subd_hi_ix[1]-self.subd_lo_ix[1]
-
-        lower_x_neigh = self.lower_neighbors[0]
-        upper_x_neigh = self.upper_neighbors[0]
-        lower_y_neigh = self.lower_neighbors[1]
-        upper_y_neigh = self.upper_neighbors[1]
-        trackers = []
-        flags = dict(copy=False, track=False)
-        # communicate in the x-direction first
-        if lower_x_neigh>-1:
-            if self.slice_copy:
-                self.out_lower_buffers[0] = ascontiguousarray(solution_array[1,:])
-            else:
-                for i in xrange(0,loc_ny+1):
-                    self.out_lower_buffers[0][i] = solution_array[1,i]
-            t = self.comm.west.send(self.out_lower_buffers[0], **flags)
-            trackers.append(t)
-            
-        if upper_x_neigh>-1:
-            msg = self.comm.east.recv(copy=False)
-            self.in_upper_buffers[0] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[loc_nx,:] = self.in_upper_buffers[0]
-                self.out_upper_buffers[0] = ascontiguousarray(solution_array[loc_nx-1,:])
-            else:
-                for i in xrange(0,loc_ny+1):
-                    solution_array[loc_nx,i] = self.in_upper_buffers[0][i]
-                    self.out_upper_buffers[0][i] = solution_array[loc_nx-1,i]
-            t = self.comm.east.send(self.out_upper_buffers[0], **flags)
-            trackers.append(t)
-            
-
-        if lower_x_neigh>-1:
-            msg = self.comm.west.recv(copy=False)
-            self.in_lower_buffers[0] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[0,:] = self.in_lower_buffers[0]
-            else:
-                for i in xrange(0,loc_ny+1):
-                    solution_array[0,i] = self.in_lower_buffers[0][i]
-        
-        # communicate in the y-direction afterwards
-        if lower_y_neigh>-1:
-            if self.slice_copy:
-                self.out_lower_buffers[1] = ascontiguousarray(solution_array[:,1])
-            else:
-                for i in xrange(0,loc_nx+1):
-                    self.out_lower_buffers[1][i] = solution_array[i,1]
-            t = self.comm.south.send(self.out_lower_buffers[1], **flags)
-            trackers.append(t)
-            
-            
-        if upper_y_neigh>-1:
-            msg = self.comm.north.recv(copy=False)
-            self.in_upper_buffers[1] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[:,loc_ny] = self.in_upper_buffers[1]
-                self.out_upper_buffers[1] = ascontiguousarray(solution_array[:,loc_ny-1])
-            else:
-                for i in xrange(0,loc_nx+1):
-                    solution_array[i,loc_ny] = self.in_upper_buffers[1][i]
-                    self.out_upper_buffers[1][i] = solution_array[i,loc_ny-1]
-            t = self.comm.north.send(self.out_upper_buffers[1], **flags)
-            trackers.append(t)
-            
-        if lower_y_neigh>-1:
-            msg = self.comm.south.recv(copy=False)
-            self.in_lower_buffers[1] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[:,0] = self.in_lower_buffers[1]
-            else:
-                for i in xrange(0,loc_nx+1):
-                    solution_array[i,0] = self.in_lower_buffers[1][i]
-        
-        # wait for sends to complete:
-        if flags['track']:
-            for t in trackers:
-                t.wait()
-
-    def update_internal_boundary_send_recv (self, solution_array):
-        """update the inner boundary, sending first, then recving"""
-        nsd_ = self.nsd
-        dtype = solution_array.dtype
-        if nsd_!=len(self.in_lower_buffers) | nsd_!=len(self.out_lower_buffers):
-            print "Buffers for communicating with lower neighbors not ready"
-            return
-        if nsd_!=len(self.in_upper_buffers) | nsd_!=len(self.out_upper_buffers):
-            print "Buffers for communicating with upper neighbors not ready"
-            return
-
-        loc_nx = self.subd_hi_ix[0]-self.subd_lo_ix[0]
-        loc_ny = self.subd_hi_ix[1]-self.subd_lo_ix[1]
-
-        lower_x_neigh = self.lower_neighbors[0]
-        upper_x_neigh = self.upper_neighbors[0]
-        lower_y_neigh = self.lower_neighbors[1]
-        upper_y_neigh = self.upper_neighbors[1]
-        trackers = []
-        flags = dict(copy=False, track=False)
-        
-        # send in all directions first
-        if lower_x_neigh>-1:
-            if self.slice_copy:
-                self.out_lower_buffers[0] = ascontiguousarray(solution_array[1,:])
-            else:
-                for i in xrange(0,loc_ny+1):
-                    self.out_lower_buffers[0][i] = solution_array[1,i]
-            t = self.comm.west.send(self.out_lower_buffers[0], **flags)
-            trackers.append(t)
-        
-        if lower_y_neigh>-1:
-            if self.slice_copy:
-                self.out_lower_buffers[1] = ascontiguousarray(solution_array[:,1])
-            else:
-                for i in xrange(0,loc_nx+1):
-                    self.out_lower_buffers[1][i] = solution_array[i,1]
-            t = self.comm.south.send(self.out_lower_buffers[1], **flags)
-            trackers.append(t)
-            
-        if upper_x_neigh>-1:
-            if self.slice_copy:
-                self.out_upper_buffers[0] = ascontiguousarray(solution_array[loc_nx-1,:])
-            else:
-                for i in xrange(0,loc_ny+1):
-                    self.out_upper_buffers[0][i] = solution_array[loc_nx-1,i]
-            t = self.comm.east.send(self.out_upper_buffers[0], **flags)
-            trackers.append(t)
-        
-        if upper_y_neigh>-1:
-            if self.slice_copy:
-                self.out_upper_buffers[1] = ascontiguousarray(solution_array[:,loc_ny-1])
-            else:
-                for i in xrange(0,loc_nx+1):
-                    self.out_upper_buffers[1][i] = solution_array[i,loc_ny-1]
-            t = self.comm.north.send(self.out_upper_buffers[1], **flags)
-            trackers.append(t)
-        
-        
-        # now start receiving
-        if upper_x_neigh>-1:
-            msg = self.comm.east.recv(copy=False)
-            self.in_upper_buffers[0] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[loc_nx,:] = self.in_upper_buffers[0]
-            else:
-                for i in xrange(0,loc_ny+1):
-                    solution_array[loc_nx,i] = self.in_upper_buffers[0][i]
-
-        if lower_x_neigh>-1:
-            msg = self.comm.west.recv(copy=False)
-            self.in_lower_buffers[0] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[0,:] = self.in_lower_buffers[0]
-            else:
-                for i in xrange(0,loc_ny+1):
-                    solution_array[0,i] = self.in_lower_buffers[0][i]
-        
-        if upper_y_neigh>-1:
-            msg = self.comm.north.recv(copy=False)
-            self.in_upper_buffers[1] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[:,loc_ny] = self.in_upper_buffers[1]
-            else:
-                for i in xrange(0,loc_nx+1):
-                    solution_array[i,loc_ny] = self.in_upper_buffers[1][i]
-            
-        if lower_y_neigh>-1:
-            msg = self.comm.south.recv(copy=False)
-            self.in_lower_buffers[1] = frombuffer(msg, dtype=dtype)
-            if self.slice_copy:
-                solution_array[:,0] = self.in_lower_buffers[1]
-            else:
-                for i in xrange(0,loc_nx+1):
-                    solution_array[i,0] = self.in_lower_buffers[1][i]
-        
-        # wait for sends to complete:
-        if flags['track']:
-            for t in trackers:
-                t.wait()
-    
-    # use send/recv pattern instead of x/y sweeps
-    update_internal_boundary = update_internal_boundary_send_recv
-
diff --git a/docs/examples/newparallel/wave2D/communicator.py b/docs/examples/newparallel/wave2D/communicator.py
deleted file mode 100644
index 4abb2eb2ae0..00000000000
--- a/docs/examples/newparallel/wave2D/communicator.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-"""A simple Communicator class that has N,E,S,W neighbors connected via 0MQ PEER sockets"""
-
-import socket
-
-import zmq
-
-from IPython.parallel.util import disambiguate_url
-
-class EngineCommunicator(object):
-    """An object that connects Engines to each other.
-    north and east sockets listen, while south and west sockets connect.
-    
-    This class is useful in cases where there is a set of nodes that
-    must communicate only with their nearest neighbors.
-    """
-    
-    def __init__(self, interface='tcp://*', identity=None):
-        self._ctx = zmq.Context()
-        self.north = self._ctx.socket(zmq.PAIR)
-        self.west = self._ctx.socket(zmq.PAIR)
-        self.south = self._ctx.socket(zmq.PAIR)
-        self.east = self._ctx.socket(zmq.PAIR)
-        
-        # bind to ports
-        northport = self.north.bind_to_random_port(interface)
-        eastport = self.east.bind_to_random_port(interface)
-        
-        self.north_url = interface+":%i"%northport
-        self.east_url = interface+":%i"%eastport
-        
-        # guess first public IP from socket
-        self.location = socket.gethostbyname_ex(socket.gethostname())[-1][0]
-    
-    def __del__(self):
-        self.north.close()
-        self.south.close()
-        self.east.close()
-        self.west.close()
-        self._ctx.term()
-    
-    @property
-    def info(self):
-        """return the connection info for this object's sockets."""
-        return (self.location, self.north_url, self.east_url)
-    
-    def connect(self, south_peer=None, west_peer=None):
-        """connect to peers.  `peers` will be a 3-tuples, of the form:
-        (location, north_addr, east_addr)
-        as produced by
-        """
-        if south_peer is not None:
-            location, url, _ = south_peer
-            self.south.connect(disambiguate_url(url, location))
-        if west_peer is not None:
-            location, _, url = west_peer
-            self.west.connect(disambiguate_url(url, location))
-    
-
diff --git a/docs/examples/newparallel/wave2D/parallelwave-mpi.py b/docs/examples/newparallel/wave2D/parallelwave-mpi.py
deleted file mode 100755
index f747217a8b4..00000000000
--- a/docs/examples/newparallel/wave2D/parallelwave-mpi.py
+++ /dev/null
@@ -1,205 +0,0 @@
-#!/usr/bin/env python
-"""
-A simple python program of solving a 2D wave equation in parallel.
-Domain partitioning and inter-processor communication
-are done by an object of class MPIRectPartitioner2D
-(which is a subclass of RectPartitioner2D and uses MPI via mpi4py)
-
-An example of running the program is (8 processors, 4x2 partition,
-400x100 grid cells)::
-
-   $ ipclusterz start --profile mpi -n 8 # start 8 engines (assuming mpi profile has been configured)
-   $ ./parallelwave-mpi.py --grid 400 100 --partition 4 2 --profile mpi
-
-See also parallelwave-mpi, which runs the same program, but uses MPI 
-(via mpi4py) for the inter-engine communication.
-
-Authors
--------
-
- * Xing Cai
- * Min Ragan-Kelley
-
-"""
-
-import sys
-import time
-
-from numpy import exp, zeros, newaxis, sqrt
-
-from IPython.external import argparse
-from IPython.parallel import Client, Reference
-
-def setup_partitioner(index, num_procs, gnum_cells, parts):
-    """create a partitioner in the engine namespace"""
-    global partitioner
-    p = MPIRectPartitioner2D(my_id=index, num_procs=num_procs)
-    p.redim(global_num_cells=gnum_cells, num_parts=parts)
-    p.prepare_communication()
-    # put the partitioner into the global namespace:
-    partitioner=p
-
-def setup_solver(*args, **kwargs):
-    """create a WaveSolver in the engine namespace"""
-    global solver
-    solver = WaveSolver(*args, **kwargs)
-
-def wave_saver(u, x, y, t):
-    """save the wave log"""
-    global u_hist
-    global t_hist
-    t_hist.append(t)
-    u_hist.append(1.0*u)
-    
-
-# main program:
-if __name__ == '__main__':
-    
-    parser = argparse.ArgumentParser()
-    paa = parser.add_argument
-    paa('--grid', '-g',
-        type=int, nargs=2, default=[100,100], dest='grid',
-        help="Cells in the grid, e.g. --grid 100 200")
-    paa('--partition', '-p',
-        type=int, nargs=2, default=None,
-        help="Process partition grid, e.g. --partition 4 2 for 4x2")
-    paa('-c',
-        type=float, default=1.,
-        help="Wave speed (I think)")
-    paa('-Ly',
-        type=float, default=1.,
-        help="system size (in y)")
-    paa('-Lx',
-        type=float, default=1.,
-        help="system size (in x)")
-    paa('-t', '--tstop',
-        type=float, default=1.,
-        help="Time units to run")
-    paa('--profile', 
-        type=unicode, default=u'default',
-        help="Specify the ipcluster profile for the client to connect to.")
-    paa('--save', 
-        action='store_true',
-        help="Add this flag to save the time/wave history during the run.")
-    paa('--scalar', 
-        action='store_true',
-        help="Also run with scalar interior implementation, to see vector speedup.")
-    
-    ns = parser.parse_args()
-    # set up arguments
-    grid = ns.grid
-    partition = ns.partition
-    Lx = ns.Lx
-    Ly = ns.Ly
-    c = ns.c
-    tstop = ns.tstop
-    if ns.save:
-        user_action = wave_saver
-    else:
-        user_action = None
-    
-    num_cells = 1.0*(grid[0]-1)*(grid[1]-1)
-    final_test = True
-    
-    # create the Client
-    rc = Client(profile=ns.profile)
-    num_procs = len(rc.ids)
-    
-    if partition is None:
-        partition = [1,num_procs]
-    
-    assert partition[0]*partition[1] == num_procs, "can't map partition %s to %i engines"%(partition, num_procs)
-    
-    view = rc[:]
-    print "Running %s system on %s processes until %f"%(grid, partition, tstop)
-    
-    # functions defining initial/boundary/source conditions
-    def I(x,y):
-        from numpy import exp
-        return 1.5*exp(-100*((x-0.5)**2+(y-0.5)**2))
-    def f(x,y,t):
-        return 0.0
-        # from numpy import exp,sin
-        # return 10*exp(-(x - sin(100*t))**2)
-    def bc(x,y,t):
-        return 0.0
-    
-    # initial imports, setup rank
-    view.execute('\n'.join([
-    "from mpi4py import MPI",
-    "import numpy",
-    "mpi = MPI.COMM_WORLD",
-    "my_id = MPI.COMM_WORLD.Get_rank()"]), block=True)
-    
-    # initialize t_hist/u_hist for saving the state at each step (optional)
-    view['t_hist'] = []
-    view['u_hist'] = []
-    
-    # set vector/scalar implementation details
-    impl = {}
-    impl['ic'] = 'vectorized'
-    impl['inner'] = 'scalar'
-    impl['bc'] = 'vectorized'
-    
-    # execute some files so that the classes we need will be defined on the engines:
-    view.run('RectPartitioner.py')
-    view.run('wavesolver.py')
-    
-    # setup remote partitioner
-    # note that Reference means that the argument passed to setup_partitioner will be the
-    # object named 'my_id' in the engine's namespace
-    view.apply_sync(setup_partitioner, Reference('my_id'), num_procs, grid, partition)
-    # wait for initial communication to complete
-    view.execute('mpi.barrier()')
-    # setup remote solvers
-    view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly,partitioner=Reference('partitioner'), dt=0,implementation=impl)
-
-    # lambda for calling solver.solve:
-    _solve = lambda *args, **kwargs: solver.solve(*args, **kwargs)
-    
-    if ns.scalar:
-        impl['inner'] = 'scalar'
-        # run first with element-wise Python operations for each cell
-        t0 = time.time()
-        ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test, user_action=user_action)
-        if final_test:
-            # this sum is performed element-wise as results finish
-            s = sum(ar)
-            # the L2 norm (RMS) of the result:
-            norm = sqrt(s/num_cells)
-        else:
-            norm = -1
-        t1 = time.time()
-        print 'scalar inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
-    
-    impl['inner'] = 'vectorized'
-    # setup new solvers
-    view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly,partitioner=Reference('partitioner'), dt=0,implementation=impl)
-    view.execute('mpi.barrier()')
-    
-    # run again with numpy vectorized inner-implementation
-    t0 = time.time()
-    ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test)#, user_action=wave_saver)
-    if final_test:
-        # this sum is performed element-wise as results finish
-        s = sum(ar)
-        # the L2 norm (RMS) of the result:
-        norm = sqrt(s/num_cells)
-    else:
-        norm = -1
-    t1 = time.time()
-    print 'vector inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
-    
-    # if ns.save is True, then u_hist stores the history of u as a list
-    # If the partion scheme is Nx1, then u can be reconstructed via 'gather':
-    if ns.save and partition[-1] == 1:
-        import pylab
-        view.execute('u_last=u_hist[-1]')
-        # map mpi IDs to IPython IDs, which may not match
-        ranks = view['my_id']
-        targets = range(len(ranks))
-        for idx in range(len(ranks)):
-            targets[idx] = ranks.index(idx)
-        u_last = rc[targets].gather('u_last', block=True)
-        pylab.pcolor(u_last)
-        pylab.show()
diff --git a/docs/examples/newparallel/wave2D/parallelwave.py b/docs/examples/newparallel/wave2D/parallelwave.py
deleted file mode 100755
index af2f15c1af4..00000000000
--- a/docs/examples/newparallel/wave2D/parallelwave.py
+++ /dev/null
@@ -1,209 +0,0 @@
-#!/usr/bin/env python
-"""
-A simple python program of solving a 2D wave equation in parallel.
-Domain partitioning and inter-processor communication
-are done by an object of class ZMQRectPartitioner2D
-(which is a subclass of RectPartitioner2D and uses 0MQ via pyzmq)
-
-An example of running the program is (8 processors, 4x2 partition,
-200x200 grid cells)::
-
-   $ ipclusterz start -n 8 # start 8 engines
-   $ ./parallelwave.py --grid 200 200 --partition 4 2
-
-See also parallelwave-mpi, which runs the same program, but uses MPI 
-(via mpi4py) for the inter-engine communication.
-
-Authors
--------
-
- * Xing Cai
- * Min Ragan-Kelley
-
-"""
-#
-import sys
-import time
-
-from numpy import exp, zeros, newaxis, sqrt
-
-from IPython.external import argparse
-from IPython.parallel import Client, Reference
-
-def setup_partitioner(comm, addrs, index, num_procs, gnum_cells, parts):
-    """create a partitioner in the engine namespace"""
-    global partitioner
-    p = ZMQRectPartitioner2D(comm, addrs, my_id=index, num_procs=num_procs)
-    p.redim(global_num_cells=gnum_cells, num_parts=parts)
-    p.prepare_communication()
-    # put the partitioner into the global namespace:
-    partitioner=p
-
-def setup_solver(*args, **kwargs):
-    """create a WaveSolver in the engine namespace."""
-    global solver
-    solver = WaveSolver(*args, **kwargs)
-
-def wave_saver(u, x, y, t):
-    """save the wave state for each timestep."""
-    global u_hist
-    global t_hist
-    t_hist.append(t)
-    u_hist.append(1.0*u)
-    
-
-# main program:
-if __name__ == '__main__':
-    
-    parser = argparse.ArgumentParser()
-    paa = parser.add_argument
-    paa('--grid', '-g',
-        type=int, nargs=2, default=[100,100], dest='grid',
-        help="Cells in the grid, e.g. --grid 100 200")
-    paa('--partition', '-p',
-        type=int, nargs=2, default=None,
-        help="Process partition grid, e.g. --partition 4 2 for 4x2")
-    paa('-c',
-        type=float, default=1.,
-        help="Wave speed (I think)")
-    paa('-Ly',
-        type=float, default=1.,
-        help="system size (in y)")
-    paa('-Lx',
-        type=float, default=1.,
-        help="system size (in x)")
-    paa('-t', '--tstop',
-        type=float, default=1.,
-        help="Time units to run")
-    paa('--profile', 
-        type=unicode, default=u'default',
-        help="Specify the ipcluster profile for the client to connect to.")
-    paa('--save', 
-        action='store_true',
-        help="Add this flag to save the time/wave history during the run.")
-    paa('--scalar', 
-        action='store_true',
-        help="Also run with scalar interior implementation, to see vector speedup.")
-        
-    ns = parser.parse_args()
-    # set up arguments
-    grid = ns.grid
-    partition = ns.partition
-    Lx = ns.Lx
-    Ly = ns.Ly
-    c = ns.c
-    tstop = ns.tstop
-    if ns.save:
-        user_action = wave_saver
-    else:
-        user_action = None
-    
-    num_cells = 1.0*(grid[0]-1)*(grid[1]-1)
-    final_test = True
-    
-    # create the Client
-    rc = Client(profile=ns.profile)
-    num_procs = len(rc.ids)
-    
-    if partition is None:
-        partition = [num_procs,1]
-    else:
-        num_procs = min(num_procs, partition[0]*partition[1])
-    
-    assert partition[0]*partition[1] == num_procs, "can't map partition %s to %i engines"%(partition, num_procs)
-    
-    # construct the View:
-    view = rc[:num_procs]
-    print "Running %s system on %s processes until %f"%(grid, partition, tstop)
-    
-    # functions defining initial/boundary/source conditions
-    def I(x,y):
-        from numpy import exp
-        return 1.5*exp(-100*((x-0.5)**2+(y-0.5)**2))
-    def f(x,y,t):
-        return 0.0
-        # from numpy import exp,sin
-        # return 10*exp(-(x - sin(100*t))**2)
-    def bc(x,y,t):
-        return 0.0
-    
-    # initialize t_hist/u_hist for saving the state at each step (optional)
-    view['t_hist'] = []
-    view['u_hist'] = []
-
-    # set vector/scalar implementation details
-    impl = {}
-    impl['ic'] = 'vectorized'
-    impl['inner'] = 'scalar'
-    impl['bc'] = 'vectorized'
-    
-    # execute some files so that the classes we need will be defined on the engines:
-    view.execute('import numpy')
-    view.run('communicator.py')
-    view.run('RectPartitioner.py')
-    view.run('wavesolver.py')
-    
-    # scatter engine IDs
-    view.scatter('my_id', range(num_procs), flatten=True)
-    
-    # create the engine connectors
-    view.execute('com = EngineCommunicator()')
-
-    # gather the connection information into a single dict
-    ar = view.apply_async(lambda : com.info)
-    peers = ar.get_dict()
-    # print peers
-    # this is a dict, keyed by engine ID, of the connection info for the EngineCommunicators
-    
-    # setup remote partitioner
-    # note that Reference means that the argument passed to setup_partitioner will be the
-    # object named 'com' in the engine's namespace
-    view.apply_sync(setup_partitioner, Reference('com'), peers, Reference('my_id'), num_procs, grid, partition)
-    time.sleep(1)
-    # convenience lambda to call solver.solve:
-    _solve = lambda *args, **kwargs: solver.solve(*args, **kwargs)
-
-    if ns.scalar:
-        impl['inner'] = 'scalar'
-        # setup remote solvers
-        view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly, partitioner=Reference('partitioner'), dt=0,implementation=impl)
-
-        # run first with element-wise Python operations for each cell
-        t0 = time.time()
-        ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test, user_action=user_action)
-        if final_test:
-            # this sum is performed element-wise as results finish
-            s = sum(ar)
-            # the L2 norm (RMS) of the result:
-            norm = sqrt(s/num_cells)
-        else:
-            norm = -1
-        t1 = time.time()
-        print 'scalar inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
-    
-    # run again with faster numpy-vectorized inner implementation:
-    impl['inner'] = 'vectorized'
-    # setup remote solvers
-    view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly,partitioner=Reference('partitioner'), dt=0,implementation=impl)
-
-    t0 = time.time()
-    
-    ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test)#, user_action=wave_saver)
-    if final_test:
-        # this sum is performed element-wise as results finish
-        s = sum(ar)
-        # the L2 norm (RMS) of the result:
-        norm = sqrt(s/num_cells)
-    else:
-        norm = -1
-    t1 = time.time()
-    print 'vector inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
-    
-    # if ns.save is True, then u_hist stores the history of u as a list
-    # If the partion scheme is Nx1, then u can be reconstructed via 'gather':
-    if ns.save and partition[-1] == 1:
-        import pylab
-        view.execute('u_last=u_hist[-1]')
-        u_last = view.gather('u_last', block=True)
-        pylab.pcolor(u_last)
-        pylab.show()
\ No newline at end of file
diff --git a/docs/examples/newparallel/wave2D/wavesolver.py b/docs/examples/newparallel/wave2D/wavesolver.py
deleted file mode 100755
index 00cb2fc8988..00000000000
--- a/docs/examples/newparallel/wave2D/wavesolver.py
+++ /dev/null
@@ -1,267 +0,0 @@
-#!/usr/bin/env python
-"""
-A simple WaveSolver class for evolving the wave equation in 2D.
-This works in parallel by using a RectPartitioner object.
-
-Authors
--------
-
- * Xing Cai
- * Min Ragan-Kelley
-
-"""
-import time
-
-from numpy import exp, zeros, newaxis, sqrt, arange
-
-def iseq(start=0, stop=None, inc=1):
-    """
-    Generate integers from start to (and including!) stop,
-    with increment of inc. Alternative to range/xrange.
-    """
-    if stop is None: # allow isequence(3) to be 0, 1, 2, 3
-        # take 1st arg as stop, start as 0, and inc=1
-        stop = start; start = 0; inc = 1
-    return arange(start, stop+inc, inc)
-
-class WaveSolver(object):
-    """
-    Solve the 2D wave equation u_tt = u_xx + u_yy + f(x,y,t) with
-    u = bc(x,y,t) on the boundary and initial condition du/dt = 0.
-
-    Parallelization by using a RectPartitioner object 'partitioner'
-
-    nx and ny are the total number of global grid cells in the x and y
-    directions. The global grid points are numbered as (0,0), (1,0), (2,0),
-    ..., (nx,0), (0,1), (1,1), ..., (nx, ny).
-
-    dt is the time step. If dt<=0, an optimal time step is used.
-
-    tstop is the stop time for the simulation.
-
-    I, f are functions: I(x,y), f(x,y,t)
-    
-    user_action: function of (u, x, y, t) called at each time
-    level (x and y are one-dimensional coordinate vectors).
-    This function allows the calling code to plot the solution,
-    compute errors, etc.
-
-    implementation: a dictionary specifying how the initial
-    condition ('ic'), the scheme over inner points ('inner'),
-    and the boundary conditions ('bc') are to be implemented.
-    Normally, values are legal: 'scalar' or 'vectorized'.
-    'scalar' means straight loops over grid points, while
-    'vectorized' means special NumPy vectorized operations.
-
-    If a key in the implementation dictionary is missing, it
-    defaults in this function to 'scalar' (the safest strategy).
-    Note that if 'vectorized' is specified, the functions I, f,
-    and bc must work in vectorized mode. It is always recommended
-    to first run the 'scalar' mode and then compare 'vectorized'
-    results with the 'scalar' results to check that I, f, and bc
-    work.
-
-    verbose: true if a message at each time step is written,
-    false implies no output during the simulation.
-
-    final_test: true means the discrete L2-norm of the final solution is
-    to be computed.
-    """
-    
-    def __init__(self, I, f, c, bc, Lx, Ly, partitioner=None, dt=-1,
-                user_action=None, 
-                implementation={'ic': 'vectorized',  # or 'scalar'
-                                'inner': 'vectorized',
-                                'bc': 'vectorized'}):
-        
-        nx = partitioner.global_num_cells[0]  # number of global cells in x dir
-        ny = partitioner.global_num_cells[1]  # number of global cells in y dir
-        dx = Lx/float(nx)
-        dy = Ly/float(ny)
-        loc_nx, loc_ny = partitioner.get_num_loc_cells()
-        nx = loc_nx; ny = loc_ny              # now use loc_nx and loc_ny instead
-        lo_ix0 = partitioner.subd_lo_ix[0]
-        lo_ix1 = partitioner.subd_lo_ix[1]
-        hi_ix0 = partitioner.subd_hi_ix[0]
-        hi_ix1 = partitioner.subd_hi_ix[1]
-        x = iseq(dx*lo_ix0, dx*hi_ix0, dx) # local grid points in x dir
-        y = iseq(dy*lo_ix1, dy*hi_ix1, dy) # local grid points in y dir
-        self.x = x
-        self.y = y
-        xv = x[:,newaxis]   # for vectorized expressions with f(xv,yv)
-        yv = y[newaxis,:]   # -- " --
-        if dt <= 0:
-            dt = (1/float(c))*(1/sqrt(1/dx**2 + 1/dy**2))  # max time step
-        Cx2 = (c*dt/dx)**2;  Cy2 = (c*dt/dy)**2;  dt2 = dt**2  # help variables
-
-        u = zeros((nx+1,ny+1))   # solution array
-        u_1 = u.copy()           # solution at t-dt
-        u_2 = u.copy()           # solution at t-2*dt
-
-        # preserve for self.solve
-        implementation=dict(implementation) # copy
-
-        if 'ic' not in implementation:
-            implementation['ic'] = 'scalar'
-        if 'bc' not in implementation:
-            implementation['bc'] = 'scalar'
-        if 'inner' not in implementation:
-            implementation['inner'] = 'scalar'
-
-        self.implementation = implementation
-        self.Lx = Lx
-        self.Ly = Ly
-        self.I=I
-        self.f=f
-        self.c=c
-        self.bc=bc
-        self.user_action = user_action
-        self.partitioner=partitioner
-
-        # set initial condition (pointwise - allows straight if-tests in I(x,y)):
-        t=0.0
-        if implementation['ic'] == 'scalar':
-            for i in xrange(0,nx+1):
-                for j in xrange(0,ny+1):
-                    u_1[i,j] = I(x[i], y[j])
-
-            for i in xrange(1,nx):
-                for j in xrange(1,ny):
-                    u_2[i,j] = u_1[i,j] + \
-                           0.5*Cx2*(u_1[i-1,j] - 2*u_1[i,j] + u_1[i+1,j]) + \
-                           0.5*Cy2*(u_1[i,j-1] - 2*u_1[i,j] + u_1[i,j+1]) + \
-                           dt2*f(x[i], y[j], 0.0)                       
-
-            # boundary values of u_2 (equals u(t=dt) due to du/dt=0)
-            i = 0
-            for j in xrange(0,ny+1):
-                u_2[i,j] = bc(x[i], y[j], t+dt)
-            j = 0
-            for i in xrange(0,nx+1):
-                u_2[i,j] = bc(x[i], y[j], t+dt)
-            i = nx
-            for j in xrange(0,ny+1):
-                u_2[i,j] = bc(x[i], y[j], t+dt)
-            j = ny
-            for i in xrange(0,nx+1):
-                u_2[i,j] = bc(x[i], y[j], t+dt)
-
-        elif implementation['ic'] == 'vectorized':
-            u_1 = I(xv,yv)
-            u_2[1:nx,1:ny] = u_1[1:nx,1:ny] + \
-            0.5*Cx2*(u_1[0:nx-1,1:ny] - 2*u_1[1:nx,1:ny] + u_1[2:nx+1,1:ny]) + \
-            0.5*Cy2*(u_1[1:nx,0:ny-1] - 2*u_1[1:nx,1:ny] + u_1[1:nx,2:ny+1]) + \
-            dt2*(f(xv[1:nx,1:ny], yv[1:nx,1:ny], 0.0))
-            # boundary values (t=dt):
-            i = 0;  u_2[i,:] = bc(x[i], y, t+dt)
-            j = 0;  u_2[:,j] = bc(x, y[j], t+dt)
-            i = nx; u_2[i,:] = bc(x[i], y, t+dt)
-            j = ny; u_2[:,j] = bc(x, y[j], t+dt)
-
-        if user_action is not None:
-            user_action(u_1, x, y, t)  # allow user to plot etc.
-        # print list(self.us[2][2])
-        self.us = (u,u_1,u_2)
-    
-    
-    def solve(self, tstop, dt=-1, user_action=None, verbose=False, final_test=False):
-        t0=time.time()
-        f=self.f
-        c=self.c
-        bc=self.bc
-        partitioner = self.partitioner
-        implementation = self.implementation
-        nx = partitioner.global_num_cells[0]  # number of global cells in x dir
-        ny = partitioner.global_num_cells[1]  # number of global cells in y dir
-        dx = self.Lx/float(nx)
-        dy = self.Ly/float(ny)
-        loc_nx, loc_ny = partitioner.get_num_loc_cells()
-        nx = loc_nx; ny = loc_ny              # now use loc_nx and loc_ny instead
-        x = self.x
-        y = self.y
-        xv = x[:,newaxis]   # for vectorized expressions with f(xv,yv)
-        yv = y[newaxis,:]   # -- " --
-        if dt <= 0:
-            dt = (1/float(c))*(1/sqrt(1/dx**2 + 1/dy**2))  # max time step
-        Cx2 = (c*dt/dx)**2;  Cy2 = (c*dt/dy)**2;  dt2 = dt**2  # help variables
-        # id for the four possible neighbor subdomains
-        lower_x_neigh = partitioner.lower_neighbors[0]
-        upper_x_neigh = partitioner.upper_neighbors[0]
-        lower_y_neigh = partitioner.lower_neighbors[1]
-        upper_y_neigh = partitioner.upper_neighbors[1]
-        u,u_1,u_2 = self.us
-        # u_1 = self.u_1
-        
-        t = 0.0
-        while t <= tstop:
-            t_old = t;  t += dt
-            if verbose:
-                print 'solving (%s version) at t=%g' % \
-                      (implementation['inner'], t)
-            # update all inner points:
-            if implementation['inner'] == 'scalar':
-                for i in xrange(1, nx):
-                    for j in xrange(1, ny):
-                        u[i,j] = - u_2[i,j] + 2*u_1[i,j] + \
-                           Cx2*(u_1[i-1,j] - 2*u_1[i,j] + u_1[i+1,j]) + \
-                           Cy2*(u_1[i,j-1] - 2*u_1[i,j] + u_1[i,j+1]) + \
-                           dt2*f(x[i], y[j], t_old)
-            elif implementation['inner'] == 'vectorized':
-                u[1:nx,1:ny] = - u_2[1:nx,1:ny] + 2*u_1[1:nx,1:ny] + \
-               Cx2*(u_1[0:nx-1,1:ny] - 2*u_1[1:nx,1:ny] + u_1[2:nx+1,1:ny]) + \
-               Cy2*(u_1[1:nx,0:ny-1] - 2*u_1[1:nx,1:ny] + u_1[1:nx,2:ny+1]) + \
-               dt2*f(xv[1:nx,1:ny], yv[1:nx,1:ny], t_old)
-            
-            # insert boundary conditions (if there's no neighbor):
-            if lower_x_neigh < 0:
-                if implementation['bc'] == 'scalar':
-                    i = 0
-                    for j in xrange(0, ny+1):
-                        u[i,j] = bc(x[i], y[j], t)
-                elif implementation['bc'] == 'vectorized':
-                    u[0,:] = bc(x[0], y, t)
-            if upper_x_neigh < 0:
-                if implementation['bc'] == 'scalar':
-                    i = nx
-                    for j in xrange(0, ny+1):
-                        u[i,j] = bc(x[i], y[j], t)
-                elif implementation['bc'] == 'vectorized':
-                    u[nx,:] = bc(x[nx], y, t)
-            if lower_y_neigh < 0:
-                if implementation['bc'] == 'scalar':
-                    j = 0
-                    for i in xrange(0, nx+1):
-                        u[i,j] = bc(x[i], y[j], t)
-                elif implementation['bc'] == 'vectorized':
-                    u[:,0] = bc(x, y[0], t)
-            if upper_y_neigh < 0:
-                if implementation['bc'] == 'scalar':
-                    j = ny
-                    for i in xrange(0, nx+1):
-                        u[i,j] = bc(x[i], y[j], t)
-                elif implementation['bc'] == 'vectorized':
-                    u[:,ny] = bc(x, y[ny], t)
-
-            # communication
-            partitioner.update_internal_boundary (u)
-
-            if user_action is not None:
-                user_action(u, x, y, t)
-            # update data structures for next step
-            u_2, u_1, u = u_1, u, u_2
-
-        t1 = time.time()
-        print 'my_id=%2d, dt=%g, %s version, slice_copy=%s, net Wtime=%g'\
-              %(partitioner.my_id,dt,implementation['inner'],\
-                partitioner.slice_copy,t1-t0)
-        # save the us
-        self.us = u,u_1,u_2
-        # check final results; compute discrete L2-norm of the solution
-        if final_test:
-            loc_res = 0.0
-            for i in iseq(start=1, stop=nx-1):
-                for j in iseq(start=1, stop=ny-1):
-                    loc_res += u_1[i,j]**2
-            return loc_res
-        return dt
-
diff --git a/docs/examples/newparallel/workflow/client.py b/docs/examples/newparallel/workflow/client.py
deleted file mode 100644
index 985e8225b38..00000000000
--- a/docs/examples/newparallel/workflow/client.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from IPython.parallel.client import Client
-
-client = Client()
diff --git a/docs/examples/newparallel/workflow/job_wrapper.py b/docs/examples/newparallel/workflow/job_wrapper.py
deleted file mode 100755
index 216fe51fbf5..00000000000
--- a/docs/examples/newparallel/workflow/job_wrapper.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-"""Python wrapper around a submitted workflow job.
-
-In reality this would be a more sophisticated script, here we only illustrate
-the basic idea by considering that a submitted 'job' is a Python string to be
-executed.
-"""
-
-import sys
-
-argv = sys.argv
-
-from IPython.parallel.engine import EngineFactory
-from IPython.parallel.ipengineapp import launch_new_instance
-
-ns = {}
-
-# job
-exec sys.argv[1] in ns
-
-# this should really use Config:
-EngineFactory.user_ns = ns
-
-# start engine with job namespace
-launch_new_instance()
diff --git a/docs/examples/newparallel/workflow/wmanager.py b/docs/examples/newparallel/workflow/wmanager.py
deleted file mode 100644
index e4786b4a250..00000000000
--- a/docs/examples/newparallel/workflow/wmanager.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""Mock workflow manager.
-
-This is a mock work manager whose submitted 'jobs' simply consist of executing
-a python string.  What we want is to see the implementation of the ipython
-controller part.
-"""
-
-from __future__ import print_function
-
-import atexit
-import sys
-
-from subprocess import Popen
-
-def cleanup(controller, engines):
-    """Cleanup routine to shut down all subprocesses we opened."""
-    import signal, time
-    
-    print('Starting cleanup')
-    print('Stopping engines...')
-    for e in engines:
-        e.send_signal(signal.SIGINT)
-    print('Stopping controller...')
-    # so it can shut down its queues
-    controller.send_signal(signal.SIGINT)
-    time.sleep(0.1)
-    print('Killing controller...')
-    controller.kill()
-    print('Cleanup done')
-
-
-if __name__ == '__main__':
-
-    # Start controller in separate process
-    cont = Popen(['python', '-m', 'IPython.parallel.ipcontrollerapp'])
-    print('Started controller')
-
-    # "Submit jobs"
-    eng = []
-    for i in range(4):
-        eng.append(Popen(['python', 'job_wrapper.py','x=%s' % i]))
-
-    # Ensure that all subpro
-    atexit.register(lambda : cleanup(cont, eng))
diff --git a/docs/gh-pages.py b/docs/gh-pages.py
deleted file mode 100755
index 005084153ed..00000000000
--- a/docs/gh-pages.py
+++ /dev/null
@@ -1,132 +0,0 @@
-#!/usr/bin/env python
-"""Script to commit the doc build outputs into the github-pages repo.
-
-Use:
-
-  gh-pages.py [tag]
-
-If no tag is given, the current output of 'git describe' is used.  If given,
-that is how the resulting directory will be named.
-
-In practice, you should use either actual clean tags from a current build or
-something like 'current' as a stable URL for the most current version of the """
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-import os
-import re
-import shutil
-import sys
-from os import chdir as cd
-from os.path import join as pjoin
-
-from subprocess import Popen, PIPE, CalledProcessError, check_call
-
-#-----------------------------------------------------------------------------
-# Globals
-#-----------------------------------------------------------------------------
-
-pages_dir = 'gh-pages'
-html_dir = 'build/html'
-pdf_dir = 'build/latex'
-pages_repo = 'git@github.com:ipython/ipython-doc.git'
-
-#-----------------------------------------------------------------------------
-# Functions
-#-----------------------------------------------------------------------------
-def sh(cmd):
-    """Execute command in a subshell, return status code."""
-    return check_call(cmd, shell=True)
-
-
-def sh2(cmd):
-    """Execute command in a subshell, return stdout.
-
-    Stderr is unbuffered from the subshell.x"""
-    p = Popen(cmd, stdout=PIPE, shell=True)
-    out = p.communicate()[0]
-    retcode = p.returncode
-    if retcode:
-        raise CalledProcessError(retcode, cmd)
-    else:
-        return out.rstrip()
-
-
-def sh3(cmd):
-    """Execute command in a subshell, return stdout, stderr
-
-    If anything appears in stderr, print it out to sys.stderr"""
-    p = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True)
-    out, err = p.communicate()
-    retcode = p.returncode
-    if retcode:
-        raise CalledProcessError(retcode, cmd)
-    else:
-        return out.rstrip(), err.rstrip()
-
-
-def init_repo(path):
-    """clone the gh-pages repo if we haven't already."""
-    sh("git clone %s %s"%(pages_repo, path))
-    here = os.getcwd()
-    cd(path)
-    sh('git checkout gh-pages')
-    cd(here)
-
-#-----------------------------------------------------------------------------
-# Script starts
-#-----------------------------------------------------------------------------
-if __name__ == '__main__':
-    # The tag can be given as a positional argument
-    try:
-        tag = sys.argv[1]
-    except IndexError:
-        try:
-            tag = sh2('git describe')
-        except CalledProcessError:
-            tag = "dev"   # Fallback
-    
-    startdir = os.getcwd()
-    if not os.path.exists(pages_dir):
-        # init the repo
-        init_repo(pages_dir)
-    else:
-        # ensure up-to-date before operating
-        cd(pages_dir)
-        sh('git checkout gh-pages')
-        sh('git pull')
-        cd(startdir)
-
-    dest = pjoin(pages_dir, tag)
-
-    # don't `make html` here, because gh-pages already depends on html in Makefile
-    # sh('make html')
-
-    # This is pretty unforgiving: we unconditionally nuke the destination
-    # directory, and then copy the html tree in there
-    shutil.rmtree(dest, ignore_errors=True)
-    shutil.copytree(html_dir, dest)
-    shutil.copy(pjoin(pdf_dir, 'ipython.pdf'), pjoin(dest, 'ipython.pdf'))
-
-    try:
-        cd(pages_dir)
-        status = sh2('git status | head -1')
-        branch = re.match('\# On branch (.*)$', status).group(1)
-        if branch != 'gh-pages':
-            e = 'On %r, git branch is %r, MUST be "gh-pages"' % (pages_dir,
-                                                                 branch)
-            raise RuntimeError(e)
-
-        sh('git add %s' % tag)
-        sh('git commit -m"Updated doc release: %s"' % tag)
-        print
-        print 'Most recent 3 commits:'
-        sys.stdout.flush()
-        sh('git --no-pager log --oneline HEAD~3..')
-    finally:
-        cd(startdir)
-
-    print
-    print 'Now verify the build in: %r' % dest
-    print "If everything looks good, 'git push'"
diff --git a/docs/make.cmd b/docs/make.cmd
new file mode 100644
index 00000000000..3f95b10e466
--- /dev/null
+++ b/docs/make.cmd
@@ -0,0 +1,83 @@
+@ECHO OFF
+REM ~ Windows command line make file for Sphinx documentation
+
+SETLOCAL
+
+SET SPHINXOPTS=
+SET SPHINXBUILD=sphinx-build
+SET PAPER=
+SET SRCDIR=source
+SET PYTHON=python
+
+IF "%PAPER%" == "" SET PAPER=a4
+SET ALLSPHINXOPTS=-d build\doctrees -D latex_paper_size=%PAPER% %SPHINXOPTS% %SRCDIR%
+
+FOR %%X IN (%SPHINXBUILD%.exe) DO SET P=%%~$PATH:X
+
+FOR %%L IN (html html_noapi pickle htmlhelp latex changes linkcheck) DO (
+    IF "%1" == "%%L" (
+        IF "%P%" == "" (
+            ECHO.
+            ECHO Error: Sphinx is not available. Please make sure it is correctly installed.
+            GOTO END
+        )
+        MD build\doctrees 2>NUL
+        MD build\%1 || GOTO DIR_EXIST
+        %PYTHON% autogen_config.py && ECHO Created docs for config options
+        %PYTHON% autogen_magics.py && ECHO Created docs for line ^& cell magics
+        %PYTHON% autogen_shortcuts.py && ECHO Created docs for shortcuts
+        IF NOT "%1" == "html_noapi" (
+            %PYTHON% autogen_api.py && ECHO Build API docs finished
+            %SPHINXBUILD% -b %1 %ALLSPHINXOPTS% build\%1
+        ) ELSE (
+            %SPHINXBUILD% -b html %ALLSPHINXOPTS% build\%1
+        )
+        IF NOT ERRORLEVEL 0 GOTO ERROR
+        ECHO.
+        ECHO Build finished. Results are in build\%1.
+        IF "%1" == "pickle" (
+            ECHO Now you can process the pickle files or run
+            ECHO    sphinx-web build\pickle to start the sphinx-web server.
+        )
+        IF "%1" == "htmlhelp" (
+            ECHO Now you can run HTML Help Workshop with the
+            ECHO    .hhp project file in build/htmlhelp.
+        )
+        IF "%1" == "linkcheck" (
+            ECHO Look for any errors in the above output
+            ECHO    or in build\linkcheck\output.rst.
+        )
+        GOTO END
+    )
+)
+
+
+IF "%1" == "clean" (
+    RD /s /q build dist %SRCDIR%\api\generated 2>NUL
+    IF ERRORLEVEL 0 ECHO Build environment cleaned!
+    GOTO END
+)
+
+ECHO.
+ECHO Please use "make [target]" where [target] is one of:
+ECHO.
+ECHO    html        to make standalone HTML files
+ECHO    html_noapi  same as above, without the time consuming API docs
+ECHO    jsapi       to make standalone HTML files for the Javascript API
+ECHO    pickle      to make pickle files (usable by e.g. sphinx-web)
+ECHO    htmlhelp    to make HTML files and a HTML help project
+ECHO    latex       to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+ECHO    changes     to make an overview over all changed/added/deprecated items
+ECHO    linkcheck   to check all external links for integrity
+GOTO END
+
+:DIR_EXIST
+ECHO.
+ECHO Info: Run "make clean" to clean build environment
+
+:ERROR
+ECHO.
+ECHO Error: Build process failed!
+
+:END
+ENDLOCAL
\ No newline at end of file
diff --git a/docs/man/ipcluster.1 b/docs/man/ipcluster.1
deleted file mode 100644
index 418edd7a9a0..00000000000
--- a/docs/man/ipcluster.1
+++ /dev/null
@@ -1,48 +0,0 @@
-.TH IPCLUSTER 1 "October 28, 2008" "" ""
-.SH NAME
-\fBipcluster \- IPython parallel computing cluster control tool
-.SH SYNOPSIS
-.nf
-.fam C
-\fBipcluster\fP {\fmpiexec,local,mpirun,pbs,ssh\fP} [\fIoptions\fP]
-.fam T
-.fi
-.SH DESCRIPTION
-ipcluster is a control tool for IPython's parallel computing functions.
-
-IPython cluster startup. This starts a controller and engines using various
-approaches. Use the IPYTHON_DIR environment variable to change your IPython
-directory from the default of .ipython or _ipython. The log and security
-subdirectories of your IPython directory will be used by this script for log
-files and security files.
-.SH POSITIONAL ARGUMENTS
-
-The first positional argument should be one of: {mpiexec, local, mpirun, pbs,
-ssh}, which are the available cluster types.
-
-For detailed help on each, type "ipcluster TYPE --help". Briefly:
-
-  local         run a local cluster
-  mpirun        run a cluster using mpirun (mpiexec also works)
-  mpiexec       run a cluster using mpiexec (mpirun also works)
-  pbs           run a pbs cluster
-  ssh           run a cluster using ssh, should have ssh-keys setup
-.SH OPTIONS
-.TP
-.B
-\-h, \-\-help
-show help message and exit
-.SH EXAMPLE
-ipcluster local -n 4
-
-This command will start 4 IPython engines on the local computer.
-.SH SEE ALSO
-.BR ipython(1), ipcontroller(1), ipengine(1)
-.br
-.SH AUTHOR
-\fBipcluster\fP is a tool that ships with IPython, created by
-the IPython Development Team.
-.PP
-This manual page was written by Stephan Peijnik <debian@sp.or.at>,
-for the Debian project (but may be used by others).  Modified by Fernando Perez
-<Fernando.Perez@berkeley.edu> for inclusion in IPython.
diff --git a/docs/man/ipcontroller.1 b/docs/man/ipcontroller.1
deleted file mode 100644
index bb480815cdf..00000000000
--- a/docs/man/ipcontroller.1
+++ /dev/null
@@ -1,87 +0,0 @@
-.TH IPCONTROLLER 1 "October 29, 2008" "" ""
-.SH NAME
-\fBipcontroller \- IPython parallel computing controller control tool
-.SH SYNOPSIS
-.nf
-.fam C
-\fBipengine\fP [\fIoptions\fP]
-.fam T
-.fi
-.SH DESCRIPTION
-ipcontroller is a control tool for IPython's parallel computing functions.
-.SH OPTIONS
-.TP
-.B
-\-h, \-\-help
-show this help message and exit
-.TP
-.B
-\-\-client\-ip=CLIENT_IP
-the IP address or hostname the controller will listen on for
-client connections
-.TP
-.B
-\-\-client\-port=CLIENT_PORT
-the port the controller will listen on for client connections
-.TP
-.B
-\-\-client\-location=CLIENT_LOCATION
-hostname or ip for clients to connect to
-.TP
-.B
-\-x
-turn off all client security
-.TP
-.B
-\-\-client\-cert\-file=CLIENT_CERT_FILE
-file to store the client SSL certificate
-.TP
-.B
-\-\-task\-furl\-file=TASK_FURL_FILE
-file to store the FURL for task clients to connect with
-.TP
-.B
-\-\-multiengine\-furl\-file=MULTIENGINE_FURL_FILE
-file to store the FURL for multiengine clients to connect with
-.TP
-.B
-\-\-engine\-ip=ENGINE_IP
-the IP address or hostname the controller will listen on for engine connections
-.TP
-.B
-\-\-engine\-port=ENGINE_PORT
-the port the controller will listen on for engine connections
-.TP
-.B
-\-\-engine\-location=ENGINE_LOCATION
-the IP address or hostname for engine to connect to
-.TP
-.B
-\-y
-turn off all engine security
-.TP
-.B
-\-\-engine\-cert\-file=ENGINE_CERT_FILE
-file to store the engine SSL certificate
-.TP
-.B
-\-\-engine\-furl\-file=ENGINE_FURL_FILE
-file to store the FURL for engines to connect with
-.TP
-.B
-\-l LOGFILE, \-\-logfile=LOGFILE
-log file name (default is stdout)
-.TP
-.B
-\-r
-try to reuse all furl files
-.SH SEE ALSO
-.BR ipython(1), ipcluster(1), ipengine(1)
-.br
-.SH AUTHOR
-\fBipcontroller\fP is a tool that ships with IPython, created by
-the IPython Development Team.
-.PP
-This manual page was written by Stephan Peijnik <debian@sp.or.at>,
-for the Debian project (but may be used by others).  Modified by Fernando Perez
-<Fernando.Perez@berkeley.edu> for inclusion in IPython.
diff --git a/docs/man/ipengine.1 b/docs/man/ipengine.1
deleted file mode 100644
index e65c3688884..00000000000
--- a/docs/man/ipengine.1
+++ /dev/null
@@ -1,38 +0,0 @@
-.TH IPENGINE 1 "October 28, 2008" "" ""
-.SH NAME
-\fBipengine \- IPython parallel computing engine control tool
-.SH SYNOPSIS
-.nf
-.fam C
-\fBipengine\fP [\fIoptions\fP]
-.fam T
-.fi
-.SH DESCRIPTION
-ipengine is a control tool for IPython's parallel computing functions.
-.SH OPTIONS
-.TP
-.B
-\-h, \-\-help
-show this help message and exit
-.TP
-.B
-\-\-furl\-file=FURL_FILE
-The filename containing the FURL of the controller
-.TP
-.B
-\-\-mpi=MPI
-How to enable MPI (mpi4py, pytrilions, or empty string to disable)
-.TP
-.B
-\-l LOGFILE, \-\-logfile=LOGFILE
-log file name (defaults to stdout)
-.SH SEE ALSO
-.BR ipython(1), ipcluster(1), ipcontroller(1)
-.br
-.SH AUTHOR
-\fBipengine\fP is a tool that ships with IPython, created by
-the IPython Development Team.
-.PP
-This manual page was written by Stephan Peijnik <debian@sp.or.at>,
-for the Debian project (but may be used by others).  Modified by Fernando Perez
-<Fernando.Perez@berkeley.edu> for inclusion in IPython.
diff --git a/docs/man/ipython-wx.1 b/docs/man/ipython-wx.1
deleted file mode 100644
index 78c7f544cb5..00000000000
--- a/docs/man/ipython-wx.1
+++ /dev/null
@@ -1,25 +0,0 @@
-.TH IPYTHON-WX 1 "October 29, 2008" "" ""
-.SH NAME
-\fBipython-wx \- Graphical frontend that embeds a multithreaded IPython Shell
-.SH SYNOPSIS
-.nf
-.fam C
-\fBipython-wx\fP
-.fam T
-.fi
-.SH DESCRIPTION
-ipython-wx is, compared to ipythonx, a more advanced graphical frontend
-to IPython. It is implemented using WxWidgets. 
-.SH OPTIONS
-.TP
-.B
-ipython-wx does not accept any command line options.
-.SH SEE ALSO
-.BR ipython(1), ipythonx(1)
-.br
-.SH AUTHOR
-\fBipython-wx\fP is a tool that ships with IPython, created by
-the IPython Development Team.
-.PP
-This manual page was written by Stephan Peijnik <debian@sp.or.at>,
-for the Debian project (but may be used by others).
diff --git a/docs/man/ipython.1 b/docs/man/ipython.1
index 091041ef732..0f4a191f3fa 100644
--- a/docs/man/ipython.1
+++ b/docs/man/ipython.1
@@ -2,7 +2,7 @@
 .\" First parameter, NAME, should be all caps
 .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 .\" other parameters are allowed: see man(7), man(1)
-.TH IPYTHON 1 "November 30, 2004"
+.TH IPYTHON 1 "July 15, 2011"
 .\" Please adjust this date whenever revising the manpage.
 .\"
 .\" Some roff macros, for reference:
@@ -22,318 +22,39 @@
 .\" To preview this page as plain text: nroff -man ipython.1
 .\"
 .SH NAME
-ipython \- An Enhanced Interactive Python
+ipython \- Tools for Interactive Computing in Python.
 .SH SYNOPSIS
 .B ipython
 .RI [ options ] " files" ...
+
+.B ipython subcommand
+.RI [ options ] ...
+
 .SH DESCRIPTION
-An interactive Python shell with automatic history (input and output),
-dynamic object introspection, easier configuration, command
-completion, access to the system shell, integration with numerical and
-scientific computing tools, and more.
-.
-.SH REGULAR OPTIONS
-After the above threading options have been given, regular options can follow
-in any order.  All options can be abbreviated to their shortest non-ambiguous
-form and are case-sensitive.  One or two dashes can be used.  Some options
-have an alternate short form, indicated after a |.
-.br
-.sp 1
-Most options can also be set from your ipythonrc configuration file.
-See the provided examples for assistance.  Options given on the
-commandline override the values set in the ipythonrc file.
-.br
-.sp 1
-All options with a [no] prepended can be specified in negated form
-(\-nooption instead of \-option) to turn the feature off.
-.TP
-.B \-h, \-\-help
-Show summary of options.
-.TP
-.B \-autocall <val>
-Make IPython automatically call any callable object even if you didn't type
-explicit parentheses. For example, 'str 43' becomes
-str(43) automatically.  The value can be '0' to disable the
-feature, '1' for 'smart' autocall, where it is not applied if
-there are no more arguments on the line, and '2' for 'full'
-autocall, where all callable objects are automatically called
-(even if no arguments are present).  The default is '1'.
-.TP
-.B \-[no]autoindent
-Turn automatic indentation on/off.
-.TP
-.B \-[no]automagic
-Make magic commands automatic (without needing their first character
-to be %).  Type %magic at the IPython prompt for more information.
-.TP
-.B \-[no]autoedit_syntax
-When a syntax error occurs after editing a file, automatically open the file
-to the trouble causing line for convenient fixing.
-.TP
-.B \-[no]banner
-Print the intial information banner (default on).
-.TP
-.B \-c <command>
-Execute the given command string, and set sys.argv to ['c'].  This is similar
-to the \-c option in the normal Python interpreter.
-.TP
-.B \-cache_size|cs <n>
-Size of the output cache (maximum number of entries to hold in
-memory).  The default is 1000, you can change it permanently in your
-config file.  Setting it to 0 completely disables the caching system,
-and the minimum value accepted is 20 (if you provide a value less than
-20, it is reset to 0 and a warning is issued).  This limit is defined
-because otherwise you'll spend more time re-flushing a too small cache
-than working.
-.TP
-.B \-classic|cl
-Gives IPython a similar feel to the classic Python prompt.
-.TP
-.B \-colors <scheme>
-Color scheme for prompts and exception reporting.  Currently
-implemented: NoColor, Linux, and LightBG.
-.TP
-.B \-[no]color_info
-IPython can display information about objects via a set of functions,
-and optionally can use colors for this, syntax highlighting source
-code and various other elements.  However, because this information is
-passed through a pager (like 'less') and many pagers get confused with
-color codes, this option is off by default.  You can test it and turn
-it on permanently in your ipythonrc file if it works for you.  As a
-reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
-that in RedHat 7.2 doesn't.
-.br
-.sp 1
-Test it and turn it on permanently if it works with your system.  The
-magic function @color_info allows you to toggle this interactively for
-testing.
-.TP
-.B \-[no]confirm_exit
-Set to confirm when you try to exit IPython with an EOF (Control-D in
-Unix, Control-Z/Enter in Windows). Note that using the magic functions
-@Exit or @Quit you can force a direct exit, bypassing any
-confirmation.
-.TP
-.B \-[no]debug
-Show information about the loading process. Very useful to pin down
-problems with your configuration files or to get details about session
-restores.
-.TP
-.B \-[no]deep_reload
-IPython can use the deep_reload module which reloads changes in
-modules recursively (it replaces the reload() function, so you don't
-need to change anything to use it). deep_reload() forces a full reload
-of modules whose code may have changed, which the default reload()
-function does not.
-.br
-.sp 1
-When deep_reload is off, IPython will use the normal reload(), but
-deep_reload will still be available as dreload(). This feature is off
-by default [which means that you have both normal reload() and
-dreload()].
-.TP
-.B \-editor <name>
-Which editor to use with the @edit command. By default, IPython will
-honor your EDITOR environment variable (if not set, vi is the Unix
-default and notepad the Windows one). Since this editor is invoked on
-the fly by IPython and is meant for editing small code snippets, you
-may want to use a small, lightweight editor here (in case your default
-EDITOR is something like Emacs).
-.TP
-.B \-ipythondir <name>
-The name of your IPython configuration directory IPYTHON_DIR.  This can
-also be specified through the environment variable IPYTHON_DIR.
-.TP
-.B \-log|l
-Generate a log file of all input. The file is named ipython_log.py in your
-current directory (which prevents logs from multiple IPython sessions from
-trampling each other). You can use this to later restore a session by loading
-your logfile as a file to be executed with option -logplay (see below).
-.TP
-.B \-logfile|lf
-Specify the name of your logfile.
-.TP
-.B \-logplay|lp
-Replay a previous log. For restoring a session as close as possible to
-the state you left it in, use this option (don't just run the
-logfile). With \-logplay, IPython will try to reconstruct the previous
-working environment in full, not just execute the commands in the
-logfile.
-.br
-.sp 1
-When a session is restored, logging is automatically turned on again
-with the name of the logfile it was invoked with (it is read from the
-log header). So once you've turned logging on for a session, you can
-quit IPython and reload it as many times as you want and it will
-continue to log its history and restore from the beginning every time.
-.br
-.sp 1
-Caveats: there are limitations in this option. The history variables
-_i*,_* and _dh don't get restored properly. In the future we will try
-to implement full session saving by writing and retrieving a
-snapshot of the memory state of IPython. But our first attempts
-failed because of inherent limitations of Python's Pickle module, so
-this may have to wait.
-.TP
-.B \-[no]messages
-Print messages which IPython collects about its startup process
-(default on).
-.TP
-.B \-[no]pdb
-Automatically call the pdb debugger after every uncaught exception. If
-you are used to debugging using pdb, this puts you automatically
-inside of it after any call (either in IPython or in code called by
-it) which triggers an exception which goes uncaught.
-.TP
-.B \-pydb
-Makes IPython use the third party "pydb" package as debugger,
-instead of pdb. Requires that pydb is installed.
-.TP
-.B \-[no]pprint
-IPython can optionally use the pprint (pretty printer) module for
-displaying results. pprint tends to give a nicer display of nested
-data structures. If you like it, you can turn it on permanently in
-your config file (default off).
-.TP
-.B \-profile|p <name>
-Assume that your config file is ipythonrc-<name> (looks in current dir
-first, then in IPYTHON_DIR). This is a quick way to keep and load
-multiple config files for different tasks, especially if you use the
-include option of config files. You can keep a basic
-IPYTHON_DIR/ipythonrc file and then have other 'profiles' which include
-this one and load extra things for particular tasks. For example:
-.br
-.sp 1
-1) $HOME/.ipython/ipythonrc : load basic things you always want.
-.br
-2) $HOME/.ipython/ipythonrc-math : load (1) and basic math-related
-modules.
-.br
-3) $HOME/.ipython/ipythonrc-numeric : load (1) and Numeric and
-plotting modules.
-.br
-.sp 1
-Since it is possible to create an endless loop by having circular file
-inclusions, IPython will stop if it reaches 15 recursive inclusions.
-.TP
-.B \-prompt_in1|pi1 <string>
-Specify the string used for input prompts. Note that if you are using
-numbered prompts, the number is represented with a '\\#' in the
-string. Don't forget to quote strings with spaces embedded in
-them. Default: 'In [\\#]: '.
-.br
-.sp 1
-Most bash-like escapes can be used to customize IPython's prompts, as well as
-a few additional ones which are IPython-specific.  All valid prompt escapes
-are described in detail in the Customization section of the IPython HTML/PDF
-manual.
-.TP
-.B \-prompt_in2|pi2 <string>
-Similar to the previous option, but used for the continuation prompts. The
-special sequence '\\D' is similar to '\\#', but with all digits replaced dots
-(so you can have your continuation prompt aligned with your input
-prompt). Default: '   .\\D.: ' (note three spaces at the start for alignment
-with 'In [\\#]').
-.TP
-.B \-prompt_out|po <string>
-String used for output prompts, also uses numbers like prompt_in1.
-Default: 'Out[\\#]:'.
-.TP
-.B \-quick
-Start in bare bones mode (no config file loaded).
-.TP
-.B \-rcfile <name>
-Name of your IPython resource configuration file.  normally IPython
-loads ipythonrc (from current directory) or IPYTHON_DIR/ipythonrc.  If
-the loading of your config file fails, IPython starts with a bare
-bones configuration (no modules loaded at all).
-.TP
-.B \-[no]readline
-Use the readline library, which is needed to support name completion
-and command history, among other things. It is enabled by default, but
-may cause problems for users of X/Emacs in Python comint or shell
-buffers.
-.br
-.sp 1
-Note that emacs 'eterm' buffers (opened with M-x term) support
-IPython's readline and syntax coloring fine, only 'emacs' (M-x shell
-and C-c !)  buffers do not.
-.TP
-.B \-screen_length|sl <n>
-Number of lines of your screen.  This is used to control printing of
-very long strings.  Strings longer than this number of lines will be
-sent through a pager instead of directly printed.
-.br
-.sp 1
-The default value for this is 0, which means IPython will auto-detect
-your screen size every time it needs to print certain potentially long
-strings (this doesn't change the behavior of the 'print' keyword, it's
-only triggered internally). If for some reason this isn't working well
-(it needs curses support), specify it yourself. Otherwise don't change
-the default.
-.TP
-.B \-separate_in|si <string>
-Separator before input prompts.  Default '\n'.
-.TP
-.B \-separate_out|so <string>
-Separator before output prompts.  Default: 0 (nothing).
-.TP
-.B \-separate_out2|so2 <string>
-Separator after output prompts.  Default: 0 (nothing).
-.TP
-.B \-nosep
-Shorthand for '\-separate_in 0 \-separate_out 0 \-separate_out2 0'.
-Simply removes all input/output separators.
-.TP
-.B \-upgrade
-Allows you to upgrade your IPYTHON_DIR configuration when you install a
-new version of IPython.  Since new versions may include new command
-lines options or example files, this copies updated ipythonrc-type
-files.  However, it backs up (with a .old extension) all files which
-it overwrites so that you can merge back any custimizations you might
-have in your personal files.
-.TP
-.B \-Version
-Print version information and exit.
-.TP
-.B -wxversion <string>
-Select a specific version of wxPython (used in conjunction with
-\-wthread). Requires the wxversion module, part of recent wxPython
-distributions.
-.TP
-.B \-xmode <modename>
-Mode for exception reporting.  The valid modes are Plain, Context, and
-Verbose.
-.br
-.sp 1
-\- Plain: similar to python's normal traceback printing.
-.br
-.sp 1
-\- Context: prints 5 lines of context source code around each line in the
-traceback.
-.br
-.sp 1
-\- Verbose: similar to Context, but additionally prints the variables
-currently visible where the exception happened (shortening their strings if
-too long).  This can potentially be very slow, if you happen to have a huge
-data structure whose string representation is complex to compute.  Your
-computer may appear to freeze for a while with cpu usage at 100%.  If this
-occurs, you can cancel the traceback with Ctrl-C (maybe hitting it more than
-once).
-.
-.SH EMBEDDING
-It is possible to start an IPython instance inside your own Python
-programs.  In the documentation example files there are some
-illustrations on how to do this.
-.br
-.sp 1
-This feature allows you to evalutate dynamically the state of your
-code, operate with your variables, analyze them, etc.  Note however
-that any changes you make to values while in the shell do NOT
-propagate back to the running code, so it is safe to modify your
-values because you won't break your code in bizarre ways by doing so.
-.SH AUTHOR
-IPython was written by Fernando Perez <fperez@colorado.edu>, based on earlier
-code by Janko Hauser <jh@comunit.de> and Nathaniel Gray
-<n8gray@caltech.edu>.  This manual page was written by Jack Moffitt
-<jack@xiph.org>, for the Debian project (but may be used by others).
+An interactive Python shell with automatic history (input and output), dynamic
+object introspection, easier configuration, command completion, access to the
+system shell, integration with numerical and scientific computing tools,
+web notebook, Qt console, and more.
+
+For more information on how to use IPython, see 'ipython \-\-help',
+or 'ipython \-\-help\-all' for all available command\(hyline options.
+
+.SH "ENVIRONMENT VARIABLES"
+.sp
+.PP
+\fIIPYTHONDIR\fR
+.RS 4
+This is the location where IPython stores all its configuration files.  The default
+is $HOME/.ipython if IPYTHONDIR is not defined.
+
+You can see the computed value of IPYTHONDIR with `ipython locate`.
+
+.SH FILES
+
+IPython uses various configuration files stored in profiles within IPYTHONDIR.
+To generate the default configuration files and start configuring IPython,
+do 'ipython profile create', and edit '*_config.py' files located in
+IPYTHONDIR/profile_default.
+
+.SH AUTHORS
+IPython is written by the IPython Development Team <https://github.com/ipython/ipython>.
diff --git a/docs/man/ipythonx.1 b/docs/man/ipythonx.1
deleted file mode 100644
index 979da98db8a..00000000000
--- a/docs/man/ipythonx.1
+++ /dev/null
@@ -1,30 +0,0 @@
-.TH IPYTHONX 1 "October 29, 2008" "" ""
-.SH NAME
-\fBipythonx \- Simple graphical frontend to IPython, using WxWidgets.
-.SH SYNOPSIS
-.nf
-.fam C
-\fBipengine\fP [\fIoptions\fP]
-.fam T
-.fi
-.SH DESCRIPTION
-ipythonx is a simple graphical frontend to IPython, using WxWidgets.
-.SH OPTIONS
-.TP
-.B
-\-h, \-\-help
-show this help message and exit
-.TP
-.B
-\-d, \-\-debug
-Enable debug messages for the wx frontend.
-look for config files and profiles in this directory
-.SH SEE ALSO
-.BR ipython(1), ipython-wx(1)
-.br
-.SH AUTHOR
-\fBipythonx\fP is a tool that ships with IPython, created by
-the IPython Development Team.
-.PP
-This manual page was written by Stephan Peijnik <debian@sp.or.at>,
-for the Debian project (but may be used by others).
diff --git a/docs/man/irunner.1 b/docs/man/irunner.1
deleted file mode 100644
index 14edf623a92..00000000000
--- a/docs/man/irunner.1
+++ /dev/null
@@ -1,49 +0,0 @@
-.TH IRUNNER 1 "April 24, 2007" "" ""
-.SH NAME
-\fBirunner \- interactive runner interface
-.SH SYNOPSIS
-.nf
-.fam C
-\fBirunner\fP [\fIoptions\fP] \fIfile_to_run\fP
-.fam T
-.fi
-.SH DESCRIPTION
-irunner is an interface to the various interactive runners
-available in IPython's \fBirunner\fP module. 
-.PP
-The already implemented runners are listed below; adding
-one for a new program is a trivial task, see the source
-for examples.
-.SH OPTIONS
-.TP
-.B
-\-h, \-\-help
-show this help message and exit
-.TP
-.B
-\-\-ipython
-IPython interactive runner (default).
-.TP
-.B
-\-\-python
-Python interactive runner.
-.TP
-.B
-\-\-sage
-SAGE interactive runner.
-.SH EXAMPLE
-irunner.py \-\-python \-\- \-\-help
-will pass \-\-help to the python runner.
-Similarly,
-irunner.py \-\-ipython \-\- \-\-interact script.ipy
-.SH SEE ALSO
-.BR ipython(1)
-.br
-.SH AUTHOR
-\fBirunner\fP is an extension of Ken Schutte <kschutte-AT-csail.mit.edu>'s
-script contributed on the ipython-user list:
-http://scipy.net/pipermail/ipython-user/2006-May/001705.html
-.PP
-This manual page was written by Bernd Zeimetz <bernd@bzed.de>, for the Debian
-project (but may be used by others).  Modified by Fernando Perez
-<Fernando.Perez@berkeley.edu> for inclusion in IPython.
diff --git a/docs/man/pycolor.1 b/docs/man/pycolor.1
deleted file mode 100644
index a1d4b0bf0d3..00000000000
--- a/docs/man/pycolor.1
+++ /dev/null
@@ -1,38 +0,0 @@
-.\"                                      Hey, EMACS: -*- nroff -*-
-.\" First parameter, NAME, should be all caps
-.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
-.\" other parameters are allowed: see man(7), man(1)
-.TH PYCOLOR 1 "May 12, 2007"
-.\" Please adjust this date whenever revising the manpage.
-.\"
-.\" Some roff macros, for reference:
-.\" .nh        disable hyphenation
-.\" .hy        enable hyphenation
-.\" .ad l      left justify
-.\" .ad b      justify to both left and right margins
-.\" .nf        disable filling
-.\" .fi        enable filling
-.\" .br        insert line break
-.\" .sp <n>    insert n+1 empty lines
-.\" for manpage-specific macros, see man(7)
-.SH NAME
-pycolor \- Colorize a python file or stdin using ANSI and print to stdout.
-.SH SYNOPSIS
-.B pycolor
-.RI [ options ]
-.RI [ file ]
-.SH DESCRIPTION
-Prints a colorized version of the input file (or standard input if no file is
-given, or the file name - is given) to standard out.
-.SH OPTIONS
-.TP
-.B \-h, \-\-help
-Output a brief help message.
-.TP
-.B \-s, \-\-scheme <scheme>
-Give the color scheme to use.  Currently only Linux (default),
-LightBG, and NOColor are implemented.
-.SH AUTHOR
-pycolor was written by Fernando Perez <fperez@colorado.edu>.
-This manual page was written by Jack Moffitt <jack@xiph.org>,
-for the Debian project (but may be used by others).
diff --git a/docs/pycon.ico b/docs/pycon.ico
deleted file mode 100644
index 55ee14afa61..00000000000
Binary files a/docs/pycon.ico and /dev/null differ
diff --git a/docs/requirements.txt b/docs/requirements.txt
new file mode 100644
index 00000000000..9ffcdb18fed
--- /dev/null
+++ b/docs/requirements.txt
@@ -0,0 +1,12 @@
+-e .[doc]
+sphinx>7
+setuptools
+sphinx_rtd_theme>=1.2.0
+numpy
+exceptiongroup
+testpath
+matplotlib
+docrepr
+prompt_toolkit
+ipykernel
+intersphinx_registry
diff --git a/docs/source/_images/2.0/running-crop.png b/docs/source/_images/2.0/running-crop.png
new file mode 100644
index 00000000000..3180e25f2d2
Binary files /dev/null and b/docs/source/_images/2.0/running-crop.png differ
diff --git a/docs/source/_images/2.0/running.png b/docs/source/_images/2.0/running.png
new file mode 100644
index 00000000000..70f96ad3894
Binary files /dev/null and b/docs/source/_images/2.0/running.png differ
diff --git a/docs/source/_images/2.0/treeview.png b/docs/source/_images/2.0/treeview.png
new file mode 100644
index 00000000000..36655c465ba
Binary files /dev/null and b/docs/source/_images/2.0/treeview.png differ
diff --git a/docs/source/_images/2.0/user-interface.png b/docs/source/_images/2.0/user-interface.png
new file mode 100644
index 00000000000..f7c0d3839c2
Binary files /dev/null and b/docs/source/_images/2.0/user-interface.png differ
diff --git a/docs/source/_images/2.0/widgets.png b/docs/source/_images/2.0/widgets.png
new file mode 100644
index 00000000000..91ff6279fd2
Binary files /dev/null and b/docs/source/_images/2.0/widgets.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_1_prompt_no_text.png b/docs/source/_images/8.0/auto_suggest_1_prompt_no_text.png
new file mode 100644
index 00000000000..7e83b2426db
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_1_prompt_no_text.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_2_print_hello_suggest.png b/docs/source/_images/8.0/auto_suggest_2_print_hello_suggest.png
new file mode 100644
index 00000000000..cd84e0a22be
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_2_print_hello_suggest.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_3_print_hello_suggest.png b/docs/source/_images/8.0/auto_suggest_3_print_hello_suggest.png
new file mode 100644
index 00000000000..27e14ce571c
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_3_print_hello_suggest.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_4_print_hello.png b/docs/source/_images/8.0/auto_suggest_4_print_hello.png
new file mode 100644
index 00000000000..d3672127920
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_4_print_hello.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_d_completions.png b/docs/source/_images/8.0/auto_suggest_d_completions.png
new file mode 100644
index 00000000000..332111bd0d8
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_d_completions.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_d_phantom.png b/docs/source/_images/8.0/auto_suggest_d_phantom.png
new file mode 100644
index 00000000000..14aa013cbc3
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_d_phantom.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_def_completions.png b/docs/source/_images/8.0/auto_suggest_def_completions.png
new file mode 100644
index 00000000000..a37218dc4da
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_def_completions.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_def_phantom.png b/docs/source/_images/8.0/auto_suggest_def_phantom.png
new file mode 100644
index 00000000000..d63f220e1f7
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_def_phantom.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_match_parens.png b/docs/source/_images/8.0/auto_suggest_match_parens.png
new file mode 100644
index 00000000000..22259a428a9
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_match_parens.png differ
diff --git a/docs/source/_images/8.0/auto_suggest_second_prompt.png b/docs/source/_images/8.0/auto_suggest_second_prompt.png
new file mode 100644
index 00000000000..b3cd2490884
Binary files /dev/null and b/docs/source/_images/8.0/auto_suggest_second_prompt.png differ
diff --git a/docs/source/_images/8.0/pathlib_pathlib_everywhere.jpg b/docs/source/_images/8.0/pathlib_pathlib_everywhere.jpg
new file mode 100644
index 00000000000..941cca0d08b
Binary files /dev/null and b/docs/source/_images/8.0/pathlib_pathlib_everywhere.jpg differ
diff --git a/docs/source/_images/autosuggest.gif b/docs/source/_images/autosuggest.gif
new file mode 100644
index 00000000000..ee105489432
Binary files /dev/null and b/docs/source/_images/autosuggest.gif differ
diff --git a/docs/source/_images/ipy_013_dashboard.png b/docs/source/_images/ipy_013_dashboard.png
new file mode 100644
index 00000000000..be6b08bd886
Binary files /dev/null and b/docs/source/_images/ipy_013_dashboard.png differ
diff --git a/docs/source/_images/ipy_013_dashboard_cluster.png b/docs/source/_images/ipy_013_dashboard_cluster.png
new file mode 100644
index 00000000000..de9a5a18753
Binary files /dev/null and b/docs/source/_images/ipy_013_dashboard_cluster.png differ
diff --git a/docs/source/_images/ipy_013_notebook_cythonmagic.png b/docs/source/_images/ipy_013_notebook_cythonmagic.png
new file mode 100644
index 00000000000..699d019c815
Binary files /dev/null and b/docs/source/_images/ipy_013_notebook_cythonmagic.png differ
diff --git a/docs/source/_images/ipy_013_notebook_long_out.png b/docs/source/_images/ipy_013_notebook_long_out.png
new file mode 100644
index 00000000000..ebe73684f58
Binary files /dev/null and b/docs/source/_images/ipy_013_notebook_long_out.png differ
diff --git a/docs/source/_images/ipy_013_notebook_octavemagic.png b/docs/source/_images/ipy_013_notebook_octavemagic.png
new file mode 100644
index 00000000000..1751adf8456
Binary files /dev/null and b/docs/source/_images/ipy_013_notebook_octavemagic.png differ
diff --git a/docs/source/_images/ipy_013_notebook_rmagic.png b/docs/source/_images/ipy_013_notebook_rmagic.png
new file mode 100644
index 00000000000..d7205e956d4
Binary files /dev/null and b/docs/source/_images/ipy_013_notebook_rmagic.png differ
diff --git a/docs/source/_images/ipy_013_notebook_script_cells.png b/docs/source/_images/ipy_013_notebook_script_cells.png
new file mode 100644
index 00000000000..ba89a651ede
Binary files /dev/null and b/docs/source/_images/ipy_013_notebook_script_cells.png differ
diff --git a/docs/source/_images/ipy_013_notebook_spectrogram.png b/docs/source/_images/ipy_013_notebook_spectrogram.png
new file mode 100644
index 00000000000..0d8ac7f973d
Binary files /dev/null and b/docs/source/_images/ipy_013_notebook_spectrogram.png differ
diff --git a/docs/source/_images/ipy_013_notebook_tooltip.png b/docs/source/_images/ipy_013_notebook_tooltip.png
new file mode 100644
index 00000000000..1860c63840d
Binary files /dev/null and b/docs/source/_images/ipy_013_notebook_tooltip.png differ
diff --git a/docs/source/_images/ipy_013_par_tb.png b/docs/source/_images/ipy_013_par_tb.png
new file mode 100644
index 00000000000..1b29437c820
Binary files /dev/null and b/docs/source/_images/ipy_013_par_tb.png differ
diff --git a/docs/source/_images/ipy_013_qtconsole_baboon.png b/docs/source/_images/ipy_013_qtconsole_baboon.png
new file mode 100644
index 00000000000..67345b7e7d6
Binary files /dev/null and b/docs/source/_images/ipy_013_qtconsole_baboon.png differ
diff --git a/docs/source/_images/ipy_013_qtconsole_completer.png b/docs/source/_images/ipy_013_qtconsole_completer.png
new file mode 100644
index 00000000000..96909e0fb6e
Binary files /dev/null and b/docs/source/_images/ipy_013_qtconsole_completer.png differ
diff --git a/docs/source/_images/ipython-6-screenshot.png b/docs/source/_images/ipython-6-screenshot.png
new file mode 100644
index 00000000000..0cced67a22d
Binary files /dev/null and b/docs/source/_images/ipython-6-screenshot.png differ
diff --git a/docs/source/_images/jedi_type_inference_60.png b/docs/source/_images/jedi_type_inference_60.png
new file mode 100644
index 00000000000..9eb1ba04487
Binary files /dev/null and b/docs/source/_images/jedi_type_inference_60.png differ
diff --git a/docs/source/_images/kernel_selector_screenshot.png b/docs/source/_images/kernel_selector_screenshot.png
new file mode 100644
index 00000000000..6668776e7e3
Binary files /dev/null and b/docs/source/_images/kernel_selector_screenshot.png differ
diff --git a/docs/source/_images/ms_visual_studio.png b/docs/source/_images/ms_visual_studio.png
new file mode 100644
index 00000000000..7367c959ad5
Binary files /dev/null and b/docs/source/_images/ms_visual_studio.png differ
diff --git a/docs/source/_images/notebook_specgram.png b/docs/source/_images/notebook_specgram.png
new file mode 100644
index 00000000000..0a992a4d170
Binary files /dev/null and b/docs/source/_images/notebook_specgram.png differ
diff --git a/docs/source/_images/ptshell_features.png b/docs/source/_images/ptshell_features.png
new file mode 100644
index 00000000000..79d4b002576
Binary files /dev/null and b/docs/source/_images/ptshell_features.png differ
diff --git a/docs/source/_images/qtconsole.png b/docs/source/_images/qtconsole.png
new file mode 100644
index 00000000000..c6e352503a9
Binary files /dev/null and b/docs/source/_images/qtconsole.png differ
diff --git a/docs/source/_images/qtconsole_tabbed.png b/docs/source/_images/qtconsole_tabbed.png
new file mode 100644
index 00000000000..96ca94e775d
Binary files /dev/null and b/docs/source/_images/qtconsole_tabbed.png differ
diff --git a/docs/source/_images/unicode_completion.png b/docs/source/_images/unicode_completion.png
new file mode 100644
index 00000000000..3c046a498de
Binary files /dev/null and b/docs/source/_images/unicode_completion.png differ
diff --git a/docs/source/_static/default.css b/docs/source/_static/default.css
deleted file mode 100644
index ea605da1c06..00000000000
--- a/docs/source/_static/default.css
+++ /dev/null
@@ -1,510 +0,0 @@
-/**
- * Alternate Sphinx design
- * Originally created by Armin Ronacher for Werkzeug, adapted by Georg Brandl.
- */
-
-body {
-    font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva', 'Verdana', sans-serif;
-    font-size: 14px;
-    letter-spacing: -0.01em;
-    line-height: 150%;
-    text-align: center;
-    /*background-color: #AFC1C4; */
-    background-color: #BFD1D4;
-    color: black;
-    padding: 0;
-    border: 1px solid #aaa;
-
-    margin: 0px 80px 0px 80px;
-    min-width: 740px;
-}
-
-a {
-    color: #CA7900;
-    text-decoration: none;
-}
-
-a:hover {
-    color: #2491CF;
-}
-
-pre {
-    font-family: 'Consolas', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-    font-size: 0.95em;
-    letter-spacing: 0.015em;
-    padding: 0.5em;
-    border: 1px solid #ccc;
-    background-color: #f8f8f8;
-}
-
-td.linenos pre {
-    padding: 0.5em 0;
-    border: 0;
-    background-color: transparent;
-    color: #aaa;
-}
-
-table.highlighttable {
-    margin-left: 0.5em;
-}
-
-table.highlighttable td {
-    padding: 0 0.5em 0 0.5em;
-}
-
-cite, code, tt {
-    font-family: 'Consolas', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-    font-size: 0.95em;
-    letter-spacing: 0.01em;
-}
-
-hr {
-    border: 1px solid #abc;
-    margin: 2em;
-}
-
-tt {
-    background-color: #f2f2f2;
-    border-bottom: 1px solid #ddd;
-    color: #333;
-}
-
-tt.descname {
-    background-color: transparent;
-    font-weight: bold;
-    font-size: 1.2em;
-    border: 0;
-}
-
-tt.descclassname {
-    background-color: transparent;
-    border: 0;
-}
-
-tt.xref {
-    background-color: transparent;
-    font-weight: bold;
-    border: 0;
-}
-
-a tt {
-    background-color: transparent;
-    font-weight: bold;
-    border: 0;
-    color: #CA7900;
-}
-
-a tt:hover {
-    color: #2491CF;
-}
-
-dl {
-    margin-bottom: 15px;
-}
-
-dd p {
-    margin-top: 0px;
-}
-
-dd ul, dd table {
-    margin-bottom: 10px;
-}
-
-dd {
-    margin-top: 3px;
-    margin-bottom: 10px;
-    margin-left: 30px;
-}
-
-.refcount {
-    color: #060;
-}
-
-dt:target,
-.highlight {
-    background-color: #fbe54e;
-}
-
-dl.class, dl.function {
-    border-top: 2px solid #888;
-}
-
-dl.method, dl.attribute {
-    border-top: 1px solid #aaa;
-}
-
-dl.glossary dt {
-    font-weight: bold;
-    font-size: 1.1em;
-}
-
-pre {
-    line-height: 120%;
-}
-
-pre a {
-    color: inherit;
-    text-decoration: underline;
-}
-
-.first {
-    margin-top: 0 !important;
-}
-
-div.document {
-    background-color: white;
-    text-align: left;
-    background-image: url(contents.png);
-    background-repeat: repeat-x;
-}
-
-/*
-div.documentwrapper {
-    width: 100%;
-}
-*/
-
-div.clearer {
-    clear: both;
-}
-
-div.related h3 {
-    display: none;
-}
-
-div.related ul {
-    background-image: url(navigation.png);
-    height: 2em;
-    list-style: none;
-    border-top: 1px solid #ddd;
-    border-bottom: 1px solid #ddd;
-    margin: 0;
-    padding-left: 10px;
-}
-
-div.related ul li {
-    margin: 0;
-    padding: 0;
-    height: 2em;
-    float: left;
-}
-
-div.related ul li.right {
-    float: right;
-    margin-right: 5px;
-}
-
-div.related ul li a {
-    margin: 0;
-    padding: 0 5px 0 5px;
-    line-height: 1.75em;
-    color: #EE9816;
-}
-
-div.related ul li a:hover {
-    color: #3CA8E7;
-}
-
-div.body {
-    margin: 0;
-    padding: 0.5em 20px 20px 20px;
-}
-
-div.bodywrapper {
-    margin: 0 240px 0 0;
-    border-right: 1px solid #ccc;
-}
-
-div.body a {
-    text-decoration: underline;
-}
-
-div.sphinxsidebar {
-    margin: 0;
-    padding: 0.5em 15px 15px 0;
-    width: 210px;
-    float: right;
-    text-align: left;
-/*    margin-left: -100%; */
-}
-
-div.sphinxsidebar h4, div.sphinxsidebar h3 {
-    margin: 1em 0 0.5em 0;
-    font-size: 0.9em;
-    padding: 0.1em 0 0.1em 0.5em;
-    color: white;
-    border: 1px solid #86989B;
-    background-color: #AFC1C4;
-}
-
-div.sphinxsidebar ul {
-    padding-left: 1.5em;
-    margin-top: 7px;
-    list-style: none;
-    padding: 0;
-    line-height: 130%;
-}
-
-div.sphinxsidebar ul ul {
-    list-style: square;
-    margin-left: 20px;
-}
-
-p {
-    margin: 0.8em 0 0.5em 0;
-}
-
-p.rubric {
-    font-weight: bold;
-}
-
-h1 {
-    margin: 0;
-    padding: 0.7em 0 0.3em 0;
-    font-size: 1.5em;
-    color: #11557C;
-}
-
-h2 {
-    margin: 1.3em 0 0.2em 0;
-    font-size: 1.35em;
-    padding: 0;
-}
-
-h3 {
-    margin: 1em 0 -0.3em 0;
-    font-size: 1.2em;
-}
-
-h1 a, h2 a, h3 a, h4 a, h5 a, h6 a {
-    color: black!important;
-}
-
-h1 a.anchor, h2 a.anchor, h3 a.anchor, h4 a.anchor, h5 a.anchor, h6 a.anchor {
-    display: none;
-    margin: 0 0 0 0.3em;
-    padding: 0 0.2em 0 0.2em;
-    color: #aaa!important;
-}
-
-h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor,
-h5:hover a.anchor, h6:hover a.anchor {
-    display: inline;
-}
-
-h1 a.anchor:hover, h2 a.anchor:hover, h3 a.anchor:hover, h4 a.anchor:hover,
-h5 a.anchor:hover, h6 a.anchor:hover {
-    color: #777;
-    background-color: #eee;
-}
-
-table {
-    border-collapse: collapse;
-    margin: 0 -0.5em 0 -0.5em;
-}
-
-table td, table th {
-    padding: 0.2em 0.5em 0.2em 0.5em;
-}
-
-div.footer {
-    background-color: #E3EFF1;
-    color: #86989B;
-    padding: 3px 8px 3px 0;
-    clear: both;
-    font-size: 0.8em;
-    text-align: right;
-}
-
-div.footer a {
-    color: #86989B;
-    text-decoration: underline;
-}
-
-div.pagination {
-    margin-top: 2em;
-    padding-top: 0.5em;
-    border-top: 1px solid black;
-    text-align: center;
-}
-
-div.sphinxsidebar ul.toc {
-    margin: 1em 0 1em 0;
-    padding: 0 0 0 0.5em;
-    list-style: none;
-}
-
-div.sphinxsidebar ul.toc li {
-    margin: 0.5em 0 0.5em 0;
-    font-size: 0.9em;
-    line-height: 130%;
-}
-
-div.sphinxsidebar ul.toc li p {
-    margin: 0;
-    padding: 0;
-}
-
-div.sphinxsidebar ul.toc ul {
-    margin: 0.2em 0 0.2em 0;
-    padding: 0 0 0 1.8em;
-}
-
-div.sphinxsidebar ul.toc ul li {
-    padding: 0;
-}
-
-div.admonition, div.warning {
-    font-size: 0.9em;
-    margin: 1em 0 0 0;
-    border: 1px solid #86989B;
-    background-color: #f7f7f7;
-}
-
-div.admonition p, div.warning p {
-    margin: 0.5em 1em 0.5em 1em;
-    padding: 0;
-}
-
-div.admonition pre, div.warning pre {
-    margin: 0.4em 1em 0.4em 1em;
-}
-
-div.admonition p.admonition-title,
-div.warning p.admonition-title {
-    margin: 0;
-    padding: 0.1em 0 0.1em 0.5em;
-    color: white;
-    border-bottom: 1px solid #86989B;
-    font-weight: bold;
-    background-color: #AFC1C4;
-}
-
-div.warning {
-    border: 1px solid #940000;
-}
-
-div.warning p.admonition-title {
-    background-color: #CF0000;
-    border-bottom-color: #940000;
-}
-
-div.admonition ul, div.admonition ol,
-div.warning ul, div.warning ol {
-    margin: 0.1em 0.5em 0.5em 3em;
-    padding: 0;
-}
-
-div.versioninfo {
-    margin: 1em 0 0 0;
-    border: 1px solid #ccc;
-    background-color: #DDEAF0;
-    padding: 8px;
-    line-height: 1.3em;
-    font-size: 0.9em;
-}
-
-
-a.headerlink {
-    color: #c60f0f!important;
-    font-size: 1em;
-    margin-left: 6px;
-    padding: 0 4px 0 4px;
-    text-decoration: none!important;
-    visibility: hidden;
-}
-
-h1:hover > a.headerlink,
-h2:hover > a.headerlink,
-h3:hover > a.headerlink,
-h4:hover > a.headerlink,
-h5:hover > a.headerlink,
-h6:hover > a.headerlink,
-dt:hover > a.headerlink {
-    visibility: visible;
-}
-
-a.headerlink:hover {
-    background-color: #ccc;
-    color: white!important;
-}
-
-table.indextable td {
-    text-align: left;
-    vertical-align: top;
-}
-
-table.indextable dl, table.indextable dd {
-    margin-top: 0;
-    margin-bottom: 0;
-}
-
-table.indextable tr.pcap {
-    height: 10px;
-}
-
-table.indextable tr.cap {
-    margin-top: 10px;
-    background-color: #f2f2f2;
-}
-
-img.toggler {
-    margin-right: 3px;
-    margin-top: 3px;
-    cursor: pointer;
-}
-
-img.inheritance {
-    border: 0px
-}
-
-form.pfform {
-    margin: 10px 0 20px 0;
-}
-
-table.contentstable {
-    width: 90%;
-}
-
-table.contentstable p.biglink {
-    line-height: 150%;
-}
-
-a.biglink {
-    font-size: 1.3em;
-}
-
-span.linkdescr {
-    font-style: italic;
-    padding-top: 5px;
-    font-size: 90%;
-}
-
-ul.search {
-    margin: 10px 0 0 20px;
-    padding: 0;
-}
-
-ul.search li {
-    padding: 5px 0 5px 20px;
-    background-image: url(file.png);
-    background-repeat: no-repeat;
-    background-position: 0 7px;
-}
-
-ul.search li a {
-    font-weight: bold;
-}
-
-ul.search li div.context {
-    color: #888;
-    margin: 2px 0 0 30px;
-    text-align: left;
-}
-
-ul.keywordmatches li.goodmatch a {
-    font-weight: bold;
-}
-div.figure {
-    text-align: center;
-}
diff --git a/docs/source/_static/favicon.ico b/docs/source/_static/favicon.ico
new file mode 100644
index 00000000000..4e323758171
Binary files /dev/null and b/docs/source/_static/favicon.ico differ
diff --git a/docs/source/_static/logo.png b/docs/source/_static/logo.png
index 10fbc0dbe5d..e9bdce39415 100644
Binary files a/docs/source/_static/logo.png and b/docs/source/_static/logo.png differ
diff --git a/docs/source/_static/theme_overrides.css b/docs/source/_static/theme_overrides.css
new file mode 100644
index 00000000000..156db8c24b0
--- /dev/null
+++ b/docs/source/_static/theme_overrides.css
@@ -0,0 +1,7 @@
+/*
+ Needed to revert problematic lack of wrapping in sphinx_rtd_theme, see:
+ https://github.com/readthedocs/sphinx_rtd_theme/issues/117
+*/
+.wy-table-responsive table.shortcuts td, .wy-table-responsive table.shortcuts th {
+  white-space: normal!important;
+}
diff --git a/docs/source/_templates/breadcrumbs.html b/docs/source/_templates/breadcrumbs.html
new file mode 100644
index 00000000000..804ad69e671
--- /dev/null
+++ b/docs/source/_templates/breadcrumbs.html
@@ -0,0 +1,7 @@
+{%- extends "sphinx_rtd_theme/breadcrumbs.html" %}
+
+{% block breadcrumbs_aside %}
+{% if not meta or meta.get('github_url') != 'hide' %}
+{{ super() }}
+{% endif %}
+{% endblock %}
diff --git a/docs/source/_templates/layout.html b/docs/source/_templates/layout.html
deleted file mode 100644
index 0667e7e8930..00000000000
--- a/docs/source/_templates/layout.html
+++ /dev/null
@@ -1,23 +0,0 @@
-{% extends "!layout.html" %}
-
-
-{% block rootrellink %}
-        <li><a href="{{ pathto('index') }}">home</a>|&nbsp;</li>
-        <li><a href="{{ pathto('search') }}">search</a>|&nbsp;</li>
-       <li><a href="{{ pathto('index') }}">documentation </a> &raquo;</li>
-{% endblock %}
-
-
-{% block relbar1 %}
-
-<div style="background-color: white; text-align: left; padding: 10px 10px 15px 15px">
-<a href="{{ pathto('index') }}"><img src="{{
-pathto("_static/logo.png", 1) }}" border="0" alt="IPython Documentation"/></a>
-</div>
-{{ super() }}
-{% endblock %}
-
-{# put the sidebar before the body #}
-{% block sidebar1 %}{{ sidebar() }}{% endblock %}
-{% block sidebar2 %}{% endblock %}
-
diff --git a/docs/source/_templates/notebook_redirect.html b/docs/source/_templates/notebook_redirect.html
new file mode 100644
index 00000000000..0114404b873
--- /dev/null
+++ b/docs/source/_templates/notebook_redirect.html
@@ -0,0 +1,9 @@
+<html>
+    <head>
+        <meta http-equiv="Refresh" content="0; url=../notebook/index.html" />
+        <title>Notebook docs have moved</title>
+    </head>
+    <body>
+        <p>The notebook docs have moved <a href="../notebook/index.html">here</a>.</p>
+    </body>
+</html>
diff --git a/docs/source/about/credits.txt b/docs/source/about/credits.txt
deleted file mode 100644
index c54e389620b..00000000000
--- a/docs/source/about/credits.txt
+++ /dev/null
@@ -1,277 +0,0 @@
-.. _credits:
-
-=======
-Credits
-=======
-
-IPython was started and continues to be led by Fernando Pérez.
-
-Core developers
-===============
-
-As of this writing, core development team consists of the following
-developers:
-
-* **Fernando Pérez** <Fernando.Perez-AT-berkeley.edu> Project creator and leader, 
-  IPython core, parallel computing infrastructure, testing, release manager.
-
-* **Robert Kern** <rkern-AT-enthought.com> Co-mentored the 2005 Google Summer of
-  Code project, work on IPython's core.
-
-* **Brian Granger** <ellisonbg-AT-gmail.com> Parallel computing 
-  infrastructure, IPython core.
-
-* **Benjamin (Min) Ragan-Kelley** <benjaminrk-AT-gmail.com> Parallel computing
-  infrastructure.
-
-* **Ville Vainio** <vivainio-AT-gmail.com> IPython core, maintainer of IPython
-  trunk from version 0.7.2 to 0.8.4.
-
-* **Gael Varoquaux** <gael.varoquaux-AT-normalesup.org> wxPython IPython GUI,
-  frontend architecture.
-
-* **Barry Wark** <barrywark-AT-gmail.com> Cocoa GUI, frontend architecture.
-
-* **Laurent Dufrechou** <laurent.dufrechou-AT-gmail.com> wxPython IPython GUI.
-
-* **Jörgen Stenarson** <jorgen.stenarson-AT-bostream.nu> Maintainer of the
-  PyReadline project, which is needed for IPython under windows.
-
-Special thanks
-==============
-
-The IPython project is also very grateful to:
-
-Bill Bumgarner <bbum-AT-friday.com>, for providing the DPyGetOpt module that
-IPython used for parsing command line options through version 0.10.
-
-Ka-Ping Yee <ping-AT-lfw.org>, for providing the Itpl module for convenient
-and powerful string interpolation with a much nicer syntax than formatting
-through the '%' operator.
-
-Arnd Baecker <baecker-AT-physik.tu-dresden.de>, for his many very useful
-suggestions and comments, and lots of help with testing and documentation
-checking. Many of IPython's newer features are a result of discussions with
-him.
-
-Obviously Guido van Rossum and the whole Python development team, for creating
-a great language for interactive computing.
-
-Fernando would also like to thank Stephen Figgins <fig-AT-monitor.net>,
-an O'Reilly Python editor. His October 11, 2001 article about IPP and
-LazyPython, was what got this project started. You can read it at
-http://www.onlamp.com/pub/a/python/2001/10/11/pythonnews.html.
-
-Sponsors
-========
-
-We would like to thank the following entities which, at one point or another,
-have provided resources and support to IPython:
-
-* Enthought (http://www.enthought.com), for hosting IPython's website and
-  supporting the project in various ways over the years, including significant
-  funding and resources in 2010 for the development of our modern ZeroMQ-based
-  architecture and Qt console frontend.
-
-* Google, for supporting IPython through Summer of Code sponsorships in 2005
-  and 2010.
-
-* Microsoft Corporation, for funding in 2009 the development of documentation
-  and examples of the Windows HPC Server 2008 support in IPython's parallel
-  computing tools.
-  
-* The Nipy project (http://nipy.org) for funding in 2009 a significant
-  refactoring of the entire project codebase that was key.
-
-* Ohio Supercomputer Center ( part of Ohio State University Research
-  Foundation) and the Department of Defense High Performance Computing
-  Modernization Program (HPCMP), for sponsoring work in 2009 on the ipcluster
-  script used for starting IPython's parallel computing processes, as well as
-  the integration between IPython and the Vision environment
-  (http://mgltools.scripps.edu/packages/vision).  This project would not have
-  been possible without the support and leadership of Jose Unpingco, from Ohio
-  State.
-
-* Tech-X Corporation, for sponsoring a NASA SBIR project in 2008 on IPython's
-  distributed array and parallel computing capabilities.
-
-* Bivio Software (http://www.bivio.biz/bp/Intro), for hosting an IPython sprint
-  in 2006 in addition to their support of the Front Range Pythoneers group in
-  Boulder, CO.
-
-  
-Contributors
-============
-
-And last but not least, all the kind IPython contributors who have contributed
-new code, bug reports, fixes, comments and ideas. A brief list follows, please
-let us know if we have omitted your name by accident:
-
-* Mark Voorhies <mark.voorhies-AT-ucsf.edu> Printing support in Qt console.
-
-* Thomas Kluyver <takowl-AT-gmail.com> Port of IPython and its necessary ZeroMQ
-  infrastructure to Python3.
-
-* Evan Patterson <epatters-AT-enthought.com> Qt console frontend with ZeroMQ.
-
-* Justin Riley <justin.t.riley-AT-gmail.com> Contributions to parallel support,
-  Amazon EC2, Sun Grid Engine, documentation.
-
-* Satrajit Ghosh <satra-AT-mit.edu> parallel computing (SGE and much more).
-
-* Thomas Spura <tomspur-AT-fedoraproject.org> various fixes motivated by Fedora
-  support.
-
-* Omar Andrés Zapata Mesa <andresete.chaos-AT-gmail.com> Google Summer of Code
-  2010, terminal support with ZeroMQ
-
-* Gerardo Gutierrez <muzgash-AT-gmail.com> Google Summer of Code 2010, Qt
-  notebook frontend support with ZeroMQ.
-
-* Paul Ivanov <pivanov314-AT-gmail.com> multiline specials improvements.
-  
-* Dav Clark <davclark-AT-berkeley.edu> traitlets improvements.
-  
-* David Warde-Farley <dwf-AT-cs.toronto.edu> %timeit fixes.
-  
-* Darren Dale <dsdale24-AT-gmail.com>, traits-based configuration system, Qt
-  support.
-
-* Jose Unpingco <unpingco@gmail.com> authored multiple tutorials and
-  screencasts teaching the use of IPython both for interactive and parallel
-  work (available in the documentation part of our website).
-  
-* Dan Milstein <danmil-AT-comcast.net> A bold refactor of the core prefilter
-  machinery in the IPython interpreter.
-
-* Jack Moffit <jack-AT-xiph.org> Bug fixes, including the infamous color
-  problem. This bug alone caused many lost hours and frustration, many thanks
-  to him for the fix. I've always been a fan of Ogg & friends, now I have one
-  more reason to like these folks. Jack is also contributing with Debian
-  packaging and many other things.
- 
-* Alexander Schmolck <a.schmolck-AT-gmx.net> Emacs work, bug reports, bug
-  fixes, ideas, lots more. The ipython.el mode for (X)Emacs is Alex's code,
-  providing full support for IPython under (X)Emacs.
-
-* Andrea Riciputi <andrea.riciputi-AT-libero.it> Mac OSX information, Fink
-  package management.
-
-* Gary Bishop <gb-AT-cs.unc.edu> Bug reports, and patches to work around the
-  exception handling idiosyncracies of WxPython. Readline and color support
-  for Windows.
-
-* Jeffrey Collins <Jeff.Collins-AT-vexcel.com>. Bug reports. Much improved
-  readline support, including fixes for Python 2.3.
-
-* Dryice Liu <dryice-AT-liu.com.cn> FreeBSD port.
-
-* Mike Heeter <korora-AT-SDF.LONESTAR.ORG>
-
-* Christopher Hart <hart-AT-caltech.edu> PDB integration.
-
-* Milan Zamazal <pdm-AT-zamazal.org> Emacs info.
-
-* Philip Hisley <compsys-AT-starpower.net>
-
-* Holger Krekel <pyth-AT-devel.trillke.net> Tab completion, lots more.
-
-* Robin Siebler <robinsiebler-AT-starband.net>
-
-* Ralf Ahlbrink <ralf_ahlbrink-AT-web.de>
-
-* Thorsten Kampe <thorsten-AT-thorstenkampe.de>
-
-* Fredrik Kant <fredrik.kant-AT-front.com> Windows setup.
-
-* Syver Enstad <syver-en-AT-online.no> Windows setup.
-
-* Richard <rxe-AT-renre-europe.com> Global embedding.
-
-* Hayden Callow <h.callow-AT-elec.canterbury.ac.nz> Gnuplot.py 1.6
-  compatibility.
-  
-* Leonardo Santagada <retype-AT-terra.com.br> Fixes for Windows
-  installation.
-  
-* Christopher Armstrong <radix-AT-twistedmatrix.com> Bugfixes.
-
-* Francois Pinard <pinard-AT-iro.umontreal.ca> Code and
-  documentation fixes.
-  
-* Cory Dodt <cdodt-AT-fcoe.k12.ca.us> Bug reports and Windows
-  ideas. Patches for Windows installer.
-  
-* Olivier Aubert <oaubert-AT-bat710.univ-lyon1.fr> New magics.
-
-* King C. Shu <kingshu-AT-myrealbox.com> Autoindent patch.
-
-* Chris Drexler <chris-AT-ac-drexler.de> Readline packages for
-  Win32/CygWin.
-  
-* Gustavo Cordova Avila <gcordova-AT-sismex.com> EvalDict code for
-  nice, lightweight string interpolation.
-  
-* Kasper Souren <Kasper.Souren-AT-ircam.fr> Bug reports, ideas.
-
-* Gever Tulley <gever-AT-helium.com> Code contributions.
-
-* Ralf Schmitt <ralf-AT-brainbot.com> Bug reports & fixes.
-
-* Oliver Sander <osander-AT-gmx.de> Bug reports.
-
-* Rod Holland <rhh-AT-structurelabs.com> Bug reports and fixes to
-  logging module.
-
-* Daniel 'Dang' Griffith <pythondev-dang-AT-lazytwinacres.net>
-  Fixes, enhancement suggestions for system shell use.
-
-* Viktor Ransmayr <viktor.ransmayr-AT-t-online.de> Tests and
-  reports on Windows installation issues. Contributed a true Windows
-  binary installer.
-
-* Mike Salib <msalib-AT-mit.edu> Help fixing a subtle bug related
-  to traceback printing.
-
-* W.J. van der Laan <gnufnork-AT-hetdigitalegat.nl> Bash-like
-  prompt specials.
-
-* Antoon Pardon <Antoon.Pardon-AT-rece.vub.ac.be> Critical fix for
-  the multithreaded IPython.
-
-* John Hunter <jdhunter-AT-nitace.bsd.uchicago.edu> Matplotlib
-  author, helped with all the development of support for matplotlib
-  in IPyhton, including making necessary changes to matplotlib itself.
-
-* Matthew Arnison <maffew-AT-cat.org.au> Bug reports, '%run -d' idea.
-
-* Prabhu Ramachandran <prabhu_r-AT-users.sourceforge.net> Help
-  with (X)Emacs support, threading patches, ideas...
-
-* Norbert Tretkowski <tretkowski-AT-inittab.de> help with Debian
-  packaging and distribution.
-
-* George Sakkis <gsakkis-AT-eden.rutgers.edu> New matcher for
-  tab-completing named arguments of user-defined functions.
-
-* Jörgen Stenarson <jorgen.stenarson-AT-bostream.nu> Wildcard
-  support implementation for searching namespaces.
-
-* Vivian De Smedt <vivian-AT-vdesmedt.com> Debugger enhancements,
-  so that when pdb is activated from within IPython, coloring, tab
-  completion and other features continue to work seamlessly.
-
-* Scott Tsai <scottt958-AT-yahoo.com.tw> Support for automatic
-  editor invocation on syntax errors (see
-  http://www.scipy.net/roundup/ipython/issue36).
-
-* Alexander Belchenko <bialix-AT-ukr.net> Improvements for win32
-  paging system.
-
-* Will Maier <willmaier-AT-ml1.net> Official OpenBSD port.
-
-* Ondrej Certik <ondrej-AT-certik.cz> Set up the IPython docs to use the new
-  Sphinx system used by Python, Matplotlib and many more projects.
-
-* Stefan van der Walt <stefan-AT-sun.ac.za> Design and prototype of the
-  Traits based config system.
diff --git a/docs/source/about/history.txt b/docs/source/about/history.rst
similarity index 100%
rename from docs/source/about/history.txt
rename to docs/source/about/history.rst
diff --git a/docs/source/about/index.rst b/docs/source/about/index.rst
new file mode 100644
index 00000000000..fb2b5a9ef20
--- /dev/null
+++ b/docs/source/about/index.rst
@@ -0,0 +1,12 @@
+.. _about_index:
+
+=============
+About IPython
+=============
+
+.. toctree::
+   :maxdepth: 1
+
+   history
+   license_and_copyright
+
diff --git a/docs/source/about/index.txt b/docs/source/about/index.txt
deleted file mode 100644
index 3abd31b8c98..00000000000
--- a/docs/source/about/index.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-.. _about_index:
-
-=============
-About IPython
-=============
-
-.. toctree::
-   :maxdepth: 1
-
-   credits
-   history
-   license_and_copyright
-
diff --git a/docs/source/about/license_and_copyright.rst b/docs/source/about/license_and_copyright.rst
new file mode 100644
index 00000000000..17cfccd21d1
--- /dev/null
+++ b/docs/source/about/license_and_copyright.rst
@@ -0,0 +1,408 @@
+.. _license:
+
+======================
+Licenses and Copyright
+======================
+
+Licenses
+========
+
+IPython source code and examples are licensed under the terms of the
+new or revised BSD license, as follows::
+
+    Copyright (c) 2011, IPython Development Team
+
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+    Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+    Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+    Neither the name of the IPython Development Team nor the names of its
+    contributors may be used to endorse or promote products derived from this
+    software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+IPython documentation, examples and other materials are licensed under
+the terms of the Attribution 4.0 International (CC BY 4.0) license, as
+follows::
+
+    Creative Commons Attribution 4.0 International Public License
+    
+    By exercising the Licensed Rights (defined below), You accept and agree
+    to be bound by the terms and conditions of this Creative Commons
+    Attribution 4.0 International Public License ("Public License"). To the
+    extent this Public License may be interpreted as a contract, You are
+    granted the Licensed Rights in consideration of Your acceptance of
+    these terms and conditions, and the Licensor grants You such rights in
+    consideration of benefits the Licensor receives from making the
+    Licensed Material available under these terms and conditions.
+    
+    
+    Section 1 -- Definitions.
+    
+      a. Adapted Material means material subject to Copyright and Similar
+         Rights that is derived from or based upon the Licensed Material
+         and in which the Licensed Material is translated, altered,
+         arranged, transformed, or otherwise modified in a manner requiring
+         permission under the Copyright and Similar Rights held by the
+         Licensor. For purposes of this Public License, where the Licensed
+         Material is a musical work, performance, or sound recording,
+         Adapted Material is always produced where the Licensed Material is
+         synched in timed relation with a moving image.
+    
+      b. Adapter's License means the license You apply to Your Copyright
+         and Similar Rights in Your contributions to Adapted Material in
+         accordance with the terms and conditions of this Public License.
+    
+      c. Copyright and Similar Rights means copyright and/or similar rights
+         closely related to copyright including, without limitation,
+         performance, broadcast, sound recording, and Sui Generis Database
+         Rights, without regard to how the rights are labeled or
+         categorized. For purposes of this Public License, the rights
+         specified in Section 2(b)(1)-(2) are not Copyright and Similar
+         Rights.
+    
+      d. Effective Technological Measures means those measures that, in the
+         absence of proper authority, may not be circumvented under laws
+         fulfilling obligations under Article 11 of the WIPO Copyright
+         Treaty adopted on December 20, 1996, and/or similar international
+         agreements.
+    
+      e. Exceptions and Limitations means fair use, fair dealing, and/or
+         any other exception or limitation to Copyright and Similar Rights
+         that applies to Your use of the Licensed Material.
+    
+      f. Licensed Material means the artistic or literary work, database,
+         or other material to which the Licensor applied this Public
+         License.
+    
+      g. Licensed Rights means the rights granted to You subject to the
+         terms and conditions of this Public License, which are limited to
+         all Copyright and Similar Rights that apply to Your use of the
+         Licensed Material and that the Licensor has authority to license.
+    
+      h. Licensor means the individual(s) or entity(ies) granting rights
+         under this Public License.
+    
+      i. Share means to provide material to the public by any means or
+         process that requires permission under the Licensed Rights, such
+         as reproduction, public display, public performance, distribution,
+         dissemination, communication, or importation, and to make material
+         available to the public including in ways that members of the
+         public may access the material from a place and at a time
+         individually chosen by them.
+    
+      j. Sui Generis Database Rights means rights other than copyright
+         resulting from Directive 96/9/EC of the European Parliament and of
+         the Council of 11 March 1996 on the legal protection of databases,
+         as amended and/or succeeded, as well as other essentially
+         equivalent rights anywhere in the world.
+    
+      k. You means the individual or entity exercising the Licensed Rights
+         under this Public License. Your has a corresponding meaning.
+    
+    
+    Section 2 -- Scope.
+    
+      a. License grant.
+    
+           1. Subject to the terms and conditions of this Public License,
+              the Licensor hereby grants You a worldwide, royalty-free,
+              non-sublicensable, non-exclusive, irrevocable license to
+              exercise the Licensed Rights in the Licensed Material to:
+    
+                a. reproduce and Share the Licensed Material, in whole or
+                   in part; and
+    
+                b. produce, reproduce, and Share Adapted Material.
+    
+           2. Exceptions and Limitations. For the avoidance of doubt, where
+              Exceptions and Limitations apply to Your use, this Public
+              License does not apply, and You do not need to comply with
+              its terms and conditions.
+    
+           3. Term. The term of this Public License is specified in Section
+              6(a).
+    
+           4. Media and formats; technical modifications allowed. The
+              Licensor authorizes You to exercise the Licensed Rights in
+              all media and formats whether now known or hereafter created,
+              and to make technical modifications necessary to do so. The
+              Licensor waives and/or agrees not to assert any right or
+              authority to forbid You from making technical modifications
+              necessary to exercise the Licensed Rights, including
+              technical modifications necessary to circumvent Effective
+              Technological Measures. For purposes of this Public License,
+              simply making modifications authorized by this Section 2(a)
+              (4) never produces Adapted Material.
+    
+           5. Downstream recipients.
+    
+                a. Offer from the Licensor -- Licensed Material. Every
+                   recipient of the Licensed Material automatically
+                   receives an offer from the Licensor to exercise the
+                   Licensed Rights under the terms and conditions of this
+                   Public License.
+    
+                b. No downstream restrictions. You may not offer or impose
+                   any additional or different terms or conditions on, or
+                   apply any Effective Technological Measures to, the
+                   Licensed Material if doing so restricts exercise of the
+                   Licensed Rights by any recipient of the Licensed
+                   Material.
+    
+           6. No endorsement. Nothing in this Public License constitutes or
+              may be construed as permission to assert or imply that You
+              are, or that Your use of the Licensed Material is, connected
+              with, or sponsored, endorsed, or granted official status by,
+              the Licensor or others designated to receive attribution as
+              provided in Section 3(a)(1)(A)(i).
+    
+      b. Other rights.
+    
+           1. Moral rights, such as the right of integrity, are not
+              licensed under this Public License, nor are publicity,
+              privacy, and/or other similar personality rights; however, to
+              the extent possible, the Licensor waives and/or agrees not to
+              assert any such rights held by the Licensor to the limited
+              extent necessary to allow You to exercise the Licensed
+              Rights, but not otherwise.
+    
+           2. Patent and trademark rights are not licensed under this
+              Public License.
+    
+           3. To the extent possible, the Licensor waives any right to
+              collect royalties from You for the exercise of the Licensed
+              Rights, whether directly or through a collecting society
+              under any voluntary or waivable statutory or compulsory
+              licensing scheme. In all other cases the Licensor expressly
+              reserves any right to collect such royalties.
+    
+    
+    Section 3 -- License Conditions.
+    
+    Your exercise of the Licensed Rights is expressly made subject to the
+    following conditions.
+    
+      a. Attribution.
+    
+           1. If You Share the Licensed Material (including in modified
+              form), You must:
+    
+                a. retain the following if it is supplied by the Licensor
+                   with the Licensed Material:
+    
+                     i. identification of the creator(s) of the Licensed
+                        Material and any others designated to receive
+                        attribution, in any reasonable manner requested by
+                        the Licensor (including by pseudonym if
+                        designated);
+    
+                    ii. a copyright notice;
+    
+                   iii. a notice that refers to this Public License;
+    
+                    iv. a notice that refers to the disclaimer of
+                        warranties;
+    
+                     v. a URI or hyperlink to the Licensed Material to the
+                        extent reasonably practicable;
+    
+                b. indicate if You modified the Licensed Material and
+                   retain an indication of any previous modifications; and
+    
+                c. indicate the Licensed Material is licensed under this
+                   Public License, and include the text of, or the URI or
+                   hyperlink to, this Public License.
+    
+           2. You may satisfy the conditions in Section 3(a)(1) in any
+              reasonable manner based on the medium, means, and context in
+              which You Share the Licensed Material. For example, it may be
+              reasonable to satisfy the conditions by providing a URI or
+              hyperlink to a resource that includes the required
+              information.
+    
+           3. If requested by the Licensor, You must remove any of the
+              information required by Section 3(a)(1)(A) to the extent
+              reasonably practicable.
+    
+           4. If You Share Adapted Material You produce, the Adapter's
+              License You apply must not prevent recipients of the Adapted
+              Material from complying with this Public License.
+    
+    
+    Section 4 -- Sui Generis Database Rights.
+    
+    Where the Licensed Rights include Sui Generis Database Rights that
+    apply to Your use of the Licensed Material:
+    
+      a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+         to extract, reuse, reproduce, and Share all or a substantial
+         portion of the contents of the database;
+    
+      b. if You include all or a substantial portion of the database
+         contents in a database in which You have Sui Generis Database
+         Rights, then the database in which You have Sui Generis Database
+         Rights (but not its individual contents) is Adapted Material; and
+    
+      c. You must comply with the conditions in Section 3(a) if You Share
+         all or a substantial portion of the contents of the database.
+    
+    For the avoidance of doubt, this Section 4 supplements and does not
+    replace Your obligations under this Public License where the Licensed
+    Rights include other Copyright and Similar Rights.
+    
+    
+    Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+    
+      a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+         EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+         AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+         ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+         IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+         WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+         PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+         ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+         KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+         ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+    
+      b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+         TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+         NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+         INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+         COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+         USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+         ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+         DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+         IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+    
+      c. The disclaimer of warranties and limitation of liability provided
+         above shall be interpreted in a manner that, to the extent
+         possible, most closely approximates an absolute disclaimer and
+         waiver of all liability.
+    
+    
+    Section 6 -- Term and Termination.
+    
+      a. This Public License applies for the term of the Copyright and
+         Similar Rights licensed here. However, if You fail to comply with
+         this Public License, then Your rights under this Public License
+         terminate automatically.
+    
+      b. Where Your right to use the Licensed Material has terminated under
+         Section 6(a), it reinstates:
+    
+           1. automatically as of the date the violation is cured, provided
+              it is cured within 30 days of Your discovery of the
+              violation; or
+    
+           2. upon express reinstatement by the Licensor.
+    
+         For the avoidance of doubt, this Section 6(b) does not affect any
+         right the Licensor may have to seek remedies for Your violations
+         of this Public License.
+    
+      c. For the avoidance of doubt, the Licensor may also offer the
+         Licensed Material under separate terms or conditions or stop
+         distributing the Licensed Material at any time; however, doing so
+         will not terminate this Public License.
+    
+      d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+         License.
+    
+    
+    Section 7 -- Other Terms and Conditions.
+    
+      a. The Licensor shall not be bound by any additional or different
+         terms or conditions communicated by You unless expressly agreed.
+    
+      b. Any arrangements, understandings, or agreements regarding the
+         Licensed Material not stated herein are separate from and
+         independent of the terms and conditions of this Public License.
+    
+    
+    Section 8 -- Interpretation.
+    
+      a. For the avoidance of doubt, this Public License does not, and
+         shall not be interpreted to, reduce, limit, restrict, or impose
+         conditions on any use of the Licensed Material that could lawfully
+         be made without permission under this Public License.
+    
+      b. To the extent possible, if any provision of this Public License is
+         deemed unenforceable, it shall be automatically reformed to the
+         minimum extent necessary to make it enforceable. If the provision
+         cannot be reformed, it shall be severed from this Public License
+         without affecting the enforceability of the remaining terms and
+         conditions.
+    
+      c. No term or condition of this Public License will be waived and no
+         failure to comply consented to unless expressly agreed to by the
+         Licensor.
+    
+      d. Nothing in this Public License constitutes or may be interpreted
+         as a limitation upon, or waiver of, any privileges and immunities
+         that apply to the Licensor or You, including from the legal
+         processes of any jurisdiction or authority.
+    
+    
+About the IPython Development Team
+==================================
+
+Fernando Perez began IPython in 2001 based on code from Janko Hauser
+<jhauser-AT-zscout.de> and Nathaniel Gray <n8gray-AT-caltech.edu>. Fernando is still
+the project lead.
+
+The IPython Development Team is the set of all contributors to the IPython
+project. This includes all of the IPython subprojects. See the release notes
+for a list of people who have contributed to each release.
+
+Our Copyright Policy
+====================
+
+IPython uses a shared copyright model. Each contributor maintains copyright
+over their contributions to IPython. But, it is important to note that these
+contributions are typically only changes (diffs/commits) to the repositories.
+Thus, the IPython source code, in its entirety is not the copyright of any
+single person or institution. Instead, it is the collective copyright of the
+entire IPython Development Team. If individual contributors want to maintain a
+record of what changes/contributions they have specific copyright on, they
+should indicate their copyright in the commit message of the change, when they
+commit the change to one of the IPython repositories.
+
+Any new code contributed to IPython must be licensed under the BSD license or
+a similar (MIT) open source license.
+
+Miscellaneous
+=============
+
+Some files (DPyGetOpt.py, for example) may be licensed under different
+conditions. Ultimately each file indicates clearly the conditions under which
+its author/authors have decided to publish the code.
+
+Versions of IPython up to and including 0.6.3 were released under the GNU
+Lesser General Public License (LGPL), available at
+http://www.gnu.org/copyleft/lesser.html.
+
+Online versions of the Creative Commons licenses can be found at:
+
+* http://creativecommons.org/licenses/by/4.0/
+* http://creativecommons.org/licenses/by/4.0/legalcode.txt
diff --git a/docs/source/about/license_and_copyright.txt b/docs/source/about/license_and_copyright.txt
deleted file mode 100644
index e88da84c26f..00000000000
--- a/docs/source/about/license_and_copyright.txt
+++ /dev/null
@@ -1,95 +0,0 @@
-.. _license:
-
-=====================
-License and Copyright
-=====================
-
-License
-=======
-
-IPython is licensed under the terms of the new or revised BSD license, as
-follows::
-
-    Copyright (c) 2008, IPython Development Team
-
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-
-    Redistributions of source code must retain the above copyright notice,
-    this list of conditions and the following disclaimer.
-
-    Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
-    Neither the name of the IPython Development Team nor the names of its
-    contributors may be used to endorse or promote products derived from this
-    software without specific prior written permission.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-    PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-About the IPython Development Team
-==================================
-
-Fernando Perez began IPython in 2001 based on code from Janko Hauser
-<jhauser-AT-zscout.de> and Nathaniel Gray <n8gray-AT-caltech.edu>. Fernando is still
-the project lead.
-
-The IPython Development Team is the set of all contributors to the IPython
-project. This includes all of the IPython subprojects. Here is a list of the
-currently active contributors:
-
-* Matthieu Brucher
-* Ondrej Certik
-* Laurent Dufrechou
-* Robert Kern
-* Brian E. Granger
-* Fernando Perez (project leader)
-* Benjamin Ragan-Kelley
-* Ville M. Vainio
-* Gael Varoququx
-* Stefan van der Walt
-* Barry Wark
-
-If your name is missing, please add it.  
-
-Our Copyright Policy
-====================
-
-IPython uses a shared copyright model. Each contributor maintains copyright
-over their contributions to IPython. But, it is important to note that these
-contributions are typically only changes (diffs/commits) to the repositories.
-Thus, the IPython source code, in its entirety is not the copyright of any
-single person or institution. Instead, it is the collective copyright of the
-entire IPython Development Team. If individual contributors want to maintain a
-record of what changes/contributions they have specific copyright on, they
-should indicate their copyright in the commit message of the change, when they
-commit the change to one of the IPython repositories.
-
-Any new code contributed to IPython must be licensed under the BSD license or
-a similar (MIT) open source license.
-
-Miscellaneous
-=============
-
-Some files (DPyGetOpt.py, for example) may be licensed under different
-conditions. Ultimately each file indicates clearly the conditions under which
-its author/authors have decided to publish the code.
-
-Versions of IPython up to and including 0.6.3 were released under the GNU
-Lesser General Public License (LGPL), available at
-http://www.gnu.org/copyleft/lesser.html.
-
diff --git a/docs/source/api/index.rst b/docs/source/api/index.rst
new file mode 100644
index 00000000000..8940cf1f93b
--- /dev/null
+++ b/docs/source/api/index.rst
@@ -0,0 +1,12 @@
+.. _api-index:
+
+###################
+  The IPython API
+###################
+
+.. only:: html
+
+   :Release: |version|
+   :Date: |today|
+
+.. include:: generated/gen.txt
diff --git a/docs/source/api/index.txt b/docs/source/api/index.txt
deleted file mode 100644
index d5c55f480e8..00000000000
--- a/docs/source/api/index.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-.. _api-index:
-
-###################
-  The IPython API
-###################
-
-.. htmlonly::
-
-   :Release: |version|
-   :Date: |today|
-
-.. include:: generated/gen.txt
diff --git a/docs/source/attic/parallel_task_old.txt b/docs/source/attic/parallel_task_old.txt
deleted file mode 100644
index bd7ca1dc94f..00000000000
--- a/docs/source/attic/parallel_task_old.txt
+++ /dev/null
@@ -1,240 +0,0 @@
-.. _paralleltask:
-
-==========================
-The IPython task interface
-==========================
-
-.. contents::
-
-The ``Task`` interface to the controller presents the engines as a fault tolerant, dynamic load-balanced system or workers. Unlike the ``MultiEngine`` interface, in the ``Task`` interface, the user have no direct access to individual engines. In some ways, this interface is simpler, but in other ways it is more powerful. Best of all the user can use both of these interfaces at the same time to take advantage or both of their strengths.  When the user can break up the user's work into segments that do not depend on previous execution, the ``Task`` interface is ideal.  But it also has more power and flexibility, allowing the user to guide the distribution of jobs, without having to assign Tasks to engines explicitly.
-
-Starting the IPython controller and engines
-===========================================
-
-To follow along with this tutorial, the user will need to start the IPython
-controller and four IPython engines. The simplest way of doing this is to
-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.
-
-The magic here is that this single controller and set of engines is running both the MultiEngine and ``Task`` interfaces simultaneously.
-
-QuickStart Task Farming
-=======================
-
-First, a quick example of how to start running the most basic Tasks.
-The first step is to import the IPython ``client`` module and then create a ``TaskClient`` instance::
-    
-    In [1]: from IPython.kernel import client
-    
-    In [2]: tc = client.TaskClient()
-
-Then the user wrap the commands the user want to run in Tasks::
-
-    In [3]: tasklist = []
-    In [4]: for n in range(1000):
-        ...     tasklist.append(client.Task("a = %i"%n, pull="a"))
-
-The first argument of the ``Task`` constructor is a string, the command to be executed.  The most important optional keyword argument is ``pull``, which can be a string or list of strings, and it specifies the variable names to be saved as results of the ``Task``.
-
-Next, the user need to submit the Tasks to the ``TaskController`` with the ``TaskClient``::
-
-    In [5]: taskids = [ tc.run(t) for t in tasklist ]
-
-This will give the user a list of the TaskIDs used by the controller to keep track of the Tasks and their results.  Now at some point the user are going to want to get those results back.  The ``barrier`` method allows the user to wait for the Tasks to finish running::
-
-    In [6]: tc.barrier(taskids)
-
-This command will block until all the Tasks in ``taskids`` have finished.  Now, the user probably want to look at the user's results::
-
-    In [7]: task_results = [ tc.get_task_result(taskid) for taskid in taskids ]
-
-Now the user have a list of ``TaskResult`` objects, which have the actual result as a dictionary, but also keep track of some useful metadata about the ``Task``::
-
-    In [8]: tr = ``Task``_results[73]
-    
-    In [9]: tr
-    Out[9]: ``TaskResult``[ID:73]:{'a':73}
-    
-    In [10]: tr.engineid
-    Out[10]: 1
-    
-    In [11]: tr.submitted, tr.completed, tr.duration
-    Out[11]: ("2008/03/08 03:41:42", "2008/03/08 03:41:44", 2.12345)
-
-The actual results are stored in a dictionary, ``tr.results``, and a namespace object ``tr.ns`` which accesses the result keys by attribute::
-
-    In [12]: tr.results['a']
-    Out[12]: 73
-    
-    In [13]: tr.ns.a
-    Out[13]: 73
-
-That should cover the basics of running simple Tasks.  There are several more powerful things the user can do with Tasks covered later.  The most useful probably being using a ``MutiEngineClient`` interface to initialize all the engines with the import dependencies necessary to run the user's Tasks.
-
-There are many options for running and managing Tasks. The best way to learn further about the ``Task`` interface is to study the examples in ``docs/examples``. If the user do so and learn a lots about this interface, we encourage the user to expand this documentation about the ``Task`` system.
-
-Overview of the Task System
-===========================
-
-The user's view of the ``Task`` system has three basic objects:  The ``TaskClient``, the ``Task``, and the ``TaskResult``.  The names of these three objects well indicate their role.
-
-The ``TaskClient`` is the user's ``Task`` farming connection to the IPython cluster.  Unlike the ``MultiEngineClient``, the ``TaskControler`` handles all the scheduling and distribution of work, so the ``TaskClient`` has no notion of engines, it just submits Tasks and requests their results.  The Tasks are described as ``Task`` objects, and their results are wrapped in ``TaskResult`` objects.  Thus, there are very few necessary methods for the user to manage.
-
-Inside the task system is a Scheduler object, which assigns tasks to workers.  The default scheduler is a simple FIFO queue.  Subclassing the Scheduler should be easy, just implementing your own priority system.
-
-The TaskClient
-==============
-
-The ``TaskClient`` is the object the user use to connect to the ``Controller`` that is managing the user's Tasks.  It is the analog of the ``MultiEngineClient`` for the standard IPython multiplexing interface.  As with all client interfaces, the first step is to import the IPython Client Module::
-
-    In [1]: from IPython.kernel import client
-
-Just as with the ``MultiEngineClient``, the user create the ``TaskClient`` with a tuple, containing the ip-address and port of the ``Controller``.  the ``client`` module conveniently has the default address of the ``Task`` interface of the controller.  Creating a default ``TaskClient`` object would be done with this::
-
-    In [2]: tc = client.TaskClient(client.default_task_address)
-
-or, if the user want to specify a non default location of the ``Controller``, the user can specify explicitly::
-
-    In [3]: tc = client.TaskClient(("192.168.1.1", 10113))
-
-As discussed earlier, the ``TaskClient`` only has a few basic methods.
-
- * ``tc.run(task)``
-    ``run`` is the method by which the user submits Tasks.  It takes exactly one argument, a ``Task`` object.  All the advanced control of ``Task`` behavior is handled by properties of the ``Task`` object, rather than the submission command, so they will be discussed later in the `Task`_ section.  ``run`` returns an integer, the ``Task``ID by which the ``Task`` and its results can be tracked and retrieved::
-    
-        In [4]: ``Task``ID = tc.run(``Task``)
-    
- * ``tc.get_task_result(taskid, block=``False``)``
-    ``get_task_result`` is the method by which results are retrieved.  It takes a single integer argument, the ``Task``ID`` of the result the user wish to retrieve.  ``get_task_result`` also takes a keyword argument ``block``.  ``block`` specifies whether the user actually want to wait for the result.  If ``block`` is false, as it is by default, ``get_task_result`` will return immediately.  If the ``Task`` has completed, it will return the ``TaskResult`` object for that ``Task``.  But if the ``Task`` has not completed, it will return ``None``.  If the user specify ``block=``True``, then ``get_task_result`` will wait for the ``Task`` to complete, and always return the ``TaskResult`` for the requested ``Task``.
- * ``tc.barrier(taskid(s))``
-    ``barrier`` is a synchronization method.  It takes exactly one argument, a ``Task``ID or list of taskIDs.  ``barrier`` will block until all the specified Tasks have completed.  In practice, a barrier is often called between the ``Task`` submission section of the code and the result gathering section::
-        
-        In [5]: taskIDs = [ tc.run(``Task``) for ``Task`` in myTasks ]
-        
-        In [6]: tc.get_task_result(taskIDs[-1]) is None
-        Out[6]: ``True``
-        
-        In [7]: tc.barrier(``Task``ID)
-        
-        In [8]: results = [ tc.get_task_result(tid) for tid in taskIDs ]
-        
- * ``tc.queue_status(verbose=``False``)``
-    ``queue_status`` is a method for querying the state of the ``TaskControler``.  ``queue_status`` returns a dict of the form::
-        
-        {'scheduled': Tasks that have been submitted but yet run
-         'pending'  : Tasks that are currently running
-         'succeeded': Tasks that have completed successfully
-         'failed'   : Tasks that have finished with a failure
-        }
-    
-    if @verbose is not specified (or is ``False``), then the values of the dict are integers - the number of Tasks in each state.  if @verbose is ``True``, then each element in the dict is a list of the taskIDs in that state::
-    
-        In [8]: tc.queue_status()
-        Out[8]: {'scheduled': 4,
-                'pending'  : 2,
-                'succeeded': 5,
-                'failed'   : 1
-                }
-        
-        In [9]: tc.queue_status(verbose=True)
-        Out[9]: {'scheduled': [8,9,10,11],
-                'pending'  : [6,7],
-                'succeeded': [0,1,2,4,5],
-                'failed'   : [3]
-                }
-        
- * ``tc.abort(taskid)``
-    ``abort`` allows the user to abort Tasks that have already been submitted.  ``abort`` will always return immediately.  If the ``Task`` has completed, ``abort`` will raise an ``IndexError ``Task`` Already Completed``.  An obvious case for ``abort`` would be where the user submits a long-running ``Task`` with a number of retries (see ``Task``_ section for how to specify retries) in an interactive session, but realizes there has been a typo.  The user can then abort the ``Task``, preventing certain failures from cluttering up the queue.  It can also be used for parallel search-type problems, where only one ``Task`` will give the solution, so once the user find the solution, the user would want to abort all remaining Tasks to prevent wasted work.
- * ``tc.spin()``
-    ``spin`` simply triggers the scheduler in the ``TaskControler``.  Under most normal circumstances, this will do nothing.  The primary known usage case involves the ``Task`` dependency (see `Dependencies`_).  The dependency is a function of an Engine's ``properties``, but changing the ``properties`` via the ``MutliEngineClient`` does not trigger a reschedule event.  The main example case for this requires the following event sequence:
-     * ``engine`` is available, ``Task`` is submitted, but ``engine`` does not have ``Task``'s dependencies.
-     * ``engine`` gets necessary dependencies while no new Tasks are submitted or completed.
-     * now ``engine`` can run ``Task``, but a ``Task`` event is required for the ``TaskControler`` to try scheduling ``Task`` again.
-     
-    ``spin`` is just an empty ping method to ensure that the Controller has scheduled all available Tasks, and should not be needed under most normal circumstances.
-
-That covers the ``TaskClient``, a simple interface to the cluster.  With this, the user can submit jobs (and abort if necessary), request their results, synchronize on arbitrary subsets of jobs.
-
-.. _task: The Task Object
-
-The Task Object
-===============
-
-The ``Task`` is the basic object for describing a job.  It can be used in a very simple manner, where the user just specifies a command string to be executed as the ``Task``.  The usage of this first argument is exactly the same as the ``execute`` method of the ``MultiEngine`` (in fact, ``execute`` is called to run the code)::
-
-    In [1]: t = client.Task("a = str(id)")
-    
-This ``Task`` would run, and store the string representation of the ``id`` element in ``a`` in each worker's namespace, but it is fairly useless because the user does not know anything about the state of the ``worker`` on which it ran at the time of retrieving results.  It is important that each ``Task`` not expect the state of the ``worker`` to persist after the ``Task`` is completed.  
-There are many different situations for using ``Task`` Farming, and the ``Task`` object has many attributes for use in customizing the ``Task`` behavior.  All of a ``Task``'s attributes may be specified in the constructor, through keyword arguments, or after ``Task`` construction through attribute assignment.
-
-Data Attributes
-***************
-It is likely that the user may want to move data around before or after executing the ``Task``.  We provide methods of sending data to initialize the worker's namespace, and specifying what data to bring back as the ``Task``'s results.
-
- * pull = []
-    The obvious case is as above, where ``t`` would execute and store the result of ``myfunc`` in ``a``, it is likely that the user would want to bring ``a`` back to their namespace.  This is done through the ``pull`` attribute.  ``pull`` can be a string or list of strings, and it specifies the names of variables to be retrieved.  The ``TaskResult`` object retrieved by ``get_task_result`` will have a dictionary of keys and values, and the ``Task``'s ``pull`` attribute determines what goes into it::
-        
-        In [2]: t = client.Task("a = str(id)", pull = "a")
-        
-        In [3]: t = client.Task("a = str(id)", pull = ["a", "id"])
-        
- * push = {}
-    A user might also want to initialize some data into the namespace before the code part of the ``Task`` is run.  Enter ``push``.  ``push`` is a dictionary of key/value pairs to be loaded from the user's namespace into the worker's immediately before execution::
-
-        In [4]: t = client.Task("a = f(submitted)", push=dict(submitted=time.time()), pull="a")
-
-push and pull result directly in calling an ``engine``'s ``push`` and ``pull`` methods before and after ``Task`` execution respectively, and thus their api is the same.
-
-Namespace Cleaning
-******************
-When a user is running a large number of Tasks, it is likely that the namespace of the worker's could become cluttered.  Some Tasks might be sensitive to clutter, while others might be known to cause namespace pollution.  For these reasons, Tasks have two boolean attributes for cleaning up the namespace.
-
- * ``clear_after``
-    if clear_after is specified ``True``, the worker on which the ``Task`` was run will be reset (via ``engine.reset``) upon completion of the ``Task``.  This can be useful for both Tasks that produce clutter or Tasks whose intermediate data one might wish to be kept private::
-    
-        In [5]: t = client.Task("a = range(1e10)", pull = "a",clear_after=True)
-        
-    
- * ``clear_before``
-    as one might guess, clear_before is identical to ``clear_after``, but it takes place before the ``Task`` is run.  This ensures that the ``Task`` runs on a fresh worker::
-
-        In [6]: t = client.Task("a = globals()", pull = "a",clear_before=True)
-
-Of course, a user can both at the same time, ensuring that all workers are clear except when they are currently running a job.  Both of these default to ``False``.
-
-Fault Tolerance
-***************
-It is possible that Tasks might fail, and there are a variety of reasons this could happen.  One might be that the worker it was running on disconnected, and there was nothing wrong with the ``Task`` itself.  With the fault tolerance attributes of the ``Task``, the user can specify how many times to resubmit the ``Task``, and what to do if it never succeeds.
-
- * ``retries``
-    ``retries`` is an integer, specifying the number of times a ``Task`` is to be retried.  It defaults to zero.  It is often a good idea for this number to be 1 or 2, to protect the ``Task`` from disconnecting engines, but not a large number.  If a ``Task`` is failing 100 times, there is probably something wrong with the ``Task``.  The canonical bad example:
-    
-        In [7]: t = client.Task("os.kill(os.getpid(), 9)", retries=99)
-        
-    This would actually take down 100 workers.
-    
- * ``recovery_task``
-    ``recovery_task`` is another ``Task`` object, to be run in the event of the original ``Task`` still failing after running out of retries.  Since ``recovery_task`` is another ``Task`` object, it can have its own ``recovery_task``.  The chain of Tasks is limitless, except loops are not allowed (that would be bad!).
-
-Dependencies
-************
-Dependencies are the most powerful part of the ``Task`` farming system, because it allows the user to do some classification of the workers, and guide the ``Task`` distribution without meddling with the controller directly.  It makes use of two objects - the ``Task``'s ``depend`` attribute, and the engine's ``properties``.  See the `MultiEngine`_ reference for how to use engine properties.  The engine properties api exists for extending IPython, allowing conditional execution and new controllers that make decisions based on properties of its engines.  Currently the ``Task`` dependency is the only internal use of the properties api.
-
-.. _MultiEngine: ./parallel_multiengine
-
-The ``depend`` attribute of a ``Task`` must be a function of exactly one argument, the worker's properties dictionary, and it should return ``True`` if the ``Task`` should be allowed to run on the worker and ``False`` if not.  The usage in the controller is fault tolerant, so exceptions raised by ``Task.depend`` will be ignored and functionally equivalent to always returning ``False``.  Tasks`` with invalid ``depend`` functions will never be assigned to a worker::
-
-    In [8]: def dep(properties):
-        ...     return properties["RAM"] > 2**32 # have at least 4GB
-    In [9]: t = client.Task("a = bigfunc()", depend=dep)
-    
-It is important to note that assignment of values to the properties dict is done entirely by the user, either locally (in the engine) using the EngineAPI, or remotely, through the ``MultiEngineClient``'s get/set_properties methods.
-
-
-
-
-
-    
diff --git a/docs/source/conf.py b/docs/source/conf.py
old mode 100644
new mode 100755
index 60a9e4816b6..1096440d012
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -1,191 +1,214 @@
-# -*- coding: utf-8 -*-
-#
 # IPython documentation build configuration file.
 
 # NOTE: This file has been edited manually from the auto-generated one from
 # sphinx.  Do NOT delete and re-generate.  If any changes from sphinx are
 # needed, generate a scratch one and merge by hand any new fields needed.
 
-#
-# This file is execfile()d with the current directory set to its containing dir.
-#
-# The contents of this file are pickled, so don't put values in the namespace
-# that aren't pickleable (module imports are okay, they're removed automatically).
-#
-# All configuration values have a default value; values that are commented out
-# serve to show the default value.
-
 import sys, os
+from pathlib import Path
+
+import tomllib
+
+from sphinx_toml import load_into_locals
+from intersphinx_registry import get_intersphinx_mapping
+import sphinx_rtd_theme
+import sphinx.util
+import logging
+
+load_into_locals(locals())
+# https://read-the-docs.readthedocs.io/en/latest/faq.html
+ON_RTD = os.environ.get("READTHEDOCS", None) == "True"
+
+if ON_RTD:
+    tags.add("rtd")
+
+    # RTD doesn't use the Makefile, so re-run autogen_{things}.py here.
+    for name in ("config", "api", "magics", "shortcuts"):
+        fname = Path("autogen_{}.py".format(name))
+        fpath = (Path(__file__).parent).joinpath("..", fname)
+        with open(fpath, encoding="utf-8") as f:
+            exec(
+                compile(f.read(), fname, "exec"),
+                {
+                    "__file__": fpath,
+                    "__name__": "__main__",
+                },
+            )
+
+# Allow Python scripts to change behaviour during sphinx run
+os.environ["IN_SPHINX_RUN"] = "True"
+
+autodoc_type_aliases = {
+    "Matcher": " IPython.core.completer.Matcher",
+    "MatcherAPIv1": " IPython.core.completer.MatcherAPIv1",
+}
 
 # If your extensions are in another directory, add it here. If the directory
 # is relative to the documentation root, use os.path.abspath to make it
 # absolute, like shown here.
-sys.path.insert(0, os.path.abspath('../sphinxext'))
-
-# Import support for ipython console session syntax highlighting (lives
-# in the sphinxext directory defined above)
-import ipython_console_highlighting
+sys.path.insert(0, os.path.abspath("../sphinxext"))
 
 # We load the ipython release info into a dict by explicit execution
 iprelease = {}
-execfile('../../IPython/core/release.py',iprelease)
+exec(
+    compile(
+        open("../../IPython/core/release.py", encoding="utf-8").read(),
+        "../../IPython/core/release.py",
+        "exec",
+    ),
+    iprelease,
+)
 
 # General configuration
 # ---------------------
 
-# Add any Sphinx extension module names here, as strings. They can be extensions
-# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = [
-    # 'matplotlib.sphinxext.mathmpl',
-    'matplotlib.sphinxext.only_directives',
-    # 'matplotlib.sphinxext.plot_directive',
-    'sphinx.ext.autodoc',
-    'sphinx.ext.doctest',
-    'inheritance_diagram',
-    'ipython_console_highlighting', 
-    'numpydoc',  # to preprocess docstrings
-]
+# - template_path: Add any paths that contain templates here, relative to this directory.
+# - master_doc: The master toctree document.
+# - project
+# - copyright
+# - github_project_url
+# - source_suffix = config["sphinx"]["source_suffix"]
+# - exclude_patterns:
+#       Exclude these glob-style patterns when looking for source files.
+#       They are relative to the source/ directory.
+# - pygments_style: The name of the Pygments (syntax highlighting) style to use.
+# - default_role
+# - modindex_common_prefix
+
+
+intersphinx_mapping = get_intersphinx_mapping(
+    packages={
+        "python",
+        "rpy2",
+        "jupyterclient",
+        "jupyter",
+        "jedi",
+        "traitlets",
+        "ipykernel",
+        "prompt_toolkit",
+        "ipywidgets",
+        "ipyparallel",
+        "pip",
+    }
+)
+
+# External links configuration (replaces custom github extension)
+extlinks = {
+    "ghissue": ("https://github.com/ipython/ipython/issues/%s/", "#%s"),
+    "ghpull": ("https://github.com/ipython/ipython/pull/%s/", "PR #%s"),
+}
 
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
 
-# The suffix of source filenames.
-source_suffix = '.txt'
+# Options for HTML output
+# -----------------------
+# - html_theme
+# - html_static_path
+#     Add any paths that contain custom static files (such as style sheets) here,
+#     relative to this directory. They are copied after the builtin static files,
+#     so a file named "default.css" will overwrite the builtin "default.css".
+#     Favicon needs the directory name
+# - html_favicon
+# - html_last_updated_fmt = config["html"]["html_last_updated_fmt"]
+#     If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+#     using the given strftime format.
+#     Output file base name for HTML help builder.
+# - htmlhelp_basename
 
-# The master toctree document.
-master_doc = 'index'
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
 
-# General substitutions.
-project = 'IPython'
-copyright = '2008, The IPython Development Team'
+# Options for LaTeX output
+# ------------------------
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, document class [howto/manual]).
+latex_documents = []
+
+
+# Options for texinfo output
+# --------------------------
+texinfo_documents = [
+    (
+        master_doc,
+        "ipython",
+        "IPython Documentation",
+        "The IPython Development Team",
+        "IPython",
+        "IPython Documentation",
+        "Programming",
+        1,
+    ),
+]
 
+#########################################################################
+# Custom configuration
 # The default replacements for |version| and |release|, also used in various
 # other places throughout the built documents.
 #
 # The full version, including alpha/beta/rc tags.
-release = iprelease['version']
-# The short X.Y version.
-version = '.'.join(release.split('.',2)[:2])
-
+release = "%s" % iprelease["version"]
+# Just the X.Y.Z part, no '-dev'
+version = iprelease["version"].split("-", 1)[0]
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
-#today = ''
+# today = ''
 # Else, today_fmt is used as the format for a strftime call.
-today_fmt = '%B %d, %Y'
-
-# List of documents that shouldn't be included in the build.
-#unused_docs = []
-
-# List of directories, relative to source directories, that shouldn't be searched
-# for source files.
-exclude_dirs = ['attic']
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
+today_fmt = "%B %d, %Y"
 
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#add_module_names = True
+rst_prolog = ""
 
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#show_authors = False
 
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+def is_stable(extra):
+    for ext in {"dev", "b", "rc"}:
+        if ext in extra:
+            return False
+    return True
 
 
-# Options for HTML output
-# -----------------------
-
-# The style sheet to use for HTML and HTML Help pages. A file of that name
-# must exist either in Sphinx' static/ path, or in one of the custom paths
-# given in html_static_path.
-html_style = 'default.css'
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# The name of an image file (within the static path) to place at the top of
-# the sidebar.
-#html_logo = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+if is_stable(iprelease["_version_extra"]):
+    tags.add("ipystable")
+    print("Adding Tag: ipystable")
+else:
+    tags.add("ipydev")
+    print("Adding Tag: ipydev")
+    rst_prolog += """
+.. warning::
 
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#html_additional_pages = {}
+    This documentation covers a development version of IPython. The development
+    version may differ significantly from the latest stable release.
+"""
 
-# If false, no module index is generated.
-#html_use_modindex = True
 
-# If true, the reST sources are included in the HTML build as _sources/<name>.
-#html_copy_source = True
 
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
+class ConfigtraitFilter(logging.Filter):
+    """
+    This is a filter to remove in sphinx 3+ the error about config traits being duplicated.
 
-# If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = ''
+    As we autogenerate configuration traits from, subclasses have lots of
+    duplication and we want to silence them. Indeed we build on travis with
+    warnings-as-error set to True, so those duplicate items make the build fail.
+    """
 
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'ipythondoc'
+    def filter(self, record):
+        if (
+            record.args
+            and record.args[0] == "configtrait"
+            and "duplicate" in record.msg
+        ):
+            return False
+        return True
 
 
-# Options for LaTeX output
-# ------------------------
-
-# The paper size ('letter' or 'a4').
-latex_paper_size = 'letter'
-
-# The font size ('10pt', '11pt' or '12pt').
-latex_font_size = '11pt'
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title, author, document class [howto/manual]).
-
-latex_documents = [
-    ('index', 'ipython.tex', 'IPython Documentation',
-     ur"""The IPython Development Team""", 'manual', True),
-    ('parallel/winhpc_index', 'winhpc_whitepaper.tex',
-     'Using IPython on Windows HPC Server 2008',
-     ur"Brian E. Granger", 'manual', True)
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-#latex_logo = None
+ct_filter = ConfigtraitFilter()
 
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#latex_use_parts = False
 
-# Additional stuff for the LaTeX preamble.
-#latex_preamble = ''
+logger = sphinx.util.logging.getLogger("sphinx.domains.std").logger
+logger.addFilter(ct_filter)
 
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
 
-# If false, no module index is generated.
-latex_use_modindex = True
+def setup(app):
+    app.add_css_file("theme_overrides.css")
 
 
 # Cleanup
diff --git a/docs/source/config/callbacks.rst b/docs/source/config/callbacks.rst
new file mode 100644
index 00000000000..60c7aba4a35
--- /dev/null
+++ b/docs/source/config/callbacks.rst
@@ -0,0 +1,113 @@
+.. _events:
+.. _callbacks:
+
+==============
+IPython Events
+==============
+
+Extension code can register callbacks functions which will be called on specific
+events within the IPython code. You can see the current list of available
+callbacks, and the parameters that will be passed with each, in the callback
+prototype functions defined in :mod:`IPython.core.events`.
+
+To register callbacks, use :meth:`IPython.core.events.EventManager.register`.
+For example::
+
+    class VarWatcher(object):
+        def __init__(self, ip):
+            self.shell = ip
+            self.last_x = None
+
+        def pre_execute(self):
+            self.last_x = self.shell.user_ns.get('x', None)
+
+        def pre_run_cell(self, info):
+            print('info.raw_cell =', info.raw_cell)
+            print('info.store_history =', info.store_history)
+            print('info.silent =', info.silent)
+            print('info.shell_futures =', info.shell_futures)
+            print('info.cell_id =', info.cell_id)
+            print(dir(info))
+
+        def post_execute(self):
+            if self.shell.user_ns.get('x', None) != self.last_x:
+                print("x changed!")
+
+        def post_run_cell(self, result):
+            print('result.execution_count = ', result.execution_count)
+            print('result.error_before_exec = ', result.error_before_exec)
+            print('result.error_in_exec = ', result.error_in_exec)
+            print('result.info = ', result.info)
+            print('result.result = ', result.result)
+
+    def load_ipython_extension(ip):
+        vw = VarWatcher(ip)
+        ip.events.register('pre_execute', vw.pre_execute)
+        ip.events.register('pre_run_cell', vw.pre_run_cell)
+        ip.events.register('post_execute', vw.post_execute)
+        ip.events.register('post_run_cell', vw.post_run_cell)
+
+.. versionadded:: 8.3
+
+   Since IPython 8.3 and ipykernel 6.12.1, the ``info`` objects in the callback
+   now have a the ``cell_id`` that will be set to the value sent by the
+   frontened, when those send it.
+
+
+
+Events
+======
+
+These are the events IPython will emit. Callbacks will be passed no arguments, unless otherwise specified.
+
+shell_initialized
+-----------------
+
+.. code-block:: python
+
+    def shell_initialized(ipython):
+        ...
+
+This event is triggered only once, at the end of setting up IPython.
+Extensions registered to load by default as part of configuration can use this to execute code to finalize setup.
+Callbacks will be passed the InteractiveShell instance.
+
+pre_run_cell
+------------
+
+``pre_run_cell`` fires prior to interactive execution (e.g. a cell in a notebook).
+It can be used to note the state prior to execution, and keep track of changes.
+An object containing information used for the code execution is provided as an argument.
+
+pre_execute
+-----------
+
+``pre_execute`` is like ``pre_run_cell``, but is triggered prior to *any* execution.
+Sometimes code can be executed by libraries, etc. which
+skipping the history/display mechanisms, in which cases ``pre_run_cell`` will not fire.
+
+post_run_cell
+-------------
+
+``post_run_cell`` runs after interactive execution (e.g. a cell in a notebook).
+It can be used to cleanup or notify or perform operations on any side effects produced during execution.
+For instance, the inline matplotlib backend uses this event to display any figures created but not explicitly displayed during the course of the cell.
+The object which will be returned as the execution result is provided as an
+argument.
+
+post_execute
+------------
+
+The same as ``pre_execute``, ``post_execute`` is like ``post_run_cell``,
+but fires for *all* executions, not just interactive ones.
+
+
+.. seealso::
+
+   Module :mod:`IPython.core.hooks`
+     The older 'hooks' system allows end users to customise some parts of
+     IPython's behaviour.
+   
+   :doc:`inputtransforms`
+     By registering input transformers that don't change code, you can monitor
+     what is being executed.
diff --git a/docs/source/config/custommagics.rst b/docs/source/config/custommagics.rst
new file mode 100644
index 00000000000..284fe026a98
--- /dev/null
+++ b/docs/source/config/custommagics.rst
@@ -0,0 +1,208 @@
+.. _defining_magics:
+
+Defining custom magics
+======================
+
+There are two main ways to define your own magic functions: from standalone
+functions and by inheriting from a base class provided by IPython:
+:class:`IPython.core.magic.Magics`. Below we show code you can place in a file
+that you load from your configuration, such as any file in the ``startup``
+subdirectory of your default IPython profile.
+
+First, let us see the simplest case. The following shows how to create a line
+magic, a cell one and one that works in both modes, using just plain functions:
+
+.. sourcecode:: python
+
+    from IPython.core.magic import (register_line_magic, register_cell_magic,
+                                    register_line_cell_magic)
+
+    @register_line_magic
+    def lmagic(line):
+        "my line magic"
+        return line
+
+    @register_cell_magic
+    def cmagic(line, cell):
+        "my cell magic"
+        return line, cell
+
+    @register_line_cell_magic
+    def lcmagic(line, cell=None):
+        "Magic that works both as %lcmagic and as %%lcmagic"
+        if cell is None:
+            print("Called as line magic")
+            return line
+        else:
+            print("Called as cell magic")
+            return line, cell
+
+    # In an interactive session, we need to delete these to avoid
+    # name conflicts for automagic to work on line magics.
+    del lmagic, lcmagic
+
+
+You can also create magics of all three kinds by inheriting from the
+:class:`IPython.core.magic.Magics` class.  This lets you create magics that can
+potentially hold state in between calls, and that have full access to the main
+IPython object:
+    
+.. sourcecode:: python
+
+    # This code can be put in any Python module, it does not require IPython
+    # itself to be running already.  It only creates the magics subclass but
+    # doesn't instantiate it yet.
+    from __future__ import print_function
+    from IPython.core.magic import (Magics, magics_class, line_magic,
+                                    cell_magic, line_cell_magic)
+
+    # The class MUST call this class decorator at creation time
+    @magics_class
+    class MyMagics(Magics):
+
+        @line_magic
+        def lmagic(self, line):
+            "my line magic"
+            print("Full access to the main IPython object:", self.shell)
+            print("Variables in the user namespace:", list(self.shell.user_ns.keys()))
+            return line
+
+        @cell_magic
+        def cmagic(self, line, cell):
+            "my cell magic"
+            return line, cell
+
+        @line_cell_magic
+        def lcmagic(self, line, cell=None):
+            "Magic that works both as %lcmagic and as %%lcmagic"
+            if cell is None:
+                print("Called as line magic")
+                return line
+            else:
+                print("Called as cell magic")
+                return line, cell
+
+
+    # In order to actually use these magics, you must register them with a
+    # running IPython.
+
+    def load_ipython_extension(ipython):
+        """
+        Any module file that define a function named `load_ipython_extension`
+        can be loaded via `%load_ext module.path` or be configured to be
+        autoloaded by IPython at startup time.
+        """
+        # You can register the class itself without instantiating it.  IPython will
+        # call the default constructor on it.
+        ipython.register_magics(MyMagics)
+
+If you want to create a class with a different constructor that holds
+additional state, then you should always call the parent constructor and
+instantiate the class yourself before registration:
+
+.. sourcecode:: python
+
+    @magics_class
+    class StatefulMagics(Magics):
+        "Magics that hold additional state"
+
+        def __init__(self, shell, data):
+            # You must call the parent constructor
+            super(StatefulMagics, self).__init__(shell)
+            self.data = data
+        
+        # etc...
+
+    def load_ipython_extension(ipython):
+        """
+        Any module file that define a function named `load_ipython_extension`
+        can be loaded via `%load_ext module.path` or be configured to be
+        autoloaded by IPython at startup time.
+        """
+        # This class must then be registered with a manually created instance,
+        # since its constructor has different arguments from the default:
+        magics = StatefulMagics(ipython, some_data)
+        ipython.register_magics(magics)
+
+
+.. note::
+
+   The legacy :func:`define_magic` API function has been removed.
+   Extensions should use the decorator-based API shown above.
+
+
+Accessing user namespace and local scope
+========================================
+
+When creating line magics, you may need to access surrounding scope  to get user
+variables (e.g when called inside functions). IPython provides the
+``@needs_local_scope`` decorator that can be imported from
+``IPython.core.magic``. When decorated with ``@needs_local_scope`` a magic will
+be passed ``local_ns`` as an argument. As a convenience ``@needs_local_scope``
+can also be applied to cell magics even if cell magics cannot appear at local
+scope context.
+
+Silencing the magic output
+==========================
+
+Sometimes it may be useful to define a magic that can be silenced the same way
+that non-magic expressions can, i.e., by appending a semicolon at the end of the Python
+code to be executed. That can be achieved by decorating the magic function with
+the decorator ``@output_can_be_silenced`` that can be imported from
+``IPython.core.magic``. When this decorator is used, IPython will parse the Python
+code used by the magic and, if the last token is a ``;``, the output created by the
+magic will not show up on the screen. If you want to see an example of this decorator
+in action, take a look on the ``time`` magic defined in
+``IPython.core.magics.execution.py``.
+
+Complete Example
+================
+
+Here is a full example of a magic package. You can distribute magics using
+setuptools, distutils, or any other distribution tools like `flit
+<https://flit.readthedocs.io>`_ for pure Python packages.
+
+When distributing magics as part of a package, recommended best practice is to
+execute the registration inside the `load_ipython_extension` as demonstrated in
+the example below, instead of directly in the module (as in the initial example
+with the ``@register_*`` decorators). This means a user will need to explicitly
+choose to load your magic with ``%load_ext``. instead implicitly getting it when
+importing the module. This is particularly relevant if loading your magic has 
+side effects, if it is slow to load, or if it might override another magic with
+the same name. 
+
+.. sourcecode:: bash
+
+   .
+   ├── example_magic
+   │   ├── __init__.py
+   │   └── abracadabra.py
+   └── setup.py
+
+.. sourcecode:: bash
+
+   $ cat example_magic/__init__.py
+   """An example magic"""
+   __version__ = '0.0.1'
+   
+   from .abracadabra import Abracadabra
+   
+   def load_ipython_extension(ipython):
+       ipython.register_magics(Abracadabra)
+
+.. sourcecode:: bash
+
+    $ cat example_magic/abracadabra.py
+    from IPython.core.magic import (Magics, magics_class, line_magic, cell_magic)
+
+    @magics_class
+    class Abracadabra(Magics):
+
+        @line_magic
+        def abra(self, line):
+            return line
+
+        @cell_magic
+        def cadabra(self, line, cell):
+            return line, cell
+
diff --git a/docs/source/config/details.rst b/docs/source/config/details.rst
new file mode 100644
index 00000000000..0d92622e61e
--- /dev/null
+++ b/docs/source/config/details.rst
@@ -0,0 +1,457 @@
+==============================
+Specific configuration details
+==============================
+
+.. _llm_suggestions:
+
+LLM Suggestions
+===============
+
+Starting with 9.0, IPython will be able to use LLM providers to suggest code in
+the terminal. This requires a recent version of prompt_toolkit in order to allow
+multiline suggestions. There are currently a number of limitations, and feedback
+on the API is welcome.
+
+Unlike many of IPython features, this is not enabled by default and requires
+multiple configuration options to be set to properly work:
+
+ - Set a keybinding to trigger LLM suggestions. Due to terminal limitations
+   across platforms and emulators, it is difficult to provide a default
+   keybinding. Note that not all keybindings are availables, in particular all
+   the `Ctrl-Enter`, `Alt-backslash` and `Ctrl-Shift-Enter` are not available
+   without integration with your terminal emulator.
+
+ - Chose a LLM `provider`, usually from Jupyter-AI. This will be the interface
+   between IPython itself, and the LLM – that may be local or in on a server.
+
+ - Configure said provider with models, API keys, etc – this will depend on the
+   provider, and you will have to refer to Jupyter-AI documentation, and/or your
+   LLM documenatation.
+
+
+While setting up IPython to use a real LLM, you can refer to
+``examples/auto_suggest_llm.py`` that both provide an example of how to set up
+IPython to use a Fake LLM provider, this can help ensure that the full setup is
+working before switching to a real LLM provider.
+
+
+Setup a keybinding
+------------------
+
+You may want to refer on how to setup a keybinding in IPython, but in short you
+want to bind the ``IPython:auto_suggest.llm_autosuggestion`` command to a
+keybinding, and have it active only when the default buffer isi focused, and
+when using the NavigableSuggestions suggestter (this is the default suggestter,
+the one that is history and LLM aware). Thus the ``navigable_suggestions &
+default_buffer_focused`` filter should be used.
+
+Usually ``Ctrl-Q`` on macos is an available shortcut, note that is does use
+``Ctrl``, and not ``Command``.
+
+The following example will bind ``Ctrl-Q`` to the ``llm_autosuggestion``
+command, with the suggested filter::
+
+    c.TerminalInteractiveShell.shortcuts = [
+        {
+            "new_keys": ["c-q"],
+            "command": "IPython:auto_suggest.llm_autosuggestion",
+            "new_filter": "navigable_suggestions & default_buffer_focused",
+            "create": True,
+        },
+    ]
+
+
+Choose a LLM provider
+---------------------
+
+Set the  ``TerminalInteractiveShell.llm_provider_class`` trait to the fully
+qualified name of the Provider you like, when testing from inside the IPython
+source tree, you can use
+``"examples.auto_suggest_llm.ExampleCompletionProvider"`` This will always
+stream an extract of the Little Prince by Antoine de Saint-Exupéry, and will not
+require any API key or real LLM.
+
+
+In your configuration file adapt the following line to your needs:
+
+.. code-block:: python
+
+    c.TerminalInteractiveShell.llm_provider_class = "examples.auto_suggest_llm.ExampleCompletionProvider"
+
+Configure the provider
+----------------------
+
+It the provider needs to be passed parameters at initialization, you can do so
+by setting the ``llm_construction_kwargs`` traitlet.
+
+.. code-block:: python
+
+    c.TerminalInteractiveShell.llm_constructor_kwargs = {"model": "skynet"}
+
+This will depdend on the provider you chose, and you will have to refer to
+the provider documentation.
+
+Extra configuration may be needed by setting environment variables, this will
+again depend on the provider you chose, and you will have to refer to the
+provider documentation.
+
+LLM Context
+-----------
+
+The option ``c.TerminalInteractiveShell.llm_prefix_from_history`` controls the
+context the ``Provider`` gets when trying to complete. See the help of this
+options (``ipython --help-all``)::
+
+    Fully Qualifed name of a function that takes an IPython history manager and
+    return a prefix to pass the llm provider in addition to the current buffer
+    text.
+
+    You can use:
+
+     - no_prefix
+     - input_history
+
+    As default value. `input_history` (default),  will use all the input history
+    of current IPython session
+
+
+
+
+
+
+.. _custom_prompts:
+
+Custom Prompts
+==============
+
+.. versionchanged:: 5.0
+
+From IPython 5, prompts are produced as a list of Pygments tokens, which are
+tuples of (token_type, text). You can customise prompts by writing a method
+which generates a list of tokens.
+
+There are four kinds of prompt:
+
+* The **in** prompt is shown before the first line of input
+  (default like ``In [1]:``).
+* The **continuation** prompt is shown before further lines of input
+  (default like ``...:``).
+* The **rewrite** prompt is shown to highlight how special syntax has been
+  interpreted (default like ``----->``).
+* The **out** prompt is shown before the result from evaluating the input
+  (default like ``Out[1]:``).
+
+Custom prompts are supplied together as a class. If you want to customise only
+some of the prompts, inherit from :class:`IPython.terminal.prompts.Prompts`,
+which defines the defaults. The required interface is like this:
+
+.. class:: MyPrompts(shell)
+
+   Prompt style definition. *shell* is a reference to the
+   :class:`~.TerminalInteractiveShell` instance.
+
+   .. method:: in_prompt_tokens()
+               continuation_prompt_tokens(self, width=None)
+               rewrite_prompt_tokens()
+               out_prompt_tokens()
+
+      Return the respective prompts as lists of ``(token_type, text)`` tuples.
+
+      For continuation prompts, *width* is an integer representing the width of
+      the prompt area in terminal columns.
+
+
+Here is an example Prompt class that will show the current working directory
+in the input prompt:
+
+.. code-block:: python
+
+    from IPython.terminal.prompts import Prompts, Token
+    import os
+
+    class MyPrompt(Prompts):
+         def in_prompt_tokens(self):
+             return [(Token, os.getcwd()),
+                     (Token.Prompt, ' >>>')]
+
+To set the new prompt, assign it to the ``prompts`` attribute of the IPython
+shell:
+
+.. code-block:: python
+
+    In [2]: ip = get_ipython()
+       ...: ip.prompts = MyPrompt(ip)
+
+    /home/bob >>> # it works
+
+See ``IPython/example/utils/cwd_prompt.py`` for an example of how to write
+extensions to customise prompts.
+
+Inside IPython or in a startup script, you can use a custom prompts class
+by setting ``get_ipython().prompts`` to an *instance* of the class.
+In configuration, ``TerminalInteractiveShell.prompts_class`` may be set to
+either the class object, or a string of its full importable name.
+
+To include invisible terminal control sequences in a prompt, use
+``Token.ZeroWidthEscape`` as the token type. Tokens with this type are ignored
+when calculating the width.
+
+Colours in the prompt are determined by the token types and the highlighting
+style; see below for more details. The tokens used in the default prompts are
+``Prompt``, ``PromptNum``, ``OutPrompt`` and ``OutPromptNum``.
+
+.. _termcolour:
+
+Terminal Colors
+===============
+
+.. versionchanged:: 9.0
+
+IPython 9.0 changed almost all of the  color handling, which is now referred to
+as **themes**. A Theme can do a bit more than purely colors, as it can handle
+bold, italic and basically any style that ``pygments`` support.  Themes also
+support a number of ``Symbols``, which allows you to – for example – change the
+shape of the arrow that mark the current frame and line numbers in the debugger
+and the tracebacks. 
+
+Most of the various IPython options that were used pre 9.0 have been renamed,
+with a exceptions a few, and most classes  that deal with themes can, now take a
+``theme_name`` parameter.
+
+To reflect this, the  ``--colors`` flag now is also aliased to ``--theme``.
+
+The default themes included are the same, except lowercase, for ease of typing. 
+
+``'nocolor', 'neutral', 'linux', 'lightbg', 'gruvbox-dark'``, with the addition of ``'pride'``
+to celebrate the inclusively of this project (I welcome update to the pride
+theme as I'm not a designer myself). 
+
+In addition, the ``--theme=pride`` theme, is the first to make use of unicode
+symbols for the traceback separation line, and the debugger and traceback arrow, 
+as well as making some use of ``bold``, and ``italic`` formatting, and not limit
+itself to the 16 base ANSI colors.
+
+Theme details
+-------------
+
+We encourage you to contribute themes, and to distribute them, 
+while currently you need to modify source code to add a theme, it should be
+possible to load theme from Json, Yaml, or any other declarative file type. 
+
+Since IPython 9.0, most of IPython internal code emit a sequence of `(Token
+Type, string)`, which is fed through pygments, and a theme is mapping from those
+token types to a style. For example: ``Token.Prompt : '#ansired underline'``, or
+``Token.Filename : 'bg:#A30262``.
+
+For simplicity, a theme can be derived from from a pygments style (which will
+give the basic code highlighting).
+
+A theme can also define a few symbols (see the source for how), for example
+``arrow_body``, and ``arrow_head``, can help customising line indicators.
+
+
+
+Colors in the pager
+-------------------
+
+On some systems, the default pager has problems with ANSI colour codes.
+To configure your default pager to allow these:
+
+1. Set the environment PAGER variable to ``less``.
+2. Set the environment LESS variable to ``-r`` (plus any other options
+   you always want to pass to less by default). This tells less to
+   properly interpret control sequences, which is how color
+   information is given to your terminal.
+
+.. _editors:
+
+Editor configuration
+====================
+
+IPython can integrate with text editors in a number of different ways:
+
+* Editors (such as `(X)Emacs`_, vim_ and TextMate_) can
+  send code to IPython for execution.
+
+* IPython's ``%edit`` magic command can open an editor of choice to edit
+  a code block.
+
+The %edit command (and its alias %ed) will invoke the editor set in your
+environment as :envvar:`EDITOR`. If this variable is not set, it will default
+to vi under Linux/Unix and to notepad under Windows. You may want to set this
+variable properly and to a lightweight editor which doesn't take too long to
+start (that is, something other than a new instance of Emacs). This way you
+can edit multi-line code quickly and with the power of a real editor right
+inside IPython.
+
+You can also control the editor by setting :attr:`TerminalInteractiveShell.editor`
+in :file:`ipython_config.py`.
+
+Vim
+---
+
+Paul Ivanov's `vim-ipython <https://github.com/ivanov/vim-ipython>`_ provides
+powerful IPython integration for vim.
+
+.. _emacs:
+
+(X)Emacs
+--------
+
+If you are a dedicated Emacs user, and want to use Emacs when IPython's
+``%edit`` magic command is called you should set up the Emacs server so that
+new requests are handled by the original process. This means that almost no
+time is spent in handling the request (assuming an Emacs process is already
+running). For this to work, you need to set your EDITOR environment variable
+to 'emacsclient'. The code below, supplied by Francois Pinard, can then be
+used in your :file:`.emacs` file to enable the server:
+
+.. code-block:: common-lisp
+
+    (defvar server-buffer-clients)
+    (when (and (fboundp 'server-start) (string-equal (getenv "TERM") 'xterm))
+      (server-start)
+      (defun fp-kill-server-with-buffer-routine ()
+        (and server-buffer-clients (server-done)))
+      (add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine))
+
+Thanks to the work of Alexander Schmolck and Prabhu Ramachandran,
+currently (X)Emacs and IPython get along very well in other ways.
+
+With (X)EMacs >= 24, You can enable IPython in python-mode with:
+
+.. code-block:: common-lisp
+
+    (require 'python)
+    (setq python-shell-interpreter "ipython")
+
+.. _`(X)Emacs`: http://www.gnu.org/software/emacs/
+.. _TextMate: http://macromates.com/
+.. _vim: http://www.vim.org/
+
+.. _custom_keyboard_shortcuts:
+
+Keyboard Shortcuts
+==================
+
+.. versionadded:: 8.11
+
+You can modify, disable or modify keyboard shortcuts for IPython Terminal using
+:std:configtrait:`TerminalInteractiveShell.shortcuts` traitlet.
+
+The list of shortcuts is available in the Configuring IPython :ref:`terminal-shortcuts-list` section.
+
+Advanced configuration
+----------------------
+
+.. versionchanged:: 5.0
+
+Creating custom commands requires adding custom code to a
+:ref:`startup file <startup_files>`::
+
+    from IPython import get_ipython
+    from prompt_toolkit.enums import DEFAULT_BUFFER
+    from prompt_toolkit.keys import Keys
+    from prompt_toolkit.filters import HasFocus, HasSelection, ViInsertMode, EmacsInsertMode
+
+    ip = get_ipython()
+    insert_mode = ViInsertMode() | EmacsInsertMode()
+
+    def insert_unexpected(event):
+        buf = event.current_buffer
+        buf.insert_text('The Spanish Inquisition')
+    # Register the shortcut if IPython is using prompt_toolkit
+    if getattr(ip, 'pt_app', None):
+        registry = ip.pt_app.key_bindings
+        registry.add_binding(Keys.ControlN,
+                         filter=(HasFocus(DEFAULT_BUFFER)
+                                 & ~HasSelection()
+                                 & insert_mode))(insert_unexpected)
+
+
+Here is a second example that bind the key sequence ``j``, ``k`` to switch to
+VI input mode to ``Normal`` when in insert mode::
+
+   from IPython import get_ipython
+   from prompt_toolkit.enums import DEFAULT_BUFFER
+   from prompt_toolkit.filters import HasFocus, ViInsertMode
+   from prompt_toolkit.key_binding.vi_state import InputMode
+
+   ip = get_ipython()
+
+   def switch_to_navigation_mode(event):
+      vi_state = event.cli.vi_state
+      vi_state.input_mode = InputMode.NAVIGATION
+
+   if getattr(ip, 'pt_app', None):
+      registry = ip.pt_app.key_bindings
+      registry.add_binding(u'j',u'k',
+                           filter=(HasFocus(DEFAULT_BUFFER)
+                                    & ViInsertMode()))(switch_to_navigation_mode)
+
+For more information on filters and what you can do with the ``event`` object,
+`see the prompt_toolkit docs
+<https://python-prompt-toolkit.readthedocs.io/en/latest/pages/asking_for_input.html#adding-custom-key-bindings>`__.
+
+
+Enter to execute
+----------------
+
+In the Terminal IPython shell – which by default uses the ``prompt_toolkit``
+interface, the semantic meaning of pressing the :kbd:`Enter` key can be
+ambiguous. In some case :kbd:`Enter` should execute code, and in others it
+should add a new line. IPython uses heuristics to decide whether to execute or
+insert a new line at cursor position. For example, if we detect that the current
+code is not valid Python, then the user is likely editing code and the right
+behavior is to likely to insert a new line. If the current code is a simple
+statement like `ord('*')`, then the right behavior is likely to execute. Though
+the exact desired semantics often varies from users to users.
+
+As the exact behavior of :kbd:`Enter` is ambiguous, it has been special cased
+to allow users to completely configure the behavior they like. Hence you can
+have enter always execute code. If you prefer fancier behavior, you need to get
+your hands dirty and read the ``prompt_toolkit`` and IPython documentation
+though. See :ghpull:`10500`, set the
+``c.TerminalInteractiveShell.handle_return`` option and get inspiration from the
+following example that only auto-executes the input if it begins with a bang or
+a modulo character (``!`` or ``%``). To use the following code, add it to your
+IPython configuration::
+
+    def custom_return(shell):
+
+        """This function is required by the API. It takes a reference to
+        the shell, which is the same thing `get_ipython()` evaluates to.
+        This function must return a function that handles each keypress
+        event. That function, named `handle` here, references `shell`
+        by closure."""
+
+        def handle(event):
+
+            """This function is called each time `Enter` is pressed,
+            and takes a reference to a Prompt Toolkit event object.
+            If the current input starts with a bang or modulo, then
+            the input is executed, otherwise a newline is entered,
+            followed by any spaces needed to auto-indent."""
+
+            # set up a few handy references to nested items...
+
+            buffer = event.current_buffer
+            document = buffer.document
+            text = document.text
+
+            if text.startswith('!') or text.startswith('%'): # execute the input...
+
+                buffer.accept_action.validate_and_handle(event.cli, buffer)
+
+            else: # insert a newline with auto-indentation...
+
+                if document.line_count > 1: text = text[:document.cursor_position]
+                indent = shell.check_complete(text)[1]
+                buffer.insert_text('\n' + indent)
+            
+                # if you just wanted a plain newline without any indentation, you
+                # could use `buffer.insert_text('\n')` instead of the lines above
+
+        return handle
+
+    c.TerminalInteractiveShell.handle_return = custom_return
diff --git a/docs/source/config/editors.txt b/docs/source/config/editors.txt
deleted file mode 100644
index bda308bfe35..00000000000
--- a/docs/source/config/editors.txt
+++ /dev/null
@@ -1,117 +0,0 @@
-.. _editors:
-
-====================
-Editor configuration
-====================
-
-IPython can integrate with text editors in a number of different ways:
-
-* Editors (such as (X)Emacs [Emacs]_, vim [vim]_ and TextMate [TextMate]_) can
-  send code to IPython for execution.
-
-* IPython's ``%edit`` magic command can open an editor of choice to edit
-  a code block.
-
-The %edit command (and its alias %ed) will invoke the editor set in your
-environment as :envvar:`EDITOR`. If this variable is not set, it will default
-to vi under Linux/Unix and to notepad under Windows. You may want to set this
-variable properly and to a lightweight editor which doesn't take too long to
-start (that is, something other than a new instance of Emacs). This way you
-can edit multi-line code quickly and with the power of a real editor right
-inside IPython.
-
-You can also control the editor via the commmand-line option '-editor' or in
-your configuration file, by setting the :attr:`InteractiveShell.editor`
-configuration attribute.
-
-TextMate
-========
-
-Currently, TextMate support in IPython is broken.  It used to work well,
-but the code has been moved to :mod:`IPython.quarantine` until it is updated.
-
-vim configuration
-=================
-
-Currently, vim support in IPython is broken.  Like the TextMate code,
-the vim support code has been moved to :mod:`IPython.quarantine` until it
-is updated.
-
-.. _emacs:
-
-(X)Emacs
-========
-
-Editor
-======
-
-If you are a dedicated Emacs user, and want to use Emacs when IPython's
-``%edit`` magic command is called you should set up the Emacs server so that
-new requests are handled by the original process. This means that almost no
-time is spent in handling the request (assuming an Emacs process is already
-running). For this to work, you need to set your EDITOR environment variable
-to 'emacsclient'. The code below, supplied by Francois Pinard, can then be
-used in your :file:`.emacs` file to enable the server::
-
-    (defvar server-buffer-clients)
-    (when (and (fboundp 'server-start) (string-equal (getenv "TERM") 'xterm))
-      (server-start)
-      (defun fp-kill-server-with-buffer-routine ()
-        (and server-buffer-clients (server-done)))
-      (add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine))
-
-Thanks to the work of Alexander Schmolck and Prabhu Ramachandran,
-currently (X)Emacs and IPython get along very well in other ways.
-
-.. note::
-
-    You will need to use a recent enough version of :file:`python-mode.el`,
-    along with the file :file:`ipython.el`. You can check that the version you
-    have of :file:`python-mode.el` is new enough by either looking at the
-    revision number in the file itself, or asking for it in (X)Emacs via ``M-x
-    py-version``. Versions 4.68 and newer contain the necessary fixes for
-    proper IPython support.
-
-The file :file:`ipython.el` is included with the IPython distribution, in the
-directory :file:`docs/emacs`. Once you put these files in your Emacs path, all
-you need in your :file:`.emacs` file is::
-
-    (require 'ipython)
-
-This should give you full support for executing code snippets via
-IPython, opening IPython as your Python shell via ``C-c !``, etc.
-
-You can customize the arguments passed to the IPython instance at startup by
-setting the ``py-python-command-args`` variable.  For example, to start always
-in ``pylab`` mode with hardcoded light-background colors, you can use::
-
-    (setq py-python-command-args '("-pylab" "-colors" "LightBG"))
-
-If you happen to get garbage instead of colored prompts as described in
-the previous section, you may need to set also in your :file:`.emacs` file::
-
-    (setq ansi-color-for-comint-mode t)
-
-Notes on emacs support:
-
-* There is one caveat you should be aware of: you must start the IPython shell
-  before attempting to execute any code regions via ``C-c |``. Simply type
-  ``C-c !`` to start IPython before passing any code regions to the
-  interpreter, and you shouldn't experience any problems. This is due to a bug
-  in Python itself, which has been fixed for Python 2.3, but exists as of
-  Python 2.2.2 (reported as SF bug [ 737947 ]).
-
-* The (X)Emacs support is maintained by Alexander Schmolck, so all
-  comments/requests should be directed to him through the IPython mailing
-  lists.
-
-* This code is still somewhat experimental so it's a bit rough around the
-  edges (although in practice, it works quite well).
-
-* Be aware that if you customized ``py-python-command`` previously, this value
-  will override what :file:`ipython.el` does (because loading the customization
-  variables comes later).
-
-.. [Emacs] Emacs. http://www.gnu.org/software/emacs/
-.. [TextMate] TextMate: the missing editor.  http://macromates.com/
-.. [vim] vim. http://www.vim.org/
diff --git a/docs/source/config/eventloops.rst b/docs/source/config/eventloops.rst
new file mode 100644
index 00000000000..113f0e26e5d
--- /dev/null
+++ b/docs/source/config/eventloops.rst
@@ -0,0 +1,112 @@
+================================
+Integrating with GUI event loops
+================================
+
+When the user types ``%gui qt``, IPython integrates itself with the Qt event
+loop, so you can use both a GUI and an interactive prompt together. IPython
+supports a number of common GUI toolkits, and it is possible to integrate
+other event loops without modifying IPython itself.
+
+Supported event loops include ``qt5``, ``qt6``, ``gtk2``, ``gtk3``, ``gtk4``,
+``wx``, ``osx`` and ``tk``. Make sure the event loop you specify matches the
+GUI toolkit used by your own code.
+
+.. note::
+
+   ``gtk2`` is deprecated and GTK3 or GTK4 should be used instead for new projects.
+
+To make IPython GUI event loop integration occur automatically at every
+startup, set the ``c.InteractiveShellApp.gui`` configuration key in your
+IPython profile (see :ref:`setting_config`).
+
+If the event loop you use is supported by IPython, turning on event loop
+integration follows the steps just described whether you use Terminal IPython
+or an IPython kernel.
+
+However, the way Terminal IPython handles event loops is very different from
+the way IPython kernel does, so if you need to integrate with a new kind of
+event loop, different steps are needed to integrate with each.
+
+Integrating with a new event loop in the terminal
+-------------------------------------------------
+
+.. versionchanged:: 5.0
+
+   There is a new API for event loop integration using prompt_toolkit.
+
+In the terminal, IPython uses prompt_toolkit to prompt the user for input.
+prompt_toolkit provides hooks to integrate with an external event loop.
+
+To integrate an event loop, define a function which runs the GUI event loop
+until there is input waiting for prompt_toolkit to process. There are two ways
+to detect this condition::
+
+    # Polling for input.
+    def inputhook(context):
+        while not context.input_is_ready():
+            # Replace this with the appropriate call for the event loop:
+            iterate_loop_once()
+
+    # Using a file descriptor to notify the event loop to stop.
+    def inputhook2(context):
+        fd = context.fileno()
+        # Replace the functions below with those for the event loop.
+        add_file_reader(fd, callback=stop_the_loop)
+        run_the_loop()
+
+Once you have defined this function, register it with IPython:
+
+.. currentmodule:: IPython.terminal.pt_inputhooks
+
+.. function:: register(name, inputhook)
+
+   Register the function *inputhook* as the event loop integration for the
+   GUI *name*. If ``name='foo'``, then the user can enable this integration
+   by running ``%gui foo``.
+
+
+Integrating with a new event loop in the kernel
+-----------------------------------------------
+
+The kernel runs its own event loop, so it's simpler to integrate with others.
+IPython allows the other event loop to take control, but it must call
+:meth:`IPython.kernel.zmq.kernelbase.Kernel.do_one_iteration` periodically.
+
+To integrate with this, write a function that takes a single argument,
+the IPython kernel instance, arranges for your event loop to call
+``kernel.do_one_iteration()`` at least every ``kernel._poll_interval`` seconds,
+and starts the event loop.
+
+Decorate this function with :func:`IPython.kernel.zmq.eventloops.register_integration`,
+passing in the names you wish to register it for. Here is a slightly simplified
+version of the Tkinter integration already included in IPython::
+
+    @register_integration('tk')
+    def loop_tk(kernel):
+        """Start a kernel with the Tk event loop."""
+        from tkinter import Tk
+
+        # Tk uses milliseconds
+        poll_interval = int(1000*kernel._poll_interval)
+        # For Tkinter, we create a Tk object and call its withdraw method.
+        class Timer(object):
+            def __init__(self, func):
+                self.app = Tk()
+                self.app.withdraw()
+                self.func = func
+
+            def on_timer(self):
+                self.func()
+                self.app.after(poll_interval, self.on_timer)
+
+            def start(self):
+                self.on_timer()  # Call it once to get things going.
+                self.app.mainloop()
+
+        kernel.timer = Timer(kernel.do_one_iteration)
+        kernel.timer.start()
+
+Some event loops can go one better, and integrate checking for messages on the
+kernel's ZMQ sockets, making the kernel more responsive than plain polling. How
+to do this is outside the scope of this document; if you are interested, look at
+the integration with Qt in :mod:`IPython.kernel.zmq.eventloops`.
diff --git a/docs/source/config/extensions.txt b/docs/source/config/extensions.txt
deleted file mode 100644
index d3297116465..00000000000
--- a/docs/source/config/extensions.txt
+++ /dev/null
@@ -1,61 +0,0 @@
-.. _extensions_overview:
-
-==================
-IPython extensions
-==================
-
-Configuration files are just the first level of customization that IPython
-supports. The next level is that of extensions. An IPython extension is an
-importable Python module that has a a few special function. By defining these
-functions, users can customize IPython by accessing the actual runtime objects
-of IPython.  Here is a sample extension::
-
-    # myextension.py
-
-    def load_ipython_extension(ipython):
-        # The ``ipython`` argument is the currently active 
-        # :class:`InteractiveShell` instance that can be used in any way.
-        # This allows you do to things like register new magics, plugins or
-        # aliases.
-
-    def unload_ipython_extension(ipython):
-        # If you want your extension to be unloadable, put that logic here.
-
-This :func:`load_ipython_extension` function is called after your extension is
-imported and the currently active :class:`InteractiveShell` instance is passed
-as the only argument. You can do anything you want with IPython at that point.
-
-The :func:`load_ipython_extension` will be called again is you load or reload
-the extension again. It is up to the extension author to add code to manage
-that.
-
-You can put your extension modules anywhere you want, as long as they can be
-imported by Python's standard import mechanism. However, to make it easy to
-write extensions, you can also put your extensions in
-``os.path.join(self.ipython_dir, 'extensions')``. This directory is added to
-``sys.path`` automatically.
-
-Using extensions
-================
-
-There are two ways you can tell IPython to use your extension:
-
-1. Listing it in a configuration file.
-2. Using the ``%load_ext`` magic function.
-
-To load an extension called :file:`myextension.py` add the following logic
-to your configuration file::
-
-    c.Global.extensions = [
-        'myextension'
-    ]
-
-To load that same extension at runtime, use the ``%load_ext`` magic::
-
-.. sourcecode:: ipython
-
-    In [1]: %load_ext myextension
-
-To summarize, in conjunction with configuration files and profiles, IPython
-extensions give you complete and flexible control over your IPython
-setup.
diff --git a/docs/source/config/extensions/autoreload.rst b/docs/source/config/extensions/autoreload.rst
new file mode 100644
index 00000000000..3b354898298
--- /dev/null
+++ b/docs/source/config/extensions/autoreload.rst
@@ -0,0 +1,9 @@
+.. _extensions_autoreload:
+
+==========
+autoreload
+==========
+
+.. magic:: autoreload
+
+.. automodule:: IPython.extensions.autoreload
diff --git a/docs/source/config/extensions/index.rst b/docs/source/config/extensions/index.rst
new file mode 100644
index 00000000000..71e979dce24
--- /dev/null
+++ b/docs/source/config/extensions/index.rst
@@ -0,0 +1,99 @@
+.. _extensions_overview:
+
+==================
+IPython extensions
+==================
+
+A level above configuration are IPython extensions, Python modules which modify
+the behaviour of the shell. They are referred to by an importable module name,
+and can be placed anywhere you'd normally import from.
+
+Getting extensions
+==================
+
+A few important extensions are :ref:`bundled with IPython <bundled_extensions>`.
+Others can be found on the `extensions index
+<https://github.com/ipython/ipython/wiki/Extensions-Index>`_ on the wiki, and
+the `Framework :: IPython tag <https://pypi.python.org/pypi?:action=browse&c=586>`_
+on PyPI.
+
+Extensions on PyPI can be installed using ``pip``, like any other Python package.
+
+Using extensions
+================
+
+To load an extension while IPython is running, use the ``%load_ext`` magic:
+
+.. sourcecode:: ipython
+
+    In [1]: %load_ext myextension
+
+To load it each time IPython starts, list it in your configuration file::
+
+    c.InteractiveShellApp.extensions = [
+        'myextension'
+    ]
+
+Writing extensions
+==================
+
+An IPython extension is an importable Python module that has a couple of special
+functions to load and unload it. Here is a template::
+
+    # myextension.py
+
+    def load_ipython_extension(ipython):
+        # The `ipython` argument is the currently active `InteractiveShell`
+        # instance, which can be used in any way. This allows you to register
+        # new magics or aliases, for example.
+
+    def unload_ipython_extension(ipython):
+        # If you want your extension to be unloadable, put that logic here.
+
+This :func:`load_ipython_extension` function is called after your extension is
+imported, and the currently active :class:`~IPython.core.interactiveshell.InteractiveShell`
+instance is passed as the only argument. You can do anything you want with
+IPython at that point.
+
+:func:`load_ipython_extension` will not be called again if the users use
+`%load_extension`.  The user has to explicitly ask the extension to be
+reloaded (with `%reload_extension`). In cases where the user asks the extension to
+be reloaded, the extension will be unloaded (with
+`unload_ipython_extension`), and loaded again. 
+
+Useful :class:`InteractiveShell` methods include :meth:`~IPython.core.interactiveshell.InteractiveShell.register_magic_function`, 
+:meth:`~IPython.core.interactiveshell.InteractiveShell.push` (to add variables to the user namespace) and 
+:meth:`~IPython.core.interactiveshell.InteractiveShell.drop_by_id` (to remove variables on unloading).
+
+.. seealso::
+
+   :ref:`defining_magics`
+
+You can put your extension modules anywhere you want, as long as they can be
+imported by Python's standard import mechanism.
+
+When your extension is ready for general use, please add it to the `extensions
+index <https://github.com/ipython/ipython/wiki/Extensions-Index>`_. We also
+encourage you to upload it to PyPI and use the ``Framework :: IPython``
+classifier, so that users can install it with standard packaging tools.
+
+.. _bundled_extensions:
+
+Extensions bundled with IPython
+===============================
+
+.. toctree::
+   :maxdepth: 1
+
+   autoreload
+   storemagic
+
+* ``octavemagic`` used to be bundled, but is now part of `oct2py <https://blink1073.github.io/oct2py/>`_.
+  Use ``%load_ext oct2py.ipython`` to load it.
+* ``rmagic`` is now part of `rpy2 <https://rpy2.github.io/>`_. Use
+  ``%load_ext rpy2.ipython`` to load it, and see :mod:`rpy2.ipython.rmagic` for
+  details of how to use it.
+* ``cythonmagic`` used to be bundled, but is now part of `cython <https://github.com/cython/cython/>`_
+  Use ``%load_ext Cython`` to load it.
+* ``sympyprinting`` used to be a bundled extension, but you should now use
+  :func:`sympy.init_printing` instead.
diff --git a/docs/source/config/extensions/storemagic.rst b/docs/source/config/extensions/storemagic.rst
new file mode 100644
index 00000000000..5037e3d3563
--- /dev/null
+++ b/docs/source/config/extensions/storemagic.rst
@@ -0,0 +1,9 @@
+.. _extensions_storemagic:
+
+==========
+storemagic
+==========
+
+.. automodule:: IPython.extensions.storemagic
+
+.. automethod:: StoreMagics.store
diff --git a/docs/source/config/index.rst b/docs/source/config/index.rst
new file mode 100644
index 00000000000..28e6994cc21
--- /dev/null
+++ b/docs/source/config/index.rst
@@ -0,0 +1,35 @@
+.. _config_index:
+
+===============================
+Configuration and customization
+===============================
+
+Configuring IPython
+-------------------
+
+.. toctree::
+   :maxdepth: 2
+
+   intro
+   options/index
+   shortcuts/index
+   details
+
+.. seealso::
+
+   :doc:`/development/config`
+      Technical details of the config system.
+
+Extending and integrating with IPython
+--------------------------------------
+
+.. toctree::
+   :maxdepth: 2
+
+   extensions/index
+   integrating
+   custommagics
+   shell_mimerenderer
+   inputtransforms
+   callbacks
+   eventloops
diff --git a/docs/source/config/index.txt b/docs/source/config/index.txt
deleted file mode 100644
index 0ceaf335229..00000000000
--- a/docs/source/config/index.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-.. _config_index:
-
-===============================
-Configuration and customization
-===============================
-
-.. toctree::
-   :maxdepth: 2
-
-   overview.txt
-   extensions.txt
-   plugins.txt
-   ipython.txt
-   editors.txt
-   old.txt
diff --git a/docs/source/config/inputtransforms.rst b/docs/source/config/inputtransforms.rst
new file mode 100644
index 00000000000..222d113d1cf
--- /dev/null
+++ b/docs/source/config/inputtransforms.rst
@@ -0,0 +1,90 @@
+
+===========================
+Custom input transformation
+===========================
+
+IPython extends Python syntax to allow things like magic commands, and help with
+the ``?`` syntax. There are several ways to customise how the user's input is
+processed into Python code to be executed.
+
+These hooks are mainly for other projects using IPython as the core of their
+interactive interface. Using them carelessly can easily break IPython!
+
+String based transformations
+============================
+
+.. currentmodule:: IPython.core.inputtransformers2
+
+When the user enters code, it is first processed as a string. By the
+end of this stage, it must be valid Python syntax.
+
+.. versionchanged:: 7.0
+
+   The API for string and token-based transformations has been completely
+   redesigned. Any third party code extending input transformation will need to
+   be rewritten. The new API is, hopefully, simpler.
+
+String based transformations are functions which accept a list of strings:
+each string is a single line of the input cell, including its line ending.
+The transformation function should return output in the same structure.
+
+These transformations are in two groups, accessible as attributes of
+the :class:`~IPython.core.interactiveshell.InteractiveShell` instance.
+Each group is a list of transformation functions.
+
+* ``input_transformers_cleanup`` run first on input, to do things like stripping
+  prompts and leading indents from copied code. It may not be possible at this
+  stage to parse the input as valid Python code.
+* Then IPython runs its own transformations to handle its special syntax, like
+  ``%magics`` and ``!system`` commands. This part does not expose extension
+  points.
+* ``input_transformers_post`` run as the last step, to do things like converting
+  float literals into decimal objects. These may attempt to parse the input as
+  Python code.  
+
+These transformers may raise :exc:`SyntaxError` if the input code is invalid, but
+in most cases it is clearer to pass unrecognised code through unmodified and let
+Python's own parser decide whether it is valid.
+
+For example, imagine we want to obfuscate our code by reversing each line, so
+we'd write ``)5(f =+ a`` instead of ``a += f(5)``. Here's how we could swap it
+back the right way before IPython tries to run it::
+
+    def reverse_line_chars(lines):
+        new_lines = []
+        for line in lines:
+            chars = line[:-1]  # the newline needs to stay at the end
+            new_lines.append(chars[::-1] + '\n')
+        return new_lines
+
+To start using this::
+
+    ip = get_ipython()
+    ip.input_transformers_cleanup.append(reverse_line_chars)
+
+.. versionadded:: 7.17
+
+    input_transformers can now have an attribute ``has_side_effects`` set to
+    `True`, which will prevent the transformers from being ran when IPython is
+    trying to guess whether the user input is complete. 
+
+
+
+AST transformations
+===================
+
+After the code has been parsed as Python syntax, you can use Python's powerful
+*Abstract Syntax Tree* tools to modify it. Subclass :class:`ast.NodeTransformer`,
+and add an instance to ``shell.ast_transformers``.
+
+This example wraps integer literals in an ``Integer`` class, which is useful for
+mathematical frameworks that want to handle e.g. ``1/3`` as a precise fraction::
+
+
+    class IntegerWrapper(ast.NodeTransformer):
+        """Wraps all integers in a call to Integer()"""
+        def visit_Num(self, node):
+            if isinstance(node.value, int):
+                return ast.Call(func=ast.Name(id='Integer', ctx=ast.Load()),
+                                args=[node], keywords=[])
+            return node
diff --git a/docs/source/config/integrating.rst b/docs/source/config/integrating.rst
new file mode 100644
index 00000000000..aaf2b03b376
--- /dev/null
+++ b/docs/source/config/integrating.rst
@@ -0,0 +1,186 @@
+.. _integrating:
+
+=====================================
+Integrating your objects with IPython
+=====================================
+
+Tab completion
+==============
+
+To change the attributes displayed by tab-completing your object, define a
+``__dir__(self)`` method for it. For more details, see the documentation of the
+built-in :external+python:py:func:`dir`
+
+You can also customise key completions for your objects, e.g. pressing tab after
+``obj["a``. To do so, define a method ``_ipython_key_completions_()``, which
+returns a list of objects which are possible keys in a subscript expression
+``obj[key]``.
+
+.. versionadded:: 5.0
+   Custom key completions
+
+.. _integrating_rich_display:
+
+Rich display
+============
+
+Custom methods
+--------------
+
+IPython can display richer representations of objects.
+To do this, you can define ``_ipython_display_()``, or any of a number of
+``_repr_*_()`` methods.
+Note that these are surrounded by single, not double underscores.
+
+
+.. list-table:: Supported ``_repr_*_`` methods
+   :widths: 20 15 15 15
+   :header-rows: 1
+
+   * - Format
+     - REPL
+     - Notebook
+     - Qt Console
+   * - ``_repr_pretty_``
+     - yes
+     - yes
+     - yes
+   * - ``_repr_svg_``
+     - no
+     - yes
+     - yes
+   * - ``_repr_png_``
+     - no
+     - yes
+     - yes
+   * - ``_repr_jpeg_``
+     - no
+     - yes
+     - yes
+   * - ``_repr_html_``
+     - no
+     - yes
+     - no
+   * - ``_repr_javascript_``
+     - no
+     - yes
+     - no
+   * - ``_repr_markdown_``
+     - no
+     - yes
+     - no
+   * - ``_repr_latex_``
+     - no
+     - yes
+     - no
+   * - ``_repr_mimebundle_``
+     - no
+     - ?
+     - ?
+
+If the methods don't exist, the standard ``repr()`` is used.
+If a method exists and returns :py:data:`None`, it is treated the same as if it does not exist.
+In general, *all* available formatters will be called when an object is displayed,
+and it is up to the UI to select which to display.
+A given formatter should not generally change its output based on what other formats are available -
+that should be handled at a different level, such as the :class:`~.DisplayFormatter`, or configuration.
+
+``_repr_*_`` methods should *return* data of the expected format and have no side effects.
+For example, ``_repr_html_`` should return HTML as a `str` and ``_repr_png_`` should return PNG data as `bytes`.
+
+If you wish to take control of display via your own side effects, use ``_ipython_display_()``.
+
+For example::
+
+    class Shout(object):
+        def __init__(self, text):
+            self.text = text
+
+        def _repr_html_(self):
+            return "<h1>" + self.text + "</h1>"
+
+
+Special methods
+^^^^^^^^^^^^^^^
+
+Pretty printing
+"""""""""""""""
+
+To customize how your object is pretty-printed, add a ``_repr_pretty_`` method
+to the class.
+The method should accept a pretty printer, and a boolean that indicates whether
+the printer detected a cycle.
+The method should act on the printer to produce your customized pretty output.
+Here is an example::
+
+    class MyObject(object):
+
+        def _repr_pretty_(self, p, cycle):
+            if cycle:
+                p.text('MyObject(...)')
+            else:
+                p.text('MyObject[...]')
+
+For details on how to use the pretty printer, see :py:mod:`IPython.lib.pretty`.
+
+More powerful methods
+"""""""""""""""""""""
+
+.. class:: MyObject
+
+   .. method:: _repr_mimebundle_(include=None, exclude=None)
+
+     Should return a dictionary of multiple formats, keyed by mimetype, or a tuple
+     of two dictionaries: *data, metadata* (see :ref:`Metadata`).
+     If this returns something, other ``_repr_*_`` methods are ignored.
+     The method should take keyword arguments ``include`` and ``exclude``, though
+     it is not required to respect them.
+
+   .. method:: _ipython_display_()
+
+      Displays the object as a side effect; the return value is ignored. If this
+      is defined, all other display methods are ignored.
+
+
+Metadata
+^^^^^^^^
+
+We often want to provide frontends with guidance on how to display the data. To
+support this, ``_repr_*_()`` methods (except ``_repr_pretty_``?) can also return a ``(data, metadata)``
+tuple where ``metadata`` is a dictionary containing arbitrary key-value pairs for
+the frontend to interpret. An example use case is ``_repr_jpeg_()``, which can
+be set to return a jpeg image and a ``{'height': 400, 'width': 600}`` dictionary
+to inform the frontend how to size the image.
+
+
+
+.. _third_party_formatting:
+
+Formatters for third-party types
+--------------------------------
+
+The user can also register formatters for types without modifying the class::
+
+    from bar.baz import Foo
+
+    def foo_html(obj):
+        return '<marquee>Foo object %s</marquee>' % obj.name
+
+    html_formatter = get_ipython().display_formatter.formatters['text/html']
+    html_formatter.for_type(Foo, foo_html)
+
+    # Or register a type without importing it - this does the same as above:
+    html_formatter.for_type_by_name('bar.baz', 'Foo', foo_html)
+
+Custom exception tracebacks
+===========================
+
+Rarely, you might want to display a custom traceback when reporting an
+exception. To do this, define the custom traceback using
+`_render_traceback_(self)` method which returns a list of strings, one string
+for each line of the traceback. For example, the `ipyparallel
+<https://ipyparallel.readthedocs.io/>`__ a parallel computing framework for
+IPython, does this to display errors from multiple engines.
+
+Please be conservative in using this feature; by replacing the default traceback
+you may hide important information from the user.
diff --git a/docs/source/config/intro.rst b/docs/source/config/intro.rst
new file mode 100644
index 00000000000..182eeb63729
--- /dev/null
+++ b/docs/source/config/intro.rst
@@ -0,0 +1,234 @@
+=====================================
+Introduction to IPython configuration
+=====================================
+
+.. _setting_config:
+
+Setting configurable options
+============================
+
+Many of IPython's classes have configurable attributes (see
+:doc:`options/index` for the list). These can be
+configured in several ways.
+
+Python configuration files
+--------------------------
+
+To create the blank configuration files, run::
+
+    ipython profile create [profilename]
+
+If you leave out the profile name, the files will be created for the
+``default`` profile (see :ref:`profiles`). These will typically be located in
+:file:`~/.ipython/profile_default/`, and will be named
+:file:`ipython_config.py`, for historical reasons you may also find files
+named with IPython prefix instead of Jupyter:
+:file:`ipython_notebook_config.py`, etc. The settings in
+:file:`ipython_config.py` apply to all IPython commands.
+
+By default, configuration files are fully featured Python scripts that can
+execute arbitrary code, the main usage is to set value on the configuration
+object ``c`` which exist in your configuration file.
+
+You can then configure class attributes like this::
+
+    c.InteractiveShell.automagic = False
+
+Be careful with spelling--incorrect names will simply be ignored, with
+no error. 
+
+To add to a collection which may have already been defined elsewhere or have
+default values, you can use methods like those found on lists, dicts and
+sets: append, extend, :meth:`~traitlets.config.LazyConfigValue.prepend` (like
+extend, but at the front), add and update (which works both for dicts and
+sets)::
+
+    c.InteractiveShellApp.extensions.append('Cython')
+
+.. versionadded:: 2.0
+   list, dict and set methods for config values
+
+Example configuration file
+``````````````````````````
+
+::
+
+    # sample ipython_config.py
+
+    c.TerminalIPythonApp.display_banner = True
+    c.InteractiveShellApp.log_level = 20
+    c.InteractiveShellApp.extensions = [
+        'myextension'
+    ]
+    c.InteractiveShellApp.exec_lines = [
+        'import numpy',
+        'import scipy'
+    ]
+    c.InteractiveShellApp.exec_files = [
+        'mycode.py',
+        'fancy.ipy'
+    ]
+    c.InteractiveShell.colors = 'lightbg'
+    c.InteractiveShell.xmode = 'Context'
+    c.TerminalInteractiveShell.confirm_exit = False
+    c.TerminalInteractiveShell.editor = 'nano'
+
+    c.PrefilterManager.multi_line_specials = True
+
+    c.AliasManager.user_aliases = [
+     ('la', 'ls -al')
+    ]
+
+JSON Configuration files
+------------------------
+
+In case where executability of configuration can be problematic, or
+configurations need to be modified programmatically, IPython also support a
+limited set of functionalities via ``.json`` configuration files. 
+
+You can define most of the configuration options via a JSON object whose
+hierarchy represents the value you would normally set on the ``c`` object of
+``.py`` configuration files. The following ``ipython_config.json`` file::
+
+    {
+        "InteractiveShell": {
+            "colors": "lightbg",
+        },
+        "InteractiveShellApp": {
+            "extensions": [
+                "myextension"
+            ]
+        },
+        "TerminalInteractiveShell": {
+            "editor": "nano"
+        }
+    }
+
+Is equivalent to the following ``ipython_config.py``::
+
+    c.InteractiveShell.colors = 'lightbg'
+    c.InteractiveShellApp.extensions = [
+        'myextension'
+    ]
+    c.TerminalInteractiveShell.editor = 'nano'
+
+
+Command line arguments
+----------------------
+
+Every configurable value can be set from the command line, using this
+syntax::
+
+    ipython --ClassName.attribute=value
+
+Many frequently used options have short aliases and flags, such as
+``--matplotlib`` (to integrate with a matplotlib GUI event loop) or
+``--pdb`` (automatic post-mortem debugging of exceptions).
+
+To see all of these abbreviated options, run::
+
+    ipython --help
+    jupyter notebook --help
+    # etc.
+
+Options specified at the command line, in either format, override
+options set in a configuration file.
+
+The config magic
+----------------
+
+You can also modify config from inside IPython, using a magic command::
+
+    %config IPCompleter.greedy = True
+
+At present, this only affects the current session - changes you make to
+config are not saved anywhere. Also, some options are only read when
+IPython starts, so they can't be changed like this.
+
+.. _configure_start_ipython:
+
+Running IPython from Python
+----------------------------
+
+If you are using :ref:`embedding` to start IPython from a normal 
+python file, you can set configuration options the same way as in a 
+config file by creating a traitlets :class:`Config` object and passing it to 
+start_ipython like in the example below.
+
+.. literalinclude:: ../../../examples/Embedding/start_ipython_config.py
+    :language: python
+
+.. _profiles:
+
+Profiles
+========
+
+IPython can use multiple profiles, with separate configuration and
+history. By default, if you don't specify a profile, IPython always runs
+in the ``default`` profile. To use a new profile::
+
+    ipython profile create foo   # create the profile foo
+    ipython --profile=foo        # start IPython using the new profile
+
+Profiles are typically stored in :ref:`ipythondir`, but you can also keep
+a profile in the current working directory, for example to distribute it
+with a project. To find a profile directory on the filesystem::
+
+    ipython locate profile foo
+
+.. _ipythondir:
+
+The IPython directory
+=====================
+
+IPython stores its files---config, command history and extensions---in
+the directory :file:`~/.ipython/` by default.
+
+.. envvar:: IPYTHONDIR
+
+   If set, this environment variable should be the path to a directory,
+   which IPython will use for user data. IPython will create it if it
+   does not exist.
+
+.. option:: --ipython-dir=<path>
+
+   This command line option can also be used to override the default
+   IPython directory.
+
+To see where IPython is looking for the IPython directory, use the command
+``ipython locate``, or the Python function :func:`IPython.paths.get_ipython_dir`.
+
+
+Systemwide configuration
+========================
+
+It can be useful to deploy systemwide ipython or ipykernel configuration
+when managing environment for many users. At startup time IPython and
+IPykernel will search for configuration file in multiple systemwide
+locations, mainly:
+
+  - ``/etc/ipython/``
+  - ``/usr/local/etc/ipython/``
+
+When the global install is a standalone python distribution it may also
+search in distribution specific location, for example:
+
+  - ``$ANACONDA_LOCATION/etc/ipython/``
+
+In those locations, Terminal IPython will look for a file called
+``ipython_config.py`` and ``ipython_config.json``, ipykernel will look for
+``ipython_kernel_config.py`` and ``ipython_kernel.json``.
+
+Configuration files are loaded in order and merged with configuration on
+later location taking precedence on earlier locations (that is to say a user
+can overwrite a systemwide configuration option).
+
+You can see all locations in which IPython is looking for configuration files
+by starting ipython in debug mode::
+
+    $ ipython --debug -c 'exit()'
+
+Identically with ipykernel though the command is currently blocking until
+this process is killed with ``Ctrl-\``::
+ 
+    $ python -m ipykernel --debug
diff --git a/docs/source/config/ipython.txt b/docs/source/config/ipython.txt
deleted file mode 100644
index 87674a84ea8..00000000000
--- a/docs/source/config/ipython.txt
+++ /dev/null
@@ -1,136 +0,0 @@
-.. _configuring_ipython:
-
-===========================================================
-Configuring the :command:`ipython` command line application
-===========================================================
-
-This section contains information about how to configure the
-:command:`ipython` command line application. See the :ref:`configuration
-overview <config_overview>` for a more general description of the
-configuration system and configuration file format.
-
-The default configuration file for the :command:`ipython` command line application
-is :file:`ipython_config.py`.  By setting the attributes in this file, you
-can configure the application.   A sample is provided in
-:mod:`IPython.config.default.ipython_config`.  Simply copy this file to your
-:ref:`IPython directory <ipython_dir>` to start using it.
-
-Most configuration attributes that this file accepts are associated with
-classes that are subclasses of :class:`~IPython.core.component.Component`.
-
-A few configuration attributes are not associated with a particular 
-:class:`~IPython.core.component.Component` subclass.  These are application
-wide configuration attributes and are stored in the ``Global`` 
-sub-configuration section.  We begin with a description of these 
-attributes.
-
-Global configuration
-====================
-
-Assuming that your configuration file has the following at the top::
-
-    c = get_config()
-
-the following attributes can be set in the ``Global`` section.
-
-:attr:`c.Global.display_banner`
-    A boolean that determined if the banner is printer when :command:`ipython`
-    is started.
-
-:attr:`c.Global.classic`
-    A boolean that determines if IPython starts in "classic" mode.  In this
-    mode, the prompts and everything mimic that of the normal :command:`python`
-    shell
-
-:attr:`c.Global.nosep`
-    A boolean that determines if there should be no blank lines between
-    prompts.
-
-:attr:`c.Global.log_level`
-    An integer that sets the detail of the logging level during the startup
-    of :command:`ipython`.  The default is 30 and the possible values are
-    (0, 10, 20, 30, 40, 50).  Higher is quieter and lower is more verbose.
-
-:attr:`c.Global.extensions`
-    A list of strings, each of which is an importable IPython extension. An
-    IPython extension is a regular Python module or package that has a
-    :func:`load_ipython_extension(ip)` method. This method gets called when
-    the extension is loaded with the currently running
-    :class:`~IPython.core.iplib.InteractiveShell` as its only argument. You
-    can put your extensions anywhere they can be imported but we add the
-    :file:`extensions` subdirectory of the ipython directory to ``sys.path``
-    during extension loading, so you can put them there as well. Extensions
-    are not executed in the user's interactive namespace and they must be pure
-    Python code. Extensions are the recommended way of customizing
-    :command:`ipython`. Extensions can provide an
-    :func:`unload_ipython_extension` that will be called when the extension is
-    unloaded.
-
-:attr:`c.Global.exec_lines`
-    A list of strings, each of which is Python code that is run in the user's
-    namespace after IPython start. These lines can contain full IPython syntax
-    with magics, etc.
-
-:attr:`c.Global.exec_files`
-    A list of strings, each of which is the full pathname of a ``.py`` or
-    ``.ipy`` file that will be executed as IPython starts. These files are run
-    in IPython in the user's namespace. Files with a ``.py`` extension need to
-    be pure Python. Files with a ``.ipy`` extension can have custom IPython
-    syntax (magics, etc.). These files need to be in the cwd, the ipythondir
-    or be absolute paths.
-
-Classes that can be configured
-==============================
-
-The following classes can also be configured in the configuration file for
-:command:`ipython`:
-
-* :class:`~IPython.core.iplib.InteractiveShell`
-
-* :class:`~IPython.core.prefilter.PrefilterManager`
-
-* :class:`~IPython.core.alias.AliasManager`
-
-To see which attributes of these classes are configurable, please see the
-source code for these classes, the class docstrings or the sample
-configuration file :mod:`IPython.config.default.ipython_config`.
-
-Example
-=======
-
-For those who want to get a quick start, here is a sample
-:file:`ipython_config.py` that sets some of the common configuration
-attributes::
-
-    # sample ipython_config.py
-    c = get_config()
-
-    c.Global.display_banner = True
-    c.Global.log_level = 20
-    c.Global.extensions = [
-        'myextension'
-    ]
-    c.Global.exec_lines = [
-        'import numpy',
-        'import scipy'
-    ]
-    c.Global.exec_files = [
-        'mycode.py',
-        'fancy.ipy'
-    ]
-    c.InteractiveShell.autoindent = True
-    c.InteractiveShell.colors = 'LightBG'
-    c.InteractiveShell.confirm_exit = False
-    c.InteractiveShell.deep_reload = True
-    c.InteractiveShell.editor = 'nano'
-    c.InteractiveShell.prompt_in1 = 'In [\#]: '
-    c.InteractiveShell.prompt_in2 = '   .\D.: '
-    c.InteractiveShell.prompt_out = 'Out[\#]: '
-    c.InteractiveShell.prompts_pad_left = True
-    c.InteractiveShell.xmode = 'Context'
-
-    c.PrefilterManager.multi_line_specials = True
-
-    c.AliasManager.user_aliases = [
-     ('la', 'ls -al')
-    ]
diff --git a/docs/source/config/old.txt b/docs/source/config/old.txt
deleted file mode 100644
index fe6e0bd14e6..00000000000
--- a/docs/source/config/old.txt
+++ /dev/null
@@ -1,231 +0,0 @@
-.. _initial config:
-
-=============================================================
-Outdated configuration information that might still be useful
-=============================================================
-
-.. warning::
-
-    All of the information in this file is outdated. Until the new
-    configuration system is better documented, this material is being kept.
-
-This section will help you set various things in your environment for
-your IPython sessions to be as efficient as possible. All of IPython's
-configuration information, along with several example files, is stored
-in a directory named by default $HOME/.config/ipython if $HOME/.config 
-exists (Linux), or $HOME/.ipython as a secondary default. You can change this by
-defining the environment variable IPYTHONDIR, or at runtime with the
-command line option -ipythondir.
-
-If all goes well, the first time you run IPython it should automatically create
-a user copy of the config directory for you, based on its builtin defaults. You
-can look at the files it creates to learn more about configuring the
-system. The main file you will modify to configure IPython's behavior is called
-ipythonrc (with a .ini extension under Windows), included for reference
-:ref:`here <ipythonrc>`. This file is very commented and has many variables you
-can change to suit your taste, you can find more details :ref:`here
-<customization>`. Here we discuss the basic things you will want to make sure
-things are working properly from the beginning.
-
-Color
-=====
-
-The default IPython configuration has most bells and whistles turned on
-(they're pretty safe). But there's one that may cause problems on some
-systems: the use of color on screen for displaying information. This is
-very useful, since IPython can show prompts and exception tracebacks
-with various colors, display syntax-highlighted source code, and in
-general make it easier to visually parse information.
-
-The following terminals seem to handle the color sequences fine:
-
-    * Linux main text console, KDE Konsole, Gnome Terminal, E-term,
-      rxvt, xterm.
-    * CDE terminal (tested under Solaris). This one boldfaces light colors.
-    * (X)Emacs buffers. See the emacs_ section for more details on
-      using IPython with (X)Emacs.
-    * A Windows (XP/2k) command prompt with pyreadline_.
-    * A Windows (XP/2k) CygWin shell. Although some users have reported
-      problems; it is not clear whether there is an issue for everyone
-      or only under specific configurations. If you have full color
-      support under cygwin, please post to the IPython mailing list so
-      this issue can be resolved for all users.
-
-.. _pyreadline: https://code.launchpad.net/pyreadline
-      
-These have shown problems:
-
-    * Windows command prompt in WinXP/2k logged into a Linux machine via
-      telnet or ssh.
-    * Windows native command prompt in WinXP/2k, without Gary Bishop's
-      extensions. Once Gary's readline library is installed, the normal
-      WinXP/2k command prompt works perfectly.
-
-Currently the following color schemes are available:
-
-    * NoColor: uses no color escapes at all (all escapes are empty '' ''
-      strings). This 'scheme' is thus fully safe to use in any terminal.
-    * Linux: works well in Linux console type environments: dark
-      background with light fonts. It uses bright colors for
-      information, so it is difficult to read if you have a light
-      colored background.
-    * LightBG: the basic colors are similar to those in the Linux scheme
-      but darker. It is easy to read in terminals with light backgrounds.
-
-IPython uses colors for two main groups of things: prompts and
-tracebacks which are directly printed to the terminal, and the object
-introspection system which passes large sets of data through a pager.
-
-Input/Output prompts and exception tracebacks
-=============================================
-
-You can test whether the colored prompts and tracebacks work on your
-system interactively by typing '%colors Linux' at the prompt (use
-'%colors LightBG' if your terminal has a light background). If the input
-prompt shows garbage like::
-
-    [0;32mIn [[1;32m1[0;32m]: [0;00m
-
-instead of (in color) something like::
-
-    In [1]:
-
-this means that your terminal doesn't properly handle color escape
-sequences. You can go to a 'no color' mode by typing '%colors NoColor'.
-
-You can try using a different terminal emulator program (Emacs users,
-see below). To permanently set your color preferences, edit the file
-$IPYTHON_DIR/ipythonrc and set the colors option to the desired value.
-
-
-Object details (types, docstrings, source code, etc.)
-=====================================================
-
-IPython has a set of special functions for studying the objects you are working
-with, discussed in detail :ref:`here <dynamic_object_info>`. But this system
-relies on passing information which is longer than your screen through a data
-pager, such as the common Unix less and more programs. In order to be able to
-see this information in color, your pager needs to be properly configured. I
-strongly recommend using less instead of more, as it seems that more simply can
-not understand colored text correctly.
-
-In order to configure less as your default pager, do the following:
-
-   1. Set the environment PAGER variable to less.
-   2. Set the environment LESS variable to -r (plus any other options
-      you always want to pass to less by default). This tells less to
-      properly interpret control sequences, which is how color
-      information is given to your terminal.
-
-For the bash shell, add to your ~/.bashrc file the lines::
-
-    export PAGER=less
-    export LESS=-r
-
-For the csh or tcsh shells, add to your ~/.cshrc file the lines::
-
-    setenv PAGER less
-    setenv LESS -r
-    
-There is similar syntax for other Unix shells, look at your system
-documentation for details.
-
-If you are on a system which lacks proper data pagers (such as Windows),
-IPython will use a very limited builtin pager.
-
-.. _Prompts:
-
-Fine-tuning your prompt
-=======================
-
-IPython's prompts can be customized using a syntax similar to that of
-the bash shell. Many of bash's escapes are supported, as well as a few
-additional ones. We list them below::
-
-    \#
-        the prompt/history count number. This escape is automatically
-        wrapped in the coloring codes for the currently active color scheme. 
-    \N
-        the 'naked' prompt/history count number: this is just the number
-        itself, without any coloring applied to it. This lets you produce
-        numbered prompts with your own colors. 
-    \D
-        the prompt/history count, with the actual digits replaced by dots.
-        Used mainly in continuation prompts (prompt_in2) 
-    \w
-        the current working directory 
-    \W
-        the basename of current working directory 
-    \Xn
-        where $n=0\ldots5.$ The current working directory, with $HOME
-        replaced by ~, and filtered out to contain only $n$ path elements 
-    \Yn
-        Similar to \Xn, but with the $n+1$ element included if it is ~ (this
-        is similar to the behavior of the %cn escapes in tcsh) 
-    \u
-        the username of the current user 
-    \$
-        if the effective UID is 0, a #, otherwise a $ 
-    \h
-        the hostname up to the first '.' 
-    \H
-        the hostname 
-    \n
-        a newline 
-    \r
-        a carriage return 
-    \v
-        IPython version string 
-
-In addition to these, ANSI color escapes can be insterted into the
-prompts, as \C_ColorName. The list of valid color names is: Black, Blue,
-Brown, Cyan, DarkGray, Green, LightBlue, LightCyan, LightGray,
-LightGreen, LightPurple, LightRed, NoColor, Normal, Purple, Red, White,
-Yellow.
-
-Finally, IPython supports the evaluation of arbitrary expressions in
-your prompt string. The prompt strings are evaluated through the syntax
-of PEP 215, but basically you can use $x.y to expand the value of x.y,
-and for more complicated expressions you can use braces: ${foo()+x} will
-call function foo and add to it the value of x, before putting the
-result into your prompt. For example, using
-prompt_in1 '${commands.getoutput("uptime")}\nIn [\#]: ' 
-will print the result of the uptime command on each prompt (assuming the
-commands module has been imported in your ipythonrc file).
-
-
-      Prompt examples
-
-The following options in an ipythonrc file will give you IPython's
-default prompts::
-
-    prompt_in1 'In [\#]:' 
-    prompt_in2 '   .\D.:' 
-    prompt_out 'Out[\#]:'
-
-which look like this::
-
-    In [1]: 1+2 
-    Out[1]: 3
-
-    In [2]: for i in (1,2,3): 
-       ...:    print i, 
-       ...: 
-    1 2 3
-
-These will give you a very colorful prompt with path information::
-
-    #prompt_in1 '\C_Red\u\C_Blue[\C_Cyan\Y1\C_Blue]\C_LightGreen\#>' 
-    prompt_in2 ' ..\D>' 
-    prompt_out '<\#>'
-
-which look like this::
-
-    fperez[~/ipython]1> 1+2 
-                    <1> 3 
-    fperez[~/ipython]2> for i in (1,2,3): 
-                   ...>     print i, 
-                   ...> 
-    1 2 3
-
-
diff --git a/docs/source/config/options/index.rst b/docs/source/config/options/index.rst
new file mode 100644
index 00000000000..4330e39f0e3
--- /dev/null
+++ b/docs/source/config/options/index.rst
@@ -0,0 +1,10 @@
+.. _terminal_options:
+
+Terminal options
+================
+
+Any of the options listed here can be set in config files, at the
+command line, from inside IPython, or using a traitlets :class:`Config` object.
+See :ref:`setting_config` for details.
+
+.. include:: terminal.rst
diff --git a/docs/source/config/overview.txt b/docs/source/config/overview.txt
deleted file mode 100644
index 4f99e7a63bf..00000000000
--- a/docs/source/config/overview.txt
+++ /dev/null
@@ -1,342 +0,0 @@
-.. _config_overview:
-
-============================================
-Overview of the IPython configuration system
-============================================
-
-This section describes the IPython configuration system. Starting with version
-0.11, IPython has a completely new configuration system that is quite
-different from the older :file:`ipythonrc` or :file:`ipy_user_conf.py`
-approaches. The new configuration system was designed from scratch to address
-the particular configuration needs of IPython. While there are many
-other excellent configuration systems out there, we found that none of them
-met our requirements.
-
-.. warning::
-
-    If you are upgrading to version 0.11 of IPython, you will need to migrate
-    your old :file:`ipythonrc` or :file:`ipy_user_conf.py` configuration files
-    to the new system.  Read on for information on how to do this.
-
-The discussion that follows is focused on teaching user's how to configure
-IPython to their liking.  Developer's who want to know more about how they
-can enable their objects to take advantage of the configuration system
-should consult our :ref:`developer guide <developer_guide>`
-
-The main concepts
-=================
-
-There are a number of abstractions that the IPython configuration system uses.
-Each of these abstractions is represented by a Python class.
-
-Configuration object: :class:`~IPython.config.loader.Config`
-    A configuration object is a simple dictionary-like class that holds
-    configuration attributes and sub-configuration objects. These classes
-    support dotted attribute style access (``Foo.bar``) in addition to the
-    regular dictionary style access (``Foo['bar']``). Configuration objects
-    are smart. They know how to merge themselves with other configuration
-    objects and they automatically create sub-configuration objects.
-
-Application: :class:`~IPython.core.application.Application`
-    An application is a process that does a specific job. The most obvious
-    application is the :command:`ipython` command line program. Each
-    application reads a *single* configuration file and command line options
-    and then produces a master configuration object for the application. This
-    configuration object is then passed to the configurable objects that the
-    application creates. These configurable objects implement the actual logic
-    of the application and know how to configure themselves given the
-    configuration object.
-
-Component: :class:`~IPython.config.configurable.Configurable`
-    A configurable is a regular Python class that serves as a base class for
-    all main classes in an application. The
-    :class:`~IPython.config.configurable.Configurable` base class is
-    lightweight and only does one things.
-
-    This :class:`~IPython.config.configurable.Configurable` is a subclass
-    of :class:`~IPython.utils.traitlets.HasTraits` that knows how to configure
-    itself. Class level traits with the metadata ``config=True`` become
-    values that can be configured from the command line and configuration
-    files.
-    
-    Developers create :class:`~IPython.config.configurable.Configurable`
-    subclasses that implement all of the logic in the application. Each of
-    these subclasses has its own configuration information that controls how
-    instances are created.
-
-Having described these main concepts, we can now state the main idea in our
-configuration system: *"configuration" allows the default values of class
-attributes to be controlled on a class by class basis*. Thus all instances of
-a given class are configured in the same way. Furthermore, if two instances
-need to be configured differently, they need to be instances of two different
-classes. While this model may seem a bit restrictive, we have found that it
-expresses most things that need to be configured extremely well. However, it
-is possible to create two instances of the same class that have different
-trait values. This is done by overriding the configuration.
-
-Now, we show what our configuration objects and files look like.
-
-Configuration objects and files
-===============================
-
-A configuration file is simply a pure Python file that sets the attributes
-of a global, pre-created configuration object.  This configuration object is a 
-:class:`~IPython.config.loader.Config` instance.  While in a configuration
-file, to get a reference to this object, simply call the :func:`get_config`
-function.  We inject this function into the global namespace that the 
-configuration file is executed in.
-
-Here is an example of a super simple configuration file that does nothing::
-
-    c = get_config()
-
-Once you get a reference to the configuration object, you simply set
-attributes on it.  All you have to know is:
-
-* The name of each attribute.
-* The type of each attribute.
-
-The answers to these two questions are provided by the various
-:class:`~IPython.config.configurable.Configurable` subclasses that an
-application uses. Let's look at how this would work for a simple component
-subclass::
-
-    # Sample component that can be configured.
-    from IPython.config.configurable import Configurable
-    from IPython.utils.traitlets import Int, Float, Str, Bool
-    
-    class MyClass(Configurable):
-        name = Str('defaultname', config=True)
-        ranking = Int(0, config=True)
-        value = Float(99.0)
-        # The rest of the class implementation would go here..
-
-In this example, we see that :class:`MyClass` has three attributes, two
-of whom (``name``, ``ranking``) can be configured.  All of the attributes
-are given types and default values.  If a :class:`MyClass` is instantiated,
-but not configured, these default values will be used.  But let's see how
-to configure this class in a configuration file::
-
-    # Sample config file
-    c = get_config()
-    
-    c.MyClass.name = 'coolname'
-    c.MyClass.ranking = 10
-
-After this configuration file is loaded, the values set in it will override
-the class defaults anytime a :class:`MyClass` is created.  Furthermore,
-these attributes will be type checked and validated anytime they are set.
-This type checking is handled by the :mod:`IPython.utils.traitlets` module,
-which provides the :class:`Str`, :class:`Int` and :class:`Float` types.  In 
-addition to these traitlets, the :mod:`IPython.utils.traitlets` provides
-traitlets for a number of other types.
-
-.. note::
-
-    Underneath the hood, the :class:`Configurable` base class is a subclass of
-    :class:`IPython.utils.traitlets.HasTraits`. The
-    :mod:`IPython.utils.traitlets` module is a lightweight version of
-    :mod:`enthought.traits`. Our implementation is a pure Python subset
-    (mostly API compatible) of :mod:`enthought.traits` that does not have any
-    of the automatic GUI generation capabilities. Our plan is to achieve 100%
-    API compatibility to enable the actual :mod:`enthought.traits` to
-    eventually be used instead. Currently, we cannot use
-    :mod:`enthought.traits` as we are committed to the core of IPython being
-    pure Python.
-
-It should be very clear at this point what the naming convention is for 
-configuration attributes::
-
-    c.ClassName.attribute_name = attribute_value
-
-Here, ``ClassName`` is the name of the class whose configuration attribute you
-want to set, ``attribute_name`` is the name of the attribute you want to set
-and ``attribute_value`` the the value you want it to have. The ``ClassName``
-attribute of ``c`` is not the actual class, but instead is another
-:class:`~IPython.config.loader.Config` instance.
-
-.. note::
-
-    The careful reader may wonder how the ``ClassName`` (``MyClass`` in
-    the above example) attribute of the configuration object ``c`` gets
-    created. These attributes are created on the fly by the
-    :class:`~IPython.config.loader.Config` instance, using a simple naming
-    convention. Any attribute of a :class:`~IPython.config.loader.Config`
-    instance whose name begins with an uppercase character is assumed to be a
-    sub-configuration and a new empty :class:`~IPython.config.loader.Config`
-    instance is dynamically created for that attribute. This allows deeply
-    hierarchical information created easily (``c.Foo.Bar.value``) on the fly.
-
-Configuration files inheritance
-===============================
-
-Let's say you want to have different configuration files for various purposes.
-Our configuration system makes it easy for one configuration file to inherit
-the information in another configuration file. The :func:`load_subconfig`
-command can be used in a configuration file for this purpose. Here is a simple
-example that loads all of the values from the file :file:`base_config.py`::
-
-    # base_config.py
-    c = get_config()
-    c.MyClass.name = 'coolname'
-    c.MyClass.ranking = 100
-
-into the configuration file :file:`main_config.py`::
-
-    # main_config.py
-    c = get_config()
-    
-    # Load everything from base_config.py
-    load_subconfig('base_config.py')
-    
-    # Now override one of the values
-    c.MyClass.name = 'bettername'
-
-In a situation like this the :func:`load_subconfig` makes sure that the
-search path for sub-configuration files is inherited from that of the parent.
-Thus, you can typically put the two in the same directory and everything will
-just work.
-
-Class based configuration inheritance
-=====================================
-
-There is another aspect of configuration where inheritance comes into play.
-Sometimes, your classes will have an inheritance hierarchy that you want
-to be reflected in the configuration system.  Here is a simple example::
-
-    from IPython.config.configurable import Configurable
-    from IPython.utils.traitlets import Int, Float, Str, Bool
-    
-    class Foo(Configurable):
-        name = Str('fooname', config=True)
-        value = Float(100.0, config=True)
-    
-    class Bar(Foo):
-        name = Str('barname', config=True)
-        othervalue = Int(0, config=True)
-
-Now, we can create a configuration file to configure instances of :class:`Foo`
-and :class:`Bar`::
-
-    # config file
-    c = get_config()
-    
-    c.Foo.name = 'bestname'
-    c.Bar.othervalue = 10
-
-This class hierarchy and configuration file accomplishes the following:
-
-* The default value for :attr:`Foo.name` and :attr:`Bar.name` will be
-  'bestname'.  Because :class:`Bar` is a :class:`Foo` subclass it also
-  picks up the configuration information for :class:`Foo`.
-* The default value for :attr:`Foo.value` and :attr:`Bar.value` will be
-  ``100.0``, which is the value specified as the class default.
-* The default value for :attr:`Bar.othervalue` will be 10 as set in the
-  configuration file.  Because :class:`Foo` is the parent of :class:`Bar`
-  it doesn't know anything about the :attr:`othervalue` attribute.
-
-
-.. _ipython_dir:
-
-Configuration file location
-===========================
-
-So where should you put your configuration files?  By default, all IPython
-applications look in the so called "IPython directory".  The location of
-this directory is determined by the following algorithm:
-
-* If the ``--ipython-dir`` command line flag is given, its value is used.
-
-* If not, the value returned by :func:`IPython.utils.path.get_ipython_dir`
-  is used. This function will first look at the :envvar:`IPYTHON_DIR`
-  environment variable and then default to a platform-specific default.
-
-On posix systems (Linux, Unix, etc.), IPython respects the ``$XDG_CONFIG_HOME``
-part of the `XDG Base Directory`_ specification. If ``$XDG_CONFIG_HOME`` is
-defined and exists ( ``XDG_CONFIG_HOME`` has a default interpretation of
-:file:`$HOME/.config`), then IPython's config directory will be located in
-:file:`$XDG_CONFIG_HOME/ipython`.  If users still have an IPython directory
-in :file:`$HOME/.ipython`, then that will be used. in preference to the 
-system default.
-
-For most users, the default value will simply be something like 
-:file:`$HOME/.config/ipython` on Linux, or :file:`$HOME/.ipython`
-elsewhere.
-
-Once the location of the IPython directory has been determined, you need to
-know what filename to use for the configuration file. The basic idea is that
-each application has its own default configuration filename. The default named
-used by the :command:`ipython` command line program is
-:file:`ipython_config.py`.  This value can be overriden by the ``-config_file``
-command line flag.  A sample :file:`ipython_config.py` file can be found
-in :mod:`IPython.config.default.ipython_config.py`.  Simple copy it to your
-IPython directory to begin using it.
-
-.. _Profiles:
-
-Profiles
-========
-
-A profile is simply a configuration file that follows a simple naming
-convention and can be loaded using a simplified syntax.  The idea is
-that users often want to maintain a set of configuration files for different
-purposes:  one for doing numerical computing with NumPy and SciPy and
-another for doing symbolic computing with SymPy.  Profiles make it easy
-to keep a separate configuration file for each of these purposes.
-
-Let's start by showing how a profile is used:
-
-.. code-block:: bash
-
-    $ ipython -p sympy
-
-This tells the :command:`ipython` command line program to get its
-configuration from the "sympy" profile. The search path for profiles is the
-same as that of regular configuration files. The only difference is that
-profiles are named in a special way. In the case above, the "sympy" profile
-would need to have the name :file:`ipython_config_sympy.py`.
-
-The general pattern is this: simply add ``_profilename`` to the end of the
-normal configuration file name. Then load the profile by adding ``-p
-profilename`` to your command line options.
-
-IPython ships with some sample profiles in :mod:`IPython.config.profile`.
-Simply copy these to your IPython directory to begin using them.
-
-Design requirements
-===================
-
-Here are the main requirements we wanted our configuration system to have:
-
-* Support for hierarchical configuration information.
-
-* Full integration with command line option parsers.  Often, you want to read
-  a configuration file, but then override some of the values with command line
-  options.  Our configuration system automates this process and allows each
-  command line option to be linked to a particular attribute in the 
-  configuration hierarchy that it will override.
-
-* Configuration files that are themselves valid Python code. This accomplishes
-  many things. First, it becomes possible to put logic in your configuration
-  files that sets attributes based on your operating system, network setup,
-  Python version, etc. Second, Python has a super simple syntax for accessing
-  hierarchical data structures, namely regular attribute access
-  (``Foo.Bar.Bam.name``). Third, using Python makes it easy for users to
-  import configuration attributes from one configuration file to another.
-  Forth, even though Python is dynamically typed, it does have types that can
-  be checked at runtime. Thus, a ``1`` in a config file is the integer '1',
-  while a ``'1'`` is a string.
-
-* A fully automated method for getting the configuration information to the
-  classes that need it at runtime. Writing code that walks a configuration
-  hierarchy to extract a particular attribute is painful. When you have
-  complex configuration information with hundreds of attributes, this makes
-  you want to cry.
-
-* Type checking and validation that doesn't require the entire configuration
-  hierarchy to be specified statically before runtime. Python is a very
-  dynamic language and you don't always know everything that needs to be
-  configured when a program starts.
-
-
-.. _`XDG Base Directory`: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
diff --git a/docs/source/config/plugins.txt b/docs/source/config/plugins.txt
deleted file mode 100644
index c0aa1ae7072..00000000000
--- a/docs/source/config/plugins.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-.. _plugins_overview:
-
-===============
-IPython plugins
-===============
-
-IPython has a plugin mechanism that allows users to create new and custom
-runtime components for IPython. Plugins are different from extensions:
-
-* Extensions are used to load plugins.
-* Extensions are a more advanced configuration system that gives you access
-  to the running IPython instance.
-* Plugins add entirely new capabilities to IPython.
-* Plugins are traited and configurable.
-
-At this point, our plugin system is brand new and the documentation is 
-minimal. If you are interested in creating a new plugin, see the following
-files:
-
-* :file:`IPython/extensions/parallemagic.py`
-* :file:`IPython/extensions/pretty.`
-
-As well as our documentation on the configuration system and extensions.
diff --git a/docs/source/config/shell_mimerenderer.rst b/docs/source/config/shell_mimerenderer.rst
new file mode 100644
index 00000000000..75872ac6a35
--- /dev/null
+++ b/docs/source/config/shell_mimerenderer.rst
@@ -0,0 +1,60 @@
+
+.. _shell_mimerenderer:
+
+
+Mime Renderer Extensions
+========================
+
+Like it's cousins, Jupyter Notebooks and JupyterLab, Terminal IPython can be
+thought to render a number of mimetypes in the shell. This can be used to either
+display inline images if your terminal emulator supports it; or open some
+display results with external file viewers.
+
+Registering new mimetype handlers can so far only be done by extensions and
+requires 4 steps:
+
+   - Define a callable that takes 2 parameters:``data`` and ``metadata``; return
+     value of the callable is so far ignored. This callable is responsible for
+     "displaying" the given mimetype. Which can be sending the right escape
+     sequences and bytes to the current terminal; or open an external program. -
+   - Appending the right mimetype to ``ipython.display_formatter.active_types``
+     for IPython to know it should not ignore those mimetypes.
+   - Enabling the given mimetype: ``ipython.display_formatter.formatters[mime].enabled = True``
+   - Registering above callable with mimetype handler:
+     ``ipython.mime_renderers[mime] = handler``
+
+
+Here is a complete IPython extension to display images inline and convert math
+to png, before displaying it inline for iterm2 on macOS ::
+
+
+    from base64 import encodebytes
+    from IPython.lib.latextools import latex_to_png
+
+
+    def mathcat(data, meta):
+        png = latex_to_png(f'$${data}$$'.replace('\displaystyle', '').replace('$$$', '$$'))
+        imcat(png, meta)
+
+    IMAGE_CODE = '\033]1337;File=name=name;inline=true;:{}\a'
+
+    def imcat(image_data, metadata):
+        try:
+            print(IMAGE_CODE.format(encodebytes(image_data).decode()))
+        # bug workaround
+        except:
+            print(IMAGE_CODE.format(image_data))
+
+    def register_mimerenderer(ipython, mime, handler):
+        ipython.display_formatter.active_types.append(mime)
+        ipython.display_formatter.formatters[mime].enabled = True
+        ipython.mime_renderers[mime] = handler
+
+    def load_ipython_extension(ipython):
+        register_mimerenderer(ipython, 'image/png', imcat)
+        register_mimerenderer(ipython, 'image/jpeg', imcat)
+        register_mimerenderer(ipython, 'text/latex', mathcat)
+
+This example only work for iterm2 on macOS and skip error handling for brevity.
+One could also invoke an external viewer with ``subprocess.run()`` and a
+temporary file, which is left as an exercise.
diff --git a/docs/source/config/shortcuts/index.rst b/docs/source/config/shortcuts/index.rst
new file mode 100755
index 00000000000..42fd6acfd33
--- /dev/null
+++ b/docs/source/config/shortcuts/index.rst
@@ -0,0 +1,31 @@
+.. _terminal-shortcuts-list:
+
+=================
+IPython shortcuts
+=================
+
+Shortcuts available in an IPython terminal.
+
+.. note::
+
+  This list is automatically generated. Key bindings defined in ``prompt_toolkit`` may differ
+  between installations depending on the ``prompt_toolkit`` version.
+
+
+* Comma-separated keys, e.g. :kbd:`Esc`, :kbd:`f`, indicate a sequence which can be activated by pressing the listed keys in succession.
+* Plus-separated keys, e.g. :kbd:`Esc` + :kbd:`f` indicate a combination which requires pressing all keys simultaneously.
+* Hover over the ⓘ icon in the filter column to see when the shortcut is active.
+
+You can use :std:configtrait:`TerminalInteractiveShell.shortcuts` configuration
+to modify, disable or add shortcuts.
+
+.. role:: raw-html(raw)
+   :format: html
+
+
+.. csv-table::
+    :header: Shortcut,Description and identifier,Filter
+    :delim: tab
+    :class: shortcuts
+    :file: table.tsv
+    :widths: 20 75 5
diff --git a/docs/source/coredev/index.rst b/docs/source/coredev/index.rst
new file mode 100644
index 00000000000..d624bb13d0d
--- /dev/null
+++ b/docs/source/coredev/index.rst
@@ -0,0 +1,305 @@
+.. _core_developer_guide:
+
+=================================
+Guide for IPython core Developers
+=================================
+
+This guide documents the development of IPython itself.  Alternatively,
+developers of third party tools and libraries that use IPython should see the
+:doc:`../development/index`.
+
+
+For instructions on how to make a developer install see :ref:`devinstall`.
+
+Backporting Pull requests
+=========================
+
+All pull requests should usually be made against ``main``, if a Pull Request
+need to be backported to an earlier release; then it should be tagged with the
+correct ``milestone``.
+
+If you tag a pull request with a milestone **before** merging the pull request,
+and the base ref is ``main``, then our backport bot should automatically create
+a corresponding pull-request that backport on the correct branch.
+
+If you have write access to the IPython repository you can also just mention the
+**backport bot** to do the work for you. The bot is evolving so instructions may
+be different. At the time of this writing you can use::
+
+    @meeseeksdev[bot] backport [to] <branchname>
+
+The bot will attempt to backport the current pull-request and issue a PR if
+possible. 
+
+.. note::
+
+    The ``@`` and ``[bot]`` when mentioning the bot should be optional and can
+    be omitted.
+
+If the pull request cannot be automatically backported, the bot should tell you
+so on the PR and apply a "Need manual backport" tag to the origin PR.
+
+.. _release_process:
+
+IPython release process
+=======================
+
+This document contains the process that is used to create an IPython release.
+
+Conveniently, the ``release`` script in the ``tools`` directory of the ``IPython``
+repository automates most of the release process. This document serves as a
+handy reminder and checklist for the release manager.
+
+During the release process, you might need the extra following dependencies:
+
+ - ``keyring`` to access your GitHub authentication tokens
+ - ``graphviz`` to generate some graphs in the documentation
+ - ``ghpro`` to generate the stats
+
+Make sure you have all the required dependencies to run the tests as well.
+
+You can try to ``source tools/release_helper.sh`` when releasing via bash, it 
+should guide you through most of the process.
+
+
+1. Set Environment variables
+----------------------------
+
+Set environment variables to document previous release tag, current
+release milestone, current release version, and git tag.
+
+These variables may be used later to copy/paste as answers to the script
+questions instead of typing the appropriate command when the time comes. These
+variables are not used by the scripts directly; therefore, there is no need to
+``export`` them. The format for bash is as follows, but note that these values
+are just an example valid only for the 5.0 release; you'll need to update them
+for the release you are actually making::
+
+    PREV_RELEASE=4.2.1
+    MILESTONE=5.0
+    VERSION=5.0.0
+    BRANCH=main
+
+For `reproducibility of builds <https://reproducible-builds.org/specs/source-date-epoch/>`_,
+we recommend setting ``SOURCE_DATE_EPOCH`` prior to running the build; record the used value
+of ``SOURCE_DATE_EPOCH`` as it may not be available from build artifact. You
+should be able to use ``date +%s`` to get a formatted timestamp::
+
+    SOURCE_DATE_EPOCH=$(date +%s)
+
+
+2. Create GitHub stats and finish release note
+----------------------------------------------
+
+.. note::
+
+    This step is optional if making a Beta or RC release.
+
+.. note::
+
+    Before generating the GitHub stats, verify that all closed issues and pull
+    requests have `appropriate milestones
+    <https://github.com/ipython/ipython/wiki/Dev:-GitHub-workflow#milestones>`_.
+    `This search
+    <https://github.com/ipython/ipython/issues?q=is%3Aclosed+no%3Amilestone+is%3Aissue>`_
+    should return no results before creating the GitHub stats.
+
+If a major release:
+
+    - merge any pull request notes into what's new::
+
+          python tools/update_whatsnew.py
+
+    - update ``docs/source/whatsnew/development.rst``, to ensure it covers
+      the major release features
+
+    - move the contents of ``development.rst`` to ``versionX.rst`` where ``X`` is
+      the numerical release version
+
+    - You do not need to temporarily remove the first entry called
+      ``development``, nor re-add it after the release, it will automatically be
+      hidden when releasing a stable version of IPython (if ``_version_extra``
+      in ``release.py`` is an empty string.
+
+      Make sure that the stats file has a header or it won't be rendered in
+      the final documentation.
+
+To find duplicates and update `.mailmap`, use::
+
+    git log --format="%aN <%aE>" $PREV_RELEASE... | sort -u -f
+
+If a minor release you might need to do some of the above points manually, and
+forward port the changes.
+
+3. Make sure the repository is clean
+------------------------------------
+
+of any file that could be problematic.
+   Remove all non-tracked files with:
+
+   .. code::
+
+       git clean -xfdi
+
+   This will ask for confirmation before removing all untracked files. Make
+   sure the ``dist/`` folder is clean to avoid any stale builds from
+   previous build attempts.
+
+
+4. Update the release version number
+------------------------------------
+
+Edit ``IPython/core/release.py`` to have the current version.
+
+in particular, update version number and ``_version_extra`` content in
+``IPython/core/release.py``.
+
+Step 5 will validate your changes automatically, but you might still want to
+make sure the version number matches pep440.
+
+In particular, ``rc`` and ``beta`` are not separated by ``.`` or the ``sdist``
+and ``bdist`` will appear as different releases. For example, a valid version
+number for a release candidate (rc) release is: ``1.3rc1``. Notice that there
+is no separator between the '3' and the 'r'. Check the environment variable
+``$VERSION`` as well.
+
+You will likely just have to modify/comment/uncomment one of the lines setting
+``_version_extra``
+
+
+5. Run the `tools/build_release` script
+---------------------------------------
+
+Running ``tools/build_release`` does all the file checking and building that
+the real release script will do. This makes test installations, checks that
+the build procedure runs OK, and tests other steps in the release process.
+
+The ``build_release`` script will in particular verify that the version number
+match PEP 440, in order to avoid surprise at the time of build upload.
+
+We encourage creating a test build of the docs as well. 
+
+6. Create and push the new tag
+------------------------------
+
+Commit the changes to release.py::
+
+    git commit -am "release $VERSION" -S
+    git push origin $BRANCH
+
+(omit the ``-S`` if you are no signing the package)
+
+Create and push the tag::
+
+    git tag -am "release $VERSION" "$VERSION" -s
+    git push origin $VERSION
+
+(omit the ``-s`` if you are no signing the package)
+
+Update release.py back to ``x.y-dev`` or ``x.y-maint`` commit and push::
+
+    git commit -am "back to development" -S
+    git push origin $BRANCH
+
+(omit the ``-S`` if you are no signing the package)
+
+Now checkout the tag we just made::
+
+    git checkout $VERSION
+
+7. Run the release script
+-------------------------
+
+Run the ``release`` script, this step requires having a current wheel, Python
+>=3.4 and Python 2.7.::
+
+    ./tools/release
+
+This makes the tarballs and wheels, and puts them under the ``dist/``
+folder. Be sure to test the ``wheels``  and the ``sdist`` locally before
+uploading them to PyPI. We do not use an universal wheel as each wheel
+installs an ``ipython2`` or ``ipython3`` script, depending on the version of
+Python it is built for. Using an universal wheel would prevent this.
+
+Check the shasum of files with::
+
+    shasum -a 256 dist/*
+
+and takes notes of them you might need them to update the conda-forge recipes.
+Rerun the command and check the hash have not changed::
+
+    ./tools/release
+    shasum -a 256 dist/*
+
+Use the following to actually upload the result of the build::
+
+    ./tools/release upload
+
+It should posts them to ``archive.ipython.org`` and to PyPI.
+
+PyPI/Warehouse will automatically hide previous releases. If you are uploading
+a non-stable version, make sure to log-in to PyPI and un-hide previous version.
+
+
+8. Draft a short release announcement
+-------------------------------------
+
+The announcement should include:
+
+- release highlights
+- a link to the html version of the *What's new* section of the documentation
+- a link to upgrade or installation tips (if necessary)
+
+Post the announcement to the mailing list and or blog, and link from Twitter.
+
+.. note::
+
+    If you are doing a RC or Beta, you can likely skip the next steps.
+
+9. Update milestones on GitHub
+-------------------------------
+
+These steps will bring milestones up to date:
+
+- close the just released milestone
+- open a new milestone for the next release (x, y+1), if the milestone doesn't
+  exist already
+
+10. Update the IPython website
+------------------------------
+
+The IPython website should document the new release:
+
+- add release announcement (news, announcements)
+- update current version and download links
+- update links on the documentation page (especially if a major release)
+
+11. Update readthedocs
+----------------------
+
+Make sure to update readthedocs and set the latest tag as stable, as well as
+checking that previous release is still building under its own tag.
+
+12. Update the Conda-Forge feedstock
+------------------------------------
+
+Follow the instructions on `the repository <https://github.com/conda-forge/ipython-feedstock>`_
+
+13. Celebrate!
+--------------
+
+Celebrate the release and please thank the contributors for their work. Great
+job!
+
+
+
+Old Documentation
+=================
+
+Out of date documentation is still available and have been kept for archival purposes.
+
+.. note::
+
+  Developers documentation used to be on the IPython wiki, but are now out of
+  date. The wiki is though still available for historical reasons: `Old IPython
+  GitHub Wiki.  <https://github.com/ipython/ipython/wiki/Dev:-Index>`_
diff --git a/docs/source/development/coding_guide.txt b/docs/source/development/coding_guide.txt
deleted file mode 100644
index 9801147a632..00000000000
--- a/docs/source/development/coding_guide.txt
+++ /dev/null
@@ -1,123 +0,0 @@
-============
-Coding guide
-============
-
-General coding conventions
-==========================
-
-In general, we'll try to follow the standard Python style conventions as
-described in Python's PEP 8 [PEP8]_, the official Python Style Guide.
-
-Other general comments:
-
-* In a large file, top level classes and functions should be separated by 2
-  lines to make it easier to separate them visually.
-
-* Use 4 spaces for indentation, **never** use hard tabs.
-
-* Keep the ordering of methods the same in classes that have the same methods.
-  This is particularly true for classes that implement similar interfaces and
-  for interfaces that are similar.
-
-Naming conventions
-==================
-
-In terms of naming conventions, we'll follow the guidelines of PEP 8 [PEP8]_.
-Some of the existing code doesn't honor this perfectly, but for all new
-IPython code (and much existing code is being refactored), we'll use:
-
-* All ``lowercase`` module names.
-
-* ``CamelCase`` for class names.
-
-* ``lowercase_with_underscores`` for methods, functions, variables and
-  attributes.
-
-This may be confusing as some of the existing codebase uses a different
-convention (``lowerCamelCase`` for methods and attributes).  Slowly, we will
-move IPython over to the new convention, providing shadow names for backward
-compatibility in public interfaces.
-
-There are, however, some important exceptions to these rules.  In some cases,
-IPython code will interface with packages (Twisted, Wx, Qt) that use other
-conventions.  At some level this makes it impossible to adhere to our own
-standards at all times.  In particular, when subclassing classes that use other
-naming conventions, you must follow their naming conventions.  To deal with
-cases like this, we propose the following policy:
-
-* If you are subclassing a class that uses different conventions, use its
-  naming conventions throughout your subclass.  Thus, if you are creating a
-  Twisted Protocol class, used Twisted's
-  ``namingSchemeForMethodsAndAttributes.``
-
-* All IPython's official interfaces should use our conventions.  In some cases
-  this will mean that you need to provide shadow names (first implement
-  ``fooBar`` and then ``foo_bar = fooBar``).  We want to avoid this at all
-  costs, but it will probably be necessary at times.  But, please use this
-  sparingly!
-
-Implementation-specific *private* methods will use
-``_single_underscore_prefix``.  Names with a leading double underscore will
-*only* be used in special cases, as they makes subclassing difficult (such
-names are not easily seen by child classes).
-
-Occasionally some run-in lowercase names are used, but mostly for very short
-names or where we are implementing methods very similar to existing ones in a
-base class (like ``runlines()`` where ``runsource()`` and ``runcode()`` had
-established precedent).
-
-The old IPython codebase has a big mix of classes and modules prefixed with an
-explicit ``IP``. In Python this is mostly unnecessary, redundant and frowned
-upon, as namespaces offer cleaner prefixing. The only case where this approach
-is justified is for classes which are expected to be imported into external
-namespaces and a very generic name (like Shell) is too likely to clash with
-something else.  However, if a prefix seems absolutely necessary the more
-specific ``IPY`` or ``ipy`` are preferred.
-
-.. [PEP8] Python Enhancement Proposal 8.  http://www.python.org/peps/pep-0008.html
-
-Attribute declarations for objects
-==================================
-
-In general, objects should declare in their *class* all attributes the object
-is meant to hold throughout its life.  While Python allows you to add an
-attribute to an instance at any point in time, this makes the code harder to
-read and requires methods to constantly use checks with hasattr() or try/except
-calls.  By declaring all attributes of the object in the class header, there is
-a single place one can refer to for understanding the object's data interface,
-where comments can explain the role of each variable and when possible,
-sensible deafaults can be assigned.
-
-.. Warning::
-    
-    If an attribute is meant to contain a mutable object, it should be set to
-    ``None`` in the class and its mutable value should be set in the object's
-    constructor.  Since class attributes are shared by all instances, failure
-    to do this can lead to difficult to track bugs.  But you should still set
-    it in the class declaration so the interface specification is complete and
-    documdented in one place.
-
-A simple example::
-
-    class foo:
-        # X does..., sensible default given:
-        x = 1
-        # y does..., default will be set by constructor
-        y = None
-        # z starts as an empty list, must be set in constructor
-        z = None
-        
-        def __init__(self, y):
-            self.y = y
-            self.z = []
-
-	    
-New files
-=========
-
-When starting a new file for IPython, you can use the following template as a
-starting point that has a few common things pre-written for you.  The template
-is included in the documentation sources as
-:file:`docs/sources/development/template.py`:
-
-.. literalinclude:: template.py
diff --git a/docs/source/development/config.rst b/docs/source/development/config.rst
new file mode 100644
index 00000000000..db9f69bd64f
--- /dev/null
+++ b/docs/source/development/config.rst
@@ -0,0 +1,128 @@
+.. _config_overview:
+
+============================================
+Overview of the IPython configuration system
+============================================
+
+This section describes the IPython configuration system. This is based on
+:mod:`traitlets.config`; see that documentation for more information
+about the overall architecture.
+
+Configuration file location
+===========================
+
+So where should you put your configuration files? IPython uses "profiles" for
+configuration, and by default, all profiles will be stored in the so called
+"IPython directory". The location of this directory is determined by the
+following algorithm:
+
+* If the ``ipython-dir`` command line flag is given, its value is used.
+
+* If not, the value returned by :func:`IPython.paths.get_ipython_dir`
+  is used. This function will first look at the :envvar:`IPYTHONDIR`
+  environment variable and then default to :file:`~/.ipython`.
+  Historical support for the :envvar:`IPYTHON_DIR` environment variable will
+  be removed in a future release.
+
+For most users, the configuration directory will be :file:`~/.ipython`.
+
+Previous versions of IPython on Linux would use the XDG config directory,
+creating :file:`~/.config/ipython` by default. We have decided to go
+back to :file:`~/.ipython` for consistency among systems. IPython will
+issue a warning if it finds the XDG location, and will move it to the new
+location if there isn't already a directory there.
+
+Once the location of the IPython directory has been determined, you need to know
+which profile you are using. For users with a single configuration, this will
+simply be 'default', and will be located in
+:file:`<IPYTHONDIR>/profile_default`.
+
+The next thing you need to know is what to call your configuration file. The
+basic idea is that each application has its own default configuration filename.
+The default named used by the :command:`ipython` command line program is
+:file:`ipython_config.py`, and *all* IPython applications will use this file.
+The IPython kernel will load its own config file *after*
+:file:`ipython_config.py`. To load a particular configuration file instead of
+the default, the name can be overridden by the ``config_file`` command line
+flag.
+
+To generate the default configuration files, do::
+
+    $ ipython profile create
+
+and you will have a default :file:`ipython_config.py` in your IPython directory
+under :file:`profile_default`.
+
+.. note::
+
+    IPython configuration options are case sensitive, and IPython cannot
+    catch misnamed keys or invalid values.
+    
+    By default IPython will also ignore any invalid configuration files. 
+
+.. versionadded:: 5.0
+
+    IPython can be configured to abort in case of invalid configuration file.
+    To do so set the environment variable ``IPYTHON_SUPPRESS_CONFIG_ERRORS`` to
+    `'1'` or `'true'`
+
+
+Locating these files
+--------------------
+
+From the command-line, you can quickly locate the IPYTHONDIR or a specific
+profile with:
+
+.. sourcecode:: bash
+
+    $ ipython locate
+    /home/you/.ipython
+    
+    $ ipython locate profile foo
+    /home/you/.ipython/profile_foo
+
+These map to the utility functions: :func:`IPython.paths.get_ipython_dir`
+and :func:`IPython.paths.locate_profile` respectively.
+
+
+.. _profiles_dev:
+
+Profiles
+========
+
+A profile is a directory containing configuration and runtime files, such as
+logs, connection info for the parallel apps, and your IPython command history.
+
+The idea is that users often want to maintain a set of configuration files for
+different purposes: one for doing numerical computing with NumPy and SciPy and
+another for doing symbolic computing with SymPy. Profiles make it easy to keep a
+separate configuration files, logs, and histories for each of these purposes.
+
+Let's start by showing how a profile is used:
+
+.. code-block:: bash
+
+    $ ipython --profile=sympy
+
+This tells the :command:`ipython` command line program to get its configuration
+from the "sympy" profile. The file names for various profiles do not change. The
+only difference is that profiles are named in a special way. In the case above,
+the "sympy" profile means looking for :file:`ipython_config.py` in :file:`<IPYTHONDIR>/profile_sympy`.
+
+The general pattern is this: simply create a new profile with:
+
+.. code-block:: bash
+
+    $ ipython profile create <name>
+
+which adds a directory called ``profile_<name>`` to your IPython directory. Then
+you can load this profile by adding ``--profile=<name>`` to your command line
+options. Profiles are supported by all IPython applications.
+
+IPython extends the config loader for Python files so that you can inherit
+config from another profile. To do this, use a line like this in your Python
+config file:
+
+.. sourcecode:: python
+
+    load_subconfig('ipython_config.py', profile='default')
diff --git a/docs/source/development/contributing.txt b/docs/source/development/contributing.txt
deleted file mode 100644
index ba80dc00e7b..00000000000
--- a/docs/source/development/contributing.txt
+++ /dev/null
@@ -1,82 +0,0 @@
-.. _contributing:
-
-============================
-How to contribute to IPython
-============================
-
-Overview
-========
-
-IPython development is done using Git [Git]_ and Github.com [Github.com]_.
-This makes it easy for people to contribute to the development of IPython.
-There are several ways in which you can join in.
-
-
-Merging a branch into trunk
-===========================
-
-Core developers, who ultimately merge any approved branch (from themselves,
-another developer, or any third-party contribution) will typically use
-:command:`git merge` to merge the branch into the trunk and push it to the main
-Git repository. There are a number of things to keep in mind when doing this,
-so that the project history is easy to understand in the long run, and that
-generating release notes is as painless and accurate as possible.
-
-* When you merge any non-trivial functionality (from one small bug fix to a
-  big feature branch), please remember to always edit the appropriate file in
-  the :ref:`What's new <whatsnew_index>` section of our documentation.
-  Ideally, the author of the branch should provide this content when they
-  submit the branch for review. But if they don't it is the responsibility of
-  the developer doing the merge to add this information.
-
-* When merges are done, the practice of putting a summary commit message in
-  the merge is *extremely* useful. It is probably easiest if you simply use
-  the same list of changes that were added to the :ref:`What's new
-  <whatsnew_index>` section of the documentation.
-
-* It's important that we remember to always credit who gave us something if
-  it's not the committer. In general, we have been fairly good on this front,
-  this is just a reminder to keep things up. As a note, if you are ever
-  committing something that is completely (or almost so) a third-party
-  contribution, do the commit as::
-  
-    $ git commit --author="Someone Else <who@somewhere.com>"
-
-  This way it will show that name separately in the log, which makes it even
-  easier to spot. Obviously we often rework third party contributions
-  extensively, but this is still good to keep in mind for cases when we don't
-  touch the code too much.
-
-
-.. [Git] The Git version control system. 
-.. [Github.com] Github.com. http://github.com
-
-
-Commit messages
-===============
-
-Good commit messages are very important; they provide a verbal account of what
-happened that is often invaluable for anyone trying to undestand the intent of
-a commit later on (including the original author!).  And git's log command is a
-very versatile and powerful tool, capable of extracting a lot of information
-from the commit logs, so it's important that these logs actually have useful
-information in them.
-
-In short, a commit message should have the form::
-
-  One line summary.
-        <THIS LINE MUST BE LEFT BLANK>
-  More detailed description of what was done, using multiple lines and even
-  more than one paragraph if needed.  For very simple commits this may not be
-  necessary, but non-trivial ones should always have it.
-
-  Closes gh-NNN.  # if the commit closes issue NNN on github.
-
-This format is understood by many git tools that expect a *single line*
-summary, so please do respect it.
-
-An excellent reference on commits message is `this blog post`_, please take a
-moment to read it (it's short but very informative).
-
-.. _this blog post: http://who-t.blogspot.com/2009/12/on-commit-messages.html
-
diff --git a/docs/source/development/doc_guide.txt b/docs/source/development/doc_guide.txt
deleted file mode 100644
index 79bb2aa76d0..00000000000
--- a/docs/source/development/doc_guide.txt
+++ /dev/null
@@ -1,167 +0,0 @@
-.. _documenting-ipython:
-
-=====================
- Documenting IPython
-=====================
-
-When contributing code to IPython, you should strive for clarity and
-consistency, without falling prey to a style straitjacket.  Basically,
-'document everything, try to be consistent, do what makes sense.'
-
-By and large we follow existing Python practices in major projects like Python
-itself or NumPy, this document provides some additional detail for IPython.
-
-
-Standalone documentation
-========================
-
-All standalone documentation should be written in plain text (``.txt``) files
-using reStructuredText [reStructuredText]_ for markup and formatting. All such
-documentation should be placed in the directory :file:`docs/source` of the
-IPython source tree. Or, when appropriate, a suitably named subdirectory
-should be used. The documentation in this location will serve as the main
-source for IPython documentation.
-
-The actual HTML and PDF docs are built using the Sphinx [Sphinx]_
-documentation generation tool. Once you have Sphinx installed, you can build
-the html docs yourself by doing:
-
-.. code-block:: bash
-
-    $ cd ipython-mybranch/docs
-    $ make html
-
-Our usage of Sphinx follows that of matplotlib [Matplotlib]_ closely. We are
-using a number of Sphinx tools and extensions written by the matplotlib team
-and will mostly follow their conventions, which are nicely spelled out in
-their documentation guide [MatplotlibDocGuide]_. What follows is thus a
-abridged version of the matplotlib documentation guide, taken with permission
-from the matplotlib team.
-
-If you are reading this in a web browser, you can click on the "Show Source"
-link to see the original reStricturedText for the following examples.
-
-A bit of Python code::
-
-    for i in range(10):
-        print i,
-    print "A big number:",2**34
-
-An interactive Python session::
-
-    >>> from IPython.utils.path import get_ipython_dir
-    >>> get_ipython_dir()
-    '/home/fperez/.config/ipython'
-
-An IPython session:
-
-.. code-block:: ipython
-
-  In [7]: import IPython
-
-  In [8]: print "This IPython is version:",IPython.__version__
-  This IPython is version: 0.9.1
-
-  In [9]: 2+4
-  Out[9]: 6
-
-
-A bit of shell code:
-
-.. code-block:: bash
-
-    cd /tmp
-    echo "My home directory is: $HOME"
-    ls
-
-Docstring format
-================
-
-Good docstrings are very important.  Unfortunately, Python itself only provides
-a rather loose standard for docstrings [PEP257]_, and there is no universally
-accepted convention for all the different parts of a complete docstring.
-However, the NumPy project has established a very reasonable standard, and has
-developed some tools to support the smooth inclusion of such docstrings in
-Sphinx-generated manuals.  Rather than inventing yet another pseudo-standard,
-IPython will be henceforth documented using the NumPy conventions; we carry
-copies of some of the NumPy support tools to remain self-contained, but share
-back upstream with NumPy any improvements or fixes we may make to the tools.
-
-The NumPy documentation guidelines [NumPyDocGuide]_ contain detailed
-information on this standard, and for a quick overview, the NumPy example
-docstring [NumPyExampleDocstring]_ is a useful read.
-
-
-For user-facing APIs, we try to be fairly strict about following the above
-standards (even though they mean more verbose and detailed docstrings).
-Wherever you can reasonably expect people to do introspection with::
-
-  In [1]: some_function?
-
-the docstring should follow the NumPy style and be fairly detailed.
-
-For purely internal methods that are only likely to be read by others extending
-IPython itself we are a bit more relaxed, especially for small/short methods
-and functions whose intent is reasonably obvious.  We still expect docstrings
-to be written, but they can be simpler.  For very short functions with a
-single-line docstring you can use something like::
-
-    def add(a, b):
-       """The sum of two numbers.
-       """
-       code
-
-and for longer multiline strings::
-
-    def add(a, b):
-       """The sum of two numbers.
-
-       Here is the rest of the docs.
-       """
-       code
-
-
-Here are two additional PEPs of interest regarding documentation of code.
-While both of these were rejected, the ideas therein form much of the basis of
-docutils (the machinery to process reStructuredText):
-
-* `Docstring Processing System Framework <http://www.python.org/peps/pep-0256.html>`_
-* `Docutils Design Specification <http://www.python.org/peps/pep-0258.html>`_
-
-.. note::
-
-   In the past IPython used epydoc so currently many docstrings still use
-   epydoc conventions.  We will update them as we go, but all new code should
-   be documented using the NumPy standard.
-   
-Building and uploading
-======================
-The built docs are stored in a separate repository. Through some github magic,
-they're automatically exposed as a website. It works like this:
-
-* You will need to have sphinx and latex installed. In Ubuntu, install
-  ``texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended``.
-  Install the latest version of sphinx from PyPI (``pip install sphinx``).
-* Ensure that the development version of IPython is the first in your system
-  path. You can either use a virtualenv, or modify your PYTHONPATH.
-* Switch into the docs directory, and run ``make gh-pages``. This will build
-  your updated docs as html and pdf, then automatically check out the latest
-  version of the docs repository, copy the built docs into it, and commit your
-  changes.
-* Open the built docs in a web browser, and check that they're as expected.
-* (When building the docs for a new tagged release, you will have to add its link to
-  index.rst, then run ``python build_index.py`` to update index.html. Commit the 
-  change.)
-* Upload the docs with ``git push``. This only works if you have write access to
-  the docs repository.
-* If you are building a version that is not the current dev branch, nor a tagged release,
-  then you must run gh-pages.py directly with ``python gh-pages.py <version>``, and *not*
-  with ``make gh-pages``.
-
-.. [reStructuredText] reStructuredText.  http://docutils.sourceforge.net/rst.html
-.. [Sphinx] Sphinx. http://sphinx.pocoo.org/
-.. [MatplotlibDocGuide] http://matplotlib.sourceforge.net/devel/documenting_mpl.html
-.. [PEP257] PEP 257.  http://www.python.org/peps/pep-0257.html
-.. [NumPyDocGuide] NumPy documentation guide.  http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines
-.. [NumPyExampleDocstring] NumPy example docstring. http://projects.scipy.org/numpy/browser/trunk/doc/EXAMPLE_DOCSTRING.txt
-
diff --git a/docs/source/development/execution.rst b/docs/source/development/execution.rst
new file mode 100644
index 00000000000..73e386d5c8e
--- /dev/null
+++ b/docs/source/development/execution.rst
@@ -0,0 +1,72 @@
+.. _execution_semantics:
+
+Execution of cells in the IPython kernel
+========================================
+
+When IPython kernel receives `execute_request <https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute>`_
+with user code, it processes the message in the following phases:
+
+1. Fire the ``pre_execute`` event.
+2. Fire the ``pre_run_cell`` event unless silent is ``True``.
+3. Execute ``run_cell`` method to preprocess ``code``, compile and run it, see below for details.
+4. If execution succeeds, expressions in ``user_expressions`` are computed.
+   This ensures that any error in the expressions don't affect the main code execution.
+5. Fire the ``post_execute`` event.
+6. Fire the ``post_run_cell`` event unless silent is ``True``.
+
+.. seealso::
+
+    :doc:`/config/callbacks`
+
+
+Running user ``code``
+=====================
+
+First, the ``code`` cell is transformed to expand ``%magic`` and ``!system``
+commands by ``IPython.core.inputtransformer2``. Then expanded cell is compiled
+using standard Python :func:`compile` function and executed.
+
+Python :func:`compile` function provides ``mode`` argument to select one
+of three ways of compiling code:
+
+*single*
+  Valid for a single interactive statement (though the source can contain
+  multiple lines, such as a for loop).  When compiled in this mode, the
+  generated bytecode contains special instructions that trigger the calling of
+  :func:`sys.displayhook` for any expression in the block that returns a value.
+  This means that a single statement can actually produce multiple calls to
+  :func:`sys.displayhook`, if for example it contains a loop where each
+  iteration computes an unassigned expression would generate 10 calls::
+
+      for i in range(10):
+          i**2
+
+*exec*
+  An arbitrary amount of source code, this is how modules are compiled.
+  :func:`sys.displayhook` is *never* implicitly called.
+
+*eval*
+  A single expression that returns a value.  :func:`sys.displayhook` is *never*
+  implicitly called.
+
+
+The ``code`` field is split into individual blocks each of which is valid for
+execution in 'single' mode, and then:
+
+- If there is only a single block: it is executed in 'single' mode.
+
+- If there is more than one block:
+
+  * if the last block is a single line long, run all but the last in 'exec' mode
+    and the very last one in 'single' mode.  This makes it easy to type simple
+    expressions at the end to see computed values.
+
+  * if the last block is no more than two lines long, run all but the last in
+    'exec' mode and the very last one in 'single' mode.  This makes it easy to
+    type simple expressions at the end to see computed values.  - otherwise
+    (last one is also multiline), run all in 'exec' mode
+
+  * otherwise (last block is also multiline), run all in 'exec' mode as a single
+    unit.
+
+
diff --git a/docs/source/development/figs/allconnections.png b/docs/source/development/figs/allconnections.png
deleted file mode 100644
index bc29fb13b48..00000000000
Binary files a/docs/source/development/figs/allconnections.png and /dev/null differ
diff --git a/docs/source/development/figs/allconnections.svg b/docs/source/development/figs/allconnections.svg
deleted file mode 100644
index 88415b988bc..00000000000
--- a/docs/source/development/figs/allconnections.svg
+++ /dev/null
@@ -1,4012 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
-	<!ENTITY ns_extend "http://ns.adobe.com/Extensibility/1.0/">
-	<!ENTITY ns_ai "http://ns.adobe.com/AdobeIllustrator/10.0/">
-	<!ENTITY ns_graphs "http://ns.adobe.com/Graphs/1.0/">
-	<!ENTITY ns_vars "http://ns.adobe.com/Variables/1.0/">
-	<!ENTITY ns_imrep "http://ns.adobe.com/ImageReplacement/1.0/">
-	<!ENTITY ns_sfw "http://ns.adobe.com/SaveForWeb/1.0/">
-	<!ENTITY ns_custom "http://ns.adobe.com/GenericCustomNamespace/1.0/">
-	<!ENTITY ns_adobe_xpath "http://ns.adobe.com/XPath/1.0/">
-]>
-<svg version="1.1" xmlns:x="&ns_extend;" xmlns:i="&ns_ai;" xmlns:graph="&ns_graphs;"
-	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="432px" height="432px"
-	 viewBox="0 0 432 432" enable-background="new 0 0 432 432" xml:space="preserve">
-<font horiz-adv-x="1000">
-<!-- Copyright 1992, 1994, 1997, 2000, 2004 Adobe Systems Incorporated. All rights reserved. Myriad is either a registered trademark or a trademark of Adobe Systems Incorporated in the United States and/or other countries. -->
-<font-face font-family="MyriadPro-Semibold" units-per-em="1000" underline-position="-100" underline-thickness="50"/>
-<missing-glyph horiz-adv-x="500" d="M0,0l500,0l0,700l-500,0M250,395l-170,255l340,0M280,350l170,255l0,-510M80,50l170,255l170,-255M50,605l170,-255l-170,-255z"/>
-<glyph unicode="B" horiz-adv-x="576" d="M71,2C103,-2 154,-7 222,-7C346,-7 425,14 473,55C511,88 537,135 537,195C537,287 472,343 401,361l0,3C474,391 513,447 513,509C513,567 485,611 443,636C398,667 341,679 251,679C181,679 110,672 71,664M193,583C206,586 227,588 263,588C341,588 389,559 389,495C389,438 342,398 256,398l-63,0M193,309l61,0C339,309 408,277 408,198C408,115 337,86 258,86C230,86 209,86 193,89z"/>
-<glyph unicode="E" horiz-adv-x="515" d="M448,399l-254,0l0,174l269,0l0,101l-392,0l0,-674l407,0l0,101l-284,0l0,198l254,0z"/>
-<glyph unicode="P" horiz-adv-x="559" d="M71,0l122,0l0,255C210,251 230,250 253,250C340,250 416,274 466,323C503,359 523,411 523,475C523,538 497,591 457,624C414,660 349,679 259,679C177,679 116,673 71,665M193,578C206,581 230,584 264,584C349,584 401,545 401,470C401,392 345,346 253,346C228,346 209,347 193,352z"/>
-<glyph unicode="Q" horiz-adv-x="704" d="M673,-10C618,0 553,14 495,30l0,4C594,74 669,183 669,345C669,536 553,686 358,686C165,686 36,540 36,331C36,112 175,-3 331,-11C346,-12 361,-15 375,-21C460,-54 544,-82 638,-108M353,88C235,88 166,200 166,335C166,470 231,587 354,587C476,587 539,468 539,340C539,198 471,88 353,88z"/>
-<glyph unicode="R" horiz-adv-x="569" d="M71,0l122,0l0,277l62,0C325,275 356,247 376,159C394,75 411,20 421,0l126,0C534,26 516,104 494,188C478,253 449,300 400,318l0,3C464,343 523,402 523,489C523,547 502,594 465,625C419,663 354,679 257,679C186,679 118,673 71,664M193,580C205,583 230,586 269,586C349,586 400,551 400,478C400,411 349,367 266,367l-73,0z"/>
-<glyph unicode="S" horiz-adv-x="519" d="M41,32C78,9 152,-11 224,-11C397,-11 479,83 479,192C479,289 423,348 306,392C216,427 177,451 177,503C177,543 210,584 288,584C351,584 398,565 423,552l29,99C417,669 364,685 291,685C144,685 52,602 52,491C52,394 123,335 235,295C320,264 354,234 354,183C354,128 310,91 232,91C169,91 108,111 69,134z"/>
-<glyph unicode="U" horiz-adv-x="666" d="M70,674l0,-386C70,76 171,-11 327,-11C489,-11 596,81 596,289l0,385l-123,0l0,-393C473,149 420,88 331,88C248,88 193,149 193,281l0,393z"/>
-<glyph unicode="X" horiz-adv-x="594" d="M574,0l-205,345l197,329l-141,0l-72,-139C332,494 318,464 300,422l-3,0C280,460 264,493 242,535l-73,139l-142,0l193,-333l-200,-341l141,0l67,134C255,186 273,222 289,261l2,0C311,222 330,186 359,134l72,-134z"/>
-</font>
-
-	<font horiz-adv-x="1000">
-<!-- Copyright 1992, 1994, 1997, 2000, 2004 Adobe Systems Incorporated. All rights reserved. Myriad is either a registered trademark or a trademark of Adobe Systems Incorporated in the United States and/or other countries. -->
-<font-face font-family="MyriadPro-Bold" units-per-em="1000" underline-position="-100" underline-thickness="50"/>
-<missing-glyph horiz-adv-x="500" d="M0,0l500,0l0,700l-500,0M250,395l-170,255l340,0M280,350l170,255l0,-510M80,50l170,255l170,-255M50,605l170,-255l-170,-255z"/>
-<glyph unicode="C" horiz-adv-x="595" d="M538,138C507,125 457,116 410,116C275,116 195,201 195,336C195,486 289,559 409,559C464,559 507,547 537,534l32,120C542,669 482,684 403,684C199,684 35,557 35,327C35,135 155,-11 388,-11C469,-11 533,5 560,18z"/>
-<glyph unicode="E" horiz-adv-x="534" d="M467,409l-248,0l0,140l263,0l0,125l-415,0l0,-674l429,0l0,125l-277,0l0,160l248,0z"/>
-<glyph unicode="H" horiz-adv-x="689" d="M67,674l0,-674l152,0l0,282l251,0l0,-282l152,0l0,674l-152,0l0,-259l-251,0l0,259z"/>
-<glyph unicode="S" horiz-adv-x="540" d="M40,32C78,11 154,-10 231,-10C416,-10 502,86 502,199C502,294 447,356 328,400C240,433 203,452 203,495C203,529 235,560 301,560C366,560 415,541 441,528l34,122C435,669 380,684 303,684C145,684 48,597 48,482C48,384 122,322 234,282C315,254 347,230 347,188C347,144 310,115 240,115C175,115 111,136 71,157z"/>
-<glyph unicode="b" horiz-adv-x="598" d="M61,146C61,91 59,32 57,0l129,0l6,68l2,0C228,10 284,-11 341,-11C453,-11 564,77 564,253C565,403 480,500 363,500C295,500 244,473 215,431l-2,0l0,279l-152,0M213,280C213,290 214,299 216,308C226,352 264,383 305,383C376,383 410,323 410,247C410,159 370,109 305,109C261,109 226,141 216,181C214,189 213,198 213,208z"/>
-<glyph unicode="c" horiz-adv-x="451" d="M410,125C387,115 359,109 323,109C249,109 189,157 189,246C188,326 240,383 320,383C360,383 387,376 405,368l24,113C397,493 353,500 313,500C131,500 33,383 33,240C33,87 134,-10 292,-10C350,-10 401,0 428,13z"/>
-<glyph unicode="d" horiz-adv-x="596" d="M383,710l0,-264l-2,0C359,479 313,501 252,501C135,501 32,405 33,240C33,88 126,-11 242,-11C305,-11 365,17 395,71l3,0l6,-71l135,0C537,33 535,91 535,146l0,564M383,218C383,206 382,194 380,183C371,140 335,110 291,110C228,110 187,162 187,245C187,322 222,384 292,384C339,384 372,350 381,310C383,301 383,290 383,282z"/>
-<glyph unicode="e" horiz-adv-x="528" d="M493,196C495,207 498,230 498,256C498,377 438,500 280,500C110,500 33,363 33,239C33,86 128,-10 294,-10C360,-10 421,0 471,21l-20,103C410,110 368,103 316,103C245,103 182,133 178,196M177,300C181,340 207,399 271,399C341,399 357,337 357,300z"/>
-<glyph unicode="g" horiz-adv-x="585" d="M524,343C524,416 526,457 528,489l-132,0l-5,-59l-2,0C364,471 322,500 255,500C134,500 33,400 33,242C33,102 119,4 240,4C296,4 343,27 372,67l2,0l0,-31C374,-55 319,-93 247,-93C189,-93 136,-74 105,-56l-30,-116C119,-196 186,-209 251,-209C323,-209 396,-195 449,-149C505,-100 524,-23 524,71M372,218C372,205 371,189 367,177C357,142 326,116 286,116C223,116 187,173 187,246C187,335 231,385 287,385C329,385 358,358 369,318C371,309 372,299 372,290z"/>
-<glyph unicode="h" horiz-adv-x="586" d="M61,0l152,0l0,290C213,301 214,314 218,323C229,351 254,377 294,377C351,377 373,333 373,269l0,-269l152,0l0,285C525,433 451,500 354,500C326,500 298,493 275,481C251,469 231,452 215,430l-2,0l0,280l-152,0z"/>
-<glyph unicode="i" horiz-adv-x="274" d="M213,0l0,489l-152,0l0,-489M138,701C89,701 57,668 57,625C57,583 88,549 136,549C187,549 218,583 218,625C217,668 187,701 138,701z"/>
-<glyph unicode="l" horiz-adv-x="275" d="M61,0l152,0l0,710l-152,0z"/>
-<glyph unicode="n" horiz-adv-x="586" d="M61,0l152,0l0,282C213,296 214,310 218,320C229,348 254,377 296,377C351,377 373,334 373,271l0,-271l152,0l0,289C525,433 450,500 350,500C268,500 219,453 199,421l-3,0l-7,68l-132,0C59,445 61,394 61,333z"/>
-<glyph unicode="(" horiz-adv-x="314" d="M174,691C121,613 61,481 60,286C60,94 121,-39 174,-117l106,0C224,-23 179,110 179,286C179,465 224,599 280,691z"/>
-<glyph unicode=")" horiz-adv-x="314" d="M141,-117C194,-38 254,93 255,287C255,483 194,614 141,691l-106,0C91,598 136,465 136,288C136,111 91,-24 35,-117z"/>
-<glyph unicode="r" horiz-adv-x="380" d="M61,0l152,0l0,248C213,260 214,272 216,282C226,329 264,359 320,359C337,359 349,357 361,355l0,143C350,500 343,501 329,501C281,501 222,471 197,399l-4,0l-6,90l-130,0C60,447 61,400 61,328z"/>
-<glyph unicode="s" horiz-adv-x="434" d="M33,24C70,4 127,-11 191,-11C331,-11 402,56 402,148C401,219 363,267 270,299C210,320 191,332 191,356C191,380 212,395 249,395C290,395 333,379 355,367l26,105C351,487 301,501 244,501C123,501 45,432 45,340C44,282 83,227 185,193C241,174 256,162 256,136C256,111 237,96 191,96C146,96 88,115 60,132z"/>
-<glyph unicode="t" horiz-adv-x="367" d="M82,580l0,-91l-65,0l0,-112l65,0l0,-200C82,108 96,61 124,32C149,7 190,-10 239,-10C281,-10 318,-4 337,3l-1,115C322,115 312,114 291,114C246,114 231,141 231,200l0,177l109,0l0,112l-109,0l0,132z"/>
-<glyph unicode="u" horiz-adv-x="583" d="M522,489l-152,0l0,-291C370,185 368,174 364,165C355,141 330,112 288,112C234,112 211,155 211,226l0,263l-152,0l0,-287C59,51 131,-11 231,-11C319,-11 365,39 384,69l3,0l7,-69l132,0C524,41 522,93 522,157z"/>
-</font>
-
-	<font horiz-adv-x="2048">
-<!-- Anonymous Pro is a trademark of Mark Simonson. -->
-<!-- Copyright: Copyright 2011 Adobe System Incorporated. All rights reserved. -->
-<font-face font-family="AnonymousPro" units-per-em="2048" underline-position="-187" underline-thickness="123"/>
-<missing-glyph horiz-adv-x="1118" d="M883,0l-834,0l0,1305l834,0M186,117l559,0l0,1071l-559,0z"/>
-<glyph unicode="A" horiz-adv-x="1118" d="M995,0l-147,0l-123,373l-516,0l-121,-373l-147,0l434,1305l186,0M686,494l-219,673l-219,-673z"/>
-<glyph unicode="D" horiz-adv-x="1118" d="M975,651C975,564 966,481 948,402C929,323 900,253 860,194C819,134 767,87 704,52C640,17 563,0 473,0l-424,0l0,1305l424,0C562,1305 638,1287 702,1252C765,1216 817,1168 858,1108C898,1048 928,979 947,900C966,821 975,738 975,651M838,651C838,822 806,954 742,1048C677,1141 588,1188 473,1188l-287,0l0,-1071l287,0C588,117 677,163 742,256C806,349 838,480 838,651z"/>
-<glyph unicode="E" horiz-adv-x="1118" d="M883,0l-834,0l0,1305l834,0l0,-117l-697,0l0,-467l514,0l0,-117l-514,0l0,-487l697,0z"/>
-<glyph unicode="F" horiz-adv-x="1118" d="M883,1188l-697,0l0,-467l514,0l0,-117l-514,0l0,-604l-137,0l0,1305l834,0z"/>
-<glyph unicode="M" horiz-adv-x="1118" d="M883,0l-138,0l0,1087l-231,-673l-98,0l-230,673l0,-1087l-137,0l0,1305l178,0l238,-682l240,682l178,0z"/>
-<glyph unicode="O" horiz-adv-x="1118" d="M967,651C967,564 958,479 940,398C922,317 893,245 854,183C815,121 763,71 700,34C636,-4 558,-23 467,-23C376,-23 298,-4 235,34C171,71 119,121 80,183C40,245 11,317 -6,398C-24,479 -33,564 -33,651C-33,738 -24,823 -6,904C11,985 40,1057 81,1120C121,1183 173,1233 237,1271C300,1308 377,1327 467,1327C557,1327 634,1308 698,1271C761,1233 813,1183 852,1120C891,1057 920,985 939,904C958,823 967,738 967,651M829,651C829,737 821,815 805,884C788,953 765,1011 734,1060C703,1109 666,1146 621,1172C576,1197 524,1210 467,1210C396,1210 337,1193 291,1160C244,1127 207,1083 179,1029C151,975 132,915 121,849C110,783 104,717 104,651C104,586 110,520 121,454C132,387 151,328 179,275C207,222 244,178 291,145C337,111 396,94 467,94C538,94 596,111 643,145C690,178 727,222 755,275C783,328 802,387 813,454C824,520 829,586 829,651z"/>
-<glyph unicode="Q" horiz-adv-x="1118" d="M967,651C967,568 959,488 944,411C928,334 903,265 868,204C833,143 787,93 731,54C675,14 607,-10 528,-18C543,-107 574,-169 621,-203C667,-237 735,-254 825,-254C848,-254 868,-254 885,-253C901,-252 917,-251 932,-250l0,-117C913,-368 894,-369 877,-370C859,-371 842,-371 825,-371C689,-371 587,-342 518,-284C449,-226 406,-137 391,-16C318,-7 254,17 200,56C146,94 102,143 68,202C33,261 8,330 -8,407C-25,484 -33,565 -33,651C-33,738 -24,823 -6,904C11,985 40,1057 81,1120C121,1183 173,1233 237,1271C300,1308 377,1327 467,1327C557,1327 634,1308 698,1271C761,1233 813,1183 852,1120C891,1057 920,985 939,904C958,823 967,738 967,651M829,651C829,717 823,783 812,849C801,915 781,975 754,1029C727,1083 689,1127 642,1160C595,1193 536,1210 467,1210C396,1210 337,1193 291,1160C244,1127 207,1083 179,1029C151,975 132,915 121,849C110,783 104,717 104,651C104,478 136,342 199,243C262,144 351,94 467,94C582,94 671,144 734,243C797,342 829,478 829,651z"/>
-<glyph unicode="R" horiz-adv-x="1118" d="M944,0l-174,0l-381,559l-203,0l0,-559l-137,0l0,1305l430,0C622,1305 733,1274 812,1212C891,1149 930,1056 930,932C930,877 920,828 901,785C882,741 855,704 822,673C789,642 749,618 703,599C656,580 606,569 551,565M788,932C788,1021 761,1086 706,1127C651,1168 575,1188 479,1188l-293,0l0,-512l293,0C575,676 651,696 706,737C761,777 788,842 788,932z"/>
-<glyph unicode="W" horiz-adv-x="1118" d="M995,1305l-235,-1305l-162,0l-133,637l-135,-637l-160,0l-233,1305l145,0l184,-1074l131,701l135,0l132,-701l184,1074z"/>
-<glyph unicode="Z" horiz-adv-x="1118" d="M887,0l-838,0l0,117l656,1071l-539,0l0,-320l-117,0l0,437l817,0l0,-117l-649,-1071l553,0l0,325l117,0z"/>
-<glyph unicode="_" horiz-adv-x="1118" d="M932,-186l-932,0l0,117l932,0z"/>
-</font>
-
-	<font horiz-adv-x="1000">
-<!-- Copyright 1992, 1994, 1997, 2000, 2004 Adobe Systems Incorporated. All rights reserved. Myriad is either a registered trademark or a trademark of Adobe Systems Incorporated in the United States and/or other countries. -->
-<font-face font-family="MyriadPro-Regular" units-per-em="1000" underline-position="-100" underline-thickness="50"/>
-<missing-glyph horiz-adv-x="500" d="M0,0l500,0l0,700l-500,0M250,395l-170,255l340,0M280,350l170,255l0,-510M80,50l170,255l170,-255M50,605l170,-255l-170,-255z"/>
-<glyph unicode="A" horiz-adv-x="612" d="M424,212l72,-212l93,0l-230,674l-104,0l-230,-674l90,0l70,212M203,280l66,195C283,516 293,558 303,597l2,0C315,558 325,518 340,474l67,-194z"/>
-<glyph unicode="B" horiz-adv-x="542" d="M76,2C105,-2 151,-6 211,-6C321,-6 397,14 443,57C478,89 501,134 501,192C501,292 426,345 362,360l0,3C432,388 476,445 476,511C476,564 454,604 419,630C378,664 322,679 235,679C175,679 114,673 76,664M163,606C177,609 200,612 240,612C328,612 387,580 387,502C387,437 333,388 242,388l-79,0M163,323l72,0C330,323 409,284 409,193C409,95 326,62 236,62C205,62 181,63 163,66z"/>
-<glyph unicode="C" horiz-adv-x="580" d="M529,91C494,74 440,63 386,63C223,63 128,168 128,334C128,511 233,612 391,612C447,612 494,600 526,584l22,71C525,667 471,685 388,685C179,685 36,543 36,331C36,109 178,-11 368,-11C450,-11 515,5 546,21z"/>
-<glyph unicode="D" horiz-adv-x="666" d="M76,2C120,-3 171,-6 234,-6C365,-6 469,28 533,91C595,153 630,243 630,353C630,462 595,540 534,595C475,649 386,679 261,679C192,679 129,673 76,664M163,601C186,606 220,610 265,610C449,610 539,509 538,350C538,168 438,64 251,64C217,64 185,65 163,68z"/>
-<glyph unicode="H" horiz-adv-x="652" d="M75,674l0,-674l88,0l0,316l326,0l0,-316l88,0l0,674l-88,0l0,-282l-326,0l0,282z"/>
-<glyph unicode="I" horiz-adv-x="239" d="M75,674l0,-674l88,0l0,674z"/>
-<glyph unicode="M" horiz-adv-x="804" d="M660,0l86,0l-42,674l-111,0l-120,-326C443,263 419,189 401,121l-2,0C381,191 359,265 331,348l-115,326l-111,0l-47,-674l83,0l18,289C165,391 170,503 172,587l2,0C193,507 219,421 251,325l110,-321l66,0l119,327C580,424 607,509 631,587l2,0C633,504 639,390 644,296z"/>
-<glyph unicode="N" horiz-adv-x="658" d="M158,0l0,288C158,400 157,481 152,566l3,1C188,494 233,417 280,342l214,-342l88,0l0,674l-82,0l0,-282C500,287 502,205 510,115l-3,-1C476,183 436,254 387,333l-215,341l-96,0l0,-674z"/>
-<glyph unicode="O" horiz-adv-x="689" d="M348,686C168,686 36,546 36,332C36,128 160,-11 339,-11C511,-11 652,113 652,344C652,545 533,686 348,686M345,615C490,615 560,475 560,340C560,187 482,60 344,60C206,60 128,189 128,334C128,481 200,615 345,615z"/>
-<glyph unicode="P" horiz-adv-x="532" d="M76,0l87,0l0,270C183,265 207,264 233,264C318,264 392,289 439,338C473,373 491,421 491,482C491,542 468,591 432,623C392,659 329,679 243,679C173,679 118,673 76,666M163,603C178,607 207,610 245,610C340,610 404,567 404,477C404,386 340,334 235,334C206,334 182,336 163,341z"/>
-<glyph unicode="Q" horiz-adv-x="689" d="M657,-26C600,-16 527,0 460,17l0,4C572,61 652,171 652,345C652,544 533,686 349,686C167,686 36,547 36,331C36,113 172,-5 333,-11C346,-11 359,-16 374,-21C452,-48 541,-75 632,-99M344,60C206,60 128,189 128,333C128,479 200,615 347,615C490,615 560,476 560,340C560,187 482,60 344,60z"/>
-<glyph unicode="R" horiz-adv-x="538" d="M76,0l87,0l0,292l82,0C324,289 361,254 381,161C399,77 414,20 425,0l90,0C501,26 485,91 463,185C447,255 416,303 365,321l0,3C435,348 491,407 491,495C491,548 471,594 438,624C397,661 336,679 243,679C184,679 120,673 76,665M163,604C178,608 207,611 249,611C341,611 404,573 404,486C404,409 345,358 252,358l-89,0z"/>
-<glyph unicode="T" horiz-adv-x="497" d="M204,0l88,0l0,600l206,0l0,74l-499,0l0,-74l205,0z"/>
-<glyph unicode="U" horiz-adv-x="647" d="M75,674l0,-397C75,67 179,-11 317,-11C463,-11 572,73 572,280l0,394l-88,0l0,-400C484,126 419,60 320,60C230,60 163,124 163,274l0,400z"/>
-<glyph unicode="X" horiz-adv-x="571" d="M546,0l-210,346l205,328l-101,0l-91,-158C324,473 307,442 288,402l-3,0C267,438 248,472 223,516l-89,158l-101,0l198,-333l-206,-341l100,0l81,148C240,207 260,243 279,282l2,0C302,243 323,206 358,149l87,-149z"/>
-<glyph unicode="a" horiz-adv-x="482" d="M413,297C413,393 377,494 229,494C168,494 109,477 69,452l20,-59C123,416 170,429 216,429C315,430 326,357 326,318l0,-10C139,309 35,245 35,128C35,58 85,-11 183,-11C252,-11 304,23 331,61l3,0l7,-61l79,0C415,33 413,74 413,116M328,163C328,155 327,145 324,135C310,94 269,54 205,54C161,54 123,80 123,138C123,232 232,249 328,247z"/>
-<glyph unicode="b" horiz-adv-x="569" d="M73,125C73,82 71,33 69,0l75,0l5,79l2,0C188,16 244,-11 314,-11C422,-11 532,75 532,248C532,394 448,494 327,494C249,494 193,460 162,406l-2,0l0,304l-87,0M160,280C160,294 162,306 165,317C183,383 239,425 298,425C393,425 443,342 443,245C443,134 389,59 296,59C232,59 180,101 164,162C161,172 160,183 160,194z"/>
-<glyph unicode="c" horiz-adv-x="448" d="M403,83C378,72 345,60 295,60C199,60 127,129 127,241C127,341 187,424 298,424C346,424 379,412 400,401l20,67C396,481 350,494 298,494C140,494 38,385 38,236C38,88 133,-11 279,-11C344,-11 395,6 418,17z"/>
-<glyph unicode="d" horiz-adv-x="564" d="M403,710l0,-289l-2,0C379,459 330,494 255,494C138,494 37,396 38,235C38,88 129,-11 246,-11C325,-11 383,30 409,84l3,0l4,-84l78,0C492,33 490,82 490,125l0,585M403,203C403,189 402,177 399,165C383,100 329,60 270,60C176,60 127,141 127,239C127,345 181,425 272,425C338,425 386,379 399,324C402,313 403,298 403,287z"/>
-<glyph unicode="e" horiz-adv-x="501" d="M462,226C464,236 465,249 465,267C465,356 424,494 265,494C124,494 38,380 38,234C38,88 127,-11 276,-11C353,-11 407,6 438,20l-16,63C390,69 351,58 288,58C199,58 124,107 122,226M123,289C130,350 168,431 258,431C357,431 381,344 380,289z"/>
-<glyph unicode="f" horiz-adv-x="292" d="M169,0l0,417l117,0l0,67l-117,0l0,26C169,585 188,650 263,650C289,650 306,645 319,639l12,68C314,714 288,721 256,721C215,721 171,708 138,676C98,637 82,575 82,507l0,-23l-67,0l0,-67l67,0l0,-417z"/>
-<glyph unicode="g" horiz-adv-x="559" d="M487,352C487,410 488,450 491,484l-78,0l-3,-73l-2,0C386,451 341,494 257,494C145,494 38,402 38,238C38,104 124,2 244,2C319,2 372,38 398,83l2,0l0,-53C400,-93 334,-140 244,-140C184,-140 134,-122 102,-101l-22,-68C119,-195 183,-209 241,-209C302,-209 370,-194 418,-151C464,-108 487,-41 487,71M399,206C399,191 397,174 392,159C374,103 325,69 270,69C176,69 127,148 127,243C127,355 187,426 271,426C336,426 378,384 394,332C398,321 399,308 399,293z"/>
-<glyph unicode="i" horiz-adv-x="234" d="M161,0l0,484l-88,0l0,-484M117,675C84,675 62,650 62,620C62,590 83,566 115,566C150,566 171,590 171,620C171,651 149,675 117,675z"/>
-<glyph unicode="k" horiz-adv-x="469" d="M160,710l-87,0l0,-710l87,0l0,182l45,50l166,-232l108,0l-213,285l186,199l-105,0l-143,-167C190,300 174,279 162,262l-2,0z"/>
-<glyph unicode="l" horiz-adv-x="236" d="M73,0l88,0l0,710l-88,0z"/>
-<glyph unicode="n" horiz-adv-x="555" d="M73,0l88,0l0,291C161,306 163,321 167,332C183,381 228,422 285,422C368,422 397,357 397,279l0,-279l88,0l0,288C485,454 381,494 314,494C234,494 178,449 154,404l-2,0l-5,80l-78,0C72,444 73,404 73,353z"/>
-<glyph unicode="o" horiz-adv-x="549" d="M278,494C145,494 38,399 38,238C38,85 140,-11 270,-11C386,-11 511,67 511,246C511,393 417,494 278,494M276,428C380,428 421,325 421,243C421,134 358,55 274,55C188,55 128,135 128,241C128,332 173,428 276,428z"/>
-<glyph unicode="p" horiz-adv-x="569" d="M73,-198l87,0l0,263l2,0C191,17 247,-11 311,-11C425,-11 532,75 532,249C532,395 444,494 326,494C247,494 189,460 154,401l-2,0l-5,83l-78,0C71,438 73,388 73,326M160,281C160,292 163,305 166,316C182,382 239,424 299,424C392,424 443,341 443,245C443,134 389,58 296,58C233,58 180,100 164,161C161,172 160,184 160,197z"/>
-<glyph unicode="." horiz-adv-x="207" d="M110,-11C147,-11 171,16 171,52C171,89 147,115 112,115C77,115 52,88 52,52C52,16 76,-11 110,-11z"/>
-<glyph unicode="r" horiz-adv-x="327" d="M73,0l88,0l0,258C161,272 162,287 164,299C176,365 220,411 282,411C294,411 303,411 312,409l0,83C304,493 297,494 288,494C229,494 175,453 153,388l-3,0l-4,96l-77,0C72,439 73,390 73,333z"/>
-<glyph unicode="s" horiz-adv-x="396" d="M40,23C74,3 123,-11 176,-11C289,-11 356,49 356,135C356,207 312,249 229,280C166,305 138,323 138,363C138,399 166,429 218,429C263,429 298,412 317,400l21,64C312,481 269,494 220,494C117,494 53,430 53,352C53,294 94,247 182,215C246,191 271,169 271,127C271,86 241,55 178,55C134,55 88,73 61,89z"/>
-<glyph unicode="/" horiz-adv-x="343" d="M66,-39l280,725l-69,0l-278,-725z"/>
-<glyph unicode="t" horiz-adv-x="331" d="M93,574l0,-90l-75,0l0,-67l75,0l0,-264C93,96 103,53 127,26C148,3 181,-11 222,-11C256,-11 283,-5 300,1l-4,67C283,64 269,62 245,62C196,62 179,96 179,156l0,261l126,0l0,67l-126,0l0,116z"/>
-<glyph unicode="u" horiz-adv-x="551" d="M478,484l-88,0l0,-296C390,171 387,155 382,143C366,103 325,62 266,62C187,62 158,125 158,217l0,267l-88,0l0,-283C70,32 161,-11 237,-11C323,-11 375,40 397,79l2,0l5,-79l78,0C479,38 478,82 478,133z"/>
-<glyph unicode="y" horiz-adv-x="471" d="M9,484l178,-446C192,27 194,20 194,15C194,10 191,3 187,-6C166,-51 137,-85 113,-104C87,-126 58,-140 36,-147l22,-73C80,-216 122,-201 166,-164C226,-111 269,-27 332,139l132,345l-93,0l-96,-284C263,165 253,128 244,99l-2,0C234,128 222,166 210,198l-105,286z"/>
-</font>
-
-	<switch>
-	<foreignObject requiredExtensions="&ns_ai;" x="0" y="0" width="1" height="1">
-		<i:pgfRef  xlink:href="#adobe_illustrator_pgf">
-		</i:pgfRef>
-	</foreignObject>
-	<g i:extraneous="self">
-		<g id="Layer_9" display="none">
-			<rect x="-21.334" y="22.34" display="inline" fill="#231F20" width="472" height="414"/>
-		</g>
-		<g id="BG">
-			<rect x="113.277" y="116" fill="#A6A8AB" width="164.261" height="160"/>
-		</g>
-		<g id="iopub">
-			<g>
-				<g>
-					<path fill="none" stroke="#58595B" stroke-width="2" stroke-miterlimit="10" d="M96,209.005
-						c12.341-3.63,39.817-7.253,49.52-39.81"/>
-					<g>
-						<path fill="#58595B" d="M147,163.339c0.311,3.013,1.171,6.874,2.469,9.465l-4.175-2.854l-5.034,0.478
-							C142.65,168.788,145.271,165.826,147,163.339z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M113.333,323.666
-						c0,0-44.272-44.267-47.208-85.962"/>
-					<g>
-						<path fill="#231F20" d="M66,231.667c1.138,2.807,3.041,6.275,5.01,8.401l-4.805-1.577l-4.701,1.862
-							C63.341,238.112,65.033,234.537,66,231.667z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M116.667,93.338
-						c0,0-44.791,51.146-49.015,92.304"/>
-					<g>
-						<path fill="#231F20" d="M67.333,191.673c-0.877-2.899-2.454-6.527-4.22-8.824l4.641,2.01l4.852-1.424
-							C70.57,185.497,68.558,188.903,67.333,191.673z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="#00ADEE" d="M98.835,337.821c-0.552,0-1-0.448-1-1v-21.601c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.601
-						c0,0.552-0.448,1-1,1H98.835z"/>
-					<path fill="#231F20" d="M134.835,315.221v21.601h-36v-21.601H134.835 M134.835,313.221h-36c-1.104,0-2,0.896-2,2v21.601
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.601C136.835,314.116,135.939,313.221,134.835,313.221L134.835,313.221z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 106.0293 329.543)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-			</g>
-			<g>
-				<g>
-					<path fill="#262261" d="M112.835,98.153c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H112.835z"/>
-					<path fill="#231F20" d="M148.835,75.553v21.6h-36v-21.6H148.835 M148.835,73.553h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C150.835,74.449,149.939,73.553,148.835,73.553L148.835,73.553z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 120.269 89.8755)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">SUB</text>
-			</g>
-			<text transform="matrix(1 0 0 1 117.6836 71)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">IOPub</text>
-			<g>
-				<g id="PUB_3_">
-					<g>
-						<path fill="#00ADEE" d="M51.667,211.667c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.552,0,1,0.448,1,1v16
-							c0,0.552-0.448,1-1,1H51.667z"/>
-						<path fill="#231F20" d="M81.667,194.667v16h-30v-16H81.667 M81.667,192.667h-30c-1.104,0-2,0.896-2,2v16c0,1.104,0.896,2,2,2
-							h30c1.104,0,2-0.896,2-2v-16C83.667,193.562,82.771,192.667,81.667,192.667L81.667,192.667z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 55.8608 206.1885)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-				</g>
-				<g id="SUB_1_">
-					<g>
-						<path fill="#262261" d="M51.667,229.667c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.552,0,1,0.448,1,1v16
-							c0,0.552-0.448,1-1,1H51.667z"/>
-						<path fill="#231F20" d="M81.667,212.667v16h-30v-16H81.667 M81.667,210.667h-30c-1.104,0-2,0.896-2,2v16c0,1.104,0.896,2,2,2
-							h30c1.104,0,2-0.896,2-2v-16C83.667,211.562,82.771,210.667,81.667,210.667L81.667,210.667z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 56.1006 224.1885)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">SUB</text>
-				</g>
-				<g id="PUB_4_">
-					<g>
-						<path fill="#00ADEE" d="M83.667,225.667c-0.552,0-1-0.448-1-1v-24c0-0.552,0.448-1,1-1h16c0.552,0,1,0.448,1,1v24
-							c0,0.552-0.448,1-1,1H83.667z"/>
-						<path fill="#231F20" d="M99.667,200.667v24h-16v-24H99.667 M99.667,198.667h-16c-1.104,0-2,0.896-2,2v24c0,1.104,0.896,2,2,2
-							h16c1.104,0,2-0.896,2-2v-24C101.667,199.562,100.771,198.667,99.667,198.667L99.667,198.667z"/>
-					</g>
-					<text transform="matrix(0 1 -1 0 87.6655 202.3823)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 92.333 349.002)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">stdout/err</text>
-		</g>
-		<g id="Notification">
-			<g>
-				<g>
-					<path fill="#00ADEE" d="M222.667,161.041c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H222.667z"/>
-					<path fill="#231F20" d="M258.667,138.44v21.6h-36v-21.6H258.667 M258.667,136.44h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C260.667,137.336,259.771,136.44,258.667,136.44L258.667,136.44z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 229.8608 152.7627)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-			</g>
-			<g>
-				<g>
-					<path fill="#262261" d="M223.001,60.986c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H223.001z"/>
-					<path fill="#231F20" d="M259.001,38.386v21.6h-36v-21.6H259.001 M259.001,36.386h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C261.001,37.282,260.106,36.386,259.001,36.386L259.001,36.386z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 230.4355 52.7085)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">SUB</text>
-			</g>
-			<g>
-				<g>
-					<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" x1="241.667" y1="62" x2="241.667" y2="129.965"/>
-					<g>
-						<path fill="#231F20" d="M241.667,136c-1.054-2.84-2.852-6.363-4.756-8.547l4.756,1.72l4.755-1.72
-							C244.517,129.637,242.719,133.16,241.667,136z"/>
-					</g>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 228.6665 34)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Notif.</text>
-		</g>
-		<g id="HB">
-			<g>
-				<g>
-					<path fill="#00A551" d="M210,245.619c-0.552,0-1-0.448-1-1v-21.601c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.601
-						c0,0.552-0.448,1-1,1H210z"/>
-					<path fill="#231F20" d="M246,223.019v21.601h-36v-21.601H246 M246,221.019h-36c-1.104,0-2,0.896-2,2v21.601
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.601C248,221.914,247.104,221.019,246,221.019L246,221.019z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 214.5781 237.3408)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-			</g>
-			<g>
-				<g>
-					<path fill="#00ADEE" d="M146.449,245.619c-0.552,0-1-0.448-1-1v-21.601c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.601
-						c0,0.552-0.448,1-1,1H146.449z"/>
-					<path fill="#231F20" d="M182.449,223.019v21.601h-36v-21.601H182.449 M182.449,221.019h-36c-1.104,0-2,0.896-2,2v21.601
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.601C184.449,221.914,183.553,221.019,182.449,221.019L182.449,221.019z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 153.6436 237.3413)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-			</g>
-			<g>
-				<g>
-					<g>
-						<path fill="#006838" d="M212.05,378.868c-0.552,0-1-0.447-1-1v-21.601c0-0.553,0.448-1,1-1h36c0.552,0,1,0.447,1,1v21.601
-							c0,0.553-0.448,1-1,1H212.05z"/>
-						<path fill="#231F20" d="M248.05,356.268v21.601h-36v-21.601H248.05 M248.05,354.268h-36c-1.104,0-2,0.896-2,2v21.601
-							c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.601C250.05,355.163,249.154,354.268,248.05,354.268L248.05,354.268z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 215.7568 370.5898)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">XREQ</text>
-				</g>
-				<g>
-					<g>
-						<path fill="#262261" d="M146.331,378.867c-0.552,0-1-0.447-1-1v-21.601c0-0.553,0.448-1,1-1h36c0.552,0,1,0.447,1,1v21.601
-							c0,0.553-0.448,1-1,1H146.331z"/>
-						<path fill="#231F20" d="M182.331,356.267v21.601h-36v-21.601H182.331 M182.331,354.267h-36c-1.104,0-2,0.896-2,2v21.601
-							c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.601C184.331,355.162,183.436,354.267,182.331,354.267L182.331,354.267z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 153.7646 370.5898)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">SUB</text>
-				</g>
-				<text transform="matrix(1 0 0 1 156.1099 389.8672)" fill="#231F20" font-family="'AnonymousPro'" font-size="12">ZMQ_FORWARDER</text>
-				<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M250.351,382.873c0,6.628-5.373,12-12,12H156.04
-					c-6.627,0-12-5.372-12-12V358.33c0-6.628,5.374-12,12-12h82.311c6.627,0,12,5.372,12,12V382.873z"/>
-				<g>
-					<g>
-						
-							<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" x1="183.846" y1="366.232" x2="185.846" y2="366.232"/>
-						
-							<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="3.3328,3.3328" x1="189.179" y1="366.232" x2="200.843" y2="366.232"/>
-						
-							<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" x1="202.51" y1="366.232" x2="204.51" y2="366.232"/>
-						<g>
-							<path fill="#231F20" d="M210.545,366.232c-2.84,1.054-6.363,2.852-8.547,4.756l1.72-4.756l-1.72-4.755
-								C204.182,363.382,207.705,365.18,210.545,366.232z"/>
-						</g>
-					</g>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 172.1396 409.9219)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Heartbeat</text>
-			<g>
-				<g>
-					<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" x1="164" y1="356" x2="164" y2="253.035"/>
-					<g>
-						<path fill="#231F20" d="M164,247c1.054,2.84,2.852,6.363,4.756,8.547l-4.756-1.72l-4.755,1.72
-							C161.149,253.363,162.947,249.84,164,247z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" x1="230" y1="356" x2="230" y2="253.035"/>
-					<g>
-						<path fill="#231F20" d="M230,247c1.054,2.84,2.852,6.363,4.756,8.547l-4.756-1.72l-4.755,1.72
-							C227.149,253.363,228.947,249.84,230,247z"/>
-					</g>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 136.8867 285)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">ping</text>
-			<text transform="matrix(1 0 0 1 231.5 285)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">pong</text>
-		</g>
-		<g id="Fade" display="none">
-			<g display="inline">
-				<rect x="-20" y="-14" opacity="0.8" fill="#FFFFFF" width="468" height="457"/>
-			</g>
-		</g>
-		<g id="Queues">
-			<g>
-				<g>
-					<path fill="none" stroke="#58595B" stroke-width="2" stroke-miterlimit="10" d="M298.667,168.338
-						c-61.639,15.41-93.643-14.208-118.669-14.02"/>
-					<g>
-						<path fill="#58595B" d="M174,155c2.72-1.332,6.046-3.473,8.029-5.586l-1.236,4.904l2.187,4.559
-							C180.616,157.2,176.931,155.763,174,155z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M332.962,352.078
-						c0,0,31.582-81.111,35.887-112.396"/>
-					<g>
-						<path fill="#231F20" d="M369.333,233.668c0.792,2.923,2.265,6.595,3.963,8.942l-4.581-2.143l-4.891,1.283
-							C365.918,239.748,368.028,236.401,369.333,233.668z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M337.667,74.333
-						c0,15.167,31.244,51.582,33.234,111.965"/>
-					<g>
-						<path fill="#231F20" d="M371,192.333c-1.144-2.805-3.054-6.269-5.027-8.391l4.809,1.567l4.697-1.871
-							C373.646,185.882,371.961,189.461,371,192.333z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#58595B" stroke-width="2" stroke-miterlimit="10" d="M343.333,215.671
-						c-44.127,0-93.308-29.062-162.914-51.513"/>
-					<g>
-						<path fill="#58595B" d="M174.667,162.333c3.027-0.097,6.939-0.681,9.616-1.792l-3.143,3.962l0.12,5.055
-							C179.794,167.058,177.024,164.234,174.667,162.333z"/>
-					</g>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 300.9097 387.2949)"><tspan x="0" y="0" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Apply</tspan><tspan x="-2.016" y="14.4" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Queue</tspan></text>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M317.667,351.667
-						c0,0,10.511-68.802,10.983-155.964"/>
-					<g>
-						<path fill="#231F20" d="M328.667,189.668c1.013,2.854,2.76,6.404,4.632,8.615l-4.73-1.789l-4.779,1.651
-							C325.725,195.99,327.573,192.492,328.667,189.668z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M295,79.667
-						c0,17.624,23.769,29.9,26.425,62.635"/>
-					<g>
-						<path fill="#231F20" d="M321.667,148.334c-1.179-2.79-3.132-6.23-5.132-8.327l4.828,1.507l4.674-1.93
-							C324.231,141.851,322.592,145.451,321.667,148.334z"/>
-					</g>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 275.8867 54.334)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Direct</text>
-			<g>
-				<g>
-					<path fill="#262261" d="M136.22,161.392c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H136.22z"/>
-					<path fill="#231F20" d="M172.22,138.792v21.6h-36v-21.6H172.22 M172.22,136.792h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C174.22,137.688,173.325,136.792,172.22,136.792L172.22,136.792z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 143.6543 153.1143)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">SUB</text>
-			</g>
-			<text transform="matrix(1 0 0 1 137.5884 135.9995)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="10">Monitor</text>
-			<text transform="matrix(1 0 0 1 54.5151 387.9609)"><tspan x="0" y="0" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Control</tspan><tspan x="2.004" y="14.4" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Queue</tspan></text>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M63,356c0,0-37.397-72.556-38.95-166.964"/>
-					<g>
-						<path fill="#231F20" d="M24,183.001c1.123,2.813,3.006,6.292,4.962,8.429l-4.796-1.604l-4.711,1.835
-							C21.305,189.432,23.017,185.866,24,183.001z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" d="M77.333,75.001
-						c0,0-44.514,38.034-51.694,62.041"/>
-					<g>
-						<path fill="#231F20" d="M24.667,143.001c-0.541-2.98-1.694-6.764-3.187-9.248l4.381,2.526l4.982-0.862
-							C28.586,137.235,26.2,140.389,24.667,143.001z"/>
-					</g>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 55.2383 51)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Control</text>
-			<g>
-				<g>
-					<path fill="#006838" d="M55.5,78.009c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H55.5z"/>
-					<path fill="#231F20" d="M91.5,55.409v21.6h-36v-21.6H91.5 M91.5,53.409h-36c-1.104,0-2,0.896-2,2v21.6c0,1.104,0.896,2,2,2h36
-						c1.104,0,2-0.896,2-2v-21.6C93.5,54.304,92.604,53.409,91.5,53.409L91.5,53.409z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 59.208 69.731)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">XREQ</text>
-			</g>
-			<g>
-				<g>
-					<path fill="#00A551" d="M296.962,374.679c-0.552,0-1-0.448-1-1v-21.601c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.601
-						c0,0.552-0.448,1-1,1H296.962z"/>
-					<path fill="#231F20" d="M332.962,352.078v21.601h-36v-21.601H332.962 M332.962,350.078h-36c-1.104,0-2,0.896-2,2v21.601
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.601C334.962,350.974,334.067,350.078,332.962,350.078L332.962,350.078z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 301.5405 366.4004)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-			</g>
-			<g>
-				<g id="XREP_6_">
-					<g>
-						<path fill="#00A551" d="M356.666,214.333c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.553,0,1,0.448,1,1v16
-							c0,0.552-0.447,1-1,1H356.666z"/>
-						<path fill="#231F20" d="M386.666,197.333v16h-30v-16H386.666 M386.666,195.333h-30c-1.104,0-2,0.896-2,2v16
-							c0,1.104,0.896,2,2,2h30c1.104,0,2-0.896,2-2v-16C388.666,196.229,387.771,195.333,386.666,195.333L386.666,195.333z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 358.2441 209.8555)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-				</g>
-				<g id="PUB_5_">
-					<g>
-						<path fill="#00ADEE" d="M338.666,227.333c-0.552,0-1-0.448-1-1v-24c0-0.552,0.448-1,1-1h16c0.552,0,1,0.448,1,1v24
-							c0,0.552-0.448,1-1,1H338.666z"/>
-						<path fill="#231F20" d="M354.666,202.333v24h-16v-24H354.666 M354.666,200.333h-16c-1.104,0-2,0.896-2,2v24
-							c0,1.104,0.896,2,2,2h16c1.104,0,2-0.896,2-2v-24C356.666,201.229,355.771,200.333,354.666,200.333L354.666,200.333z"/>
-					</g>
-					<text transform="matrix(0 -1 1 0 350.6665 225.6611)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-				</g>
-				<g id="XREQ_1_">
-					<g>
-						<path fill="#006838" d="M356.666,232.333c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.553,0,1,0.448,1,1v16
-							c0,0.552-0.447,1-1,1H356.666z"/>
-						<path fill="#231F20" d="M386.666,215.333v16h-30v-16H386.666 M386.666,213.333h-30c-1.104,0-2,0.896-2,2v16
-							c0,1.104,0.896,2,2,2h30c1.104,0,2-0.896,2-2v-16C388.666,214.229,387.771,213.333,386.666,213.333L386.666,213.333z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 357.374 226.8555)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">XREQ</text>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="none" stroke="#58595B" stroke-width="2" stroke-miterlimit="10" d="M56.667,163.672
-						c17.112,1.268,33.329-9.304,70.679-14.561"/>
-					<g>
-						<path fill="#58595B" d="M133.333,148.338c-2.658,1.453-5.884,3.742-7.77,5.941l1.015-4.955l-2.39-4.456
-							C126.625,146.438,130.371,147.707,133.333,148.338z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g id="XREP_1_">
-					<g>
-						<path fill="#00A551" d="M8,163.167c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.552,0,1,0.448,1,1v16
-							c0,0.552-0.448,1-1,1H8z"/>
-						<path fill="#231F20" d="M38,146.167v16H8v-16H38 M38,144.167H8c-1.104,0-2,0.896-2,2v16c0,1.104,0.896,2,2,2h30
-							c1.104,0,2-0.896,2-2v-16C40,145.062,39.104,144.167,38,144.167L38,144.167z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 9.5781 158.6885)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-				</g>
-				<g id="XREP_2_">
-					<g>
-						<path fill="#00A551" d="M8,181.167c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.552,0,1,0.448,1,1v16
-							c0,0.552-0.448,1-1,1H8z"/>
-						<path fill="#231F20" d="M38,164.167v16H8v-16H38 M38,162.167H8c-1.104,0-2,0.896-2,2v16c0,1.104,0.896,2,2,2h30
-							c1.104,0,2-0.896,2-2v-16C40,163.062,39.104,162.167,38,162.167L38,162.167z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 9.5781 176.6885)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-				</g>
-				<g id="PUB_1_">
-					<g>
-						<path fill="#00ADEE" d="M40,176.167c-0.552,0-1-0.448-1-1v-24c0-0.552,0.448-1,1-1h16c0.552,0,1,0.448,1,1v24
-							c0,0.552-0.448,1-1,1H40z"/>
-						<path fill="#231F20" d="M56,151.167v24H40v-24H56 M56,149.167H40c-1.104,0-2,0.896-2,2v24c0,1.104,0.896,2,2,2h16
-							c1.104,0,2-0.896,2-2v-24C58,150.062,57.104,149.167,56,149.167L56,149.167z"/>
-					</g>
-					<text transform="matrix(0 1 -1 0 43.9995 152.8823)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-				</g>
-			</g>
-			<g>
-				<g id="XREP_4_">
-					<g>
-						<path fill="#00A551" d="M306.833,170c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.552,0,1,0.448,1,1v16
-							c0,0.552-0.448,1-1,1H306.833z"/>
-						<path fill="#231F20" d="M336.833,153v16h-30v-16H336.833 M336.833,151h-30c-1.104,0-2,0.896-2,2v16c0,1.104,0.896,2,2,2h30
-							c1.104,0,2-0.896,2-2v-16C338.833,151.896,337.938,151,336.833,151L336.833,151z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 308.4116 165.522)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-				</g>
-				<g id="XREP_3_">
-					<g>
-						<path fill="#00A551" d="M306.833,188c-0.552,0-1-0.448-1-1v-16c0-0.552,0.448-1,1-1h30c0.552,0,1,0.448,1,1v16
-							c0,0.552-0.448,1-1,1H306.833z"/>
-						<path fill="#231F20" d="M336.833,171v16h-30v-16H336.833 M336.833,169h-30c-1.104,0-2,0.896-2,2v16c0,1.104,0.896,2,2,2h30
-							c1.104,0,2-0.896,2-2v-16C338.833,169.896,337.938,169,336.833,169L336.833,169z"/>
-					</g>
-					<text transform="matrix(1 0 0 1 308.4116 183.522)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-				</g>
-				<g id="PUB_2_">
-					<g>
-						<path fill="#00ADEE" d="M288.833,183c-0.552,0-1-0.448-1-1v-24c0-0.552,0.448-1,1-1h16c0.552,0,1,0.448,1,1v24
-							c0,0.552-0.448,1-1,1H288.833z"/>
-						<path fill="#231F20" d="M304.833,158v24h-16v-24H304.833 M304.833,156h-16c-1.104,0-2,0.896-2,2v24c0,1.104,0.896,2,2,2h16
-							c1.104,0,2-0.896,2-2v-24C306.833,156.896,305.938,156,304.833,156L304.833,156z"/>
-					</g>
-					<text transform="matrix(0 -1 1 0 300.834 181.3271)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">PUB</text>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 289.999 147.6729)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">MUX</text>
-			<text transform="matrix(1 0 0 1 375.998 244.3394)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Balanced</text>
-			<g>
-				<g>
-					<path fill="#00A551" d="M55.628,376.346c-0.552,0-1-0.447-1-1v-21.601c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.601
-						c0,0.553-0.448,1-1,1H55.628z"/>
-					<path fill="#231F20" d="M91.628,353.745v21.601h-36v-21.601H91.628 M91.628,351.745h-36c-1.104,0-2,0.896-2,2v21.601
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.601C93.628,352.641,92.733,351.745,91.628,351.745L91.628,351.745z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 60.2065 368.0674)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-			</g>
-			<text transform="matrix(1 0 0 1 329.7163 50.667)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Task</text>
-			<g>
-				<g>
-					<path fill="#006838" d="M272.946,81.342c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H272.946z"/>
-					<path fill="#231F20" d="M308.946,58.742v21.6h-36v-21.6H308.946 M308.946,56.742h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C310.946,57.638,310.051,56.742,308.946,56.742L308.946,56.742z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 276.6543 73.0645)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">XREQ</text>
-			</g>
-			<g>
-				<g>
-					<path fill="#006838" d="M322.451,78.009c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H322.451z"/>
-					<path fill="#231F20" d="M358.451,55.409v21.6h-36v-21.6H358.451 M358.451,53.409h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C360.451,54.304,359.555,53.409,358.451,53.409L358.451,53.409z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 326.1587 69.731)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">XREQ</text>
-			</g>
-		</g>
-		<g id="Query_1_">
-			<g>
-				<g>
-					
-						<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" x1="197.195" y1="79.246" x2="197.195" y2="177.963"/>
-					<g>
-						<path fill="#231F20" d="M197.195,183.998c-1.054-2.84-2.852-6.363-4.756-8.547l4.756,1.72l4.755-1.72
-							C200.046,177.635,198.248,181.158,197.195,183.998z"/>
-					</g>
-				</g>
-			</g>
-			<g>
-				<g>
-					<path fill="#00A551" d="M179.195,208.318c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H179.195z"/>
-					<path fill="#231F20" d="M215.195,185.719v21.6h-36v-21.6H215.195 M215.195,183.719h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C217.195,184.614,216.3,183.719,215.195,183.719L215.195,183.719z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 183.7729 200.041)" fill="#231F20" font-family="'MyriadPro-Semibold'" font-size="12">XREP</text>
-			</g>
-			<text transform="matrix(1 0 0 1 166.9727 340.0781)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Registration</text>
-			<g>
-				<g>
-					
-						<line fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" x1="197.195" y1="305" x2="197.195" y2="214.035"/>
-					<g>
-						<path fill="#231F20" d="M197.195,208c1.054,2.84,2.852,6.363,4.756,8.547l-4.756-1.72l-4.755,1.72
-							C194.345,214.363,196.143,210.84,197.195,208z"/>
-					</g>
-				</g>
-			</g>
-			<text transform="matrix(1 0 0 1 180.7661 71.9683)" fill="#231F20" font-family="'MyriadPro-Regular'" font-size="12">Query</text>
-			<g>
-				<g>
-					<path fill="#006838" d="M178.194,98.486c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H178.194z"/>
-					<path fill="#231F20" d="M214.194,75.886v21.6h-36v-21.6H214.194 M214.194,73.886h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C216.194,74.782,215.299,73.886,214.194,73.886L214.194,73.886z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 181.9023 90.2085)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">XREQ</text>
-			</g>
-			<g>
-				<g>
-					<path fill="#006838" d="M178.194,327.8c-0.552,0-1-0.448-1-1v-21.6c0-0.552,0.448-1,1-1h36c0.552,0,1,0.448,1,1v21.6
-						c0,0.552-0.448,1-1,1H178.194z"/>
-					<path fill="#231F20" d="M214.194,305.2v21.6h-36v-21.6H214.194 M214.194,303.2h-36c-1.104,0-2,0.896-2,2v21.6
-						c0,1.104,0.896,2,2,2h36c1.104,0,2-0.896,2-2v-21.6C216.194,304.095,215.299,303.2,214.194,303.2L214.194,303.2z"/>
-				</g>
-				<text transform="matrix(1 0 0 1 181.9023 319.5215)" fill="#FFFFFF" font-family="'MyriadPro-Semibold'" font-size="12">XREQ</text>
-			</g>
-		</g>
-		<g id="overlay">
-			
-				<rect x="113.277" y="116" fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="4" width="164.261" height="160"/>
-			<text transform="matrix(1 0 0 1 373.8784 37.6665)" fill="#231F20" font-family="'MyriadPro-Bold'" font-size="12">Client(s)</text>
-			<text transform="matrix(1 0 0 1 248.7451 131.6045)" fill="#231F20" font-family="'MyriadPro-Bold'" font-size="14">Hub</text>
-			<text transform="matrix(1 0 0 1 361.7368 355)" fill="#231F20" font-family="'MyriadPro-Bold'" font-size="12">Engine(s)</text>
-			<text transform="matrix(1 0 0 1 370.2607 127.4526)" fill="#231F20" font-family="'MyriadPro-Bold'" font-size="12">Schedulers</text>
-			
-				<rect x="-5" y="116" fill="none" stroke="#231F20" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="4" width="441" height="160"/>
-		</g>
-	</g>
-</switch>
-<i:pgf  id="adobe_illustrator_pgf">
-	<![CDATA[
-	eJzsvXuTHMeRJ/gJ8jvU/TFm0t6iO+MdIVtbs6rq6jntQSJNErXSja3RWkCTwkyjgcVDGu6nP39H
-ZGYVCJLQmrSDDiNR7Z0VERkPD3/83OOf/q8vf/tk//zVn+6fhKt5N/3TPx3f3N+9e/XmFzui7n75
-8PD+7bs3SPrZb36+c+lqhof2v6xfy4O/v3/z9sWrx1/Qn+iPt/jtn/3qxePuN3ff3j0++X/vHx7u
-v/v57mc/hz/+7sW7h3v4893Dw7NXj4/3z97Bl99evf3Ltz/XxoFwc/cOHorX9dq53dx+4RJ17e7x
-L3dv3774X/A3l0MNQDu8ev/4/MXjt4dX//6L3ZO8exJd2MVQdk88/vn/efGb+7dnnvFXzbumD161
-lB08ffPq2fuX94/vvnzz6tn927fHVw+v3rz9xe743d3j7ld338Jf7nZ/hLd59dfd4eHu2b8NX7l9
-9fgOHt0/vnr87uWr92+hCvjr/7371XdvXtw9h9+e/Ob+2/cPd29W1N/ev3zxp1cPz1fkA5O09l/f
-3z+/f/43aWP/y/T17YuHe5i1l3fvds7hHO5/6fzXh/cvHp7/+v3LP93DfIbWkBy+pkH56i2MBgwM
-fkZy+fqXL4Hy2/t372CcoY+4Dn7zz4dxIIFI5Wf/Ar18QWsKZvp//FyqffPq9cu7N/+G34UJCn6H
-/838x9/dv3z9AEuCJjC0fJV2T8KM/4y/yLPwLjzRxe+epJJ3aY47Vxz/uU/x/V9e3P/1F7tfv3q8
-51HYv3n3W15bMc4z/5//8pv3D/dvvnp88Y7fbP/LxsPwq1fP7x/gefv+7cMdvT0V1//PD/zu7s23
-9+9gQb56eP+O9kzVFmCYn959d4+rrXEDX7y+f/zdq99TH5+0ehVCgBf17SrnnHYO3rqluksV3q1S
-IznDW0Zr2/X/cxNYIVan7ZRQPFQaMkzVlzB5X7x58e2Lx180GP4ye57Vf37z4nmfVBjQyv+jl7qq
-w39N/+Pew0C8e3f/KGMDi+n4q2FxzFe/+i20enp8fnz1EmfjLe5kWBWPsGAeXn3Lf7PP9Bf4+vvX
-079MoV3/z/ev3t2/hboe7nctX3/75u4v9zvn6/X++Yv7N/CXt9f7N/Dn6+Oz++cvHh7urk93z96/
-u7/+9TtY0ffXX+hj0/VX9o07fuSOaru+e/biDSyUbx7u//36rj/D37+jyp9p5ff0zen6nr96P3z1
-3r76gqt/wc+8GJ55Yc88UvXT9St+9hU/+2p49pU9+4q78p4ffc+Pvu+PTtfv7dnnd99+e//m+jl0
-8P7++hmM9/Xbd/dvHvAt3jIHvv7Te2DS765f373BEXj952v4xsu7x+d/eoBRekMbFmp7fv3s1Wtg
-IN/++d01bODn97hlr7kP1tzV46t3z++/ud6frr94+3D39s+TkV7DYfLyxeP7/pD++9394/XL92vy
-tHlO/3315vk3wNYeXzze4+eXd2+fvX/AX/SBO6BL6//z/f1bfMnnr/76eH3/788e7l7SR1hdL57d
-PcAX7FvfwK5+8bjtxrfACx/uX76Cw+ubd/03Hgk4EV68xjd/+/ru2f31nidjL4tN/jldv8I18vgc
-unR9/5L+oYUMQ0yV6i9cJ/3W6Ux8/uIvL3CB2KDZmP/RPn3z5o5n9PT+zSvqKe0U6zf9RtVN19+8
-gBeW5QEtX7+Gdl49xwVCc9332Z/u3t5bB+kXePTdn+EMgiUyXe+HJXoaPu95ZZyscyceml8y/Zfj
-cv2lPfRLfugLfuiLoT597y/4ia/4ia/Gar7iPz3HmQJR4Xr4Nk/Ey7tnb3C9A/+nx+6e0YbgLc07
-err+8/vHb+/evH/5cPf+HexDOCL+7frZHXxv+t2JuGn6b1//7i0cJP38CF8Tmzo9PnuFssYvdl+P
-5/Ty0P6X68UfrxdPMgP/3f/HlQIf1Cp3v3vz/v53372+/+gebASDM6IC9GVDvN5+kQ+Vc70iOfFH
-dkslk3PCyqJjSr0+892/TdcOy24dNl06LLtz+Niu/IvLTngxHNjhGtb0/f98f/cAv+TrF4/fAE97
-993AKXEd0wNw0IF0DJsEf5lcdcgwgWG/e3H38PzFN99cw8u9JKHq+vWbV8/fPwN2/gJqfIcHE1Rf
-2/UXL++/vdtNrqVr4N7I/Hauleu71/CFf5detHp9c/8Akq53UTgOcMr/df/47f3OxxkffgAe9PVv
-v3sJw//1Nf+7WLaJx/VrGOcvYWPhsT/9+vVEasOXD+/hT//85tX71798/ObV9DPWM0BgeHO/4z+C
-qkC/6r9Xdy9e//yD3765/wbE1/51pp4e/3L/8Or1UK1RgG3t/vvdm9ffX/WXD3ePsP6JbjU/fQES
-x5d38Gq97k77iEpBAnuNJ+9ftHOrBj7wwPCn72/od3Aa4PL74k//Cl+BbwvBGhr0uyuY2e/p9t27
-P4PmA4fYW6uAf10OA9O+v3e/fYZS4pvd4c37t3/e/e7Vqwerdvknq13IRMXn/z7a+JK+8PjFIw/Q
-tiV5YN0SaAx/d63A05dbgD/+Pdd+vANJjMTXF8/ONXDm79YS/+2HLCziey/evuzraaB8iXz52cP9
-b78Dwfnlh2rD0QCm/xwW4m/fv3h333v76uVrtFzsfvvnu9f3VOe7P9/Sk7+1ChOeMiOjffLkAxzY
-zbvD4/D3f8ZTAMSfXwCnBWl+9+4VGzZ+Pq1+B9budwc4Aaf5KreSfcEPJXn+EGoqCT6U0FJq8MGB
-cpmQ4rxLmSg+xTbF3T99fXgzVLPTanZazU6r2Wk1O61mJ9VAX0DfBcV+50BRhxpBm/z6E9Z4ePuT
-++egNg9/+VS9s/qgb4cbm3mdwPNz+s8gYzz+ZzFZ/efdF2/u4BCHuT1Ph8oLz/F/mWY3+znMcU5z
-nstc5zbv5+N8M5/c7Bz0LroEckwBKaS5vTu4o7txJ3frZ++898FHnzy8rq+++b0/TP7ob/zJ34Y5
-uIB2hwglhRxKqKGFfTiEI5RTuI1zdNHDn2NMMccSa2xxHw/xGG/ibZqTSz6FKcWUUk41tbRPh3ST
-Tuk2z9nnkGPOueSW9/mQj/mUb8tcfAklllxqaWVfjuVUbutcXQ011lxLrVPd10M91lO9bXPzLbbU
-YMpaa/t2aMd2arf7ee/3YR/3aZ/3dd/2+/1hf9zf7E+H+eAO/hAO8QB9OeRDOdTp0A77w+FwPNwc
-TlBuj/MRhuno4T3hXY7pmI/QkSO0eWxHqOcIjx7x5wbKicotlhsY9hsY3gn+56UEKVFK2pRM/32w
-TPS//wrTTR08QUe5YE/wZw+vgKVAgbGEt+Pi4W2h7G+hnKAcYRwOMBowhHsY3X2aYIhgzmC4YHHs
-Zxi8U7uBAmMGA1phYDMMb4RhhuXTZhj0GxiGQ20VfwrMSYSZ8TBDc7mFcpxgpA5QdS34k2EqYadA
-mfMtlBN2DqZ7nytMfIHph4UDC8HDgpjTLSyNmwTjDVOzh+XSYNGUCdZOhhUUqHhYVnO8hcLjeYS3
-pBfAjsASLFgfLMcEi5JWLixRBwt1DrewZLEcJ1q/R1jJXKqUAmsci3wP1j6XmYu/hV2BhSf26A9S
-2gQ7B0uVkqVEKfozc3G3Um6kHKTspVRUGSpNNy4qKPz/0y3+8P9/3M9pgq+fqKqb24OVvZXDbYOi
-nzv1YNT98vNEX1BCtdJwMdC/+olLMTo/3ZvCRo7cw6O97Cf4mT5VRX+rCnlSaLrncz9uVXQd8bKM
-UhKVLIcAHgNwEExwFgDHo/MATgQot1QHngveBdwacDrg+cAnRJVTYk/r8UhnBZ4WWGjNTtQ0fduW
-tW0UWOrBFn2kg2X5b7Qn9cdN+oFK3xsnKbxDjps90qS3RUqSEid6qeikRqc/NHTzLQ0ClhspRyk4
-THBs0LhhqVJAaipUspS0KnFVwoWi0+Yn+h/tbgf9uT2dTjdwhByAP7dTPZVTPqVTBFblYQBm2Pin
-mxs4aA43e2DM9abQgRHhSPEwNDOcOyc4hY5wEuwnOJ4qHFQZWGgEFudhBmfYVyc6KfiUqHRCJDgb
-Ap0OM50MN3Qy7IHr47mQ6VAIez/RmXBLZ8IRzhc+E4qcCYFOhRm2sZ4KezoXCpzTSc4FR+fCqdzw
-sTDBoV7pXEhyMjg6GU5wvh3pZGh0MmTg+XwuuOFc4FMBRTE8ECIeBxNMOp4HJzsLGp0DWU4Aj9yf
-eP8NsPwDsPsmrD4Biw+wFp2wdmbp+4kYeQH2nWi9elmWJ1mGvPQKbBhYbLCFcIXxurqhVbSntVNo
-oeBi8CihzTTdmU6yrD9FSpXSpOylHKQcpagwcJJyO9GReltkgepWoOPWkxzFJUpJUrRl/alSGs5O
-I7GLy0HKUcqNlJMU5ea6WWRP6jlYwyRna5SSpOg7a9P606TspRykHKXcTLDQsJyk6Gmj29ZJkRMZ
-liiXKCVJ0cEuE7+xNtz0Zy9F5CpY/VxupJyk6PE3S3G4ZRxN94Y9rpljL3koZSh1KCZmNBLUtRyG
-chzKzVBOQ7ntZVowKDeU3uXxJw4lDSVrmUhL6KUOpQ1lP5SDleNQRGie6J/TUG57WbBdN5RxmHuX
-6Wfif0hA1JKHUoZSh9KGsh/KYUIpG6Zb1GU4wtfnQT8T+qflEd7L+gyBJ6bVETJWsJQHunygn9YS
-BP1MZ8nnhAx38YnFb7TYSXBAkUFVy0DLWpRKWI+oUeLCYl0S18MBp1Z0SJwRHHHUHm+Amd9OrDzC
-/GRgWaPm6EhzTKY53hAHRK4Xiac1Ylw3pDciK0KuU2qbTGd0pjNW2ui4qU+4dVca46gvRtEVB0WR
-T/BR4sXS5VyVdcvwzPikSryHW1EeUejtsqXK6afVJ/7tRr7EXxt/7xR6bvrBgvSJBHAuqiD0Xh4v
-y6k/4ecfoEKa7eUoradkWY6rctiU/TRoXljapqyXTtmUPJYJ/pc2Ja5K2BS/KiaG02t/rPj5sdLn
-9LHi58fKntPHCZ8fL3syS0tW8qaUTalnShvLRP/sN+WwKcdNudkU0A0m05IGDW1Z/LwpblPsZzzH
-RNpUI5War/Rk7tKF9mimxXAr9rAT2cZuyEpGVqqJ1geXSuukkFhL5h5aL4EEFyer5tbsXGrhYhtX
-FQtXmsjAFUjycaS9nWwl4VoaVxOvpyA2rvWaEivXRMe7/4FKzZEk5bMra1otrQ8pNYNKc1mjQell
-VGhUnWFlZqnK7Fd6zFaLAR1mEiWmqzArBUbPdiy69HVTqLToz+vaUCVr2rema59Y155E3VaVW9Xu
-/RkFvJFqg5+yqjmihxcxd0A/J7F9JLOCdOW8K+ldWR/VdhW8Fv9O9qdz/3Zzy9hcXvybpb/y7yS/
-Vnsds9HI6/Yh4P8f5P8HGqwjmXCOYsiB/080nGbTgUG+FQPH+K/j/5O9h/8fxPIT5P9R/h95KbCz
-IInLQM1CxN74BOTT7pP9/N0b5/4PrFDtvzeXhJNpZRReCifAGVkGXJ4rawXiB5dpUA==
-	]]>
-	<![CDATA[
-	WD6NyPZpq/tc4dkHRB0454Vku/NJeBDbmz/KFzkNeuPaF7n2RN58ryeStMnZ9MlEGqV6I4/mj3Ti
-kWTNsppX8kb8kk48k2g/K5O4Jw9kFVMXpSdTV2I3JZmxUOe8EU+lI3uUeiur+SvRmHQ7kQLanZZl
-6bYEZXF0XJLbcuG1ZJ8leyzJXzmJs/JAbsoTOScd+SMj+RsLyPINZPoDSGk3NydgCTPIkP4EKvkp
-nfKpnOoJ1GIQwo6nm9PpBGxmRoESDS+gU2Tz4hzUXUNLQYRaNU+pmUcNJsmKmjnV2Kg2P7O8kQi3
-n2gMuByl3Fg5SVE3kooVXZZW25hameIkntFkRQ2tau5Uq6PZ/rT9g/4cpZAPdqJ/TlJUYVa/Qpfh
-1TKnNq4oJVkRO++k5la1eprc3HQEtANH/bmxchod0uySntQvLeX7XdNqa1aLr1hd1fg50crhoq5o
-7QD90FIQH3Q3lqkBrZvVurFNDXDdLNd/xII3kTmfSzf2dUGu67NqLLQ3HCyLuhJgUU6yOrthsg7O
-YC5m2xzsndqh/iPW0olkcC3db6ylW2G7/qTroltxu21341mug224W4zVihw3brbB0cZlQj1g44he
-u9vY5ablcMb5pqVOpuuqHpyXisLCNvoZq/IZq/IZq/IZq/JRaspnrMrfX4WfsSqfsSqfsSqfsSqf
-sSqfsSqfsSqfsSqfsSqfsSqfsSp/bxV+xqp8xqp8xqp06+85rMqH0CoTGc22eJUtYmWNWVmjVgS3
-MtFyMugKralIksQSvdLxK4xg6atMUSyCY5kGKAsvOl12DGgpYgxLhmlRo9gtyaI3JKIeSHAl89hE
-i5GXIy9IWpKyKBXqwktzT2JolQXKSzSSFOVpec0KfjnRvBzNjtYEBpNJt1BrmqdVyjY11p7UrnYg
-V1EjeIzZ1hJJQoGEUVzwamNDveokdrajeR7U39B9DOpb8JP5EdR70L0G4iEQ50C3uHUHAIucZukn
-GXVjdjuqId9sbm1hvV/a7blOsS5gmczIsDYxLC3za7v82hRvzGEywbML0G4N22H0iJXTxgzBhRxt
-0wrGs4TwrO0TvZSzBRbBZLaLsaztGJfKGXn2vJC7fugjYE4XzDSXgU7TYK1ZjtEW7LSEO50HPOWJ
-ME9pNSrj+OTVWGw/jya4YWxGsX4U8Lef10rC4vM01J7mESU19nZESnW0VF7ZroripvIwJmX4XIdR
-4xGtw3iOozuM+2S/9CnRCeqTpYa20ei2BLHZb5NN/MmWAYGv9JNCsmShbGjjdsPfJkFs4QK7NRto
-/8EVuKV4283jcUm0aYPUW+jPgzZ6iR7N+Jq4wvWf4hn5Y6Sli/IJMarpjPPwx4oxVKaFvfWHlosV
-fk/5jJD7XOE/SoWjJnhOKxxVdNalP0JJ/EFlOuPS6y68Ne3DhWwUaw31kp76caXetunCH350mT7q
-ob8VuHK0sv10G8Onq+pzhZ8r/FzhJ67wx+Byvxd5NY3gqwF7tUXnrvC5K/yVIbAmdkwoTLcDsRZI
-3Y7VFbTugNdVxK5gdicDaAlw1wzuCt5N4kys4js8iLfwJN5BJzheRvKmSTx/VXx9B4H03rBDT9x4
-Xhx36q4r4p9Tr9zR/HAE9J0FI6vI2CSQ32II2L0BXhXmemvAVoWzCop1MvBqFUzw3kCqN4ZNVUyq
-IlGD4cUUd2qosclwpiN07EahY6L5dCBpR4x16GiHjS7goh0qyj8nKiyEsPbEdg42o6gjjQw7p0SF
-rEoT4ZMLYZS5sIdT8cCKxlXrnrRz0h+V0U3xmroR0srgvLMyWqq7KXtp5F6c9EvR4ZygsyxrGcu8
-JNMZq/3NxrJ/qfxYifNjIN3xIqT7Aqh7EtPmGtZ9Dti9hXafAXdPA75bN8YlkHeHeY9Q7xHsDTto
-2iC+R9R331g3C+j3AP9eQMChTAsL+cL3fVz4kg0VvkSGD+jwNUZ8iRTfIsZH1PgaPT6gyKfj+HOz
-KadN2a7ShXlwDTrfws/HEs6WOJZp+GULTF3i1relbMu0gbdfKu0jCiza6Wb/EeXw8WXaoOt/YpkG
-3vtJfqaPeuhHRwN8IB5gon9G+MTHxQRcigs4TiMLGUAf7Wx8QF2AR/K5OIFpESywDBgIYYG1WRje
-lki8EQOzCCFYhhGMoQTbkIJlWIH5JEaUTlsAeJahBtuQg2XggZVpgRraRiOsIZXjz9bX58gDsi3n
-nIcLL8m6DMxnWnGjrfvyXODDuSLH4nTGS7qOkvhQ+QGmxh9nzczTB62qP7yk6YJl90eXj6qwO3wx
-Jy3K5wFTs84tRJfxPpNWCt5BdDXPsFID3XuSYTsV+HjlW3SuSnbWdTbaT1AX5aGdZ3RqYpbYGFvD
-rzdUGwLVM0fKJNtimhtewxIaKGSVMsniT6+uAsmV3rtPWiv30+VKNeL70odGnluuEZQ5vDXmihy1
-RKse+FivKsehcz+5KurRT5yBWD7ZZMbyKecyzJ96HsP8SebQpU82h1DVT55DX3efaD9STT8k8/KX
-79+8frjf/QYIdw8/n1a/Q53eMi3zj9sENKQh40MVG8t+kbhhjGZwo19uHdKgqJtlQMOtgGG8AHMV
-hquw26bhcAeD0wp81tCyio9FgQRllGJmmmbQ1uNgriFBajIwqmJPO9qUDTcH0VVOZr6ZyYTjRCDo
-8huCN8pEoG60q7DKeCCk5A1ZdU5i2eFThiUMFqlGKPoIPwdVc4L/jYjzcyDzJbBcAeUCIzcUuaDH
-J9Go1L6whYsHw4mvEeK51gEdLqrvVActc6FWnMaygkyMuHBE7gwy6CQf0oWSv6fUdZm2JPvTf12u
-+7CyJTbSyNmWaOsaFg5OYbckCtBWrYmTrOEiK7edtSUmwWcz+lZR1mpHVEsiqgplItAz6hZrOyJa
-EtmKyBH/B4n417hOtCIGUjQSgelwZR3yYaIAzxtZSWo9TALaRdvhXoC7R7EbjlbDbCZDDQs4ThoA
-QEGg3uYvG47/QOBethMyQt8TyJftLHkwD5LpZBK7iVlIzB6iZo9u4Oh2jG656PYJnJ9w9BMwjriy
-CDLsbTQhjNYBws6Zvr9U7UVdX6vlW31aleKuo44/p6HcToPZay3h+00JF0vSMvWP6/JxwGG3+M8t
-fp83f5MEJyNxW13/vPrymeKned3y+co++uf/EN/HP0SFW3/sMoSBf3x33a4fX8TpXfAUX47pO1/+
-owLmP1f4H7tCjZhgHAyDWxg8woEMWWIVokQgOImGvSV30g0ZxA/kr2gSF1vYS5XIdRUkQNYRivZW
-wmRv6Lw7SLRCo5OxSMxCMgC7wtbn4+0kePUxr+JeYOrrlIpxnVJxk1QRyrTKrFhFaliD1BWm7gTI
-qhkaTnR4s2xAkPVJMOtNhN8i2PUsHiLFrwcxQrKljLGZ7CM7WVYHArVPhGs/kHi0F3x7M/mUhfds
-WHfFu0cKuggUeNGx74R/nwRtq2gbFcC7WK4+lC60mxtrkIztZ7LA0CIQei1pURYhejWsymB2neTD
-JTPgGTT1Alm9ibqZtiT7k637G1nzTdY7r3W/ifr+UNy3hN5Mi9ibdfTNMv5mjMAZY3B6FE7DnCfF
-FmTQhShLUKNxNFJizPfJK2yWdXVjsTn7aRUlESVIh8J0LsRIcLxOkXkdgyRgSniIe5zEweIkqiUX
-yQQ+iJZkxCIlKKxHQyUkWGKyaIkqCusyaiKIgjxGTtyS6HqziJ+wCIqJgtErBaQXVqhTsmiKaBlL
-NKrCCYT7doitOJkDDmZskiCL0alz2aVzzqEzunSiOnTCxq2zdO1sXDyb8FVz+Uzb2DH704Lf3xic
-UQGDa66vfF84/4L3K/c/TMMBUMV+kGmjjKeAnQN2EizPggPpQ3QeTMORkIfYph7RdC6WSU+Hfj5o
-IFOdFnFM/aAYY5m8eD/mxZGhWXyOlsWHTo7JDo8mzLIfIHqIJFklYThKvLlR5uFIgR09DedKP1uO
-hhXoPwooqMNRU4YDRw6dyc6dOJw+4xnUz6HhNFqcSePJdJoWR1QvK5d7O2zK/kyBn6md/7lolBlK
-OVem82T608KHgpJPcLsPfODCltUw73K4cqm00ab9I2sgizEy3oZ36MGLgKrD5t1At+rBl32M8CG2
-Oge8Xs/HMtPNe6l5qOKCK+fTVflDbMi/ff8a74R89c07voRx9/sX3z7ev3uHN/hd/hu0FvSmRjgJ
-QvB0l+HcYsQPEQ8LsqtnF/FexrnE5PBf6jZ+SLGBziYz+kkq6X3ZaTU7rWan1eykmp1Ws9Nq9HLG
-DA/4tkvlCjl7n55PXzUtpJ9Y7VVOzseEK9Rd1TyHXWlXpbhP1/HLLXyS/rd0Zit8ykp/yGb46vHx
-7uX98923Qto52AVniAvXymWY6hqkugKoriCqkh5wkrQjZli2FIEKUx2TBO7NwHwaDMwboKr5OUAw
-6qlk2ZmhaWR7wgc2Jd/kE1mQOU2gJAlEdwJmm0EzMfoJbsj8j4keEDmKiFG0AaP1N8Fx1uDYuyED
-Lxp3Eb/GaR0w9x+ixxJZahvGLN+QQdaRAVYzvEp+V4JW9tyumtkVsZG3ktgVIY9JUrsWjn5QkCLn
-exhy+o3oti4vDHKDpaoyS/PyE38+3E79owgbYxj1SQLyj4v0gaq0jp+aSiKTwflYHBkFE/13BAFm
-0/MKPa3PNxVsMHa7/4zwrBHs5wzNN+L2qkHzDh12Ny3SMHaz+Qht6/roCBsbfwgyy/+fRJS0oun4
-jpIMYy+q3fifZmjAGQ8k0uLPgVZGl2FRdkW5FbYa2t9RTMVOoTwaVQKldo4k9aBoifvE04xin/c0
-mCgFotQ307ug8AY7YeJUjiRN4UBX0t9Ra0cN7IbEugqbBBUJTtrIty2gQoWMjDM1ouKEsmZD8Hch
-xQbVI0zFxcoQNt7khoVMmg5pN7SVsbOstvTIcIyDRHGfUvocDPaFTtNAQZS4VW7kjoU9+WCR7wSy
-vuJAceYtDSWOErBJUZ4TRY/eEGsjAfNjM+mNVtplCp6LmfQGz/NwC4Dm0csS6dgsf97a1TywVMX9
-m6d55Wg+LdzNl3LK9Sy4txNh106GWjtQpRopXwVslgQ9xvkonQC8FJm1N0xURoxTtAjX2XLnafju
-gcalBxcvw8WXOYpk9JfOGjMRfk6C9/efBG/MXzcmzOoYzRHEOELbekT6iPQnJjgNxpVuYtHSgeZD
-hvPBKT9aAiWx3TQYYroxZjTJdLPMaJwZTTRmpsEyDdYatdcsrTaaG+NoGTLWBpz9mDxsWpgsz4Fz
-z8Nz4wh5HY0409p+o6nnNN2cym+Xec3tgBHwluiN07oJpGU6g2jREKQOHlBYi4JaqqVLO0g80o2C
-WqYB0aKBSYnxLAIraAZmORqYReEFToAsDDIgGMskiRQ1geLBACwnySs9W27EYNkQs+U/7IAVSXQ4
-WfTSMn4pCjxF0xaOIUxHQaBoRkJnwAQYh8nimCSSaW04+BRQtk+OjRNoXIMn6cFaog==
-	]]>
-	<![CDATA[
-	bwRswzOf8Wwux+Gr85WXSvMFg8KnqOwnaU8+nlOfgAqv69V8kGrwLk1o2wAdjz7gjoB/XaxzxA8w
-iKz5R8LN4Qf6NM4rAevODMKKTqOMtO1ELqg/7b3z2ffO+N5hBcnbykznZaVLVzdZapJplWDkUlkn
-uFmnv7HPk93kNKYdGcsYJnTzvUXSjZw+stx+f5k+5qF1+VCs+fSTg9U/V0gVdt0Af/Mm72eSY0cr
-SbeTLEV89hiOeFLKw6YyPkr5kZJfchkPXk3ciiLWjcjqtwtEKR/BcRJYaU+uOuZTXeZNXeRL1aic
-dWLUaZUXdRQmxp+lK2mZGnWRHnUaZJd2sexX5dwzIi5NC9nph5XjuTKdJ//48g9SYV/huLpxZVe6
-EASvA8FVXMhpf3QnydKKsuGeZEHMzxoIylxpfeE64vjyPEly1sXFHnbnE4toaqiLg6nuSBqN3uvh
-u9Q1WaT4jUCCu4yVBPaLUtJBsraOMpWzjM4oJhYGfCLgdk+YT83WzC4k8jJpbuZFzO33xNlO61uT
-FvG1XG4WIaCnTVkEJk9nwm7PFX+mnA2WmlaE8FPL9NOr+N9RIaxwdYX1nKzrPKznUuqcT2CzSq86
-nc+s+iOSqkpa1elydtUz5XvlhNPt9LER6uZQ/56f6WMe2vzcXC7Th/74Y8p/1Ao/hCVaoom6AU1N
-aGpES0uwHIO+R3zEfoOVu4CWE0jE7Tq567RFRazSu2Yz6/BJFRbgCD8EiEpof3dedLTE8uajjpzo
-Zf1jjHoauPYZFMECbfHhIi6OaZHy4IeVfK5M58k/vvyDVKgr/IauFSrkOHGwmm/IbVLIVeJh1Z5o
-qTZanuglcbQM0eCLqw3XF64mtvMSBnMvRt5u4l0aeHuS6aV1d23fJQvvNIDYbsTMe/h+CJsgBxnD
-tkCxTUPC3w5my2LHjJb8N1iguFNwmwHcFORGZRoSM/SUFssB3y/KNoxpgbSc7GP5YPnon2n1e/qp
-ZfrpVfzvqLCb+Uxq+cAHLqNdEMRxxyGZFY14ZXYx+hEVhF5uh5TiYLnkbs1DmstnbE+fsM7D28mJ
-JQtqjBYCuyTqU1elrMxba/JPsm+F+Zx9C6gLXERPQLuyA539fMbwg6aDZW7ZmTMXc8pjjTdFlxo5
-AAfDQB7uxDhIfJ4jXV9DRxk2gYZ1icebxJJ+EN1uOINH2Ppe8L9LyPr6kJ3pDMWz0hDqzNfR0r6W
-rC8Ju+dvDjgjwy7F0KmLjXytwFLwyCtw8yV4s0IsN569abhhAOsfAme7oyGQYUOdDdliZ5cOh6M6
-HEaXwySp0WJe5U2YY6uZg71BtcV9VZ1rZMbuGwp3DwKGKqOBYEPxzhIIVrkKc4gL+/2nrJXj23/a
-ti+fnpOUT2TQD2fxUEAdDdt9ny438Nm87KcVO1hnaj+x2fjDluXjxXL2+Wn4SOl90KHInlz1484E
-ouAbd9mHmwYMBaevOSzc/tWuovRTv2fPgBVjKpd+8cRHJl6Zho8EZAqWF6zaJc9HwlWdFpnyxixd
-y2x5/Z7Vhq58za11PonWNoHWmRRaY5mGjwteJ1rXKpndmM5ufbHGomxU/2mR4u5c2V7T8sEycGMe
-6g9dV24XltNgNrmz/DBcWDtcVsu5wqZFwsHLt1WfS9x1NifXkLhLwQM9zGJ5OcX2eor94OMvC6e+
-OfOnjTffX/Dmn/HrnyvT8HG8z+tmlal+zRHOiAcrh85CNtizz0AAQXGQB0AaIDdAGiL0T6MksBUE
-ugiwX4X/pMXBP9PBfzMe+99z6q/P+u05vz3lF5YhPeK//86gj7kxSM7zfpL3U7wM+Uw/BBj4Gx3e
-V3D8nTkXP2WtP/3wpiwu4ar4WrHST3N8ryrlXv7U9/Z+C2T4dHX+JCEjpXNCBlA7auC/TIZtbOtw
-REtwt01zV1ap7lYJ76IlvVumvosC1WHIzpgCzy0S4JF3kb2MnPDudnWpjqa5W6a1U5dlIShYXeWn
-s0R00/pK31HGOHOj72mTJ26V/20ycWOZoK0z8nO3a/QMd5vLd6YPSHmXxLWlU2Z1Ec+0AStcupfn
-zG08567hmb7vxp0LNwpfvGn4A/kIPlguus+nxa+f4OdvE4rOstGBzo02gDwDAaV7eKsGVBcLbMUg
-NTcEte4p1TTaAdNEpkAJZkU3pAWyqgWQLWVRwo5x1Y6Rq3tydqqZL5Y0abiq2PCOgrfek9t0vM1L
-kZVuEJVUUMIDT0JP8R4vFofWN3j1+7vGm7uyQA6j3tsFbGRxadckGT1ZRj8MmG3lWUk0j7C9s2vg
-LcZXNHqkJ8VkkHdnKT2TpfIPR/hk5R23C65xmIaEkcu8j1m4xXhlznjd1HhB16AMMmhnre2NPID/
-7fikjloat7xdMTVt9/nZDf4hgPeFJCPnN+nf0x68uSHPEsp+LPmh3IdSH8p8KKayxOdQawGJj0VT
-Fkt5x7LF/lZt9pOZ7PVmyJNsUzTYq7He0y5lOz2CMdlGXwiumRdg7JuJYJ4HscPzxvQCxT7JruQ9
-qTfsIawhGtJ5pj2pOxIEz8n0FdZTAu1GJ9Ds28U9erwXi+xEBfsG2oUeQTvjHuw35/U9iDJCXO0/
-2n3w30mQ3DeE8t3383yC/41JaBMZBjQiQM/wbh+4HWwEp8FCoBvvMOj/w97jzHucg+/SOc2oqsEQ
-000qyxvCzl3zNh62Ta5b1+vd9J4zu95t3HXn9t/21rXVrltl87mw//TnB+/Hv+EelIlaSlJZbq6P
-m/lwMhddMFpNwbTidUuRZj20lwbzolDxCcSKf+iEOZ8r/D+rQpZF+5UJ+aAxkv16hPFGhPEWBLv5
-YBEP6jmn4HirwfIeg/HigjHHoF1JsLp65GQm0UXKwfEWkrAyDK5Ng2uzoBn+1mn21wkIe+ZBVca2
-mQcpzGSy60r6lSV2bQmVYqWubi8ZbzCxO0ymxUUmxwXuZvy5PWsHXtuCVxCvtSn4w1bfvCllCUI7
-d3/89hKU81ehDFeiTLeHs+XD5vLj7c2lsrw75Qch0s7fo/K3ua2PDYeLi44Gg6BGDxULHBpuObI8
-pUFuOcoULlRLmyRWSC85Op255IgTlvastYvwoEVw0CI06PwVR7eSvtTZZTHRQKvj/UZ7vd9o+r4L
-jg7j7Ubb+402txtNR79iOovrjX747UbTwFQ6OxlZSeciI/8YeMfydqNpSFEat9cbrTjEmjecud1o
-OucROsMDPny7URxdOJt9fnaDf9+2PnPb4w/cvJd27HR5e/7UPWiJIez+ssXtZZISYggVPA1A8zPX
-lk2LfMMdd15kM/NWvrGtPF5XNl5WxhF/sIsnu6vM0zYeN7HG+C23sF5Sxkj05f6FPTWttu94Pdn6
-crJh69LOvbWd2/dtmkyG2G7b77+SbL1fxb06bti1Y9BduIpscRGZ7FS5W+fMRr14CdmlPTrs0Mm2
-6HKDrk/r9e68uDens2fxx+zLC3ty+gGXjn3UXjy3B3/STtQ9+KOTVG18Wz/m2+QdwrDkhF6aElAT
-3dENCOjQcXMMhbxMc6qV3DcJHU/ovHEJtqG6m/JVm+c8eoc+YZ0f8g4B4etfv3r88s2Lx3cvHr99
-8mRwGo1/mH79Gv8S+C9f3r17d//m8Re7nz29+/b9493PJ/2AwJQr4CBxV+MVdCfgv6U5eKf3+F47
-BtDNuz98R7/+N/j4r0D86y7ufrX7l/8x754T/Q+/oX+krpf0C9e0ewq/LCtfkOQrT8fv4y+PRPhC
-pppHrjUfZsxl1EqcfeNAXUcfmk+U9sjNrc44Dy46V/LuD3eI7pt3v4J/or+aS3W7gN5DGGrspvM4
-dWUH/9ZS2q5dzbFW/DXO0Obv4ZFy5WuBlQQdLti6ff+P+H3ocobZ9PNVcjiZDeNyI3okQ6htt27z
-CN/5ZuhLKlepzXXRlzjz36QvoV3lucWxL9FdBbo1w74/9iWWKzhoqvUlQd8CDPu6zXVfZHbGrmRo
-EJ2d0pWcr+rc8tiVXK9SmTE4WL4+9qTEq+Z6Rwp0DCZut2pQ+/ETc7zRVNuyGuY4xasAS8jmOLkr
-x1NucxzbVcjJ2ySvpw1fKqUrhC/ZVBcHY5SzTfW6aX0tpY9TrV3SqZYujVOtXdK5Xs/e2CWdce2S
-zvi66XWXhhnXHumMS4/GGdce6ZSvpnHskEy89kcnftVun/gfdy8Mzbh3VzO+awhXCWaTVm/jdxCS
-K1c1FhhdD6370H+XiXqGXxGar1fZw2RqFR6GA1eitqK/43c8rCccMnsmwtvWZHXo72M7RpO+aB3S
-1dXLPJMBUnK+CiAZLt5RSNp/GPeER5++IjPU8Q3dVYSNay84W5vz4qVm6758wXreq1SSNKpflS6t
-Or15FzgSq19OmNK0r6nhaZn677KOx/eBJVc91Kd14EJusIe0Hf19fDl7Rl5A67Dfh3aMJn2xt5S+
-rt9n/Z61XLXq4+I9labvUPNVSrH033l/jK9Zw9UMCoG9ZnXQRdiY1oz8Pr6mPSOvoHXY770ZI0lP
-rArp6fpt9C0x6ycoNePuy8CwQFNSEowbHM7VVrz9PuwKpenO0Sp0Z2kr4+7L8QqT7PVnYJ3NyI61
-Dvl9bMdo0hetQ7q6epn1Ow67TzsoJO2/bAR7xb5VlCSbSb8/W5vz4qVm675+QXveq1SSNKpflS6t
-Or15l2H32csITfuqK95+H3aF0WTnaB26s7SdcfdpD+0ZeQGrQ38f2jGa9MXeUvq6fp/1e467T/uo
-NH0HXfP2e98WRpKdY1XIzrJmht2nXbRn5BWsDv29N2Mk6YlVIT1dv42+5aeQmBZSO0hqNYWEMk6Z
-I51Ds8djEKSBEiqJAQH7jXwIzuAulkglKATADoSPwJHhyzkmFLSax5NnZuHAWrTzfyGuaR9AqGlz
-CNaHWEEQikMXYr7KoF6dFda0DyBgecw/pH0ImFyWYhHWYtq8ENC0EyWBShGSdQJ+TyX5oRclXFU3
-p7PymfYChKqICYW0FzC/OYY8yO9dFPqpys5qQvBlQAxrAaQqnVV6KWSvw6wWEPQyH6M0ryv9DN+m
-UKe8zSvs2xnXk87rquW1ejHOsfZI51h7NMyxdkhneS1ejz3SWdYe6Sz/EO1Lu6Qzrl0aZ1z7pHO+
-lq/HPumca590zi9pYV9NJ1bZQccXhf1H6fyV/3J48/7tn7Wen/36/q87+QWT9s67Pfz3h79O76eF
-in9ewSf1/gloTjAYFWSEl/aLz7ArEirsQCmwchD0epEMX3061vN0epxQxcc8xiVTJrAMI80fAkJY
-yJ7SEvEsBNISX3NoNyEKbQNY9KTfa8UBGk/VDb0MOIPR9+5UVJUukuX7Tzc1Pp2+MVoCpQ+UlqGV
-BBJTy2ld3SWyfP/ppkZtBY71xs3DnsjANF6uyAXWU4ub7l8gSyVPz9e9aRQ2Yg6+rhvF/epgk6xq
-v0SWSp6er3vbaIalktym0XSFQJFN7RfIUsm6USOvG4X9CqfjenSR/8MJvB7G82SpYw==
-	]]>
-	<![CDATA[
-	3aRS1y0GOMVT3LymvwohblbKJbJUsm7TyN9M/+n95HY39rUqy9HFlNZtK3lVW3JXueq8Ajkn4OuX
-ySBq1Ljp0mXyDDt5eC/u4EVyrwTIMLgfImMHY95UcoFsL/8N8CMasIbWj5SG7/CAQXOutXVVA3nx
-rr2SC2Sr5Bv5QwUxcHieG/VXKWS3qaaTF33plVwgWyXUaG1XxcW4flMgz5jxcFXNQB77MlRygbx8
-0wpsZ45+0ygeiXXT94G8qL1XcoG8ahQO7xbyptF85fA0WjfayYvaeyUXyKtGgUnVsB1eEB1L2Q5v
-Jy9q75VcIK8ajSBiuLppNCCz95tGO3lRe6/kAnnVqL/K2W2HF8QqPMnXjXbyovZeyQXyqlF3heDW
-TaOg4sQUN4128qL2XskF8mqfAo+NIPWtmUMAMXgum53XyYvt2yu5QB4a/U9fTV+xbAfC4EKy+xiB
-z/80gQ859lbqE7kpiKh3iarffrqpD6U/OaE+qRCYq8qbMYIWkAL3HFTsllVuoE9IBM7i0D6NMglo
-1o2IyLWSTIED6Q/UbTwvHOpyWSU10EiQCC8TqDEgIpKGiCBqJJ/5ZIGpL1IBCEklCR8H1hJ2TIye
-5htkqIqiGBLTFQyA475m9EdwBWRAkMM/4jXuSMRb3n1hQQFURn6vzRg862cbvJ9LrnHtpIrQAEFF
-qXipPaP9i5v0PjquCNSYKN2b5cmEkW7SOxhgT3IAeiPQ/8qv57Me98G+jlcp8/jCCOrbRbR0yVBS
-YB0POnZY5Gj8Fr9AkycdfxfeF16E5hFfjucGJrcE7lC+Sruzb/6MNxdz8BRoHEEv8HkWeRt4LKL6
-mexQIX9QMo5KgE7DkD8Id2kxiZTYKrT8cL7iB2YjMA4tzlQ1iHhOTnsYRucDiaCw7n1W+RYanGlG
-gRyT8zKSwaFfDYnUOV2StE7RhkF6OFOBmzhurDkTYeNVSNyax94HI0feLFBHDP3hOeEFN0h1aEDi
-FZLnim/h61X1Lghxbi4wMTvQno+ygPXdwvhu0PRMewDJJUQjpxYqVwKvXIzsZ+KnQA6wfXWdgE4h
-RDRcM9HnqETs2lEqmEPBASIzQdZ3huHOxAuoXhshWLchyftF7KasQHkyluiERGZnIqasb4yTRXse
-Jn8Q49GF1UQJ9W6WtnB9xpy4DpCcRHOC1V0iLTcc4uyDbnEfZIrmGKMQYbCF6BP3Ab8eSEwIeHan
-YrXGTNwk4JnjZNRx1zjaNVAFjJ4zsvcpy1JDBVN4KuxUWashKjExQwow/miTPUoFc3EyySE2OR3h
-6TzPjsnkelWyC/R2UAlitoSc2BtJy3Wunnd14nnhfSQ9iyDucs9AdIiz8HAkp1m+nwOv4BzwfJHv
-Z1jCSoxZn0whSAVAbkn2bAwlSWM5J9lENK9CjEoMblZOBePYigwZGQb4bTHsRZZemJ0w9lpos/jC
-n4xNziSteTy8StYDg0UVnAiqs1QMVPY8ghglJF+vuHON7OVR2TxAC65EIdYYhRjTrAu6KvMGcsaz
-mIkxsdrs0DfuhAgnh6yDCO9op6BOODQW5cArFF4taya0IseoHEgBTWpOewCn6+xlujAfmjHIJTft
-qkbOdBjDCUailWpyPrLGHPHt1TIChyALLnBCOD5ugAYniGcaCB20/VCJk2qhYWROR2ltTsRb4Mzx
-eAiqTjIH7+UoCsmbUpaCPh2NKTe6SExsGSB/0Hw0dFklMbZ4eEshggooRFqYR1GYfJrFXtNfDsnY
-JbbXVDcokjAWLAT5FpKR4QXVXiND4VE4q3LOyuwjMSkxI38/ilqRfBMzULUNj0+7IuKwcwM5MXtA
-7EJs+nqw8EReJ8M5E6PIYSigF+HqcCIDt1LNIah1Ag/qnIScam7WnM9eVKGCC07JzgWzCcxZproF
-50WcyywkArGwiAZEYn1HOezbzMYQnK8QbOTnkLQKZ/Iw7IAQxPgHW7naIqxSd8DF63a6YGk7oaSJ
-jPsJKdi5RRo1OMhLSjb/IElHftbmGah1JpYGDxN2R5V0jwyWyCB5dzW6gkCA5MSnBhMTcl0iRqyZ
-iXJC4g1+sYg8h2SxxmR+eybSCgNiYUyQPOlZY0eiy1YB62oweI1PdNzMOExUJ0YJKjGzKplxjDx/
-HQYMQ/F4EOA4112UIz8bYS9HXsABUXpqk8Kz65moYsLVcHfWOek0dNEc9GaZhuay2PBgVoXXEpmM
-AkgufFrhlGUWzb1tISAm8i4hcY62hZpKZ0gOzFeBGFlzBmKUTYEVzE6IdO5oD2C9EjsLPOVMBAVN
-BH1lL9jXyps4EvtUdoY1MjWauXHLU4XZpmbKSGA8ATFbXG/GbHNg0R52Qkuz8MSG5jMhligKGUaT
-cz8S2bqE29KkIHE2voOqEy8wZCqB+EhEU5UXjgi7XA4YshrzsQtNRNa1sTEUc5kI85sGtkUVRJSn
-SEiIycRAWG+omPKow+lDI7kdgyMPDkgErejEeddEw8i2+kFrdiCpqUzjQ2CZjcBWXEEJSQS5AH0y
-oabZswQW4Aowh49ImC02IfqZ5i3I4j1qBZH0KSDPoFpJY+QHpFqrY34D4k9tTXpASLWjiGVyGGK9
-s4hgSXlTqFyVNDVTUxENQLpXt0MjOhKJnV52C53ML0VQznMQGzvIVqoDAPehzglGhp9kbx6Obs5V
-NgaQ8eIxJmNOEXmWPDCkGBSXq1bARx68xuz0oAcyvKfnZ4mj81TKvoBaycjBRDgTxbNEW1MraEHd
-BHMJfnf2db+zjZUTnZowbmRrfilkzA3Br5xQyEMiKv9USRARn5dqzVn625c13rUqEnzhB7iC2amC
-ROYNqVUWSWX5nSsAMhtA8NnK5zbUWlKTgSQNlYm0oZmIB8YzqcAX9VzBocVrZ2ZnDU9PjEU2lpj3
-YQyyayJRb4dG1k5CMEUR9gvHukh+QIaDWbw2pIQiMRgzmpnB/F4YVwpRyMo/EeModgXQDXXMkrFE
-RKIkHZ6kWgDW69nmA7XKiwQ0NRUlZjw7mZhylbdDFuMdk8ndxUTQznUXoTbw3fkX1pEIKvQDSyJF
-+KVwVR1QzwIDE2VhUyWNtlZy7F+nw0AZqhyk0AVYgkm/W1l6hn7VrHw++iYGKlBzirF0EGfsbBPu
-TQYhqQDUjCBEkHHlbUkefCYv5fG6YCLTgjz7pn8URgL7KWWphIS4l0LOaC6iVa0WlOy0awEteTLm
-sNVKFk0eviMHS0aFIUcmk8rOFTiXhaGSKMfE5Mh6ArWSAM8VOJW+4VkyzHCtwCbFZqS2sEzZr6IS
-i6qkghDTZ/WomGd9dhbhB162VD5FYZydmhW3Q6MGKtQpaDbgETrT1EIVKs0H6K1kv3tCaqmbSdoi
-W5zYhryKKkgExVA0OFSjgpCj8Ay0DaWMr4EWlyI6MLZLTBK1YT1uCh4yxOgzTUrWttjAjHYjBFYx
-0fEagU8FDcVWAc8P2Y1Eh65sUYBaUUgRY9pmCOQwRz14ZgUiMzZe/TogN4hakBsrspXswUTEnrM8
-X/EwyCq1dpkxq9EL+ZQ+C0vLNxG7C2xKIaJ5nInV9hWQG283uk+7amN+dkIke5x0y7HGVBDrHa0C
-JSezNqEDxrF6JnasJ+RBnQutaOyrq95MDKuhebAxg20qEnmdQzFnjRiOEy5l1q+qwwvjxKLbRPiu
-Zq2EJxs++UwGHfiUuKSqGDXQqzUn9cZEGciAR7ioff0UrGjDzNIDPfDQ0eWDmJ5DZqmoiuDFap+q
-22j4rdIUbNu2O/uycpQXlF14nbkB2FFx79EoZNfVJdyaofDyo5OIeyuLOiP8qBV7CTEQZHqdpi9M
-QHwkznOzySxkBs+yVbSCmQ3VSG6i8QWBjGEFHjVpGa9KaxeIMc/CkfHZSC5T5DQ6Y6DsU50YkiB2
-WTjJZlrjyCjRx/Xs/MD0dSPcEIXSbHsNjahJxoEMZEwEtY6IhfnQ7+VZEZ0z4kDYdVJNgcho5WdG
-hrWydoQiNE67znFqxJ6QLN4fmDNxNaO9kk0k6DVkMzJa9RDE+UymF3hWU+4SdSDktAIi2cK+O/++
-A0Nm03cmwI16bqqqIWj/xfHUSsgeBkRd07hjfRDOCSeHmtTQmMPz2bjP8mzgtVdNuYFac2PeX3lA
-1CrYKumvKAI7ebYpQAGlbTQsCNE7aWrwjcHcy5oubIQ4+7p/tC2UUiOGWscFgVArL2TaprwC4Vih
-bdxMN0HemcmOjJstzdVYHyxRJ6t19vosHEGBK2jOmEOJzOOgL06loqrYQSLPXhk1aRhUq7pNiJhk
-Y5Cm9mxSMvvGGo+vsPTA71XQx6rTExx7pyubTJ+dHxpcO++hPCElX6YfoatzS4b18JVt+9GkDXxW
-5NHAitMTtiC2WRw4JDiZ1ZPNm+hFmhVmhjaFxp4Aj7dtqh0L+Jhoq8AbvBBdpgWIHUsq2mAFJYhe
-Gdqs5osUq/hO2iznE7zCXEVkU8cH2mrY3hkIQ1rVgMO2UVRDmlMTr74sHvjWeuE1iRqPnHnYkHhu
-qi3UWvUACI1VJzXfgOwgcr6tx8aHKquuLmj3RaIh9aN0841MTETxR94fjldXREb24met6IgihQll
-OBwU7UFMVaX0YAMY5q5kyiJtetoBsbrYjXi5sZAdeIqY6Nk3gkK2DCFC0xkDBcQUBoN4yWr6mc1g
-J6camYOcmvbU7hJ5hJ6J0VKcqmiQ12eLqWWgi8Gc6doU+wyNtVpCVctOvDKZmKtantRgAsQ4q7eY
-jk9tHz6rLV58Iyi7FX3Was0qjyERtQazCOciDv6kJ3BWOyZa4iODEVAem1lREhFaWQLsfjGJhTko
-SwiJrDNkr8rGqaRWIGJGXRWPMEubkPHE5LO6sq0DiGaGDGhQ9NqDWSsA+YddQdRbr/JNKup68KoF
-ZN6RRETH+FGOLVdmQQaQRUyJbiT+RY+ioM+C4JFEYJHtidUKdgPlHbFtFhZXVAhpNcizWdQhHBlR
-IeEN0LIgA8tGBvSSoHytErha+gRKK5PLBwb2ICattbZZiARatFOETW9IFssOHkOF13xBu6SeTc7p
-GM4Yo6HjLUc3kUU/qqqpwvJCjirjXYOTVwDdMdmAzwyYU9Pqg4ytD1GqiLGZiDnrAieTk0hyXncI
-OfRsJYn7B8nyZskWOKzqxnoT4eGqNEXKru4mEQdjZmlVNq4o8qQBJ90hfOqi0w0xOrqbyJdJ5Jya
-bgbv9FkCpkpfWSkAIrnPdXmErHxCG8OxjewYQw9CUPejsj4YRHT1qvuxm61Ja1CiG4m6mDkalvrQ
-ZJcCf82xMFFdyKTCNOVoKGbr3gfBqSn3s7EVsQiJAnZBnsYyfRSDsbHPTB40NOuLmYaO6yRWfQJk
-8JOBNVfg36W71ZBTzeJBUJMm6qOpiLPABVGNzLgMRG+wHlxKKUgPcow64KLlxmTKGfp7WV6MYqrV
-AUfrmExOZts/E9tANO7Rgrhv55x1MbvQ9HWLrBkYpVrkuKrmnsc3E9teME82Do3sMg==
-	]]>
-	<![CDATA[
-	hC6YJ0vM9tEzJ7QDUziNH59V42C3daE7rkQ5m224YYPkWZ8UgANBUdVlRAow9zTVKgd2gve1LUpc
-kw/sqqoA2dJoAJpY1dCKk7IMa8C9qqMtVlrcH2KwJGIxIog0Otp6NkabGdK7nRgVaR1xrwQ1gEbF
-FIOxWjEgoEW3ZGUHlQVblG+0VrQpODHa0omvApLivuau3jY1RWE4vahD5KSs4hwgSI6OdxIzfjMl
-B20wLCajgTdVPVxBuZCmcm19vL3YKRxINSyfEPRBUXPei0KWJZ4IB3zG80oHXOChxOiqbgVx9irx
-L6JmlZRk0YKqrso4nF0iDzpvWk+LauQm0JmdbTHJ0KiRDIbGsUcSRFqaXRnZ6jTOxCCIKDuKW6lg
-JKSJxEUM+2Qj033gxOtB+0vHGzQbeRZkSBV8cmZsWrcd4rHC8Hwgkjxp4y2Cth7uiKtkgxWOiojZ
-BDJUEZEgEDraLhQRPVub9RR1oXrdH7CKdLRVwvHMVni0xUqITiYVPaOuTrQie+9stF2q4hsZJHXv
-NayIZuZJOaOYITDxq6ntfvbz3R/+u2hv8HxgfcTx0aX4dbGUISInicBTVJoOjtetEC9pb04ANYP2
-RpIpkdG+ZVNVGDcR5q6fIn/ygg3rgE7kUAwXxAqyyUxzUPyQ6Q54Vjt5MxCYtGMRwVBabxBWEhAe
-IqggEDeMxYsZXxQlFaTErhcQrlNVmCRJicdLMB6V7InyZGumvTi1JhEESeRGhGdUQTCZhXVWLD6+
-VzB2PA/AJp2cYg54RDDJ+UvWkiKAMwocNNMMG14RRVW9WmHUQeEQJK0oLgkr0eWheCs5KRGcFk34
-Vh3aj/sosm+Wgl3dIPC4KkA2vLdbT4+5Sm9DLSoxzSWLvt99rbgV7VkdRDTBpyRwwDjLOZNsuAM7
-KNRcL4ZJ7JjIziWaOyXYPkI4a4iywikDCvcgDrjTqr6FaEaLfnqVoDAI9Lun0IGrkSFAiJUsXr0b
-hEqTCoIS4YDVCsIsYkHx7G9nf8zMGgwSBTeYDKGCxNTEd0SMyyqIassICtxDVT2J2WJO5giprKqE
-wkK6VtDYHo38tHXwblYAQ1D0OQzdrBIboU50DIpTUwDp9A9CxlxzfPwQo5fxKjxj1dhPIeGpcMe6
-yIUQc+FfmWNCpLeCpUaLmFcXkWdoaogMVrYKmhPjkYr/2IMWxaalAAqcXbZR4CyY2Q9fISv+IXux
-3we1HOCAi5eXiOoZJMee9kCiAPAA0+Up7ixENGiNZDBiOdTAE7gOncbuwdN1tyU6PZKiuvZRZpyz
-LmSQ+CSak5BvQmSnCp49XgUAIhevp0/UZ70MH5nbmCQBN4gZjgP4FFVN2aC65JMdXt1SWJLCk3Fz
-xOxsK8P4CrmqpTmpxo1LXsUlNLvyaSc6mTKT2XsRQJIwX+xtS1UHO6lHcrZlTIxPh1tYBCk0IgEg
-MamW0yWAxIGBLJ+2qqD7NIe2lFaQnZUkzt3SrbEdr4yaqQ0NmxrjCHUNhU+6wLzomQrj0dD5wjSy
-mv/otLYoEsx6L3yvhdBZd1SxYlCdKhu50V9cgwqnWQywifHW2gEv0Q/FtAnEEzXBqhmAV8QyhIlh
-n3SoVXeMZjwkohuJOtSDNhSLisElz8oxFNVf1O6DGzOFfs7pgkdFtNk5JyDoYMZ/dJcIFIawqN1t
-qc96hmMzEcZYDkpF3aJaL3wosJapThCVbTGMoaoqAHqmSnbZaa0hFekrhTDYUc2qchDzCQ8MSPei
-OikYAQ+/qMbSVFN3jM8ui95BcNAHmUWdB2DRxSk8W4W2MsoQghDACK6mSi2+cNaj0s7PphOJyH3h
-mt2lhsJCUJcwekjl/HTdp4zw3SRSH4jTVYixagUZkV0qiM2MbwyDCj4rGhWBb2o4mtVkgjw+qh0X
-3SWVTfS5SzwZI70UANNYwCyREUc0iDWkLoREP4uBJbemvEAWnRL/IhMJM62agzrkKBpHNaqYtLeC
-5AlijVRvITQsTMKMmF5nN3hbXzVogBUOYqrd6pIYiUMw/aJSchPmP7jEowImadmX7hKP4noJ3RAx
-CjdmdfYakIDnh0H6cHZZBw6ZFUjZj4z8iChiZmX/arZOdLmaDbga2iI70JXojOi6qiYRMoMcgy5X
-WYuodVazvknIVB4XaDCRPHIiIR4a8RPggCvsYqOFLVW1/qmH31M4ZJZGSU4jzY3cLwvyUyHrzpSo
-ACQ6U7yymVVQ4S9F+OMcVNRDclNInfoL0ZTRVPNW0ysZB7xoqPB94aWRL7mTQ1aM8NiDWlWulBVB
-+0ZPafLJ0NyRnayKnYH02adCrk5hmzT9ShaQAnGd4o3ckVEqwmEVwmST6QLI7TJv7sjmEu5FUg82
-mmx8FfQyWlgbE0lZZWJUxyu6JWOxR52bhcepbIpm2+iVzzenRI2LEcw+dyHzwiHWa+GxaFCOimgj
-bUDJIWRRf8jkoWTxjQdBWyCxMKCKiYKuRd9EVUksVD2H0ZkTZnE5kmfqqZDV5jxzCAuTJTaEK8HT
-Qp+OA5k5CkbNiiIaGEv9hKDSgorA18i5GYJaxFQc+FmD/zBmJKiliqRHJZdmoYJJpyn1wLlgpsxE
-OE6ZuzA7RQ3SocQs1GC3BARPYtujYIGnQhZcz2JlAply/8hhoqExiBKKiq7TsUCUkMl6ih5GlJCz
-tDKMHxOyd2LHouShXG9QeRP9yFmjBRMhexQ52Go1MqFgee9JXFKKxvi77wiDNdi3iYIFxvpzL6K6
-4IIImlxraV71HnEZJ1MJlVNxBVlxaQsGRilvDPQqsaq0uJselSxKInDT7GazRgoi+6om9dWgnErF
-3kLhlUxTiweeqDK2A7Nl6tMVtXK6AyY32zErMvmaiayGaVRlPSMXmoFTcaKCcrqa1O88NCfkVS8o
-N0ztreXatlQJlUGXvnjr0Gwbg2rbEkOOTXg1VJKnYtUHJa/7EBik+1R4fhlUoIHcoiqt6vjEGZqd
-xn+I/5sOIz3GiSOteyHkdS8EkPVU594860uy4COyxelj17J6kNWWTK8x5CTa9kLI615UxnzqS3uB
-IY9kdBGw9k+xJRwvgqtCYnQaq15MlCcpnY0fOhFapz7dUMnCp+RQvPsA2XGw6rqSC2SMZ1MyzjAL
-d0tyVANg6sGteFq6psTEyDl0A3HcgVagLL6yT2lRLwX6ZQugkzAZ2+UY3KPcS3JerOpFhsLxsct6
-A/JkRWg2FpQwOYNThKbqNcgqi74ZodVXq0LJq1WhmR6eCruUmOIlGQ0VmrfAYjDyEK1Xg3StGHhU
-KqBe5MJm6FW9nYx4TkvplYtKhxgOVNkERLnmGDw6AM6Lxh4QOlHBAZ2sZy2iBvmo3FJyYR1fyRIg
-gyg90bER8cfG1SzZKZlYC40Vhr+g6+M4Lclw7qFZy0LRE63H3CzcAwGG7OrHjHrCZHoFRSz6q3rJ
-VqzxtVQFSQtkiGF/GRL5hES92PECwQoqxVCVMiDVO3mRxwQ7zyvhMpmM/RrsL1acy+ReCUYxsXnp
-EtkzxljJAv5Ht4YEjxFqns4kVJu7XVlAooiFTepjGciRFdCnYtEUt8MlMrphazZySiQmob8jJ7WA
-SpqF0iywAQ0XHBSM6nDqNjmhLltDmH74AJkSfmkEMXrxHMGcsD1xY1IMOWky2LOaFFdKuYz5LVS/
-78RFY1VNi5fIbojzJvQScbo6eGuaxrFX8W49YccQr8Lq+kAM1LG16lRAuER2bLVUss6G74YZrxoZ
-ttdUF6blSLTUo047edEaiv1t27dOnjn2WcmgDghZzXGExCBWWfo+R48qm3bQL+Z9D/OXqGJKXWLG
-HYkSzz1cB7uTGcYd2fqr3kMlF1Qke/4q8TVisJ3krKgY3cqMsiYD5Bg2nPIcaKUS3Ik48ujs25zv
-B/mwwgEjm7KJSEY3NWRJ3iskV02OiLaKSu6dTOnL1AeLBr05KDl7IweO5MbcHqJqVAs1w9jEGhUl
-QvsKwdZJ4d51VuAbxlFaWxi3RkdWbkN2AES+FQ22IaOkkgUhprlMnhQOcycLVemhdeh1zmRvxnws
-ehLUWUM5CvqBfc/QFRypwMUxZFd90ZGNoBiw41V0QvRGIU0TA30U2100sAYDgSSqF4mcpBBT00QL
-10d2RX5Q9Jp5G9+RPCx1NJRy2FDg/WJkZoroB5J0MNg1Ob2iJj7Ct2BIAy3pNmx6x28R2Z+svEQy
-JZYoCS24DrEMktms9JGQmER0T1Rrb2YsD5rNJOgZkXmFlgkyzGbAo5l9JPRsCapv43xwFgCsogVv
-sy/6IJ6hqXTyzOB+NNJnA4tJ9BNa/zrysbF7CNEbIeRhZfI8wwu50DOxCeoELauWJ4F2Lcn6pQ7J
-dZD1cCYQAjwabEDMFxRu1DSSJjcldl8rYmNzkkNjNJ62KmxKRSwCm5IcTAytKmwvMoaPe5ANJCIx
-y5RDJVTjXVxB5cHpvIvIev7TKJKItKVQ5FrqGzMz6ATnIBTFmjVOQ0RQLokNwlQwHHEnJiRFsHmN
-uAtOw8ckQpDCRiQICM1gTeJDKDZW0a9KxnAgyz1iB3H23VaPjJkjfiTDi/SVZdnU2ByiKBWYDhL2
-o/ljCYioiGdd9bOm6ImCe9OlVVwVFHR2lpkjcTYjVt8GaB6DhzAqN7OLDIHc9Uy/EJEaJBZq1pAP
-r87jnMwCi4dXUmbuYg+dIc2DBhw6oIg9cZWjxKV+q6YJLVCaxXwH6tmAbsq6yhpQ4GUShygSr+CK
-SqFYHdwtKZFwlxU5/Rya4kSysDDGWRG1SAyGUKmaVBFlnqB2foGUURicU1yBZCvDgz5pAHjxGvNe
-e3hMwdz5Kmg2UUWLhVuRvGKuHadGWj1cn5AsXjhx3dCrWdN0lMY+cXP/8wlHI2zu/861ZkkUgkgD
-hrgSe5p7ByT5BgL/1PU4q55GWJmoryUYQPKipp7YzzsNUx180hJKin8WRY+S7EU50UnPNQfd3CR2
-tSULb9Pce41zdvLMyO5IYrpR6bcwiBCNgiijqZgrwPsU7CxFItvlUQFXmboyv2YVvWN/Kl8/QXYJ
-ha7iOuXVRfGSVkFPCErJpA3/xPEAaOUVCHWxbCf4rPrAkag5P11UBBYFnDGxxKyuz1I1Q2zy6vnU
-nDtugNNi81UzJM81a+hVYRcQVuqb4rcq4wrUlqwVtBwli2qTWJNCOWA0KZFCCHBCNQsNZW/U7SUQ
-HcqgWHUKNOK1J0bCk9QyrfYgInSMhyyvoHGhSOQ8K5ibRePtBJBIRDJaKogBTiuJPvbqmo8aw4Pr
-yBtySJMiRU7x/Uw03eqbGDiyZOtAwwKby9EYpqncJFigcDyDpt7MKMUGxSqnYvlFGDWKhkXBZGW0
-Q1toUWyaIiXrgGPmTE3bZomCKZ2mpfGL5m4nX8kzUe21B97C/JFhJydICK+LazaXsBsjJGeDnaDb
-e6d1ejUGR0s3Itki0TVkQUCYhYS5CVlImxlDBIIuUjE/GRidSAjy2BOeSNA+pR2SIQ==
-	]]>
-	<![CDATA[
-	RMOz4ls0vo6O+GqhZIaymjn/J5PF4YRMjnVu8g46S44oycjdEAiF6gNHPNJoWW8lXJGcoU1TG0pw
-pbrln4nhqnCMH06NBGKiEpc0T3oVBoMpCNkoTyl4FHyEZjAWeJTMZhtnCIvZQvowdD1rlJ1CT3C7
-zxbM1hQ5glwsGfwlMcAxGSCUPNVcAcayO80ahyIAu1urojHRrir5DCJdBSOxWGTp/+PEZCepPxp7
-bJ+wOZYPK3KbiW8uqXCFGyyrbxi1kSzW5iKAlmhO8SjhuU/EWZvEZE4JgLiCMFjdzSuLYfNVQp6c
-YBto4JJmepsVJoMuDEbEYFaRxjCG0EMJGnN/JkpKhyh5Usw7LZEPzfBu0TJmwHAV0UdxqxXLgzcr
-O4newgeDoVHQEceKFe4bEdmwB5IhCvav16ye+OysCVzIUctEUTERBC44WXSAtSzQdsorox56yXWL
-UaTFfOmSeCF2tDKuE+FcjrN0cgVFHa+4RcRBRUtOM61oTF/yKt1gX4oim3F9z+r4UmsBJv4xGHqT
-NFsZHU1OoBEUW6KbSQKpKHEn6xlojuS8wwjblJD80t9r5gBGtTwmNrihu2VMBivZDUKyhAPIvwUU
-Kw6AZccCR4Vxx2Y1QqD7WfTNJGHpDBUSN1YqnJ9UAAZq9KWEfgpHJLI6feV0xCqyDbmTJFc9xRvG
-DTolNuOgxBxq0v6yKIMrkPky+q4lywRnE2vrjg1OxbFjW3TJcJEBpuYKmrwyWsqA1BNfj165VA2f
-Ey1eODU1VFNquKoZmmRzq7vwKM1JmoOFFzEnddtjFZI9IScLiOmosm1/NXsavlvT5JX9RaIl7Bwd
-eyR/BHEDkpf8CXlqZk4USwAM8UOhZyBqMLAh/zEBG8fcLxyR+H4SsZkNCE4+lyDRpYqC2PZXXgRl
-qy740BVsTBW3VWyqr5BoloUpkr4iD0qYsfgmdTuKvrJwWWbz0GPCThH+MDOGZCNtvI5EHkttcE7y
-XmjahdFlmSq/EXdMAltS1Rh+PJkEZQjrTFzTi1rXQ/DUMnY5P48+z5cbMmW6UcdbyllVA1GQEOpg
-94vYYd5ddFLv8Xxz2o+iAXPLflgcIKYeFA5PKRm0FxQ4zzWLrIPEGDvT7eTu0902J/3IZiRd9GMg
-j85ezG8hGYUukMdGt3Vro4Y0WzbayWPtlD+j5A+QF41u6tZGLafNstFOXtTuNT35JfKi0U3dTy0h
-Y6pnhreTF7WbmeASedHopm5tNKmJc9loJy9qT+xmu0xeNLqpWxolnYwGX3N+WHrZpP7m4tRwh8nw
-StKcinrpQexR/ugzdKLmkVWguxKJjMc1uq61XgmOQ2akIHSn0F0kqslEvusRk3vs/Q6jh82plJUR
-jCrp5jHyJEtCIyfprRbvrFm7ZpU5MMVQ0TSK3XGr5JU/N+N+13TsQyUXyFbJN8tqMIGMZatZkL0l
-ae7VXCZTJU/P171tFLNt6CUPA7mwurSu/QJZKlk3auR1o5Ldd90oOs1829R+gSyVrBs18rrRxFGC
-60YTwx/XtV8kUyXrRo28bjSyYrBuVMB569ovkKWSdaNGXjfqhwDQBdmjDKrViNsZUTfNzBuCwEUp
-t5sqRVTReo/nm9N+oJczjexXb1jJjCdd8qpOXvCqXskFslXCjaJRoKVNo5Xt4+tGO3lmn5wBWDhg
-DqV5l/SylOT1fjBFOG2bUxZiWAWUPxAp+nJJRt5sHkr06HEYNcqDGt0dFI6ZM/s+n4zQCrRemCeo
-k8nOZhd0BHSneO6FormxMbYjYJK+lC1OctnfoyUT05zkEjDzcknOMwudiq7QPHCOrytiosRo5Z4Z
-vUgKYGLclPBG4fxCxq1kqxSrEFMokqXWHPXJ1D0Kq94e15sCQyGiJhXse0vJTzdkSryzRu5cJEsl
-60Ydm3210VBbHsjaaGQ0IJIF0IpEdl5S7LHEk/TuOb6k6LjqNSrNWz58iWy9WPcajZRztF4rtEjI
-Wk0rs/hlsmCyGpsF2C0jZhq6gYhsrlUw18dNN4i87p21tuodumEw0bJNpMFDiPzUhroIlGSwvUp0
-IV3ux+gMtFEy4APt9s401bE5Ij8934tt9wonOVLmK8g7dItYHmnJbkJekaZDJxGCRaAc626MCI9t
-a70bsCN0y4UuwIhrDqgkGbJURIYd2rLE9YVYekZJzeyDZDZ3ZknLLkuUg21QBItOiZLLPQvkX+3L
-onBj6llNWN70Dr2cLLcQ4UWKcD+KEVU3IHkMGOriLIhW8kxmTtdCNlC6w8TJ2yqgioizygf4iZ9t
-mm4hu564FF3MOSgDthDIOKtrjWxM6psTKxPyXDGUoZuOXS2ItdPA69lwIJGZiI5MnSmejK4o8eqK
-lCBG9pAFq1XRD+a+GX2OWbJQYDZbDurHFdZMLFegTeUrNNRwLwODbifJd4CuA744hFy1QYUDuXQH
-HcwWS4ZLjjMfY5Snm/UFJMUUunWzxaM7jhomp25UH57TLFVIFkAGLgN2GBJMx6lLRGaL8I61D2FP
-A2w39FSNGEWPRbJ075qRs7FeZt4PztSFHExyBhL4iXs7MxJGOFzk/YzJvTWHGl0O7QXEFAxRWeai
-gCtEhf1RuT17mbGH0XwihS/oydUCpxE3wQGQpBkp/IRyJWtWURPcimKoUeGcjR0vmcGzjZpDgMTN
-mVgGYw7jt4KMjSatbxrRTizffOqqD2HuTr/hpNraWh8y8jc6lqyl4nQH1UfVDIdDpbfHOYaKcC/E
-Q1b0BSyapmgjdn0UThIbyagJ2R+rdv+4Yeyeg6BXUjV+L7UuVWeBMK7IctUH7oGoN/N5RgDism9B
-ZW2dA88bf3XCayfWx4CRtdMKPApDEuFsUVPIrCRfMPnYimzVwUmnNWMyAk3/NJDDcGH0trk+l3Ia
-UP7t6Gw2HQOrimehU4ic35dudsulz6YkJO6zibVlPZPpIAtjI1JbLka0C9+Wvdnq/ZHvmlttiJwG
-+B+JEc6OrawMT65xQNOwMnwxK2qtx/ONPbVeyFUSCFSF9Wu98HMW8IalN0HznKH/NV6514xwjDPN
-Ua1Pzzemxs2qh6oGPbwUstw4knpKGHSbxFk0Q7Vspw6VGIM0OgZ/EaQxQP49xxsqWRSY7DlUkYmB
-a8a8/LPxeYnyynJfgTYnOYsXsRvbt9PXxjhoP1rSXgpZHI/4Se4+wY9ebzlWx3py6jFbGpFRpK9b
-m24nL4yxm1707mnozOgVcAo3XpjfUYZrYn7Ps/junN4hhzZ51+w+BcHCNQ5r1D4XzphC0Ze8Ezc9
-+D33DLOOsqNvYbBEN0Psl1vre0e7bJDwOhYmWotem03M5gn5wkXkxK5XTRa6IPeBG3pxgby0eOIf
-kt3ppOMZ7bYScjM3vfFHXAYYvySQR/TJc3wt+p7xTsqjVJAkE2lTqPji0Wa3CKWsroUe2bjulHbW
-Uiwt1iYmRo1qE6aUUEyMTVPYsyCDLi6+AQVXRtCkRQvyMGSbxrQXXiHdSW7m0yh1vTbMWbZc9FBm
-jTfToCfMOLhc3MdNvUM/Ns31fmgu48qhv9oPQV3FahpftItGEaTQ1KUqN8pg4HOu0YALkaFzsZrT
-CtuS8MZmwjm6Ljn/KmEkLCo+arYIGnkWKjDu28L01OONOSmr3kweOvbCIpoU3SSrT268ymxMVe4R
-xV/aU5QkSZdM3lWCnDxh/04zDI6IGRkzHdnNVIamS3b92gChSVHxXXTdILALvvvGW+h6NXAQ9mBW
-UAnFN1D+BTTUzHpVdhUtK2UFHdMG54WDjmfmXTS2QS9zKQbJmw1Vkii/ju5WxdUgqLcEnTHVstBY
-zuoEbcIqj0osKDPHIsQOPyEfhHbAe7teT+/3whReXsIG9c5odIRkJRZL1ZrGGwVlZiT5B72UpopN
-3q4Hq/2iNeLDXniIhmzhtwT6RxxfB3u2HPHOnOkU7q7wQ82pTUBIBVp2AE1yBgw1YTVZWnbsoMCY
-6To8de7RBQm6jiVHC3ZlrrqO0dLDb+AkDXDsaTsre2uMMzE8mOCLwtiy4o2SoHufCPxFMY10oOpe
-BhFIeuskDXA0oT9149SWmYiORLHn6oMmqMNLIfcr4oug1BjcJjXrtbEIE3K2ZC1d3kBecLve3AWy
-9EKYIMZ0N7VrkybM3TPAXbLrWxFVU+xRSUGKyRRmWzs9JcZIHuKEx9YukKkT2rvCSVJWBxamHGCQ
-/7KaTl6EMvdKLpCX51Ow5L7LRqsaUpeNdvKidtheaes5RXLTLqriFMgOpDBdwSkPvZh5zx7Pd+4p
-Xy3+1fRP+1/Wr0+Pzw9v3r/985d3797dv3lk4uH+2xePC/LPvnp8vHt5/3wXfj7Nuz3894e/0u0N
-887tZip/+A5++W/w4V+B9Ndd3P1q9y//Y949x2d/Mz0JzYN2tQOpHZVOvuoLFFYMTYZ11slPR3IA
-+QdRvETlCs6Qxi8/Sq++mDAqACT5skNnaPL8ATdi2mEsfkMLx0yRKAkpDnZKJorH3fiHO+oHotFA
-8I/zjPektCy9TpzpnMiJwJ1EJFMgEUG5CULMeAwD0bM1+ygVeEyZxPVi7iMhIoPnZzFSkonACaWp
-4BmsCOTIwRVAxmwDlRtDr7eXZyOKQfIkHlZE5CxKRKTUqlyrY78qV4DnLJFda51MiZipMUyIxzNE
-AB6uAcM/FrM5kwc6WGtRhmtmKVyrJfcDV8uOdKKS/M4Px6bDOEerGMOIZGgwzyp/vwQbWodJE4ka
-8SAXIu4pItL1JFKpd/IkiR9HmXM4sYKQCVZOzxLCjF8XrWD8pMcQMVkGfJs8V1CyDG4iQxsTZ50G
-WGBud3Z5kV2A/tAwSRX1ARakl3VXEEPdmCwBV0RtmBWCB6e2gYyHAy8RynYS5MZ6nWHMmcVEh9f9
-8su1pANR+Wb05TsXThFERI+2XibWWKVWAtQdtQeYmkx2RNEelLno6GAQOxPpynBa+o5TUHMHZHg8
-I+S00lrkURIoiJhdlDfIZS7WAbq3ntc+xnjy2BJCkHvVpzJV3mbeMJtEjva2Dc9rIUoPhs2LtzN4
-Ywm20TIzJiYTtpKIZE5gYklaQRBOgcTWKyDwCm8HvOn+qZATZkPkydWhwYRMuqHIGs1vi7YJpoUa
-rdoZZBTkphgg6INVSwuMyJRXiEeR1gERE+XR5qWI1xcRkRJmyIhLla3qcgGJSh6jPMJnV3df9qtB
-fKnkaEsmWSUe0bBCzPnDO/L8s0OtnbieRupa9bZsMQu7lx1JmeeY6Wd7P4yyw3sfiFiYDVPkXU1M
-U2tRYBckMzbE4HHMM5NrlhryzNwVo/StC8EHoQWESBBNc2kQOTlmCYn9Bkyky7D42cS7odJRIy8Q
-U+r9IvmXn3VR1gdF6zvprpxQle5j99wWhbDLg3I+IWA1yGpGcuXXpeAdL9VKEBeQMYlmCEYmHCSR
-vWcOhh5vV2QgkyzR7ezwtEFv0HhUpHOY6/ulkDOmTCIyiF24pJGYWpA+p5lYGz/JfQ==
-	]]>
-	<![CDATA[
-	wJyKbF0jMsEOmIx3IQmx8mskXadneqAripLOFX474n68ojD5FS+eyinBngp5DnPip9ssk4cqYQhM
-hC3admfr1QZRpgdZmfZiRNfKy052Qi4yyhLSyMSYbbFhzUzEqAZdK+SHIzKls3lq5JAHshJ9O0N0
-I9HqBalMyK4WW/DAxZihJD5Ht28mr9y8HfHjKyM586R2joZEmf7G48ZEh54sJgZlKPQsTyoFWuj3
-E59hi++vOiA9I69upbHMvICoZxS/yeOT+ZKyp0J2eGYRuVBoIBFBPBIi8Q4m0vUfREyC8GUymgWZ
-LKcuBa1rYzoZlJo2ypOV70fgtjDckTtQdVWWwmIokItuA66hFCaCakvMh1AEM01Rj8rmClBUJnKZ
-mVEN/ULDu9fORsxcRMQuSeOLocZNjbEthkcRZH8hIvcRIuZ6ZaIeWBR37uV1Ce7y9Pz0PGWGMst1
-R3z4o4v+pZKFMaKZQ6phclNRgeVWrsKp1Fdob52p99gbRBMNC/VOOdjlBlNTOZWSeDIxooVSqmht
-d7bezpdynYUZU56Gl0puTnl0S8qAioghxUTEcwzog0wexkWqEMkc20INlrtAkc/n+tU7POcivJjO
-YD2az541fUcnNuPZyYZOICLDFox2rHg5RsPM0tu2OWU2ImbTXm9ujsZs5Ch0YrbiZ3X00a6WmQNh
-BCZXUNmoxMyGroNoTG6yyZrjKDmqIKDH6gK3kY7NVciOLrxgzsbyppt5R3Otome52W5g5Y7NNDjO
-4c1/+mxl0cPpPddUK40XkOiKEeWWuThpKhbWqPDrmc4uN3MQlbwVWi55CJvrFYi67GbO8KesmXiw
-Q4d2UmLwJI85GmGtIDBKj3sQSWdolCQ1cGfJ2I5ERJIEGYBhBCPL3lwt3b1GRNkRbjbloMlNRjwq
-kngWyKjARnoWz57gtTHPRCfpcoioXRWjhvZgLlFtHRTbTUTHnMRhnpmstTpWEt1ocmh0N26QZ5Mc
-LPgwr0PnTKzAR2UQ1bNCxMiyBr5Ycdmq1QkPyVahiL/OqZyKtMwUwlvZd1lqc2ibcnKowLO1Vmme
-wlKZCOyx6dKaoy6BTJqYE/OoLhcdFgqM1V553jBI1DXs+aAgImy4ZOtdFFd8g9p0vaekz0ZXZcHy
-75ptnR4jf6e000Rha+iFKbICKSUgcJLGWjFvK5l/vCXKiMTYmXsimlDfn0LkmBgqSenYpTAXJc6z
-EPsCojwlOgeOouWISLucG3Nss9KrMXn8W3JWQci6KshKgMSimpVDSxxSsu0K1Ln1nL0s1npua0Yj
-ROEqMEk8n4W18+KI/iglxuCtXkLl0KlAJhQmVs/ctfCqlwp8SsOhohVU16QCgv0xMfPCmrsAgRfJ
-ZSHpmYYmpKqtx1lbb/JO6NIUhSiZaQ2dWVmHhS7ok0PNhG90Gc5yOKiNBReA88JtCN5h6yI7kURt
-rc9XcjLUmJVC4Cx+LBhjRWigF0HYz0nPJi92uSYgQl6rYuKpDMTUCgicwGRXtDESqpmoTGXmpAB8
-uKHX/Xj+0HwqpzpaDnhiK8bbNjnVEWxYZcF4z6I7EEtI8qwT0wMSi/bC6daudI1z0bWVqj7qdWXx
-8bRtXqUNHL9ZOtDwppKXSuYTAslRdyJ0QNY83ZW6eRC5m85jyVmWd9NliBDN4rQCea/zM7F8NgVd
-NEWbstaXvdfXkgRybDHIJvOprS2pQYmSUGXRkjkjPcuB6LJkJTe6LvLVENU0UJsKd9UkLUrLIS3J
-Mk4aGSW9EoEmoQvYy/5SYzDenet00y3632VDNVPnK3HNMFV4CSWi72aILs3OUSZRrhcSYtPubmRR
-IbOgM9OVQcGeVZtJzdkGbNEvlSEzq9hiVyjS4dbtkIks8E/1YT4qZk2uxsRgpo3I87OttivIaihq
-7Mo1BdmbeGr6bUxZFpjJe11gQ6LJW46dEkyexbTfRPlnFspnIAnCPugB4KsQZ+luZbnGmE2dtQfN
-tkMW+0ol/NuHtpiczMiBVJqvZuhCBZQ5IJ6AYmOiO8ztAIz9pZrXR2fRMijL7IdZT5uzmXDkXEB9
-3QnRJ9F/qnHVYteoMNlsQAT3EWLWDqgKjsRZzyUzAuBpzzIUrVobALVkoQ1JDltExnoletd5TBAX
-V5EE6jJYQTqgygEOa0pSgSvDaRVrS3rY2mmVpbEsqVL4DBELS7HU8Hxc1KTDHUQMRnRRMzMY8/Tm
-ODk9DxYG1OnKLEUZIKVeYEE0inG2DwwRvfDZGOsgs/ZFEFQ4JRs6P+q9ypb9FHS+dF1mteOeGgeu
-snEz7Tk1B1ImEKb6pLJQm/ujs8o3dIsKE7vaHY3dLiogs8u6gmUHkEfoZSFkwclFVSNSUV4KGQRb
-UcNoRpiX4jNNpFAnwuKMG5QfVLYttkP5dhns1ylIpRwiws8GEotQYw1RjdoqlaLD14RVuqVWtEtO
-u0JMV/WC2ea+82wU4/3AyisbUpAsWjuKkC2pzhycHkc+N2kq8pGqQmyTjpFuwsTELl7sgQ867pnd
-b/hki12yzVk1Br4ki2vlw99J/JESnYwspY7VCkitZbILJkazVxDFSNGjqFtRaiX/h70Cq6IomxWr
-QI++1isIqlwgUSDTYtsJIoo21U+ibTaUXXUIRbWa7aYdFgpsuN1w0Hs1EXCiICbOQXpKJjU7j0WM
-b7w4dMJVvMVrR4XWUjjTgSSmnsZCu6widiqqIM7rTWV+lMPUl4xWJVEumnmCMB2jDnZUqRDvSp7V
-RKJuBvq+zUDqxir0O9am1cZoe64blaIqU8jwVDb2RbZ6f7KwFeQoFai46INM92wOzIo5oGgjYWSa
-uM4ae5L063PhYwt9gmxmqYIEkL4WNdjPLcpw0aGlFaTZy5J3YmZBV9Tc1NaekxJFbHCYACl1lwHB
-lnhus4gD5AzVCRcdBXkRG9WcxCFZD3LS7VEHbuayPu0LC4Ga4JLqVXkA47pasqnRk5OC9tRcV2Ze
-CUjECeGOiQWKLlZtuuhNlEY2W6OuUGdG9T62lOb1LJ8+atod7p5YQYQnvBSy2KmdBIA9FTIBQxcs
-CEMYfXBKjPbay3qPDDOCv9GNa0WACMSeXip5Vs80bH8a04BOFPVr+8qrFYlsJ5spUZNsLiQbKEQ7
-gsTmV+iNbQ/+f/bedLfO41gXvgLdA/8ESD5ESs/D9q9YGbAPmAFxkp2NgwODpiibJxx8KCqO99V/
-XcNT3eSiLFJUnFfSQuBYLvXqt8fqGp9S8bdoYS92HE2TbUmUW6euq26m48LI3SCrrk1dUI9KzAd3
-dovvOXkr2Afh7XtZw0jFCeGD2owIMYrOmvompGsnwSXcg9ODtNutfo+rNiPuhaugnIOsOg2RnRoD
-iazypbP7S0Q121M+iHyQawYGbQlYjLs+p7INx6lVdSc6uOE4pK1rYAHs0hz+hkUORjJHIB+K5/pz
-rnwnP+9l/rygTxEcdr4+d4PjMGTZkmScCNl3kDOWnUEwlVZBU8ep5io+xx4TB9Be7fehBfw+iBJ4
-17bdOSxdRcIUpJsn3jY6lucgWzdJ7wHBJnkPoqoFRCzihKtwk2sHNmJ1fDMxF3xM367dEWApi6Qt
-aDyJ04NGZGIbQi6ynQTzRMZOITYxLxMxw7dMZ/353d3qUjB4eVVvoIcbjvHLk+w0BzHDm6fyjZCd
-cO8krjBxSMJLudPtc1v6YseKlRwsPVsfmczPkBL1sMWCGVd1PZLjHDydOu0gx2q/5ojB213e+jwu
-uIMB21HQt9cjHJ247ydZid5HEJVfEjGHhfgcHQS54FxbURnEztd0O8IMnVC34znI3oGs0mqg9yOp
-+3MosUGJMXYQZzBfl+ARJXu0zSoBUgca+7gzAl0hQmZVedVJz+cg6wo5CbcS4gz9q+pSoqQJhyeJ
-7TfPtQMnbyOi7pSoIXN0t+X52h0BNk+9Eyxbsdp5rmSYHqsF7hFRo9aqRZdG8npAzWdZ+Dk6MNUX
-hgb6WOowwIOP74xgDu1WzxiaKkCsaVftYyrPRYMhqNi8hq1VCbDByDiYRNomkei5U1Pf1QRz19Rk
-PwlS32trzjg6Bzk7kNViT0TRwRzHPyiN773QCuzQRFYf6eSX/PuiRK7qfucAntslmGGUmew3uATO
-4oJ5UZ6+OTizqzXeiTiHMMimo6DHtmtTXFs3Q+KaeaYdsZluv0egmzNOx0GjVTnz4HYIw2QAPiYi
-uUziQ+k8KRfu+Fh0OP8wIYRmjLaLoQYdcFSCRPIgNJDiQLo+Ayz26wgSInmKPYlBceeF/+HKr5yS
-gRe0A5L/mIOj7p0sLQlnIgKoAB8otgtBkNFVMERGFpTVCjYFUnkggzrEbHbxoetLJgoXBbhqCCEJ
-8G6uAWzpxC8EnUs4nIZwOfPABIbNUGJWb3F0ImQIUZPMZQwekeANptbQxLzAh872vJmzSaOofpDz
-BhX7llhy0vaqhrOMc4DB3jr28z605NSux1AMuA9Nn5YikeNYCPgvFMFVV701EHHyuoU+UBxkmQtx
-63OLrKCsnpxcPpmsEDuUp+RqNllhquwsQghxanWw0u72Ox/lpEbxKA//uZHF1KxkPKoc/aZk1Vic
-BM/tEG/2i2AyjSmQkZBv9NzIsAeELLeGiVCRuZqgEivsDNNnzG1h/1jbTuLa640RYGicIaoSIxs+
-z43cTDwVdZhoHcFkUCxVRlCJE+yacPpMRobflOsdRJVjcTx3B7AuGswCiwi5ksXlVddwQUSa3DXj
-nZ8vbS00MKjiuPt9yJoUmQ+LPOs15yB3vLOwhhW63UHFAnaA/VXbhooQLISb3Gg73hl0cOtjGEW0
-F0ZD0M/vJh+CrBapoiCrQqS6wUJUwz4R1WpSrCjo3f1CfmPTosb9lSm/9Q71pHdJE6HiwzWrTO80
-rpORv6O+CM5COBM77hBPqH49ruJpQYbqYdkdwXKCbt4aO0G9qsEqwioTLNBbuY0SNS1FcaGOn6Dt
-5EzRDqGFp8YU33RtRd+usBa5xL6Lc6V2Jx4CQormyeWZTpFwEYmmsYikOFXV7okcq3aKAFf+vZyf
-JCqlEr0H0ZZ8Z1SwDhDKjNcxsNxzruQmtK62eqJomkgig3QHUR8wRU58rr+GWJrEIkvEvAT0YdMz
-YSdnLEuFyY7aamRCMomQelUnaDLlPmtJOObLzSESKBfrN5qMx7C88qJFcwtk9pFlIRYTGbiMMX4u
-zmRqqfeMw7yqEudUyYOD1cZeqxEjaxCwjFPf/0HUYC96VDIyXygju4pQTuGc0KSpU4/HqnVfjHx7
-Z5UqIX5EVW9fnrlCpIFXI6q/OS0ZSLlYrEEyY041QSwrf949P8/tYN06GnawLALBqUU5z0gcwv+u
-OFu9BxDNC0lkBx+713S0XBDNxR348qbDKUMLYopOkqGBGzrTSbKC7wnRI5cC4TSU461CPWFi9S6s
-g8i6bZnqUhV0kKN1ILxnZwAzS6DklpYpI0sA8cZZ2LYQ1cvGuQ0WzQ8LLJVlcTNL4A==
-	]]>
-	<![CDATA[
-	FhmujKAG3zy9Kd5CtfLMVPFLesYMCtgdLx6OYLlAVPNRn41gglxEIChVodYeogWCUn625q5RxSVE
-2RA5Jr0WkDsYrKGCqG4mImYQOWDPOvBdb7XZHdZRwU5ye/zzTEMNoKI1cMNSYV+TDTkDThmTWnw0
-tOUHuRUi8Sg6JuBMw/YRoe/vDuC5LTgElCR2GSy5OjRcslymxMn8yp4Is4qJ3pz7aYlsonodGreR
-LLIpTctF0lpHTESIuVbZQQewaydhX/oxNUUkO7u7U8DcPMUQZPTscZy8PG9KzjYKcX0zsb5laFlD
-F5IFFt/qVd763RHcdM+Tm6zjueqWUEKO8AiGYH7sIJVK9BmsSNm6FRhvnnQ19ZP7YwbRz49584FG
-22jGuBMi7kYSEBv0yrkrQtanqIVljfg9ESIMX0nSCtFBbq7ttFV/FX9s6bXrqRqqxNKBOjYHuRa0
-RSjKIGasS9GopSTIC/h9r3hEfJv5EAlhbJlSkp7+UGwbxHEqk9MRTFAc5GgL0dkNzNCmARKz0zRj
-ctmrGSybzMEed7xinCdnkSE5aluL5smmqiTc+DbT3bMItAh+jWoNoCehwQtdxFXC4woWAN2KpcKM
-lwnhwxTVV3RkTZVt+tzMrathhsrOGDjLaaymjKYZYVjFXyS7YJYSIlOhFDngIaED5MwnFSeWMKsk
-jxN+XqoJlBhrs5gyAsTJFr4VkX0ZvJ/xY0FDlbMYDoWoEdhOK4QLsTi8zdNf0Jod72yQZRKVJcEL
-LGZptHMXpiZPs8YCUACdOlLLogpR/JROomjpYQnWazi1uOJ9PlRFqiMjpkmzLuhjNSHkf7l3ajyg
-SCm1ZSaBaLH8DJWKs9lXKEGjQNLj1FQhTiuPMxcWhWWpXF40qKRHMSPJKVAmRx+yMFHNepJh1SCT
-pXl1HWq3HFyn9kmaVDM9N7eZcYAYhSKxXk81kwN2KrwwPVlWUll8fj3Z8y1XHNkZEIuzJIUJsatc
-kETpe8r5JVNw9JY1sBv3icDR0APOl8bl9CL2WLnO6mHoBX59Inq43tn3PPcrIfK0EcvTh14DRGdm
-fpa0g2PtIGeMAPZYIipLpreqoIOsR4N0PtxG0vob3hVLHyJ0A4eLp1FflFioTqs1FZnswK7Pd01b
-2lsFUI1OYYI4sSVYLOr0YiUIjd05ux62LESc37cXsDPwBuTWrKUNmIxhZdhoqYv5LLGwr/0GCDBc
-bhr94oSbXNPZyWCvsISq8Aj0giTL9OyM4ACOlsSwQkQfoMkFfhW4T31V4sxooKYIsIxQFOT3Dpso
-BjBuqXgnUUrYooNugqimVXXCeggYq2qNTMwwM3AounQQTKNNEi5yCLK64ZLW+xjEaFJvEkhCIcJ/
-lqbHj8iL8aBobuWYZEp4BMVsTUSIkSQb2Myoul+9yZH4YxGvKNfuYRoHSCotzN+zp0YGK0bhTpwh
-IBpeo2c7X1Z7xZED1h2Xx8atk4R6SgTVJCq+oZYdirSMDHcqkTsSAfmA6wi6ZV9ksYQKEW62JOlW
-3AFFa1UYCjR7gIhrSoF04L1lkeapPzG5421n+70QYdjIYrASIjStdRMoKS6Co4lVhWg5QcbE0fAR
-sZqrXYnIc8PVxkhEOMZJNvDoIGjkHYlS9nPouyQk+6Iti22BE6MQEaeCru4FIifKyQGnlzwuasv+
-AOmgWQfN4QHuWD8FIZCLJIrX+IzwYBXD5Az5GRmvYuvxEyHHbucVO9jWA2+/9x1yc0PCIJGn4sa8
-7FDJyFHV3RLshMlPF+IbEBlKhvoiMR6MveDBer0oxdKw2AZqnHQPTuoVCteQ528ctGfwVKltAohT
-tFBFTW30W4gKSUAJBJzKS7gNkxn95xBfUnktiniK1gj6j2qxIxose8oildjANxOSZJmsRqkIaztP
-QCm9gsLOBvmM4oQxOVfEgah0TcTiYMHU/Gci4gbGKZxyv7FoB8llW+qkEScp6Po3A8QIEiRm50KP
-MNvPE86geieCsX0iNuBkWX45kYvEaFJbQHI0c5kF4+++GeZJEDepdFDpFdSYl+A8RoAwmDgPNjCU
-grwe+P6Ma1EzHd8WdXZ6DeHjz3d4URsiEJicRHwK9vL7YibUAEAeIuYadVSWIkpXOxrWmC1AsQQd
-jxgjapn1qPkZnUHkIAHjtDNkzThUjgO1wwNlhFlWA7YTnnkfxFSfxJfsgvE8xAWr2+9Qyd66YLVU
-2zoA8Cg6E/crIacMw2RHhtBonK6Y5vLJu1EBARQVhMWb6zXM+G5+eDQE1SMEoXOoOGKO1HfG72G0
-yKCM14hyhgwFLXV7+sA4DRqNPsVGT5lXMimwm5LkxWJxqOSuzMgjsLdzPHDWbVfbPxGTigpBZAr0
-W7sdcQnl5I913DzOzhCisxPK8gM6gGJNzksVKzSKYl5drAGu2CLs7ABaTESMjMMkQeZMVBmbpUcg
-YmTVov0inlbLqtEtO1Ty3AjBtBeiBqMq+lhH7JMSwcA5Tgo4HV5MdiwYWWCDRr52N58/D38phChE
-bKjtS5YgK7GLpLAggjgJ87Lf66PmJiZIFYe4EMUH1tl3iwDnZHeB/LwObQ0ekQW+pFdMbUQkHHYN
-OHCSoX5TjKTfO0jzXF5M18BngxnJlh9Gy62S7Ioe6FQKW2RWb5lonW3qBl8WVR8JFtfhxJEvRPYh
-S0QR4hNZ9Fc4Gc6Bj9CILPJG0z06B+FEBC/ViuNJGSUhIsRbtQFnnM4h9oN7lfwepxCc6CAWcIQS
-bAQuIYAKOU4cA45jkH2cHSAh2ln0EYfJArHOiSeA1cpqsIwGUkDpB05XFlB+iC+V3yOXrpsk5iSL
-1jrQxFQim7bM+H4awdX19xOSkSuD4Pcs1Ei0WPJQwScuXFZ7FuEAhaRxUtUSlIgcncWgiQ+fDAYZ
-gHeIUqB4Dg9imOnrVbDANDCtFTNvjHcPewvTVX3WsNawNkAQcohllh8DerRDGSHzSlyCrNRckOVK
-yVR7naYcTSHhSDGFdsnmbaAk1gijTQh2v4uNIEthVNlYoHoUwYGWti5bWm9G7Fbw9vNujNcpJB39
-XNtVBVJbhuQlDxs/Tx0xuwzpc6jkbECG/N7ftlDRNZEoQMIPMTRGFxMsZ8VyMGamH8HAeKcLw0ZE
-IfJjqehjyAkej6qhENoZcgKxqdfbIwE42XmDd4GMnypfLdeQ2uYGxsf41UKEMEshu2rc72Lak5Np
-CFKNEcB0Bh5YfR1JgUwslqrscLRMjGH7bUWQ+5DVAMLBt1sx0TR1rgkukk62T8NyjUBaa4rCQm17
-vnUJlsRmt+aIUr5XtusVkcI7MylK7zBtcyaN7IKBnpDFOyDyFNlJbYWINBSOKkk7c1gw7jN4rgZ4
-qgZF5JaQiMPVGoXIcpCcDiTQFZExZQ08DLPkS1DUsG7hKS1bSFg3yy6jdiCWFAEITcFk5ZmZ+AO3
-P55ED5vnTX5tODocDZ4t/Y/eGI4mKpq10oJEW2okqi1rsMwO4uvWll3QN5eVHHLY7dqX/ENGUNVT
-lADjVyz0l7HyhXgLxA/edQaj1g1wK7Zfy7fGcKOLZqCTb8D2ixWvcsnIVETKCl0USxDegfZ7ygl5
-fW5hC8hqpKoyurSWc8zBHJb6gZ/7DIg6yy929hy1eSwI2qkpkQUgjJ+fVPlUQhwMjdag75Bb6gV6
-hZtW5PGSkdMpMc8Ee8175t8D57hRSUGvaHasLz6VjD0dF1X/BuSuTFfh/2AWb16kfSYCrrqptC8t
-40y85gCGKClnbUZpdE21KktCHA1XN6dKtIO11nytqjXY9Cy7iuDMbs5djcBmWddOLVuTlKoNEZk+
-YSKoyxoRrReWW8OZDhLxOb3bVa9SE2el3EWv/LRJ4qi5dhXssE1UuyDp2ELU+GSCf1XptN3EPcE2
-NkPyZt9w1RGkBeqoI7yVDYdwzbJzQPrVJCDCH/IR5wD4E9kuTRPTExiX051pglF8qGRWypTN2fYW
-UfxlaOppI95H7g4halgMsVmLu+UIPLDvpqicy9DKsjh14uqkjkvW5pJXsZXK6uIVJqzLoseLRWgd
-a0CUMJ9Qe0ASjiKzVXNG69taLdpsWQUKHs6G7qTMg5Lg0nxAWgP/cJpowaubtFdjq8mSvFbQEuTL
-S1tARGXRrplowK3kQfa4NvNKZzFYC1nDSWlzHDL5omYe0LxS0paL3zmtcdUT4QoPbgamO6e7B0Ds
-z6xsRaTjy488yxaN05XJqaIYZJjIQRm4Dl5PM4Hd2IXEfSoWaBDE5yydOjfvI+vMcYX+F+RiYQmZ
-GZgytZSUyThcUm/pKwqYA1aHAOA8c8W9hBJy2wCEBy+iqyzAmu7OBW64g4oXKGYDT0XyAMmrOMYM
-Z8o/pzxq2xb1uzBRw92LeXwpJVwlMYrdQsIDcq5lBVX/opxyFS8Kh/UJjSOq5VzMUHXOmkEMvV6v
-2iSAUEfVkGeelfsWwz7jn+NYAFydy34Ck5ZvnhDn+L2J/lWDRmWtNfWFOrBJATy/NhPY9LBJB010
-IhmByldVAdv08THw2KoZrmWa75hsd179C/yxamxWw5hqEwukcJ0JX9vEFzEZ/aGSm8Ko03QiumgF
-nCRoFBotYmlIOE2QOxlUBbC44FC1CdqzsE7V14lo8pVPOJuMN2D5Ts1jc7pxf6fQUERseJbMC9tQ
-n1Y+VhUwuMs50baYAeug3OlMBadDX2G3qa3iIHOgCRM1opmmar+fsjOdw5hBDhg/GGQ36DHaroYU
-4zoP9220X8D68qXSV0KvVxF7/g3ZolJMVdOdTRanQaVyYwXcsIcgVPNyl7tE1lfFBpRu9Q0fRFZy
-55uIbmOCjGjwzBT7U6ApqCWkclyZ9jqNDkQOplVoKj0RE9KeAe1ExJq05Yz3JnJL+npVBV5gIjIf
-pKCSEDtypCeSYZ2YB22CSSdBRJfRatYcETPe+jwvY5ZAPzlIAJtIEjwRF0sAVTGOHXAQpupxSXvg
-SfCDhXwu1iXkfCiPGE27KddqzqnkdDe10rBnqc6ysvQOFxwRIYp1eFEpG6MbTMEsPkDkqa9lSCZU
-W3QmVQpSM2d+FOjcALehErTesicnj/ACrqdj0IF5QeiSXWhiNqCSpMrR2gIdWTVSQ5gXIEXIaw58
-iQb+f0cOlZLVhloNaq4q6GhcpW8i1pnuBcmiTi2qCnqcTqGbFKNBPDwsvFXLE0JOsVzB7AsSq8pU
-HzS6SSpjK+viggbooKrI00w2qqtWYmtAXk3I/xMnqmrkmHQABPQoliKRZrsm60RxhgqxQbih87VI
-1H4e21tIBCCzYUpbF1yIYNzHllxxC6Nl0+FzuJHVAq+4A8izUBD54mBteWlwzSpEcrjymGgfW9hP
-Uq2iChazXt6AozQ2/9blVVkGgWqcjAkZIxr+ES2lHrwimEYg40BLdQq7aMHEV028Umw3GVpEMlbQ
-ATDwPk5o95DHYoy4kGzxk88XPfdOMPiZOBGc6DRHSB5Z4ZeqggGLmKjSO5e67/o2mQ==
-	]]>
-	<![CDATA[
-	W5na5gSUkayglFSFt0LDVjcBVwtXTleWl5BqJBdoRpyCIUQIGOPiQMihWnsOCojp00TuUEahzRbF
-NtV9FG5NRajJ1yinI4OFUkncBANG16Sl0iScN7ICorh0pZgGUyTrWDooErY/BT1JOsxigpTNUZhm
-rm2MSgdVQ0mpNnnC5syI4BLFaSZLTrZ+JDOymiMnH5mWceEqXUHMSzTG2JbIaPpchYI5NNiiA+OE
-eeEqSVMkSWk07Ba7ZCUtt7QALma9kMjQKEnCI6XXDsZYNNRdyMvSBGwPZOuxiDCi1AU6jcimewP6
-jHCRKkwCyPkvWfJBppyDDqA0VXm1DnUrQw2wvKnqXLIJpk1LhcpZ0F1os7xXKQJ3EE1gRqcJ661v
-aVEd9vbSFjnacsg1kYlOUsSjBSQiqr2dwGU4aNE6iNEeOBssX265ZFjaO9ByhMwAcvrqdUDzwNpS
-LW+Y4XMwBVah0MEQNMCrTAgtdTEJhqb9TjeA3mkl6ltWp0+UOpiSnXcGPdPsObZTVwQUSg6CAZQS
-iE+BvCgye6kmnje49u+Es1FyN/IEMsLT0g3Qi4jmDAoRYnSp9rhMBaFowqAIcMHghrgD8frYY4wd
-SyvY1Zhsq4DlAJhOKZa94RY4/FLsfZ5QGXSSTTAEwMkutJGdrgppkU2xuDawjKyIf7tAYyBPnQy4
-0VQePqEwHrvX9OA34IgkeiZweZNC1TpkBZcb3kqNcS/qA5W1sehsIpssDhg3IuZ8eyN2oNbAQRFp
-4gyDvERDn7EAAWbWBW5MdgGhgxmh4Io9A85AgpD+S8QSzFtZJw8PHlESxlMojA3RG7DZUP34DGVg
-qmRELuYuBA/3ZjPqZtIsfimEyLhr0oG3kjldkkS0bYvQ05Jl9sO80cRLihHMh7uJ15tGFaPZX+e0
-PNxcucNCRTn5Ul6AZ2ssPJrNQqsDg8yOezm5WJu0oJPAfFqS4dp1yQu2VzNAoXGKtlO07MRNnhAF
-eVQmAXWEH2OwmmI1y0oQ2GV5uLsdJd+AHQdEBlqGDh/BcpiHiJ+xttFaRhCBjRbMLbnK97QJFThj
-mlpCC5uAPZDVQU5DSm598+3rZqNC4Y/iLUqjiVtOj4ZBZbDJBceI46SmKABwQXa867g4WoeI2ezS
-uPdvhLlzHnJDQnp6Xx4W1A+kEtgNHfC+cge5L6hz/HxL0jjtKKQcDms51NaMwTHFCSHCi1gNizYz
-5r0ulyXzd5MgNYMdizD9gIx7KcRk9gnoxUVDBaN5b7AKqDQ1ESdyX7Yc4ExZCzWI2GBcIrdF9HHd
-8uybxKJGc32AnOcDq3aHrBdZboP6B+lzCt+3mvVoaBFmHoZHurmMDUGyTEz4lBakEnLODSZALc5C
-q6sWkgDpjSOFAM5k9SFzN6GsSZgZ9qF4GKVawxn3JiQAcYnOuFlzZplN2rIO9MCqGhkfRvDP5jTN
-vy2SA4f3YBvGZOEvU7E0N/NDkuITlOamoDfPF7m1YLZuKlUyfoO5MzQ5kVKqA3TtWTYmsyIL4a0A
-eDYXMyJWgwjM2TzKVQxgTxXFAi44SxcgMhvB5ZpWPaCZpGxoEipTAQZDNQnb8GRvixoXDpXcEg4d
-LknWIidKFFZLoy2Gv5LgoeRJeLM+CbenMVTz+Gl0BY3W/CcWL81LY752GBwJb0EDHtqcbiFXpfKE
-2lH5hbA0Mvgl3uLRNqtENa1PuS57FsyWkpUTTcYmxGpIn2UibzRTOmZ0CpGjLY2afWlYBXqPVxMe
-QXeYaD7DIAhNpIKJAzKJphvBfmB4pnkFeCdjXRax2UuU1ClB07U4CvUh0QHXxWqoeqZXxO4YNMLc
-xPks0l+d6+IQARfjsgS14j5yzr8ONkJS1Hw3XoJqwJoIVBaIDjzaqB5AGAfm/oYYnrPgaNyeQl59
-+BE4YDmb8tZmlgbfJ2dsEU9OtqiJGeJBl8EhKMiytnMyKYlTh61XRgdSDqynLpkzsYnpUIhc9UyZ
-PeyYOZkhFFUwcpS6DHIMND6U2kUIA3zB8HOK39VDGxV3JFkUXpuvazKbS5vR3jwsB+bBVipwCfhY
-1QQo5CiwbnJxrJpkJrEOznqEfnIXsNBqqDG1DBmv/BR1clyYHYdeSr/BildON1/2Aq8hKwGiEy+F
-jNc8vdlZIMIMAshuDW9wDfDDt6GGtWnFpndFDcl+KWgJuTR7QceR3xd7nrzUdpC2qtBlb+a6WQqJ
-PmWMgsEr0YG3kBw4H8e6LE5CVTBysPWuC94C7U3rEPcgeQTzSHZLXs9UIMiZTSza75vJGCakJFHS
-5IRr6CQRLeRs1tbJWjZIGEXIb/5+MKjlvnjLMyWLoK29pEHSg5iYFFqEiOZRzJPRTF9Dn/vtJYtA
-2nbXlJgzosAXNCMvIbQ6MBTAzN4iIpt5G+h0ZsTSAYk2O3M+Eq9sy+mysrxNfe7ZWQ01hwo+hI1t
-wZDTkZS6FQOhWHlcUiL36c6qxchgADOiMnVjgN1Kng1iuL2Iqa9CHT2J6LQbA21pUrMWKSehzHpt
-qrk1iZLR71vEFitJ+BpiAZpJgKlLJUVh7EHBdrogI0TTPaWDZv7iJnE6h0rGo9UkSQnk7PGW4eFN
-TewqysUbiGxllH4t9po6CFDuFxDbahZPYPnR2hpzn+pIamZNUZu7EKcZEsGOqVmciMZGSAd1ceTA
-YZvq6t1Wp9ObYfVmnB3MdQSrZ3a5oh52WgOLIeVkeUxhgs0C+4lGa+jgXtJjmOiBvB9im3vmbQ1Q
-L4IW0U4tDFK06dFCyk0gSE08WyunofU2c59mTssxgJFq1l1JivQqvwe2UZN0EWU/ujN1cTkXq95O
-5Gbwr95uXjXEACeSpZENXrosVOANeilkIfsAUBCH8u1vgrfOC+gw/FYpWbEuN+9TNmPMasFLyTKH
-nNkHUhLWK2xNNc0UzS2h/iN0MOPP42RLUeBj5epoKeyUzBhhqP+jIUKX2+JpJHJoJvHqfST0ScjR
-yK6glh5GFrMypSDWQKE2Q3fi46E3X3fXSU6afCnZAJyJzM3wzwfROTwZiMCMXZLC9H2GaTM2Cyjg
-KltoCxfuFJNis9jDtuAwRo1VFbKk2nIHCbE5kPZik0RRGYEZ6mNbxFV1Sca6QD8jvDUqUJ4uFoSB
-WCzYpIszXogTfNqpwTVSrD/kKZPHYrlhahRTdKzLDcPDFOtSb36Bt6+LVVGB8EkX80bq+LVVokhz
-8sE8/lA4Ivk77eNpLr8lS8ya57wrOO9qZKNOG/hTU/MWLXO0xJACsBomF7geNDw5chwKmJbieUet
-tKm5LagDRx1YDiKws2IVOA8Zle0pxIIa5tJpaS5iDOpOjhMx1Ik/RudUwTP7/Dnqb3ph2odKjhV+
-iIp3NlZLtnTiMj3U7U8KveVNyY/FAOPHcKOggccsGCmy/fP8Es+DiGnA31mSUPVWOHTQ1bOo10o6
-IOSBhGr2Xlu6qWA7o3k83bOcNZ10kyQRbhGzYdd2qZurLS29ilFj8flmwp0mOsTpkPLzTmQUfUZ+
-Mn7vdK0sy1A6hb8CCUMxW9oyRbvCjEdkBz8ZmHDMBiXsLPiViPaWcVaedJDExJRW/HoiKrSGBwwG
-EZN5giZwXkwSxqZJrHgjY7JKP95iSmMSL5kGjOl6R1ll9erh7Y1RVDXNddSTHK3yozOP7SDOpKmJ
-OxujHaNZMyzOR6sbNiimIEQL3YxJ7vpNVpIkAVhOh3phY7LglC4iCzqAMNwX93BMi1EFZeS5Xzzz
-Tn3Gu+WBsOlTMetzwafCCxmdNrLg4QpWMqhY/NQ0gcVVve+KnUm7aMFPigzAa+ihDTQzIBHZEsqQ
-kBWDQIfJJuCG3VEFSshL8pvqLoMI6A6qAmBlpJJB+M/4+hgM/NYJmoJ+zAo02BQIfKBZSjqMcFSF
-o+CWWxZN9BJErOKeVfyYucR28SiQDyx5RmRSDQ5LMIYOScSMfEsU3I7O8IbckkgTnYGKOcPvjn6p
-JgHTGnVQkOU9reLUQYUTVvFDiIj82GDou6Eb6JMXNEbugMiacunN2sb4/wYBoLHNd9V/EXJRmdlb
-9FSwamfOz+IZ3eBDtFd0EAoy6LtZB6m1SsLBIF9ptLo03pwIVE+iFQXVWE7dTt0dFAMAHGCwkPao
-CbNMHHcEG+kN7oWNrOi3Cm2cX6z3hKEOqrpwMQlg0EwYuuiWTrlSixAnZC2qKO4WM7Bp6YsdxbWL
-aQE+g2bgcGyBbo1z6O3AxfWKe4lgE7JXedUbmHm0UFnqoGFUpVa7oIATTpK4K8SuiIHRDFrE6BuQ
-pP2UuFQ9kAE0PQMxmjaVZA2FdWk9UoJfU1U3ZgPTyEv0Kj/5AYh7sHoQV++A00qKQhczKmQyUUmx
-A0AuWhAPkw2Vs8ILTpJQAuwVIspIvNDoj2x50rEY61vQRmMxYa6I20SIXjGXiiW4shzvgP9plgWS
-pBRQuRgyAU3LSnmEKUfECQdmnixexG4QiQlP4IQMXOQI9mdKB8VGkExdJ+zHcFs2yLNeYLJ05iSF
-Ge2pUaElG/JijAv4OqpLErHjU3HqPXEFJtVCa3SMDLzM1YQOUFsyi4yPKQSbQm0miAA4Ks9aIVFy
-JXS/3HzsJsq5ps3Sq9SwXEiEoqJMDsRFdfQSmHjryK5Yobayzl418pk0I3pA0RqYxsrhKCCplZU/
-ZMuI4O8AQK9YAn304mmRU4TSVgS7CJy0UpcxAVK0mxstdEn4lPsZyuRaE36MTwnIrhhanCIHUxkd
-Z9isRcxWoa3IeBamFrrVE5nIv2HiEGQB2VB+PIHtUp5suhh2JEzGQYU9WQWNxo/OkFnLgndKMzO8
-U6wudZBRFBpVh3ar9di7WnCbp3csOtNXqmTOqxSQULrMBZNZ3lAgjK30QlYPMhEdaqQjE5VOR8On
-otmt4gSVrFYUiiU/1FOHeSYGQ/6tK58iLFuMFmWpSEa0T9mt8R61wWYM41LVtCJhhd4fPbbVCmfE
-gKrPVArN/Cz0JSvSgsBdGqqGqDXA+8lAvRK9+eu5bdcqvqarhKXqeXSmAeH5aatkEi3Or5r5kvhG
-Qk26polTRKyoBsdhztaB7YzVGYwmO5fZazTJWRfWOtBXYaaKE09WcHAyXTdwb6wWx8MUY5MABtW8
-brysOFxNlFl9QfTALLpGEi+odJAXZQWHtgEh7o6P6cD0glFMalg60Ps8y9fTCBSYpE57XpIwT5nu
-tP1NcJkqkdJ43Wehu7Y++lkd8Q0AaWITSR6rYHo+gLj7Ej0Cmxy3RV53LEvdK7MUFnGaSQdTnS72
-jCh6Ciw41Q50U8cdWZasIBLckbEupa4n/yFrnS7krP1Gk1BJd4akLR1UeR1hA4MxvSKCLzYrPtxE
-8BAi0P764ucgskaCtim/qq9HpkXb8FdtO28fStGQbU4ZRQc2JVnxgFHTlwyM2Ewu7tPg1QwYv5sd
-OSqahHRgOeTUVgWPblGjZF5OKKxtTKGbN6FL0qF00C2gt2szADN2CRIVIiAcV89tcg==
-	]]>
-	<![CDATA[
-	VjBx5iYmwtUIVkZeKjV5CRSUbxsIS/KGlzkPy1JAoj+DazBY4cy+3NoUlnOleHxc9EOtXTOuNE1T
-QF/SOagAhRYImRbfFCR+WyarIksK4pKXqZrTM0iWiJwrzfbnpq3jaln9CbCNxlmv+H7vKN1Z4dEi
-SazrWYOZiEaqT21bUs3pW8ZnmeMeKtl3vJVTB01RnCnyWuY2HS9O4d2qWcZoFXLXK7esbbcSm4vj
-I9oprkAPJM8NBFJNLXzKLiWOoUpWzBM+qa6idrMgu1Qlf04YpbkLU8dF5kcUjjnc+QbDOztHdQU0
-YeCuAp9Pp19RBxXgwWsVRRgUZJCIAMIrC44CuVEb3oSAwSP2vFqVRXLoabmHKjZK+XmxeoXKKLVP
-W39ULSLfn5YVU1glTGAKfUjYT03cHtJrmu58E1jYHAp3elbwRC3UOp33VlnWr4ECPUE+UfU4dYMG
-a7OWkTO0rbZEPme3yCcsIh4qGZENs3AzhUbo89NmeDCBkCYdWO5pxsLUgqcKqLwcNoK7f6D/nbOe
-K4WE5NAQzYugOCmLLYk2AfKaiwUwR1FIZZyaeUzRTArl1xZ7OsVfqYGhrRGdeDubYVFQ3KUa9ark
-aUsHWZydMlpUr8oiAA6ONJHJqIJZxSXisCPpoJimcSMKrpr5a6aQc8AxBAAUnMhTAeJHbAYIdheN
-x1DL4sz8Vk1fLU6QvvhwJoJMOH4i5FkAFIG9ZUIYFzNb7FZC5O9TEoX1i7rJnETRM26CpsJ4g90r
-S8Q09avwptWKY3D8PZbbQp692ZfrElpcvGTh69HsyLiYVTjjzC5BoZgu6YjSQZBgf9mDbNmPwdB6
-m3hWQEbJhzbzVrz55zTlXojAO26LAYnyEOyKAjqCFkfDCar4KnRgFbx72sOpAwdGmWfZR6ewvNVM
-BJQHUXCdDLyWU28c9K0cLRHEq8BQJbFGiCmCUU10Ls7V9LiPzYpUpsVcBfmOJuFRLNtpyZ7dapTY
-iWlTsBxQv1STq6q4l1l6NYt1xbbSB1QtUhSqQWymo2tlxxLNTlJuJiWhSG6W5FabmNkDupptiVig
-cSXlv5SEqvXoiiSOPNcOZlFOOzTJiq8XRfTmHFTVWtf6J5QDas8QAvGKQlWk1RhAWZkd29jdmq9q
-W26lQpMU3pT3OgjzKZOtrvhPtGC64JNdc6/JVDPLPqp2y6ZAT2Srj841BJBK542xWkrhrBjZzZZZ
-iq1BW8AZKYvU5BM2tSChD+7qZnHPlD9pvGbJX5zvaJlnnHzjURcHeivlL0ZoGtBwKbXUYWnYi3is
-HaRaIU0p+AJlUKqev2TikiEBHVg1Ccr29qYqZEvOJ7KWLu7mbaV0cYdKpwhPKd1qg60rVp15p5sU
-YRMihLIpr1dnJZnWQEuGoAALhMJQJ3p2t8Rh+pQawJs4zTEClDZpEvrwVPE2oMZEYMcEUfnlU4Yt
-RTgeGqLRrFApVwEOOHgqxt9VBVjJDeqJm+ggsKF0ifsXYrF61VPpqpy0lm7Vto5L6WaE0RExQBdf
-xlrNsFInqk805Pz5lhGYgsdYYeglLIYAgYyDAdABsiqbpdaPj6EYULME26phvHofDXMkGuxyk/Rs
-JVYYE/VocK02ZShtHg0u6wZxRGWqmqSY9I23iZFnTAswRlWnUFYtda8mq5bSLJ5ptPQp6EjZRYgR
-lGo2JIAYJTMyNCsNRlgfU1JbAThulR03qIwQjSdVTGI5HMnQPqpZvPqENkqmdJE9YYHgqPOSqj2x
-UnKEg55ZJzRRh7xeDACP2vrScEB1d7OpYt1AiqUlrBQ5zA6qlDAksHstilqzJL1JB+p0r/RYB/0U
-G1qkg2Kq9gQWravFC9XvarGqt30J9yHYKOMdSGipxdD0J7BQkTPJtG7mdmpaYKqJakajTiN+75zC
-7xQrmd0Wx1GdcTxTPyCIqoqHgYUUPZ+mI89sTcKt0oICVRCgDbcqZNNnsDW5Qs/nqk9KNKfetGcS
-dJZKgGUOoZixnPO2sC5mVK8GIVcXiRlpDbUs1l8Nbho0OFLaEmszfj8dA6gMWouFsy9nsz4DK5mY
-WesLyrLMoZJZZ5ZvAU2H3mO9nkAUagICKcRmiDFNHJnKIu3zVQrvUR2IbtBtWiySqiKZIEIoZ91r
-W0TuElEe1UFkV9QOcXZA6AqoHjWRN+hzHq4/wEzXvgivYGc3S/Uaxqc3r2oyU0+bZS3SMxTqdaaB
-pBXTrpvaTawK7KWjyHdBDU1ntRiSBcE3J7G4Ik/XBQIxzbpmE2/RBRRDApo1YRBaMaQbuxWt6E4J
-BnMHbTzZreimx0ZJ4cEAUOEmzXea5JqkoQXIYiRAPa0xPGFPaU1UoYgTY9stY0J8C+2JetakcDH2
-BDJ+XLDFCMlYy5BGixKiJUwoGwTAMSJq2aUo+cDPtQMOe5QO9JEibGB9pLQuphIbdpXDoe2wNFT5
-nsAUuzWcQUYpO6usJgDFVhkzGPFWlVsp0MvVfzqqInIM1DnI2coEi6+WibPKq7NKQTCRJ/GuHj+x
-tnpEK2r6FDtKVi1s5/s0MCe1eUmedKjiw/bCc5VTUbo6WKmBGqxwGkl24tkgQDEr/TK98SySopRz
-BZiXM4U2mXGDOnAoRVVQtoTFMau4Wy0Rj8HSUKTM+HKwUkrJ6tHXtY7zIv96QQhJa0nS6kxODAY9
-QUR1vYdZD4VRr0rUthEXW9PwpK0GItF01dYbJHTg+d1LrmXBSZGwmvI8y3PVWmBbzpPBOjN5J4BQ
-lhmpliYsEWkXVuAQCQTVWbRGshqsdUZTJUHAfW7DCrZrHW05W1/Z20TpujkBOmlaBbp0Cx4iJmsn
-jVQqFHU0+YGUH/QO7ZhBxBDcwKgMz+/u93A53m0p/MzJU+cgKw3STbPaktEKfjDiawa3nHKypi+m
-pQykYLNW1EObCKK5GWue2IDN/PvRjDVAktVhVTzEt8avVb9rtXqiyhPOITgkMLcJUUGtVXdOZoIg
-acIKfANhgl5olXuSeC/t4XbZdqmiba6oU500TXR3YBhxMpZSpOdzJcM8rJhpcvmbxQ0ZfGO06mxJ
-8B3AKJotEVDVCDHTJgx8A0byC/Z41ql4BY3wSfOhTaZM8a1BBwiBpNjiPNUTIBUlif3R6dq1g3mY
-NSwr1JyW36u4lkSCFWKchdAnGiJ8KnlFTlRgudszwCNVpk6fzeacRWUy1VHvUDGjMXXgklrpANq1
-u4vLFY/VKvUlcQafg2y1z2HCi+pTS0sxWM5qSYhbtPWhxIyGkr6WXBabOZ1m+fglrSTN9J2+BFm2
-vjiOZ9VVlLuIsy5jEkO3EGHmjmvQHQUgGc9AOGQ3FTbNBIZutdOTWOXg+3YWUguYB5qCR9wgnEi7
-K7u84SmZGV9NEOdKxs2KwhiVqBUWOS/7v7mlwg/I7VbIRc6MhLBbkThbrZTl+kSQW9EjhNPSS2eB
-wDyzycpSXXkWFkplMTR7K+aBYqbsTULyIHxERVbHMg0TzqplyRWTFQo0gEHTVqjbxqmHyrmn7Z2W
-RIPRC2fLCw0miyyZDvg9WFUy+J5B9FYnF9GfKQtYh7TVVzclS27JEuvw/AnICPwDInbKVnYtGRhC
-yrb9lPuCdz/lpTo0IvHIpz2vggovKS8PfOxLmiRyXqJlZVA6Y4CUC4zCFC0mKUl+G7zqSITJDG8K
-Z73X0nNZjIZCDN2bBidvUSKfBkSDGSxLyY9uXucIx35p3cqJ6yZGcebLJphuTuECpoUhSpLbwqUQ
-ZtSGeh7Lkm1CoRBqiskmnVDEQkVUq10XioSAU6Sj6iSRp8lifssVVLrXJD9qNw9wW6JWuiaZFcsn
-S34pHw8RlltiAbyVuKF+7bqinAwRLeIa6S40qgDWy/YjdMC5j3NnDpUcTf1AXsggJuMjSOlcViAt
-1UmogxxNgpVHL3nL6EqG3kbTrWBZDPJ6rB04h+OJCme0ChF1ZYFxkZxlU8UFZpFGoNcuinAuRBR8
-jgb6ktZisxOZjsj2KATL/kpKgWBHZ0jftGhZPIlL0SojT/O4hCX3gA0Ecl5R9y2Kt0qvhrcxWSEx
-ul0JL0Gw2OhBZiRWfSDEYE2hMLoFM1Fj94VRoa7M8M8gtcDOlYxAzWgQ+0UBKeTQVAMvi+qJ0x0X
-oX7qXmmxHhBuVjJeCYywttg/oJ/kmfaZxGcGn38yLyeAHnMTZHJhKMp8Moc+IZB5Qm00K2WcJTHf
-0M9i18wEuHAIbMgYsyFvVZM6spwl9AtttSy+uNzMml0mNEgzrlImENSM5CuLaJjbEjoQNRqOkNLs
-/muyPcGfddjgWF59risOQXqmQdCKGxFORoqyaN1CHyykhUM5tC0ijLkDOMedVg/jNURs0qwFSW31
-KFSLRqRpWYgyQqGppar29ebSzvALK/fK5IgQYZSmI2y6ac3Ntt7FHK2zxoecJTgD1XZP29sRzoBI
-JiKaP9MqszJZI9VXKy+DfyGo0IDCqhnPq9leCCLLIhemRsRkBzM14oO0aFZa47n4UxbqbkX3cjVX
-vNnec7XsoWoKMkFkWSTSDAXOdfkWSn0xdBd8pz4kdJC1ZHwVa8zxk5urOKHg6XxUjMqAZ5olQpRF
-NKeBmYtsVj8BpFdagwlyNZ5QJiYiAzMjSSX6OTNEoGSLraX1Dni6Vc4knDCH6KBlZYrFdmZz8uVi
-4bLTwEMYcvpqZLFuI5oKteDJqW/IW1zeTj6G25DMLJuXSMMczWqYJQQGAFelwM4JLE+K/dKctWxP
-N5CRVKZApgvFlE2ZIqFMIpEL5sb8A2SInHmFzvLZNLqq0GjBMuyoDCJM/gDkSsj20TkYb0YyHY8r
-6TJwKSL8Pphd12DY4hKdaHwtSO6UbDnM23kmGGRLGshRoHrk9wq1nWd4UZFYGHSQIlJaIthPsLDA
-PNlasCcyMy6bXBEvCI7yQjqNywvmM0nz4gWLy0sL8JfCbsmrSXcFkE9BRc6IcjEUrGgCt8Ubzmzd
-tJ5PZ9w6GRSzwIHBUo0Hi0ymENUqhdWhgyn0O8VAonhLh0MQneTKJgUEFqnMUpZTtyzDJDKvEjOI
-mvadFGVTaAkLk7qlNySLASRwqAIZNKu3mtF4INfivUvN/KzJuHdSf5sQnUd877SABCuMmRSDQxZg
-fqrM3dIo+aSovyLtTZyjGUwbxUsFCKhmbhpIDTTZghRgJPXmGY8SJXcSO8OYRCLHBkPFJVQMWLnh
-wiZAMTX5RKs2nb3l1ATRYHASkVAYTGsgSDO9SkGCJJSoOk5YyqXlIIUGZBJmKshTmg5SUwCsh3Fx
-5XOoG85k9StpUL7xRfXqUJC5vkTJrnQ0FZYwCSuWZ9ZPYnI371xFB/DEJnPk5pnCk6h4tP1+akpQ
-uAmqMUK3R+E9gkOdLSejSZb6MA3s9yAG/6Df/7e2ReFmmqEH2qRTwTAKsK4QEdYXF/gTnm1fZXmA
-NSaNsIxWIpPaqhU9iIKHEfi67K5NotohhXzObjM5TMkBhLLrPQtL5h2RLUk89op5wQ==
-	]]>
-	<![CDATA[
-	axkkA1KIQblaEKkS7z7C58IqPeFoeApvgt6RVKQKS3gTSUQeziiUoMrdnuIgOFLSge8Y6wT3bILe
-yN9KJkTXbDcBfL0LfozOyjBxu2UIBDMm5m4RYsHUdVbHmq6AjxONGlfGG4yy08iFOMtlcOlXsIic
-J9483rUgeUwIKPYGdZAt8hdppcGAG3fVVOivySw8mtl3ruSp26O2DsVbqkkvzpoueVHD+TjIgLPF
-+UVDb+R6JnBdr0TVTgjKxX7eKlTaZkIa1T7ocHMDw7zkNc4BWPxZNOwk7sE2+0XoW1oLJSBhLVlh
-RGqp19h0wVIkemuVDcoMK4pWbpmqSpgTaRYcKrP8exRoQWkLv1k2e0PJlnS9+AGosEVAjnUM+NQU
-75BdQDVA2pSYrGgAyeR48MGISrHXJ83o72oRfmmBaqe4VJNFAfBIcanKm9Isj9KWDpIlyhSO2VQW
-z+YnIaaEFHU/q4D0iLlyyrR1ECDi2mqR+tlg+8S5arbVWUz96GCRkXHrmuVoZoPaIWKHs77f8fsk
-2dVChKXYQm1Kk+rUslZmDijdwlqXw9al2NoN8ah0e6fVUY8OgkosyXClC2P52KiKEWGTNtCU0s0m
-nWiAiHnuxkmSyUGli2Aua4Wz3RfNhW10x9qBJrQsPjwqOmVKFeKSqL6VMqi8WNsp4thMtcz5MLBp
-v0GOB7nHK7L/LY2hS7VMbsmIx7ZeCTrNUmUHCCOzluxyZssSrlsoLQMfW2pqKDan3rGCg4DY4Gmu
-KpqcIsR5Eoq56ibUALMIi9pDr9le3xXwoRQr8DLN+GUGwRYI+sS4FXAirxV10g23onwqLs43lzvC
-8r0za7dBuFJmQoW8Zqk6aYkXQpHakiyCI8lDiw7GuQaTIP85UiaQgZzkxQE5W9ySVftIZjqIM99o
-51FbfLS1LLVAOM/jHGQD/7bAdCJalRaUmCsLQOx8WrjtrL1p8ZZLNZSFaPCsTHx+98AojuP/+wu8
-nIQB0RFiwz87V3LTixdWHCYueChEBaonGAu1NYVF3yJyMu3BA9yCHWki7eSJYnFzACpEUA+m7HCN
-G4wsWwiU1ywGHkRUOaqrLZ8QOjqEu4mWxlNzKoVMzPDdzx3aOLxDahAnfMg4mgkT2eLSCf/DzmmZ
-oCCTt3Gk53PtAHlmxYxWoZlzlQwgAbPjsFxuOavsBZJpi1ruoNJSrxnQKAAEDtWSMcriKA/Vgv7Y
-B9v1YxMiKBYj3lqDuUnJUr84iw+bBEigyvwCS4xshCo2BJCnEZZlhcO7u9YNiWq0nTCriIdI1ar6
-Ko+gIAcHUP8ULR4CFTibvGsWEBGs/pyGqFOIwISk1iCQ3REgKNGJ+UbG4DQaq/tZfEghaA+ZHCSw
-S5GtmS0PVXWpjBIEMfeOfnX9U7EcFSdxPudKdhXkUBwc7TWibBViTzkduxtsd10yryvqHSFtN00c
-CCdB3U8l99g6mEXzdgd2aCPmQD/Fls7eRpwiyrUCU48hpztKDHcLlnBaQZHyeszFWCSnY0Jv6igM
-etfiBYpV6NT0qOd3DwwjpvzIDnM8BRyeKxmySWPdz/zwlvofzAC424d2Tuaf5SxWdK4OomjVOywV
-OqCaD8tOh3d3gqF3q7Xd+B7+UOdvJt/sYy5L0rBTvalYFiRxC4AvkAe6wYIEy2Pc7WOeEvAENu9W
-OyXTSs7yoIWFdIBMdWxyMeSt6ixM5laveo3IGGyVN4LFiOZgNU+boKnCBFaalUaZxn4KXAX4K1tv
-Du/uG3NslpBSBVz7HJbKgBQ1pJGnbiFcs04OwZl75Gwt6BV3dtAs2WdW8twdAdYjSn6CiFYUHHYO
-sum0VupmxUMDAB4RLUqcA/3hH0BCWzJkEOq1Qq8tycFpcGsEbx2aN31xGRrXuxBZEnWudqz55vpw
-ZkxO8HL4CmXNHFtvHBm5R2YcdtYLkSf2LueizQIw3VDklF1xVRiIxIh2JSuZqXHVcB9zsr2jbhOM
-d0i7mfGVjCAAcLts2Zyo83Rjwsng0hi46IftlxW6IZQw/pLp59FqfiBiMi3oGjRXC1C3+iJZRC/V
-OK1G1K11nWESqEFTxAFyrmatrJUOigUSEwJAQLE9U0G8RNVGqRhrdRid4a0vZXO9FR8oVgeNbG0q
-XpQlloogBFpVstXS9QIlwUSEZu5OAXPb6flcyUAYL8hBK7OGzVIA2Vlpw7KgIFFbBWIv5u1lfAZU
-p2Zn3humhguIOC9KMKqTNWQkHoZ5zOMCsMOV6A/v7OPQdrRr1ZqyXG5KmPeov40AvRIEVUKIKpmR
-SVLrYxXBv3yuHfA+Rikc7QBGwOyTibnj97cGcGz70QxUlY2A2A8z3SkGO628OZUMgGJmBsQlZI3a
-VouhUjGL9xjwqwE/v/X1aWldhN6ARxhKtJBhj0qSbSnvU7d61MHKi86qf2WtOgWUHqrRGlFvGCV9
-dkeAoRHaBEBc+QXG7QQ7iaL9HioZ5yeKU/zw7k4ObT9gOe8CdYL9QLzfhJ4inI4EqBOrAuvMIl9F
-mX1u40jQXELCBUEA3ay1QAwhAj8ghOWGwUrbBI5VP5YQk6IVRnZnMBfuVsdYONfRsZUqpnwwdAzn
-PCOYIBXbW5URapuR/hjAFZH41wwq+K6JvVTTEAJQOGJWx1Usji5L2W0lWpiErcIbDchIaspmFiCi
-5TQm3IzbA8DA4jJhVh7ANmBVVaHpUFtP5hMBLJKk5KTKUnY5uFy8bNu01k4c4Fn2p0QD7G2ipOun
-GjC/ioW67o535iqhVkkR4xuyeWAFKkt9GGrdizIrVkNBjlo4q0j8nBCBPV8trn/3c89tHPMJ5Sbn
-P/zBrGXFypr8hQrrxeJLd/vFDmbL3s8SrnKuZAQAZolHFSLkxWzV3cgaaSrArLJJbhwL7e6KJLrr
-xrlzBFiLIBnavHIce4ZcPsYqiVL20SMnKMjghGx+8N1OsONkrUw7Lx4nr3jdw6l5UPJIxfPEvh5L
-2dfynkXsdod3942PalFqUbvoYmBKcJV3i5Op3sKHmsEdV62llww15DnWxBBKm2lA9LkKMEI425dc
-yImRSCPwdokMB253vDqRpkn3IqlVPTWtC2YxU2GHb32ptgxQASJa+eJqJamaInPIQ6dhEq2LYzxK
-/SuRTVsXEAZVjvEItGaVJ6t4tg+V7CMOB1xl3EVDzR5NbWldzIdSEMFwCVqzwqZklpGb1tpSgQvl
-YVqTTEYlWp6vJqvLeJHn2yQpSmZWRYNrTdx6ugaIgiTyrE8rVU9aFUeV7ILiCLcqbh4hmpGtVUlw
-kb0p2hKVbGYN6UZ/63Ckvc/282DSsrXkm7+KxETTdSpsfcaPvcm5MCcRMQTIlioxDKLTorBlgX1r
-1UqVlQUzrVWz8pdnipNItIK7B4APGr0rqxhqa6IVRIo5nlqVRCEmQmFpzQ5meWbOqDYr+RBvjzja
-/LRz06Bx4a0vHCGbLtm6FdHVNTjE7VL1qMiuGbna+1LswEI2LOv1wnJPVIFuFaKKRfn09QUB4HJ3
-ErYnn7fHs3sxtwuZYroOQW4Z6pWKvN1bZTYF71CiHa1ZOaIHiYYTchMhj4hairhYRm+fZTSLeOel
-Ay0VOnUPGVgVBBo5yTq1aux9HnmqVWpcx1vhG35HwOMQ9S/1pe0aJRC55pPK5wjkok9EY1xqWqXb
-u1Ru1l75pqLwckX+CJGbWR0VRYg6sLJoqBzR56VvC+qB6FcofKO5RbT9Vvq5qg+2a/yucEjLtiZy
-QWVa5FT0LIYTUV3U1dGzsa225I/0LIEZ0rbCWtvTUg05aDppp8RHlANEAm5PSxW4Ce7TNbIqSg0z
-BOJ2KmmKclFFJcQel6LBRUHJexSsLhmvBQYR2Qqusf/tEGc0gtUjwm0Qs9kdUQete8m8lpnZTadb
-kq2aMApbDGqKKGbmVb8eRA5Xlxlrfk/3y7OSDW6YyFay0rbCies8rvXdaFzVCveFODkQCgSTypK9
-sZpkNXtx9olbabEhre59lySg0tvuO3gOlplh2VVDV6uiyKh+XEGsVq5oYiZyW5TkQ8QId+rXb73h
-IX6p7ALlCotgdpz/EBdhTQ5PnyJ782Uo6EKLX+32i6XIJDKg4ryDfbKV5aVCwF/LVktamYoQS2lm
-cQF7aMXK3BKPhCTcihWKKub7bkVStYXxKaMnopWBDma02R0vpD4FAZWHhUKMMRFI5MUiyVqxQ1gs
-huVNz/ubJ9ITnjbNuG2zImGxOMfdgT23ETP/Yk2UQ4Ew4q7I7Arma/KEoZsFg2ne7WRKwRO8khNh
-IAYDoqIIoJoKi4h7UVyrphi8+vMwhWCg1xXDvm8TmLxYYYLd78/LVw3fmzmpDUwt8H1hxkQugBfk
-V+Dw7k5k2p1qLgWrNUnBP+cgt24hE6z+EpFTaoQoob1EbCa8N1Qj4LbRG5ltF9yrWdQ0s+GOEcy7
-7Tp8PhOVg6t6otp4VaAiUkeUa1QLB+mMnSu3pELOY4dw1Pc9Wi1lrrvblPUxSwUZ9bOrWIFArloB
-u5qXuzcrQUepQ2IhY4MgzODdrOPkJzY/KaCC+iyhW03cJTezQzF4A/Hq7DyGLmxVVojMGN7Ch5rq
-tty6ObAnSaDtXCCtmPzkI4gJ41WDGpGjqK26anrJOgLtoujvbHXqjL9UdWianN1dWr2ryMPuHMOK
-cvBZbGedwWs8SrUKBisRUSy2icFCOghiKI+LLsYdBI/QAolkIeJa4biVeVAbKrdT5OihdusLqj9X
-xOJx4+IrjoOrumTJDoNCd3YulgcZzMrzdueWLR63Eh3kjlgmzZeRa4GYCYTcE5XjaGVmEo5IRDY5
-MFGDV++8VjpYD7crXHxcKhge/p7wLN66fTM8w5tWXaoySiZnaNUF2FVMrgjJUo2CiVZkWMsf3tGv
-flCAAlH2G16czmCcAcJ3DvY91yCjehQx+YHRsap+86AojKKsvOSbda7rALkmhayruTM0sNUm4dB6
-MTrG3KQAxMqmmDgDYSQ+k4izCLHFO/GkLbBFq05xBw7MWkEsO8Ncotq6mea7eJCspmYJ+JgOqyHf
-lIhw92jh9ud3zwxTpnx9GDV61HzrzrG8mAiQFjpDPEToDBG3bqeL2ffNTtA1Lt6610S2EAwtOMbE
-YNFDAojSOTgLm2p6zl1DllEUi03QOjTnSk76LJqhqzPWBxhmExmNiJzVLsRUwAR3+p3T5pwV2VhI
-PEw2uduhjNSd3QgZatTCjotU45IuRK6843PPbRy3FhrjyB7MTFFqmNigWKg2yJ9LsPOaAvDGidyx
-ry9VQ0KqjFaKOVeFbpZkmRIgkTUvhVgF4E+oE/PMzNqUu33jo9FK8LVF/uppiRvJWlmpTxinWVCh
-p8VzxmZraL2oWkP8rkG9BTi84uXdOQJISLQBHLHpvQTLnCtZkxm8M4dop/Qhloe9A/4emwSCkCaG
-BxElQZm4ptZY6dkcshz3Zkq+wUtP9CIiSxQo4XYqtjt1IH4k6hXafBaIcwGptbIKPA==
-	]]>
-	<![CDATA[
-	1qxtncZqk5lBor+8m+atZPUsCR0JNvSeFregqd3J0lq7QfS/eXMAJmR8lhcGdVA0E6Cv2Lne0HtF
-aQTKrcbssyMp6bYUdZkxkf12HLOITFFSkmQC3nOWie62HBjvDfx89wjgbCQ4D30QLQXHtgReBB8M
-LY0MMBLWzW27t+VqSmS3kS2tnFAamTolqVfJQfVh7vjOCDC0bvi3lFSepmCfPco0Is+bKhFXJDrA
-nkDVnDvqehbLgKeyyZp0yuU+D5U4y1oieJVG4AFWFrQw9O6wbLz6+aYvzxu/5A0uDum1vVuA/kyA
-udHhsih9At90+xBCwLIhPve+FI4E8Oddo1eyhlJmg1pjYi7oNdv0bwwAzL+aF6UKBtU5yGZR1TCl
-ztUJAlQgMRWTxODUwFKlwO9z7YDxnm6+HnXxOlWI8zsjgChaTJxqom6KKFoX8TLDnshkZ1HIklNI
-xPkQaojjHf3qB8MsDJnlXJ6DHAGI0EWKDM6S0LNmpDFNfXhFl3inpaThSpcGeSQGpTs+fzzHdaNj
-DAtlzQqAfIjY7fBAAwkTNElQn2RgXsp6Jov0PFTyAg9AQF0gg5MWKe2oQ9DH1pJm7lqGl0/+8qQf
-/PRnB3/7rzf86Se//M/25a8vXnx+9frVN388ur4+uboQ4ucnX59e3CD/9C8XF0fnJy8OmHowyONb
-P3viDn45/vnbd09ej3/5A8f/+9v34z/+1/jD/x2k7w7Swe8O/vf/cQcvqOWfnjytQ2Ab93aMtrYW
-5UyPxa2JFOUhTS/kwxvk2rnUspBnJ28gL51cjC//4Ql1Mza4HlCxhhzkD5Rrmw8oqb0Tj+VS5HSF
-6EH1lD/CL2vqB387euJl+InDQca7SEquFBiT4XOdz7iQn47PUGzJOBuVMiBcJySXWjh3xdNEA7MY
-ViTG0CgltERpy5lPg5g4eZzbko8xMLFQulKq8qnsxDQ2yGQ5CUr2mepH1UJhF3QQB5Hc8UmIWkmO
-iZw3e0wdULWFoQwJOXEO3CASsFvUDihGjolJIO2YiPQabjukmy5kV6hWi3TAfUaFg2CS96UKMfXk
-9ef01BFxjCOS1sYj5YIag0ggwyHrnFqVHWBnHH4+yGR3Z/KQgtB2CFf0KU/yTGsg5hCFOJY36vwd
-+Tlpqp7MJOQvkLb0yDFRKuoycXAx+pSnuo41WQd16AlCHq8gRtBJm2GiCxnzGn/klpxmo7/3IsEy
-tcSEwXJyJRPHca34vcPv+QigAx+HjMtknxq+xTEvg0gZhHIIK5keZagkG5Q5gnEllOzmx9haPYhJ
-EjBks7zjTfBJFhZnyHsZAZ23krTteFW7EqMewiD1ooXobAQUQMln0yd9i/nAJHo1BpFOk896CPVs
-+ChjlQ4INzUVJWfXcGCLTJfysxI6yLGgZePILSGP08bTpQwtPfFZIEaZKMUXmRjJpMPEwYiyjqCM
-g1iUPJRSmS6FlBZ0kKqsLLm4+cp6herhDgg4na4Kr0HM/K3GKHpNdkb0Xyam0bOeLSraLb/3krEk
-Z9Z1XsNGMrKMipIdatQBjMVocmdYcJEZqPuIyQKzNohVnHtM5Hsucw2Rzwa/ug1rSN7urm0DOigC
-76MfiwG9kurAwxocU5kZkbtMl5NlC9r2opeZjfW62lWOAdlalhGkzKzXt8nMSBML2jakhl30ISqR
-nVg4R0P6L/KxWJ3XI8P2LVkYLrfJHXAheGZS42gUHYHWG2eyZBAwMWcQW20dw1Iex+uKUzSEriL8
-MHibLH4eJjfWgHImZvLbYxNdj03IPesekKjLF4FYr5cVaM5eDn017Rjqe0BVCRqOUetNOyip6jF0
-FDciNMUHGmTGVW5CjjrXVu05cBQfNEjdSU6gjF9DH4TsMf7xYndtq+eCiSmBaKuSg9MFaJQpXrWt
-BPsNIqHJsZgR2ACedFDd8e0OCjsjHVS5lLIzHETKRFYLhaivBPnuWsA75ZPuIbnSelNyZVOREJOM
-gKLNelVi03ea1NYYrYNM8VtMTuzRZWLwQTvgmuNEzORYUaKnXo91D9iUyQc2O3l9GsFd1qRHm7Rl
-IbIpnnlJG3dNNzGKDYuflBb0Y0mQIYUZZXnoGuGGxYa3oylDJ6dtkH6TukpktDRwIRYldVKK5UFp
-gqLGK9uy1weFK/jIzrJPlD8lHgImjkNY9PWlB+W5ngKGaGVyrBltlT95ci2FCmLx2sFkRXSM9FWn
-mBK5iHxioooQLstDSUeDXEvcktGNMAXeUSZL2UMm1tSV62QVC9iBL0tIkR+xzjUgN7uIG67gIrlS
-dQpSoISPxpBstAOnIH9MZmOQsDgXvLYl3oEHwW4CJkvykvN2E7Ir6zuhU2ix3hS4KLIg86f4QVDB
-pDW5gEwV4Cgm6hIMIu+4rDZDjfM55kcCd5mNJ3K88a0uQXhMDBS6BG6SQCQWfazcJJDkIZfGCzsn
-Yi92kzzY0WD3yqKZbaEDlvTkKup6DyJHiQvrZ4zlQSR2WEGkiHDpQJN9hNxkx9lKGq2tyKdkaM3g
-O9xSOggCRCI8wslJ5jibrtNlz6gQK6VHCN8ZEoB10JLoKF5RDJjYyWBzk0gBQOBnVb2LZOQUm6Ds
-WND1oncm66tcVNqgtNvGbweLwk34WSXgmMqCBUlMqs9w1BBvo5v3g/2qLkhLfpNkBGQ9LCoa6UGs
-XHKj6sdY/KSWabk0QTG65IY4kdno1RVZtEcpQT9GQGZTXw90rJn3i7yy5AXiKXh6Ifi1dZyp7rkt
-xdAGk9wbhpUKhCvWkmQXImYWUKmTOSq7vQexYASFS6Sx2BsobCWpmtXI0MXMM6rCoAsekqqPyfFl
-qjTCBu4fm9Rc5CmMC+BltFICYBCLxPyNeXXN/RtEthFTr4yc3IN2wGjfgbRvrfIkH/PCPhkpjV9L
-Xi05HIyZpDy1eo1T5485fZbIihQbtyXBO8kUkjiuxqc0Y1BGwGyE9P9WbcfoiSt0QSpZcflwVZKT
-AgtnBLyVqkh3lfTxEFUMaPoESqRyljUUXG9565pcmi7TkoNYoBDEQIH7XWcb5cwRqgSjfI1PUalQ
-qOssBMgIyDsu+j4ndNBdGmrvOFJON4zjm4mYpSqtKIvjv6UDKnVQ5GFzmgfKHaTA94ONRpHXJXpx
-o/EF47MhHZBIIbqxk10iIj2SoiYQw5OzEQlWskBP6TgGgcMp9RypMDm0Xgkg4A6C60JMGCuDvKps
-QBvGjho23AwllUfA6OjOy46rzFMTSRw8Ak4pajqC1CUhs3IpBbbI8cWNjoUmWo0s+iofE6eXhgsE
-4mnletJMHvKPPe4xeiF23yA4csoB98rC3nO9zSmymhDj5OoabziItOUFw5J2TR4FuQgUncfkNFar
-eTkFzh5GcgPxW1VTgcwTktR95RXIVEklgv+LkF4L1zGAMSqwslmp9kmtDS+g8oLaZJdVfeKfNw92
-SPyhsNg6xi3AD4NIcZXiIxjkJPgKfGmlvvroVIFemZ/2KvvKZfbkzmfDgecBtMSsk+26zM2I6CuL
-w+TYjqyv18rCalIiPWQyAsJeL16fDw4/5REwbCWf2MpWm1o5La3IyUzR60WkXMHE14AyeZ20JSgl
-giIfHyVghiADoOiycc/4ZLLQxwMgbw95Y/hP0rKrvaaJTFEpbC2J8NBFTZbFjwLfWTkXVFc/dggw
-mbyI0qH3eB+o0oLWqB7kTIeGOmBwjShMm7zmrFBSnfvE0h7zxspciLJfoeXybfU8eUL980VuK/kH
-Oo222JkgMdfxRalBpiUDaGD6pIWKUaB6zYetVMGtiZZKvDGLEagF8ZeKRFAFQLM2YR+Et5P4wWhU
-j7XJ1aHiCKz1cckhydZmMpsGqpYz7dqB78wBa4DCUhm2lQXryiXhqn6cSj3wPaEksuQTltrzUnO2
-mGv6wHNdukrlhrhC4XPtQJk4mbPEMMUPYWTzYjU7KnUw3itaE6qiqXFg/I61Jm3pIssrQCOovCZk
-+NIOeFgZw/JgoUL2OoUud9WrMCpEvVNCLJhs6PYUR5kZ1TbntHAelo/M7AgLPMgzwrjfLJozBEXL
-ugZNYF2EbJOtDi0jRCTHj7PQ1GRJi9Xkfca5FGJq/FwQpLNS2F7DFIqixY85ZKkKAracPm7KF5Dh
-q1UWqxI2xUSuxogDwEeEyQykRUTSRHn5CblULD+V4chkllwIFidI9U8mqzWgMrKeEbse7CRmP5IA
-aNQYAUlYLGkTuev6JbliTFRlRVp6bRmJ/UGk5pR53irJmeBLEEWRZHBzeQAcxSkwo2SQeqcHgDws
-hXWzvAhz7C/RDtimJES9wkTsauchspqCqQM1dFGYpdhZ+GMxKtHLw0LEqK84yVJNBFoabRKrFrvL
-mbMIPHpWQV1NHwQTS4oAFBv20PLZ6otq5bry0QQi6VD8MhH2CMUhmGYkFpFECrBqBUmst5WBh4oo
-/pxdxOYfKqXToSBzugmfWC7mY+vF9gJuq1MgpsWxgcyyY1I7Cy94E6ZdtPS8rGziF4tAYnryuohN
-pNRU5EiJIEJ2Dt4xmkJS1arTs9KFqHoJtxTbP8NHq6GEPhYcS0gEdp0TOK9LvOUkanH4Op+uoJ/q
-tB/JTmISqzFBuPiIYx/E/EKFo2rDUXbiaeE1aMWUu5pdVmFIXmLWpiMb9yKdLrEckOmOZxCrxIOL
-MBdE4RdyUYMlx642JdaODtTATcSh/6qVIUquo3zLifOBFAAx0keU1WYdbGhbSmRocRi7sqg7sZuJ
-u7Fm1YXouzjmGk2cxR6S4yGMsKVGjkzsmhkgRHnnqOKYas3N5EGqTRbNUlOgQSTU7RXDlEoE9h6w
-6MsiDhfNcQUmR4rQluOly6mWFrHXJQ768UqMja844Ro5D2NTg3ctNTDlgmxCOTIpVl3EJCY/gnPy
-ydYw1Kanq8Fgxz5P/b25P1gjLELsvkE/9sY9nZyOp+JqiUXPoZnAHLQKvrUZHTg5qUwG7+JqtlWJ
-/HwKsYkxeBDZ54oRcO2QKqV7xNhEllQyGzERjinS+3tXYs9wBjd6uWRpCYLDwWzbxYhGhXuauAdb
-hNJMvmJvI+DvZmE9Xs30BHrblJ+ZrmPqGjV0i42hUWyHTKzBQjtmVeX7gkvNRC/KKR0XeDJJKxAb
-N9dT0gXguXohZqVwnRCmsPKAa6gO3uTkndG7KRp7chC1iKieRSq7VwI+H6SQEJM5FVqIXNxDriG8
-YpyX0eUejwOCEZAExkw66jOhRBe17ZD6QEziOohNbLPogNNjmZwoTlCPUOd5xWb8jQsiR/2UM2th
-ZQOasjhWdoTI4IpMrFF9eAzeEYXIYh/cPzxGJidX0DalpG19Vw8zKVsO3NTMjVxZvGhbqc7ALjiG
-wxzEAm2NiAwqIERvDvkip0TJDU5XvZxEVOWc/btV+S770uCNZjHzBusuHGuFYenhoNgH8cvRvMjN
-ySOIWbgdK+clS1sG4zwQuw0RMonDVVTzICkP9OPEuWAl6Y89mxoTCYwiKMQMD+ISEg==
-	]]>
-	<![CDATA[
-	AiINPxHGaGXf6NrWwlxiFD/NTaITQ590YGQyV3E1sbXXGWhyR1DKMYcAvSnIJxPxy99fXvzx6vTi
-+vTi66dPhcyxP+tfPPn9t/Q33slfffHX3/7m9Gx08+QX9seD/3jyi7/97vD3ly9Oxh9/+pKJPzv4
-xRfXo4+vD376z/Ozi/F3T+n/KIzoZwc/f3L33/7j6Ow1/7U/+MV/Xlzf/Mvr77/lv/vFL6+ujr6/
-/dGTP7+++ur12cnF8cmP8OnP5t8ff3N69uLq5IL//lenx9enlxdHV7fHJz384i8Xp8eD8kPD++n1
-OpEf+IGNOLy3ES+Nxlm5Ov3q9fXJK2o2/sJ6XGZ1dfLq9dn1A+a1qRlh9Dfn9Or69Pr4mz+fnlG7
-e03s4vIL/s2mJndjGjdn+NXRq5PfXJ38v9fjjH1/zzmSILWp+d2axM0ZXrw+/8Px9dE/7r2FYVNz
-W4f/8x9q+fNbPPD55fm3l69OrzfJAk8v3rLK2+UUPPSf35rNPSfzxeXrq+OT314dffvN6fHGZnV7
-UpffnlwdXV9e3XNqb1uDH3k+c/RvuTQPPrrfnb64fgt7t0Xxzv1kU8uig7+509+cnH79zX1f7s1N
-CaO/Oad7v2XbmszO6/XPD3Me/7w9D1EExgCv7/sMX371f0+Orz+/fH3xYjT6/PItK/EjT/DGfG69
-Bi/e8uL+9Jf/+eUvz7795uhLv6k50cB/kFv+4lcnLw8+22t7/ypt7+XV0RD1zn5/efpqr+/t9b3t
-6Hvb4lPvV91Lm5rbXt3bGKPYq3t7dW+v7m1nSnt1b4Pz2Kt791L3tiVqfKjq3m+PXr96dXp08fnZ
-6x/j4w9+MR6kGH0lk9jOqbhbMXqgyMPHfVPT2hV4Xl2/+NXJP06P6PcfpKpwcwIPUhb+8PLlq5Pr
-D/7yXPI0Pv/IrtDmWMLu3XlxXzllWzfmxY6c8uK+guPGJvL9Ay/8F9+eHL8+O7o6JOF5jP5Hf7T/
-eHl6cX2oisfmuM59T8HToQ45t6mj8M4qxNO8tans3M7/ue9Uwua25X/evyXi1fX3Z/f1JJzpPX96
-fHl2efUf330jhsHtrI9O5pZIplzq+eXFq+uji3vbKLY1s51J3Jrk66uXR8cnXxwf3Xs3txVtdXMC
-d+/gr//57eXFyf13cFuXd3cWj3B9UWd/eP2W1nsJ9T1IqB+Lt+SjPV73dQJt14jw7r6gLe7TJ+sF
-+oCYwd/fonlOl8CmtoKGfXOd//4WMW2rE/E7E4kfpFxKw741kfvy441NZIcJP+jBPDu9/uPR6dtE
-0w/sxdzm67KPnLhjakdXp9ffnJ9cb2xe7/h2/u7k6usf492846v0n1t8se99yDfqvniwMvVx7MYm
-34V77MVjv/GvjolKG4tVeQ8xUVub0uNiop6GjU3n3V0aW5vJjkfjXsFCn5/84+Tsi2+OXlx+t88Q
-eT/ywuXVt99cnl1+/f0Wn6iroxenr+8bJ+efbSs/GYN/hEa2LSPfJxMA9UC95cXp2dHGnIirzrLD
-ZT+8k/dW7rojeO/Z2obZ2rbyWB7J1jZ2U/bMbOvn7cHM7COJSf1qWxL7Yz39m5rM7rW//+XY1rbI
-7XinSNSnH3go6j5b/1+9JY/O1v9qY7LYPlf/Abn629q7H8zVv/8ztDHu/Yh3aFvbs/sOPRg/YVvB
-qe+Mn/Cr01ffnh0dn5yfXFz/7ujbLb5N/3z+zdHFxcnZFydnJ8f313X+tKkN2p3ELa/Fu03yl5ua
-5O4kHvMavyXeaBOv8f1DVbbGAR8RpfIRPUvbOmO7z9KrB6RLbGsur5An8YDH6Dll7fzuaDT65xYf
-ogcoSeeYxHY25C71iIdwX4nHHeB/Bzt/9Df+uKl5Y46PeYq2ZXt4rHFrW4ziMex7W/vyYNvvjwzp
-sX786OL0/Gibof8vT8/O7m2LOjn5n21ZoWT0N3f66Pj49fnrt7teFpPNxbZmtc7g1im+ujz/IOPp
-ZeA3JzNkluPfXb647zadnV6cHG0rinXO4NYRRMPf8+DvF11/b6iYH/s03pzMLfMh1Wi5r0jzFtnn
-x7YaytBvzuf68oO0SNGwd0Su66Ore0dHnX139P22tscmcMuF9bZA9rlD25oPD/wWm3jx4vT69B/3
-5RBXJ2w83NSs5hTeNxLFw3SGbV3Hx+oMG5O0H6EzbGtf7jD5PBygbVuC1R6g7XhbG7IPhtnktjwm
-GKZtaib7YJiPLxjmeFv+qn0wzMdaqPDe79DW2PcjHqJt3a33EA2zMSSzfTjMzg7tw2E+7HCY4215
-7R4bDrM1FviIcJiP6F3a1hl7XDjMtlSkfTjMRx8O4z+VcJjjbRmDH2ne2hrTewT73ta+bD0c5l9s
-A96WCv7YS7Kxo/WIS7Ktfdn7f/awej/IdO5/RTd2sN9p7z/4Xdiae/nT3IUtwnY8Phbl/UazPAjN
-0G8MYW6PZnjbI7y16TyiQNO2JrIv8vqDFvf//PL55eXZ59sLxN+DNv7b0c22ZVm5G9tsj82+eViw
-9yv33Iun/YpX5MttHeA9R/u3c7SyqQOx52h7jvZAjratA7znaP92jratJ27P0d40tZOry7flpX5a
-DO3XtCB7CW3Pz/YS2p6ffTT8bFvH90PlZ1uPJHkHH/+2AjAe5OP/19yXdY+/3Nbq7K/NZq5N3dTB
-2Nq12dbqfJjX5uNA0ro6Ob98G+zHBpC0HhSh7Q/8Z8Ed+Dz+3x2Mfz4bfx7//mz8xcGmpnp3UPbH
-DBv2QKStV98S1tam5vY+kbaEcf3pbSd7D7P1XuZ1J8zWHp3Kb2ybPn54qpvn79uTo+tf3Xu3Ti9e
-nLw8vTjdmJdrmcanm/vx1dZqm38yxT3vDwO2tS16L4kg29LnHpEI8vzy/NvLV6fbVKselgeGmfzh
-9Vt+shGecN8M/i37Jh5R22JzfOGxjpa3TX2rXpYPiCH8/S3m56kIbWoraNg31/nvb8kk3OpE/M5E
-3hIXsNHUSRr2rYnclx1vbCI7HPidH81tTez9vJpbFKUfAYCzVRHn0W/n0dXp9TfnJ9cbE3De8Q3d
-Z1c/Irt6sxxpm9ml+yS5m27XP57+8+Tsj2dH33+5sdOzY3a4py9iFjVwB3lb4uAyg707+T0yy0/c
-ncwHnRzKwX22vUO/dyG/ZWYfebGmvQt570J+D8rt3oV8+yHbu5D3LuT3Ij7tXcibtHvdqc59kFu0
-dyHfhPJ/+fL1q5NDQlUa09ircbY0n7Ya9/3J2dnld599fXVycvHZuMMnn4138PTry8/+cXp5dnL9
-2dXJi88ur44uvt7WvPf63aet350pH3t6TKjwm5rmXsn7tJS8fRnbvZL371LyfnU6Tu/F9aEifW5O
-uDr6n9Pz1/fHVW3bMiLb6G8u+8nZGMgDdIiyrVktw3/fKZevXl+9HJzjiwfUpdkWQPTNCTwiZOeF
-qFubmtxjC99uTsF/d2PFFrdn114hG/aQ27Qtb/qN8d+c2kPk91u66qameHset6RIOWbPLy/4mf4g
-N3FnDg8SUL749uR4qLNXe7vT3u50WxAnK5PYndQIxeanvd1pb3d6v3Pb2532dqe93Wlvd9rbnT4Z
-u9O9FcGzt9fI+bergXsj2qdlRFOV6aFa47YWaHcWP3+sqdB/OLZCzP7X//x2SPr338ONzXBnFo+w
-iKKzrWXFffxW0XeytQ39e1PT2jW0PUBc2XS6/Ed9iz7lROCt7tUeQ2P7TOHTw9DYltfjERgaG9uR
-d8fQ2NhEHoehcXZ6/cej07dJ4h/Yq7lJN/YjXswtg2g98s38uLAz9m/npt7OjU1kjz+1tYm8n7dz
-W5N67OO5XfXs3R/QTUo5+7dzjzv1wy/2g8/3tjjRHnPqw8KcessL8W93+O4xp26uxI/OLPfYCf8O
-we2DdxXcntI74A1sizU9Am/gDy9fvjrZZGzQgy7PJU+D+MDVyYvtnbmP33n94i1CiM1lWzUvadi3
-JvL9hzmR7/fqzY+m3myc29xDz/kYd2XrXom94rltxfOLb45eXH63SaTjvWq2V832qtk9I9A3NaW9
-arZxYWmvmtlc2qYm8gjVbGMT2atme9Vsr5rtVbP7L+x3py/un0iY3E82taQ6+Jsn+ZuTt2dwzinF
-jU0Jo785p/s+R0993tZ0vr89k/tKCJubyY6MsDdq3GnU2Ja/6kM1avz59dVXr89OLo5/bOlsj4/0
-r7teO/hIHzNK0Mury/P7Bis/21aWswz95nT2oEfr9L46enXym6uT//d6cKi3yCZbwjy6vrz3idxW
-mQca+M9vG8Y+cbijPdrRHu3o8YfwvmhHD5ZWZLD3WpyXV0fH10dnv7883VjmnvX4rhb5421pA3db
-4F9dn14ff/Pn07N7h9deXH7Bv9nU5G5M4+YMH/Bcb1YouzWHd3SiHG/M577jQrk3TtnGrtZuzPrF
-6/M/DLb2j3vfqo3hVa3j/3hSYT9tAJatXZpPFXflXWw/e2Pramy9Ptpa8uPe1Pqv4NcPUCOu14ls
-51w8WomgeW1qRns14iFqhPuA9IgHy6zbiv/Zi6wfn8i6Oe63F1r/JbE1bmOBKO8htmZrU3pcbM3G
-JvPOkTUbm8c+ruYtqt7UT758C2jWXuH7tBS+j9dvtDmhZ6/yPUTl21bC+vvV+LY1t73Gt9f49hrf
-XuPba3x3Tmmv8W1wHnuN7/4a37Zs5x+qxreHiPjxdaOPJmPznaKzNrdJu/FZ7wB4sS3dZw94sfEU
-9I8f8OLe/OASB25Ds9nhCHtkxX/zRB4K3/Gbs8vLtwmU/xYu9ur6+3sXcX1Jk5Aijv/x1dnR8d8/
-OxDS5bdHx6fX3//H1uyJOrlHmLfvUXZzG6z63sHom5vQW1WVD8og+ilIBfc1+W58eo8KT9/eNfqI
-Tb/vxOleMcrF8+1t1EP53a+kUuChVlH+0W0yvzrlKvCHal7eHMu994ngOtQbyyvZEe2P/uf0/PX9
-XRNxW3ZHG/3NSZ2cjYE8BK9zWwlmy/Dftx/q1eurl0fHJ18cH91bDN/Wjt+cwCNE7S0WRN3bRTa9
-PbvcUzbsIbdpW2nGN8Z/c2pn+v4/vYfsabP77putATncnsYte5CcsueXFyxzfJB7uDOHB0l7X2hp
-y724917EvU2djL2096lLe3q5P2j+tjuJn386Ii0m/+t/fnt5cXL/HdzWEd+dxSME960WY/74hfeP
-ViT8JL0BH9o9+pQjv7e6Vx+zF+BjYQp/f4uTfEYDb2oraNg31/nvb5FLNyq/0rBvTeQt6Zpb3ZG4
-M5H78uSNTWSHET/o4Tw7vf7j0enbZPEP7NXcpL31ES/mhxQ8/MA38+jq9Pqb85OtwXzt387NbMUj
-3s6NTeTd386NCQHv/nZubCL7t3NnUtvVzt79/dzkRu2fzhtP575I4x0AAR9LsOi7nIUPflc2zHUe
-75l7wG7ukYj+1Zv6aCSiP28TVHePR3R/PKIPCoH2gZaPrT5p+0IQbPM4u7z63dFo9A==
-	]]>
-	<![CDATA[
-	zw+cv59jEtvZlbs4Ow/h3qfswOn/7vqTUTY1aUzwEQ/ab8dQXr09iGYT79m9meFGX+kHi/cfFVDJ
-ZrWu9wJYsr1p7b68e4iPD/4S/WHbBoxHXqXNzmv3Lt0bHOPptq7QI9Axnm5Lb3owPMamfY4P4gI0
-E7orf94aNOhjfSobZ2+Pca1sU9Deh/J9fIL2yh22lYj+SPFgs2zvvYjafmMVdh8hbPNLSykff746
-unj18t8A8fmb1xfHf9riTX6Ale366KuNvRZ3Gdl4lH99iKUtHGzLoHtjBg8DXBun7Lf7U7bJU/as
-HriDbc3rUefs8/052+Y58x8wO/vXC6J/G6//b06vtrXzj5RDt6zKfbL2EDHDfzBH7WF5jdvMaHh3
-Y8hmOcPeHrKPMX1kNOOGmdH7iml8Z0bNO/zLs7NNrcpk0e93ZR5U/SlvrCrPe6j+tLUpPa7601O/
-sem8c/2nzc1kXwHqh6b2y//88r8uL198fXW0MdnivuWffvLL//Tuy19fvLAyUETKRPny95cXfxwT
-YWCWp0L+/OTr04v1L578/lvuI8lfffH9+VeXZ2Ndrq4uvzvwP3viDn45/vnbd09eP5khe3/7fvzH
-/xp/+L+D9N1BOvjdwf/+P+7gBbX80xOfD+rB+ZOn/O9D/vdT+sPyb/rXxWj9p/HPb0eLNPo6f1Kf
-pdJrHH8+e9KeOe9q4j9/MVr9Yfzz9ROfnrmUO7f2/llwxR/4Zy7H6g/qs9JCCQfhWcs+l4P8LPWW
-00F6VnNu5eB49B98q5n7xN8+pb9OrQ0SOnhKPbjxFXzhKX0ijIHNzx8/efnkL09+8uXY8Osbe/qT
-L7Oej7Go8Y9j106uLv40lvbV9RVb+/+sR+UnX4bdhoTmdHU9m7iDX3x+eXl2s80F2SB++/r0hRyF
-n3w5TsGXT/rBT3928Lf/Wg6EbOX7OA2fX3534yTgf7wtz5xrLRy4Z72H6Dr9oSYX6A/Oec9/6CEn
-+rd3vblEf0je13Lwt6N7n6r+LDQfxhEqz0LulU5Yf5ZaiZH2cJybUA/as+pTS7SDqfVQDsoz+u8k
-Iwg9jn176p7lWnwNB/1Zq2EclNFjytHHg0hz8PVgNGmtVN8P4jiGdYzz+Tijz4rPYTRKNK08jl0s
-MbSD0Mavx6f++iQ86z54fxDDM+9LHQcylDj+HUf/1O1fn5Rn0Y0jfhDGZPoYVqGlGgcs+GfN93bw
-j3EGc+yuHPj8LI+1GzMqtY6TN35QE5/IWsfH0/h4Gif5+RM/PjYW/iA+CzG20SI8q9HR8JoLY7l8
-lL93427FMamxAoPU4/gxTSn2kqnX5sYNGesYgi/tYGetn4/jfudhH+/dWE5Xe1k47eef//L4+PX5
-ny6vzb+lh3RsfEh5fNvTrj9zocVMf2h0GjJR+jgYjQ5IGHe40wEZS1HdaDVGl1MZN/Wc2ICvsdH4
-+pCEEs2glDGB9iy31Attba5pXOX+LJcxkePBT2T7xvs8JtkzbXLyeVzrQSrP5CAkPTZPAzMR3vf6
-rJceEtPGpvXBudwYELGBp2Mlcx9rSkeCWMzTMQ6fUh4bWQanSJ1HUEIdJ689Gz8OgcZYu3fhrkXe
-2YjdrbpjO2/v+O0TcdeZqa2PY/dsnKmxssTWiGMOdldb83z4XOy0RM7xcTx+wgcy8t1wfpzqwK2C
-54Uc36VjTBS6R0SJMbhI3xoL0TstzTj7ro4plbETdGkjMQE+6Te39/i9nbXBdPxg8XLWxl3kdRsH
-JNJ7M4Y45hPpD4n+REdtbE2N414+HSvEczx/Qus9JjVIeUxknLkxD57a03FpuxsnajwOvEZPQxwb
-0WjSuwfp8Mkd523nTO4e29sHe/fk7y7fzgrvbMEd+zRmk8Z0Dp7m8ebRX44vxTSuIh3gNLjUwc7i
-vK+N+ou9Xa/fiUGM817owNMyFp/i2LUxdrlIYxa9U/NSmf/ThrhxLg7+mz5VWh+XlWnjitAm5bHd
-jW/74N6DwbP8Mk5+dXTdaRdGb6OVS7VlPgOjX1rp7Pp4DKhJ8J2u5XiDPDMHOjk+OE+tutwY2tUx
-EVrbNCSO0aaOoxMTHR06G8VV2nI9eYMZxEyvWtPnY3TdZQPH25PS+N0xjdIXen0GrQwWxOcy026P
-jwx+M87Bzjq9P67+OBFgdz7nT+6Y9e7K3LF8Y2llowdXTdkHPgK+psaSHp/sp74+i7zxkUYTG+/W
-4M+9Ek8s9LuxxmORXBkXbHw/Rf1VGpczJJIGA6/5+OM4BuM5rzRAYhFt7O8QEXJMdZwxuit8raKn
-wXve+nHAOvXSU+M2Y8NKHhs2jlzukYc+HpOxP0OQiGPnqE0iHk4/yvRp5iAs+46nKPrOg6ttfHKw
-IBeKHIj2rBXPbCCGRL8aHCjlRicxj8lGPhJuyL7CgWJOxHEGqVdiOYOU6O0ZxyYUejAHIY/7eNc5
-2jlru8fxrkO7Df5BjDs5WsWxkeNZ7XT8xlLXVAvTxuNMd30Ik54v++iu0xzHhkVHSzV2d7wqjc4f
-8Q06fkSSZ2IQGvF0OgLEi5hCDzJTauLNGjQXs3SVXA38OZb86HNdmM04F7zIg5Lp6tDvsvJ6Or+8
-bWPgxdEeB5Iu6bqM6TWfOv9V6ywBEE1ZCbHKXOU58zzPsRp8cQIxPr4K/z97b7erSXJe6V1B30Od
-GJAPdiMj4ycjMUdiAzYMt43BDMYeHw2oEmdETDcJ0JQA3b3jeVbkrq5dReqHvSlZGJ6wd9SX35cZ
-GfHG+7PWes8cOvzeeq9rX7o9XEE5BjmRyr0fdH181COLcvLd/N7yNU4eouz54WC87ztLuV3F383R
-tkbOsR9v3fr0hFxbiwjMx8NpwhFaPtIHZqBoZVlxc89J1xivk2t56PnM9IjGnT8xGGvk9iHXr896
-7inZv88RzwyuHZSXsn5dX59ba+xeH7Z72mIE2jFya3vtaw+6L2W9sDzb5yvs53Ny/kTT27ZjwXJZ
-pmHG9Pa7eQjybtbsYH7K7fRjhJnANSPaS1buLAeWA5+kV4wc8c2h07Tedmssa4wnk8t7L/jOhFZN
-K+rG0l+ZBmKZpY4zUpc3cl/3H9hqX27ILzftlxP/ldfzlVf4tRf9xXL4csl8bV0NEhROYscU+qF1
-kNyeP8OfW1/UC7fU2F6ZTW59ZyiKrr4jLSdZGQVT6uPdfndZS+be6/jenzrXljuzx+tsiW+Kd5DT
-lddYxjjO/Xv3nLqWM/O67PvRr8zPOQ9Ppjo61okX28/4K+sIwMysod4wM2sKVlQ+s/9Pdu/afvWu
-IztqVB+PO8i9rLDD2+Rwu4/pImvnOhu/XJw/n8fyT44NvjSHP37zNaP5pWH9mvldu2DesZWtvUaX
-IwsutuqrZvRLY/s1g/zWbP/rOGeJKJbfnBtbThCBfN87nj3JacdknTzXsu9rsy1va62dsWJVXLx5
-LYdihSor5GmHkfRsjYtI5rWSBcvr4kx49mUOBY6NWPB9bniyzGufLMtjYi/PvfVPYq510XJZjnl+
-OqM4xQgKcoqdH3xF89qvSKvkijjLfkPL6/IFzXu/oLVReD9GAb6fE5PERWefexmtR2MVGSq6itZm
-dl7OuhfRYBF50Pf4BWvl+NRxufQFlqHCYSg6Fa8Ow7nt0qtXgePB1D1+h87JdmC2c7KGrgydy4Id
-XnNPpqHiWjIvDBAakhxrmqHTZOvMZ+ZaxqdGYPot1/I1eaRG0k6TPk8j13sZk9G9O7+YTAWmjDfM
-D3yxhP61nKNsaN+Px1phacdCvp58vCRjvudwJHC/toe4T9BGkNDHp2OWV1yeAXx4juYyf2oQP50q
-WM2La846PZ1KbMSa+BaP/tX69u0aPhZ6GfF+1raN+Doml6G/yjY+Z2fXsbcGv8NhwHLgvHDXPecF
-h4pxxqdDheXrsf+cPFyknXwOJ1ZBmT89wNwDiXtzyjFg5uw5CDktdQY/nZbYhFNHI8ko1v556Kes
-aVq75Gt25K2t+cIafWW5fbEi3y7ZryzrL5f+F5vjqxsobn9lF/NEfUWt5JTWEqtjvbS3a+5fMHH2
-hU378Zuv2b03lvEr1vPcE84puOycz4i5y0F5tK8awi+M5Rfm9EuT+3MfiQfxzSBf8IGFsHbgxdyt
-4GVWR2I6jjlOKlDk1h7T8Xbb/PjP2jbMqit+bd1SG0n89Q5rktRY7Z9pS//rsLe6hpfLa91r7feO
-W8ybOFbiOr9xIP+vfErL/NmnPvuu/+dne8p/7qL40kNPTuKtH/+lr/+ViIClUXAyn6XxgtEywHoW
-x9c8+y/d/y9DhK8EEj/fAimF2Vl3Uy4N0XJmNDvrf5WBtSpimq7X/1ix3gpA9wRuO1yXMR9tT+Ac
-RBiV2gWvHq+vnBkhxP3wdzrZay4Sfd4lecYeI7/Obp/7740G1xRe24Zfl4YuUU6laLBO07/T0a8V
-t36ZftMd+p2syDXQdsz6+X3+XDO4QuBEFOumj94omK6F0Kp3OPIfriji62fg77A9HlufPkOYzcqo
-BKTk/9YZ5ZpZh9V5bP91LeDmjJVZqb+9+e2//5c7m0gYJdxvOYaFDhxl5wnMCqyBlhODdOXk1VGL
-qykEzLr8hUHN5Ez0XsoyR3+P/bQywtCaRNKh8fD6sppUc0nPNhMi5J4bPl+fxzH3MphXvmR/hszG
-HB9+OuBh+NPvWf/R1yP0jXFgfekK/T33u+39iAV4vbs1UGrne5Zbc1uULHhDHdfwKZgfebcETnom
-5xM5fZq+fX9fzOfP9W5f2qc0zmyHATYQDHyF1zdl7eQ2o/P6qsiyH/ddPr0s0i83WSZfVqluWHLl
-ph59W/w9r52OOZcd/jt/jbNnv69uonzu+Hzv27//6af2jHw2sl/ZT8bW744czKW0q++XNuv+Ls9x
-Xlo5knPJXfrWrnwVhvgen14bKRbe5H5vtymWVvsxfvLiPk3nc5tv5/fnenH/vHRA96xtH14LFT9+
-w4tJOeJeZ+Hy9In055HsxnGwXscVu8KO0Il5weofJs/WVceVTNtdb796GaKRA2vch67BMhat7EJb
-8mt8qOYF7SIhP2/taWTbeoutmYKp345ykHDhACDhkpJ/TXi1HPYvnutfMmn19gF+ZKjflTiCmpGL
-fK20FSJ111zK1p1d59HPSZ+E3dpjsV0FU2hcibPYPn0Iq9T13tfWpOJJoIn/lRsYnIkMlBRKr3XR
-12br7YR+OeVfeS//OtzSL9Yna7qNEYt/XD7wMe+Z5DobdR3/49zOp1mbj9+s5zUeNUE99R7WDJyp
-8hjw/sRl3bXMj9aukzDEjb2zfNt5xOmoJru+sg2+3CtfbqivbLufP376E/09fOI6Y/KX8+FSXzb7
-qFdqYZM4++WI41o/Df0d+IH9dGvoWk5a2zjBnBTr0Pn7b/Czrx1jLvtFEbTv19jy2tYp/eqD9536
-ZZNmZ5Gc8fqyDoM6rk/f/ZHbPFOwek6rWOpSPv3cl4/3c7mJPgBZVI4Q4+gfU3vQdw==
-	]]>
-	<![CDATA[
-	mE+ksY6e21LJmRX4d/Gm9YjuJ3v0xVf93c90k4VEo3VAUEw3+8qk7ySfkzfDKe7WWBbl6MMX0nYe
-YF1+roPlwxdf83Pd36d1/PX/+upv/EOwzS9QmH/7V7B8PwdiBhn7ByCU5XiDzC1spv7AZ/3vsbb4
-WrT8HynuwleVknKe/1JELTyfe/EDVMM8ODL22b+9ePXzffz1/NSnb3xu4+M3v/irbx75z1/8zTfl
-w1/8p98Azv7rD//td7/861//6je/RxV0baRyu3tP4AuHZy4QtJ8IiZYPv/hv3+SUqQ68PH+8XGtT
-f7t8qfsDsDeBCR9+8eN69es3f7HeTvvwf3gT//mvvxk/7yv77m//6ldvMNQ/B2L2P6zvGPc1TCeA
-bMp/YHRwtpYD2bsX1+vs/ZPXxX/wtf/5L79cM4U1823/yqp5acsKlMvX1g/8NPJGQt0ayMerionc
-QwS251juAWiq8a3H1hCUMxl6813ff/NXX5/p4wFH/+73/+vvfv3X//6HX/7mEyb6P/zqlz98/k+P
-AuEnszY5O2dQOXdZs/CjP24dpBwB4eQWT7wm73GucxDA13EI2lzmjzhgnYTff+X73u/W19taG4V4
-hlRvc8r5/Y1Cw/kv53OjCde40b7haitwH5e166Omiv39177z/e6/nd+aSxprv49xZ8FcRJofuOO1
-pIOiPSh79Cyi2vbq6CUx8PJFfJy3X/Z+t31NcnTnh3qtX+xBQvDj86c/nlvsucX7J0sjZ+TyCfzU
-2+96x8VygBFvHm7tMg/Kj+PSVQBl49y3iLPp4ultfFoR5rm82XA13nzb+903RYt+sCIEQrvGKd+a
-Wyhr4qVniJs9zkacwdo5yvG6KsjI+WIOoZtffOE7rpTlPR9rOidedNW0+OsAdI/7gYl/tnTnMV7X
-BVSDtS6Wa+jQmy97v9u+19IFXtzx54sZ0Us2xMmPL0fvdekCU+AWj6zmrIplfFgVUBm+//LL3u22
-CWyvFfd+Fgmsk+b8SWzgWOsHUF+B3BPw7U50aftd7drvSgx1S0T6zFKuiIJ1pPFfQZI2dTQn4O3X
-/cFnLX/is2JcqNByPDZz1vx0Mzzjp70b73AKhF132H0UjrFLMgFH7cTgvP2ud7tpjv6bTDGGvJyU
-KvjtZchzzM+yb7BjgbzB7TDcSUafJDbaT8eeb3q3e16LfEUo7kMP+LVAWOPUeCmJXMP18dmaOZ+V
-MEroAGQG19Dbr3q/xXGu2HEFNmOkZvGjP12XNWer3tfc9ydbxeWiYWw7GeO7cE7fftF7rowp1iHH
-fiFu48cLCAOAY88N9lGyUC9vh+tMG7EOzusZ+vyr3m9trO1FaQaDfEsCuUk1r2W5bN11ublYLULO
-C6mZMvc6IKfCOqh+6O0XvdsdszzN+N9gtVkYR+5u/XKdrebu+lrW3N2yaVdWwX0swz06bDfu7s3X
-vOOyKNJbSqtB9f7ITy+/r/vbwiiySqk6ukrv4RooQ+S5nsB1ZF28+a53vOu7m0XjfLghbOmuNBPd
-z8lEEXeFOo2xsWKI1i1BgdLmSMk5M2/tDVacoqJWvM6vHEg5fKrl+hVITxAPzMwXX/cHH/r801/V
-qGHSmKCdpIcaZaPy3OVycXKXqT/kc9eV9dSSaQYLc1/3fodvvvDdbl6zHRxyFRLyxK6jPXd6H8ed
-O02Z9vWD3//0g66tuP9ffuU7zv1yC4EjuELG4JTyGJ37GAWMvN2BMZ+PXT0rpN9OMiHg4SR/+XXv
-N/GNDKhpfleItbxPfCt+/3A1sJKOlL3257KjSw2knxVSkzf44hvf7+5n3RXvbDkzouv3m4jy7Lkn
-gg3n7vWDe4GU+rqUTmOYL77x/W7enEv7lHPJiq8NhMKn1IzriALiJ3+Rj1lA/uRVfvFl73fbrOJM
-sKvjxFXg5w/QiPx+632fAT3gv+dze3Hc/Xk5fTy5kc+/8B1vHoxehx2b1TEsXR/EVmXfabvvfacr
-gDo/fXAvjgC9XRy1PFmcz7/y3W6/fJ4KNHX89Wf6WpKPz53gVn4aRJGwXZcANTKUH1f9Qw/1i7/6
-atb3bP/za5+oL9K8K9T5dtaj7DxvCbPvw8u1Ji8/MA8oIPzsf17nFYxVAIZvPj5r2/zqTx//xcd/
-0rf/4g9/+zX68hHPOj7/9p11fp+F+GWE/xX/6Kup2q9nDb8M8v85r4vvXl+4J/TsoNEx+k6oP3rd
-95EfXa9rraZvAae9+fRy/2eYnJ8+/YuP/6Qv/8Uf/PLruluIRZ99+R97WX96XuMLL/grccbXdtfX
-XuBX3vMfeFW9/wOvipLx6/S0QvLB6RE14PR4H+tNrT0eivnbj9/gmFk4nz6+X9U/8st/8Ue+/HVf
-ffblf+xV/amu/5+q9FJ+LqWXgcJJuT6ch5iuDydUtBXJXyVwMqbKB0onxHXFZ194/8cffv3xV//x
-4y9/+PVv/huP+7//6u//cRIybwtb/8sPv12Xf/iPv//db//7urkvxWEexZ5/Qm3yJCEAvmxW6BCs
-AOBc1GFg/1HTLQOOy50qiHC3cgONDjlfGOZ335xH2RwswPmk8rQcc1MzDdeZOBOxjlAQhLozN0CK
-sQn4/AScce/LwEND5qtHLmu1nGLWb9zZIChO0HknANB+BNSytgKkgKGQS4qSXc70uXYqmi7CXC5Z
-S8cyQT2AeFFnZ78+MZAgDqyrxtorOVg7KT+4A8vPvI0Q64pMHVnLJCEjxS2B9RMa9x3YG4TIc/Yd
-nGHimcHlBW7+ENoSd+7xRpkG89PBGzFx2MlxhlYefvi93lKAQd/WkmdbUxTbe25IVSUtTkbiAjU7
-5oeqdsqaEWrzMOPXRWhZQPwF+gaQshZS0CtiYGJhTFcjtib1YQxJHPU8EpDxZnjpDAhL4rVQu6mn
-Ch3lw3orJ6wOLipZa5wdkO24SJPSjlR3KhSQc604PATIJ9weZmc9cOMZLu9OhgOvDRxE9eifH/p6
-MhYrl8jg7x86yj9j3csBNQsLv6KEa3m2a1l/Wy//vssx9tSBPevrmamULkfEOXQAdZb1FteKv/jb
-ShpvaUrJ91s65LZ7JBpfA/2EsXVvr2QtKMGIebUVtAuhwMCm8P5hzXVKP1DD5hUmXD/ioLKMNpWl
-jSjVMHAJYzrNjHPNmqj17u4Ay7lmBtWydvN98vLmHTgGCON5saZIV631XvvrHr7P7G8wxhJB7hqW
-FCjktZLWwKa+s9ko1nLRejNIslRIxtAm1lRZT6r7UKwHi4NFURN4Mt9KPvBDYv7q0aLhA0a8nqev
-SLmfyvve7wiO67rzFeyt+G99Fns8XD4DO8MH1H1Y01J9IL5W5BspzXHxOzV1H0KC2acvepKEaODx
-cs0BNOlihKqL7xm70kAq1tv3TEbsg3F0H87Bep3IDPC1CEwwT7K5G9jePWAxZ93J2vgalbtn4taQ
-OGgGztflP4YDLvb2urgZOpigRnDb88UHMAbqXoPF4MDl4jjLfT4XUeFt0AtPF+a97oK/65pFB+RE
-r6nUreMa0G789t5oPzikcM0aah0FLQbcyTc6S1dWPACUii0vktF4BnCEa6iR4HQmNDQoidXmwAQn
-sgZc5h+dzxXCeD85S+4RtRjf9ZWnVBinHZ5E+SGLHT7UdWf2/JJCTnPugdGdmfN4ZuYZGhSbHPDt
-r8VLMsevxRfkHVCO2C9uTX2D+TTP3FyBOMijbksg2Z2M0PPeyFAM93DvGDKWGXXKNbBXcwnevAk1
-uLZVqiAtG9BQzdJ6T6Q01s1Y9GbJS0DikS6XFUMTGC9TRQDMADpW7JuLz/AtnIE1fNr8zmSj9khU
-sTsbz7q2J5kW7lUiDw4mwDie5w7pAMtQ79sDSUwkBh8gjO/5XkdCpbRz5iKoLBma18FEnYHNV7QO
-oOTdJckHbyV7axkuT3GOjRUXaTL1uq0pQo2YVziFLKDwM8+5bHH1td5t8BGtXnUTUy/yGlJbbV2z
-XJH9Qy6gDpv8ys2IjiUQGzgU7CMobcugW/XOzlexBhtPbscXPddK7dQQWdVHQMI5fVpekYDEiyGx
-opqlcjhQ2yx5ryylNXBQYOWi9dgeQWuiqXyByUcur5MkowRSahCo/QT/m8NdoQAPE98nZzsOyTpN
-j6M1z/bOMb0WlEwirln7Er7CWj85PjmVMW4VfP+sDgwsokzke+yLVC8775B9PLc7/sF6m90flklw
-4ni08dzbtaZblDlmHXwgq6Jwc/7OqZwQjFBfDJNwBS87t4qaS9WiFcpRezMOFqZMLwC1vCRYB8E0
-t76uOkkOKWRCGIuLeV2I8ygCdkizjtMX2Q1cPEq/Rq4RQmmbyM1pymbFV1xv2VMU1hFgUUnt4VPe
-5IPjUYp3OgGUHmcYB1etmhVoS3KaHkT4mWR9rgO2qgMd8sP+CI43Wk33HkOuA1d8eaP58rW0lrt3
-t12pRoWsRyNurjVxHVF1ucH7r7MUtboaF/amir2W0sUylMBbQ3lsPZsXYOE6SqnG3Y8mCJh+IgZ4
-VoKgUVLDnKJ/h9MizK5vrSwiBXx4TC0kaqKRLmEnBITvjE8eOnUAQEg53aKjLw0eA3JE2AXhYDC0
-Nh6WkcVTlG9YW3+Zgjr7hy9inu/+sKzoX0TOrd/1H4dk/xzPuGJQfFFYHxjwW0zEGoSfpV5m9JsK
-Rsk3gf6qiI+19KJJx82DCf7IdRqxY1MGVMXCs80yWisMK1w5/ObWpupedi57Vuu5l6iLve3aBb4z
-app3TQoEEVZjIK7T3+oAs2fcK4DpaKuxcfvyaYwC8O3rKRTLi2Clxc3RZBJeFE6BsU6j7m/diYnw
-khHI8xYx12CEO4R9YrBZskEJDe6Zk0IPZZ0UDYvuZfEc+P1Rjny3mhTsQBwUrIOaFIiDFYVveK72
-rYSXynNofUceH48EiRitLwg/fapa9mU1EJUmpaj6a3L+lzG9cwSOBLytJ7rKPRI6ns5IMU5kQInc
-M2R2XQ48AwR1MvX/58+yGsuHv/jL3/z2Nx+W3/QIiOz8QKfYsCaxIUV2sipXiF+RTGyEnmtzX+At
-b32yZQ6XvR07wrgyw999c4/EarVH/mPt5ETprIZTet+VNXmn+I0J2KqZMCrWEvpQzn28IYgxMTgc
-KY1lwuHQtVO4+7pmPXqNhZkEnSNfDPrTOsM7xnit1ENeShlIdZYIvl1Itl3EXaeiGQLW13uKP0a9
-qOWH7p3BIG1AjLeeH3znjLeFXe3JTKwN5bUY3xGZmHUI93Yl6aG8UY/SUnbosj6u/5lMyR1BgkFo
-jAOMEiXCcgO4PzQHhOHQXCDzlLhRXiE5pxRI/UhDCuqCRIlPzwA3d1HBb+dzERyrqwkt8GvxZy6I
-uPtLlFC9xqsWwMHbWjvwWnMKTjFZnGW5JocxThBmAaGgSZRy5Qhi5tcMTWwF+Qqy2Ry084mHjjN+
-3SR+nN4dFVQUi2aPW8F06/OsgX6BRyXHAShu7hCCd3SFG+8vcWRw3HP2TDgbHEY64w==
-	]]>
-	<![CDATA[
-	zXs581p7JDomb7F7Fi5fuvF3P/zdlgN0DSynKLR+uAs8smzCgvFZywNkhwkLBnRyrzukk6weQudr
-JMbl7/sktV3jGPKdLm2W4tBr4pcl6q63uiZlLVMcTHSxB+yOWn2ac4VNrATd7EyBOaRxRX2j3DOk
-ljWwjCizfwRuP1C8UKGR+ff8GciFsVcODtDlr4ydR1pBRKKv9dN9Lb69FnTX1x0vJ4n1UvYaqzlA
-To/ntXIvbrNm0UnuXhMxt2sF/4NtiUlXEbOcCVB4QyPRUWGCQUTuErpfTFyz7M5t5kxN1mWKyWvU
-RBPof6E8MWcEyBhwc8w7YRPr27BiopA495YgfXZvbR4eca55Xn8rKeWOwCDx9tr97CIN3L2P4h8c
-8gi41eYpfs3F7d5PVA6aB/ovCwlL91E/rRM0sA7I7jHjphBv/EVOBl4BIdR9JoLloivv9jYf9SRV
-eYKyjhO9Z6K60wFP5/ySREKG5jZKk4PSgW2UyNb5t8wR3zWvlqGBReYZUZ8j23+VWA+hjWsy/fZM
-zU349kROvAEtI1mtUfNK5HuC1u57gXA+rBue6D6c3XctcpqX3/aAzDsWyKl216lazFpoaxGJrnYR
-MYsss+FASU5jLcXatioUCce16C/kS2Zek+sWo8mRxPSu3XCz6CeESBY9xnHdxZgxym4dktaDfTe6
-24t3zf47zKGyA3XDhoHopeWCJzJmUjBsY7VQBsluf0eztA5z9xsHBsYgFh1Ico/BMHl1lSBHuOhM
-emw9kSIJGiJImZgdiHsMaDMvjGmEp1mDywCBNm7eTA0Jjw1ZrkQH2oB5RvMndyd1YO4QjyfAGcTo
-19icgnzqbJ+M2W1SFVIEMteYd8K72bZLt6IS6018YEb++ED+a1mjYFP4THN7zp1n4GVU3i5wrGvm
-mgsN+Ordm8xiX9U1gT5xOX3LBtzXLq7GkpEQv3pQJPwt9IiTkVy3A6A1OD2HXEuHyE2yWOrcn4EJ
-jLUmB+q3Hjmld0qPjUX0CHxusGmOGYr/IIPnErwSOw/2WRKo+BAsZTziS+NBwmbdDEnicmRa3Aid
-SK22veQIlVqX9738mXs7tevFREH3CPuKpGuqGOXaigbnfljcJKVJlEZiaeBJgQpdAwUGBeFe2/mc
-i6eeRnsesCdPQjighka8upG8K36dm+jk+wYC+Rg9E7CRNQN1YcyIt5i4GQfSNYezThabjFIVEl+x
-0XNEG40kd5ezPEt2DJkufvgaO3cHq+hwJ02cVvN9ZgLG9uBInGPUBrztWw/PdPyrY1zjGH+nq4x+
-QEboYcESLWZMlrs7uaRsX/oCbcffSc1Hr5i/yQBzE33ZU67nJG6RAf7w1hd/x2j0Jz/V4/b/T/9l
-FrdrO3O+FKw87GPkPXEmKB9bi4Gny6IxEsW/Ju3ha8W5sdxw+H5rPMAzRaOOy9R2LIS5lY59kRuL
-Q4qPsHbHNVq2rmJCl5O441dd0rW0p8yOS++y6I7NXK4tvTVWmnVv8T6irz+Px4krOaQGnvkRO64k
-sob9CZYfF2eMIKZPslG8p7nVyLwduMf3lnx8j4DtfBOwETCdlEU65pc3V++oR9WtY0dqCh+HJN06
-T7AvArEs5ZhIvc5ImQELJSmEu1usJqHwpqtifKvetT7tvQ0pYRsB3l65lPZIVgIb9oAi+QAbmHwN
-2rEEf9c+oM4j0mHkuYCvrkAk5zOZKEoy31lxboCiZQyj6dI2AqZsCbE1gwEHlf3KMGbxZTx0cOs5
-vBCAwQIfnli7M4CCxHE9LCpVvoUix0l6jH/BddApVoexqnioM0QyjyOcJM2llOCanRmjosgQvl/f
-N8s8jngrY0ugVe5xfXTMnBhPuQuwk6kfqnM911ypY1ZiTpLaxGRkrUoESSkv38eROgR+HgnrY6cW
-CJjwZueZrGC7kjInz6lfSpYbHksKg3VNe+dIMaddIgjXZ1ROyU806pnrISQzpMR3uqg46Wylcicg
-ulqE/clok/YhauSFpcJ3Qcyf1qd26Y2CEslYYBR8YiJ/jnM02r5Gyk85kKTD6PBD96hmF2YfKSvo
-fprG6+OpqtpAoJQtYkt6XxEHcowpkRb71nyAXuJxzpTvJGx59GPPQaqbATwhZpREHLVc1nFJVERJ
-mMOY/Ia5XMwqnk6xUxE1gF62Sokug55BYx2x/inhUHJrI5HBPSOIxoA6M3cN4Y6LcE/XfVETxsMg
-AS3TZD0Nm5qfXnb8uiLrwc1N1A+GUafOEG+RxMclz6P6iGb6HYgbf20kp1uqJ/smGPhSKbFZcC7E
-ZxdKlSkAMcMIB1/sLyw+ZRnsBokCqBjUUwpYAFbAOPsusbRuNkmlA/5WfXhuyEU+QJh3x8vLNWLX
-WTfHmZK5CQh9X7P5M8mdu6YNQe5OVAgpORwZnsBgEb/JmtGZ3M59v6Y+WCL4VGJI1dxfz3ZTUGbE
-kgq78PmIVobZ2xMhL/iisn5RL8qAZTT2tg4XP6bJO69tbO87RR0GVM0gCUKy6zpTFDa0aN4feKNj
-LUoeQTzStU+0G41sLBAOHliOtV/7UWKK7iTF7mdnjDsfttB5xjiZQcFebr98bKN3b5ClBmwmbjab
-xYDHC+/rTooK44Al3sRcfggoxbTi5r2RDRS6kC2xbj8BJfvnzhwI2Cbuo7cD89bZl7OFUbP3rM4A
-Cm5EmNcVjUpWGflkXhHc8klKwkOJ16jqNTAJErYMWIyfmzWRAZYUJ0O/90V0JjPyrnsxKGJMjH8z
-k1ce9G5JFu+lgPv8lKJdCV6DPgYn6dUSVYIPKKnfmLBb/3aPUAaZF3OxXDRaXpnC6nd/Xd+8tCOf
-0SCc5HpwwqnkYzBPk4nrP25CnAQaJHnJi4jqAMhGhQuP+1bs9XLgAB/EM/a8Jc4yjlwCS0JkBpIP
-OUPpXI5zBEgITmcmj6Hae4Zu+rwxVCFC3GeaZpxkRKkMUAMWTTB2SvPWuCmCPKhBFtMxZ/epjhQw
-7yMpAr7WhC740aITx5DOAi/z9KnOmBuyPmRgGDAPQBKlR0yPIaSS+CXKRgzkXiyC5s/pnSgem0sE
-yvEAE1dx1JyKPvXpbNoUigTPeK0pCpIhCWTajYjEVEzdYLfwll1my/S4rEjsMSGczFd2o8c7lYRO
-Mfs6tvGgzBRXh0VEpC7aggj32vEJkf1liEdgwrcorP9sLk34vftO4YS435+aBSs8h1Tbe0QlqPvc
-FfPrDmyKs8DeKewR3FIt/j5trpSAyQ2fTNNFFSfJ415zYzoROC9XgHRYBrN/rO4ze0RIlWeLN3Zs
-d2OQXdqWzxZgI6uTv2W7rXs7Gw83gH9Ns4N9bmtJrYG3cSR56wA/+KTkNJ94e5bMxmNis7wU4pne
-iwtPFMuduwWZj10uPVCr60zqnUTKxA+7anysW/pN3cbv9oSqV3y3a/s+nCPmMdZcmpznqDnpbuUB
-JQmYkZbsKseY3sgRBAInnekUQG3AGk8zP80v3ohH0jaNFOeUjEKFznKPlqzHwzIcJ7t07UN3BgXF
-cjg8ZJnOpFeH6ZC5BcgEo91zXyQjEhegb0TchR73+sXuopqcNXnXZ8lRCHqD5MZUiXEG3yEugIpG
-j+fbkdm9ZvyeuMsX3ti1+00wnTooYDkRF4lvFGdJPFM2rCmSa7uYeFguNFcpOarOLsShmlkGeGEl
-e5hp5fDG+zPBNa991DUdf+1sPdr29chh3LssejbcnjNhl9WbjkdwMwBkNG4EZacESjWWDO/UnD2u
-sGlLLAwZQol3Iylt7AWWGmdYR8+VRfafEfEsrJG0XjtVpA0UB4QjePcSN0i4DpUk476Cgeb8SXNA
-eyR82NAnZswKIYEjkJikOAHC3Dt+AMonhLImfti9fB6XgwH1Q/HkkJu02guskHdexxOoTLqkEUyp
-C35vzVneLCVe6sgXZSwM8Ua6kTqjWDXMGJSsdWx939Lkp0wylDtLnjLO4rqJTmQlMZpN1lAPA1pD
-XKtj4sAGTT+O9inAb7nyPZue+kkrAYhoKU7BcrJTWYCibgzstSEcO3LdqtimKV55o4i+Vdoli0lJ
-TnRuizgVboacB1Kjt5BqzRfCw2Mn8zHDRbQNbC6SjilcnZ8KWPqq4ic0SAbdBjoQI1EYwiUF5FES
-oJAo0iMqpqXNJ7LfCcTIJJNfuuKMAKonW1tUiCYIu2IYvlMSIIE6wAnVFVQw9HGma/sIKoDVm5iw
-PABSxIZPPCUiyaaQbk7gLfdNvwbLpbPaNIuc5doIyz7fsvzra75Wp4IMzKkRIjsL0KtekanpR4RH
-eCAoyI0z80pGtijuXO+tT4OWfPCwUoqRMTm0y5QDT171fZZE6yYs6kg1/oe0hfATrnO7l/UzJWtP
-ebKVlrBrVUGSC6hH1i2mg8K90Ige2P3bzNI7ph+TaPJWGjEO6Uex0pdpjhuuIaEctUF19y9jbEuZ
-wMnwBUztkdflMF7fYxAC9N+IkN107ZgA9xNU293nBmLUKG+un5zBtWFI9KquS+jamaNdNtlyiXKZ
-cct5BppApu0Er8u3s+pGNWN25dB9/CAvbPcufR3JE3pygPqznoP1pPRjfUFnK7+2D79r1zYT7JLb
-vlRGNqgeI/W0Y8Ng5o5vhON2zZV1fjN2pH0SWa1nJqN3POgZ9ire6oySv6eCjj2yuDX3Z2Rz7zDB
-qywYxyVPunC5SJ2yOY6WeBYf6Dmvr+fHNoaOApJEgWtaPCG0c1Yp3xDAcNrXjbnhyD7pOgMwHf1h
-rtIR1Ne6c3AZAAlMb9frkynsy5MMfmwMzd9tk61EBBW/pKSe8h4p3PomhRs9UDLqRDlHFB93okHc
-bU+jNosLJCVK7Ztd0rSWJuW2QnyjCca1ebp999pGSzQoQ/B05B1KLNCyPDhDgcyY9OH4xoqh51jU
-nUpVdQC3jmX/Nu0RRxKUtFlFYIkM6TGs9WiibKFXt3ErxMucLNY7ttsKSgd4h2mzafZYqfPvvsEh
-x/xh1fHZCNyr6d8cKuRw3KBUb3QW7y2qTdZx1PhGu8MdiQ+Qc0wYHtYLVvk0fUk2r6cX63rtQIhh
-iY9oC137AAN9dUXb+6mb9nsDK2sajhaVX5AAajvesgzKefoCrPsMjBMEkESodm8nBK6RnTA6ceda
-fuKf1p8cRWVnmaMVCwDONA1pZvk9woY5uplAvuN6RSaMtmVuu/DMZAoEvzJiwsa0sj2roHWf7d4R
-GPP6gn/TelIbhl7c0XKWiwFBLUpc15R9OIuoYaI0DFdFf9kI7ciDGe+TZksPuL4h5HHW08eul+fM
-2QcgI+msQQx22MfsCMEkDARKbi/4yhYc7ytYrZenJqlPOOGqtY1kCufDxCq6+PggwvsCTy1ZaKCI
-r1YiGnsf/YFX3+kBucXAGTGt+CLqVhd0x5J27syqP3Ya9+XSa2kbPHjbBSe9P4TXi6ut6VGeTLf9
-ZdDGJQtSdIoviw/MlhSHp7BACFoftLkQYbJIZYSgE8YUjBE5JDvP29y3D67d1l2Gpw==
-	]]>
-	<![CDATA[
-	fDHTL3CRVOimHPnEoKSzRAijyTzXkH9NAOPEnrvjBK9ehJc0rzidFJSGrNn1dRZYCM/saS0wuCTQ
-ZAegh20l8DtJcjq4L+xznoXvPiIJXpKD4+fF62APxSfuBLSt75DXq/u5XIWCX22twmzYQLvskndI
-CEfaORHkHwFgel66+WsNmeHajT3WHZXnjZ27FUE7LHVe++dYRWV0Efi7KY4sHd80hW7qhrY5xMGt
-VBvq7tkZyh1uW72fJpbhfuCGNq25baiXs3imguAhoRtZdw5UZG8qKDqf0dp1/3+/hoKOVI/3kmFe
-odUMFUDOTchoj7oZEGySsrWVUE1s1HRYc6tSis70YDfRxIhHjZ+S7EVsI2ScLrz15CBnTFDhi/0d
-RsunzrGbt6+J4ot2470j6LCP/lwkuYUesRrh9px7xPI0I7stfEmow3UljALHIC60Iwh3GxUTmDsy
-jt3ZIBDfuqlEDoE9/cEhwRM8zOBkdOoii34G6+j8hp1aU7Ter6FsogCSvL6Hlipn1quCE7zTkg55
-2GvcdAkUNTrsAjtZHLuD+S6WsDjOb3ez0BIElsustN0uhlXpYnQWOIH75pCcKRAgjc3JYeXMNl80
-1a6bojqj+VLT9zjJoJaNRXVcB9NmsbAlYkHq7oPBMdhzDgqntAHXY5s4QIJqX/bnHjlA7kO9cYqe
-e1/3IE+J/0nkm9sxQezeOLVXBvWo7MQMW3xiUwOoFNg3d8VYTsnYqYr1coJXethItjrjIxgg8du8
-DaTg+X4zFwRP5+7cE3agOpeveu2cQVuRn1w1al9HDd7khbR6L+c+lWI+ug5dzomok89Nfwifsaal
-Yu8JGYFMOIv0SZvnNjvueumzmwe5tdT58k2U6Snz0SJNz8i7sqEQhE/pUuBEb87T+gpjxfJZAXhh
-z0qHvmtKafg4KYHPnaLEw+nlOS/idj283PNx7Dnj7aJHykR6Syc9Hr+HpEm35UdNfoKEszu1t82/
-u1qQzy8icWp5Mq7DBkh993Yb9NSxS/zWZNRdOuJRiaVODdaJZmwcBMNiy3VE6KEz9cyi4YRHcyeb
-hwH2OALLcvPdZOAiGX8lAY4jKPcG18RIHITCnVqPMqUTRvVAm76lBQ71h9JsZeqrLFmVpb62uzT7
-NKxO7x5i1DgYKS05kxfZizvbod9I0496EuldsZQkdebGylB+wd4W817goZsIn/WDl4VcnSpYSyJw
-OrRSzNBhHo98Ok43QcsEINl24ZqeSrdUaXElNG2p1gdwgGegQxfJafgVqc5/a8CSlpn4CaGzGHZ0
-0/m3bVs+cJq5NS/7hsgnsgv9uUHFthRpCepK2JfpMbO8BtzuLrO/RUGGzNbZ0maLOvkhFGTA+8X+
-tcOOkc0QwyZbALkM6WcayGI81ofhSNjp9LRVIaaqpweK8RWJqhVndKNRe9i4RChW79a0ioiRgy8f
-vggL3zEB82IUR5aXJFIbZmBYewJAhms6fVbF6ipksA+/SUESLs/RApRSU+gUv2cfVIgitynh5GAg
-N1S5DJZ/PwZqdgI5V8Wzu0SlcHE+0KOQ2C1t2LvZ8iRg2COy3u3gA3ebJKPBKW0+yxTy+TgdbeM+
-TAOcT+eS3lV/1yik2/E4bVvncadyMBteNye5IqwgoU4DqdY1utG1ksN+xwrbWFGA0xybIzSTr9Ct
-gZKk1aXo0GKFOYYkzsuP6ht0RsG7Zczem6Ccz2bPuRUU1TNHp90ecOZmna+0KVOQafndyydytZ6r
-TGyAeG37n1fvmRplFKaW6IqLreNxpRmphg8vSukDo+b6Tsyk9jZLAizstBfWo77n8iOcEAyWRnq3
-xF8RZOmwYoJgEr/o6NC5w3QmJ6nkt9MEdSMRneauadQVeeU6AlvF9QU61sLJrEIVKgv2YiYgPNIy
-pGSraHeDacKc2Mihp4QNcVOkYvjxZDjC4oXEdI90MEUzYVcKSbdARupi2gAWJViRWF+S6yGDgHoA
-1Qu2EO4vOcaTLdG+Ndbum1hcarwNTlFhUIoDqIhRo0p7FSurHfGjc/c/g2dy7Iqu2hAiM+V4UnIK
-qwi0JH4ISVww7lZi8XqMJPoHq7mwp7596LeiaFylu45XU295kcp3Cm+yPbJZVCtNgC6eI8+tbkW6
-7wDwMpv/ynO0CxnvAv+7ZUtWYfgWnM5tc4VJlyMUCx3gO7wvJ/9Ir70w16gJcEDhGKkUUCCo22wv
-R3vfzAI9CQAeBfSLLcSo18gRmlf4fS+A5O6NkR+Pts61D8/D42s5gUw8gAaOXyzU42OvNUN8aVQ3
-AyyCdXwYV4NoMcHbxha/YeSOso7VKvaLY1RSVUThDCJXy6sQPmF6SLe/PRUnK9FI6C1f7KlKHYq3
-WY8QKGDsDang2kHCsVV6rg1qxGiJPWMGDKMxWHGvgLQcyWJR+LXJnIQm8mWThCAhiKzEJL3tE4nZ
-1mf5Tk63QIwXMCLElIyIiSH5pc47I7Zz8wC4QtifrymyM/63scPRk3sKsn0+newajNwU0cmA2PK5
-jU1OIOhxESAEAcaVKaDTkc6z/4SLO6M88IKvZzKaHYIpYiTvhTIgjyLYc4O9jj1THH/UXMmzS/BB
-4d4CmRAfAqPkwzYwiJSJNyXGult2CNuX9BuhUZ876ETG4LyCG7y2wJAnJJka8472jzlzgnF4Kv/x
-AigyCMqxGYWs+ggtjHMvTdAVt7Ceuju9XbtAFiSSEJ8XQMmming62+JSKKjiH44tbgtdOVlpUBND
-7+wy6d0MD6LDBNvj3HXXJBetAgWbBnhbh/2igkigMfcNs4KlgnAyC0h+4cPBcwGUosymWuRZouxh
-cxVO7Eh9EHfPc+/NqCMplj2yGUNwt85NeMLSxpArgGNLLABFdcNf6+6YLLhkQ2a1DtAAreIdj6Yp
-qnW1PEG9QfTLbRrX7xaI9UJ93W6yImvvZC7PR57Ku4pOwCOvypCG8kWc6iA5JZBEYatjszm/U/7D
-sMJBnXuhupLI17NnoSiaVKJ/NZ4+q4k6cyvkHc/8xGU2/rg2aQU8sXpbx5X6+kdvV/Eqv22ivBIh
-jb5/s80ZQR8V5R0S+ZZLjfodPCCU/+Cg4YjPagjhNPl+i1Ofudypq+NMTTUzPqdiuUfZ/mHdjaDv
-O+IPjIhO8E1l+TJm7dv3eUpQr0+3W5IOR5IHyQ7K8OvPG06ZQfzMGQRFeqfKigFrc+9AjYX4cKVI
-F1/bblvRNKeuuD6JWM0DRy04npdpsvVJrZq9As51mbSNj4wtM4ADB6wfDe9sQ4+pmFMSYm8aYooa
-tW/7ZSuwapieFmci1loQNuxpc8IzgSQ2rDAXWBUVaLEzqhJierZwGeZI/ZAXTc6G5gjN14hVxd3u
-gFish5wBrfV7/14HZH4F6tfrSPQwK2X0MZInRDpWUlmwYdsi10CGsVBiAV7CBaoa8hyw2OgtKwMG
-VMlxUpxi0QWOWrVg1XjiHUEKepTQbTo2K33TXkWlZttt74lyJGdjdMzgkNro/Xl5OhBkK66NwjqR
-SkpO4wpgOuJ5vVsH3Shrz2oQG/1Mlk29DubctElQ4DgZ2PbRHom7CKAAYE5ZNy3zrhFgozg2ywIK
-5F3P6bYdEfaP77xvy045ABlO3jm5Rddujz22hnXH/OoHi7S6vaxnX+sJRZgbalycbuAQFtPwaFj0
-dgbEbuDQ3LKUny6cU2RpuPCbDvKykb4S0k0/c+pc+u3MJEuOYno2AvCEZNc5+ZA6R0YljSOppnV1
-DsYuXEoL03cvT29dm0CTNix2sbVN9T5ny0+TusYi+L33ljKmoNENejYO1ELIFAlQAmUyF3LpL8tR
-PSJYCHFT/DepYKidnAFz03teum4Ci3LuirKg2yZBQJwnpRhqIuxvwFp85fCkGGS4hZElm9XvXeWq
-sdeAl0jlUfQ9RcL1NOskxpF8oAYNGg4jCZl+pDsxmjiXW7NtDC25KpxRREOIcu5ozBGTYfuOb3el
-qqI1K105L8qKzjCDZMabT5Zh/bxKnQLdZiqaC6rRUizc4fbpQMGO/H7omZjCHtaQ1ZTDA7kaOnqI
-vISOUnnuaRjyUqVe2gqlkhx/6d9GdFs5GwOJh+ukn5o8FjTSLhRmH767XvsU6tQAuuyZCX6sDK8i
-Tc9INV62ETLCJwTdaeVsFGLzaxnNtia0B1p37E73VDFbmB/Ow4h4vgnff5Zs1rr4d7/MRT/5z7JV
-ZBVyJdP304F/9/bC87NPQ3v+Ix+un3345J3+kU+3zz7dcQLffvrfffiL//6X/9svfvXLv/39r//r
-3/6wFVz/y//967/+/d/8+9/99r/++odf/eVvPv7Nb3+3JWfvrV37D130H371469+/Ktf/e5Xf/3v
-f//db//2N79/o2v7T7j+l7//m+9++O3/+7e/+9UfTSHayyxSQU3msTlE6kIHzFv/MXpRGmhrj+Sj
-DqMgmFRE/TuBFaAVaIcA4Ug5cVJR6Vr7sO8WxxTWnrwjpwn17QcyQ7XIWNEszib0GFpoP8Zmg9an
-WybqVfgIRfr+NBJd0X1VW0tLxZnUrwdKRGilYwdk+SA4BOWv/4CAQdBVI7Bhzgnxzk9yTtEFYpyz
-qI3atk6WGI4aVHWUumA8kvELxOoORN9u65O0HsUYKxdDcEKQHvtU3U3t85tIZ1V1uwPMRSUuNQ8x
-31fE/Iz947pfPxf86X9s0n+pTfopm9rfZlP7zuk35VVs7wD4nWxH3+pnWGqFayjl6g5AoICfsYw3
-bBtjrrlTrqd6DOzrSx2+JvfttI5yKNNqtfoU8avnXEqKjBz4RbWmVL8pOx0hUGwyrDJ/lOvpmDr8
-BtOB6FRSN4BbclnuxUsmDYQHwL/01HbFFBwqJHL+v9jrNTk09o0NAjAlZG/GE9pbDF0HHBkM0XNA
-aCNxBXfOHQwiGKfW9IO18X28iT7cPerabaKIfIL2R2ehbL0LKz1XHBE4c4pJg/8dksCwDGZtlLAc
-5jfXZE3tlbZAqJvwD9N6utFkM1NuIA05bPo7dhdsmofQ0ZvqYfJWJNNOJ8P8pnCasZE/y3+UJIBn
-LzqveG9J2mwaXcGRsjZr3CNfe+sO4/1aDVIK0KAMfkt4F6VtXLrJnqbPs8WhGbFJl4VQ6yu2gchl
-NfYbC7e+E3F9xuY4YvW0ZsXcm1+1260zkonCMt5XNAvbk4Nq5nYQMaz6tqQmockwkncrp3lixBnb
-Ie2GHTmSObAJVHMkPjq3SSiQ67ZxJl85c92Z571gNv7khs70q/noTdoUl2cj+e3T3ld+zKwPI832
-fVw2FRMtomTw21mdZ9optieCZsqpevAObDRxnUlJ8abscAWrNEXR8PBJTxDMWB1Fjtn3iyEYkfow
-7UP+NjB4lk4ATmM+XOnxpGtHxJWV/9CnHWmy7uIdG4Q32KfT3PwFGUKoIllXE05nTSyrifjOxkuq
-0hMqS869+4O2ICrFA3haM1FKTz1oblIdaf/OsU+yw417HiEI26GiRRNRjfplycjNpA==
-	]]>
-	<![CDATA[
-	EXdSK/KjzeIpOK1yhIJtLyOy4ctktKhRvoilgzUg/566tWQmFF8v1UnbVJPImo297Jt1/xq+CNI6
-QvvlF4Sa8xpT1eO1nm2TtlOVTuuzki5abAhRy9FTGtlOT0sumXBNGnONTB65rvQCVIaDStgl1ViB
-p2KPbANf5bGaWJcoNPEKTOnif3meqJNgnhyzNygr2yJzl4NwyqqbksK9YYS3qSvGpIhunDOrRQhJ
-t3h6n2mPXsTxta32SeN5RcT0Kk3r76Ou5Q4/fnkIfv/ni0lm/ZO9jPGvxMv4MhQAxqZu0cYRwNCw
-2cAQZE14aRkHdrpMNtN04Lmviw2L29nZdXOGU9QMbTUmLG0j7a4GEEHD3XeRvSYJaRcOMgqn2k7o
-nJw5x5XyQZ7WeN+o4Qp3WzweZQYQbWZL6WBwhrwcSA/dktbmSNhAopliplBtDk/5cUYJY+7SbWsh
-2mGlZR38Gd3pf0Pr65MXO956sXWjFkFLcoj96NBx3Q4FbF0jv4ic531srDeJCLD70eokidZRAqol
-XApQWH644qLikCFVKqz82yTeCcDS1PtIdwZ8uFryEbOkrJ9TguyWCwhMSJIN8KZ2xBOUT3huEUfV
-eq2jzjwQKZn20LKttKdliDy8mQK36SC6RnOT55GLiKjQYD2i/lat9pd0XgCihZNQxRVo4HMS+EAz
-ypOlhQgB0BWF+bIjzvYK+qXrBxpteDDenntayeLb6ZXrQ+a8mLeuW74eAsO1FXxR84IPomr+Pt6A
-LpS5JbYqtUfQhC26qNL0kUyxe8lWkmnXIzJJdHtETB8n5C4pHCi3f4fofIWJOa2s4UjIkOI2ScuT
-M+UVNzXjLvOqwnm67JTAAkJL71vBESqa0qXwfZU2glAL9hnORjnDNDlyy32TCdLMmPxciT/PQAip
-NbrloacAh0VdR7o4nxEcgJOn/AhOyhGhl9qDQKA7C6kSFHeqpLUZsSYVEk3BPpTo+nBqwQ3eJXqq
-sMGQ0BGZK9X6ccGAOYBdyMthpgZIobkFeMqjt/f0507Rbt6R47rib4zMg6V1UpiwMbW7M2n+Yims
-+AkbOnBRSWqHItcdJRR/JapBI80/5iaDGDMZ/Cn1UtSaUAVuUvbbOkPqjuI9GFLMHc8JQGmKzIjz
-nQK3FQaQs10DX5xbGnXac9Sf1j1Wdm4qJ6KA1tyyo7qZT+9hPXE1SJq6sao0zr1Ao0mGK0exDogD
-GBnCAIoWACt4raxdXpX0c3qqqCfHFYTn6EHViOO6v66tgvoAOSzEXJxjc7Omrr0oYXHj3Clocknc
-M4RCJuW5QJYJtwlJgxojFWCYjBTtKA82W+wlF+hUuQpnSc6et0R4A+QX3oe0zihMnoegIMWBbpUd
-1zvwbVkYp9pDqRDaNwCuKQ6Vyb3PrQsAZyfqF+aqfQ1NOKFMADj2UWZgBVE5UpfAGohlcRiGLCXW
-4NwCsuqiZOEav7K4r022F3/NE501CCKMlewTXWX40Zglphk0GrvMworsqNON6HYLeMZ4VFtyZb6w
-S8V2Caevebqbd3rvuh4giVz9KwLPqRxIdqbosqH/lovktteoWGyDhO1EDg5TWWyhBRTs3lWUomyZ
-dZicENRVcI36xvjI7QeRjPrk6ClC6YRTmTm3duMdsQYbTfC1x9OnBj22SCrh/retBSDEi60CqFzi
-7ymwAuUylsW1G3e03R9+RVZbRxlQsSa2JWATipVGO6cyeDNFHprUUH/vRzqJ0FGk7/IRjHcP/eL3
-lR6hgiHqAsyPx/eZ+nsbGzk9BVvTnCeSbWWD60DtgLmMtrB9SdbSASEXkmUdYc1QFrqEPpBcEWWw
-uwLUEmoOVM4o7iHw4RrWD5CbOeO9xFMYYYsnFrtDGsW9iNdS0pL4pHHd2JyQpvZ8mrbgtZTIIdD7
-NF7LFVsFJLGZrsKcD7AGge3gHdU54i6dxvB6UCT1aDvQDHuPuDj4BfcecLrqFvXBD6P2pTNnnIjL
-1pUzaBDuba8ot2i3YflOb0+FRijY2GY9QkURaiqlQvfuw5k9b/G/DFWOclpVAXFkoC2TyS9ZFH15
-vo6vJ4zPReqocBOiIsA33xlQuuULZ/Q98dr13ESXM/WRHzeIu15DV8zlRjJya73R8oHqnI3keG/H
-A9auQhcQgyQ2IveKBA7YMhYijLSju4musVnlLUgnOKIoN4w7QuQkwEgZKFpd3R3CixMuXVswn7Jn
-j/qeRZmuuKkmS5QBmiTHLndIz21KGtczbpXWWHDzEem/HOx4wld+CoUzdCU40o/oNI20KVAckTMC
-9RpEvGi68B7Q5ettmNJqvCn234oam9n2c0MgGTtElD9QMInQPWziq7tNd09BVvyt8j+Yd/EJJLfG
-NTZH0U/Xfc4xsnFuUHv6vZmMIVXSfUkrIetwhM3chIs5co+9j+txlz0mN/GK9eOblL6DXKROKCM1
-dA0/bli0noXznf84LglmDzADpPO8g07QL/vOSrLE4xdZayNExOUnhGurbs9LEtHlWd4+HsGXuWyo
-CTJsp/7wCwxXcNBAinU8ATFsjPYLpEzY2i8jKaEXGydNk0fFaMjOySmwqboVhdFA4l4kJmI2TAvL
-XmuCspuSuV69q/vrlAKBMOw+VIWI0ZwHp4NEmuGbOXtyb9geTW/ZomvADu1/NCP4o9D9KYsf3R7O
-q1rTTCyyFi+QNmVd2NRPSjcV09s+HvYZfHmE9NeBOMJ+sRsms9jSM4bDoAEbWX/rcr3Q9itATfKu
-ULVcx/P2NC3B2NoTgL9rWlXe6WPpNUnaUmI58plUWmewK6hjerPX+Tg3/YxgHqghe+v2LY0iPPOq
-QtcV+gKxszsRkUs11k/7w/lhbE0tarWmLQHIyh1TtS14lIe0i6QER6DieuSLiB8AM1xPPh2icBXb
-DLbJLKZy/pGQkp32YlOHNd/XszmQ0uuy1FCjllKLbg6CDQifYadfVKa9bZFwAhV/uTfZal30YLUY
-IrD+gaHgsGwCun4DP12whcol/GlHU3QIb4Aa84GfqvMXfSQxQ6pN2W15E9ru80FlEgtYwka7LmJW
-Q+jefW5V+pmgwWtOU3E8j57CvUsvPvHINK3tqN662tjOm2hvW5GcucbumVcNjsnZxo23cFRyc7P4
-ogELPverR8VKwpt8sUMbLvAIxP5F+rs2bewWHSwGG1qADnT9P4pwfaQNCkvKWpmpiGBTncPKuRXC
-/wV+IAMhQ15nvETz95YlKaYZIrC+hWUra31kIDoNNK2dm6jhG3cf4bD0c1MD07ndXSIPmt0ovzjs
-jrqdEpPdfAtnPF6Wysk4wzKjyCwlHcXuI0FuppP77Md+S+apqh5wiKjqhVhUwgcOA3+rTXDsY2gk
-llMmoxLlRWFozHjc4XVc5Dqibmyj15eojihGbd7rhacPeq1uEj6prEjwRkSvGgefNp3lQdprXzaJ
-0fgUawH1FJZF2ZGfUthUz1PmbwS+6BzL4qiJ/qNQTbW4eAi9ttQV1r8t/1RuylVWsbP1DjrwEAlr
-4m9ns5Uemfv43by1l6cSDXQuVfV0xjmtafSRmlHfpFtKzlb8hN5paKZeVvFk84QluOi7NVskyF7K
-a8PjZnERzNaV/48dR02gyoO/04swJ7ZH3/l47Pj95stxw2hEoYNgf3bm/r5fHYtTivG5a3t269ze
-xxC6WuOsetBfKQoxtkcGKqD6SOmSfKdZIWW8YNzPI50AGJllj7ShWhFlcI9RMY6HXAmwRmc8DVF/
-flPZvoeMY64DKTDO7aHMlA2BN2bEd/qF3/aeLr39p/t2kF7xU7VFFDVs0Dt55e0mtmiceWyXa3tU
-5xXn+SVowYgKHB6YTPAjYxCiC7XP1NcijZ4L1eV3Id9aoNNIu8FsvwQ40XpG4CS2+5F/SsWP4qSB
-Y5uxyC+CFBOAZ+Ea5Y1cBbtbggs4Ba1H2VhqDPh1mM06BfJLym/1XTz2+bYNWkmShz2phOOPHABU
-sdyJB6m6bnO3bEDV78bzgHDsit76qJ86MCrRiKhrrKU4GQvFASX7fqVtgLTQvmPx4D+N3cEDYy6F
-/nqQJLWlB7YnYWj29kA+7QcWvicNHMiDwBsSD0eGfsR7OVKXl5t/pN1UbLfSlS1NxCQ5gJePooJ6
-l5opspvkF8+n9L/F0g3Ynpr+6TNdPackhX9VJKmqG06MGbF29LtITb2M154BU+GOnKgUOuaG3Au6
-wNOTDsa+vnrSqOYCjT45lzsHNck/eQ3KQZPosgnmPrqvIU5YmkvgIyNoYwsDQ/gIjadLos3IVggV
-SdsdxOcfkInZQNOCD8JDYBEZsAgnQIhsm5WPU+xdQXChjkndQd6GUqMtEvETwr7wiaZ8crFDHH4T
-ZMuTM+4w/xtIhd1QVAEV9T22Nk7uc7+0FsFVKTYsHbHoysISBYyA0zfOQfpLk0dhRqZIN5kBEe2y
-/7H9CqSUe9Lvj+AI66E/2p1YdLQY4LcpT3x5gwaH65q6/RUUja90umpzLwfFbdAjqUJeIIvP5AnH
-BhTpGdtnrQWTc7Ig+UAm+ZU7IX1U4klP9MDXyjHkxaPIip5v823BFktC8qFW4V8j1o3csnR0+ywU
-NeZkH748uq7OgkeNrJvb8sjuyERU0vq90fia8vuInk3yzEGpEpkAm+B9xgE0z73ba8Rb4kZ2bvbZ
-3YiFd0s4xX97QRurlLQ7TXZLZfsyd4o68izsigmprhhwtxGmkzApv0rXhjueNUsRBEg0hkjuQMwo
-Zfc/esn6PrL4tyqOKJUapM6MMP6L6rRAo3jsLP/yQH8FoYrME7t2lUfO4rn0SiNIFqkdhB26B2Te
-Y/f1ekn6PKn140n3ld0TlTeSd0Q2fC23e9MhdEMUUdm79VU26FTdv+xCovJG9DVtuxWAOtoOWbr6
-KChpi+aQNa7b/tRI+J1n9C5Vux0RWTqT4+LS13dDZuc6sv9aGgjjkZ+2v9hCqw6JTnDI8rJJfjtj
-Yt98MXZopvZAmW2fz9SDUgZkv8t0tGjYS+pzEgyd3eQIWQQlKlxUEiMLiHWMpoZYIt/pTHnA13zu
-hRt5IJdUv5+lGxKZ1o22hEoECxbUwA5gh2WX67MGkwK3CXB4CsduPwabpMzNcAzCjgWdrXF/Gw10
-vkyFeTbHTJnl2FiN6O9n5YpzJHquaf54bBybsXBkiq9NI7s3n5K787ggutzspLy2Gr61Arn0bpib
-rqR/YYNYnAkK2MNfe3qvyTtCTBQbacoFqipJWeLgbalUq/b0i04Q5o0QWRWnzbOb0WNXRuVFFXg9
-WqybiRuA49QRgJzmJL6if2oTJfYER0x99BaFnkkBQ3nG1hMEk1ZjAI4eu80YI26QTISa/JwWZqZZ
-cYmH1sht6a3vrUvHgSsNqakjCxwaUK2xZfQ2VCVs7NbWjIho4LS0xJr3ZWjIKdsgJue8JtNHhml6
-yo5IHgLb7M8myLkLoyCK6WTB96xSk9UgUOBhZBSzCmiWmLIhUUVW8t4NzXVOyMOQbg==
-	]]>
-	<![CDATA[
-	8HfWG98V3igHXCqrWejSVKpiOy39ipTlkWz+/h2ZlXgX+I3cE79WS6bGHli6QlemL+VwW2aRzkPb
-lBrs9dRGxiFyJHAC7GCfT7N3ky33lqLkt6/dG/tVx0nyQrzJOXcbKQyiDcP8vA3ek59OA73k6ezi
-ppb89YhtUhwCp8F7ai3gq2aebm71OSLO4XoVjq2q1kbR2Imnh9dh4Q+muyo8ZSvzmRF0n6OSYqmX
-6oUwrzTmUMG7hxCKOIMP1Ev08bquSKfFW4lMhgqOGB7w5UAeXvoW6elHehmqvVrEsjFh+6Jb1Aaf
-UReMOoa1ybfhxnu2eisbPN3tTZ3SESsjLK3dvcYXcaQ4MHjteF2S/utuNC94Dm/njlqnqBBWZXIZ
-6MI1K907TXZGOMESDZxF/akeXVeMh/T260oySX1ihcSuHm5fqkj41mc2UdQ3SHoIoaf7gtJE1ITU
-+qCSdNWn/vTcvt2XpwK/2SZXUiVPW9eXqPfnB+9HFG+aAX4sAat8qkU+d/spbJNNh/aN4ptERfaw
-L+f22XJ043ONI6e+ZJ+XqO2f7xPb3r74n2c13XsZfQ7B86TRlpzXhuBJPMKkE0SyZlrtwg/yN/nh
-tTfUWpop/c7kxGWFWoKdEQuT8i33dcNaFI7XXSHTpIYioCrcs2pCvBmaHyPBsBhu9Szu1HyuZIh7
-3xTedXMCaFDEkXpANRjhql4D/kthWuA4xHBpvued7ru9BANHsmw98pmtnBQXWVTagJlWPcdT52qk
-Ve14T1bA2gBN2EYSfiwOYksUR4Y6Kh6etkvUq3pp8sHKh6cysi5i06JmQ23E4v2Wi+o9ihlPNazv
-fvTrtEL9dJizECIlGQxbCoQkQkcUFIggpwc+cshEOhxFnLfk5MSlkFeG8v7USGrEPQRNmP0mgbM+
-+D2C8zdUQPsnFSEG4ivgnyEwSaqa/NTc+plIpEbEBkwuHJp6RpmfAjAUBWr7My2E5x2V0zTCosyD
-FaatHvnae2s71RZXULGD/lxR0mpuudmq+gtHu3daArgCS9QmAVHMPkKq1qb0M8L5Un9h1iFYDs6q
-h1qt+isCg5vdfexE4ind27+VAKCWqh7UsevgqAtueTijDynF5uB1rLotZL+1/EinMED/JsCleSuH
-fAhMMYQlPEUVg7+PtKjZrc2Qp+rpIo0rSbREXYLiOc4/XWCuGkBfpDF3GcGuPXdPDwWr6smU9/AO
-iHnbbrazO3eBwpm7WezlFQJOBLGCJONYSY+xO51XZw+Yrm5mgYoGU9TJbas4K/kRPU3zG26KvBNV
-yiEwi2opFP88w3HpQ4FwVeockN9lY0WPOLpCCWSgWnEmfTCDGDqTg8RVRisCApLddjaBi8wx5Ur6
-FTahLOAl5pU40R9TBvyqO+7a8IhrJBFzhUeFMI8Q9+OOL0fnF/IjHHOd4lW7diM6Uozp4wYuytzM
-Q/D63qE60yOhtutM10cHZvKRrz0HAYs2E2dtrxUBZiX4LOXF0yix9sCfFME6ArL9yC+psikOtd+5
-YzcDn8FRFZpb8rVGx15U0gjGiReOqyCRcTmwwXalkYm393pR5Mh4BNIidkBseUbyFvzNUnQebgmH
-7YpOhrNFLtCpKdO2JCV4CKDApeR8tq5pdrRGIuwa+oGAiTNEPQBuYw+ANtkvJri+9tKzKOOSMYJV
-I7Xam9h8Fr4PwQVNW0iV2BsxetAtsqpz94EG2lPBQV5xOWqkcJ7mR7YAUfQceOGZFh8H5Uw3CjC1
-rnYU+0RsQE08xsdnmrUOhIWNSdEbi54asNu2G5GncYJaWfZNBYagLT1DxfYAtRn5jIhZ4Np3z2mp
-+Vh3YNPBK6oKtmibiW80Jyo40LAHaUESImDC3DbEoogVEnynQ9WxbSlEzSAHoZQjqQ3aloGhluMT
-wR/pcPJdep3Ujf9WcvZO7zp/aIRaanWBtN2Vk0E4jglk69zVErNPZyKinhEdoh1bG9sOpZHaKXCS
-0wqPkFeOc40TwXwKbB5bbgJ4t/0xom0abGyPTpXqp5fwUAG7eQ7qp0CRVVRFjq5ZyE/Xlx7dpOtO
-I0hnWBYjrjZilN+rpErCl6hTFCeBAL572Df22iXtZoSps8CP2uZGoiOB92EL8hXwbJpsTfvqFZoL
-GppJDuNAnVvwW41KhNWKwLQR/C0+TCvRq5BKq0eV1AiSpAih4HPJdYQlC+eSr60jLtYdQbrOBp+B
-MB1gaXDmVB/nbGCm+u5+iDPXokSBxA3nKMSecqEnQixNign/1M4UlF/vtt1G30XH/MQ9lV6C1pBS
-bwwcat3eoftmZCsnKhB6uYFh/qULwZXzx7ZNXjAC9kzHwfQpUAQAr0zBM/wZpO34RPoF4K3yWdLv
-9903lnGtcL4VQqnARbJwvMD7KPuaUqhYlQ0XwuuB9GFvaCqtukFes0W7HblO20cTmPsdJJ2GCc6N
-mcRBPNRWyRUyGpWCO/IroTMcG9LFd5yBHKuX8DGxA4EfgAhpmCIdDz9zCbJiW6F4Y4d2ISoBhp7e
-i3xgB1C1GrYRDzbTPrl0khzn80ufBS5/RvJf/8dLHRyk7/7RWgcGnf9orYMGEvOPfLq/UUa4/+h9
-j88+Pdgs/1Z0FL6Kv5WIM46EBz/uQftWyuARsHwlAB41xgOTIOCQddk2YDWB7Uh01mWo7Q7zhG9t
-Swsvk1hszX2nARI4Hk5xwEBjYy/V5SEjVfqDCqBOfUTby8RENIZ6zh2CPsJBUoU2RBsBQFwbFBLB
-49Q55pmzCZ53SR/P5++6e1M7EfIwz7hJnPO3bdPOiBOtrUxpSk/kyGl8pzXrurWRBPJ9pzEHJPDq
-0XfuVvRXwohdWRGHbLSb8xTHzbKAKWVAdG3LlOlF7gn4c4mZ/I8N/v+rDf6aLZvHm/wWis4kgQa6
-hg0gCBrMB2fL3BX4GXBfeqJVMyOscpum9bGD5rUdSOtvWXwh1WS/bexLvmkKL60j7SC7DWqvR7Fr
-Rq73EpVsIEDCitR/P9JVJI3Qrx3wwLQkVYA6HQJuYkKmTDC7xovIIxEAFazfd7pMBhUvMZIcPt62
-rCO9GbnMVR6SILXvCXFFPJDOAW0OLYCKCi2jYF8R4ILGezo5GI9ZIrGM3q6EcF1KG9hsNyyeCrjV
-U7o0rEyx0kd0H/gECVmxv7fRZYSjjydpa7w5ZKRpHLgLIMX8DVESK4E/iDxxswUd930F+2pdgeCO
-wNzeuNXgHreNx0pf93a+3qbwijUVJQlt24kjxk2AfKZ+s/wcph8fEbzubRbSnopnwE1Q8/DRSKap
-oO0bFqD1KCUa66kaf/XI6J27iQdw4xmLeqSQY9MCybkGhYh43OqNix1VrxkjSYIna9I8e/q6IVwD
-/AT9WgTqUAMCjVQx1qRRLhOAx9a+G3EOx5WKFn/Dex+PtOBmE44r2YyP3xian46EmjrI5/unHSVG
-Ei78PT1/HLn2yMwnYG24G7fe+k935zvWTbhXos1hxfj2xAdvIOZY5cM7EAK0gcjgqbkopGo+YmN0
-jrgDkCqqd13R76PIUUNJVzwV2TAYaB6m44FdK0/SSioRr0ttpO02q5Wa3jtUEGZ5i47bEPy2m638
-+I1qofMOazrpdsg2/Ikho7/l/eCJhcDb0X15RqTCr2m04iZsu6E9HhM4E1gE89rwfFH5wKIpr7Jy
-WUv0jKGlNHBxlgiBXhWScLVgC3GjmM2rB/rQdxNVEWLV6oFRqdVVzGXfbGCqUfBhCJM2ydqFLUDq
-KceCoKbU1GORVfkG5DaNuTuoHpbMOTbIXSwmZwcwIUqz3CxLCBGJq4b1STUrGe1r998ed/ys66F2
-7rZ44MeQcrG/X3+QgDP0hYH79cM3z1QR4cPWRYaU8gDfQfbg2q2xOcHS3fQ6uCXZD3z4TuJfsWIq
-g6r8y9eufjjsGUZYFtfTMWBGs5wdwDHmN+SK3WzLPo/Fk0/dK/627TYK91PeuyUfJ85iHmL63ARA
-4HU+IbXBeYBZhKSjdJ/GSeW9izehqCmWlXz1sF395G8hzbzKUve7l83OyyYpKaiC1XJH0PXCmpXJ
-akntGqYSvJcrPCzlokwq2H+ckjqnCeXzq+33ojA4kq8AvKhjkxGkhIQ0IMCJkvpxtsiZBgsybQx3
-s96PLAT2lApnR7pnfvcNd4I6Qpg4xfwGCWH+lrBXSfDo/W8iCmmT1KM9yfvOFPQtfE6ihbRx37nc
-j988GZ220atccYd62+uRPAyl/Wz0kSvs7OVIsUTV5/7AYYrIqrumZM5c8Jlx+VnC8j9QCq9BAWF0
-wCLZdnikutjueBS8bkA3bWfHkKQicciknltDBhgjGWfCKg7Ta/dOp6knIDg6bZbIQTxxCOuRKoCw
-2imJRmcDrAwMYU5+eBz0jNhNcoTQsmQ5CaoKu6Jthe1Md7WUHTYR7Xff4yQ435wEiCPnrGdtdU7F
-U4nOrqSUfJCTyJSc66PveZ4tKb7yqW8XJyGJS7BjRKinSrwRBbUxaN2d0/w73bfUE9lDmGl6dl37
-M1cnpd12XxGkjY/0nmsyIhQURFNFkrltPHKM0pvZnHFRdFdfHCW/an8Y3Rzkp8XRk9XEBNsWQz5q
-fVwjRDhlSxb1zaeNMuwUU6wUnIpfW+grrxhp9cDV6utBmdjzjCcjRTtqNLRBkDLrkS+zOXKctWZv
-tSP5z7IXCQ2D0pKaSkpJN86SQoNDa5p+cMimtfms/djApdh0UlnwspsUbZzqx2/SieiuqUKe+SWr
-V0ApfR2AY0kRAEIctrFmSKi47dnv3K/UGoMmBMsYoNRIOpjaaS6SXqmIsi1powJNcla28xWUF0Ld
-daYbxNhg1hGAuFMrE59C5Uz3WzmPLJ6WoEt4tl3PLKL6DvGA0UJLS5QRqHUR0BaJ+iPwUjoRsWxB
-FdSIWCsx5XqyirZ3A0vwyiQqXcXsQkU5UnS3oMO6jepKz8ylD7AuFBgnDjQ7vZBTpwWR/ZfZIUQ+
-qNOka5GbCCSD0ry4pPZ0or7SI/bjVkz/rhFhI3ZrqnM99OBTEYGjRDSOGk0ZYYkK1M0eYQgitkOd
-HgoMpZ64xVgYiHBGy2FvPxv74bQ06v7oRWq2lQ1OPc0KtRFeeoka+2cG5z270vNbJpCadpvjwY47
-9ClgxrD/p9WE4XxNhOtR5FVKD+tW+u4V35+meQR6difZIfttt/JsMZNwVN3eyXq/bTxekLthqwqb
-uOn6Rm8imbI0nJJxfG89BbgoVv3OhMd1u6yU/SBzEr/jizI3oGrJZDRKTHTNpVTnMW8/nEjo1wCd
-aZrTrvQ7Ep5NjE/pfLnuKXKhgHynO4wN/HIaW4M8tcFT/8Fy6+k+o8KtK5kKWA+4mou0MWBZOMMN
-T3gZZVdSqXDHFqjDlZREBDPEu9wlOQp+GTNHWqPN19V7bqAf0iRsoVOV/pqO5wQA57m7G3jKFE2i
-RdL7eo18ztTf43Xx/6ccvbCwp945D2AhpYUMqEK1ajo4TXsSlFBBSSsHLLhoMLz2BQ==
-	]]>
-	<![CDATA[
-	gz1pN93DS4zSmW6L7uqyROCL3pFdua160MSCfjJ0pG4j2KzT6ukVjZUZVaj7ivCtBD/KtHAUYC8R
-uWLzi31FuiVxc7vkHu7I9F5h7hXhJXQzoZ0VsbVd7g6hHfoJ37l4tRWgPc58RMMl5ody8NztSQH9
-XG5EhlApdsHbOG7WJK9MawOIIOFMG7C6Keofv9wlf7ZCEXiZPzXDWv+VZFi/zKfMXUmon6yr1kdx
-cnBn6+wQknOrSYeNKLLsTa/NEkf6PLaGTtt1A9axJT73T83+0bK2HU3+2eoA/5be36dT5G1jxvO1
-LxFgMkUYMRwB6oLW0X+X8iMTcibCOZXLKilUPVa3Ro/M7iT2Xum7nycWD/+q2DBXAEFviRyOaFVg
-5W38cp5Pn2wa7nIR/S3HvTtzzxw/5yu56AwAiM4vVt/kNXH+QL+UPRCsZ99xylZhAD6MTQSVkO5K
-JLOB4TAyxfXvnge5bnM3vq1GE0Y89tEwwlOrd27yhkrSaYFE6j9s8dtMyQ8ObdKmeIvTC9PMSd2R
-Ozc190jzpPjoLSgGhc77iV7WqRoztXx2oN0WzhHt6hebGhqPn+cWKXtBXo6451TZUkURA1Bnzv5z
-YxPn82sBvY6ndSm/LxeWKSAv5GS2tHe89QQzUZmEmfacDMi9uB/RE+5axsgtHtCFwx0J5uVU80P9
-26f3u1PJGkjPRTyGfjyurnqF6cXecz6njxJRGexPjlqj6nTZjots/4jN6jXnyOmaVqpl66ezuiNl
-ghM5snjYA765Eok4t0kaq1o5cSfJZ4VqFV2w45GkKnvlMRKqZCC59x7ZX3RVBcodk3BLBH6cTzu3
-uRtOvN2z7+lG81t5GbRxTOac+Xntb2+gZ09elVSZQxIdWbESVyKy8h4+8dvGCCekqmnrLrbjgVNM
-79zcGihOjQX935WlwfO5SvrSReeltSQE09o9gjEtSkM2Bw5fpJ2BMVZV3AD7NCHYdoPDDtrviUCQ
-VsqWWlr6QHboC7Vst83LajrJ63+G8Y3jWOUSziiHSK+p5yZOp1Ok6YDlTT1KPjWwznr2Ld5vFzJx
-1zjpM/3MWnpRV3aq3U4MeJbh+94x+yso5uCF1276BUSWHnIVwG86GOPK2SOesbRSQXwfkFkN9C0j
-5tCq4ra774E4vI/fVKHBco5Uev/AQKiVNlvn50Bry0jhtdDCdV0Gzk7xfjvZ9+mXh4LY9glUo5CX
-J661dK+bm1fEGNoRjtgagBEOnXpudJ0jnDW5ritcwxg4jh8cC9ug1ZABmKqcdW23zmIEQZLcZ1Ry
-eBNm93xbrTrpfdO52hl5QV5pDjcCsEsoYt30FtbddWfWz1QXXUIY0qqEhpNVkpapD6STkZbLjNE5
-TZ9WAi7X2rKE3QMu6nyxWV22wthcF5t2X2lnuFXOzlQa7T+jUnuTTB8w+JXCJe8P9Rf2YjjGD8Sa
-HavKLM3vdC2++yZjzSFDlx8cKnlXV7hJjCi7+dK23fQz15Xu3nZz+JivSuvWGQXLU0VwTsQ2s1w1
-GpKAMBqXwiSOjf2pZSJaPuWWxbKMD1+amve0wvfToaR9ssK8gzQFoYK9LJuWZiMA76Bo3JzSmtlB
-72WG3yp7c1bKTnvBrwdw8KPRv2wUKIij25atbhkpqXozkXD2mnXBhLHmjDjsEG2yTXJ55BDQHyk9
-UXfWMFqmbetbH5t432WY47Rt1iztEYve3yYCM3CVI5e1zWCl0Gg+FVNJARH2mZDQE4Mj81ycY7zf
-emwZtrF10k75L5gzcJgwTSTA4HlQHErHG/N+TzveqLKQkgLN+aJeNn4dYfNWhHhaR9e21Z+QQlNy
-HGafWhbQfPHQSbArf8NAUTuTtKNO9Yu9oPE1gbGGpfrgzqVY9Xy1GZdcd4/dM1IgPCMRaRN+Bm+G
-30svqxa+/UdvM/TzUZ8sf40YNM8rq4FZUQdLVYqx4Q93dEaYYDJO3+taDqVMBHQPnUSh9Lw8AdYn
-OAoeDuHxmZQT1QtUzVgYw20MnEcFOpeTzf/u7W73M8qbLLqdBGJp2rzErE0WT9ldcEmJavIF5B1j
-x0DhLxK/SicqZcueKJTOuoDXfNQ0BxP0F+dyHx+ESNUPRQIR6xL3cgYdzkgDfvLRy4LRNmnV8uUm
-tOwcatdVvknKqHsxVvGL/fmOdbo8W8ktmWeOC3nuG2X26OrODEengTm3CfPjEnXxBLuLmvHKsdtc
-oyvP1hMYZY9TEYqPC4ReSr2udzF6b3VCC/LMQsXp0XQKMilQ3kPPP8OzKEronH0z5Mdli/ko5g4B
-4xK7KAtGZGWER1UoS6pPNLaUcgEupEbQEExq/g7QgtddJczbQm/ftBaqMrvL3CQKBXQiP0Q2x6Xx
-IruPEgPq6mcaqa7pXN+jYrkdWa8HGcdYJEfBkx52yuyqPyOJEqk1uGRzy/695v623o+iUBCbbPLa
-otYwJKuorEB8ffeHZFpsW18vRVKi6eOI112hIJsRVHH53sJT++GKIefcsgVwFNUIuO/wiJKOLMre
-HcFFJXU4dkfrI4UWVMvt8Cut7/ZO7Z/gR9z5H30+KSz5Msr7pEQjm7p+UaxNmRsDZh/pOB2OSTx2
-rOP4ZEyxCyBeup8+t6QKnlvyzKM3z9ysgD3vKzRt+DybEoSmPLGF82xVlG9XZEftyjMjl5p1oU+X
-fV2cPV4rlO884vTFh/nIZf0RYezzWR2KsSiQTkFstu2yWfd0VZWnyYr9J/011uC5u2qlospKVebB
-9lQUYljM0jBQUrqyiFEw0G9+WsUUO9Mzn2PrzrCvouTHgXSn/xlfsQUWJhg5Nu2tCslQ/GwNtFRJ
-06ZxZIe2RxNLmdgPJdIZ0wHPDg2C+S5ZFhLEGYtG19hNpxjJSxngEEtGPjckf7Zuqyete/+tJD2/
-AgKsEWJmYkVumbYer4mKmtZWrJvdNLtHS9D15uGrPsnYoHf2IZWyl8CPMK5bbR3dKFvPa0ijwEp7
-gvZn7Mr5b+plfjp336r9UXpVoI2ECcWfH7+x+YQstLYRxz0leZRJRqnzlROtoOrQftxH2HmqA8AM
-v3crl9DSujI/AkDlIxWTPfAdtOuAuHsJBfymjZVsL7Bkdni8I71RytN7RUiWXBGkdr9X1CiHIt36
-EMTKWFeVqV451str21dUwmVpKqJ0hZA2A0BnrG/RhbgYpM6v0NzqfYaBvOVc7qSNuKqmkw9j6XJD
-z7zDqBOFF+XFemBwjLiDPtpYIso3lASdg7JlApWBuB96syKmdWuE5Doz0FLpbKJddotwm3Uh+88d
-RFmpjjjpH+12EyW/ulXHuPPkqeruGcKIgRkjZpA+Oivx6Zkp+2+XqB1kys8oV0VcUI2L1xYYpTrl
-I0nt75U0yiFJiXPIcN0Aw5f0ZPKtR4aUWvyZlo5oDOjnSPur0mWMJew+ME8pyDpAymz2svXrEnuZ
-DGuKnyQxaEbrUEEhAcx5JRazY42N21F3T+eWtmX9TqLKbouS6444vZBkBRvNXDEkPR1ph0jIlt0g
-5hFOgvnbI0kd1W0EzdhWjzaOfCY65XDFFX3ZnVD7Yr++Y+whWKpHN1/UDgb/fnSziRu4E/XVTDzW
-9pCO6j4T2ELvlTa531gywebKqZ7JM//4jQKTJXkN5brL7pLZ0U+AK1wCsSYamqekUpBQ5YostU4S
-4k8K5ONPXF0xpwiv4Y00lYAB8Z47yaCZgs8Sn+cKdg/Yb/ISM9KB/lIkp0HNNzppHlvw6do5nuuI
-IIeKZclcgmOOJjyIrSJwOfpqaEzNEvy0C1GFor5VVdMAGyWiDU+OlgtASpBOhkUtWkXLdMwNOnfD
-01qHnI7I7uNpPQs2HEPVI0m0W1GCOTYdoU5o9aLotKGeD1D6CouXgcsVDULcTOC1I5TxBO+A2EGj
-yTa6r60fZuzOkMp/DLWNKn8CtVsi4tydU2xY+nrNbhyrJMgPDKkn7yPRj4FgsDw9auuGadtyGMp4
-UaRj3FHWUkeNjKnvb1y7a2wNbrzbNVmlvwCgU4XiP/Z6UP5Jp7xmIO3NHyfbVZUeM0waOXdejgnK
-sYWouMu7Rci0FYvCvq2S5Wo2U4A5YcNa0FooPf0jDdfHbf9YdG2dYbJBBQh32VqrpgSHuN5popnd
-FR4VFx07y2NBBXy+x4bi78WLIkjYN6hP+LtUBofOsHCSz4mO+x3SCGcBv1SOjbL/yVAbHz7b6yga
-fTaQUscX9uAdLeWzP/0tDB6W0ie7k+ek1xKNAM5kD1XqhE1k/vSKWvU7GMn7LaUPaBdVVpRf8Wl+
-/AYxSvtXIYtzBfE5ESMEa9kFXRpyYTpvdZqEkK3XnO7DkcrJkarePsvmLA/iAf2ZY/czj7arlRfS
-1QjJKlQlmK592Mw/RBVcuAropHBNGV44w7XrGDQXJJ8CkkC97kt6xxm6WByjFBZsCaW8jiiFJtB2
-RSHsvUcJyotU3H4BQMOepvfLMDkCGqDaJcowXMnrFHbOLdNFpV2RZj5zR3o1DP7zfvpWlug/fVRC
-CXCealdW945oZVqvh9yPyI/a8ajGVrE+9RHJU6PuULJDzSoG1mZWGUjll5d076z5JRV7Geq7g6f0
-oRcVovJLyebeG4RA6SYNsMHbAVFEqCoin2aE7M4ZiMm082HNPHgwvkyPIj9z0jcTcIPMLGSi6Ob8
-AvWkmRY5t8QwGBBT/yIyrEJAjL4V+FBtAd3LdPI5WzS9XqrkSaWkUkk8k69D8eO22I+y4bGVXIwC
-LDWTtgI7zUtHUkpFT4A2ps3ArF7p+Q0tZaLxrmFXgujg75HYZq18iBLkwKs5dzRckHuxdWQl9UTq
-XakUW4aeNIV2x52Bl0shpxC2+x0szw6P1684heUBC/Q3DkWkbmVAab+wtlghEL5VcW6OrOmh/wms
-Gxvj0Lv3zVb/o2kQTv22Jv2fZ/5guZIAPe1M8ODZKAFiN4aF3Fcg0snpzrqSBuUCbv0fsH7/pNv7
-ZP3ekvcoxANYQCuDbPCPjLi2YDqBd2pti93Zyd2/52bFpQcCLRfwehkBAmzVvkbGA01EmMHAHvzb
-5JO9wYZ0F9PwbWwpF7vZiSe9IkYnOgtWBp4NA2OGSkxNTtkE+r2OnJdyou47JF775Y0dZvL3jCa/
-Tqm/kH8+jeWeOxDAX3q6l91eYC2hqT7mn0X6Fg9N5pELMNH2lJjeoyINdo9o3tNZdCjaQ+47dj/B
-FsgLf+MGekUUVJRG++gVZHrGJhf5dy44gfO+eXXvWC72l2vuZMyc5U2Wo1NU0xJOaU/+RA3aKY7a
-C57ye5zkb+lHxAhDuqUFrh/j79zSptZBpfN1qLfh+gszi3BjbP6DDpy3O3oS+rhrACVGj9zMtb02
-/q51u3xmeSh3YqNkWK/zTQHeFhq/HE7xedsdlZbPCKo6Pzji8txNBvRP850YMLWZJF/36L19/Oaz
-kT7yiVyhYtZnf9+5wLz82IoZ1nqulqk4bCEspsnJi8zTmZiDgpHE/TOlQeKZGX/YTA==
-	]]>
-	<![CDATA[
-	PSHPVbfLnICGJNQY8XVzhQypy/bZdfNhNwlSZQJGztpDWjvzm8gm8UahykupenpU2DmXEQgf0llH
-ftREKX/Su4q/Sd6/WRTvuEmuLZk2dk/jH+MFC1PigWiVc+1Tmc+UiDy4KsaWRP1zbJP7CAyHCglh
-8o/JVJ5SouVT0FOXPNZli+Co45Kd4orjfpqyEkr6HajAlU3u3VITCEhWeYsqTihFfiB4iMd/qFWu
-XhZ/YlDuLR18jagMesGg0AnRlkOT6hGYLKiQl0J6x5E/h+6qA3fI8tTlf3DEhiQj2K17a3nyN0Q3
-G4nd/j2jse9I8a6Q4/QrQ+MeuWcBFf49ODWQTwdTDjmYnO+9+2LxN674XRIWQ9yb125SYXlcavil
-/l+0IEYKM7ybTUaX7WEW2eYSzmz59IGeM/De7N3nRXz0gr7f7lBuzljXv9v++ydv/x03BD9Fsoyf
-GruDEUsJDCGvlf5Fj3ygLylT7NMLRvlz7AaTtnoTLcJ3PzqknP0gIVMjD6lWW0vjef+2gTIc1jQ8
-KBsjZ2lvpr+GYdNoW8aTAQq0FPruKNmXT2Tv234TDGjwyMccbV80ZYP3FLv9XsR4awpH3gypURIe
-s+/eCGxn2MMjJUmHeoYaDbYcYaeNGimlPPT0IxG0TYB2ZsClpVa1vRCrPdWsAwjDlqh8ZKCBmx+v
-7Q0tHmxyvSp15s3ZHjwkmyCJ9JmZ2R1qHEJyDoLunRb08gOY8nLll8RW81Ke6TwDH+C9wSu1lsEM
-8G4BNdn8QQ+ghbeXiw7ycw6tRZe50f4pD/Ak9vudjxy7avLTNfOeQiPeTJaNRFQjCR6seUN17ueK
-ql9NxJi3WcIgJxj+c2wlifPp2VDYLj9+Iy0+XUPUvkSdQF7V0ZMnZuC68gkpy/YhFNTG0GhRPOAM
-sQFMmwoWyEqwN0T6IKBhUNK94UDCQp0QgCDH9gq4ESv/x0hg7jUlrU+G7KIfHCk9I6rLdnGr/jlG
-KHl17H8mg992+tCviKhBta3E9gDabsxTZM4JzAK0ZQGLp0OhQ47e2HOUv3e7FPoWJsC648Y61NOK
-XCp1BqIY/tnMv2cocAcUnN9qseptp3t9qiGLUIeambAs2jcz0Lkr70No/WI9glPkrupMJvhHm0Xw
-Ci3CjAgHgZukiGi4NyPfaenTXAl1Avt8X8lWI4rC/1MuBcA+Nk+Tf98BgYumbgwxf5Eb3mqf/unv
-TeFn1+auWUG8zPTa1NSOmOmAYcaCG4w0HjouTCAPpZzmTDNNGOGkkdBAsU36TDtmqxa6/ggLnmvB
-OwnFaRHl9ZNp0puxp4YxHL9BBWCEnFw34IC/MfrV6kFKHEJF6+64aWOYcWfi5/3h7Yt4x+X505/C
-7bGdBe8CcsVMk6Gxu8XUzUZTmi2TPM/+57GVoJcVzkV/mUkOoFmzMbfhkzXEeTb7t7vD8xEQCPi2
-eofJe+T0n8pezDB5IVbN3aGQAVcIwJHrDAS6pEAO/IzcvKDSfGST8UtIa7OlypprlB5iiMTPDw55
-OUO952vSgb1tnp/uy7m/+AipvwR2Nh8UtQNtD4y5B3r+vq99jZl3UXxtfy+mWp14qYG7cfPcIpm5
-YVPZs6ec5MzUCGSPElKWy5T+AaW1PZsKdDg0M5vC/rgIcZjP3hsJ0Y+fv0ri388HyF++fdnvKlPw
-6RGk2Dz8qivTZZIi7/tSNf+YRya0+4mWjsx/nj1wpgiL5t643AIJABigoayIfrzqNh5u/u6jTZPy
-FlKkcu632mcbvF/jVUPPOtwBNdkbBh7pgI0fRzX07iHJH2cUAcVsyZqnJEJ2cbdtKJ+kRI8qwrgF
-4dJs2+nf6krBM7miys6QadQrdfUfHFISB+ZJm/maDmYGBURUhryo5aIeHaQMVS+SyZeBYw+cewD3
-o+1DLRfpb7UrwFMfGw8W1sdxZa6uHl2DrQxQI+TCUJl5Be4SFfWPfAfz4QPVEHXP4HSYBmQJGXB7
-Mpkn3BoGIgp57tqXIzNv+gxnUqUd18K+xBPUgUi/OHR/GsoCOl8X0NsF9a7bjPuN+EGhD0W2WU3W
-l+e+jj29db/9WPBmQk6lyn8oxf9zbbOhb20WB723tc1IiHLi3XC2hlI24hP5231HQs6KyYYGUXi8
-0u+BpIZ8JXAclC+eJprn2PKb9+5UmIsslTp0u/qVd6zK4psJyGfALgEQwZYzQMqDgWr2MkNkohiC
-muFAkjLCnxmo/x9775I0uY2l245Ac9AEXEYABAm0o5uziK7UvPO/vta36SFFVOVJs8yQ1al7rRqV
-ATl/p5N47Mf3QO/XAfvq/AizM63qR5SZNDjjM+rdWKrrKUeNnABXsU5kg6mCXHjp/XCHr/K/49mM
-5xrZvTxhyew8cZiIDKDW5sCIB6mqPF/rrdRLufKJs333728v7WdOZY1hl7OhL3VfGLzKxAS1w52H
-dwPessjV6hWMvLd+/qcElf9PcxmMDGCfdibz+cMhcYotqBbEnWJPG35C1+sg4lvPJgerAeiRsl56
-Zcw0kVvJlHQrlzPCXzOGGXcUAdoI3U85Ln4/YEEAMihPibiMQJC7HEO6gWI52/ORVqpH1IP7XdZg
-7ubTaetQU/zsVGGMARxpHPAXVc/fgVzzTXFJle9uIfXyj0hl6XfNawZiD8TQDY3Y86jnKURX9bTb
-xb8t4Htz5yNKpo0hQ7SiGRDe4S9kvdwRyFVTLdGm72x5u7LcHKin0v2BZ5gkZ1Q/v/7ylxHmmv/2
-Au2x6987A/fnij9NjJ9JQOK77vPM/c9aMMp73pF0o3rMK/AdtxKr9LXlDsVR/C3rpZfEPE1lzVT/
-kAx3xCHxCLBF/uEd1sn7ACBQ6LucyWnzPnCV/dikon17hbcYl00gEWBKMxLgw6UTZ64Le1tFUCU4
-tnME+En0ERhAFoyRoKL6IzX/DDkgSMurkEL63FBcc0Zd1u5cdlll7MIztGAFegH1Tp72EvUx3Aci
-rWH0BLpF+T51NOTUtxJa9zNn+DuP/aRjcQg+EhA4sks6xNpBNDrqgYuk/Fq6HWvUGMGjr+qs6/Tg
-+eHl/cxTwNuOq3Oe6h81qs2Gsqctz1w6E+gXbbx9L8iz+nqvv2le05tRU/h6xDpDaU4wbkGXAWjy
-BGOeyhzpK2iDK/KPnOmcGQRxeOo6oCApRq4r5G4jVkENZy7qMZlEZYDfHXb5kQG2BQYUWOCibqfI
-IeCEDL1XfzHQha3wXVD+JYCzTqCyI1/CAFnvmdbPl/xqeu4Gney+WJCdATi8d9YzA1fk1ldF5w6N
-UmA/6qJRnmNT5vt3D/OnEs9H4A3ezTPLeHX1M2bntNoFKOan30WOVwTTR/p31Wh04NmhZInz/aPG
-znCwBIgyEpoDJCA65HKZ76MYWEfUZUZJDweEyikIVyOmxS2w8S4nYRdPLPAueAPhoBWugJEP4fk4
-doRO7a36mRnyOPpKK387jhl4X6rPwd8miGDgAXFfd+osjrVnDAcpR8DDOSLpHHbpfkZS06E8Gaq2
-5o3eZLQxYKUh4cXIqU8vGBolk/1twvwA0bjlSq64wnmXDyFRXMA9ryAwAx/czocu7J/DQgfpx8hx
-1iu57xqItxhjTWK8Y/nb7vT5Q7gP/vDCf+ZK8IZG3dB5prPjj1NlQKfTmQd31hvQDsCXe62MGJL/
-LX3S9UzgtUOT/iNj3glm1of8z8oS9DunuyJ/844B+nsph/55R/8G+qftcEbikIu73JTIeZfOxK6e
-Ua4LxJ0xrMgZiVrNLtgRI8YdjpzHquuWrBjHmv1PxqTTOCbl9baJ4h+ngOaA1MpdrFsYtSuC0Pl9
-d30hxU9GzuvITYUDuz52ioypQMLDM0pcd+RSpDp3tQav9H4duQXuOnZ43Qpc1EcuSpC/BLP/xxfz
-M7uR3JC7xvP1H6E+SQMLBOad9xLE8Z8fkypZPMz1N4W/gz6jVBCoUkp3/uGg0aKD8jj8nLwjLZ1p
-EDpUgd2ITOeX/D23IwYRrWTgyj8VoHWAasYLwtbReq/LLFE6eO73u2VIh0GHzCMZCh/d9uhcdaXS
-9hlj/fyewdEzpqWAIxK4HbrqRiQSprUqT9QxD6ZcufOlGwH/Gur5YwJdMoSq8FcVeyxEOKgQK0ND
-mRuG/KkMnRrtSVIccTdhsCLLMxplfx2SFeOQ0j76ah7X/VwKYMHBC09sv/UKzhuK5DodUqs0b29/
-Lo0VH28ZCLKf09cuL36svD9VIB262/o89DtI3J7+Rd7NddXQMRxJftIeCbZceV3112p6PG+5TA+d
-C0jq1tAzq1byA0AN86oJ+e0v9Zmh9lx3WV1mzKpXBmHQ/3Xo+lzYn58Ddf/rf7UyfmLGnFvY9bCu
-VpodPn2DAm//0HhTRFhNIErUmdurptk7s/qbzjvbpYYwO5HTHxmT32MbmNIJdNeIzey0sxiJaCCk
-qCtKE6M8zxiL9S4GsOpEyl7j4Bq75AfhTrX7uU51rKJE/drO8tl2QOHp87Cy5MCOusJ5FK/Exqaq
-5i0dXD/VrPCUprt3lEjHsV5/Swrn7xmTZ8QY6jiMSOb194Hr8TMSofQekMLrUH4dvIB8Rmb7Vd6u
-jnhuMpJuOGM5OR/vEe/cPYa3gIBIU2fsysh7rffPL65fc8Rt4CgiHiO0LXxQ2KhKN9xBGUE67jvf
-d8BQbVKV6w3nulH+5I6cmoMwlj3oilLxP/KKJepzo2plMxFQkHcE31C3KLlsTbgSsylpAvRtv32l
-VZlPAXpxFu67/qyuGxlbz5h/eD3xtxYq6/sR9fF+nNE/ccX7ZWz1ucnkeT63Ue9Xt2Hepp0IZ8Fn
-ppQ0x1x/TyOSY2NJomlhlb+XumKNVGMw/tXOgcPLbXRUBdwtihc8ehgQMLJnzc7Rk6K3TxwhyX9k
-JBRFrgviQoSQj2u0x9f9OYUZOQrdsy+/r0U15Wtd13eN1WWz/t3FJlUcMGp156L7yN8ZhSsabhij
-Pf7Ks14LNKsREYDjLO4l8gXwhxjJ63SE8jkP0kXmXxohqY+8UIZO76gK5o5AA8xHjlYvQILjd2Nt
-1Kd6DUBb+v61/czAl++K6W5L1uiEPs4KJfHqQpuTJxfhHPydcUjyBShVyYts66dQv3/kQvQqOd4t
-ROQ/ZGSbiUltbcH8K3wptL/JIhCcxkC/WhFuLfVKnWbTuUtK8S5Up9yFFjZw6TH5UQnCxUXTtaqF
-W233ns+G5Wl7OBTdUcTPEC16ilUOaIrWY+/iwOlTZMjQ1aHLPxuJZgf6nYH9DBg53I8oxft/vNND
-jXPCyJX4PbVje37hO/cS0jXS2/AhCOMfVS8Xz99i4aZE690fxDt/Ttm7u0VOjt/ogSefPuZ8M4zo
-KwbWDh310oY4XR/zWZ+SItFjPOcARYsf3vTPpDg8MsJSPSqKkx9/hSgvNo6BTLQR221+ubnfo3rz
-t6yAMi43wb9FWCny5EDm2BlOCANCa3Vmev+zPQDtuwzUXzbGg6qXoPKysxsgv0gPLw==
-	]]>
-	<![CDATA[
-	umIFhlnTzmdsIUtZGPU9K4wEeTwONLleejuuFEAMQPwrSnJBYhoSG5IK7XK9+Mrt7ecPnz0kAenT
-5Nija4wW4aldpl9ap4nosvbiTFY21fKMlJsRd9Hk6XkK+hPOqowwB0f1WHaxu/78iXe4trPOIrSy
-dShznbV9VRGG5fD9+/mZ83boxu5XcaY4bc+S85SmcElTSKjJ/OhNokdKlryT62+KRdDmTTJ4pgjw
-R4bcP6Ul3ksBXx2YkKBW0VYt5+i5B84cKecUgXWFJHfuAPV2hHDbUdrA+n6olpvte+gC5J+69SF1
-IFLSd4hAiAyX1HL1pr/+krGzxvACzMisEbgKGblWjYTIzdilWu6lRKD3tNTO1v+nOSKzzAcw70eo
-OgID9k/u209FBUlN6Lv7UOzeqyQdRU3H1KpgbJUa8ukpwXWNSowjV41MvWe/ey9qV/9l5Pph5KeS
-a/7yO1TANqPmGUSaexYwGVEBRYlOLUvzfJMH8BKwyfl7eDYzVTTUFLoJgeJP5ZSmaoifUeWxR9SJ
-AQ5rAGZHi6jUzIEoH2T4Cak4OtoAvsfdSoszyCA911zhY7VqIqkeZc23xwaNgYkMjp+IppZK/T0X
-3XXRzh+B0v3+d60hqSpnvuiO9RHgMPq1Dpy5mZtqNgNR6etBzH/9JUP+oBWFRr7oCKDlwM2oPaYB
-DKgBp+fW5UC7xlW3aySqG1nPZ+Q6M7DATvCjm1lm0Nq5qJe9nXu0ElrLj2hImodZA720wGa5wY1U
-qJreV71FJoPkgbd4P7oZ63lrFuNbLbXMhi14RkGbH6bHT6XUzLQB/PLzKkrNTK2FuafLHs+Lg1ek
-IhULXpSPv8fl7W8ha5bgLG/q/aoha54hQvJqAO/t2px5De8ZrPtWDNt8sF9+2c+imtFdQgEVliPi
-aBSPdwk1a7aojM2eRTg5M832Ff0k8UYgvkq3TqCTlhv7Ct8YrMt+L4B9xRdLTNb7D9CSL5u2aRed
-kRU3vRuXaHyiNPob0XDi3ysTT2vRr7/oJLXizQgcrxqjrTwM/vzvqROnI8HfiGnZ1XERbQvXEtEZ
-DemW3fUNJ3P55KzQIJ3W43Q3EADaV0p2zXr6zhXt2r6KGxu3HRFT3gwBBQ+W6pKLysNnl5VjvO4a
-nzjK+VoLdGVUVfqMTskX37/4MEbe+aXzQU1P8F07/z78DsvzX3/58whCu/575AqQW9/PqJ9JAD2D
-7NevYq0QQJltPdMV1AMzp8cRUbkx3hLiHu3juPU3nE1zpX8lL2LpfAeTjv4F4B8wSyooTy36Lvux
-SCOb+VKnakcUY4t8QynXDWYVc3rzTkbUO9k8NxL09insnZHQRW5j6LGne4wyIMxfcSHsO9XvRsFl
-1UttiUU6xakjJ49tABD/MohbhXwxqvHILOngriQRW+6KXbLePsoDtXQU6Zq3+CsQgYkMHuXBhCOG
-qiWjOpoKsZvGdgxGbPMgM4TZz1l6zKdGa5cD1Ic1votg+Vkau7rkgnNgAHQgft0kxVxzEa1g0L0l
-XTLk8QrOAjYx3pla3UG6vb2op5guejUqO3pXQKjcOfT4BcbAmrICQAbOQHEdm2l6nMEqcCSDLe0F
-OVDL/i69BJ6LW5wIzxbEQcVizooRvX7TX+x9UdJXwB/c9TpiJ8xFFW7ojdpFTFM45DLEB+kAdotN
-76m4KOQosX/Er3aVrexX7QNUB8GrFcrJB2KHpKJ/BVgeRezHUDXgOYNGFJP3HN98d9FXXoJWWlr3
-DMwz4I+ebtm9C5U/Cmh73+Wiq99AaPW03L9o1usI5qQQBkBwwI0mA6c5LMrF5zvSnOKaMh9BU4HA
-4704EpxY9FdPpyfnRG1hxnkX9Rrtz1usJjOLujbwoTqpb3OFsthyzYhfikasengeqSuNHUEW7+7x
-H2yBkmkreKtd9X7KQVDG9rGOEX3HlM3yxMqK3OnUsBLPsAPiHro19sW8LqckEPkYnNEH7fFwdZPY
-OMfYKSk9eJBSiLzp+ngEfLA/cGedL0RpMBcMgMrm8J6JHUvjvNWJ3avWfa+4fxOmekoKqz5Gwt8U
-v6nqo9lAyAzikk10oRkeejInY9wI4FyXchoyk0fCaj3uGZj+ZqF4OwO7u9fNpfVOhvixJRnIgDI8
-rSxnftjR/8kp969IH19QKf+3SB//GBDPEohrLQSpgDqqWEcz8ByxQ1t0lnm9JNMCuPRs7DE2jbft
-ERDbWX6emmrTonAL1n6kpXO+ypLxnxzx/597N9+ClO/teUHSQNnjocexhyCbgH7MyFXYo7g1632/
-hShDWH9RKfqKTEXBAMesXaLPEAUkMgQw+/6GUfYPdDWLTXwTsDZO5SOmmxoBt1lCDXh8xbfxHZDF
-lOqMVx/K9lr0zcIiNhVE36sU65XS9r81WFeOQkJ00+x8e0qr58IGZJyEOMjS64YhyQ2rrHIcIJjE
-o5Ujvt26gv+6pFvFDOBSFlGNm6tlH+MuN1h+fTF6ak3bLDw3dyRz3nCv2c6gvkiMOBQ9nv5G4Wri
-go7y3GjhjNoTut2kjL+UB4C8MM/AeR0p5wykDGzsC7ghHz2r7nDMqEM2PMLMK8TO5DK68iwyv1+J
-boEBfHlPS46ObHKy90gJAYK3PBQbaIllG+HdbbOR30x1g9OcWCBGFolzMRmCm+eYgnsGAe972tsq
-hv+mlYQg9TYdY8g3utdTUxhOt41WoqUAcr/tv7cAscahCteMcNc6kaQSPyLvjwG1IPibp9QRfkF4
-GLhME6o0tbe3P7K1nab6SgORjtzxQAjkrgtQmVJ0etBCwRlJcRmB6otQOiNyHi5o6SHQKeUN5hAP
-tiivmTjQxu+STOQJFkGEGTUhZkv1UM/aZhWKGfk6o9p4S5SQBcpSTC6BH4sH3Sfv2y7MYdJug475
-e6ZnhPI3SsYsAhfgLqaBq40iAjDFZheDpSMlirWk4AoDrAJWG01bIl1Sd65NyQzSFGERuBN7+awl
-2mIaV7BeUCeAxztXWJ5ffkmM8N7BZ5E7OYyM8zAqGubbPd724OtnhM/PonmfUgSDgGDrY9I3uV+t
-RA6IpGziNevM5ywpB+KJwk2Pu9YjTPmdHXaY4PuiWVZOIZ7gldSev8GDW7v8oVfwKl/Ypq8WLQRh
-jkFExrT4Jmbf6bUjNoAc9leuiFrCHTNHojWORbZhQtbvN/5/M5QZ7xDw3z4uz/8hx+WPAu07S5sX
-dK3S3UQ2AYLjOAUQsNHQzCMJIdxlggmoQdqSDpBeHHQHCWYncvs6lxekYa0cEM7cs1APluK9bo5A
-1zVlSGVjVLkRtIBhq5nh5W5pvPVvRkD/q17ptwjoe2vpV1Wu8CB4H5vUk5BOVTIRI454dgoXR73n
-pTszcZCAgVN/gzMQdM606/HmYEvXNPMqeAdnzSXu7dRaQeFmFG1vSby6bBgsGybpa2nFuFeH86TC
-knbFCP1BU7IjJWf1mJAVj6lPjwyyNn8RUW4FkdS/yzqsUostgD5UlSP6cUUyfgeTBvd4R2Zelts/
-ftHLWgRC/9TUoogM2Eohq1l2b5flWLdjlkjcxHSRQrR2jxiOza7jMBDX0Bbe225c8d5xXHnp2R7v
-VYTlV1qFidqhWuARcu+Cqa6YN7LMesmK4CAnJ71iG5pUBY+gt7VWmp7CRrvi92ltNaRNehnu2BOL
-DwGdUn7yqbi+tyaEIw6wMlMQYor1qtQDr0lT/BSW4kekvFDY2pZBeDHl27uPGGqnR8xQX+Q9om9n
-LqJh1EUAx233fRLURRJrtW8dUgUL3YHX7ta7+7c7JrDv+RmOTqn6n7n1x2Q4TMOR8smnb+lv2fmK
-K+zaXoWK1yOb24tkmye9SlW6zAJ5GffO21nnX15XTACUdy+GTSlav3dAUel0KAGe45/oauvPXJ/W
-u2vqBBk768t7iygG5phKIr3n2zsKC3HIMIrqxPuhsHovHn+zwGzMxqydLcTh0FCvolTVUjwLWwrv
-jmR3FJhl4cP73ar6YVG9f5uL6r0JddeiJswwxEeL4aUUP+1kWny8ZhIVtTtWFv2dj0iX4XHePaRh
-rfN4cSuwua5dvMY4JToXdeNYxLyfuJ4QZ0EGI2bH4rVzTiGPt37KnmqxJUI4R7ux7na5pnHR4Usa
-sXYxB3s14TBn7I60SmW10lRgpH6UZvLC+ByTVYNR/CE7pZfGyevUn6L+Vtc1+323lFlfAQxw3L74
-X1rwkI7S/3lxFPvreknc/rD7Jw76IQJ4+c0jV+peYwxwp9nFk4nX34yALFYEjaq6yXKL58atxvP7
-qjOyDTCtNmAxOMGxBFUN3q2hH764EVZEjvJvh9j3VrZot0svus4kHB5iU68nkkgOLETB/PG6PVIM
-1zpFadkypzuLOX2pWfVOk+m9oj+9s4xIlnv8XWy3cHpd/D4hWHTqDue4QqOXv57c616f1B99E4SP
-juj2UyoEFLJGjgw6e9Sw14zbvAvM3jnmfhzJrpWBATiiQhCaqM69FxzeiLbL8Dgjw3APIHbGjpa/
-2ZIlqBOcCvVs7+t5n7AI7h1BcM7xIVDg3tGBaqGIU2Dndb2oMMnbsFTgbb6oT0WqeaXV/MJmg8L0
-XdnJS4rH9O+8QwkChhepU2m9bnbWfzDZh1IjJEYxRAXKf/uZcPj01z18rPmFLxQW7jO3o9cJJL9d
-9yeqPSgvr1AoBDcA6918c6iQJL+ADu/AXLyGMvRd6bwXNeufVku2tzKdKKrfttwahSCugfLpIuyq
-e96VYzJVpbQ/qhUMpARPKiKPnd9sVY+HIO2EpyLG844+tE+Oikjun3Xr8/XusJs9eZY6nay8Aqoe
-vqWI8a4CrJFUimnnWUX9rOmy7Ju0Vgx2gOr4HZffae138E/fBxvkbbWKHBaV1oWKzIrPFO6N0CPY
-51YLcM4jQGY1Fp8FRbl3NM+OkRK66GzMKcdOdSTyHzhYgsTAd80MeWWH2XZFRuBlyGErJhFA6Pb5
-0KifSle7R2flRXtQIALliEMdO9t1zul3ZghsEM0b0ebv40Oc6+Ndydu1/HOFRpS5+JEdlx5p7Seq
-4UfX8Amu4REh3MtklSGx7py0l27JrIKjtHDLnEJclRucyc0Pe94//putGzM4onC0Th9y+IxpAhJF
-a2UPAXTPxnWZ+UenapXeOts2pRAlykkGNYjQq+Jedno+38Iyvcf5r2zZp/q0GHy99w5OFE6Z2FkJ
-otePjw1TpH0vfY1eghOMLNv5LwFHhJ+0S8PPKytSbLq79jAjsPdS5fHthqMGh7zFVQbxyR6DOsxC
-XziwhJk41qNNweBh90v7dnDKL6qLrgCGYk9I3lF4sCMwBC89d8xI4NbIpVbnX27M2Sp4p0d56ufX
-oi6dm+1q0RLnxn3vcO90h6x6zUvfU+wPDI9vRe2531txAAavlkX/zkakTp491rrvobYKDdgfsTo2
-hzuEJuJvTRXDLTaEIv85/QntjJ8cN3wbg/NTl/GTtvf7jGlPDFP58Ve+9B00+Bh8SA==
-	]]>
-	<![CDATA[
-	5iMx9zGU8WEm+3wf4GFO7HI2lIcsR2uUCXie7+Ep6Rs0vj0ipshbjhLJoYnFEQ/AESvGVysTFeaL
-9uyN0F/Gx0h5DDuh+IgPxbHOHF9HMNn4APYYxuxotwwE9M8EZplmRyoexnhbaqNj5JK/u5it9L9s
-IBuqIxN6JLgKf0mdwTgMvmd3toDbGcLYeWgwRw/yysjddNZCjuaOM6FYCK87lbPMWK47o5vgajSH
-/H59/neh4bPyvQnyKTYYpuc+Q6Jh19yZO/UsqPTfWSSG7s6cefwY6M3v+zWrtPfYgMcdmX2PYGJ8
-sTwjMHD1PlKxtdvLf1/x0Fkx3KOgILyKOv07VowAyJFyvx17wJ1TNil1J13gAete5EKthDWxS7cf
-QXuZqYbz/ExdWUAxFiyki9CW+p28X1P0OxV+O6nX8aTJKcejk96y977XeGpmWBDblEYs4oq/QUtq
-KS2Ou7geaOF5VLRXZnr0Mkxariq6kkB1G+Rox3WVpHoJp98e6NbYBDFcd8zvuKYkHjEVC3qNI+uK
-MV6oZjOCVNf9xAftLEY1HZ5Vn6EmrKfzSv+LdhmX7DSjffSn4sHv4Gv6Ga1fVha213hal7psC4r5
-12LGNc1lTrWELRt5X7x2hGq38o8ZyoCdiBm0GwOL8B0kzI7Hn43wXNJWFII9vGFzlviXPmvySSnu
-x+SvgWHNc2wjz1Fon88a0vBVEsi+jHpG81RjrEWbUkXA9TAr+4wU8E2I52un4s9rv1e4jvwHZkYu
-Ia89W/UKpkVSZWo0zTbRboltdJyJAXm/05Gjk8iiZB67G84zMpYU+S+Cp4ncYPixhGww6+hQXzZ4
-VhjG5yq/Ztn8iIEuZFLDfis73VMDr7SkqPOfyj+4dqmOncpPlM1qFH/uCJO5+nOBu537w9hZppIA
-0ZsYUeP09a9b0TP7fwjmMuW2m4HaLF+5QOyjikZErSvbxEMK+H4L+m+2RT/W/didneodQt3BiJ8a
-Cl95RnhSwiXowonft9PT1RVHaPG7p2BGDZzYgvejWvi8q4U2euwlKY5QyfSqEWW9ODaG0/xMMDuf
-Tv7uLO3Xv5BjU4NPx2hESeOPX2jCTf74ecaQqc1SVqDoT6BDS85UjC3gDnAcrRqSevVTDy2UdTpo
-v1oYY7HjBIQjtF0/ZqlGou/UYhaaLP3jhfYrt+Wyo9tNmW+WBxSds+6kNexN9y37MSVgFvgNI/g9
-sSYxOTgZkuJ3nDjBnopRC9gw0KaFu19bZe48VYd4/7tHaGbOJ1oD5CGRY5YOAgNid/SDZU8HBkLy
-58DMF51hoTNkR3qdKTdOXAn5PYpPH35TuR6jNAzWiBGBimtmpxHfx/NngHXu3UoNYUiU+Iyeq39E
-q7Er6oMapsMNZUBHU2+F3+ZzGfkIkKM5y2KD31O4Qp1T8xA+v3nWQ/g8FdHpPrlx5SHsu562tE6f
-HNVDHv+R29d7YB3Z1h8DUd7qTguS37xa4RM4F3kqtCudCBQn5/wg+yUqvsPd9+wgFGs6HC1n0zs4
-GKIRiNWFThbyoHhrk4OZe6F4D1JCdAE8B4qph1vgO1YI8OAKd8H96NSVep5BaV4Fe5gjtMRzVkt4
-9kgcuIbS8Ji9urdnYGEZOPyMyl256IydWdPks+XOp+sVaVUGZCwxQM3ghxX932xlXKhSOC527XHL
-oEzcY9CQiAhCJ92YeT2yRWcu42W2a/4fdxhAjx76oPve6YPKYGcEcntJ0wJybFR/ulWGCE4pQYW4
-4vrgSiXlYh19lZiX8LehTPolOtWwyBxS51zwiLqM0sckSOln2c2OFGgCe6W0Nq6HGQ2q0YSDfEPN
-RV4aBRpxIT0A28SnR/riXHRHzsl8DD2wEw2Bboz6TkH5K7vEtgsP/L4IsweULOaRx82Arp264h4Z
-mGSGcwglyDVs9RbI37/oH++RluN/XoFLZkhu4rxLnZ3PgP+dpbjEgGDLeScR+eJFHu5ADoTuzpY+
-hThi8GhTEM9mQEucr16kzNEsi1O/GjA21eKOmOA8QtifKzP0q7/BbJu/wwpygALNLKMBBsTnci/N
-/Mah93tnBL2K/HuLcg5K284hj2bF+Tx3J+nu288+IiE0S5I5IDxMG21jjnrCQibYGEfzcR6hcc4R
-8aP3kEYep4e6WJ2uPUmLCcuu932gEsREOKKlDlAD1TYtAFug22Ib6KiposhU40wUNRa87FktQqZ3
-Okw9pj24NLA4mNT30QJHS1LHxLfAqk4bn0E0BRVNJr5/RU+KS2SuHfYsMdnbJHdXCfbppko8KZAY
-7DalxlHGy1w0ws8ix715L6PHyRncu7YK6ClAuMS19a4GWAvUyqF3GPS7Q/JbejEg/UxkpN//fzX/
-8EH3hJ3k0slbwLfqd1fk3xnwCGAAasoP289/sx3mL3X3JKvXkZg7g8OmFYIcdtec5PIJyeDkORM8
-C2++E9oJrgYHRvMb0QZeqmJ5KH008dhsnuCmVRHvdVmhts+SHM+suwX6Y1ybRd1dSH9Cg37bem9/
-y3+GobLryfw//t+nvqeXFEoYOgzZMXqRJNOHpnCikAr4oZto+lupjWi2ZI1+S3WAAs3YVW0aZWj7
-IoB977000aW/0nLgoDrKprloV69GkVMnYRuP9JmIItIgJWtZKoEBVaTsDxFpHikrkp7AB3pJFEJE
-rB+rRH/o6XsfXeKbbswfKP57cAWkzeC2b9aBkNdIRPJ6V6kpf7+Mbl6KBB/1OYPSFxMu2jRwfmw8
-lBpmPmXJnEun1S4eTdLBV9dsjVILFV0OvBeCyVuVsF2FfK7ExoR9/FWJyKtLiFdPRQE9it9wtzC/
-+JQPKYEdPcLtp2B0y0X4/rwnOHDCrUaLxlql4T1F+L3Hzthy0kMklHyPsIPAjziScL1H3ue4Asgj
-LCuvy59lkUYQYOC8TFwZ6sXKiPSMISmzrttJ+4WZ5Ps2UcL69ak9+rdViwILetno9x48DsTdnmfd
-5zlyEkckZpgJEF7FHOg9VDKehqCIErwnTQCYJm18PfhVQCssUbq0PswROwjONqfUAAsLBm6uEE/f
-IwQCh2eZmqm8vr2S0HDgAczLu8phlhJqhxVHf8OE7EjDSGHebYAmpew9D3Zl+iMIv/fIHXt78/pU
-aN9fVfYb72d56LW8rrRwzx4oX67rQ6xgsYzfY+s3Gd0rQFe/TvbRuIIR85bUgwJGtmbWkj6WGDyd
-AYG90LsFUjhKUa7Lfzt26FI9U3rjXTCkUKWU2/cuVTyO5l3PMjbnZyQznwlNI3CcBv6+FCui3pLF
-5ZIoAju4M0uQpAO2Q9hns1OBNV1MjszFvHByPmrpd7qm/CV17zm4t6I/4GLP03M/3uZOAcDVks+z
-0rlxmZ1kEcuVzhRo8V7Rh9wpwOZF5j2vepJXzmSqWJbReXICAUgklhiGXT38U/xd9iT4r0BbQdQo
-fuDI6fuWSfkMONJ71k7GUIJW7WnVH6dLfRbHxBG3PhAZc3/ukoLHmY5MforoM6TF7lTJ2fxnplcX
-1+yYSvvIwN2zfp0kUUaat30apxEfYZDiVWcpFuz03jNChwv08tXPjJjp0bloBrOO2fs/qwT1e8bc
-eP15Rz0nT2gewV3P6cA/5+zxYKznZN7YCwTmAHgKY728zJkQmbfyeZu0NK+WBO+qb1Ncg0Stz3rg
-Nq5Oc7Hzuc5y9Flv1eern70Ir2dEg3LK6MezDleMllj2YkGchvdKNe2Zq+YVlNLX/dnTjhTgddJ0
-0ltKASymRkW0GrM0xl2XXTHEOUooTllDCu70e5zyjBwAOgDc9+N6FpSb8yjdTdezMh1ndC29aXHm
-IOOPZ6aqJchQRJ/ZPXySJohnvZMLFbgxYmHkZSO2YOwo9n+6nizdHaVOauDgFB8kh+THuc2ins4p
-vkRMLgWg/S0awruBypAmGo8Q5ntsVutC1aNfHdBf1OTAhYnELxgHIsJx7Gff1aSMnCRxATYrlcqk
-ke3KOJrnk7ySWoiiDuYKMy9TAGthErSZpbmDjJw7P8CXoFcqQ33lFBvKzjFwZp6gZpA/0543h3Df
-aDnXnF0gXQ5A7NfngOYmL0uhzyrggG49jpbpVRoi0MvCDygibbA0Zy2Unh27H8khyH7Ec47ewu3j
-MArGAgbhWL7eouR7nd0smYjGO+8Re5L9SnbkDUgJAK14tfaJI6Q87wAZ3iMzhrzEEwIhCSQmQquA
-HfqV62g8SW+lGHjVeWQVs+vWUZN1UZqmz10mQb7QdFk5UGy7ed5DRAhOpdW8M7d/sYJ3XSrsomk+
-MK3gvId6nvJLCjQj9/spT0NnINx3TnhU0HS4IN5khzUE3RgcvgSHOUQh4QlxR21KvL7TXv1duFcp
-o8JW4BTcht9QWillMHQ9v5QVSS+FwT2MY3g7h5H7TjftBQ/78HER942WdQ9W1C2ekFHhMCN3Xz9D
-6wnwMVp15ApyiUSgGVB7pc/yaJGKZkiu1vt/BBTPnT2Lnzri1XceiG/rBZlmRR6NTrfZja7AHC9Y
-zmb56z/LpnJKU+UvgDCDQkzPjWZFPoMNE+2vyxKKf0slYY5aJZqVaCHM85m3X39M1n6igIFfJsZL
-JPZMPfGdCu4I273I3U0A2lkaLS/SWKWZ4O9oxMa0E2Dw1YsJSVWyaxqP96RqpYO7ddx8USZI1EGb
-JfXI98QbqaMlk3IK3Kc2auRR9Czc56+g3/3jQbfkSGI3pkDhGUUP2ObKFb+cbA4yAbtY8FzXKWov
-q7mG3WwFThhE62e+ccfRga137/qVhtlVmd+JTGCik7hZxFktJ5C6/aPs7nIl8RIsRsXw6gtO+nXk
-loHTwGBjfQ6bOv35jWXXPMp20ZPZh0FQdfZPZHuvBDCjPVeScsZCULFUv1NC3HkXIsDAjlV0VihT
-N3umDEgxO5uIeix0AjuQzLMCosvte+2fon13tx8QS2c0iYiCEY/+45eCTxuo5RwFCOatQ91jTtCm
-4hg3Lk7OHKJYJyYs1XnEE6bhbdC4UMkBUXH2z2CcSGdGiFY6BL434js8ed7XlY145Ukz2aomQO9W
-mip4EF0YmiY53ULV5RZJIHRZUb8q+lKBmboRreAJxogut8hsam5NiWuMmi9LdQVdeDXZC9Tz7gS3
-L/oq0oH6LvMIai98C19ae7/iHCuhXXReIeBPuWmHdj4ocehrB5IiUO73GDnXZd+qK/D4jgFTzWfR
-3IbN72eUNjtCghW0HdRCb2293/fdaqdYAUtoYvrqD9xDbECdUO8xaXD3kTpzRkhbFU8wrmLkfaCo
-xXnN9rmOXyr36axPdRAHsP1Fn6tJAGwey7G7f+5TaTFwlxa1+DWW/VYZifgMBJSB/r1XVa1OpQBX
-5bQv1A0E851le8BBtTkBadCsp9Z15GTFDbZOxG2MZhen5Z0IZ1hWbgy+GtQ9oHLwGdXnJ51jUq4q
-vVhYMzhZRfPwshECAT9EUg4jHQFS+nunMweBFrCv/vw7ByAONiA0wNs2i4XYEDLV7w==
-	]]>
-	<![CDATA[
-	kTJp/jb6KIC0r6uuU65NU+KpliP3qSrdo7ftT3kAoB6gXhemMy3yTOe9UrETIX46w47YlQHkiOrK
-ewwHhCP4FvXmu5r/AkmcVr7KGZWNFdSFc+AitmY2kQy9NNultXyPVPodeSeYCmSeIyGX2hFBmVug
-eeGPqZPqQnggIz14jXU+lGjHZPmuMol3RG7deuhKcSw+ZecdRVDQ5bagFvbSXnohU5+xeMS5qaXy
-5cBKo8wheVwKUz5rzF1ekU9DNNbheWRktU+c9f4tPWNWDI47PQI8M+/zfkZu3S/NTkjPGQNagSHU
-1Sse8Jv3eMpPx4qHgSPtzHVsuVtarzVH7zySXr0IMo6wL/F9oVpk6HboWMTJGekaZUbzOupBsZ/c
-6slkiOonQ0z733MHC8i/OqbG7U1xT0cCg9R6uPF8d5XWmkqpWybsedbkGev0PSWKLt/oixE5wDUL
-nNrrqlJ02cyK/Z2p9bRCaTN7rqo9tGJmsIIPXyeyecTB93pKyPxtani0389vs8fzUQmaVVvfViZI
-Z8O8OPCVl9L917PV3xSVrqJPZ4lFlMb9x3UYUBxHz6jlu2wDXsX5dT2b2LBYfbms+o6GMfC1kfSV
-vcFDHSjZ9KjdZ+Y/W78VKXaZ90t1l/m2Gba0ce8SZHPEtcV+pcueOxh4UrgVa97Prha0NSlpdtGi
-wi0C99ZzB/YdBFGc+9nVFkf7Uh1h1K4GdhfpGYNhC34jr248O/ZFI0WXchM6JN3IyoF9XNmMi3aw
-ZmS6vK5OIabF7bTgxGAaUZTYWU89xdtVRm++usJjrk9pifKPNIHCN/h6bQepMHFf3/Kr9yta1Ttw
-otg1vXdctbN65u1xoJpv7TMiI3CODEUKQ0YwY5y/vRZP5mAPEasuU9CTzdc+kCN3CAMRQPVPrytw
-wKqQICf2TvoF4K1dMUEYAUNqwJOHvKefwX2KYowdCEqoEdMrdGG1gkQ6c0gbSVq0EdFbL+Geqc2u
-HK6lhqxZlz2zVdszfdggi95BWMvO93B3DdTMF1EthbybaA6gJTqxBVdvCn8pGxbXkFcTbE0ztmQP
-DR4jR1bdG2POVSZqdwq5LyBsqqr0FRTeC6SbGICdw47L3iv/wKlbqL9uiFfqNraSR+Ji9TMAeGyV
-Dl73jP77qBiSCHygKX8WLiJhe4pmhu1fjOTlxTokhxbLUy7qqfRk4LKcLTXvqxfJhz1LrMm/Qigu
-z5RdiW/ivE6CUNf8JWX4ieYQ9TutLM+kJ+9BxMtMPu6ZgsGRDgmg7uyJmMGhg0zvnAg9+TQThElu
-+uBetsqibrDAWu3BdvblW55P8naUl/pEpfWuZUM5HfG/K5N9B4l+n8957YU7cfkq7asEruwjawVq
-lA0OQ5Y1Mm1ys9uD9Yr2UbbLlqaPmNyjzgczd2OyT/L/HEciam3TtjudLwpee9XdKh6jR/f8KZbM
-9/fiiVBLlYQbV4zM3rnmGFnjiF6kE7lzrqEIaOv1PEtSjTxQlKTU4hltjbRzyZbgSaO9Z/qnmeG2
-vfWwTW55TtY9pVa81sjEVspO/fGTADTYieygyPjs4V6Rgrl2F6dihjFCcPIpTdRbskprWuHmdk5W
-C4e9ROVaOcO8R9QQBdAJ6S1nH79HwdxSnntvVqscPUhFVva4Q2xf/+3ZYe6CRSiDZmGxpxYobblV
-IjL3VF2tBQTiiXVzaKtRaze1lZmVQpBXqov6zDXK7xXySnOAH1yqgS+QX2uEhx97BEqhgh0gdRwz
-kfnVE8KMR/Jfm3DoUBRhhl2Fuwn0HgLFqvZamsQqJzhzzS+7de9uPwxyI0Spc/72qRPf9MYOq+Xp
-xlBTGuycwnGbbeGRwkJgyetpAotjocVdbOgd69NLWkvVou5zyFpb1Yi3SwemV++js6rXJC4QxHvq
-1Dv4PdbzqDL/oaeNcYSE2PSacCfcBTBypF3BjUvoqE6prN+oSkkgs1uuutDjsGczjzoB5dP2NJBb
-2R5RuG5pal/hdlBpmWmYI4XHbO3GIvmJt9phzJcWrNp76CgeA10GWVs4xB86xVC2Dsb0PR92ACkI
-JQvCfQ/NVDyB2KcE994L8Q3pAsivfid/BBR0lCJKUySB+SbKa1cV0RHLfdrVHnXhEiuAw6JkHNBD
-B+JRrA7Uut4jZ/IT2L3RTHyPrYRPd7ECLPWLLqQLYH2685KpqNztgfj6dBqWN7cETrtYtMhSH7Gn
-ZGw6ZKAeTzufAi9SEMyJ9LeXWR83KXPdXsYJFm3NIBqr9SULBT/HAjSU3ZjOlLa+lvQONYH63p/r
-Ilh25Ac4It2SfO5Y1aG76VQRrUfaIKsC0QjqrUdu84yK1g41w1aKlVfqK1VaWgU0opmmGRGr0oej
-GJjWuDRcRCY5dFYeBq14qWwGGsWt6J7hxKAaluoSbwiRBys6taexW3Aw7JWz+D3SE03vVVuxmwyg
-aHWk7wTKKDTg42BLftc71omDGm1tVzv9GsvmV21qxZPSc9gXcRVxj/UrU5IR8tm1o0npZTsmGDz9
-0xbQtYsr/HigcksKdCw6PP3pQ920fcC2R3ThHqntUQXbvgfnrWnIfT/tqxlgIqkJG4jPt/dKX3o2
-VTCkEOyVDWjPHvpOFbzLqQwIIxIBmS2Zdwq3vvfQqvYoxccEO1N79MuFHyol7k9lRVDno/X8JOy6
-/FzKYour9beKIuVTqS/eR6kfz/C3nucP1Ibvm2J2SIunr+10+VwIku8SNOt5IJSzYX7xJtMeYyvH
-YJcEOKn4pRS4P3VfhSeDb0Rhj/JclDF6KYpTwDfQunrOD1rRqxrVVw9Yhp75fD51QOGnbGSLs+PY
-yw/YZT1HGQVKCSvqoN72q/92ojO1XAFX2ZFs2iXXfC6yz2FKbqZGlRiDOI4tjwUto08HrrHru6rl
-5pi7sQ7Rt1P7SsiLsoUqfCUcXdcJO/CRvEPT3/OY3olNbmG49ULXoalC9XNmeZ1x5GPHni2TB1gf
-lSfoUDDsfVFWBKl+6n/cTUkjVd6OKn1fBWVWEt0TjWkhf54O1LNlb+aw53TtarecRsckd2UaUjre
-Nr1rOb1z1ha99v45CC9CP3dDD7P7TlAmEMha4S3DT6nIVocgosc0tfjJ25rBvcPt2BC73XwZcW0c
-aWXWdaLu1qpKBiPaQQOmUO+ArzMXXlcsHWoTFUsoE2bXHmrXS5ENp5R76GVZ3bJa7aFitKmuiBPl
-Qc0U0esovQ/TXIEbz8sLGGkJnssruGk0U2QNaHOFT4L38a5CA1xCdNKfWKdbk07BUUOFvEqCtD2+
-VfXZieGMCuB6Xq/sK4T3a0M7gkN47/LzqG33rvxJIWRzNvR8jpwOGh04BbSvsCZ+fmLQ7Dx2OLLt
-2gRUlG3WpmaLhOOpIhemCbAHcjQhlU4THT2OI7tzjr/TASE39b73WvmU0EtPUqNRhSrTO1q9jAT2
-tyoRUeTKoTyfs1w1fY61OSuaGHcm4WcdaCu9sl6PWTHvwOACuKzKBYycUKD4L9eo63aoGauYe/Wp
-a+YUscy8dg5Zj6w+n++b5FcUwcZauU8fDFOdI8GfYrJ3Qxx97rOFsgIlZx3nkwrYqTpy2hCZgdy7
-W4i8tWtbWXfMFB8wzhUvqgCriQRt1KDz8MgvgDXibF+P+yhhpsorGo5H9Oiq42984K6q0ROoEYO0
-fGqll6cvogC62SpDS/st3/fIqKEKVXpGOw1C6krr2TcFKTdTy/kJJ3Bzox517vtZ6aAEaJQGvuMc
-4iERq9vX85E+3hrKixeahjJ+PGFWgfQigUryWAlu3/uRer0L5GqnfRq+9xhQOITEK02oq6ChI2o2
-zKxWVyXMES14Jt9RXpeKaK+Vq5zuMiovvQzqu2xK9jLvgjNK1L/KfrGyHbu/c/1WQgQuABlyRkBG
-slbhzz81rVBwgYUDmfN2y13F4ZHxadPqXglEz4I3Vfhjjwlz2pGT4bEm3uFeusHMI1KiuyRu2Abb
-n9F8OTDDOzHBcs5Ook/Uua5qdp0rXfheZkUvOC2mshQVRM70XlKgoOev6jEDUOo6In36DDOVPCq/
-uzoBomqyINPfJMQnpKWvrM5Cu6ulRQQe5gFiVz2yg/K8LbjWrVOO6IqGjTs0NyBhvjyqIe8dWUMU
-xW4tuFLNi4GJbArLKnId+Hnpi1J0o1ALGuauPiytYpRWAbqZCO+dUib1Wm+TwG9HbVBY8fsqWhAN
-ks1KdvDS4RJASCur9avlABMEGfAo1IQd7lwEUlDyoGNtIccK3SKxUERbApGzJFkjWtxKNQJHYKOB
-1S4IiAHKLlDyzhkY8J2IhpK4QIVOmnZZPImNak/RfVyh6X/9sdr2M8u0PrbQrc6+Iwv/EmF5iYtW
-Eu/F4jtlqv1mYKjplRrFKwdiKp+gSwirMTq8rZ1AX6SXQjEoGxzBDRztESWkgtiwoZ+iLVdhK9Uc
-Ig4zqbV4c6TucIaDkCuNaFoEX0feHHDjoZkTLSHPGw4AaAZP/pNrJb6dpT3m+TlLR8FuvbuMfb/t
-ITQf6lLQhuTxt13NOp83skfkVUbvHKDXTK/6eHBPqwJACpZhKoz0h5z70xqcYdw0IlFhub4RtpAB
-0OwVyen9QuDkiuJOhT1to/HnyT49yt2ycty0JhxWMtaAl/htR8LC/nDBEisRNa4Ryp+/WrwAQWce
-9V2m59Q6xgO1Ys/tyDzv8kf2Sl01TMoTic4c0uKYz/vbrzzVD7/SbTINfH+5V0pYMQczhmzB3vyM
-+vf3uvy9BAWcPYteBmcxUaZPP/46uuky5WieoiqosHiB91GXgGgNzzwVI/UcstlZZ+L9FLvoEWi6
-JXiKadIOF9ymtOr+0M86KOXTzU+YISf1TiQNrmrqDIkRUZNHaC1IXUOCQ01KcnCaRp8eSCG7EZmw
-EFDmXLrgnuo34CN0JPfXHmaeMaGyKL9oQbcSH3TP4PeqyG5EB2iMhzHrd73im/yOMtXi6ZLFkPUU
-OD1Vs/wS0FiIPRxOzZa0NjszqFX9yl7K46eAV9iOL4GAKSeBbJEN/iaARx5YabnYmM+uAwTyOOfT
-E41RL1XywjCsSNMo6bmFpPCUUXdGIxWFoVTaV7low/A3Tj5rd6DfESSwISLgcYVSV8UhF8p6xIv0
-RTShNT8DFfKS1Dsrtz2jwkqdeLRPBSdNv+LEUEm3KgzO3tIMATGbMOz8B9DCWjYmgCF9ikxZoL7U
-fHow7N0UViUvhMs/bINuZKT5R4hQd4oDatmevegNzQbI+AYxIJi0RKnoVdeBHfic1B2kqu4H2Wlt
-CZHP99ooThq+TQHQlNYoQ/MQSwhvI996Zb9hxpRmUmgdMJaA74bvOfT2bhGz2gqkem/80iGRsD/V
-fhWHQLSXZ/pR1rnoyR6Kl8lGoD5Aq2Y+TA5aJNA0FLwx2h2ZV/Z8nRxiiSAYid34pGhRksEpSogW
-yRchC9iPoG7WHbXm8Vu0x566NPTILqe/JyGLmaYEuJHA2Zj6MLI9ah6MKKK8tNm66g==
-	]]>
-	<![CDATA[
-	bCouJISeZKGjMChXCbDWpQJxoHDaX+cbPIFfNjRzE8vMD07BrKooO7g8nU4Zpe1KKvxTMqVXSAgS
-lNSWnUVMFFlq/WTECPQ10B0+gxgKrf09dEezFsS1j45LpWX2YOADrXg/Ot7REIfdVoT7zug7vFop
-f3CpsaHgBBSuEX18j+3qNmjTuaaD8MJsHdDrsznN0D1sXPdwAx0KGB/4ZKAKGdthMUiU+p3BFlND
-BqM0ztCt/h7njYSJIVnJHe6InsNXLh3B0L0ExTmtWZpWWmwyyodREEqYP+ZarT+XyqDzR0Cd9CuM
-E/ixQW5wI0UsHhHu/pobDsGOQbF0DNmPdSgC6wy1qy49PMl9AJevAAYATZc8TYWfH5+qPPWVP1Z2
-CXk7d8/rUVXc18NO2UNVPhSY8HUHoNvumGY6KVK8Z4eXldVLtIW549N07oyUr97b/ocjs2I8+VIs
-++HfSvZXm3j0+7NtuSJ6qY8417P3oH7sZGP/DFNwhDVVDUojRL60j1F800OZRNg//XiIqk0eQiGb
-n/qQBJRW1lmpG5znM7HvIm3NdoUkI0SljoXIgzIRlzglClcCq6htKM7HkKsVkudd1RcaYNpGS41v
-tWuk7dE04ajk3cMJStOeHzpZo3sMbPI66iSyyjGiB5q6GMGFXmbnh042KP1Aiszus+MyYgPoYRpp
-93mq/dOf4+uWrvjZ3OjTQok/HwXBvp/c/beoZ1YHV90wBBDu+3mRdkgO1VfOopilj2VN9n7On5LI
-p5T3HHFxYr9tHtfRpdgIS7Z29SFW1B1gBugQftph4/bIr3WO3Snbz2APvoS4aBn2pavfrEOvNxEb
-M7gDu9kQShG+PGahHJEHUzxSrP0s3gNZGiHRbk+Z8KNyfrXxqUsOKqjEFD0y4AtnVwOglgqNr1t5
-zpft40KZU9ThRginxqxTSD27CmNmpt0I5GkEJFTV1zWNG8/4WJlrkkMSOUXMwaoOrRniK5XiqwqX
-KQ5GSElQ4rDTSTGVbrgrXmMDn3d6z08dxzaQLEHX8lilqwApJnU4SgmGr2gtVdilL40/87pKyCGN
-C6J1QMoBuEez/4qpAPEsHe9xRLJVS04rN+oc84YFIqKtlp/Rv2HVRyuCYCvQqSi4kHTU8LaaA0/O
-0I++SM9eQGpat4QM2hEkXFMkivNIJBzrEvA0OLwc0nQ2htKI9X1XUTJB0jgRLZLeZkBrpcN37git
-cNhHFoGGK1jBJyYl40F5ADDfE/SMKM5QMTOifth4/YrWl1EHKJpekpqUjUBMoKLzm+K2WJMNXUtL
-SDIJCfdm5wXB5luE6vv2LZqD9gRPJEJrWBJLYXXErhVVr0J4q88zzaWIFSTuqzdT5tMUf48yspBj
-0RJQ9RKoUZZw7tyc/x6GdF81cSBZJIFf5eGgybcQpfnr94nrT+TRcbMUGmSWl+E2PiI81Uu8//BZ
-zRQUYynWs2YhnJF3WQS4Svb+0fJhDqjl2HcVka6CzBM3HlXMAbPQY3cS4iZ15tvoGDxhy+RWE5Rg
-/7gfShl5o6bgLJdwWimPOoGQhjUgEvwX2gvAJPbKFCy66zFeL6qMu1HYXXlFkO3MVqc7rE4aRxUt
-Kl1yh9VCPlu4pcqXbPBd8iVN1NMRZ71is62UWF6m10cRcQ3KzsqfOPWoEEnrmw/EcNkwcbAZQkDL
-QHXtxd6+jW5WeR29+CVrPKWkdUXWgy1EI+qw0A8L3xBm7uLtFRDiDDo4N2xsndZl7baG4nfCblNn
-Q8KuKUsomT+nuPO95RBFdQNn0gCOpj+Qd9dp4YlEpDOkrqlE4K3fl8bRR4oU00MqHgvbWafQs248
-iAuiULLi4FpQMAorYrxbiZUgJa7zXbsr9MXSUTdzKGJVk4fttazLeLRRWCcRoIoU+gsq1rGbHSWU
-QHgZmKOpl8LIKwPNOGvMsrw5fnuCMcQm9pYfLv1KKQYK/yvles57BUEQFIpY30u5o9k+ruOuifi9
-Vt8PeCG1DM6EFnrDe7UknAJCu7Jq2ojLdQo7nMVHmh7jCmD9Lh9qtl4jZ4QagVuzr7Afvla1F16R
-uQ9ncaRH+FqKIgz3iKvtZFZDavdRZttkEeWPbZVKZ2TjaFVQaF80WdM9onbuLpZrmfdi8KoTYvbw
-Cky5+I5qtKkBPoUH04WIM0yP9yGXot+jUDZBjugfyuvNGsk1Hi4xwDDgFBjc9GqASpiQDoaljekP
-MGiT3fvp6iv7xL6C+UcrfE2/Sh+IiH0buI3SmX0BQjKogEDLLknjr1frFIjepo4jZsE2mxEWL5SQ
-LpQJcTHB795zfSA96k2+SC9uN9C7JOp5q+38QMbgE72k+T/wqBVqDgzWMxVqOl1iZej8186bTA0w
-1/Wg8O7qS+lBcFebPBE2aNGZMtiqUt1MK6IiW/3hUu4TWkXoc6RYpnSy36mM3Iuq35yfhCrpNOdH
-+CKEsWIqv+mcrKMgJgjglKx7IClG5yP6xoEorKjeX2n/Knepln//pox0i2Ub5T11FFBDeT2GViE1
-ruLQqDhdUgQcXkObqTsuOB5sl2JRyLrlxEQ7kblu6NyrCTtX/NhZ23M8wbN0DFZ3usVMBj15eAmP
-vISQJyEvj713QFiAB3iDqU0bnQuDEVl2foOk4H3Fq+/76dgaK8LKsAZtSpDDWdOUbylrlNh0i1mF
-5mwK5oOlu3OYat/OpPT8MkU6iwWodmxSzSu7lJP88jjdpQ3K4nj2oiG4xHl/1bwJ493PrfjCe6Zb
-Qnhxlu8npYNcyh5FKdHCkENCYyGQ9asyUFHLL1SsK+hNcZMtH2hnN7ii1b/cwY72RCGg4uzbHj1n
-05coUcmoe+mFeBbCuWpJx9OeYcw4+IW7rXtBVVAt4ToqtPz3UmbZGUvb3b8oFx98grrJUcgx22TM
-ysPXPMCxZMHCQ267VARWRO3Iog0eGTM7cAwXrMglkWb1+mRxMngmZu/tKOO+lHnPZ8xF+jX3HZCv
-wJBrF/rhjjrfMR4Xr6PnrfkgH1US6wV2c0i75ydoEuZQ3rq+KcFcvr7RvgmyWb3hNcvgc0gxHNGt
-Bcy4QOYxZ0apDuZJuxuXY2Uq81zIVA8Rm4zTojE7WCnFWMHWP5DIsVS6RnF7NYoyOIWN4gYNUWV9
-IPkxM4JjP65Ht8XaGyrJaUqQpJsD2xkufBkHl8ItMNC7N4d1jgfFPQOgykGBIBDn3DPF2QcOoyf6
-lyPgtKpzgAxI+YkD1OmP0PKDJb4qOPes2FedWEMRv+t6lORIt8H560NXaBzTfzc3ibvyKCL+xxa4
-H+xSqsxI3kV610FJ1pZF3FHxWVhVY2nZUoBOKnloIaYwVdeqE1r+1y7gcW3trUohwqqPeLf48L4U
-qhhZglih3NWejRiWFtM5SY8CQjx14Kr0ywD3eOofvNeZIkXx+9nQtkMrzs51cE5ZQrNCZo/cKrv0
-KtIiTiVQzMjxfmQBtSNssQ+8ohcFoNY2pTOr2u13q/hxnRXPMNlpvoeFd2ZfF03zknObA/yqMghQ
-06MqO6uwZ0ytfnkQraMCmjuS9YFIk/ozwR8Qiyh1z5qlEnzOVx0GDKGOwJaJ1iyczPDCnQzXE/dc
-sQN8RTjVkOl+3tV5VVDkUMn/gECx6MpgYAQUAWFfZTGvhHxGKvZrHl4r5yzPlPdN+1ZKbqn/3IWD
-a3irG7kB49rFLwbAJfgVOpCQrDbrBKHL6Z6BwcON6dwrXVXgQurRCrjxbnRvSOdvxF9BZlYMSSn7
-7KJxSo+xXTQKS6lp9jWSHA8jXjgFj6bOc6ci2D0/RhYZZ3l6gzIUX3os+LKr9BBYkeyhl7o17PXA
-O7c0rSfGTB+bpGNWqxqgP5WbYadiOs1kCV/lWkborvSHTJmsZcJimvdbje5uNfECk0sn52ypJSpf
-QXbZcorQ5xUAqEpf2reXdiyVuwNu6bqbRPqNpI5InM/MYltSWaGvycPKoVAKhcAWz0f6jnK/nf9M
-oxmEM6pSPT2IARqKsl4hKduMvkXT3jNNWMKktqpIcKWx2FIX8lvK5Q0VMkXaOE/6Fv4mgVn689RY
-+b0le2tdTT0zRX2Lzt9i/MTXURo0c+k86lXWLzucQqBq1CIoP9H/FN62rR0VdejR6pDPZ0CoIKaW
-knsZXCrP2E12nceRbqeoBALz9FGJ/zYhLgqFIrNCJv5acviP1OX+FRvpg4PkexvpP326/+XTcCb+
-yYfHXz7c2SH+yafPv3x6El/8u37W+3+In/V/4VFQu4ei3u/5Eo/y2Gueur62X2nK0UPfMjCc4kth
-lcdLtuqThcQ5HzxKeZTT1e7ZHMI9HX8qopIw0/F6as2cAuUzxvJhdhpq2uCdAaDk6wQz6gc7i1je
-FJO5U8EfHmkUbA3OV6meFKDuLBNJuGuHpzzUGwBSHGqrAG5XokvSLX0FPuXFWGzeXXvv9Jui1WXT
-JbC6qyjxgFP7+ZRSwSvdhduM1XO30S0F/3j6YoD5bEQiYbPWc9txcewGr9VgB2HrxXLh7icNMaUg
-FfiTqeD/v2r/L12130rC3/u6XZbhWD3vAOeG7k7fUB9NDL9/jQsuKphbvBhIBpYDeUMME3CXW+a5
-auoY1dCD5xQ8StuGZE5P+fZYk73SnU8T6UoGnlqKhWOO9XaGyUnh96jaUo9Wavu0cyn0ij3UfOWl
-nuPaf66gPpTrZWOsGT+oX3gKLElL06j8sysRqRB/mHPTH7lTQVtm4SPVQXxqlJC9ouKSmCiW7kvt
-3Ky+GGSyI1LaJc0Tk/oSL5mQgEJLSR4UCQY4QMRerrh9vuTDCgLrH3SQOsSOrUj0vmDfHLMAfnEx
-NJ23NAYU/EhMRdwZb/V5JXV5Qae4MQVhF9liX2jbuaXy23eyZOLaSj+uQKDfG+lR0JDr0atV2i4d
-rP1RN2hoAxNRkIp2o9Q7BXtrupdCqkTLMy7mQZPa5A2N/+6Vv9PJOjDcMtHNSI9yMyNG5F6J4HhP
-PiwC+B8ZDOxL+LE1FJI8vRfJIsUrMFR5M6W1XjQByHP8vjsasL86dDk/7h4Ka/wRrAryBTuOnrrk
-KZNCRV9UW3wUqo63W11puYnkI87H+UrSivtM/yO3lrl0RirBoeAsbiXxdy5lht35VTFS97cjPO8P
-vSP1OSKu493eBSZ9DEX9VWPkuZUoL2NBgvpm6nEErKFdxO0b7R8KOa955IG0EodmKkQ21MKtBX5E
-L66UOh+CIDNLqj4zy8558qpmaH0/jcE+kplr/ZukhtksXZCVnM8z50Pmms+xbMPf52b6mbWxnwru
-+TB9OZytVKipzz3CIrvUSh6R9mIVn3EvpO+X9iLVIEvWreQN7/I1/OQNX9T8CJ21VSzOkkl4AMuO
-3cyajLq9UVXMDjUixP4SWOoDAaHJDkd4ZIXiHUxMDWv3kwbPQmAqdHxU+Z1smERcwwrE9QnzNdR9
-UDnRNQCp1v7cP25lmanxxYiP+n2U9h913NrgVVMz5ex6Tld/WUadWYzFXTZ4VRXh9A==
-	]]>
-	<![CDATA[
-	3Coz4A0M5Vyi+gCr0EmRljlRNmaljtTrbeZGs3R7ZzyPovPfbFxeCpcyfkMD5pM4RQPbgIxDueGy
-Y3wKObwstoKSulT//frLpfgNjeetOZYlhejpSg78/jT9G5OdNf7taOX6HxKt/JBjAOADMh9pJbtn
-aMIZbp+/9pJuhjErExRjcvJz+6270oTpsdsiLxOZnBxaxA72k+XhBMVD8SPNfCJrfd9KcxHjzS1w
-ToHFl4bkZgwF70tOcle1GAAtNAY2B2XtX6ph26zoleXgFwm8JkkJemQmzECo3L0VMzEFgXrce4nC
-Lk3OsdMjwPgbA/T/RTPtW1z8vSUe0Fk0Vkb5sfzxC7puQnXEe2M8/Y4UAVQTFo8jNMWhvhHBAtAD
-YASjRQGm75JLa6nko8tLA2e0TJX3hrZyeo0q1PfCnlCWYn8H0lVaUJYMBVGJW+w7iBMmCjEirl7A
-EkDIAhQGuqOd4VluXyVkRcDOQd6llitTThHHL0hR6D3ZidtHezT1iP16BKp6wPH0NnAwax/YhpKZ
-4yG9tirfUZg/Siy+RatthyQBxnjHjDV26mo6Yb21CmjAQ9rxwmkzQcWYwdxoy8dKBMdBF1BXupke
-L7ovM8bjVUkUwmnx9rRCaVkCJKK9bmI9+jh6S0dHUf39rtFtare7yTHRx9YaKYR3aJlQqGORGgku
-fUSWVBVAFPOMY2VPM47iHmx8oCS9fSS5+pgaCQaoSxSj8pbqhBaoeXqX/kJnq3N2K76h6YN/Gulz
-5i5sUBuvgjMoh1KiKFKLu4oKzaVd7YhaBcR85du10+u6709nhBtQnXHnSyRIim5XvcqdFRX2FnFk
-AYNedsZhWNUXL+spRayrzFAkMfKoRW7Xc1whvKy72vs2VQkwUcW7U6Oo9r7MzRJQpG25Qtazoo0s
-AmAKtYREw4hoRHmpdHJ2KWXx5YiTvHYpSQPe1eEdCYgRjZp5JCFA/64rihcMp1ICKz+8z13MsPdD
-pu9+RITcn7J9XPozMWARd7XCDtGmROcdQvcciS2vIEvgb45qnFjJolVzi/S5YtSL8EbIyavwLDQg
-jdtJKg9y+VV+SvZLdhSMic/fSYMqX6cKUErPCnOBk480yHnkInXI7x1qVi6SGgiCYMwAZsxtaSSc
-56qa3HqEAm0tqwMy/AVaUTNw4QO5ahq8fBUoj7UIgebhWUhQuH2lpavB5ONfyxOXmr8KV8dFO92W
-NQrOY3ztW0rpUg2J0aMeEvyLIjOX0kbvSbjNATTaVa/CpOCK6s4qhHgyhx7jau2QMg3RcwDmsM2L
-hS9EKeVaBVhms6CPy9gIPuGK94i9RIGDR4B4UWS822dxgOViKczgA3Y8O2nzTFNz8nywoTy4tmoF
-9wCElOZyeyJ8bxFbSitebQVWDqzdgvGx8uWoK2/97A/QHNRBUK1EzQdamPS659MJayWU3Z+ShJZ8
-S/HfMhABstej3ipUsK7jTV6tUko3No2A12NjgoIb2SMQ9NK+yX6EoML5MPAVDZwRdM22OgI1neKx
-q+m2A6HWRLhV8VMK81k6eW71wFYCjM0O0CIoqNkXiSqFVV2XLtGnr7vEIzAiLi1m9O957ucHYnUG
-Mgfl0F3+qVnR2aq3hs+Eft47/HQOQOGIIPNlA43iNnO77QFUxXMOO4+wYnqmHVWFcxeAnNT2LGaS
-yX/w8/HlTVPLPA0aKUxfLGuopY75aFAO94gZGydwnaI9FDvVNsnVP/Xu0UxPjrAKg4QiFHIMTWLt
-efVgz13okPbDe+otzt29BKMBHx4JZuzs9YpB+n5QSxiXlgODQLc4FyukKkScu7kqdOPjO3qsoxJX
-iouYt4wCSkIrUSWXG5GjyRPnfCM0ZGLrNXIYJNocoFQHeG3050fwgLR8LZHLUcD4gZJD7Kw03OvR
-3/36y6gKFhcqlDCiqaL676HjhAEn/75E/Og0Mkb+dB/50/kLsDq+D2x/Ik4eW9ceCxYzndi1Zh/T
-VDYlhbs8nOBHBMVGBHx8MPLqjaBocZWfpqGMdDy7siXMTbXmeuQHzoLyzPI3o6ai4zFlOMvNu5f1
-86Wnz5N93aXzfBfIhy3uYveZPYLRyqSCl0BF8ni6MjJMFE8YKYS4NSkMJpb8qD08Z8pK2O2ViD/x
-YzmUkHliR7ly8KjZwtFpQ+j+WOf954Hi93fZjxaEd1reCuG9059d1V6dm96nDas/Ok89C3PY9Et1
-6B1V3FmB/SoaoZo0VOoUSO+VBrVisGnddLprtYcQroOrplxttlTMu7Itniyvxw/hyy9Uv7uH9Hsy
-KdJEBKGaB3JAndJOVGsuiKBmHYQ1ct3PzCMAhh7aT2VMiNQuLlBkjA72D8fQoBFILokYfXhYiYIB
-1adnJxMl5I4KjoDDIJgisvZAUQhcjSyF5UiU7gXEHo+ZVK+DFbzmpLLUguRwJ2f7/5OZbCG3htpM
-gb/vtrIdxyBNgLnU5/kgt2mZWBwOH2iaSRl3vm+zRTOGOvotgPuIpHf6KnunGBHityiooFWKOCYy
-4y7e817JBGapQokefwh19xUQGjXjUOdi0MX2XxDU2eqEJR8WIAQQxPPTpHyE2Z+oFWueESk2Kjaq
-X2ORajLAXxKZS9F3X/lLRYLDvixCnYzN86oscdd1t1nvk43wt+eqavdxPd8XVuPNr5EydxYjEMyz
-A1eUeIHeWJvmslVIlY+85lWOBcSrGjJQbArkfJdOLMHEii0cFnOSZ+/yyGCHO58QJDeCtmELTPJ+
-iLUwbM13VOlvwdq2axeWeAq1HY/fKg5Kvrw9grmh1KUmKiNpMkCHy07WI8PxRYqcfOY4yt5CjM5n
-ZPp39sO5LSY1KcKRPJKxeV+5LKg9VAtP3k60Hy5H5hWLUDIem9+7NPX5fimBiuwcwT93WepcRlX6
-qzeZ5HyfIfb+/ouVPPYyKRVuVHf5rXtTQlR5TuPObaqBxw8+c9D7WILc5Hfl8abnz2tRvX6PmNDz
-Nnfh4cg/AiO/i9ms54ksEQK/mVngE+e6HhFk5kparjQ1Pfm0s6yux3HVrHs8uueooozmUDJxekTL
-+J1ZNywEtSZu5R5qDQcmscoxeiogmJJKgH/z0BIxS6pMQmclBy68+tAkYBLauWrHEA6HCXChVdlE
-xDxTbecJntdjK7Kiji6+8xbA0dO8YF+7CtpNN044LZGhbAWY9wHdsi+xJxDyjaTabQUP3/Vq6Slg
-IfUB3FfX41YNKkDHu/JzpzxCE/uQr/OCXxJ/9THSzYEkpqbAIQqmSNbAMFagdtEearoDWWu7dHo5
-TK6VDrHv5xlponoqHeNBMZ4t/qr2xqlGZPcILOjZ9LU3j0mJqsyMJI7U9whCgGimy5aw7P1N/beI
-fih7hp73jKKrD4pkUdPFFoKQDBRjdRVteb55diMZEwPrROdsVjmBVDB6PviZRWCg/LwpkUZ8aUQM
-kwgjTPCRtqABtSa3GbpU05/yNHov3/H7ISz0B3WNak0082qyDwMH/y3UmNRnxnEIJCTPQe7kkSHx
-ERrN1S9ij6GeWehTPLZ4DMhzhZbfUiOgcxtiR4u+DgPxeCd+kPOol0AcTdKuf6R6GNBqCPteyZS9
-HMm//mJPu4cUZ83k/OhGctHSCGOeBTG46pK/xng/UXsthqL1Mx+Q2Pj0S0f4DdgN5BFXv5X13Vak
-HjRhJvaVaHhnQqaUQqt6htpm9WMGkJI89SgPx8ZZ5ESh/GYg+94NAvu4b+PyF7UkE8OK1wozlffB
-CeLWdK5oDL5kQMrDP+o+R9iP1XEaxeKZV3gNbFOBrXNYy8HiyLnOnJ6KF/yM6H794Kf4FHDIjmB/
-/vGLygFSd+DDe+hKbhrhxpq900rXzljJkh6pVLgBvWQ2JnlYmtVHCv3RElICe2e9ySHhgDyC/HNb
-98S6H94++bkPjhPS7plOi5FsR/x2FOYlixgQ3SqKmOfibbHVc+Je62myx7/hI/RkUEQsRZ+NVo7F
-f0V6pCpE1Yj22ixMTNDcsU7Zhmcp196zvOUQjH7Q0VEKg/Kno8p9FxzvgoLCvkeMotTrRZ4Y0BG9
-hqMHFBG+35olCnhXmLTKUpU8c+agi2Fay42IQIcQri4Et1G1rFYbMHy6Vrh2G4izmi5gIT5cylIT
-Oq5wbwGQVPkfMVWJFjzSFa5SuTj6Tovvs0JN8NU/aJxjpaohckgYhWXNmZgmFDmKbml78jTvo2pz
-RQfhoe/7wzLy39nmKM3p4Alj/szLUzF5fiL4Yc22ABXWBll3M4ZG3JPWuGkFxO7hKp8BQ2LfGrBK
-jW4MW88AlUa5FqryxC6nIciZKC7iXDxlIm9DcKfRnU5B3l/cSJkSR4Wt996hE0XWUbtW6909QVx+
-XgDaqFzNQL16Qb1sIaQEjR/7kar3Q0WVYOAGsB9elsXk+l0xatQVcQb9YqhcsLG8/YiNW+doJfME
-F7f6Pz1lR4G3pcwKyTlzqtV60wzZ7MmquC14Yf9Re5pPE9LRIHKcfdG0UgZWrjDGXzJH+F+KCXmF
-WvU17XpmOCJKEjH4/VYy1eCLwNLxAQFb+y67mwPEzq42V1WgjvNTHKIi2oqfsetQgKtbFXP4cbFM
-3qWT5ytSENNqdqy8jopMUgavNmp/CIdPDOJYmVQTNV3P44wPoGMzulQhOH4Gq0v52NCSiyvQxVi1
-DFv4AF5rA7VGH+/xVlBpW4lK1YVAHuegI65+X3Pf95nfcny4lRxcmSy1fdm061eRYu7SV+PJnpew
-OtWBV00EqfVRYq1pMAvpJMzrbrWdXYEavko49c60fq5mDa+aJtlmmzDR8UFEPqTPXUpjjEWCz8Kg
-nG2n1n76A2vM/UzvUqU6CoEXJ3FNpZ3z83gmOJYnLo3V1jO/Vf5kCUUCQ7sw+Vzo/M+rmjsn5vYs
-yKf3y9z2h9qtPKp3FLD7bhU+y+qXErnLUbMmWD9YdLSGVGLDtfFsKTkmREJX21X7GNJkd4y2SPSm
-z+yOrbLzodsA2vhnMR21ya3d0XcLhz0M3lYLl93R5FOXiDvsq4cUrpXjedauur9VSD3nxxn6p9sH
-KNIUtXS7SNVX+jt7rMUjvDe049KOw1N7JiPhKsqEV46HABbliaoCOJ6lB5nUqsjVU3moh9kMRjT1
-mg9P2FrhVRiRHKf+x2t8sL8fpq9SB5l/d23s11keONoNeRBc87eHt5XtjsOIs6usqXcpZ8LG6rOG
-ckeAc8+arkehcl/6BOUU3/K0PMXvz856WIOG7HU+P3U9AgWcvVG4viPYIrY1snnssIrEEC+t69Po
-DGMcOuF49s2h3QazQoE3FovO7RLXr5D0adivYuqddpR3wXIFVBvJSIG8rgrIApJkJssevqvmoeV3
-y+QpBDE1Yh/tDgw84Vvo/NeKnjx/M5DK6ypnqbvOLC222mPfFkrX9Ujaa8i0gkLVfuN1BzhEWeRR
-dbqPR2nkrIY0/FaTbsLVFLCOGJIb1F79uS6SNAS+AloYEUtBcCzjFOLwTD3lLgNiag==
-	]]>
-	<![CDATA[
-	TKrRjCcWvp5mPxVkYa2EqVdkreMcz3WESm6qu44AprF6XCrx22Z5MiHIeS2gfRgtI1FhWVGgW+Yb
-xtlwliSrzuy0e3Ypis4jQAkA9tnNeRqWZKiA2VPhM1ZNphKpsX5stWPO2BoyUFKzROz+oRYgOp9I
-gvhjTvRTHSNbFGL5IUaPapGTUWxPibLacGZEPXsEGxGg/A5/cZyPSNLdy3lutjSMfYFi2y8FSkNq
-D69bI6NHrUgzH9Hfs+ik+8Hw33cx01Xsttd2z2j3V7NspeLqztzDcmglnIT/yRx1cl4yV2mY3ePT
-aXt+iE6sK7Fo5VF3rUjNmVdq07Pv+t79KKeuntacu4irHGJVe/Yf+6IvHUOeO24VdbthT+UmPFZ7
-8Ee9VIKaKri9cAlaNv+MvHw7Hf4zc2zX5PoTgnGkAMuS7MwwWsdU+yDhogdCB5j3cdm68p+gUCBs
-Jx6z5wwTqKWLM0qo4WoRtKejjM4uZ95WQY9uNch3Whcq/48sfY5KNJZwj2A3QekkWpFjRh8ZLjsR
-EkhCkIZ8ghoXbpkUjLRm5PN3nKVbgAWYSRAIXkfIF5pLAIXbQdfzb0J+VFm0Kyi273vScf6AdScw
-gm8fTReMHuGaoErNb3saSSjjCALo2ZBnGTkJAlBHD5qyfb+dXHWyAy69f+0HzhHGv7BNccmIy1DJ
-QmePgBxikszbK2QYSvGn55/1lvcGj34AwpD0ishFZjl8PhSAeaYFy2FrSN5ExtyegO8jHJDC9djz
-mg11jbtVK/zyS0ml/nrtUoBppcRM9SF2Ly2YVHaLvh7RLWoN94490T/sQ8rKgmivYi6q7roz9XiX
-vxRxDwJrFVqt74LFzZCePZ123OYsLowWWwmRUwkogDaw3NnEVHgaerSVH/3tv22i46x2lqx2pcjY
-uLXCltp4wqJ8X+kvCqAgHL7nc3Oag0mvUuaXn3SU3VGJiZMRtxgC6jmeZ6NjB2OX+TulTcIHUaOj
-qp9GsTEcPCI/QWgZX6b46qr/N7V3OhWQS2qmTcKqQJlpVGZSlkh2UsQ9S7cFsBZ99V2Sb7nE4Ayz
-iBTxdh6y8hQ79WR9lHnqZ6keUQXkTd1B0QbSIVIufd1ZCDygFg8KCfll1aJi5wkscHhJjw7Pb7QL
-Hq/IvKZ3YuaXRO6B1jUnPZDNWbB5lbG1airtYZqKRxzqlNg/e6BjCrir/DeC9MPg+ihg1Yy/ZQJ7
-pivQLXjIJvWyUBJ03VoJiejhujvvxsBZzd6zJBQ5BafNVWxAOX2a4VCKWUBLWCimrhz3/8gY3gMc
-UHpoMxJhBGAkUSe5Hwvdnf533YOyc62cG/MpjJaYDa3+kt1ujVKHvh6MiZEWrmd8e5ZzsZ/qxToO
-54Zw79RlmjHUI/w67Rb5EJJDjGQJxkiqbvO5DI8iFAT4MQY2jNAy9QefPnTcY0aeSonnn3cMvXx6
-GKTlSYl78hnf9afC4zh2FVuB9FAI9m0Vk0xlWdfdU6gBL0So4iLLjzmd0FhBnUH3wY1jIlGQU60R
-2TpAwaS8iuKJlXi/TXLS8rrCGpjWFgZ5alqM8pwXhyrB+grdECDQXbJRpHq3fnktkpGpj6ByPyKi
-HWi6cKCzRJICoHBdxQeLUEp3k6BjRdcdXuRTy2I0MATquUp4xOydgR5r5Mi6kDud/dGd5a74u6P6
-WebAmqhZwtppfglFLQ7hStEVYFNLu9A1aO/j9t8eBnt83OEYumLEudYK6iWmuQBKVPpEMK9rsapU
-Mvd2BFpiBXi2q3qM2gzDBEqP0QCFAQkR+UkRZKWAtq5szUu7sOrf8SBUrDEcbN+ckYZcZ7bMIy+m
-Kd9xtEgaCsQkWdWArE6doSj7rsfDv2Pm+UhOjTMlU3XWZs2IQV65S/PDa464EwZixh/FmHeFdVwH
-ImV3MGddndEI6GqnuCOWFjrpKr3+HG6Wu+H/j3jYRPf38X4MCfn9YbpVpSlO6A0IfEQ/6h++B71n
-UQWaVkKRwATiO1LrPxXyo4CxSjyFx7qN9dbFUt4Y/SSas09AfY2avBlkqrmw/jjR54zkle5//FSQ
-DMAjyBQoKgfHwPcsl2GTCEKpV+l/4MBHSumtvL1xV7vceZ5G9smO8n6c6lweUktEI/WCTJm1ClLo
-pMQJ4TznRwuynhCPR0ZgDGKCgG27egl8OVIIG4V+3plPcyYAxkqe00gNLdVzYNS8b9SnQRd87Mgr
-goamawkJ3GD7SCDvFYvnB4L6CIBXiemrbCAIfw3O3w/szD2dTG4Byol14T3SdKl/D7zcruM5cQGT
-Em/h8ook2++OgPlB8/C9Yoi2oKdhxAM8lQANHsRUqi74VutEDPTkGJ4QhPD+yBGTWqYEyWEQsc0v
-oNDlf39vJ9wTe+F3Wc/fqTbzr8tWHDAW/mXdCpO2f1m34qQ2908+Pb9Tudj/9L6vv3z64qT+36KJ
-8V/BlRVtYCqxHv7ImMUBaQnnFUfE99Z0KcffWVE6izAbz4L0ug7ZX+605dC8xflgzgBR2MepHOLv
-uGMkRj5EtQL8IgXSyNnzz4MiGjgIGhJUu2gwpphBazaDq4R9s/xRtxbocMW3WObOxwluRxB24TpA
-vwChBgfWt4FRfqE+hvBgCztJuhEHoN+ELVlHsdhmFnAknNrwvXOTV1qwOLypC4XIBLkvmZ8lYwH+
-lzGLzIQHvn2dCZAi/nqFw2cjWBTeWcK2hpn1SP4ugZr/f6H/X7XQPwW3dXwPhLF7+D6mwDFSJv8D
-34nAWKiJD4uxS1kKGiVpOe44mlJZf2yGj0S/hD79CtSs9fcRjIrJDl7NIAithxbEZi8XMKU+etYB
-VZh7FkSbMgTBhpLPJWo7wj2jCbKMNKnXAORTbu5K3f8MfU8EwReJQwTB4k2o1YOVpH2mQ3eLFLc9
-Iys490c+b3uNdeh/JEuG7QcAV1IVDIs71K8IdLNGJdEVD7fSU9rswBiuUoR+BxjSGM3uzfqIsICf
-RphLFeY7NMCmBrOudCEc6oRjRvvO4cI6u58MUxDRXYxns0ISTAbst5AU0hATLzxzERWLlK4iigiJ
-i2CEwBda6EuafXdgXvU4y6BV/uuVZ9O0JfMRi7HhkSO0C+pZtZVRbD9hyKVTO0OiQvJaQXYjnzvM
-OQVHx5H2FyCeWXUhkuvhJGmVqlGJucschnl2vuNy5pl7eCJ1ezSgq4R1kbu9pyAQo1g/u6f1X7XZ
-nA8EVm7M47PJoiDMZlFUV/FKefbiVRRX94qDEEMROLryWBgILeCy6HpR2ih1mytApavKKg4wkUU9
-529YDWSBPviES/O4rFmtt1jEtYaFKHy3qH8iw8kfTUP9ukNxtI8DdoGsmC3kDrUlypi7mHoq6SOL
-d0TopSTlojZ5y/CKjIxyzjRdlK0xr4TdwsNvj90EelLNmXU/+rdUo74t7/L/ZqHO9h9SivhuY20/
-IAzHb9bEjwDigy/UP5YcSjVNEhtw3d9A4Ssu13LkkwNfVdgFTH7Zw+7RFBU4nra8dTwiozKvA364
-pHaquKecEBCxWUw5cX5y6pH5D54dbSVIDHOWEwG78HmbeUZ7+JZMvUi2Cod4J5UnUVHS976DPqU7
-IrIZzB8PgS5pCyCIjftOjLZXcUTcGRWm3wGKKeWnEGFxJ84U7FH/uAqCKHQQWdrSfPI/XBV4FkqS
-Ru5VhHSVl/gCBnRDYe4B0QCgV7qz9xHeskCBXY+ONgOfGdWPtErIzN4Ga3aTqZH6TTMXHTPfVLSB
-I9g3TtAefJJ9ze5ngsi/Fdyz8dDqmvfhlw+sPesa1Skciqr6/UgY7IKe8rOrgZH5ctezpx25CngK
-XelQ9yBAQ57vjhBCcCmiE053Ml3lAwjAz4rm/wp6T9QELU2VKW8KqsfwXZeCHO1TVJGZDwF1FvRk
-7qJ9iVzoJvB2dbiIqIBZVX7Y3JxYWJIHDYZv3QdPG1AjYcHtKrmY4VMXy6sEBKBZCP8kXRmuEpPl
-LxJGPL7hWwhRJ4WndUfNw048y3GHgnyPp5EfdPwuT1PtItYZyvT6tdgk/lHpVF/cCKQ6OPS+t98d
-iuzSLjNTO2PNz1Sff+TmZjl/ffUi2b3SSii7ga7mD84jiDJ2HIAdbjmrLqEK7ED+qAYl/tvq0l/3
-qJ95TMwyc+dpA7WK9Th8nC7h3Oa2XuQAQc+n/YYQ3xkJE/W3QoidqcqQ96nSQdSJbAAOa8LWsH5r
-1cN8ssX76ULu9GKAvQjgvB5/e+JMmMZoXD9WU6Be3MLKHTBmI9O1rOaJq5ImGcufX/gzTpf+/emC
-vrcCMeL8Ls+Xbr8LRul8BFmJws+Y8kSRvfdToT3UnMpiomvS5FVuAu8QitTqvaEpbOtpLXOaNBy9
-vvLgQzu2x8/Lwp92eMKm+LZwX4D7n1FSFqTHdcitSRc9yzEAw3bjFnWn5EicpfD6ECvNFmaUFtoj
-yYhgvxKESjs7cGW3biKgyypkhxzdqv6oaPtNhIUEwjRXAWuH66m3VEHjXW5XkH3E7iBluyTsXsU0
-w87AtnUrUPWXWBOmIUVDPda6R2RpdHbKv20o2p+qmvpCtrZhyuTzXkW0p9gvSoYRGV+W/4PXYewd
-0OoPVWahi05uSz89DqSrYAK0NSkaPtfdGQs8SF8wZnd7Tg1G0u+l1aY0V8bIXRxrnj8K5VOCbc/6
-0Cb+iLHVGV+ClfouhY+S7dTAGiQnU0yJfp/3jC63RZ28FWjm7Ru8zHdHGwp2sGR03y8wljYK4eks
-AGCq+2zZYjlVTivfOSeZTm3bFAyNwEl3AXSm11YWNVLjM7TyXFA9JtxS909PC3IfpILbmaj/S0zB
-9atmdc50iGdK1Eyxw1nPmupqnj/iKS48wmbHXL+304InENcwli/OWe1PZuCUypjtj5K0G4Emkh9e
-MtuFLr1oB9xBQDIWCcNRqqeaBsAQYmXIJu6P4jk/9zA5Zcgud3uMybvpxuGKjs+KuxNID3enpJo/
-7Fg/E13m77U4dnoAeNrokoCVEJtfdwcZ9kpc5ArtKiS9aKEp1jQLqtWVzXIa9HIjGXFFQt2nrKGa
-nHMX2k86BcYPxRvZ00EVYSdg9caOJH2Eq8y0G13Xdc6UblWd1eAIKYydGqRAiDPMLdKnlY7mHYMq
-iXPyxQR/vDOIc4aMYeWnR3iGLGvEJW2qa0arXDexDkyXxr1aYKMgFETfiYHKXwp+BBVmzQy20+gM
-J0YRmJrtvqoj4ZQz+w51jr99xRO8kE7nh3rRI2FhqBQ4b9c6L8GdUDBHZiI5e6hMWWwYwYkgMNNd
-R5pcDoVrWvEnSd7OX3XJHTXTd8rdVmhXLUhxyqIOhLy0AoCgGFA2RXQLiXUMLp1lHK3smCdQQrEo
-rmheiVlNTjj3tNtPWUfOs70TRgXUwhsYlC/OFeHaL7EDydO9q7WP76WCHfi7nDI7wejAJY0HTHqW
-sFwIu3AI1xHlPQOjT3GaoDjBsHlBua9SDEsqxW8fQGzPshqRe4MThXisNZIx2Ogtig==
-	]]>
-	<![CDATA[
-	FnXyHWUd1+jvGXN/0Tlz5UKdsPmQtDFGugvDF/41F5mf0VYWcOFnQOECPRAJ+f16+tuaZ2SF/261
-efwPqTb/FzWiVS2W8aft2LfP5qsmthTXQ8EowCLOvgZo6XBaHeSe2Yu10W6mWGmoMLkVUNduyBH8
-SdiMz6oH/G29kf9N7/HbwfO9i6o7RXFybqMY0g95dsrF3MWL1Ok61PkIGro1pSbCCX0VoqFpI5tC
-Zskr61Ox0i6LKk3X2F7S2YyD1Zds0bFaJEaS2t8VIoq8+OO+2DnbRhSmdcbw0klaHBmdUAzwxCzh
-ncOzwxE1lV5bhNF4Mqbj0IftUUhgKDzHFSlDRwQPvZBK6RFJYNDk54XwQCQZ+mM7fH1sekGbWHO7
-Si7nS/w6w6XiUHDfdUg/YJLUPWuIYujrFF2W86g/9p+n0Iu6uVBYTuVEzQwfJYuTwF3udyyPpTpR
-IZLJ3COl+rIbkq9cZcUt/LON58Kmwj1Ffh7u7/n1OR9MsHdFuAGx6euXG7nrZd3lnVIPrnwVkY5Q
-C4AHrAIECYfqLvzSEPviAzifBzePsMCo9DhFPuy5/vhM4WB8lUH641DOVIrEFuHgkQicassdseSy
-OoUDaQLaFIN9wpS4ShOfeCHsO98483jWWihH2gQBHspLNaOAxfZd4VSW2kqRK6tPcg4fioUsYVgE
-GxiLowqd6fNRI7pjGNwf4uYN9z8vWY/CrOUg7fxj0m9Z3orE/LDif2axyC8Tbc2z6tVU4HklneH3
-tHQZV+lL2HvRi1ZdNRnOKS79jEj8ew+RV4fvp/4K8FPeGzsicZGVfpGWzjxwfGpkqIzxWM3o0HCO
-VAO/xPxR4B3Ntqh7DLidJwHux8N8KCEoOqClYsOlmWfDQWPF99AVrIJDMRENNjqfOndB544SlSQF
-2JGV6rRez5gFhjKl5LJqWT3GfF56sqCiQBCdouH2egSCHB3kwX61KFWe45nwg1UsnGEk6v9HxqyQ
-+EhcsYPdyardOdIvdWiKRAejupMeOEi1Rk+HabUV73FdprU3bCLrH7San1MEbQxBYwFI70TyjA1b
-4Gdhrx1q7gTkQFa1+WNzas84kwh/zZcm/cIeI68BeWsLsbSSW3t+1n3nCwyqv+Y3pMCU5uv4/PwM
-qWaaIZJ8h4bNMJ+csvsieZcQya4DAtosMZvnvFFj1VT3LBrBE/GfVSbzNcyg3eJFnIvPYuqrlnmt
-zAc5wDGnbPX3euJxBqNkwexKEQNIuoa3zEGBkUyuEZqjczVA9Va7lzNa/RqGNDVXtrtn9u7++N3e
-0b9xYrYAU8+yRDlLPFJz1KZMghoyheXcK4UPX6pGK6zdM5joK2h11/iSZEr2d5VdAzJVlt9Nd8Xz
-yP09IgfXU1mBjoF04SuC3tl3wbXK6z3veEzlc7JtaeebJPUPk/iMWNFz6Sg4wYgnaw8Ww5GUMtyS
-2lVDdS7/sE/91DLMfpw9zj/t42xuI5sb2FzXAZ1yq7OY3whvYn6Hgs2L+lkb+fei9x7AsZY5V/CW
-VtZbaaCpPZsaW9meaHIqDNrKmLhfAWk1Pzj/kY6V8ahhQVe0a5V8X5UDdgGAgcve5cAKTkFpsin2
-bCS2DayZfsrtKQ+yxnWFhu6q3L4jTKst9yyDT8v83c/dFcF05MBAc0HFrey+K1m6w9cViQewGY0p
-NbYhpcUjcZzlXq4/fSqas3zUrjOhZLUJFM1yMGErQF+ZkSjnbOWORgld09vpPXN8pI1tuyckKgTN
-xiNVMlPBm6FyOtSCj2AwMseUgoGoeLuRMOSvxReYoSMjNo+98gyqXoVi/4d1WmmagIA1temCzIvY
-fpRDTBdoLpe4+RMs5yY7oLMo44InHkbErL5vxbZNAQushSNZ1bW+aCon7Tjo9IeBNqf+mc8Uec+u
-DLajylgRHIUJl9J6e6z85oiQas3LmHcp0jTnUyS2+9g/Ql60co7oPM7jubQKKSERJzejeLajZHlJ
-p2EhZeKTqBd0yEGtlhw80kM4VuVO1Nm8xKFWipqe54z0u5yGtWn+mitzupwKgNfXSrA/S1b5v1jR
-Pzd0XcXOwkGBg6Zi114ScTK4TTbJiT1C2QZitp0z0neyxmOIYgKjj/0s0X6nVglSEbX0LIQINlxn
-vvdnbJffq+S+w266eYo40cF6/xpK0Ogzanh0qQ/2q66SKhhCdLit7dC3UemU/WOX2ZUO3W4qE76B
-oT5A4H6Vz4yqIzfVpFKGNPr30itRUOzWpG4CYlPPE9Bh3K6wHOgl+rRLqLItd6apekfJo8PzUVNT
-A4ddQ2prxem82DrPD10rO/7/y967LdlxHFmiX4B/2C9jRo4NwIx7RPcTCallmqaaMlLdw3N62mRg
-oShBqgJgANgSz9efXGt5REbuXSBFqAoXaouSWOWVl8i4eHi4L19OUWVVd1Dqqzox7jQy0GzE9cD6
-kuaDpJr0h6BAAO2MFs36dswEZRmsNHIPIVS0r7GiLpsWrZ4bUh9dtWZoGqKkfA7bW9m9EBZZx4gX
-rJtMsXLK2Rps1EbIyKQe4muTJKwDdKGOI0Ba7DhNR9lglfwMBm1uVuMNstwb3oz8rqT3Gpl+tVQI
-8rCIWAOPK/YdHihU8+RmWmkUpqzvANMpiWCAtmMxOYpgaiKhTWwbtdMNolB0raNLlxZFeyqYDz+X
-3DCgpaMfCpJqHLLmHNY8ofJsnZiBItYCB57cWOCSHf1Zz6EjDCMLe7FCd0jmxF51omiwCJZcRYtx
-CWF6+z7Vwf8exLLFKemA1+EYFid6Aq4b8viS2iIZdRnrlZOkpddywTrUrev6Usocin3riIOdsRhh
-Flk/nHG88YSHZS7cGsuwC7wYLJUsOxH88tZgFcWz6zMsdzplS73XnWxRXlSy/kJ3GhUa4i50p+TY
-XwruDz3sWAe9Rbd9PUW3f6j+3puwncEIMJA/BUNenvs8XCy9xiU0N4P1tK/Iw0k1HZyRHwIKoXyI
-Gjtqp6jwAiMBxtTa5zFXB1V2qzoIvUUX/s9oTLet+4QCs9re7A0Ncs36jSxsAxS1PBqooNMMZ22l
-eaqOBcxpjwJlg2dL6OvatTXyxrGtwV3C2krYrcwbtW6txmnUZLOTtaCKi8Qbs2voGASyMtLviTAh
-wpkPxXQmoi2W4DAKJibWAQ8slmfSnJGWOmR55R+KakzkSsj9i+JrgFAMc6jHyoaDC4V7LunhGUfH
-kU9uMWQQV3tcBCezXis+RMfS8lEJ+oXeU+R0y88TirTshQp06nQMjg5tkJ14D+fg4JXUBKgWPW9N
-jukLvVW9g5pf9Nk6YlRoWi+DA5DYT97JBHjeaZwXfENa7DLnqg7fzkpThc472oa/Aj1SSVIWYNp7
-IzBk2v7I8DZOQ7a3CHZtnd5Ilg4uYpKHMn2dDIShGCkSh4a2HkchDKIuUZmjN0Hx8blo8lTAiWav
-EuOZpEzCQER4CWJG0lWLltLFzOh1GhJjfp8VSuQ5Amm5Bt9ZwKgtoutgshgzmpnWncTcQF6oh6TW
-EkoY1dq4blj1ihUhEE0gG7kbiIMHLLH5kCtvqVZIImBEr0j0LpMLkD1jyidAgLncbHp1/YyDFasx
-ASyMzqFePYiVlBVFMkLDk4V+l8cfwsbYai+ePW4YIN2Ts3Ax+l+ynpF5C6dwJ8LDYLsK5tJdOXza
-sRpEghIdYihvglG5pkzrlgfmLIRpI0VSSsp9Ivkr/R/JIikPDXOOb0mdHQKF5Hje6AxClLQghjRS
-Huo+cd5no7TiiYUTEFttzIKv03BroqF8yFbKmsKJJ1glYVY35A/eJMbeRjpQ4p4bqM70xOqDnimD
-uQwOv14AGLQ3xtoBO5LpMiyITCrYalx3TNhosjWljZCPU6UhKQuixiNQ6IoyYw4muFtsffIdFXJi
-i6fQOJCjilxcKLOBpLUlGp9yzsbWigQGn+UbSqK1CypgrvsUNGB1a2/0bovlQqg7YBLT9coREkof
-MiLFKGu6L0c7U8qrQFPa7iOm8ULf5ztamMBbZCpEr/Ev9ABxJDmyXiXANTZirwU3H9lMkA+QbAaK
-mrJYcjvH3+IvZL1r+mPu4y0uGg631wPMtVUVDdTEIyyIlaQ1Ybq/PptiJcckOWoxYWMrdp9yKGDm
-l2T8iI5Uc02AUzaPrP+piMhDU5Z8WlhGohcj1aIWmoiDF6OewHIMlkdAWZMMRQWvJKOZCeeJOkOJ
-h/BJMQpQer35ZCDkC6VLFGOJM+I2Z8YFntM4vd3UguL6fVaS1vdB26mNXq99p0juUs9y7HuDoCup
-Z1FJXCR47QELgBbSC3FNiEsWGWF0IgLAaLzwt6xi20mOKawPzDx4FWECXpP4grE78tdR+1tYj7W5
-aEdY2EwYZ9laqnd8IN1JaGJ4og2BcJD4jkDPpaKr9C/KkR4sdujtcOxxzGdcjV60yB2cNFWoJmEl
-EiAj2wRxDSJvL0oqBH4h+Cher/VthC8kGicPlaJYyQ9Om1KZrfgrwAuRjEKk/yKwgGnv5hxtFiNq
-dGrI+vBEmVSLURorx/22QUqQJEubrXVGSFgxDI4RaxNEHLYEWYRia77gfa0uQr9kWX+LMHsERRBe
-AEYyqzKoHBlGkB5Y3ztL0AGXlZEOg5dCpDv2bANQXrBXrPQhbCsFu4zWhSWVor6X7D3kyUQ8296X
-yfkL9I9Q7oMsJVoRiyr8HhFh0jTeyo4SL8LqM4iXcqdQ8I4oXgM+4992JGF0lMzn2GmMEdS8F+h8
-BviUcwoyTe7puC1Kh9+Xw4LxFi1BBNCVqeo6sgNUvzo4IQLKgxMLOoUsxEWEj16lL+izSjIdMHZW
-LxjJDMDqMqVNPNw6JaMyhzgs4YQqKHzVepXNRiprD5HgTsh/AaUmlkWg+YoEYRbuij25DQA6IN/J
-OMnzOEsjQaDKEngTjR6sbpxTLu5xYHykhG6sxpw/3qMBa1bqBYIU7J69kvjBuCR22vXryhtqTyZA
-owTL2s4cBh5R5ycQMDPzVoggDqFqMjdLa2H1m/QjyvMnNXFTnid5pAjko4tA/4JM5GuKWDMrL1bX
-JSbCKXInOAe+oOmCavWKWPUPSYo9/BBBWOvI9VFSz5It/J2s6w/vKWG8kVkmqDQRXN+eVDQy3iGw
-N5Nq6OKeiCoyOXjIvkgBQj4Q0M/JF5G+xvt+C5uSmng82FYlljIKwqx0JDpD4ORUBNTCiVWHdKfo
-ArIiNfMYAjtRlGqoUjSQIKiVSPwchOnA50FQswSuiGmH9F+6h0V68kjFR40wMQAxQU9XBH3OYmRv
-kdTzlAjpQzJXjiAjWEdDepeGAt6VRSjlUBidUx2dhfIWxiDEDscxJxsoXkPEMWQu511YCScpbTBd
-QdzAmK33PIctzE+kZzor+Zb5AzDnvZnAjkn4eTBiwuwD6x+S+AjpYFEVjCrcB2YYitQpi8HL7Fmv
-7NZU7XTHor94tY4lXqGmbBAm3QQQCIJdKjvnVbg1G48LD0+AAIE2OvVbSLAN41p87Q==
-	]]>
-	<![CDATA[
-	Xpi+PHjBvfj2cM8izUhRLBLFYNcEuyZ1gdOLgGGym0wCpJFShanUc0cmwmRPap64HgoRNxWCEuR9
-QW8C7AURAbEwPLG+GEY3Q5gHjWzpg2blI/Eq2zqmsc5ix0AZWVp1ztGpN61ezCKbDMPP0E+xItgQ
-RKMEJwM087tSz6LezZm7BLMUs1LwLhxHr80OJ1YW88QtOswxhIirXA12oFo0WCG9pbXUFmlUFGAE
-1uqaIjj0Si+8iLonufKSKqJ/+IscficuQG7dBpKV0hFjKI2Cx5XOjQ4KetQAxUNy7rVcGDCFiNA5
-VjNcj0OIYJG8hMX+FiNxMIMBfrPIa8xiQE3GQuoXMq1SsBjzQxHYjaKgmzIBxojMtchvIrYS8CPA
-HUFdoDiqsYQX5gXLKsKAVT6YCvI+mWDVXmcU3OvMZ8+RpkQdwywgBJGrlV+gjwMCuonI5A2OFFTo
-UuHItsjFXMipGMzJ6HhNZegEo0bukiSCTt3EUB9EYZFnktOp9MRJCrLepJqRlBQ1mEU+KWiaDcyO
-P54ed7kB4V3wCLLBVveM3QOOPAwMLQt2emCLLFTeNNhFMd+3sGZYwASnJFBT4Ex3LZn4H6IMHVXx
-AUdC7h5o+sCd7kvNyjU5y0QH97xTjoFX3dgcRU9rksxnL72gBWSIFCPwyVXJp8Oxjvio6w52FrfN
-W61NyEiZw1z2xd7nkG6ZA+vlyrveFjG5ERdsfvkacpSMsWqWZ9Ft9JRQgHXLslKCSUnmSJNICscr
-kwG8xGhvsjox9Lag6T5bE8jxynJUFkKHLFJUa2/BeuLgtzRVz6GkqadGD5sTPBOHZg1leWiGg1Ve
-CT6zwPs6gRRlTYMVk72OydsYUN9LMNE5hUEPdRRgasl4S4qzYMW6nrOYTBhyxwRC1javMajC8aS6
-yx2KTQJ9eo7KbNe5BnNYEzbUPoVZDgqj4GLtfbCICmFZ7gQ7dLrgkHoJZlZWmMosAcFKp5g8LJRC
-gGsTthsCkp7wElhGjmmmSg+BDHleCAsqJwSUEoUE4plVvaKR1OD3PEq4LtHrJu4OJObBCRCCXivP
-JTYnM0XiQhVcUSKBoqJ8RLKKVMlkq4BSwyU9e2HVSVxDqnvUTLJqd5CZqMSqYifk6uLXxiq4GP0J
-rGIWfW+4CKaXJI8sG+XBE41u06GjMQeXfVtaryLL4xxlKeki8rBIwjPR8Zjc6dnE3EtqZLS9ITaV
-YmEfZGslUIHoS3EHJ0tD5kC5u8m2Pp2vQJgiFAPGS6QZXisegdICwTA2ChgU8sw2X1RyyMMkwRVR
-Z0r434EtA0kAS4KSWG89UwQks4RsBEJZXJvO6Izg4lx7hUHVamEAHFVYDsKKFnUaXVa5k3mMUC8k
-0QI9DcFnCHgUZ7FlvYgW/wVDEB4xJARqmUCAyIUX8Wcp5kNGVpqaIhwqCM7Ax4QGZwvLcLkxlJcN
-noswC77Rol5E7BZ9tqrcZCluCFSDJ+ugA0FzPZLDsgsYhMWQwAiC8fdaDyejdJcTWB9VRoNVw6Yo
-9gYhi4qxAxObrPwt8syp14mAeyuzFxDdgDwNMGPDDXFtSfggLITtK95wY9KpyUKKkJAxqRp360PB
-4VWIImlQKaHlTXhdtCfxiAfe7dzKuG+dOKsoiGmGFPYgP4wg6W4mgdEKScnyOLPeXNN9pdh9JPOm
-pA4JPgWSFsd9VY3qYXbIfFKjRB9AZzlbkAjHQ5+Q6xkIpOI3sgLkdtRoAVZIaO1U8nlY0j2JAAEm
-DM31+2gsoqOUJwrfIcCDtSt4SoBMxyBYJhZlMDtZUaJYq+iV5Oj1JP+gsfPOsjUpCkPUx/xEsE2C
-O4VCs82l6Su827L4EGWo3eugIRH/7cJS6JoWkZ0bfb6T0kM3LRAvSjMUv4B//tpkgC+h/IVXsqeV
-6QG9plssE8TxvqIadA8FkWdNWZa6UNJHEAck+D4ZbvHkXWkU5E5uEaQ/kS6zaNyj9vpYDAUECW0d
-PLrnHpB7hkwOiVliFAAOwgISze6qejLZky7umUxNoo1lklwlWXKX6ENo4vT7wGUDGWA2V5IxRoVu
-0fSM4mwUuVORBIdN+Iw77REytIE8YJ1i5X0bAwT4j1uy7mWJTuRhdeoKRgvBAZDlYVP3AvkMX7Jl
-MwQlacSsltl9JP2JeVBs6KQJItQmbI1XnB2SPAg2yLtHkbdJQHL72IvSSsIPYabcxfF8Otw/mV//
-cadrz0oT8sPqyEII8jyjv8tivVRsonYNFUkfh5lTfizIcWtrL1sRYiAJg/Ym+inXmd9Gdn62/CLm
-zYnfG13pIiSsIMSobRYfNzLdtMvAGEGZDW+0rB6gGhQK8qPgMUTcESATKSxZXJ0eLZAXeiQ7lVZq
-ylGiLJmM2oySkCXhoqLEe0kWP+5bD6uUwfC+koxZuiwKSm2di8qbwDXnmMaUbVkQcWnVp3IW9Lb1
-JDVIaGBAwlWcBZJsVrvqobqXvQGZ8vgxBnD3QSJCt17vkKPipDR2Mn84GrpwLLjjLaYXA0Wb4dPX
-NM/iTWBJGhjWlLA4LF2azoaXZH8Y33hb9Ok/Os+LaKXJHia+Js+6mo58WtyaKSEnMFbi4kzCoAYp
-vqJRoSXFKsiaV3URA+TU/WJeS0JdurjViimm+iATCLGQrKuI8qoZrx2D4KYKeFuRm6XvPpQwnod2
-ZwbKIcHExdc1i95T5qNkdg12NhJzcVlRoq+lT/bC6OHg9gSm1SlUL14LRy+Yl4D7irO6ttYlpYn5
-zQir0En4cnK6ResTKjrmb9q2W5ISHpzlU2CYiFHHbkS7GONGZrS48S5Rpk9z8j9TxIpRPTlyvkjR
-T0qq2A69fa1B3sQp1y+pXWAMhfO8udM1hXchG5mcb6mvKVLCZg0J85s8qxg3fgiTIDVJNJFYxOjt
-LClQQEQVTFeZt2sJw6Ka0SoqoOuC0AhFiTwQsQbXfUChk9kIhJcsQkOoPjKyNpUVzlwqznWkzjbj
-I0m+88I0FXwiCUxltSbfLJETOBSl/0KkktLY4HTqljCYsLnar4PrCKB68YjNIlZCGrd6ImSc6ktv
-rWsEw3mJeEACmqjDT5iOWqyXZF0CgkNWAYKHSlUvqU4fLHdnOaAQLnYd0/jYv1n1lg03RVFSSW7U
-UcqDUiY2vdRyiSkqNoTF91t3o3qnU96bg4FvQ5rmdReLFp/OQ2fjrhJXjes5SmRYb3no3860R/01
-WBOEV4QgvpFgdZwQtfaErATRM9MMFK+BlyMbMX95IclrAEI0sJQMGgLwToK6grBZCFgFBrCLkGO/
-jWElyLwpQNIQ6Do/HuUBhIIkq3CKF9aUEI5ofAZOfke8kdWTKUHFMrSckQnSJVTarj03gI+SiS+G
-EREOxKBTB1cbeoBshFnEww97P8kMNm+FepM91/wSD6f9e6fzj8X0StPrx/Tjx2g4k882eMTiYvDI
-5sEOZxdgEN6aLylkSzvIVoD7WsJMGj8KmaWcuWtRQNA0c/qZHwCRgS8802mSUv+KW4wiQEkkEElZ
-BzJARSUIWlFSOCmLV2bh4mkohA4kzyzmdiAZq1vgXAIPebHEeQiDlasvQRVKWItbuYsCFUEk4CRE
-0Wh3KQy6la4AiQZpglEmV4WRJTJegrLRKCwk/uaHiqDc9dz3kA1sjKYtg2y50DYA4Lqp0EVnPGJq
-ge/8CLkpq5Jc/Q/7WCUJVWnPq8SwsscZEjBRtYGp21sFZuQABrtV9StZ55x5JieT4U6XCt6mku2G
-/bjuYjGns9JbsvlCFyb6p4qQAd7ooulCJvS3E1iuCjkxIRhJr2RpRf4BFguEhNFCxJqY98HXGool
-RmboBYgYWHqoWxkIq81yxRzqH2KvBMNmEeVrsTBl20pJUJgkEzErH9UMeqDEE4o4+SlyyvyCcOm3
-gtrmSkJxAbUOG4MoApbH13KGMbeTuhki8DZaSxwLlTYLsBkXaNCtpItgv7FmMb6rlWxfbyc5fazX
-ZYkxhtrEUSER0+3QlTHFfqcWTG2DGRcqqzQbGmKRjwfrTmun1GyLiE3q6Aj2BRNramNhYfW1wMvz
-EBNUxY6tb8vcDgsz3pWpmVCI5NqEDNdSStpvygiOoUz1OxHETJzZkInwCWE+Js9JRrw6Q3+xX2cS
-1cXQe2W/QrrOSy8paRopys1uzXTXQdaUSurFyMt7s004SEUaG0iJa5/RaMwG0o1yUoGUrsklCGlg
-4gAT2VK/WSwvkFl+AWRZlm1QOUe7u5ubUQWYuqxIRjpTe6KLkpXQueHw7kxpYrlQayVDfIwAL2K6
-SgJnUcaOtS7TDkwp82TZZ0V8D0mnaclU/QsyvOXCOty7fjcqEkvmrDmxtj4I3CUoK9mNmxdvjYRj
-4WoMf9A3KqeV04TZGOwL9hSnU/HWP/xq+xoF2dC/YgelzL4wjMkjNg+O1pLKuDd06cIsJr7ZZ5tm
-FdhXXSdCEc6oMqaeONwoRaKwfQ2zPCUlRlUyy20W3dHpIrpLLaO31f4BrnPScCqIoALNoMLhCsjW
-ywpBcNgaMUx4UHtb8BCHGHprlijneMJxzFAOilyr/DREnpl1EIlGmqnNzCpsvZYwZLRrKAPby+cS
-1vEOxmlcXJgmIREnOESCDyJy3wypFWnkpqNbZfxB5AkuIuGipeGtC0JpTKQ9y2owKcQg0T6P6DvZ
-myCClcuUQDN3IdOAIWNTlb8octFABCLCdR2M0BQludCtRFVQSK1IUbAvYDRDIhIO5qZc4X6rJSyy
-B6/sE8hBCQSB5ha/vke3WYUM/RYsiZHZfdZvTGAV9oDLD6NAZ40SWSVhXTtmLwIHZyMY+6fKzcKx
-Z4oG20uaFsyQKEnKddxJYBY7k6hJTK4x8r4wRz9YzTeOi6URSZhtwjnx2FKIooOaX1zuEGUbGmXO
-a/72GZetdBuFwXdh7ddlmzYk2zqZ+ndqhKjp9t2LHT65hoJNyXXYbUoyrMBupMGpOaT5gmpkb0cx
-gByVhHDBdSg29VXQJu5UR5wiQi4lSqXvmFmp/uREwxgLa5bseWKOSF37uQehb2TyBgYnph+7U6MJ
-YS2218ryDki9al20iHYUefCaCBTGYMJqW6oUbeisxBJxT/TiNrdbtZ2RwyBYe6VngjdHDxW4KmKC
-UkNFe7ifOhHAWiCE22mwb9BRmx1skuBt3ULmaC04IREk8iKiNc5ODc0SrSv7p0LogglT7dflMYT9
-abtRvdNJj7cxLRBvw1dr1i/R9n9UGkzdeGJsESI5VTl2zHhEL7p6J0wFNyTIEIugXGtWP7imjGdB
-pl8r3RzlkpnsQdrHElT6mBnlBl9HEnzpqd3OSqoFbgU9W4EScn0wy6U0u49+aya1J7uN7mj8ZbH0
-lVaZ9hBEXPVQ7AadAIDViZRzXy1FvxrfQSHZJ0mD5BOnLHaZi3aV3eaNXkEgbEqUfcUKeP0TOMSQ
-cLjQcDLUIzuGuZVl4/KCrBjlAY+JKiFa7P6enEOgRPGq56Hbol+MEMI7e91GGmHtZg==
-	]]>
-	<![CDATA[
-	PR7ln7d+X6IVwBJ+lgtEQAcl3hKKmO7LARfG52QS3GnKi1fRV+VQdbuRPAeWdiSfEST6YuRxeHWG
-DqfF+O3ezgoJlmHHIzEXtaZYliugKYsMcDAnDwfnCaot6VeydT9kEUKcT/icwO+BVveWf8GQSclG
-1QDmN4TfH7JGIrFuzPVwyr+PxdI2Gusg8zbSA1pO9oVucySncUY2iLwIHiOYpUNKuGzYN0pUkAvh
-TkavoH45TEkuTyIBkpFpLJbsY8D5whNnVpOScXXooqXneAXzScKx0xkmkA+Q9bmyrSmx9BLWhqGk
-mYQ+nwvd14p1JTMT+PThtrDX7UbtTokTgpIy26IyY5rRUeXplKyS1ZM6Y6NTvLPxpu2Nfstvy9YJ
-ZOKqSoolJOtabOuiREKiL2cjRCKEYMxGxgbMH2fpncmOrSCWpaECFBJZokDzTTQ1a86TfQkSKnig
-ubxz/U5RdEBo7PBRvN0kk45kUMLzU9Wt3QCQMCQTJrtVtCuxV3GgiMwCFImuit/Vn+eWYtctzT5B
-JArkIC+LkXUreRkycZHFbO5OiHh+VYZxMfZyeali6lgHyUKz7iUbF4aBpWX6MNjILLWL5OKg0JdN
-aKKcT26dB/VOj/94G+l9+DkdZs9upGXAYJLMzmhEWOjG0AnfdShC/4t06q3kYiWpOxIdVLHKsmyb
-c5KJVS2JcR4SI0FLKvgDie/cY1mHNMgWpbsQ7UcMiKArjoW5+WhG0+w2hjdBmFbpY3RZxiHLS3q7
-LaP6DCGgIff7SBsACjVxGTpkyXsVJCRG3YH6FxWNCCa1VhbVuYEoZkupKnRHul5AgQKkRkFipFnG
-Y8Rkslg7rxyPKk78BgdrE0pQwsYR55uh5CAJLvWWk43CedV3VEfB8OBVui+psiTT4KwgGCuhBN5n
-DKKkjfa8T+VTwGFhTaqLG7cxZ40QzGgPJygI3UmeCF6DwkEczyWO++AugMzq9wCHvgTNjGLv282f
-Oz1L6PVVDYq5p13B25nZUzKX2L/VeiXT84FBR/46xjOF9paSgyMK/LFqKSkUkRycrIgmROQCTloI
-vTw9GYjhb+NiErV9M/JjZ+wB4NZjCi3L1kHLtywAG6ZDFG8DSYsbK8mqtkSz/GOX5OqAoAlptR4N
-uBRbEbkwUc7MIC62fqPBVloRcSDAScZ12zqsLIispfWl06tdtr7gglzrF3oRC9+aiIKoFV9IZgGB
-F8KsGJFxy6InI1YsiWuYZTWxTYWwUQ4S4CakUMtyOBNgR2MsiS+NdT3J5JxUlJylP3Oz/iaWHD0V
-yFLYF1Ay8i7Um0EKgVabuiEqhxvKEwq9RVZG4qDREUDKY6wmJhYEuyfjJAMRd3Veg4lrlVUpABsM
-BI3krBJpgqgOK6eZ85pTSxdM8+5Os46j0H2sJsL9A8IkcI/rsBYMlVeZYTKUcZI4qRbGld7OZpeq
-yN6QK4oA7bUxH8PnzFxNZpfSwbtQn6hyD1ifGXel7jcHT6mi8ISidSqE6JRuDz0kjw8qKhbBHclj
-08OqfjGlyrgtqbUoIFyRNR15GnDGiYLbGrAQnvNWDNAo3QQjkkqBQJ5FPnjwGpVeHKuXXYUrvpe/
-wLoFR1K0+geETbK4jOGNAGrD7AbbJqt8o1oD2dgCiVQMTjEKODoDCUWcvVBnsHX4fgwi3GcpapV9
-xXyxmqE4ufG+JHBJSj1ZCFchWpetGPMq8UoAAP9DslrDeB9skNyhdD5YsSWwRajAFtqZVjVYwogo
-ET8DqKIAogRlwAup3H5BElWzIpOlgfR3D1Wcgx79UnqR4uDFkFVaR6XTAwqiBsDXDCiP8hTIlIOM
-ThgiCbE7l2and0qYL7SImLnjDWFEVAOZWN3idfJUZ0Y93sfjIiROVeiC1ZwFHWn11kyPkmUiMe2F
-NdDwuqgSxYUKkrCMDWTABl5JRo8QSrjnZB1Da7ZU8056sgWDRKCoHpp18QLDu/RCVCw8EkXCwJOO
-AEQA8JcovyzvaypWy/LTqgPtFOvMraOfWf4ok5ym0/x70QcxR9zxLIJJRWg6phCZDzTNUJu2ynri
-fVDGoCZKym+VBLCHZCQzvK8CLoJa6UuvV52056C0E9mD0SqCRJB8GAXXaXI8sKZLttolxgnjq7JB
-NIBwhuAQqaQCFO8CWZgTC9ZDVR+hiYvK5p6gJNroXjXSiTVBuhd92QAFJ/HDeHihF1l+wrpCj2iH
-AU0po1MEJUL/GHbsoSrINuBEScDFkASQEtgLReFEWASyjID9xyKyIE4FK/4qyYqMu2JJuYgyRRWU
-S3IIIozhjJsNMY3EGs9ZNdCglAXv7jXAqLq5Jxu5G+5LRSz0yKWMjASlImcyvm4hQgASXE8Wg8LY
-OmQ5NF6lTgFxZtQewJLypzvFD2yhfwvVeUZ+1M+F6vwGwzwZ5Z9zSh0zdI25kxEyjCrVCTLRxG61
-tLdQ5BmHosmhWCEW1G6BkyVa2WwViAdWI3f4GdUc7qxLD9i81oT4hxuizQg6KWVesfEyTZ7x72va
-yKyzgrxzFy24tHZ2PJC4XXSWi3xSwcpU8nhowEvKeEamgytYAjsjrk7YLqjCqNgGA8LIqgSWjYs2
-MuEZVa6ZybnOJtB7ECXdt1BMMG7sKD9EwI/sttXuSd6OEKimwcJFCbyTBuGDFx8vBjOK6pCSigeE
-QYtChKsElLyOXEXNDujY4aGd6iIAAQVwbaFutmhmSN+E/OKiPLaHKo3D4zR8merJdW9j8AE0/VJI
-jGi0QzOMnOk/Osxb69E9kCaL+8J1YBIpWaDKF5rD0oCZIVgIe2EaKjyA9BjRZORvbR3YPkXkQUI2
-9uhipiExW1DWhHIHY4lQDZAYxDHMGRGz3AnrQBHPJUSWN+BG9LzOi0BGwwwyNZLFI9LFsS9kSIHM
-qSBr6NkuKIBO1mQHUnlEZxsqtwu5DBmB5K1amSwXLEEJZStEXhPMW4SaNlEOfycDzaFrDTvCCgir
-MYViOL7Yk0jV28CSsQjFEYJS/NAsUhRSRJc1a+toU0QbUFtM5XYWFRvAFl/4kYsVisJnExiN71ZE
-BN1TsGjQY1ZjTDAO8qR4zW2hTrASibAS7T/qcqL6tSBtVqmGAPskXpK4iNZ30TlAXCkqpBvFSktR
-L3KD3RBoZVG6cB0D2ssDJEKyRZOPJQLZjKUXqimKpuCrVkXDRbGoIOTaldkxSk9+dewBJLDUjRhb
-pDxVW0es7ktvP2d6IRc4FhYzPu2wxfMjlp+4bUtVXS6sUBIEQ0ILpWRFV2xBkqeZqBU9PAjUuCoE
-Oga5+kjAhGp9vdxUtiJ2ydn+sx4/1SVYJPTPJdJM0QJsVmIVo8CychFc21KADS4JqttC9w7mH8Mz
-65wIvVqQT0oVFClSFTNEYCEQY2Va4I5hCYbcBkqggBskaebRO7LadSGZb78anzmWXFHp4moIJ7xa
-qVJNGHMWhjB0LDmAyTji6arBTeARAWjfeT2YrljsINUJHzzvKH+nqUSaib93H47vyT58Q90GWDSg
-Zymqgm0uzEXZtSEKDwLN0jQHSuQGhEqBsPzBtpqKFazD9sIywylZDoRDiJK0F1XcXtooMSO4dr3v
-1YESVPuBRT9Uw4sFeuG+ADRD/Mk86yVqRpp1f6eJ9bMa2s3EikcmFpA/kcYts4FhYznGBXkINSfP
-OuBRNYpRQZQM+Z5cQeJIr0nWUiSGGLJqaDvATchyjSMaS52RQFVwHuL8aJtZNSGW6KF3CtloXnVs
-VAID/iZv4bIabAd6wELSaTHYB9OgEWjG+bhoXwdgTlkh/DjuziiAogKfJPq9T3Y9kpZaHTq0aL0k
-CARgDhxRuxRFz1cT7nPR1XsDQqh6B2I5dO4AP0hwCl1gVkitWtQc8SHVMwRlM7nVqw6HSAEKTL3w
-6HNLsiH7OT1kSIisrAhaWckGhV+JdOQpUb4ZUUuiRChjJDzIY/wSi38qwIlq3cUKxmo8PHwRGCGW
-DhBC0ndmHZTvZClSxl1FCKbkKdxGkGi0Bug24abJA83kf6swComAuj4YqiBaPXA1U3m3KF3tyZKO
-CB5LgIo6vXgr4h2TEaz30ioxmFMaEjJ9wPHCKJP3cj6wCHnL5q2ycq/RAl14lUBPEZmJOrNZEfno
-O76ZTSRMIpqlwA9hStoqaU7Oo35NUBaL7mNSNKsWW0aaAYX5sTVZl5AaO42KGug4psqy45i7GUXw
-pc51kjgW1+MQmOumMyBxoDRwApPMQynvKItXjInC2t9YQYu6XPXN4bwoJA9YSGhyn8zXVuuqWs2N
-7K3YkMvaGFBzlOgQ191ooK7oyGt4ugw1qiUOLGMU4sk5qy8wLUPL9Nkvw2TrsNJrRjq0ploFIgRA
-rUK+hvG2qnS0mM0oNLuZCoNlMbl+k2Z8ZQkUVmhNIr9eWo9RgiA7sVK1qJZVDyqoGhXLBFQyQ6HC
-FINU612c6FnwQK+slE5mg+Io9OYDm5lUlSAqtWkhUcKiohIkiMGMlVLNYuRAGIYlVaCcPUl6QT/l
-rChBDOusJBU882yN5Y89yoy4qOG7uBd7o+HdI23N+q8+V6gzI2lnnW0WrBhxsn8IeXZiSxBBGdRI
-FoiTLUEaICb29lKcyQr6woZldijL6kQZkA95E46pluKoMWVZh6ACJwQsYjUvXEtBeS8yBrZt8LjC
-NxOTmzFjI1YLdGIyWmnkBLJ0EvlVs5UKZZVyMH1WxdqBESGMNh6I16d6ZV1uh/M7N0mUCOF7cNJo
-st9R4zt6ep+jkcmiAkOGA9wSFwDMBBEWawVp4jJ4XJOSGbEGPAOalaXtGSPHWXw9cnhD+DeVWap4
-uByuFdClwFMJS+2icVRqOKZwIsBvjOBQQS67NmtE3OGdL6oNjinLCV6qED5wVDAJGWceEZ4RCQfE
-YqkW6YbtsC5dOFxx1gOgET2JKBVRl/g8eMnWwxWdPZ/fIwsKiKqLKuqCjAIbH39fp2oiNt/TrV+4
-BECdjiy5wkID5QAHQxT/MYPqCAGa07+RzB6gDcD0yDxSDxgp0JQVFhA8ZCN0KFULGtcHEpSh7iq2
-h0QXgsPvTPHB2CBIgq9u5KxLVuKjmH8o0RnDZwbUNmXF8cQnwj7G4ip58fxq9j96AcYEvhrfFGyZ
-o5+0iXrmWKMjMaU+v6c0ZnU1Dm0YC0aQ0WpAJ+CPZJBNZ1RZVnTu80u0vgJrdnMeKGk4WXgEmRle
-tI3gYV0Yj0nOkYuChXnhZCenFvIFGDOSS0lq1OHrUOqWXEPOC5oLgjeWgSVfmuPUp2PEpn7W1E8A
-u32usifY5GqwTGayXIFMDrQNIlUWkyo6uh9jF64XOtgYwkd5sMzQG5359xXCZHAnN2GBUfIFPh4c
-0GlsUQuCuL/onHRfhbMU+LMS1CDkJCsh6+JWVDdJBBHCTYHZgKm7GB2xz5q6jgqdknVSX91LLL/l
-RVmM4z+CFpURJNaeTIAEhzr4hDHXksKN68MQb8fuA18Ua8mtfXyk8B7erLUTq0KK3w==
-	]]>
-	<![CDATA[
-	eDAQyFVHCn6Sv3EgYdWhMwlAJB9PJekhA0hU241hPccwopwghBFztmKm9HdhspcQf1Rlk4Y5qnwg
-z5PX0BuKN6P8EcI9ZHnwSs8gLhfWIXyVSH9gYshDLBHG0LBX04ULFnKeNUIkjwTCAGJlhE9DtStR
-iUg1epBdDzpocDoyQAP/RCxYWQitWSFPmhe4LYDVybOCJgtuLsRFQJOGJvAIXc2RJsciSBOtgKYQ
-I/KpoDsWKh3Wr8fxCa9zSTB2uOGggXHbuky5gyMinfm6dcktSZYv86aArqX7iPaxI58qnHHyd8PO
-heW2MM8WHYerkAuKijGCY8GG5iFfdcYWGcPML1+op8ysplMdIVyl/aKZntg01hthC1Clw2d+nNn1
-KBVVsP0ilEy44iIw0kO2UrWf2HWr1t+qI6F7Yc4vTGYFmgCDIMYYUBmosCqGiq3ETLLBJF8gScsS
-B5y/c5aEwEMqLJkDsXCw9hEvhfMDaDWVaEXAN3ATK1ah1MuohNmyWGJMwNYCBEFiZVKq5cSlX1Rr
-NCwiHEwE5iTV4Qr43YiAUPWr8XSRrHYDDtngc4PRwfABQvIZbpgHNnmwUlTxlXzlVnuTkQWcDDXH
-FzmfYSAyj5+CKAPxaMW9xtbrK5ltxkntmh4V1DlwyndqsEkXhom9xiHSxmLlLs1pnnuOdUA6CRBV
-EYkBHJxDL2nBFF2wZToC0IJqF0GADZs4K6BXY1GGIYywqhTYaCwKcBOz0nss4nO3VGKHoA45SLiH
-VKVmrTIreE2PA+gsadUVeUgzGEETloRlTXnueKvajuZAWDcRHVjg1xU3EhwkGM28jAi5AgurrsjO
-cmAcXCbRAkaWXYj4PLW+3BbB0klBk1iqxT88nK2ITip5HusuIl5pXIM9cALTHISHdERAwimSO+Uz
-vHCE5qNMZ7Q+gYsZqZ8wixNxtShMBfQzqwwyqQtwB1C/ggM5m0kLWQMhfRWVwZVkhCkwoZJngcgi
-GARYOMfYBLk1C59FlMmFXNs8TaAUqWpzQYL6ObUfLWOWrxtbt0rfQUS6FlI8clRQYQrhKXI1Vgv/
-0W+MPohRZP4M/WXeV+jdpgSfYpzbJnA0FGjI8TZwCyd2VE+btLgbOqrIoxXktmYH98CLt0IIeBZn
-JnWrY7t9tfTfCP9ZtpCoxWvIvcGiSEvPiW0LKxOxoIFmDysqpK0WRMjy2uagYtmchUTPgTiH9PCu
-5xJm4+3gHC86VyZAaRhYEvR+VXvwBqmCQxPJYXKqw0yjMAqevK4pwvJY6plbFtc4T14I8GGHw6im
-ZEmXjq4pUloxb6WKLxOjuhRb9QB8xyQY00OVeE5itBLxKXVHZDRXx3/qFydq2CyuRPCloGRPJOXM
-Ab9z2COZ/03QGpuybnUM7YGVA3hNBGRINQNulkUku4xtnSiy1xhk1iByQhUpPJhWRXD8mC25k5qp
-Bn69LFOAigvBQ06ITjnW4QiD/Ri0gXLYyL6fSg+XBmMBgA8VzhXdGMS8qHLFWVql6wuV7cacR0tz
-1Rf9mD3HsEFC7yBssNqPRDymoKI6MfVYdoqGcMo9bJdQAcBX9Z08WQ5uU/CEYe5knZDhn1qV8oGx
-Rth3LiszKjnzxyJKyLFFvMx8RKxAtc5thiAI2GZaI+ZxfEAPCgJ3suTThvdHXJC3WZnGVdJUoRfO
-JmbOu7qIfK9Xj+6gJOwWNkkpaEgNQ23cQB9zhR72jKM08xMCvUJagpQsfQuSgLNgsjQfIVxQY4YS
-bwBPuBMlUlya5NqBDZBtBQmNupQf9Eh+TaItSIbkpoQHktSJIlYBwVT4kKZFQBm2C+LXOCnxIBDx
-JKtrxrfhgEqJU2IzmgTPC57NoB5bDZclmq348fxt0XIn5h4Q8wd7SRcFdYlXlmWy1F0bAeb2s+U2
-AtQBEEQRJC2inmcnCQzI4cXyTyBgbT00XHSfp2OXEwWYymTHKd4XBLpItrdzxsljEfp+ycLR67pO
-BjTkBE+qgkRoBG2BXuWHPl+CVfIiahXShFulG+hj+D2iJWNgZSQSszgtvGQoDGY2xahihFyIPNpi
-kxIDEhcswxaQieMmWXIJII6aCJDAHohRqSEXuo9pUNgCGSngVUnYW0HqT5TB6xQiG0E3aFTJKzkW
-s1eoPba+aSDxF8DUlAcfVNSdGH2X049rKMC4CHJFyd/SCe7gyls/3tdeBSAgi3xdHoTEknUcqFO3
-broor7sYGTw2VrggYOgN+C9OHcFbuQwwk5FAiaFNOU0A1KQjKqQRglkU1xhkbYChEp6JBxYjVY9e
-mRN4ZtVV9PYD7pTtQVGspEQEdJh0BviXyAEnCkagmrB6WR5SAYgmp2Os2jt4H8L37sD6Nj7rohrX
-T0/OAlTAzTGmkYK+ErchPIFMB6ysVdl9fs/gdetESHDkudBlqOyMXcroI5MTySUBIvSO04W/muBE
-R0q78vHL+lcgtOhnhwBI64QAnLPbGlqTqmLYiN4kOwzAJ80gTCLclQKd8SAp8HPhQZbkChmXSqpm
-5lPisONUMa5TAl6QpF3T7mIYjCKyiybywFDAICoFwPlAgsOh3UZc6dQBTjwQ6CQRxbKTPFX5wM/j
-exHiZNA0j+5dDTyODLrJRAHETwCZOMLsUW4HbCyoO8QVhiEW/77hhTkPjMgOuLmqiQC7FQdMb/s3
-McseygbHSiPNxVxE4EbQo2jTFTgjgvmLoZgJFgD5n+/YaicwXKBH2Gt5kMACKAUWdPXBuEt4VE+2
-rMz9CToH7OFiCgSEKiyW7j5YDkGaWzsGPCkA6quMAmHOccj2nZkSGoJoMaQoxGrvgwdhfarPncSd
-3Bur8YyrRGYdnBJkEWIvE14eRzQ/CigQQY8nwZT0/T5WZ8byX3K/b6e5XnN0V8NgtuEFrhuY+Chm
-QHhDP7N7WGSaRCXR9BAK9jDJopiByVQIoM4QGFPla2wpUFMgmFFdcNp2UP5OCVx2p6VHwIDXeFNh
-ZB6lQ188bCvx1jeYmIVfdTvZRM366DVPG1CNT3/t0m+f/PXy6reXL769vHj11ffX3zy7+uXTR99c
-Xf758ns9MRkuZL04/PbRq1eXL55+efmHJy9fveBrf/f9c0NvuNMLf/nX589evNoumd88ruHrfvXd
-k8eXhkRxImvAAobvB1GYGhShAYAOcAlMBgJefvNo7Y2/rjftntm+unpycfnVxaOrtad+9eLJ43/t
-X7Prn/+x3rL8/pdPH+vD+Xv8/Wfr1z01yUfrzdeXH6+T79P1f1//Zd1h/+d366j9Ymy0y8GxNetf
-v19/+d/rD39aRX85xMNvDv/5X8vh8Xr5118yvUzoCg8LpjAPnq4clR9aLZ1O90jeKGZYMxh2fN/D
-G56FJbKepCw5PRmXLFmFstBHVMyLnUhJPww8hSAsYI8DCjCxdFGHwZG5F4gVojbwIPrrsYMKT3r8
-Opg9+ADmE0EfO5Kb3octnWVKSjshXQZHzGS1mu5XL1oTrK4mJwBPpg66UYyfVTXsk9F3nrznAi+H
-fUUTEBbj4kntODZxuMfId5fgFICxitMVzRna9M0AOlaGA1ct9CIjugsrOVnSB9P22YiT97ELwgC4
-oAqBDofEKXKHhDeI/ELVnBtU43KqKwcFNpkzqsRm1ZuDIRlxmyCs3DXoXa1KaGZA3+mQFZ1KMtFt
-rNx9VPjDjhw7bgDecWbKYR9a6IQniElBCOQRBrk39RpE/lkZ8OTz8NFwHYagy0gEd33PkQ1Wvt2I
-0KyLdrjxVVE0ZNUyndxbId2H95zlnuLhPOYDDM/pRoE/nLyIbw9KUL3vSeSPmQ/sFP1pABTB/c0k
-7cZAGJk5kZfI3L3E1sGmg4jQEWTl4pCg4qJ8LqCZzMXdvwhvT/Rosjw6g4TX9+CwA8q1qggDZhd0
-PhKkgC3qAAPl3hSCIDwdFzDS4JmI4iFef2Wix/Eb+M1LlS3N8Utc7mT9ImgfYAJvWHJCqTG0jMfB
-+5Rp0CHwUEjEAl+SeCjAI1kZTlVCLn379Coyv4Swm8pMTfA4R1U8g183RUuKc00M+HA+MzmlUwVc
-3Is9/RlJVnDUYXLRUme+vJ0CqvgM5N26uIfloTLGBB+tpkKyGYBgNTQSgD5UbUllCS7uIXOdLAFw
-p8OezPTfrxs5Ys5rC5zKsN/HHBAVK1xv1IYVsRAcTc1F5qqqL7EWWxDSKCjDqpFVSUguupvJ9cfJ
-6VhEioWxVEUB+BTPqMki4gOk7KDoASBYRD0AagcGQKaLMfCHNPQgIxNk46K2RxoqbUPkOJOHxiHE
-jreQAIQ6Hqe5ovucFxMbyVRgq/fKDoHM+uWgvLyokFYiMByaQZEcuHeRHEG3gJbuwipzcKbp06Jo
-vwmqdPa5yQY68rjEqkKojwclijLQqgQk8mUFuJU0Gwd9oDHr8EO8s1FQop2g4IbmKk1dqSJWrmiN
-Y0a0RZ0lLcCkPwtpII3BeQ1k0AjzXIQFQq9ZM8XIrCqdSV0nRfR28OQQN5UoUKIhJcQXhSCH2gVx
-kMzRZ0+yib0sRAy9yA2sWC+YHA+UsLmznYOQlMDe8kbLghVCrnI/aHsRL00G3UusGYBkWZ0Dolgr
-sI6l2gCUJXWa1wGR5zGb6p41FoTTE8+rd72gArJfglB10eqBKx5XNW7cUrBzSeX3A0Ugq79AtJwb
-6/sApYcLHZevq6Rpd0u2zRmFHny6izY1lo97yPuEsA2sGG4hz0Vz25F0IASZ226L1mC7UnnlpRsC
-KluHBcdxQ9E5AYWtJOIFS80uvgqSqVKeMA04JxEboP6EuaStKQqoeEELRPSBvlcsTEBrcuHQ2wcr
-guUoqVoTT0rwTWq5BXB6ClHGrHR+PiMn2Ao4a3n60wkL2wGJr0Kz82Jqhg6EW4UJnnAu047Evh9V
-0wjucQ54jPKCAA+ZOXVh2jB2DHQ7I8C091SohaE69Hey0piQsCuh/cl+l4tt1ylLJV6wXCxxSMAC
-k4yF4Edu/HBBEMZcnBWoYVzGdXYwmqUAZ9LRep9pJ0koZnoGYUq6ZsRt1eqJVd+pBAVSrbYcyQZX
-mcMRjWETeTVNxZTXu6IoUZOlZGMTJDJv7R0NC2o40c0Jp0xRBTWWccJV6xeLShNX0dMCJzuRt0h/
-54wxKoILspitej+rL4Nx86kByQ45aB1TYVgLGualOjN1ZqtY2TtFNZ+A1yXtbxK9pyCfkQHDtQdF
-XM2ZggWdjQucVgAj7hkJU1xWVb4NzcyQLexPPYqAGBmyvQqv3kfsi1seMe7yUNCRWYRkFdEHyzGq
-dFFYZI82G9NsaISHNNW9RythF+HfiKhUXISPjpwwoM5WjFsZzA/ZSB7Owe1MXEPqTMLBLAR8PwMa
-9wMZTHrJX+H0AQWKxh1p3ndnhGJE1InZRzC19b7S7fRCWHAS5JPzQ7mH4hNkRbL7nAHiAcDSIDui
-4wYvpD9GleoI+30G0HidCmy+ijmtg1KAMWWRIgIfncyRpkJhxJHK0ANujN1RB52L0w==
-	]]>
-	<![CDATA[
-	IjV8JTiUFi1t6jbmmSq5jrNqbQq0Hfmz6iKMPdiZgPPjmQ14Iux/TtmcWHIwCuEEFu1wIu0jtmjE
-mDgw8O57QXrtVEXjCWkX3D2Rf4OILvdML5XARJuA05Y8tMnYqIOZDFhYtCYAaEq29hYeF6tWOG5K
-Is1gMBnaPRXxnSNnlskYRROWCbMyYOBsxBfBTY0B4BfAwQXHHKFI8MiD5Adrq+msjPAjC9gUyy9g
-+HltFU6Q5PbEJ0F3pyyTWK2rSW5LLUx4kZ3Kmy6WKsLNhWXfRUPKivCFzy00/JKx6OHLCBxKFrUC
-2tjoqlNWjW5k/lsNFUZsBsKBhxQgOxf15UNuYhGuX0ADOccWjXkKZukggQDbO87WVZQ7oFaG6xpN
-CFkHR7jYuLNkwbMYT0YK7sIDO0SMexczhalMCMbrx1Dwm+BoU9PYFUhvvv4NKXXE5gHlhL0SwTAx
-7ZuWBf4VThWYHF5dZyyzOAvBcQ5VqVIDTZ5BeNLh3rvgiV2hy9KNlGJeiyAnJu0RsKomL58NbjIX
-B9wUsnubwiHR6nzSY4N8GIacLb+DtIAITDUZuJpOwfJPOjkSuFuaInGN5hK9IUWlL7lsGdEjTBc5
-YcQxZ4s4rWciFhMltpPM5NAXmFikLCdgV4Y5tsRCoCzrA69Kk2FyoAhQWaoRccE8Rf6LM4tJJACe
-CZ6XGlF2CzsuMkKimAKI6RuD2IRXwa5G1ZIkQgISF8BNhWcgdAOLEBEVel3Yg0koyIUQW8BwEFog
-lnZhAJANM8cNwIY6p0H9sNzvYqntYHtbNXB3+BZscvo9eIKsKkN8Cc+gOUenC65YhDBhEex1i8Tv
-ShWGcsWko+fFg2QE6EDsyXBswVWC4G0kBmo91HqyjRPC5ZieSMQeFl6Vv5keIHjMkIy7Hp2hHlcz
-DhqKVYqTiOJSFeQXugE6HV0feKpCJxOwYnwyiPooMi0/tDMHdZRN9/AeZmRVHExKMOoK0ggkJtay
-SgTmIabF+hWsui4WIljtUNnAgXFu4zTvrU9U+/HiHk4RlQE6HNuD3Eescw+auSK0JpS6Y+gBEigg
-oF2RZAUTg787JasThL3qMnj6F8KRkRSDZ3kDcgDjFkUL04kPM96JMEUm9JG75PoNWJeI/vWEGZ9E
-XYzfMWeQpiQoDt4KjiG4QnBwh5GDdnsjlwf1FryDWNgk4wURnIOXgigYZOnAP+INrOGCDEEcdcUh
-IP6HSMIpbI0+iMSTqS3riGIyQQN6KzK+ntfzYDPjRgn/B+lA4DMRwR2ORW7UYHFWXQ5MWJjXeDnm
-uUtyuyClj+U6gUvwdgdzEpDxQYa5qLQ0sOJgPwFuHbgk+N0az76wNJNIuliorGpyoEPh4sndFbNo
-SAAOXec+s/lV1RjMMkDm0vYpyCZyvAMpCOKhICIIKPy1o6C7kHkZSCWgjTGaaw+YPFUTC+aKq+YY
-ctx1w4F+DvAH0lu26k1TZUzw4Jy20pQwZLFi6TKNo2045BW6XGBCse5F1Pk8pFG2MtHDhE0uq+CE
-fHTr0muGtSIfYCMUYGHeEPkAA4ESRPlitqjqHN3STGwPQmPA6pbDzctTi3t4hsaMFS4zCbLDLAMo
-BTykMJ0raMtHLJyle0D+lzlXUlSRdPpJYFyhLp1yT6usolx60ctFRGMX9wqIWM01xl2TzFpRflwu
-sNqZmsDi5Zg+3YLlikI9AhQKYBy9FszQL6JroBK633PtL+j0VBW7YKYjYHikAbvPyN/h1FVKPz2o
-0wk+Rj4J9Mo1j2W6sgLZ4o2BuvVDYyVpfDYna81Kl3nIU6DSzRCpUmpgNI9JaWT0PX0dG5E7GR7A
-s5UM5TwHENIOY5+spdzGmQkcdDbDiUbe9RyU3vmQp7xYeKYiC1k/uXqdNdZ17Q+n72Mr4IHApPVm
-plzzGEEfkM9WGSsbI7rvRTbZzMTocaeOyubu8tkCIzjyY4IBNAzv48mb+HrXOWORr4+FS7Zc12lT
-OhHNOqyEO2H3XTp9Dg+Y1TyfD3UfPQGgUaCbiU9HN1aiQNzh9H1yqFvJOVZIpTe96rAL/DqZN5dG
-ED72G7CTIOnT6wYjIuPLMVGxAVGfkCC3spMCmX77q33qQFJHNrDAPYYVvdESYm/RSTCYjpqG1v7P
-1wd3exR2OVw8u37+7Lunjw8v//jo+eXh+tnjOdP+NU94+wHfRCZ6EG3CcQB2GPRoo02MSn5vLdr7
-5bPrR08Pv3vx5Prwm0cv/vzy8H8/avf59P/78S4I7A6fPl9//sXrw79r7/f474L472o2kginNYVl
-x2+f6zf+3+f3jn4c1zxVwBnwXabG5EIKd/ywAEkB3ya4+9SWj/5zHrH/+viAZn79/8F3gclPTUes
-uWMJM9HwLPiRF0w/usrYMnY5Ij2AQcogLIJryoNjlW5R0Nu87tUPnL08l/Hy/uz9G3nB9ON4eSYT
-pxkKiPY4FBUH8iegiMVr3+ztzUyT0Jv7g/ev4wXTj9ubU4QfGa9CIIVJOg0Jxwt5qOvre/xBsJfL
-ocSX92fv3yhc+vbjeDm4QfAGVK+DlmPOUGFG1doW7PmvfXm0lwc3Xt6fvX9jcPsft5c77jg4Ka/n
-+Db/sDYiLD/Q7cle7rbZFrbZNr3Rtf2P4+XrwTtwkoX14FbY2ymAK4E5uzAfX/vy3Kf6eLfbJtv0
-wrL7abw5rPtXYQ9HANjwbxRMw3sXsDG/9r1F791m2jbRxqvS/MN45XrSy/xYlxaQuTIzAfV5f/yl
-VS9142PHBBuvcmX303jreobOmM/LOr/1gasFyiS7H3tp00v9GF03PnV7mW+7n/prqTcfYAlVZviB
-UMNP75xejmhopKwF/Ofw9aN7fCT0FQ2Eyh+v7MdCZlVeMP3YnL34y79Te/6/WBOHv7xpE14COHQb
-OtyxDWDgoGMaeatwH11LqFg/hARtUIQDHkWRQHKIwCxNESzTC7uVOXUQ5n6nNwEjM5CkRqYqE9mN
-qgSxv45MCdUou90o4NBb0e9ktgtb6+2dush4krbfLXK1SVjdxrEeRqMg9I+jy5KY/jyaqLMIhATh
-SJQlogPnSNS2btmESiBis6PeySAFJc66gE633lBG8JiAEPt1Ankl0KH2D2Yx7C7qY0FbeXcdU+H5
-CobYOQMYYMRXuThupReZQjsMdjoiwrCW0kVV/UhC934raWnQl7EPB3HYFDHA4Ui7YvOJWBa7lXme
-dRTMhaR3ufA8jmwwYZPwxmhUOLvLOJJ8PsO2PlpaCloRVKYEQhUir5a6QxGRxuw2FcvbRFHnPrt1
-CJXTqqchcI78jWbNUCGkGkekT23zutNnb2/QuQqihVsbUQz2fIrsVoXIp+uQneD1iv4JZMGUxCvm
-yh7ngQ1C0SNCxOK0tZf94VDxTA6RHL4S0umMj1j6SiTSiiLfrB05ZROlOoY009UPobHSBIu+oJOW
-sRZ4xu2iMfOjP75usTO0VZflyrKOM6wEZcW+X2gRiuiPqCSUOJYsZXTSEHpG4PSw3r3Jt/7OaCPj
-66aGiGrmyETXF2rUrW7oNBX5hSik0V7l/Q3XALs829OW2NeuAD7VCJX6kmFhnkoIts1f/UQyRmfz
-ciEOo4v6LHScSvN1yUZGJSg4yRl22X2qJZFoUKvNXwEuaod87ETEAtitJkyKMuthQXpQYS69NPbF
-20ZzLaSYbErxCxZThKRV2GkHSsaaCXF3GSg1vF6ah94m/kgb0DJmvoB73ONK14OlP40ohNNN9EIH
-a6aV87DTGpOfyQAOmMFkqLR1Q8s89QAthNk97BPVFJ8tAvxoJXFwwfRjaXdin/zkJty2fRJtn6LX
-K7pun2hUkEgGl/mVCYkQgnDsdmJ3Kn3VucE4BpFvm36j+oMwdrVC3hqKxNNIE6hMoqEwQtuE1hS5
-unY30y+qVwTTg9oMixHG2vNEQMsmdwUk1Am+q7QjSWpDcw2Z73unOLIgWkwfKeWwBMWH+heoUmFX
-dBQltSHm0u0L7qtd1DWeuABN2L+d+hg8yj6MsTGWs52IyK4uVINVUA9Itm6XCaYN0dgDgUldhI5w
-gudBtFiFS9c3qE0yDfQQCrVCEcuDQFT6WHGLKF4YpH4nc4NZPbS6Pgr2LGM0CMaN1kV9crVN1Kcq
-SHX2twqDuHu+iuCyHa5uJpJAPsY7wx3AUEkkxNmL5m/fhDl1K8F6iOgYvdLbSC1+dLdAsLthsbU2
-Dx6RckPUv52K8WjkrYipOJYkjCL+YlXPvozixo5nGFrfS/RCFHPf7pJNEVrKXeVzMItFAKRJFqvj
-KrQfRdE+lyK71VBT83XeHT3L9zqsZAgYRmg7aprwS/yAbB9AZMX40G6EJtM/c4+M6qtb30XLZDwW
-hpB3oxEVUdCYxWEQ2+JaJhMgjSmgbTBuK87QwzuRn2zYLuzTLlqcaJqceKlzR3O4Ww3TXI+9MO22
-InoQYreYopDw++UUt1m73TyWyXiDsht2qxqZBM3b4u8GjwqGWmGJnWT++iHL1uGq8jPppGgF03e6
-C0jJHHaLqZtEu+GzjWteTNGSbY/GXtxdOx1MErVyImSW4KzVe/rPpPp7OvRui4g9hjV2ktHl23Yz
-i8auNAtt84oCDs07XBTX2X4njEbMOe2Yxr48batRCa/7PXmsnHlPjoKr7G/WCXza9rG+fN+Tt8GO
-VuS5WxFRh9bZ1oiGujz6/L318vkwDNe16NLODlyH0U+WIWUyCJfNJMxl2GO9NCKiY2kYYdOP6wV3
-YRL+5CbcvstKyNNFobHr2YLrQokIfYfIdTtdEG6Ipu1N+VNADI9tMAuBt2xb5SaZbLUhFDh/9zAB
-RXcv5Ulu+FescUL96uSdTUTIOL/UdUJkvy3GmOfr+uz285USMdNgegVhQEctMcz53OJoB6zpuyaR
-m1boJsz9zv6w3pdRUetdl0dx/M9DQ1rovBtALLISNtG8yXbZ1V7Gwg5dBS4dtArcRReSeeZYKOpe
-E0qr0MCEqCsebnYQlLzpNpqr2TCckyJDUpPgxTvRtANuQjvw950t9zylTT1ngtnGnd7uJKzQdKA1
-Tr5XbQDEK7uBnt91CYX29Sr0cywMpG6dnxgWww1v2tgzU4vN2+aE8gz4GV3NiuuSH9v3gE00dcom
-HJ1HRs19F8tLcDQUhH7MAybDZjeo0S3TOA/Vnk+niTOsAwe4G621T4lxYT+HHguZeja9ujtpRvOC
-uK32HwGfRL+qdQedyMunLplF86lgCIcmYj0mDUT3XIiSPG85NGpb3Q/s9AV9+GHwu3A0ofpZejd3
-ejbwkZA+rN0DSUO1f60BRNzuaI59Ul8RdoesaTrNoqlPNuHou/6wrYPHO+eBGG3rwyXo1W5Ildu1
-m03Tt8+zSXzPUE+J1KZ74abHjja2YSw0kH6j/EpGwR4o7wUkSDAVktxKbp2bDduogzuJceZccRwb
-hkNKY9e2/dkxLWxs1dOPKd2J4fCTm3D7vqRMkFpsU6wLjN9FMgt1ReN4gyj2QxFRsw==
-	]]>
-	<![CDATA[
-	FI1QVxRPKIU95mDwsDZiWNFyeLqo739k/t5ft/S29ROFnMy9GV1fMVmHzfXd8KTtDuhu68fTTTQi
-XpMwpnGnkyT07xQxPTCAI+zVQxgQWtgrilCeOe3j3LiJ2tZFm9DCXrGXGGg97IUPdZYgP8Je3TYH
-gtHCXtGyEiEaRrfiLV00xqW1o+uydW6PekVz5uGjRtQrCgR9f4JARuNTZi5S9wYwu4+iEfWKPYO/
-jahXP4VBZFGvaDzAGIO4uacFWSd/UD9Ltd7lPZ7Vg1FdxFuTUVXtrhNJL1+hqBS86Daht8BXshS0
-2EbUKFkRSqbq6ew7RHUKfE3CHvji0yixYEWywiSxTnGvpJwjCHvcy4KOFFk8K8lVMET93Nz2l0VL
-hIx1itwR+kyRn8y0oIb0sFdPMY91hL26ZRjrFPbqBhO+YemLUiY/RH4EK0g+BFHabC1a2pBZ1MsY
-QdlFS18KzO8ZojHxcz26TodSPK2Nc2q2bhtRr9iHuY6oFw6lUR0SwolkRL0mYY96RUtiJvdrjyvp
-4MHerZNCanbd0g0tFW5D6sWm3WjmxjpFvaIlf8Y6ol6x0w7UEfWKVr451inqhSUT1OAt6tVYR4Ls
-tc4mpU40XdSXDGPRu+ti6U8zL1Cy2O7uW0E/V6zvLOzVq3nFOsJek2gLew1h62Ev47Lj+rOwVzJL
-jUu3jfbKWwONbwa1ZWdRZPGsSTvMcS+yoMzXRTF9UTQUN5mWtBktm/OFjnJueKWvmtifFvqhbb+h
-Wtxr3bVlNHmbonPkRgoYCmuK3KiEH4QjcqNUX351t/vEEAvRZB4yw1GbZI/cLPRIsenqsF7wu4t4
-qzf+zy68MqHP+ejmviV2Q9UbKwBb0kfYP2AhA7XY2Z191+mG6iQZPqJJZp40T5IG0+quv7EE2yLq
-9gHONHj33nmlURN9Lxeft8NhF9mdxlneJv+g7+WJ6uRe9EaJeSRUuLoLJWIuO5VxsjfLoNqpcXi9
-TUd1N6m3DHNmauVjyRjpSdhDN16pNVq3fbBI5kLR8PIa4yWF5g32ZvXV4TH2faOvu9jNMnTPFrxR
-8vl0b7D8+ekFwSgQ2JDtSEIOAgpH9MYIGuoUvRmiOXqzCbtLismbEAy3lav2nbN7y3Utu0Vv3Kbc
-+tlL6fZdZP3WGHHfDf6g/WlTrCJo11Ti5RYFVUkV6EYL3wTLtYTIYiRhswm28A3ShbJd5zqES3sf
-RR1+JNqlLuqHt67Mt+tQJuDoaSLN4FvDeGs3YrbGCZTGT8j2CUyWGp9qd9ZudM2dIhKLo+5T0uex
-cFgfY0DMPq2z97JvvyOAE5RTp1kwYHl9fvYAziyaZtQQbjNPSnQ3P1n44ngei9hwN9/LmMdjVQgo
-sVtR0Q4CuyU1ynnVKYCzLZURwWH23n5tR7PUp73b3IH8rh7B6ZI5gjNk3bQTAmtSTXijrbHZEjU+
-rzpFcJj7N49fFMPSfkF1WM1u8KNRdOyUcdz2tVkokttJvUexls97AHo4H+8VloM5bSmjz9sUwdlE
-cwhjCIf3zvX9aYvgOGJBd1siwqtWkW3zGdK1Nm2v0UZptzePpdN2qAoWOZhvDlbHdbf9l5L75jwB
-PGjE7swJMrTtjQ5xI+y+/9iM2UI4S62G7YFJg7KNcRGufXGOPzSv6ibrTK4sPITyXqsFObwy60ro
-LhFzfjDbzA0/yPRjDHfilfnJTbhtr0yyuDxo54ad2O3PUCY7EUix0qyGST8dWPGTMsXmVIEAomm1
-F7IJMPm4H6EKT5IQjbmYVSmn7KKJ2mW6sIfcl+qPbhblGF8xovDFWPDmVaFKemxyXz1MP9WH9TW2
-iaa1uAnHmhVmBqK+sAlLAZfrtPwDadcgHGoihkXN3ZSJIu5dNM6jfpP1r+fpE6xCOxQC1vaREOnt
-QyZJMEKioT2Dswmw07JWXHBSxtWojDaNPSSzXu/CbieqphElZQMOZrV13kqMYipPW05QcaU8bUzK
-Yu2iPr3oz+jCEXCHJtrdXIki2r3CKObyDiEhR0bIE5KiiQkrT3iLIdohE4awB+XEqw/JCMopys8u
-36JyYs/YDY2tuHn8LN027zY2HQSPxl7uE6TYTqiWRvMs5B3Qp1WbJt1STHBu683dGEsG44RoWIpJ
-teFHGSOJaKtRtNgx3bk0iexWZmMeXVdtDm9Pk1+Dbw2bE4Ge0F3r5F7iN2T7BrlO+rd25xkjtbte
-WYXEMO36zyrBnAiJH5lGJFmSbsjDVExG7hbyZCumTnSSh62YtqXXbcVZ5CfHXRf2yZeUdD5PUbw1
-1KOpnCxPeJryyUicpoWRxIW/X1VwmqRpqVkHjKm73bytlvEKEZLtFngSL7cUQffzNGnBPIzFSTR3
-wCbM1uuK6U0aKhl9006RgafFKj33VdWdQbsxtH1sXlUotXAy/IVm8U4dJxE1nQh5nJ/0e1JO8bwL
-oCm2pW67BfLgbbewPWV0+rbxzKKxQc1C28iSRcmn7c74NffbYjI+xGn7TAbumTbZZBio3Q49Vs+8
-QydLFdjdrNDDZAQkUVXujYVkUJ7JqEjGFLhZHsncs0ffv7dlPt87xJyfxvN69l9NUyEYadk0YXAQ
-7yx+kyuFqdzzBPQWQd5m6SyZXClD2AMk08PET7l7KQGW3SHSGyd+aX2C6a7JH+KWaecbNniZrhs2
-/RKObq7io5xfMdbQ3BRRyU5NDgaumz5sEu2gsEPY0cLjYRukuO9JM/LYGCfzDIVdWj4aQaNYnBez
-ORd2q3mT0XdosmbTljOznwZVXO5ISEdEF1LknM1JbR06INpa4+Qfh/Bg143MDx3gWGqgm1ebKG34
-m01YO8pVR/qdQatj6ZHhy9TnvYGs4N7OjBYj426Fb50yHwdFfHgs9EaytZ0RE7esadUH26J3qz4Y
-w/W06oPt7vzYDqvYRKNTZuGYUMrRm7q45z3thiKYW3Masu7TmQY2bKYURWNBHc2JwApCmFCk4ekO
-u908GU7Mvo/MQiKfdy+WSbFrnufB+egzvOn97Wu3gpOjTzbR1HdTYcq+Zs1uKqJxs5d2vR8md6r3
-5Whkxyds4y+yuaMJpWDCbvL4zl69F4Luan6gFxPe/NoeNmDzlqFmy9K/QiGU7mOe5tMsGn0yC4ci
-7w/rHTy9cxuHqW19vIw8ax5V3w2QeTpNXz9PiUCfC1QUQr3HwlmX7Xa34SYBYwrz/5d1CmckiK+K
-FsXjWJhzVflM0Y4F1j4YfApqSA4HSdjyo8OWH+22pOjpx3A3Kdo/uQl3BVvx6RS24tMJbMWnE9iK
-TzfAVnw6hq34dAJb8ekG2Mr+uqW3bQ9b8ekG2IpPJ7AVn05gKz7dAFvx6Ri24tMxbAUnrrbBQARb
-8Vu2doej+HQCW/HpBtiKTyewFZ+OYSs8XE7Qc1WGSSewFZ9OYCs+3QBb2V2XrXOPYSvETaQj2IpP
-J7AVn05gKz7dAFvx6QS24tMJbMWnG2ArPp3AVnw6ga34dANsZXedYCs+ncBWfLoBtuLTCWzFpxPY
-io83wFZ8PIat+HgMW/HxBtiKjyewFR9PYCtd1L0xbX9Zh634eAJb8XO6tsFWfDyBrfh4Alvx8QbY
-yvByaSJxbsUT2IqPp7AVH09gKz6ewFa6aEx843A/hq0M7+PmOPTxFLbi4wlsxcdj2IqPN8BWfDyB
-rfh4Alvx+wxmwVZ8PIGtwE4tA5ROYIqPN8BWfDyBrfh4Alvx8QbYio8nsBUfTmArPtwAW9ldp0in
-jyewld23dtiKjyewFR9PYCs+3gBb8ekYtuLTCWzFpxtgKz6dwFZ8OoGt+HQDbMWnE9iKTyewFZ9u
-gK34dAJb8ekEtuLTjbAVZ/UNTk/pXXh/OwhzGe9P6TsF0A/WmEJHp3SepfKx5OSU7nvy/u5hx6d0
-H284pUN4dErnfNyf0rtod0rvwt0pfXezTum7V+iUftQUK/gST07p04dNotNT+tZP08OOTum7Pu+n
-9Gls+il9N4JWviOentK77Gov47SZT+ndf7Q7pR8LS986j07pPp2c0ruLandKh/DolI6N6+iUTi/Y
-8SkdwqNTOhfk/pQO0ckpnfbb/pTOVbU/pXfRxb5TTk/px0Kr13hySudr96d0Nu/4lM7P2J/S+bH7
-U/quU2bh0Sl96uJ+St8NRT+lT0PWT+nTwPZTehdNp/TdnLBTOrTVySn96ELX6+CcntJ3LzZrJJ2c
-0o8+g6f03dfq9L3rk010ckpnH+9P6RyJ/Sm9n0p2p/TdyI5POD6lH00ondJ3k6efU4+Exczd41P6
-9Np+Ymbzjk7pYxfbTt/TfJpFJ6f0qe+2hx2f0nfjMLXt+JQ+jarfNt/TU/rRlNCBvFu2x8KTU3qX
-jVN6gd3irWZUxXF9tZVz4A+r0eBwiPXALqTdD6ATbNtp3W1sIW5jC5kYQuYz812c1X9iA24fyiBS
-YbArj5N6UgXE+50zXCIeI8I4qScVaqNonNST6UQX+kk9WeVD0jf3UF/qDM8U9TuJeNtdp+C+C/2k
-nsww7s3odlsK9jg7qadezyqMk/osGif1SRjTuFMckf2kbgdIVuYaJ/V+6ILQTuoQOYm2WOUmalsX
-bUI7qeMLeGAK/aSejKPFhemk3oNBoHq3k7oVX6RoRHmSfcB2UFcVvaPLVPbIhXFST4YlwUeNkzqE
-urMf1IcrJYyDeuqVcMJ0UE+9ElkYB/Ue9nNhHNSTlU/CEIyDerLMUghpLDF42Xu8H8BzTxwO00F9
-REPm60S+wldI7WftZ2jHOKf3Gr/8fB1zsyUko9/snD5EfjqnT8J+Ts8jha8f1LNS+UBJPs7pWeTe
-EPZz+hbqHgfwbPhw53dRWpUEm65LIqNzfnI0SPdCNM7pSUUvKYw9hC4ONbYj2JiWRX+cDurJziGs
-BNDXZM/qHQf1ZDnVZF+vmy8jWWWkflIHsEBx+HEC73Uxu2hMfKFApuv6njNO6oiBlt7BI36ucfbj
-oJ5UW4eicCIZB/VJ2A/qeJb1rp3TkxUvY+9uZ1ejkffjnJ4e6CK3KcAkrTQd0pPVTUJRBTukI3Ru
-j1qGt6eoj6czOgZZ8I1xRk/G7eHcOHv3Yl1dZPPPlvB8nar0uY1gJJsbavedqK5j86Of0fODyr16
-FfUz+iTazuhDGPoZvfPKs/xhs0lvZluQdrQ7Y7TV3c/ouQ9HGGfvSTFsZ/Sk6g3zdYBcWA3OPFS2
-eI64DS1j1luBzzDO6MnAwy6MM/rxVro7o0cDkDi/gwwq9u7CDjK4qLPDREtnKLBguQhuc9vsWT/E
-kO9mUjCxUbqZ16spI3hPCibysC7shx6ai7ubM+1gN5OCiVTV7UnBLG16JgUbO86WBb2JJvjqJhy8
-YKrt5yZeMLkH3Z4XLFfbrORn4nd50/QbMZiVE90TgxWbfzMvmEoMuSMqKN+V5ySUg83N5FLZtOJ2
-oM9LnBR7P+HZaXfyD3Q01uZE2CTzsbILN2Iw23wmXjBWm6VoIgZT6Xo3E3eZxTfTew==
-	]]>
-	<![CDATA[
-	9YjJDjWoGnZuT2bEMk7zzbFX6JjZjFzvoxk1qPwPN/MvKQ3FzSxNQzSjBjdhRw3qjOb8hBoUstz5
-HWrQdU27oQaXTcMNFwJRb87vnC3NZtFu9JstxRk0OOoAzqDBvpdM7GC+2fin4YcdNsHMDsYySRQO
-Ri+WHpKoB0xUzNvt2cGGQp+uKzaM29PEVen2/GDDiNlap4iamwnCOqJwRxBWu9E194roQdwRH1Ty
-p7JhfIzxMOt05gczTbEnCOtn+ylilvsEVdbDXjRNqSHcpl4/Y08TtGv83URWvcrdhM9jIo9lIc/u
-bk2N8NwOMuiSDeQGGdyWyoAMutYX/AQZ7JN68rH3Q8oEGRyiGTK4Cbtx1/t6ggw62z53xigrO81L
-ChHAsF9SgLnOQ223qhrfbvyTitLt9XHatredsNgGt4EGnbacbRtI4gDabxfJqttvu8ro9jCBBjfR
-DJobwgEadGnZb3hJ1t1+Y0RLnO2WAzS46JC6bbMIqIzD9bSktHr2JGHKlpxu7nWOJzMgWt3fvbVQ
-mJy0syp0pJhND7Fv7z7/2JjZYQb9ZiaPaIS3UOk0F7yx80wzxls51t3MwoEk5t0MhAFuM2Y4sTbJ
-FI0Ywi0aMR62RSPGS7cQwNS4HirwhhSeVqQ3btLdau5Ri91y7nGL3fbqjFdmikao3OKuKaEX+PZT
-NMK1rhxGNGKIZgthE3ZDYjxsszZcN2cmo8TFbqkM40XZzTsLZ+k7wZyAKQD0bjVPwjkeofAg7fvJ
-Lehs6u6E2ujC5D62g2Ans6WIWU9c9Zv72Pa+MPmPh7to8x9vosl/vAlrz60UvdfOqI3kIjoyfsWc
-uzOSVfp6Z0qL8OnIDh+9MruKW3f87ITe3DCbA1k8hdPC9/1sOK981GFq+5XfPbf82u5B3kSTB3kT
-jsWnGmRTH3uFuHZD4VVRfh4ybzHSaWARHIzTrOhrKh7NCRW6dn6KR/ijaWJCFhA8ERbzZm7vVUWG
-XetsD9h/RYp9YxofK8r0XZdsoqnrNuHQR6Jk4kDU/rRxhhsBCZhp/nhgxzdswy/6qN2E8qzWczJ3
-lEdyJByH4fHAvqONly6ue2RHOMKxUJO+QaaSswjvNJlm0eiRWWg9tz1s697xznkY+owYg7WZAWNI
-ndzBYReMGF8+z4dhMm7BiEk4a7Ld5jaCEbkVFUvKq4GjH5Bah4hDgX+KKZVh3W8hccafjsBGnGIR
-G0vlIKkEsAC8XxYDOPr1/t3QZb5ZO24fQyglypgNvMHmMpEvd0jHaQsW1JBKRsJjETZ2tBeVAYtI
-Ya6OMygU0zKdF1T5e+FxoT9uyHzbJSlLuh4Yxs018XFLHkg8eWgXHBjKhoHTTgqyS3HnUobam5Ch
-4pQd1lQScci69Uaf1JCOBD6Xju+vIR2/Rkl9C88NbsumowJdWBG0x+prURvbgF6aZN8PXTh1WH/a
-1q2iHDju/srykftxUs3H/XgqSXbIejfwgHI8H7I+7wYhiO5gXV3Ntx8LGdjsQjVSvm0onFE+grUt
-SMOXNgictlvS9YWpv0TpdyShqp87EASBscPY1H8OlCH9MKphc6QM2e4MkokXcJsEjoq8d6g8mCbq
-ZjwnVhf2pcQZuLvZTD7uA7sZTd7DOjlzkp7nBtGn1gdJHnu/DdH8+UO4gUQ0bbgRdDYFucO5EYyP
-UNH13ch45pHtxs9sLRNdzBrmaPC72qmNh/UOJ9LRa740WJ7YsdCqee+ELYS8axE8Sbnu2h0spxTf
-hzNJ97jJMAGho+ueKXllHiTrtVk0d+oQCuakp9nouuENbjYztpEM3eDcRhxeYxvxPi+s9tFuTo2d
-fJ5TocNt53sNRrBN29CDsfPshn2tbsob5Yf24G2pbJLt4zfZZuTLUke1h17ZJibnjybUIBafByZZ
-r03DJ7T5bkKFTo27n1BK5AU3tg8b+zGrt0LqzR3NLi6q+14GZK0GarfSFoTH7TWiRQcGwqxWuuoT
-90V8b+dQoZ9/rzD7AO11YxBf+Kxv0V9OMpc6WCYutqUuc+Et1f8ggfKYLSLRJ83y0g9oQzbtHJt0
-7DB4oLbpbR8yL+LRjhXGYt32tk6xM2+BwdDx+y0UdnjLx1toENJhf7uCGXhNHMXlSDIDETF/9kRh
-F0B4uhXp0U+wB4TJZBBh0dAsld9ld5fjjijWlrlnlem6sDz5Ms65Sh5euKzCpnaympOyOPfl1tbe
-mGN3RgIWvDhNKBrbw02u7RqEWkvXyvQ4LuTRHYYWgVYLqyLFtFeuoJClu/1Iu9pE6xb0rZiw4fCX
-Qzz85p6VlbVqyvyZVRi/ukchRQN0w4qz9pepTO36t1GC9is9xaUwV7FdTZjx9+mFu/dNr9u9bfey
-o3ftX3X8phsKRt5UQvKmfnLqJ9QwtzK9PIRhDI2TvseCakr7n+wi/nRBo7/bDvxT1xh2uX7VKhOM
-Y1w+/RT6M8MUvpvud4eT93gU7X6Jp+at1VqQxcZJTzS/Y5lHnuiR/qUj+78DU0YuyfhSW5V1w2Uf
-dNqZLtev9qX8ebt8/NQv4k/mBN7dHw8n77Ev/fvXhNe57h9lmG/zAPqhTZd/MTX69yqIMWl6S66n
-7pi7f9m6f/0zdZduHaN+fW8/afYjPc21/SzcT9ExKXDZPF32c2maZfv5t5+co22YYmNWoaF5+8Jp
-fu2m19Ql+7HdD8g0JfaTZT+TRqfisnlU90M+TYb9NNnPodG2W1QcP9uBvC098YFMiFtWDZNyHC+Z
-ensZvb1XCzYl8rCi8Os0kcbc8uYFXp/Rf5m3o+0CTordFLGn2540T6wx15bp6fbLvDFNF7jD8XTW
-08fuNH+Mq+PXoSS75WZ60oU0/z3uOyPuJs2YEm1ubtuaO6ZGv4AzYzcd5s5YbBLpED1uDvPTw/b0
-8fpxQdw9IO464zbtlPMEabdvyvw8JtpdWDgnPXM8Qj7sRshPJ7Vtk9yesptyJzNyP2NPZvRuws8T
-SjvmNAWP5uJ+rp7M5d1Un9vb9865/XnXCftZejxJ9z24mxknE2c/sU4m3m5ezkOhzXDMiZMps59S
-J1NuNyPn9t6ynfSPOgVu05T6cKfSHVhYx51xNCBDLx2rpX+/9z9+/8mnL1794skFnv3oxfeHf1pF
-6fDJr5++Onz06a9d+O2jV68uXzydm/C7759ffnz4X+uF7vTCX/71+bMXr3aXfPbs2dX+mqePvrm6
-/NV3Tx5fvrSrWpG30qM6pFuEnSiFHfDJl5ePrn7z6NWLJ39dL909qX119eTi8quLR1dPnv7hVy+e
-PP7Xy+/1xH9e/3evHT76+PD1/7n3P9Zblt//8unjr76//ubZFX5P+PX3//bs6W9fPHn6ar37/n2J
-P1u/9On8h3v/9hx/qfrLb6++W///i2/+dHnx6t5Hnz5+9s3l4bMX37384+E3j54++sPli8MXLx5f
-vvj4h/920B8fPrq6evKHF4+e//HJhV35u7WzPjn4w/NXDw5f/Pej9efTSz8+3F8fMV+ffvD6Gy7l
-I/7l6tGrH70+8Povn3339PH+Wj7ihhvK6244vVYf4tLpHeuk/OLpOsh/3D364R8fXf35cP/w1cWL
-J9+sU2i9mo/4gVv+5erZi0dXh69eXV73Zz/W38dVfAQufXL1zeWL0SM2xW545i8uL55hKfz3OrzP
-MKLrhzzQHFkn1W6G3PJMO2761TqXrNnrT8sBPNzJ/gfVWlYFvv4SDp/++vefvVhX8NUl7/38yTfr
-Yv/9w6/WC+vvMQ9+/5Dd8N2L/758Wx/zmlmxfsg8I/Arpgj+Cw83fd74r7Tj8kOtfaOXb2uPr/b4
-Jx9KHK91d/LacPTJYf2nf/D0z62/V12NKcDXpoN6tvG/d/vS0cd4qeML7+d1tqqT3R28txx1cln/
-+YmdfJsr4CaVtbbrWM1xUn5y+PenTx9dXz4+hE8O/Z++Cj45sMNcn529A+0fLm33hr35mkZOivWo
-fbpsveMQl62paNHrmmn7wMHFgro/EL+tIXidll+/6UTN23f+2+Vf+m0H98mRwE8D8wCReKtZyR81
-DuvvPzJetzsBm/6yjuNXr76/unx575N/ffrsL0/5y2rvffTp02dPPz588m/r4K2m0yefXuCT+18/
-efjs+jnWy7rNrB+I69fp+eTpQRdI+rEmoV3yv1Yj/ZP/ePLyyTp18cDTJ3z16tHFn3/CEz579PLJ
-xXz7i2d/vvzb7/f8w9UXL+zG9Ymzxbt++rNXX2KwH6+zd/2jLrMeOMhaB8JD3BEpuYU/IJiNofUl
-uQqzPVhJc1QyWHCgCahUGg5ff3pvG+evv19/+d/rD39aNxYFVw//+V/L4fEq/vrLe7js68drAy+/
-Pfzz4d7ho6kxH/9Yy5MZy4ePPvvq0xcvnv0FJu9qHPPObqyvf3r833rq9qz/uHzx8gmmwfqGX61z
-7cv19f+0mtp4CBbjJ7Kc1zm0tmp+OsW4bRX/+dNff3b56LtXT7797kovePnbRy8eXb/Ee8wy/+cD
-v+Dwz/cOn6x/fHXD8D589vTxd09e/S0j+wNPwYj/hCn2Q9269DPMv7+8/OV/Xz794vFjdhResc2S
-GwbY3TDAy/EAj6e8pnt+4Bs/u7p8+viWPvITPuwnf872Hdv9r/2Qe5/88q+XF9+hDfwD771JHeFM
-/kGpJG0mpl+++Pbbl5evPmYXvuZ+u+HXV1ff8Vj97MWDR8+fr58sbb/edGkf/9HuoYfPsR398ttv
-181gvfp3T17dnob7e5DpRxrOrTPGvaGGG6tNcn33r5++fPKYf/7oi+9e6Wd8xbrLHT76xZOXz68e
-fa9ff95KBg60dW9ZAsYnBKIlUZ0pp4ANx+cF5EuwPeJSagxkNGp53bC+fnTzJnSzjnJnHfU36Kg2
-6aivnlw/vxo6SiP14y4+/fMmY/PbVeO9+rEW1pQ/KDX6Tiy7W9R7Z8vu56h0z5bdbWrNdW19UDrp
-bNqdTbu3Y9rRBfQgLCm0SAbKpdDOc+ZOcAH/wSUV3qSzSXcHyikvZ+X04Sqn5ayc7u7c+abVbs46
-6rZ1lPugdNTbPtS9qbl+pA/ubjH//WP0PqiDu3Ru/M0a4O0texhg9Q4W/j+8MvMflDI7G1zn0+DZ
-0f8Pp6TSWUmdldRZSd2gpDI4KBy9VGkhjP8GGPs6iquOgqzJh3VWUnegpM6xvncb64uHn0G0byRs
-fPbVLx69/OOnj/90jgH+HU6Fs666QVelpX1QqupsT5297Gcv+z+WinLnQOAHrKLOR76zX+pnr6NK
-OQcCf0SpHH51qhd4aCP9chIN5K2hNP/mo9l67HqEXHukCtVmhz3ebz+BF7S06dfQ6vZXHt0eXj5d
-++zy8f958vjVH1/yiR+r06wN/MNXz757cXG5f+n0WJ9bnH5tLccbWsP3/cejF0+Qt8/H/u4/Hl19
-d7m99Xw+PJ8Pb1OxfVhBwfdKsa1qrbj3QLHVdc/fNEty7TV6LvtZzyUf2h3ouWX3Eg==
-	]]>
-	<![CDATA[
-	j5pcs9ZL/qz1zlrvnWu9cNZ6b6r1UkAR3nev9Vq8SZWAvn2vDvOdqLmwWo07xVZuUrpnxXZWbG9X
-scWzYntTxeZLCu9er7F8/Y16LS1h+jUnl+5CrzVf93rtfEw967V3r9c+LFjYe6TXUHvHL+XdKzaP
-yts3G2xhVjkRNWjuQLGldHQSDWfFdlZs71yxnaFkb6jY3IOCgnjvXK+l7PONes0tNe0OotN1t6fX
-Yst5p9fO9tpZrb17tfZhMU+8V2otpZLeA3stx9leWtproqduyXNcc77rFoMKS56jChHlEmedF27S
-wGeld1Z6b1fpfVhMiu+R0gsPFuStvHull0rYQ0P8a51xuyBDvQulF9wcYghLmP1/DWWNz0rvrPTe
-tdL7sBIM3iOltx5gWd79PVB6E+JtjxjJs5YrId3FCdYvee+Zc2dr7qzY3rliqx9WWsJ7pNj8g1DD
-+wD5ja7lnTp7DTAuxPnX3V23aM65nf3mStybc/UmS/Os9c5a7+1qvXOiw5uac+9e36UYZr+Yj6+P
-cd6KSmvpRqjxWWmdldbbVVrnJIYPVWntQgkx3HQOvUV9FZazvjrrq3evr87pB2/sM1tiKu9BdLSl
-/Jr0g1J3eIz5utvTZK7WOSDa5tSus2I7K7Z3pdjO6QdvHgxArfh3rtdSSrP6yrHuLLR0xyfK6Hau
-uBb8GaV71mvvXq+d0w/eHM5WUnkP8qpyiLNiK9Xv9NqUzXknem2pO29/qK9931mvnfXaW9Nr5+yD
-N9ZrMebwzt1n4HJzM/42uNdjYW/Hh1ZuTHc4q66z6nq7quucYfDmR83k3wMXWirLDsVf9/iIVZPd
-sUm27Bg8QjwDMM567d3rtXMSwRvDzhZX34OTZmxp1msV2Vwz2jW8NkPzduC0R6GBM0bjrNfeB712
-zhN4Y3utNUBX37liS4ufLbQS8qznnLsxQ/QWY5457COr9XwQPSu2d67Y2jlP4I0Vm08l53ev2EpL
-c9Qx+Z1Lzbny2pPh7ZxE6+717fWxiLNeO+u1t6bXzpkAb67Xon8fKDzqEuf8Te/j3VpoLeczXOOs
-ut696jrnA3yo+QCruXUjrPYuQLRnf/9ZV717XXXOBXhj0qAUy3vBbFvda7jR3L4SQbkDJebTjj23
-1XiTAj2rtbNae7tq7ZwJ8Obu/vhesGckF19HbOtmx3/JU0TzFt39S93hM+pN+VZnvXbWa29Xr50z
-AT7Uo+XOx+524C+3J5TNId8FA9CxRgvnA+hZo717jXbOAfi5Wmrz4XO+5GyknVXaz1qlnXMDfq4q
-bTXV3AxCi3dSVOWs1s5q7b1TazXMltpXT66fXw21thy+YJmMZQlrI1//g/75+tG9nzA2jmPz21VJ
-vvrRFpb3voXn9Iof2RrW028ttR7IBbIqQvzgsytl/cGX5CoGK8S0tMof2uLx75RrDoevP7153PwN
-4/Z3bSmpq2tsKi9ePPvLL9eFdvFId/7N+82vvvjmT1+ur/+nw0d8yAGYp6++v/7m2dWn6/r8593T
-KT6r9bNav2W1Hs8A4h9VSa1kDwWUS/L6IdRU0gFZCC2ldkDCaPEJktVCTJkSn2I7q6SzSjqrpJ+q
-kj4s7O+nj599A41E/fLFt9++vHz1MbvwNffbDb++uvru5asXj149e/Hg0fPn6yf/9uq7Pzx5ut50
-aR//0e6hh8/Xjjj88ttvLy/WF3zyuyev3ksNh8O8e0MNN1ab5PruXz99+eQx//zRF9+90s/4iidP
-/3D46BdPXj6/evS9fv15K5kv7uFsglJcKbQIe9gvJWCwnJnBLuA/uKQuofk3OsecddMP66YPCzB3
-1k1n3fR2dNPyYNVBC9VRCLFGKKh15FKAYvJ5iYXj8CAuZV1EkLmW1/P9WUfdvo76sFAiZx11MmPO
-OuqOdFQNi6PncClLzBk6KqW0JHqAfQtUUTmWhUMWXFl/PquoO1BRHxbs46yizmbU21JRueXMKIeL
-afH+pmgVR7FGyprOfGcddds6qrlzEsE5WHf2jJ894++RSjqf7M5m09lsOnvG30Pd5M9Ru7NuOuum
-85HufdZRH1b07gx2Oh/p3j+Ndj7S3Y5Kgilx/eTpo1eXh//n8upqnX8flHJ6w9n793/JjYbcw0dX
-V0/+8OLR8z8+uTh89uK7l388/O4ZFuwPmXS6iVfj4gePntxs0J0+/JYtuSW2ymjU0nIpOKdU51qs
-s6XQMiLn+FPqjjTo4fxarQt2Hkzkn6Z3P0qH568eHP7l6hHM1X9/+uTi2ePL19ptsw6db/yxUbFO
-Xm++vJCmVa+uqr1r9l88WXufk2HLJf3oS0ydp5cvX+6knz79w9Ulc6FemW5fbA8Y1//i8vm6al9+
-8fTmx+1ubvsH7+7orbrxbbz8+E38S7/txj/yti8v145bl/zvnv2Nu8dd6sTlQap3oBZf+y3vwtBZ
-VrvGEYjSaJuXxcW4s82bb9FBUrTQ1hXHRXjLK+6msb4jLWlH0t8+evXH2zrs7h45lOIPDkfn6/no
-+urJNXrgPuj1l57b+NGzb1++mrMm//T01fO/cVH8LDaDvzVL7Wel9/1Z779rvQ9Vt57i7lLv37pe
-exf+nJ/olPnsm3Vyf/TvT5+uU+HxYV0V/z9777mfTo4sgN4X4B2MMTl1IjQ5Z2wMOOCECY2NiSbM
-7pwP99mvpM5NJ8LszDl3Z3/rP9DqklSqrCppPGXA8hNhdqh+GkPsjAm+CH6V+wIv53JHOE//WSqJ
-/JdILk8kGPdC7luVXkjMzTWQUws8SfifTi+hv8LJ/udERC4mE0icHepfIhL+ltA3FsIiIbQDh4fx
-KPwQjZJhMqTu2ZI0gYfR/l2ECp1Wh//fcJNGuAntQwGTbQ4tr+f/VaGm/7R7eGqE04Rj998Q8Ik8
-yToW3c1guZ2sNotLua8SgOacVwFBO/5N4PqCMSx514R9umEZrcdtSLBOxBZuUVT6pcEIDEnmXmxW
-u8GO6beBHhgst2qPCszXhmEUnQyW49Vi+j/stgeGyfp57LeYzQhoFbWHFelD4dFi9Qd8bbflRi2b
-yjP8keRcl/V02VpNOdiKbmXTY0GgJ43pktke9FeR9IdAL/eL/Go9ZZv+zXGwv01YIwf1Kr/aLJnN
-Fva33v2VEluV12RjuBS/KYCa4zlcZAbAIHtNyviv4vmv4vnv3qMZ+dL5HoxX//qvEfi/mRf/T4RJ
-/tIz2U52lVl9Vtis1lc8p+ipP9iQbae5ayCDZU7r8QdNur5Xm/+BA+fPmnQN5/uNZqrZGek756B4
-O5pvZGbjejBljcCAcIGpa7UejNzSqf3BbJANKSb0jAebmdQcHM6XY+n30XYzMhbi/3+T593pdrtn
-rlqDNZzOf6X6f6X63yvV/4FnQSjx0upkx4M1+NJfI2ndby13BlvE5t0c5ByDASHf3Jy4D+am/INs
-J1+tRkMFBu7Bgkd2K/jvOtxbvVX/Jz9Nki74tRh5nO0K7Hfab70O/L8pmJs4HuwGSMSGOYEJf+hw
-MQIS4/ceWxvmj8KGkXv6X3//HmTkv7tLJs2mUJiCofIIRdE0iqJHo3SUZM0mCml+Wqi8ZNNWhDKY
-//LZEXzm+j/JZ/R/+ewv29Yrbxhm6eOSen1Xd5vB8otR37y9xL7e/3YGG/6fZTDqr2Swvy01FDqT
-f4+X8wp+Heznu/dLnvP+VxW9qKEEv1I/LN6erdL94nKc3ezQTLbwlxD8pX+7WrY2kAeXX34/+3OO
-AUzaGsyZ3Y5BnkpriLxsjMDRFOgwsgPCEYxAxWY0hod5UnS9tsHbiOsBqt/dSAY9/49F+bulNToO
-ka6n7+mO4d47MwoBCAY4lcIYoihvgKYJEqORJ0FhBI2GgOPoA41ehBdn0FGMQnV2OB4JI1D5Zq9+
-1WbGPDQyQuHy7AMyShKkdEai5SRCYIU5B+TUU6RYUEg9CIg6sTKQBZX/c8BDommUVAHgERREOEZh
-FI0+YGBsCCls6TP4QAOMw0fwIA5CMrLcfM+vIIZjYQ7r7NsA13SYlCGOWzcIiMWXAKg5+GKWQHyz
-sPBIFMdIFrE4eBtNMxIB64jsV85IxVk0weZh6CAiYEmwVs0k3L3sJWnsqg4+iqQZjuAsdRMojztK
-0SFkEkuWlqv6Jrg+CNhJiAMNeBPC7CWjIQBYhIujFJQIHY2gd2mKxgkOLMG6six1wZNMYIY4HDJ3
-pIkAN4oGLIdLhhFGAZ2wg6KjNBFVlHgAmoGAQxGeoiW0gwCHIGCIDxlklvPJEInmH6UiJEXLAPNL
-jxY8JGBEhAuIR4mIEEWh6QIYBEtbgJ4jlAwuu1QSDmRJi4ULl05YOB4sgeFcXQsZRYwI0UBEpFCF
-NKAo4KBoVJQVLFgC4+DK0QDwGqFZxqFCiJBomsJwGYJDPLFFeAQTLJdyA1aHHAGvcfMOR9H60MDZ
-4niUwNGBA4gCrlAVAR2GjwgafuIAR0KqgOFihBHFYxGAFAQRLCLGMRWPXIJFAwsqyjKEAEtgiJND
-LgAojUhAoFlSnDkAwdJ+CF52Dtk1SsrrknA+ewuNEuUQS2hLmHlESlsRGqMRyeJgEggcBWiXFamA
-nUOc2OMWKyzl2ijGz5+SQQRSjhVuIRq4u9wAaZlE5Q+DAHwIpA6iLyRXuZEiwJANZEsUwjHE4sDL
-pqIsU1EkJhOEuDhx8C9ChUROsyuG+FYKmKZZ0gZiG2ECA4oAY4kMoIJFbJRVotxSQXmNUM1JRgwJ
-MDhgEREnnIMhgGKlLAGBESGBAPAwInBYn4ZeBLZEKIJzmg7xmxhd4Ak2xMoxCQWwsGXsipNYFPE/
-HcLR64CVcE5s4VQ4JMKBi8oJ2pBU0IYwVchkGAisyBUnEaOs7I4C4YXWnselYHWQYM1InrpIcbBk
-SKZuaMDZrFCJUGH4ATJCmJVbQEMgBcRrMt4MIeXrJYAOycV3iA6xRgfNViIBERnCZcaWIF55XqPg
-mKUKB9EBIRO0EFdIwtFhGnkjGBElZawbYbEpYd0wpAqeLAiIDAICpmT4pUPsYlAURwpUFMwXWT9h
-oCpIEQ5cZk6rU3xGJwBMwRFTIR4TIYEkogQqfgS0QSFMAM4PkSghlMRJZLJQFKx6lFIdKRU3IUFH
-hjEpHYcoMswPDEfyL0yByYcQoAiOscTCERknuiEKET9zoCE2wgg0pAxKwDMJQKHVpkMESSPQBBZl
-bSagiBB+eUKG/6ekkhfhmBKgCjjGIiGaFTsAGArWABWEitEwOhxCVm+YlzYUr9RJlvA4UhZQEZFR
-MmQPJHmAUiAQmUWBkEDSggILgPhOMHD4cUP8R0gpkyBMRGVIJmnwPs4iIMRWsdJg2ZG44c+HE0Qk
-gWySK4XthCgjHOKNBpIHDWx2kqUIGshhxIfAu0E0B5iPtVBJQV/yPI4paS4i6s2QKIholhmgGYUw
-DZQTywxA6NEhcfYSnwWTao6QABrhI8JCZmNBpcGYudqtrliPxiAGpGjNQZHXBXT2aw==
-	]]>
-	<![CDATA[
-	4MF3VpMd2+rqcfq1hJ6gIXDtN8XhnhS60nhLdfit/Qa461co0XFuCFjeGgJ0NQZf++XALXuP/d+r
-BMj71VpoyupFMMjBnyiNrfV1AQ+Vlbq86gEkxTt0EZp9B4gutgNA8KxdRoWB0Y3ok/dGhH+Rdj4E
-SwtQzzln8QBsVCD9KHTNEA8ROLJpKGiJsh4NUvsUm4gPPvAsQLHG+SHUiAAVmMRoaBT0fJHmATYU
-QgEGrEmE4xBvJod4zRNSejo83DAPF0jZKBobEOV0CM00BMQCggvcZxbZvF0f4j2ekNQjkcINiQIx
-wq43EQXDRbIpAmSkzJMUTFFefIWlNrkUrKgXAPY5dU7iUdY5Ag6fzHKM8OZYhJe4EQ1SEExyHDRF
-IQecINnFA95plJa5ZVHeG4FWApJpUUIiCqVwCcEMiVKspQQkN+vsAIWjqNPgF43mF42WKhw5Qwjx
-FppVLsD4YHUiQUZpuZfOE67kgzoSQjwv5zbTr++dyM3nxoiSom2m9K3P22bjQEdCh5CBec9GK2iS
-Qh/oCBHBJY4wWskw+A/9pjT48IMIAzDuOC4DEHHWTY1EOEMyQoS5sBTPyNDYwbW8StFLoUJobtEI
-RbDLBpmOHSUepiSzFeVZWO6hHFj+0NBF7hfQ4WwwCBggIY7U2BALxVsHBB9Fk/FxWAVwKycETfnY
-qBgtlYZRLbdrNuCKnvAh18Z0u5NGmIUcSfVk7IN6GtXzXBSJOQdxXtSpYahXZfA4xj5ijyWCYP4f
-gJf9EGhdoOimC/hvab7aTMfcEXdb8EMOzSa3Hw7nDJrWYrC86oLWV83BZra9enPR/s58OmLe3G6u
-E+HkI7YL7aFy2CysRvsFs9wVBruBxd4P8t+vYuibZJ8Bfn9uNm7hxhD84rKNubaSc+L+vZgvQQM/
-/ANL5eD2gb2v/vwPePsx24Dm9oakj3d/rrmnwp3LyhEsmN2A3XU6dwD4aQP4g7vOucNA2fb3D+Jv
-H8N/Egtxsc3oezofb5gl10ZBtpKGgx3ofLjfsduP8JHvcC6x7QBuUUGW+A8vrOkpyUcM3zEepsux
-3PZH++1utYhrNJaMmfjPLgM/h8PlQA9if5ibHqDD7T91cnAOPjPkeCIVzFejGTM2xtNytWT+eSji
-R6/Cj4MNYMNbNAGjuQ2nyzF4jv/z5iedxV9JBUfIgn8ys5hEknzu28m//jYNuIV22D9SVxyLRDiR
-zmq/GTE5aEf/I+ckH/K/pmN0mJX+MKmIcGTRP4TSuXEfrsE3A91l4xkB/+qfNSN+4IdT+tNwNn6K
-Iv9h0/lT1SAxngmBw03df9hk/q02meFqB+zBBjPZ3W2mwB80nJuQsvcPmdXhBE5QHKv1brqY/g9K
-pQJaGnrJf58/txtsvpjd3z6M1m2ZoEqrzWLwn3QrT9QA6GyH9QC0HhkLmn8aCcsHf0idE5QEasK0
-x/5hExMHfjip5aoJj+HIr+bw6In/ZROTD/5wctMlmPd8MPpfuGbSoR9ObGF+zVy2Evrvn+dgLBRr
-91e5YnJBXi2YoYUDRPydculg/KqyiTGpJExolL9XVgkTuSxR/AM8feAY/y939P8GbOsPXrL7IbMp
-slUcv2ptmC2z+YO56jL/3l0Vx9PdYDidT3d/yvkctRV2XACj7ddXjcHyaz/4Yq5aq/V+zQEPk1FS
-eId/IT9Y/jHY8gU2cktOMRVXdrMbrgabMboxQ3FW8K1E/nBV/aiIqM3Mu6s2a1VDG8/VWm2nECp6
-inMuKElc+eEfs+8RAr5Y56iVbSswWN3yo+X29m4PBCR3vHGTO3rA3o9E6NBVJBoNScaB+m7v58xG
-7hlwC8h3grAmB5/frNbZDTNgq/GFZ9wFJnOGGUN/41Fi3hLicV3ZKn11t9+t97ur9mALlCnnV1y1
-me1qvuePIrb3Sfk7TWb7bfAGJiMyngCvpqAV3MQcwqod7rxnzcaz5Wo0W4HBfW1WPH25DolCjTTh
-idE7ZslsWPreXYkLoyQ4ij/8YTXfSGbLloWtpwHFEAfz6VZBBdv1aqdotRhsueUmhZM11oPxWODJ
-bPUqu9+tBCxygwuHQmRIYB/6asAzwwjaAFf41Rcq8DDXdigseoigiKh2U+JKsHwNWx4zAPNQhwfu
-12EzueSHz6XeCBjYdHy1FTApoSn6ag23yMHDxX4+kNGohE+6q7WETSSvd0pPV8V/r1eb3VV3dZXv
-dNTebsNgkpTNrnAlf7eYzXbNID4tg7H2hUuFRG5WNgGUvpNPW9miKyg9IgzLBdRbQRlQli+cTss2
-v2wkEQlHNBqW5qvVJifOVziHRdkwz8zn+dWe1z6EeByLsmVlBRhhtaxIAnOhqGZrONLiv3eCWtOG
-i4Z6tx6MBK0WxWn8KgIzcg3WCHbSmg+WDKAO4VBCOCyYTa2NQREvhigUkK0zVURc0rmi8Ucp4/F3
-dgNBnemTmkT7VJdj5t8dZrRajo9EFxqoCr5QqhCCYgLfj4PldPsNRLsEAKWNnMcp8y/QGOjZ3WA5
-MoF2NEgJN5hGpkAMORTIOwGppelmq1QVMBfmaiLoK6Dv5tMlc7UD5hiHPJjCHyXxsOnxQZaTsQaP
-u/J8NRzM28x6P98KYpDSZF2EqRJwsIU7C47AlkgL5tElvIIKiJEZCinYQEoiPjr+NQFdqm9FYQWg
-GZLlJP8hzWoLJBQClsoj7MofwjDDnrjrHNB81XokNXuEFNGR6kY9ScldWMrSRjSipVRQYwkf6a6q
-KBGlVoNqU0EiahMmRKCCLrWxjYDK0I1r8N5oPl0DWwNm1PwbGC9fgEV4W08wCRWvbJD95v+DgefS
-XgHmEmUQJbFUOHsU2qv3+wEktasG8wczNycLtlyaHUuYsDjAjDgQuUkpD1w4FcACmMTNnmWrpf18
-zlvR3E2G4Kk+wta887j6g9msYdIenxejDAfIPPIOM68MdqCzxgrYQNA030pcG422VRjtqxakLaWP
-uzCnC/Z6MGJov+XhygLrjfek1Ew4VkxJbLiDSSi+4+FIJELgogkMe6p0m42r3GA0g04LSu0UTFeF
-TYlaPmyZq+oCOtHZreQ1pS2sCflKIrLE5VR/ge2HvU1JcEPUGoobOmpoUBkV/8JVt/AEN4qlJhyl
-07wDuBKQGiC33XQ0mJt+gbMUd/wrhM4raNbNwRrSmsz2N+qkuFjv/oSss9VePuEdsI5Sz0C7YXkF
-k3vhATZgNMM5o0quihksR/P9GL4DeVOLwxTfCTkaO4M/IGXA41eQL3yFjtBZQo8ZuhBXIQ6RxFFv
-RdXQb/QSH1ahj3qL5Lo6blph7i3sqLfwk/qKsG+ZnRagM0Eh40d1hHGK9KiXKAXP6wxMncAUVC28
-M9hdPU2X49W/1NlE2q7JntB5QO7SNsDl/bdiqJLHU2lsUjlCBUJgcpAR4jFzr7AoVKdb/XfeMIyn
-puiR7xHqVGj4nganGL5HnfheSElZmohXV82r9Z8Hmk9BRJwEvHputlRhiFq0sx9OVvMxs1FjrMJ+
-DcYG44/i6HLMN+AEXkW7phCKdKuCG4AcuCScKEwbgeS4Sq5A9XQNr53EOI6uZkIH+Cj2flQaKp5J
-g6Oy50HJYUwKflKe1WT4mB93UNyBCK63AeBKQHuRv19PFktWNv0eANwyCqwpGs3xEZIEuo1GwDZA
-qcO6bRbQfN0emASKdkvmayCLras1GqJjybgJagxcZu8ftJgsd4HtfrjdyQlXBuRrMQsMoam6mkwC
-+y0D1hVZrjoY+/c6sFqP9wYNtjqzQw1GK+1hgQbQcdJvsFrC45hZR0a3L66lGP7AQxotvzZquxRq
-LTfKlpGQekOZ/4ZrkKmcnNW6HC0CvGe02n0rZZFGy9Hiz5ncnFI0hOkOgqvvegh0AldPzBDITyDQ
-xldvrs7TXevNffUHcbhFctDlCu4h6w5rAV5XuhXSJpvxBvAQKtHgRqTfLWo/WC5XOx3soka8e6mH
-YbbhfjkyaMIsoVvIKRXXa5MZT/cLyWbVu/6gAUkcpjxIG/yshoD3d4vBWkliBuhAvAze3sFTD82/
-wSJcXDxVcQQbbvkT8XTayJCjKpRHm3EAuvbzwTrwh8l23zp8AZrtgAHH7/upkh5osx2NllsdCc+2
-Wc/5HDRcXaWwzQZzhh+7YbtvozluvozxANp8C3FX1bGvuV1m/RlOgFDlj+cHIovQagd8YXggmj5A
-qF7G8/VmspLaYRrNRN4Pq8pASDwLWNYJ9RCb1Wq6+UaMDJhovVutTbedM5OdztrItad01CaaS0Zt
-orUwahNtZaNW51O0+zkcbPQMI9huIzll0aDpGlid0+VkZdTzRjITHXuEawMvh9aa8JiZwFimpI5A
-lZ7nm4AQSxyy55roteXtivVqp6ePQUuRpg3kLBTpxkIfDXCwZWW/iaYShaum3oV2Q66ORQ/gmNlO
-v5YGyzxarzcBtEGuJ69go++VJOCv3exf5ppJyyp0gIlk4CowE0AY46vhn1eFDTC0NwZ6ELwurk8k
-pC4ZQCPkyskYPURT+o0lbE7rtxRYHI/qNxT5O0ITWk2lSAvjms0kWFP1D0CTMZuHpMO0oNERZtt2
-N+ear9dj7a5hM65roZ0JyKAt5Mu5JAfQxEuQT5iNLEled0Bse94GlJzzq2clr+bw8AXAYgpXH6XM
-AYBXWb7xlbjrYOAiqw0UMvR2Nl0DYbfUEXawGRzTwa6mstEGuJmbLQM73ZiWd3yiDXckk95YWcE3
-n+v5BqgdIP4jwPEj2KqhurYaVoGykiD62LRE6Q5bSHyhNf03M28xmwkzErZQJZluAHax1bmCl0vC
-naOrwXLMpkkqs91w6XDgK3eK/TA8dAi2zN/MDMGyKXVabqrwDpsuFnxktxtzUndVnkSHBsFtH3ZF
-X1qzTUe6xXjYDO2f5bmd0bZ0Z1TDqZIl50EIOhl5EuwRV9nqAfLka4KamFiS0MFLxyEcvWIS3+yw
-ddEta6KJbdTqHGQjAPq4FtPilitx4/ZqukRb39A14fc/dQ7bp9J3jldv4inpjA+efTXScefPZTbl
-xXfsa2mtlaw+lzM/HQS2N+GHSjFsi2UeyqkmlY413pzNzGY/ipSKRDNqxynKhmHbwk/hy4fdZOIf
-AU8m4VtvM9s6EbTYM/GGdcM3qu1yX5X7RiZBMZ38NJkaFQIB59dBV41xD/QXKZTsschLeVf4ec9R
-L35fdrFqbLPVzu7bmwrb9qUCdfOU+5k7nyz2wgSrDVWB3UToSeTx/vUt280HHrU7lbaLvWcSs9J7
-JrYNLLwFn31fcpXHE4sdIav02b/bFybvT5HcPDN/jk1y37v8d+QFl6Hj01EY4Y3fTCLtfGLhgCFv
-8x9fHyvwyfFbqI6r1pw/+nOT7fhtS3YMz4Px3mKnf1zeUXEUunflv6l+PJG1kw5v7tb36c3knQ+l
-PLP3pB5rtu/4aDSYwU9Tb3HS+GZ7xrHgILKZ3nzGph+1cW5uTzv9G+/bPtvoOH7h+A==
-	]]>
-	<![CDATA[
-	3Zl47Zu02MPxx/dMdjlyLrzJZjwYWbwlp5FIcDshs5tRFffOYrgAcVSobR8B2iJOJvJEYuPYNB8c
-gPXFm0mX38fk5pHWgp1Br2HP5KsJ21PRR4e2YF2qr2FbKpJffXgTj+PXGDG0vSOwqaUdTCgV9tjg
-kryGn8L3S4inVG7mDvs50nwcNzD83dYsBAcJR8nqfdnAXsLwwQeCgppY7Njwukqhz95UKcF9SjwV
-62zzvK/4yQIjekQVkO4z5k2lij6ikP5KcnCekon4+Of2A62kMGAA7y4X4noBjXI1YQDv4gBwV7IN
-GzEU+i1kzRX6CNUFZpumwi/hn1G2W/jxFibB+m9xMHDe5MLDh/tEpdBPZbvfo122dTNqZrsECVY/
-G3nv2cA745fi82d6L6CIpVoZmX7MRGDReWBT4RestypMOsUxwicAO3B7U7b4E7tCELLFXuzj3scc
-9VwrZTab7wcq1nxKoxWKhqabMFg8j8+bW9EfSlTKJy7FO48ndmEhKIs97k3uXaXCHM9htVAM/Clj
-UxZOKjxcZeLd3XW2W9vtD1GpWEkJ3vmFf95Y4W9dIMd+A9OsEk/7Ns2UXI61O/8dbr8Uh1jCU2A2
-Gx/GtJJxYSAsOgRkNMrZfg1H1Jbwf5Ygp9YDhepPZMDyPrug0c7vop69+8g1S/lJLYrh9eG4lB8v
-ekh4qqxBOTcPJ59E2OFdI/mSq3RtScUYLHYwCuauUJ7ZGdDVfQJKGBKbxJ5Wh6NVthuBT75deX09
-pGlvnLpVYCRe3a4m+el2GobS0v/aIty2akWcVZyJORaAk9tuSF5Nb7L2UuM7/XoDcowET+0NT3nX
-Hy+ync9aIThNukosgImzEs52m6uvzGO3OigVo/fPFnvCixXfBHSsi77VLVFyhGPPYM33dHE0+3Xw
-HSAGmQ9Ywex4dTaAeEw6s+352iNtdz+oAPHnpCLtb08gW+91lha7RITzz/uZbsRxl2/8dnGZyvA4
-CpOs80OmA9qlUt9t/UbTADJ3yQCWCg0VT7nVh89nMk0jedsDlGh5VfR1R0mAxfsnwNjPN95UMkyi
-p9mOL7PMT6f3Yzg1K2zSLdTrFX8pUQy50VM4ly/Pkm3ebWbsuXkNC8C1ehX5MxJNTz1U5nEYjLQq
-zTY+/HjIkg7rTZFw33zk8XK+kYGfUoDE8STGDGNp3OfKp4XfUha7/B22JfoNfs1BoZhHL6Kv4U6D
-uIdPk+htoYM8/C3Hgsom/KVIyF9oE/2XdRE2SQCZDJvDHwpCVznY6FaEw/YC+5ODyAiDTwlvxFET
-OJoWGhIaA5gLgJNlhwKnyU4YDgpipwt/iyNgYi8IhBJFcMhqnaKvHMYgxI4cmeidOHyKppEWUck2
-hoNjsbj8it8LKOggfAq9JCRzERcvpbu0phdCsQwWu2Ih2HcgskTYaBoIT3J0JNGsxK8IlNBzWRyD
-xS5fy5QayekuCTtk9EmYFdup+JWlMVXCMEEWsHFDmJVIKkqaZeeiiawkO1PEOTw6kuKcYeM7NaQq
-ONViF1CYVExTwElMDiItH01efBc9VXTKrYvIdxKKka1qSqRa1BhiIqvCKnFhhC1BeLBEys6lhPCI
-wJpFtWQMuvSCUA5WH+JRgJ1SE4BoagJrHkeGaEFYjCWEDtAY2+Eo7r5Dn1j0CzONhB8DEyDAf0hO
-79HZZbY9+aoDs7K+ViiMbPexvixlcHxmsZft5T7AScgVltgm+3t7otTfdT2ZONayeouPzxVelflv
-JOaExCpQeknSdoCSoWPAmi9ABXslrhlOA4elngs7gennftX0piLxl0YpS85uasgPkE/IixwEiz26
-qmGRot83oQr19C8l7SXXZ7LtZech29lVF0VvI+iSP52XMrR9zTsVbbfofLEdVF+7v9m7fK4FbRjO
-ulrIEAM8UGiFyWcqMTYi8dFDOxt5q7ULtY3nUw1ANlR5r2brT/fATuZG9mCflbd3zIYz/RrhHFDb
-bwHBdwjo+w76ngO0LnjfAQKLRB7emXphcr/tBKetV2A2F3/zrL1NEtev+s6QpitksUudIZFC4dRY
-D/s5e1cq/Dz189OfcDA+Wdi/gH3rwQFOUp+RSHu8goPzi/YRZ8Z25u8iKEDJHLD/S55F2CPEA1KF
-L787zXZwT6Y+gaF258x/e3v54DSVjHFrJceTzBeZAbIPlERHGMgx6Rq0Kgj9oFPSBoMHDZbmOeKU
-DETLqXCkWDoXGaBVmQPPQrT/5da/ZKD0jKnnwYTG3tJnP0UXyr3IBLjjRQIjylRTCfbe6n5TOCks
-jRX5bj/vC5MHbxnI6VKBcI+LLAciTxXqAJoVXB8Jx0yLryKlj3ePrVRc7j8JO72Icquf8N0EX6OR
-UaOWu29lwFx6i1vOwd/37Nn7285jqeAe8w9EYl85sMhsP2xhjfpwLfrIypgD8TID65L/frPGvKly
-v89T1nsArGCgnps1vcC0b01Eno3BSMtHbkYkreIDIRCAxcaLOQaVyC3E9osY7QAen0rfl+6ZtZRu
-pay7Dtx704+DX76DbiQTr/eugfv4bZXDvst2yuMfsC7JDZF5sNJoDdAKJF17goEkN0EPgBxLf2/3
-aJHpeyBUQS8fAwCiuy321/gwE39wBiRBMiI0v45P9q2fbPdh0AMdxOZY6S1DgtFU/IJ0VgYwLHZ6
-XlpNtCgGF1p2ee6VAjPJvaQ0oqjPvxgRzjoKQ4rpGHKvZCCQe78AJZfcrXm8VAi9EN5U791zCNGE
-ly8B25Bwb67R/0b4BOuSCtf2hUB77M/Ebn9mgorqhq9LyzwXGgTE51//rqaF4HM8w+PTyQS/mY9P
-iM8tN7hyIclJ0KdkCKp5Ire4SwEtJjM8bqnc3Z58Aahub4teT3gi0Vgi3UFSCt/YfqOZ2NPvND6p
-DL8yseeSFBQrsVnfnR5a7EhjJ3y9cAXBluhuriXmAn76bgTW7yVeYNZ3DWROhG0NygZ/Iwr1bvNa
-7D7yOG90gaJL3xT72PK9MOkWJhZ70bdq7rOhTPa1OGrN3QpziYtMftlnQKDS15Ft8PYx221kIBvS
-/sPBJ1yZjZ/eZ1vt4Hts+hGdgBV/8oB1kZg3rDpKBgHFNDzAQHl7KPXj30Flp0TqdwEW+cua+U2P
-GPEBXKt9NjpcfwXwyqOP+w0sMbDHuje//pJrRbsVj/Bho0qIIAT9Cod868/NF9gE0MvsJZyK3fUy
-8TWNH06NawfXBbSMRO9XHs1GqElsPB7+HjZ58Rcw+sVZyjPhWbZbGOC5edQWxQjf7zQTu7ufowWT
-SJgDKkL7E8nR8ytgmkIz2+5mfg9pw7bNT5PNbSZWsg/C6fBzOX+bf0wL1mGY0y+RxHT0WqiO2q0c
-9UTsDhb+w2YFygO7L7lq6QZdeSvtOCOYW8QAILR6OF6/yU4KX7Z3KhJbB/LAHJp6RFDI6oPAJswK
-Et1rwn1j70PqThSHwZe13PJmRxbtOm46pb7N0QHz874VP352IxSDPMRneVcc5jwuiz3W9JKv2W7X
-YZURS7oqgG1wUSqOLBqsEOa/vmkQSMVWymffgYmYqT4DOVbwdUNCzJAdLT3LFrvZCN3+oqnP3AJM
-ModpNoGKYABdJbd/6esK5hnwwrqP6VkmkVo/AV05X2IOFRBMbubc1XJU7/qhknyjnKZmypl5Miiu
-wBvsZVa9Be5HcSXlu3BmBbVhDcY6wXRDpA24CC+0CCKGR623JXevtcvWe/hY0mmyfjsujBe0T7pn
-AUbmAlL+bvYlyl9WCK8+v0MSThV2L1iB671d/RQmdG1eGHqmdrrxuUmUsvPlNQqHKugFrD7cyovd
-5oNvhXo9EWRNNeK+4y8V8YmrFMu2r/kFfXIByd8NhpOlbCoXtq9Dhepgbj+QP/OWG+DmvQ1laaBQ
-r17ngbSUM1DCt2/1Shls1wdrvhyWrB4fDlzYB/gOTQDOIT8BG6ajErCkx+VmnctIN/LB711l7PLd
-Nw4J8ZKrusjS32+3tlKh1eyU7GsKCJcn5itD5l4okRc5Mwh8Eg0stIeXjXRs+Sz4fyWT8Afcqr3A
-Ro4yDBa/gUZF8pDHbLMs5co9FF3b4TsUJLgSWdjW94JWADCuv6fZS6eRI9yTrioI3FkbQ5e5nl19
-33mknpMepyKy5z0+XcIXgu+vaBcArhVRGHTKb2V7+T0K6GW2lzTeNUrvYPUzN8gUQXuU0E4OZ5qF
-wN13QkK1qbBvVfK4fWFgBlF24Epk5mizMc7Qo0duCy5ce5DOVBqCSBOluO9adOAPaEyqttfjSclV
-L9PSRUa0ev9mgw/m2c5wPWG9RSJ8/ZVbXEd/JJZSprL+5blS1C+olycyMYjE7+9a2c7+gThUKKFN
-obqYboHayi3ACOfh0mfTTmtbAHexRBtgrDlu2NSXm7cpovQqOCoOVxW/Qbuu4+m9OPisXucWXodE
-QfM0JrE+0rfPYKWnkn17BTAJ3x3MFCqUSR8sYsXzC0zu6i2vkZH4/Nk4n0uO/ZrJUfsc8HSApy3x
-yVGThSsKJGigOM/9/LQyher4fleouVwluA1aZfeNsvPBAplGxZ2jauV7ru2BNX5ovDbULFjOjN3Y
-xpDufNl7Tx9oyNECl4rj2n6HVV/LCQU/cHMBBsqoG7v9GO5Lnx/EAtIYKWymv0hJKcnkJOIf8jmL
-Bzs2ewXK4dlVmDjWtvCuvkuW+vNAUNbL9MP3BVZj64nEPrwduB/kVa4L6V6SwCCgBlnK6VzR+FM9
-mI2WtzuYNgAMuurgObN1P18X6rX33wKT+LgWFwzZ/J8UUNGTNRAfb8FwbHjnMPs2fJcGzlWlUurv
-3v2ljJPpyjfjwohRWAnDOwYtoJoz/u8o6M9XLr9Eu2/FYTf7VPgKOaYK6SUILl5mCVqalVPckhTR
-WljsaAsy//2a+C1lW5l1rLndr+ShwXD4F6fbhVF+MCt4psFRJEEWmeLLpFoUwpOoSQdwfKcEddMg
-G/UHrmEspIzEFsJY6yXS/awES4V9Fm1L3gOLw+kvlJbZJtCfXXduFk/4OQNFAfELCLjOvjsWEzdY
-acgBvb/OhdylIJBj41jhSyItueddG4dlDncP2faq8RlO/bpnUpcZ4jjnTDSKvvcc8PfDxEIMziJk
-Ad37NgUYS/16aoXhM9MG3JaqlHv99SeSkQL7aGBeWBwuTpgEAtxfsoU395U0MH3SQETXf3NoSHx0
-lLh37SA9JcIPrXEQcOqDr2THXcBvvm/7CjXrBJPOgG28xsOPv5MsUgkleyMSU8AWGgMaKzlevpaF
-yerdi0JHqvFrTtTnojA63C3vA+uPbP3FHRVXH6YAOIuj/fVH9K5CdmnSV4uX+r7HmGIuApxucaVQ
-23I4n/mv75IT7npHZUMWAKzD5ezqdxuE2R13hfdpzybdrRYFQKw2eGyK85e50ffA/m2WnGV7qbIQ
-3CLgID3dBAo1ry0k7Xm+uymOhr4xzCJ4ItLcr4trB1z4PrTXErJI93skE//w77PdfA==
-	]]>
-	<![CDATA[
-	pA+8zjHwsIP+QXaVZUri4FgopCsbz8TfH3KRZbWLF96/3gng73fmmSAPDMiL1hjw3zQBJiwzRYsl
-R7mxFtORAlYH/RgO16Zf4a6/90IUrf5c8Hs5HtzQX08bMNYKPMsjh+en1lcn4BevZ/RbwG78S6Te
-Q9a8Bwc+weIamPsPwzKMnNpx8v9NCRmnBMw1vbpbw8y67VUBXdglS5vrPJZbXxP2R75QGvyGCnPF
-Gl5cfFJcDJkxm0YoT10FzwrdwkH70mq5kxUDC/0+D5TJrOBHmGx4txTP9FBAkh96QUiGtRytxtJC
-LAEiPJawzmyU5ziivhZrMQGZFIG1NsxoelhIqzyQhj2jEp1Iw6VbRmhMmnApxb3a4Qi0MtV3DUAp
-z9CBUxivhgw6Vgae5KF4fnBE2vfqX5XpWJkfedBseYB+QL6DP5jmfr6brudMVp7BbJAK7nqFV/qh
-ap3V5ur0nHS1NHCYc9sqlPqtwRdTFYp8XN1vZstcDTbM1e6bueKS46+2fG35v76Z5dWWrV8fLK+k
-w4O1K1eDLfwZofYKQBeO6Qyg6vsdAi4H9udqfwUIZnm1Wl4x4yl8grpmwX0NpkuYdCrpyHcFOhNe
-XTIAV7sVBDFirqYoQ3VwNR/8CY8EHazZUn549uh2P/qGw6suC6gyRgTD9rYczK/2YHSridj9dHu1
-X86Wq38tA/pIh4QJkQlAjzbT9WHOtxrm2YNXp5KE/sOCDlnbrqTOTRMqvGU4L1at16fKc4JUX4J5
-wIBpu9/7xXA5mM51iov4uYIFRYn3XUmtph6hcfnG3YPLAfQGJmR5G8NHJx3lhAI4ImSEJTBw5lCA
-KFpTaFm5EnpjpIDZrdcGDXG24XSBLr00u/gNoUQIV61g5xt39kPAYFCstyHhm1h7gIoCIHH2kkCR
-XtROKBBxfXDOisaY9E8t1F8ktKKmVgk1b66Wq9H3ZrVg1KajfkKArCvxNa3SDRMMx53cpvue4fFt
-Gu8hEmuxdfnotJMtOrYTyLg/TVXx8CDY45xBD0Ayc+BEZaFx9IbpY6BVS+0EfkblgSWwSEAT/mu1
-meXkhcH6C6Qu13QXVk7dJtcVIamzGwCTcaMvPU0eDBjSRKmJU7L1iI8/mD072qyGg11j8CcjCEBC
-rbJcg+DRCTPZ4Yo/wYQyxWeq66Hfr3w9lN3qTVVJATJGO47oBEV6/GEPCm0Gj9ZE1TMi/xw3lLbk
-DDxdQoZYPxpxvFGymy65I35FWaFrFLLVkFBBiW7GUcIlv1qO0fEF1TEQMtPJVO+AEwO5dIKEa7NV
-7n8e1o+pteZIC1aJKyWqIUWq6RrVk2PMnwmqfkSNnpo7RWRITOoia3fnB2v2Wocpr4eOo+WG/tkK
-MnNGKvf1ccwyPOjiHCo0JnlAMUfZYxLG1TrSQGnrPcmr3rUtZUAaT8wQnll91JwljC6rRwbPWCGV
-F3xDDq7oqLEN4GEzK9a3VlYMSt1ujXsSzB33BRye+XYXGImnvfN1vNXl7Ape8y4p4ZUEI6BJyxq3
-u8OQhIaXnZ3POwycMiNcqnAwxjh7e3xxOZbfHQ+HxN4pD8Mn/DMLWiXpL6qVj95U6DPiTT8Og1jQ
-2/R50987En4iqMR9jBQe3Auf0IM4me7ucoUJXZ5VbO3koDDBeinhKeFNtsPfVuf6wWH1ff90LXar
-f3n/Dj+/Wv1Rf8zqDzqfA2SDtnpTZauD2pI396hnKn33mcIqn7U0HFcU1e0UmE1uX/Q2G0+FetXa
-4Z8WZoHgNlShP7vlZPEpx7Qt9kxw+5WIvbeadOGlkP4Ok661K/9e3a9B89oCvNjKo15C1rz7jh0o
-mhXmvonCupxNflJ+s2bvProPpUSR+uHn3NhuNsR2AScxBHPxEaWs1fvi8qJpWO0M3rB6R4EqfJCD
-k2xbva+3N1gw2XMJ/d1TW2LbRONGkyRzUTIafgkvXlB5FcohFp9a7Filz+Q3m9RgWZ4//gxzn837
-bNa3KnmLT/nr52Al+1LPVsLpfKmbpp4zwV1ie/wkLXaVaQ7g1GpWb/k3ZXWNsYDV30k/wlXD0Fpa
-/bkedTA1yteGn3K4J/uWRdNI0ZWbH/QJVdfCVQUT2lrfnQXCmbouKBqBtYyWibSt8gG+lufY2NEr
-SMcV3z5u3ubROhakOi4pqUCg0bL92WInM/cuF3gRX0qmDglx8573ZAC1RfcctfELgTqlVu3OUqvT
-j817/7sjdiqbS7Sc/Az9etaYaqcf4ZeWVqcV23wYfFHvNGF9tdi3tsdeS32u90lnKpZ/ral16o2P
-qIRGp6Fvz02aaoqdwh1esVuq94yVME9TtdPr0jh8E2m7b9U6xUrdp4JGp2GbxW5vdbJZ9blSvU+s
-bHt5UO+07M84q8PAsyp6334GYa7TltMJ1kW+qmR8Nx+jTgFJDovyVe1t3onaLezUfUhKgVcq2cx7
-QafUStGpxb55/0iUxG4VnYbmd9c7rU4Hmw+H/VGj09IovHSGSdSpxa6c6zb7Tmp1WqFWr72VeqeJ
-a9fWGXFs1DoFc9l/4na3K/36rjZXbyLe1ppp2Gb73b9E1Duleq9YqZ5A1OtGWQQKUlrQduq2cK/W
-KVZaTWuanTqad0xZrVMwF9Atg5XvbS/qCL59wuyz4GMHdBpZKzrdOst9Hr09v0vRaeh31mmjTi12
-vPg2K8nm+pLCGlWahJ16DmZamf1GqFyaUusUaywmjFqnFjvqNtosfgzZuR52+oHdze866p3WnS/1
-QGC1Ue200yQjqFOo9w/n2ihTdUqj01cK61Y7bo1O97tOo/waUXQKekHdPmK7qSaCu8xt8Fur0yr2
-+OFMqXfaoJ2PLuttGuhKtbk++R8dmp0+ZV1xm1anU+zFl/xQdMpp5O31bZX5sY48LtVO34fXTc1O
-Z7G5s6bR6Vsa+/jIUqAX1bneea/XHiDeVTv9JJ9dmp1e9z48QUWnsBdO11g3m1JrBjv1HjDNHZHx
-XkcTI9Bp7Fcpk/b48pHrdEZ7FJ3+9iOLDbIty3Og7V0V2VzdLW9stSvCTn2HnNoN2u+mzTboNLNV
-zrR4u8a4TndpL+oU9cKJQjt202eZhnjfxWpyqXSPFYsPJdhpQNEpEIR2q5NxRXqg09JeKQiTQf8T
-4ErUbRqv+xXy97pb67ICgkw/NBoyY2q3tBL53Qh2ih3M9JF8+3kuJDyg05oVdQq0mIjgzabo5bVq
-a6EYlJWgqxPtp+So6td8CjGWXM01nwPR69hoPsWKibGPf9o5sAUamcqrIGHKjwcCvtHu9vm3VZ6O
-P0faT5vW+ZfiqRRjWJO6CWi/fbef/Wg/7TzStOZTwC+d72JO++1ue3Wn+XSz8xG8Uiv3Drj38SHy
-K2LsTclo2ONXfs+/ffj06aZ1o/M0/OZSPJVh7KnyXdB++yX06tV++j5z3Wk+BRj7cFHP2m9/fH0w
-mk+Bek+ltJ9Sj/6BDsbwZGDyoP12jqYo7ae3KXKlgzH87jcW13w75liv+ppPrQ5vPsQ/7W8OMGa9
-aaZm/POhUvZZCaywkD9dKzwwKGbagp/uQE9Ta3cCur/NpaDFBu2czM3mHOlktzDD87lg7algY2qd
-Qtrb6Ub9VscefCq3gIfpzJee30pj0XsDAGxOlQgBsPmD0+TQDZbxuggkerotk32ba8KZbPlZ2wv6
-OZKZpmykE/mxSLRCP6cnittgM7p0AtfzeQ+VyDOSyZOE2K3YKZDoMVyzU+TnaHQatkE/511qj8m6
-7b1pdgpM2zWp3Sn0czQ7tdihp/PFd1ueSztNWN3STqnOjRS9rRAh6XTscNgk6IXWv9Apqn6SdBv6
-htb/XL1Tyv2u3el1aRDQ7BTQGLT/xW4Vc4XW/6dGp72+Tqflm7DMHpN3i6x/jU6BaQBsioFWp23N
-ToEnHr2tP2rOFdkU8lW9gU99wic/Zy55kkHNdha7tCWZx0xAxD49sayJdsjUQtKC88Vg7IaSxIVk
-rOtE2BHDMim6/JwnnGmsChFDKmOCKV/RJ/mT93vyaF1Yd/2ejeuBX9siPwG0htze3Gp7y44BfCrA
-uEER9awQTKD7hxb46oDG996DOkAmMOsjcx1IxtNyrPlGnYwYTkNCD6uF7HbxT2rtGnc5i1kRfgSN
-wTAzvxaukSz0iYacC34zBTv8YxOw41GL9YEZvBbwwY2zIiBQivdUqmiHXAn+AShsrgwHVdrqDsmG
-+x5wH/zzKo24oMiVhFgQ0tOuYt0I6ejP4LkgetVq8yNv4vUGmh+vK+UzlPwRVlBj/ZzXJtaP1S9P
-Uq9GHvDkiKq1OGf9OM8CzRBjfpjHY5ClTQwYs509iaCgRjYkdy1iX+HF921Zk7JEurIYk3s8YALz
-+ngHGOMw399chnOwST7wqsC7uC6GyFKInuJbyiMXPUWl6BFmDzB23Gr0fBsZAoUhy0UP0wo4WKNM
-jSuL0Juuqo2HG01/7wSyvekTcKe6wwAafxSJ932uLuFK0pAr2XicytT81yamZlFOTjm1dOy+qTM1
-lofcDsRDWjheW0QeO1RH4qzKdQe3+irEXnwr+PUnZFFdrYO1Au6clM4FNpTRuQP+aastE6KxjyI2
-wa97ZyNGU0tDfvHlXBzZJJtBfupsUEcdWO6FrmmofHVQMo2s4LvBddkr57uSJt/pcx2M8ytGOyT2
-+msZnNpiPvSHk4FqO46QLAbX/WvURNgZUV9QO7ugkkD0AW2UDmSgFFQGY3YPQcvhyIakW2NkTUJz
-ksHvlTepsMLE1eUxJl8S1lKULUnZyArTEz3S/RfQfFzGPbmfkrpiOrQZlRajpPEsuhMnzkn+E9cX
-DP5jb8J6stjV7Cf5+paVcvoQWR6pQXc4JM4TB4NirrUGlRGsOVWTTjkkFYNO1JV3bYFrjZXHuCya
-dOqGhYHNL11B2q5vWJhdP+QlPfovAwyCUjV4uHU5GljwqHGhyJU2MOySGMMvhzHikhgjz8MYp5aF
-xJUDx/Wrgo2dg6IJ61i0jQX9Ih9t7nmsLzkkBq06F+zSViM5JjGw1bnyqyLX8edw5S59c6SjjPZj
-VWks97wz7ShrjcahPxqLGexgzKD/YDKMoGoYorn0DTjZ1EBkLp5iIBa7iaHAgRgwrv5AkG0JhqKw
-LY/GCRyINqda7Kq+4eB6V1ZRURUUuj7GM/RKvCQxzYhPa3IVNoDFX/OS0b5vv3bHdODWtGF+qmad
-a30GAUP6lWh4tPdqflCKIZkVABa7gWEFbAUDtWxCAPA2zPvO5TgR6Yr5kenHblMxPxZjRyP92zwf
-c9kdGrZ8FW3qXWZ+YC4T5+/zEbFODZ8c0P5OM6xosR+NLOq44A9EFRdPPkTWcSwuQ5aCwfHaFmox
-GYuTN/R6b+x1G0eXFjWRwXUjJHqxBPIm5rrRHY0kJMtlRGhZ8DWlBa8eCDAKySLJv6jJLfjTpka5
-NKdmsZsIcKCBKNXyMeENnvcBJezlLuVJE6J/STU3WmrBGsd9amhz9/i4j0K/AMRMYg==
-	]]>
-	<![CDATA[
-	rpcjYiAa8RqIGzFeo0vJoiiQRRrkpnTw0JRe1+WmNCnmjuoY06prkH7w2sziTiJh5ES1ruvsSR1a
-wjpqMHbvtNjVaOJ4SxhMLXY+v6zrch14HJ1zlAyGYsfNzEqPzusHeo+fEBvnNxPhZGlHofJMCgAZ
-jYGFssr13SkCAKAlrECLkNGtpeo0bNn6gaLT00NsXp9XW9XBzSp5/sY9+5uc7/S5TsjqPJw6FMLe
-cykiD5aJUuyK6uk7XW0HgcW0ESjhFxPxVggsuTtbJj93LrBJAVdNrvKQJ34aHLkjqQtFa08cwjmN
-Aw+gAF+Ss2HOg2Oo9yymNB8LTL5DeIwSZSW/JCwOt3ldCnsT/hbQ5xz9qJdMwgBg2GXUDQTlEdWg
-2T0+TVR2liZQaVEYoLoS7XF1KNHAb8YSzWLGkoC8YbCLpy/RWC2WP0iqOF2iAVANpWvCZ0Qcu4ME
-gbWsZ1tKzw+XkGhg1aBEO5v3IRxDiWYxBedcicblJ19g7xVBkUs0walHvtjdvbiPo4hsqS6YngfN
-bh1yAkcSu5BZKWtZLaXbe2jQPz8evwGrqV96a3mk7ATLDC4nJkatz9vIhcC0t0tl+/smxCwApuo0
-mhAzEt7P48W3N9OOjxZtPB4kNWlJGGM46qa9JhRh9ZVwzkuB4KFwDrXBzrsxHFOJR3BfzIgNH0+M
-VYu6UJbbA2d4qA3Bb8fY92q6kI9dADkWPNu+B2LkWTW2JvH4zGtDIZ/CbDaFdgwWAhuezT5PSBee
-rcXAqhmHtExoMQjnCPteU4sBOBew7yEUDV0oz4UzAUdDG+rrQlUJ83S8NtTVhX5u9eXa8PnEdKTD
-2fc3SBey/r5+8pQJW+AZBuoqGuO6u2czVZQJIloRizzodKhvUarytmqcHwL7NsGQZixdAGp2YxBV
-0JO1cozpmrvKvVddj6i/MRW6Ptw9lXl8gBkCOqHrozLz4JAEJuV7kdOEkampdNKG20O1BH4T1JLJ
-eLKWkwZcSu1ApJi5ZrGr5a4dzn+41QkCGjKXMtrTu1i2LQAl7N2orctRCfUQGF5vXCZCMtyaiidr
-7AzIKTkfCJpKvkXANEwMmE+gjIBIe5FlM6oPSjEkkxQRtKjHQFjW5dgCLkQjoncoDVctF5m8TiKF
-l9JjJxPc5RrFzUeyjyroLPbL1NDpV9BJK4bOqaHTr6BTnN5wcg2dfgWdrFrwjBo6/Qo6ebXg6TV0
-+hV0imrBk2vo9CvoLPbL1NDpV9ApqgVPrqHTr6ADcuwiNXT6FXQsv5xfQ4emoVlBx+5Wn19Dp19B
-h7yko2voFAnJ2nVAybXcE1d3e6V2nXYFVs9f1h+SqUgvGFRe3623yaynA+NcyCBqObaXSYY9iPSC
-IZ0a6S0otb3u0uns8YEOOpq55GbwJNaVKatsVDLNmitzRXidpeaQNPb4dIAZ5GGpzk+lZsRE5Zzp
-+SkjV6cj3TC5D9bxmRuUQeRKZ0hQ1kjt5KOK5o6SNeg8papmkYzJoM5HUT8VhPcszBSb9PzWE/fm
-5JYSW2PWMxH8MpiawnTXyroxKnY7buNf1d8vHh8xVpuQGKjS95KMit3MpoIIO7zqiNHeij3KDUGU
-XDDj55pMwfIcmhCDEsqE1A0Wm5JZJX2nl/UrTbq9g5JYZGpu+5lLZ1Wt4/vVM5KOCpwNSmgvWzPS
-Kw2TaAXO5IFD6jB6P4tuFDtW59TWPGsHOSVVaabqwAzNrmPq+HSPLjiijo82rH+BpOsyUZomr03V
-Li00zIEHg7JpmoPi0umvn1jHN7vR17nm6/jkEczDmnfT/DkuG9XEyECxUWs9YPqnIJgbF9pNgMD0
-imSOm6RKTv3pGDOomDkOYzpbIcdjTOUwBPPAFIHfXepXkeiEqp8+TjYcJXy1S+01+UpSyeUyWy+n
-Ly209sV2aYOzRILT1jOO/hhI59zzrypvK/NgTTh7FfPOntYZERU1AaEPQglA5WgUpfcqrrRmWZhh
-yevhCskt2F1qq1MnLjdp1DkMFrgZ874xOuT5/Dpkr7HLo18lp6LetCwXOCEZl6ucD6Nwr3TsSP+h
-HflTVauKlddYye1I7bIow/COovhIo7pWXiBnKHU0K6KKtovZY+87u0FJq8Usx1ePCu8o8pBkNPa+
-8zovgafCThHcUfErzZLAEREZtC565WxHRWS0hsRlRFwGT5oRGemZXebwdFRERuElyeO/5A09C8oj
-MrVzIjJSGiNvYtfnhi0WNTU/TiFhTJbn4HXHUREZuC5a5Tk3Mdx59tRQREYru8N8GZqZHHCD85Rq
-l4jILGqHFanHR2RQdZ5uRMZiFjEhE4jRLM6R2DC1o8pzDLIk0rHWTjSWJTVWBtk0ZoxlYMvZ1OZ8
-XE1i/cRMBrWcq3X9xKCOytRcRjm9ZqZmMoGd27PQGorVVOqCUfkYaa5a0Kiuzihp1mKuru7M3HWo
-9wFijGop9RJE5NiJmKJkk6l6LpV91I7xeX3mNh9OrIdT+mJsRdyl6+HOP3/MTD2cCRq7QD0csscO
-KuIuXQ93VIbqyfVwcjuZr4g7f1byIJFWteBl6+F0s6EuVg8nnDuqVapxkXo4XsLIK+LM6S7z9XCa
-VZwXrYcz9MU0tnXy6MTiS9SLXSwnEtaLXeREC66OTSMn8ijef1ydWF4vr+LczrxnmxMIiiIz+JQd
-XhbOMRVY6nEYFs65NfYIiiQ2fm7GMyyu0w57y3PgzWU899aHbAh+091btZhnwzNyGsS4JSw/uhQb
-PiqY0Iwc02TDRxOpyYbWOMT3OadcCIV5vgucBozg6J8tY8p7ZeGcUQgpVHJBOGezIYRiHIcxZ9qz
-wLS3XdVPotCJSztVjgSGJV4NA1Na4VBrVqS+/V6gIhW/xi9XkYpfGxSRHlORil9TJzqhsorUwTWj
-f3SVqZK6y1SkPl2oIvXpIhWpTxeqSH0ycQw0ZycbnziTPzwGWpawYJxkBK1xGRuqHAMNq7Ee9BWY
-2WxbvhjuLymFU2gxMxk9J5TCmTkL+vxSOClXHiSSXKwU7hy/0nwpnE7G3QVL4VBUQVoMp5/jdWIp
-HOpFWgx3Rtpd/uAQYXlttayU1fBEeGgTH3ciPFp9nSqxyxyoxmHsQgFkVL2mcozhaTZMPqAantQM
-TipP1VAUsRnEQAyPCYbVh0Dlade9mihuVgxJmyJgrM9kDqrIvfDWOFVy5laIvS/8C16L3rf6Hj+K
-8J73LPlh9dfoohU4MHn4qcdeGw7+ZOAt6TWrr9DOwz9P8AL4G2G5HYohc59kBWCbLW7fyM9VkFUo
-UddEjFavO0tcO/SK3QJ+Kb0oKuy8CeLrXqPTsM32sJ6/ahW7vehdF/ejX2E3ue1odurAa/2RVqdj
-RS2W4j6+XEfSqaLYzfbNiEJReYla6vdmIcxUeV1cT6fCDiA4qV1hh5Vo7Faj07Dtpr0gPjQr7Hq6
-FXZbSrvTsu/zUbNTix3eB/utVU0Y0Ou04dTsdLN9SFnFThUVdmGbNfPu78pWlaH57tEnbiHc+Zfx
-wky7j/1iKc3p1WgZtv1+FJ/vDNuFvjm641QnLDl6y3JRuAPW/XQdHmlY2mvfkmQi5VZpwarsEb0W
-jI79N9TXwj1WLWdJI/B05KVfarktejlX2qU98vMgjKv81GN959wkpxwSjC7JMu0vcpOc2tKZjsIV
-zKdI6ufDwHvRPJoul0pen969b7Lkaa173066RE5zfmbufTO8UcVwfigCDy9rM8qcNlmCGlfNLJXf
-M2IS6YYp06b5JW54j4pKQrJ8O02spZN4fBeqplOLOx8fhzGqplPzA7SicKdX0x1OrXdt5nyY46rp
-1LwSy8Wr6VSkU5E7e/CC1XRqlCOcdXOxajqdqPUFq+nUaumOPCHERDWdmlN/gkY2qKZT26fR3Hs9
-uZpOrZZOcsbdharpNPdeL1pNp1szcrFqOtPnXJ1VTadWSyfZFb1QNZ2aMrJcvJpObUjy3epLVNOp
-1dKp3phzVjWd2vpJ+OVC1XRqoMQd3ktV06nV0qnWjJxVTXc6xo6ppjPE2EWq6dRq6Y7GmGE1nVot
-nXaN1anVdGqWp0pt9ZnVdGq1dAf3JpxdTae2W8L5lRespjsAoDwR9CLVdGrrrLMzcmI1nZxK2Fo6
-ff1ySjWdll952Wo6OTJI40quk6rpjM8g0jBK4aBC5ziAnBwj3rfDgHzHtXrk0U3at3gtrRb9qjWz
-hXQGhbNK6+L8++oMrYuL3FfHl9FJb6tTty5M4slpliJYrtTGk7FhYYYEgEZ+336bjlMYDElLFGhl
-2uvcLndUaaxbM7sDDsrIAjA7pNBxEkYPTw3qzaSEkYpMuUeU3Ck9IlhUZZRmLQuCafqV0ovuTq5Z
-46+5086HMWuSm7nmTnnPiBb6z7vmjq/k0r3ozmwhnWaCxBH5yWdccyev4tS46O6YKJXqNXfHRxRP
-ueZOI6Iov+ju+FolxTV3aieBH1x0d1qyR12MGpx+zhWwTA1qzczXWZDph4iJ4leDyiJ2X6xuNgVY
-d2punVyFIwrpDnIPj8+1BmuuVVZ0zISsakJWJVPFqMLQTAWsQVVaXTft8JgkMlhkyBvQupSslUSm
-rCca9J0H9USDvoQY5L7Ycfs9sDxQHq07LTu9tbhgNhQAdqlsqNbCZDaUfoHGoH/C3ZBqlY9u17lK
-BkHxGK2+STimN2a0vVcEx3eRWflNVQqbyOyCwLSTzczcwK4orHUf6r3n7gVPBQTATiv7Us3o7poU
-ZlLdpYnKsYMImloXqSOpW8hweBQzrMSL6eT1HRH6Kz+u9E13c5UpQL0Z3A1klHUjB2ZKfJi5wXA7
-Iy7A+wfnHp9c+Xi6OSGDopfVeQycC5wSgOCcclu1IrsDwdG+XOu4XFWYTYEpQgJn7fA6VU4phpV4
-eSUCT4vAH3vDnUZ9pXDH3QXqiZy/xKXurda/4c60NX7WDXfyyscLsKHqDXcn3pR3ZD2R5k1557Eh
-D4VjQoPz+U3Uh5i54c5i/pCcU2+4M3mqOax+aps40MdIjj1drrD2Sc3MkZ89aL6w9ukor1qn8vEC
-hbX4tZ/r5Ww4JqJZRjlXLJxzI5jwnCsI5/zCWgBF91y44+rb4XV5evXtakVMchtGyYb9zSEbgt+O
-jmtp3vv2qnmwzLFFTDEXrqPF1MqY9IvUNN128bw+kxk2ENjRbrsmV/Y3psLUJoqYYq7wpfxKsJKP
-2hdoH/qVGoLrWTeX0cAwPIgqwEFd8CB9J5F77vnZuKW0xlWZnHGqfzbcioJJ5aa8I2tce/rXPaqf
-A69XETbTd4u0d2wO10WZtXH60VQA1M4ut2FOrnHtmTifyvxNeSde9yjLTkc30l3qukcwJHn+lE7V
-s66NJhrsML22sVXpjzP92Du5rJ56HEdFerCwr2P19cddq6ebDcNPLa62r94PYcHnWYRTPMnVTDo4
-Prokr5xyiZVTbNxSdtFdK4hJJZ6sHm7rvFmtpYpOdg+ba3jTnqnVw1nssDhNeeecrA==
-	]]>
-	<![CDATA[
-	YOtDWfsnLU3Lhe80Og3bbpZkvC/1X+SlaR86nZatIe1Oy+VNT+hUUppmsaOqLttveP+mVZqmUw8X
-vc9I7xGUl6Z54/MHtgiPl2NyBHsyT5611uVvPb16uC9MrVOAMRbB7xWtgsOwzT4LPg61Oh3oXXOH
-xWSRK2UZ3lfNptmp9c0WftBCr0+tU3QjG5pr1aFYVciaftQ9+sSXYO7Hptrd2Ri5hNFqeX2XtJqA
-uNn3Z3aJmoRzVsnu4FkXvO1zKVSnnvt011bRdqppk7wnnmo5For9IBQ9vcAlBC3H2nJsypB2SVJG
-O6VN8JFNDUo7y11/o0txM8tr4ZzUKvmQ9ooY7MmpVQBPLauJpRPXRRNPTsO7G0xXpR2XWqVTleZV
-G9LhOb2m6CnuO2p+mlFrWOJmLmXTeEgBI34xX3Wnl6XF22PmBqWME5/ML3p5WncP6rmxCte651se
-3JmiFmU+RVz1fNqF0aZjsMVzglsKjH0UL7Vv3fNfKyTMKUVzR51Eq1mT6Ftj5x4YB+vT/EYng5la
-K3ORZYvdqArw7ENoAVpM14sZei0AmGaWlrn4mKJq9vCsuJJ+zewREmZw/ax6KM8JPnLpYoedwoI7
-XoKqZd0cd9hVSfcofDZAYzncetKJqngPEwjGZcNTF9CNbKaq26Lat/SaOiNCkumrjFaeUUh2cP7Y
-GeVHJq56RcqIk5Y6g9qla1pKzdAaV9wvJpf3x5UCytaPvjGu3zddCrg0KGlQrB+SyVrIMizUMUsM
-aM9C52bjIylL4xYdyf1ixwCTa5UzMWZUy3MUxrQTCI6epPrO5YkYYzRlxEG5sGyH96QqQLPWofKu
-tOOqAM3WAKqfqqEF4tQb9Q7uRz6qClA3niypARQk/0lVgKZ8KK37kU1XAZqtATS6I1VjhY68UU8t
-V8F8FaDZGkCDGiuDKkCzNYCaPrKpKkCzNYA6PjI3nsNZHX8p3xk3sh1xKZ/ObVkXvJTPOKpwiUv5
-JPfx/YWX8h3Ksb/iUj4+OnoqCZi7lM9ieH/TJS7lYzVy9ZiqYIMhqdnOp91feeylfFp1SXBQOrYz
-OxqDs6HEW/0Ut5hd4GwotVv9TqnkutjZUEff66d/q9/Z2bbcvX7n5SmZvddPv+ruMmdDwaq788+G
-Mr7Xz2R95Zn3+sn44SCUoUrJJ9zrJ1RgqR4MLvUszrnX7+hKrgtlK0pv9VPJVDnpXj/9qRncX2n6
-Xj/9qrsL3ACC7vXTn5DFBOuaudfPRIbqBe7107/Vz2I/KudM814/fe6VWONn3eunr+gO7LET7/VT
-pCgpbvWTnalybHxBcq+ffuqUxUzylIl7/cxkQZ9/r59X91a/Y+/jO60AV+U+vnOvslW51U/zvqQj
-7/XTTSczOJ/f/L1++hsqXFTh7Hv99D01KPkvca+fMC7VW/1U6l5PutdPf5+G5f3z7/XT95zQPvIF
-7vXTypNkb/WT7b2eXvfwoL/RJdqW593rdxTvn3yvn5TQDm/1O/0+vmNO8dC7j+/se6wY/la/M6s5
-GP5ePw0vl9vVRfcmXOBeP/3EVoixS9zrp3+eh+y2rDPu9ROIXfVWP3nF0On3+pmRY+ff66en8npr
-i/0y9/rp2/RH3Md32mE68ozuM+/1k0BR8aWPPb3h8F4/g6v4kGGvXZF63L1++sUW6MacC9zrp0Fe
-3K1+51elGdSvB/kb2S5xr5++mSOrrD/jXj8Ztg9u9TvxPr4jq3A17+M7O5olvdXv7Pv4TFXh6udc
-qdzrd1IxPBtTOv9eP/1b/bhezr7XTyxm0z3p6Mx7/fQTnfjzYM+910/fbRcxdt69frJxHdzqd0zc
-Uu9ev3P8SvP3+ukI1JgrACsgLlTzpHOr38Fp8yfe6+fVvdXPYjdhGkqWVuteP/2CWC2NfOy9fvrl
-Y7pZnccVxOrc6iePKJ5+r99pNsyx9/rp3+p3RHWtBn/2TBTECvmWZ97rp68cLHZV9XB4BHEe/Pal
-XdXNMq7WEaZi1o0bUwntvuqFdg0S7yVliyhCUlIEtfLSGNanfS5je2iyCTnErGDmUOCWoCUVaq2k
-kSuFLwpr3ypRv9WxLz7lnqzgt86aa9Jn8ptNksilHt57Lqt9GaGszhhWsnpWnXsrEes0vfF5LOdN
-JTcZ70P924kVb9ckVqKLwOPDSu/vFazs27exRiT3ijVeX0ZY07MNYJ24M4R1+ukc9vAzHGOPzuU3
-9tjAf7HHde0Ge0oPC9j73ayOve8Cz1i/6l9in562HftMfLg3m1u/c7PNvoc325WjarFv9rHd69a2
-zk0CZCO6R7VvVs/XqpUKO63Nh5ydiLgGTqZle3zppm6Wm2DJQVD9W+dnJxa97tZGfm+31HKm7hNM
-2CsUAjorzFvRH2k4fsCCeEsWOyx781s30/eg/W7abCNzX4XtJfWlVvd0Tlu9c+pedgUkvE+Scve8
-iYQ/JiILoQpgDCELoQNM2IF9Nl334lzVZuqNjyjwNpZOYaXuUwkr21atzTb6NEaVpMK9hV1vMuhH
-d1Fe8zWJxeJPcLN9W8XhrzaFyc5yicg+qeRaUjjBmhNcvLVBS/dkeDzwep9djffSHt6N+Ywu0LT6
-mk/PVpd/cA1LbGvwTxxeqdmy+oOOD4i2FLxt8w1epEnDwdklNI2sGWaXiXrZWtHsYtXYZutPTx/e
-gs++L7kq1SrwQBdvpb77tQ54uheCFscNlDDA4f60+VnPKRV628KvQU4IhypO4ZML3uA3h7EgeKlO
-BZ1sDOt+gcb2wR983Nd8IAC/BoQXg97i43MFjuaNTD+uc/npIIhjwRTlKhWJJhxy3S0Zpo/eDTLx
-hnUDH8DMLsmjhnckPPJLH3xEGOGB2N870DRfWb6/O1xECxIZWLCc9KDfAMbgr7gnj8e55uW8T2wO
-cJdP8g+qAVgc6QG4e/NCZLmBBP3ZgwdtHH0l0w9W8LWV8QgA+lwOCfi1hPDtAQzE5BDZQAEYhRQT
-BexztwFN7oLwaDkfypMEXx8QWA95Qy924OsrGWx2ZiR4t+v1pmwJG3zqBR0EFliw1/BLVv+T7+UT
-YDn84i8EBwlH7GvpfCglitSPqBc42V1+vpeGjvj4Ea/oGjQY4TKP4MHVvwREwpm6LvAjdNei93S0
-XMo4mW6hOk5aOS0G5vWM88TSJcSFJ9zzvq04mv3SoMmAEiY+AL3saG7Bhnd+iCIfQGpkCb4+BJEb
-DT49Y/iwUXXDdRm+4qyODw4/iBRdJVbg04DkP40pBIJb2lkbQfQjAwx8fQ5y785eMf7Th0htQ2CI
-NVIWOzee2ZiUPPqwkn2WKz+bv3ZuLrNFGGkaMhclo3Hmwz3Jf4dLd7l51BaVCFTEkFANshNiz7dk
-P7NRB15jY8Hdc0DodMQRy+4Dw8t4xgU+DXD+05gQ2wFB0Qbz2/1QitGAuXyHdo8ljzsVjzz6r5ul
-z6adlkp+TWnJXx9K5Hreold+XoBUu6YjTos95lgRFNC+v4+Z4M5T8NIhKgE+JWqZ4HadBg+atcJ+
-0LoDD5LpEn3THuffazZ0WW2DpywgmMFaCXKstuBWCCAdyUAUuaq5ERfxjR5/IYsHoFB0SYSiIMfA
-1wjg1BDuQodAgj9JoFVCEQ/qCsDrUAg2dJB+0ZpCGgtl/KhmHJYjvgDj53HDr1skwZo0k4fYq6o9
-PfnIvHEiWvgDH+A+53dQlKAWuyBDvUh8yoWnn5WbUE7jvq9ksFBLrDAgGUsibbzDZLR5bn69LOH+
-m+o3L1Vv3Yi3eXus3LgOEAX/qxeIvYwXrlsTsnMECJwM4Jdyyc9KRpaAyo0gFhrWoVl1i7HdV8IN
-ETZPGzLKkZ3cIqcd8iaWLKvTDsxacHjoEkS/H8z5K83Fk5M9CoKikM2r3HlHoSMXIIxIlijMH4JI
-LKjG2SRK3R2NEK6vtof4fHq/4wMBXFE9cInHBZETpTkkYFAfCdKRyN1BAR8OTsv5ND56eR2oORVH
-zUqZB4tm5QaM3S6ws/Lln+OEuxquocCvtqEG060wZliKEe52+hYIvRiN1Vp4GvzWyHFeEn/9b21x
-KOXhVsFnyIMPPz5KgJEIP5n1+GtkzjFJGCGVcEOZ/AzmQjpu35Ng1p5scDp8ThOF0d2HEsECUjmV
-yIaAP8Og57scGG0SkJytEghOe2OAgkryVYHjg0x72F8hOE01yoR7P05CEBEyWyTLXPxeg4oEbF/j
-vl+syKGtu4Q6xUvDc3vwD9zs1M1MXKAs6cnGweZ7TBw8QbgXZAH3xdp59QCOZM9t8YrVZvkUeKPS
-RgMBEKsZrO4aoGqOB26YyV6Hz4RUhNyBHeIj7WN/Ca/Yb4CB0r1OBb8nriS70WdA2FZPjSPs2CAt
-7FgZohpjZu0kkETjIjzqwkn0X34ShjP9GRCFl20KThK32JEIU8xQfX7lEaCi8kMZSLSaB1DyfdEs
-UkEvxmjVQGqdgMtZgps1LoDKnwzuc1UTakUgyjoLbf41xb39jQcsJ3YL+vsggre+UgLY+V8NLqZ0
-ouQw2TOUlhNXKUEUxhjM1L73AMyXwEp/BF4MZaR57lWVlpCoqjFAxM4SkM4dL/AsBkDM9DJpE8sN
-GDdRAUbStMkyM7Co0gBjn4l61NxyJwLgnbskPmpX4sCda8S0dlyV2IY0djq+oecYJwqv9C0cgxdI
-y0EDcEn13UhaEp9koolYF3SaofU1rYBjD1bHH7JQTlNqOy0qvTx1K2wvk4eFgT4XenECXiuViKIn
-FwbKYUdp55BIkTl5dBbAH2sVXhUVIT49fmA4xZ4LZlFJZp/oGunYfLbA/J48OntJSqr9nkSA8LzJ
-RIGWfgX2wWbe5uKkhoIQ2vyzTASvZCotIArjwMoc/hRxH7ZUDVRell8m+CANUPSVR9cAQ2OjSGab
-H/0Te4bWuDlNC8iiXsPqBectJCUMyIjnGtEfld5M9AxjsKfreDRn8NpDARjLOzw4DWWAsNq/fv7l
-1gUAcJNn1Umq9eTERzdfQMIgOvnLZTJ425rDKxGsCRUToLHWuI5X0m3lrA/mTNZvAUG+ZknH9CYN
-PKKfLJnd3N8dQ2OPoGff1yKDjuIBRvdrBhB7MX6iRQX1voYxydmRonS21V1AXC1qMFJGARX8kcDq
-wEoxgXLIlecg/dMN9J4tk4N2JOSrKpjG07vSgD6sFzvXjoTaIAYk3208eGuLRMGKp1vwdrl9rv5X
-0thnFO6MfK/sSXy4xoFbNByUSAfx8HE5EZYTpCUfLUGzBlw0yMNx30EzD4NGG7Bb8XbuHLOZrUsy
-VPm7vR8M+Q5iJ+gHOiCQhjEApeI9UIjFehVZoyjj7jtBuCvrlDks+7zA5l2UoT8YJQoBa5PMTm/D
-+owEdeUxRKXllZGOYrgEzKFcA/EVXglY2aNDhLy+v0h6OQBJvebJ7C1dh3NxrQIAhe+tC7pFitUV
-vCRb2oN7Z3cV1o5udn5Jor/w5425qUo6Pu+LYDTxCHRmabWZyrNteaHBon+Sfy4SRQ==
-	]]>
-	<![CDATA[
-	stI8e5KCpaRtt6bd0JHKINoAvp8rA/g4Bmyv+GJklnuhfjlRGfetWYBUrAoNEB/AdjUDTaiAGk3L
-7xV1xyMAWYE4Xs7feYGeoqGVuQuT2e/10ISgBDO1hw9i2tq2JdAbwIn5xeqwcDFKuF+dBWBAV+7N
-EjHa4AHDTMMa+y7aRw7dlfDyOmZg8hCfty9tzkzvZaImDWgHQCWMwQZvUw9pM47IpO/Mkzna3YZn
-AeJgamQBauk7E/Njz7d0wLAbDUw6D8BO+qcEXKnNnRm/Kxd9bxJFa7gI6NdBwnFHgDtDhkzHLmDP
-r4BfEqN08LZcSgFfc0Fc1rpQJaB3bwq885GFQh8n3P4PIMpfc2Z4FkYUTxJNwpz90KtOAaaJuqAG
-LOCjjLOu6FntVI2ThSL3tffugg5SDdo1AXxUvclCH/lp9Ghi1kCiJfKQcWNk1mMNmOqv9enhLdiC
-f5w1yS8NLiL1AGSSWYdz8vFThnHLp3foSOdcADGZHFFIL4LGoeQ4ogjI3WX9ULK0vhL3fUPZNyYr
-MALmArZ1G5LuR0r9EAq0EXSQ7MvvJQ2JlTSlos/k4fnJyeAP2spDyRAYcx0KihhDv9mp28I9NrYv
-C6DxxitdOrSPk0h3JACqb76AHMA3sJQe+h6YjtXebTbE9kF2dDJMDCC2NkkSg+OFqEmwyO7aJ+5E
-APeHAPY2i10KouKoiDkmECfsGcBoz8Kb8t0S8FIhP/hU8cJPAeG3oPAbBj514OaYa8Nu2mGuwItE
-8juEWX977AnrJ3cI72cSoDrUXAonV7/hg2uqDB7gARnZuxbchCg3PNeZtrKJDYn4om1Bu1dWlDHB
-pinIT3HmFhSdr4vWJeeuC0kclffA9c8Dyt8AnQb8KAsGjcbtSr/OpdWC7M1KCGNk5G7GpU0Qexxl
-TPCJFndNLHjHXPOjkZx67ZGg4HVDDnkUxHARBRa7O/8y/uCREJCdx/1J/QpI+JAigfi6F1DwIkUB
-GI0UBehUJoACSMmaSBgkbkUkkK9zPCoigU2YknTKZY68q6GAPW9cgYSASP3P1lWwyCJhk+u9mqOD
-zJ4n7L0VoYDLVLFS21eHgIRnHTpgi9RYLL4pSEkTgKwanSuwUadGU7TIXhB0MAYwF91RyECgy02O
-nIbMR+bSQc+ZxrdyNcS1kHCl3jRab+tzaBqd29PXYAuzqGwxW81pIACIkj03EhDp/O9KBmJlNR6D
-rnTaXKNqDgSitxBBYJVmbyRt2XsT6LcnWXj58fEEWyl7Lo11lmfTGLM7EQQPYG49m8Yel2fTWG91
-nuhtDTf6BMJKyxe9aXyficrWbC/S2Gkgen0T7PqMrAtNEENV2XfEGBgWlSzGTlqN3rcBx4tj4PTL
-4ShmZ65Gb7kXUcli7OhpbLR5Q20MYC4Ho9hfn0fYLzabsUYmtm8iCKvz8bsjBTEcnqAD5Bp5yPwa
-YcJgDN+q/AmlpVlMDGfbc6XlcLkzXFBdPTT83WuOwaS0HO6t0q8j27Xsq8PGugpsCuwu7YWJTiFZ
-jZXMV1lbPc7rkfU6n72WXJEjpjKpJEXLUqGbLs4rGfz6pDnwQrXHWngeNQ0b5lyJGXfszcWp8pML
-Zb2JWaLHZHX29w68EnBWUJEPcD0XFKpIkKcywc1bax6OJg78/V07Nw98eSz2bGs0aRTqVWtHdPCF
-G0fyYghKUmMlQCQdj4usAmL2Lt99LxXm16Nsu/vmLA79mSdpzQh68QCBoYCTt7JxmBTemyNPTkhO
-DamkcMM8wVaeC2kBx5yLkKDUyNj4Jd3jUt4Gv0/sO5j7JorhVWccHU8D8e0wvVnDDvN55rewSYl8
-thtKln2MKnshPlcwP+V5e/DAU8/CPG03xgypMD7yL0pcxnbviT+Shz87fYMiDDQ+/Pgh2O0RmBgK
-Iy09gdBYzLMgpM4e60GLSYfPEIuUtL7HloAZd9PeHSKMiLi0Bxhr+xNsaiu3LfdLYrXZQxo4ZDMc
-5YMQ7tFzmI+VdNbw7PS+NzXb7WGEB+Oy1MibeLFGOqzpOjyaNk9mH8dxrJ7/SZOOpxcUvsLhdmIe
-H663JBeNlmxr9Hcw7PQCd/UrhDuC1WCAMQozCwpE0T1IwDjMrhTFJk1rGWUMwNBYTtyagAeYLLic
-3hDllk1jGAB8V0MU4RIqWNaSeA0bw6F8bVbyHz7SLLEgy0urJ0fhcrly0JgrXwB0ztdYmUjOlVbH
-/CLMo8xoDnbvLqCfuCxIflnqMpAcAfa4ZYDPagZgpw9jbwtlPFLCmmylEz9gyFyUGMiCNYn51xeY
-V/3Cvi2vneLnQgSEfNMHOXXfhe+ZmxQnN1/IijiryO0gnUTvqu3vF9toYw6rPQ9xsNJ3caxWzmeE
-rKmcOn9CxpX3Es+1H5sohmP5/9r78r44cl3RT9DfARIaaGiacu3FDs1OB0ISJpBM2AlDCFlYzr3n
-n/fZnySXbbmqGnqpnjn3/u4972UodZUsy7YsyZJczfyUbB49YeLwco2t1Olgvp6GcGO+Y3p4PQfC
-8+vkvLMjJhsU4qrWS0aWHMn45Pm6LQ/HaXzT2OBD53X+w2CqXXso1vaWxWbVibQEOZQxvRhadRtO
-LnyvvU4zMR/Hj3AtJt7yhLdNHlNYs1NNWIvX69DT80DUm3tNMVUN98nFj3G3M9rF/6c6fwg33bXh
-zS26k+utEBut1oq7+m4CFrYXogA4WMagGBBrt4cLZlwojltlF2zW7G5MYewd8W4EY61Z+piUMO8y
-CWuZpVvsYybH6MLD49LXA2dleTMMl9Y/LPqH8Nfp7tr9p8OnSZ1rllaiyCw+g+dh+MvYqgl1l8lu
-FMBO+5Tyb47byUkzGaFgRQ/ylKzVG9x/Jgkj90y+uM6LVjmd73e9zsEm72rTts/4LJ2qp3U++SN3
-0DXzeY7OXhcE7KXX8yznCxdswUretRvdp/FFLaxh/4Aeys1JMwOhFTkHZ2BdU0JB8ZZ4hUlF0+Pp
-SUVGuNw8bSKChPs4rLWN2U9ydVvFB958mQdtrjG1kzaQngCuZPn0bWxzwYRXcBXje931Ru9vdjEh
-oq6rNR7eYi2cHw/umns9B3vgH2Jy4SkYRb1uDgs9g9rlTr/yRlfPfL6HTzhNPClexukTgjw4nveW
-b75gMttt4FWfHpbFxZZD5/tuPXBPNi/rTDbAbEvc2rupNXw9FBvHh6tu7fPUBkqdGKTJ4bK3vLs/
-A4JirqVkJKj7OuED4zPGjLglaRlNpAJ3wR/XWmEH8qDdQRCZD4+vh2unVxfDtd2jmrSRn9nA8ytV
-XchJaYu4zk1iBe6AICjGNzNSQFVveBG3LQVwWYBcoUPige77C8GnkE/n7++ra/Wkdrw06/wxYmkm
-43eyPsy7bKaMyqPRGL/4BRj310//OGquTsa19fW1N3/EXBJZDNSSH6SNkclY/6aezhhcTZnjNpbL
-cptM0GSQh5aMkLevjgyjzW2MtNO6dZJ9WOBjsnsDoq35oKRlKQZEW/NBRkM9b0BMdmhAjE/fBPNz
-3mhtz8mYD1ZfnjMgQrBAPq9iiLNnGRCXoPPf3t5jclKoqwF/TqM3wGhwvo4fb6bahbe8NrUB6sYO
-CI2JqU1g+t26uNjcm6FgJRbCgueCymwQMxSQjAbJFoZZyzBjUZ/ZWgL5s7arhvMSa3eoE/UPzuX4
-uyPKEcTs2zF7DCbUGGCmGs+SekH+8PssihLfZz/tYCxMdXN1kiW+96SK0F7JlJFJKwdfi5QOcKem
-dcxPOEfdyTSPz60tLs3q6bUSPL4dudr48un8WyqGDm9fo4PmTF5pXD+5+DQ8+vAQDY9+X2g9n1XJ
-8yv5YTpLS/3oYKrCKOWFwtxZ35zsMu1Whm+NOureap4mO6cMMo4x/HS3+X31a/Xhw9Lc4qFvpE7Z
-VtLMg/KAYfQOkyFvj5gBaK1tpHVzDMvj32duy3o2fETOiELVaL9YhCnZlpGWq2gRzUxmDG6YQH9O
-yWzQQn2FjBhcTah2ZNW4L3cn2xhvqec3yXtSHDG9l5J7JZd5d1tvQf74S9DdlYgl5T5rSFWyphRJ
-Dudr884zphTdXwR82khd89yQGo3hvc/bon4yEWVkDcaIzIl661vTRHVeNrWs+VMJu1/LmMiyj6Fq
-kS3qtjFiCQzcbz+8rKgrMKQqnZhS/RlSiw1Y+7OLTv1i5kvr97u+xZUtrOqWtCxPXNnCKnVjolu0
-Un3WMfoaNqEzxP1mUtTF4bqssVTbmku4YHoxgbxYH8tERlsJ5Lkk8A5SwKU+VrfkPYoFy2coZwx3
-0+Yukgd1vzrTVmfCVpTWVKQz4deTfQshrG/5ohjqWwjpekrPiSEza+XF5i8LIZAHrQVMnxJp/FgH
-YigjhNzVKRA4mN6ZEULQq0efDtbQ9x8Ymw1j4VD4gJK/6J58b8VZz+vJ1sQbYMyx+4zndW1qCZ1I
-WxnPK6XHuacfP77B/JcZEQ/E82p+UBx7wfN6c/s4PD5y9KtHw03fypQ33WSVqHYOnK4MN7kqC023
-8GB+prl8MDr7Q5lX73+ROhh8P78cXf20fvRhMvGXR8RKsniSMb4yppeOtrVLci4EH4S2q8+w/mFd
-ysOCg6IOjolY/n6vB0UdHBOZONjOD4r0gMmDog6OiWBc9EERahcTJdp5VisDs/OMlSf3l74OiqZv
-FvbWvNHZz27bYyLk2LMHRSB6ZjDXJbDtvCNzUJQ7Jjr/tYWeqXkjrKSmhAdFB/PiIhoWzx4UbYMl
-t/M2J65uP4OJ93F/C93ZfpGwqlRLFFdthZVdgWolGB4eX/x+NpDT6vn7/zut7uu02mZgL6fVExkh
-1N1pdb1HIfQ/4LS6Y2cTZdkUu5tKdDahbtnG3VSiswmzONu4m0p0Nj13LtbO2TTzZW/7d1fOpkq1
-Q/utL2cTakrd2m/dW2/ouerWfuveeuNrv1P7Lc/Al6w3+8YcY78dR/Md+LyLrbfjqNFN9lPvTqSM
-9UanPOU7kTIupLSO4otOpPl5t3a5O9epEyljvVHG0NI87Xy2/bYOokckbZxIB6tiqjoVFDiRFmR5
-FluCSD8/cyK5p97iLuzYR64lwhysXjvTxCJkcQdOpIwLSer85TqRFs5+kHWzcrobfIC/rg4rVUpt
-MqPVQSiMsbHSk9LDz/d8gxY7U5kgG30DSFdhNqbmJ8w7NKkaz5+QGfvFNtPqKzX35C4MUBdKMKBK
-YIniJl3koeme0UaaZ0uG6YxkYCfvnXt2Ng7G23t2iiQDaX1KNsDXtmfn2ylub4sw0dZi0OZO3/JN
-uzMDiTQTyqx/RjfxqpfDG8722/kJGXozebtetxbf/gTmty+rKqH1sTTWJGeL2cfzi2L7IS1UeXib
-1kGVxPMYhEXM727i4fwbfriJfgFL3q1PyhumtNVWn76pry/CWq1iSYnWqrd88yEm4o08AJIfA0yy
-HHNPa4czeGLu05E8Fw+1IAB76G7N+frHFDL6y1vUlDa21rHKx4J7Ory5Kc6vjzHv9w==
-	]]>
-	<![CDATA[
-	TYK5zmvS0Fr8Y3fHPV1b29YlQRa85dMPG+7qu+StNzLTmMdk1CXYHM+2kYY5d3Xqm2M0k0rV6Cbp
-GGw0p+RpvByDMk7j6UzcPo//eDJR9mk8nSbkzuPLPo2vVLtw6swdP+/UaevSgVVZnlOnrTWFHsVe
-nTqdW1OVajt7akxqmd04dbQ1hVVCg/Euqmp0LbOKJBZKmNKcOm2tqUq1Q3uqNn3zen0ZY3u87q0p
-tF8ebuPpm4WDNXTRxO3sqYimrmVNXS+I+snITt4tc7gIzF9ZKzx5//Olrx/3ZmGnSbbRSHO78kBT
-dm1ZTh3m0hmfOqvh+fbR8NT0GOgwWFZ8rWzBBXK6uWPEVmHEXSeCqysbKr2ZpdMzsEzgjk1y+7Ad
-XXG6KHDn/Op3ryfhMmFHsUX2ZQtm3sctjCOchm4047LjCLPnyKXGEWpFRZ6+PaeqHGD9gtvD9Q5U
-lSJJJDanfi1jDdXm9Q6zrMYWJzaoYB4VyYGlGYygs3gGHwN18cSfD1TzU2xGwyBkbz6SXxZrdC81
-3dWlYdc93T19R+kEWGsKo6C3j7ZmZf+lL6UWJ6hnbIJ0hlEYHR5bAhF9ueVsPzx6gPHDmjj/9W2T
-TBxRbx3M/oNr33bnynEpyaHb1p1rVWnu16Hb1p0rYxRLcuh2ImH6d+i2VUC0hOkp/ajTOGbu7VGR
-zI2f3dTV6kQSsVOejmOau5dE0gv3XEzzbfyrI6NpfH0eLYtmkSRifXlGFtWPz9bERXVkIyOJ0HiO
-YZBjb3LhojaS8aQYb6w6E2e+lNYxGE3DlFvUNhynrTPYWcVCjBviYv9g1nhSdBXNnjIbOvWkVKpt
-fCkPj3Nz9YWLcvwn5m7BXDxbz2lKKOX4nSkfGnbs6PTrh7nJg9l7LYZ+pkm0vw5G8cqWD8Mjq/HI
-8Oj6QYhlZR5fDOlLL09lfUnclc8Tx/LmB1D3XXVvRAmO30r/gTsdOH7BEu8kcKc1Oduz47c1Wf+/
-6MH/ix78m6IHZ1//VX3f6fnTf1T0IAt1rlRfCna+iHc6DXZuG+pMsT1lBTu3DXXm5/sdBTurxIqi
-YOe2oc6ZDLtp0Xuq2LTgI9lBfcseU0LbJoRWqiWmhFoJoViJSyWN6RumipLGPoxHYqo6tpNeqtN9
-0tjbn9Mo72Rc3yuHJ419r712a1O+Az+M+5aJh6E3c2NLmP6Z5GTWweW6Wxs5myoK2yHf+DNfY+Lp
-kru6NbHez2E5nfF1mZvR/WF5rlpj1+Kqk8NyO+u5z2Dntn5gecZXUrBzW1HX9rasUnUmab12fCSG
-zoOoe52JTqsbY/j1+OB0JulVKCnYua3OBGu/3XF5iYflOlswf1xe4mE53mbS5ri8xMNyWpXlm3gZ
-nYlirlKtaXAZF9bdtQPLuEBNqfeYnU6FkNbHeorZ6VQI8ejBkjIuNlqvkowQgtHv1HSDryd6FELM
-o9hDzE6nQohuZ+glZqerjAtc+yrnYnAZF9laN4PJuKBaN2nOxeAyLrqudbN79Lv7jAvLNz6wjAuj
-j3WZLN9VqnzFTm3vPFm+q1R5vfa7SJa3GdhJqryKTudnbqnDrwf/Ubvo5TZ3C5Zy3m5O220JU+p5
-O0uhYPcjt0miKKPWFlqvz1XbKqfWlrbF2lTbKqfWFnkUyztv/zwxIi/snlr23uDl3PPwl/um/Nod
-6M8IS4ke7Fb+pFZS2cU62uWLlVasI8MxcgiZypPPuIQsVbPmdO8QqlSVSwi+zrmEVnaBlfMruKRm
-na+tX1h7ZnFD38nasUOoUu3AJdS3Q4jmWJFLqDY+2VHQz+Ik2i/Q3c319ikUz2dyPXrTN/WlBaRR
-2EIIUIw/PuDta7NoOUWTC0/TI+7JpyUfwxhnbCfRZ7wDYvN6ztmZHd5DgRTCfnC26Y2urYDV5nlN
-bGUdI4hmQMyMrJpxUYkVtRCXQuiNnt6AWJuY28arZVt4Y1UAtsHnBRjOy03pG49Q2drAqAV3IFU8
-LCupra8IL9BeT0ZefVi+2Fs/ffFETspFtAiaj/Zpda/5Wy+FJmu7svvQ5OwBe0py2+P1NMPu2QP2
-6e4Xu1rqWKmfZdjJAJ+P++sY4ONgwO5cp8fqHRyqS3u/r2P1lwJ8qHZH8bF6d9lPxxtoerv2wv0C
-a6T66I2+uZ6lG9hPPFnin8cYx3MkrlBXWLOibn7ugga3/yb17x5/W+TBxbvyNm68WG1rVtUI+wvz
-95dPFzfdtYnNt6SM6CtkylyaefulvJwn4z9J9/2B5DxZsT0Dy3ky/hMtYQaQ82TtlQPLeTL+E3OO
-jB6U40bPR9/wbb2t/yQ9ex1IzpPxn1CO1YBynoz/pFIdXM6TceJWqoPLeTJOXIwcHlTOk3HiWvt+
-f0ff/mhy+v71t8Xdub3fMyt+fDd3f/7mcnbRqZ2DBuuMeCWF8FjlPP9kxRWs/Mqu4wgHHz3YTWDO
-31lRZ7x710rOsbLxfbhtMDPtL8+GM9MtJflgQtCsx3ZQ847ExgEYO8v3X9611XrUKU8vBVI/0IWN
-WBx4YxKk0xEYNq3jJjpn60ZEwQ6fYL2+jYNLR/pXJm+XZsUFaIYvO1nGOjxueo95RxijuL2xNd2F
-pDI9OI9h8kVzoCI2HLBAfJiGYfOL0pQuT+mKArc20nBJU3of0a0EeBLuAquv/DTvYWrdx4NxWGNH
-Uxva5vmEFs8yCKY7dKfUyZW8SBwBmRRuY7XqbXExEmFJ1ctF2KC3mip6UCWTBzB/52dVgdRwHUST
-v4jRWQGsnLMFUZ/Zm4c9cMMVG78u6WLstUKPzO7GehOv5lwhtYq0i/0J56s4XuvK8OlAtwp3m79G
-V07ffFmrVFcXJ8+PFg4+vP8xPHF9vz8Aifb2jmt9fUk0UJzqbSVapdpvgYuMmmMlyikxonTLjgVJ
-emFGd1kR0n4Zo69z9ZVXh1cpqF9sLo0t92M0Zc+S+o9FLjKa6ITX1FfGa6gKa6dnqiuPh6A/fNsG
-VeRVo4NAGRkRYald5z+B+PHPzVygzNGPJ/d09dsc2lUupXKioTUPi9l9TbloVmHlcAuD8pqoZ7ho
-Je3ub7LSystzYwtgNK3tIZ5ZOsLgRdfF2aK3/HFtHQs5z4j6r7tNXVg5Sb0r918SzBB9Ywors2zB
-bGnlEgsrZ29m+T08tZ3sY2LUeYkFb+TaRyNg6aEMKVDsMKlUX3Kh9uAwsQnusc4V0C22eq5zBdL0
-qM7R1uJ5Updwxuz0mLxNDtSCrIEBJEJKOWZ6UO/MJzo3MX0TRDPuydM70cHBjIzrs6XSD4FnO0tY
-BiZT3QpQuHEVnaAhrMo/vUwylFt7N7zqrUyfvsEVjXcuzLUoGQrv4d29+ECUoToRe8unu2t2MtSs
-O36Na3oi9PEk+B13y9x/2QD94d0SpnEvYhr3XJEaUKkOrrqVWVeV6uCqWxXk8gygupXZ/CvVwVW3
-Mu4bHmlfdnUrbr+UV91qHAzzme0i0QMcezEfewIn31T31a2KTkbKr25lhBBo4wOrbmVqW1WqvZ0P
-d1dKXepjg6luZWpbkQ4zoOpWvXh655NaMBw5I85598YHjyEpNj+soPceM6KkhySbE9VbRlTQNiOK
-JEwuJ6rsjCgV01uy46Uom6OnwLqpka2lTt3CRsIoxzB8LcqO7rXl2KCie3P3WPUaWHfe2lt1vv4x
-7Bc5W0xfnnEMe9XLsW2xWfXitoF16G6ZssNaQDC9nm9SdRyUMFxmoQQ6xuHeEJmoFDqTynxtu4XX
-0AWz4q7uN6OMvKOI7kEmcJJbOBfPf3+/0LykqjDrycj8F/jr/buq44QT6x8WHvfpnwHIMVkbK+Om
-7tYZg32hGzoHepGddVvWwC60KTgTH8CFNui7EK9muk+bsu/RUwdmsMUWhTxJ3zgZIqPth/tyVPwo
-Nk17qAx2flzNRCB/wluiltyJYXn+G7irU9frYAytzHR1fkatDFJQ5vL3M4LSG0lunQ4EJUi5CRSU
-I0FbrzT1pb2gFO7J5jcMBg4TW1CumRph6Fiao9MuLApWtY/T0HPcXEa70ttJUn9zsDSP23vi7KxO
-rHsro6A5YvEBGJdkA97b3LfkZriO9/ZtuLVP72Zgpl6CvTvybS0tonw+v+iNzs35gDnZpUqtrTVM
-szuffPb2rpddTHu2xxDPO75M0FkDeeDbRVVxNyYN8ihsVgdTivNlVM/u1L8wCWw73nRPZy/9HmOu
-fviYuLhECXdt/QswD35nM/HAGHgAG2puLcIIqXW67/VwGcO/YhjzsTVQ/A/XSVt3T4fHcMzX3tpj
-vilLPKH70V1dPGuKjdbZqlZumqD4fwCrZWKRoq+2yMqV+lg/Y96JW1Gd8VluxdIvfDY28iAvfDaa
-0iBLaHecZdOXk6FS7bSSf/dOBlPyDaOhuiz6NpEp+taBk6Fthl2pTgZWE3KAFz6rWgSDvfAZT3hL
-C0JvG4IOu1h5QehtPZ2V57wOLxV+6vhYA8al38JPHQghVdm4I19nbTveT+KN9eX95mcSFDCx5zfB
-Fpk/X12cfP9hdXH88pP7dHsauc0P58xXSRWnCwXJaEaQgBLxfjgdnPNDRxXP/Y/Sxu2KoD0Fdrw9
-+vn8eSz1pV1gB3xdTpUoGZ3e6823nZ7MUl86vPm20ypRojUHRvgOK60rK4J2XrGu/utuFTQgMDTa
-V4m6/et3JvaMTnkm5ymYPSOzQJd3tp3tvT+d9j7RNt+6IM/fgR3QpIiPiVXUx5jEG5DOlJ6MmMNY
-W2d6KEdnkmd89We2/DJ0JrleehZXxz9vR1/WekYrWb2nH3HVVlip+8VKEVdto9DISupUXP3xo/vw
-kcm03jh+XXZRu4ywohj48ovavVgJXHpfXhZXMC1m3dW7zS4rgVviSjTBwG9drufEVTjjYcSZN5kt
-ttL+nqM9mSn8rvmsO7TwoiUVlj+3DWbfQ8E1S1xY0bgMKHLECKtKFYuAL2B23x6ec3zG7L6fmOe3
-Ozw1PbrzQpafPEYqusfeEkwZu7KEjJqi8BDQLroMEHEnug+Ez+Ukis3Fd8u9BsLDt67l1/p27mxv
-TMao8x8fL2BIow/21FbifD2ZCMsOhM/FKpQYCE+FWtpV0O3YNsLMONiFUstCR4BhoBd65mZQBsbk
-r8Gs5zfXgfTYYDl/rJbrGaMJ7LP9jemb+swC6RmiPnMIatDNxRsY1dXYrY3ghQPvwi1iuXuyeTmX
-sjyNBdvyluemFmhcrpdkOGi9udd0a3fJmqzkP359veFsH7UaGPiKsT2Pobf8168evHXP3THU4cLm
-tf13j2pF69jy83edr9tpbX87Sq3b6v6d5smgdjHQ9N3ytYu2plA32oU6Depe9OB5ZSY2bQDl+v+Z
-KLUeAkR6jFLrMkCkg/AQsl/6CxDpIDwEdZgysnSfDw+pVClAJHKq3sRK7fvHDbAdgu2yg9XtCrob
-b+8GEqxe+m2MhcHqlWp/zhE1as/Lg0w92FQi4HoZteVBQMIV9rO5re5jVf/pm1ipQw==
-	]]>
-	<![CDATA[
-	4y+fJO7jKln1Vka/JL2eJLqYirPjLZ/uZ0Iu1ihYFPSD6hPeNpSAKIiiycWZ/XG6RSaXv48FuOfd
-k88jK1L12xCf1yl4Fc+DWnipEBgVs3cLot76tcJDV92a665OfV5xts/XKfNmQ4eu+s7Xg28L7ulE
-SCkyAerJm5f1gWTtWxFEg0gNVr6LNDGYfBflpwZnEoOxPswAUoMzicEqX6zk1OBMBFilOpDUYJ4Y
-/GtmvtKJGCpODf41k70OsW0EmLnnvdTU4Iw9JP1jpacGZ8SRtivLTQ3OJAbTTazlpwZnEoMz8WNl
-pQZ3c5b0wnWI61crp7vT75Y3QTlbj5/Oh9tKonRcpJghvV1FZfd1qdkgqzVmDQ1NcHrzVy+KxcXo
-607dmGxHVqcu8LXt18O7gdaaWDpEuLWp49nunZdpDu+AnZe6Lly+eEifpUN+4O3t40toIATKN57a
-Dsd/gsJQJwdGAkTFAd3+Y5cOmdWamV065OM63sWOtZHOA7e2+WvB+CUp/+VTi4qHgP7wmRUPgdGY
-2xEbrYNl1BCwbNBWrUf9oF2Fwy7SW4Pv59/GV5/O/ny/8f198m729e3JPKzUm/3lTW/6etKKtyyh
-IOtUESG8HmxXeLrXPeguTqZ9RB3k/HdvcqRRN2VfWZiJXlFyrKMbg9xS6pDUD8RcqmwUCC6JEcyr
-54Z7A9Sq0aNVKS1Vvl8qLcNu6yTVG3yQqSSat7Or7wMFy3/m27K3fL+/l0ZBy3Epr0p+UfBe+1rQ
-3VTJj+6fT/1N7xqgKvnuyZ3TcfJvvkr+vYPXv+6goJy2Un//ekBPb20Pz5lXw8nF2cknS5GpoxE3
-voiSMUhDMs8P17C9ZbHRvF4GRSbZobMbDMnEzMCpbX52421ifdklvGNIlgAQl0ugr6y9RVfzLJ6e
-L6Q+XzCP8TDnDSg/D34J0jIzlphCUp++8f8cf85Q5hNNZpQghcaJ0C63upuSwCuHR40OAnKx+tzU
-ry3QW9faG9LPB+TCXN1bgQXyuZHJXEBNIaBaePKO1DnHvgJT1P9y1nGs1ql2LxaFWMREeyyDN+2h
-OrymZgSezdWbC3hJ5+mkCon6E7bGtTVxseS8oTJ4lGUTzbhr3hd4cy4BdXhhaZYuDKaShmJz5Nfm
-P6rBvrtZ/7Bwu9uBCy3VYDuv+NDTJVRWTRV7i8IpOTPZx8meOdeTlVq7usa7h00md8Ynt4fe7sXN
-LFKYaLukg9WpYhvWz9PiscQ94OotTnFvJaIsG9oF9jLrbnT65m1rzdmZEdNyD7iZP//44h4gI0uz
-e4CdZSP3gGqI5XLepleEd7oH3M4soL8KFJm3N7B83kzsgb61PEHXi8uTxD/otlGUArOwPVw/aimw
-hfdXLqBxiXP69zzW6KFA6h3UmGOvenEHP03fzGHy/TvVXRIA385UIMU8rpfF2uyMmLydX8bF7sGQ
-fWgBs7YWQa7Mg9A//bSVXneeW/uGqQ259qGVWtlrv/ML6P7BtV9OuiW7gK6gztUA0i3/zjpX/Tvb
-TA3gIlebXC/tnW349Vjf6ZboUxrUPQZGZVFnr6U42yxXG7+ArtKbs63LC+ioXt9LV9D1fQEdVWgv
-y9nWVlgxOdZOXC1dLE0/TqzCP8760teDscXl+t3o1+d9/8bfBnp3q1Wplu1xK7J8la+vX48bkdz2
-IE9XB3re43b+132PgYP0rRXdIWsZnYw1vZWk9o6Ond1Tz1sVm0tre//DKlAtzrx97NP39juavtnY
-WxcXi1u+8bxR9ODxp8mFp/prLC81S0oEPLqUDOZnj/Ez/Fy9m1jxlm++LqROuY29NXlt7Y54WBUb
-JyO7KutZndhhAanLHW95znMxLQyW7uv1NTQzZ8RFeLeizMzREG/obpLm0qmZSTO51Jpz8ebs7uXM
-l7d/zC3thDeXL3nhmL9cO1T6vGfkb6nTm/WdW8T34jmXmcBqg7bu4X35NAxzYRvWkfyorOuMhQrb
-H8n/x1ZuaZve2T73gHywVjjvRnN9ETT4i/eZcF4sUy9gS6zOyQTOtdpZYCVNTWynvm9xOK8rwPno
-BsK7a08/fv1IJSR14ex0u90+Olyikwrcm1dV+bfRAGOlNsBWmYlFfeZbehr/7BaLcmxQt7ya+8pS
-bbw8B7l93Va6nWbuFS3hxrJSd+SuCqtgjtWgNH3DQKNb9qTpww7YSb3tNrE98HX7itvdF1bJtDKg
-egHpzV8l3lhWdF9Zpi8l3FhWdF8ZRt2Ue2NZ0X1lpPOXemNZO52/tGTNrrKfek7WHFT2k52s+b8p
-+6mU+OSNo199ZD/B1/9bs596T9bsOvupp2TNtqmalWqJyZr/CdlPD/eY7tQcrrvr7zEP6gved9bC
-xz28V36j74vO9O3Y+uIuUAKTsos46RtAer9qsYNMiZfr9JaRNq4juttwrKciTjWlxqq7j1ic0sun
-+rV65oADLzp7A1b+8RtRT2DhXp03ExAUv3ZoKZjznIIMiNJO9Y2iUunjVL/WYbrEyhhl2fhLuGA7
-Keubk5GPr3y8AADraDeZ4wXTJQ7lRWegIkW0v5xHFPSEMVCxvOqMQqKqT1u5dIqvM9dLoP2DRJPV
-5z4my2Lj+FcLjTnXHb/+tiEuGl6MAodq+zdJ4JBlIVWsz1QyWFyMPGyqSMilWSoLhWZ2EwvYbVAA
-Ae40c2aQO/Cnyn2/XGNvaXiOytet1G6Wb7rww3SYsPWSH2ZwodDU50rbHLPergE5fyhSQCie/2U/
-KnydiVt0a40JrN6/MA0dWk/+19SIeHEJm/uSMOfp7dlGvl7N3We69AxDzBaglZmf5mSWsW37KFpK
-nSi16QizJrfStTY8tm4iIeWx7LG8/gxW5bSYvH23RrkQWEYNa2gdbuKRSajvnvuH7khtd0ezyXzs
-OcmygzuaC2p2DSDJ8n/qHalFJRy6vgEEzPrujRh9Awh8PTgj5h+Ngu6ihMOCs/142XreiKG+tKs4
-I5oLWHxhLevzvfj0OWlXwqHwlmWcybd7cyByxtZRYQifKeFQXGELPd7jYN2888K2RkylOuDLP0xE
-hMz1nkWDZXd48ilZ6rxmQ2e1tXnl/HJuXC6SJZVqoTRhazpPcvd2gKzR3cctqPBtNp7r44dNeSHn
-14O7RVo5/5Niev3fbWJ6u6k4jfSA2vx7OOMY3cYgXY8KqaJqL6xyDJptrct5jIVLkxHmQHk/nHW2
-z/eWcLXFOhlBlWFY8xZRk3Dck0/f1pQmMTvjnmyNraEdgHXvVlrmNp5/pqbKC8UX+i69UEJERAda
-QaU6YIcCaQV29OCg6tCVbFm8/Vl4wWCHlgV83Y9WYNVPHpiNYXT+Li5W7ti1Ob4+D/v6WdP2WndV
-h+74bE1cVEc2nnFtXtRk5hRKS+3cbFc+AWTR8TrASGtoG33VtnqDQ9Xn3l5uyMCPgUVfqZPEjo6G
-h5+Wph8Xd5ork1d3zx8MZ3wF/7Nirp5f0R3GXMFk6TnmCr7Nxlz1n+VYtI5lvOVgIq3MOsZx6d1b
-wGvb1pfWczf43f5+pOMBeTd6nLvCawSr0Nx82qeCBYB2qZla/rune1gHfctbmZ7CPeduKXOBF768
-jmk8iUmORDlG6ZGnFzuwxK838cA0MemR5ZyUtst8LPektFIdcFlb0n6xOlBpZW2d048P097S/vh4
-xjsoowcHWNaWlAmtJw+qrG1WWvakTpz/fupA9GTjLXXA5++nEp0M2VZKd1mSEKIIokGWtVWnb4Mt
-a0tnnZj7NtCytuRkwFYGWtaWnb49V1Du48lE+aeifZ9PFNk0uPYtqyY8mJ9pLh+Mzv5QouL9L5V0
-DrYqnqtMJv7kvRh9mDvtyCqRfksuSD4IPThnOittpO/M61wMSffXExZvDta9Acixjm4OmOj+ZlSd
-FFf/v+pzr+dqGO+9jHmoXq/V52J5k8iaex23qz4XZTJlQcxcL4j6ychOvrYtShhg/8rac9ZPu68f
-92bBDkq20Sxyn783YAB3pMppuPznstx21/5coBvYU6VlXA/Ellg7npmjIEFneu/qR0oUzCwqioXs
-n5LL9cvDXxSjKFOf00z209eYLzUqKwLRjU6UX+nXCADNLv2kgEd6TJdAsCRjHdXO93rMG5mbO5UB
-/F+Pl67lpkbx+kpufHEux8dnUjIXZqAvqW8OfuI9WFiqmx9M/CP8sN5gPxwPeyfUHp68m/YEY8vG
-ym/iWLA7waEH4+fq9d06/+Hav9Q/NMghJDZHluS+j7freviDIN5hlVt83JeYK1WJ4vx6Eksl7Ms0
-LXExEs2ke0T9DZX4X4H1OS/wlWlSVTBfA43n/RQtGNmE1sPV9JoWHC1cXbNrykd58WHK0N3b4XXV
-/oeJYGxlc32uRIxubb81r/GtBI9vR64q1Y0vn+Lr5fdPIzdrny7fOvYmc+p+eTpeSgf+6NhTToYP
-Puv46mJ0oQbsYxovu7rfRHf2x2l9+hZ8BNznXzBp+aNIPb3BR1KxfuJfnv7LlyjWZu9IG08xnlzQ
-wH+aVt9+cvRfgo++e+oe3yh6PnmM0NPV25F0Vd5+C1RfujxT1CeJz6j7DdMolQBFmKM2gi9C/+Xy
-995c+8ZU0OdiLxkLK8poIifL6zHFE9gmZFoqLE65cs5ebdfk1pG+QjXuYO40sBvjZCPj79NG/0sL
-cwRinCw1+Gf+FymBUiadvXrvS20clOrfSggvTVFmMljD/idYcH/cm3tFo/Qw/evBzOeUCv2P/OF4
-6c8se0n+1sf+wvm0U2OCop484oa4M2mt/XprEpfmjpw2WBlsenV77qeTEVyY//J95furH+t4M+hf
-WuDUiP2SsxutVw0sfTjpTG8sTeI8eCMrt0SpON5YJ/lbS8XxRmvaCc53cFXuOql8ClsGt2v00v+3
-UImiJBiK4jgYmn739P3qfu/+5vrmx1C9MluZXt4S4uDH5c/1+6urD1f//bj68+Lp7urH49DM0PTy
-++bWVhysXl38vLwaqstTlIglwlg2jNdO25VCYPVrsnG7+frd/NnqV+doIetIGPv14TdmTYMNiqGM
-1eH6yeVnGc84vvlQx8cj1NeHmcadS/MiXWri9erV/crT2uSb1seM/CIlOTn9sAG2ztrHlat3S9MP
-13PTm8ufdkBr/uM9Znf+VJpPmjzClcz23g1pW4wO1+Z2/eGp6bE/MABzFfoyshpPD9drS0sI3R6e
-3H+1KyvTww+LGKp5OVx/c7g5PPH79T1PMqHDCZVkImBezqaycf3kRA3z258kWdT5ef36eoEWm1wE
-07evpDMWJuDdI1pr03IJge46nv717WoideTCFEL37WRqDNPjzDjO782p1JuC6yxFAcvqUa3CLcfM
-dTCGHxO1e0c1tt+zHizMT7Ifzkaa8+qH5hTXEcCqP1hUP21N8xU1e72sftgT+odjUrxgdcxPGBhv
-eaMpNQ15sn3M297YaqCEmkgrPeBS+/Lw7Ql+eCfoEZSnYXh8u2Rwn8AXPizOt+ukEg==
-	]]>
-	<![CDATA[
-	TRgBiXIplis4BuG1B0P7dm8aRVsdEzJH4PGA0E7IwZl++9kDdfIW950Pk0wVuBxtwGZw1JrSjZ5m
-KmtVqh3V1pL6nv7HqjIAFP5oTj5bq6uobsEzGFVmi+VfWxq7+rC6dTk/nK6mo0Ohd3nX2ldr309e
-p9Pr6MzXXT/j0+t8jyRiPfWrnB9Mp9P+/NCh41b467NIt6bzY3ch2XJhrM7P8OQh/fvSJxTp0N6+
-I4xTdEENPB5Oq3oLnx3117GZbedcVb299NgPqKpCX6huw+mb31WlCnR5TfaLuVyHDbZeLtLJ8njs
-pJ6TxzOh/rp0zXvpHtJFJliFCVx5gWxBueaX4sDlSU40NjP60/VB+v7+gzLqJ5PAn4O/5rYrVRDH
-vxbhpzfbq09nb/fgp/nF9WTk3WXzy/brzYXfI3ctdjlD10oIqSBSqxqgEpLW8h+wEkIwWd9rgEoI
-qSDQSr9KyMszZz+t69nGUfZmNBU9alLRVj45/37t0rms/li9v5+/GOUKAc22uZ2P9Bm9jGlOPrWS
-njAS9PXv8OmNQnFazaJ4On/7G6u3PEktZfSTu80ciwQbnj9Cff3dI+ZhHMDLX+cy90UcveUogp/r
-WRTe1meD4j2hYNXPiLNSyq2fjMk6H2D2j8t7PBxUS2op9Oz3RAq7fTWJXolAz+5Li/OwvVOfn05n
-BC0fZMZfE0sfJ85gsCfX4YfGFKkYsv79X7Xxxc/fDe+kJYjET87N3mE65+ET9LT2BXW0V/KH2e8H
-u0joK/zhSPbKLqxDI3A4/HN6jaJaXq3d368cwVIJ3vygRsfPR979CevO3wB6RMNS+Bo/FceehqVi
-SKz0Hz6PIp+GsdFD/OG1ocbyCmO0lWLCkseYUJ0bPlVM8KeJCZqaW8MCzNmspyxYfXivWfCnPN1S
-THj6vKeZcGgzoZ5hQhEL6MgpZcHZ4p5hAUWBzTykTIBmDRPSIWnDBO4YF9sP6dxfqe1oFmx+abz6
-dkAsqFTNTCiaB6jaO+kkjvZuUya4T4Kz4GLvTbt5MEaSNr3rcnLOvd4vnkrPokBHWQdzEXWYdijw
-3uh+aDCTAfrSI4qVw6OpTpcUxmflUaCUn+5jNOS+Z+Y0+dHTWd3hnB7no8GXRXs+0HrhKAwz23dj
-ceb2h0IxkUVg+GBokBzrWD6Zie1srr4/V904+mG/J32m8r31Dyv7hmNHXzKDY97scYIYmdv7HENH
-dac0tJljfa74cc6HHucY330s0dsWQW6O8RXfdppyFNlu8OWqWFkwx57jRFejYRCwnIxaR5x4hoYa
-X/EWDfYu9iyKNiu+k+GUdmXNjEZvk6rGN+M8K9X+8jwKNqDddoMQUPR3OqA9dqNIcGVogL48S0UH
-63N4bPXP/RSB+3BsI5DGjt6Re+HEhJmVz9Ogd+Q8FZmdqHsazKzsVVpOdDIr9T5Eaz+7E008Py87
-oEEeUOtHnGN4E4IGeCMzzR19Pjmdegbmj/zu/YjGi1ipDs6PaLyI6FEclB/R/ICn9IPyIxovYqU6
-OD+i8SLiehmUH9F4/SrVwfkRDT6q9DAgP6LxIlaqg/MjGi9ielv7QPyIxotYGaAf0XgH6aRuQH5E
-ciexfV86dVKezB9JaQLzcpmUxAnluXv/K33l7DcKkiN0sflIzTievZ886oB0mFmPC79RHJH8qdHt
-06N3XCAd/WykcQ1Lw1/S8IVmo05y2v3yNLc1fXP42JABSzf1mUlyWlG2j6RB/yN/kHeSZBhMSVmp
-MzEjvWiOZQTXq61fJLMoyANViFvpqKsfR1c6zMHBvkR/bDZPb5cvodlfK0rgzNSMqw4D/ITk4sbB
-OJ4lXe/JqAdyIm1c+4001oG8dSNLylm4seeQdKpUuVDcOHDVQdjD/1uozFaqeFx4svbjkh8VVqpV
-gLy/enz6hS8EJytX1zc/Wmf/vrqvOEOC/ufQ/+L0v85QgP+0zivj9NpQUhtq/ahUT6aX7x9Xby4e
-b37+OLv/99AMgMTQ9MrPn9+Hxpe33q9/HFr7718/7x+H5Gcffg4137+v4dHkyfThm9bB1urQzJDE
-eQI4Z/Er4ZwAVvhJvvccvj9uHm7Ov19ZeKHTJ9CN5YoYOvwv+AP+EUPLv+CvvYrTCJModKMh+CMK
-XPmHFwdRAH9EXhIECfwhvMgNECJcEYQEcQM/GTo8I/ZIhhz+Gx624Y9vAPqvIeEMvRn6/MUZusQm
-31X8ADCH4dCU74UNz0viobvKlAuKiOczWMvAXFeB9KcFIPbl10prRQ4fDCaxY2oqN5xyKCXNYsgb
-ihL8f9Q7M6QrG6WOJqIrbSBh6OQYOvQHDqEHQ0fj5MZRmPj4RxQ6Xgh/OPB/nsBBDRxgEv43jl2f
-htuBP7saQjeKGoEX4UDAP3cVITxsKZHPLfYsBD6b97PP8v0eBqxg/d38/PV0Xup4pRgHM2RP8D9H
-Lr93FVpsUYwDEwSBcOgPNxRRRIMYiBjHzvPTwfP8xHHxv0EYh97Q4XLx2LkFY5cg150EJkTg49A5
-MWCD9gAYNDyYP0PCCxqxoNF0RAOEwZDwg0YgkgDGL0wa8Ec8dFF5T/Tv9Uv6GXAF5JAfIXIPlnCc
-IFl+1PCEQy3Cug5cGH0/bojIwUkVAWLhJgBKGn6YuAhyG7HjRUAXEusmXiKJTXz4+TsA4RNYCvJj
-3w1jArqN0E/ozbgBXRDUUzcSCAEmuEE0ZFN2AXP1oJIMjdeGDj9afxHrLythCqieZBgNUwYffN+X
-rIYmkdUplwm53VQTPtkF5owv//j5YwgUEsIrZ827fuX1csVFrgtsC5jiuR5J0bsKsMwJke9ulDRA
-nCZDwH+BSKZcL2pEKE3+xce+v10Dx54EuieQgAApiOCD2EWY3/AjaA9p8oUkIPGFPxQJ4GqCcxaG
-1QkjH8YFyHQdn1DFDZhjEQxwKBqBQ1uIjxPODRAGXfaFJ98TwvWGYKQdD0inBgMPyLEoaj/khWJm
-nOZUHLi1oen3j/c3P65B7q8sX4CC8e7n4xm+au3GmVlTMCTVk9CXpMCgBHI+WRT+QTOlBGr0ZPOd
-QUy2MO1FQjMcFwUMZEzbgg9DHcO7MPhhACM8JeIAKHfLn2wgVzwX5UoC3ItcFDYwdfwgQDJiEAMR
-TBhgOIi0lAwBswpmDc0VAICg8eMQZ1yEwhGlRwyvB7BUvldADNHqEbHX8D34EEAgDkOcrIjLT0C4
-gLAJgljI9hIHRjtP1d896/JjA9NOUwVylqjK0/mvsude4nps7slRD0PaQ0A4O67LlRn1B02J2CdY
-4uH/4XgncSP2gFgP5Ebswpq/Q5Ab41rXsCQyL3kRfw7lC82KBgnYHFyQLC0GwqUJQ28QA4Re0q0r
-QLMiQMDYMNCVYLeF/dNlQNqALewMEhhkQYbSFofJ3jDsqsOGCAVp5jmFOtnEUwlLzvQ4JfyOwQzh
-hoA8yHA9j61VWYeZs8p/8VQ7BoHHhi3yHA5LQsNqWAUuA2hOaxAjLjQMS1w/HjKYYVuRE0t3KVZs
-Zj2P+ZCBtsKBwstiZ5DQIMtS2uKwtDsMvepynlfNAv7RDDgoUmzIZqyeOMB2eMgNJkqOguFkQEMv
-/74YyhH8YEJCEDEU84sGPAgcZ2gaI38xAhikCj2d3V1t/bi8+m94BrULhNDP+38rgDs0jR8u/3i8
-Oft+c/aA4gnDiLP9NaKXKex70hppwIh70s4Cyr2IZJRUb4WUQvAKqKWgguJaEK7sFDBCBJ5HhpOb
-ig0FE0KkL6GyBZsSB9AbMFgKBNpAEHguWVwG5DhAnEYc+fId3boCAB4/tkGAByS9lBf6O4BYmNmz
-xpPYJLYskOyGRqx7qlpXgGaeQ6WJId3TlOg7A2JE6+bzIMbqLC4tg/QPnm5Ef+7xkZKSQsGEcPQw
-+H4cMYBhsQJx0hzNLDBU4iGDOUnUZFIdSjSLdbcTPlZSROjvgizqwMlNwsDJcSbIdkRj1n3N8qiZ
-Z1unkic7gGRj5YeQAQ2p7PNCIP+ciR0RdCt2+pY6nbcFtmRvjT3Zoq0PjSsQylAR2p4DmBC+x2DS
-ZZe+5YISzCHpX82KhokkNX9aNoywauwi8VLsQr/jKVxxDtaqgCJPbRsYQDLYLYjC5WZpbXFY2iON
-Xfc6zvGmWcCvsiQe67GvRoJRoCkPnoMxzufxKbHHfnHZmGdgNHZB6DIQGhV6UPAnBtDc1jBGH4OB
-xAODSqF2hZuZAxrS5L132bjh9wYUexnUDKBnpoZx/niZzijUurt5PjULeNeh8MsPJUq/osFkUEYu
-w1AMtTD8YJ6BsFup5PUsAgutSuaefXuwcuKdFPtnyaYsS3MzfHWTvFhTMCPEAJIRa26cE2tsGlow
-W6wZoVkgPvIihYk1I3jcLHYLkhNrilYu1lSPDHbV6zjHm2YBv0oXa5pyLtYM5cGzMCYACmAZscZW
-WKGw1LLHyYg1HABLrDFuG5ihj8ESW6x5TnYOeEYY5WBMrCmQkWIpagbQM5OJOsMfL9MZIzEV6hxP
-moUbTZdiTZFlizXDLEvYuQZaNKBFeLNirVt7MhyYVHsPUk10LdX6UNrYXAj0mvK0dAuyUgQgShYo
-SIFy5BQoRwCT8sfTSluSmaAa0qwkSRYGJobjaK0tBQrHyeK3QSk6BnR9ji/TLdOE7nuSZDnULOBa
-WTLOtOZoycMoyKschTDD/zw+JeMYh/VyYyPB94FUdYszix5HgcSCyDOcLbq8GolcI0GUonbdMCeq
-wtxM0DA5clISKZhwssg5RE9RBjT8MEDVI41fdzrPrWYBBzuUdPkBRUlXNKQcagjmGIqhHEM/Cpzr
-dCrqik8BpmDjiJwoCXs5muhMCfQ7EZc9mdQd9z1Dd9fxDD6FnuD/jxIe1LD78/Hm681FyqYSYxts
-xAMPcehrh+o8MMXVBnsoGo7v4LJCYLrdKKDr6uUegpKVuHEGRG81KwyIp8q+42P0CgNGjTiO3SHW
-BIDoPUaKAgG+IM4CAV+QqD1NfxwkuSYYKDb4kizRrQxQds40oVlgSFGgZhH/ytrVeNdT+u84kNHP
-iCgCspHI41RbG/8p1M0xJCEfTrm7KRiYhIz7ngdd4yDDfQPkhDqMhTDTh0wDoaumn+mhq3nPeOHy
-sZS7kP42zOEPc2QAtjBHcMsCqo7pBnTv85xrFrGzw42uYIhxpyscZAtsyLaQtAFzJGa3E3HYrcdW
-BP/4QZHrenjUAt2CXiUYJSWnro+xTBqGEP1W4MUhg8Cg0jtyRUsYMA5ectO1lMLwGFvKKokcpwW+
-ZEhQEClsbJicn0HgRexLHAkLuQHEGpWGKUpbDKb7o5HrPmsSFKRZwK3yRFaSofyOwRjlmoIiGON7
-Dp+RVvqXULdkMIRm5EQjTiIDQoDmthuLiEMMuzWME6hgKOkTR+6AhBwA6QzzzCuK22YEBB854YTs
-wzCHO8xSgJMgS2mLw1R/FHLd5RyvmgX861g6ZYdTCqf8gHKooZdjKIZyDFwwBVG3ug==
-	]]>
-	<![CDATA[
-	aFSmYCopqMv1lS6EY58kpG9pmHCh86GPsZalBnGxFryQWgQkwiUNymvAXgCzBIMpQMZKIkIvhJkE
-cyOhqSRc0LMCF4O4bGIFhjR9ByDscS6Foak3Eeg3AkFbpcbou41IUPypbtcirdsoLkDiiyDxeovi
-KhoMDkWKWs/Ea3XVOpvJ3VqUoteDyq6tKqEsKtuo2lwp1ZRCdIM0oHDVxJ4jKH7aiRw/xIh+WCqB
-E5Dt5CaeNJ38yKH144kI/u7OdALAlOsHsJASgWvKSUAniGIGdDH4Gp9gFfjqyZe/NSvyGWUkaF0o
-yuUzaBYhbgkGHWof+IpsUT01cdWx5xatwgBEBP8EI6QNTvnkGQQRo6ilnhW9Bp3uELWonpoZHpSm
-Rsh+pWTepc+MTNlq5pkx0vpeqwwSKjRW+ZUw7AcBmFDctgK6FOYPTwmsc/VkuEfPjAwnHfsIBOcQ
-Qwd8lNyTdIeae7JfIWM/7Ny+9Ylv4fRjewb5cabjFr0Gne6QxYNmhiedqgDWcJDEzAyIghjK1Fd5
-CP/KskOcLoVkyWZIH94XgbshWQdMPGCiBCmLGoYQ8xotOQ7So8yAhn0cmK5u04Ja/YwQIzUwIJuC
-jbjowPBrDFZj32JAtn5NNsBAnkGngWYoOVB1Tbeg+28IMRKlgHelxbSxjmvZwokw5DMiioBsGPI4
-dXQb+0kLHY5E8LH0fJ+/SfH9+j1azhxkuG+AnFKf8ZAkB2tCiRbeSS2SODtCPpoU8cU+jn02drIJ
-BjJz1wA503zGGdk504RmQZ5/zSKmdhr9lh9oin8rGmoLzEVW4XAX4u7breKWY71YEi1xXId8KZ7n
-xz56V2BFIdcp18uPpETzHRRpCBNJ6FCiI54NOz7mZHgRbGthTPa2EJieETIggsx7Pmo0HBTJt5oV
-BgxCaJuSGjkQ5pSAzYw1ASB6j5GiQLQRZoG0GzbAwhD8Yz/JNcFAocGXZIluWUDVOdOEZoEhRYGa
-RfwrT1mKs/TfcSCjnxFRBGQjkcdptCjzk6+bY0h8M5wwvfzAY0AEGfaL0BMWyLDfADmlDuNhEgGr
-WBNRomag6WSi2c/YkfDhFIFvfRzkmwhypKD3JEd0ywKqzpkmNAvy/GsWMbVjXSw30FIhKxhqC2zo
-tpC0AXMkllRzu5Vq8T/uLEbR7nlCr9nITbWzCHNyDZC2TP2eL5LEAkXyLamepUDiXqi39BSIgsaT
-H6dNkDgKpX5m3iKQ3OIyQKlnxDGlOeqPYy/XBAOFBp+XJbplAVXnTBOaBYYUBWoW8a9MDS1D/x0H
-MvoZEUVANhJ5nFxDUz/5ujmGxOfD6bphyICoZBn2i9AVFsiw3wA5pT7jYRKJaIg1QeKIZqDpZKLZ
-z9iR8OH0vSDgH8f5JuIcKVJDK2BavnOmCc2CPP+aRUztQkPLkKc0tBwDLbCh20LSBsyR9OVfdnv1
-yvUSWAEj0Ftj5XmuA0wJp4MFlBQRHbIxWNIIHNzyfJhsEU6TxKe30LGcvpNCMBcmhK3FQGROjS88
-YWC4RkBmM9wc4ipMBhZAO56jDCAFFI3IcWUWVoqfJg6iU0QoAGzEhlYFbFVYlxSQ9Vs1wEGxxpfj
-WavyYHYwXFOxH9DxFExWz6UCE3GQBeJpwGcU2G4shtR/yRMpYvTBxzYGjG8CDd7LYqAvXMdtUGUJ
-+ws/Cyz7BAJUtcDH4wWrWUp2w0EJ8fQqRCeb3xCxoOMrULdjdJuib16aGXheGXt4CuF4sOVFNsHs
-zRDsBhyy7xWOEFgXC1D5WbPonUikJpkhr4vKFYXjSE6wLFJ5msAUqLBniSB6VaXKLVIQ+iRqceLi
-n24AdrEXuGXPH4ncp3RorD9Bp9wuJU3CtMWaJ3GAg4ztw0CD+MAKJYgaQAEMA9W80CTGWLPkO8ih
-pOH6OBP0SwCkMJHEt5C5YGhEntVkSlA388QwK31ABNk5kR4PlTpMrueolunPQQ2TRE7DhNU2MsME
-SyA7TFhCJDdMmsR0mCjUODtMQGF2mDBYPTNMmqAuhokxK314Zpi6SG3s1UPdRRO95g51cFDosINC
-Z0iHXmYKgK2fXV6VelYoEZZ6WihMETD444nXdMt5+HN/yP+h4wVgcWdHhT6ey/i+R4XbHPlni/4U
-uCXgz/qP9MevNDGto8jMLGVIqycMrXwQcq/RqNn7OSNedHNWLPRZsYPDLyhY0poC+09XT1cPpU4C
-hbLUon7p6P8jRcXcxATixaqADJZrctwoltVwInROOrDVuVSaC4wp4TnAcDDwpJKDIA8stdJLi0W+
-RJ5GRIgobESgNiIQA+thQxAx+rpCek9gCz4Zg3SuPqVVbdhv4b2IYESr3F7hxSSi2migKMdRGBAQ
-A1Io5jMAsQ4dHMJmE8/BCl/o3wgxGd6irBuJXsRulO2urDLkOLCFgdqMxMcSe7YtJvzL355Bo28k
-oUvaAbAxivFwwgt9VB9xg0PFNwzjIQ+oj/2EMtWSRohqbcnlnlDrpnJarodjjbUmUe1WBc3CRpAI
-b8iLYNTBJhqiQmEujo0XeQ03kTqNC2Pp4LxEeiMYZvmeH8LW/L2CenichhpguTwnIGDQSGAoZM8i
-HyY4fiyXA7brOzD5c9R1MQcKeQxgjZJiY+N8G/+yNn673FJp4x/hwqJCENA2rjoNSo1f5EYiBEVT
-IasAG9lDDhX4i8G+ANPIFgUlzAaVkK2IAt7EsvAXUOXGyC0sMRd6kgYnBCWHhjLyhBRjiU+2FNIa
-YXgirTeSPzDoUQBmWiJfRMlFMPjTx9lGhnDsytmWhLLIGdYvhL9swrqPGgsix8MCgb1EjRUMFgMm
-TkqcG8tfs6Q+F07WBVnPzMf+9jCaj35aVA9mBUwfQbtTAraSEwoGpCMP108nYOgkPu0MPgwTSlrY
-sYLYHcD2xML+PVkWKALuJ14sYSAuMFhBAEWhjPoPA5GQ+9ONXTdN88Dgd9yhwNgjVxHSGzgUzohA
-N6B9K0xk6TkAwsYbpWUyYZ9GIDYL/fflxyAvcHvOUteNiCpgO21enOdY6NOj9ebrnSrTpF0JMxF+
-t5GzvVoq5QpFkS4pjzKX0ab0XCxpSrUu0Z8WggGLoLQmaRJguU1R+pboauUhTtSeiBGtUZJW5wDM
-sM7B3vVdkoQJSMJIgHD0PCmWKdvRjT1cDIgOJrQv3wMDFmNlsXhlFCdp9qRIYRhZgUFS2LMEQ3s8
-sHmDiOJ2oVk/cdP+W9R1M+HyLAagxoglTWlLzLVh74kD8lkkqJhR4SddRMLAkghYOwT6L6iGpEw6
-mIYKWDwXxwF1DixX6znCK31XNPlsPgp5n7ZGFwQfeninqPgv6m1IXOD5rqSEQvE8ESIIt0GsxOpE
-Hs0I0fBCKpYJClEAL9PowyTyQko0gp7FPsFQygj5Xox+Zc91USOLZasgOKOhAur+3v2xaNw4NFEb
-oyFUpEkMhbSXvGH24Lnxeq1KpcKRezmmBp3XlVYXbGAApCBCL6DlZ2AIUa9hMITvZUD0lix+mQI9
-WDIJnRpaMNC7ZSVN2QDWLk7cIUZGCgFckZuBtQgWRW7Avoy8HHYLpJB5WWpbGaDslWlA993QoUDN
-Ir6VdjzN+i3Jv+MwRj6joQhoRiCHUZ9Ns19C1RbDELIxFAKPHhQMS0Ga0QljNNcZSPPdwDiNPmOe
-n+Ahr2kAtQs550z3XM13xgiXj6Pn+tbHUb6JKEdKs8KAjF35rpkWVP9znGsWcLPTM+n88JLvvmiA
-LbCm2cJRDOUo+jqRFr2Xjur+/KnX0+8uzrx7rRlTftpW6OnjExCQWBbfpRBnH5Mq0igp1I1oxy5Z
-/3R9aSBj9DS1L1w3TM1jSmeOsMR5IglADxyegpCjA4tO+57jUtpWQ4Sp4R67IZX4B1s6kOol7rqC
-crYE7lJuammDtjJEca6hai8MMInL0NOFrmlYiKFlyEBH7vAc39+hV0apAZXWZ0XVDRhJWrpIT8Vw
-kNEdQXLGAX2s9CHVao4eVxggGlbUC13KeZcRiCSywKTFaNiGn6bsRaBE4qjikAgvfQc9raAk0uE/
-vQcaoZCH4KCIxuSuxSxRD52dofSyUntenGDgaoamv1drzI0KzhKdaUiZznkSnyum/ncph6LXyByT
-q9ZzXDaehgLLYmBGjGYpuqspZ0yBAIAvgNUIckk/0E/NinwGHL4T4/lm+oy1+WGuaFzwB70gG1NP
-zQpIDfbcqoBF6lC6mAKhZWzwpU+B/tzl1LTMM5KqcamOyMbUUzPT89IqSQlO4136bGhMW808Gw7a
-3+uqURLqKazpVx7ju0eZYgoE/5WM81D2pE+acfKZEeGlrADx5Q1pZFGSTgFJc6I4l/YpYXwPKUtM
-gRILX+LZkybxMl22aNXIVFfsvjczvOi09pM1DFThLjMQCmLoUl/lIfwro24FotuEM1FyhfTec1bd
-JFRHG+gLjGiWIdAXjsuAaIOb91wsfc1BnnyrWWFAdVTSsoDpmR9rAkD0HiNFgZrW8ZZQ+NA5FqCn
-ywARlGmCg1yDz8sS3bKAaedYE4oFjBQFahbxryyJUnyyx4jQ9HMiioBmJApwKlHDf3JUcxyJw4cT
-+pEwoJv47L0EbxLiIM1+BuSU+oyHEfrZWRNRoGag6WSg2M/ZEZjhBL0a/XkGiKBMExzkGXw5olsW
-MO0ca0KxoIB/zSKmdii4CgZa+sIKhtoCG7oLDy5bxbgzEs1JupVobvk5Z73KNAzfDunWJmHORAEG
-m1LMgBifnr7mNWKYbTaE3oERVDCRRBLW4rAQjya9IYMeQSn60LykkMVZGCCLI11mU30aR1n8BhIZ
-ZFGG2pYNk33S6E3H4yx/mgU8K02MmT5HejQMBYb04BkYZ34On5Zg5peAj7sNk8MHmmLAgJhwoDnu
-4umAARiGK5hFoW/4hraTQY7nbvZM0JAm50DABy+KHOvTOM6gNwAzRRXM4lKc6ZBGbjqd41ezgIed
-yqvc8NGBUMFAMygjmGEohloYeJHNrquODa6e8OG7tbcn4d9ZUBgvMpLscc3qotv2SNYpoIwxoNfC
-VC5wiBp8DXNcPZEMTKSyyKCn2xQJfWxeyq0WBZMrD4SRxz/VMlfjNxA3J4U1tS0bpuV3il53XFPh
-mnWc41lpss702QS+GAoM6YaCAhhjfg6flnXmF4ePuw2Tw5eKIwXEe540x0k0GIBhuIZxCkPDNxJG
-BrkOWTE9i/MzQcHk4KWyTn8aZNEHWRr4PsW5lO2QQa47neNXs4CHHetm2eEjWVcw0BxqCOYYiqEc
-Qz8Fhf/z6wkHPUjLnp1eZqZ4bH1qzVABjWTxRFYz9EReJokgL5OEn9UMmeJZoH/ldDKuGTLVLcri
-NxC2iUcZals2LKsZ6o7HWf40C3hWumaoSeeaISM9eA7G9ac8LKMZMuWkWN80ypuXFRx0ZWTCAUFe
-knAKfcO3jGboedmZ4Hn5meBZan0q0PSnWhFU6A3ATFGjLTIuxZkOMbXTy84DUUCX4Q==
-	]]>
-	<![CDATA[
-	V2fSMjekd5ZeZ1hmaXsBgxYMbBHerLT0uj017L0QVAea4X5nV020LyHZf3BmoK6exZuvw0jgjbyR
-l9YWwEBEukEuxjSBQKUJYPEGLM0IqCkcKQFxlg2MKiE000vjF2X0DkXZC48kS5oXECWwdKhGJJXL
-EejQiDEX18VllSYKuFGCUWwC9s8gkrcdJw3PpWw1gedk1FHfb8RhQpGZeKGB69O5UAjLiCIegLaI
-wj99TPbEyJYsbV2cXRaxvHpCcZcU25BeMk13/MpeeBjx4hW02v6W8n4rF8aSPCEjrpDFlLSsYWkU
-RoTsS/8W8lKGSHJOyNsPIhlMFmJ5doMF63jRdRPsb5Qn7BHFUloxUMMoXlZhkw+h/jhhVLT0IxFo
-MCnyPd6/ptXb8vYyRt9dRcUTp23knwzPPPtRbVhymqbo+FOrElJ1QMFgoeSUE7ryT82n0Go4lB3H
-zEiDI/TN6Ki/09EJfcPgtB6ghvmOQSb/1nOCHk2P5KOkzuBRpFs9bdod73iDYc3T1R5Wr+WzoSf9
-IAfgX/TjX/B6PdXt0L/Qy4VF/QgGDHPPCgYFo6QMxwgG+JsJBjN/olT+2YJBLUJ7eXr2+ixYzgnD
-5iX2vE0YFS39mBEMinyP969p9bZUwRDqlSxb1PTln9iasx+ZYDBz3Z63bFG7RjAAp5RgMHwKrYZD
-2XFbMMSuGZ3YtUYnZpJXLWgFo+WeIpN/6zkh5YTukRIhtmBQpFs9bWYlaueCQTWvBIPpdSoofPPs
-FQL4F30JhsHKBffv9DvS2EVmv1MVhzWMVl4UpCsvfeCLNBDWIsV7GeV6VpgCh02oQE8iqZjqIQlU
-pWENo4BThU4+6BVOj5FWOtQjEWkwqT5QU1FoTd8oZFOwBPkgu6NFrGwysJZI5tEwzvpWSYgg1XpT
-hHL3TZg0laWFNcxLeU2rMLa4RY8RU9Fk/3FlGzxRxIZJPaTDpB6R02p9K1jAsAWxNT+C2O4mo9Dg
-UfRb/W3a3e9QTlhMRzmRYXsKMBSln+QA/JN+3Hai4wqe/5jfrgdbtpzDXQd2KDT2gdsOSh54dmMK
-ZIRnzwnUr5R+h+f8HIST2jwHWNGAP7tS9jCcmCZmWgzc1DVunqWLHVd8+jZdxWKjYyAvPWYxFLXs
-55RogxN75fE+NzM8KC/eJGRk3vFnSabT9lky0rOfVViJgYp0vMyzZD/eBEGPnuObH6WA4SBinnlO
-qfANL9JMKY0SBRXjlbBHLxIp82X6J76MYi2DzIDk9DHPaa/jHMkaJXbJ6n8zw49OFRmL9TJp2B4M
-CxLISh3ZAcri6Vef8Qd8kNrRVYPlixWKE2QiAPUXIyPiKCdWZOSQeY6ELVZgKmXFComqzKL27EWd
-FQFRDh0DCVuspGFQUY5ogxN75fE+NzM8GIBYiYQtViSZTtvndIHazzmxQisiL5yUDMC8Ti4zcmJF
-Ms88p1SY5zgrVuKEj16c2KMXJ5ZYwZeNjNDIGCiyxUra6zhHskYZJkN2/5s5Yd2tWEnDy7KDY0Ei
-kRUieUgulKx7seL2HhzbkVjp/hr7PuwkNzbjTGUv41jLFUy3MUvUlUvUAmHEpHkOcFHy50gKAoYT
-c2xMi0Fkz+wgSleGUlciLsYUOg6KbclGdZytZyMMlVzx+NqK6fIxiwelyRXWLymxfYtM3mrmmRhp
-f6/lCoOG6XiZZ8n+VF0JgdVmg5V+EwsUU9/DDBXm2ZOiwKDEkpWMaj8jl/yU+alc8S0h5CkhFVrT
-h+sAcUZpC5UoVCihS3b/mxl+dFpa3GI9yZXM4FiQQAbUZwcoi6dfo6rjopf/mE3VkQenp4KfA0+4
-9PorKdq3/oZxF25MEc0hnjWmyTJOFLoMhkfy6Vt44U3s2xB6h5KbUliAtdRITbdgIvH8IYMd7Dx6
-y9CgIJS0koFR2oyInYjBMPfFxm5BFC43S2vLhlGPDHbVa0ODgjQL+FViIlSG8jsGM5QzCgpghvN5
-fCw5Sv0iVEsMg2BjF1AlPA3DYnR6VELfCTlE89vAGIUe4xvqAkMGexSls8z0LFL8ZhyI2NhFnsu/
-THLYkxwNlEeV51KuRwa76nWeX80CHnaeWJUhLE2uyrGMQw3BHEMxlGPo63qv/q/D6cIm7rWx0u7b
-idy0qlosgH8uKZ0RVlDwDcjFsmjyJRC5CWWCMwi9A7qLhgUxDJBL+guHgW2TDGnkoD/SS4YCBUE1
-Is7AUBVJGn6CdfsUDCE2cguicSUZUls2jDpksKtOGxoUpFnArfLU0zhD+R2DGcoZBQUww/g8PqOy
-6l9C1RLDEPKhi30s+KNgVBxSjUoIUohDNL8NjFPoGL75PmaYa+x4X4KcZLpnruI344Crxw5v5wkc
-9qUnstgZRE9PA2NcEtkeGeyq13l+NQt42LEJnR1SytIqGFQONQRzDMVQjoGJQTfuVjKVfH9OP2G4
-eC0gFpxi+ece3YiNgl/BqBqXfEtmdluANKfYwEy2LoOlCeQGuUowNySYrHS8fcGGYRRnQoon+zJI
-stgNJDC4kgytLRtGHdLIdZ81CSZfPc+t8tIV4gzhdwzGCDcUFMAY43P4TLqC/kXnsjMMHh86z0et
-WsGoOJpiNyWKM4hht4ZxCh3DN0pIN9hVwjrrmc5yZxxI+NCBHcK/DHPYwywNgCvM0triMNUjjV33
-OsevZgEPO07Nyg6prNWXH1QO5dnvRQNbhLdvGdX/vThd31vtqlL09r3V+09X9/8uuxL5/b/bnpuW
-dYF1WaWLOq5Hjtl6IsEo3QhvxAip2JyG4XF/ElJp1HIv9TAtYKXgJKZWQ7xVPQ1mogKyIoElJkva
-YJ1XD2vaY/lLj+o+Rmndw4sMwSJyEnUpTEB1ttSb3+mGHMenmkkGY9yg+5NZs1nq/t7b6YvGhEMV
-VYO7ob7/mGQsmiupxfuwqVo91szDkq1Yx1IDEaTeixoxRm7bIE96Ug0Qy1FF8ojLBlLshmkCy+TS
-e4YUDcKbJoMssEVAqkBugK4Is03YII0vzBLdygCpc6YJzQJDigY1i/hX2sWhrOsp/XcVToSmnxNR
-AGQjUYBTXxzKfvJUcxyJx4fTSZyYAWk962GimDAO0uw3QIvSiPHQx2wZ04QLFmY6A00nE8V+zo6E
-D6ebJPxjV+Sa4KDI4MsR3bKAaedME5oFBfxrFjG1U+9+fqBJuhQNNQczujmSNmALSV/uH7/jJMgy
-/D+91sEov/CgEfdY0IZvypj5NZCbthI2l6lF3BjxgibhpHcq0e4ZJmlKI928RLuswMLcWOEYf7zI
-0Kqu3MKd28d79/SbCPTV9eQKo9QD3JC1a1PWzb1bGSZyCKLq+2ont9eo4BJqwMndDy8ZhoHyMRsr
-rYfv473UCiaFYPqW4+H96gYSyXeU/PRlGb44Dl0tPlMYEDdkkEe+fMmQoCAomvwMrEWwCNUHDZOi
-giG3ABpVkKG0xWFpfwxy1WdDgoI0C7hV3n7qZyi/YzBDOaOgAGb4nsdntlL9i6daYhg8PnJOjLuI
-glHgsxoUuo6DQTS/DYxTGBq+Bbh1GuxJouaY7lmi+M04kPCxk2XxFUxqSBw7g0QGV5bWFoelPTLY
-Va/z/GoW8LDjjTM7pHLfzA8qhxqCOYZiKMfQT306v/cUprJ9hYYReINBlFp6Wo5ooJE1CPLwqkAO
-CuVbXE5h3AMVMm1ZQB+NkYCJKgSl10rF7C0C8dmggVxaaaCROroJDgoMviBLdMsCpp1jTSgWMFIU
-qFnEv/LFlqafyy1GPyeiCGhGogBnXnZ5jqea40g8PpxSvmigEULIficJXAuk2c+AnNKQ8TBxUhsi
-bcKN1Qw0nYwV+zk7Yj6cUs5ooBFGugkOCg2+HNEtC5h2jjWhWFDAv2YRU7uWZpo8W5wxBlpgQ7eF
-pA2YI+mr5Gb/VkDX1xyGyrWYuebw57+u7r+fletd1DjLv+jw7/An+kPshkM8HvHIwxHR7cAC04zJ
-aIjoinn9LATF5On3s8/y/Ydu1PGO7Te8rVO5QXsNmuo1gL6LJnq1R7tg2T98vbyePL6np8xUoAYf
-/5LTgn5mf6rJUbSsq2/Prq8+3J/dfIdFff1w9q+robMfP9DvefULfhm6vr96gD5fDT389fO/EAKf
-qNer1bW99cr/BzhdosE=
-	]]>
-</i:pgf>
-</svg>
diff --git a/docs/source/development/figs/hbfade.png b/docs/source/development/figs/hbfade.png
deleted file mode 100644
index a42f4766d86..00000000000
Binary files a/docs/source/development/figs/hbfade.png and /dev/null differ
diff --git a/docs/source/development/figs/iopubfade.png b/docs/source/development/figs/iopubfade.png
deleted file mode 100644
index 30ed94b446d..00000000000
Binary files a/docs/source/development/figs/iopubfade.png and /dev/null differ
diff --git a/docs/source/development/figs/ipy_kernel_and_terminal.png b/docs/source/development/figs/ipy_kernel_and_terminal.png
new file mode 100644
index 00000000000..f17fda69549
Binary files /dev/null and b/docs/source/development/figs/ipy_kernel_and_terminal.png differ
diff --git a/docs/source/development/figs/ipy_kernel_and_terminal.svg b/docs/source/development/figs/ipy_kernel_and_terminal.svg
new file mode 100644
index 00000000000..529169b7bb9
--- /dev/null
+++ b/docs/source/development/figs/ipy_kernel_and_terminal.svg
@@ -0,0 +1,281 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="589.86841"
+   height="532.51233"
+   id="svg2"
+   version="1.1"
+   inkscape:version="0.48.5 r10040"
+   sodipodi:docname="New document 1">
+  <defs
+     id="defs4">
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Lend"
+       style="overflow:visible">
+      <path
+         id="path3857"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 526.18109 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="764.09448 : 613.32395 : 1"
+       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
+       id="perspective3814" />
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Lend-3"
+       style="overflow:visible">
+      <path
+         inkscape:connector-curvature="0"
+         id="path3857-5"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
+    </marker>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.7"
+     inkscape:cx="26.0015"
+     inkscape:cy="66.637114"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:snap-object-midpoints="false"
+     inkscape:window-width="1680"
+     inkscape:window-height="1014"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     units="cm"
+     fit-margin-top="1"
+     fit-margin-right="1"
+     fit-margin-bottom="1"
+     fit-margin-left="1" />
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-96.410679,217.95483)">
+    <path
+       sodipodi:type="arc"
+       style="fill:#000000;fill-opacity:0;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="path3766"
+       sodipodi:cx="338.57144"
+       sodipodi:cy="588.79077"
+       sodipodi:rx="205.71428"
+       sodipodi:ry="70.714287"
+       d="m 544.28572,588.79077 c 0,39.05442 -92.10142,70.71429 -205.71428,70.71429 -113.61286,0 -205.71428,-31.65987 -205.71428,-70.71429 0,-39.05442 92.10142,-70.71429 205.71428,-70.71429 113.61286,0 205.71428,31.65987 205.71428,70.71429 z"
+       transform="matrix(1,0,0,1.1278581,0,-730.60879)" />
+    <g
+       id="g3782"
+       transform="translate(61.428571,-349.14286)">
+      <path
+         transform="matrix(0.92727271,0,0,1.0231405,15.012992,-6.2896699)"
+         d="m 304.28571,282.36218 c 0,34.71504 -43.81213,62.85715 -97.85714,62.85715 -54.045,0 -97.85714,-28.14211 -97.85714,-62.85715 0,-34.71504 43.81214,-62.85714 97.85714,-62.85714 54.04501,0 97.85714,28.1421 97.85714,62.85714 z"
+         sodipodi:ry="62.857143"
+         sodipodi:rx="97.85714"
+         sodipodi:cy="282.36218"
+         sodipodi:cx="206.42857"
+         id="path3780"
+         style="fill:#52b4ff;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+         sodipodi:type="arc" />
+      <text
+         sodipodi:linespacing="125%"
+         id="text3768"
+         y="272.29187"
+         x="206.92076"
+         style="font-size:40px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+         xml:space="preserve"><tspan
+           style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+           y="272.29187"
+           x="206.92076"
+           id="tspan3770"
+           sodipodi:role="line">Python</tspan><tspan
+           style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+           id="tspan3772"
+           y="312.29187"
+           x="206.92076"
+           sodipodi:role="line">execution</tspan></text>
+    </g>
+    <text
+       xml:space="preserve"
+       style="font-size:40px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+       x="390"
+       y="-76.035278"
+       id="text3788"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3790"
+         x="390"
+         y="-76.035278"
+         style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:Droid Sans;-inkscape-font-specification:Droid Sans">stdin &amp;</tspan><tspan
+         sodipodi:role="line"
+         x="390"
+         y="-36.035278"
+         id="tspan3792"
+         style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:Droid Sans;-inkscape-font-specification:Droid Sans">stdout</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans Bold"
+       x="517.14288"
+       y="-158.20926"
+       id="text3794"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3796"
+         x="517.14288"
+         y="-158.20926">Terminal</tspan><tspan
+         sodipodi:role="line"
+         x="517.14288"
+         y="-118.20926"
+         id="tspan3800">IPython</tspan></text>
+    <path
+       sodipodi:type="arc"
+       style="fill:#52b4ff;fill-opacity:0;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="path3798"
+       sodipodi:cx="260"
+       sodipodi:cy="685.93359"
+       sodipodi:rx="100"
+       sodipodi:ry="196.42857"
+       d="m 360,685.93359 c 0,108.48451 -44.77153,196.42858 -100,196.42858 -55.22847,0 -100,-87.94407 -100,-196.42858 0,-108.4845 44.77153,-196.42857 100,-196.42857 55.22847,0 100,87.94407 100,196.42857 z"
+       transform="matrix(1.1189801,0,0,0.92946844,-23.322527,-628.33705)" />
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+       x="228.57144"
+       y="84.647888"
+       id="text3802"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3804"
+         x="228.57144"
+         y="84.647888">JSON,</tspan><tspan
+         sodipodi:role="line"
+         x="228.57144"
+         y="124.64789"
+         id="tspan3806">ØMQ</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans Bold"
+       x="368.57144"
+       y="128.93359"
+       id="text3808"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3810"
+         x="368.57144"
+         y="128.93359">IPython</tspan><tspan
+         sodipodi:role="line"
+         x="368.57144"
+         y="168.93359"
+         id="tspan3812">Kernel</tspan></text>
+    <g
+       sodipodi:type="inkscape:box3d"
+       style="fill:#52b4ff;fill-opacity:0;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="g3816"
+       inkscape:perspectiveID="#perspective3814"
+       inkscape:corner0="0.75968289 : 0.77789212 : 0 : 1"
+       inkscape:corner7="0.0055330806 : 0.38177683 : 0.99976299 : 1">
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3828"
+         style="fill:#e9e9ff;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="11"
+         d="m 508.07326,-461.53631 154.81767,-93.98694 0,197.53457 -154.81767,40.00122 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3818"
+         style="fill:#353564;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="6"
+         d="m 307.83925,-554.01393 0,225.10607 200.23401,10.9204 0,-143.54885 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3820"
+         style="fill:#4d4d9f;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="5"
+         d="m 307.83925,-554.01393 158.57143,-256.79275 196.48025,255.28343 -154.81767,93.98694 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3826"
+         style="fill:#afafde;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="13"
+         d="m 307.83925,-328.90786 158.57143,-87.96321 196.48025,58.88239 -154.81767,40.00122 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3824"
+         style="fill:#d7d7ff;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="14"
+         d="m 466.41068,-810.80668 0,393.93561 196.48025,58.88239 0,-197.53457 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3822"
+         style="fill:#8686bf;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="3"
+         d="m 307.83925,-554.01393 158.57143,-256.79275 0,393.93561 -158.57143,87.96321 z" />
+    </g>
+    <g
+       id="g4300"
+       transform="translate(1.924434,-652)">
+      <path
+         inkscape:connector-curvature="0"
+         id="path3830"
+         d="m 275.71429,841.83443 0,84.28572"
+         style="fill:none;stroke:#000000;stroke-width:3;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-end:url(#Arrow2Lend)" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path3830-6"
+         d="m 255.66144,928.60421 0,-84.28572"
+         style="fill:none;stroke:#000000;stroke-width:3;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-end:url(#Arrow2Lend)" />
+    </g>
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+       x="292.85715"
+       y="267.505"
+       id="text4304"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan4306"
+         x="292.85715"
+         y="267.505"
+         style="font-size:24px;font-style:italic;-inkscape-font-specification:Droid Sans Italic">Messages</tspan></text>
+  </g>
+</svg>
diff --git a/docs/source/development/figs/notiffade.png b/docs/source/development/figs/notiffade.png
deleted file mode 100644
index a5646cfc11b..00000000000
Binary files a/docs/source/development/figs/notiffade.png and /dev/null differ
diff --git a/docs/source/development/figs/other_kernels.png b/docs/source/development/figs/other_kernels.png
new file mode 100644
index 00000000000..067e45d4d75
Binary files /dev/null and b/docs/source/development/figs/other_kernels.png differ
diff --git a/docs/source/development/figs/other_kernels.svg b/docs/source/development/figs/other_kernels.svg
new file mode 100644
index 00000000000..f57da8dd842
--- /dev/null
+++ b/docs/source/development/figs/other_kernels.svg
@@ -0,0 +1,332 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="589.86841"
+   height="532.51233"
+   id="svg2"
+   version="1.1"
+   inkscape:version="0.48.5 r10040"
+   sodipodi:docname="other_kernels.svg"
+   inkscape:export-filename="/home/takluyver/Code/ipython/docs/source/development/figs/ipy_kernel_and_terminal.png"
+   inkscape:export-xdpi="100"
+   inkscape:export-ydpi="100">
+  <defs
+     id="defs4">
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Lend"
+       style="overflow:visible">
+      <path
+         id="path3857"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <inkscape:perspective
+       sodipodi:type="inkscape:persp3d"
+       inkscape:vp_x="0 : 526.18109 : 1"
+       inkscape:vp_y="0 : 1000 : 0"
+       inkscape:vp_z="764.09448 : 613.32395 : 1"
+       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
+       id="perspective3814" />
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Lend-3"
+       style="overflow:visible">
+      <path
+         inkscape:connector-curvature="0"
+         id="path3857-5"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="Arrow2Lend-4"
+       style="overflow:visible">
+      <path
+         id="path3857-0"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+    <marker
+       inkscape:stockid="Arrow2Lend"
+       orient="auto"
+       refY="0"
+       refX="0"
+       id="marker7174"
+       style="overflow:visible">
+      <path
+         id="path7176"
+         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
+         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
+         transform="matrix(-1.1,0,0,-1.1,-1.1,0)"
+         inkscape:connector-curvature="0" />
+    </marker>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="0.7"
+     inkscape:cx="26.0015"
+     inkscape:cy="66.637114"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:snap-object-midpoints="false"
+     inkscape:window-width="1680"
+     inkscape:window-height="1014"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     units="cm"
+     fit-margin-top="1"
+     fit-margin-right="1"
+     fit-margin-bottom="1"
+     fit-margin-left="1" />
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(-96.410679,217.95483)">
+    <g
+       id="g3782"
+       transform="translate(61.428571,-349.14286)">
+      <path
+         transform="matrix(0.92727271,0,0,1.0231405,15.012992,-6.2896699)"
+         d="m 304.28571,282.36218 c 0,34.71504 -43.81213,62.85715 -97.85714,62.85715 -54.045,0 -97.85714,-28.14211 -97.85714,-62.85715 0,-34.71504 43.81214,-62.85714 97.85714,-62.85714 54.04501,0 97.85714,28.1421 97.85714,62.85714 z"
+         sodipodi:ry="62.857143"
+         sodipodi:rx="97.85714"
+         sodipodi:cy="282.36218"
+         sodipodi:cx="206.42857"
+         id="path3780"
+         style="fill:#800080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+         sodipodi:type="arc" />
+      <text
+         sodipodi:linespacing="125%"
+         id="text3768"
+         y="280.57758"
+         x="206.42125"
+         style="font-size:30px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;line-height:125%;letter-spacing:0px;word-spacing:0px;fill:#ffffff;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+         xml:space="preserve"><tspan
+           style="font-size:30px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;font-family:Droid Sans;-inkscape-font-specification:Droid Sans;fill:#ffffff;fill-opacity:1"
+           y="280.57758"
+           x="206.42125"
+           id="tspan3770"
+           sodipodi:role="line">$LANGUAGE</tspan><tspan
+           style="font-size:30px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;text-anchor:middle;font-family:Droid Sans;-inkscape-font-specification:Droid Sans;fill:#ffffff;fill-opacity:1"
+           id="tspan3772"
+           y="318.07758"
+           x="206.42125"
+           sodipodi:role="line">execution</tspan></text>
+    </g>
+    <path
+       sodipodi:type="arc"
+       style="fill:#52b4ff;fill-opacity:0;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="path3798"
+       sodipodi:cx="260"
+       sodipodi:cy="685.93359"
+       sodipodi:rx="100"
+       sodipodi:ry="196.42857"
+       d="m 360,685.93359 c 0,108.48451 -44.77153,196.42858 -100,196.42858 -55.22847,0 -100,-87.94407 -100,-196.42858 0,-108.4845 44.77153,-196.42857 100,-196.42857 55.22847,0 100,87.94407 100,196.42857 z"
+       transform="matrix(1.1189801,0,0,0.92946844,-23.322527,-628.33705)" />
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+       x="270.04199"
+       y="44.647888"
+       id="text3802"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3804"
+         x="270.04199"
+         y="44.647888">IPython</tspan><tspan
+         sodipodi:role="line"
+         x="270.04199"
+         y="84.647888"
+         id="tspan3806">JSON, ØMQ</tspan><tspan
+         sodipodi:role="line"
+         x="270.04199"
+         y="124.64789"
+         id="tspan7160">machinery</tspan></text>
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans Bold"
+       x="105.71431"
+       y="221.49724"
+       id="text3808"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3810"
+         x="105.71431"
+         y="221.49724">Wrapper</tspan><tspan
+         sodipodi:role="line"
+         x="105.71431"
+         y="261.49725"
+         id="tspan3812">Kernel</tspan></text>
+    <g
+       sodipodi:type="inkscape:box3d"
+       style="fill:#52b4ff;fill-opacity:0;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+       id="g3816"
+       inkscape:perspectiveID="#perspective3814"
+       inkscape:corner0="0.75968289 : 0.77789212 : 0 : 1"
+       inkscape:corner7="0.0055330806 : 0.38177683 : 0.99976299 : 1">
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3828"
+         style="fill:#e9e9ff;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="11"
+         d="m 508.07326,-461.53631 154.81767,-93.98694 0,197.53457 -154.81767,40.00122 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3818"
+         style="fill:#353564;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="6"
+         d="m 307.83925,-554.01393 0,225.10607 200.23401,10.9204 0,-143.54885 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3820"
+         style="fill:#4d4d9f;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="5"
+         d="m 307.83925,-554.01393 158.57143,-256.79275 196.48025,255.28343 -154.81767,93.98694 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3826"
+         style="fill:#afafde;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="13"
+         d="m 307.83925,-328.90786 158.57143,-87.96321 196.48025,58.88239 -154.81767,40.00122 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3824"
+         style="fill:#d7d7ff;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="14"
+         d="m 466.41068,-810.80668 0,393.93561 196.48025,58.88239 0,-197.53457 z" />
+      <path
+         sodipodi:type="inkscape:box3dside"
+         id="path3822"
+         style="fill:#8686bf;fill-rule:evenodd;stroke:none"
+         inkscape:box3dsidetype="3"
+         d="m 307.83925,-554.01393 158.57143,-256.79275 0,393.93561 -158.57143,87.96321 z" />
+    </g>
+    <g
+       id="g4300"
+       transform="translate(1.924434,-652)">
+      <path
+         inkscape:connector-curvature="0"
+         id="path3830"
+         d="m 275.71429,841.83443 0,84.28572"
+         style="fill:none;stroke:#000000;stroke-width:3;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-end:url(#Arrow2Lend)" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path3830-6"
+         d="m 255.66144,928.60421 0,-84.28572"
+         style="fill:none;stroke:#000000;stroke-width:3;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-end:url(#Arrow2Lend)" />
+    </g>
+    <g
+       id="g7249"
+       transform="translate(0,7.3059)">
+      <path
+         transform="matrix(1.1189801,0,0,0.92946844,246.7999,-635.64295)"
+         d="m 360,685.93359 c 0,108.48451 -44.77153,196.42858 -100,196.42858 -55.22847,0 -100,-87.94407 -100,-196.42858 0,-108.4845 44.77153,-196.42857 100,-196.42857 55.22847,0 100,87.94407 100,196.42857 z"
+         sodipodi:ry="196.42857"
+         sodipodi:rx="100"
+         sodipodi:cy="685.93359"
+         sodipodi:cx="260"
+         id="path3798-7"
+         style="fill:#800080;fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
+         sodipodi:type="arc" />
+      <text
+         sodipodi:linespacing="125%"
+         id="text3802-3"
+         y="-69.79245"
+         x="537.72693"
+         style="font-size:32px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:center;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#ffffff;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans"
+         xml:space="preserve"><tspan
+           y="-69.79245"
+           x="537.72693"
+           id="tspan3804-4"
+           sodipodi:role="line">$LANGUAGE</tspan><tspan
+           id="tspan7245"
+           y="-29.79245"
+           x="537.72693"
+           sodipodi:role="line">execution</tspan><tspan
+           id="tspan7247"
+           y="10.20755"
+           x="537.72693"
+           sodipodi:role="line">&amp;</tspan><tspan
+           id="tspan3806-2"
+           y="50.20755"
+           x="537.72693"
+           sodipodi:role="line">JSON, ØMQ</tspan><tspan
+           id="tspan7160-8"
+           y="90.20755"
+           x="537.72693"
+           sodipodi:role="line">machinery</tspan></text>
+    </g>
+    <g
+       id="g4300-0"
+       transform="translate(272.04686,-652)">
+      <path
+         inkscape:connector-curvature="0"
+         id="path3830-9"
+         d="m 275.71429,841.83443 0,84.28572"
+         style="fill:none;stroke:#000000;stroke-width:3;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-end:url(#Arrow2Lend)" />
+      <path
+         inkscape:connector-curvature="0"
+         id="path3830-6-4"
+         d="m 255.66144,928.60421 0,-84.28572"
+         style="fill:none;stroke:#000000;stroke-width:3;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-end:url(#Arrow2Lend)" />
+    </g>
+    <text
+       xml:space="preserve"
+       style="font-size:32px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:125%;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;font-family:Droid Sans;-inkscape-font-specification:Droid Sans Bold"
+       x="576.15625"
+       y="222.96599"
+       id="text3808-4"
+       sodipodi:linespacing="125%"><tspan
+         sodipodi:role="line"
+         id="tspan3810-1"
+         x="576.15625"
+         y="222.96599">Native</tspan><tspan
+         sodipodi:role="line"
+         x="576.15625"
+         y="262.96597"
+         id="tspan3812-5">Kernel</tspan></text>
+  </g>
+</svg>
diff --git a/docs/source/development/figs/queryfade.png b/docs/source/development/figs/queryfade.png
deleted file mode 100644
index c64605b1e6c..00000000000
Binary files a/docs/source/development/figs/queryfade.png and /dev/null differ
diff --git a/docs/source/development/figs/queuefade.png b/docs/source/development/figs/queuefade.png
deleted file mode 100644
index ba8e69e41cd..00000000000
Binary files a/docs/source/development/figs/queuefade.png and /dev/null differ
diff --git a/docs/source/development/frontend-kernel.png b/docs/source/development/frontend-kernel.png
deleted file mode 100644
index 49f3cb09005..00000000000
Binary files a/docs/source/development/frontend-kernel.png and /dev/null differ
diff --git a/docs/source/development/frontend-kernel.svg b/docs/source/development/frontend-kernel.svg
deleted file mode 100644
index 97370e8f43c..00000000000
--- a/docs/source/development/frontend-kernel.svg
+++ /dev/null
@@ -1,6760 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="744.09448819"
-   height="1052.3622047"
-   id="svg2"
-   version="1.1"
-   inkscape:version="0.47 r22583"
-   sodipodi:docname="ipython-frontend-kernel.svg"
-   inkscape:export-filename="/home/jtriley/Documents/ipython-frontend-kernel.png"
-   inkscape:export-xdpi="90"
-   inkscape:export-ydpi="90">
-  <defs
-     id="defs4">
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow1Send"
-       style="overflow:visible;">
-      <path
-         id="path5065"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
-         transform="scale(0.2) rotate(180) translate(6,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Mstart"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow1Mstart"
-       style="overflow:visible">
-      <path
-         id="path5058"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
-         transform="scale(0.4) translate(10,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow1Mend"
-       style="overflow:visible;">
-      <path
-         id="path5061"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
-         transform="scale(0.4) rotate(180) translate(10,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Tail"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Tail"
-       style="overflow:visible">
-      <g
-         id="g5088"
-         transform="scale(-1.2)">
-        <path
-           id="path5090"
-           d="M -3.8048674,-3.9585227 L 0.54352094,0"
-           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
-        <path
-           id="path5092"
-           d="M -1.2866832,-3.9585227 L 3.0617053,0"
-           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
-        <path
-           id="path5094"
-           d="M 1.3053582,-3.9585227 L 5.6537466,0"
-           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
-        <path
-           id="path5096"
-           d="M -3.8048674,4.1775838 L 0.54352094,0.21974226"
-           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
-        <path
-           id="path5098"
-           d="M -1.2866832,4.1775838 L 3.0617053,0.21974226"
-           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
-        <path
-           id="path5100"
-           d="M 1.3053582,4.1775838 L 5.6537466,0.21974226"
-           style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.8;marker-start:none;marker-end:none;stroke-linecap:round" />
-      </g>
-    </marker>
-    <marker
-       inkscape:stockid="SquareL"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="SquareL"
-       style="overflow:visible">
-      <path
-         id="path5123"
-         d="M -5.0,-5.0 L -5.0,5.0 L 5.0,5.0 L 5.0,-5.0 L -5.0,-5.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
-         transform="scale(0.8)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow2Lend"
-       style="overflow:visible;">
-      <path
-         id="path5073"
-         style="font-size:12.0;fill-rule:evenodd;stroke-width:0.62500000;stroke-linejoin:round;"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         transform="scale(1.1) rotate(180) translate(1,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Lstart"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow1Lstart"
-       style="overflow:visible">
-      <path
-         id="path5052"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none"
-         transform="scale(0.8) translate(12.5,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Lend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow1Lend"
-       style="overflow:visible;">
-      <path
-         id="path5055"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
-         transform="scale(0.8) rotate(180) translate(12.5,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow2Lstart"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow2Lstart"
-       style="overflow:visible">
-      <path
-         id="path5070"
-         style="font-size:12.0;fill-rule:evenodd;stroke-width:0.62500000;stroke-linejoin:round"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         transform="scale(1.1) translate(1,0)" />
-    </marker>
-    <inkscape:perspective
-       sodipodi:type="inkscape:persp3d"
-       inkscape:vp_x="0 : 526.18109 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_z="744.09448 : 526.18109 : 1"
-       inkscape:persp3d-origin="372.04724 : 350.78739 : 1"
-       id="perspective10" />
-    <inkscape:perspective
-       id="perspective2828"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3632"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3665"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3735"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3735-0"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3766"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3796"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3841"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3867"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3894"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3894-7"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3935"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3963"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective3995"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4020"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4045"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4126"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4126-4"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4245"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4245-8"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4280"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4280-6"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4873"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4873-5"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4914"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4914-3"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective4977"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective10625"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow2Lend-1"
-       style="overflow:visible">
-      <path
-         id="path5073-6"
-         style="font-size:12px;fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
-         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
-         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective10653"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective10729"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,581.99821,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4597"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,425.42457,285.82987)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4480"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,347.64282,285.82987)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4472"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,265.82046,285.82987)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4464"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,179.95749,285.82987)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4456"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,101.16559,285.82987)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4448"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,285.82987)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4440"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4427"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,661.80026,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4356"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,581.99821,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4348"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,499.1657,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4340"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,421.38395,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4332"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,338.55144,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4324"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,261.77985,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4316"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,183.9981,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4308"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,102.17574,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4300"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       y2="214.21933"
-       x2="171.66098"
-       y1="319.12198"
-       x1="171.66098"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,199.9669)"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient4292"
-       xlink:href="#linearGradient3134"
-       inkscape:collect="always" />
-    <linearGradient
-       id="linearGradient3134">
-      <stop
-         id="stop3136"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3138"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient5756">
-      <stop
-         style="stop-color:#dadada;stop-opacity:1;"
-         offset="0"
-         id="stop5758" />
-      <stop
-         style="stop-color:#b7b7b7;stop-opacity:1;"
-         offset="1"
-         id="stop5760" />
-    </linearGradient>
-    <inkscape:perspective
-       id="perspective11303"
-       inkscape:persp3d-origin="526.18109 : 248.03149 : 1"
-       inkscape:vp_z="1052.3622 : 372.04724 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 372.04724 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective11733"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow2Lend-0"
-       style="overflow:visible">
-      <path
-         id="path5073-3"
-         style="font-size:12px;fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
-         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
-         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective12001"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective12023"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective12023-2"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective12059"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective12059-1"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective6789"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow2Lend-4"
-       style="overflow:visible">
-      <path
-         id="path5073-1"
-         style="font-size:12px;fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
-         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
-         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective6789-0"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow2Lend-8"
-       style="overflow:visible">
-      <path
-         id="path5073-61"
-         style="font-size:12px;fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
-         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
-         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective6789-2"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow2Lend-06"
-       style="overflow:visible">
-      <path
-         id="path5073-5"
-         style="font-size:12px;fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round"
-         d="M 8.7185878,4.0337352 -2.2072895,0.01601326 8.7185884,-4.0017078 c -1.7454984,2.3720609 -1.7354408,5.6174519 -6e-7,8.035443 z"
-         transform="matrix(-1.1,0,0,-1.1,-1.1,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective7707"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Send-8"
-       style="overflow:visible">
-      <path
-         id="path5065-3"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.2,0,0,-0.2,-1.2,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective7707-1"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Send-6"
-       style="overflow:visible">
-      <path
-         id="path5065-8"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.2,0,0,-0.2,-1.2,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective7707-19"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Send-9"
-       style="overflow:visible">
-      <path
-         id="path5065-39"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.2,0,0,-0.2,-1.2,0)" />
-    </marker>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6263"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6265"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383845,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6267"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,102.17574,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6269"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,181.97779,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6271"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,257.73923,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6273"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,339.56159,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6275"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,419.36364,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6277"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,498.15554,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6279"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,576.94744,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6281"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,652.70888,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6283"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6285"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6287"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,102.17574,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6289"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,183.9981,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6291"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,261.77985,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6293"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,338.55144,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6295"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,421.38395,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6297"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,499.1657,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6299"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,581.99821,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6301"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6303"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6305"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,101.16559,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6307"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,179.95749,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6309"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,265.82046,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6311"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,347.64282,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6313"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,417.34334,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6317"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6319"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,21.734804,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6321"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,103.16338,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6323"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,178.87767,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6325"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,256.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6327"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,333.93443,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6329"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,416.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6331"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,496.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6333"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,577.4491,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6335"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,660.30624,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6337"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.9559964,0,0,0.6857303,343.53616,285.68268)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <inkscape:perspective
-       id="perspective3219"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <linearGradient
-       id="linearGradient5756-2">
-      <stop
-         style="stop-color:#dadada;stop-opacity:1;"
-         offset="0"
-         id="stop5758-4" />
-      <stop
-         style="stop-color:#b7b7b7;stop-opacity:1;"
-         offset="1"
-         id="stop5760-7" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3134-3">
-      <stop
-         id="stop3136-9"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3138-2"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3232">
-      <stop
-         id="stop3234"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3236"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3239">
-      <stop
-         id="stop3241"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3243"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3246">
-      <stop
-         id="stop3248"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3250"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3253">
-      <stop
-         id="stop3255"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3257"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3260">
-      <stop
-         id="stop3262"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3264"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3267">
-      <stop
-         id="stop3269"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3271"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3274">
-      <stop
-         id="stop3276"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3278"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3281">
-      <stop
-         id="stop3283"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3285"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3288">
-      <stop
-         id="stop3290"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3292"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3295">
-      <stop
-         id="stop3297"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3299"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3302">
-      <stop
-         id="stop3304"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3306"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3309">
-      <stop
-         id="stop3311"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3313"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3316">
-      <stop
-         id="stop3318"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3320"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3323">
-      <stop
-         id="stop3325"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3327"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3330">
-      <stop
-         id="stop3332"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3334"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3337">
-      <stop
-         id="stop3339"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3341"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3344">
-      <stop
-         id="stop3346"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3348"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3351">
-      <stop
-         id="stop3353"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3355"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3358">
-      <stop
-         id="stop3360"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3362"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3365">
-      <stop
-         id="stop3367"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3369"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3372">
-      <stop
-         id="stop3374"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3376"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3379">
-      <stop
-         id="stop3381"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3383"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3386">
-      <stop
-         id="stop3388"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3390"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3393">
-      <stop
-         id="stop3395"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3397"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3400">
-      <stop
-         id="stop3402"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3404"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3407">
-      <stop
-         id="stop3409"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3411"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3414">
-      <stop
-         id="stop3416"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3418"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3421">
-      <stop
-         id="stop3423"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3425"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3428">
-      <stop
-         id="stop3430"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3432"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3435">
-      <stop
-         id="stop3437"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3439"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3442">
-      <stop
-         id="stop3444"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3446"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3449">
-      <stop
-         id="stop3451"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3453"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3456">
-      <stop
-         id="stop3458"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3460"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3463">
-      <stop
-         id="stop3465"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3467"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3470">
-      <stop
-         id="stop3472"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3474"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3477">
-      <stop
-         id="stop3479"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3481"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3484">
-      <stop
-         id="stop3486"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3488"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <inkscape:perspective
-       id="perspective3219-7"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <linearGradient
-       id="linearGradient5756-9">
-      <stop
-         style="stop-color:#dadada;stop-opacity:1;"
-         offset="0"
-         id="stop5758-1" />
-      <stop
-         style="stop-color:#b7b7b7;stop-opacity:1;"
-         offset="1"
-         id="stop5760-70" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6263-6"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3134-0">
-      <stop
-         id="stop3136-8"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3138-5"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6265-3"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383845,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3232-9">
-      <stop
-         id="stop3234-4"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3236-1"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6267-5"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,102.17574,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3239-4">
-      <stop
-         id="stop3241-1"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3243-5"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6269-5"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,181.97779,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3246-4">
-      <stop
-         id="stop3248-9"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3250-8"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6271-3"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,257.73923,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3253-8">
-      <stop
-         id="stop3255-5"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3257-2"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6273-2"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,339.56159,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3260-2">
-      <stop
-         id="stop3262-7"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3264-0"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6275-3"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,419.36364,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3267-4">
-      <stop
-         id="stop3269-6"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3271-3"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6277-6"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,498.15554,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3274-3">
-      <stop
-         id="stop3276-3"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3278-4"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6279-4"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,576.94744,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3281-3">
-      <stop
-         id="stop3283-9"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3285-7"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6281-2"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,652.70888,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3288-5">
-      <stop
-         id="stop3290-8"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3292-9"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6283-0"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3295-2">
-      <stop
-         id="stop3297-4"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3299-7"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6285-6"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3302-5">
-      <stop
-         id="stop3304-7"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3306-1"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6287-3"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,102.17574,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3309-3">
-      <stop
-         id="stop3311-3"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3313-8"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6289-51"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,183.9981,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3316-0">
-      <stop
-         id="stop3318-8"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3320-7"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6291-6"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,261.77985,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3323-3">
-      <stop
-         id="stop3325-5"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3327-0"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6293-8"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,338.55144,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3330-0">
-      <stop
-         id="stop3332-4"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3334-1"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6295-1"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,421.38395,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3337-3">
-      <stop
-         id="stop3339-5"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3341-9"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6297-3"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,499.1657,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3344-4">
-      <stop
-         id="stop3346-1"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3348-5"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6299-0"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,581.99821,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3351-8">
-      <stop
-         id="stop3353-3"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3355-5"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6301-6"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3358-5">
-      <stop
-         id="stop3360-9"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3362-9"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6303-0"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3365-7">
-      <stop
-         id="stop3367-6"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3369-3"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6305-7"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,101.16559,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3372-6">
-      <stop
-         id="stop3374-1"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3376-5"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6307-0"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,179.95749,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3379-6">
-      <stop
-         id="stop3381-5"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3383-0"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6309-8"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,265.82046,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3386-1">
-      <stop
-         id="stop3388-2"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3390-2"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6311-6"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,347.64282,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3393-9">
-      <stop
-         id="stop3395-1"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3397-0"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6313-4"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,417.34334,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3400-2">
-      <stop
-         id="stop3402-7"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3404-4"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       id="linearGradient3407-3">
-      <stop
-         id="stop3409-2"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3411-8"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6317-0"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3414-3">
-      <stop
-         id="stop3416-7"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3418-0"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6319-0"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,21.734804,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3421-3">
-      <stop
-         id="stop3423-4"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3425-9"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6321-2"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,103.16338,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3428-7">
-      <stop
-         id="stop3430-4"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3432-2"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6323-5"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,178.87767,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3435-2">
-      <stop
-         id="stop3437-4"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3439-4"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6325-3"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,256.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3442-8">
-      <stop
-         id="stop3444-6"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3446-0"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6327-8"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,333.93443,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3449-9">
-      <stop
-         id="stop3451-2"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3453-2"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6329-31"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,416.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3456-8">
-      <stop
-         id="stop3458-3"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3460-4"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6331-2"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,496.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3463-2">
-      <stop
-         id="stop3465-4"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3467-5"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6333-1"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,577.4491,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3470-7">
-      <stop
-         id="stop3472-5"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3474-7"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6335-1"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,660.30624,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3477-6">
-      <stop
-         id="stop3479-9"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3481-8"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient6337-1"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.9559964,0,0,0.6857303,343.53616,285.68268)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       id="linearGradient3484-3">
-      <stop
-         id="stop3486-3"
-         offset="0"
-         style="stop-color:#f6f6f6;stop-opacity:1;" />
-      <stop
-         id="stop3488-3"
-         offset="1"
-         style="stop-color:#b7b7b7;stop-opacity:1;" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-0"
-       id="linearGradient4933"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.7753191,0,0,0.15960984,-106.93223,45.461266)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient5756-9"
-       id="linearGradient5040"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.6394366,0,0,1.0001283,-239.14484,-220.22534)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134"
-       id="linearGradient6175"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.7753191,0,0,0.15960984,241.72444,41.501454)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient5756"
-       id="linearGradient6282"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.6394366,0,0,1.0001283,106.86557,-224.18515)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient5756-2"
-       id="linearGradient7058"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.6394366,0,0,1.0001283,465.85077,-219.91284)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7060"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7062"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383845,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7064"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,102.17574,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7066"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,181.97779,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7068"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,257.73923,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7070"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,339.56159,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7072"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,419.36364,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7074"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,498.15554,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7076"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,576.94744,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7078"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,652.70888,114.10393)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7080"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7082"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7084"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,102.17574,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7086"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,183.9981,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7088"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,261.77985,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7090"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,338.55144,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7092"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,421.38395,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7094"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,499.1657,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7096"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,581.99821,199.9669)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7098"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7100"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,23.383846,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7102"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,101.16559,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7104"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,179.95749,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7106"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,265.82046,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7108"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,347.64282,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7110"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,417.34334,285.82987)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7112"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.7753191,0,0,0.15960984,600.70964,45.773766)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7114"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,-55.408053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7116"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,21.734804,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7118"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,103.16338,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7120"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,178.87767,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7122"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,256.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7124"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,333.93443,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7126"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,416.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7128"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,496.02053,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7130"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,577.4491,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7132"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(0.5946191,0,0,0.6857303,660.30624,29.818216)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient3134-3"
-       id="linearGradient7134"
-       gradientUnits="userSpaceOnUse"
-       gradientTransform="matrix(1.9559964,0,0,0.6857303,343.53616,285.68268)"
-       x1="171.66098"
-       y1="319.12198"
-       x2="171.66098"
-       y2="214.21933" />
-    <inkscape:perspective
-       id="perspective5992"
-       inkscape:persp3d-origin="200 : 161.33333 : 1"
-       inkscape:vp_z="400 : 242 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 242 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <inkscape:perspective
-       id="perspective8459"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Send-9-8"
-       style="overflow:visible">
-      <path
-         id="path5065-39-9"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.2,0,0,-0.2,-1.2,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Mend-3"
-       style="overflow:visible">
-      <path
-         id="path5061-3"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.4,0,0,-0.4,-4,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective8493"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Send-9-4"
-       style="overflow:visible">
-      <path
-         id="path5065-39-8"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.2,0,0,-0.2,-1.2,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Mend-2"
-       style="overflow:visible">
-      <path
-         id="path5061-36"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.4,0,0,-0.4,-4,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective8527"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Send-9-1"
-       style="overflow:visible">
-      <path
-         id="path5065-39-5"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.2,0,0,-0.2,-1.2,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Mend-35"
-       style="overflow:visible">
-      <path
-         id="path5061-7"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.4,0,0,-0.4,-4,0)" />
-    </marker>
-    <inkscape:perspective
-       id="perspective8561"
-       inkscape:persp3d-origin="0.5 : 0.33333333 : 1"
-       inkscape:vp_z="1 : 0.5 : 1"
-       inkscape:vp_y="0 : 1000 : 0"
-       inkscape:vp_x="0 : 0.5 : 1"
-       sodipodi:type="inkscape:persp3d" />
-    <marker
-       inkscape:stockid="Arrow1Send"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Send-9-2"
-       style="overflow:visible">
-      <path
-         id="path5065-39-2"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.2,0,0,-0.2,-1.2,0)" />
-    </marker>
-    <marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0"
-       refX="0"
-       id="Arrow1Mend-5"
-       style="overflow:visible">
-      <path
-         id="path5061-6"
-         d="M 0,0 5,-5 -12.5,0 5,5 0,0 z"
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none"
-         transform="matrix(-0.4,0,0,-0.4,-4,0)" />
-    </marker>
-  </defs>
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="0.90509668"
-     inkscape:cx="256.73404"
-     inkscape:cy="303.39911"
-     inkscape:document-units="px"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     showguides="true"
-     inkscape:guide-bbox="true"
-     inkscape:window-width="1440"
-     inkscape:window-height="825"
-     inkscape:window-x="0"
-     inkscape:window-y="24"
-     inkscape:window-maximized="1"
-     inkscape:snap-nodes="true" />
-  <metadata
-     id="metadata7">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title />
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1">
-    <flowRoot
-       xml:space="preserve"
-       id="flowRoot3679"
-       style="font-size:40px;font-style:normal;font-weight:normal;writing-mode:tb-rl;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"><flowRegion
-         id="flowRegion3681"><rect
-           id="rect3683"
-           width="46.42857"
-           height="117.85714"
-           x="480.71429"
-           y="490.93362"
-           style="writing-mode:tb-rl" /></flowRegion><flowPara
-         id="flowPara3685">PUBsfasdfasdf</flowPara></flowRoot>    <rect
-       style="fill:#0000ff;fill-opacity:1"
-       id="rect4229"
-       width="715.18799"
-       height="175.45087"
-       x="8.1421356"
-       y="565.46863"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="197.70563"
-       y="711.97626"
-       id="text4231"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         id="tspan4233"
-         x="197.70563"
-         y="711.97626"
-         style="font-weight:bold">IPython Kernel</tspan></text>
-    <rect
-       style="fill:#241c1c;fill-opacity:1"
-       id="rect4235"
-       width="151.52289"
-       height="92.934036"
-       x="43.015251"
-       y="565.53973"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       style="fill:#008000;fill-opacity:1"
-       id="rect4235-2"
-       width="151.52289"
-       height="92.934036"
-       x="285.4671"
-       y="565.53973"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       style="fill:#ff0000;fill-opacity:1"
-       id="rect4235-8"
-       width="151.52289"
-       height="92.934036"
-       x="530.37073"
-       y="565.53973"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="75.632164"
-       y="624.2724"
-       id="text4268"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         id="tspan4270"
-         x="75.632164"
-         y="624.2724"
-         style="fill:#ffffff">REQ</tspan></text>
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="308.98245"
-       y="626.58685"
-       id="text4268-9"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         id="tspan4270-1"
-         x="308.98245"
-         y="626.58685"
-         style="fill:#ffffff">XREP</tspan></text>
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="565.14587"
-       y="626.30365"
-       id="text4268-4"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         id="tspan4270-7"
-         x="565.14587"
-         y="626.30365"
-         style="fill:#ffffff">PUB</tspan></text>
-    <flowRoot
-       xml:space="preserve"
-       id="flowRoot4308"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       transform="translate(84.260191,-74.726213)"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><flowRegion
-         id="flowRegion4310"><rect
-           id="rect4312"
-           width="687.85077"
-           height="287.19901"
-           x="74.751289"
-           y="834.16925" /></flowRegion><flowPara
-         id="flowPara4845"
-         style="font-weight:normal"> - Kernel raw_input</flowPara><flowPara
-         style="font-weight:normal"
-         id="flowPara6339"> - Requests to kernel</flowPara><flowPara
-         style="font-weight:normal"
-         id="flowPara4851"> - Kernel output broadcast</flowPara><flowPara
-         style="font-weight:normal"
-         id="flowPara12084"> - Request/Reply direction</flowPara></flowRoot>    <rect
-       style="fill:#0000ff;fill-rule:evenodd;stroke:#000000;stroke-width:0.93826735px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       id="rect2816"
-       width="336.66351"
-       height="265.22681"
-       x="211.68776"
-       y="129.72862"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       style="fill:#00ff00"
-       id="rect3695"
-       width="240"
-       height="51.42857"
-       x="253.54944"
-       y="144.6738"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <flowRoot
-       xml:space="preserve"
-       id="flowRoot3614"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       transform="translate(170.4283,-70.442566)"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><flowRegion
-         id="flowRegion3616"><rect
-           id="rect3618"
-           width="286.88333"
-           height="82.832504"
-           x="127.27922"
-           y="222.01678" /></flowRegion><flowPara
-         id="flowPara3620"
-         style="font-size:28px;font-weight:bold">Front-end</flowPara></flowRoot>    <path
-       style="fill:#05ff00;stroke:#2af510;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none;fill-opacity:1"
-       d="m 373.73648,243.10253 -0.11904,-45.00016"
-       id="path3711"
-       inkscape:connector-type="polyline"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       style="fill:#00ff00;fill-opacity:1"
-       id="rect3884"
-       width="318.09625"
-       height="130.85158"
-       x="221.90559"
-       y="244.85242"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="277.12085"
-       y="287.81665"
-       id="text3713"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         x="277.12085"
-         y="287.81665"
-         id="tspan3717"
-         style="font-size:28px;font-weight:bold">Kernel Proxy</tspan></text>
-    <rect
-       style="fill:#280b0b;fill-opacity:1"
-       id="rect4859-9"
-       width="92.172592"
-       height="44.285713"
-       x="435.88266"
-       y="313.34006"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="454.03732"
-       y="345.68896"
-       id="text4861-2"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         id="tspan4863-6"
-         x="454.03732"
-         y="345.68896"
-         style="font-size:28px;fill:#ffffff">REP</tspan></text>
-    <rect
-       style="fill:#ff0000;fill-opacity:1"
-       id="rect4859-9-4"
-       width="92.172592"
-       height="44.285713"
-       x="334.2355"
-       y="313.62433"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="351.64505"
-       y="345.95956"
-       id="text4861-2-8"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         id="tspan4863-6-9"
-         x="351.64505"
-         y="345.95956"
-         style="font-size:28px;fill:#ffffff">SUB</tspan></text>
-    <rect
-       style="fill:#008000;fill-opacity:1"
-       id="rect4859-9-3"
-       width="92.172592"
-       height="44.285713"
-       x="232.23549"
-       y="313.62433"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="239.47998"
-       y="344.35312"
-       id="text4861-2-2"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90"><tspan
-         sodipodi:role="line"
-         id="tspan4863-6-97"
-         x="239.47998"
-         y="344.35312"
-         style="font-size:28px;fill:#ffffff">XREQ</tspan></text>
-    <rect
-       style="fill:#0000ff;fill-rule:evenodd;stroke:#000000;stroke-width:0.80252945px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       id="rect2816-3"
-       width="246.17426"
-       height="265.36255"
-       x="604.09601"
-       y="129.66075" />
-    <rect
-       style="fill:#00ff00"
-       id="rect3695-4"
-       width="224.375"
-       height="51.42857"
-       x="616.02551"
-       y="144.67378" />
-    <flowRoot
-       xml:space="preserve"
-       id="flowRoot3614-1"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       transform="translate(522.42786,-70.442567)"><flowRegion
-         id="flowRegion3616-8"><rect
-           id="rect3618-9"
-           width="286.88333"
-           height="82.832504"
-           x="127.27922"
-           y="222.01678" /></flowRegion><flowPara
-         id="flowPara3620-0"
-         style="font-size:28px;font-weight:bold">Front-end </flowPara></flowRoot>    <path
-       style="fill:none;stroke:#06ff00;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-       d="m 728.27256,243.10253 -0.1191,-45.00015"
-       id="path3711-4"
-       inkscape:connector-type="polyline" />
-    <rect
-       style="fill:#00ff00;fill-opacity:1"
-       id="rect3884-4"
-       width="225.90875"
-       height="130.85158"
-       x="614.38171"
-       y="244.85243" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="621.59692"
-       y="287.81665"
-       id="text3713-9"><tspan
-         sodipodi:role="line"
-         x="621.59692"
-         y="287.81665"
-         id="tspan3717-9"
-         style="font-size:28px;font-weight:bold">Kernel Proxy</tspan></text>
-    <rect
-       style="fill:#ff0000;fill-opacity:1"
-       id="rect4859-9-4-5"
-       width="92.172592"
-       height="44.285713"
-       x="726.71155"
-       y="313.62433" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="744.12109"
-       y="345.95956"
-       id="text4861-2-8-0"><tspan
-         sodipodi:role="line"
-         id="tspan4863-6-9-1"
-         x="744.12109"
-         y="345.95956"
-         style="font-size:28px;fill:#ffffff">SUB</tspan></text>
-    <rect
-       style="fill:#008000;fill-opacity:1"
-       id="rect4859-9-3-5"
-       width="92.172592"
-       height="44.285713"
-       x="624.71161"
-       y="313.62433" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="631.95612"
-       y="344.35312"
-       id="text4861-2-2-8"><tspan
-         sodipodi:role="line"
-         id="tspan4863-6-97-6"
-         x="631.95612"
-         y="344.35312"
-         style="font-size:28px;fill:#ffffff">XREQ</tspan></text>
-    <rect
-       style="fill:#0000ff;fill-rule:evenodd;stroke:#000000;stroke-width:0.80252945px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       id="rect2816-3-6"
-       width="246.17426"
-       height="265.36255"
-       x="-86.899628"
-       y="129.66077" />
-    <rect
-       style="fill:#00ff00"
-       id="rect3695-4-1"
-       width="224.375"
-       height="51.42857"
-       x="-74.970123"
-       y="144.6738" />
-    <flowRoot
-       xml:space="preserve"
-       id="flowRoot3614-1-3"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       transform="translate(-167.37833,-70.442569)"><flowRegion
-         id="flowRegion3616-8-8"><rect
-           id="rect3618-9-6"
-           width="286.88333"
-           height="82.832504"
-           x="127.27922"
-           y="222.01678" /></flowRegion><flowPara
-         id="flowPara3620-0-0"
-         style="font-size:28px;font-weight:bold">Front-end</flowPara></flowRoot>    <path
-       style="fill:none;stroke:#04ff00;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-       d="m 37.276897,243.10252 -0.11904,-45.00015"
-       id="path3711-4-8"
-       inkscape:connector-type="polyline"
-       sodipodi:nodetypes="cc" />
-    <rect
-       style="fill:#00ff00;fill-opacity:1"
-       id="rect3884-4-1"
-       width="225.90875"
-       height="130.85158"
-       x="-76.613922"
-       y="244.85245" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="-69.398712"
-       y="287.81665"
-       id="text3713-9-4"><tspan
-         sodipodi:role="line"
-         x="-69.398712"
-         y="287.81665"
-         id="tspan3717-9-0"
-         style="font-size:28px;font-weight:bold">Kernel Proxy</tspan></text>
-    <rect
-       style="fill:#ff0000;fill-opacity:1"
-       id="rect4859-9-4-5-6"
-       width="92.172592"
-       height="44.285713"
-       x="35.715977"
-       y="313.62433" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="53.125515"
-       y="345.95956"
-       id="text4861-2-8-0-0"><tspan
-         sodipodi:role="line"
-         id="tspan4863-6-9-1-7"
-         x="53.125515"
-         y="345.95956"
-         style="font-size:28px;fill:#ffffff">SUB</tspan></text>
-    <rect
-       style="fill:#008000;fill-opacity:1"
-       id="rect4859-9-3-5-8"
-       width="92.172592"
-       height="44.285713"
-       x="-66.284027"
-       y="313.62433" />
-    <text
-       xml:space="preserve"
-       style="font-size:40px;font-style:normal;font-weight:normal;fill:#000000;fill-opacity:1;stroke:none;font-family:Bitstream Vera Sans"
-       x="-59.039528"
-       y="344.35312"
-       id="text4861-2-2-8-7"><tspan
-         sodipodi:role="line"
-         id="tspan4863-6-97-6-1"
-         x="-59.039528"
-         y="344.35312"
-         style="font-size:28px;fill:#ffffff">XREQ</tspan></text>
-    <path
-       style="fill:#ff0000;stroke:#ff0000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-mid:url(#Arrow1Mstart)"
-       d="m 123.8316,357.91004 355.72174,187.40953 50.81739,26.77279"
-       id="path10788"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4859-9-4-5-6"
-       inkscape:connection-end="#rect4235-8"
-       sodipodi:nodetypes="ccc"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="fill:#d40000;fill-opacity:1;stroke:#ff0000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-mid:url(#Arrow1Mstart)"
-       d="M 759.43823,357.91004 696.80284,461.72488 634.16746,565.53973"
-       id="path10790"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4859-9-4-5"
-       inkscape:connection-end="#rect4235-8"
-       sodipodi:nodetypes="ccc"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="fill:none;stroke:#278900;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-mid:url(#Arrow1Mstart)"
-       d="M 10.376699,357.91004 297.06778,565.53973"
-       id="path10792"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4859-9-3-5-8"
-       inkscape:connection-end="#rect4235-2"
-       sodipodi:nodetypes="ccc"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="fill:#008000;fill-opacity:1;stroke:#238800;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-mid:url(#Arrow1Mstart)"
-       d="M 645.98339,357.91004 413.30206,565.53973"
-       id="path10794"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4859-9-3-5"
-       inkscape:connection-end="#rect4235-2"
-       sodipodi:nodetypes="ccc"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="fill:none;stroke:#ff0000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-mid:url(#Arrow1Mstart)"
-       d="m 398.42235,357.91004 127.29423,155.72226 42.43141,51.90743"
-       id="path10796"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4859-9-4"
-       inkscape:connection-end="#rect4235-8"
-       sodipodi:nodetypes="ccc"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="fill:#280b0b;stroke:#000000;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-mid:none"
-       d="M 179.80746,565.53973 452.88606,357.62577"
-       id="path10800"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4235"
-       inkscape:connection-end="#rect4859-9"
-       sodipodi:nodetypes="ccc"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <path
-       style="fill:#ff0000;stroke:#449900;stroke-width:4;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-mid:url(#Arrow1Mend)"
-       d="M 347.28257,565.53973 284.96744,357.91004"
-       id="path10802"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4235-2"
-       inkscape:connection-end="#rect4859-9-3"
-       sodipodi:nodetypes="ccc"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       style="fill:#000000;fill-opacity:1;stroke:none"
-       id="rect11963"
-       width="218.76115"
-       height="125.95339"
-       x="274.21359"
-       y="-20.699326" />
-    <rect
-       inkscape:label="#rect2160"
-       ry="1.1637948"
-       rx="1.1637946"
-       y="-8.9381561"
-       x="289.54568"
-       height="102.87033"
-       width="187.36421"
-       id="rect4783"
-       style="fill:url(#linearGradient6282);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:0.46551785;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="q"
-       inkscape:label="#g4203"
-       transform="matrix(0.23275892,0,0,0.23275892,289.14995,-44.778246)">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="261.68634"
-         x="10.849505"
-         height="70.532257"
-         width="67.956474"
-         id="Q"
-         style="fill:url(#linearGradient6263);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text3142"
-         y="318.48373"
-         x="19.733997"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="318.48373"
-           x="19.733997"
-           id="tspan3144"
-           sodipodi:role="line">Q</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="w"
-       transform="matrix(0.23275892,0,0,0.23275892,289.12382,-44.778246)"
-       inkscape:label="#g4208">
-      <rect
-         style="fill:url(#linearGradient6265);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4115"
-         width="67.956474"
-         height="70.532257"
-         x="89.641403"
-         y="261.68634"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="93.385269"
-         y="319.85873"
-         id="text4117"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4119"
-           x="93.385269"
-           y="319.85873"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">W</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="e"
-       transform="matrix(0.23275892,0,0,0.23275892,289.0977,-44.778246)"
-       inkscape:label="#g4213">
-      <rect
-         style="fill:url(#linearGradient6267);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4123"
-         width="67.956474"
-         height="70.532257"
-         x="168.4333"
-         y="261.68634"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="180.25529"
-         y="319.8587"
-         id="text4125"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4127"
-           x="180.25529"
-           y="319.8587"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">E</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="r"
-       transform="matrix(0.23275892,0,0,0.23275892,288.83645,-44.778246)"
-       inkscape:label="#g4218">
-      <rect
-         style="fill:url(#linearGradient6269);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4131"
-         width="67.956474"
-         height="70.532257"
-         x="248.23535"
-         y="261.68634"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="256.99484"
-         y="319.8587"
-         id="text4133"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4135"
-           x="256.99484"
-           y="319.8587"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">R</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="t"
-       transform="matrix(0.23275892,0,0,0.23275892,289.51569,-44.778246)"
-       inkscape:label="#g4223">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="261.68634"
-         x="323.9968"
-         height="70.532257"
-         width="67.956474"
-         id="rect4139"
-         style="fill:url(#linearGradient6271);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4141"
-         y="319.8587"
-         x="338.31879"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="319.8587"
-           x="338.31879"
-           id="tspan4143"
-           sodipodi:role="line">T</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="y"
-       transform="matrix(0.23275892,0,0,0.23275892,288.7842,-44.778246)"
-       inkscape:label="#g4228">
-      <rect
-         style="fill:url(#linearGradient6273);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4147"
-         width="67.956474"
-         height="70.532257"
-         x="405.81915"
-         y="261.68634"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="418.60989"
-         y="319.8587"
-         id="text4149"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4151"
-           x="418.60989"
-           y="319.8587"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">Y</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="u"
-       transform="matrix(0.23275892,0,0,0.23275892,288.52295,-44.778246)"
-       inkscape:label="#g4233">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="261.68634"
-         x="485.62122"
-         height="70.532257"
-         width="67.956474"
-         id="rect4155"
-         style="fill:url(#linearGradient6275);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4157"
-         y="319.46808"
-         x="496.55258"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="319.46808"
-           x="496.55258"
-           id="tspan4159"
-           sodipodi:role="line">U</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="i"
-       transform="matrix(0.23275892,0,0,0.23275892,288.49683,-44.778246)"
-       inkscape:label="#g4238">
-      <rect
-         style="fill:url(#linearGradient6277);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4163"
-         width="67.956474"
-         height="70.532257"
-         x="564.41309"
-         y="261.68634"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="589.3913"
-         y="319.8587"
-         id="text4165"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4167"
-           x="589.3913"
-           y="319.8587"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">I</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="o"
-       transform="matrix(0.23275892,0,0,0.23275892,288.4707,-44.778246)"
-       inkscape:label="#g4243">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="261.68634"
-         x="643.20496"
-         height="70.532257"
-         width="67.956474"
-         id="rect4171"
-         style="fill:url(#linearGradient6279);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4173"
-         y="319.87433"
-         x="652.18317"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="319.87433"
-           x="652.18317"
-           id="tspan4175"
-           sodipodi:role="line">O</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="p"
-       transform="matrix(0.23275892,0,0,0.23275892,289.14994,-44.778246)"
-       inkscape:label="#g4248">
-      <rect
-         style="fill:url(#linearGradient6281);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4179"
-         width="67.956474"
-         height="70.532257"
-         x="718.96637"
-         y="261.68634"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="730.52271"
-         y="319.8587"
-         id="text4181"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4183"
-           x="730.52271"
-           y="319.8587"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">P</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="a"
-       inkscape:label="#g4358"
-       transform="matrix(0.23275892,0,0,0.23275892,289.14995,-44.778246)">
-      <rect
-         style="fill:url(#linearGradient6283);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4273"
-         width="67.956474"
-         height="70.532257"
-         x="10.849505"
-         y="347.54932"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="23.483994"
-         y="405.72168"
-         id="text4275"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4277"
-           x="23.483994"
-           y="405.72168"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">A</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="s"
-       transform="matrix(0.23275892,0,0,0.23275892,289.12056,-44.778246)"
-       inkscape:label="#g4363">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="347.54932"
-         x="89.641403"
-         height="70.532257"
-         width="67.956474"
-         id="rect4286"
-         style="fill:url(#linearGradient6285);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4288"
-         y="405.72168"
-         x="102.51027"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="405.72168"
-           x="102.51027"
-           id="tspan4290"
-           sodipodi:role="line">S</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="d"
-       transform="matrix(0.23275892,0,0,0.23275892,289.09117,-44.778246)"
-       inkscape:label="#g4368">
-      <rect
-         style="fill:url(#linearGradient6287);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4294"
-         width="67.956474"
-         height="70.532257"
-         x="168.4333"
-         y="347.54932"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="178.53654"
-         y="405.72168"
-         id="text4296"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4298"
-           x="178.53654"
-           y="405.72168"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">D</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="f"
-       transform="matrix(0.23275892,0,0,0.23275892,288.35641,-44.778246)"
-       inkscape:label="#g4373">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="347.54932"
-         x="250.25566"
-         height="70.532257"
-         width="67.956474"
-         id="rect4302"
-         style="fill:url(#linearGradient6289);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4304"
-         y="405.72168"
-         x="263.53076"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="405.72168"
-           x="263.53076"
-           id="tspan4306"
-           sodipodi:role="line">F</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="g"
-       transform="matrix(0.23275892,0,0,0.23275892,288.56214,-44.778246)"
-       inkscape:label="#g4378">
-      <rect
-         style="fill:url(#linearGradient6291);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4310"
-         width="67.956474"
-         height="70.532257"
-         x="328.03741"
-         y="347.54932"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="337.42191"
-         y="405.72168"
-         id="text4312"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4314"
-           x="337.42191"
-           y="405.72168"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">G</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="h"
-       transform="matrix(0.23275892,0,0,0.23275892,289.003,-44.778246)"
-       inkscape:label="#g4383">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="347.54932"
-         x="404.80902"
-         height="70.532257"
-         width="67.956474"
-         id="rect4318"
-         style="fill:url(#linearGradient6293);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4320"
-         y="405.72168"
-         x="415.69351"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="405.72168"
-           x="415.69351"
-           id="tspan4322"
-           sodipodi:role="line">H</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="j"
-       transform="matrix(0.23275892,0,0,0.23275892,288.03312,-44.778246)"
-       inkscape:label="#g4388">
-      <rect
-         style="fill:url(#linearGradient6295);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4326"
-         width="67.956474"
-         height="70.532257"
-         x="487.64154"
-         y="347.54932"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="507.24478"
-         y="405.33105"
-         id="text4328"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4330"
-           x="507.24478"
-           y="405.33105"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">J</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="k"
-       transform="matrix(0.23275892,0,0,0.23275892,288.23886,-44.778246)"
-       inkscape:label="#g4393">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="347.54932"
-         x="565.42328"
-         height="70.532257"
-         width="67.956474"
-         id="rect4334"
-         style="fill:url(#linearGradient6297);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4336"
-         y="405.72168"
-         x="575.77649"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="405.72168"
-           x="575.77649"
-           id="tspan4338"
-           sodipodi:role="line">K</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="l"
-       transform="matrix(0.23275892,0,0,0.23275892,287.26898,-44.778246)"
-       inkscape:label="#g4398">
-      <rect
-         style="fill:url(#linearGradient6299);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4342"
-         width="67.956474"
-         height="70.532257"
-         x="648.2558"
-         y="347.54932"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="663.23401"
-         y="405.72168"
-         id="text4344"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4346"
-           x="663.23401"
-           y="405.72168"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">L</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="z"
-       inkscape:label="#g4482"
-       transform="matrix(0.23275892,0,0,0.23275892,289.14995,-44.778246)">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="433.41229"
-         x="10.849505"
-         height="70.532257"
-         width="67.956474"
-         id="rect4421"
-         style="fill:url(#linearGradient6301);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4423"
-         y="491.58466"
-         x="25.437119"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="491.58466"
-           x="25.437119"
-           id="tspan4425"
-           sodipodi:role="line">Z</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="x"
-       transform="matrix(0.23275892,0,0,0.23275892,289.14995,-44.778246)"
-       inkscape:label="#g4515">
-      <rect
-         style="fill:url(#linearGradient6303);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4434"
-         width="67.956474"
-         height="70.532257"
-         x="89.641403"
-         y="433.41229"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="102.33839"
-         y="491.58466"
-         id="text4436"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4438"
-           x="102.33839"
-           y="491.58466"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">X</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="c"
-       transform="matrix(0.23275892,0,0,0.23275892,289.38507,-44.778246)"
-       inkscape:label="#g4510">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="433.41229"
-         x="167.42316"
-         height="70.532257"
-         width="67.956474"
-         id="rect4442"
-         style="fill:url(#linearGradient6305);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4444"
-         y="491.58466"
-         x="177.9639"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="491.58466"
-           x="177.9639"
-           id="tspan4446"
-           sodipodi:role="line">C</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="v"
-       transform="matrix(0.23275892,0,0,0.23275892,289.38507,-44.778246)"
-       inkscape:label="#g4505">
-      <rect
-         style="fill:url(#linearGradient6307);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4450"
-         width="67.956474"
-         height="70.532257"
-         x="246.21506"
-         y="433.41229"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="258.95892"
-         y="491.58466"
-         id="text4452"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4454"
-           x="258.95892"
-           y="491.58466"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">V</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="b"
-       transform="matrix(0.23275892,0,0,0.23275892,287.73921,-44.778246)"
-       inkscape:label="#g4492">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="433.41229"
-         x="332.07803"
-         height="70.532257"
-         width="67.956474"
-         id="rect4458"
-         style="fill:url(#linearGradient6309);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4460"
-         y="491.58466"
-         x="344.0719"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="491.58466"
-           x="344.0719"
-           id="tspan4462"
-           sodipodi:role="line">B</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="n"
-       transform="matrix(0.23275892,0,0,0.23275892,287.03385,-44.778246)"
-       inkscape:label="#g4487">
-      <rect
-         style="fill:url(#linearGradient6311);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4466"
-         width="67.956474"
-         height="70.532257"
-         x="413.90039"
-         y="433.41229"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="424.95676"
-         y="491.58466"
-         id="text4468"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4470"
-           x="424.95676"
-           y="491.58466"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">N</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="m"
-       inkscape:label="#g5775"
-       transform="matrix(0.23275892,0,0,0.23275892,289.14995,-44.778246)">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="433.41229"
-         x="483.60089"
-         height="70.532257"
-         width="67.956474"
-         id="rect4474"
-         style="fill:url(#linearGradient6313);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4476"
-         y="491.58466"
-         x="490.96976"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="491.58466"
-           x="490.96976"
-           id="tspan4478"
-           sodipodi:role="line">M</tspan></text>
-    </g>
-    <rect
-       style="fill:url(#linearGradient6175);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:0.46551785;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-       id="rect4497"
-       width="88.60791"
-       height="16.417011"
-       x="328.11716"
-       y="75.852585"
-       rx="1.1637946"
-       ry="1.1637946"
-       inkscape:label="#rect2160" />
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="1"
-       inkscape:label="#g4707"
-       transform="matrix(0.23275892,0,0,0.23275892,289.14995,-44.778246)">
-      <rect
-         style="fill:url(#linearGradient6317);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4618"
-         width="67.956474"
-         height="70.532257"
-         x="10.849505"
-         y="177.40062"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="29.421494"
-         y="235.66675"
-         id="text4620"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4622"
-           x="29.421494"
-           y="235.66675"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">1</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="2"
-       transform="matrix(0.23275892,0,0,0.23275892,289.50094,-44.778246)"
-       inkscape:label="#g4712">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="177.40062"
-         x="87.992363"
-         height="70.532257"
-         width="67.956474"
-         id="rect4631"
-         style="fill:url(#linearGradient6319);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4633"
-         y="235.66675"
-         x="104.92372"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="235.66675"
-           x="104.92372"
-           id="tspan4635"
-           sodipodi:role="line">2</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="3"
-       transform="matrix(0.23275892,0,0,0.23275892,288.85438,-44.778246)"
-       inkscape:label="#g4717">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="177.40062"
-         x="169.42093"
-         height="70.532257"
-         width="67.956474"
-         id="rect4643"
-         style="fill:url(#linearGradient6321);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4645"
-         y="235.2605"
-         x="185.71167"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="235.2605"
-           x="185.71167"
-           id="tspan4647"
-           sodipodi:role="line">3</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="4"
-       transform="matrix(0.23275892,0,0,0.23275892,289.53789,-44.778246)"
-       inkscape:label="#g4722">
-      <rect
-         style="fill:url(#linearGradient6323);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4651"
-         width="67.956474"
-         height="70.532257"
-         x="245.13521"
-         y="177.40062"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="262.45718"
-         y="235.573"
-         id="text4653"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4655"
-           x="262.45718"
-           y="235.573"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">4</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="5"
-       transform="matrix(0.23275892,0,0,0.23275892,289.88887,-44.778246)"
-       inkscape:label="#g4727">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="177.40062"
-         x="322.27808"
-         height="70.532257"
-         width="67.956474"
-         id="rect4659"
-         style="fill:url(#linearGradient6325);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4661"
-         y="234.86987"
-         x="338.41257"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="234.86987"
-           x="338.41257"
-           id="tspan4663"
-           sodipodi:role="line">5</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="6"
-       transform="matrix(0.23275892,0,0,0.23275892,290.06038,-44.778246)"
-       inkscape:label="#g4776">
-      <rect
-         style="fill:url(#linearGradient6327);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4667"
-         width="67.956474"
-         height="70.532257"
-         x="400.19199"
-         y="177.40062"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="416.63898"
-         y="235.27612"
-         id="text4669"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4671"
-           x="416.63898"
-           y="235.27612"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">6</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="7"
-       transform="matrix(0.23275892,0,0,0.23275892,289.26079,-44.778246)"
-       inkscape:label="#g4732">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="177.40062"
-         x="482.27808"
-         height="70.532257"
-         width="67.956474"
-         id="rect4675"
-         style="fill:url(#linearGradient6329);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4677"
-         y="235.27612"
-         x="498.39694"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="235.27612"
-           x="498.39694"
-           id="tspan4679"
-           sodipodi:role="line">7</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="8"
-       transform="matrix(0.23275892,0,0,0.23275892,288.94675,-44.778246)"
-       inkscape:label="#g4737">
-      <rect
-         style="fill:url(#linearGradient6331);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4683"
-         width="67.956474"
-         height="70.532257"
-         x="562.27808"
-         y="177.40062"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="578.56879"
-         y="235.27612"
-         id="text4685"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4687"
-           x="578.56879"
-           y="235.27612"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">8</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="9"
-       transform="matrix(0.23275892,0,0,0.23275892,288.3002,-44.778246)"
-       inkscape:label="#g4750">
-      <rect
-         inkscape:label="#rect2160"
-         ry="5"
-         rx="5"
-         y="177.40062"
-         x="643.70667"
-         height="70.532257"
-         width="67.956474"
-         id="rect4691"
-         style="fill:url(#linearGradient6333);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <text
-         sodipodi:linespacing="100%"
-         id="text4693"
-         y="235.27612"
-         x="659.96613"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         xml:space="preserve"><tspan
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-           y="235.27612"
-           x="659.96613"
-           id="tspan4695"
-           sodipodi:role="line">9</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="0"
-       transform="matrix(0.23275892,0,0,0.23275892,287.32115,-44.778246)"
-       inkscape:label="#g4755">
-      <rect
-         style="fill:url(#linearGradient6335);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4699"
-         width="67.956474"
-         height="70.532257"
-         x="726.56378"
-         y="177.40062"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="742.94824"
-         y="235.27612"
-         id="text4701"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan4703"
-           x="742.94824"
-           y="235.27612"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">0</tspan></text>
-    </g>
-    <g
-       style="stroke:#570f0f;stroke-opacity:1"
-       id="enter"
-       transform="matrix(0.23275892,0,0,0.23275892,289.64872,-44.778246)"
-       inkscape:label="#g5780">
-      <rect
-         style="fill:url(#linearGradient6337);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:1.99999988;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect5762"
-         width="223.54247"
-         height="70.532257"
-         x="561.49011"
-         y="433.26514"
-         rx="5"
-         ry="5"
-         inkscape:label="#rect2160" />
-      <text
-         xml:space="preserve"
-         style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-         x="562.58948"
-         y="491.43753"
-         id="text5771"
-         sodipodi:linespacing="100%"><tspan
-           sodipodi:role="line"
-           id="tspan5773"
-           x="562.58948"
-           y="491.43753"
-           style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">ENTER</tspan></text>
-    </g>
-    <rect
-       style="fill:#000000;fill-opacity:1"
-       id="rect4235-4"
-       width="71.973373"
-       height="22.223358"
-       x="68.191956"
-       y="776.48932"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       style="fill:#008000;fill-opacity:1"
-       id="rect4235-4-9"
-       width="71.973373"
-       height="22.223358"
-       x="69.869621"
-       y="827.32819"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <rect
-       style="fill:#ff0000;fill-opacity:1"
-       id="rect4235-4-1"
-       width="71.973373"
-       height="22.223358"
-       x="71.869621"
-       y="879.32819"
-       inkscape:export-filename="/home/jtriley/Documents/path10411-0-4-9.png"
-       inkscape:export-xdpi="90"
-       inkscape:export-ydpi="90" />
-    <g
-       id="g6750"
-       transform="translate(-13.999977,0)">
-      <rect
-         style="fill:url(#linearGradient7058);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:0.46551785;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4783-9"
-         width="187.36421"
-         height="102.87033"
-         x="648.53088"
-         y="-4.665844"
-         rx="1.1637946"
-         ry="1.1637948"
-         inkscape:label="#rect2160" />
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,648.13515,-40.505934)"
-         inkscape:label="#g4203"
-         id="q-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7060);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="Q-2"
-           width="67.956474"
-           height="70.532257"
-           x="10.849505"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="19.733997"
-           y="318.48373"
-           id="text3142-1"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan3144-2"
-             x="19.733997"
-             y="318.48373"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">Q</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4208"
-         transform="matrix(0.23275892,0,0,0.23275892,648.10902,-40.505934)"
-         id="w-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="89.641403"
-           height="70.532257"
-           width="67.956474"
-           id="rect4115-7"
-           style="fill:url(#linearGradient7062);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4117-3"
-           y="319.85873"
-           x="93.385269"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.85873"
-             x="93.385269"
-             id="tspan4119-1"
-             sodipodi:role="line">W</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4213"
-         transform="matrix(0.23275892,0,0,0.23275892,648.0829,-40.505934)"
-         id="e-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="168.4333"
-           height="70.532257"
-           width="67.956474"
-           id="rect4123-9"
-           style="fill:url(#linearGradient7064);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4125-0"
-           y="319.8587"
-           x="180.25529"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="180.25529"
-             id="tspan4127-5"
-             sodipodi:role="line">E</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4218"
-         transform="matrix(0.23275892,0,0,0.23275892,647.82165,-40.505934)"
-         id="r-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="248.23535"
-           height="70.532257"
-           width="67.956474"
-           id="rect4131-7"
-           style="fill:url(#linearGradient7066);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4133-7"
-           y="319.8587"
-           x="256.99484"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="256.99484"
-             id="tspan4135-4"
-             sodipodi:role="line">R</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4223"
-         transform="matrix(0.23275892,0,0,0.23275892,648.50089,-40.505934)"
-         id="t-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7068);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4139-6"
-           width="67.956474"
-           height="70.532257"
-           x="323.9968"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="338.31879"
-           y="319.8587"
-           id="text4141-4"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4143-7"
-             x="338.31879"
-             y="319.8587"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">T</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4228"
-         transform="matrix(0.23275892,0,0,0.23275892,647.7694,-40.505934)"
-         id="y-4"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="405.81915"
-           height="70.532257"
-           width="67.956474"
-           id="rect4147-8"
-           style="fill:url(#linearGradient7070);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4149-5"
-           y="319.8587"
-           x="418.60989"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="418.60989"
-             id="tspan4151-8"
-             sodipodi:role="line">Y</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4233"
-         transform="matrix(0.23275892,0,0,0.23275892,647.50815,-40.505934)"
-         id="u-2"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7072);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4155-6"
-           width="67.956474"
-           height="70.532257"
-           x="485.62122"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="496.55258"
-           y="319.46808"
-           id="text4157-0"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4159-6"
-             x="496.55258"
-             y="319.46808"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">U</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4238"
-         transform="matrix(0.23275892,0,0,0.23275892,647.48203,-40.505934)"
-         id="i-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="564.41309"
-           height="70.532257"
-           width="67.956474"
-           id="rect4163-4"
-           style="fill:url(#linearGradient7074);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4165-6"
-           y="319.8587"
-           x="589.3913"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="589.3913"
-             id="tspan4167-2"
-             sodipodi:role="line">I</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4243"
-         transform="matrix(0.23275892,0,0,0.23275892,647.4559,-40.505934)"
-         id="o-8"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7076);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4171-9"
-           width="67.956474"
-           height="70.532257"
-           x="643.20496"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="652.18317"
-           y="319.87433"
-           id="text4173-6"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4175-0"
-             x="652.18317"
-             y="319.87433"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">O</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4248"
-         transform="matrix(0.23275892,0,0,0.23275892,648.13514,-40.505934)"
-         id="p-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="718.96637"
-           height="70.532257"
-           width="67.956474"
-           id="rect4179-0"
-           style="fill:url(#linearGradient7078);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4181-1"
-           y="319.8587"
-           x="730.52271"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="730.52271"
-             id="tspan4183-0"
-             sodipodi:role="line">P</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,648.13515,-40.505934)"
-         inkscape:label="#g4358"
-         id="a-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="10.849505"
-           height="70.532257"
-           width="67.956474"
-           id="rect4273-3"
-           style="fill:url(#linearGradient7080);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4275-7"
-           y="405.72168"
-           x="23.483994"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="23.483994"
-             id="tspan4277-7"
-             sodipodi:role="line">A</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4363"
-         transform="matrix(0.23275892,0,0,0.23275892,648.10576,-40.505934)"
-         id="s-2"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7082);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4286-6"
-           width="67.956474"
-           height="70.532257"
-           x="89.641403"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="102.51027"
-           y="405.72168"
-           id="text4288-4"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4290-5"
-             x="102.51027"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">S</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4368"
-         transform="matrix(0.23275892,0,0,0.23275892,648.07637,-40.505934)"
-         id="d-2"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="168.4333"
-           height="70.532257"
-           width="67.956474"
-           id="rect4294-0"
-           style="fill:url(#linearGradient7084);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4296-2"
-           y="405.72168"
-           x="178.53654"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="178.53654"
-             id="tspan4298-9"
-             sodipodi:role="line">D</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4373"
-         transform="matrix(0.23275892,0,0,0.23275892,647.34161,-40.505934)"
-         id="f-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7086);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4302-9"
-           width="67.956474"
-           height="70.532257"
-           x="250.25566"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="263.53076"
-           y="405.72168"
-           id="text4304-9"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4306-4"
-             x="263.53076"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">F</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4378"
-         transform="matrix(0.23275892,0,0,0.23275892,647.54734,-40.505934)"
-         id="g-5"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="328.03741"
-           height="70.532257"
-           width="67.956474"
-           id="rect4310-1"
-           style="fill:url(#linearGradient7088);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4312-0"
-           y="405.72168"
-           x="337.42191"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="337.42191"
-             id="tspan4314-3"
-             sodipodi:role="line">G</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4383"
-         transform="matrix(0.23275892,0,0,0.23275892,647.9882,-40.505934)"
-         id="h-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7090);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4318-8"
-           width="67.956474"
-           height="70.532257"
-           x="404.80902"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="415.69351"
-           y="405.72168"
-           id="text4320-8"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4322-6"
-             x="415.69351"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">H</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4388"
-         transform="matrix(0.23275892,0,0,0.23275892,647.01832,-40.505934)"
-         id="j-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="487.64154"
-           height="70.532257"
-           width="67.956474"
-           id="rect4326-4"
-           style="fill:url(#linearGradient7092);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4328-6"
-           y="405.33105"
-           x="507.24478"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.33105"
-             x="507.24478"
-             id="tspan4330-7"
-             sodipodi:role="line">J</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4393"
-         transform="matrix(0.23275892,0,0,0.23275892,647.22406,-40.505934)"
-         id="k-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7094);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4334-0"
-           width="67.956474"
-           height="70.532257"
-           x="565.42328"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="575.77649"
-           y="405.72168"
-           id="text4336-9"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4338-7"
-             x="575.77649"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">K</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4398"
-         transform="matrix(0.23275892,0,0,0.23275892,646.25418,-40.505934)"
-         id="l-5"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="648.2558"
-           height="70.532257"
-           width="67.956474"
-           id="rect4342-9"
-           style="fill:url(#linearGradient7096);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4344-7"
-           y="405.72168"
-           x="663.23401"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="663.23401"
-             id="tspan4346-8"
-             sodipodi:role="line">L</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,648.13515,-40.505934)"
-         inkscape:label="#g4482"
-         id="z-5"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7098);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4421-3"
-           width="67.956474"
-           height="70.532257"
-           x="10.849505"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="25.437119"
-           y="491.58466"
-           id="text4423-3"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4425-8"
-             x="25.437119"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">Z</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4515"
-         transform="matrix(0.23275892,0,0,0.23275892,648.13515,-40.505934)"
-         id="x-3"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.41229"
-           x="89.641403"
-           height="70.532257"
-           width="67.956474"
-           id="rect4434-7"
-           style="fill:url(#linearGradient7100);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4436-9"
-           y="491.58466"
-           x="102.33839"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.58466"
-             x="102.33839"
-             id="tspan4438-3"
-             sodipodi:role="line">X</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4510"
-         transform="matrix(0.23275892,0,0,0.23275892,648.37027,-40.505934)"
-         id="c-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7102);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4442-8"
-           width="67.956474"
-           height="70.532257"
-           x="167.42316"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="177.9639"
-           y="491.58466"
-           id="text4444-7"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4446-4"
-             x="177.9639"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">C</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4505"
-         transform="matrix(0.23275892,0,0,0.23275892,648.37027,-40.505934)"
-         id="v-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.41229"
-           x="246.21506"
-           height="70.532257"
-           width="67.956474"
-           id="rect4450-9"
-           style="fill:url(#linearGradient7104);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4452-0"
-           y="491.58466"
-           x="258.95892"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.58466"
-             x="258.95892"
-             id="tspan4454-9"
-             sodipodi:role="line">V</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4492"
-         transform="matrix(0.23275892,0,0,0.23275892,646.72441,-40.505934)"
-         id="b-8"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7106);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4458-8"
-           width="67.956474"
-           height="70.532257"
-           x="332.07803"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="344.0719"
-           y="491.58466"
-           id="text4460-5"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4462-8"
-             x="344.0719"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">B</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4487"
-         transform="matrix(0.23275892,0,0,0.23275892,646.01905,-40.505934)"
-         id="n-4"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.41229"
-           x="413.90039"
-           height="70.532257"
-           width="67.956474"
-           id="rect4466-3"
-           style="fill:url(#linearGradient7108);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4468-7"
-           y="491.58466"
-           x="424.95676"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.58466"
-             x="424.95676"
-             id="tspan4470-1"
-             sodipodi:role="line">N</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,648.13515,-40.505934)"
-         inkscape:label="#g5775"
-         id="m-3"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7110);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4474-8"
-           width="67.956474"
-           height="70.532257"
-           x="483.60089"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="490.96976"
-           y="491.58466"
-           id="text4476-0"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4478-9"
-             x="490.96976"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">M</tspan></text>
-      </g>
-      <rect
-         inkscape:label="#rect2160"
-         ry="1.1637946"
-         rx="1.1637946"
-         y="80.124893"
-         x="687.10236"
-         height="16.417011"
-         width="88.60791"
-         id="rect4497-7"
-         style="fill:url(#linearGradient7112);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:0.46551785;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,648.13515,-40.505934)"
-         inkscape:label="#g4707"
-         id="1-9"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="10.849505"
-           height="70.532257"
-           width="67.956474"
-           id="rect4618-9"
-           style="fill:url(#linearGradient7114);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4620-3"
-           y="235.66675"
-           x="29.421494"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.66675"
-             x="29.421494"
-             id="tspan4622-2"
-             sodipodi:role="line">1</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4712"
-         transform="matrix(0.23275892,0,0,0.23275892,648.48614,-40.505934)"
-         id="2-4"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7116);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4631-3"
-           width="67.956474"
-           height="70.532257"
-           x="87.992363"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="104.92372"
-           y="235.66675"
-           id="text4633-7"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4635-1"
-             x="104.92372"
-             y="235.66675"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">2</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4717"
-         transform="matrix(0.23275892,0,0,0.23275892,647.83958,-40.505934)"
-         id="3-2"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7118);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4643-2"
-           width="67.956474"
-           height="70.532257"
-           x="169.42093"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="185.71167"
-           y="235.2605"
-           id="text4645-0"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4647-2"
-             x="185.71167"
-             y="235.2605"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">3</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4722"
-         transform="matrix(0.23275892,0,0,0.23275892,648.52309,-40.505934)"
-         id="4-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="245.13521"
-           height="70.532257"
-           width="67.956474"
-           id="rect4651-7"
-           style="fill:url(#linearGradient7120);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4653-5"
-           y="235.573"
-           x="262.45718"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.573"
-             x="262.45718"
-             id="tspan4655-1"
-             sodipodi:role="line">4</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4727"
-         transform="matrix(0.23275892,0,0,0.23275892,648.87407,-40.505934)"
-         id="5-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7122);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4659-4"
-           width="67.956474"
-           height="70.532257"
-           x="322.27808"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="338.41257"
-           y="234.86987"
-           id="text4661-1"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4663-7"
-             x="338.41257"
-             y="234.86987"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">5</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4776"
-         transform="matrix(0.23275892,0,0,0.23275892,649.04558,-40.505934)"
-         id="6-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="400.19199"
-           height="70.532257"
-           width="67.956474"
-           id="rect4667-1"
-           style="fill:url(#linearGradient7124);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4669-1"
-           y="235.27612"
-           x="416.63898"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.27612"
-             x="416.63898"
-             id="tspan4671-7"
-             sodipodi:role="line">6</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4732"
-         transform="matrix(0.23275892,0,0,0.23275892,648.24599,-40.505934)"
-         id="7-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7126);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4675-4"
-           width="67.956474"
-           height="70.532257"
-           x="482.27808"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="498.39694"
-           y="235.27612"
-           id="text4677-0"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4679-8"
-             x="498.39694"
-             y="235.27612"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">7</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4737"
-         transform="matrix(0.23275892,0,0,0.23275892,647.93195,-40.505934)"
-         id="8-5"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="562.27808"
-           height="70.532257"
-           width="67.956474"
-           id="rect4683-1"
-           style="fill:url(#linearGradient7128);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4685-6"
-           y="235.27612"
-           x="578.56879"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.27612"
-             x="578.56879"
-             id="tspan4687-6"
-             sodipodi:role="line">8</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4750"
-         transform="matrix(0.23275892,0,0,0.23275892,647.2854,-40.505934)"
-         id="9-2"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient7130);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4691-1"
-           width="67.956474"
-           height="70.532257"
-           x="643.70667"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="659.96613"
-           y="235.27612"
-           id="text4693-9"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4695-6"
-             x="659.96613"
-             y="235.27612"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">9</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4755"
-         transform="matrix(0.23275892,0,0,0.23275892,646.30635,-40.505934)"
-         id="0-4"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="726.56378"
-           height="70.532257"
-           width="67.956474"
-           id="rect4699-8"
-           style="fill:url(#linearGradient7132);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4701-0"
-           y="235.27612"
-           x="742.94824"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.27612"
-             x="742.94824"
-             id="tspan4703-8"
-             sodipodi:role="line">0</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g5780"
-         transform="matrix(0.23275892,0,0,0.23275892,648.63392,-40.505934)"
-         id="enter-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.26514"
-           x="561.49011"
-           height="70.532257"
-           width="223.54247"
-           id="rect5762-0"
-           style="fill:url(#linearGradient7134);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:1.99999988;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text5771-2"
-           y="491.43753"
-           x="562.58948"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.43753"
-             x="562.58948"
-             id="tspan5773-2"
-             sodipodi:role="line">ENTER</tspan></text>
-      </g>
-    </g>
-    <g
-       id="g4874">
-      <rect
-         style="fill:url(#linearGradient5040);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:0.46551785;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-         id="rect4783-8"
-         width="187.36421"
-         height="102.87033"
-         x="-56.464729"
-         y="-4.978344"
-         rx="1.1637946"
-         ry="1.1637948"
-         inkscape:label="#rect2160" />
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,-59.50672,-40.818434)"
-         inkscape:label="#g4203"
-         id="q-67"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6263-6);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="Q-0"
-           width="67.956474"
-           height="70.532257"
-           x="10.849505"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="19.733997"
-           y="318.48373"
-           id="text3142-4"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan3144-8"
-             x="19.733997"
-             y="318.48373"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">Q</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4208"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.53285,-40.818434)"
-         id="w-4"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="89.641403"
-           height="70.532257"
-           width="67.956474"
-           id="rect4115-8"
-           style="fill:url(#linearGradient6265-3);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4117-1"
-           y="319.85873"
-           x="93.385269"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.85873"
-             x="93.385269"
-             id="tspan4119-6"
-             sodipodi:role="line">W</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4213"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.55897,-40.818434)"
-         id="e-8"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="168.4333"
-           height="70.532257"
-           width="67.956474"
-           id="rect4123-5"
-           style="fill:url(#linearGradient6267-5);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4125-2"
-           y="319.8587"
-           x="180.25529"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="180.25529"
-             id="tspan4127-1"
-             sodipodi:role="line">E</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4218"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.82022,-40.818434)"
-         id="r-9"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="248.23535"
-           height="70.532257"
-           width="67.956474"
-           id="rect4131-9"
-           style="fill:url(#linearGradient6269-5);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4133-6"
-           y="319.8587"
-           x="256.99484"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="256.99484"
-             id="tspan4135-0"
-             sodipodi:role="line">R</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4223"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.14098,-40.818434)"
-         id="t-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6271-3);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4139-4"
-           width="67.956474"
-           height="70.532257"
-           x="323.9968"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="338.31879"
-           y="319.8587"
-           id="text4141-9"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4143-9"
-             x="338.31879"
-             y="319.8587"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">T</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4228"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.87247,-40.818434)"
-         id="y-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="405.81915"
-           height="70.532257"
-           width="67.956474"
-           id="rect4147-89"
-           style="fill:url(#linearGradient6273-2);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4149-3"
-           y="319.8587"
-           x="418.60989"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="418.60989"
-             id="tspan4151-1"
-             sodipodi:role="line">Y</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4233"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.13372,-40.818434)"
-         id="u-4"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6275-3);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4155-8"
-           width="67.956474"
-           height="70.532257"
-           x="485.62122"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="496.55258"
-           y="319.46808"
-           id="text4157-9"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4159-67"
-             x="496.55258"
-             y="319.46808"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">U</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4238"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.15984,-40.818434)"
-         id="i-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="564.41309"
-           height="70.532257"
-           width="67.956474"
-           id="rect4163-3"
-           style="fill:url(#linearGradient6277-6);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4165-7"
-           y="319.8587"
-           x="589.3913"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="589.3913"
-             id="tspan4167-1"
-             sodipodi:role="line">I</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4243"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.18597,-40.818434)"
-         id="o-2"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6279-4);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4171-2"
-           width="67.956474"
-           height="70.532257"
-           x="643.20496"
-           y="261.68634"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="652.18317"
-           y="319.87433"
-           id="text4173-1"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4175-5"
-             x="652.18317"
-             y="319.87433"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">O</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4248"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.50673,-40.818434)"
-         id="p-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="261.68634"
-           x="718.96637"
-           height="70.532257"
-           width="67.956474"
-           id="rect4179-9"
-           style="fill:url(#linearGradient6281-2);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4181-0"
-           y="319.8587"
-           x="730.52271"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="319.8587"
-             x="730.52271"
-             id="tspan4183-4"
-             sodipodi:role="line">P</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,-59.50672,-40.818434)"
-         inkscape:label="#g4358"
-         id="a-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="10.849505"
-           height="70.532257"
-           width="67.956474"
-           id="rect4273-1"
-           style="fill:url(#linearGradient6283-0);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4275-3"
-           y="405.72168"
-           x="23.483994"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="23.483994"
-             id="tspan4277-74"
-             sodipodi:role="line">A</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4363"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.53611,-40.818434)"
-         id="s-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6285-6);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4286-1"
-           width="67.956474"
-           height="70.532257"
-           x="89.641403"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="102.51027"
-           y="405.72168"
-           id="text4288-3"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4290-0"
-             x="102.51027"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">S</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4368"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.5655,-40.818434)"
-         id="d-3"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="168.4333"
-           height="70.532257"
-           width="67.956474"
-           id="rect4294-2"
-           style="fill:url(#linearGradient6287-3);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4296-1"
-           y="405.72168"
-           x="178.53654"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="178.53654"
-             id="tspan4298-7"
-             sodipodi:role="line">D</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4373"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.30026,-40.818434)"
-         id="f-5"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6289-51);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4302-6"
-           width="67.956474"
-           height="70.532257"
-           x="250.25566"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="263.53076"
-           y="405.72168"
-           id="text4304-5"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4306-42"
-             x="263.53076"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">F</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4378"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.09453,-40.818434)"
-         id="g-2"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="328.03741"
-           height="70.532257"
-           width="67.956474"
-           id="rect4310-17"
-           style="fill:url(#linearGradient6291-6);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4312-2"
-           y="405.72168"
-           x="337.42191"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="337.42191"
-             id="tspan4314-4"
-             sodipodi:role="line">G</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4383"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.65367,-40.818434)"
-         id="h-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6293-8);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4318-6"
-           width="67.956474"
-           height="70.532257"
-           x="404.80902"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="415.69351"
-           y="405.72168"
-           id="text4320-5"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4322-7"
-             x="415.69351"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">H</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4388"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.62355,-40.818434)"
-         id="j-8"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="487.64154"
-           height="70.532257"
-           width="67.956474"
-           id="rect4326-5"
-           style="fill:url(#linearGradient6295-1);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4328-9"
-           y="405.33105"
-           x="507.24478"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.33105"
-             x="507.24478"
-             id="tspan4330-2"
-             sodipodi:role="line">J</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4393"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.41781,-40.818434)"
-         id="k-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6297-3);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4334-3"
-           width="67.956474"
-           height="70.532257"
-           x="565.42328"
-           y="347.54932"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="575.77649"
-           y="405.72168"
-           id="text4336-6"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4338-4"
-             x="575.77649"
-             y="405.72168"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">K</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4398"
-         transform="matrix(0.23275892,0,0,0.23275892,-61.38769,-40.818434)"
-         id="l-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="347.54932"
-           x="648.2558"
-           height="70.532257"
-           width="67.956474"
-           id="rect4342-97"
-           style="fill:url(#linearGradient6299-0);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4344-2"
-           y="405.72168"
-           x="663.23401"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="405.72168"
-             x="663.23401"
-             id="tspan4346-2"
-             sodipodi:role="line">L</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,-59.50672,-40.818434)"
-         inkscape:label="#g4482"
-         id="z-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6301-6);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4421-6"
-           width="67.956474"
-           height="70.532257"
-           x="10.849505"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="25.437119"
-           y="491.58466"
-           id="text4423-30"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4425-2"
-             x="25.437119"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">Z</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4515"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.50672,-40.818434)"
-         id="x-1"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.41229"
-           x="89.641403"
-           height="70.532257"
-           width="67.956474"
-           id="rect4434-5"
-           style="fill:url(#linearGradient6303-0);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4436-6"
-           y="491.58466"
-           x="102.33839"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.58466"
-             x="102.33839"
-             id="tspan4438-5"
-             sodipodi:role="line">X</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4510"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.2716,-40.818434)"
-         id="c-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6305-7);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4442-0"
-           width="67.956474"
-           height="70.532257"
-           x="167.42316"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="177.9639"
-           y="491.58466"
-           id="text4444-3"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4446-46"
-             x="177.9639"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">C</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4505"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.2716,-40.818434)"
-         id="v-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.41229"
-           x="246.21506"
-           height="70.532257"
-           width="67.956474"
-           id="rect4450-0"
-           style="fill:url(#linearGradient6307-0);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4452-2"
-           y="491.58466"
-           x="258.95892"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.58466"
-             x="258.95892"
-             id="tspan4454-5"
-             sodipodi:role="line">V</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4492"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.91746,-40.818434)"
-         id="b-89"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6309-8);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4458-5"
-           width="67.956474"
-           height="70.532257"
-           x="332.07803"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="344.0719"
-           y="491.58466"
-           id="text4460-0"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4462-6"
-             x="344.0719"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">B</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4487"
-         transform="matrix(0.23275892,0,0,0.23275892,-61.62282,-40.818434)"
-         id="n-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.41229"
-           x="413.90039"
-           height="70.532257"
-           width="67.956474"
-           id="rect4466-8"
-           style="fill:url(#linearGradient6311-6);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4468-3"
-           y="491.58466"
-           x="424.95676"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.58466"
-             x="424.95676"
-             id="tspan4470-7"
-             sodipodi:role="line">N</tspan></text>
-      </g>
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,-59.50672,-40.818434)"
-         inkscape:label="#g5775"
-         id="m-8"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6313-4);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4474-2"
-           width="67.956474"
-           height="70.532257"
-           x="483.60089"
-           y="433.41229"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="490.96976"
-           y="491.58466"
-           id="text4476-1"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4478-0"
-             x="490.96976"
-             y="491.58466"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">M</tspan></text>
-      </g>
-      <rect
-         inkscape:label="#rect2160"
-         ry="1.1637946"
-         rx="1.1637946"
-         y="79.812393"
-         x="-20.539513"
-         height="16.417011"
-         width="88.60791"
-         id="rect4497-5"
-         style="fill:url(#linearGradient4933);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:0.46551785;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-      <g
-         transform="matrix(0.23275892,0,0,0.23275892,-59.50672,-40.818434)"
-         inkscape:label="#g4707"
-         id="1-8"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="10.849505"
-           height="70.532257"
-           width="67.956474"
-           id="rect4618-5"
-           style="fill:url(#linearGradient6317-0);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4620-5"
-           y="235.66675"
-           x="29.421494"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.66675"
-             x="29.421494"
-             id="tspan4622-0"
-             sodipodi:role="line">1</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4712"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.15573,-40.818434)"
-         id="2-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6319-0);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4631-38"
-           width="67.956474"
-           height="70.532257"
-           x="87.992363"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="104.92372"
-           y="235.66675"
-           id="text4633-2"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4635-3"
-             x="104.92372"
-             y="235.66675"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">2</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4717"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.80229,-40.818434)"
-         id="3-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6321-2);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4643-7"
-           width="67.956474"
-           height="70.532257"
-           x="169.42093"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="185.71167"
-           y="235.2605"
-           id="text4645-7"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4647-7"
-             x="185.71167"
-             y="235.2605"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">3</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4722"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.11878,-40.818434)"
-         id="4-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="245.13521"
-           height="70.532257"
-           width="67.956474"
-           id="rect4651-9"
-           style="fill:url(#linearGradient6323-5);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4653-1"
-           y="235.573"
-           x="262.45718"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.573"
-             x="262.45718"
-             id="tspan4655-19"
-             sodipodi:role="line">4</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4727"
-         transform="matrix(0.23275892,0,0,0.23275892,-58.7678,-40.818434)"
-         id="5-0"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6325-3);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4659-8"
-           width="67.956474"
-           height="70.532257"
-           x="322.27808"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="338.41257"
-           y="234.86987"
-           id="text4661-9"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4663-8"
-             x="338.41257"
-             y="234.86987"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">5</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4776"
-         transform="matrix(0.23275892,0,0,0.23275892,-58.59629,-40.818434)"
-         id="6-8"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="400.19199"
-           height="70.532257"
-           width="67.956474"
-           id="rect4667-0"
-           style="fill:url(#linearGradient6327-8);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4669-3"
-           y="235.27612"
-           x="416.63898"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.27612"
-             x="416.63898"
-             id="tspan4671-70"
-             sodipodi:role="line">6</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4732"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.39588,-40.818434)"
-         id="7-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6329-31);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4675-9"
-           width="67.956474"
-           height="70.532257"
-           x="482.27808"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="498.39694"
-           y="235.27612"
-           id="text4677-2"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4679-1"
-             x="498.39694"
-             y="235.27612"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">7</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4737"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.70992,-40.818434)"
-         id="8-7"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="562.27808"
-           height="70.532257"
-           width="67.956474"
-           id="rect4683-7"
-           style="fill:url(#linearGradient6331-2);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4685-9"
-           y="235.27612"
-           x="578.56879"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.27612"
-             x="578.56879"
-             id="tspan4687-7"
-             sodipodi:role="line">8</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4750"
-         transform="matrix(0.23275892,0,0,0.23275892,-60.35647,-40.818434)"
-         id="9-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           style="fill:url(#linearGradient6333-1);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0"
-           id="rect4691-2"
-           width="67.956474"
-           height="70.532257"
-           x="643.70667"
-           y="177.40062"
-           rx="5"
-           ry="5"
-           inkscape:label="#rect2160" />
-        <text
-           xml:space="preserve"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           x="659.96613"
-           y="235.27612"
-           id="text4693-7"
-           sodipodi:linespacing="100%"><tspan
-             sodipodi:role="line"
-             id="tspan4695-1"
-             x="659.96613"
-             y="235.27612"
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial">9</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g4755"
-         transform="matrix(0.23275892,0,0,0.23275892,-61.33552,-40.818434)"
-         id="0-5"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="177.40062"
-           x="726.56378"
-           height="70.532257"
-           width="67.956474"
-           id="rect4699-88"
-           style="fill:url(#linearGradient6335-1);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:2;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text4701-4"
-           y="235.27612"
-           x="742.94824"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="235.27612"
-             x="742.94824"
-             id="tspan4703-5"
-             sodipodi:role="line">0</tspan></text>
-      </g>
-      <g
-         inkscape:label="#g5780"
-         transform="matrix(0.23275892,0,0,0.23275892,-59.00795,-40.818434)"
-         id="enter-6"
-         style="stroke:#570f0f;stroke-opacity:1">
-        <rect
-           inkscape:label="#rect2160"
-           ry="5"
-           rx="5"
-           y="433.26514"
-           x="561.49011"
-           height="70.532257"
-           width="223.54247"
-           id="rect5762-5"
-           style="fill:url(#linearGradient6337-1);fill-opacity:1;fill-rule:nonzero;stroke:#570f0f;stroke-width:1.99999988;stroke-linecap:square;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;stroke-dashoffset:0" />
-        <text
-           sodipodi:linespacing="100%"
-           id="text5771-6"
-           y="491.43753"
-           x="562.58948"
-           style="font-size:24px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:#570f0f;stroke-opacity:1;font-family:Zekton"
-           xml:space="preserve"><tspan
-             style="font-size:64px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:100%;writing-mode:lr-tb;text-anchor:start;stroke:#570f0f;stroke-opacity:1;font-family:Arial"
-             y="491.43753"
-             x="562.58948"
-             id="tspan5773-8"
-             sodipodi:role="line">ENTER</tspan></text>
-      </g>
-    </g>
-    <path
-       style="fill:none;stroke:#4cea15;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"
-       d="m 372.5284,92.269596 0.68494,52.404204"
-       id="path6285"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#rect4497"
-       inkscape:connection-end="#rect3695" />
-    <path
-       style="fill:none;stroke:#07ff00;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
-       d="m 728.98863,98.204487 0.69887,46.345193"
-       id="path7136"
-       inkscape:connector-type="polyline"
-       inkscape:connection-start="#g6750" />
-    <path
-       style="fill:none;stroke:#06ff00;stroke-width:8;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none"
-       d="m 37.066258,97.891987 0.09752,46.781813"
-       id="path5028"
-       inkscape:connector-type="polyline"
-       inkscape:connection-end="#rect3695-4-1"
-       inkscape:connection-start="#g4874" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:3.20000005;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#Arrow1Send-9);marker-mid:none;marker-end:url(#Arrow1Mend)"
-       d="m 97.76109,405.78583 c 49.81163,34.41382 20.9084,50.49106 -23.630766,17.69543"
-       id="path7783"
-       sodipodi:nodetypes="cc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:3.20000005;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#Arrow1Send-9);marker-mid:none;marker-end:url(#Arrow1Mend)"
-       d="m 312.09795,404.48277 c 20.4602,56.98148 -12.3994,53.22371 -29.51521,0.6277"
-       id="path7783-6"
-       sodipodi:nodetypes="cc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:3.20000005;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#Arrow1Send-9);marker-mid:none;marker-end:url(#Arrow1Mend)"
-       d="m 352.24273,416.35623 c 50.54054,-33.33409 54.64651,-0.51617 7.57791,28.53274"
-       id="path7783-6-0"
-       sodipodi:nodetypes="cc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:3.20000005;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#Arrow1Send-9);marker-mid:none;marker-end:url(#Arrow1Mend)"
-       d="m 586.4612,429.62887 c -44.53641,41.01239 -53.8555,9.27868 -12.05841,-26.94693"
-       id="path7783-6-7"
-       sodipodi:nodetypes="cc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:3.20000005;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none;marker-start:url(#Arrow1Send-9);marker-mid:none;marker-end:url(#Arrow1Mend)"
-       d="m 109.00517,932.32503 c 49.81163,34.41382 20.9084,50.49106 -23.630766,17.69543"
-       id="path7783-2"
-       sodipodi:nodetypes="cc" />
-  </g>
-</svg>
diff --git a/docs/source/development/gitwash/branch_list.png b/docs/source/development/gitwash/branch_list.png
deleted file mode 100644
index 1196eb754d3..00000000000
Binary files a/docs/source/development/gitwash/branch_list.png and /dev/null differ
diff --git a/docs/source/development/gitwash/branch_list_compare.png b/docs/source/development/gitwash/branch_list_compare.png
deleted file mode 100644
index 336afa37460..00000000000
Binary files a/docs/source/development/gitwash/branch_list_compare.png and /dev/null differ
diff --git a/docs/source/development/gitwash/configure_git.txt b/docs/source/development/gitwash/configure_git.txt
deleted file mode 100644
index 260898dbf29..00000000000
--- a/docs/source/development/gitwash/configure_git.txt
+++ /dev/null
@@ -1,89 +0,0 @@
-.. _configure-git:
-
-===============
- Configure git
-===============
-
-.. _git-config-basic:
-
-Overview
-========
-
-::
-
-  git config --global user.email you@yourdomain.example.com
-  git config --global user.name "Your Name Comes Here"
-
-
-In detail
-=========
-
-This is to tell git_ who you are, for labeling any changes you make to
-the code.  The simplest way to do this is from the command line::
-
-  git config --global user.email you@yourdomain.example.com
-  git config --global user.name "Your Name Comes Here"
-
-This will write the settings into your git configuration file - a file
-called ``.gitconfig`` in your home directory. 
-
-Advanced git configuration
-==========================
-
-You might well benefit from some aliases to common commands.
-
-For example, you might well want to be able to shorten ``git checkout`` to ``git co``. 
-
-The easiest way to do this, is to create a ``.gitconfig`` file in your
-home directory, with contents like this::
-
-  [core]
-          editor = emacs
-  [user]
-          email = you@yourdomain.example.com
-          name = Your Name Comes Here
-  [alias]
-          st = status
-          stat = status
-          co = checkout
-  [color]
-          diff = auto
-          status = true
-
-(of course you'll need to set your email and name, and may want to set
-your editor).  If you prefer, you can do the same thing from the command
-line::
-
-  git config --global core.editor emacs
-  git config --global user.email you@yourdomain.example.com
-  git config --global user.name "Your Name Comes Here"
-  git config --global alias.st status
-  git config --global alias.stat status
-  git config --global alias.co checkout
-  git config --global color.diff auto
-  git config --global color.status true
-
-These commands will write to your user's git configuration file
-``~/.gitconfig``.
-
-To set up on another computer, you can copy your ``~/.gitconfig`` file,
-or run the commands above.
-
-Other configuration recommended by Yarik
-========================================
-
-In your ``~/.gitconfig`` file alias section::
-
-   wdiff = diff --color-words
-
-so that ``git wdiff`` gives a nicely formatted output of the diff. 
-
-To enforce summaries when doing merges(``~/.gitconfig`` file again)::
-
-   [merge]
-      summary = true
-
-
-.. include:: git_links.txt
-
-
diff --git a/docs/source/development/gitwash/development_workflow.txt b/docs/source/development/gitwash/development_workflow.txt
deleted file mode 100644
index b66c710bb91..00000000000
--- a/docs/source/development/gitwash/development_workflow.txt
+++ /dev/null
@@ -1,233 +0,0 @@
-.. _development-workflow:
-
-====================
-Development workflow
-====================
-
-You already have your own forked copy of the ipython_ repository, by
-following :ref:`forking`, :ref:`set-up-fork`, and you have configured
-git_ by following :ref:`configure-git`.
-
-Workflow summary
-================
-
-* Keep your ``master`` branch clean of edits that have not been merged
-  to the main ipython_ development repo.  Your ``master`` then will follow
-  the main ipython_ repository.
-* Start a new *feature branch* for each set of edits that you do.
-* If you can avoid it, try not to merge other branches into your feature
-  branch while you are working.
-* Ask for review!
-
-This way of working really helps to keep work well organized, and in
-keeping history as clear as possible.
-
-See - for example - `linux git workflow`_. 
-
-Making a new feature branch
-===========================
-
-::
-
-   git branch my-new-feature
-   git checkout my-new-feature
-
-Generally, you will want to keep this also on your public github_ fork
-of ipython_.  To do this, you `git push`_ this new branch up to your github_
-repo.  Generally (if you followed the instructions in these pages, and
-by default), git will have a link to your github_ repo, called
-``origin``.  You push up to your own repo on github_ with::
-
-   git push origin my-new-feature
-
-From now on git_ will know that ``my-new-feature`` is related to the
-``my-new-feature`` branch in the github_ repo.
-
-The editing workflow
-====================
-
-Overview
---------
-
-::
-
-   # hack hack
-   git add my_new_file
-   git commit -am 'NF - some message'
-   git push
-
-In more detail
---------------
-
-#. Make some changes
-#. See which files have changed with ``git status`` (see `git status`_).
-   You'll see a listing like this one::
-
-     # On branch ny-new-feature
-     # Changed but not updated:
-     #   (use "git add <file>..." to update what will be committed)
-     #   (use "git checkout -- <file>..." to discard changes in working directory)
-     #
-     #	modified:   README
-     #
-     # Untracked files:
-     #   (use "git add <file>..." to include in what will be committed)
-     #
-     #	INSTALL
-     no changes added to commit (use "git add" and/or "git commit -a")
-
-#. Check what the actual changes are with ``git diff`` (`git diff`_).
-#. Add any new files to version control ``git add new_file_name`` (see
-   `git add`_). 
-#. To commit all modified files into the local copy of your repo,, do
-   ``git commit -am 'A commit message'``.  Note the ``-am`` options to
-   ``commit``. The ``m`` flag just signals that you're going to type a
-   message on the command line.  The ``a`` flag - you can just take on
-   faith - or see `why the -a flag?`_. See also the `git commit`_ manual
-   page.
-#. To push the changes up to your forked repo on github_, do a ``git
-   push`` (see `git push`). 
-
-Asking for code review
-======================
-
-#. Go to your repo URL - e.g. ``http://github.com/your-user-name/ipython``.
-#. Click on the *Branch list* button:
-
-   .. image:: branch_list.png
-
-#. Click on the *Compare* button for your feature branch - here ``my-new-feature``:
-
-   .. image:: branch_list_compare.png
-
-#. If asked, select the *base* and *comparison* branch names you want to
-   compare.  Usually these will be ``master`` and ``my-new-feature``
-   (where that is your feature branch name).
-#. At this point you should get a nice summary of the changes.  Copy the
-   URL for this, and post it to the `ipython mailing list`_, asking for
-   review.  The URL will look something like:
-   ``http://github.com/your-user-name/ipython/compare/master...my-new-feature``.
-   There's an example at
-   http://github.com/matthew-brett/nipy/compare/master...find-install-data
-   See: http://github.com/blog/612-introducing-github-compare-view for
-   more detail.
-
-The generated comparison, is between your feature branch
-``my-new-feature``, and the place in ``master`` from which you branched
-``my-new-feature``.  In other words, you can keep updating ``master``
-without interfering with the output from the comparison.  More detail?
-Note the three dots in the URL above (``master...my-new-feature``) and
-see :ref:`dot2-dot3`.
-
-Asking for your changes to be merged with the main repo
-=======================================================
-
-When you are ready to ask for the merge of your code:
-
-#. Go to the URL of your forked repo, say
-   ``http://github.com/your-user-name/ipython.git``.
-#. Click on the 'Pull request' button:
-
-   .. image:: pull_button.png
-
-   Enter a message; we suggest you select only ``ipython`` as the
-   recipient.  The message will go to the `ipython mailing list`_.  Please
-   feel free to add others from the list as you like.
-
-Merging from trunk
-==================
-
-This updates your code from the upstream `ipython github`_  repo. 
-
-Overview
---------
-
-::
-
-   # go to your master branch
-   git checkout master
-   # pull changes from github
-   git fetch upstream
-   # merge from upstream
-   git merge upstream/master
-
-In detail
----------
-
-We suggest that you do this only for your ``master`` branch, and leave
-your 'feature' branches unmerged, to keep their history as clean as
-possible.  This makes code review easier::
-
-   git checkout master
-
-Make sure you have done :ref:`linking-to-upstream`.
-
-Merge the upstream code into your current development by first pulling
-the upstream repo to a copy on your local machine::
-
-   git fetch upstream
-
-then merging into your current branch::
-
-   git merge upstream/master
-
-Deleting a branch on github_
-============================
-
-::
-
-   git checkout master
-   # delete branch locally
-   git branch -D my-unwanted-branch
-   # delete branch on github
-   git push origin :my-unwanted-branch
-
-(Note the colon ``:`` before ``test-branch``.  See also:
-http://github.com/guides/remove-a-remote-branch
-
-Several people sharing a single repository
-==========================================
-
-If you want to work on some stuff with other people, where you are all
-committing into the same repository, or even the same branch, then just
-share it via github_.
-
-First fork ipython into your account, as from :ref:`forking`.
-
-Then, go to your forked repository github page, say
-``http://github.com/your-user-name/ipython``
-
-Click on the 'Admin' button, and add anyone else to the repo as a
-collaborator:
-
-   .. image:: pull_button.png
-
-Now all those people can do::
-
-    git clone git@githhub.com:your-user-name/ipython.git
-
-Remember that links starting with ``git@`` use the ssh protocol and are
-read-write; links starting with ``git://`` are read-only.
-
-Your collaborators can then commit directly into that repo with the
-usual::
-
-     git commit -am 'ENH - much better code'
-     git push origin master # pushes directly into your repo
-
-Exploring your repository
-=========================
-
-To see a graphical representation of the repository branches and
-commits::
-
-   gitk --all
-
-To see a linear list of commits for this branch::
-
-   git log
-
-You can also look at the `network graph visualizer`_ for your github_
-repo.
-
-.. include:: git_links.txt
diff --git a/docs/source/development/gitwash/dot2_dot3.txt b/docs/source/development/gitwash/dot2_dot3.txt
deleted file mode 100644
index 7759e2e60d6..00000000000
--- a/docs/source/development/gitwash/dot2_dot3.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-.. _dot2-dot3:
-
-========================================
- Two and three dots in difference specs
-========================================
-
-Thanks to Yarik Halchenko for this explanation.
-
-Imagine a series of commits A, B, C, D...  Imagine that there are two
-branches, *topic* and *master*.  You branched *topic* off *master* when
-*master* was at commit 'E'.  The graph of the commits looks like this::
-
-
-        A---B---C topic
-        /
-   D---E---F---G master
-
-Then::
-
-   git diff master..topic
-
-will output the difference from G to C (i.e. with effects of F and G),
-while::
-
-   git diff master...topic
-
-would output just differences in the topic branch (i.e. only A, B, and
-C).
diff --git a/docs/source/development/gitwash/following_latest.txt b/docs/source/development/gitwash/following_latest.txt
deleted file mode 100644
index 475e0927502..00000000000
--- a/docs/source/development/gitwash/following_latest.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-.. _following-latest:
-
-=============================
- Following the latest source
-=============================
-
-These are the instructions if you just want to follow the latest
-*ipython* source, but you don't need to do any development for now.
-
-The steps are:
-
-* :ref:`install-git`
-* get local copy of the git repository from github_
-* update local copy from time to time
-
-Get the local copy of the code
-==============================
-
-From the command line::
-
-   git clone git://github.com/ipython/ipython.git
-
-You now have a copy of the code tree in the new ``ipython`` directory.
-
-Updating the code
-=================
-
-From time to time you may want to pull down the latest code.  Do this with::
-
-   cd ipython
-   git pull
-
-The tree in ``ipython`` will now have the latest changes from the initial
-repository.
-
-.. include:: git_links.txt
diff --git a/docs/source/development/gitwash/forking_button.png b/docs/source/development/gitwash/forking_button.png
deleted file mode 100644
index d0e04134d4d..00000000000
Binary files a/docs/source/development/gitwash/forking_button.png and /dev/null differ
diff --git a/docs/source/development/gitwash/forking_hell.txt b/docs/source/development/gitwash/forking_hell.txt
deleted file mode 100644
index dab481a2e3b..00000000000
--- a/docs/source/development/gitwash/forking_hell.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-.. _forking:
-
-==========================================
-Making your own copy (fork) of ipython
-==========================================
-
-You need to do this only once.  The instructions here are very similar
-to the instructions at http://help.github.com/forking/ - please see that
-page for more detail.  We're repeating some of it here just to give the
-specifics for the ipython_ project, and to suggest some default names.
-
-Set up and configure a github_ account
-======================================
-
-If you don't have a github_ account, go to the github_ page, and make one.
-
-You then need to configure your account to allow write access - see the
-``Generating SSH keys`` help on `github help`_.
-
-Create your own forked copy of ipython_
-=========================================
-
-#. Log into your github_ account.
-#. Go to the ipython_ github home at `ipython github`_.
-#. Click on the *fork* button:
-
-   .. image:: forking_button.png
-
-   Now, after a short pause and some 'Hardcore forking action', you
-   should find yourself at the home page for your own forked copy of ipython_.
-
-.. include:: git_links.txt
-
diff --git a/docs/source/development/gitwash/git_development.txt b/docs/source/development/gitwash/git_development.txt
deleted file mode 100644
index 64522c6581c..00000000000
--- a/docs/source/development/gitwash/git_development.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-.. _git-development:
-
-=====================
- Git for development
-=====================
-
-Contents:
-
-.. toctree::
-   :maxdepth: 2
-
-   forking_hell
-   set_up_fork
-   configure_git
-   development_workflow
-   
diff --git a/docs/source/development/gitwash/git_install.txt b/docs/source/development/gitwash/git_install.txt
deleted file mode 100644
index 6c6a57c0445..00000000000
--- a/docs/source/development/gitwash/git_install.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-.. _install-git:
-
-=============
- Install git
-=============
-
-Overview
-========
-
-================ =============
-Debian / Ubuntu  ``sudo apt-get install git-core``
-Fedora           ``sudo yum install git-core``
-Windows          Download and install msysGit_
-OS X             Use the git-osx-installer_
-================ =============
-
-In detail
-=========
-
-See the git_ page for the most recent information.
-
-Have a look at the github_ install help pages available from `github help`_
-
-There are good instructions here: http://book.git-scm.com/2_installing_git.html
-
-.. include:: git_links.txt
diff --git a/docs/source/development/gitwash/git_intro.txt b/docs/source/development/gitwash/git_intro.txt
deleted file mode 100644
index 6b0aa7931d0..00000000000
--- a/docs/source/development/gitwash/git_intro.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-==============
- Introduction
-==============
-
-These pages describe a git_ and github_ workflow for the ipython_
-project.
-
-There are several different workflows here, for different ways of
-working with *ipython*.
-
-This is not a comprehensive git_ reference, it's just a workflow for our
-own project.  It's tailored to the github_ hosting service. You may well
-find better or quicker ways of getting stuff done with git_, but these
-should get you started.
-
-For general resources for learning git_ see :ref:`git-resources`.
-
-.. include:: git_links.txt
diff --git a/docs/source/development/gitwash/git_links.txt b/docs/source/development/gitwash/git_links.txt
deleted file mode 100644
index bcf41b50628..00000000000
--- a/docs/source/development/gitwash/git_links.txt
+++ /dev/null
@@ -1,67 +0,0 @@
-.. This (-*- rst -*-) format file contains commonly used link targets
-   and name substitutions.  It may be included in many files,
-   therefore it should only contain link targets and name
-   substitutions.  Try grepping for "^\.\. _" to find plausible
-   candidates for this list.  
-
-.. NOTE: reST targets are
-   __not_case_sensitive__, so only one target definition is needed for
-   nipy, NIPY, Nipy, etc...
-
-.. PROJECTNAME placeholders
-.. _PROJECTNAME: http://neuroimaging.scipy.org
-.. _`PROJECTNAME github`: http://github.com/nipy
-.. _`PROJECTNAME mailing list`: http://projects.scipy.org/mailman/listinfo/nipy-devel
-
-.. nipy
-.. _nipy: http://nipy.org/nipy
-.. _`nipy github`: http://github.com/nipy/nipy
-.. _`nipy mailing list`: http://mail.scipy.org/mailman/listinfo/nipy-devel
-
-.. ipython
-.. _ipython: http://ipython.scipy.org
-.. _`ipython github`: http://github.com/ipython/ipython
-.. _`ipython mailing list`: http://mail.scipy.org/mailman/listinfo/IPython-dev
-
-.. nipy
-.. _dipy: http://nipy.org/dipy
-.. _`dipy github`: http://github.com/Garyfallidis/dipy
-.. _`dipy mailing list`: http://mail.scipy.org/mailman/listinfo/nipy-devel
-
-.. git stuff
-.. _git: http://git-scm.com/
-.. _github: http://github.com
-.. _github help: http://help.github.com
-.. _msysgit: http://code.google.com/p/msysgit/downloads/list
-.. _git-osx-installer: http://code.google.com/p/git-osx-installer/downloads/list
-.. _subversion: http://subversion.tigris.org/
-.. _git cheat sheet: http://github.com/guides/git-cheat-sheet
-.. _pro git book: http://progit.org/
-.. _git svn crash course: http://git-scm.com/course/svn.html
-.. _learn.github: http://learn.github.com/
-.. _network graph visualizer: http://github.com/blog/39-say-hello-to-the-network-graph-visualizer
-.. _git user manual: http://www.kernel.org/pub/software/scm/git/docs/user-manual.html
-.. _git tutorial: http://www.kernel.org/pub/software/scm/git/docs/gittutorial.html
-.. _git community book: http://book.git-scm.com/
-.. _git ready: http://www.gitready.com/
-.. _git casts: http://www.gitcasts.com/
-.. _Fernando's git page: http://www.fperez.org/py4science/git.html
-.. _git magic: http://www-cs-students.stanford.edu/~blynn/gitmagic/index.html
-.. _git concepts: http://www.eecs.harvard.edu/~cduan/technical/git/
-.. _git clone: http://www.kernel.org/pub/software/scm/git/docs/git-clone.html
-.. _git checkout: http://www.kernel.org/pub/software/scm/git/docs/git-checkout.html
-.. _git commit: http://www.kernel.org/pub/software/scm/git/docs/git-commit.html
-.. _git push: http://www.kernel.org/pub/software/scm/git/docs/git-push.html
-.. _git pull: http://www.kernel.org/pub/software/scm/git/docs/git-pull.html
-.. _git add: http://www.kernel.org/pub/software/scm/git/docs/git-add.html
-.. _git status: http://www.kernel.org/pub/software/scm/git/docs/git-status.html
-.. _git diff: http://www.kernel.org/pub/software/scm/git/docs/git-diff.html
-.. _git log: http://www.kernel.org/pub/software/scm/git/docs/git-log.html
-.. _git branch: http://www.kernel.org/pub/software/scm/git/docs/git-branch.html
-.. _git remote: http://www.kernel.org/pub/software/scm/git/docs/git-remote.html
-.. _git config: http://www.kernel.org/pub/software/scm/git/docs/git-config.html
-.. _why the -a flag?: http://www.gitready.com/beginner/2009/01/18/the-staging-area.html
-.. _git staging area: http://www.gitready.com/beginner/2009/01/18/the-staging-area.html
-.. _git management: http://kerneltrap.org/Linux/Git_Management
-.. _linux git workflow: http://www.mail-archive.com/dri-devel@lists.sourceforge.net/msg39091.html
-.. _git parable: http://tom.preston-werner.com/2009/05/19/the-git-parable.html
diff --git a/docs/source/development/gitwash/git_resources.txt b/docs/source/development/gitwash/git_resources.txt
deleted file mode 100644
index 69e344ec4d1..00000000000
--- a/docs/source/development/gitwash/git_resources.txt
+++ /dev/null
@@ -1,57 +0,0 @@
-.. _git-resources:
-
-================
- git_ resources
-================
-
-Tutorials and summaries
-=======================
-
-* `github help`_ has an excellent series of how-to guides.
-* `learn.github`_ has an excellent series of tutorials
-* The `pro git book`_ is a good in-depth book on git. 
-* A `git cheat sheet`_ is a page giving summaries of common commands.
-* The `git user manual`_ 
-* The `git tutorial`_
-* The `git community book`_
-* `git ready`_ - a nice series of tutorials
-* `git casts`_ - video snippets giving git how-tos.
-* `git magic`_ - extended introduction with intermediate detail
-* Fernando Perez' git page - `Fernando's git page`_ - many links and tips
-* A good but technical page on `git concepts`_
-* Th `git parable`_ is an easy read explaining the concepts behind git.
-* `git svn crash course`_: git_ for those of us used to subversion_
-
-Advanced git workflow
-=====================
-
-There are many ways of working with git_; here are some posts on the
-rules of thumb that other projects have come up with:
-
-* Linus Torvalds on `git management`_
-* Linus Torvalds on `linux git workflow`_ .  Summary; use the git tools
-  to make the history of your edits as clean as possible; merge from
-  upstream edits as little as possible in branches where you are doing
-  active development.
-
-Manual pages online
-===================
-
-You can get these on your own machine with (e.g) ``git help push`` or
-(same thing) ``git push --help``, but, for convenience, here are the
-online manual pages for some common commands:
-
-* `git add`_
-* `git branch`_
-* `git checkout`_
-* `git clone`_
-* `git commit`_
-* `git config`_
-* `git diff`_
-* `git log`_
-* `git pull`_
-* `git push`_
-* `git remote`_
-* `git status`_
-
-.. include:: git_links.txt
diff --git a/docs/source/development/gitwash/index.txt b/docs/source/development/gitwash/index.txt
deleted file mode 100644
index 93610f3289e..00000000000
--- a/docs/source/development/gitwash/index.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-.. _using-git:
-
-Working with *ipython* source code
-======================================
-
-Contents:
-
-.. toctree::
-   :maxdepth: 2
-
-   git_intro
-   git_install
-   following_latest
-   patching
-   git_development
-   git_resources
-
-
diff --git a/docs/source/development/gitwash/patching.txt b/docs/source/development/gitwash/patching.txt
deleted file mode 100644
index 9053db68c73..00000000000
--- a/docs/source/development/gitwash/patching.txt
+++ /dev/null
@@ -1,123 +0,0 @@
-================
- Making a patch
-================
-
-You've discovered a bug or something else you want to change in ipython_ - excellent!
-
-You've worked out a way to fix it - even better!
-
-You want to tell us about it - best of all!
-
-The easiest way is to make a *patch* or set of patches.  Here we explain
-how.  Making a patch is the simplest and quickest, but if you're going
-to be doing anything more than simple quick things, please consider
-following the :ref:`git-development` model instead.
-
-.. _making-patches:
-
-Making patches
-==============
-
-Overview
---------
-
-::
-
-   # tell git who you are
-   git config --global user.email you@yourdomain.example.com
-   git config --global user.name "Your Name Comes Here"
-   # get the repository if you don't have it
-   git clone git://github.com/ipython/ipython.git
-   # make a branch for your patching
-   cd ipython
-   git branch the-fix-im-thinking-of
-   git checkout the-fix-im-thinking-of
-   # hack, hack, hack
-   # Tell git about any new files you've made
-   git add somewhere/tests/test_my_bug.py
-   # commit work in progress as you go
-   git commit -am 'BF - added tests for Funny bug'
-   # hack hack, hack
-   git commit -am 'BF - added fix for Funny bug'
-   # make the patch files
-   git format-patch -M -C master
-
-Then, send the generated patch files to the `ipython mailing list`_ - where we will thank you warmly.
-
-In detail
----------
-
-#. Tell git_ who you are so it can label the commits you've made::
-
-      git config --global user.email you@yourdomain.example.com
-      git config --global user.name "Your Name Comes Here"
-
-#. If you don't already have one, clone a copy of the ipython_ repository::
-
-      git clone git://github.com/ipython/ipython.git
-      cd ipython
-
-#. Make a 'feature branch'.  This will be where you work on your bug
-   fix.  It's nice and safe and leaves you with access to an unmodified
-   copy of the code in the main branch::
-
-      git branch the-fix-im-thinking-of
-      git checkout the-fix-im-thinking-of
-
-#. Do some edits, and commit them as you go::
-
-      # hack, hack, hack
-      # Tell git about any new files you've made
-      git add somewhere/tests/test_my_bug.py
-      # commit work in progress as you go
-      git commit -am 'BF - added tests for Funny bug'
-      # hack hack, hack
-      git commit -am 'BF - added fix for Funny bug'
-
-   Note the ``-am`` options to ``commit``. The ``m`` flag just signals
-   that you're going to type a message on the command line.  The ``a``
-   flag - you can just take on faith - or see `why the -a flag?`_.
-
-#. When you have finished, check you have committed all your changes::
-
-      git status
-
-#. Finally, make your commits into patches.  You want all the commits
-   since you branched from the ``master`` branch::
-
-      git format-patch -M -C master
-
-   You will now have several files named for the commits::
-
-      0001-BF-added-tests-for-Funny-bug.patch
-      0002-BF-added-fix-for-Funny-bug.patch
-
-   Send these files to the `ipython mailing list`_.
-
-When you are done, to switch back to the main copy of the code, just
-return to the ``master`` branch::
-
-   git checkout master
-
-Moving from patching to development
-===================================
-
-If you find you have done some patches, and you have one or more feature
-branches, you will probably want to switch to development mode.  You can
-do this with the repository you have.
-
-Fork the ipython_ repository on github_ - :ref:`forking`.  Then::
-
-   # checkout and refresh master branch from main repo
-   git checkout master
-   git pull origin master
-   # rename pointer to main repository to 'upstream'
-   git remote rename origin upstream
-   # point your repo to default read / write to your fork on github
-   git remote add origin git@github.com:your-user-name/ipython.git
-   # push up any branches you've made and want to keep
-   git push origin the-fix-im-thinking-of
-
-Then you can, if you want, follow the :ref:`development-workflow`.
-
-.. include:: git_links.txt
diff --git a/docs/source/development/gitwash/pull_button.png b/docs/source/development/gitwash/pull_button.png
deleted file mode 100644
index e5031681b97..00000000000
Binary files a/docs/source/development/gitwash/pull_button.png and /dev/null differ
diff --git a/docs/source/development/gitwash/set_up_fork.txt b/docs/source/development/gitwash/set_up_fork.txt
deleted file mode 100644
index 2ae413a6c53..00000000000
--- a/docs/source/development/gitwash/set_up_fork.txt
+++ /dev/null
@@ -1,68 +0,0 @@
-.. _set-up-fork:
-
-==================
- Set up your fork
-==================
-
-First you follow the instructions for :ref:`forking`. 
-
-Overview
-========
-
-::
-
-   git clone git@github.com:your-user-name/ipython.git
-   cd ipython
-   git remote add upstream git://github.com/ipython/ipython.git
-
-In detail
-=========
-
-Clone your fork
----------------
-
-#. Clone your fork to the local computer with ``git clone
-   git@github.com:your-user-name/ipython.git``
-#. Investigate.  Change directory to your new repo: ``cd ipython``. Then
-   ``git branch -a`` to show you all branches.  You'll get something
-   like::
-
-      * master
-      remotes/origin/master
-
-   This tells you that you are currently on the ``master`` branch, and
-   that you also have a ``remote`` connection to ``origin/master``.
-   What remote repository is ``remote/origin``? Try ``git remote -v`` to
-   see the URLs for the remote.  They will point to your github_ fork.
-
-   Now you want to connect to the upstream `ipython github`_ repository, so
-   you can merge in changes from trunk.
-
-.. _linking-to-upstream:
-
-Linking your repository to the upstream repo
---------------------------------------------
-
-::
-
-   cd ipython
-   git remote add upstream git://github.com/ipython/ipython.git
-
-``upstream`` here is just the arbitrary name we're using to refer to the
-main ipython_ repository at `ipython github`_.
-
-Note that we've used ``git://`` for the URL rather than ``git@``.  The
-``git://`` URL is read only.  This means we that we can't accidentally
-(or deliberately) write to the upstream repo, and we are only going to
-use it to merge into our own code.
-
-Just for your own satisfaction, show yourself that you now have a new
-'remote', with ``git remote -v show``, giving you something like::
-
-   upstream	git://github.com/ipython/ipython.git (fetch)
-   upstream	git://github.com/ipython/ipython.git (push)
-   origin	git@github.com:your-user-name/ipython.git (fetch)
-   origin	git@github.com:your-user-name/ipython.git (push)
-
-.. include:: git_links.txt
-
diff --git a/docs/source/development/how_ipython_works.rst b/docs/source/development/how_ipython_works.rst
new file mode 100644
index 00000000000..aa077375384
--- /dev/null
+++ b/docs/source/development/how_ipython_works.rst
@@ -0,0 +1,63 @@
+How IPython works
+=================
+
+Terminal IPython
+----------------
+
+When you type ``ipython``, you get the original IPython interface, running in
+the terminal. It does something like this::
+
+    while True:
+        code = input(">>> ")
+        exec(code)
+
+Of course, it's much more complex, because it has to deal with multi-line
+code, tab completion using :mod:`readline`, magic commands, and so on. But the
+model is like that: prompt the user for some code, and when they've entered it,
+exec it in the same process. This model is often called a REPL, or
+Read-Eval-Print-Loop.
+
+The IPython Kernel
+------------------
+
+All the other interfaces—the Notebook, the Qt console, ``ipython console`` in
+the terminal, and third party interfaces—use the IPython Kernel. This is a
+separate process which is responsible for running user code, and things like
+computing possible completions. Frontends communicate with it using JSON
+messages sent over `ZeroMQ <http://zeromq.org/>`_ sockets; the protocol they use is described in
+:ref:`jupyterclient:messaging`.
+
+The core execution machinery for the kernel is shared with terminal IPython:
+
+.. image:: figs/ipy_kernel_and_terminal.png
+
+A kernel process can be connected to more than one frontend simultaneously. In
+this case, the different frontends will have access to the same variables.
+
+.. TODO: Diagram illustrating this?
+
+This design was intended to allow easy development of different frontends based
+on the same kernel, but it also made it possible to support new languages in the
+same frontends, by developing kernels in those languages, and we are refining
+IPython to make that more practical.
+
+Today, there are two ways to develop a kernel for another language. Wrapper
+kernels reuse the communications machinery from IPython, and implement only the
+core execution part. Native kernels implement execution and communications in
+the target language:
+
+.. image:: figs/other_kernels.png
+
+Wrapper kernels are easier to write quickly for languages that have good Python
+wrappers, like `octave_kernel <https://pypi.python.org/pypi/octave_kernel>`_, or
+languages where it's impractical to implement the communications machinery, like
+`bash_kernel <https://pypi.python.org/pypi/bash_kernel>`_. Native kernels are
+likely to be better maintained by the community using them, like
+`IJulia <https://github.com/JuliaLang/IJulia.jl>`_ or `IHaskell <https://github.com/gibiansky/IHaskell>`_.
+
+.. seealso::
+
+   :ref:`jupyterclient:kernels`
+   
+   :doc:`wrapperkernels`
+
diff --git a/docs/source/development/index.rst b/docs/source/development/index.rst
new file mode 100644
index 00000000000..35da0dca403
--- /dev/null
+++ b/docs/source/development/index.rst
@@ -0,0 +1,20 @@
+.. _developer_guide:
+
+=====================================================
+Developer's guide for third party tools and libraries
+=====================================================
+
+.. important::
+
+    This guide contains information for developers of third party tools and
+    libraries that use IPython. Alternatively, documentation for core
+    **IPython** development can be found in the :doc:`../coredev/index`.
+
+.. toctree::
+   :maxdepth: 1
+
+   how_ipython_works
+   wrapperkernels
+   execution
+   config
+   inputhook_app
diff --git a/docs/source/development/index.txt b/docs/source/development/index.txt
deleted file mode 100644
index 328c673725d..00000000000
--- a/docs/source/development/index.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-.. _developer_guide:
-
-=========================
-IPython developer's guide
-=========================
-
-.. toctree::
-   :maxdepth: 1
-
-   contributing.txt
-   gitwash/index.txt
-   coding_guide.txt
-   doc_guide.txt
-   testing.txt
-   release.txt
-   roadmap.txt
-   reorg.txt
-   messaging.txt
-   parallel_messages.txt
-   parallel_connections.txt
-   magic_blueprint.txt
-   notification_blueprint.txt
-   ipgraph.txt
-   ipython_qt.txt
-   ipythonzmq.txt
-   parallelzmq.txt
diff --git a/docs/source/development/inputhook_app.txt b/docs/source/development/inputhook_app.rst
similarity index 100%
rename from docs/source/development/inputhook_app.txt
rename to docs/source/development/inputhook_app.rst
diff --git a/docs/source/development/ipgraph.txt b/docs/source/development/ipgraph.txt
deleted file mode 100644
index 65862efd575..00000000000
--- a/docs/source/development/ipgraph.txt
+++ /dev/null
@@ -1,61 +0,0 @@
-====================================================
-Notes on code execution in :class:`InteractiveShell`
-====================================================
-
-Overview
-========
-
-This section contains information and notes about the code execution 
-system in :class:`InteractiveShell`.  This system needs to be refactored
-and we are keeping notes about this process here.
-
-Current design
-==============
-
-Here is a script that shows the relationships between the various
-methods in :class:`InteractiveShell` that manage code execution::
-
-    import networkx as nx
-    import matplotlib.pyplot as plt
-
-    exec_init_cmd = 'exec_init_cmd'
-    interact = 'interact'
-    runlines = 'runlines'
-    runsource = 'runsource'
-    runcode = 'runcode'
-    push_line = 'push_line'
-    mainloop = 'mainloop'
-    embed_mainloop = 'embed_mainloop'
-    ri = 'raw_input'
-    prefilter = 'prefilter'
-
-    g = nx.DiGraph()
-
-    g.add_node(exec_init_cmd)
-    g.add_node(interact)
-    g.add_node(runlines)
-    g.add_node(runsource)
-    g.add_node(push_line)
-    g.add_node(mainloop)
-    g.add_node(embed_mainloop)
-    g.add_node(ri)
-    g.add_node(prefilter)
-
-    g.add_edge(exec_init_cmd, push_line)
-    g.add_edge(exec_init_cmd, prefilter)
-    g.add_edge(mainloop, exec_init_cmd)
-    g.add_edge(mainloop, interact)
-    g.add_edge(embed_mainloop, interact)
-    g.add_edge(interact, ri)
-    g.add_edge(interact, push_line)
-    g.add_edge(push_line, runsource)
-    g.add_edge(runlines, push_line)
-    g.add_edge(runlines, prefilter)
-    g.add_edge(runsource, runcode)
-    g.add_edge(ri, prefilter)
-
-    nx.draw_spectral(g, node_size=100, alpha=0.6, node_color='r',
-                     font_size=10, node_shape='o')
-    plt.show()
-
-
diff --git a/docs/source/development/ipython_qt.txt b/docs/source/development/ipython_qt.txt
deleted file mode 100644
index 0363e423810..00000000000
--- a/docs/source/development/ipython_qt.txt
+++ /dev/null
@@ -1,114 +0,0 @@
-.. _ipython_qt:
-
-====================
-IPython Qt interface
-====================
-
-Abstract
---------
-
-This is about the implementation of a Qt-based Graphical User Interface (GUI)
-to execute Python code with an interpreter that runs in a separate process and
-the two systems (GUI frontend and interpreter kernel) communicating via the
-ZeroMQ Messaging library.  The bulk of the implementation will be done without
-dependencies on IPython (only on Zmq). Once the key features are ready,
-IPython-specific features can be added using the IPython codebase.
-
-
-Project details
----------------
-
-For a long time there has been demand for a graphical user interface for
-IPython, and the project already ships Wx-based prototypes thereof.  But these
-run all code in a single process, making them extremely brittle, as a crash of
-the Python interpreter kills the entire user session.  Here I propose to build
-a Qt-based GUI that will communicate with a separate process for the code
-execution, so that if the interpreter kernel dies, the frontend can continue to
-function after restarting a new kernel (and offering the user the option to
-re-execute all inputs, which the frontend can know).
-
-This GUI will allow for the easy editing of multi-line input and the convenient
-re-editing of previous blocks of input, which can be displayed in a 2-d
-workspace instead of a line-driven one like today's IPython. This makes it much
-easier to incrementally build and tune a code, by combining the rapid feedback
-cycle of IPython with the ability to edit multiline code with good graphical
-support.
-
-
-2-process model pyzmq base
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Since the necessity of a user to keep his data safe, the design is based in a
-2-process model that will be achieved with a simple client/server system with
-`pyzmq <http://www.zeromq.org/bindings:python>`_, so the GUI session do not
-crash if the the kernel process does. This will be achieved using this test
-`code
-<http://github.com/fperez/pyzmq/blob/completer/examples/kernel/kernel.py>`_ and
-customizing it to the necessities of the GUI such as queue management with
-discrimination for different frontends connected to the same kernel and tab
-completion. A piece of drafted code for the kernel (server) should look like
-this::
-
-    def main():
-        c = zmq.Context(1, 1)
-        rep_conn = connection % port_base                              
-        pub_conn = connection % (port_base+1)
-        print >>sys.__stdout__, "Starting the kernel..."
-        print >>sys.__stdout__, "On:",rep_conn, pub_conn
-        session = Session(username=u'kernel')
-        reply_socket = c.socket(zmq.XREP)
-        reply_socket.bind(rep_conn)
-        pub_socket = c.socket(zmq.PUB)
-        pub_socket.bind(pub_conn)                                         
-        stdout = OutStream(session, pub_socket, u'stdout')         
-        stderr = OutStream(session, pub_socket, u'stderr')
-        sys.stdout = stdout                                                 
-        sys.stderr = stderr                     
-        display_hook = DisplayHook(session, pub_socket)
-        sys.displayhook = display_hook
-        kernel = Kernel(session, reply_socket, pub_socket)
-
-This kernel will use two queues (output and input), the input queue will have
-the id of the process(frontend) making the request, type(execute, complete,
-help, etc) and id of the request itself and the string of code to be executed,
-the output queue will have basically the same information just that the string
-is the to be displayed. This model is because the kernel needs to maintain
-control of timeouts when multiple requests are sent and keep them indexed.
-
-Qt based GUI
-~~~~~~~~~~~~
-
-Design of the interface is going to be based in cells of code executed on the
-previous defined kernel. It will also have GUI facilities such toolboxes,
-tooltips to autocomplete code and function summary, highlighting and
-autoindentation.  It will have the cell kind of multiline edition mode so each
-block of code can be edited and executed independently, this can be achieved
-queuing QTextEdit objects (the cell) giving them format so we can discriminate
-outputs from inputs.  One of the main characteristics will be the debug support
-that will show the requested outputs as the debugger (that will be on a popup
-widget) "walks" through the code, this design is to be reviewed with the
-mentor.  `This <http://gfif.udea.edu.co/IPythonQt_snapshot.png>`_ is a
-tentative view of the main window.
-
-The GUI will check continuously the output queue from the kernel for new
-information to handle. This information have to be handled with care since any
-output will come at anytime and possibly in a different order than requested or
-maybe not appear at all, this could be possible due to a variety of reasons(for
-example tab completion request while the kernel is busy processing another
-frontend's request). This is, if the kernel is busy it won't be possible to
-fulfill the request for a while so the GUI will be prepared to abandon waiting
-for the reply if the user moves on or a certain timeout expires.
-
-
-POSSIBLE FUTURE DIRECTIONS
----------------------------
-
-The near future will bring the feature of saving and loading sessions, also
-importing and exporting to different formats like rst, html, pdf and
-python/ipython code, a discussion about this is taking place in the ipython-dev
-mailing list. Also the interaction with a remote kernel and distributed
-computation which is an IPython's project already in development.
-
-The idea of a mathematica-like help widget (i.e. there will be parts of it that
-will execute as a native session of IPythonQt) is still to be discussed in the
-development mailing list but it's definitively a great idea.
diff --git a/docs/source/development/ipythonzmq.txt b/docs/source/development/ipythonzmq.txt
deleted file mode 100644
index 0454653f44c..00000000000
--- a/docs/source/development/ipythonzmq.txt
+++ /dev/null
@@ -1,116 +0,0 @@
-.. _ipythonzmq:
-
-=====================================================
- Porting IPython to a two process model using zeromq
-=====================================================
-
-Abstract
---------
-
-IPython's execution in a command-line environment will be ported to a two
-process model using the zeromq library for inter-process communication. this
-will:
-
-- prevent an interpreter crash from destroying the user session,
-- allow multiple clients to interact simultaneously with a single interpreter
-- allow IPython to reuse code for local execution and distributed computing (dc)
-- give us a path for python3 support, since zeromq supports python3 while
-  twisted (what we use today for dc) does not.
-
-
-Project description
--------------------
-
-Currently IPython provides a command-line client that executes all code in a
-single process, and a set of tools for distributed and parallel computing that
-execute code in multiple processes (possibly but not necessarily on different
-hosts), using the twisted asynchronous framework for communication between
-nodes. for a number of reasons, it is desirable to unify the architecture of
-the local execution with that of distributed computing, since ultimately many
-of the underlying abstractions are similar and should be reused.  in
-particular, we would like to:
-
-- have even for a single user a 2-process model, so that the environment where
-  code is being input runs in a different process from that which executes the
-  code. this would prevent a crash of the python interpreter executing code
-  (because of a segmentation fault in a compiled extension or an improper
-  access to a c library via ctypes, for example) from destroying the user
-  session.
-
-- have the same kernel used for executing code locally be available over the
-  network for distributed computing. currently the twisted-using IPython
-  engines for distributed computing do not share any code with the command-line
-  client, which means that many of the additional features of IPython (tab
-  completion, object introspection, magic functions, etc) are not available
-  while using the distributed computing system.  once the regular command-line
-  environment is ported to allowing such a 2-process model, this newly
-  decoupled kernel could form the core of a distributed computing IPython
-  engine and all capabilities would be available throughout the system.
-
-- have a route to python3 support. twisted is a large and complex library that
-  does currently not support python3, and as indicated by the twisted
-  developers it may take a while before it is ported
-  (http://stackoverflow.com/questions/172306/how-are-you-planning-on-handling-the-migration-to-python-3).
-  for IPython, this means that while we could port the command-line
-  environment, a large swath of IPython would be left 2.x-only, a highly
-  undesirable situation.  for this reason, the search for an alternative to
-  twisted has been active for a while, and recently we've identified the zeromq
-  (http://www.zeromq.org, zmq for short) library as a viable candidate. zmq is
-  a fast, simple messaging library written in c++, for which one of the IPython
-  developers has written python bindings using cython
-  (http://www.zeromq.org/bindings:python). since cython already knows how to
-  generate python3-compliant bindings with a simple command-line switch, zmq
-  can be used with python3 when needed.
-
-As part of the zmq python bindings, the IPython developers have already
-developed a simple prototype of such a two-process kernel/frontend system
-(details below). I propose to start from this example and port today's IPython
-code to operate in a similar manner. IPython's command-line program (the main
-'ipython' script) executes both user interaction and the user's code in the
-same process. This project will thus require breaking up IPython into the parts
-that correspond to the kernel and the parts that are meant to interact with the
-user, and making these two components communicate over the network using zmq
-instead of accessing local attributes and methods of a single global object.
-
-Once this port is complete, the resulting tools will be the foundation (though
-as part of this proposal i do not expect to undertake either of these tasks) to
-allow the distributed computing parts of IPython to use the same code as the
-command-line client, and for the whole system to be ported to python3.  so
-while i do not intend to tackle here the removal of twisted and the unification
-of the local and distributed parts of IPython, my proposal is a necessary step
-before those are possible.
-
-Project details
----------------
-
-As part of the zeromq bindings, the IPython developers have already developed a
-simple prototype example that provides a python execution kernel (with none of
-IPython's code or features, just plain code execution) that listens on zmq
-sockets, and a frontend based on the interactiveconsole class of the code.py
-module from the python standard library. this example is capable of executing
-code, propagating errors, performing tab-completion over the network and having
-multiple frontends connect and disconnect simultaneously to a single kernel,
-with all inputs and outputs being made available to all connected clients
-(thanks to zqm's pub sockets that provide multicasting capabilities for the
-kernel and to which the frontends subscribe via a sub socket).
-
-We have all example code in:
-
-* http://github.com/ellisonbg/pyzmq/blob/completer/examples/kernel/kernel.py
-* http://github.com/ellisonbg/pyzmq/blob/completer/examples/kernel/completer.py
-* http://github.com/fperez/pyzmq/blob/completer/examples/kernel/frontend.py
-
-all of this code already works, and can be seen in this example directory from
-the zmq python bindings:
-
-* http://github.com/ellisonbg/pyzmq/blob/completer/examples/kernel
-
-Based on this work, i expect to write a stable system for IPython kernel with
-IPython standards, error control,crash recovery system and general
-configuration options, also standardize defaults ports or auth system for
-remote connection etc.
-
-The crash recovery system, is a IPython kernel module for when it fails
-unexpectedly, you can retrieve the information from the section, this will be
-based on a log and a lock file to indicate when the kernel was not closed in a
-proper way.
diff --git a/docs/source/development/kernels.rst b/docs/source/development/kernels.rst
new file mode 100644
index 00000000000..0d9a5fd0d09
--- /dev/null
+++ b/docs/source/development/kernels.rst
@@ -0,0 +1,8 @@
+:orphan:
+
+==========================
+Making kernels for IPython
+==========================
+
+Kernels are now part of Jupyter - see
+:ref:`jupyterclient:kernels` for the documentation.
diff --git a/docs/source/development/magic_blueprint.txt b/docs/source/development/magic_blueprint.txt
deleted file mode 100644
index 2a82f2f71b8..00000000000
--- a/docs/source/development/magic_blueprint.txt
+++ /dev/null
@@ -1,103 +0,0 @@
-==============================
- The magic commands subsystem
-==============================
-
-.. warning::
-
-   These are *preliminary* notes and thoughts on the magic system, kept here
-   for reference so we can come up with a good design now that the major core
-   refactoring has made so much progress.  Do not consider yet any part of this
-   document final.
-
-Two entry points:
-
-- m.line_eval(self,parameter_s): like today
-- m.block_eval(self,code_block): for whole-block evaluation.
-
-This would allow us to have magics that take input, and whose single line form
-can even take input and call block_eval later (like %cpaste does, but with a
-generalized interface).
-
-Constructor
-===========
-
-Suggested syntax::
-
-    class MyMagic(BaseMagic):
-        requires_shell = True/False
-        def __init__(self,shell=None):
-
-
-Registering magics
-==================
-
-Today, ipapi provides an *expose_magic()* function for making simple magics.
-We will probably extend this (in a backwards-compatible manner if possible) to
-allow the simplest cases to work as today, while letting users register more
-complex ones.
-
-Use cases::
-
-    def func(arg): pass  # note signature, no 'self'
-    ip.expose_magic('name',func)
-    
-    def func_line(arg): pass
-    def func_block(arg):pass
-    ip.expose_magic('name',func_line,func_block)
-
-    class mymagic(BaseMagic):
-        """Magic docstring, used in help messages.
-        """
-        def line_eval(self,arg): pass
-        def block_eval(self,arg): pass
-
-    ip.register_magic(mymagic)
-
-
-The BaseMagic class will offer common functionality to all, including things
-like options handling (via argparse).
-
-
-Call forms: line and block
-==========================
-
-Block-oriented environments will call line_eval() for the first line of input
-(the call line starting with '%') and will then feed the rest of the block to
-block_eval() if the magic in question has a block mode.
-
-In line environments, by default %foo -> foo.line_eval(), but no block call is
-made.  Specific implementations of line_eval can decide to then call block_eval
-if they want to provide for whole-block input in line-oriented environments.
-
-The api might be adapted for this decision to be made automatically by the
-frontend...
-
-
-Precompiled magics for rapid loading
-====================================
-
-For IPython itself, we'll have a module of 'core' magic functions that do not
-require run-time registration.  These will be the ones contained today in
-Magic.py, plus any others we deem worthy of being available by default.  This
-is a trick to enable faster startup, since once we move to a model where each
-magic can in principle be registered at runtime, creating a lot of them can
-easily swamp startup time.
-
-The trick is to make a module with a top-level class object that contains
-explicit references to all the 'core' magics in its dict.  This way, the magic
-table can be quickly updated at interpreter startup with a single call, by
-doing something along the lines of::
-
-    self.magic_table.update(static_magics.__dict__)
-
-The point will be to be able to bypass the explicit calling of whatever
-register_magic() API we end up making for users to declare their own magics.
-So ultimately one should be able to do either::
-
-    ip.register_magic(mymagic) # for one function
-
-or::
-
-    ip.load_magics(static_magics)  # for a bunch of them
-
-I still need to clarify exactly how this should work though.
diff --git a/docs/source/development/messaging.rst b/docs/source/development/messaging.rst
new file mode 100644
index 00000000000..861dd40d8c3
--- /dev/null
+++ b/docs/source/development/messaging.rst
@@ -0,0 +1,7 @@
+:orphan:
+
+Messaging in IPython
+====================
+
+The message specification is now part of Jupyter - see
+:ref:`jupyterclient:messaging` for the documentation.
diff --git a/docs/source/development/messaging.txt b/docs/source/development/messaging.txt
deleted file mode 100644
index 641b48a5c72..00000000000
--- a/docs/source/development/messaging.txt
+++ /dev/null
@@ -1,924 +0,0 @@
-.. _messaging:
-
-======================
- Messaging in IPython
-======================
-
-
-Introduction
-============
-
-This document explains the basic communications design and messaging
-specification for how the various IPython objects interact over a network
-transport.  The current implementation uses the ZeroMQ_ library for messaging
-within and between hosts.
-
-.. Note::
-
-   This document should be considered the authoritative description of the
-   IPython messaging protocol, and all developers are strongly encouraged to
-   keep it updated as the implementation evolves, so that we have a single
-   common reference for all protocol details.
-   
-The basic design is explained in the following diagram:
-
-.. image:: frontend-kernel.png
-   :width: 450px
-   :alt: IPython kernel/frontend messaging architecture.
-   :align: center
-   :target: ../_images/frontend-kernel.png
-
-A single kernel can be simultaneously connected to one or more frontends.  The
-kernel has three sockets that serve the following functions:
-
-1. REQ: this socket is connected to a *single* frontend at a time, and it allows
-   the kernel to request input from a frontend when :func:`raw_input` is called.
-   The frontend holding the matching REP socket acts as a 'virtual keyboard'
-   for the kernel while this communication is happening (illustrated in the
-   figure by the black outline around the central keyboard).  In practice,
-   frontends may display such kernel requests using a special input widget or
-   otherwise indicating that the user is to type input for the kernel instead
-   of normal commands in the frontend.
-
-2. XREP: this single sockets allows multiple incoming connections from
-   frontends, and this is the socket where requests for code execution, object
-   information, prompts, etc. are made to the kernel by any frontend.  The
-   communication on this socket is a sequence of request/reply actions from
-   each frontend and the kernel.
-
-3. PUB: this socket is the 'broadcast channel' where the kernel publishes all
-   side effects (stdout, stderr, etc.) as well as the requests coming from any
-   client over the XREP socket and its own requests on the REP socket.  There
-   are a number of actions in Python which generate side effects: :func:`print`
-   writes to ``sys.stdout``, errors generate tracebacks, etc.  Additionally, in
-   a multi-client scenario, we want all frontends to be able to know what each
-   other has sent to the kernel (this can be useful in collaborative scenarios,
-   for example).  This socket allows both side effects and the information
-   about communications taking place with one client over the XREQ/XREP channel
-   to be made available to all clients in a uniform manner.
-
-   All messages are tagged with enough information (details below) for clients
-   to know which messages come from their own interaction with the kernel and
-   which ones are from other clients, so they can display each type
-   appropriately.
-
-The actual format of the messages allowed on each of these channels is
-specified below.  Messages are dicts of dicts with string keys and values that
-are reasonably representable in JSON.  Our current implementation uses JSON
-explicitly as its message format, but this shouldn't be considered a permanent
-feature.  As we've discovered that JSON has non-trivial performance issues due
-to excessive copying, we may in the future move to a pure pickle-based raw
-message format.  However, it should be possible to easily convert from the raw
-objects to JSON, since we may have non-python clients (e.g. a web frontend).
-As long as it's easy to make a JSON version of the objects that is a faithful
-representation of all the data, we can communicate with such clients.
-
-.. Note::
-
-   Not all of these have yet been fully fleshed out, but the key ones are, see
-   kernel and frontend files for actual implementation details.
-
-   
-Python functional API
-=====================
-
-As messages are dicts, they map naturally to a ``func(**kw)`` call form.  We
-should develop, at a few key points, functional forms of all the requests that
-take arguments in this manner and automatically construct the necessary dict
-for sending.
-
-
-General Message Format
-======================
-
-All messages send or received by any IPython process should have the following
-generic structure::
-    
-    {
-      # The message header contains a pair of unique identifiers for the
-      # originating session and the actual message id, in addition to the
-      # username for the process that generated the message.  This is useful in
-      # collaborative settings where multiple users may be interacting with the
-      # same kernel simultaneously, so that frontends can label the various
-      # messages in a meaningful way.
-      'header' : { 'msg_id' : uuid,
-                   'username' : str,
-           'session' : uuid
-         },
-
-      # In a chain of messages, the header from the parent is copied so that
-      # clients can track where messages come from.
-      'parent_header' : dict,
-
-      # All recognized message type strings are listed below.
-      'msg_type' : str,
-
-      # The actual content of the message must be a dict, whose structure
-      # depends on the message type.x
-      'content' : dict,
-    }
-
-For each message type, the actual content will differ and all existing message
-types are specified in what follows of this document.
-
-
-Messages on the XREP/XREQ socket
-================================
-
-.. _execute:
-
-Execute
--------
-
-This message type is used by frontends to ask the kernel to execute code on
-behalf of the user, in a namespace reserved to the user's variables (and thus
-separate from the kernel's own internal code and variables).
-
-Message type: ``execute_request``::
-
-    content = {
-        # Source code to be executed by the kernel, one or more lines.
-    'code' : str,
-
-    # A boolean flag which, if True, signals the kernel to execute this
-    # code as quietly as possible.  This means that the kernel will compile
-    # the code witIPython/core/tests/h 'exec' instead of 'single' (so
-    # sys.displayhook will not fire), and will *not*:
-    #   - broadcast exceptions on the PUB socket
-    #   - do any logging
-    #   - populate any history
-    #
-    # The default is False.
-    'silent' : bool,
-
-    # A list of variable names from the user's namespace to be retrieved.  What
-    # returns is a JSON string of the variable's repr(), not a python object.
-    'user_variables' : list,
-
-    # Similarly, a dict mapping names to expressions to be evaluated in the
-    # user's dict.
-    'user_expressions' : dict,
-    }
-
-The ``code`` field contains a single string (possibly multiline).  The kernel
-is responsible for splitting this into one or more independent execution blocks
-and deciding whether to compile these in 'single' or 'exec' mode (see below for
-detailed execution semantics).
-
-The ``user_`` fields deserve a detailed explanation.  In the past, IPython had
-the notion of a prompt string that allowed arbitrary code to be evaluated, and
-this was put to good use by many in creating prompts that displayed system
-status, path information, and even more esoteric uses like remote instrument
-status aqcuired over the network.  But now that IPython has a clean separation
-between the kernel and the clients, the kernel has no prompt knowledge; prompts
-are a frontend-side feature, and it should be even possible for different
-frontends to display different prompts while interacting with the same kernel.
-
-The kernel now provides the ability to retrieve data from the user's namespace
-after the execution of the main ``code``, thanks to two fields in the
-``execute_request`` message:
-
-- ``user_variables``: If only variables from the user's namespace are needed, a
-  list of variable names can be passed and a dict with these names as keys and
-  their :func:`repr()` as values will be returned.
-
-- ``user_expressions``: For more complex expressions that require function
-  evaluations, a dict can be provided with string keys and arbitrary python
-  expressions as values.  The return message will contain also a dict with the
-  same keys and the :func:`repr()` of the evaluated expressions as value.
-
-With this information, frontends can display any status information they wish
-in the form that best suits each frontend (a status line, a popup, inline for a
-terminal, etc).
-
-.. Note::
-
-   In order to obtain the current execution counter for the purposes of
-   displaying input prompts, frontends simply make an execution request with an
-   empty code string and ``silent=True``.
-
-Execution semantics
-~~~~~~~~~~~~~~~~~~~
-
-When the silent flag is false, the execution of use code consists of the
-following phases (in silent mode, only the ``code`` field is executed):
-
-1. Run the ``pre_runcode_hook``.
-
-2. Execute the ``code`` field, see below for details.
-
-3. If #2 succeeds, compute ``user_variables`` and ``user_expressions`` are
-   computed.  This ensures that any error in the latter don't harm the main
-   code execution.
-
-4. Call any method registered with :meth:`register_post_execute`.
-
-.. warning::
-
-   The API for running code before/after the main code block is likely to
-   change soon.  Both the ``pre_runcode_hook`` and the
-   :meth:`register_post_execute` are susceptible to modification, as we find a
-   consistent model for both.
-
-To understand how the ``code`` field is executed, one must know that Python
-code can be compiled in one of three modes (controlled by the ``mode`` argument
-to the :func:`compile` builtin):
-
-*single*
-  Valid for a single interactive statement (though the source can contain
-  multiple lines, such as a for loop).  When compiled in this mode, the
-  generated bytecode contains special instructions that trigger the calling of
-  :func:`sys.displayhook` for any expression in the block that returns a value.
-  This means that a single statement can actually produce multiple calls to
-  :func:`sys.displayhook`, if for example it contains a loop where each
-  iteration computes an unassigned expression would generate 10 calls::
-
-      for i in range(10):
-          i**2
-
-*exec*
-  An arbitrary amount of source code, this is how modules are compiled.
-  :func:`sys.displayhook` is *never* implicitly called.
-
-*eval*
-  A single expression that returns a value.  :func:`sys.displayhook` is *never*
-  implicitly called.
-
-
-The ``code`` field is split into individual blocks each of which is valid for
-execution in 'single' mode, and then:
-
-- If there is only a single block: it is executed in 'single' mode.
-
-- If there is more than one block:
-
-  * if the last one is a single line long, run all but the last in 'exec' mode
-    and the very last one in 'single' mode.  This makes it easy to type simple
-    expressions at the end to see computed values.
-
-  * if the last one is no more than two lines long, run all but the last in
-    'exec' mode and the very last one in 'single' mode.  This makes it easy to
-    type simple expressions at the end to see computed values.  - otherwise
-    (last one is also multiline), run all in 'exec' mode
-
-  * otherwise (last one is also multiline), run all in 'exec' mode as a single
-    unit.
-
-Any error in retrieving the ``user_variables`` or evaluating the
-``user_expressions`` will result in a simple error message in the return fields
-of the form::
-
-   [ERROR] ExceptionType: Exception message
-
-The user can simply send the same variable name or expression for evaluation to
-see a regular traceback.
-
-Errors in any registered post_execute functions are also reported similarly,
-and the failing function is removed from the post_execution set so that it does
-not continue triggering failures.
-
-Upon completion of the execution request, the kernel *always* sends a reply,
-with a status code indicating what happened and additional data depending on
-the outcome.  See :ref:`below <execution_results>` for the possible return
-codes and associated data.
-
-
-Execution counter (old prompt number)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The kernel has a single, monotonically increasing counter of all execution
-requests that are made with ``silent=False``.  This counter is used to populate
-the ``In[n]``, ``Out[n]`` and ``_n`` variables, so clients will likely want to
-display it in some form to the user, which will typically (but not necessarily)
-be done in the prompts.  The value of this counter will be returned as the
-``execution_count`` field of all ``execute_reply`` messages.
-
-.. _execution_results:
-
-Execution results
-~~~~~~~~~~~~~~~~~
-    
-Message type: ``execute_reply``::
-
-    content = {
-      # One of: 'ok' OR 'error' OR 'abort'
-      'status' : str,
-
-      # The global kernel counter that increases by one with each non-silent
-      # executed request.  This will typically be used by clients to display
-      # prompt numbers to the user.  If the request was a silent one, this will
-      # be the current value of the counter in the kernel.
-      'execution_count' : int,
-    }
-
-When status is 'ok', the following extra fields are present::
-
-    {
-      # The execution payload is a dict with string keys that may have been
-      # produced by the code being executed.  It is retrieved by the kernel at
-      # the end of the execution and sent back to the front end, which can take
-      # action on it as needed.  See main text for further details.
-      'payload' : dict,
-
-      # Results for the user_variables and user_expressions.
-      'user_variables' : dict,
-      'user_expressions' : dict,
-
-      # The kernel will often transform the input provided to it.  If the
-      # '---->' transform had been applied, this is filled, otherwise it's the
-      # empty string.  So transformations like magics don't appear here, only
-      # autocall ones.
-      'transformed_code' : str,
-      }
-
-.. admonition:: Execution payloads
-    
-   The notion of an 'execution payload' is different from a return value of a
-   given set of code, which normally is just displayed on the pyout stream
-   through the PUB socket.  The idea of a payload is to allow special types of
-   code, typically magics, to populate a data container in the IPython kernel
-   that will be shipped back to the caller via this channel.  The kernel will
-   have an API for this, probably something along the lines of::
-
-       ip.exec_payload_add(key, value)
-
-   though this API is still in the design stages.  The data returned in this
-   payload will allow frontends to present special views of what just happened.
-
-   
-When status is 'error', the following extra fields are present::
-
-    {
-      'exc_name' : str,   # Exception name, as a string
-      'exc_value' : str,  # Exception value, as a string
-
-      # The traceback will contain a list of frames, represented each as a
-      # string.  For now we'll stick to the existing design of ultraTB, which
-      # controls exception level of detail statefully.  But eventually we'll
-      # want to grow into a model where more information is collected and
-      # packed into the traceback object, with clients deciding how little or
-      # how much of it to unpack.  But for now, let's start with a simple list
-      # of strings, since that requires only minimal changes to ultratb as
-      # written.
-      'traceback' : list,
-    }
-
-
-When status is 'abort', there are for now no additional data fields.  This
-happens when the kernel was interrupted by a signal.
-
-Kernel attribute access
------------------------
-
-.. warning::
-
-   This part of the messaging spec is not actually implemented in the kernel
-   yet.
- 
-While this protocol does not specify full RPC access to arbitrary methods of
-the kernel object, the kernel does allow read (and in some cases write) access
-to certain attributes.
-
-The policy for which attributes can be read is: any attribute of the kernel, or
-its sub-objects, that belongs to a :class:`Configurable` object and has been
-declared at the class-level with Traits validation, is in principle accessible
-as long as its name does not begin with a leading underscore.  The attribute
-itself will have metadata indicating whether it allows remote read and/or write
-access.  The message spec follows for attribute read and write requests.
-
-Message type: ``getattr_request``::
-
-    content = {
-        # The (possibly dotted) name of the attribute
-	'name' : str,
-    }
-
-When a ``getattr_request`` fails, there are two possible error types:
-
-- AttributeError: this type of error was raised when trying to access the
-  given name by the kernel itself.  This means that the attribute likely
-  doesn't exist.
-
-- AccessError: the attribute exists but its value is not readable remotely.
-
-
-Message type: ``getattr_reply``::
-
-    content = {
-        # One of ['ok', 'AttributeError', 'AccessError'].
-        'status' : str,
-	# If status is 'ok', a JSON object.
-	'value' : object,
-    }
-
-Message type: ``setattr_request``::
-
-    content = {
-        # The (possibly dotted) name of the attribute
-	'name' : str,
-	
-	# A JSON-encoded object, that will be validated by the Traits
-	# information in the kernel
-	'value' : object,
-    }
-
-When a ``setattr_request`` fails, there are also two possible error types with
-similar meanings  as those of the ``getattr_request`` case, but for writing.
-    
-Message type: ``setattr_reply``::
-
-    content = {
-        # One of ['ok', 'AttributeError', 'AccessError'].
-        'status' : str,
-    }
-
-
-    
-Object information
-------------------
-
-One of IPython's most used capabilities is the introspection of Python objects
-in the user's namespace, typically invoked via the ``?`` and ``??`` characters
-(which in reality are shorthands for the ``%pinfo`` magic).  This is used often
-enough that it warrants an explicit message type, especially because frontends
-may want to get object information in response to user keystrokes (like Tab or
-F1) besides from the user explicitly typing code like ``x??``.
-
-Message type: ``object_info_request``::
-
-    content = {
-        # The (possibly dotted) name of the object to be searched in all
-	# relevant namespaces
-        'name' : str,
-
-    	# The level of detail desired.  The default (0) is equivalent to typing
-	# 'x?' at the prompt, 1 is equivalent to 'x??'.
-	'detail_level' : int,
-    }
-
-The returned information will be a dictionary with keys very similar to the
-field names that IPython prints at the terminal.
-    
-Message type: ``object_info_reply``::
-
-    content = {
-    # The name the object was requested under
-    'name' : str,
-    
-    # Boolean flag indicating whether the named object was found or not.  If
-    # it's false, all other fields will be empty.
-    'found' : bool,
-    
-    # Flags for magics and system aliases
-    'ismagic' : bool,
-    'isalias' : bool,
-
-    # The name of the namespace where the object was found ('builtin',
-    # 'magics', 'alias', 'interactive', etc.)
-    'namespace' : str,
-
-    # The type name will be type.__name__ for normal Python objects, but it
-    # can also be a string like 'Magic function' or 'System alias'
-    'type_name' : str,
-
-    # The string form of the object, possibly truncated for length if 
-    # detail_level is 0
-    'string_form' : str,
-
-    # For objects with a __class__ attribute this will be set
-    'base_class' : str,
-
-    # For objects with a __len__ attribute this will be set
-    'length' : int,
-
-    # If the object is a function, class or method whose file we can find,
-    # we give its full path
-    'file' : str,
-
-    # For pure Python callable objects, we can reconstruct the object
-    # definition line which provides its call signature.  For convenience this
-    # is returned as a single 'definition' field, but below the raw parts that
-    # compose it are also returned as the argspec field.
-    'definition' : str,
-
-    # The individual parts that together form the definition string.  Clients
-    # with rich display capabilities may use this to provide a richer and more
-    # precise representation of the definition line (e.g. by highlighting
-    # arguments based on the user's cursor position).  For non-callable
-    # objects, this field is empty.
-    'argspec' : { # The names of all the arguments
-                  args : list,
-		  # The name of the varargs (*args), if any
-                  varargs : str,
-		  # The name of the varkw (**kw), if any
-		  varkw : str,
-		  # The values (as strings) of all default arguments.  Note
-		  # that these must be matched *in reverse* with the 'args'
-		  # list above, since the first positional args have no default
-		  # value at all.
-		  defaults : list,
-		  },
-
-    # For instances, provide the constructor signature (the definition of
-    # the __init__ method):
-    'init_definition' : str,
-    
-    # Docstrings: for any object (function, method, module, package) with a
-    # docstring, we show it.  But in addition, we may provide additional
-    # docstrings.  For example, for instances we will show the constructor
-    # and class docstrings as well, if available.
-    'docstring' : str,
-
-    # For instances, provide the constructor and class docstrings
-    'init_docstring' : str,
-    'class_docstring' : str,
-    
-    # If it's a callable object whose call method has a separate docstring and
-    # definition line:
-    'call_def' : str,
-    'call_docstring' : str,
-    
-    # If detail_level was 1, we also try to find the source code that
-    # defines the object, if possible.  The string 'None' will indicate
-    # that no source was found.
-    'source' : str,
-    }
-'
-    
-Complete
---------
-
-Message type: ``complete_request``::
-
-    content = {
-        # The text to be completed, such as 'a.is'
-    'text' : str,
-
-    # The full line, such as 'print a.is'.  This allows completers to
-    # make decisions that may require information about more than just the
-    # current word.
-    'line' : str,
-
-    # The entire block of text where the line is.  This may be useful in the
-    # case of multiline completions where more context may be needed.  Note: if
-    # in practice this field proves unnecessary, remove it to lighten the
-    # messages.
-    
-    'block' : str,
-
-    # The position of the cursor where the user hit 'TAB' on the line.
-    'cursor_pos' : int,
-    }
-
-Message type: ``complete_reply``::
-
-    content = {
-        # The list of all matches to the completion request, such as
-    # ['a.isalnum', 'a.isalpha'] for the above example.
-    'matches' : list
-    }
-
-    
-History
--------
-
-For clients to explicitly request history from a kernel.  The kernel has all
-the actual execution history stored in a single location, so clients can
-request it from the kernel when needed.
-
-Message type: ``history_request``::
-
-    content = {
-    
-      # If True, also return output history in the resulting dict.
-      'output' : bool,
-
-      # If True, return the raw input history, else the transformed input.
-      'raw' : bool,
-
-      # This parameter can be one of: A number,  a pair of numbers, None
-      # If not given, last 40 are returned.
-      #  - number n: return the last n entries.
-      #  - pair n1, n2: return entries in the range(n1, n2).
-      #  - None: return all history
-      'index' : n or (n1, n2) or None,
-    }
-
-Message type: ``history_reply``::
-
-    content = {
-      # A dict with prompt numbers as keys and either (input, output) or input
-      # as the value depending on whether output was True or False,
-      # respectively.
-      'history' : dict,
-    }
-
-
-Connect
--------
-
-When a client connects to the request/reply socket of the kernel, it can issue
-a connect request to get basic information about the kernel, such as the ports
-the other ZeroMQ sockets are listening on. This allows clients to only have
-to know about a single port (the XREQ/XREP channel) to connect to a kernel.
-
-Message type: ``connect_request``::
-
-    content = {
-    }
-
-Message type: ``connect_reply``::
-
-    content = {
-        'xrep_port' : int  # The port the XREP socket is listening on.
-        'pub_port' : int   # The port the PUB socket is listening on.
-        'req_port' : int   # The port the REQ socket is listening on.
-        'hb_port' : int    # The port the heartbeat socket is listening on.
-    }
-
-
-
-Kernel shutdown
----------------
-
-The clients can request the kernel to shut itself down; this is used in
-multiple cases:
-
-- when the user chooses to close the client application via a menu or window
-  control.
-- when the user types 'exit' or 'quit' (or their uppercase magic equivalents).
-- when the user chooses a GUI method (like the 'Ctrl-C' shortcut in the
-  IPythonQt client) to force a kernel restart to get a clean kernel without
-  losing client-side state like history or inlined figures.
-
-The client sends a shutdown request to the kernel, and once it receives the
-reply message (which is otherwise empty), it can assume that the kernel has
-completed shutdown safely.
-
-Upon their own shutdown, client applications will typically execute a last
-minute sanity check and forcefully terminate any kernel that is still alive, to
-avoid leaving stray processes in the user's machine.
-
-For both shutdown request and reply, there is no actual content that needs to
-be sent, so the content dict is empty.
-
-Message type: ``shutdown_request``::
-
-    content = {
-        'restart' : bool # whether the shutdown is final, or precedes a restart
-    }
-
-Message type: ``shutdown_reply``::
-
-    content = {
-        'restart' : bool # whether the shutdown is final, or precedes a restart
-    }
-
-.. Note::
-
-   When the clients detect a dead kernel thanks to inactivity on the heartbeat
-   socket, they simply send a forceful process termination signal, since a dead
-   process is unlikely to respond in any useful way to messages.
-    
-
-Messages on the PUB/SUB socket
-==============================
-
-Streams (stdout,  stderr, etc)
-------------------------------
-
-Message type: ``stream``::
-
-    content = {
-        # The name of the stream is one of 'stdin', 'stdout', 'stderr'
-        'name' : str,
-    
-        # The data is an arbitrary string to be written to that stream
-        'data' : str,
-    }
-
-When a kernel receives a raw_input call, it should also broadcast it on the pub
-socket with the names 'stdin' and 'stdin_reply'.  This will allow other clients
-to monitor/display kernel interactions and possibly replay them to their user
-or otherwise expose them.
-
-Display Data
-------------
-
-This type of message is used to bring back data that should be diplayed (text,
-html, svg, etc.) in the frontends. This data is published to all frontends.
-Each message can have multiple representations of the data; it is up to the
-frontend to decide which to use and how. A single message should contain all
-possible representations of the same information. Each representation should
-be a JSON'able data structure, and should be a valid MIME type.
-
-Some questions remain about this design:
-
-* Do we use this message type for pyout/displayhook? Probably not, because
-  the displayhook also has to handle the Out prompt display. On the other hand
-  we could put that information into the metadata secion.
-
-Message type: ``display_data``::
-
-    content = {
-
-        # Who create the data
-        'source' : str,
-
-        # The data dict contains key/value pairs, where the kids are MIME
-        # types and the values are the raw data of the representation in that
-        # format. The data dict must minimally contain the ``text/plain``
-        # MIME type which is used as a backup representation.        
-        'data' : dict,
-
-        # Any metadata that describes the data
-        'metadata' : dict
-    }
-
-Python inputs
--------------
-
-These messages are the re-broadcast of the ``execute_request``.
-
-Message type: ``pyin``::
-
-    content = {
-        'code' : str  # Source code to be executed, one or more lines
-    }
-
-Python outputs
---------------
-
-When Python produces output from code that has been compiled in with the
-'single' flag to :func:`compile`, any expression that produces a value (such as
-``1+1``) is passed to ``sys.displayhook``, which is a callable that can do with
-this value whatever it wants.  The default behavior of ``sys.displayhook`` in
-the Python interactive prompt is to print to ``sys.stdout`` the :func:`repr` of
-the value as long as it is not ``None`` (which isn't printed at all).  In our
-case, the kernel instantiates as ``sys.displayhook`` an object which has
-similar behavior, but which instead of printing to stdout, broadcasts these
-values as ``pyout`` messages for clients to display appropriately.
-
-IPython's displayhook can handle multiple simultaneous formats depending on its
-configuration. The default pretty-printed repr text is always given with the
-``data`` entry in this message. Any other formats are provided in the
-``extra_formats`` list. Frontends are free to display any or all of these
-according to its capabilities. ``extra_formats`` list contains 3-tuples of an ID
-string, a type string, and the data. The ID is unique to the formatter
-implementation that created the data. Frontends will typically ignore the ID
-unless if it has requested a particular formatter. The type string tells the
-frontend how to interpret the data. It is often, but not always a MIME type.
-Frontends should ignore types that it does not understand. The data itself is
-any JSON object and depends on the format. It is often, but not always a string.
-
-Message type: ``pyout``::
-
-    content = {
-
-        # The counter for this execution is also provided so that clients can
-        # display it, since IPython automatically creates variables called _N
-        # (for prompt N).
-        'execution_count' : int,
-        
-        # The data dict contains key/value pairs, where the kids are MIME
-        # types and the values are the raw data of the representation in that
-        # format. The data dict must minimally contain the ``text/plain``
-        # MIME type which is used as a backup representation.
-        'data' : dict,
-
-    }
-    
-Python errors
--------------
-
-When an error occurs during code execution
-
-Message type: ``pyerr``::
-
-    content = {
-       # Similar content to the execute_reply messages for the 'error' case,
-       # except the 'status' field is omitted.
-    }
-
-Kernel status
--------------
-
-This message type is used by frontends to monitor the status of the kernel.
-
-Message type: ``status``::
-
-    content = {
-        # When the kernel starts to execute code, it will enter the 'busy'
-        # state and when it finishes, it will enter the 'idle' state.
-        execution_state : ('busy', 'idle')
-    }
-
-Kernel crashes
---------------
-
-When the kernel has an unexpected exception, caught by the last-resort
-sys.excepthook, we should broadcast the crash handler's output before exiting.
-This will allow clients to notice that a kernel died, inform the user and
-propose further actions.
-
-Message type: ``crash``::
-
-    content = {
-       # Similarly to the 'error' case for execute_reply messages, this will
-       # contain exc_name, exc_type and traceback fields.
-
-       # An additional field with supplementary information such as where to
-       # send the crash message
-       'info' : str,
-    }
-
-
-Future ideas
-------------
-    
-Other potential message types, currently unimplemented, listed below as ideas.
-    
-Message type: ``file``::
-
-    content = {
-    'path' : 'cool.jpg',
-    'mimetype' : str,
-    'data' : str,
-    }
-
-    
-Messages on the REQ/REP socket
-==============================
-
-This is a socket that goes in the opposite direction: from the kernel to a
-*single* frontend, and its purpose is to allow ``raw_input`` and similar
-operations that read from ``sys.stdin`` on the kernel to be fulfilled by the
-client.  For now we will keep these messages as simple as possible, since they
-basically only mean to convey the ``raw_input(prompt)`` call.
-
-Message type: ``input_request``::
-
-    content = { 'prompt' : str }
-
-Message type: ``input_reply``::
-
-    content = { 'value' : str }
-    
-.. Note::
-
-   We do not explicitly try to forward the raw ``sys.stdin`` object, because in
-   practice the kernel should behave like an interactive program.  When a
-   program is opened on the console, the keyboard effectively takes over the
-   ``stdin`` file descriptor, and it can't be used for raw reading anymore.
-   Since the IPython kernel effectively behaves like a console program (albeit
-   one whose "keyboard" is actually living in a separate process and
-   transported over the zmq connection), raw ``stdin`` isn't expected to be
-   available.
-
-   
-Heartbeat for kernels
-=====================
-
-Initially we had considered using messages like those above over ZMQ for a
-kernel 'heartbeat' (a way to detect quickly and reliably whether a kernel is
-alive at all, even if it may be busy executing user code).  But this has the
-problem that if the kernel is locked inside extension code, it wouldn't execute
-the python heartbeat code.  But it turns out that we can implement a basic
-heartbeat with pure ZMQ, without using any Python messaging at all.
-
-The monitor sends out a single zmq message (right now, it is a str of the
-monitor's lifetime in seconds), and gets the same message right back, prefixed
-with the zmq identity of the XREQ socket in the heartbeat process. This can be
-a uuid, or even a full message, but there doesn't seem to be a need for packing
-up a message when the sender and receiver are the exact same Python object.
-
-The model is this::
-
-    monitor.send(str(self.lifetime)) # '1.2345678910'
-
-and the monitor receives some number of messages of the form::
-
-    ['uuid-abcd-dead-beef', '1.2345678910']
-
-where the first part is the zmq.IDENTITY of the heart's XREQ on the engine, and
-the rest is the message sent by the monitor.  No Python code ever has any
-access to the message between the monitor's send, and the monitor's recv.
-
-
-ToDo
-====
-
-Missing things include:
-
-* Important: finish thinking through the payload concept and API.
-
-* Important: ensure that we have a good solution for magics like %edit.  It's
-  likely that with the payload concept we can build a full solution, but not
-  100% clear yet.
-
-* Finishing the details of the heartbeat protocol.
-
-* Signal handling: specify what kind of information kernel should broadcast (or
-  not) when it receives signals.
-
-.. include:: ../links.rst
diff --git a/docs/source/development/notification_blueprint.txt b/docs/source/development/notification_blueprint.txt
deleted file mode 100644
index c874de90bc9..00000000000
--- a/docs/source/development/notification_blueprint.txt
+++ /dev/null
@@ -1,123 +0,0 @@
-.. _notification:
-
-==========================================
-IPython.kernel.core.notification blueprint
-==========================================
-
-Overview
-========
-
-The :mod:`IPython.kernel.core.notification` module will provide a simple
-implementation of a notification center and support for the observer pattern
-within the :mod:`IPython.kernel.core`. The main intended use case is to
-provide notification of Interpreter events to an observing frontend during the
-execution of a single block of code.
-
-Functional Requirements
-=======================
-
-The notification center must:
-
-* Provide synchronous notification of events to all registered observers.
-
-* Provide typed or labeled notification types.
-
-* Allow observers to register callbacks for individual or all notification
-  types.
-
-* Allow observers to register callbacks for events from individual or all
-  notifying objects.
-
-* Notification to the observer consists of the notification type, notifying
-  object and user-supplied extra information [implementation: as keyword
-  parameters to the registered callback].
-
-* Perform as O(1) in the case of no registered observers.
-
-* Permit out-of-process or cross-network extension.
-    
-What's not included
-===================
-
-As written, the :mod:`IPython.kernel.core.notification` module does not:
-
-* Provide out-of-process or network notifications (these should be handled by
-  a separate, Twisted aware module in :mod:`IPython.kernel`).
-
-* Provide zope.interface style interfaces for the notification system (these
-  should also be provided by the :mod:`IPython.kernel` module).
-    
-Use Cases
-=========
-
-The following use cases describe the main intended uses of the notification
-module and illustrate the main success scenario for each use case:
-
-Scenario 1
-----------
-
-Dwight Schroot is writing a frontend for the IPython project. His frontend is
-stuck in the stone age and must communicate synchronously with an
-:mod:`IPython.kernel.core.Interpreter` instance. Because code is executed in blocks
-by the Interpreter, Dwight's UI freezes every time he executes a long block of
-code. To keep track of the progress of his long running block, Dwight adds the
-following code to his frontend's set-up code::
-
-    from IPython.kernel.core.notification import NotificationCenter
-    center = NotificationCenter.sharedNotificationCenter
-    center.registerObserver(self, type=IPython.kernel.core.Interpreter.STDOUT_NOTIFICATION_TYPE, notifying_object=self.interpreter, callback=self.stdout_notification)
-
-and elsewhere in his front end::
-
-    def stdout_notification(self, type, notifying_object, out_string=None):
-        self.writeStdOut(out_string)
-    
-If everything works, the Interpreter will (according to its published API)
-fire a notification via the
-:data:`IPython.kernel.core.notification.sharedCenter` of type
-:const:`STD_OUT_NOTIFICATION_TYPE` before writing anything to stdout [it's up
-to the Intereter implementation to figure out when to do this]. The
-notificaiton center will then call the registered callbacks for that event
-type (in this case, Dwight's frontend's stdout_notification method). Again,
-according to its API, the Interpreter provides an additional keyword argument
-when firing the notificaiton of out_string, a copy of the string it will write
-to stdout.
-
-Like magic, Dwight's frontend is able to provide output, even during
-long-running calculations. Now if Jim could just convince Dwight to use
-Twisted...
-
-Scenario 2
-----------
-
-Boss Hog is writing a frontend for the IPython project. Because Boss Hog is
-stuck in the stone age, his frontend will be written in a new Fortran-like
-dialect of python and will run only from the command line. Because he doesn't
-need any fancy notification system and is used to worrying about every cycle
-on his rat-wheel powered mini, Boss Hog is adamant that the new notification
-system not produce any performance penalty. As they say in Hazard county,
-there's no such thing as a free lunch. If he wanted zero overhead, he should
-have kept using IPython 0.8. Instead, those tricky Duke boys slide in a
-suped-up bridge-out jumpin' awkwardly confederate-lovin' notification module
-that imparts only a constant (and small) performance penalty when the
-Interpreter (or any other object) fires an event for which there are no
-registered observers. Of course, the same notificaiton-enabled Interpreter can
-then be used in frontends that require notifications, thus saving the IPython
-project from a nasty civil war.
-
-Scenario 3
-----------
-
-Barry is wrting a frontend for the IPython project. Because Barry's front end
-is the *new hotness*, it uses an asynchronous event model to communicate with
-a Twisted :mod:`IPython.kernel.engineservice` that communicates with the
-IPython :class:`IPython.kernel.core.interpreter.Interpreter`. Using the
-:mod:`IPython.kernel.notification` module, an asynchronous wrapper on the
-:mod:`IPython.kernel.core.notification` module, Barry's frontend can register
-for notifications from the interpreter that are delivered asynchronously. Even
-if Barry's frontend is running on a separate process or even host from the
-Interpreter, the notifications are delivered, as if by dark and twisted magic.
-Just like Dwight's frontend, Barry's frontend can now receive notifications of
-e.g. writing to stdout/stderr, opening/closing an external file, an exception
-in the executing code, etc.
-
diff --git a/docs/source/development/parallel_connections.txt b/docs/source/development/parallel_connections.txt
deleted file mode 100644
index 37b0258e887..00000000000
--- a/docs/source/development/parallel_connections.txt
+++ /dev/null
@@ -1,159 +0,0 @@
-.. _parallel_connections:
-
-==============================================
-Connection Diagrams of The IPython ZMQ Cluster
-==============================================
-
-This is a quick summary and illustration of the connections involved in the ZeroMQ based
-IPython cluster for parallel computing.
-
-All Connections
-===============
-
-The Parallel Computing code is currently under development in IPython's newparallel_
-branch on GitHub.
-
-.. _newparallel: http://github.com/ipython/ipython/tree/newparallel
-
-The IPython cluster consists of a Controller, and one or more each of clients and engines.
-The goal of the Controller is to manage and monitor the connections and communications
-between the clients and the engines.  The Controller is no longer a single process entity,
-but rather a collection of processes - specifically one Hub, and 3 (or more) Schedulers.
-
-It is important for security/practicality reasons that all connections be inbound to the
-controller processes. The arrows in the figures indicate the direction of the
-connection.
-
-
-.. figure:: figs/allconnections.png
-    :width: 432px
-    :alt: IPython cluster connections
-    :align: center
-
-    All the connections involved in connecting one client to one engine.
-
-The Controller consists of 1-4 processes. Central to the cluster is the **Hub**, which monitors
-engine state, execution traffic, and handles registration and notification. The Hub includes a
-Heartbeat Monitor for keeping track of engines that are alive. Outside the Hub are 4
-**Schedulers**. These devices are very small pure-C MonitoredQueue processes (or optionally
-threads) that relay messages very fast, but also send a copy of each message along a side socket
-to the Hub. The MUX queue and Control queue are MonitoredQueue ØMQ devices which relay
-explicitly addressed messages from clients to engines, and their replies back up. The Balanced
-queue performs load-balancing destination-agnostic scheduling. It may be a MonitoredQueue
-device, but may also be a Python Scheduler that behaves externally in an identical fashion to MQ
-devices, but with additional internal logic. stdout/err are also propagated from the Engines to
-the clients via a PUB/SUB MonitoredQueue.
-
-
-Registration
-------------
-
-.. figure:: figs/queryfade.png
-    :width: 432px
-    :alt: IPython Registration connections
-    :align: center
-
-    Engines and Clients only need to know where the Query ``XREP`` is located to start
-    connecting. 
-
-Once a controller is launched, the only information needed for connecting clients and/or
-engines is the IP/port of the Hub's ``XREP`` socket called the Registrar. This socket
-handles connections from both clients and engines, and replies with the remaining
-information necessary to establish the remaining connections. Clients use this same socket for 
-querying the Hub for state information.
-
-Heartbeat
----------
-
-.. figure:: figs/hbfade.png
-    :width: 432px
-    :alt: IPython Heartbeat connections
-    :align: center
-
-    The heartbeat sockets.
-
-The heartbeat process has been described elsewhere. To summarize: the Heartbeat Monitor
-publishes a distinct message periodically via a ``PUB`` socket. Each engine has a
-``zmq.FORWARDER`` device with a ``SUB`` socket for input, and ``XREQ`` socket for output.
-The ``SUB`` socket is connected to the ``PUB`` socket labeled *ping*, and the ``XREQ`` is
-connected to the ``XREP`` labeled *pong*. This results in the same message being relayed
-back to the Heartbeat Monitor with the addition of the ``XREQ`` prefix. The Heartbeat
-Monitor receives all the replies via an ``XREP`` socket, and identifies which hearts are
-still beating by the ``zmq.IDENTITY`` prefix of the ``XREQ`` sockets, which information
-the Hub uses to notify clients of any changes in the available engines.
-
-Schedulers
-----------
-
-.. figure:: figs/queuefade.png
-    :width: 432px
-    :alt: IPython Queue connections
-    :align: center
-
-    Control message scheduler on the left, execution (apply) schedulers on the right.
-
-The controller has at least three Schedulers. These devices are primarily for
-relaying messages between clients and engines, but the Hub needs to see those
-messages for its own purposes. Since no Python code may exist between the two sockets in a
-queue, all messages sent through these queues (both directions) are also sent via a
-``PUB`` socket to a monitor, which allows the Hub to monitor queue traffic without
-interfering with it.
-
-For tasks, the engine need not be specified. Messages sent to the ``XREP`` socket from the
-client side are assigned to an engine via ZMQ's ``XREQ`` round-robin load balancing.
-Engine replies are directed to specific clients via the IDENTITY of the client, which is
-received as a prefix at the Engine.
-
-For Multiplexing, ``XREP`` is used for both in and output sockets in the device. Clients must
-specify the destination by the ``zmq.IDENTITY`` of the ``XREP`` socket connected to
-the downstream end of the device.
-
-At the Kernel level, both of these ``XREP`` sockets are treated in the same way as the ``REP``
-socket in the serial version (except using ZMQStreams instead of explicit sockets).
-
-Execution can be done in a load-balanced (engine-agnostic) or multiplexed (engine-specified)
-manner. The sockets on the Client and Engine are the same for these two actions, but the
-scheduler used determines the actual behavior. This routing is done via the ``zmq.IDENTITY`` of
-the upstream sockets in each MonitoredQueue.
-
-IOPub
------
-
-.. figure:: figs/iopubfade.png
-    :width: 432px
-    :alt: IOPub connections
-    :align: center
-
-    stdout/err are published via a ``PUB/SUB`` MonitoredQueue
-
-
-On the kernels, stdout/stderr are captured and published via a ``PUB`` socket. These ``PUB``
-sockets all connect to a ``SUB`` socket input of a MonitoredQueue, which subscribes to all
-messages. They are then republished via another ``PUB`` socket, which can be
-subscribed by the clients.
-
-Client connections
-------------------
-
-.. figure:: figs/queryfade.png
-    :width: 432px
-    :alt: IPython client query connections
-    :align: center
-
-    Clients connect to an ``XREP`` socket to query the hub.
-
-The hub's registrar ``XREP`` socket also listens for queries from clients as to queue status,
-and control instructions. Clients connect to this socket via an ``XREQ`` during registration.
-
-.. figure:: figs/notiffade.png
-    :width: 432px
-    :alt: IPython Registration connections
-    :align: center
-
-    Engine registration events are published via a ``PUB`` socket.
-
-The Hub publishes all registration/unregistration events via a ``PUB`` socket. This
-allows clients to stay up to date with what engines are available by subscribing to the
-feed with a ``SUB`` socket. Other processes could selectively subscribe to just
-registration or unregistration events.
-
diff --git a/docs/source/development/parallel_messages.txt b/docs/source/development/parallel_messages.txt
deleted file mode 100644
index 95d455beea9..00000000000
--- a/docs/source/development/parallel_messages.txt
+++ /dev/null
@@ -1,378 +0,0 @@
-.. _parallel_messages:
-
-Messaging for Parallel Computing
-================================
-
-This is an extension of the :ref:`messaging <messaging>` doc. Diagrams of the connections
-can be found in the :ref:`parallel connections <parallel_connections>` doc.
-
-
-ZMQ messaging is also used in the parallel computing IPython system. All messages to/from
-kernels remain the same as the single kernel model, and are forwarded through a ZMQ Queue
-device. The controller receives all messages and replies in these channels, and saves
-results for future use.
-
-The Controller
---------------
-
-The controller is the central collection of processes in the IPython parallel computing
-model. It has two major components:
-
-    * The Hub
-    * A collection of Schedulers
-
-The Hub
--------
-
-The Hub is the central process for monitoring the state of the engines, and all task
-requests and results.  It has no role in execution and does no relay of messages, so
-large blocking requests or database actions in the Hub do not have the ability to impede
-job submission and results.
-
-Registration (``XREP``)
-***********************
-
-The first function of the Hub is to facilitate and monitor connections of clients
-and engines. Both client and engine registration are handled by the same socket, so only
-one ip/port pair is needed to connect any number of connections and clients.
-
-Engines register with the ``zmq.IDENTITY`` of their two ``XREQ`` sockets, one for the
-queue, which receives execute requests, and one for the heartbeat, which is used to
-monitor the survival of the Engine process.
-
-Message type: ``registration_request``::
-
-    content = {
-        'queue'   : 'abcd-1234-...', # the MUX queue zmq.IDENTITY
-        'control'   : 'abcd-1234-...', # the control queue zmq.IDENTITY
-        'heartbeat' : 'abcd-1234-...' # the heartbeat zmq.IDENTITY
-    }
-
-.. note::
-
-    these are always the same, at least for now.
-
-The Controller replies to an Engine's registration request with the engine's integer ID,
-and all the remaining connection information for connecting the heartbeat process, and
-kernel queue socket(s). The message status will be an error if the Engine requests IDs that
-already in use.
-
-Message type: ``registration_reply``::
-
-    content = {
-        'status' : 'ok', # or 'error'
-        # if ok:
-        'id' : 0, # int, the engine id
-        'queue' : 'tcp://127.0.0.1:12345', # connection for engine side of the queue
-        'control' : 'tcp://...', # addr for control queue
-        'heartbeat' : ('tcp://...','tcp://...'), # tuple containing two interfaces needed for heartbeat
-        'task' : 'tcp://...', # addr for task queue, or None if no task queue running
-    }
-
-Clients use the same socket as engines to start their connections. Connection requests
-from clients need no information:
-
-Message type: ``connection_request``::
-    
-    content = {}
-
-The reply to a Client registration request contains the connection information for the
-multiplexer and load balanced queues, as well as the address for direct hub
-queries. If any of these addresses is `None`, that functionality is not available.
-
-Message type: ``connection_reply``::
-
-    content = {
-        'status' : 'ok', # or 'error'
-        # if ok:
-        'queue' : 'tcp://127.0.0.1:12345', # connection for client side of the MUX queue
-        'task' : ('lru','tcp...'), # routing scheme and addr for task queue (len 2 tuple)
-        'query' : 'tcp...', # addr for methods to query the hub, like queue_request, etc.
-        'control' : 'tcp...', # addr for control methods, like abort, etc.
-    }
-
-Heartbeat
-*********
-
-The hub uses a heartbeat system to monitor engines, and track when they become
-unresponsive. As described in :ref:`messaging <messaging>`, and shown in :ref:`connections
-<parallel_connections>`.
-
-Notification (``PUB``)
-**********************
-
-The hub publishes all engine registration/unregistration events on a ``PUB`` socket.
-This allows clients to have up-to-date engine ID sets without polling. Registration
-notifications contain both the integer engine ID and the queue ID, which is necessary for
-sending messages via the Multiplexer Queue and Control Queues.
-
-Message type: ``registration_notification``::
-
-    content = {
-        'id' : 0, # engine ID that has been registered
-        'queue' : 'engine_id' # the IDENT for the engine's queue
-    }
-
-Message type : ``unregistration_notification``::
-
-    content = {
-        'id' : 0 # engine ID that has been unregistered
-    }
-
-
-Client Queries (``XREP``)
-*************************
-
-The hub monitors and logs all queue traffic, so that clients can retrieve past
-results or monitor pending tasks. This information may reside in-memory on the Hub, or
-on disk in a database (SQLite and MongoDB are currently supported).  These requests are
-handled by the same socket as registration.
-
-
-:func:`queue_request` requests can specify multiple engines to query via the `targets`
-element. A verbose flag can be passed, to determine whether the result should be the list
-of `msg_ids` in the queue or simply the length of each list.
-
-Message type: ``queue_request``::
-
-    content = {
-        'verbose' : True, # whether return should be lists themselves or just lens
-        'targets' : [0,3,1] # list of ints
-    }
-
-The content of a reply to a :func:`queue_request` request is a dict, keyed by the engine
-IDs. Note that they will be the string representation of the integer keys, since JSON
-cannot handle number keys.  The three keys of each dict are::
-
-    'completed' :  messages submitted via any queue that ran on the engine
-    'queue' : jobs submitted via MUX queue, whose results have not been received
-    'tasks' : tasks that are known to have been submitted to the engine, but 
-                have not completed.  Note that with the pure zmq scheduler, this will
-                always be 0/[].
-
-Message type: ``queue_reply``::
-
-    content = {
-        'status' : 'ok', # or 'error'
-        # if verbose=False:
-        '0' : {'completed' : 1, 'queue' : 7, 'tasks' : 0},
-        # if verbose=True:
-        '1' : {'completed' : ['abcd-...','1234-...'], 'queue' : ['58008-'], 'tasks' : []},
-    }
-
-Clients can request individual results directly from the hub. This is primarily for
-gathering results of executions not submitted by the requesting client, as the client
-will have all its own results already. Requests are made by msg_id, and can contain one or
-more msg_id. An additional boolean key 'statusonly' can be used to not request the
-results, but simply poll the status of the jobs.
-
-Message type: ``result_request``::
-
-    content = {
-        'msg_ids' : ['uuid','...'], # list of strs
-        'targets' : [1,2,3], # list of int ids or uuids
-        'statusonly' : False, # bool
-    }
-
-The :func:`result_request` reply contains the content objects of the actual execution
-reply messages. If `statusonly=True`, then there will be only the 'pending' and
-'completed' lists.  
-
-
-Message type: ``result_reply``::
-
-    content = {
-        'status' : 'ok', # else error
-        # if ok:
-        'acbd-...' : msg, # the content dict is keyed by msg_ids,
-                         # values are the result messages
-                        # there will be none of these if `statusonly=True`
-        'pending' : ['msg_id','...'], # msg_ids still pending
-        'completed' : ['msg_id','...'], # list of completed msg_ids
-    }
-    buffers = ['bufs','...'] # the buffers that contained the results of the objects.
-                            # this will be empty if no messages are complete, or if 
-                            # statusonly is True.
-
-For memory management purposes, Clients can also instruct the hub to forget the
-results of messages. This can be done by message ID or engine ID. Individual messages are
-dropped by msg_id, and all messages completed on an engine are dropped by engine ID. This
-may no longer be necessary with the mongodb-based message logging backend.
-
-If the msg_ids element is the string ``'all'`` instead of a list, then all completed
-results are forgotten.
-
-Message type: ``purge_request``::
-
-    content = {
-        'msg_ids' : ['id1', 'id2',...], # list of msg_ids or 'all'
-        'engine_ids' : [0,2,4] # list of engine IDs
-    }
-
-The reply to a purge request is simply the status 'ok' if the request succeeded, or an
-explanation of why it failed, such as requesting the purge of a nonexistent or pending
-message.
-
-Message type: ``purge_reply``::
-
-    content = {
-        'status' : 'ok', # or 'error'
-    }
-
-
-Schedulers
-----------
-
-There are three basic schedulers:
-
-  * Task Scheduler
-  * MUX Scheduler
-  * Control Scheduler
-
-The MUX and Control schedulers are simple MonitoredQueue ØMQ devices, with ``XREP``
-sockets on either side. This allows the queue to relay individual messages to particular
-targets via ``zmq.IDENTITY`` routing. The Task scheduler may be a MonitoredQueue ØMQ
-device, in which case the client-facing socket is ``XREP``, and the engine-facing socket
-is ``XREQ``.  The result of this is that client-submitted messages are load-balanced via 
-the ``XREQ`` socket, but the engine's replies to each message go to the requesting client.
-
-Raw ``XREQ`` scheduling is quite primitive, and doesn't allow message introspection, so
-there are also Python Schedulers that can be used. These Schedulers behave in much the
-same way as a MonitoredQueue does from the outside, but have rich internal logic to
-determine destinations, as well as handle dependency graphs Their sockets are always
-``XREP`` on both sides.
-
-The Python task schedulers have an additional message type, which informs the Hub of
-the destination of a task as soon as that destination is known.
-
-Message type: ``task_destination``::
-
-    content = {
-        'msg_id' : 'abcd-1234-...', # the msg's uuid
-        'engine_id' : '1234-abcd-...', # the destination engine's zmq.IDENTITY
-    }
-
-:func:`apply` and :func:`apply_bound`
-*************************************
-
-In terms of message classes, the MUX scheduler and Task scheduler relay the exact same
-message types.  Their only difference lies in how the destination is selected.
-
-The `Namespace <http://gist.github.com/483294>`_ model suggests that execution be able to
-use the model::
-
-    ns.apply(f, *args, **kwargs)
-    
-which takes `f`, a function in the user's namespace, and executes ``f(*args, **kwargs)``
-on a remote engine, returning the result (or, for non-blocking, information facilitating
-later retrieval of the result). This model, unlike the execute message which just uses a
-code string, must be able to send arbitrary (pickleable) Python objects. And ideally, copy
-as little data as we can. The `buffers` property of a Message was introduced for this
-purpose.
-
-Utility method :func:`build_apply_message` in :mod:`IPython.zmq.streamsession` wraps a
-function signature and builds a sendable buffer format for minimal data copying (exactly
-zero copies of numpy array data or buffers or large strings).
-
-Message type: ``apply_request``::
-
-    content = {
-        'bound' : True, # whether to execute in the engine's namespace or unbound
-        'after' : ['msg_id',...], # list of msg_ids or output of Dependency.as_dict()
-        'follow' : ['msg_id',...], # list of msg_ids or output of Dependency.as_dict()
-        
-    }
-    buffers = ['...'] # at least 3 in length
-                    # as built by build_apply_message(f,args,kwargs)
-
-after/follow represent task dependencies. 'after' corresponds to a time dependency. The
-request will not arrive at an engine until the 'after' dependency tasks have completed.
-'follow' corresponds to a location dependency. The task will be submitted to the same
-engine as these msg_ids (see :class:`Dependency` docs for details).
-
-Message type: ``apply_reply``::
-
-    content = {
-        'status' : 'ok' # 'ok' or 'error'
-        # other error info here, as in other messages
-    }
-    buffers = ['...'] # either 1 or 2 in length
-                    # a serialization of the return value of f(*args,**kwargs)
-                    # only populated if status is 'ok'
-
-All engine execution and data movement is performed via apply messages.
-
-Control Messages
-----------------
-
-Messages that interact with the engines, but are not meant to execute code, are submitted
-via the Control queue. These messages have high priority, and are thus received and
-handled before any execution requests.
-
-Clients may want to clear the namespace on the engine. There are no arguments nor
-information involved in this request, so the content is empty.
-
-Message type: ``clear_request``::
-
-    content = {}
-
-Message type: ``clear_reply``::
-
-    content = {
-        'status' : 'ok' # 'ok' or 'error'
-        # other error info here, as in other messages
-    }
-
-Clients may want to abort tasks that have not yet run. This can by done by message id, or
-all enqueued messages can be aborted if None is specified.
-
-Message type: ``abort_request``::
-
-    content = {
-        'msg_ids' : ['1234-...', '...'] # list of msg_ids or None
-    }
-
-Message type: ``abort_reply``::
-
-    content = {
-        'status' : 'ok' # 'ok' or 'error'
-        # other error info here, as in other messages
-    }
-
-The last action a client may want to do is shutdown the kernel. If a kernel receives a
-shutdown request, then it aborts all queued messages, replies to the request, and exits.
-
-Message type: ``shutdown_request``::
-
-    content = {}
-
-Message type: ``shutdown_reply``::
-
-    content = {
-        'status' : 'ok' # 'ok' or 'error'
-        # other error info here, as in other messages
-    }
-
-
-Implementation
---------------
-
-There are a few differences in implementation between the `StreamSession` object used in
-the newparallel branch and the `Session` object, the main one being that messages are
-sent in parts, rather than as a single serialized object. `StreamSession` objects also
-take pack/unpack functions, which are to be used when serializing/deserializing objects.
-These can be any functions that translate to/from formats that ZMQ sockets can send
-(buffers,bytes, etc.).
-
-Split Sends
-***********
-
-Previously, messages were bundled as a single json object and one call to
-:func:`socket.send_json`. Since the hub inspects all messages, and doesn't need to
-see the content of the messages, which can be large, messages are now serialized and sent in
-pieces. All messages are sent in at least 3 parts: the header, the parent header, and the
-content. This allows the controller to unpack and inspect the (always small) header,
-without spending time unpacking the content unless the message is bound for the
-controller. Buffers are added on to the end of the message, and can be any objects that
-present the buffer interface.
-
diff --git a/docs/source/development/release.txt b/docs/source/development/release.txt
deleted file mode 100644
index a24dc219126..00000000000
--- a/docs/source/development/release.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-.. _releasing_ipython:
-
-=================
-Releasing IPython
-=================
-
-This section contains notes about the process that is used to release IPython.
-Our release process is currently not very formal and could be improved.
-
-Most of the release process is automated by the :file:`release` script in the
-:file:`tools` directory.  This is just a handy reminder for the release manager.
-
-#. For writing release notes, this will cleanly show who contributed as author
-   of commits (get the previous release name from the tag list with ``git
-   tag``)::
-
-   git log --pretty=format:"* %an" PREV_RELEASE... | sort | uniq
-
-#. Run :file:`build_release`, which does all the file checking and building
-   that the real release script will do.  This will let you do test
-   installations, check that the build procedure runs OK, etc.  You may want to
-   disable a few things like multi-version RPM building while testing, because
-   otherwise the build takes really long.
-
-#. Run the release script, which makes the tar.gz, eggs and Win32 .exe
-   installer.  It posts them to the site and registers the release with PyPI.
-
-#. Update the website with announcements and links to the updated changes.txt
-   in html form. Remember to put a short note both on the news page of the 
-   site and on Launcphad.
-   
-#. Drafting a short release announcement with i) highlights and ii) a link to
-   the html version of the :ref:`Whats new <whatsnew_index>` section of the 
-   documentation.
-
-#. Make sure that the released version of the docs is live on the site.  For
-   this we are now using the gh-pages system:
-
-   - Make a static directory for the final copy of the release docs.
-   - Update the :file:`index.rst` file and run :file:`build_index.py` to update
-     the html version.
-   - Update the ``stable`` symlink to point to the released version.
-   - Run ``git add`` for all the new files and commit.
-   - Run ``git push`` to update the public version of the docs on gh-pages.
-
-#. Celebrate!
\ No newline at end of file
diff --git a/docs/source/development/reorg.txt b/docs/source/development/reorg.txt
deleted file mode 100644
index cd4b2052c39..00000000000
--- a/docs/source/development/reorg.txt
+++ /dev/null
@@ -1,71 +0,0 @@
-.. _module_reorg:
-
-===========================
-IPython module organization
-===========================
-
-As of the 0.11 release of IPython, the top-level packages and modules have
-been completely reorganized.  This section describes the purpose of the
-top-level IPython subpackages.
-
-Subpackage descriptions
-=======================
-
-* :mod:`IPython.config`.  This package contains the configuration system of 
-  IPython, as well as default configuration files for the different IPython
-  applications.
-
-* :mod:`IPython.core`. This sub-package contains the core of the IPython
-  interpreter, but none of its extended capabilities.
-
-* :mod:`IPython.deathrow`. This is for code that is outdated, untested,
-  rotting, or that belongs in a separate third party project. Eventually all
-  this code will either i) be revived by someone willing to maintain it with
-  tests and docs and re-included into IPython or 2) be removed from IPython
-  proper, but put into a separate third-party Python package. No new code will
-  be allowed here. If your favorite extension has been moved here please
-  contact the IPython developer mailing list to help us determine the best
-  course of action.
-
-* :mod:`IPython.extensions`.  This package contains fully supported IPython
-  extensions.  These extensions adhere to the official IPython extension API
-  and can be enabled by adding them to a field in the configuration file.
-  If your extension is no longer in this location, please look in
-  :mod:`IPython.quarantine` and :mod:`IPython.deathrow` and contact the
-  IPython developer mailing list.
-
-* :mod:`IPython.external`. This package contains third party packages and
-  modules that IPython ships internally to reduce the number of dependencies.
-  Usually, these are short, single file modules.
-
-* :mod:`IPython.frontend`. This package contains the various IPython
-  frontends. Currently, the code in this subpackage is very experimental and
-  may be broken.
-
-* :mod:`IPython.gui`.  Another semi-experimental wxPython based IPython GUI.
-
-* :mod:`IPython.kernel`.  This contains IPython's parallel computing system.
-
-* :mod:`IPython.lib`. IPython has many extended capabilities that are not part
-  of the IPython core. These things will go here and in.  Modules in this
-  package are similar to extensions, but don't adhere to the official
-  IPython extension API.
-
-* :mod:`IPython.quarantine`. This is for code that doesn't meet IPython's
-  standards, but that we plan on keeping. To be moved out of this sub-package
-  a module needs to have approval of the core IPython developers, tests and
-  documentation. If your favorite extension has been moved here please contact
-  the IPython developer mailing list to help us determine the best course of
-  action.
-
-* :mod:`IPython.scripts`.  This package contains a variety of top-level
-  command line scripts.  Eventually, these should be moved to the 
-  :file:`scripts` subdirectory of the appropriate IPython subpackage.
-
-* :mod:`IPython.utils`. This sub-package will contain anything that might
-  eventually be found in the Python standard library, like things in
-  :mod:`genutils`. Each sub-module in this sub-package should contain
-  functions and classes that serve a single purpose and that don't
-  depend on things in the rest of IPython.
-
-
diff --git a/docs/source/development/roadmap.txt b/docs/source/development/roadmap.txt
deleted file mode 100644
index d7912cedd47..00000000000
--- a/docs/source/development/roadmap.txt
+++ /dev/null
@@ -1,121 +0,0 @@
-.. _roadmap:
-
-===================
-Development roadmap
-===================
-
-IPython is an ambitious project that is still under heavy development.
-However, we want IPython to become useful to as many people as possible, as
-quickly as possible. To help us accomplish this, we are laying out a roadmap
-of where we are headed and what needs to happen to get there. Hopefully, this
-will help the IPython developers figure out the best things to work on for
-each upcoming release.
-
-Work targeted to particular releases
-====================================
-
-Release 0.11
-------------
-
-* Full module and package reorganization (done).
-
-* Removal of the threaded shells and new implementation of GUI support
-  based on ``PyOSInputHook`` (done).
-
-* Refactor the configuration system (done).
-
-* Prepare to refactor IPython's core by creating a new component and 
-  application system (done).
-
-* Start to refactor IPython's core by turning everything into components
-  (started).
-
-Release 0.12
-------------
-
-* Continue to refactor IPython's core by turning everything into components.
-
-
-Major areas of work
-===================
-
-Refactoring the main IPython core
----------------------------------
-
-During the summer of 2009, we began refactoring IPython's core. The main
-thrust in this work was to make the IPython core into a set of loosely coupled
-components. The base component class for this is
-:class:`IPython.core.component.Component`. This section outlines the status of
-this work.
-
-Parts of the IPython core that have been turned into components:
-
-* The main :class:`~IPython.core.iplib.InteractiveShell` class.
-* The aliases (:mod:`IPython.core.alias`).
-* The display and builtin traps (:mod:`IPython.core.display_trap` and
-  :mod:`IPython.core.builtin_trap`).
-* The prefilter machinery (:mod:`IPython.core.prefilter`).
-
-Parts of the IPythoncore that still need to be turned into components:
-
-* Magics.
-* Input and output history management.
-* Prompts.
-* Tab completers.
-* Logging.
-* Exception handling.
-* Anything else.
-
-Process management for :mod:`IPython.kernel`
---------------------------------------------
-
-A number of things need to be done to improve how processes are started
-up and managed for the parallel computing side of IPython:
-
-* All of the processes need to use the new configuration system, components
-  and application.
-* We need to add support for other batch systems.
-
-Performance problems
---------------------
-
-Currently, we have a number of performance issues in :mod:`IPython.kernel`:
-
-* The controller stores a large amount of state in Python dictionaries. Under
-  heavy usage, these dicts with get very large, causing memory usage problems.
-  We need to develop more scalable solutions to this problem. This will also
-  help the controller to be more fault tolerant.
-
-* We currently don't have a good way of handling large objects in the
-  controller. The biggest problem is that because we don't have any way of
-  streaming objects, we get lots of temporary copies in the low-level buffers.
-  We need to implement a better serialization approach and true streaming
-  support.
-
-* The controller currently unpickles and repickles objects. We need to use the
-  [push|pull]_serialized methods instead.
-
-* Currently the controller is a bottleneck. The best approach for this is to
-  separate the controller itself into multiple processes, one for the core
-  controller and one each for the controller interfaces.
-
-Porting to 3.0
-==============
-
-There are no definite plans for porting of IPython to Python 3. The major 
-issue is the dependency on Twisted framework for the networking/threading 
-stuff. It is possible that it the traditional IPython interactive console 
-could be ported more easily since it has no such dependency. Here are a few
-things that will need to be considered when doing such a port especially
-if we want to have a codebase that works directly on both 2.x and 3.x.
-
-1. The syntax for exceptions changed (PEP 3110). The old `except exc, var`
-   changed to `except exc as var`. At last count there was 78 occurrences of this
-   usage in the code base. This is a particularly problematic issue, because it's
-   not easy to implement it in a 2.5-compatible way.
-
-Because it is quite difficult to support simultaneously Python 2.5 and 3.x, we
-will likely at some point put out a release that requires strictly 2.6 and
-abandons 2.5 compatibility.  This will then allow us to port the code to using
-:func:`print` as a function, `except exc as var` syntax, etc.  But as of
-version 0.11 at least, we will retain Python 2.5 compatibility.
diff --git a/docs/source/development/session_format.txt b/docs/source/development/session_format.txt
deleted file mode 100644
index 26b24d64b5e..00000000000
--- a/docs/source/development/session_format.txt
+++ /dev/null
@@ -1,111 +0,0 @@
-===============================
- IPython session storage notes
-===============================
-
-This document serves as a sample/template for ideas on how to store session
-data on disk.  This stems from discussions we had on various mailing lists, and
-should be considered a pure work in progress.  We haven't settled these ideas
-completely yet, and there's a lot to discuss; this document should just serve
-as a reference of the distilled points from various conversations on multiple
-mailing lists, and will congeal over time on a specific design we implement.
-
-The frontend would store, for now, 5 types of data:
-
-#. Input: this is python/ipython code to be executed.
-
-#. Output (python): result of executing Inputs.
-
-#. Standard output: from subprocesses.
-
-#. Standard error: from subprocesses.
-
-#. Text: arbitrary text.  For now, we'll just store plain text and will defer
-   to the user on how to format it, though it should be valid reST if it is
-   later to be converted into html/pdf.
-
-The non-text cells would be stored on-disk as follows::
-
-    .. input-cell::
-      :id: 1
-
-      3+3
-
-    .. output-cell::
-       :id: 1
-
-       6
-
-    .. input-cell::
-       :id: 2
-
-       ls
-
-    .. stdout-cell::
-       :id: 2
-
-       a.py b.py
-
-    .. input-cell::
-       :id: 3
-
-      !askdfj
-
-    .. stderr-cell::
-       :id: 3
-
-       sh: askdfj: command not found
-
-Brian made some interesting points on the mailing list inspired by the
-Mathematica format, reproduced here for reference:
-
-The Mathematica notebook format is a plain text file that itself is *valid
-Mathematica code*.  This id documented here: 
-
-http://reference.wolfram.com/mathematica/guide/LowLevelNotebookProgramming.html
-
-For examples a simple notebook with one text cell is just::
-
-  Notebook[{Cell['Here is my text', 'Text']}]
-
-Everything - input cells, output cells, static images and all are represented
-in this way and embedded in the plain text notebook file.  The Python
-generalization of this would be the following: 
-
-* A Python notebook is plain text, importable Python code.
-
-* That code is simply a tree of objects that declare the relevant parts of the
-  notebook. 
-
-This has a number of advantages:
-
-* A notebook can be imported, manipulated and run by anyone who has the support
-  code (the notebook module that defines the relevant classes).
-  
-* A notebook doesn't need to be parsed.  It is valid Python and can be imported
-  or exec'd.  Once that is done, you have the full notebook in memory.  You can
-  immediately do anything you want with it.
-  
-* The various Notebook, Cell, Image, etc. classes can know about how to output
-  to various formats, latex, html, reST, XML, etc::
-
-  import mynotebook
-  mynotebook.notebook.export('rest')
-
-* Each individual format (HTML, reST, latex) has weaknesses.  If you pick any
-  one to be *the* notebook format, you are building those weaknesses into your
-  design.  A pure python based notebook format won't suffer from that syndrome.
-  
-* It is a clean separation of the model (Notebook, Cell, Image, etc.) and the
-  view (HTML, reST, etc.).  Picking HTML or reST for the notebook format
-  confuses (at some level) the model and view...
-  
-* Third party code can define new Notebook elements that specify how they can
-  be rendered in different contexts.  For example, matplotlib could ship a
-  Figure element that knows how to render itself as a native PyQt GUI, a static
-  image, a web page, etc.
-  
-* A notebook remains a single plain text file that anyone can edit - even if it
-  has embedded images.  Neither HTML nor reST have the ability to inline
-  graphics in plain text files.  While I love reST, it is a pain that I need an
-  entire directory of files to render a single Sphinx doc.
-  
\ No newline at end of file
diff --git a/docs/source/development/template.py b/docs/source/development/template.py
deleted file mode 100644
index 385e58d9de1..00000000000
--- a/docs/source/development/template.py
+++ /dev/null
@@ -1,51 +0,0 @@
-"""A one-line description.
-
-A longer description that spans multiple lines.  Explain the purpose of the
-file and provide a short list of the key classes/functions it contains.  This
-is the docstring shown when some does 'import foo;foo?' in IPython, so it
-should be reasonably useful and informative.
-"""
-#-----------------------------------------------------------------------------
-# Copyright (c) 2011, the IPython Development Team.
-#
-# Distributed under the terms of the Modified BSD License.
-#
-# The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-from __future__ import print_function
-
-# [remove this comment in production]
-#
-# List all imports, sorted within each section (stdlib/third-party/ipython).
-# For 'import foo', use one import per line.  For 'from foo.bar import a, b, c'
-# it's OK to import multiple items, use the parenthesized syntax 'from foo
-# import (a, b, ...)' if the list needs multiple lines.
-
-# Stdlib imports
-
-# Third-party imports
-
-# Our own imports
-
-
-# [remove this comment in production]
-#
-# Use broad section headers like this one that make it easier to navigate the
-# file, with descriptive titles.  For complex classes, simliar (but indented)
-# headers are useful to organize the internal class structure.
-
-#-----------------------------------------------------------------------------
-# Globals and constants
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Local utilities
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Classes and functions
-#-----------------------------------------------------------------------------
diff --git a/docs/source/development/testing.txt b/docs/source/development/testing.txt
deleted file mode 100644
index abda16ac52f..00000000000
--- a/docs/source/development/testing.txt
+++ /dev/null
@@ -1,391 +0,0 @@
-.. _testing:
-
-==========================================
- Testing IPython for users and developers
-==========================================
-
-Overview
-========
-
-It is extremely important that all code contributed to IPython has tests.
-Tests should be written as unittests, doctests or other entities that the
-IPython test system can detect.  See below for more details on this.
-
-Each subpackage in IPython should have its own :file:`tests` directory that
-contains all of the tests for that subpackage. All of the files in the
-:file:`tests` directory should have the word "tests" in them to enable
-the testing framework to find them.
-
-In docstrings, examples (either using IPython prompts like ``In [1]:`` or
-'classic' python ``>>>`` ones) can and should be included.  The testing system
-will detect them as doctests and will run them; it offers control to skip parts
-or all of a specific doctest if the example is meant to be informative but
-shows non-reproducible information (like filesystem data).
-
-If a subpackage has any dependencies beyond the Python standard library, the
-tests for that subpackage should be skipped if the dependencies are not found.
-This is very important so users don't get tests failing simply because they
-don't have dependencies.
-
-The testing system we use is a hybrid of nose_ and Twisted's trial_ test runner.
-We use both because nose detects more things than Twisted and allows for more
-flexible (and lighter-weight) ways of writing tests; in particular we've
-developed a nose plugin that allows us to paste verbatim IPython sessions and
-test them as doctests, which is extremely important for us.  But the parts of
-IPython that depend on Twisted must be tested using trial, because only trial
-manages the Twisted reactor correctly.
-
-.. _nose: http://code.google.com/p/python-nose
-.. _trial: http://twistedmatrix.com/trac/wiki/TwistedTrial
-
-
-For the impatient: running the tests
-====================================
-
-You can run IPython from the source download directory without even installing
-it system-wide or having configure anything, by typing at the terminal:
-
-.. code-block:: bash
-
-   python ipython.py
-
-In order to run the test suite, you must at least be able to import IPython,
-even if you haven't fully installed the user-facing scripts yet (common in a
-development environment).  You can then run the tests with:
-
-.. code-block:: bash
-
-  python -c "import IPython; IPython.test()"
-
-Once you have installed IPython either via a full install or using:
-
-.. code-block:: bash
-
-  python setup.py develop
-
-you will have available a system-wide script called :file:`iptest` that runs
-the full test suite.  You can then run the suite with:
-
-.. code-block:: bash
-
-   iptest  [args]
-
-
-Regardless of how you run things, you should eventually see something like:
-
-.. code-block:: bash
-
-   **********************************************************************
-   Test suite completed for system with the following information:
-   {'commit_hash': '144fdae',
-    'commit_source': 'repository',
-    'ipython_path': '/home/fperez/usr/lib/python2.6/site-packages/IPython',
-    'ipython_version': '0.11.dev',
-    'os_name': 'posix',
-    'platform': 'Linux-2.6.35-22-generic-i686-with-Ubuntu-10.10-maverick',
-    'sys_executable': '/usr/bin/python',
-    'sys_platform': 'linux2',
-    'sys_version': '2.6.6 (r266:84292, Sep 15 2010, 15:52:39) \n[GCC 4.4.5]'}
-
-   Tools and libraries available at test time:
-      curses foolscap gobject gtk pexpect twisted wx wx.aui zope.interface
-
-   Ran 9 test groups in 67.213s
-
-   Status:
-   OK
-
-
-If not, there will be a message indicating which test group failed and how to
-rerun that group individually.  For example, this tests the
-:mod:`IPython.utils` subpackage, the :option:`-v` option shows progress
-indicators:
-
-.. code-block:: bash
-
-   $ iptest -v IPython.utils
-   ..........................SS..SSS............................S.S...
-   .........................................................
-   ----------------------------------------------------------------------
-   Ran 125 tests in 0.119s
-
-   OK (SKIP=7)
-
-
-Because the IPython test machinery is based on nose, you can use all nose
-options and syntax, typing ``iptest -h`` shows all available options.  For
-example, this lets you run the specific test :func:`test_rehashx` inside the
-:mod:`test_magic` module:
-
-.. code-block:: bash
-
-   $ iptest -vv IPython.core.tests.test_magic:test_rehashx
-   IPython.core.tests.test_magic.test_rehashx(True,) ... ok
-   IPython.core.tests.test_magic.test_rehashx(True,) ... ok
-
-   ----------------------------------------------------------------------
-   Ran 2 tests in 0.100s
-
-   OK
-
-When developing, the :option:`--pdb` and :option:`--pdb-failures` of nose are
-particularly useful, these drop you into an interactive pdb session at the
-point of the error or failure respectively.
-
-To run Twisted-using tests, use the :command:`trial` command on a per file or
-package basis:
-
-.. code-block:: bash
-
-    trial IPython.kernel
-
-.. note::
-
-   The system information summary printed above is accessible from the top
-   level package.  If you encounter a problem with IPython, it's useful to
-   include this information when reporting on the mailing list; use::
-
-       from IPython import sys_info
-       print sys_info()
-
-   and include the resulting information in your query.
-
-For developers: writing tests
-=============================
-
-By now IPython has a reasonable test suite, so the best way to see what's
-available is to look at the :file:`tests` directory in most subpackages.  But
-here are a few pointers to make the process easier.
-
-
-Main tools: :mod:`IPython.testing`
-----------------------------------
-
-The :mod:`IPython.testing` package is where all of the machinery to test
-IPython (rather than the tests for its various parts) lives.  In particular,
-the :mod:`iptest` module in there has all the smarts to control the test
-process.  In there, the :func:`make_exclude` function is used to build a
-blacklist of exclusions, these are modules that do not get even imported for
-tests.  This is important so that things that would fail to even import because
-of missing dependencies don't give errors to end users, as we stated above.
-
-The :mod:`decorators` module contains a lot of useful decorators, especially
-useful to mark individual tests that should be skipped under certain conditions
-(rather than blacklisting the package altogether because of a missing major
-dependency).
-
-Our nose plugin for doctests
-----------------------------
-
-The :mod:`plugin` subpackage in testing contains a nose plugin called
-:mod:`ipdoctest` that teaches nose about IPython syntax, so you can write
-doctests with IPython prompts.  You can also mark doctest output with ``#
-random`` for the output corresponding to a single input to be ignored (stronger
-than using ellipsis and useful to keep it as an example).  If you want the
-entire docstring to be executed but none of the output from any input to be
-checked, you can use the ``# all-random`` marker.  The
-:mod:`IPython.testing.plugin.dtexample` module contains examples of how to use
-these; for reference here is how to use ``# random``::
-
-    def ranfunc():
-	"""A function with some random output.
-
-	   Normal examples are verified as usual:
-	   >>> 1+3
-	   4
-
-	   But if you put '# random' in the output, it is ignored:
-	   >>> 1+3
-	   junk goes here...  # random
-
-	   >>> 1+2
-	   again,  anything goes #random
-	   if multiline, the random mark is only needed once.
-
-	   >>> 1+2
-	   You can also put the random marker at the end:
-	   # random
-
-	   >>> 1+2
-	   # random
-	   .. or at the beginning.
-
-	   More correct input is properly verified:
-	   >>> ranfunc()
-	   'ranfunc'
-	"""
-	return 'ranfunc'
-
-and an example of ``# all-random``::
-	
-    def random_all():
-	"""A function where we ignore the output of ALL examples.
-
-	Examples:
-
-	  # all-random
-
-	  This mark tells the testing machinery that all subsequent examples
-	  should be treated as random (ignoring their output).  They are still
-	  executed, so if a they raise an error, it will be detected as such,
-	  but their output is completely ignored.
-
-	  >>> 1+3
-	  junk goes here...
-
-	  >>> 1+3
-	  klasdfj;
-
-	In [8]: print 'hello'
-	world  # random
-
-	In [9]: iprand()
-	Out[9]: 'iprand'
-	"""
-	return 'iprand'
-
-
-When writing docstrings, you can use the ``@skip_doctest`` decorator to
-indicate that a docstring should *not* be treated as a doctest at all.  The
-difference between ``# all-random`` and ``@skip_doctest`` is that the former
-executes the example but ignores output, while the latter doesn't execute any
-code.  ``@skip_doctest`` should be used for docstrings whose examples are
-purely informational.
-
-If a given docstring fails under certain conditions but otherwise is a good
-doctest, you can use code like the following, that relies on the 'null'
-decorator to leave the docstring intact where it works as a test::
-
-  # The docstring for full_path doctests differently on win32 (different path
-  # separator) so just skip the doctest there, and use a null decorator
-  # elsewhere:
-  
-  doctest_deco = dec.skip_doctest if sys.platform == 'win32' else dec.null_deco
-
-  @doctest_deco
-  def full_path(startPath,files):
-      """Make full paths for all the listed files, based on startPath..."""
-
-      # function body follows...
-
-With our nose plugin that understands IPython syntax, an extremely effective
-way to write tests is to simply copy and paste an interactive session into a
-docstring.  You can writing this type of test, where your docstring is meant
-*only* as a test, by prefixing the function name with ``doctest_`` and leaving
-its body *absolutely empty* other than the docstring.  In
-:mod:`IPython.core.tests.test_magic` you can find several examples of this, but
-for completeness sake, your code should look like this (a simple case)::
-
-    def doctest_time():
-	"""
-	In [10]: %time None
-	CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
-	Wall time: 0.00 s
-	"""
-	
-This function is only analyzed for its docstring but it is not considered a
-separate test, which is why its body should be empty.
-
-
-Parametric tests done right
----------------------------
-
-If you need to run multiple tests inside the same standalone function or method
-of a :class:`unittest.TestCase` subclass, IPython provides the ``parametric``
-decorator for this purpose.  This is superior to how test generators work in
-nose, because IPython's keeps intact your stack, which makes debugging vastly
-easier.  For example, these are some parametric tests both in class form and as
-a standalone function (choose in each situation the style that best fits the
-problem at hand, since both work)::
-
-  from IPython.testing import decorators as dec
-
-  def is_smaller(i,j):
-      assert i<j,"%s !< %s" % (i,j)
-
-  class Tester(ParametricTestCase):
-
-      def test_parametric(self):
-	  yield is_smaller(3, 4)
-	  x, y = 1, 2
-	  yield is_smaller(x, y)
-
-  @dec.parametric
-  def test_par_standalone():
-      yield is_smaller(3, 4)
-      x, y = 1, 2
-      yield is_smaller(x, y)
-      
-
-Writing tests for Twisted-using code
-------------------------------------
-      
-Tests of Twisted [Twisted]_ using code should be written by subclassing the
-``TestCase`` class that comes with ``twisted.trial.unittest``. Furthermore, all
-:class:`Deferred` instances that are created in the test must be properly
-chained and the final one *must* be the return value of the test method.
-
-.. note::
-  
-  The best place to see how to use the testing tools, are the tests for these
-  tools themselves, which live in :mod:`IPython.testing.tests`.
-  
-    
-Design requirements
-===================
-
-This section is a set of notes on the key points of the IPython testing needs,
-that were used when writing the system and should be kept for reference as it
-eveolves.
-
-Testing IPython in full requires modifications to the default behavior of nose
-and doctest, because the IPython prompt is not recognized to determine Python
-input, and because IPython admits user input that is not valid Python (things
-like ``%magics`` and ``!system commands``.
-
-We basically need to be able to test the following types of code:
-
-1. Pure Python files containing normal tests.  These are not a problem, since
-   Nose will pick them up as long as they conform to the (flexible) conventions
-   used by nose to recognize tests.
-
-2. Python files containing doctests.  Here, we have two possibilities:
-   - The prompts are the usual ``>>>`` and the input is pure Python.
-   - The prompts are of the form ``In [1]:`` and the input can contain extended
-     IPython expressions.
-
-   In the first case, Nose will recognize the doctests as long as it is called
-   with the ``--with-doctest`` flag.  But the second case will likely require
-   modifications or the writing of a new doctest plugin for Nose that is
-   IPython-aware.
-
-3. ReStructuredText files that contain code blocks.  For this type of file, we
-   have three distinct possibilities for the code blocks:
-   - They use ``>>>`` prompts.
-   - They use ``In [1]:`` prompts.
-   - They are standalone blocks of pure Python code without any prompts.
-
-   The first two cases are similar to the situation #2 above, except that in
-   this case the doctests must be extracted from input code blocks using
-   docutils instead of from the Python docstrings.
-
-   In the third case, we must have a convention for distinguishing code blocks
-   that are meant for execution from others that may be snippets of shell code
-   or other examples not meant to be run.  One possibility is to assume that
-   all indented code blocks are meant for execution, but to have a special
-   docutils directive for input that should not be executed.
-
-   For those code blocks that we will execute, the convention used will simply
-   be that they get called and are considered successful if they run to
-   completion without raising errors.  This is similar to what Nose does for
-   standalone test functions, and by putting asserts or other forms of
-   exception-raising statements it becomes possible to have literate examples
-   that double as lightweight tests.
-
-4. Extension modules with doctests in function and method docstrings.
-   Currently Nose simply can't find these docstrings correctly, because the
-   underlying doctest DocTestFinder object fails there.  Similarly to #2 above,
-   the docstrings could have either pure python or IPython prompts.
-
-Of these, only 3-c (reST with standalone code blocks) is not implemented at
-this point.
diff --git a/docs/source/development/wrapperkernels.rst b/docs/source/development/wrapperkernels.rst
new file mode 100644
index 00000000000..a15cf8e4326
--- /dev/null
+++ b/docs/source/development/wrapperkernels.rst
@@ -0,0 +1,175 @@
+Making simple Python wrapper kernels
+====================================
+
+.. versionadded:: 3.0
+
+You can now re-use the kernel machinery in IPython to easily make new kernels.
+This is useful for languages that have Python bindings, such as `Octave
+<http://www.gnu.org/software/octave/>`_ (via
+`Oct2Py <http://blink1073.github.io/oct2py/>`_), or languages
+where the REPL can be controlled in a tty using `pexpect <https://pexpect.readthedocs.io/en/latest/>`_,
+such as bash.
+
+.. seealso::
+
+   `bash_kernel <https://github.com/takluyver/bash_kernel>`_
+     A simple kernel for bash, written using this machinery
+
+Required steps
+--------------
+
+Subclass :class:`ipykernel.kernelbase.Kernel`, and implement the
+following methods and attributes:
+
+.. class:: MyKernel
+
+   .. attribute:: implementation
+                  implementation_version
+                  language
+                  language_version
+                  banner
+    
+     Information for :ref:`msging_kernel_info` replies. 'Implementation' refers
+     to the kernel (e.g. IPython), and 'language' refers to the language it
+     interprets (e.g. Python). The 'banner' is displayed to the user in console
+     UIs before the first prompt. All of these values are strings.
+
+   .. attribute:: language_info
+
+     Language information for :ref:`msging_kernel_info` replies, in a dictionary.
+     This should contain the key ``mimetype`` with the mimetype of code in the
+     target language (e.g. ``'text/x-python'``), and ``file_extension`` (e.g.
+     ``'py'``).
+     It may also contain keys ``codemirror_mode`` and ``pygments_lexer`` if they
+     need to differ from :attr:`language`.
+
+     Other keys may be added to this later.
+
+   .. method:: do_execute(code, silent, store_history=True, user_expressions=None, allow_stdin=False)
+   
+     Execute user code.
+     
+     :param str code: The code to be executed.
+     :param bool silent: Whether to display output.
+     :param bool store_history: Whether to record this code in history and
+         increase the execution count. If silent is True, this is implicitly
+         False.
+     :param dict user_expressions: Mapping of names to expressions to evaluate
+         after the code has run. You can ignore this if you need to.
+     :param bool allow_stdin: Whether the frontend can provide input on request
+         (e.g. for Python's :func:`raw_input`).
+     
+     Your method should return a dict containing the fields described in
+     :ref:`execution_results`. To display output, it can send messages
+     using :meth:`~ipykernel.kernelbase.Kernel.send_response`.
+     See :doc:`messaging` for details of the different message types.
+
+To launch your kernel, add this at the end of your module::
+
+    if __name__ == '__main__':
+        from ipykernel.kernelapp import IPKernelApp
+        IPKernelApp.launch_instance(kernel_class=MyKernel)
+
+Example
+-------
+
+``echokernel.py`` will simply echo any input it's given to stdout::
+
+    from ipykernel.kernelbase import Kernel
+
+    class EchoKernel(Kernel):
+        implementation = 'Echo'
+        implementation_version = '1.0'
+        language = 'no-op'
+        language_version = '0.1'
+        language_info = {'mimetype': 'text/plain'}
+        banner = "Echo kernel - as useful as a parrot"
+
+        def do_execute(self, code, silent, store_history=True, user_expressions=None,
+                       allow_stdin=False):
+            if not silent:
+                stream_content = {'name': 'stdout', 'text': code}
+                self.send_response(self.iopub_socket, 'stream', stream_content)
+
+            return {'status': 'ok',
+                    # The base class increments the execution count
+                    'execution_count': self.execution_count,
+                    'payload': [],
+                    'user_expressions': {},
+                   }
+
+    if __name__ == '__main__':
+        from ipykernel.kernelapp import IPKernelApp
+        IPKernelApp.launch_instance(kernel_class=EchoKernel)
+
+Here's the Kernel spec ``kernel.json`` file for this::
+
+    {"argv":["python","-m","echokernel", "-f", "{connection_file}"],
+     "display_name":"Echo"
+    }
+
+
+Optional steps
+--------------
+
+You can override a number of other methods to improve the functionality of your
+kernel. All of these methods should return a dictionary as described in the
+relevant section of the :doc:`messaging spec <messaging>`.
+
+.. class:: MyBetterKernel
+
+   .. method:: do_complete(code, cusor_pos)
+
+     Code completion
+     
+     :param str code: The code already present
+     :param int cursor_pos: The position in the code where completion is requested
+     
+     .. seealso::
+     
+        :ref:`msging_completion` messages
+
+   .. method:: do_inspect(code, cusor_pos, detail_level=0)
+
+     Object introspection
+     
+     :param str code: The code
+     :param int cursor_pos: The position in the code where introspection is requested
+     :param int detail_level: 0 or 1 for more or less detail. In IPython, 1 gets
+         the source code.
+     
+     .. seealso::
+     
+        :ref:`msging_inspection` messages
+
+   .. method:: do_history(hist_access_type, output, raw, session=None, start=None, stop=None, n=None, pattern=None, unique=False)
+
+     History access. Only the relevant parameters for the type of history
+     request concerned will be passed, so your method definition must have defaults
+     for all the arguments shown with defaults here.
+
+     .. seealso::
+     
+        :ref:`msging_history` messages
+
+   .. method:: do_is_complete(code)
+   
+     Is code entered in a console-like interface complete and ready to execute,
+     or should a continuation prompt be shown?
+     
+     :param str code: The code entered so far - possibly multiple lines
+     
+     .. seealso::
+     
+        :ref:`msging_is_complete` messages
+
+   .. method:: do_shutdown(restart)
+
+     Shutdown the kernel. You only need to handle your own clean up - the kernel
+     machinery will take care of cleaning up its own things before stopping.
+     
+     :param bool restart: Whether the kernel will be started again afterwards
+     
+     .. seealso::
+     
+        :ref:`msging_shutdown` messages
diff --git a/docs/source/faq.txt b/docs/source/faq.txt
deleted file mode 100644
index 60dc3bfcaf2..00000000000
--- a/docs/source/faq.txt
+++ /dev/null
@@ -1,93 +0,0 @@
-.. _faq:
-
-========================================
-Frequently asked questions
-========================================
-
-General questions
-=================
-
-Questions about parallel computing with IPython
-================================================
-
-Will IPython speed my Python code up?
---------------------------------------
-
-Yes and no. When converting a serial code to run in parallel, there often many
-difficulty questions that need to be answered, such as:
-
-* How should data be decomposed onto the set of processors?
-
-* What are the data movement patterns?
-
-* Can the algorithm be structured to minimize data movement?
-
-* Is dynamic load balancing important?
-
-We can't answer such questions for you. This is the hard (but fun) work of parallel
-computing. But, once you understand these things IPython will make it easier for you to
-implement a good solution quickly. Most importantly, you will be able to use the
-resulting parallel code interactively.
-
-With that said, if your problem is trivial to parallelize, IPython has a number of
-different interfaces that will enable you to parallelize things is almost no time at
-all.  A good place to start is the ``map`` method of our :class:`MultiEngineClient`.
-
-What is the best way to use MPI from Python?
---------------------------------------------
-
-What about all the other parallel computing packages in Python?
----------------------------------------------------------------
-
-Some of the unique characteristic of IPython are:
-
-* IPython is the only architecture that abstracts out the notion of a 
-  parallel computation in such a way that new models of parallel computing
-  can be explored quickly and easily.  If you don't like the models we
-  provide, you can simply create your own using the capabilities we provide.
-  
-* IPython is asynchronous from the ground up (we use `Twisted`_).
-
-* IPython's architecture is designed to avoid subtle problems 
-  that emerge because of Python's global interpreter lock (GIL).
-  
-* While IPython's architecture is designed to support a wide range
-  of novel parallel computing models, it is fully interoperable with
-  traditional MPI applications.
-  
-* IPython has been used and tested extensively on modern supercomputers.
-
-* IPython's networking layers are completely modular.  Thus, is 
-  straightforward to replace our existing network protocols with 
-  high performance alternatives (ones based upon Myranet/Infiniband).
-  
-* IPython is designed from the ground up to support collaborative
-  parallel computing.  This enables multiple users to actively develop
-  and run the *same* parallel computation.
-  
-* Interactivity is a central goal for us.  While IPython does not have
-  to be used interactivly, it can be.
-      
-.. _Twisted: http://www.twistedmatrix.com
-
-Why The IPython controller a bottleneck in my parallel calculation?
--------------------------------------------------------------------
-
-A golden rule in parallel computing is that you should only move data around if you
-absolutely need to. The main reason that the controller becomes a bottleneck is that
-too much data is being pushed and pulled to and from the engines. If your algorithm
-is structured in this way, you really should think about alternative ways of
-handling the data movement. Here are some ideas:
-
-1. Have the engines write data to files on the locals disks of the engines.
-
-2. Have the engines write data to files on a file system that is shared by
-   the engines.
-
-3. Have the engines write data to a database that is shared by the engines.
-
-4. Simply keep data in the persistent memory of the engines and move the
-   computation to the data (rather than the data to the computation).
-
-5. See if you can pass data directly between engines using MPI.
-
diff --git a/docs/source/index.rst b/docs/source/index.rst
new file mode 100644
index 00000000000..8803c6f6c0c
--- /dev/null
+++ b/docs/source/index.rst
@@ -0,0 +1,116 @@
+.. _introduction:
+
+=====================
+IPython Documentation
+=====================
+
+.. only:: html
+
+   :Release: |release|
+   :Date: |today|
+
+Welcome to the official IPython documentation.
+
+IPython provides a rich toolkit to help you make the most of using Python
+interactively.  Its main components are:
+
+* A powerful interactive Python shell.
+
+
+    .. image:: ./_images/ipython-6-screenshot.png
+        :alt: Screenshot of IPython 6.0
+        :align: center
+
+
+* A `Jupyter <https://jupyter.org/>`_ kernel to work with Python code in Jupyter
+  notebooks and other interactive frontends.
+
+The enhanced interactive Python shells and kernel have the following main
+features:
+
+* Comprehensive object introspection.
+
+* Input history, persistent across sessions.
+
+* Caching of output results during a session with automatically generated
+  references.
+
+* Extensible tab completion, with support by default for completion of python
+  variables and keywords, filenames and function keywords.
+
+* Extensible system of 'magic' commands for controlling the environment and
+  performing many tasks related to IPython or the operating system.
+
+* A rich configuration system with easy switching between different setups
+  (simpler than changing ``$PYTHONSTARTUP`` environment variables every time).
+
+* Session logging and reloading.
+
+* Extensible syntax processing for special purpose situations.
+
+* Access to the system shell with user-extensible alias system.
+
+* Easily embeddable in other Python programs and GUIs.
+
+* Integrated access to the pdb debugger and the Python profiler.
+
+
+The Command line interface inherits the above functionality and adds 
+ 
+* real multi-line editing thanks to `prompt_toolkit <https://python-prompt-toolkit.readthedocs.io/en/stable/>`_.
+ 
+* syntax highlighting as you type.
+
+* integration with command line editor for a better workflow.
+
+The kernel also has its share of features. When used with a compatible frontend,
+it allows:
+
+* the object to create a rich display of Html, Images, Latex, Sound and
+  Video.
+
+* interactive widgets with the use of the `ipywidgets <https://ipywidgets.readthedocs.io/en/stable/>`_ package.
+
+
+This documentation will walk you through most of the features of the IPython
+command line and kernel, as well as describe the internal mechanisms in order
+to improve your Python workflow.
+
+You can find the table of content for this documentation in the left
+sidebar, allowing you to come back to previous sections or skip ahead, if needed. 
+
+
+The latest development version is always available from IPython's `GitHub
+repository <https://github.com/ipython/ipython>`_.
+
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+   self
+   overview
+   whatsnew/index
+   install/index
+   interactive/index
+   config/index
+   development/index
+   coredev/index
+   api/index
+   sphinxext
+   about/index
+
+.. seealso::
+
+   `Jupyter documentation <https://jupyter.readthedocs.io/en/latest/>`__
+     The Jupyter documentation provides information about the Notebook code and other Jupyter sub-projects.
+   `ipyparallel documentation <https://ipyparallel.readthedocs.io/en/latest/>`__
+     Formerly ``IPython.parallel``.
+
+
+.. only:: html
+
+   * :ref:`genindex`
+   * :ref:`modindex`
+   * :ref:`search`
+
diff --git a/docs/source/index.txt b/docs/source/index.txt
deleted file mode 100644
index 243bdec4e9d..00000000000
--- a/docs/source/index.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-=====================
-IPython Documentation
-=====================
-
-.. htmlonly::
-
-   :Release: |release|
-   :Date: |today|
-
-Welcome to the official IPython documentation.
-
-Contents
-========
-
-.. toctree::
-   :maxdepth: 1
-
-   overview.txt
-   whatsnew/index.txt
-   install/index.txt
-   interactive/index.txt
-   parallel/index.txt
-   config/index.txt
-   development/index.txt
-   api/index.txt
-   faq.txt
-   about/index.txt
-
-.. htmlonly::
-   * :ref:`genindex`
-   * :ref:`modindex`
-   * :ref:`search`
-
diff --git a/docs/source/install/index.rst b/docs/source/install/index.rst
new file mode 100644
index 00000000000..41036d83675
--- /dev/null
+++ b/docs/source/install/index.rst
@@ -0,0 +1,58 @@
+.. _install_index:
+
+============
+Installation
+============
+
+.. toctree::
+   :maxdepth: 3
+   :hidden:
+
+
+   install
+   kernel_install
+
+
+
+This sections will guide you through :ref:`installing IPython itself <install>`, and
+installing :ref:`kernels for Jupyter <kernel_install>` if you wish to work with
+multiple version of Python, or multiple environments.
+
+
+Quick install reminder
+~~~~~~~~~~~~~~~~~~~~~~
+
+Here is a quick reminder of the commands needed for installation if you are
+already familiar with IPython and are just searching to refresh your memory:
+
+Install IPython:
+
+.. code-block:: bash
+
+    $ pip install ipython
+
+
+Install and register an IPython kernel with Jupyter:
+
+
+.. code-block:: bash
+
+    $ python -m pip install ipykernel
+
+    $ python -m ipykernel install [--user] [--name <machine-readable-name>] [--display-name <"User Friendly Name">]
+
+for more help see 
+
+.. code-block:: bash
+    
+    $ python -m ipykernel install  --help
+    
+
+
+.. seealso::
+
+   `Installing Jupyter <https://jupyter.readthedocs.io/en/latest/install.html>`__
+     The Notebook, nbconvert, and many other former pieces of IPython are now
+     part of Project Jupyter.
+
+
diff --git a/docs/source/install/index.txt b/docs/source/install/index.txt
deleted file mode 100644
index 9879894420f..00000000000
--- a/docs/source/install/index.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-.. _install_index:
-
-============
-Installation
-============
-
-.. toctree::
-   :maxdepth: 2
-
-   install.txt
-
diff --git a/docs/source/install/install.rst b/docs/source/install/install.rst
new file mode 100644
index 00000000000..a8f754cc920
--- /dev/null
+++ b/docs/source/install/install.rst
@@ -0,0 +1,141 @@
+.. _install:
+
+Installing IPython
+==================
+
+
+IPython requires Python ≥ 3.11.
+
+
+Quick Install 
+-------------
+
+With ``pip`` already installed :
+
+.. code-block:: bash
+
+    $ pip install ipython
+
+This installs IPython as well as its dependencies.
+
+If you want to use IPython with notebooks or the Qt console, you should also
+install Jupyter ``pip install jupyter``.
+
+
+
+Overview
+--------
+
+This document describes in detail the steps required to install IPython. For a
+few quick ways to get started with package managers or full Python
+distributions, see `the install page <https://ipython.org/install.html>`_ of the
+IPython website.
+
+Please let us know if you have problems installing IPython or any of its
+dependencies.
+
+IPython and most dependencies should be installed via :command:`pip`.
+In many scenarios, this is the simplest method of installing Python packages.
+More information about :mod:`pip` can be found on
+`its PyPI page <https://pip.pypa.io>`__.
+
+
+More general information about installing Python packages can be found in
+:external+python:doc:`Python's documentation <installing/index>`.
+
+.. _dependencies:
+
+Dependencies
+~~~~~~~~~~~~
+
+IPython relies on a number of other Python packages. Installing using a package
+manager like pip or conda will ensure the necessary packages are installed.
+Manual installation without dependencies is possible, but not recommended.
+The dependencies can be viewed with package manager commands,
+such as :command:`pip show ipython` or :command:`conda info ipython`.
+
+
+Installing IPython itself
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+IPython requires several dependencies to work correctly, it is not recommended
+to install IPython and all its dependencies manually as this can be quite long
+and troublesome. You should use the python package manager ``pip``.
+
+Installation using pip
+~~~~~~~~~~~~~~~~~~~~~~
+
+Make sure you have the latest version of :mod:`pip` (the Python package
+manager) installed. If you do not, head to `Pip documentation
+<https://pip.pypa.io/en/stable/installing/>`_ and install :mod:`pip` first.
+
+The quickest way to get up and running with IPython is to install it with pip:
+
+.. code-block:: bash
+
+    $ pip install ipython
+
+That's it.
+
+
+Optional: Command-line completion
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+IPython supports command-line completion via the ``argcomplete`` package.
+To enable tab completion for IPython and other Python programs that support
+argcomplete, install IPython with the ``terminal`` extra:
+
+.. code-block:: bash
+
+    $ pip install ipython[all]
+    $ activate-global-python-argcomplete
+
+Alternatively, you can install argcomplete separately:
+
+.. code-block:: bash
+
+    $ pip install argcomplete
+    $ activate-global-python-argcomplete
+
+This will enable shell completion for all Python programs that support argcomplete,
+including IPython. Note that you may need to restart your shell for the changes
+to take effect.
+
+For more information, see the `argcomplete documentation <https://github.com/kislyuk/argcomplete>`_.
+
+
+.. _devinstall:
+
+Installing the development version
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+It is also possible to install the development version of IPython from our
+`Git <https://git-scm.com/>`_ source code repository.  To do this you will
+need to have Git installed on your system.  
+
+
+Then do:
+
+.. code-block:: bash
+
+    $ git clone https://github.com/ipython/ipython.git
+    $ cd ipython
+    $ pip install -e '.[test]'
+
+The :command:`pip install -e .` command allows users and developers to follow
+the development branch as it changes by creating links in the right places and
+installing the command line scripts to the appropriate locations.
+
+Then, if you want to update your IPython at any time, do:
+
+.. code-block:: bash
+
+    $ git pull
+
+If the dependencies or entrypoints have changed, you may have to run
+
+.. code-block:: bash
+
+    $ pip install -e .
+
+again, but this is infrequent.
diff --git a/docs/source/install/install.txt b/docs/source/install/install.txt
deleted file mode 100644
index 1a3e77d03d3..00000000000
--- a/docs/source/install/install.txt
+++ /dev/null
@@ -1,332 +0,0 @@
-Overview
-========
-
-This document describes the steps required to install IPython.  IPython is
-organized into a number of subpackages, each of which has its own dependencies.
-All of the subpackages come with IPython, so you don't need to download and
-install them separately.  However, to use a given subpackage, you will need to
-install all of its dependencies.
-
-
-Please let us know if you have problems installing IPython or any of its
-dependencies. Officially, IPython requires Python version 2.6 or 2.7.  There
-is an experimental port of IPython for Python3 `on GitHub 
-<https://github.com/ipython/ipython-py3k>`_
-
-.. warning::
-
-    Officially, IPython supports Python versions 2.6 and 2.7.
-
-    IPython 0.11 has a hard syntax dependency on 2.6, and will no longer work
-    on Python <= 2.5.
-
-Some of the installation approaches use the :mod:`setuptools` package and its
-:command:`easy_install` command line program.  In many scenarios, this provides
-the most simple method of installing IPython and its dependencies.  It is not
-required though.  More information about :mod:`setuptools` can be found on its
-website.
-
-More general information about installing Python packages can be found in
-Python's documentation at http://www.python.org/doc/.
-
-Quickstart
-==========
-
-If you have :mod:`setuptools` installed and you are on OS X or Linux (not
-Windows), the following will download and install IPython *and* the main
-optional dependencies:
-
-.. code-block:: bash
-
-    $ easy_install ipython[zmq,test]
-
-This will get pyzmq, which is needed for
-IPython's parallel computing features as well as the nose package, which will
-enable you to run IPython's test suite.  
-
-.. warning::
-
-    IPython's test system is being refactored and currently the
-    :command:`iptest` shown below does not work. More details about the
-    testing situation can be found :ref:`here <testing>`
-
-To run IPython's test suite, use the :command:`iptest` command:
-
-.. code-block:: bash
-
-    $ iptest
-
-Read on for more specific details and instructions for Windows.
-
-Installing IPython itself
-=========================
-
-Given a properly built Python, the basic interactive IPython shell will work
-with no external dependencies.  However, some Python distributions
-(particularly on Windows and OS X), don't come with a working :mod:`readline`
-module.  The IPython shell will work without :mod:`readline`, but will lack
-many features that users depend on, such as tab completion and command line
-editing.  If you install IPython with :mod:`setuptools`, (e.g. with `easy_install`),
-then the appropriate :mod:`readline` for your platform will be installed.
-See below for details of how to make sure you have a working :mod:`readline`.
-
-Installation using easy_install
--------------------------------
-
-If you have :mod:`setuptools` installed, the easiest way of getting IPython is
-to simple use :command:`easy_install`:
-
-.. code-block:: bash
-
-    $ easy_install ipython
-
-That's it.
-
-Installation from source
-------------------------
-
-If you don't want to use :command:`easy_install`, or don't have it installed,
-just grab the latest stable build of IPython from `here
-<https://github.com/ipython/ipython/downloads>`_.  Then do the following:
-
-.. code-block:: bash
-
-    $ tar -xzf ipython.tar.gz
-    $ cd ipython
-    $ python setup.py install
-
-If you are installing to a location (like ``/usr/local``) that requires higher
-permissions, you may need to run the last command with :command:`sudo`.
-
-Windows
--------
-
-There are a few caveats for Windows users.  The main issue is that a basic
-``python setup.py install`` approach won't create ``.bat`` file or Start Menu
-shortcuts, which most users want.  To get an installation with these, you can
-use any of the following alternatives:
-
-1. Install using :command:`easy_install`.
-
-2. Install using our binary ``.exe`` Windows installer, which can be found
-   `here <http://ipython.scipy.org/dist/>`_
-
-3. Install from source, but using :mod:`setuptools` (``python setupegg.py
-   install``).
-
-IPython by default runs in a terminal window, but the normal terminal
-application supplied by Microsoft Windows is very primitive.  You may want to
-download the excellent and free Console_ application instead, which is a far
-superior tool.  You can even configure Console to give you by default an
-IPython tab, which is very convenient to create new IPython sessions directly
-from the working terminal.
-
-.. _Console:  http://sourceforge.net/projects/console
-
-Note for Windows 64 bit users: you may have difficulties with the stock
-installer on 64 bit systems; in this case (since we currently do not have 64
-bit builds of the Windows installer) your best bet is to install from source
-with the setuptools method indicated in #3 above.  See `this bug report`_ for
-further details.
-
-.. _this bug report: https://bugs.launchpad.net/ipython/+bug/382214
-
-   
-Installing the development version
-----------------------------------
-
-It is also possible to install the development version of IPython from our
-`Git <http://git-scm.com/>`_ source code repository.  To do this you will
-need to have Git installed on your system.  Then just do:
-
-.. code-block:: bash
-
-    $ git clone https://github.com/ipython/ipython.git
-    $ cd ipython
-    $ python setup.py install
-
-Again, this last step on Windows won't create ``.bat`` files or Start Menu
-shortcuts, so you will have to use one of the other approaches listed above.
-
-Some users want to be able to follow the development branch as it changes.  If
-you have :mod:`setuptools` installed, this is easy. Simply replace the last
-step by:
-
-.. code-block:: bash
-
-    $ python setupegg.py develop
-
-This creates links in the right places and installs the command line script to
-the appropriate places.  Then, if you want to update your IPython at any time,
-just do:
-
-.. code-block:: bash
-
-    $ git pull
-
-Basic optional dependencies
-===========================
-
-There are a number of basic optional dependencies that most users will want to
-get.  These are:
-
-* readline (for command line editing, tab completion, etc.)
-* nose (to run the IPython test suite)
-* pexpect (to use things like irunner)
-
-If you are comfortable installing these things yourself, have at it, otherwise
-read on for more details.
-
-readline
---------
-
-In principle, all Python distributions should come with a working
-:mod:`readline` module.  But, reality is not quite that simple.  There are two
-common situations where you won't have a working :mod:`readline` module:
-
-* If you are using the built-in Python on Mac OS X.
-
-* If you are running Windows, which doesn't have a :mod:`readline` module.
-
-When IPython is installed with :mod:`setuptools`, (e.g. with `easy_install`),
-readline is added as a dependency on OS X, and PyReadline on Windows, and will
-be installed on your system.  However, if you do not use setuptools, you may
-have to install one of these packages yourself.
-
-On OS X, the built-in Python doesn't not have :mod:`readline` because of
-license issues.  Starting with OS X 10.5 (Leopard), Apple's built-in Python has
-a BSD-licensed not-quite-compatible readline replacement. As of IPython 0.9,
-many of the issues related to the differences between readline and libedit seem
-to have been resolved.  While you may find libedit sufficient, we have
-occasional reports of bugs with it and several developers who use OS X as their
-main environment consider libedit unacceptable for productive, regular use with
-IPython.
-
-Therefore, we *strongly* recommend that on OS X you get the full
-:mod:`readline` module.  We will *not* consider completion/history problems to
-be bugs for IPython if you are using libedit.
-
-To get a working :mod:`readline` module, just do (with :mod:`setuptools`
-installed):
-
-.. code-block:: bash
-
-    $ easy_install readline
-
-.. note::
-
-    Other Python distributions on OS X (such as fink, MacPorts and the official
-    python.org binaries) already have readline installed so you likely don't
-    have to do this step.
-
-If needed, the readline egg can be build and installed from source (see the
-wiki page at http://ipython.scipy.org/moin/InstallationOSXLeopard).
-
-On Windows, you will need the PyReadline module. PyReadline is a separate,
-Windows only implementation of readline that uses native Windows calls through
-:mod:`ctypes`. The easiest way of installing PyReadline is you use the binary
-installer available `here <https://launchpad.net/pyreadline/+download>`_.
-
-nose
-----
-
-To run the IPython test suite you will need the :mod:`nose` package.  Nose
-provides a great way of sniffing out and running all of the IPython tests.  The
-simplest way of getting nose, is to use :command:`easy_install`:
-
-.. code-block:: bash
-
-    $ easy_install nose
-
-Another way of getting this is to do:
-
-.. code-block:: bash
-
-    $ easy_install ipython[test]
-
-For more installation options, see the `nose website
-<http://somethingaboutorange.com/mrl/projects/nose/>`_.  
-
-.. warning::
-
-    As described above, the :command:`iptest` command currently doesn't work.
-
-Once you have nose installed, you can run IPython's test suite using the
-iptest command:
-
-.. code-block:: bash
-
-    $ iptest
-
-pexpect
--------
-
-The pexpect package is used in IPython's :command:`irunner` script, as well as
-for managing subprocesses [pexpect]_. IPython now includes a version of pexpect
-in :mod:`IPython.external`, but if you have installed pexpect, IPython will use
-that instead. On Unix platforms (including OS X), just do:
-
-.. code-block:: bash
-
-    $ easy_install pexpect
-
-Windows users are out of luck as pexpect does not run there.
-
-Dependencies for IPython.parallel (parallel computing)
-======================================================
-
-:mod:`IPython.kernel` has been replaced by :mod:`IPython.parallel`, 
-which uses ZeroMQ for all communication.
-
-IPython.parallel provides a nice architecture for parallel computing.  The
-main focus of this architecture is on interactive parallel computing.  These
-features require just one package: pyzmq.  See the next section for pyzmq
-details.
-
-On a Unix style platform (including OS X), if you want to use
-:mod:`setuptools`, you can just do:
-
-.. code-block:: bash
-
-    $ easy_install ipython[zmq]    # will include pyzmq
-
-Security in IPython.parallel is provided by SSH tunnels.  By default, Linux
-and OSX clients will use the shell ssh command, but on Windows, we also
-support tunneling with paramiko [paramiko]_.
-
-Dependencies for IPython.zmq
-============================
-
-pyzmq
------
-
-IPython 0.11 introduced some new functionality, including a two-process
-execution model using ZeroMQ for communication [ZeroMQ]_. The Python bindings
-to ZeroMQ are found in the pyzmq project, which is easy_install-able once you
-have ZeroMQ installed (or even if you don't).
-
-IPython.zmq depends on pyzmq >= 2.0.10.1, but IPython.parallel requires the more
-recent 2.1.4.  2.1.4 also has binary releases for OSX and Windows, that do not
-require prior installation of libzmq.
-
-Dependencies for ipython-qtconsole (new GUI)
-============================================
-
-PyQt
-----
-
-Also with 0.11, a new GUI was added using the work in :mod:`IPython.zmq`,
-which can be launched with ``ipython-qtconsole``. The GUI is built on PyQt ,
-which can be installed from the 
-`PyQt website <http://www.riverbankcomputing.co.uk/>`_.
-
-pygments
---------
-
-The syntax-highlighting in ``ipython-qtconsole`` is done with the pygments project, 
-which is easy_install-able [pygments]_.
-
-.. [ZeroMQ] ZeroMQ.  http://www.zeromq.org
-.. [paramiko] paramiko. https://github.com/robey/paramiko
-.. [pygments] Pygments syntax highlighting. http://pygments.org
-.. [pexpect] Pexpect. http://www.noah.org/wiki/Pexpect
diff --git a/docs/source/install/kernel_install.rst b/docs/source/install/kernel_install.rst
new file mode 100644
index 00000000000..c75f32ced61
--- /dev/null
+++ b/docs/source/install/kernel_install.rst
@@ -0,0 +1,106 @@
+.. _kernel_install:
+
+Installing the IPython kernel
+=============================
+
+.. seealso::
+
+   :ref:`Installing Jupyter <jupyter:install>`
+     The IPython kernel is the Python execution backend for Jupyter.
+
+The Jupyter Notebook and other frontends automatically ensure that the IPython kernel is available.
+However, if you want to use a kernel with a different version of Python, or in a virtualenv or conda environment,
+you'll need to install that manually.
+
+Kernels for Python 2 and 3
+--------------------------
+
+If you're running Jupyter on Python 3, you can set up a Python 2 kernel after
+checking your version of pip is greater than 9.0::
+
+    python2 -m pip --version
+
+Then install with ::
+
+    python2 -m pip install ipykernel
+    python2 -m ipykernel install --user
+
+Or using conda, create a Python 2 environment::
+
+    conda create -n ipykernel_py2 python=2 ipykernel
+    source activate ipykernel_py2    # On Windows, remove the word 'source'
+    python -m ipykernel install --user
+
+.. note::
+
+    IPython 6.0 stopped support for Python 2, so
+    installing IPython on Python 2 will give you an older version (5.x series).
+
+If you're running Jupyter on Python 2 and want to set up a Python 3 kernel,
+follow the same steps, replacing ``2`` with ``3``.
+
+The last command installs a :ref:`kernel spec <jupyterclient:kernelspecs>` file
+for the current python installation. Kernel spec files are JSON files, which
+can be viewed and changed with a normal text editor.
+
+.. _multiple_kernel_install:
+
+Kernels for different environments
+----------------------------------
+
+If you want to have multiple IPython kernels for different virtualenvs or conda
+environments, you will need to specify unique names for the kernelspecs.
+
+Make sure you have ipykernel installed in your environment. If you are using
+``pip`` to install ``ipykernel`` in a conda env, make sure ``pip`` is
+installed:
+
+.. sourcecode:: bash
+
+    source activate myenv
+    conda install pip
+    conda install ipykernel # or pip install ipykernel
+
+For example, using conda environments, install a ``Python (myenv)`` Kernel in a first
+environment:
+
+.. sourcecode:: bash
+
+    source activate myenv
+    python -m ipykernel install --user --name myenv --display-name "Python (myenv)"
+
+And in a second environment, after making sure ipykernel is installed in it:
+
+.. sourcecode:: bash
+
+    source activate other-env
+    python -m ipykernel install --user --name other-env --display-name "Python (other-env)"
+
+The ``--name`` value is used by Jupyter internally. These commands will overwrite
+any existing kernel with the same name. ``--display-name`` is what you see in
+the notebook menus.
+
+Using virtualenv or conda envs, you can make your IPython kernel in one env available to Jupyter in a different env. To do so, run ipykernel install from the kernel's env, with --prefix pointing to the Jupyter env:
+
+.. sourcecode:: bash
+
+    /path/to/kernel/env/bin/python -m ipykernel install --prefix=/path/to/jupyter/env --name 'python-my-env'
+
+Note that this command will create a new configuration for the kernel in one of the preferred location (see ``jupyter --paths`` command for more details):
+
+* system-wide (e.g. /usr/local/share),
+* in Jupyter's env (sys.prefix/share),
+* per-user (~/.local/share or ~/Library/share)
+
+If you want to edit the kernelspec before installing it, you can do so in two steps.
+First, ask IPython to write its spec to a temporary location:
+
+.. sourcecode:: bash
+
+    ipython kernel install --prefix /tmp
+
+edit the files in /tmp/share/jupyter/kernels/python3 to your liking, then when you are ready, tell Jupyter to install it (this will copy the files into a place Jupyter will look):
+
+.. sourcecode:: bash
+
+    jupyter kernelspec install /tmp/share/jupyter/kernels/python3
diff --git a/docs/source/interactive/autoawait.rst b/docs/source/interactive/autoawait.rst
new file mode 100644
index 00000000000..4f6f1713110
--- /dev/null
+++ b/docs/source/interactive/autoawait.rst
@@ -0,0 +1,318 @@
+.. _autoawait:
+
+Asynchronous in REPL: Autoawait
+===============================
+
+.. note::
+
+   This feature is experimental and behavior can change between python and
+   IPython version without prior deprecation.
+
+Starting with IPython 7.0, IPython offers the ability to run asynchronous code
+from the REPL. Constructs which are :exc:`SyntaxError` s in the Python REPL can
+be used seamlessly in IPython.
+
+The examples given here are for terminal IPython, running async code in a
+notebook interface or any other frontend using the Jupyter protocol needs
+IPykernel version 5.0 or above. The details of how async code runs in IPykernel
+will differ between IPython, IPykernel and their versions.
+
+When a supported library is used, IPython will automatically allow Futures and
+Coroutines in the REPL to be ``await`` ed. This will happen if an :ref:`await
+<await>` (or any other async constructs like async-with, async-for) is used at
+top level scope, or if any structure valid only in :external+python:ref:`async def
+<async def>` function context are present. For example, the following being a
+syntax error in the Python REPL::
+
+    Python 3.12.0
+    [GCC 11.4.0]
+    Type "help", "copyright", "credits" or "license" for more information.
+    >>> import aiohttp
+    >>> session = aiohttp.ClientSession()
+    >>> result = session.get('https://api.github.com')
+    >>> response = await result
+      File "<stdin>", line 1
+        response = await result
+                              ^
+    SyntaxError: invalid syntax
+
+Should behave as expected in the IPython REPL::
+
+    Python 3.12.0
+    Type 'copyright', 'credits' or 'license' for more information
+    IPython 9.0.0 -- An enhanced Interactive Python. Type '?' for help.
+
+    In [1]: import aiohttp
+       ...: session = aiohttp.ClientSession()
+       ...: result = session.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}...',
+    ...
+    }
+
+
+You can use the ``c.InteractiveShell.autoawait`` configuration option and set it
+to :py:data:`False` to deactivate automatic wrapping of asynchronous code. You can
+also use the :magic:`%autoawait` magic to toggle the behavior at runtime::
+
+    In [1]: %autoawait False
+
+    In [2]: %autoawait
+    IPython autoawait is `Off`, and set to use `asyncio`
+
+
+
+By default IPython will assume integration with Python's provided
+:mod:`asyncio`, but integration with other libraries is provided. In particular
+we provide experimental integration with the ``curio`` and ``trio`` library.
+
+You can switch the current integration by using the
+``c.InteractiveShell.loop_runner`` option or the ``autoawait <name
+integration>`` magic.
+
+For example::
+
+    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(5):
+       ...:         n.spawn(child, i)
+       ...: print('parent end')
+    parent start
+       child 2 goes to sleep
+       child 0 goes to sleep
+       child 3 goes to sleep
+       child 1 goes to sleep
+       child 4 goes to sleep
+       <about 2 seconds pause>
+       child 2 wakes up
+       child 1 wakes up
+       child 0 wakes up
+       child 3 wakes up
+       child 4 wakes up
+    parent end
+
+
+In the above example, ``async with`` at top level scope is a syntax error in
+Python.
+
+Using this mode can have unexpected consequences if used in interaction with
+other features of IPython and various registered extensions. In particular if
+you are a direct or indirect user of the AST transformers, these may not apply
+to your code.
+
+When using command line IPython, the default loop (or runner) does not process
+in the background, so top level asynchronous code must finish for the REPL to
+allow you to enter more code. As with usual Python semantics, the awaitables are
+started only when awaited for the first time. That is to say, in first example,
+no network request is done between ``In[1]`` and ``In[2]``.
+
+
+Effects on IPython.embed()
+--------------------------
+
+IPython core being asynchronous, the use of ``IPython.embed()`` will now require
+a loop to run. By default IPython will use a fake coroutine runner which should
+allow ``IPython.embed()`` to be nested. Though this will prevent usage of the
+:magic:`%autoawait` feature when using IPython embed. 
+
+You can set a coroutine runner explicitly for ``embed()`` if you want to run
+asynchronous code, though the exact behavior is undefined.
+
+Effects on Magics
+-----------------
+
+A couple of magics (``%%timeit``, ``%timeit``, ``%%time``, ``%%prun``) have not
+yet been updated to work with asynchronous code and will raise syntax errors
+when trying to use top-level ``await``. We welcome any contribution to help fix
+those, and extra cases we haven't caught yet. We hope for better support in Core
+Python for top-level Async code.
+
+Internals
+---------
+
+As running asynchronous code is not supported in interactive REPL (as of Python
+3.7) we have to rely to a number of complex workarounds and heuristics to allow
+this to happen. It is interesting to understand how this works in order to
+comprehend potential bugs, or provide a custom runner.
+
+Among the many approaches that are at our disposition, we find only one that
+suited out need. Under the hood we use the code object from a async-def function
+and run it in global namespace after modifying it to not create a new
+``locals()`` scope::
+
+    async def inner_async():
+        locals().update(**global_namespace)
+        #
+        # here is user code
+        #
+        return last_user_statement
+    codeobj = modify(inner_async.__code__)
+    coroutine = eval(codeobj, user_ns)
+    display(loop_runner(coroutine))
+
+
+
+The first thing you'll notice is that unlike classical ``exec``, there is only
+one namespace. Second, user code runs in a function scope, and not a module
+scope.
+
+On top of the above there are significant modification to the AST of
+``function``, and ``loop_runner`` can be arbitrary complex. So there is a
+significant overhead to this kind of code.
+
+By default the generated coroutine function will be consumed by Asyncio's
+``loop_runner = asyncio.get_event_loop().run_until_complete()`` method if
+``async`` mode is deemed necessary, otherwise the coroutine will just be
+exhausted in a simple runner. It is possible, though, to change the default
+runner.
+
+A loop runner is a *synchronous*  function responsible from running a coroutine
+object.
+
+The runner is responsible for ensuring that ``coroutine`` runs to completion,
+and it should return the result of executing the coroutine. Let's write a
+runner for ``trio`` that print a message when used as an exercise, ``trio`` is
+special as it usually prefers to run a function object and make a coroutine by
+itself, we can get around this limitation by wrapping it in an async-def without
+parameters and passing this value to ``trio``::
+
+
+    In [1]: import trio
+       ...: from types import CoroutineType
+       ...:
+       ...: def trio_runner(coro:CoroutineType):
+       ...:     print('running asynchronous code')
+       ...:     async def corowrap(coro):
+       ...:         return await coro
+       ...:     return trio.run(corowrap, coro)
+
+We can set it up by passing it to ``%autoawait``::
+
+    In [2]: %autoawait trio_runner
+
+    In [3]: async def async_hello(name):
+       ...:     await trio.sleep(1)
+       ...:     print(f'Hello {name} world !')
+       ...:     await trio.sleep(1)
+
+    In [4]: await async_hello('async')
+    running asynchronous code
+    Hello async world !
+
+
+Asynchronous programming in python (and in particular in the REPL) is still a
+relatively young subject. We expect some code to not behave as you expect, so
+feel free to contribute improvements to this codebase and give us feedback.
+
+We invite you to thoroughly test this feature and report any unexpected behavior
+as well as propose any improvement.
+
+Using Autoawait in a notebook (IPykernel)
+-----------------------------------------
+
+Update ipykernel to version 5.0 or greater::
+
+   pip install ipykernel ipython --upgrade
+   # or
+   conda install ipykernel ipython --upgrade
+
+This should automatically enable :magic:`autoawait` integration. Unlike
+terminal IPython, all code runs on ``asyncio`` eventloop, so creating a loop by
+hand will not work, including with magics like :magic:`%run` or other
+frameworks that create the eventloop themselves. In cases like these you can
+try to use projects like `nest_asyncio
+<https://github.com/erdewit/nest_asyncio>`_ and follow `this discussion
+<https://github.com/jupyter/notebook/issues/3397#issuecomment-419386811>`_
+
+Difference between terminal IPython and IPykernel
+-------------------------------------------------
+
+The exact asynchronous code running behavior varies between Terminal IPython and
+IPykernel. The root cause of this behavior is due to IPykernel having a
+*persistent* `asyncio` loop running, while Terminal IPython starts and stops a
+loop for each code block. This can lead to surprising behavior in some cases if
+you are used to manipulating asyncio loop yourself, see for example
+:ghissue:`11303` for a longer discussion but here are some of the astonishing
+cases.
+
+This behavior is an implementation detail, and should not be relied upon. It can
+change without warnings in future versions of IPython.
+
+In terminal IPython a loop is started for each code blocks only if there is top
+level async code::
+
+   $ ipython
+   In [1]: import asyncio
+      ...: asyncio.get_event_loop()
+   Out[1]: <_UnixSelectorEventLoop running=False closed=False debug=False>
+
+   In [2]:
+
+   In [2]: import asyncio
+      ...: await asyncio.sleep(0)
+      ...: asyncio.get_event_loop()
+   Out[2]: <_UnixSelectorEventLoop running=True closed=False debug=False>
+
+See that ``running`` is ``True`` only in the case were we ``await sleep()``
+
+In a Notebook, with ipykernel the asyncio eventloop is always running::
+
+   $ jupyter notebook
+   In [1]: import asyncio
+      ...: loop1 = asyncio.get_event_loop()
+      ...: loop1
+   Out[1]: <_UnixSelectorEventLoop running=True closed=False debug=False>
+
+   In [2]: loop2 = asyncio.get_event_loop()
+      ...: loop2
+   Out[2]: <_UnixSelectorEventLoop running=True closed=False debug=False>
+
+   In [3]: loop1 is loop2
+   Out[3]: True
+
+In Terminal IPython background tasks are only processed while the foreground
+task is running, if and only if the foreground task is async::
+
+   $ ipython
+   In [1]: import asyncio
+      ...:
+      ...: async def repeat(msg, n):
+      ...:     for i in range(n):
+      ...:         print(f"{msg} {i}")
+      ...:         await asyncio.sleep(1)
+      ...:     return f"{msg} done"
+      ...:
+      ...: asyncio.ensure_future(repeat("background", 10))
+   Out[1]: <Task pending coro=<repeat() running at <ipython-input-1-02d0ef250fe7>:3>>
+
+   In [2]: await asyncio.sleep(3)
+   background 0
+   background 1
+   background 2
+   background 3
+
+   In [3]: import time
+   ...: time.sleep(5)
+
+   In [4]: await asyncio.sleep(3)
+   background 4
+   background 5
+   background 6g
+
+In a Notebook, QtConsole, or any other frontend using IPykernel, background
+tasks should behave as expected.
diff --git a/docs/source/interactive/figs/besselj.png b/docs/source/interactive/figs/besselj.png
deleted file mode 100644
index 3e791e64c59..00000000000
Binary files a/docs/source/interactive/figs/besselj.png and /dev/null differ
diff --git a/docs/source/interactive/figs/colors_dark.png b/docs/source/interactive/figs/colors_dark.png
deleted file mode 100644
index 821d2751ee0..00000000000
Binary files a/docs/source/interactive/figs/colors_dark.png and /dev/null differ
diff --git a/docs/source/interactive/figs/jn.html b/docs/source/interactive/figs/jn.html
deleted file mode 100644
index 56675246742..00000000000
--- a/docs/source/interactive/figs/jn.html
+++ /dev/null
@@ -1,690 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
-<html><head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="qrichtext" content="1" /><style type="text/css">
-p, li { white-space: pre-wrap; }
-</style></head><body style=" font-family:'Monaco'; font-size:13pt; font-weight:400; font-style:normal;">
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">34</span><span style=" color:#000080;">]:</span> from scipy.special import jn</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">35</span><span style=" color:#000080;">]:</span> x = linspace(0,4*pi)</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">36</span><span style=" color:#000080;">]:</span> for i in range(6):</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">    ...:</span>     plot(x,jn(i,x))</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><img src="data:image/png;base64,
-iVBORw0KGgoAAAANSUhEUgAAAbAAAAEgCAYAAADVKCZpAAAACXBIWXMAAAsT
-AAALEwEAmpwYAAAgAElEQVR4nOzdd3hT1RsH8G+6oVBo6S6F0gItZbTsLaiA
-KEMQEBSQKcuBiKA/ERkqIggORARBBGUqoExBNm1p6S7de++92yT3/f1xpTI6
-kjQhrbyf5+GBJvee86a0ee89Oec9EiIiMMYYY82MjrYDYIwxxlTBCYwxxliz
-xAmMMcZYs8QJjDHGWLPECYwxxlizxAmMMcZYs8QJjDHGWLPECYwxxlizxAmM
-McZYs8QJjDHGWLPECYwxxlizxAmMMcZYs8QJjDHGWLPECYwxxlizxAmMMcZY
-s8QJjDHGWLPECYwxxlizxAmMMcZYs8QJjDHGWLPECYwxxlizxAmMMcZYs8QJ
-jDHGWLPECYwxxlizxAmMMcZYs8QJjDHGWLPECYwxxlizxAmMMcZYs6Sn7QA0
-YcmSJfD29oa9vb22Q1FJdXU19PX1IZFItB2KSrKysmBlZaXtMFTG8WsPEUEq
-lcLAwEDboahEJpNBIpFAV1dX26GoJCIiAmvWrMG8efO0HYpC/pMJLCcnBxYW
-FliyZIm2Q1HJ2bNnMWLECLRu3VrboajkyJEjeOWVV7Qdhso4fu3Jy8uDv78/
-xowZo+1QVBIQEABjY2M4OztrOxSVLFu2DESk7TAU9p9MYCYmJjAxMcG4ceO0
-HYpKEhMTMXr0aLRr107boajE39+/2X7vAY5fm9LS0iCVSptt/Hp6emjbti0G
-Dhyo7VBU0qpVK7Rp00bbYSiMPwNjjDHWLP0n78AMDQ21HUKjWFpaQk+v+f7X
-TJw4UdshNArHrz36+vowNzfXdhgqMzExgbGxsbbDUJmhoSF0dJrPfU3zfZes
-h42NjbZDaJRp06ZpO4RGcXd313YIjcLxa4+lpSVefPFFbYehssGDB2s7hEax
-s7NrVhNomk+qZYwxxu7DCYwxxlizxAmMMcZYs8QJjDHGWLPECYwxxlizxAmM
-McZYs8QJjDHGWLPECYwxxlizxAmMMcZYs8QJjDHGWLPECYwxxlizxAmMMcZY
-s8QJjDHGWLPECYwxxlizxAmMMcZYs9SsE1hRURESExMhCIK2Q2GMMfaYNZkE
-tmPHDvTt2xdGRkZYtGhRg8dv2LABjo6OeP7559G1a1dERkY+higZY4w1FU0m
-gTk4OOCzzz7DjBkzGryj8vDwwNdff42QkBBERERg9uzZWLhw4WOKlDHGWFPQ
-ZBLYhAkTMHbsWLRt27bBY48fP45JkybBzs4OALB06VJ4enoiPT1d02Eyxhhr
-IppMAlNGTEwMunbtWvO1paUl2rZti+joaABAeTkgk2krOsYYY4+DnrYDUEVF
-RQWMjIweeKxFixYoLy8HAISEAFeuXMfZs0CPHkCnTsDGjeu0ESpjjDVZGRkZ
-2LNnT83XycnJWoxGec0ygZmYmKCkpKTmayJCcXEx2rRpAwAYNAjo3n0k7O3X
-4ehR4K+/gKwsYMYM4KmnAF1dbUXOGGNNh42NDdat+/fi3s/PT4vRKK9ZDiH2
-6tULQUFBNV/HxcWhsrIS3bt3r3msdWtg+XLg9m3A1xdwcgJefx0YOBAoKtJG
-1IwxxtSpySSw5ORkeHh4IC0tDZmZmfDw8EBiYiIAcb3XqFGjam5v58yZg0uX
-LuHy5csoKSnBmjVrMG3atDongDg4AKtXAzExwIABwNixQHHxY3phjDHGNKLJ
-JLDLly/jgw8+QEZGBgoLC/HBBx/gwoULAMQhwsrKShARAKBLly44cuQIVqxY
-AScnJ+jq6mLXrl0N9iGRAN99B7i7A88/D9w3CskYY6yZkdC9rPAfsmHDBgB4
-YGz3foIALF0KhIUBFy6Iw42MMfakmzBhApYsWYJx48ZpOxSFNJk7sMdJRwfY
-tQvo1g0YNw4oLdV2RIwxxpT1RCYwQExiu3cDXbsC48cDZWXajogxxpgyntgE
-BohJbM8eoEMHYPJk4L83mMoYY/9dT3QCA8Qktm8fkJ0NHDqk7WgYY4wp6olP
-YACgrw/88AOwahVQUKDtaBhjjCmCE9g/Bg0CJk4E1qzRdiSMMcYUwQnsPp9/
-Dpw8Cdy5o+1IGGOMNYQT2H3MzICtW4ElS7iaPWOMNXWcwB4yaxbQpg3w/ffa
-joQxxlh9OIE9RCIRFzlv3Ajw/piMMdZ0cQKrhYuLOIy4YoW2I2GMMVYXTmB1
-WLMG8PMDLl7UdiSMMcZqwwmsDi1aADt2AMuWAXK5tqNhjDH2ME5g9XjhBcDa
-GjhxQtuRMMYYexgnsAasXg1s2cJ1EhljrKnhBNaACRPESvVXr2o7EsYYY/fj
-BNYAHR2xRuKWLdqOhDHG2P04gSlg5kwgNBQIDNR2JIwxxu7hBKYAQ0Ng+XKx
-zBRjjLGmQU/bATQXixcDjo5AQgLQqZO2o2GMMcZ3YApq0wZYuBDYvl3bkTDG
-GAM4gSll+XLg11+BnBxtR8IYY4wTmBJsbYGXXgJ27tR2JIwxxjiBKem998QE
-Vlam7UgYY+zJxglMSd26AUOGAD/9pO1IGGPsycYJTAXvvw9s28ZFfhljTJs4
-galgyBDAwgK4fFnbkTDG2JOLE5iKXn8d2LdP21EwxtiTixOYiqZPB/7+G8jN
-1XYkjDH2ZOIEpqI2bYCJE8V1YYwxxh4/TmCNMH++OBuR9wpjjLHHjxNYIzz1
-FFBRAfj5aTsSxhh78nACawSJBJg3jydzMMaYNnACa6Q5c4Djx4Hycm1Hwhhj
-TxZOYI1kZwcMHgycOKHtSBhj7MnCCUwNFizgYUTGGHvcOIGpwfjxQEQEEBur
-7UgYY+zJwQlMDQwMgFmzuMAvY4w9TpzA1GT+fODAAUAm03YkjDH2ZOAEpibd
-uwP29sDFi9qOhDHGngycwNRo/nyezMEYY48LJzA1mj4duHIFyMnRdiSMMfbf
-xwlMjdq0EWck/v67tiNhjLH/Pk5gajZjBnD0qLajYIyx/z5OYGo2ZgwQGgqk
-pmo7EsYY+2/jBKZmhobApEnAb79pOxLGGPtv4wSmATyMyBhjmscJTAOefhpI
-TATi4+s/rrCyEHP+mINFZxbhWuI15FXkPZb4GGPsv0BP2wH8F+npAVOnindh
-H3744HMCCbiRdAP7AvbhbPRZCCSgr21frL26Fnez76KVQSv0tOyJXla9MMll
-EobYD9HOi2CMsSaOE5iGzJgBvPHGvwksrSQN+wP3Y3/QfrQyaIUFvRfg67Ff
-w7ylec05BEJyUTJCskLgkeyBl469hIV9FmLdyHXQ19HX0ithjLGmiYcQNWTo
-UCA/HwgLA+6k3UH3nd2RWpyK36b9hqAlQXh74NsPJC8AkECCjm06YkLXCfhi
-1BcIXhoM/wx/DP9pOOIK4rT0ShhjrGniBKYhOjpiZY4vjl/D+MPjcWjKIfww
-/gf0sekDCSQKtWFlbIVzr57DjB4zMGjvIPwS8ouGo2aMseaDE5gG2T1zBoer
-p+PY1OMY12WcSm3oSHTwzqB38Pfsv7Hp1ibMPDkTRVVFao6UMcaanyaVwKqr
-qxEfH4+Kigpth9JoR0KPYEvE67C+eg4m+SMb3Z67tTv8F/lDX0cfw34ahtLq
-0sYHyRhjzViTSWCXLl2Cvb09Jk2aBHt7exw5cqTOYz/++GPo6ek98Ce2CW2H
-/IPfD1h1aRWuzLmCOaP6q21NWEv9ltg/aT/62fbD7FOzIZCgnoYZY6wZahIJ
-rKKiArNmzcLOnTsREhKCM2fOYOHChcjKyqr1eEEQsGjRIlRWVtb8cXJyesxR
-127b7W3Y6rUVN+fdRHeL7pgxAzh2DBDUlGskkOCH8T8guywb666vU0+jjDHW
-DDWJBHb9+nXo6OhgypQpAIDBgwejW7duOHPmTJ3n6OjoQCKRQFdXF3p6epBI
-FJsYoUk3km5gi+cW3Jh7A46mjgCAHj2A1q2B27fV14+hriFOTj+JX4J/wbGw
-Y+prmDHGmpEmkcCio6Ph7Oz8QBLq0qULYmJi6jxn3759aNGiBSwsLPDRRx9B
-Lpc/jlDrVFxVjLl/zMWBSQfQ3qR9zeMSiWZKS1kZW+HPV/7Em+ffhF+6n3ob
-Z4yxZqBJLGSuqKiAkZHRA4+1aNEC5eXltR4/e/ZsvPvuuzA1NYWfnx8mTZqE
-du3aYcWKFTXHXL9+/YFz1q3T7HDbiosrMLbzWIztPPaR56ZPB556CvjqK7FK
-h7q4Wbnhxwk/YvKxybjz+h3YtLJRX+OMsf+8jIwM7Nmzp+br5ORkLUajvCaR
-wExMTFBcXPzAY8XFxbC1ta31eGdn55p/9+/fH2+88QbOnDnzQAIbOXKkxpPW
-PaejTuNG4g0ELQmq9fmuXQFbW+DGDeDZZ9Xb9ySXSQjPCceko5NwY+4NGOkZ
-NXxScTEQFQXs3w8sWgT07Ano6qo3MMZYk2djY/PA+6SfX/MazWkSQ4hubm4I
-CwtDdXU1AICIEBISAjc3N4XOr66uhp46b22UkFOegyVnl+DA5ANoZdCqzuNe
-fllzOzX/b/j/4GTqhMVnFz/6ZEEBsGMHsHgxMHIkYGMD2NkBS5YAu3YBEyYA
-ZmbiRmbr1wOXLokJjjHGmrgmkcAGDx6Mjh07YuPGjaisrMSuXbtQWlqKcePE
-xb/Xrl3DjBkzao7fv38/IiMjkZOTgz/++APffvstpk+f/tjjJhAWn1mM19xe
-w1D7ofUeO2UKcOoUoImP6iSQ4MeJP+Jm0k2cjzkvPlhUBGzYAHTpAly/Dri5
-AWvXAn5+YoLy9weIgJQUICZGLNxYUQF88gnQpo2Y4AoK1B8sY4ypSZMYQtTR
-0cGpU6ewdOlStG/fHs7Ozjh37hxatmwJAJDL5aiqqqo53tvbG59++ikKCwth
-b2+Pzz77DPPnz3/scf8S/Ati82NxZGrda9bu6dIFsLICPD3Fz8PUzVjfGLvG
-7cKqk0swumoe9L/9Dhg3DvDxARpaYmBpCbz4ovgHEIs4fvgh0K0bsGULMHu2
-OBuFMcaakCaRwACgc+fO+Pvvv2t9btSoURg1alTN17t3735cYdUpuSgZKy+t
-xOXXLsNQ11Chc6ZOBU6c0EwCQ3U1xp4MweBNmQjv9xvcPDyA+z4rVIqZGfDD
-D8C8ecDSpcC+fcD33wPdu6s3ZsYYa4QmMYTY3BAI8/6ch3cHvws3K8U+pwPE
-YcQTJ9S3qLlGdrY4O+Svv1D59wU8OyYTEe3U0MnAgYCvLzBtmvj52QcfAHXM
-DGWMsceNE5gKTkedRkZJBlYNWaXUea6u4qLmO3fUGExwMDBggJhgLl+GVf+n
-8fGIj7Hs3DIQqPHt6+oCb74JhIQAd+8CL7wAlHIdRsaY9nECU5Kc5Pjo6kfY
-PGoz9HSUH4G9N4yoFidOAKNHi59TffKJuIcLgGX9l6Gosgi/hvyqpo4gzl48
-c0YclnzuuXpnKsqJEFBSgtejouDg7Y0P4uOxITERW5KTsSMtDXszMnAuLw+V
-ar8VZYw9STiBKelo6FG0MmiFCc4TVDp/yhRxOj015uZIEMQZhu++C1y8KM7R
-v4+ejh5+GC8WFM6vyG9ERw/R0RE/G+vTR0yc/8xSlBHBt6QEW1NSMP7uXZh7
-emJWRASypVL0bd0abfT0ICdCjlSKqPJy3C4uxobERFh7eWFWRARO5+ZyMmOM
-Ka3JTOJoDqSCFB9f+xh7J+5VeFPKh7m5iXkgMFDMA0orLwdeew3IzBTHIq2s
-aj1sgN0ATHGdgg+vfIgfxv+gUqy1kkiAb78F3nsP0jFjcPDwYXyWlwc9iQRj
-zMww19oaPzk7w9LAoMGmMqurcSInB9tSUzEnMhLj27XDLCsrjDEzU/G7yxh7
-knACU8JPgT/B0dQRTzs8rXIbEsm/w4hKJ7CqKmDSJMDcHLhyBTCsf/bjZ898
-BtedrpjrPheD2g9SOeaHSQEcWLkSn40ahS5XruCXsWMx1MFB6XasDQzwhp0d
-3rCzQ3pVFU7k5mJpdDS6Gxvj+65dYd/A62OMPdl4CFFBFbIKfHLjE2x6dlOj
-21JpGFEmA159FTA1BX75pcHkBQBtjdpi23PbsPjsYsip8SuoqwUBezMy0NXH
-B8dzcvDr4MG4lJmJoS+8AGRkNKptW0NDvGVnh8gBAzDAxAR9/PzwXVoa5Ip+
-kwgQKgVUZ1ejIrYCeefyUJVW1fB5jLFmi+/AFPS97/cYYDcA/W37N7qt/v3F
-ohdhYeJ2Kw0SBGDhQvGkP/5Qqm7hjB4zsMNnB46GHsXMnjNVjtm/pASvRkTA
-zsAAv3brhqFt2ohPrF8vJtdJk4CbNxVKrPUx0NHB2o4dMc3CAouionAoKws/
-Ojujh7FxzTGyYhkKrxWi4FIB8v/OhyxPBlmJDBJdCfRM9KDbRhcVMeKu3gY2
-Bmjl3qrmT+verWHkZASJDg9SMtbccQJTQHFVMbZ4bsHVOVfV0p5E8u+asAYT
-GBHwzjtAXJw4YUOBz5Ye6AsSfPbsZ1h0ZhGmd5+u9MxJORG2pqRge0oKvu3S
-BTMsLR896JNPxGy8ciXw3XdKtV8Xl5Ytcd3dHT9mZODpoCC8X2iBKYEGKLxU
-gNKAUpgMNIHpc6ZwPeQKo05G0DXRhY7BQwMKBFSmVKI0qBRlwWXIOZaD2Hdi
-oddaD3bL7WA9xxq6xlzEmLHmihOYAr7y/gpjO49Fdwv1VaKYMkUsctFgwfx1
-6wAPD+DaNeCf0lrKetrhadib2ONg8EHM7614ya3kykrMjowEAPj17YsORnVU
-updIxMr2/foBhw+LQ51qICFgqr8h3D83QnZsJs48Z4iX33eCxUhTxRKPBDDq
-YASjDkYwn2guPkZAkWcRUr9OReK6RNjMt4HtG7Yw6qBAFX/GWJPCCawBueW5
-2OGzA76LfNXa7pAhQG4uEB0tbrdSq23bgOPHxaG5e0N2KvrkmU8w88RMzOw1
-U6HSV0eys/F2TAxW2ttjlb09dBuqhdi2rXhLOWqUONWyEWWnSErIOpyFlC0p
-kBhK0On9DnCb3A6zYiJxRpaGU0amqLvufwMkQJthbdBmWBtUJlYibUca/Hv7
-w3SUKTqs6YBWvf5tmUhAaak/iot9UV2dgerqdFRViX+XlgYDAIyMOsLAwBaG
-hjYwMLCBgYEtjIw6wNR0NAwMap8hyhhTD05gDfjC8wtM7zEdndp2Umu7OjrA
-Sy+J7/n/+18tBxw8CHzzjVj9t7ZhOyUNtR8KVwtX7AvYh2X9l9V5XKUgYFFU
-FHxKSnChVy/0a91a8U7c3MRF1VOmiCWolDkXgFAlIP2HdKRsS0HLri3R+evO
-MB1lintz6o+5umJJdDSeDQ7GuZ49Ya6vr1T7DzNyMILTNic4rHdA+u50hIwO
-gc3KFmgxKxQFRReRn38J+vrmMDEZACOjTjAxGfxPsrKFgYEtdHVbQSrNRlVV
-+j/JTfw7O/soYmLehLFxD5ibT4a5+Yto0aJzo2JljD2KE1g9MkszsTdgL8Lf
-CNdI+1OmAKtW1ZLA7twRn7h2DbC3V1t/G5/eiElHJ2Fe73loodfikedzpVK8
-GBoKawMD+Pfti1aqbHI5bx7g5SVOOjl6VOEq9oXXChG9NBpGDkbocbIHWvd7
-NPnpSiTY4+yM/8XHY3hgIC65uallqj21KAamH4XB0GNILoqG3qn+aD/kJXTq
-uwlGRh3qPVdX1wFGRg6PPC4IVSgsvIbc3D8QGDgc+vrmMDefDDu7N/jOjDE1
-4Wn09fje93u82vNV2LSy0Uj7Tz0FJCcDCQn3PZiRIWa2ffvE4olq1M+2H/rb
-9ccPfo8ubI4uL8eggAAMa9MGv7m6qpa87tmxQ9xjbMeOBg+tzq5G5JxIRMyJ
-gONmR/T6q1etyeseCYDNjo5YYGODYYGBiGxEceGysnBERy+Bt7cjSktD4OTy
-BZ4ak4dOOr8gdYw7cvfogATVSqbo6BjCzGwsunb9AYMHp8HZ+UdUV2fgzp1u
-SEj4CDJZkcpxM8ZEnMDqUCmrxG7/3Vg+cLnG+tDTE2ef19RGrKoSk9fixcD4
-8Rrpc+PTG/GFxxcorf63IO+toiIMDwrCant7fOHoCJ3G7v1lZCQudPv0U/Fu
-rBYkEDJ+zIBvD1/om+tjQPgAmE8yV7iL9+ztsd7BAU8FBiJCiSRGJCAv7yyC
-g8cgOPgZGBhYY8CAcHTr9gtMTZ+FREcftktt0cerD7KPZiNkdAgqkysVbr82
-EokOTEwGwdn5R/TrF4CqqlT4+HRBSspWCEJFo9pm7EnGCawOh+4eQn/b/uja
-rq4ZFuoxZQpw8iTE6fJvvgnY2gJr1misv56WPTHSYSS+uyNOdz+UlYWXQkNx
-0MUFi2xt1deRoyOwezcwaxZQVvbAUxUxFQgaHoSMvRlwu+QGp21O0G2l/B3f
-PGtrfO7oiPF37yJHKm3w+Pz8i/Dzc0dCwkewspqFQYOS4OCwHgYGj95ht+jS
-Ar1v9UbbkW0RMDAApUHqqcBvZOQAF5ef4e5+DUVFXvDx6YL09D0gNSw0Z+xJ
-wwmsFgTCV7e/worBKzTe1zPPABERQNHmXYC3N/Dzzxrf/Xj9yPXYdns71sRF
-4X/x8bji5obnzMzU39HkycDQoQ+sFcj6JQsBQwJgMc0Cvb16o5W7yvMJAQAL
-bGww3cICk0JD6ywIXFoagpCQ5xAbuxyOjp+hX79AWFu/Bh2d+j8/k+hK0HFt
-R3TZ2QUhz4Wg8EZho2K9n7Fxd/TocQrdu/+OzMyfEBw8GlVV6Wprn7EnASew
-WlyOvwwdiQ6e6fSMxvsyMABW9r8Jg883iFU2WjXuDV0RzuYusOi1HntTYuHd
-pw96abLPr74Cfv0V8pu+iJwTiaTPk+B2xQ3t32kPia56EvWnnTrB1sAA8yMj
-H9gBraoqDZGR8xESMgbm5pPQv/9dtGs3AVCyVLDFSxbodqQbwqaFIfd0rlpi
-vsfEZBB69/aEqekz8Pfvi/z8C2ptn7H/Mk5gtfjq9ld4Z9A7KlecV0pyMt7z
-nY51Tr8CTk4a704gwpLoaOi3dYfUfxmMhLKGT2oMc3OUvPUt/MYkQqJL6Ovb
-94G1VuqgI5HgYLduiKusxIbERAhCFRIT18PPr9c/n3FFwdZ2KSQS1afdmz5j
-il4XeiF6STQyf85UY/SARKKLjh0/gqvrMURFLUJc3CoIQrVa+2Dsv4gT2EMi
-cyMRkBGAV3uqp5pEvaqqgKlTofveCuyOH41c9V7cP0JGhLmRkQgvK8OtvgMw
-qfOz2Om7U3MdEpD6TSpCvrZDJxdvOHf9U2Olm1ro6ODPHj3glX4RV717oKQk
-AH37BsDRcRP09Bq3CPye1n1bw/26OxI3JCJla4pS55aWitu3nTolro4ICBCr
-g+XmAvc+vmvb9in06xeI8vIIBAUNR2VlQv2NMvaE43VgD/nG5xss7rcYRnqP
-obTQqlWArS30P1yF0YHA6dPAfMUrPSmlWhAwMyICRTIZ/urVC8a6ulg1dBVG
-/jwSKwevREt91cpU1UVeIkfkvEhUJlSij3cftNC1E0tNTZkCdOmi1r4AQCYr
-RnHiB/iITuFL4Q283+FNGBm1VXs/Lbu2RG+P3ggZEwJpvhSOmxzrHJGsrgYu
-XQIOHQIuXACKioDwcLEmc1HRv38KCoCJE4H33gOGDTNHz55nkJLyFfz9B6Bb
-t19gZjZW7a+Dsf8CvgO7T15FHo6FHqu3UoXa/PYbcO5czaSNe1U5NKFSEDA1
-LAxVgoDTPXvC+J81Xt3Mu2Fw+8HYH7Rfrf1VxFQgYFAA9Ez10NurN1o4tQAc
-HICPPgJef12srq9Gubmn4evbHUTVGDIwHG90X4apYeFIrGzc9Pe6GNoZwv2m
-O3L/zEXKtkfvxDw9xTqXdnZiYZKRI8W7LSLgr7+AGzeAoCBx/V9+vrhH6bhx
-4trvQYOA336TwMbmXfTocQqRkXORnX1MI6+DseaOE9h99vjvwYsuL8LKWMOV
-EmJigGXLxDqHbcW7hPHjgVu3xCtydSqXyzHx7l201NXFiR49YKTz4H/5+8Pe
-x5deX0ImyNTSX975PAQMDYDdW3Zw3uMMHcP7+nvrLfHd+qef1NKXVJqP8PAZ
-iIt7Fy4uB+DsvBd6eqZ4zswMK9q3x6vh4ZAptema4vTb6cPtkhvSdqQh61AW
-AKCyEliyRCwR5uAA+PuLZSwXLwbatau7rRYtgEWLxNmoH34obnjdtStw4MAw
-uLj8jbi4lUhP362R18FYc8ZDiP+ollfjuzvf4fzM85rtqKICmDYN2LgR6Nu3
-5mETE2D4cOD8eeCVV9TTVblcjhdDQ2Ghr49funWrtSDv4PaDYW9ij9/Cf8Mr
-PRrRMQFJm5KQ/n06epzqgTZDa/ncSVcX2LtXLPg7bhxgo3qFk/z8i4iKWgBz
-85fQr18IdHUfHAJ9z94eVwsLsSExEZ90Um8dy3sM2xui5/meCH4mGHmCAWZ/
-bQpHR/H6xMRE+fZ0dIAXXxT/eHuLN6wHDvTE8eM3kZIyGjJZPjp0+ADKzqK8
-H4EQnBmMczHncPjuYYTnhMO8pTnMW5rDoqVFzb9tW9tiVq9Z6GzGNRxZ08UJ
-7B+/h/8O53bOcLNy02xHy5cD3bqJl+oPubdHmDoS2L3kZWlggAMuLvVWk39/
-2PtYc2UNZvSYodLMS3mJHJFzI1GVXoU+vn1gaFvP+qpevcRhxLffFodRle1L
-Xo74+PeRm/snXFx+hqnpqFqP05FIcMDFBb39/DDK1BQj2qr/8zAAMO5ujLy3
-XZE3NwxLVrph4Ret1LKMb9Ag4O+/ge3bgWHDHHH0qAeyssZAKs2Hk9MWKJPE
-pIIUF2Iu4FzMOZyPOQ8DXQOM6zIO25/bjiH2Q1AuLUdueS5yynKQW56L3PJc
-BGcFY8i+IRjYfiCWD1yOZx2ffTyzchlTBv0HrV+/ntavX6/w8QIJ1G9PPzod
-dVqDURHRL78QOTsTFRfX+nRODpGJCVFZWeO6KZPJaFRQEL0aHk5SQWjweIEE
-6vF9D/or9i+l+yqPK6c73e9Q5PxIklfKFTypnKhDB6Jr15Tqq7jYl3x8XCg8
-/FWSSvMVOudCXh7Ze3lRXnW1Usw4XtoAACAASURBVH0porqa6L33xJfi+Vk2
-edl6UUV8hdr7uXSJyNKS6Pvv88jffxBFRi4gQZApdG5gRiD1/qE39f6hN22/
-vZ0icyNJoIZ/JoiIyqXltC9gH/Xa1Yu67+xOu/12U1l1I3847yeTESUnE928
-SXTwINHGjUT9+xMBRF99RXTrVuN/GZhSxo8fT2fPntV2GArjBEZEXile5PSN
-E8kFBd+AVREWRmRhQRQSUu9hzzxDdPKk6t0om7zuORh8kJ7++Wml+iq4XkCe
-Vp6U8nUKKfie+K+jR4nc3MQ3sQYIgpQSEz8hT08ryso6pmRHRO/GxtLku3eV
-DrE+OTlEw4YRPfec+G8iopRvUsinqw9V56g/WcbFEfXsSfT666UUEPAshYfP
-IqGen9dKWSWtvbqWLLda0oGgAwonrdoIJNC1hGs06egkaru5Lf0a8qvKbZEg
-EP39N9GYMWKiat9e/EbOmkX00Udi4lq+nGjJEqK+fYlatBBf+Pz5YpLTwIUI
-+xcnsCZA2QQ294+5tM1rm+YCKi0lcnUl+umnBg/97jvxd1kVqiYvIqJqeTXZ
-b7enO2l3FDo+bXcaeVh4UN7FPFVCFd/Ihg0j2rOn3sMqKhIoIGAoBQU9S5WV
-aSp1VSmXU29fX9qVptr5DysrIxo0iOjNN4nkD+WQuNVx5D/IX/G7USWUlBBN
-nUo0dGgZeXsPpZiY5VTblYN3qje57nSlyUcnU0ZJhlpj8E3zJadvnOj1069T
-ubRc8ROlUqLDh4l69ybq3p1o/37F7q4qKoh8fMRfjMGDiRwdxZEMBS58GiIQ
-UWJFBR3KzKQ3oqMJ164Rrl2jZ4OCaHpYGL0ZHU3rExLou9RU8igsVOsFUFPF
-CawJUCaBFVQUUNvNbSmnLEczwQiCmJHmzVPo8LQ0IlNToqoq5bppTPK656vb
-X9HU41PrPUaQChT9VjT5dPWhsqhGDu/4+RFZWxMVFtb6dGbmIfLwsKDk5K31
-3m0oIrKsjMw9PCi0tLRR7chkRJMmif+ltX2bBblAoS+FUtTSqEb1UxdBIFqz
-hqhfv3y6fbsnJSZ+VvNcubSc3rv0Hll/aU3Hw4436q6rPkWVRfTyby9Tr129
-KCq3gddZUkL0zTdEHTsSjRhBdPbso1lfGVevionM1ZXoxIna/xPqUSWX04/p
-6TQtNJRsvbzI0tOTJt+9S1uTk+lsbi4FlJTQlfx8OpaVRTtTU2l9QgLNi4gg
-Zx8f6uLtTZ8lJlJKZaXq8deiOreacs/kqrVNVXECawKUSWA77+yk6b9N11ww
-u3eLQyBKjOUPHkx04YLiXZTKZPRMI5MXEVFJVQmZbzGn6LzoWp+X5kspaFQQ
-BT8XTNICqcr9PGDePKJVqx7sR1pI4eEzycfHmYqL/dXTDxHtS0+nnnfuULmK
-b6CCIN51Pfts/RcYsmIZ+Tj7UMYB9d793G/1aqIxY9LIy6sTpafvoZKqEhqx
-fwRNODxBcxdj9xFIoF2+u8h8izkduXuk9oP8/IgcHIjGjyfy9lZj54KYCN3d
-xWHGS5caPEUmCPRzRgY53L5NzwYF0cHMTIorL1c4xQtEdLuoiBZFRZHprVs0
-JjiYjmRlqfSzJK+QU/7lfIp7P478+vrRzdY3KeSFEJJXaPAjDAVxAmsCFE1g
-AgnUa1cvuhJ/RTOBBASIn3tFRip12tatRAsXKnZsiUxGIwIDaXZ4OMkakbzu
-WXt1LS06s+iRx8vCy8i7izfFvBNDglSNV/bp6UTt2hHFxBARUWGhB92+7UBR
-UYtIJmvc3dLDBCKaGhpK7/zTl7K2bhWvReq4YXxAaVgpeVh4UElgiUp9NUQQ
-xNz/6qsxdMvDmhYd7UYLTy/U7Oe4tQjICKDO33amJWeXUIW04t/g9uwhMjcn
-Oqb8Z5YKk8uJfvuNyM6OaOVKcZjyIQIRncjOpm4+PvRUYCB5KPKf14ByuZwO
-Z2XRyMBAsvfyogt5ig2j5/+dT0Gjg+hmq5vkP8if4tfGU8GNApJXaT9x3cMJ
-rAlQNIH5pPpobvJGYSGRk5M4WUFJcXFi3mtomL9YJqPhAQE0NyJCLcmLiCi7
-LJtMN5s+8NlJ7plc8rDwoIz9Grqj2LSJhJcmUnz8WvL0tKScnEbMYmlAdnU1
-WXl6kldRkVLnHTlCZG9PlJKi+DlZR7PI29GbpPlqult9iFRK9MLkIhqwqRdd
-uNqC8vM1dCHWgKLKIhp3aByN/XUsVRTlEc2ZIw7xRUQ8ngDy8ojGjiV6+mmi
-7Oyahy/n51NfPz/q7etLF/LyNDKgeik/nzrdvk0zw8Mpp44JJsX+xRQ0Ooh8
-uvpQxk8Z6hu90IDmlsCe6EocPwb8iIV9FkJHouZvAxEwbx4wdiwwfbrSpzs6
-imWIbt2q+5himQzPh4Sga8uW2OfsXO86L2VYtLTAKz1fETe8/GdxcvSSaPQ8
-3RPWc63V0sfDKpZOROC4iyhOPI++fQNhbj5ZI/0AgIW+Pr7u3BkLIiNRpWBJ
-qxs3xGVr584B7dsr3pfldEu0m9AOEa9FgAT1VwQplRUiZ+wYpMQ9BT+v8wgP
-n4GSkgC199MQE0MTnJpxCp3zgYyeDhCqKgEfH8DF5fEEYGYGnD0LDBkC9OsH
-ua8v1iQkYGZEBFbZ28Ovb1+MNTPTyCq20aamuNu/P6wMDNDD1xeHsrJqtvSp
-iK9A+KvhuDv+LixeskD/0P6wnmcNvba8/FZdntgEVlJdgt/Df8dc97nqb/zr
-r4GUFGDbNpWbuLeouTZFMhmeCwlBd2Nj7OnaFTpq3gBzxaAVOHD7AO6+fBd5
-f+ahj08fmAxSobREgwgZGfsQEDYCllavotcKKQz1NFzGC8B0S0t0adkSnyQl
-NXhsVBTw8svA0aNAz57K9+W01QmyAhmSNyWrEGndCioLMPqX0RjSYRDCvvwW
-x4+NRFjYDwgNnYiqqjS19qUI/XN/Yccn/rgyygmTJ5SjuoXB4w1AVxf49FMU
-fvstJnh4wDMqCiH9+mG6paXafz8eZqyri21OTjjdowe+SE7GZK9gBLwRiYAB
-ATB2NcbA6IGwXWILiT4vBFe3JzaBHbl7BM90egbWrdR8V+HlBXz+uVjn0LD+
-HX/rM3WqmMDkD+00XyCTYUxICHq3aoVdXbpo5JezfUl7bN+7HfHl8XC/4Q5D
-O9VfR12k0jyEhk5BWtq3cHe/jvYv7IOkrSmwb5/a+3qYBMCuLl2wOz0dQaWl
-9cQIvPoqsHatuHO2Sn3pS+B63BVp36ch/2K+ao08JL8iH6MOjsKIjiPw1div
-YNpWgosXgc2bX0Jm5hsIDZ0MQahQS18KubeNwqlTeG2PD3R0dTH99+mQCtLH
-FwOA0LIy9Le2Rpdhw/D3ypWwfPttQKaeGp+KGGBigpuGLlg8qxSnE7NBPi7o
-+FFH6LbSzBZC7AlOYHv89+D1Pq+rt9H0dPFyfe9eoJH191xcAAsLsbJ5TfNV
-VXgqMBBDTEywUwN3XgBQcKUAAQMDYDnLEqufWw2oP3chP/8C/Pzc0KKFE/r0
-uQNj4x6ARCLeua5dq/6KxrWwNTTEZkdHzI+MhLSOgr+ffAJYWwNvvNG4vgxt
-DeF6xBURsyNQlVbVqLakghQvHXsJwzsMx9YxW2vKO9nYiEOcixd/gIoKJ0RF
-LQSgmULGD7h0SSyjf/48MHQoDHQNcGzqMQgkYMbvMx5bEjuRk4Ong4KwtmNH
-fNO/P/Rv3waio4HZsx9bEss+mo2wZ0PQZ2NnDP+1J6ZkReFIdvZj6ftJ9UQm
-sICMAOSU52C002j1NVpZCUyeLJYVnzhRLU2+/PK/5QJjKyowLDAQr1haYnvn
-zmofzyeBkPRpEiJmRaDboW546pOn0KZFG5yNPqu2PmSyQkRGzkd09DK4uByE
-k9NW6OjclyHd3cUiv1u2qK3P+sy3sUE7fX18mfLolig+PsDu3eK1iDquE9qO
-aIv2b7dHxOwIkFz1xLL679Voqd8S257b9khtwm7dgJ07JVi4cB9KSqKQnKzh
-7+PNm8DMmcDJk0D//jUPG+ga4Pi046iWV2PmiZlq2+mgNgIRPoyPx7txcfir
-Vy+8Zv3PiIqJiZjRc3OBuXMfHcpQI5ISYlfEImFNAtwuu8FqlhWeNTXFFTc3
-fBAfj01JSY/jUuLJpO1ZJJrQ0CzEJWeX0IbrG9TXoSAQzZ4tlklozCLNh0RF
-iet8A4pKyNbLi35QUyWJh1XnVlPw88EUMDSAKlP/XaR55O4RGrF/hFr6yMu7
-QF5e7SkqajHJZLXXgiQisTaemRlRaqpa+m1IfEUFmXl4UMR96/TKyoi6diU6
-fly9fQkygQKGB1DS5iSVzj8UcoicvnGi/Ir660C+/TbRK6+kkJeXLeXmaqi+
-p7e3OFX28uU6D6mUVdKYX8bQgj8XaGRRtUBES6KiqL+fH2XXVWKqrEysz/ba
-a2qp3vGwqowqChgeQMFjg6k679EY0iorqY+fHy2IjKTqemYKe3qqPTSVNLdZ
-iE9cAiupKqG2m9tSSpES86Eb8uWX4qLKRlZ5qE2XlwrJ9LonHb9verA6FXkX
-0e0Otyl2ZSwJ1Q/+gt0rL+WX7qdy+1JpIUVGzqfbtztQfv7fip20erXiC+HU
-4JuUFBoSEFCzFOHNN4lefVUzfVUkVZCHhQcV36knidciKDOILLZYUEhW/bU0
-icRF1gMHEu3c6UUeHuZUWhqqari1CwwUqwufO9fgoSVVJdRrVy/66vZXag1B
-IKLlMTE0wN+fimpZ//WAsjKikSOJ5s5V6wVmsW8xedl6UfzaeBJkdSenEpmM
-XggJodFBQVT4UKyCQPThh0TduolFS7SNE1gTUF8C2xuwl8YfHq++zi5cILKx
-IUpS7aq6Pmdzc8n4kgdN3KhY5XWlCGLxWQ9zD8o+UXdy/NLrS3rl91dU6iI3
-9xx5edlTZOTrJJUqse4qP19cBBserlK/ypILAg0JCKBvU1Pp0iWxvmy+Br7l
-92QdyyLvzt4kK1bsjiCvPI8cv3Gsu+JFLZKSiKysiK5d+5m8vZ2oulpNpYrC
-wsRhgd9/V/iUxMJEsv7Sms7HnFdLCAIRfRAXR719fSm/oeR1T2kp0VNPES1Y
-oJYkVnS7iDwsPCj7N8UuLKWCQEuioqjHnTs168XkcqJly8RiIjmaL56iEE5g
-TUB9CWzgjwPpz8g/1dNRZKR4JerhoZ727rMvPZ2sPD3pt9AisrZW7+hHVXoV
-BT8fTL69fak8pv6CrIWVhWS62ZSSi5IVbr+yMoVCQ6eQt3cXxe+6HrZ1K9GL
-L6p2rgoiysqo3S0PsulZqUhlokaLnB9JEXMbXugrE2Q09tex9O7Fd5Xu48IF
-IltboqCgFRQUNErhLVjqlJEhNvir8tXoPZI9yGKLBYXnNP6iZENCwgOJQGEl
-JUTDhxMtWtSoJFboWSgWsj6vXCFrgYhWxcZSb19fyiqX0syZYk5Vck29RjW3
-BPZETeIIyQpBSnEKXujyQuMbKywUt879/HNg6NDGt/cPGRFWxMZic3Iyrru7
-Y2p3E9jYAB4e6mk/52QO/Nz90LpPa/Tx7oMWnVvUe3wbwzaY4z4H3/p822Db
-RDKkpGyHn19vGBv3RP/+IXVuONmgN98EAgMfnIapQS4tW8LW1w4t34/FaDXO
-7alL5286o8izCNlH65+ltv76elTJqvDFqC+U7mPsWGDBAuDdd7dAEGRITNyg
-arhAdbW4tmPRInHihpKG2g/FltFbMOHwBORV5KkcxhfJyTicnY3Lbm4w19dX
-7uRWrcSJHUFBwP/+p1L/RR5FCJ0Uim6/dIPZ82ZKnSsB8IWTEwa3agvnP0KQ
-Wy7HX3+ptns3Ez1RCWx/0H7MdZ8LPZ1GroSXSsUKG88/L65/UZN8qRQvhIQg
-vLwcPn37wqVlSwDibMTjxxvXtqxIhsi5kYhfHY/up7qj06edoGOg2H//2wPf
-xk+BP6GkuqTOY4qKvODv3xcFBRfRp48XHBzWQUfHSPWAjYyAjRuB1avFyiYa
-dvIkULG3AyROpTibp/obrKJ0W+nC9bArYt6KQWVSZa3H/Bn1Jw4GH8SxacdU
-/pldtw6QSPRw5swRZGb+hLy886oF/O67YsWLtWtVOx/AXPe5mOQyCVOPT1Vp
-ev03qanYm5GBK25usDJQcaF069ZiEjtxAtizR6lTC28WInRyKFwPucLsOeWS
-1z0lxUDY0s5oV2iMso9CIBhobnbkE0Hbt4CaUNsQYpWsiiy2WNRZaV1hMhnR
-yy8TjRtXa/FQVYWWlpKTtzetjI19pKJ8bKz4eYaqw4gFNwrotsNtiloURbIS
-1RqZdnxarR/EV1amUETEa+TlZUtZWUdJ+Z0t6yGTidVzT51SX5u1KC0V6xze
-uEF0JT+fOt6+TaUamLFWm6TNSRQwNOCRAsnpJelkudWSvFK8Gt1HVpY48nfj
-xi3y9LSkiooE5RrYv1+clqmGQrgyQUbP//o8LT6zWKmZiQcyMqi9lxclVahp
-x+uoKHH4/+JFhQ4vuFZAHuYelH9Z9Q9H8/PFz7sWLyaqlgo0OzycRgUFUYUa
-J5Y0VnMbQnxiEtgfkX/QsJ+GNa5huVwsVDpqlLjRnpqczs0lcw8POpBRd7Hc
-vn2Jrl1Trt3q3GqKWhxFnlaejd5v6HbKber4VUeSysWkLZUWUFzcB+ThYUbx
-8WuUm6ShjPPniVxc1Hqx8LD//e/BTURnh4fTqthYjfV3P0EuUOCIQEra9O8k
-IIEEGndoHK29ulZt/Zw7J+5sEh29jfz8+pJcruDPr6+vOKEmLExtsRRWFlK3
-77rR977fK3S8Z2EhtfPwoLvqnuV786a4FODu3XoPK7gqJq+CqwUqd1VeLn78
-tnTpv1uYSQWBXg4LoxdCQqiqiSSx5pbAnpghxP2B+zHPfZ7qDRCJn8vExQF/
-/CEOcTWSjAgfJyRgaXQ0zvbs+e8izFpMm6b4MCIJhIy9GfB19YVET4IBkQPQ
-bny7RsU6qP0g2JnY4WT4MaSmfo07d5whleaiX78QdOr0KfT0NDSQP3asWA5j
-/36NNB8dLY4k3b92+ksnJxzIykJIPWWm1EWiI4HLQRekbE9BaZDY3/7A/Ugr
-ScNHT32ktn5eeEEc8d60aQWMjBwQG7u84ZOys8WinLt3A66uaouljWEb/DHj
-D3x87WP4pfvVe2xyZSWmhoXhZxcX9DA2VlsMAIDhw8XqL+PHAxkZtR5SGlyK
-sOlhcD3mirZPt1WpG7lc/NjQxgb47rt/F8brSST4tVs36EskmBEeXmdFGFYP
-bWdQTXj4DiyrNIvafN6GiquUW3tTQxDE/Yb691fblKGIsjLq7+dHo4OCKE2B
-HV7j4sQRjwa3WPEvJv+B/uQ/yJ+K/VV8vbUQhGo6H/g2nbhkSCEh49W/tqg+
-d+6IY2BKbAqqCEEQd+H48stHn9ubnk6D/P1JrqZtahqScSCD7nS/QwmZCWS+
-xVyh9V7KKi0VRwJ//72IfHy6UkbGz3UfLJWKa6c+/FDtcdzzW9hv5PC1A+WV
-1z6br0QmIzdfX9qSrPgMWJVs3EjUr98j6zgrkyvJq70XZR3LUrlpQSBaskRc
-S13Xr3mlXE4bEhJU3mhVnfgOrAk6fPcwXnR5Ea0NWqvWwPr1wOXLUMeUIYEI
-36SmYlhgIOZaW+OimxtsFSj66+gIdOggVu+pjTRHiuil0bj7/F3YvG6D3p69
-0bqPiq/3PnJ5OdLSdsDHpwusEYz9qRYobLMaxsbdG922wvr3F2d6fv21Wps9
-fRpIShK3SnnYPGtr6Ekk+LGOK3N1s55tDaOuRjg67yhWDl6JnpYqlL5vgLEx
-8MsvwLJlJrCwOIG4uPdQWhpc+8GrV4vFqDduVHsc90x1nYoXnV/EnD/mQKAH
-t7YRiDAnMhLurVrhPXt7jcUAAPjoI6BHD/E26Z+SU7JCGUJeCEH7d9rD8mVL
-lZv+7DPA2xs4daru2t6GOjr42MEBLXSeiLdjtfrPf8cIhP1BjRg+/OILsSDh
-pUviLKxGSKqsxKjgYBzPyYF3nz5YZmenVE3D2mYjSnOliP8gHndc7kCiK0H/
-iP6wWWADiU7jCvhJpXlITNwIb28HFBRcg6vrMfR2v44JvdbiS68vG9W2SjZt
-ArZvF2vbqUFFBfDOO8COHUBts7F1JBLs7toVaxMSkFldrZY+6yUBPBd7wtXL
-Fa9L1Vxk+j4DBojFiRcv7gEnp68RFjYVMlnxgwedOSPO0jt8WNymRIO2jN6C
-3PJcbPXa+sDj6xMTkVldjd1du2pkH68HSCTiMGlhIfDhhxCqBYS+FIq2T7eF
-/buqJ8+9e8WR7wsXeKq8xmj7FlAT7h9CDMgIIIevHZTfdVkqJVqxgqhTJ6JG
-1iCUCgLtTE0lcw8P2pyUpPLuyQkJ4jCiVCpO0Ij7II48zDwoamkUVSY3PAyp
-iNLSEIqOfoNu3TKlyMj5VFb24GLbcmk5WW21osjcSLX0p5Q33iB65x21NLVu
-HdG0aQ0f92F8PL2ixgkMdYnOi6Z2X7Sj4MPBdLvjbZIWaW7SilRKNGgQ0Tff
-EEVFLabQ0GlUM3s0PV2stKGBxfl1SSpMIqutVnQ98ToRER3NyqKOt29TVlXV
-Y4uBiMRyGJ0cKXzYebo7+W695aEa8uef4rcxupGTnh83HkJsYn4O+hlz3ecq
-t+tyTg4wZgwQHg74+wO2tir1TQD+zM1FL19fHMvJwVV3d7zfoYPKuyc7OAA9
-batw67V43HG+A1mhDH0D+6Lr911haK/6vicyWRHS03fD338AQkKeh55eW/Tv
-fxfOzvvQsuWDu+q20GuBZf2XYfvt7Sr3p7KPPxbHwBISGtVMfLx45/WlAjeS
-H3XsCJ+SElzKV89eXrWRkxxzTs3BxyM+Rq9XesF0tClil8dqrD89PfHb+Mkn
-gFT6NSoqYpCW9j0gCGLl9sWL1bo4vyEd2nTAz5N+xqsnXsWlrES8GROD0z16
-wFLVtV6qMjdHwrOHUeGdAtfVUkh0Vfs99fERF5CfPg106aLmGNmDtJ1BNeHe
-Hdi9tV8JBQmKnxwQQNSxozi3uhFrgW4VFtKQgADqeecOncvNbdTqKEEmUO65
-XLr74l26bHSL9nSLooqkxk3jFwQp5edfoYiI1+jWrTYUGvoS5eaeU6jcUE5Z
-DpluNqWsUtU/3FbZ+vVEM2c2qomJE4k++0zx4y/k5ZGTt7fGPmT/wuMLGvnz
-yJpRAlmxjLwdvSnnpGYL5O3ZI9agLiqKIQ8PcyretYJoyBCNLlmoz3tXN5DR
-36focGa6VvpP35NO3p29qXrv7+J7gAoFtFNSxPlGfypVrU6gnJw/Sa1rKFXE
-d2BNyNnos+hh2QMObR0UO+HwYeC558RL802bVBr/Dy4txYuhoZgVEYEltrYI
-7NcPL7Rrp9I4flVqFRI3JsK7kzcSP06E2Qtm6BwwGB9kdYXESvlp/HJ5GXJz
-TyEyci68vGwQG/sOjI17YcCAaHTvfgLt2r0AiaTh12ze0hwzeszATt+dKryq
-Rlq5Erh6VSwzpYILF8Qb65UrFT9nrJkZ+rZujc+TklTqsz5xBXHY4rkF+ybu
-qxkl0G2tC5cDLoheGo3qTM19/rZwIdC+PbB1a2d0NViNcLNvITv4vXiL9pgJ
-RIgwnwSLimiEhT3+n6vCG4WIXxOPnud6Qn/BFHFCx8svi1V3FFReDkyaBLz1
-lnJbAiYnb0FCwkeQy8tUiPwJp+0Mer+ioiKKj48nmQJ3PnK5nBISEqiwluoA
-9+7AJhyeQAeDDzbccWUl0fLlRJ07N7iosTalMhn9lJFBQwMCyMLDg75KSaFK
-Fa/Wy6PLKWV7CgWOCKRbbW9R1JKoR6bDP/20osXABSovj6O0tN0UEjKebt5s
-TUFBz1BKytdUURGvUnz3ROdFk8UWCyqrVu/UdoV8/z3R6NFKnyaVittWKHd1
-LEqrrCTzh/YNayyBBBp9cDRt9dxa6/Nx78dRyPgQjV6YZ2QQOViWUXlHF4o+
-O5ru3p1M2rgT+DwpiQb5+1NKcQbZbbOjS3GPoaLyPyoSKsjTypPyLt43nV8u
-F6vtvPWWQm0IAtGMGeI2PMp8xJ2VdYS8vNpTZaUat3dqhOZ2B9ZkEtimTZvI
-zMyMXF1dycHBgUJC6l4HExUVRV26dCEXFxcyMzOjNWvWPPD8+vXr6b0P3yPT
-zaZUWl3P6v2qKqJdu8Q6QhMnKrWHhkBEt4uKaGFkJLW9dYvGhYTQyZycejet
-q7WdaoEKrhVQ7MpY8unqQ55WnhQ5P5JyTuaQrLT2RL5/vxjuI20JUiou9qeU
-lG8oNHQaeXrakJeXHYWFvUKZmYdIKlXvHiGTj05WuJqCWlVXE3XpQsqWjd+9
-m2jECOXeYO63IzWVRgQGqu3t/deQX8ltl1tNdZOHySvl5OvmS+k/anZILXb0
-EvrTZBaVlFSSn18fSkn5WqP9PexaQQFZeXpS8j8Lpa4mXCWbL20orVgzG7je
-T1YiI99evpSyvZYEUlhI5OxM9NNPDbbz6afiUrLy+jd3eKj5m+ThYU4lJUFK
-RKxZnMBU4OvrS61ataKEhAQiItq8eTP16dOHhDreaUaMGEEf/rPAMiMjg9q1
-a0fX7quztH79ehqzQNwJtlZVVUQ//EDUoQPR88+Lu8sqILe6mk7m5NDymBjq
-4u1NTt7e9FliIqUqsBCZiIgEovK4cso6mkWx78ZSwPAAutnyJvm6+1L82ngq
-8ikiQd7w22NxMVGHDtmUmHiVUlO/paioRRQQMJRu3mxFd+50p6ioxZSZ+QtV
-VCSSJq+mPZM9qfO3nUnW2G06VPHbb0S9eyu8LUZJibhtm6+v6l3KBIH6+fnR
-z/WU/FJUXnkeWX9pTT6pPvUeV3q3lDzaeVB5rBLvjMo4dYqoUydaMK2I3nqL
-qLw8ljw8zKmoqP641CW9qopsvbzor7wHFzOvv76eRuwfUWdyVwdBLlDolFCK
-mBNR96/JvS2T6nmP+OMPIjs75TYRLyuLJE9PS8rL+0u59Nd9pgAAIABJREFU
-oDWME5gKVq9eTdOnT6/5uqioiCQSCcXWUo8uMzOTAFDqfT8tr7/+Oi1btqzm
-63Xr15HlOEvySH5oKnBBgZi4OnZsMHGVymR0t7SUDmdl0ZvR0dTzzh0yuXWL
-xgYH0+dJSeRdVFRnlQZpgZSK/Yop+3g2JX2eRJELIylwZCB5tPMgL3svCp0S
-Skmbkyj/Sj5JCx/9BRWEaqqqyqSSkkDKyfmTUlN3UGzsKgoLm07+/oPJw8Oc
-Ll5sS2fPDqeoqCWUmvodFRRcp+pq5fYnUofBewfTyYiTj71fEgRx2+HDhxU6
-fP16oldU25fzAf7FxWTl6Um5yu5F9ZAFfy6gt84rNjyVsj2FAoYENGpad63S
-08Uq0V5elJ8vbuR5+TJRdvbvdPt2R43/PEkFgUYEBtLH/1y43k8myOiZA8+o
-tR7kwxI2JJD/IH+SVzRwEXT2rPjNqWU5TUiIWCpSwWtgIiKqqsoib29HSk/f
-q2TEmtfcEtjj/7S2FtHR0ejVq1fN1yYmJrCyskJ0dDScnJweODY2NhbGxsaw
-s7Oreaxr167466+/ar5OzoiDbZEhLM4FIyrlDISkZAhpqaDiElT16ImKb75C
-WUcHlMsFlPv4oEIgFFZXIbtShoyKamSVV6JcKsBGVx/tdfThrtsCr+gaoj0Z
-AgkVECpLIC9PQExRNWSF1ZAWV0JaWAVZcRVkhVUgiQwGHQEDOx3o2wL6I4DW
-LxPM7AVIjCshl5dCKi9DjrwUmeklkCUXQirNg1SaC6k0D3J5CfT0TGFgYAkj
-IwcYGnaAkVFHtG7d+59/d8L16zbYsEGCO3c0//9Tn/eGvIcvvb7EZJfJj7dj
-iUQsYDh3LvDSS3WXOQCQmQl8+624IqKx+rRujRmWlng/Ph57nZ1VauNm0k1c
-jLuIsGVhCh1vt9wOeWfzkLIlBR3+10GlPh9BJM71XrAAGDwYpgB+/FHcHSgk
-ZAosLLwRETELPXuehUSZJShKWJuQAH2JBB937PjIc7oSXRx66RD67O6D4R2H
-Y7Sjejdpyz2Vi4wfM9D3Tl/oGDXw+saNA5YtE3/Orl+vqYOamytO1ti+HRg4
-ULF+5fJyhIZOgKXlTNjYLGjci2BoEgmsoqICRg8VxzUyMkJFRUWtxxo+9GbV
-okULlJeX13xdHB0IFGZi0/VVNY/NeavlP/9KBeQXYJAAGABo+8/8QImEAJIA
-EkDyT81QSc16LR3IJRIkQQIY6YhVLiQS6OjoQaKrB+joQkdPD3p6ejDQ14OO
-vhF0dAygo2MIicQAgo4hqiUGkOu0hG51K+jqtoKBgTV0dY2ho2MMfX1T6Om1
-g76+OfT1zaGn17bBN41nnwXmzQMiIwEXl3oP1agXXV7E6r9XwyvFC0Pshzze
-zp96CujeXcxOq1bVedi6deL3ysFBPd1udHBAd19f3CoqwvA2bZQ6t0pehUVn
-FmHH8ztgYqhYeQaJjgQuP7vAr68fzMaaoVXvVqqE/aC9e8UCtn/8UfPQ2LFi
-0d/ly4H9+z9HUNAzSE7ehI4d1VdU+J5zeXn4NSsLAf361bku0rqVNQ5OPojZ
-p2bDf5E/bFurth7zYWV3yxC1KAq9LvSCgY2Ca80++EDcCHPpUuCnnyCTSzB9
-urjH5+z/t3ffYU1fXRzAv2EjQ6aI4ABxoMhwW/eoe9ddR4ta99va2oqrVq0b
-R1+1raNqq1i39a171QEIWEBAQFkCshEkAgYSkvP+cStKZSQhEMD7eR4eTfJL
-7jECJ3edO02+lyCSIjJyKvT1W8HOrhKHi6pQamoq9r11LlpiYqIao1GCuruA
-RETjx4+nZcuWlbjP3Nycbty48c61/v7+pKOjQ9K35j42bNhAQ4YMKb793Xff
-0ervVldZvDXFV19Vaa1Vue0J2ENDvYaqp/HISCJzc3boVSnCw9mJGQqsz5HL
-6YwMcvT3V3i16Zrba2jU76OUajPNK40C2gRUPORVkdhY9p6VsuI2N5eoeXM2
-NVZYmEK+vo0oO1u1KwITCwqogY8P3Xkh3/Ekq26tUtl8mDhLTH7N/SjNK03x
-J+flEbm4EP3wA335JdHAgYptFY2OXkzBwX1JKq3mCiMKqG1DiDViH5iLiwuC
-39rXk5ycjOzsbDg5Ob1zraOjI2QyGR4/flx838OHD+Hi4lLiOkHVV1BTu+nT
-gaNHWQEFdXJ3c0dwajCC05Tbm1UprVsDU6awblYpli5lH55NTVXb7FhLSzjo
-62O9AnvDnmQ9wa6AXdg1dJdSbVpNtoJBOwPELY9T6vkAWLHaTz5hb0opP1+G
-hsCvvwJz5wJZWdZwdDyGyMjpKCx8pnybb5EQYVJEBL6wtUUvE/mOJ1ndh/3f
-rr1TucLCVESInBwJi7EWsJpipfgLGBgAf/wB0bcbkXH8Fn7/Xf6tosnJe5Cd
-fRlOTmegoVHNFUbqMnVnUCKihIQEMjAwoD///JNyc3Np6tSpNHr06OLHd+zY
-QRs2bCi+PW3aNBozZgwJhUK6desWGRoaUmTkm5p9pR1oWVe5uCh+0GVV2Oa7
-jcaeGKuexp8/ZzPp/9p68ddfrJSlvItEFZX0z96wkNzcCq+VkYz6HO5DP/j9
-UKk2xVli8rX1pezrSnYpt25lJytW0HVYvZr1MKRSooSEzRQY2EUlPQeP2Fga
-FBKi8DE1KbkpZLPNhq7EKL9qL2ZJDIUMDKnUYpjAQKLRJn+RxNyKKE6+vZTP
-n18kH5+G9OpVrNLtVhfeA1NCkyZNcPr0aaxcuRL29vYoLCzEgQMHih+XSCSQ
-vLUjfvfu3TAwMICDgwMWLVqEI0eOoLU6J4LUaNo04Lff1B0FMKfjHHgneiM8
-U76FCSplbg6sWMHKa/xzKKBMBixZwgqqyHFajVJsdHWxwd4e7k+eoKiCwwiP
-hBxBnjgPCzovqFSb2mbaaH2oNR7PeAxxhoJVOh49AjZtAg4frrDrsHIlkJfH
-TrBp0uRr6Og0RGysAuVLSnElOxtH0tPxW+vW0FCwHqi1oTWOjzuOGedmID4n
-XuG204+l4/m553D83VHpGocZGWwdx7Rf+kDru5XAqFHsTSpHXt5DPH48A05O
-Z6Gvb69Uu1w51J1Bq8L71ANLSSEyMVH5WY9K2XhvI00+rYK16sooLGSnNf7z
-6dHLi50/WtVnBMqIqG9wcLmHLr7e8xWYEqiydmM9YilkcIhc+waJiL0/bm6s
-AKKcnj5l84dBQUQSyQvy82tOaWleSsWbVFBADRWY9yrLD34/kNvPbvRKIv++
-uJeBL8nb0pvyQsspalABsZhtgl/1elW/TEY0cybRqFFl9mYLCpLI19eW0tNP
-KN1udeM9MK5aWVsDXbsC58+rOxJgQecFuB53HVFZUdXfuI4Oq2H51VcozJNg
-xQpg61agqs8IFADY36oVNicmIuqtlbBvW3pjKSa2nYj21u1V1q7dWjsU5RQh
-aUeSfE9Yt459s8yaJXcbzZoBP/wATJ4MFBaaoG3b04iJWYT8/DCFYi0iwpTI
-SCywsZF73qssi7osQmuL1ph/cT4I5fd6AUCcIUb42HC0/KklDNoZKN3ukiWA
-kRE72xYA28bx44+AUFjqClipNA9hYcNhYzMfDRpMULpdrnw8gdUB06fXjGFE
-Ix0jLOq8CBu9N6ongOHDAVtb3J/+E9q2BXr3rp5mm+vrY0XTppgdFQXZv4YS
-fZ754HL0Zaztq9qTjQXaArT5vQ0SNyci90Fu+Rc/eADs28eWzis4dDd5Mtvj
-tHgxYGjoCgeH/yIsbBQkEvkPFl0bHw9dgQDLmlR+D5sAAuwfuR9/p/yNvX/v
-LfdakhAixkfAaqoVLD+yVLrNw4eBq1fZgqkSH4h0dICzZ1mF6F1vFuYQSRER
-MQlGRu3RpImH0u1yclB3F7AqvE9DiERs+NDEhA0nqtsL0Qsy22ym2BE2KpTr
-E0JZGhYU4V29VUmKZDLqEhhIP75VrUEsFZPTj050KvxUlbWbcSqD/Oz9yj4A
-Mz+f1fM7eVLpNl6+ZEvrz5xht2Njl1JwcG+5FnVcy84mG19fSlPx4ZSvi0n7
-JZVdAiNqQRSFDg+Vf5i1FHfvsmHUyMhyLoqLY3XKzrMjUaKiFtDDh/1q9HL5
-svAhRK7a1asHjBkD/P67uiMBTPRMMLfjXGzy3qSW9jdedEZYi7FwPKXaHk9F
-NAUC/NKqFVY9fYrEggIAwI77O9CkfhN81OajKmvXcpwlTAeaImpOFEodUfv6
-a6BzZ2D8eKXbMDJiJw3NmwckJQF2duuhqWmEmJj/oPRGmcSCAkyLjMQRR0dY
-qfhwyhZmLbB/5H6MPzkeGfkZ7zye8nMKXtx8AcejjqzwgBJiY9nbdvRoBcUC
-7OzYhvCZM5F4fxGEQm+0bXuOL5evBjyB1RHTpgGHDhUvwlOrxV0X41TEKSS9
-lHN+RkWSk4GffwZaHl/LjhyOjKzW9tsaGOA/Njb4LCoKT3PiscVnC3YP3V3l
-exIdtjsg/1E+Ug+llnzg0iX2tUu5fWdv69yZVeiYOhWQSjXh6OiFnJy77CTn
-UhTKZBgfEYHFtrboW8l5r7KMajUK01ymYdzJcZDI3qxSfnHjBeK/i0e7P9tB
-q75yxYaEQmDECGDVKnY4e4U6d0ba4clISfoZzmb7oaUlX5UVrnJ4AqsjevcG
-xGLA11fdkbADL93d3LHVd2u1trtmDTB7NmDtasV+8yxYUO0Z3aNJE2RKJBh1
-5wC++uAr2JnYVXmbGvoaaHOiDeKWxuFV5D8LSTIz2YKNw4cBBctdlWXpUjaF
-tmIFoKVljHbt/oeEhLV48eLmO9d+FRuLRjo6+EYF817lWdt3LYx1jTH7f7NB
-ILx68gqRH0eizYk20HfQV+o1i4rYWZb9+rFvIXlkZ19BnOlJOGd+DZ0RnwA5
-OUq1zSmGJ7A6QkOD/bDt3q3uSJivun2Fo6FHkZ6fXi3tRUayUZylS/+5Y9Ei
-IDeXlZWoRjoaGpipm4wIw64Y6jyv2to1aGMA+832eDT2EYqEEuCzz1h3SYUr
-WTQ1gZMngRMn2HC1vr7DP5U6pkAkiim+7lh6Oq5mZ+Nw69ZVXg9HU6CJ4+OO
-IzwzHOv/tx5hw8Ngt9EOJr2V7/V98QX7c+dO+a7PzX2AyMjpcHI6h3rzNrDM
-N2oUUEotV061eAKrQ2bMYKulUlMrvraqNTRsiKnOU7HxXvWsSFy2jCWv4pJR
-mpps5d3SpWwHajV5WfgSG68vwFdWRpgeFYOCaqzzZe1uDdN+pojsfQ0U95Qt
-nVcxS0v2QWHRIiA4GDA17Y+mTVchLGwkiopyEJ6fj89jYnCmbVvU16qeWuGG
-Oob4c9yfsPzKEqndUmHtbq30a+3eDdy8yZK0POGLRDEICxuFVq0OwNi4G+ui
-st3frFQ9T2JViiewOqR+fWDSJPZ7uyZY3nM5joYeRdyLStTuk4OPDysU/s5w
-j5sby+pfflml7b/tm+vfYFDzQdjk1Bst9fXhEVe1//Z/c/iPBqQRCYjvsrfK
-SpC4ugJ79gCjR7PPBjY2C2Bi0gchj8ZiUngwtjs4wNlQBRXz5UWAcKkQLg4u
-mO80H5djLiv1MleuAN9/D1y4AMgzbScWpyE0dDDs7NbAwmLkmwc0NdnQrZUV
-74lVMZ7A6pgFC4C9e9l8mLpZGVhhcbfF8LhRdXthiIBvvmGdjX+dyMOsXs0m
-Bq9erbIYXrsdfxsXoi7Ac6AnBAD2tWqFc8+f43J2dpW3DQAoKoLg02lou7II
-6dcJGSeqruc5cSLbIzZ+PCCRCODQYheCRTrwkK3B1AbmVdZuaZJ2JiHXPxed
-TnXC6cmnMf3cdASmKnb4W0AAWwh18iTwryMISyWRZCIk5ENYWU2DtfXsdy/Q
-1GTD15aWPIlVIZ7A6pi2bdmS33Pn1B0Js7jrYtxPuo/7Sfer5PXPnwfy84GP
-Py7jAgMDVjFh3jygjEoZqvBK8gqz/jcLPw77ESZ67OO7qZYWjrRujZmPHyO9
-Oj5RrF0L6OlBe+VCOP3hhOhF0cgNqmCTcyWsX8/e3sWLgR1JKfhF+zu01Rfg
-yZPZIKqeodPM05lI3JIIpz+doGmoiQ8af4B9I/Zh5O8j8TTnqVyvERbGRvsO
-HWJHzFVEInmOkJABMDcfgWbNvi37wtdJzMKCdVd5ElM5nsDqoIULVbJyWiXq
-adfD9/2+x1dXv5Kr9I8iJBI2xbVpUwUlowYPBrp1Y8sUq8i3f32Ljo06YmSr
-kSXu72VigpnW1vjk8eN3qnSo1LVrrNKGlxegoQFDF0O0/KklwseEQ5xeNclT
-U5PtDzuXmoX1UUk44eSKdk7n8OrVE8TGLkF5e8RUIftqNqLmR8H5sjP0mrzp
-fo9pPQbLeizDwCMDkZaXVu5rREezb48ffmCFXCoikWQjJORDmJkNhr39eqCi
-ZSpaWqxMjpkZ26z5zx5BTjV4AquDRo4EEhLYJHtNMNV5KkRFIpyJOKPS192z
-hw33DB4sx8U7drB5iYcPVRoDAAQkB+BI6JEyz/n6tlkzvCgqwq7kZJW3DYDt
-Lp4xgyUv6zcLGCw/soTVDCuEfxQOmbhqekTxWnko+PwJZCucEOOrB01NA7Rr
-dwEvXlxHQsKGKmkTAIS+QkROjYTTOScYur4737aw80JMd5mOnod6ltkTe/YM
-+PBDVt9w4sSK2ywqeoHQ0A9hajoA9vabUGHyek1Li+1LNDEBhgzhS+xViCew
-OkhLi42Y7dmj7kgYTYEmPAd6YumNpRBLVdMbeP6cHZWybZucT2jQANi4kW0U
-k0pVEgMAFEoL4X7eHTsG7YBlvdLr7WkLBDjm6Ih1CQnwFQpV1jYA1g2dOJEt
-C+zb952Hm33XDNqW2oj6rIxKHZWQVFiIkWFhONCmJc6sN8LEicC9e4C2thlc
-XK4hLe0gUlJ+Um2jAPJC8xA+JhyORx1Rv3vZe9xW9VqFz7t8jp4He+JRxqMS
-j2VkAAMGsLdtdilTWP9WVJSDkJCBqF+/N5o33wK5k9drWlqspEe7dkCnTkD4
-m2OHCIRL0ZcUez0OAE9gddasWcCZM0B1rR+oSH+7/mht0Ro/Pii9coOiVq9m
-iwgcHRV40qefsiOHPT1VEgMAbLi3AXamdpjcbnK519nr6+OooyM+Cg/HU1UO
-I3l4sE/2HqUvlBFoCOB4xBGvol4hZnGMypJYnlSKEWFh+I+tLcZYWKB/f7Y3
-bOxYwNsb0NGxhrPzdSQkfI/U1AMVv6CcRDEihA0JQ4vdLWA2yKzC6xd2Xogt
-H27BgN8GwC/JDwDw4gWrrjFxIjtCriJFRUKEhg5C/frd4eCwDQonr9e0tID/
-/hf49lugTx/g9GnkifMw4dQErL69GvmSfOVe932m7mKMVeF9K+ZblmnT2AG8
-NcWjjEdkucWSskVKnib8j7AwVmA1S5l6vfHxRA0aEN2/X6kYiIhC0kLIYosF
-Jb1Mkvs5u5KSqE1AAOVIyii+q4gzZ4iaNmUnUldA8kJCf3f4m2K/iWWHmFVC
-kUxGw0JD6bMnT955qatX2f+Njw+7nZ8fQffvN6X4+PVU2YYLkgrovt19Sjmg
-eNXqi1EXyXKLJZ0Kukbt2xN9/jk70qvCNgueUUBAO4qKWkSVfuPeFhhIkia2
-dGCQJX16ZrpC55tVJV7Ml6sxFi5kw4gqHDGrlLaWbTHWcSy+v/u90q9BxFa9
-rVrF5sUV1rQpsH8/2zBXie5pkawI7ufdsaH/BtgY2cj9vIU2NuhnYoIJEREV
-nuJcrpgYYM4ctu7bvOJl61omWnC+6ozsK9mI/y5e+XYBLI6JgVgmw+4WLd7p
-iwwcyKZ7Ro8G/PyAevUc4ebmg8zME4iOXggi5b4ZxelihAwIgc1CG1jPVHyj
-8tAWQ7Gj61lMOjkVzUeewo4dFZ8sk5sbiKCgrmjYcBpatPgBSve8SnGt/nO0
-cy/AwBdmOLg3Dfov+QpFZfAEVod17symfi7VoOH17/p8h8MPDyu9ufnCBVa0
-d+7cSgQxciQwbhxb+KBkpYxN3ptQX68+ZrWX/4DI13Y4OEATwKLoaOVG9EQi
-tgFr9Wr2nywnbXNtOF93RsapDCRsSFCmZWx/9gy3cnJwqm1baJeRAQYNYqvH
-R45k+6t0dW3g6noX+fmRiIiYAJlMsSFUUYwIwd2DYTXNCo2/bKxU3DdvAl+O
-64G1Dtdxx2AhVtxajkJpYZnXP3/+B0JDB8PB4b9o3PhrqCp5EQievp6Y8ccM
-/DTjFBr7PGI7wzt3ZvtBOMWouwtYFfgQ4hu//UY0YIC6oyhp3Z11NOr3USRT
-cEimsJCoRQuiy5dVEIRYTNStG9HmzQo/9W7CXWro2ZCSXyZXfHEZhBIJOQUE
-0I5nzxR7okxGNHky0YQJ8o2BlaIguYD8HPwocVuiQs/bnZREtr6+9FQkkuv6
-ixfZcOKtW+y2VFpA4eETKSioJ0kk8g0jC/2F5GPtQym/KH/Y3b59RFZWRHfu
-sNspuSk08veR1GZPG/JP8v/X1TJKTNxCvr6N6OXLB0q3WZqsV1k07uQ4ar+3
-PSXkJJR88NEjlbalrNo2hMgTWB0nEhE1bEgUFKTuSN54JXlFjrsd6VjYMYWe
-5+lJNGSICgNJSGDzYffuyf2UzPxMst1uS5eiL1W6+XiRiBr5+tKfcsxhFVu6
-lKhzZ6K8vEq1XZBYQPeb3adnO+VLoNufPaNm9+9TnJzJ67UrV1jyWLuWqKiI
-SCaTUnT0YgoIaEsi0dNyn/v8wnPytvSm5xcUeH/eIpUSff01kYMD0ZMnJR+T
-kYy8Qr3IcoslfXP9GxJJRCSTienx41n04IEzFRQoltzLU1BUQNt8t5HFFgua
-d2FejZnvKg1PYDUAT2Al7dlDNHSouqMo6UHyA7LcYin3AoiMDCJzc6KICBUH
-cuECka0ta6ACMpLR8GPDacm1JSpr3k8oJDNvb/LOyan44p07iVq2JMrMVEnb
-ojgR+Tn4UfTn0SQTl92b25iQQM39/ChBweT1WlISUd++RL17EyX+kxeePdtO
-3t5mlJp6mEpbHJGyP4V8rHxI6CdUqs20NPZhp0eP8t+u1NxUGn18NPXaZ0d3
-7rehkJAhVFT0Uqk2/01GMjoZfpLsf7CnoV5D6VFGzehllae2JTA+B/YemDWL
-HTfi7a3uSN7o2Kgj5neaj5nnZ8pVoWPVKlYuSqFl8/IYNgyYMoUVwqtgPmyn
-305k5Gdgfb/1Kmu+i7Exjjk6YsyjR7iQlVX2hSdOAFu3spqOFhYqaVvPTg8d
-HnSAKFaEh/0fQpxWco8eAVgbH4/DaWm46+qKJqUWm6yYjQ1w/TqbG+vYETh7
-FrC1XQxn52t49swTYWEjUViYUtxo/Jp4JGxIgOtdVxh3UexgSIkE2L4dcHJi
-XzdulP92WRmYY0fXDljd6jn2PYnHtxHauBBzq9L7Fe8n3Uf3X7pj/d312Dt8
-Ly5OuYi2lm0r9ZpcKdSdQasC74G96/Bhop49lZ42qRJiqZg67O1APz34qdzr
-AgIqsWxerkDERN27E3l4lHnJ6x5jbHZslYTgLxRSQx8fOpia+u6DN2+yN+Dh
-wyppWyaV0dM1T8nX1peEvqzHIyOiFXFx1DYggNIKC1XW1v37RHZ2RJ99RpSf
-z+bF4uJWkLe3JSU9PkShI0LogesDKkxVvM1r14hatyYaOJDo8eOKr3/58gE9
-eOBMISFDSCRKoBeiF7Q/cD/1OtSreLjP95mvXHO1uYW5dDHqIi2+spicfnQi
-iy0WdPjhYSqSFSn871Cn2tYDq54Dezi1mzoV2LyZlcwbNEjd0TDaGtr4bcxv
-6HWoFwbYD4CDmcM714jFgLs7qwSl1LJ5uQLRZru++/QBjI3Z4WJvERYKMfH0
-ROwZtgf2pvZVEkJnY2PcdnXFoNBQpIvFWNqkCVv39vAh23F78iTg4lIlbQs0
-BGj2bTMYdTBC2KgwNP2uGbZ9KMJtYQ5uu7rCQltbZW117cpKnC1YwHpmc+fq
-Yvas72Gb1AsxT+dAf1oLtBt8EDpGOnK/5tOnbENycDD7Phk1qvwl8lJpPuLj
-VyM93QsODtvRoMEkAALoAZjVfhZmtZ+FBGECvEK94H7eHWKpGB2sO8CingUM
-dQxhpGsEQx1DGOoYIj4nHt6J3ghKDUKnRp0wwH4ADow8gA7WHaClwX+9VjUB
-UTWfuV4N1vxTtHX16tVqjqRmOXOGlV/6+++K98BUp+33t+NM5Bnc/fQuNAWa
-JR5buxbw92fL56s85tRUlsRmzQK+/hoAW/Y8+fRkmOiZ4OfhP1dxAEByYSEG
-h4aiv6kptmtoQKNnT/ZbecKEKm8bAJ5GCPFgVCgymmtiwkFXNGhUr8raevIE
-OLKjEGaHomCrUwDd1XZoO3o7UlN3oUGDCWjUaAGMjNq/8zwiICKCnd919Spw
-5w6wfDk7Vkdfv+z2CgoSkZZ2EMnJe2BmNhgODjugrV3+cCyBEJQahPCMcOSJ
-85AnzkO+JL/47/V162OA/QD0aNID9bSr7r2qLiNGjMDcuXMxbNgwdYciF/4R
-4T0ydiwrB3j2LPDRR+qO5o0vun6B/z35Hzx9PbG0+9Li+x89YpV3goOrKeFa
-WwO3brGagpqawJdfYovPFoRnhiNgdkA1BADY6OrirpsbRvj7Y+qdOzi4bBn0
-qil5ncnMxPycaHx53hZjfipCdLtg5M2xRuMljaFtprpeGACAgPq+aRhyJhYN
-v7HBg1ZtsfMXDTzetgEDB36Brl1/gb39GEil1sjPXwAtrfHIydGDjw9LWlpa
-bCRh3jzg1Cl2mGupzVARsrIuIjV1H16+9EODBh/D1fUWDAzayRWmAAJ0sO6A
-DtYdVPiP51SFJ7D3iEDAznD64gtWKUFTs+LnVAcNgQYOjT6ETvs6YYjDEDhb
-OUMqBWbOZCfkNlZu76pybGxYEuvTBwGpf+NHGx94u3tDX6ucj/YqZnr1Kq7P
-mYMpBw7AzcwMP+XkoI88RwQrKV8qxRcxMfgrJwd/Ojmhs7ExsAtosqQxEr5P
-QEDWSniHAAAUJUlEQVTLANgstIHtYlto1a/crwxJtgQZXhlI3pMMDX0NuFx3
-gaGrIZoDmDQViIoC7txpAKFwGXx8voG+/iU0afIjDA2/Qn7+SPTt2xGff94C
-Dg4O0NNrDIHgzTo0IhnE4jQUFMRBJIpDbu4DZGaegZ5eMzRqNAdt2pyCpmbt
-7yVxb/AE9p4ZOJAdEnv0KCtEUVPYmdhh84ebMf7UePjP8sfBH02gpwd89pka
-grG1xdUDHmg9bi4ClnjAyriaMigRsHMn4OkJ/TNncLZrV5zNzMSMx4/xgbEx
-PJs3h42urkqbDMrNxeTISHQzNkZwx44weutTjV5TPbTa3wpNPJogYW0C/B38
-0WheI1hNsYJ+S30INOTrFpOMILwjROqBVGRdyILZEDO02NUCJv1N3nmNli3Z
-F6MJYASAERCJYuDkdA6vXgVCJDqOhw+jIZFkQ0/PDtrappBIslFQEA9NTSPo
-69tDT88e+voOcHG5Kndvi6t9eAJ7z7zuhU2fzsoBqvj3YaW4u7kjPCMcfX8Z
-goQt1+F/z7D8gyqryO3425j6YBluXDoLl4mfA2IdYMWKqu2yisWseKW/P3D/
-PvDPIo6PLC0x2MwMGxMT4fL33/imcWN8YWsLnUq8MQTAWyjEnuRkXMrKwr5W
-rTCpQYMyr9dvro/Wv7bGqyevkLg5EWHDwyB5LoFRRyMYdTaCcWdjGHU0gkBb
-AHGamH2lsj9FcSLk3MqBhp4GrGdZw+EHB2hbKD4cqa/v8E9Jpzek0nyIRDEo
-LEyGrq4t9PXtoKlppPBrc7UXT2DvoZ492X6qAwfYarCaQgABPAduQ+Nzc2C2
-YCRs7S4CqL6hOwAISg3C+FPjcXzccbjY9Qduu7ANaFeusDesTRvVN5qdzSYl
-jYzYZj2jkr+EDTQ18b2dHWY0bIjPo6NxKC0NC2xsMNzcHM0U2JuVK5XCKz0d
-PyYnQySTYV6jRvixRQuYybnKsF6remh9sDUAQPJcgpcBL5Hrn4uUn1MgvCeE
-ppEmdBrqQMdKBzoNdaBtpY16rerBeqY1jDsbq7IWLgBAU9MAhoYuMDSsmtWZ
-XM3HE9h76vvv2UnGU6eWPQGuDr8cEKBh4E9o9eF0jDs5DucmnoOOpvxLqisj
-KisKw44Nw97he9Hfrj+7s2lT4O5d4KefgF69gP/8h529paOCmCQSdkr0ihVs
-PHfTpnJ7eS309XHR2RkXs7LglZ6OdQkJMNTURD8TE/Q3NUVfExNY6eigQCZD
-pkSCTLEYGRIJMsRi3BEKcS4zE71MTODZvDkGmJpCoxIrY7QttGE+1BzmQyuu
-hM9xVYUnsPdU+/bsQ//8+Ww+rCYsq4+LY0uh79zRhKPTYUw4NQFTzkzB8XHH
-q3xPTdyLOAw8MhDr+q7DWMexJR/U0GBd1REj2LK39u1Zb6xrV+UaKypiZ46s
-Wwc4OADnzwPdusn1VAGA4ebmGG5uDgIQnp+PWy9e4PeMDMyNikKuVApNAJY6
-OrDU1kYDbW1Y6uighb4+gjt2RFMlq2lwXE3EE9h7bNs2drr50aOskpI6vXzJ
-jt9Ytw5wdgYAbRwfdxwjfx8J9/PuODz6MDQEVTMhdiHqAtzPu2N5z+XlH4/S
-pAnbkHb8OFvG2a8fG17s2ZNtgK6IVAocO8Y2tzVuzM4c6dlT6bgFAJwMDOBk
-YID/2NqiiAh5Uinqa2mperSO42oknsDeY/XqsWPg+/dnHQCHdwthVAuplA1l
-du9eck5OV1MX5yaew+Cjg+F+3h37R+6Htobq9iMVSgux9PpSnI08i9MTTqNX
-014VP0kgACZPBj78EPj5Z/YpYOJEoF07ltD69QM6dADS0liXMjb2zZ++vmzy
-cd8+ttdMxbQEApho8R9p7v3Bi/m+55ydWaHcKVPYQjh1WLkSEAqBXbveHcqs
-p10PF6ZcQHp+Olx/dsVf8X+ppM3o7Gh0O9AN8TnxCJ4bLF/yepuFBQv81i0g
-M5Mt7dTQAL79FjA1ZUWCd+5kJSNsbIBPP2UlI+7erZLkxXHvI/5xjcOiRay6
-wbffsnUE1cnLi43IBQSUvS7CWNcYlz6+hD8e/4FP/vgEHzT+AJ4DPWFjZKNU
-m0dCj+DLq19ide/VWNB5AQSVHXDT13/T+1q3rnKvxXGc3HgPjINAABw6xNYV
-3LxZfe0GBLCqIOfPs83V5RFAgDGtxyByQSSamzaHy08u8PT1hEQmkaut9Px0
-7A/ajw9++QDr767H9WnXsbDzwsonL47j1Ib3wDgAQIMGLInNmMEKoKvoyKky
-JSez2oz79r1etCGfetr18H2/7zHDdQYWXVqE7fe3Y3Tr0Whu1hzNTZvD3tQe
-9qb2xZXCzz0+h3OR5xCaHoohLYbgi65fYHjL4XWi8CrHve94AuOKDRzIqnO4
-u7NeUVUtrc/NZYv45swBxoxR7jVamLXA5amXcSf+DkLSQxD3Ig6342/j6Yun
-eJrzFBKpBPX16mNUq1Hw6OGB/vb9oatZg8qOcBxXaTyBcSVs2MC2N82YAezf
-r/pSU4mJrOfVpg1bA1EZAgjQp1kf9GnWp8T9BEJGfgbM9c35mUwcV4fxOTCu
-BB0dtlAuL48tlktLU91r//UX0KUL6+X9+mvV9fAEEMDKwIonL46r43gC495h
-aAicPs2GFDt3BgIDK/d6ROxMxsmT2UKRJUtqRuUPjuNqN/4RlSuVhgbw3XeA
-kxOrmbhrF+s5KerVK2D2bLYdys8PaNZM1ZFyHPe+4j0wrlzjxgHXrwNLl7Jj
-24uK5HteURFw7RqbT9PQAHx8ePLiOE61eA+Mq5CrK9uzNXYsKzLRvz/Quzf7
-cnF5U0A9J4edOnLhAnD5MisdOH8+W23Ihww5jlM1nsA4uVhZsV5UaiqriHTn
-DtvDlZbGEpxYDISGshNHRowANm5k9Wo5juOqCk9gnEKsrdlc2Ov5sPR0tmpR
-RwcYMAAwMFBvfBzHvT94AuMqxcoKGD9e3VFwHPc+4os4OI7juFqJJzCO4ziu
-VuIJjOM4jquVeALjOI7jaiWewDiO47haqcYlsLS0NKSmpqo7DI7jOK6GqzEJ
-7NWrVxg6dCg6duyIzp07Y9CgQcjPzy/12ry8PGhpaZX4mj9/fjVHzHEcx6lT
-jUlgW7duxcuXLxEXF4enT59CIpFg48aNZV4vlUqRk5ODgoICFBQUYNeuXdUY
-LcdxHKduNSaBnTlzBrNnz4aOjg60tLQwd+5cnDp1qtznaGhoQENDA1paWtB8
-XZCP4ziOey/UmAQWHR2NVq1aFd9u2bIloqOjIZVKy3xOw4YNoauri169eiEi
-IqI6wuQ4juNqiCovJXXp0iUEBASU+pienh48PDwAAAUFBdB96/x6fX19EBEK
-CwtRr169Es/T1dVFUFAQXFxckJeXBw8PDwwZMgQxMTHQ1tYGANy+fbvEc1av
-Xq3CfxXHcVztl5qain379hXfTkxMVGM0iqsxtRCNjIyQm5tbfPvly5fQ0dGB
-vr7+O9dqa2vDzc0NAGBsbIxt27Zh7969CAsLQ/v27QEAffr04UmL4ziuHNbW
-1iV+T/79999qjEZxVZ7Ahg4diqFDh1Z4Xbt27fDw4UP06tULABAcHAxnZ2cI
-5DhISiKRgIigpVVj8jHHcRxXxWrMHNisWbOwc+dOPH36FAkJCfD09MTs2bOL
-H//4449x48YNAICvry9u3LiB9PR0PHnyBDNnzkTr1q3Rtm1bdYXPcRzHVbMa
-02X55JNPkJSUhD59+oCI4O7uXiKBFRYWFi/oePXqFZYvX46nT59CV1cXvXv3
-xrVr1/hKRI7juPdIjUlgAoEAq1atwqpVq0p9/PTp08V/HzBgAAYMGFBdoXEc
-x3E1UI0ZQuQ4juM4RfAExnEcx9VKPIFxHMdxtVKdTGApKSlISUlRdxhKO3Hi
-BHJyctQdhtLK2rheW/D41ScjIwN//PGHusNQmq+vL8LCwtQdhtKSkpIgFovV
-HYbc6mQCE4vFteo/4d+eP39ebgmtmu7KlSvqDqFSePzqI5FIkJWVpe4wlJab
-m4tXr16pOwylicViyGQydYchtzqZwDiO47i6r8Yso1elly9fQigU4vz58+oO
-RSmhoaGoX78+jIyM1B2KUh4/flxr33uAx69OWVlZePjwYa2NPzg4GAYGBkhL
-S1N3KErJzc2tVdMXAiIidQehagsWLIC/vz8aN26s7lCUIhaLoa2tLVcZrZoo
-IyMDDRo0UHcYSuPxq49MJkNRURF0dHTUHYpSioqKIBAIam1RhYiICCxfvhwz
-ZsxQdyhyqZMJjOM4jqv7+BwYx3EcVyvxBMZxHMfVSnUugYnFYqxcuRKdOnXC
-oEGDcPfuXXWHJDciwn//+18MHz4cbm5uGDt2LO7fv6/usJSyceNGuLq6IiYm
-Rt2hKCQvLw8rVqxAly5d0L17d3h6eqo7JLlJpVJs2bIF3bt3R6dOnbBo0SJk
-Z2erO6wyFRQU4MiRI/j8888xadKkUhc+HDx4EN27d0ePHj1w+PDh6g+yHGKx
-GF5eXli8eDEmTZqEZ8+elXj85MmTmDBhAtzc3DBo0CCcO3dOTZGW7t69e/js
-s8/QpUsXzJkzp8zr/Pz84Orqiv3791djdPKpcwls+fLluHnzJg4ePIgZM2Zg
-+PDhiI2NVXdYcpFKpbh27Ro+/fRTHDhwAO3bt0ffvn1rXRIICgrCuXPnEBIS
-goKCAnWHIzepVIphw4YhIiICnp6e2Lx5c61aDLFjxw7s3bsXW7duxaFDhxAd
-HY1PPvlE3WGVKSsrC8eOHYOenh5OnDiBvLy8Eo+fPn0aK1aswKZNm7BhwwZ4
-eHjUqCQgFArx22+/QV9fHydOnIBQKCzx+MWLFzF06FDs378fEydOxJQpU3Dp
-0iU1RfuulJQUNG3aFG3atCnzd2RBQQHmzZsHsViM9PT0ao5QDlSHFBYWkoGB
-AXl7exffN27cOPLw8FBjVJXj7OxMe/fuVXcYcissLKT27dtTYGAgAaCwsDB1
-hyS3U6dOkZ2dHYnFYnWHopQJEybQsmXLim9funSJGjZsqMaI5CMSiQgARUdH
-l7i/R48etH379uLbnp6e1Ldv3+oOTy7yfK9PmTKF5s+fX00RyW/Hjh3Uv3//
-Uh9bvnw5rVmzhkaNGkXr1q2r5sgqVqd6YNHR0cjPz0fHjh2L7+vSpUutOyb7
-NZFIhOTkZDRr1kzdocht8+bN6NevH9q3b6/uUBR29epVDBgwANu2bcPYsWOx
-dOlSZGRkqDssuQ0ePBhXrlxBamoq8vPzcfz4cQwbNkzdYSmFiBAYGIguXboU
-39elSxcEBQWpMSrlERFiY2Nr1c9yUFAQLly4AA8PD3WHUqY6lcBycnJQr149
-6OrqFt9nampaK0vTEBEWLVoENze3WnP22aNHj3Ds2DGsWbNG3aEoJS0tDV5e
-XsjOzsa8efOQkJCAPn36QCKRqDs0uUydOhXNmjVDkyZNYGFhgYCAAKxfv17d
-YSlFLBZDJBLB1NS0+D5TU1MIhcJaVerotZ07dyIzM7PcuaaaRCwWY9asWfj5
-559r9J68OpXAdHR0IJFIQG9tbROLxdDT01NjVIojIixduhSBgYE4efIkNDRq
-x3/T7Nmz8c033yA7OxtJSUkAWFL499xGTaWjo4MWLVpgy5Yt+PDDD/Hrr78i
-KSkJ3t7e6g5NLl9++SVEIhGys7ORm5uLcePGYdiwYSV+HmoLLS1WJOjtmqZi
-sRhaWlq1boP/r7/+Ck9PT1y5cgXGxsbqDkcuO3bsQMuWLdG4cWMkJSVBJBJB
-KBQiMzNT3aGVUDt+M8qpWbNmkEgkSE5OLr4vNjYW9vb2aoxKMUSElStX4vLl
-y7h+/XqJT6A1nVAoxJo1a9CjRw/06NEDADB9+nScOXNGzZHJx97eHg0bNiy+
-raurC3Nz8xq9ku9tly5dgru7O4yMjKClpYUFCxYgMDAQqamp6g5NYZqammja
-tCni4uKK74uNjYWdnV2tSmDHjh3DsmXLcOPGDbRo0ULd4cgtNTUVfn5+xT/L
-9+7dw/79+/HFF1+oO7QS6lQCs7S0RJcuXXDkyBEAQH5+Pk6fPo1Ro0apOTL5
-rVmzBmfPnsXNmzdhYWGh7nAUEhERgfj4+OIvALh27VqtKUszduxYPHjwoHjI
-+dGjR3j27Bnc3NzUHJl8bGxs4O/vX3zb398f+vr6MDMzU2NUyhs9ejR+/fVX
-EBGICL/99htGjhyp7rDkduLECSxevBhXr16Fo6OjusN5h0QiQV5eHgoLC1FU
-VIS8vDyIRCIAbMjz7Z/lgQMHYsmSJfDy8lJz1P+ituUjVSQwMJCsrKxowIAB
-ZG9vT5MmTSKpVKrusOTy/PlzAkAmJiZkY2NT/LV79251h6aU+vXrU3h4uLrD
-UMiyZcvIxsaGhg8fTmZmZrR161Z1hyQ3Hx8fsrCwoG7dutHAgQPJ0NCwxq9g
-tbe3p0aNGhEAsrKyIhsbG8rKyiIi9vPg7OxMnTp1oo4dO5Krq2vxYzWFo6Mj
-2djYEABq0KAB2djYUEpKChERNWzYkAwMDEr8LM+bN0/NEb/h5eVF9evXL/E1
-bdq0Uq+dMmUKbdmypZojrFidrIWYn5+PoKAgmJubw9HRsdYMOchkslJXvRka
-GsLQ0FANEb2fXn/qbNWqFaytrdUdjkJEIhFCQkIgFovh5ORU43tfpW1ebtCg
-QfG8b1FREYKCgiAQCODm5lY8N1ZTpKenvzPHaGlpCU1NTWRkZLyz4ERPTw8m
-JibVGWKdVicTGMdxHFf31ak5MI7jOO79wRMYx3EcVyvxBMZxHMfVSjyBcRzH
-cbUST2Acx3FcrcQTGMdxHFcr8QTGcRzH1Uo8gXEcx3G1Ek9gHMdxXK3EExjH
-cRxXK/EExnEcx9VKPIFxHMdxtRJPYBzHcVytxBMYx3EcVyv9H492n6HuLCzN
-AAAAAElFTkSuQmCC
-" /></p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">37</span><span style=" color:#000080;">]:</span> 1/0</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#8b0000;">---------------------------------------------------------------------------</span></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#8b0000;">ZeroDivisionError</span>                         Traceback (most recent call last)</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#006400;">/Users/minrk/&lt;ipython-input-37-05c9758a9c21&gt;</span> in <span style=" color:#4682b4;">&lt;module&gt;</span><span style=" color:#00008b;">()</span></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#006400;">----&gt; 1</span><span style=" color:#8b0000;"> </span><span style=" color:#4682b4;">1</span><span style=" color:#00008b;">/</span><span style=" color:#4682b4;">0</span></p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#8b0000;">ZeroDivisionError</span>: integer division or modulo by zero</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">38</span><span style=" color:#000080;">]:</span> </p></body></html>
\ No newline at end of file
diff --git a/docs/source/interactive/figs/jn.xhtml b/docs/source/interactive/figs/jn.xhtml
deleted file mode 100644
index f802a0a2a58..00000000000
--- a/docs/source/interactive/figs/jn.xhtml
+++ /dev/null
@@ -1,375 +0,0 @@
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="qrichtext" content="1" /><style type="text/css">
-p, li { white-space: pre-wrap; }
-</style></head><body style=" font-family:'Monaco'; font-size:13pt; font-weight:400; font-style:normal;">
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Python 2.6.1 (r261:67515, Feb 11 2010, 00:51:29) </p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Type &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information.</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">IPython 0.11.alpha1.git -- An enhanced Interactive Python.</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">?         -&gt; Introduction and overview of IPython's features.</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">%quickref -&gt; Quick reference.</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">help      -&gt; Python's own help system.</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">object?   -&gt; Details about 'object', use 'object??' for extra details.</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">%guiref   -&gt; A brief reference about the graphical user interface.</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">1</span><span style=" color:#000080;">]:</span> from scipy.special import jn</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">2</span><span style=" color:#000080;">]:</span> x = linspace(0,4*pi)</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">3</span><span style=" color:#000080;">]:</span> for n in range(6):</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">   ...:</span>     plot(x,jn(n,x))</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">   ...:</span>     </p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><svg width="432pt" height="288pt" viewBox="0 0 432 288"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
-   version="1.1"
-   id="svg1">
-<filter id="colorAdd"><feComposite in="SourceGraphic" in2="BackgroundImage" operator="arithmetic" k2="1" k3="1"/></filter>
-<g id="figure1">
-<g id="patch1">
-<path style="fill: #ffffff; stroke: #ffffff; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000"  d="M0.000000 288.000000L432.000000 288.000000L432.000000 0.000000
-L0.000000 0.000000L0.000000 288.000000"/>
-</g>
-<g id="axes1">
-<g id="patch2">
-<path style="fill: #ffffff; opacity: 1.000000"  d="M54.000000 259.200000L388.800000 259.200000L388.800000 28.800000
-L54.000000 28.800000L54.000000 259.200000"/>
-</g>
-<g id="line2d1">
-<defs>
-  <clipPath id="pde1d8605900ecf467d3e3eb151742d3e">
-<rect x="54.000000" y="28.800000" width="334.800000" height="230.400000"/>
-  </clipPath>
-</defs><path style="fill: none; stroke: #0000ff; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000" clip-path="url(#pde1d8605900ecf467d3e3eb151742d3e)" d="M54.000000 54.400000L60.132975 56.496003L66.265950 62.681140
-L72.398925 72.652403L78.531900 85.923153L84.664875 101.849578
-L90.797850 119.665589L96.930825 138.524169L103.063800 157.542815
-L109.196775 175.850503L115.329750 192.633530L121.462726 207.177644
-L127.595701 218.904160L133.728676 227.398050L139.861651 232.426547
-L145.994626 233.947300L152.127601 232.105780L158.260576 227.222228
-L164.393551 219.769050L170.526526 210.340112L176.659501 199.613826
-L182.792476 188.312270L188.925451 177.158765L195.058426 166.836404
-L201.191401 157.949938L207.324376 150.993151L213.457351 146.323558
-L219.590326 144.145739L225.723301 144.504129L231.856276 147.285483
-L237.989251 152.230671L244.122226 158.954900L250.255201 166.974960
-L256.388177 175.741722L262.521152 184.675801L268.654127 193.204171
-L274.787102 200.795477L280.920077 206.991931L287.053052 211.435915
-L293.186027 213.889771L299.319002 214.247707L305.451977 212.539250
-L311.584952 208.924207L317.717927 203.679608L323.850902 197.179618
-L329.983877 189.869792L336.116852 182.237382L342.249827 174.779646
-L348.382802 167.972148L354.515777 162.239054"/>
-</g>
-<g id="line2d2">
-<path style="fill: none; stroke: #008000; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000" clip-path="url(#pde1d8605900ecf467d3e3eb151742d3e)" d="M54.000000 182.400000L60.132975 166.121349L66.265950 150.641291
-L72.398925 136.714888L78.531900 125.012633L84.664875 116.084250
-L90.797850 110.329383L96.930825 107.976844L103.063800 109.073560
-L109.196775 113.483814L115.329750 120.898751L121.462726 130.855550
-L127.595701 142.765073L133.728676 155.946344L139.861651 169.665810
-L145.994626 183.179062L152.127601 195.772600L158.260576 206.803212
-L164.393551 215.732723L170.526526 222.156153L176.659501 225.821727
-L182.792476 226.641707L188.925451 224.693508L195.058426 220.211220
-L201.191401 213.568148L207.324376 205.251562L213.457351 195.831264
-L219.590326 185.923942L225.723301 176.155493L231.856276 167.123595
-L237.989251 159.362755L244.122226 153.313885L250.255201 149.300145
-L256.388177 147.510389L262.521152 147.991087L268.654127 150.647043
-L274.787102 155.250711L280.920077 161.459378L287.053052 168.839032
-L293.186027 176.893323L299.319002 185.095758L305.451977 192.923085
-L311.584952 199.887808L317.717927 205.567828L323.850902 209.631434
-L329.983877 211.856186L336.116852 212.140626L342.249827 210.508207
-L348.382802 207.103342L354.515777 202.179944"/>
-</g>
-<g id="line2d3">
-<path style="fill: none; stroke: #ff0000; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000" clip-path="url(#pde1d8605900ecf467d3e3eb151742d3e)" d="M54.000000 182.400000L60.132975 181.353436L66.265950 178.282249
-L72.398925 173.387743L78.531900 166.991680L84.664875 159.516525
-L90.797850 151.459519L96.930825 143.362139L103.063800 135.776810
-L109.196775 129.232915L115.329750 124.204154L121.462726 121.079252
-L127.595701 120.137787L133.728676 121.532621L139.861651 125.279970
-L145.994626 131.257739L152.127601 139.212185L158.260576 148.772519
-L164.393551 159.472523L170.526526 170.777890L176.659501 182.117591
-L182.792476 192.917398L188.925451 202.633500L195.058426 210.784217
-L201.191401 216.977882L207.324376 220.935250L213.457351 222.505094
-L219.590326 221.672105L225.723301 218.556644L231.856276 213.406433
-L237.989251 206.580726L244.122226 198.527979L250.255201 189.758406
-L256.388177 180.813131L262.521152 172.231814L268.654127 164.520733
-L274.787102 158.123239L280.920077 153.394357L287.053052 150.581021
-L293.186027 149.809093L299.319002 151.077871L305.451977 154.262341
-L311.584952 159.122943L317.717927 165.322170L323.850902 172.446901
-L329.983877 180.035026L336.116852 187.604683L342.249827 194.684278
-L348.382802 200.841421L354.515777 205.709022"/>
-</g>
-<g id="line2d4">
-<path style="fill: none; stroke: #00bfbf; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000" clip-path="url(#pde1d8605900ecf467d3e3eb151742d3e)" d="M54.000000 182.400000L60.132975 182.355206L66.265950 182.046046
-L72.398925 181.229835L78.531900 179.705763L84.664875 177.332192
-L90.797850 174.039886L96.930825 169.840196L103.063800 164.827628
-L109.196775 159.176539L115.329750 153.132115L121.462726 146.996175
-L127.595701 141.108660L133.728676 135.825984L139.861651 131.497645
-L145.994626 128.442586L152.127601 126.926881L158.260576 127.144198
-L164.393551 129.200383L170.526526 133.103205L176.659501 138.758033
-L182.792476 145.969807L188.925451 154.451294L195.058426 163.837209
-L201.191401 173.703419L207.324376 183.590094L213.457351 193.027449
-L219.590326 201.562512L225.723301 208.785287L231.856276 214.352717
-L237.989251 218.008953L244.122226 219.600665L250.255201 219.086430
-L256.388177 216.539590L262.521152 212.144352L268.654127 206.185351
-L274.787102 199.031258L280.920077 191.113423L287.053052 182.900797
-L293.186027 174.872667L299.319002 167.490817L305.451977 161.172812
-L311.584952 156.267988L317.717927 153.037612L323.850902 151.640377
-L329.983877 152.124104L336.116852 154.424122L342.249827 158.368392
-L348.382802 163.689038L354.515777 170.039548"/>
-</g>
-<g id="line2d5">
-<path style="fill: none; stroke: #bf00bf; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000" clip-path="url(#pde1d8605900ecf467d3e3eb151742d3e)" d="M54.000000 182.400000L60.132975 182.398563L66.265950 182.377231
-L72.398925 182.286621L78.531900 182.049876L84.664875 181.570415
-L90.797850 180.741920L96.930825 179.459808L103.063800 177.633279
-L109.196775 175.196983L115.329750 172.121355L121.462726 168.420751
-L127.595701 164.158631L133.728676 159.449281L139.861651 154.455734
-L145.994626 149.383888L152.127601 144.473021L158.260576 139.983223
-L164.393551 136.180457L170.526526 133.320174L176.659501 131.630524
-L182.792476 131.296286L188.925451 132.444605L195.058426 135.133569
-L201.191401 139.344481L207.324376 144.978477L213.457351 151.857884
-L219.590326 159.732408L225.723301 168.289938L231.856276 177.171451
-L237.989251 185.989245L244.122226 194.347455L250.255201 201.863704
-L256.388177 208.190573L262.521152 213.035604L268.654127 216.178603
-L274.787102 217.485128L280.920077 216.915300L287.053052 214.527309
-L293.186027 210.475322L299.319002 205.001831L305.451977 198.424816
-L311.584952 191.120421L317.717927 183.502112L323.850902 175.997525
-L329.983877 169.024350L336.116852 162.966678L342.249827 158.153208
-L348.382802 154.838632L354.515777 153.189297"/>
-</g>
-<g id="line2d6">
-<path style="fill: none; stroke: #bfbf00; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000" clip-path="url(#pde1d8605900ecf467d3e3eb151742d3e)" d="M54.000000 182.400000L60.132975 182.399963L66.265950 182.398830
-L72.398925 182.391234L78.531900 182.363764L84.664875 182.292131
-L90.797850 182.139654L96.930825 181.857314L103.063800 181.385517
-L109.196775 180.657509L115.329750 179.604302L121.462726 178.160746
-L127.595701 176.272341L133.728676 173.902231L139.861651 171.037803
-L145.994626 167.696295L152.127601 163.928858L158.260576 159.822590
-L164.393551 155.500202L170.526526 151.117100L176.659501 146.855878
-L182.792476 142.918378L188.925451 139.515660L195.058426 136.856423
-L201.191401 135.134509L207.324376 134.516275L213.457351 135.128626
-L219.590326 137.048554L225.723301 140.294910L231.856276 144.823101
-L237.989251 150.523187L244.122226 157.221700L250.255201 164.687256
-L256.388177 172.639823L262.521152 180.763246L268.654127 188.720426
-L274.787102 196.170364L280.920077 202.786118L287.053052 208.272654
-L293.186027 212.383537L299.319002 214.935429L305.451977 215.819482
-L311.584952 215.008870L317.717927 212.561916L323.850902 208.620506
-L329.983877 203.403786L336.116852 197.197395L342.249827 190.338771
-L348.382802 183.199306L354.515777 176.164341"/>
-</g>
-<g id="matplotlib.axis1">
-<g id="xtick1">
-<g id="line2d7">
-<defs><path id="m30e32995789d870ad79a2e54c91cf9c6" d="M0.000000 0.000000L0.000000 -4.000000"/></defs>
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="54.000000" y="259.200000"/>
-</g></g>
-<g id="line2d8">
-<defs><path id="m9281cae24120827b11d5ea8a7ad3e96b" d="M0.000000 0.000000L0.000000 4.000000"/></defs>
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="54.000000" y="28.800000"/>
-</g></g>
-<g id="text1">
-<defs>
-<path id="c_7a2040fe3b94fcd41d0a72c84e93b115" d="M31.781250 -66.406250q-7.609375 0.000000 -11.453125 7.500000q-3.828125 7.484375 -3.828125 22.531250q0.000000 14.984375 3.828125 22.484375q3.843750 7.500000 11.453125 7.500000q7.671875 0.000000 11.500000 -7.500000q3.843750 -7.500000 3.843750 -22.484375q0.000000 -15.046875 -3.843750 -22.531250q-3.828125 -7.500000 -11.500000 -7.500000M31.781250 -74.218750q12.265625 0.000000 18.734375 9.703125q6.468750 9.687500 6.468750 28.140625q0.000000 18.406250 -6.468750 28.109375q-6.468750 9.687500 -18.734375 9.687500q-12.250000 0.000000 -18.718750 -9.687500q-6.468750 -9.703125 -6.468750 -28.109375q0.000000 -18.453125 6.468750 -28.140625q6.468750 -9.703125 18.718750 -9.703125"/>
-</defs>
-<g style="fill: #000000; opacity: 1.000000" transform="translate(50.976562,272.106250)scale(0.120000)">
-<use xlink:href="#c_7a2040fe3b94fcd41d0a72c84e93b115"/>
-</g>
-</g>
-</g>
-<g id="xtick2">
-<g id="line2d9">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="101.828571" y="259.200000"/>
-</g></g>
-<g id="line2d10">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="101.828571" y="28.800000"/>
-</g></g>
-<g id="text2">
-<defs>
-<path id="c_ed3f3ed3ebfbd18bcb9c012009a68ad1" d="M19.187500 -8.296875l34.421875 0.000000l0.000000 8.296875l-46.281250 0.000000l0.000000 -8.296875q5.609375 -5.812500 15.296875 -15.593750q9.703125 -9.796875 12.187500 -12.640625q4.734375 -5.312500 6.609375 -9.000000q1.890625 -3.687500 1.890625 -7.250000q0.000000 -5.812500 -4.078125 -9.468750q-4.078125 -3.671875 -10.625000 -3.671875q-4.640625 0.000000 -9.796875 1.609375q-5.140625 1.609375 -11.000000 4.890625l0.000000 -9.968750q5.953125 -2.390625 11.125000 -3.609375q5.187500 -1.218750 9.484375 -1.218750q11.328125 0.000000 18.062500 5.671875q6.734375 5.656250 6.734375 15.125000q0.000000 4.500000 -1.687500 8.531250q-1.671875 4.015625 -6.125000 9.484375q-1.218750 1.421875 -7.765625 8.187500q-6.531250 6.765625 -18.453125 18.921875"/>
-</defs>
-<g style="fill: #000000; opacity: 1.000000" transform="translate(99.047321,272.106250)scale(0.120000)">
-<use xlink:href="#c_ed3f3ed3ebfbd18bcb9c012009a68ad1"/>
-</g>
-</g>
-</g>
-<g id="xtick3">
-<g id="line2d11">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="149.657143" y="259.200000"/>
-</g></g>
-<g id="line2d12">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="149.657143" y="28.800000"/>
-</g></g>
-<g id="text3">
-<defs>
-<path id="c_a0416418d96557a09b8c1332d34883ba" d="M37.796875 -64.312500l-24.906250 38.921875l24.906250 0.000000zM35.203125 -72.906250l12.406250 0.000000l0.000000 47.515625l10.406250 0.000000l0.000000 8.203125l-10.406250 0.000000l0.000000 17.187500l-9.812500 0.000000l0.000000 -17.187500l-32.906250 0.000000l0.000000 -9.515625z"/>
-</defs>
-<g style="fill: #000000; opacity: 1.000000" transform="translate(146.469643,271.950000)scale(0.120000)">
-<use xlink:href="#c_a0416418d96557a09b8c1332d34883ba"/>
-</g>
-</g>
-</g>
-<g id="xtick4">
-<g id="line2d13">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="197.485714" y="259.200000"/>
-</g></g>
-<g id="line2d14">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="197.485714" y="28.800000"/>
-</g></g>
-<g id="text4">
-<defs>
-<path id="c_cc8d6d580d1b10c8632f7a42cd53db8a" d="M33.015625 -40.375000q-6.640625 0.000000 -10.531250 4.546875q-3.875000 4.531250 -3.875000 12.437500q0.000000 7.859375 3.875000 12.437500q3.890625 4.562500 10.531250 4.562500q6.640625 0.000000 10.515625 -4.562500q3.875000 -4.578125 3.875000 -12.437500q0.000000 -7.906250 -3.875000 -12.437500q-3.875000 -4.546875 -10.515625 -4.546875M52.593750 -71.296875l0.000000 8.984375q-3.718750 -1.750000 -7.500000 -2.671875q-3.781250 -0.937500 -7.500000 -0.937500q-9.765625 0.000000 -14.921875 6.593750q-5.140625 6.593750 -5.875000 19.921875q2.875000 -4.250000 7.218750 -6.515625q4.359375 -2.265625 9.578125 -2.265625q10.984375 0.000000 17.359375 6.671875q6.375000 6.656250 6.375000 18.125000q0.000000 11.234375 -6.640625 18.031250q-6.640625 6.781250 -17.671875 6.781250q-12.656250 0.000000 -19.343750 -9.687500q-6.687500 -9.703125 -6.687500 -28.109375q0.000000 -17.281250 8.203125 -27.562500q8.203125 -10.281250 22.015625 -10.281250q3.718750 0.000000 7.500000 0.734375q3.781250 0.734375 7.890625 2.187500"/>
-</defs>
-<g style="fill: #000000; opacity: 1.000000" transform="translate(194.470089,272.106250)scale(0.120000)">
-<use xlink:href="#c_cc8d6d580d1b10c8632f7a42cd53db8a"/>
-</g>
-</g>
-</g>
-<g id="xtick5">
-<g id="line2d15">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="245.314286" y="259.200000"/>
-</g></g>
-<g id="line2d16">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="245.314286" y="28.800000"/>
-</g></g>
-<g id="text5">
-<defs>
-<path id="c_bef35738d52871942e50b9de9b122bab" d="M31.781250 -34.625000q-7.031250 0.000000 -11.062500 3.765625q-4.015625 3.765625 -4.015625 10.343750q0.000000 6.593750 4.015625 10.359375q4.031250 3.765625 11.062500 3.765625q7.031250 0.000000 11.078125 -3.781250q4.062500 -3.796875 4.062500 -10.343750q0.000000 -6.578125 -4.031250 -10.343750q-4.015625 -3.765625 -11.109375 -3.765625M21.921875 -38.812500q-6.343750 -1.562500 -9.890625 -5.906250q-3.531250 -4.359375 -3.531250 -10.609375q0.000000 -8.734375 6.218750 -13.812500q6.234375 -5.078125 17.062500 -5.078125q10.890625 0.000000 17.093750 5.078125q6.203125 5.078125 6.203125 13.812500q0.000000 6.250000 -3.546875 10.609375q-3.531250 4.343750 -9.828125 5.906250q7.125000 1.656250 11.093750 6.500000q3.984375 4.828125 3.984375 11.796875q0.000000 10.609375 -6.468750 16.281250q-6.468750 5.656250 -18.531250 5.656250q-12.046875 0.000000 -18.531250 -5.656250q-6.468750 -5.671875 -6.468750 -16.281250q0.000000 -6.968750 4.000000 -11.796875q4.015625 -4.843750 11.140625 -6.500000M18.312500 -54.390625q0.000000 5.656250 3.531250 8.828125q3.546875 3.171875 9.937500 3.171875q6.359375 0.000000 9.937500 -3.171875q3.593750 -3.171875 3.593750 -8.828125q0.000000 -5.671875 -3.593750 -8.843750q-3.578125 -3.171875 -9.937500 -3.171875q-6.390625 0.000000 -9.937500 3.171875q-3.531250 3.171875 -3.531250 8.843750"/>
-</defs>
-<g style="fill: #000000; opacity: 1.000000" transform="translate(242.314286,272.106250)scale(0.120000)">
-<use xlink:href="#c_bef35738d52871942e50b9de9b122bab"/>
-</g>
-</g>
-</g>
-<g id="xtick6">
-<g id="line2d17">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="293.142857" y="259.200000"/>
-</g></g>
-<g id="line2d18">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="293.142857" y="28.800000"/>
-</g></g>
-<g id="text6">
-<defs>
-<path id="c_42baa63129a918535c52adb20d687ea7" d="M12.406250 -8.296875l16.109375 0.000000l0.000000 -55.625000l-17.531250 3.515625l0.000000 -8.984375l17.437500 -3.515625l9.859375 0.000000l0.000000 64.609375l16.109375 0.000000l0.000000 8.296875l-41.984375 0.000000z"/>
-</defs>
-<g style="fill: #000000; opacity: 1.000000" transform="translate(286.556920,272.106250)scale(0.120000)">
-<use xlink:href="#c_42baa63129a918535c52adb20d687ea7"/>
-<use xlink:href="#c_7a2040fe3b94fcd41d0a72c84e93b115" x="63.623047"/>
-</g>
-</g>
-</g>
-<g id="xtick7">
-<g id="line2d19">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="340.971429" y="259.200000"/>
-</g></g>
-<g id="line2d20">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="340.971429" y="28.800000"/>
-</g></g>
-<g id="text7">
-<g style="fill: #000000; opacity: 1.000000" transform="translate(334.588616,272.106250)scale(0.120000)">
-<use xlink:href="#c_42baa63129a918535c52adb20d687ea7"/>
-<use xlink:href="#c_ed3f3ed3ebfbd18bcb9c012009a68ad1" x="63.623047"/>
-</g>
-</g>
-</g>
-<g id="xtick8">
-<g id="line2d21">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m30e32995789d870ad79a2e54c91cf9c6" x="388.800000" y="259.200000"/>
-</g></g>
-<g id="line2d22">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m9281cae24120827b11d5ea8a7ad3e96b" x="388.800000" y="28.800000"/>
-</g></g>
-<g id="text8">
-<g style="fill: #000000; opacity: 1.000000" transform="translate(382.151563,271.950000)scale(0.120000)">
-<use xlink:href="#c_42baa63129a918535c52adb20d687ea7"/>
-<use xlink:href="#c_a0416418d96557a09b8c1332d34883ba" x="63.623047"/>
-</g>
-</g>
-</g>
-</g>
-<g id="matplotlib.axis2">
-<g id="ytick1">
-<g id="line2d23">
-<defs><path id="m3400efa6b1638b3fea9e19e898273957" d="M0.000000 0.000000L4.000000 0.000000"/></defs>
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m3400efa6b1638b3fea9e19e898273957" x="54.000000" y="246.400000"/>
-</g></g>
-<g id="line2d24">
-<defs><path id="m20b58b2501143cb5e0a5e8f1ef6f1643" d="M0.000000 0.000000L-4.000000 0.000000"/></defs>
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m20b58b2501143cb5e0a5e8f1ef6f1643" x="388.800000" y="246.400000"/>
-</g></g>
-<g id="text9">
-<defs>
-<path id="c_6a8d56c819c37117ab4cf023bec22a5a" d="M10.593750 -35.500000l62.593750 0.000000l0.000000 8.296875l-62.593750 0.000000z"/>
-<path id="c_ed3e21196fb739f392806f09ca0594ef" d="M10.687500 -12.406250l10.312500 0.000000l0.000000 12.406250l-10.312500 0.000000z"/>
-<path id="c_1260a2df50f305f3db244e29828f968e" d="M10.796875 -72.906250l38.718750 0.000000l0.000000 8.312500l-29.687500 0.000000l0.000000 17.859375q2.140625 -0.734375 4.281250 -1.093750q2.156250 -0.359375 4.312500 -0.359375q12.203125 0.000000 19.328125 6.687500q7.140625 6.687500 7.140625 18.109375q0.000000 11.765625 -7.328125 18.296875q-7.328125 6.515625 -20.656250 6.515625q-4.593750 0.000000 -9.359375 -0.781250q-4.750000 -0.781250 -9.828125 -2.343750l0.000000 -9.921875q4.390625 2.390625 9.078125 3.562500q4.687500 1.171875 9.906250 1.171875q8.453125 0.000000 13.375000 -4.437500q4.937500 -4.437500 4.937500 -12.062500q0.000000 -7.609375 -4.937500 -12.046875q-4.921875 -4.453125 -13.375000 -4.453125q-3.953125 0.000000 -7.890625 0.875000q-3.921875 0.875000 -8.015625 2.734375z"/>
-</defs>
-<g style="fill: #000000; opacity: 1.000000" transform="translate(23.156250,250.767187)scale(0.120000)">
-<use xlink:href="#c_6a8d56c819c37117ab4cf023bec22a5a"/>
-<use xlink:href="#c_7a2040fe3b94fcd41d0a72c84e93b115" x="83.789062"/>
-<use xlink:href="#c_ed3e21196fb739f392806f09ca0594ef" x="147.412109"/>
-<use xlink:href="#c_1260a2df50f305f3db244e29828f968e" x="179.199219"/>
-</g>
-</g>
-</g>
-<g id="ytick2">
-<g id="line2d25">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m3400efa6b1638b3fea9e19e898273957" x="54.000000" y="182.400000"/>
-</g></g>
-<g id="line2d26">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m20b58b2501143cb5e0a5e8f1ef6f1643" x="388.800000" y="182.400000"/>
-</g></g>
-<g id="text10">
-<g style="fill: #000000; opacity: 1.000000" transform="translate(32.500000,186.767187)scale(0.120000)">
-<use xlink:href="#c_7a2040fe3b94fcd41d0a72c84e93b115"/>
-<use xlink:href="#c_ed3e21196fb739f392806f09ca0594ef" x="63.623047"/>
-<use xlink:href="#c_7a2040fe3b94fcd41d0a72c84e93b115" x="95.410156"/>
-</g>
-</g>
-</g>
-<g id="ytick3">
-<g id="line2d27">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m3400efa6b1638b3fea9e19e898273957" x="54.000000" y="118.400000"/>
-</g></g>
-<g id="line2d28">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m20b58b2501143cb5e0a5e8f1ef6f1643" x="388.800000" y="118.400000"/>
-</g></g>
-<g id="text11">
-<g style="fill: #000000; opacity: 1.000000" transform="translate(32.750000,122.767187)scale(0.120000)">
-<use xlink:href="#c_7a2040fe3b94fcd41d0a72c84e93b115"/>
-<use xlink:href="#c_ed3e21196fb739f392806f09ca0594ef" x="63.623047"/>
-<use xlink:href="#c_1260a2df50f305f3db244e29828f968e" x="95.410156"/>
-</g>
-</g>
-</g>
-<g id="ytick4">
-<g id="line2d29">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m3400efa6b1638b3fea9e19e898273957" x="54.000000" y="54.400000"/>
-</g></g>
-<g id="line2d30">
-<g ><use style="fill: none; stroke: #000000; stroke-width: 0.500000; stroke-linejoin: round; stroke-linecap: butt;  opacity: 1.000000" xlink:href="#m20b58b2501143cb5e0a5e8f1ef6f1643" x="388.800000" y="54.400000"/>
-</g></g>
-<g id="text12">
-<g style="fill: #000000; opacity: 1.000000" transform="translate(33.015625,58.767187)scale(0.120000)">
-<use xlink:href="#c_42baa63129a918535c52adb20d687ea7"/>
-<use xlink:href="#c_ed3e21196fb739f392806f09ca0594ef" x="63.623047"/>
-<use xlink:href="#c_7a2040fe3b94fcd41d0a72c84e93b115" x="95.410156"/>
-</g>
-</g>
-</g>
-</g>
-<g id="patch3">
-<path style="fill: none; stroke: #000000; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000"  d="M54.000000 28.800000L388.800000 28.800000"/>
-</g>
-<g id="patch4">
-<path style="fill: none; stroke: #000000; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000"  d="M388.800000 259.200000L388.800000 28.800000"/>
-</g>
-<g id="patch5">
-<path style="fill: none; stroke: #000000; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000"  d="M54.000000 259.200000L388.800000 259.200000"/>
-</g>
-<g id="patch6">
-<path style="fill: none; stroke: #000000; stroke-width: 1.000000; stroke-linejoin: round; stroke-linecap: square;  opacity: 1.000000"  d="M54.000000 259.200000L54.000000 28.800000"/>
-</g>
-</g>
-</g>
-</svg>
-</p>
-<p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" color:#000080;">In [</span><span style=" font-weight:600; color:#000080;">4</span><span style=" color:#000080;">]:</span> </p></body></html>
\ No newline at end of file
diff --git a/docs/source/interactive/index.rst b/docs/source/interactive/index.rst
new file mode 100644
index 00000000000..6684eb51bfb
--- /dev/null
+++ b/docs/source/interactive/index.rst
@@ -0,0 +1,32 @@
+========
+Tutorial
+========
+
+This section of IPython documentation will walk you through most of the IPython
+functionality. You do not need to have any deep knowledge of Python to read this
+tutorial, though some sections might make slightly more sense if you have already
+done some work in the classic Python REPL.
+
+.. note::
+    
+    Some part of this documentation are more than a decade old so might be out
+    of date, we welcome any report of inaccuracy, and Pull Requests that make
+    that up to date.
+
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+
+   tutorial
+   plotting
+   reference
+   shell
+   autoawait
+   tips
+   python-ipython-diff
+   magics
+
+.. seealso::
+
+    `A Qt Console for Jupyter <https://jupyter.org/qtconsole/>`__
+    `The Jupyter Notebook <https://jupyter-notebook.readthedocs.io/en/latest/>`__
diff --git a/docs/source/interactive/index.txt b/docs/source/interactive/index.txt
deleted file mode 100644
index 81b3fb4ee98..00000000000
--- a/docs/source/interactive/index.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-==================================
-Using IPython for interactive work
-==================================
-
-.. toctree::
-   :maxdepth: 2
-
-   tutorial.txt
-   reference.txt
-   shell.txt
-   qtconsole.txt
-
-
diff --git a/docs/source/interactive/magics.rst b/docs/source/interactive/magics.rst
new file mode 100644
index 00000000000..70b7055d4f2
--- /dev/null
+++ b/docs/source/interactive/magics.rst
@@ -0,0 +1,23 @@
+=======================
+Built-in magic commands
+=======================
+
+.. note::
+
+    To Jupyter users: Magics are specific to and provided by the IPython kernel.
+    Whether Magics are available on a kernel is a decision that is made by
+    the kernel developer on a per-kernel basis. To work properly, Magics must
+    use a syntax element which is not valid in the underlying language. For
+    example, the IPython kernel uses the `%` syntax element for Magics as `%`
+    is not a valid unary operator in Python. However, `%` might have meaning in
+    other languages.
+
+Here is the help auto-generated from the docstrings of all the available Magics
+functions that IPython ships with. 
+
+You can create and register your own Magics with IPython. You can find many user
+defined Magics on `PyPI <https://pypi.org>`_. Feel free to publish your own and
+use the ``Framework :: IPython`` trove classifier. 
+
+
+.. include:: magics-generated.txt
diff --git a/docs/source/interactive/plotting.rst b/docs/source/interactive/plotting.rst
new file mode 100644
index 00000000000..2db0cef84a5
--- /dev/null
+++ b/docs/source/interactive/plotting.rst
@@ -0,0 +1,79 @@
+.. _plotting:
+
+Rich Outputs
+------------
+
+One of the main feature of IPython when used as a kernel is its ability to
+show rich output. This means that object that can be representing as image,
+sounds, animation, (etc...) can be shown this way if the frontend support it.
+
+In order for this to be possible, you need to use the ``display()`` function,
+which you can import with ``from IPython.display import display``. Then use
+``display(<your object>)`` instead of ``print()``, and if possible your object
+will be displayed with a richer representation. In the terminal of course, there
+won't be much difference as objects are most of the time represented by text,
+but in notebook and similar interface you will get richer outputs.
+
+
+.. _matplotlib_magic:
+
+Plotting
+--------
+
+.. note::
+
+    You can avoid the use of IPython's specific magic and use
+    ``matplotlib.pyplot.ion()``/``matplotlib.pyplot.ioff()`` which have the
+    advantages of working outside of IPython as well.
+
+
+One major feature of the IPython kernel is the ability to display plots that
+are the output of running code cells. The IPython kernel is designed to work
+seamlessly with the matplotlib_ plotting library to provide this functionality.
+
+To set this up, before any plotting or import of matplotlib is performed you
+may execute the ``%matplotlib`` :ref:`magic command <magics_explained>`. This
+performs the necessary behind-the-scenes setup for IPython to work correctly
+hand in hand with ``matplotlib``; it does *not*, however, actually execute any
+Python ``import`` commands, that is, no names are added to the namespace.
+
+If you do not use the ``%matplotlib`` magic or you call it without an argument,
+the output of a plotting command is displayed using the default ``matplotlib``
+backend, which may be different depending on Operating System and whether
+running within Jupyter or not.
+
+Alternatively, the backend can be explicitly requested using, for example::
+
+  %matplotlib gtk
+
+The argument passed to the ``%matplotlib`` magic command may be the name of any
+backend understood by ``matplotlib`` or it may the name of a GUI loop such as
+``qt`` or ``osx``, in which case an appropriate backend supporting that GUI
+loop will be selected. To obtain a full list of all backends and GUI loops
+understood by ``matplotlib`` use ``%matplotlib --list``.
+
+There are some specific backends that are used in the Jupyter ecosystem:
+
+- The ``inline`` backend is provided by IPython and can be used in Jupyter Lab,
+  Notebook and QtConsole; it is the default backend when using Jupyter. The
+  outputs of plotting commands are displayed *inline* within frontends like
+  Jupyter Notebook, directly below the code cells that produced them.
+  The resulting plots will then also be stored in the notebook document.
+
+- The ``notebook`` or ``nbagg`` backend is built into ``matplotlib`` and can be
+  used with Jupyter ``notebook <7`` and ``nbclassic``. Plots are interactive so
+  they can be zoomed and panned.
+
+- The ``ipympl`` or ``widget`` backend is for use with Jupyter ``lab`` and
+  ``notebook >=7``. It is in a separate ``ipympl`` module that must be
+  installed using ``pip`` or ``conda`` in the usual manner. Plots are
+  interactive so they can be zoomed and panned.
+
+.. seealso::
+
+    `Plotting with Matplotlib`_  example notebook
+
+See the matplotlib_ documentation for more information, in particular the
+section on backends.
+
+.. include:: ../links.txt
diff --git a/docs/source/interactive/python-ipython-diff.rst b/docs/source/interactive/python-ipython-diff.rst
new file mode 100644
index 00000000000..0265f2f34c1
--- /dev/null
+++ b/docs/source/interactive/python-ipython-diff.rst
@@ -0,0 +1,238 @@
+=================
+Python vs IPython
+=================
+
+This document is meant to highlight the main differences between the Python
+language and what are the specific constructs you can do only in IPython.
+
+Unless expressed otherwise all of the constructs you will see here will raise a
+``SyntaxError`` if run in a pure Python shell, or if executing in a Python
+script.
+
+Each of these features is described more in detail in the further parts of the documentation.
+
+
+Quick overview:
+===============
+
+
+All the following constructs are valid IPython syntax:
+
+.. code-block:: ipython
+
+    In [1]: ?
+
+.. code-block:: ipython
+
+    In [1]: ?object
+
+
+.. code-block:: ipython
+
+    In [1]: object?
+
+.. code-block:: ipython
+
+    In [1]: *pattern*?
+
+.. code-block:: ipython
+
+    In [1]: %shell like --syntax
+
+.. code-block:: ipython
+
+    In [1]: !ls
+
+.. code-block:: ipython
+
+    In [1]: my_files = !ls ~/
+    In [1]: for i, file in enumerate(my_files):
+       ...:     raw = !echo $file
+       ...:     !echo {file[0].upper()} $raw
+
+
+.. code-block:: ipython
+
+    In [1]: %%perl magic --function
+       ...: @months = ("July", "August", "September");
+       ...: print $months[0];
+
+
+Each of these constructs is compiled by IPython into valid python code and will
+do most of the time what you expect it will do. Let's see each of these examples
+in more detail.
+
+
+Accessing help
+==============
+
+As IPython is mostly an interactive shell, the question mark is a simple
+shortcut to get help. A question mark alone will bring up the IPython help:
+
+.. code-block:: ipython
+
+    In [1]: ?
+
+    IPython -- An enhanced Interactive Python
+    =========================================
+
+    IPython offers a combination of convenient shell features, special commands
+    and a history mechanism for both input (command history) and output (results
+    caching, similar to Mathematica). It is intended to be a fully compatible
+    replacement for the standard Python interpreter, while offering vastly
+    improved functionality and flexibility.
+
+    At your system command line, type 'ipython -h' to see the command line
+    options available. This document only describes interactive features.
+
+    MAIN FEATURES
+    -------------
+    ...
+
+A single question mark before or after an object available in the current
+namespace will show help relative to this object:
+
+.. code-block:: ipython
+
+    In [6]: object?
+    Docstring: The most base type
+    Type:      type
+
+
+A double question mark will try to pull out more information about the object,
+and if possible display the python source code of this object.
+
+.. code-block:: ipython
+
+    In[1]: import collections
+    In[2]: collections.Counter??
+
+    Init signature: collections.Counter(*args, **kwds)
+    Source:
+    class Counter(dict):
+        '''Dict subclass for counting hashable items.  Sometimes called a bag
+        or multiset.  Elements are stored as dictionary keys and their counts
+        are stored as dictionary values.
+
+        >>> c = Counter('abcdeabcdabcaba')  # count elements from a string
+
+        >>> c.most_common(3)                # three most common elements
+        [('a', 5), ('b', 4), ('c', 3)]
+        >>> sorted(c)                       # list all unique elements
+        ['a', 'b', 'c', 'd', 'e']
+        >>> ''.join(sorted(c.elements()))   # list elements with repetitions
+        'aaaaabbbbcccdde'
+        ...
+
+
+
+If you are looking for an object, the use of wildcards ``*`` in conjunction
+with a question mark will allow you to search the current namespace for objects with
+matching names:
+
+.. code-block:: ipython
+
+    In [24]: *int*?
+    FloatingPointError
+    int
+    print
+
+
+Shell Assignment
+================
+
+
+When doing interactive computing it is a common need to access the underlying shell.
+This is doable through the use of the exclamation mark ``!`` (or bang).
+
+This allows to execute simple commands when present in beginning of the line:
+
+.. code-block:: ipython
+
+    In[1]: !pwd
+    /User/home/
+
+Edit file:
+
+.. code-block:: ipython
+
+    In[1]: !mvim myfile.txt
+
+
+The line after the bang can call any program installed in the underlying
+shell, and support variable expansion in the form of ``$variable`` or ``{variable}``.
+The later form of expansion supports arbitrary python expressions:
+
+.. code-block:: ipython
+
+    In[1]: file = 'myfile.txt'
+
+    In[2]: !mv $file {file.upper()}
+
+
+The bang (``!``) can also be present on the right hand side of an assignment, just
+after the equal sign, or separated from it by a white space. In this case the
+standard output of the command after the bang will be split out into lines
+in a list-like object and assigned to the left hand side.
+
+This allows you, for example, to put the list of files of the current working directory in a variable:
+
+.. code-block:: ipython
+
+    In[1]: my_files = !ls
+
+
+You can combine the different possibilities in for loops, conditions, functions...:
+
+.. code-block:: ipython
+
+    my_files = !ls ~/
+    for i, file in enumerate(my_files):
+        raw = !echo $backup $file
+        !cp $file {file.split('.')[0] + '.bak'}
+
+
+Each ``!`` gets executed in a separate shell, so changing directory by ``!cd`` or env vars ``!export FOO=bar`` will have no effect.
+Use instead the built-in magics ``%cd DIR/`` (there are also ``%pushd DIR/``, ``%dirs``, ``%popd``) and ``%env FOO=bar``.
+
+
+Magics
+------
+
+Magic functions (magics) are often present in the form of shell-like syntax, but they are
+python functions under the hood. The syntax and assignment possibilities are
+similar to the one with the bang (``!``) syntax, but with more flexibility and
+power. Magic functions start with a percent sign (``%``) or double percent signs (``%%``).
+
+A magic call with a single percent sign will act only on one line:
+
+.. code-block:: ipython
+
+    In[1]: %xmode
+    Exception reporting mode: Verbose
+
+Magics support assignment:
+
+.. code-block:: ipython
+
+    In [1]: results = %timeit -r1 -n1 -o list(range(1000))
+    62.1 µs ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
+
+    In [2]: results
+    <TimeitResult : 62.1 µs ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>
+
+Magics with double percent signs (``%%``) can spread over multiple lines, but they do not support assignments:
+
+.. code-block:: ipython
+
+    In[1]: %%bash
+    ...  : echo "My shell is:" $SHELL
+    ...  : echo "My disk usage is:"
+    ...  : df -h
+    My shell is: /usr/local/bin/bash
+    My disk usage is:
+    Filesystem      Size   Used  Avail Capacity  iused   ifree %iused  Mounted on
+    /dev/disk1     233Gi  216Gi   16Gi    94% 56788108 4190706   93%   /
+    devfs          190Ki  190Ki    0Bi   100%      656       0  100%   /dev
+    map -hosts       0Bi    0Bi    0Bi   100%        0       0  100%   /net
+    map auto_home    0Bi    0Bi    0Bi   100%        0       0  100%   /hom
diff --git a/docs/source/interactive/qtconsole.txt b/docs/source/interactive/qtconsole.txt
deleted file mode 100644
index 5d0f2f437be..00000000000
--- a/docs/source/interactive/qtconsole.txt
+++ /dev/null
@@ -1,219 +0,0 @@
-.. _qtconsole:
-
-=========================
-IPython as a QtGUI widget
-=========================
-
-We now have a version of IPython, using the new two-process :ref:`ZeroMQ Kernel <ipythonzmq>`,
-running in a PyQt_ GUI.
-
-Overview
-========
-
-The Qt frontend has hand-coded emacs-style bindings for text navigation. This is not yet
-configurable.
-
-.. seealso:: 
-
-    `The original IPython-Qt project description. <ipython_qt>`_
-    
-``%loadpy``
-===========
-
-The ``%loadpy`` magic has been added, just for the GUI frontend. It 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
-
-    In [6]: %loadpy 
-    http://matplotlib.sourceforge.net/plot_directive/mpl_examples/mplot3d/contour3d_demo.py
-
-    In [7]: from mpl_toolkits.mplot3d import axes3d
-       ...: import matplotlib.pyplot as plt
-       ...: 
-       ...: fig = plt.figure()
-       ...: ax = fig.add_subplot(111, projection='3d')
-       ...: X, Y, Z = axes3d.get_test_data(0.05)
-       ...: cset = ax.contour(X, Y, Z)
-       ...: ax.clabel(cset, fontsize=9, inline=1)
-       ...: 
-       ...: plt.show()
-
-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.
-
-.. image:: figs/besselj.png
-    :width: 519px
-
-.. pastefig:
-
-:func:`pastefig`
-****************
-
-An additional function, :func:`pastefig`, will be added to the global namespace if you
-specify the ``--pylab`` argument. This takes the active figures in matplotlib, and embeds
-them in your document. This is especially useful for saving_ your work.
-
-.. _inline:
-
-``--pylab inline``
-******************
-
-If you want to have all of your figures embedded in your session, instead of calling
-:func:`pastefig`, you can specify ``--pylab inline``, and each time you make a plot, it
-will show up in your document, as if you had called :func:`pastefig`.
-
-
-.. _saving:
-
-Saving and Printing
-===================
-
-IPythonQt has the ability to save your current session, as either HTML or XHTML. If you
-have been using `pastefig <pastefig>`_ 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.
-
-
-.. Note:: 
-
-    Saving is only available to richtext Qt widgets, so make sure you start ipqt with the
-    ``--rich`` flag, or with ``--pylab``, which always uses a richtext widget.
-
-
-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:
-
-* LightBG for light backgrounds
-* Linux for dark backgrounds
-* NoColor for a simple colorless terminal
-
-The Qt widget has full support for the ``--colors`` flag, but adds new, more intuitive
-aliases for the colors (the old names still work): dark=Linux, light=LightBG, bw=NoColor.
-
-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 dark``, 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.
-
-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
-
-    QPlainTextEdit, QTextEdit { background-color: white;
-            color: black ;
-            selection-background-color: #ccc}
-    .error { color: red; }
-    .in-prompt { color: navy; }
-    .in-prompt-number { font-weight: bold; }
-    .out-prompt { color: darkred; }
-    .out-prompt-number { font-weight: bold; }
-
-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.
-
-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::
-
-    To connect another client to this kernel, use:
-    -e --xreq 62109 --sub 62110 --rep 62111 --hb 62112
-
-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::
-
-    $> 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.
-
-.. 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.
-
-
-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.).
-
-Rules:
-
-    * Restarting the kernel automatically clears all *local* Consoles, and prompts remote
-      Consoles about the reset.
-    * Shutdown closes all *local* Consoles, and notifies remotes that
-      the Kernel has been shutdown.
-    * Remote Consoles may not restart or shutdown the kernel.
-
-
-Regressions
-===========
-
-There are some features, where the qt console lags behind the Terminal frontend. We hope
-to have these fixed by 0.11 release.
-
-    * Configuration: The Qt frontend and ZMQ kernel are not yet hooked up to the IPython
-      configuration system
-    * History Persistence: Currently the history of a GUI session does
-      not persist between sessions.
-    * !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/
diff --git a/docs/source/interactive/reference.rst b/docs/source/interactive/reference.rst
new file mode 100644
index 00000000000..6478c48e896
--- /dev/null
+++ b/docs/source/interactive/reference.rst
@@ -0,0 +1,1082 @@
+=================
+IPython reference
+=================
+
+.. _command_line_options:
+
+Command-line usage
+==================
+
+You start IPython with the command::
+
+    $ ipython [options] files
+
+If invoked with no options, it executes the file and exits, passing the
+remaining arguments to the script, just as if you had specified the same
+command with python. You may need to specify `--` before args to be passed
+to the script, to prevent IPython from attempting to parse them.
+If you add the ``-i`` flag, it drops you into the interpreter while still
+acknowledging any options you may have set in your ``ipython_config.py``. This
+behavior is different from standard Python, which when called as python ``-i``
+will only execute one file and ignore your configuration setup.
+
+Please note that some of the configuration options are not available at the
+command line, simply because they are not practical here. Look into your
+configuration files for details on those. There are separate configuration files
+for each profile, and the files look like :file:`ipython_config.py` or
+:file:`ipython_config_{frontendname}.py`.  Profile directories look like
+:file:`profile_{profilename}` and are typically installed in the
+:envvar:`IPYTHONDIR` directory, which defaults to :file:`$HOME/.ipython`. For
+Windows users, :envvar:`HOME` resolves to :file:`C:\\Users\\{YourUserName}` in
+most instances.
+
+Command-line Options
+--------------------
+
+To see the options IPython accepts, use ``ipython --help`` (and you probably
+should run the output through a pager such as ``ipython --help | less`` for
+more convenient reading).  This shows all the options that have a single-word
+alias to control them, but IPython lets you configure all of its objects from
+the command-line by passing the full class name and a corresponding value; type
+``ipython --help-all`` to see this full list.  For example::
+
+    $ ipython --help-all
+    <...snip...>
+    --matplotlib=<CaselessStrEnum> (InteractiveShellApp.matplotlib)
+        Default: None
+        Choices: ['auto', 'gtk3', 'gtk4', 'inline', 'nbagg', 'notebook', 'osx', 'qt', 'qt5', 'qt6', 'tk', 'wx']
+        Configure matplotlib for interactive use with the default matplotlib
+        backend.
+    <...snip...>
+
+
+Indicate that the following::
+
+   $ ipython --matplotlib qt
+
+
+is equivalent to::
+
+   $ ipython --InteractiveShellApp.matplotlib='qt'
+
+Note that in the second form, you *must* use the equal sign, as the expression
+is evaluated as an actual Python assignment.  While in the above example the
+short form is more convenient, only the most common options have a short form,
+while any configurable variable in IPython can be set at the command-line by
+using the long form.  This long form is the same syntax used in the
+configuration files, if you want to set these options permanently.
+
+
+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.
+
+
+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``
+
+.. _magic:
+
+Magic command system
+--------------------
+
+IPython will treat any line whose first character is a % as a special
+call to a 'magic' function. These allow you to control the behavior of
+IPython itself, plus a lot of system-type features. They are all
+prefixed with a % character, but parameters are given without
+parentheses or quotes.
+
+Lines that begin with ``%%`` signal a *cell magic*: they take as arguments not
+only the rest of the current line, but all lines below them as well, in the
+current execution block.  Cell magics can in fact make arbitrary modifications
+to the input they receive, which need not even be valid Python code at all.
+They receive the whole block as a single string.
+
+As a line magic example, the :magic:`cd` magic works just like the OS command of
+the same name::
+
+      In [8]: %cd
+      /home/fperez
+
+The following uses the builtin :magic:`timeit` in cell mode::
+
+  In [10]: %%timeit x = range(10000)
+      ...: min(x)
+      ...: max(x)
+      ...:
+  518 µs ± 4.39 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+
+In this case, ``x = range(10000)`` is called as the line argument, and the
+block with ``min(x)`` and ``max(x)`` is called as the cell body.  The
+:magic:`timeit` magic receives both.
+
+If you have 'automagic' enabled (as it is by default), you don't need to type in
+the single ``%`` explicitly for line magics; IPython will scan its internal
+list of magic functions and call one if it exists. With automagic on you can
+then just type ``cd mydir`` to go to directory 'mydir'::
+
+      In [9]: cd mydir
+      /home/fperez/mydir
+
+Cell magics *always* require an explicit ``%%`` prefix, automagic
+calling only works for line magics.
+
+The automagic system has the lowest possible precedence in name searches, so
+you can freely use variables with the same names as magic commands. If a magic
+command is 'shadowed' by a variable, you will need the explicit ``%`` prefix to
+use it:
+
+.. sourcecode:: ipython
+
+    In [1]: cd ipython     # %cd is called by automagic
+    /home/fperez/ipython
+
+    In [2]: cd=1 	   # now cd is just a variable
+
+    In [3]: cd .. 	   # and doesn't work as a function anymore
+    File "<ipython-input-3-9fedb3aff56c>", line 1
+      cd ..
+          ^
+    SyntaxError: invalid syntax
+
+
+    In [4]: %cd .. 	   # but %cd always works
+    /home/fperez
+
+    In [5]: del cd     # if you remove the cd variable, automagic works again
+
+    In [6]: cd ipython
+
+    /home/fperez/ipython
+
+Line magics, if they return a value, can be assigned to a variable using the
+syntax ``l = %sx ls`` (which in this particular case returns the result of `ls`
+as a python list). See :ref:`below <manual_capture>` for more information.
+
+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.
+
+.. seealso::
+
+   :doc:`magics`
+     A list of the line and cell magics available in IPython by default
+
+   :ref:`defining_magics`
+     How to define and register additional magic functions
+
+
+Access to the standard Python help
+----------------------------------
+
+Simply type ``help()`` to access Python's standard help system. You can
+also type ``help(object)`` for information about a given object, or
+``help('keyword')`` for information on a keyword. You may need to configure your
+PYTHONDOCS environment variable for this feature to work correctly.
+
+.. _dynamic_object_info:
+
+Dynamic object information
+--------------------------
+
+Typing ``?word`` or ``word?`` prints detailed information about an object. If
+certain strings in the object are too long (e.g. function signatures) they get
+snipped in the center for brevity. This system gives access variable types and
+values, docstrings, function prototypes and other useful information.
+
+If the information will not fit in the terminal, it is displayed in a pager
+(``less`` if available, otherwise a basic internal pager).
+
+Typing ``??word`` or ``word??`` gives access to the full information, including
+the source code where possible. Long strings are not snipped.
+
+The following magic functions are particularly useful for gathering
+information about your working environment:
+
+    * :magic:`pdoc` **<object>**: Print (or run through a pager if too long) the
+      docstring for an object. If the given object is a class, it will
+      print both the class and the constructor docstrings.
+    * :magic:`pdef` **<object>**: Print the call signature for any callable
+      object. If the object is a class, print the constructor information.
+    * :magic:`psource` **<object>**: Print (or run through a pager if too long)
+      the source code for an object.
+    * :magic:`pfile` **<object>**: Show the entire source file where an object was
+      defined via a pager, opening it at the line where the object
+      definition begins.
+    * :magic:`who`/:magic:`whos`: These functions give information about identifiers
+      you have defined interactively (not things you loaded or defined
+      in your configuration files). %who just prints a list of
+      identifiers and %whos prints a table with some basic details about
+      each identifier.
+
+The dynamic object information functions (?/??, ``%pdoc``,
+``%pfile``, ``%pdef``, ``%psource``) work on object attributes, as well as
+directly on variables. For example, after doing ``import os``, you can use
+``os.path.abspath??``.
+
+
+Command line completion
++++++++++++++++++++++++
+
+At any time, hitting TAB will complete any available python commands or
+variable names, and show you a list of the possible completions if
+there's no unambiguous one. It will also complete filenames in the
+current directory if no python names match what you've typed so far.
+
+
+Search command history
+++++++++++++++++++++++
+
+IPython provides two ways for searching through previous input and thus
+reduce the need for repetitive typing:
+
+   1. Start typing, and then use the up and down arrow keys (or :kbd:`Ctrl-p`
+      and :kbd:`Ctrl-n`) to search through only the history items that match
+      what you've typed so far.
+   2. Hit :kbd:`Ctrl-r`: to open a search prompt. Begin typing and the system
+      searches your history for lines that contain what you've typed so
+      far, completing as much as it can.
+
+IPython will save your input history when it leaves and reload it next
+time you restart it. By default, the history file is named
+:file:`.ipython/profile_{name}/history.sqlite`.
+
+Autoindent
+++++++++++
+
+Starting with 5.0, IPython uses `prompt_toolkit` in place of ``readline``,
+it thus can recognize lines ending in ':' and indent the next line,
+while also un-indenting automatically after 'raise' or 'return',
+and support real multi-line editing as well as syntactic coloration
+during edition.
+
+This feature does not use the ``readline`` library anymore, so it will
+not honor your :file:`~/.inputrc` configuration (or whatever
+file your :envvar:`INPUTRC` environment variable points to).
+
+In particular if you want to change the input mode to ``vi``, you will need to
+set the ``TerminalInteractiveShell.editing_mode`` configuration  option of IPython.
+
+Session logging and restoring
+-----------------------------
+
+You can log all input from a session either by starting IPython with the
+command line switch ``--logfile=foo.py`` (see :ref:`here <command_line_options>`)
+or by activating the logging at any moment with the magic function :magic:`logstart`.
+
+Log files can later be reloaded by running them as scripts and IPython
+will attempt to 'replay' the log by executing all the lines in it, thus
+restoring the state of a previous session. This feature is not quite
+perfect, but can still be useful in many cases.
+
+The log files can also be used as a way to have a permanent record of
+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 :magic:`logstart` function for activating logging in mid-session is used as
+follows::
+
+    %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).
+
+'%logstart name' saves to file 'name' in 'backup' mode. It saves your
+history up to that point and then continues logging.
+
+%logstart takes a second optional parameter: logging mode. This can be
+one of (note that the modes are given unquoted):
+
+    * [over:] overwrite existing log_name.
+    * [backup:] rename (if exists) to log_name~ and start log_name.
+    * [append:] well, that says it.
+    * [rotate:] create rotating logs log_name.1~, log_name.2~, etc.
+
+Adding the '-o' flag to '%logstart' magic (as in '%logstart -o [log_name [log_mode]]')
+will also include output from iPython in the log file.
+
+The :magic:`logoff` and :magic:`logon` functions allow you to temporarily stop and
+resume logging to a file which had previously been started with
+%logstart. They will fail (with an explanation) if you try to use them
+before logging has been started.
+
+.. _system_shell_access:
+
+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.
+
+.. _manual_capture:
+
+Manual capture of command output and magic output
+-------------------------------------------------
+
+You can assign the result of a system command to a Python variable with the
+syntax ``myfiles = !ls``. Similarly, the result of a magic (as long as it returns
+a value) can be assigned to a variable.  For example, the syntax ``myfiles = %sx ls``
+is equivalent to the above system command example (the :magic:`sx` magic runs a shell command
+and captures the output).  Each of these gets machine
+readable output from stdout (e.g. without colours), and splits on newlines. To
+explicitly get this sort of output without assigning to a variable, use two
+exclamation marks (``!!ls``) or the :magic:`sx` magic command without an assignment.
+(However, ``!!`` commands cannot be assigned to a variable.)
+
+The captured list in this example has some convenience features. ``myfiles.n`` or ``myfiles.s``
+returns a string delimited by newlines or spaces, respectively. ``myfiles.p``
+produces `path objects <http://pypi.python.org/pypi/path.py>`_ from the list items.
+See :ref:`string_lists` for details.
+
+IPython also allows you to expand the value of python variables when
+making system calls. Wrap variables or expressions in {braces}::
+
+    In [1]: pyvar = 'Hello world'
+    In [2]: !echo "A python variable: {pyvar}"
+    A python variable: Hello world
+    In [3]: import math
+    In [4]: x = 8
+    In [5]: !echo {math.factorial(x)}
+    40320
+
+For simple cases, you can alternatively prepend $ to a variable name::
+
+    In [6]: !echo $sys.argv
+    [/home/fperez/usr/bin/ipython]
+    In [7]: !echo "A system variable: $$HOME"  # Use $$ for literal $
+    A system variable: /home/fperez
+
+Note that `$$` is used to represent a literal `$`.
+
+System command aliases
+----------------------
+
+The :magic:`alias` magic function allows 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'
+
+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
+parameter). The following example defines the parts function as an
+alias to the command ``echo first %s second %s`` where each ``%s`` will be
+replaced by a positional parameter to the call to %parts::
+
+    In [1]: %alias parts echo first %s second %s
+    In [2]: parts A B
+    first A second B
+    In [3]: parts A
+    ERROR: Alias <parts> requires 2 arguments, 1 given.
+
+If called with no parameters, :magic:`alias` prints the table of currently
+defined aliases.
+
+The :magic:`rehashx` magic allows you to load your entire $PATH as
+ipython aliases. See its docstring for further details.
+
+
+.. _dreload:
+
+Recursive reload
+----------------
+
+The :mod:`IPython.lib.deepreload` module allows you to recursively reload a
+module: changes made to any of its dependencies will be reloaded without
+having to exit. To start using it, do::
+
+    from IPython.lib.deepreload import reload as dreload
+
+
+Verbose and colored exception traceback printouts
+-------------------------------------------------
+
+IPython provides the option to see very detailed exception tracebacks,
+which can be especially useful when debugging large programs. You can
+run any Python file with the %run function to benefit from these
+detailed tracebacks. Furthermore, both normal and verbose tracebacks can
+be colored (if your terminal supports it) which makes them much easier
+to parse visually.
+
+See the magic :magic:`xmode` and :magic:`colors` functions for details.
+
+These features are basically a terminal version of Ka-Ping Yee's cgitb
+module, now part of the standard Python library.
+
+
+.. _input_caching:
+
+Input caching system
+--------------------
+
+IPython offers numbered prompts (In/Out) with input and output caching
+(also referred to as 'input history'). All input is saved and can be
+retrieved as variables (besides the usual arrow key recall), in
+addition to the :magic:`rep` magic command that brings a history entry
+up for editing on the next command line.
+
+The following variables always exist:
+
+* ``_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), so ``_i<n> == _ih[<n>] == In[<n>]``.
+
+For example, what you typed at prompt 14 is available as ``_i14``, ``_ih[14]``
+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.
+
+You can also re-execute multiple lines of input easily by using the magic
+:magic:`rerun` or :magic:`macro` functions. The macro system also allows you to
+re-execute previous lines which include magic function calls (which require
+special processing). Type %macro? for more details on the macro system.
+
+A history function :magic:`history` 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 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 :magic:`rerun`.
+
+.. _output_caching:
+
+Output caching system
+---------------------
+
+For output that is returned from actions, a system similar to the input
+cache exists but using _ instead of _i. Only actions that produce a
+result (NOT assignments, for example) are cached. If you are familiar
+with Mathematica, IPython's _ variables behave exactly like
+Mathematica's % variables.
+
+The following variables always exist:
+
+    * [_] (a single underscore): stores previous output, like Python's
+      default interpreter.
+    * [__] (two underscores): next previous.
+    * [___] (three underscores): next-next previous.
+
+Additionally, global variables named _<n> are dynamically created (<n>
+being the prompt counter), such that the result of output <n> is always
+available as _<n> (don't use the angle brackets, just the number, e.g.
+``_21``).
+
+These variables are also stored in a global dictionary (not a
+list, since it only has entries for lines which returned a result)
+available under the names _oh and Out (similar to _ih and In). So the
+output from line 12 can be obtained as ``_12``, ``Out[12]`` or ``_oh[12]``. If you
+accidentally overwrite the Out variable you can recover it by typing
+``Out=_oh`` at the prompt.
+
+This system obviously can potentially put heavy memory demands on your
+system, since it prevents Python's garbage collector from removing any
+previously computed results. You can control how many results are kept
+in memory with the configuration option ``InteractiveShell.cache_size``.
+If you set it to 0, output caching is disabled. You can also use the :magic:`reset`
+and :magic:`xdel` magics to clear large items from memory.
+
+Directory history
+-----------------
+
+Your history of visited directories is kept in the global list _dh, and
+the magic :magic:`cd` command can be used to go to any entry in that list. The
+:magic:`dhist` command allows you to view this history. Do ``cd -<TAB>`` to
+conveniently view the directory history.
+
+
+Automatic parentheses and quotes
+--------------------------------
+
+These features were adapted from Nathan Gray's LazyPython. They are
+meant to allow less typing for common situations.
+
+Callable objects (i.e. functions, methods, etc) can be invoked like this
+(notice the commas between the arguments)::
+
+    In [1]: callable_ob arg1, arg2, arg3
+    ------> callable_ob(arg1, arg2, arg3)
+
+.. note::
+   This feature is disabled by default. To enable it, use the ``%autocall``
+   magic command. The commands below with special prefixes will always work,
+   however.
+
+You can force automatic parentheses by using '/' as the first character
+of a line. For example::
+
+    In [2]: /globals # becomes 'globals()'
+
+Note that the '/' MUST be the first character on the line! This won't work::
+
+    In [3]: print /globals # syntax error
+
+In most cases the automatic algorithm should work, so you should rarely
+need to explicitly invoke /. One notable exception is if you are trying
+to call a function with a list of tuples as arguments (the parenthesis
+will confuse IPython)::
+
+    In [4]: zip (1,2,3),(4,5,6) # won't work
+
+but this will work::
+
+    In [5]: /zip (1,2,3),(4,5,6)
+    ------> zip ((1,2,3),(4,5,6))
+    Out[5]: [(1, 4), (2, 5), (3, 6)]
+
+IPython tells you that it has altered your command line by displaying
+the new command line preceded by ``--->``.
+
+You can force automatic quoting of a function's arguments by using ``,``
+or ``;`` as the first character of a line. For example::
+
+    In [1]: ,my_function /home/me  # becomes my_function("/home/me")
+
+If you use ';' the whole argument is quoted as a single string, while ',' splits
+on whitespace::
+
+    In [2]: ,my_function a b c    # becomes my_function("a","b","c")
+
+    In [3]: ;my_function a b c    # becomes my_function("a b c")
+
+Note that the ',' or ';' MUST be the first character on the line! This
+won't work::
+
+    In [4]: x = ,my_function /home/me # syntax error
+
+IPython as your default Python environment
+==========================================
+
+Python honors the environment variable :envvar:`PYTHONSTARTUP` and will
+execute at startup the file referenced by this variable. If you put the
+following code at the end of that file, then IPython will be your working
+environment anytime you start Python::
+
+    import os, IPython
+    os.environ['PYTHONSTARTUP'] = ''  # Prevent running this again
+    IPython.start_ipython()
+    raise SystemExit
+
+The ``raise SystemExit`` is needed to exit Python when
+it finishes, otherwise you'll be back at the normal Python ``>>>``
+prompt.
+
+This is probably useful to developers who manage multiple Python
+versions and don't want to have correspondingly multiple IPython
+versions. Note that in this mode, there is no way to pass IPython any
+command-line options, as those are trapped first by Python itself.
+
+.. _Embedding:
+
+Embedding IPython
+=================
+
+You can start a regular IPython session with
+
+.. sourcecode:: python
+
+    import IPython
+    IPython.start_ipython(argv=[])
+
+at any point in your program.  This will load IPython configuration,
+startup files, and everything, just as if it were a normal IPython session.
+For information on setting configuration options when running IPython from
+python, see :ref:`configure_start_ipython`.
+
+It is also possible to embed an IPython shell in a namespace in your Python
+code. This allows you to evaluate dynamically the state of your code, operate
+with your variables, analyze them, etc. For example, if you run the following
+code snippet::
+
+  import IPython
+
+  a = 42
+  IPython.embed()
+
+and within the IPython shell, you reassign `a` to `23` to do further testing of
+some sort, you can then exit::
+
+  >>> IPython.embed()
+  Python 3.12.0 (default, Oct 10 2023, 12:00:00)
+  Type 'copyright', 'credits' or 'license' for more information
+  IPython 9.0.0 -- An enhanced Interactive Python. Type '?' for help.
+
+  In [1]: a = 23
+
+  In [2]: exit()
+
+Once you exit and print `a`, the value 23 will be shown::
+
+
+  In: print(a)
+  23
+
+It's important to note that the code run in the embedded IPython shell will
+*not* change the state of your code and variables, **unless** the shell is
+contained within the global namespace. In the above example, `a` is changed
+because this is true.
+
+To further exemplify this, consider the following example::
+
+  import IPython
+  def do():
+      a = 42
+      print(a)
+      IPython.embed()
+      print(a)
+
+Now if call the function and complete the state changes as we did above, the
+value `42` will be printed. Again, this is because it's not in the global
+namespace::
+
+  do()
+
+Running a file with the above code can lead to the following session::
+
+  >>> do()
+  42
+  Python 3.12.0 (default, Oct 10 2023, 12:00:00)
+  Type 'copyright', 'credits' or 'license' for more information
+  IPython 9.0.0 -- An enhanced Interactive Python. Type '?' for help.
+
+  In [1]: a = 23
+
+  In [2]: exit()
+  42
+
+.. note::
+
+  At present, embedding IPython cannot be done from inside IPython.
+  Run the code samples below outside IPython.
+
+This feature allows you to easily have a fully functional python
+environment for doing object introspection anywhere in your code with a
+simple function call. In some cases a simple print statement is enough,
+but if you need to do more detailed analysis of a code fragment this
+feature can be very valuable.
+
+It can also be useful in scientific computing situations where it is
+common to need to do some automatic, computationally intensive part and
+then stop to look at data, plots, etc.
+Opening an IPython instance will give you full access to your data and
+functions, and you can resume program execution once you are done with
+the interactive part (perhaps to stop again later, as many times as
+needed).
+
+The following code snippet is the bare minimum you need to include in
+your Python programs for this to work (detailed examples follow later)::
+
+    from IPython import embed
+
+    embed() # this call anywhere in your program will start IPython
+
+You can also embed an IPython *kernel*, for use with qtconsole, etc. via::
+
+    from ipykernel.embed import embed_kernel
+
+    embed_kernel()
+
+This should work the same way, but you can connect an external frontend
+(``ipython qtconsole`` or ``ipython console``),
+rather than interacting with it in the terminal.
+
+You can run embedded instances even in code which is itself being run at
+the IPython interactive prompt with '%run <filename>'. Since it's easy
+to get lost as to where you are (in your top-level IPython or in your
+embedded one), it's a good idea in such cases to set the in/out prompts
+to something different for the embedded instances. The code examples
+below illustrate this.
+
+You can also have multiple IPython instances in your program and open
+them separately, for example with different options for data
+presentation. If you close and open the same instance multiple times,
+its prompt counters simply continue from each execution to the next.
+
+Please look at the docstrings in the :mod:`~IPython.frontend.terminal.embed`
+module for more details on the use of this system.
+
+The following sample file illustrating how to use the embedding
+functionality is provided in the examples directory as embed_class_long.py.
+It should be fairly self-explanatory:
+
+.. literalinclude:: ../../../examples/Embedding/embed_class_long.py
+    :language: python
+
+Once you understand how the system functions, you can use the following
+code fragments in your programs which are ready for cut and paste:
+
+.. literalinclude:: ../../../examples/Embedding/embed_class_short.py
+    :language: python
+
+Using the Python debugger (pdb)
+===============================
+
+Running entire programs via pdb
+-------------------------------
+
+pdb, the Python debugger, is a powerful interactive debugger which
+allows you to step through code, set breakpoints, watch variables,
+etc.  IPython makes it very easy to start any script under the control
+of pdb, regardless of whether you have wrapped it into a 'main()'
+function or not. For this, simply type ``%run -d myscript`` at an
+IPython prompt. See the :magic:`run` command's documentation for more details, including
+how to control where pdb will stop execution first.
+
+For more information on the use of the pdb debugger, see :ref:`debugger-commands`
+in the Python documentation.
+
+IPython extends the debugger with a few useful additions, like coloring of
+tracebacks. The debugger will adopt the color scheme selected for IPython.
+
+The ``where`` command has also been extended to take as argument the number of
+context line to show. This allows to a many line of context on shallow stack trace:
+
+.. code::
+
+    In [5]: def foo(x):
+    ...:     1
+    ...:     2
+    ...:     3
+    ...:     return 1/x+foo(x-1)
+    ...:     5
+    ...:     6
+    ...:     7
+    ...:
+
+    In[6]: foo(1)
+    # ...
+    ipdb> where 8
+    <ipython-input-6-9e45007b2b59>(1)<module>
+    ----> 1 foo(1)
+
+    <ipython-input-5-7baadc3d1465>(5)foo()
+        1 def foo(x):
+        2     1
+        3     2
+        4     3
+    ----> 5     return 1/x+foo(x-1)
+        6     5
+        7     6
+        8     7
+
+    > <ipython-input-5-7baadc3d1465>(5)foo()
+        1 def foo(x):
+        2     1
+        3     2
+        4     3
+    ----> 5     return 1/x+foo(x-1)
+        6     5
+        7     6
+        8     7
+
+
+And less context on shallower Stack Trace:
+
+.. code::
+
+    ipdb> where 1
+    <ipython-input-13-afa180a57233>(1)<module>
+    ----> 1 foo(7)
+
+    <ipython-input-5-7baadc3d1465>(5)foo()
+    ----> 5     return 1/x+foo(x-1)
+
+    <ipython-input-5-7baadc3d1465>(5)foo()
+    ----> 5     return 1/x+foo(x-1)
+
+    <ipython-input-5-7baadc3d1465>(5)foo()
+    ----> 5     return 1/x+foo(x-1)
+
+    <ipython-input-5-7baadc3d1465>(5)foo()
+    ----> 5     return 1/x+foo(x-1)
+
+Module Ignoring Commands
+------------------------
+
+IPython's debugger provides commands to ignore specific modules when navigating
+through stack frames. This is particularly useful when debugging applications
+that use frameworks or libraries where you want to skip over their internal
+code and focus on your application logic.
+
+The module ignoring system supports wildcard patterns using Python's ``fnmatch``
+syntax, allowing you to ignore groups of related modules with a single pattern.
+
+ignore_module <module_name>
+++++++++++++++++++++++++++++
+
+Add a module to the list of modules to skip when navigating frames. When a module
+is ignored, the debugger will automatically skip over frames from that module when
+using the ``next``, ``step``, ``continue``, ``up`` and ``down`` commands.
+
+**Usage:**
+
+.. code::
+
+    ipdb> ignore_module threading
+    ipdb> ignore_module __main__
+    ipdb> ignore_module asyncio.*      # Ignore all asyncio submodules
+    ipdb> ignore_module *.tests        # Ignore all test modules
+    ipdb> ignore_module django.*       # Ignore all django modules
+    ipdb> ignore_module  # List currently ignored modules
+    Currently ignored modules: ['__main__', 'asyncio.*', 'django.*', 'threading']
+
+**Wildcard Pattern Examples:**
+
+- ``asyncio.*`` - Matches ``asyncio.tasks``, ``asyncio.events``, etc.
+- ``*.tests`` - Matches ``myapp.tests``, ``utils.tests``, etc.
+- ``test_*`` - Matches ``test_models``, ``test_views``, etc.
+- ``django.*`` - Matches all Django framework modules
+- ``*pytest*`` - Matches any module containing "pytest"
+
+**Common use cases:**
+
+- Ignore framework code (e.g., ``django.*``, ``flask.*``, ``asyncio.*``)
+- Skip standard library modules (e.g., ``threading``, ``multiprocessing``, ``logging.*``)
+- Hide main module frames (``__main__``) to focus on function implementations
+- Skip test framework internals (``*pytest*``, ``unittest.*``)
+
+unignore_module <module_name>
++++++++++++++++++++++++++++++
+
+Remove a module from the list of modules to skip when navigating frames. This
+allows the debugger to step into frames from the specified module again.
+
+**Usage:**
+
+.. code::
+
+    ipdb> unignore_module threading
+    ipdb> unignore_module asyncio.*    # Remove the pattern
+    ipdb> unignore_module  # List currently ignored modules
+    Currently ignored modules: ['__main__']
+
+Post-mortem debugging
+---------------------
+
+Going into a debugger when an exception occurs can be
+extremely useful in order to find the origin of subtle bugs, because pdb
+opens up at the point in your code which triggered the exception, and
+while your program is at this point 'dead', all the data is still
+available and you can walk up and down the stack frame and understand
+the origin of the problem.
+
+You can use the :magic:`debug` magic after an exception has occurred to start
+post-mortem debugging. IPython can also call debugger every time your code
+triggers an uncaught exception. This feature can be toggled with the :magic:`pdb` magic
+command, or you can start IPython with the ``--pdb`` option.
+
+For a post-mortem debugger in your programs outside IPython,
+put the following lines toward the top of your 'main' routine::
+
+    # TODO: theme
+    import sys
+    from IPython.core import ultratb
+    sys.excepthook = ultratb.FormattedTB(mode='Verbose',
+    color_scheme='Linux', call_pdb=1)
+
+The mode keyword can be either 'Verbose' or 'Plain', giving either very
+detailed or normal tracebacks respectively. The color_scheme keyword can
+be one of 'nocolor', 'linux' (default) or 'lightbg'. These are the same
+options which can be set in IPython with ``--colors`` and ``--xmode``.
+
+This will give any of your programs detailed, colored tracebacks with
+automatic invocation of pdb.
+
+.. _pasting_with_prompts:
+
+Pasting of code starting with Python or IPython prompts
+=======================================================
+
+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.
+
+The following is a 'screenshot' of how things work, copying an example from the
+standard Python tutorial::
+
+    In [1]: >>> # Fibonacci series:
+
+    In [2]: ... # the sum of two elements defines the next
+
+    In [3]: ... a, b = 0, 1
+
+    In [4]: >>> while b < 10:
+       ...:     ...     print(b)
+       ...:     ...     a, b = b, a+b
+       ...:
+    1
+    1
+    2
+    3
+    5
+    8
+
+And pasting from IPython sessions works equally well::
+
+    In [1]: In [5]: def f(x):
+       ...:        ...:     "A simple function"
+       ...:        ...:     return x**2
+       ...:    ...:
+
+    In [2]: f(3)
+    Out[2]: 9
+
+.. _gui_support:
+
+GUI event loop support
+======================
+
+IPython has excellent support for working interactively with Graphical User
+Interface (GUI) toolkits, such as wxPython, PyQt/PySide, PyGTK and Tk. This is
+implemented by running the toolkit's event loop while IPython is waiting for
+input.
+
+For users, enabling GUI event loop integration is simple.  You simple use the
+:magic:`gui` magic as follows::
+
+    %gui [GUINAME]
+
+With no arguments, ``%gui`` removes all GUI support.  Valid ``GUINAME``
+arguments include ``wx``, ``qt``, ``qt5``, ``qt6``, ``gtk3`` ``gtk4``, and
+``tk``.
+
+Thus, to use wxPython interactively and create a running :class:`wx.App`
+object, do::
+
+    %gui wx
+
+You can also start IPython with an event loop set up using the `--gui`
+flag::
+
+    $ ipython --gui=qt
+
+For information on IPython's matplotlib_ integration (and the ``matplotlib``
+mode) see :ref:`this section <matplotlib_support>`.
+
+For developers that want to integrate additional event loops with IPython, see
+:doc:`/config/eventloops`.
+
+When running inside IPython with an integrated event loop, a GUI application
+should *not* start its own event loop. 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 support for this.
+Since the details vary slightly between toolkits, we point you to the various
+examples in our source directory :file:`examples/IPython Kernel/gui/` that
+demonstrate these capabilities.
+
+PyQt and PySide
+---------------
+
+.. attempt at explanation of the complete mess that is Qt support
+
+When you use ``--gui=qt`` or ``--matplotlib=qt``, IPython can work with either
+PyQt or PySide.  ``qt`` implies "use the latest version available", and it favors
+PyQt over PySide. To request a specific version, use ``qt5`` or ``qt6``.
+
+If specified, IPython will respect the environment variable ``QT_API``. If
+``QT_API`` is not specified and you launch IPython in matplotlib mode with
+``ipython --matplotlib=qt`` then IPython will ask matplotlib which Qt library
+to use. See the matplotlib_ documentation on ``QT_API`` for further details.
+
+
+.. _matplotlib_support:
+
+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, PyQt6 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.
+
+To start IPython with matplotlib support, use the ``--matplotlib`` switch. If
+IPython is already running, you can run the :magic:`matplotlib` magic.  If no
+arguments are given, IPython will automatically detect your choice of
+matplotlib backend. For information on matplotlib backends see
+:ref:`matplotlib_magic`.
+
+
+.. _interactive_demos:
+
+Interactive demos with IPython
+==============================
+
+IPython ships with a basic system for running scripts interactively in
+sections, useful when presenting code to audiences. A few tags embedded
+in comments (so that the script remains valid Python code) divide a file
+into separate blocks, and the demo can be run one block at a time, with
+IPython printing (with syntax highlighting) the block before executing
+it, and returning to the interactive prompt after each block. The
+interactive namespace is updated after each block is run with the
+contents of the demo's namespace.
+
+This allows you to show a piece of code, run it and then execute
+interactively commands based on the variables just created. Once you
+want to continue, you simply execute the next block of the demo. The
+following listing shows the markup necessary for dividing a script into
+sections for execution as a demo:
+
+.. literalinclude:: ../../../examples/IPython Kernel/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::
+
+    from IPython.lib.demo import Demo
+
+    mydemo = Demo('myscript.py')
+
+This creates the mydemo object, whose blocks you run one at a time by
+simply calling the object with no arguments. Then call it to run each step
+of the demo::
+
+    mydemo()
+
+Demo objects can be
+restarted, you can move forward or back skipping blocks, re-execute the
+last block, etc. See the :mod:`IPython.lib.demo` module and the
+:class:`~IPython.lib.demo.Demo` class for details.
+
+Limitations: These demos are limited to
+fairly simple uses. In particular, you cannot break up sections within
+indented code (loops, if statements, function definitions, etc.)
+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
+:ref:`embedding facilities <Embedding>`.
+
+.. include:: ../links.txt
diff --git a/docs/source/interactive/reference.txt b/docs/source/interactive/reference.txt
deleted file mode 100644
index 7cf643b60d8..00000000000
--- a/docs/source/interactive/reference.txt
+++ /dev/null
@@ -1,1578 +0,0 @@
-=================
-IPython reference
-=================
-
-.. warning::
-
-    As of the 0.11 version of IPython, some of the features and APIs
-    described in this section have been deprecated or are broken.  Our plan
-    is to continue to support these features, but they need to be updated
-    to take advantage of recent API changes.  Furthermore, this section
-    of the documentation need to be updated to reflect all of these changes.
-
-.. _command_line_options:
-
-Command-line usage
-==================
-
-You start IPython with the command::
-
-    $ ipython [options] files
-
-If invoked with no options, it executes all the files listed in sequence
-and drops you into the interpreter while still acknowledging any options
-you may have set in your ipythonrc file. This behavior is different from
-standard Python, which when called as python -i will only execute one
-file and ignore your configuration setup.
-
-Please note that some of the configuration options are not available at
-the command line, simply because they are not practical here. Look into
-your ipythonrc configuration file for details on those. This file is typically 
-installed in the IPYTHON_DIR directory. For Linux
-users, this will be $HOME/.config/ipython, and for other users it will be
-$HOME/.ipython.  For Windows users, $HOME resolves to C:\\Documents and
-Settings\\YourUserName in most instances.
-
-
-
-
-Special Threading Options
--------------------------
-
-Previously IPython had command line options for controlling GUI event loop
-integration (-gthread, -qthread, -q4thread, -wthread, -pylab). As of IPython
-version 0.11, these have been deprecated. Please see the new ``%gui``
-magic command or :ref:`this section <gui_support>` for details on the new
-interface.
-
-Regular Options
----------------
-
-After the above threading options have been given, regular options can
-follow in any order. All options can be abbreviated to their shortest
-non-ambiguous form and are case-sensitive. One or two dashes can be
-used. Some options have an alternate short form, indicated after a ``|``.
-
-Most options can also be set from your ipythonrc configuration file. See
-the provided example for more details on what the options do. Options
-given at the command line override the values set in the ipythonrc file.
-
-All options with a [no] prepended can be specified in negated form
-(-nooption instead of -option) to turn the feature off.
-
-    -help  print a help message and exit.
-
-    -pylab
-    Deprecated.  See :ref:`Matplotlib support <matplotlib_support>`
-    for more details.
-
-    -autocall <val>
-	Make IPython automatically call any callable object even if you
-	didn't type explicit parentheses. For example, 'str 43' becomes
-	'str(43)' automatically. The value can be '0' to disable the feature,
-	'1' for smart autocall, where it is not applied if there are no more
-	arguments on the line, and '2' for full autocall, where all callable
-	objects are automatically called (even if no arguments are
-	present). The default is '1'.
-
-    -[no]autoindent    
-	Turn automatic indentation on/off.
-
-    -[no]automagic 
-	make magic commands automatic (without needing their first character
-	to be %). Type %magic at the IPython prompt for more information.
-
-    -[no]autoedit_syntax 
-	When a syntax error occurs after editing a file, automatically
-	open the file to the trouble causing line for convenient
-	fixing.
-
-    -[no]banner		Print the initial information banner (default on).
-
-    -c <command>
-	execute the given command string. This is similar to the -c
-	option in the normal Python interpreter.
-
-    -cache_size, cs <n> 
-	size of the output cache (maximum number of entries to hold in
-	memory). The default is 1000, you can change it permanently in your
-	config file. Setting it to 0 completely disables the caching system,
-	and the minimum value accepted is 20 (if you provide a value less than
-	20, it is reset to 0 and a warning is issued) This limit is defined
-	because otherwise you'll spend more time re-flushing a too small cache
-	than working.
-
-    -classic, cl 
-	Gives IPython a similar feel to the classic Python
-	prompt.
-
-    -colors <scheme> 
-	Color scheme for prompts and exception reporting. Currently
-	implemented: NoColor, Linux and LightBG.
-
-    -[no]color_info 
-	IPython can display information about objects via a set of functions,
-	and optionally can use colors for this, syntax highlighting source
-	code and various other elements.  However, because this information is
-	passed through a pager (like 'less') and many pagers get confused with
-	color codes, this option is off by default. You can test it and turn
-	it on permanently in your ipythonrc file if it works for you. As a
-	reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
-	that in RedHat 7.2 doesn't.
-
-	Test it and turn it on permanently if it works with your
-	system. The magic function %color_info allows you to toggle this
-	interactively for testing.
-
-    -[no]debug 
-	Show information about the loading process. Very useful to pin down
-	problems with your configuration files or to get details about
-	session restores.
-
-    -[no]deep_reload: 
-	IPython can use the deep_reload module which reloads changes in
-	modules recursively (it replaces the reload() function, so you don't
-	need to change anything to use it).  deep_reload() forces a full
-	reload of modules whose code may have changed, which the default
-	reload() function does not.
-
-	When deep_reload is off, IPython will use the normal reload(),
-	but deep_reload will still be available as dreload(). This
-	feature is off by default [which means that you have both
-	normal reload() and dreload()].
-
-    -editor <name>
-	Which editor to use with the %edit command. By default,
-	IPython will honor your EDITOR environment variable (if not
-	set, vi is the Unix default and notepad the Windows one).
-	Since this editor is invoked on the fly by IPython and is
-	meant for editing small code snippets, you may want to use a
-	small, lightweight editor here (in case your default EDITOR is
-	something like Emacs).
-
-    -ipythondir <name> 
-	name of your IPython configuration directory IPYTHON_DIR. This
-	can also be specified through the environment variable
-	IPYTHON_DIR.
-
-    -log, l 
-	generate a log file of all input. The file is named
-	ipython_log.py in your current directory (which prevents logs
-	from multiple IPython sessions from trampling each other). You
-	can use this to later restore a session by loading your
-	logfile as a file to be executed with option -logplay (see
-	below).
-
-    -logfile, lf <name>   specify the name of your logfile.
-
-    -logplay, lp <name> 
-
-      you can replay a previous log. For restoring a session as close as
-      possible to the state you left it in, use this option (don't just run
-      the logfile). With -logplay, IPython will try to reconstruct the
-      previous working environment in full, not just execute the commands in
-      the logfile.
-
-      When a session is restored, logging is automatically turned on
-      again with the name of the logfile it was invoked with (it is
-      read from the log header). So once you've turned logging on for
-      a session, you can quit IPython and reload it as many times as
-      you want and it will continue to log its history and restore
-      from the beginning every time.
-      
-      Caveats: there are limitations in this option. The history
-      variables _i*,_* and _dh don't get restored properly. In the
-      future we will try to implement full session saving by writing
-      and retrieving a 'snapshot' of the memory state of IPython. But
-      our first attempts failed because of inherent limitations of
-      Python's Pickle module, so this may have to wait.
-
-    -[no]messages   
-	Print messages which IPython collects about its startup
-	process (default on).
-
-    -[no]pdb
-	Automatically call the pdb debugger after every uncaught
-	exception. If you are used to debugging using pdb, this puts
-	you automatically inside of it after any call (either in
-	IPython or in code called by it) which triggers an exception
-	which goes uncaught.
-
-    -pydb
-	Makes IPython use the third party "pydb" package as debugger,
-	instead of pdb. Requires that pydb is installed.
-	
-    -[no]pprint
-	ipython can optionally use the pprint (pretty printer) module
-	for displaying results. pprint tends to give a nicer display
-	of nested data structures. If you like it, you can turn it on
-	permanently in your config file (default off).
-
-    -profile, p <name>
-
-	assume that your config file is ipythonrc-<name> or
-	ipy_profile_<name>.py (looks in current dir first, then in
-	IPYTHON_DIR).  This is a quick way to keep and load multiple
-	config files for different tasks, especially if you use the
-	include option of config files. You can keep a basic
-	IPYTHON_DIR/ipythonrc file and then have other 'profiles' which
-	include this one and load extra things for particular
-	tasks. For example:
-
-	1. $IPYTHON_DIR/ipythonrc : load basic things you always want.
-	2. $IPYTHON_DIR/ipythonrc-math : load (1) and basic math-related modules.
-	3. $IPYTHON_DIR/ipythonrc-numeric : load (1) and Numeric and plotting modules.
-
-	Since it is possible to create an endless loop by having
-	circular file inclusions, IPython will stop if it reaches 15
-	recursive inclusions.
-
-    -prompt_in1, pi1 <string>
-
-        Specify the string used for input prompts. Note that if you are using
-	numbered prompts, the number is represented with a '\#' in the
-	string. Don't forget to quote strings with spaces embedded in
-	them. Default: 'In [\#]:'.  The :ref:`prompts section <prompts>`
-	discusses in detail all the available escapes to customize your
-	prompts.
-
-    -prompt_in2, pi2 <string>
-	Similar to the previous option, but used for the continuation
-	prompts. The special sequence '\D' is similar to '\#', but
-	with all digits replaced dots (so you can have your
-	continuation prompt aligned with your input prompt).  Default:
-	' .\D.:' (note three spaces at the start for alignment with
-	'In [\#]').
-
-    -prompt_out,po <string> 
-	String used for output prompts, also uses numbers like
-	prompt_in1. Default: 'Out[\#]:'
-
-    -quick   start in bare bones mode (no config file loaded).
-
-    -rcfile <name>   
-	name of your IPython resource configuration file. Normally
-	IPython loads ipythonrc (from current directory) or
-	IPYTHON_DIR/ipythonrc.
-
-	If the loading of your config file fails, IPython starts with
-	a bare bones configuration (no modules loaded at all).
-
-    -[no]readline
-	use the readline library, which is needed to support name
-	completion and command history, among other things.  It is
-	enabled by default, but may cause problems for users of
-	X/Emacs in Python comint or shell buffers.
-
-	Note that X/Emacs 'eterm' buffers (opened with M-x term) support
-	IPython's readline and syntax coloring fine, only 'emacs' (M-x
-	shell and C-c !) buffers do not.
-
-    -screen_length, sl <n>
-	number of lines of your screen. This is used to control
-	printing of very long strings. Strings longer than this number
-	of lines will be sent through a pager instead of directly
-	printed.
-
-	The default value for this is 0, which means IPython will
-	auto-detect your screen size every time it needs to print certain
-	potentially long strings (this doesn't change the behavior of the
-	'print' keyword, it's only triggered internally). If for some
-	reason this isn't working well (it needs curses support), specify
-	it yourself. Otherwise don't change the default.
-
-    -separate_in, si <string>
-
-	separator before input prompts.
-	Default: '\n'
-
-    -separate_out, so <string>  
-        separator before output prompts.
-        Default: nothing.
-
-    -separate_out2, so2
-	separator after output prompts.
-	Default: nothing.
-	For these three options, use the value 0 to specify no separator.
-
-    -nosep   
-	shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2
-	0'. Simply removes all input/output separators.
-
-    -upgrade 
-	allows you to upgrade your IPYTHON_DIR configuration when you
-	install a new version of IPython. Since new versions may
-	include new command line options or example files, this copies
-	updated ipythonrc-type files. However, it backs up (with a
-	.old extension) all files which it overwrites so that you can
-	merge back any customizations you might have in your personal
-	files. Note that you should probably use %upgrade instead,
-	it's a safer alternative.
-
-
-    -Version    print version information and exit.
-
-    -wxversion <string> 
-    Deprecated.
-
-    -xmode <modename>
-
-	Mode for exception reporting.
-
-	Valid modes: Plain, Context and Verbose.
-
-	* Plain: similar to python's normal traceback printing.
-	* Context: prints 5 lines of context source code around each
-	  line in the traceback.
-	* Verbose: similar to Context, but additionally prints the
-	  variables currently visible where the exception happened
-	  (shortening their strings if too long). This can potentially be
-	  very slow, if you happen to have a huge data structure whose
-	  string representation is complex to compute. Your computer may
-	  appear to freeze for a while with cpu usage at 100%. If this
-	  occurs, you can cancel the traceback with Ctrl-C (maybe hitting it
-	  more than once).
-
-Interactive use
-===============
-
-Warning: IPython relies on the existence of a global variable called
-_ip which controls the shell itself. If you redefine _ip to anything,
-bizarre behavior will quickly occur.
-
-Other than the above warning, 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``
-
-.. _magic:
-
-Magic command system
---------------------
-
-IPython will treat any line whose first character is a % as a special
-call to a 'magic' function. These allow you to control the behavior of
-IPython itself, plus a lot of system-type features. They are all
-prefixed with a % character, but parameters are given without
-parentheses or quotes.
-
-Example: typing '%cd mydir' (without the quotes) changes you working
-directory to 'mydir', if it exists.
-
-If you have 'automagic' enabled (in your ipythonrc file, via the command
-line option -automagic or with the %automagic function), you don't need
-to type in the % explicitly. IPython will scan its internal list of
-magic functions and call one if it exists. With automagic on you can
-then just type 'cd mydir' to go to directory 'mydir'. The automagic
-system has the lowest possible precedence in name searches, so defining
-an identifier with the same name as an existing magic function will
-shadow it for automagic use. You can still access the shadowed magic
-function by explicitly using the % character at the beginning of the line.
-
-An example (with automagic on) should clarify all this::
-
-    In [1]: cd ipython # %cd is called by automagic
-
-    /home/fperez/ipython
-
-    In [2]: cd=1 # now cd is just a variable
-
-    In [3]: cd .. # and doesn't work as a function anymore
-
-    ------------------------------
-
-        File "<console>", line 1
-
-          cd ..
-
-              ^
-
-    SyntaxError: invalid syntax
-
-    In [4]: %cd .. # but %cd always works
-
-    /home/fperez
-
-    In [5]: del cd # if you remove the cd variable
-
-    In [6]: cd ipython # automagic can work again
-
-    /home/fperez/ipython
-
-You can define your own magic functions to extend the system. The
-following example defines a new magic command, %impall::
-
-    import IPython.ipapi 
-
-    ip = IPython.ipapi.get()
-
-    def doimp(self, arg):
-
-        ip = self.api
-
-        ip.ex("import %s; reload(%s); from %s import *" % (
-
-        arg,arg,arg)
-
-        )
-
-    ip.expose_magic('impall', doimp)
-
-You can also define your own aliased names for magic functions. In your
-ipythonrc file, placing a line like::
-
-    execute __IP.magic_cl = __IP.magic_clear
-
-will define %cl as a new name for %clear.
-
-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.
-
-The API documentation for the :mod:`IPython.Magic` module contains the full
-docstrings of all currently available magic commands.
-
-
-Access to the standard Python help
-----------------------------------
-
-As of Python 2.1, a help system is available with access to object docstrings
-and the Python manuals. Simply type 'help' (no quotes) to access it. You can
-also type help(object) to obtain information about a given object, and
-help('keyword') for information on a keyword. As noted :ref:`here
-<accessing_help>`, you need to properly configure your environment variable
-PYTHONDOCS for this feature to work correctly.
-
-.. _dynamic_object_info:
-
-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?? 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
-without the %), this is just a summary:
-
-    * **%pdoc <object>**: Print (or run through a pager if too long) the
-      docstring for an object. If the given object is a class, it will
-      print both the class and the constructor docstrings.
-    * **%pdef <object>**: Print the definition header for any callable
-      object. If the object is a class, print the constructor information.
-    * **%psource <object>**: Print (or run through a pager if too long)
-      the source code for an object.
-    * **%pfile <object>**: Show the entire source file where an object was
-      defined via a pager, opening it at the line where the object
-      definition begins.
-    * **%who/%whos**: These functions give information about identifiers
-      you have defined interactively (not things you loaded or defined
-      in your configuration files). %who just prints a list of
-      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??.
-
-
-.. _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.
-
-
-Command line completion
-+++++++++++++++++++++++
-
-At any time, hitting TAB will complete any available python commands or
-variable names, and show you a list of the possible completions if
-there's no unambiguous one. It will also complete filenames in the
-current directory if no python names match what you've typed so far.
-
-
-Search command history
-++++++++++++++++++++++
-
-IPython provides two ways for searching through previous input and thus
-reduce the need for repetitive typing:
-
-   1. Start typing, and then use Ctrl-p (previous,up) and Ctrl-n
-      (next,down) to search through only the history items that match
-      what you've typed so far. If you use Ctrl-p/Ctrl-n at a blank
-      prompt, they just behave like normal arrow keys.
-   2. Hit Ctrl-r: opens a search prompt. Begin typing and the system
-      searches your history for lines that contain what you've typed so
-      far, completing as much as it can.
-
-
-Persistent command history across sessions
-++++++++++++++++++++++++++++++++++++++++++
-
-IPython will save your input history when it leaves and reload it next
-time you restart it. By default, the history file is named
-$IPYTHON_DIR/history, but if you've loaded a named profile,
-'-PROFILE_NAME' is appended to the name. This allows you to keep
-separate histories related to various tasks: commands related to
-numerical work will not be clobbered by a system shell history, for
-example.
-
-
-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)::
-
-    $if Python 
-    "\M-i": "    "  
-    "\M-u": "\d\d\d\d"  
-    $endif
-
-Note that there are 4 spaces between the quote marks after "M-i" above.
-
-Warning: this feature 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 ipythonrc file (set autoindent 0).
-
-
-Customizing readline behavior
-+++++++++++++++++++++++++++++
-
-All these features are based on the GNU readline library, which has an
-extremely customizable interface. Normally, readline is configured via a
-file which defines the behavior of the library; the details of the
-syntax for this can be found in the readline documentation available
-with your system or on the Internet. IPython doesn't read this file (if
-it exists) directly, but it does support passing to readline valid
-options via a simple interface. In brief, you can customize readline by
-setting the following options in your ipythonrc configuration file (note
-that these options can not be specified at the command line):
-
-    * **readline_parse_and_bind**: this option can appear as many times as
-      you want, each time defining a string to be executed via a
-      readline.parse_and_bind() command. The syntax for valid commands
-      of this kind can be found by reading the documentation for the GNU
-      readline library, as these commands are of the kind which readline
-      accepts in its configuration file.
-    * **readline_remove_delims**: a string of characters to be removed
-      from the default word-delimiters list used by readline, so that
-      completions may be performed on strings which contain them. Do not
-      change the default value unless you know what you're doing.
-    * **readline_omit__names**: when tab-completion is enabled, hitting
-      <tab> after a '.' in a name will complete all attributes of an
-      object, including all the special methods whose names include
-      double underscores (like __getitem__ or __class__). If you'd
-      rather not see these names by default, you can set this option to
-      1. Note that even when this option is set, you can still see those
-      names by explicitly typing a _ after the period and hitting <tab>:
-      'name._<tab>' will always complete attribute names starting with '_'.
-      
-      This option is off by default so that new users see all
-      attributes of any objects they are dealing with.
-
-You will find the default values along with a corresponding detailed
-explanation in your ipythonrc file.
-
-
-Session logging and restoring
------------------------------
-
-You can log all input from a session either by starting IPython with the
-command line switches -log or -logfile (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 with the -logplay option and IPython
-will attempt to 'replay' the log by executing all the lines in it, thus
-restoring the state of a previous session. This feature is not quite
-perfect, but can still be useful in many cases.
-
-The log files can also be used as a way to have a permanent record of
-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:
-
-%logstart [log_name [log_mode]]
-
-If no name is given, it defaults to a file named 'log' in your
-IPYTHON_DIR directory, in 'rotate' mode (see below).
-
-'%logstart name' saves to file 'name' in 'backup' mode. It saves your
-history up to that point and then continues logging.
-
-%logstart takes a second optional parameter: logging mode. This can be
-one of (note that the modes are given unquoted):
-
-    * [over:] overwrite existing log_name.
-    * [backup:] rename (if exists) to log_name~ and start log_name.
-    * [append:] well, that says it.
-    * [rotate:] create rotating logs log_name.1~, log_name.2~, etc.
-
-The %logoff and %logon functions allow you to temporarily stop and
-resume logging to a file which had previously been started with
-%logstart. They will fail (with an explanation) if you try to use them
-before logging has been started.
-
-.. _system_shell_access:
-
-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.
-
-Manual capture of command output
---------------------------------
-
-If the input line begins with two exclamation marks, !!, the command is
-executed but its output is captured and returned as a python list, split
-on newlines. Any output sent by the subprocess to standard error is
-printed separately, so that the resulting list only captures standard
-output. The !! syntax is a shorthand for the %sx magic command.
-
-Finally, the %sc magic (short for 'shell capture') is similar to %sx,
-but allowing more fine-grained control of the capture details, and
-storing the result directly into a named variable. The direct use of 
-%sc is now deprecated, and you should ise the ``var = !cmd`` syntax
-instead.
-
-IPython also allows you to expand the value of python variables when
-making system calls. Any python variable or expression which you prepend
-with $ will get expanded before the system call is made::
-
-    In [1]: pyvar='Hello world' 
-    In [2]: !echo "A python variable: $pyvar"  
-    A python variable: Hello world
-
-If you want the shell to actually see a literal $, you need to type it
-twice::
-
-    In [3]: !echo "A system variable: $$HOME"  
-    A system variable: /home/fperez
-
-You can pass arbitrary expressions, though you'll need to delimit them
-with {} if there is ambiguity as to the extent of the expression::
-
-    In [5]: x=10 
-    In [6]: y=20 
-    In [13]: !echo $x+y  
-    10+y  
-    In [7]: !echo ${x+y}  
-    30
-
-Even object attributes can be expanded::
-
-    In [12]: !echo $sys.argv  
-    [/home/fperez/usr/bin/ipython]
-
-
-System command aliases
-----------------------
-
-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'
-
-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
-parameter). The following example defines the %parts function as an
-alias to the command 'echo first %s second %s' where each %s will be
-replaced by a positional parameter to the call to %parts::
-
-    In [1]: alias parts echo first %s second %s 
-    In [2]: %parts A B 
-    first A second B  
-    In [3]: %parts A  
-    Incorrect number of arguments: 2 expected.  
-    parts is an alias to: 'echo first %s second %s'
-
-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).
-
-
-.. _dreload:
-
-Recursive reload
-----------------
-
-The dreload function does a recursive reload of a module: changes made
-to the module since you imported will actually be available without
-having to exit.
-
-
-Verbose and colored exception traceback printouts
--------------------------------------------------
-
-IPython provides the option to see very detailed exception tracebacks,
-which can be especially useful when debugging large programs. You can
-run any Python file with the %run function to benefit from these
-detailed tracebacks. Furthermore, both normal and verbose tracebacks can
-be colored (if your terminal supports it) which makes them much easier
-to parse visually.
-
-See the magic xmode and colors functions for details (just type %magic).
-
-These features are basically a terminal version of Ka-Ping Yee's cgitb
-module, now part of the standard Python library.
-
-
-.. _input_caching:
-
-Input caching system
---------------------
-
-IPython offers numbered prompts (In/Out) with input and output caching
-(also referred to as 'input history'). All input is saved and can be 
-retrieved as variables (besides the usual arrow key recall), in 
-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'.
-
-Additionally, global variables named _i<n> are dynamically created (<n>
-being the prompt counter), such that
-_i<n> == _ih[<n>] == In[<n>].
-
-For example, what you typed at prompt 14 is available as _i14, _ih[14]
-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).
-
-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.
-
-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.
-
-.. _output_caching:
-
-Output caching system
----------------------
-
-For output that is returned from actions, a system similar to the input
-cache exists but using _ instead of _i. Only actions that produce a
-result (NOT assignments, for example) are cached. If you are familiar
-with Mathematica, IPython's _ variables behave exactly like
-Mathematica's % variables.
-
-The following GLOBAL variables always exist (so don't overwrite them!):
-
-    * [_] (a single underscore) : stores previous output, like Python's
-      default interpreter.
-    * [__] (two underscores): next previous.
-    * [___] (three underscores): next-next previous.
-
-Additionally, global variables named _<n> are dynamically created (<n>
-being the prompt counter), such that the result of output <n> is always
-available as _<n> (don't use the angle brackets, just the number, e.g.
-_21).
-
-These global variables are all stored in a global dictionary (not a
-list, since it only has entries for lines which returned a result)
-available under the names _oh and Out (similar to _ih and In). So the
-output from line 12 can be obtained as _12, Out[12] or _oh[12]. If you
-accidentally overwrite the Out variable you can recover it by typing
-'Out=_oh' at the prompt.
-
-This system obviously can potentially put heavy memory demands on your
-system, since it prevents Python's garbage collector from removing any
-previously computed results. You can control how many results are kept
-in memory with the option (at the command line or in your ipythonrc
-file) cache_size. If you set it to 0, the whole system is completely
-disabled and the prompts revert to the classic '>>>' of normal Python.
-
-
-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
-conventiently view the directory history.
-
-
-Automatic parentheses and quotes
---------------------------------
-
-These features were adapted from Nathan Gray's LazyPython. They are
-meant to allow less typing for common situations.
-
-
-Automatic parentheses
----------------------
-
-Callable objects (i.e. functions, methods, etc) can be invoked like this
-(notice the commas between the arguments)::
-
-    >>> callable_ob arg1, arg2, arg3
-
-and the input will be translated to this::
-
-    -> callable_ob(arg1, arg2, arg3)
-
-You can force automatic parentheses by using '/' as the first character
-of a line. For example::
-
-    >>> /globals # becomes 'globals()'
-
-Note that the '/' MUST be the first character on the line! This won't work::
-
-    >>> print /globals # syntax error
-
-In most cases the automatic algorithm should work, so you should rarely
-need to explicitly invoke /. One notable exception is if you are trying
-to call a function with a list of tuples as arguments (the parenthesis
-will confuse IPython)::
-
-    In [1]: zip (1,2,3),(4,5,6) # won't work
-
-but this will work::
-
-    In [2]: /zip (1,2,3),(4,5,6) 
-    ---> zip ((1,2,3),(4,5,6))  
-    Out[2]= [(1, 4), (2, 5), (3, 6)]
-
-IPython tells you that it has altered your command line by displaying
-the new command line preceded by ->. e.g.::
-
-    In [18]: callable list 
-    ----> callable (list)
-
-
-Automatic quoting
------------------
-
-You can force automatic quoting of a function's arguments by using ','
-or ';' as the first character of a line. For example::
-
-    >>> ,my_function /home/me # becomes my_function("/home/me")
-
-If you use ';' instead, the whole argument is quoted as a single string
-(while ',' splits on whitespace)::
-
-    >>> ,my_function a b c # becomes my_function("a","b","c")
-
-    >>> ;my_function a b c # becomes my_function("a b c")
-
-Note that the ',' or ';' MUST be the first character on the line! This
-won't work::
-
-    >>> x = ,my_function /home/me # syntax error
-
-IPython as your default Python environment
-==========================================
-
-Python honors the environment variable PYTHONSTARTUP and will execute at
-startup the file referenced by this variable. If you put at the end of
-this file the following two lines of code::
-
-    import IPython 
-    IPython.Shell.IPShell().mainloop(sys_exit=1)
-
-then IPython will be your working environment anytime you start Python.
-The sys_exit=1 is needed to have IPython issue a call to sys.exit() when
-it finishes, otherwise you'll be back at the normal Python '>>>'
-prompt.
-
-This is probably useful to developers who manage multiple Python
-versions and don't want to have correspondingly multiple IPython
-versions. Note that in this mode, there is no way to pass IPython any
-command-line options, as those are trapped first by Python itself.
-
-.. _Embedding:
-
-Embedding IPython
-=================
-
-It is possible to start an IPython instance inside your own Python
-programs. This allows you to evaluate dynamically the state of your
-code, operate with your variables, analyze them, etc. Note however that
-any changes you make to values while in the shell do not propagate back
-to the running code, so it is safe to modify your values because you
-won't break your code in bizarre ways by doing so.
-
-This feature allows you to easily have a fully functional python
-environment for doing object introspection anywhere in your code with a
-simple function call. In some cases a simple print statement is enough,
-but if you need to do more detailed analysis of a code fragment this
-feature can be very valuable.
-
-It can also be useful in scientific computing situations where it is
-common to need to do some automatic, computationally intensive part and
-then stop to look at data, plots, etc.
-Opening an IPython instance will give you full access to your data and
-functions, and you can resume program execution once you are done with
-the interactive part (perhaps to stop again later, as many times as
-needed).
-
-The following code snippet is the bare minimum you need to include in
-your Python programs for this to work (detailed examples follow later)::
-
-    from IPython.Shell import IPShellEmbed
-
-    ipshell = IPShellEmbed()
-
-    ipshell() # this call anywhere in your program will start IPython
-
-You can run embedded instances even in code which is itself being run at
-the IPython interactive prompt with '%run <filename>'. Since it's easy
-to get lost as to where you are (in your top-level IPython or in your
-embedded one), it's a good idea in such cases to set the in/out prompts
-to something different for the embedded instances. The code examples
-below illustrate this.
-
-You can also have multiple IPython instances in your program and open
-them separately, for example with different options for data
-presentation. If you close and open the same instance multiple times,
-its prompt counters simply continue from each execution to the next.
-
-Please look at the docstrings in the Shell.py module for more details on
-the use of this system.
-
-The following sample file illustrating how to use the embedding
-functionality is provided in the examples directory as example-embed.py.
-It should be fairly self-explanatory::
-
-
-    #!/usr/bin/env python
-
-    """An example of how to embed an IPython shell into a running program.
-
-    Please see the documentation in the IPython.Shell module for more details.
-
-    The accompanying file example-embed-short.py has quick code fragments for
-    embedding which you can cut and paste in your code once you understand how
-    things work.
-
-    The code in this file is deliberately extra-verbose, meant for learning."""
-
-    # The basics to get you going:
-
-    # IPython sets the __IPYTHON__ variable so you can know if you have nested
-    # copies running.
-
-    # Try running this code both at the command line and from inside IPython (with
-    # %run example-embed.py)
-    try:
-        __IPYTHON__
-    except NameError:
-        nested = 0
-        args = ['']
-    else:
-        print "Running nested copies of IPython."
-        print "The prompts for the nested copy have been modified"
-        nested = 1
-        # what the embedded instance will see as sys.argv:
-        args = ['-pi1','In <\\#>: ','-pi2','   .\\D.: ',
-                '-po','Out<\\#>: ','-nosep']
-
-    # First import the embeddable shell class
-    from IPython.Shell import IPShellEmbed
-
-    # Now create an instance of the embeddable shell. The first argument is a
-    # string with options exactly as you would type them if you were starting
-    # IPython at the system command line. Any parameters you want to define for
-    # configuration can thus be specified here.
-    ipshell = IPShellEmbed(args,
-                           banner = 'Dropping into IPython',
-                           exit_msg = 'Leaving Interpreter, back to program.')
-
-    # Make a second instance, you can have as many as you want.
-    if nested:
-        args[1] = 'In2<\\#>'
-    else:
-        args = ['-pi1','In2<\\#>: ','-pi2','   .\\D.: ',
-                '-po','Out<\\#>: ','-nosep']
-    ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.')
-
-    print '\nHello. This is printed from the main controller program.\n'
-
-    # You can then call ipshell() anywhere you need it (with an optional
-    # message):
-    ipshell('***Called from top level. '
-            'Hit Ctrl-D to exit interpreter and continue program.\n'
-            'Note that if you use %kill_embedded, you can fully deactivate\n'
-            'This embedded instance so it will never turn on again')
-
-    print '\nBack in caller program, moving along...\n'
-
-    #---------------------------------------------------------------------------
-    # More details:
-
-    # IPShellEmbed instances don't print the standard system banner and
-    # messages. The IPython banner (which actually may contain initialization
-    # messages) is available as <instance>.IP.BANNER in case you want it.
-
-    # IPShellEmbed instances print the following information everytime they
-    # start:
-
-    # - A global startup banner.
-
-    # - A call-specific header string, which you can use to indicate where in the
-    # execution flow the shell is starting.
-
-    # They also print an exit message every time they exit.
-
-    # Both the startup banner and the exit message default to None, and can be set
-    # either at the instance constructor or at any other time with the
-    # set_banner() and set_exit_msg() methods.
-
-    # The shell instance can be also put in 'dummy' mode globally or on a per-call
-    # basis. This gives you fine control for debugging without having to change
-    # code all over the place.
-
-    # The code below illustrates all this.
-
-
-    # This is how the global banner and exit_msg can be reset at any point
-    ipshell.set_banner('Entering interpreter - New Banner')
-    ipshell.set_exit_msg('Leaving interpreter - New exit_msg')
-
-    def foo(m):
-        s = 'spam'
-        ipshell('***In foo(). Try @whos, or print s or m:')
-        print 'foo says m = ',m
-
-    def bar(n):
-        s = 'eggs'
-        ipshell('***In bar(). Try @whos, or print s or n:')
-        print 'bar says n = ',n
-
-    # Some calls to the above functions which will trigger IPython:
-    print 'Main program calling foo("eggs")\n'
-    foo('eggs')
-
-    # The shell can be put in 'dummy' mode where calls to it silently return. This
-    # allows you, for example, to globally turn off debugging for a program with a
-    # single call.
-    ipshell.set_dummy_mode(1)
-    print '\nTrying to call IPython which is now "dummy":'
-    ipshell()
-    print 'Nothing happened...'
-    # The global 'dummy' mode can still be overridden for a single call
-    print '\nOverriding dummy mode manually:'
-    ipshell(dummy=0)
-
-    # Reactivate the IPython shell
-    ipshell.set_dummy_mode(0)
-
-    print 'You can even have multiple embedded instances:'
-    ipshell2()
-
-    print '\nMain program calling bar("spam")\n'
-    bar('spam')
-
-    print 'Main program finished. Bye!'
-
-    #********************** End of file <example-embed.py> ***********************
-
-Once you understand how the system functions, you can use the following
-code fragments in your programs which are ready for cut and paste::
-
-
-    """Quick code snippets for embedding IPython into other programs.
-
-    See example-embed.py for full details, this file has the bare minimum code for
-    cut and paste use once you understand how to use the system."""
-
-    #---------------------------------------------------------------------------
-    # This code loads IPython but modifies a few things if it detects it's running
-    # embedded in another IPython session (helps avoid confusion)
-
-    try:
-        __IPYTHON__
-    except NameError:
-        argv = ['']
-        banner = exit_msg = ''
-    else:
-        # Command-line options for IPython (a list like sys.argv)
-        argv = ['-pi1','In <\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:']
-        banner = '*** Nested interpreter ***'
-        exit_msg = '*** Back in main IPython ***'
-
-    # First import the embeddable shell class
-    from IPython.Shell import IPShellEmbed
-    # Now create the IPython shell instance. Put ipshell() anywhere in your code
-    # where you want it to open.
-    ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg)
-
-    #---------------------------------------------------------------------------
-    # This code will load an embeddable IPython shell always with no changes for
-    # nested embededings.
-
-    from IPython.Shell import IPShellEmbed
-    ipshell = IPShellEmbed()
-    # Now ipshell() will open IPython anywhere in the code.
-
-    #---------------------------------------------------------------------------
-    # This code loads an embeddable shell only if NOT running inside
-    # IPython. Inside IPython, the embeddable shell variable ipshell is just a
-    # dummy function.
-
-    try:
-        __IPYTHON__
-    except NameError:
-        from IPython.Shell import IPShellEmbed
-        ipshell = IPShellEmbed()
-        # Now ipshell() will open IPython anywhere in the code
-    else:
-        # Define a dummy ipshell() so the same code doesn't crash inside an
-        # interactive IPython
-        def ipshell(): pass
-
-    #******************* End of file <example-embed-short.py> ********************
-
-Using the Python debugger (pdb)
-===============================
-
-Running entire programs via pdb
--------------------------------
-
-pdb, the Python debugger, is a powerful interactive debugger which
-allows you to step through code, set breakpoints, watch variables,
-etc.  IPython makes it very easy to start any script under the control
-of pdb, regardless of whether you have wrapped it into a 'main()'
-function or not. For this, simply type '%run -d myscript' at an
-IPython prompt. See the %run command's documentation (via '%run?' or
-in Sec. magic_ for more details, including how to control where pdb
-will stop execution first.
-
-For more information on the use of the pdb debugger, read the included
-pdb.doc file (part of the standard Python distribution). On a stock
-Linux system it is located at /usr/lib/python2.3/pdb.doc, but the
-easiest way to read it is by using the help() function of the pdb module
-as follows (in an IPython prompt):
-
-In [1]: import pdb 
-In [2]: pdb.help()
-
-This will load the pdb.doc document in a file viewer for you automatically.
-
-
-Automatic invocation of pdb on exceptions
------------------------------------------
-
-IPython, if started with the -pdb option (or if the option is set in
-your rc file) can call the Python pdb debugger every time your code
-triggers an uncaught exception. This feature
-can also be toggled at any time with the %pdb magic command. This can be
-extremely useful in order to find the origin of subtle bugs, because pdb
-opens up at the point in your code which triggered the exception, and
-while your program is at this point 'dead', all the data is still
-available and you can walk up and down the stack frame and understand
-the origin of the problem.
-
-Furthermore, you can use these debugging facilities both with the
-embedded IPython mode and without IPython at all. For an embedded shell
-(see sec. Embedding_), simply call the constructor with
-'-pdb' in the argument string and automatically pdb will be called if an
-uncaught exception is triggered by your code.
-
-For stand-alone use of the feature in your programs which do not use
-IPython at all, put the following lines toward the top of your 'main'
-routine::
-
-    import sys
-    from IPython.core import ultratb
-    sys.excepthook = ultratb.FormattedTB(mode='Verbose',
-    color_scheme='Linux', call_pdb=1)
-
-The mode keyword can be either 'Verbose' or 'Plain', giving either very
-detailed or normal tracebacks respectively. The color_scheme keyword can
-be one of 'NoColor', 'Linux' (default) or 'LightBG'. These are the same
-options which can be set in IPython with -colors and -xmode.
-
-This will give any of your programs detailed, colored tracebacks with
-automatic invocation of pdb.
-
-
-Extensions for syntax processing
-================================
-
-This isn't for the faint of heart, because the potential for breaking
-things is quite high. But it can be a very powerful and useful feature.
-In a nutshell, you can redefine the way IPython processes the user input
-line to accept new, special extensions to the syntax without needing to
-change any of IPython's own code.
-
-In the IPython/extensions directory you will find some examples
-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 of code starting with '>>> ' or '... '
-----------------------------------------------
-
-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.
-
-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.
-
-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
-
-The following is a 'screenshot' of how things work when this extension
-is on, copying an example from the standard tutorial::
-
-    IPython profile: tutorial 
-
-    *** Pasting of code with ">>>" or "..." has been enabled. 
-
-    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 
-       ...: 
-
-    In [2]: fib2(10) 
-    Out[2]: [1, 1, 2, 3, 5, 8]
-
-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.
-
-
-Input of physical quantities with units
----------------------------------------
-
-The module PhysicalQInput allows a simplified form of input for physical
-quantities with units. This file is meant to be used in conjunction with
-the PhysicalQInteractive module (in the same directory) and
-Physics.PhysicalQuantities from Konrad Hinsen's ScientificPython
-(http://dirac.cnrs-orleans.fr/ScientificPython/).
-
-The Physics.PhysicalQuantities module defines PhysicalQuantity objects,
-but these must be declared as instances of a class. For example, to
-define v as a velocity of 3 m/s, normally you would write::
-
-    In [1]: v = PhysicalQuantity(3,'m/s')
-
-Using the PhysicalQ_Input extension this can be input instead as: 
-In [1]: v = 3 m/s
-which is much more convenient for interactive use (even though it is
-blatantly invalid Python syntax).
-
-The physics profile supplied with IPython (enabled via 'ipython -p
-physics') uses these extensions, which you can also activate with:
-
-from math import * # math MUST be imported BEFORE PhysicalQInteractive 
-from IPython.extensions.PhysicalQInteractive import * 
-import IPython.extensions.PhysicalQInput
-
-.. _gui_support:
-
-GUI event loop support support
-==============================
-
-.. versionadded:: 0.11
-    The ``%gui`` magic and :mod:`IPython.lib.inputhook`.
-
-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
-advantages of this are:
-
-* GUIs can be enabled and disabled dynamically at runtime.
-* The active GUI can be switched dynamically at runtime.
-* In some cases, multiple GUIs can run simultaneously with no problems.
-* There is a developer API in :mod:`IPython.lib.inputhook` for customizing 
-  all of these things.
-
-For users, enabling GUI event loop integration is simple.  You simple use the
-``%gui`` magic as follows::
-
-    %gui [-a] [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.
-
-Thus, to use wxPython interactively and create a running :class:`wx.App`
-object, do::
-
-    %gui -a 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.
-
-First, the ``PyOSInputHook`` approach only works in command line settings 
-where readline is activated.
-
-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:`appstart_` 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::
-
-  try:
-      from IPython import appstart_wx
-      appstart_wx(app)
-  except ImportError:
-      app.MainLoop()
-
-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
-actually need to run the real event loops to do so. This is often needed to
-process pending events at critical points.
-
-Finally, we also have a number of examples in our source directory
-:file:`docs/examples/lib` that demonstrate these capabilities.
-
-.. _matplotlib_support:
-
-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.
-
-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 beings to include
-new logic that uses our new GUI support.
-
-.. _interactive_demos:
-
-Interactive demos with IPython
-==============================
-
-IPython ships with a basic system for running scripts interactively in
-sections, useful when presenting code to audiences. A few tags embedded
-in comments (so that the script remains valid Python code) divide a file
-into separate blocks, and the demo can be run one block at a time, with
-IPython printing (with syntax highlighting) the block before executing
-it, and returning to the interactive prompt after each block. The
-interactive namespace is updated after each block is run with the
-contents of the demo's namespace.
-
-This allows you to show a piece of code, run it and then execute
-interactively commands based on the variables just created. Once you
-want to continue, you simply execute the next block of the demo. The
-following listing shows the markup necessary for dividing a script into
-sections for execution as a demo::
-
-
-    """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!'
-
-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::
-
-    from IPython.demo import Demo
-
-    mydemo = Demo('myscript.py')
-
-This creates the mydemo object, whose blocks you run one at a time by
-simply calling the object with no arguments. If you have autocall active
-in IPython (the default), all you need to do is type::
-
-    mydemo 
-
-and IPython will call it, executing each block. Demo objects can be
-restarted, you can move forward or back skipping blocks, re-execute the
-last block, etc. Simply use the Tab key on a demo object to see its
-methods, and call '?' on them to see their docstrings for more usage
-details. In addition, the demo module itself contains a comprehensive
-docstring, which you can access via::
-
-    from IPython import demo
-
-    demo?
-
-Limitations: It is important to note that these demos are limited to
-fairly simple uses. In particular, you can not put division marks in
-indented code (loops, if statements, function definitions, etc.)
-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
-
-.. [Matplotlib] Matplotlib. http://matplotlib.sourceforge.net
-
diff --git a/docs/source/interactive/shell.rst b/docs/source/interactive/shell.rst
new file mode 100644
index 00000000000..7566921f244
--- /dev/null
+++ b/docs/source/interactive/shell.rst
@@ -0,0 +1,214 @@
+
+.. note::
+
+   This page has been kept for historical reason. You most likely want to use
+   `Xonsh <https://xon.sh/>`__ instead of this.
+
+.. _ipython_as_shell:
+
+=========================
+IPython as a system shell
+=========================
+
+
+
+Overview
+========
+
+It is possible to adapt IPython for system shell usage. In the past, IPython
+shipped a special 'sh' profile for this purpose, but it had been quarantined
+since 0.11 release, and in 1.0 it was removed altogether. Nevertheless, much
+of this section relies on machinery which does not require a custom profile.
+
+You can set up your own 'sh' :ref:`profile <Profiles>` to be different from
+the default profile such that:
+
+ * Prompt shows the current directory (see `Prompt customization`_)
+ * Make system commands directly available (in alias table) by running the
+   ``%rehashx`` magic. If you install new programs along your PATH, you might
+   want to run ``%rehashx`` to update the alias table
+ * turn ``%autocall`` to full mode
+
+
+Environment variables
+=====================
+
+Rather than manipulating os.environ directly, you may like to use the magic
+`%env` command.  With no arguments, this displays all environment variables
+and values.  To get the value of a specific variable, use `%env var`.  To set
+the value of a specific variable, use `%env foo bar`, `%env foo=bar`.  By
+default values are considered to be strings so quoting them is unnecessary.
+However, Python variables are expanded as usual in the magic command, so
+`%env foo=$bar` means "set the environment variable foo to the value of the
+Python variable `bar`".
+
+Aliases
+=======
+
+Once you run ``%rehashx``, all of your $PATH has been loaded as IPython aliases,
+so you should be able to type any normal system command and have it executed.
+See ``%alias?``  and ``%unalias?`` for details on the alias facilities. See also
+``%rehashx?`` for details on the mechanism used to load $PATH.
+
+.. warning::
+
+   See info at the top of the page. You most likely want to use
+   `Xonsh <https://xon.sh/>`__ instead of this.
+
+Directory management
+====================
+
+Since each command passed by IPython to the underlying system is executed
+in a subshell which exits immediately, you can NOT use !cd to navigate
+the filesystem.
+
+IPython provides its own builtin ``%cd`` magic command to move in the
+filesystem (the % is not required with automagic on). It also maintains
+a list of visited directories (use ``%dhist`` to see it) and allows direct
+switching to any of them. Type ``cd?`` for more details.
+
+``%pushd``, ``%popd`` and ``%dirs`` are provided for directory stack handling.
+
+
+Prompt customization
+====================
+
+See :ref:`custom_prompts`.
+
+
+.. _string_lists:
+
+String lists
+============
+
+String lists (:any:`IPython.utils.text.SList`) are handy way to process output
+from system commands. They are produced by ``var = !cmd`` syntax.
+
+First, we acquire the output of 'ls -l'::
+
+    [Q:doc/examples]|2> lines = !ls -l
+     ==
+    ['total 23',
+     '-rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py',
+     '-rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py',
+     '-rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py',
+     '-rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py',
+     '-rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py',
+     '-rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py',
+     '-rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc']
+
+Now, let's take a look at the contents of 'lines' (the first number is
+the list element number)::
+
+    [Q:doc/examples]|3> lines
+                    <3> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
+
+    0: total 23
+    1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
+    2: -rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py
+    3: -rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py
+    4: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
+    5: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
+    6: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
+    7: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc
+
+Now, let's filter out the 'embed' lines::
+
+    [Q:doc/examples]|4> l2 = lines.grep('embed',prune=1)
+    [Q:doc/examples]|5> l2
+                    <5> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
+
+    0: total 23
+    1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
+    2: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
+    3: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
+    4: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
+    5: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc
+
+Now, we want strings having just file names and permissions::
+
+    [Q:doc/examples]|6> l2.fields(8,0)
+                    <6> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
+
+    0: total
+    1: example-demo.py -rw-rw-rw-
+    2: example-gnuplot.py -rwxrwxrwx
+    3: extension.py -rwxrwxrwx
+    4: seteditor.py -rwxrwxrwx
+    5: seteditor.pyc -rwxrwxrwx
+
+Note how the line with 'total' does not raise IndexError.
+
+If you want to split these (yielding lists), call fields() without
+arguments::
+
+    [Q:doc/examples]|7> _.fields()
+                    <7>
+    [['total'],
+     ['example-demo.py', '-rw-rw-rw-'],
+     ['example-gnuplot.py', '-rwxrwxrwx'],
+     ['extension.py', '-rwxrwxrwx'],
+     ['seteditor.py', '-rwxrwxrwx'],
+     ['seteditor.pyc', '-rwxrwxrwx']]
+
+If you want to pass these separated with spaces to a command (typical
+for lists if files), use the .s property::
+
+
+    [Q:doc/examples]|13> files = l2.fields(8).s
+    [Q:doc/examples]|14> files
+                    <14> 'example-demo.py example-gnuplot.py extension.py seteditor.py seteditor.pyc'
+    [Q:doc/examples]|15> ls $files
+    example-demo.py  example-gnuplot.py  extension.py  seteditor.py  seteditor.pyc
+
+SLists are inherited from normal Python lists, so every list method is
+available::
+
+    [Q:doc/examples]|21> lines.append('hey')
+
+
+Real world example: remove all files outside version control
+------------------------------------------------------------
+
+First, capture output of "hg status"::
+
+    [Q:/ipython]|28> out = !hg status
+     ==
+    ['M IPython\\extensions\\ipy_kitcfg.py',
+     'M IPython\\extensions\\ipy_rehashdir.py',
+    ...
+     '? build\\lib\\IPython\\Debugger.py',
+     '? build\\lib\\IPython\\extensions\\InterpreterExec.py',
+     '? build\\lib\\IPython\\extensions\\InterpreterPasteInput.py',
+    ...
+
+(lines starting with ? are not under version control).
+
+::
+
+    [Q:/ipython]|35> junk = out.grep(r'^\?').fields(1)
+    [Q:/ipython]|36> junk
+                <36> SList (.p, .n, .l, .s, .grep(), .fields() availab
+    ...
+    10: build\bdist.win32\winexe\temp\_ctypes.py
+    11: build\bdist.win32\winexe\temp\_hashlib.py
+    12: build\bdist.win32\winexe\temp\_socket.py
+
+Now we can just remove these files by doing 'rm $junk.s'.
+
+The .n, .s, .p properties
+-------------------------
+
+Properties of :py:class:`SList <IPython.utils.text.SList>` wrapper
+provide a convenient ways to use contained text in different formats:
+
+* ``.n`` returns (original) string with lines separated by a newline
+* ``.s`` returns string with lines separated by single space (for
+  convenient passing to system commands)
+* ``.p`` returns list of "path" objects from detected file names
+
+.. error::
+
+   You went too far scroll back up. You most likely want to use
+   `Xonsh <https://xon.sh/>`__ instead of this.
+
diff --git a/docs/source/interactive/shell.txt b/docs/source/interactive/shell.txt
deleted file mode 100644
index 71d39f91dbc..00000000000
--- a/docs/source/interactive/shell.txt
+++ /dev/null
@@ -1,293 +0,0 @@
-.. _ipython_as_shell:
-
-=========================
-IPython as a system shell
-=========================
-
-.. warning::
-
-    As of the 0.11 version of IPython, some of the features and APIs
-    described in this section have been deprecated or are broken.  Our plan
-    is to continue to support these features, but they need to be updated
-    to take advantage of recent API changes.  Furthermore, this section
-    of the documentation need to be updated to reflect all of these changes.
-
-Overview
-========
-
-The 'sh' profile optimizes IPython for system shell usage. Apart from
-certain job control functionality that is present in unix (ctrl+z does
-"suspend"), the sh profile should provide you with most of the
-functionality you use daily in system shell, and more. Invoke IPython
-in 'sh' profile by doing 'ipython -p sh', or (in win32) by launching
-the "pysh" shortcut in start menu.
-
-If you want to use the features of sh profile as your defaults (which
-might be a good idea if you use other profiles a lot of the time but
-still want the convenience of sh profile), add ``import ipy_profile_sh``
-to your $IPYTHON_DIR/ipy_user_conf.py.
-
-The 'sh' profile is different from the default profile in that:
-
- * Prompt shows the current directory
- * Spacing between prompts and input is more compact (no padding with
-   empty lines). The startup banner is more compact as well.
- * System commands are directly available (in alias table) without
-   requesting %rehashx - however, if you install new programs along
-   your PATH, you might want to run %rehashx to update the persistent
-   alias table
- * Macros are stored in raw format by default. That is, instead of
-   '_ip.system("cat foo"), the macro will contain text 'cat foo')
- * Autocall is in full mode
- * Calling "up" does "cd .."
-
-The 'sh' profile is different from the now-obsolete (and unavailable)
-'pysh' profile in that:
-
- * '$$var = command' and '$var = command' syntax is not supported
- * anymore. Use 'var = !command' instead (incidentally, this is
- * available in all IPython profiles). Note that !!command *will*
- * work.
-
-Aliases
-=======
-
-All of your $PATH has been loaded as IPython aliases, so you should be
-able to type any normal system command and have it executed. See
-%alias?  and %unalias? for details on the alias facilities. See also
-%rehashx? for details on the mechanism used to load $PATH.
-
-
-Directory management
-====================
-
-Since each command passed by ipython to the underlying system is executed
-in a subshell which exits immediately, you can NOT use !cd to navigate
-the filesystem.
-
-IPython provides its own builtin '%cd' magic command to move in the
-filesystem (the % is not required with automagic on). It also maintains
-a list of visited directories (use %dhist to see it) and allows direct
-switching to any of them. Type 'cd?' for more details.
-
-%pushd, %popd and %dirs are provided for directory stack handling.
-
-
-Enabled extensions
-==================
-
-Some extensions, listed below, are enabled as default in this profile.
-
-envpersist
-----------
-
-%env can be used to "remember" environment variable manipulations. Examples::
-
-	%env - Show all environment variables
-	%env VISUAL=jed  - set VISUAL to jed
-	%env PATH+=;/foo - append ;foo to PATH
-	%env PATH+=;/bar - also append ;bar to PATH
-	%env PATH-=/wbin; - prepend /wbin; to PATH
-	%env -d VISUAL   - forget VISUAL persistent val
-	%env -p          - print all persistent env modifications
-
-ipy_which
----------
-
-%which magic command. Like 'which' in unix, but knows about ipython aliases.
-
-Example::
-
- [C:/ipython]|14> %which st
- st -> start .
- [C:/ipython]|15> %which d
- d -> dir /w /og /on
- [C:/ipython]|16> %which cp
- cp -> cp
-   == c:\bin\cp.exe
- c:\bin\cp.exe
-
-ipy_app_completers
-------------------
-
-Custom tab completers for some apps like svn, hg, bzr, apt-get. Try 'apt-get install <TAB>' in debian/ubuntu.
-
-ipy_rehashdir
--------------
-
-Allows you to add system command aliases for commands that are not along your path. Let's say that you just installed Putty and want to be able to invoke it without adding it to path, you can create the alias for it with rehashdir::
-
- [~]|22> cd c:/opt/PuTTY/
- [c:opt/PuTTY]|23> rehashdir .
-              <23> ['pageant', 'plink', 'pscp', 'psftp', 'putty', 'puttygen', 'unins000']
-
-Now, you can execute any of those commams directly::
-
- [c:opt/PuTTY]|24> cd
- [~]|25> putty
-
-(the putty window opens).
-
-If you want to store the alias so that it will always be available, do '%store putty'. If you want to %store all these aliases persistently, just do it in a for loop::
-
- [~]|27> for a in _23:
-    |..>     %store $a
-    |..>
-    |..>
- Alias stored: pageant (0, 'c:\\opt\\PuTTY\\pageant.exe')
- Alias stored: plink (0, 'c:\\opt\\PuTTY\\plink.exe')
- Alias stored: pscp (0, 'c:\\opt\\PuTTY\\pscp.exe')
- Alias stored: psftp (0, 'c:\\opt\\PuTTY\\psftp.exe')
- ...
-
-mglob
------
-
-Provide the magic function %mglob, which makes it easier (than the 'find' command) to collect (possibly recursive) file lists. Examples::
-
- [c:/ipython]|9> mglob *.py
- [c:/ipython]|10> mglob *.py rec:*.txt
- [c:/ipython]|19> workfiles = %mglob !.svn/ !.hg/ !*_Data/ !*.bak rec:.
-
-Note that the first 2 calls will put the file list in result history (_, _9, _10), and the last one will assign it to 'workfiles'.
-
-
-Prompt customization
-====================
-
-The sh profile uses the following prompt configurations::
-
-    o.prompt_in1= r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#>'
-    o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green>'
-
-You can change the prompt configuration to your liking by editing
-ipy_user_conf.py.  
-
-String lists
-============
-
-String lists (IPython.utils.text.SList) are handy way to process output
-from system commands. They are produced by ``var = !cmd`` syntax.
-
-First, we acquire the output of 'ls -l'::
-
-    [Q:doc/examples]|2> lines = !ls -l
-     ==
-    ['total 23',
-     '-rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py',
-     '-rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py',
-     '-rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py',
-     '-rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py',
-     '-rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py',
-     '-rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py',
-     '-rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc']
-
-Now, let's take a look at the contents of 'lines' (the first number is
-the list element number)::
-
-    [Q:doc/examples]|3> lines
-                    <3> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
-
-    0: total 23
-    1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
-    2: -rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py
-    3: -rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py
-    4: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
-    5: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
-    6: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
-    7: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc
-
-Now, let's filter out the 'embed' lines::
-
-    [Q:doc/examples]|4> l2 = lines.grep('embed',prune=1)
-    [Q:doc/examples]|5> l2
-                    <5> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
-
-    0: total 23
-    1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
-    2: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
-    3: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
-    4: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
-    5: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc
-
-Now, we want strings having just file names and permissions::
-
-    [Q:doc/examples]|6> l2.fields(8,0)
-                    <6> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
-
-    0: total
-    1: example-demo.py -rw-rw-rw-
-    2: example-gnuplot.py -rwxrwxrwx
-    3: extension.py -rwxrwxrwx
-    4: seteditor.py -rwxrwxrwx
-    5: seteditor.pyc -rwxrwxrwx
-
-Note how the line with 'total' does not raise IndexError.
-
-If you want to split these (yielding lists), call fields() without
-arguments::
-
-    [Q:doc/examples]|7> _.fields()
-                    <7>
-    [['total'],
-     ['example-demo.py', '-rw-rw-rw-'],
-     ['example-gnuplot.py', '-rwxrwxrwx'],
-     ['extension.py', '-rwxrwxrwx'],
-     ['seteditor.py', '-rwxrwxrwx'],
-     ['seteditor.pyc', '-rwxrwxrwx']]
-
-If you want to pass these separated with spaces to a command (typical
-for lists if files), use the .s property::
-
-
-    [Q:doc/examples]|13> files = l2.fields(8).s
-    [Q:doc/examples]|14> files
-                    <14> 'example-demo.py example-gnuplot.py extension.py seteditor.py seteditor.pyc'
-    [Q:doc/examples]|15> ls $files
-    example-demo.py  example-gnuplot.py  extension.py  seteditor.py  seteditor.pyc
-
-SLists are inherited from normal python lists, so every list method is
-available::
-
-    [Q:doc/examples]|21> lines.append('hey')
-
-
-Real world example: remove all files outside version control
-============================================================
-
-First, capture output of "hg status"::
-
-    [Q:/ipython]|28> out = !hg status
-     ==
-    ['M IPython\\extensions\\ipy_kitcfg.py',
-     'M IPython\\extensions\\ipy_rehashdir.py',
-    ...
-     '? build\\lib\\IPython\\Debugger.py',
-     '? build\\lib\\IPython\\extensions\\InterpreterExec.py',
-     '? build\\lib\\IPython\\extensions\\InterpreterPasteInput.py',
-    ...
-
-(lines starting with ? are not under version control).
-
-::
-
-    [Q:/ipython]|35> junk = out.grep(r'^\?').fields(1)
-    [Q:/ipython]|36> junk
-                <36> SList (.p, .n, .l, .s, .grep(), .fields() availab
-    ...
-    10: build\bdist.win32\winexe\temp\_ctypes.py
-    11: build\bdist.win32\winexe\temp\_hashlib.py
-    12: build\bdist.win32\winexe\temp\_socket.py
-
-Now we can just remove these files by doing 'rm $junk.s'. 
-
-The .s, .n, .p properties
-=========================
-
-The '.s' property returns one string where lines are separated by
-single space (for convenient passing to system commands). The '.n'
-property return one string where the lines are separated by '\n'
-(i.e. the original output of the function). If the items in string
-list are file names, '.p' can be used to get a list of "path" objects
-for convenient file manipulation.
-
diff --git a/docs/source/interactive/tips.rst b/docs/source/interactive/tips.rst
new file mode 100644
index 00000000000..33436cea24b
--- /dev/null
+++ b/docs/source/interactive/tips.rst
@@ -0,0 +1,102 @@
+.. _tips:
+
+=====================
+IPython Tips & Tricks
+=====================
+
+The `IPython cookbook
+<https://github.com/ipython/ipython/wiki?path=Cookbook>`_ details more things
+you can do with IPython.
+
+.. This is not in the current version:
+
+
+Embed IPython in your programs
+------------------------------
+
+A few lines of code are enough to load a complete IPython inside your own
+programs, giving you the ability to work with your data interactively after
+automatic processing has been completed. See :ref:`the embedding section <embedding>`.
+
+Run doctests
+------------
+
+Run your doctests from within IPython for development and debugging. The
+special ``%doctest_mode`` command toggles a mode where the prompt, output and
+exceptions display matches as closely as possible that of the default Python
+interpreter. In addition, this mode allows you to directly paste in code that
+contains leading '>>>' prompts, even if they have extra leading whitespace
+(as is common in doctest files). This combined with the ``%hist -t`` call to
+see your translated history allows for an easy doctest workflow, where you
+can go from doctest to interactive execution to pasting into valid Python code
+as needed.
+
+Use IPython to present interactive demos
+----------------------------------------
+
+Use the :class:`IPython.lib.demo.Demo` class to load any Python script as an interactive
+demo. With a minimal amount of simple markup, you can control the execution of
+the script, stopping as needed. See :ref:`here <interactive_demos>` for more.
+
+Suppress output
+---------------
+
+Put a ';' at the end of a line to suppress the printing of output. This is
+useful when doing calculations which generate long output you are not
+interested in seeing. It also keeps the object out of the output cache, so if
+you're working with large temporary objects, they'll be released from memory sooner.
+
+Lightweight 'version control'
+-----------------------------
+
+When you call ``%edit`` with no arguments, IPython opens an empty editor
+with a temporary file, and it returns the contents of your editing
+session as a string variable. Thanks to IPython's output caching
+mechanism, this is automatically stored::
+
+    In [1]: %edit
+
+    IPython will make a temporary file named: /tmp/ipython_edit_yR-HCN.py
+
+    Editing... done. Executing edited code...
+
+    hello - this is a temporary file
+
+    Out[1]: "print('hello - this is a temporary file')\n"
+
+Now, if you call ``%edit -p``, IPython tries to open an editor with the
+same data as the last time you used %edit. So if you haven't used %edit
+in the meantime, this same contents will reopen; however, it will be
+done in a new file. This means that if you make changes and you later
+want to find an old version, you can always retrieve it by using its
+output number, via '%edit _NN', where NN is the number of the output
+prompt.
+
+Continuing with the example above, this should illustrate this idea::
+
+    In [2]: edit -p
+
+    IPython will make a temporary file named: /tmp/ipython_edit_nA09Qk.py
+
+    Editing... done. Executing edited code...
+
+    hello - now I made some changes
+
+    Out[2]: "print('hello - now I made some changes')\n"
+
+    In [3]: edit _1
+
+    IPython will make a temporary file named: /tmp/ipython_edit_gy6-zD.py
+
+    Editing... done. Executing edited code...
+
+    hello - this is a temporary file
+
+    IPython version control at work :)
+
+    Out[3]: "print('hello - this is a temporary file')\nprint('IPython version control at work :)')\n"
+
+
+This section was written after a contribution by Alexander Belchenko on
+the IPython user list.
+
diff --git a/docs/source/interactive/tutorial.rst b/docs/source/interactive/tutorial.rst
new file mode 100644
index 00000000000..9bcbb5be558
--- /dev/null
+++ b/docs/source/interactive/tutorial.rst
@@ -0,0 +1,281 @@
+.. _tutorial:
+
+======================
+Introducing IPython
+======================
+
+You don't need to know anything beyond Python to start using IPython – just type
+commands as you would at the standard Python prompt. But IPython can do much
+more than the standard prompt. Some key features are described here. For more
+information, check the :ref:`tips page <tips>`, or look at examples in the
+`IPython cookbook <https://github.com/ipython/ipython/wiki/Cookbook%3A-Index>`_.
+
+If you haven't done that yet see :ref:`how to install ipython <install>`.
+
+If you've never used Python before, you might want to look at the official
+:external+python:doc:`Python tutorial <tutorial/index>`.
+
+Start IPython by issuing the ``ipython`` command from your shell, you should be
+greeted by the following::
+
+    Python 3.12.0
+    Type 'copyright', 'credits' or 'license' for more information
+    IPython 9.0.0 -- An enhanced Interactive Python. Type '?' for help.
+
+    In [1]:
+
+
+Unlike the Python REPL, you will see that the input prompt is ``In [N]:``
+instead of ``>>>``. The number ``N`` in the prompt will be used later in this
+tutorial but should usually not impact the computation.
+
+You should be able to type single line expressions and press enter to evaluate
+them. If an expression is incomplete, IPython will automatically detect this and
+add a new line when you press :kbd:`Enter` instead of executing right away.
+
+Feel free to explore multi-line text input. Unlike many other REPLs, with
+IPython you can use the up and down arrow keys when editing multi-line
+code blocks.
+
+Here is an example of a longer interaction with the IPython REPL,
+which we often refer to as an IPython *session* ::
+
+    In [1]: print('Hello IPython')
+    Hello IPython
+
+    In [2]: 21 * 2
+    Out[2]: 42
+
+    In [3]: def say_hello(name):
+       ...:     print('Hello {name}'.format(name=name))
+       ...:
+
+We won't get into details right now, but you may notice a few differences to
+the standard Python REPL. First, your code should be syntax-highlighted as you
+type. Second, you will see that some results will have an ``Out[N]:`` prompt,
+while some other do not. We'll come to this later.
+
+Depending on the exact command you are typing you might realize that sometimes
+:kbd:`Enter` will add a new line, and sometimes it will execute the current
+statement. IPython tries to guess what you are doing, so most of the time you
+should not have to care. Though if by any chance IPython does not do the right
+thing you can force execution of the current code block by pressing in sequence
+:kbd:`Esc` and :kbd:`Enter`. You can also force the insertion of a new line at
+the position of the cursor by using :kbd:`Ctrl-o`.
+
+The four most helpful commands
+==============================
+
+The four most helpful commands, as well as their brief description, is shown
+to you in a banner, every time you start IPython:
+
+==========    =========================================================
+command       description
+==========    =========================================================
+?             Introduction and overview of IPython's features.
+%quickref     Quick reference.
+help          Python's own help system.
+object?       Details about 'object', use 'object??' for extra details.
+==========    =========================================================
+
+Tab completion
+==============
+
+Tab completion, especially for attributes, is a convenient way to explore the
+structure of any object you're dealing with. Simply type ``object_name.<TAB>``
+to view the object's attributes. Besides Python objects and keywords, tab
+completion also works on file and directory names.
+
+If ``jedi`` is installed, IPython will try to pull completions from Jedi as
+well. This allows to not only inspect currently existing objects, but also to
+infer completion statically without executing code. There is nothing particular
+needed to get this to work, simply use tab completion on more complex
+expressions like the following::
+
+    >>> data = ['Number of users', 123456]
+    ... data[0].<tab>
+
+IPython and Jedi will be able to infer that ``data[0]`` is actually a string
+and should show relevant completions like ``upper()``, ``lower()`` and other
+string methods. You can use the :kbd:`Tab` key to cycle through completions,
+and while a completion is highlighted, its type will be shown as well.
+When the type of the completion is a function, the completer will also show the
+signature of the function when highlighted.
+
+Exploring your objects
+======================
+
+Typing ``object_name?`` will print all sorts of details about any object,
+including docstrings, function definition lines (for call arguments) and
+constructor details for classes. To get specific information on an object, you
+can use the magic commands ``%pdoc``, ``%pdef``, ``%psource`` and ``%pfile``
+
+.. _magics_explained:
+
+Magic functions
+===============
+
+IPython has a set of predefined 'magic functions' that you can call with a
+command line style syntax.  There are two kinds of magics, line-oriented and
+cell-oriented.  **Line magics** are prefixed with the ``%`` character and work
+much like OS command-line calls: they get as an argument the rest of the line,
+where arguments are passed without parentheses or quotes. **Line magics** can
+return results and can be used in the right hand side of an assignment.  **Cell
+magics** are prefixed with a double ``%%``, and they are functions that get as
+an argument not only the rest of the line, but also the lines below it in a
+separate argument.
+
+Magics are useful as convenient functions where Python syntax is not the most
+natural one, or when one want to embed invalid python syntax in their work flow. 
+
+The following examples show how to call the built-in :magic:`timeit` magic, both
+in line and cell mode::
+
+      In [1]: %timeit range(1000)
+      179 ns ± 2.66 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
+
+      In [2]: %%timeit x = range(10000)
+      ...: max(x)
+      ...: 
+      264 µs ± 1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+
+The built-in magics include:
+
+- Functions that work with code: :magic:`run`, :magic:`edit`, :magic:`save`,
+  :magic:`macro`, :magic:`recall`, etc.
+
+- Functions which affect the shell: :magic:`colors`, :magic:`xmode`,
+  :magic:`automagic`, etc.
+
+- Other functions such as :magic:`reset`, :magic:`timeit`,
+  :cellmagic:`writefile`, :magic:`load`, or :magic:`paste`.
+
+You can always call magics using the ``%`` prefix, and if you're calling a line
+magic on a line by itself, as long as the identifier is not defined in your
+namespace, you can omit even that::
+
+    run thescript.py
+
+You can toggle this behavior by running the :magic:`automagic` magic.  Cell
+magics must always have the ``%%`` prefix.
+
+A more detailed explanation of the magic system can be obtained by calling
+``%magic``, and for more details on any magic function, call ``%somemagic?`` to
+read its docstring. To see all the available magic functions, call
+``%lsmagic``.
+
+.. seealso::
+
+    The :ref:`magic` section of the documentation goes more in depth into how
+    the magics works and how to define your own, and :doc:`magics` for a list of
+    built-in magics.
+
+    `Cell magics`_ example notebook
+
+Running and Editing
+-------------------
+
+The :magic:`run` magic command allows you to run any python script and load all
+of its data directly into the interactive namespace. Since the file is re-read
+from disk each time, changes you make to it are reflected immediately (unlike
+imported modules, which have to be specifically reloaded). IPython also includes
+:ref:`dreload <dreload>`, a recursive reload function.
+
+``%run`` has special flags for timing the execution of your scripts (-t), or
+for running them under the control of either Python's pdb debugger (-d) or
+profiler (-p).
+
+The :magic:`edit` command gives a reasonable approximation of multi-line editing,
+by invoking your favorite editor on the spot. IPython will execute the
+code you type in there as if it were typed interactively. Note that for
+:magic:`edit` to work, the call to startup your editor has to be a blocking
+call. In a GUI environment, your editor likely will have such an option.
+
+Debugging
+---------
+
+After an exception occurs, you can call :magic:`debug` to jump into the Python
+debugger (pdb) and examine the problem. Alternatively, if you call :magic:`pdb`,
+IPython will automatically start the debugger on any uncaught exception. You can
+print variables, see code, execute statements and even walk up and down the call
+stack to track down the true source of the problem. This can be an efficient way
+to develop and debug code, in many cases eliminating the need for print
+statements or external debugging tools.
+
+You can also step through a program from the beginning by calling
+``%run -d theprogram.py``.
+
+History
+=======
+
+IPython stores both the commands you enter, and the results it produces. You
+can easily go through previous commands with the up- and down-arrow keys, or
+access your history in more sophisticated ways.
+
+Input and output history are kept in variables called ``In`` and ``Out``, keyed
+by the prompt numbers, e.g. ``In[4]``. The last three objects in output history
+are also kept in variables named ``_``, ``__`` and ``___``.
+
+You can use the ``%history`` magic function to examine past input and output.
+Input history from previous sessions is saved in a database, and IPython can be
+configured to save output history.
+
+Several other magic functions can use your input history, including ``%edit``, 
+``%rerun``, ``%recall``, ``%macro``, ``%save`` and ``%pastebin``. You can use a
+standard format to refer to lines::
+
+    %pastebin 3 18-20 ~1/1-5
+    
+This will take line 3 and lines 18 to 20 from the current session, and lines
+1-5 from the previous session.
+
+System shell commands
+=====================
+
+To run any command at the system shell, simply prefix it with ``!``, e.g.::
+
+    !ping www.bbc.co.uk
+    
+You can capture the output into a Python list, e.g.: ``files = !ls``. To pass
+the values of Python variables or expressions to system commands, prefix them
+with $: ``!grep -rF $pattern ipython/*`` or wrap in `{braces}`. See :ref:`our
+shell section <system_shell_access>` for more details.
+
+Define your own system aliases
+------------------------------
+
+It's convenient to have aliases to the system commands you use most often. This
+allows you to work seamlessly from inside IPython with the same commands you are
+used to in your system shell. IPython comes with some pre-defined aliases and a
+complete system for changing directories, both via a stack (see :magic:`pushd`,
+:magic:`popd` and :magic:`dhist`) and via direct :magic:`cd`. The latter keeps a
+history of visited directories and allows you to go to any previously visited
+one.
+
+
+Configuration
+=============
+
+Much of IPython can be tweaked through :doc:`configuration </config/intro>`.
+To get started, use the command ``ipython profile create`` to produce the
+default config files. These will be placed in
+:file:`~/.ipython/profile_default`, and contain comments explaining
+what the various options do.
+
+Profiles allow you to use IPython for different tasks, keeping separate config
+files and history for each one. More details in :ref:`the profiles section
+<profiles>`.
+
+.. _startup_files:
+
+Startup Files
+-------------
+
+If you want some code to be run at the beginning of every IPython session, the
+easiest way is to add Python (.py) or IPython (.ipy) scripts to your
+:file:`profile_default/startup/` directory. Files here will be executed as soon
+as the IPython shell is constructed, before any other code or scripts you have
+specified. The files will be run in order of their names, so you can control the
+ordering with prefixes, like ``10-myimports.py``.
+
+.. include:: ../links.txt
diff --git a/docs/source/interactive/tutorial.txt b/docs/source/interactive/tutorial.txt
deleted file mode 100644
index aa84043bdb2..00000000000
--- a/docs/source/interactive/tutorial.txt
+++ /dev/null
@@ -1,336 +0,0 @@
-.. _tutorial:
-
-======================
-Quick IPython tutorial
-======================
-
-.. warning::
-
-    As of the 0.11 version of IPython, some of the features and APIs
-    described in this section have been deprecated or are broken.  Our plan
-    is to continue to support these features, but they need to be updated
-    to take advantage of recent API changes.  Furthermore, this section
-    of the documentation need to be updated to reflect all of these changes.
-
-IPython can be used as an improved replacement for the Python prompt,
-and for that you don't really need to read any more of this manual. But
-in this section we'll try to summarize a few tips on how to make the
-most effective use of it for everyday Python development, highlighting
-things you might miss in the rest of the manual (which is getting long).
-We'll give references to parts in the manual which provide more detail
-when appropriate.
-
-The following article by Jeremy Jones provides an introductory tutorial
-about IPython: http://www.onlamp.com/pub/a/python/2005/01/27/ipython.html
-
-Highlights
-==========
-
-Tab completion
---------------
-
-TAB-completion, especially for attributes, is a convenient way to explore the
-structure of any object you're dealing with. Simply type object_name.<TAB> and
-a list of the object's attributes will be printed (see :ref:`the readline
-section <readline>` for more). Tab completion also works on file and directory
-names, which combined with IPython's alias system allows you to do from within
-IPython many of the things you normally would need the system shell for.
-
-Explore your objects
---------------------
-
-Typing object_name? will print all sorts of details about any object,
-including docstrings, function definition lines (for call arguments) and
-constructor details for classes. The magic commands %pdoc, %pdef, %psource
-and %pfile will respectively print the docstring, function definition line,
-full source code and the complete file for any object (when they can be
-found). If automagic is on (it is by default), you don't need to type the '%'
-explicitly. See :ref:`this section <dynamic_object_info>` for more.
-
-The `%run` magic command
-------------------------
-
-The %run magic command allows you to run any python script and load all of its
-data directly into the interactive namespace. Since the file is re-read from
-disk each time, changes you make to it are reflected immediately (in contrast
-to the behavior of import). I rarely use import for code I am testing, relying
-on %run instead. See :ref:`this section <magic>` for more on this and other
-magic commands, or type the name of any magic command and ? to get details on
-it. See also :ref:`this section <dreload>` for a recursive reload command. %run
-also has special flags for timing the execution of your scripts (-t) and for
-executing them under the control of either Python's pdb debugger (-d) or
-profiler (-p). With all of these, %run can be used as the main tool for
-efficient interactive development of code which you write in your editor of
-choice.
-
-Debug a Python script
----------------------
-
-Use the Python debugger, pdb. The %pdb command allows you to toggle on and off
-the automatic invocation of an IPython-enhanced pdb debugger (with coloring,
-tab completion and more) at any uncaught exception. The advantage of this is
-that pdb starts inside the function where the exception occurred, with all data
-still available. You can print variables, see code, execute statements and even
-walk up and down the call stack to track down the true source of the problem
-(which often is many layers in the stack above where the exception gets
-triggered). Running programs with %run and pdb active can be an efficient to
-develop and debug code, in many cases eliminating the need for print statements
-or external debugging tools. I often simply put a 1/0 in a place where I want
-to take a look so that pdb gets called, quickly view whatever variables I need
-to or test various pieces of code and then remove the 1/0. Note also that '%run
--d' activates pdb and automatically sets initial breakpoints for you to step
-through your code, watch variables, etc.  The :ref:`output caching section
-<output_caching>` has more details.
-
-Use the output cache
---------------------
-
-All output results are automatically stored in a global dictionary named Out
-and variables named _1, _2, etc. alias them. For example, the result of input
-line 4 is available either as Out[4] or as _4. Additionally, three variables
-named _, __ and ___ are always kept updated with the for the last three
-results. This allows you to recall any previous result and further use it for
-new calculations. See :ref:`the output caching section <output_caching>` for
-more.
-
-Suppress output
----------------
-
-Put a ';' at the end of a line to suppress the printing of output. This is
-useful when doing calculations which generate long output you are not
-interested in seeing. The _* variables and the Out[] list do get updated with
-the contents of the output, even if it is not printed. You can thus still
-access the generated results this way for further processing.
-
-Input cache
------------
-
-A similar system exists for caching input. All input is stored in a global
-list called In , so you can re-execute lines 22 through 28 plus line 34 by
-typing 'exec In[22:29]+In[34]' (using Python slicing notation). If you need
-to execute the same set of lines often, you can assign them to a macro with
-the %macro function. See :ref:`here <input_caching>` for more.
-
-Use your input history
-----------------------
-
-The %hist command can show you all previous input, without line numbers if
-desired (option -n) so you can directly copy and paste code either back in
-IPython or in a text editor. You can also save all your history by turning on
-logging via %logstart; these logs can later be either reloaded as IPython
-sessions or used as code for your programs.
-
-In particular, note taht the %rep magic function can repeat a command or get a
-command to the input line for further editing::
-
-        $ l = ["hei", "vaan"]       
-        $ "".join(l)        
-        ==> heivaan        
-        $ %rep        
-        $ heivaan_ <== cursor blinking    
-   
-For more details, type ``%rep?`` as usual.
-	
-Define your own system aliases
-------------------------------
-
-Even though IPython gives you access to your system shell via the ! prefix,
-it is convenient to have aliases to the system commands you use most often.
-This allows you to work seamlessly from inside IPython with the same commands
-you are used to in your system shell. IPython comes with some pre-defined
-aliases and a complete system for changing directories, both via a stack (see
-%pushd, %popd and %dhist) and via direct %cd. The latter keeps a history of
-visited directories and allows you to go to any previously visited one.
-
-Call system shell commands
---------------------------
-
-Use Python to manipulate the results of system commands. The '!!' special
-syntax, and the %sc and %sx magic commands allow you to capture system output
-into Python variables.
-
-Use Python variables when calling the shell
--------------------------------------------
-
-Expand python variables when calling the shell (either via '!' and '!!' or via
-aliases) by prepending a $ in front of them. You can also expand complete
-python expressions. See :ref:`our shell section <system_shell_access>` for
-more details.
-
-Use profiles
-------------
-
-Use profiles to maintain different configurations (modules to load, function
-definitions, option settings) for particular tasks. You can then have
-customized versions of IPython for specific purposes. :ref:`This section
-<profiles>` has more details.
-
-
-Embed IPython in your programs
-------------------------------
-
-A few lines of code are enough to load a complete IPython inside your own
-programs, giving you the ability to work with your data interactively after
-automatic processing has been completed. See :ref:`here <embedding>` for more.
-
-Use the Python profiler
------------------------
-
-When dealing with performance issues, the %run command with a -p option
-allows you to run complete programs under the control of the Python profiler.
-The %prun command does a similar job for single Python expressions (like
-function calls).
-
-Use IPython to present interactive demos
-----------------------------------------
-
-Use the IPython.demo.Demo class to load any Python script as an interactive
-demo. With a minimal amount of simple markup, you can control the execution of
-the script, stopping as needed. See :ref:`here <interactive_demos>` for more.
-
-Run doctests
-------------
-
-Run your doctests from within IPython for development and debugging. The
-special %doctest_mode command toggles a mode where the prompt, output and
-exceptions display matches as closely as possible that of the default Python
-interpreter. In addition, this mode allows you to directly paste in code that
-contains leading '>>>' prompts, even if they have extra leading whitespace
-(as is common in doctest files). This combined with the '%history -tn' call
-to see your translated history (with these extra prompts removed and no line
-numbers) allows for an easy doctest workflow, where you can go from doctest
-to interactive execution to pasting into valid Python code as needed.
-
-Source code handling tips
-=========================
-
-IPython is a line-oriented program, without full control of the
-terminal. Therefore, it doesn't support true multiline editing. However,
-it has a number of useful tools to help you in dealing effectively with
-more complex editing.
-
-The %edit command gives a reasonable approximation of multiline editing,
-by invoking your favorite editor on the spot. IPython will execute the
-code you type in there as if it were typed interactively. Type %edit?
-for the full details on the edit command.
-
-If you have typed various commands during a session, which you'd like to
-reuse, IPython provides you with a number of tools. Start by using %hist
-to see your input history, so you can see the line numbers of all input.
-Let us say that you'd like to reuse lines 10 through 20, plus lines 24
-and 28. All the commands below can operate on these with the syntax::
-
-    %command 10-20 24 28 
-
-where the command given can be:
-
-    * %macro <macroname>: this stores the lines into a variable which,
-      when called at the prompt, re-executes the input. Macros can be
-      edited later using '%edit macroname', and they can be stored
-      persistently across sessions with '%store macroname' (the storage
-      system is per-profile). The combination of quick macros,
-      persistent storage and editing, allows you to easily refine
-      quick-and-dirty interactive input into permanent utilities, always
-      available both in IPython and as files for general reuse.
-    * %edit: this will open a text editor with those lines pre-loaded
-      for further modification. It will then execute the resulting
-      file's contents as if you had typed it at the prompt.
-    * %save <filename>: this saves the lines directly to a named file on
-      disk.
-
-While %macro saves input lines into memory for interactive re-execution,
-sometimes you'd like to save your input directly to a file. The %save
-magic does this: its input sytnax is the same as %macro, but it saves
-your input directly to a Python file. Note that the %logstart command
-also saves input, but it logs all input to disk (though you can
-temporarily suspend it and reactivate it with %logoff/%logon); %save
-allows you to select which lines of input you need to save.
-
-
-Lightweight 'version control'
-=============================
-
-When you call %edit with no arguments, IPython opens an empty editor
-with a temporary file, and it returns the contents of your editing
-session as a string variable. Thanks to IPython's output caching
-mechanism, this is automatically stored::
-
-    In [1]: %edit
-
-    IPython will make a temporary file named: /tmp/ipython_edit_yR-HCN.py
-
-    Editing... done. Executing edited code...
-
-    hello - this is a temporary file
-
-    Out[1]: "print 'hello - this is a temporary file'\n"
-
-Now, if you call '%edit -p', IPython tries to open an editor with the
-same data as the last time you used %edit. So if you haven't used %edit
-in the meantime, this same contents will reopen; however, it will be
-done in a new file. This means that if you make changes and you later
-want to find an old version, you can always retrieve it by using its
-output number, via '%edit _NN', where NN is the number of the output
-prompt.
-
-Continuing with the example above, this should illustrate this idea::
-
-    In [2]: edit -p
-
-    IPython will make a temporary file named: /tmp/ipython_edit_nA09Qk.py
-
-    Editing... done. Executing edited code...
-
-    hello - now I made some changes
-
-    Out[2]: "print 'hello - now I made some changes'\n"
-
-    In [3]: edit _1
-
-    IPython will make a temporary file named: /tmp/ipython_edit_gy6-zD.py
-
-    Editing... done. Executing edited code...
-
-    hello - this is a temporary file
-
-    IPython version control at work :)
-
-    Out[3]: "print 'hello - this is a temporary file'\nprint 'IPython version control at work :)'\n"
-
-
-This section was written after a contribution by Alexander Belchenko on
-the IPython user list.
-
-
-Effective logging
-=================
-
-A very useful suggestion sent in by Robert Kern follows:
-
-I recently happened on a nifty way to keep tidy per-project log files. I
-made a profile for my project (which is called "parkfield")::
-
-    include ipythonrc
-
-    # cancel earlier logfile invocation:
-
-    logfile ''
-
-    execute import time
-
-    execute __cmd = '/Users/kern/research/logfiles/parkfield-%s.log rotate'
-
-    execute __IP.magic_logstart(__cmd % time.strftime('%Y-%m-%d'))
-
-I also added a shell alias for convenience::
-
-    alias parkfield="ipython -pylab -profile parkfield" 
-
-Now I have a nice little directory with everything I ever type in,
-organized by project and date.
-
-Contribute your own: If you have your own favorite tip on using IPython
-efficiently for a certain task (especially things which can't be done in
-the normal Python interpreter), don't hesitate to send it!
-
-
diff --git a/docs/source/links.rst b/docs/source/links.rst
deleted file mode 100644
index ce0b5ab5388..00000000000
--- a/docs/source/links.rst
+++ /dev/null
@@ -1,74 +0,0 @@
-.. This (-*- rst -*-) format file contains commonly used link targets
-   and name substitutions.  It may be included in many files,
-   therefore it should only contain link targets and name
-   substitutions.  Try grepping for "^\.\. _" to find plausible
-   candidates for this list.  
-
-   NOTE: this file must have an extension *opposite* to that of the main reST
-   files in the manuals, so that we can include it with ".. include::"
-   directives, but without triggering warnings from Sphinx for not being listed
-   in any toctree.  Since IPython uses .txt for the main files, this wone will
-   use .rst.
-   
-   NOTE: reST targets are
-   __not_case_sensitive__, so only one target definition is needed for
-   ipython, IPython, etc.
-
-   NOTE: Some of these were taken from the nipy links compendium.
-
-.. Main IPython links
-.. _ipython: http://ipython.scipy.org
-.. _`ipython manual`: http://ipython.scipy.org/doc/manual/html
-.. _ipython_github: http://github.com/ipython/ipython/
-.. _ipython_github_repo: http://github.com/ipython/ipython/
-.. _ipython_downloads: http://ipython.scipy.org/dist
-.. _ipython_pypi: http://pypi.python.org/pypi/ipython
-
-.. _ZeroMQ: http://zeromq.org
-
-.. Documentation tools and related links
-.. _graphviz: http://www.graphviz.org
-.. _Sphinx: http://sphinx.pocoo.org
-.. _`Sphinx reST`: http://sphinx.pocoo.org/rest.html
-.. _sampledoc: http://matplotlib.sourceforge.net/sampledoc
-.. _reST: http://docutils.sourceforge.net/rst.html
-.. _docutils: http://docutils.sourceforge.net
-.. _lyx: http://www.lyx.org
-.. _pep8: http://www.python.org/dev/peps/pep-0008
-.. _numpy_coding_guide: http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines
-
-.. Licenses
-.. _GPL: http://www.gnu.org/licenses/gpl.html
-.. _BSD: http://www.opensource.org/licenses/bsd-license.php
-.. _LGPL: http://www.gnu.org/copyleft/lesser.html
-
-.. Other python projects
-.. _numpy: http://numpy.scipy.org
-.. _scipy: http://www.scipy.org
-.. _scipy_conference: http://conference.scipy.org
-.. _matplotlib: http://matplotlib.sourceforge.net
-.. _pythonxy: http://www.pythonxy.com
-.. _ETS: http://code.enthought.com/projects/tool-suite.php
-.. _EPD: http://www.enthought.com/products/epd.php
-.. _python: http://www.python.org
-.. _mayavi: http://code.enthought.com/projects/mayavi
-.. _sympy: http://code.google.com/p/sympy
-.. _sage: http://sagemath.org
-.. _pydy: http://code.google.com/p/pydy
-.. _vpython: http://vpython.org
-.. _cython: http://cython.org
-.. _software carpentry: http://software-carpentry.org
-
-.. Not so python scientific computing tools
-.. _matlab: http://www.mathworks.com
-.. _VTK: http://vtk.org
-
-.. Other organizations
-.. _enthought: http://www.enthought.com
-.. _kitware: http://www.kitware.com
-.. _netlib: http://netlib.org
-
-.. Other tools and projects
-.. _indefero: http://www.indefero.net
-.. _git: http://git-scm.com
-.. _github: http://github.com
diff --git a/docs/source/links.txt b/docs/source/links.txt
new file mode 100644
index 00000000000..322145c304b
--- /dev/null
+++ b/docs/source/links.txt
@@ -0,0 +1,97 @@
+.. This (-*- rst -*-) format file contains commonly used link targets
+   and name substitutions.  It may be included in many files,
+   therefore it should only contain link targets and name
+   substitutions.  Try grepping for "^\.\. _" to find plausible
+   candidates for this list.  
+
+   NOTE: this file must have an extension *opposite* to that of the main reST
+   files in the manuals, so that we can include it with ".. include::"
+   directives, but without triggering warnings from Sphinx for not being listed
+   in any toctree.  Since IPython uses .txt for the main files, this one will
+   use .rst.
+   
+   NOTE: reST targets are
+   __not_case_sensitive__, so only one target definition is needed for
+   ipython, IPython, etc.
+
+   NOTE: Some of these were taken from the nipy links compendium.
+
+.. Main IPython links
+.. _ipython: https://ipython.org
+.. _`ipython manual`: https://ipython.org/documentation.html
+.. _ipython_github: https://github.com/ipython/ipython/
+.. _nbviewer: https://nbviewer.org
+
+.. _ZeroMQ: https://zeromq.org
+
+.. Documentation tools and related links
+.. _graphviz: https://www.graphviz.org
+.. _Sphinx: https://www.sphinx-doc.org
+.. _`Sphinx reST`: https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html
+.. _sampledoc: https://matplotlib.org/sampledoc
+.. _reST: https://docutils.sourceforge.io/rst.html
+.. _docutils: https://docutils.sourceforge.io
+.. _lyx: https://www.lyx.org
+.. _pep8: https://peps.python.org/pep-0008/
+
+.. Licenses
+.. _GPL: https://www.gnu.org/licenses/gpl.html
+.. _BSD: https://opensource.org/licenses/BSD-3-Clause
+.. _LGPL: https://www.gnu.org/copyleft/lesser.html
+
+.. Other python projects
+.. _numpy: https://numpy.org
+.. _scipy: https://www.scipy.org
+.. _scipy_conference: https://conference.scipy.org
+.. _matplotlib: https://matplotlib.org
+.. _pythonxy: https://python-xy.github.io/
+.. _ETS: https://docs.enthought.com/ets/
+.. _EPD: https://www.enthought.com/products/epd/
+.. _python: https://www.python.org
+.. _mayavi: https://docs.enthought.com/mayavi/mayavi/
+.. _sympy: https://www.sympy.org
+.. _sage: https://www.sagemath.org
+.. _pydy: https://www.pydy.org
+.. _vpython: https://vpython.org
+.. _cython: https://cython.org
+.. _software carpentry: https://software-carpentry.org
+
+.. Not so python scientific computing tools
+.. _matlab: https://www.mathworks.com
+.. _VTK: https://vtk.org
+
+.. Other organizations
+.. _enthought: https://www.enthought.com
+.. _kitware: https://www.kitware.com
+.. _netlib: https://netlib.org
+
+.. Other tools and projects
+.. _indefero: https://www.indefero.net
+.. _git: https://git-scm.com
+.. _github: https://github.com
+.. _Markdown: https://daringfireball.net/projects/markdown/syntax
+
+.. _Running Code in the IPython Notebook: notebook_p1_
+.. _notebook_p1: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Part%25201%2520-%2520Running%2520Code.ipynb
+
+.. _Basic Output: notebook_p2_
+.. _notebook_p2: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Part%202%20-%20Basic%20Output.ipynb
+
+.. _Plotting with Matplotlib: notebook_p3_
+.. _notebook_p3: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Part%203%20-%20Plotting%20with%20Matplotlib.ipynb
+
+.. _Markdown Cells: notebook_p4_
+.. _notebook_p4: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Part%204%20-%20Markdown%20Cells.ipynb
+
+.. _Rich Display System: notebook_p5_
+.. _notebook_p5: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Part%205%20-%20Rich%20Display%20System.ipynb
+
+.. _notebook_custom_display: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Custom%20Display%20Logic.ipynb
+
+.. _Frontend/Kernel Model: notebook_two_proc_
+.. _notebook_two_proc: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Frontend-Kernel%20Model.ipynb
+
+.. _Cell magics: notebook_cell_magics_
+.. _notebook_cell_magics: https://nbviewer.org/urls/raw.github.com/ipython/ipython/1.x/examples/notebooks/Cell%20Magics.ipynb
+
+
diff --git a/docs/source/overview.rst b/docs/source/overview.rst
new file mode 100644
index 00000000000..46c00c45cab
--- /dev/null
+++ b/docs/source/overview.rst
@@ -0,0 +1,252 @@
+.. _overview:
+
+========
+Overview
+========
+
+One of Python's most useful features is its interactive interpreter.
+It allows for very fast testing of ideas without the overhead of
+creating test files as is typical in most programming languages.
+However, the interpreter supplied with the standard Python distribution
+is somewhat limited for extended interactive use.
+
+The goal of IPython is to create a comprehensive environment for
+interactive and exploratory computing.  To support this goal, IPython
+has three main components:
+
+* An enhanced interactive Python shell.
+
+* A decoupled :ref:`two-process communication model <ipythonzmq>`, which
+  allows for multiple clients to connect to a computation kernel, most notably
+  the web-based notebook provided with `Jupyter <https://jupyter.org>`_.
+
+* An architecture for interactive parallel computing now part of the
+  `ipyparallel` package.
+
+All of IPython is open source (released under the revised BSD license).
+
+Enhanced interactive Python shell
+=================================
+
+IPython's interactive shell (:command:`ipython`), has the following goals,
+amongst others:
+
+1. Provide an interactive shell superior to Python's default. IPython
+   has many features for tab-completion, object introspection, system shell
+   access, command history retrieval across sessions, and its own special
+   command system for adding functionality when working interactively. It
+   tries to be a very efficient environment both for Python code development
+   and for exploration of problems using Python objects (in situations like
+   data analysis).
+  
+2. Serve as an embeddable, ready to use interpreter for your own
+   programs. An interactive IPython shell can be started with a single call
+   from inside another program, providing access to the current namespace.
+   This can be very useful both for debugging purposes and for situations
+   where a blend of batch-processing and interactive exploration are needed.
+  
+3. Offer a flexible framework which can be used as the base
+   environment for working with other systems, with Python as the underlying
+   bridge language. Specifically scientific environments like Mathematica,
+   IDL and Matlab inspired its design, but similar ideas can be
+   useful in many fields.
+  
+4. Allow interactive testing of threaded graphical toolkits. IPython
+   has support for interactive, non-blocking control of GTK, Qt, WX, GLUT, and
+   OS X applications via special threading flags. The normal Python
+   shell can only do this for Tkinter applications.
+
+Main features of the interactive shell
+--------------------------------------
+
+* Dynamic object introspection. One can access docstrings, function
+  definition prototypes, source code, source files and other details
+  of any object accessible to the interpreter with a single
+  keystroke (:samp:`?`, and using :samp:`??` provides additional detail).
+  
+* Searching through modules and namespaces with :samp:`*` wildcards, both
+  when using the :samp:`?` system and via the :samp:`%psearch` command.
+
+* Completion in the local namespace, by typing :kbd:`TAB` at the prompt.
+  This works for keywords, modules, methods, variables and files in the
+  current directory. This is supported via the ``prompt_toolkit`` library.
+  Custom completers can be implemented easily for different purposes
+  (system commands, magic arguments etc.)
+
+* Numbered input/output prompts with command history (persistent
+  across sessions and tied to each profile), full searching in this
+  history and caching of all input and output.
+
+* User-extensible 'magic' commands. A set of commands prefixed with
+  :samp:`%`  or :samp:`%%` is available for controlling IPython itself and provides
+  directory control, namespace information and many aliases to
+  common system shell commands.
+
+* Alias facility for defining your own system aliases.
+
+* Complete system shell access. Lines starting with :samp:`!` are passed
+  directly to the system shell, and using :samp:`!!` or :samp:`var = !cmd` 
+  captures shell output into python variables for further use.
+
+* The ability to expand python variables when calling the system shell. In a
+  shell command, any python variable prefixed with :samp:`$` is expanded. A
+  double :samp:`$$` allows passing a literal :samp:`$` to the shell (for access
+  to shell and environment variables like :envvar:`PATH`).
+
+* Filesystem navigation, via a magic :samp:`%cd` command, along with a
+  persistent bookmark system (using :samp:`%bookmark`) for fast access to
+  frequently visited directories.
+
+* A lightweight persistence framework via the :samp:`%store` command, which
+  allows you to save arbitrary Python variables. These get restored
+  when you run the :samp:`%store -r` command.
+
+* Automatic indentation and highlighting of code as you type (through the
+  `prompt_toolkit` library).
+
+* Macro system for quickly re-executing multiple lines of previous
+  input with a single name via the :samp:`%macro` command. Macros can be
+  stored persistently via :samp:`%store` and edited via :samp:`%edit`.
+
+* Session logging (you can then later use these logs as code in your
+  programs). Logs can optionally timestamp all input, and also store
+  session output (marked as comments, so the log remains valid
+  Python source code).
+
+* Session restoring: logs can be replayed to restore a previous
+  session to the state where you left it.
+
+* Verbose and colored exception traceback printouts. Easier to parse
+  visually, and in verbose mode they produce a lot of useful
+  debugging information (basically a terminal version of the cgitb
+  module).
+
+* Auto-parentheses via the :samp:`%autocall` command: callable objects can be
+  executed without parentheses: :samp:`sin 3` is automatically converted to
+  :samp:`sin(3)`
+
+* Auto-quoting: using :samp:`,`, or :samp:`;` as the first character forces
+  auto-quoting of the rest of the line: :samp:`,my_function a b` becomes
+  automatically :samp:`my_function("a","b")`, while :samp:`;my_function a b`
+  becomes :samp:`my_function("a b")`.
+
+* Extensible input syntax. You can define filters that pre-process
+  user input to simplify input in special situations. This allows
+  for example pasting multi-line code fragments which start with
+  :samp:`>>>` or :samp:`...` such as those from other python sessions or the
+  standard Python documentation.
+
+* Flexible :ref:`configuration system <config_overview>`. It uses a
+  configuration file which allows permanent setting of all command-line
+  options, module loading, code and file execution. The system allows
+  recursive file inclusion, so you can have a base file with defaults and
+  layers which load other customizations for particular projects.
+
+* Embeddable. You can call IPython as a python shell inside your own
+  python programs. This can be used both for debugging code or for
+  providing interactive abilities to your programs with knowledge
+  about the local namespaces (very useful in debugging and data
+  analysis situations).
+
+* Easy debugger access. You can set IPython to call up an enhanced version of
+  the Python debugger (pdb) every time there is an uncaught exception. This
+  drops you inside the code which triggered the exception with all the data
+  live and it is possible to navigate the stack to rapidly isolate the source
+  of a bug. The :samp:`%run` magic command (with the :samp:`-d` option) can run
+  any script under pdb's control, automatically setting initial breakpoints for
+  you.  This version of pdb has IPython-specific improvements, including
+  tab-completion and traceback coloring support. For even easier debugger
+  access, try :samp:`%debug` after seeing an exception.
+
+* Profiler support. You can run single statements (similar to
+  :samp:`profile.run()`) or complete programs under the profiler's control.
+  While this is possible with standard cProfile or profile modules,
+  IPython wraps this functionality with magic commands (see :samp:`%prun`
+  and :samp:`%run -p`) convenient for rapid interactive work.
+
+* Simple timing information. You can use the :samp:`%timeit` command to get
+  the execution time of a Python statement or expression. This machinery is
+  intelligent enough to do more repetitions for commands that finish very
+  quickly in order to get a better estimate of their running time. 
+
+  .. sourcecode:: ipython
+
+    In [1]: %timeit 1+1
+    7.88 ns ± 0.0494 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
+
+    In [2]: %timeit [math.sin(x) for x in range(5000)]
+    608 µs ± 5.57 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
+
+  .. 
+
+  To get the timing information for more than one expression, use the
+  :samp:`%%timeit` cell magic command.
+
+* Doctest support. The special :samp:`%doctest_mode` command toggles a mode
+  to use doctest-compatible prompts, so you can use IPython sessions as
+  doctest code. By default, IPython also allows you to paste existing
+  doctests, and strips out the leading :samp:`>>>` and :samp:`...` prompts in
+  them.
+
+.. _ipythonzmq:
+
+Decoupled two-process model
+==============================
+
+IPython has abstracted and extended the notion of a traditional
+*Read-Evaluate-Print Loop* (REPL) environment by decoupling the *evaluation*
+into its own process. We call this process a **kernel**: it receives execution
+instructions from clients and communicates the results back to them.
+
+This decoupling allows us to have several clients connected to the same
+kernel, and even allows clients and kernels to live on different machines.
+With the exclusion of the traditional single process terminal-based IPython
+(what you start if you run ``ipython`` without any subcommands), all
+other IPython machinery uses this two-process model. Most of this is now part
+of the `Jupyter` project, which includes ``jupyter console``,  ``jupyter
+qtconsole``, and ``jupyter notebook``.
+
+As an example, this means that when you start ``jupyter qtconsole``, you're
+really starting two processes, a kernel and a Qt-based client which can send
+commands to and receive results from that kernel. If there is already a kernel
+running that you want to connect to, you can pass the  ``--existing`` flag
+which will skip initiating a new kernel and connect to the most recent kernel,
+instead. To connect to a specific kernel once you have several kernels
+running, use the ``%connect_info`` magic to get the unique connection file,
+which will be something like ``--existing kernel-19732.json`` but with
+different numbers which correspond to the Process ID of the kernel.
+
+You can read more about using `jupyter qtconsole
+<https://jupyter.org/qtconsole/>`_, and
+`jupyter notebook <https://jupyter-notebook.readthedocs.io/en/latest/>`_. There
+is also a :ref:`message spec <messaging>` which documents the protocol for
+communication between kernels
+and clients.
+
+.. seealso::
+
+    `Frontend/Kernel Model`_ example notebook
+
+
+Interactive parallel computing
+==============================
+
+
+This functionality is optional and now part of the `ipyparallel
+<https://ipyparallel.readthedocs.io/>`_ project.
+
+Portability and Python requirements
+-----------------------------------
+
+IPython requires Python 3.11 or newer.
+
+IPython is known to work on the following operating systems:
+
+	* Linux
+	* Most other Unix-like OSs (AIX, Solaris, BSD, etc.)
+	* Mac OS X
+	* Windows (CygWin, XP, Vista, etc.)
+
+See :ref:`here <install_index>` for instructions on how to install IPython.
+
+.. include:: links.txt
diff --git a/docs/source/overview.txt b/docs/source/overview.txt
deleted file mode 100644
index 228d2a35382..00000000000
--- a/docs/source/overview.txt
+++ /dev/null
@@ -1,234 +0,0 @@
-.. _overview:
-
-============
-Introduction
-============
-
-Overview
-========
-
-One of Python's most useful features is its interactive interpreter.
-This system allows very fast testing of ideas without the overhead of
-creating test files as is typical in most programming languages.
-However, the interpreter supplied with the standard Python distribution
-is somewhat limited for extended interactive use.
-
-The goal of IPython is to create a comprehensive environment for
-interactive and exploratory computing.  To support this goal, IPython
-has two main components:
-
-* An enhanced interactive Python shell.
-* An architecture for interactive parallel computing.
-
-All of IPython is open source (released under the revised BSD license).
-
-Enhanced interactive Python shell
-=================================
-
-IPython's interactive shell (:command:`ipython`), has the following goals,
-amongst others:
-
-1. Provide an interactive shell superior to Python's default. IPython
-   has many features for object introspection, system shell access,
-   and its own special command system for adding functionality when
-   working interactively. It tries to be a very efficient environment
-   both for Python code development and for exploration of problems
-   using Python objects (in situations like data analysis).
-  
-2. Serve as an embeddable, ready to use interpreter for your own
-   programs. IPython can be started with a single call from inside
-   another program, providing access to the current namespace. This
-   can be very useful both for debugging purposes and for situations
-   where a blend of batch-processing and interactive exploration are
-   needed.  New in the 0.9 version of IPython is a reusable wxPython
-   based IPython widget.
-  
-3. Offer a flexible framework which can be used as the base
-   environment for other systems with Python as the underlying
-   language. Specifically scientific environments like Mathematica,
-   IDL and Matlab inspired its design, but similar ideas can be
-   useful in many fields.
-  
-4. Allow interactive testing of threaded graphical toolkits. IPython
-   has support for interactive, non-blocking control of GTK, Qt and
-   WX applications via special threading flags. The normal Python
-   shell can only do this for Tkinter applications.
-
-Main features of the interactive shell
---------------------------------------
-
-* Dynamic object introspection. One can access docstrings, function
-  definition prototypes, source code, source files and other details
-  of any object accessible to the interpreter with a single
-  keystroke (:samp:`?`, and using :samp:`??` provides additional detail).
-  
-* Searching through modules and namespaces with :samp:`*` wildcards, both
-  when using the :samp:`?` system and via the :samp:`%psearch` command.
-
-* Completion in the local namespace, by typing :kbd:`TAB` at the prompt.
-  This works for keywords, modules, methods, variables and files in the
-  current directory. This is supported via the readline library, and
-  full access to configuring readline's behavior is provided. 
-  Custom completers can be implemented easily for different purposes
-  (system commands, magic arguments etc.)
-
-* Numbered input/output prompts with command history (persistent
-  across sessions and tied to each profile), full searching in this
-  history and caching of all input and output.
-
-* User-extensible 'magic' commands. A set of commands prefixed with
-  :samp:`%` is available for controlling IPython itself and provides
-  directory control, namespace information and many aliases to
-  common system shell commands.
-
-* Alias facility for defining your own system aliases.
-
-* Complete system shell access. Lines starting with :samp:`!` are passed
-  directly to the system shell, and using :samp:`!!` or :samp:`var = !cmd` 
-  captures shell output into python variables for further use.
-
-* Background execution of Python commands in a separate thread.
-  IPython has an internal job manager called jobs, and a
-  convenience backgrounding magic function called :samp:`%bg`.
-
-* The ability to expand python variables when calling the system shell. In a
-  shell command, any python variable prefixed with :samp:`$` is expanded. A
-  double :samp:`$$` allows passing a literal :samp:`$` to the shell (for access
-  to shell and environment variables like :envvar:`PATH`).
-
-* Filesystem navigation, via a magic :samp:`%cd` command, along with a
-  persistent bookmark system (using :samp:`%bookmark`) for fast access to
-  frequently visited directories.
-
-* A lightweight persistence framework via the :samp:`%store` command, which
-  allows you to save arbitrary Python variables. These get restored
-  automatically when your session restarts.
-
-* Automatic indentation (optional) of code as you type (through the
-  readline library).
-
-* Macro system for quickly re-executing multiple lines of previous
-  input with a single name. Macros can be stored persistently via
-  :samp:`%store` and edited via :samp:`%edit`.
-
-* Session logging (you can then later use these logs as code in your
-  programs). Logs can optionally timestamp all input, and also store
-  session output (marked as comments, so the log remains valid
-  Python source code).
-
-* Session restoring: logs can be replayed to restore a previous
-  session to the state where you left it.
-
-* Verbose and colored exception traceback printouts. Easier to parse
-  visually, and in verbose mode they produce a lot of useful
-  debugging information (basically a terminal version of the cgitb
-  module).
-
-* Auto-parentheses: callable objects can be executed without
-  parentheses: :samp:`sin 3` is automatically converted to :samp:`sin(3)`.
-
-* Auto-quoting: using :samp:`,`, or :samp:`;` as the first character forces
-  auto-quoting of the rest of the line: :samp:`,my_function a b` becomes
-  automatically :samp:`my_function("a","b")`, while :samp:`;my_function a b`
-  becomes :samp:`my_function("a b")`.
-
-* Extensible input syntax. You can define filters that pre-process
-  user input to simplify input in special situations. This allows
-  for example pasting multi-line code fragments which start with
-  :samp:`>>>` or :samp:`...` such as those from other python sessions or the
-  standard Python documentation.
-
-* Flexible configuration system. It uses a configuration file which
-  allows permanent setting of all command-line options, module
-  loading, code and file execution. The system allows recursive file
-  inclusion, so you can have a base file with defaults and layers
-  which load other customizations for particular projects.
-
-* Embeddable. You can call IPython as a python shell inside your own
-  python programs. This can be used both for debugging code or for
-  providing interactive abilities to your programs with knowledge
-  about the local namespaces (very useful in debugging and data
-  analysis situations).
-
-* Easy debugger access. You can set IPython to call up an enhanced version of
-  the Python debugger (pdb) every time there is an uncaught exception. This
-  drops you inside the code which triggered the exception with all the data
-  live and it is possible to navigate the stack to rapidly isolate the source
-  of a bug. The :samp:`%run` magic command (with the :samp:`-d` option) can run
-  any script under pdb's control, automatically setting initial breakpoints for
-  you.  This version of pdb has IPython-specific improvements, including
-  tab-completion and traceback coloring support. For even easier debugger
-  access, try :samp:`%debug` after seeing an exception. winpdb is also
-  supported, see ipy_winpdb extension.
-
-* Profiler support. You can run single statements (similar to
-  :samp:`profile.run()`) or complete programs under the profiler's control.
-  While this is possible with standard cProfile or profile modules,
-  IPython wraps this functionality with magic commands (see :samp:`%prun`
-  and :samp:`%run -p`) convenient for rapid interactive work.
-
-* Doctest support. The special :samp:`%doctest_mode` command toggles a mode
-  that allows you to paste existing doctests (with leading :samp:`>>>`
-  prompts and whitespace) and uses doctest-compatible prompts and
-  output, so you can use IPython sessions as doctest code.
-
-Interactive parallel computing
-==============================
-
-Increasingly, parallel computer hardware, such as multicore CPUs, clusters and
-supercomputers, is becoming ubiquitous. Over the last 3 years, we have
-developed an architecture within IPython that allows such hardware to be used
-quickly and easily from Python. Moreover, this architecture is designed to
-support interactive and collaborative parallel computing.
-
-The main features of this system are:
-
-* Quickly parallelize Python code from an interactive Python/IPython session.
-
-* A flexible and dynamic process model that be deployed on anything from 
-  multicore workstations to supercomputers.
-
-* An architecture that supports many different styles of parallelism, from
-  message passing to task farming.  And all of these styles can be handled
-  interactively.
-
-* Both blocking and fully asynchronous interfaces.
-
-* High level APIs that enable many things to be parallelized in a few lines
-  of code.
-
-* Write parallel code that will run unchanged on everything from multicore
-  workstations to supercomputers.
-
-* Full integration with Message Passing libraries (MPI).
-
-* Capabilities based security model with full encryption of network connections.
-
-* Share live parallel jobs with other users securely.  We call this
-  collaborative parallel computing.
-
-* Dynamically load balanced task farming system.
-
-* Robust error handling.  Python exceptions raised in parallel execution are
-  gathered and presented to the top-level code.
-
-For more information, see our :ref:`overview <parallel_index>` of using IPython
-for parallel computing.
-
-Portability and Python requirements
------------------------------------
-
-As of the 0.11 release, IPython works with either Python 2.5 or 2.6.  
-Versions 0.9 and 0.10 worked with Python 2.4 as well.  We have not yet begun
-to test and port IPython to Python 3.  Our plan is to gradually drop Python 2.5
-support and then begin the transition to strict 2.6 and 3.
-
-IPython is known to work on the following operating systems:
-
-	* Linux
-	* Most other Unix-like OSs (AIX, Solaris, BSD, etc.)
-	* Mac OS X
-	* Windows (CygWin, XP, Vista, etc.)
-
-See :ref:`here <install_index>` for instructions on how to install IPython.
-
diff --git a/docs/source/parallel/asian_call.pdf b/docs/source/parallel/asian_call.pdf
deleted file mode 100644
index 3e5fddddd13..00000000000
Binary files a/docs/source/parallel/asian_call.pdf and /dev/null differ
diff --git a/docs/source/parallel/asian_call.png b/docs/source/parallel/asian_call.png
deleted file mode 100644
index 37ce8741e2e..00000000000
Binary files a/docs/source/parallel/asian_call.png and /dev/null differ
diff --git a/docs/source/parallel/asian_put.pdf b/docs/source/parallel/asian_put.pdf
deleted file mode 100644
index a0ca185203c..00000000000
Binary files a/docs/source/parallel/asian_put.pdf and /dev/null differ
diff --git a/docs/source/parallel/asian_put.png b/docs/source/parallel/asian_put.png
deleted file mode 100644
index 34bb270dfac..00000000000
Binary files a/docs/source/parallel/asian_put.png and /dev/null differ
diff --git a/docs/source/parallel/dag_dependencies.txt b/docs/source/parallel/dag_dependencies.txt
deleted file mode 100644
index 779e2e23346..00000000000
--- a/docs/source/parallel/dag_dependencies.txt
+++ /dev/null
@@ -1,173 +0,0 @@
-.. _dag_dependencies:
-
-================
-DAG Dependencies
-================
-
-Often, parallel workflow is described in terms of a `Directed Acyclic Graph
-<http://en.wikipedia.org/wiki/Directed_acyclic_graph>`_ or DAG.  A popular library
-for working with Graphs is NetworkX_.  Here, we will walk through a demo mapping
-a nx DAG to task dependencies.
-
-The full script that runs this demo can be found in
-:file:`docs/examples/newparallel/dagdeps.py`.
-
-Why are DAGs good for task dependencies?
-----------------------------------------
-
-The 'G' in DAG is 'Graph'. A Graph is a collection of **nodes** and **edges** that connect
-the nodes. For our purposes, each node would be a task, and each edge would be a
-dependency. The 'D' in DAG stands for 'Directed'. This means that each edge has a
-direction associated with it. So we can interpret the edge (a,b) as meaning that b depends
-on a, whereas the edge (b,a) would mean a depends on b. The 'A' is 'Acyclic', meaning that
-there must not be any closed loops in the graph. This is important for dependencies,
-because if a loop were closed, then a task could ultimately depend on itself, and never be
-able to run. If your workflow can be described as a DAG, then it is impossible for your
-dependencies to cause a deadlock.
-
-A Sample DAG
-------------
-
-Here, we have a very simple 5-node DAG:
-
-.. figure:: simpledag.*
-
-With NetworkX, an arrow is just a fattened bit on the edge. Here, we can see that task 0
-depends on nothing, and can run immediately. 1 and 2 depend on 0; 3 depends on
-1 and 2; and 4 depends only on 1.
-
-A possible sequence of events for this workflow:
-
-0. Task 0 can run right away
-1. 0 finishes, so 1,2 can start
-2. 1 finishes, 3 is still waiting on 2, but 4 can start right away
-3. 2 finishes, and 3 can finally start
-
-
-Further, taking failures into account, assuming all dependencies are run with the default
-`success=True,failure=False`, the following cases would occur for each node's failure:
-
-0. fails: all other tasks fail as Impossible
-1. 2 can still succeed, but 3,4 are unreachable
-2. 3 becomes unreachable, but 4 is unaffected
-3. and 4. are terminal, and can have no effect on other nodes
-
-The code to generate the simple DAG:
-
-.. sourcecode:: python
-
-    import networkx as nx
-    
-    G = nx.DiGraph()
-    
-    # add 5 nodes, labeled 0-4:
-    map(G.add_node, range(5))
-    # 1,2 depend on 0:
-    G.add_edge(0,1)
-    G.add_edge(0,2)
-    # 3 depends on 1,2
-    G.add_edge(1,3)
-    G.add_edge(2,3)
-    # 4 depends on 1
-    G.add_edge(1,4)
-    
-    # now draw the graph:
-    pos = { 0 : (0,0), 1 : (1,1), 2 : (-1,1),
-            3 : (0,2), 4 : (2,2)}
-    nx.draw(G, pos, edge_color='r')
-
-
-For demonstration purposes, we have a function that generates a random DAG with a given
-number of nodes and edges.
-
-.. literalinclude:: ../../examples/newparallel/dagdeps.py
-    :language: python
-    :lines: 20-36
-
-So first, we start with a graph of 32 nodes, with 128 edges:
-
-.. sourcecode:: ipython
-
-    In [2]: G = random_dag(32,128)
-
-Now, we need to build our dict of jobs corresponding to the nodes on the graph:
-
-.. sourcecode:: ipython
-
-    In [3]: jobs = {}
-    
-    # in reality, each job would presumably be different
-    # randomwait is just a function that sleeps for a random interval
-    In [4]: for node in G:
-       ...:     jobs[node] = randomwait 
-
-Once we have a dict of jobs matching the nodes on the graph, we can start submitting jobs,
-and linking up the dependencies. Since we don't know a job's msg_id until it is submitted,
-which is necessary for building dependencies, it is critical that we don't submit any jobs
-before other jobs it may depend on. Fortunately, NetworkX provides a
-:meth:`topological_sort` method which ensures exactly this. It presents an iterable, that
-guarantees that when you arrive at a node, you have already visited all the nodes it
-on which it depends:
-
-.. sourcecode:: ipython
-
-    In [5]: rc = Client()
-    In [5]: view = rc.load_balanced_view()
-    
-    In [6]: results = {}
-    
-    In [7]: for node in G.topological_sort():
-       ...:     # get list of AsyncResult objects from nodes
-       ...:     # leading into this one as dependencies
-       ...:     deps = [ results[n] for n in G.predecessors(node) ]
-       ...:     # submit and store AsyncResult object
-       ...:     results[node] = view.apply_with_flags(jobs[node], after=deps, block=False)
-
-Now that we have submitted all the jobs, we can wait for the results:
-
-.. sourcecode:: ipython
-
-    In [8]: view.wait(results.values())
-
-Now, at least we know that all the jobs ran and did not fail (``r.get()`` would have
-raised an error if a task failed).  But we don't know that the ordering was properly
-respected.  For this, we can use the :attr:`metadata` attribute of each AsyncResult.
-
-These objects store a variety of metadata about each task, including various timestamps.
-We can validate that the dependencies were respected by checking that each task was
-started after all of its predecessors were completed:
-
-.. literalinclude:: ../../examples/newparallel/dagdeps.py
-    :language: python
-    :lines: 64-70
-
-We can also validate the graph visually. By drawing the graph with each node's x-position
-as its start time, all arrows must be pointing to the right if dependencies were respected.
-For spreading, the y-position will be the runtime of the task, so long tasks
-will be at the top, and quick, small tasks will be at the bottom.
-
-.. sourcecode:: ipython
-
-    In [10]: from matplotlib.dates import date2num
-    
-    In [11]: from matplotlib.cm import gist_rainbow
-    
-    In [12]: pos = {}; colors = {}
-    
-    In [12]: for node in G:
-        ...:    md = results[node].metadata
-        ...:    start = date2num(md.started)
-        ...:    runtime = date2num(md.completed) - start
-        ...:    pos[node] = (start, runtime)
-        ...:    colors[node] = md.engine_id
-    
-    In [13]: nx.draw(G, pos, node_list=colors.keys(), node_color=colors.values(),
-        ...:    cmap=gist_rainbow)
-
-.. figure:: dagdeps.*
-
-    Time started on x, runtime on y, and color-coded by engine-id (in this case there
-    were four engines). Edges denote dependencies.
-
-
-.. _NetworkX: http://networkx.lanl.gov/
diff --git a/docs/source/parallel/dagdeps.pdf b/docs/source/parallel/dagdeps.pdf
deleted file mode 100644
index 33bdc9d1825..00000000000
Binary files a/docs/source/parallel/dagdeps.pdf and /dev/null differ
diff --git a/docs/source/parallel/dagdeps.png b/docs/source/parallel/dagdeps.png
deleted file mode 100644
index a821aaebcff..00000000000
Binary files a/docs/source/parallel/dagdeps.png and /dev/null differ
diff --git a/docs/source/parallel/hpc_job_manager.pdf b/docs/source/parallel/hpc_job_manager.pdf
deleted file mode 100644
index 3e4c180c7b7..00000000000
Binary files a/docs/source/parallel/hpc_job_manager.pdf and /dev/null differ
diff --git a/docs/source/parallel/hpc_job_manager.png b/docs/source/parallel/hpc_job_manager.png
deleted file mode 100644
index abc1d5eef70..00000000000
Binary files a/docs/source/parallel/hpc_job_manager.png and /dev/null differ
diff --git a/docs/source/parallel/index.rst b/docs/source/parallel/index.rst
new file mode 100644
index 00000000000..a34551ebb66
--- /dev/null
+++ b/docs/source/parallel/index.rst
@@ -0,0 +1,9 @@
+:orphan:
+
+.. _parallel_index:
+
+====================================
+Using IPython for parallel computing
+====================================
+
+IPython.parallel has moved to `ipyparallel <https://github.com/ipython/ipyparallel>`_.
diff --git a/docs/source/parallel/index.txt b/docs/source/parallel/index.txt
deleted file mode 100644
index 044620738da..00000000000
--- a/docs/source/parallel/index.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-.. _parallel_index:
-
-====================================
-Using IPython for parallel computing
-====================================
-
-.. toctree::
-   :maxdepth: 2
-
-   parallel_intro.txt
-   parallel_process.txt
-   parallel_multiengine.txt
-   parallel_task.txt
-   parallel_mpi.txt
-   parallel_security.txt
-   parallel_winhpc.txt
-   parallel_demos.txt
-   dag_dependencies.txt
-   parallel_details.txt
-   parallel_transition.txt
-
-
diff --git a/docs/source/parallel/ipcluster_create.pdf b/docs/source/parallel/ipcluster_create.pdf
deleted file mode 100644
index b0b8586ce1e..00000000000
Binary files a/docs/source/parallel/ipcluster_create.pdf and /dev/null differ
diff --git a/docs/source/parallel/ipcluster_create.png b/docs/source/parallel/ipcluster_create.png
deleted file mode 100644
index aea042b9fb7..00000000000
Binary files a/docs/source/parallel/ipcluster_create.png and /dev/null differ
diff --git a/docs/source/parallel/ipcluster_start.pdf b/docs/source/parallel/ipcluster_start.pdf
deleted file mode 100644
index aa35b8493e3..00000000000
Binary files a/docs/source/parallel/ipcluster_start.pdf and /dev/null differ
diff --git a/docs/source/parallel/ipcluster_start.png b/docs/source/parallel/ipcluster_start.png
deleted file mode 100644
index 69ee951413c..00000000000
Binary files a/docs/source/parallel/ipcluster_start.png and /dev/null differ
diff --git a/docs/source/parallel/ipython_shell.pdf b/docs/source/parallel/ipython_shell.pdf
deleted file mode 100644
index b242fcc091f..00000000000
Binary files a/docs/source/parallel/ipython_shell.pdf and /dev/null differ
diff --git a/docs/source/parallel/ipython_shell.png b/docs/source/parallel/ipython_shell.png
deleted file mode 100644
index 2958c2ada70..00000000000
Binary files a/docs/source/parallel/ipython_shell.png and /dev/null differ
diff --git a/docs/source/parallel/mec_simple.pdf b/docs/source/parallel/mec_simple.pdf
deleted file mode 100644
index 7adf01c5261..00000000000
Binary files a/docs/source/parallel/mec_simple.pdf and /dev/null differ
diff --git a/docs/source/parallel/mec_simple.png b/docs/source/parallel/mec_simple.png
deleted file mode 100644
index bf13104f857..00000000000
Binary files a/docs/source/parallel/mec_simple.png and /dev/null differ
diff --git a/docs/source/parallel/parallel_demos.txt b/docs/source/parallel/parallel_demos.txt
deleted file mode 100644
index 34ce2d0c03e..00000000000
--- a/docs/source/parallel/parallel_demos.txt
+++ /dev/null
@@ -1,284 +0,0 @@
-=================
-Parallel examples
-=================
-
-.. note::
-
-    Performance numbers from ``IPython.kernel``, not newparallel.
-
-In this section we describe two more involved examples of using an IPython
-cluster to perform a parallel computation. In these examples, we will be using
-IPython's "pylab" mode, which enables interactive plotting using the
-Matplotlib package. IPython can be started in this mode by typing::
-
-    ipython --pylab
-
-at the system command line.
-
-150 million digits of pi
-========================
-
-In this example we would like to study the distribution of digits in the
-number pi (in base 10). While it is not known if pi is a normal number (a
-number is normal in base 10 if 0-9 occur with equal likelihood) numerical
-investigations suggest that it is. We will begin with a serial calculation on
-10,000 digits of pi and then perform a parallel calculation involving 150
-million digits.
-
-In both the serial and parallel calculation we will be using functions defined
-in the :file:`pidigits.py` file, which is available in the
-:file:`docs/examples/newparallel` directory of the IPython source distribution.
-These functions provide basic facilities for working with the digits of pi and
-can be loaded into IPython by putting :file:`pidigits.py` in your current
-working directory and then doing:
-
-.. sourcecode:: ipython
-
-    In [1]: run pidigits.py
-
-Serial calculation
-------------------
-
-For the serial calculation, we will use `SymPy <http://www.sympy.org>`_ to
-calculate 10,000 digits of pi and then look at the frequencies of the digits
-0-9. Out of 10,000 digits, we expect each digit to occur 1,000 times. While
-SymPy is capable of calculating many more digits of pi, our purpose here is to
-set the stage for the much larger parallel calculation.
-
-In this example, we use two functions from :file:`pidigits.py`: 
-:func:`one_digit_freqs` (which calculates how many times each digit occurs)
-and :func:`plot_one_digit_freqs` (which uses Matplotlib to plot the result).
-Here is an interactive IPython session that uses these functions with
-SymPy:
-
-.. sourcecode:: ipython
-
-    In [7]: import sympy
-
-    In [8]: pi = sympy.pi.evalf(40)
-
-    In [9]: pi
-    Out[9]: 3.141592653589793238462643383279502884197
-
-    In [10]: pi = sympy.pi.evalf(10000)
-
-    In [11]: digits = (d for d in str(pi)[2:])  # create a sequence of digits
-
-    In [12]: run pidigits.py  # load one_digit_freqs/plot_one_digit_freqs
-
-    In [13]: freqs = one_digit_freqs(digits)
-
-    In [14]: plot_one_digit_freqs(freqs)
-    Out[14]: [<matplotlib.lines.Line2D object at 0x18a55290>]
-
-The resulting plot of the single digit counts shows that each digit occurs
-approximately 1,000 times, but that with only 10,000 digits the
-statistical fluctuations are still rather large:
-
-.. image:: single_digits.*
-
-It is clear that to reduce the relative fluctuations in the counts, we need
-to look at many more digits of pi. That brings us to the parallel calculation.
-
-Parallel calculation
---------------------
-
-Calculating many digits of pi is a challenging computational problem in itself. 
-Because we want to focus on the distribution of digits in this example, we
-will use pre-computed digit of pi from the website of Professor Yasumasa
-Kanada at the University of Tokyo (http://www.super-computing.org). These
-digits come in a set of text files (ftp://pi.super-computing.org/.2/pi200m/)
-that each have 10 million digits of pi.
-
-For the parallel calculation, we have copied these files to the local hard
-drives of the compute nodes. A total of 15 of these files will be used, for a
-total of 150 million digits of pi. To make things a little more interesting we
-will calculate the frequencies of all 2 digits sequences (00-99) and then plot
-the result using a 2D matrix in Matplotlib.
-
-The overall idea of the calculation is simple: each IPython engine will
-compute the two digit counts for the digits in a single file. Then in a final
-step the counts from each engine will be added up. To perform this
-calculation, we will need two top-level functions from :file:`pidigits.py`:
-
-.. literalinclude:: ../../examples/newparallel/pidigits.py
-   :language: python
-   :lines: 41-56
-
-We will also use the :func:`plot_two_digit_freqs` function to plot the
-results. The code to run this calculation in parallel is contained in
-:file:`docs/examples/newparallel/parallelpi.py`. This code can be run in parallel
-using IPython by following these steps:
-
-1. Use :command:`ipcluster` to start 15 engines. We used an 8 core (2 quad 
-   core CPUs) cluster with hyperthreading enabled which makes the 8 cores 
-   looks like 16 (1 controller + 15 engines) in the OS. However, the maximum
-   speedup we can observe is still only 8x.
-2. With the file :file:`parallelpi.py` in your current working directory, open
-   up IPython in pylab mode and type ``run parallelpi.py``.  This will download
-   the pi files via ftp the first time you run it, if they are not
-   present in the Engines' working directory.
-
-When run on our 8 core cluster, we observe a speedup of 7.7x. This is slightly
-less than linear scaling (8x) because the controller is also running on one of
-the cores.
-
-To emphasize the interactive nature of IPython, we now show how the
-calculation can also be run by simply typing the commands from
-:file:`parallelpi.py` interactively into IPython:
-
-.. sourcecode:: ipython
-
-    In [1]: from IPython.parallel import Client
-
-    # The Client allows us to use the engines interactively.
-    # We simply pass Client the name of the cluster profile we
-    # are using.
-    In [2]: c = Client(profile='mycluster')
-    In [3]: view = c.load_balanced_view()
-
-    In [3]: c.ids
-    Out[3]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
-
-    In [4]: run pidigits.py
-
-    In [5]: filestring = 'pi200m.ascii.%(i)02dof20'
-
-    # Create the list of files to process.
-    In [6]: files = [filestring % {'i':i} for i in range(1,16)]
-
-    In [7]: files
-    Out[7]: 
-    ['pi200m.ascii.01of20',
-     'pi200m.ascii.02of20',
-     'pi200m.ascii.03of20',
-     'pi200m.ascii.04of20',
-     'pi200m.ascii.05of20',
-     'pi200m.ascii.06of20',
-     'pi200m.ascii.07of20',
-     'pi200m.ascii.08of20',
-     'pi200m.ascii.09of20',
-     'pi200m.ascii.10of20',
-     'pi200m.ascii.11of20',
-     'pi200m.ascii.12of20',
-     'pi200m.ascii.13of20',
-     'pi200m.ascii.14of20',
-     'pi200m.ascii.15of20']
-    
-    # download the data files if they don't already exist:
-    In [8]: v.map(fetch_pi_file, files)
-    
-    # This is the parallel calculation using the Client.map method 
-    # which applies compute_two_digit_freqs to each file in files in parallel.
-    In [9]: freqs_all = v.map(compute_two_digit_freqs, files)
-
-    # Add up the frequencies from each engine.
-    In [10]: freqs = reduce_freqs(freqs_all)
-
-    In [11]: plot_two_digit_freqs(freqs)
-    Out[11]: <matplotlib.image.AxesImage object at 0x18beb110>
-
-    In [12]: plt.title('2 digit counts of 150m digits of pi')
-    Out[12]: <matplotlib.text.Text object at 0x18d1f9b0>
-
-The resulting plot generated by Matplotlib is shown below. The colors indicate
-which two digit sequences are more (red) or less (blue) likely to occur in the
-first 150 million digits of pi. We clearly see that the sequence "41" is 
-most likely and that "06" and "07" are least likely. Further analysis would
-show that the relative size of the statistical fluctuations have decreased
-compared to the 10,000 digit calculation.
-
-.. image:: two_digit_counts.*
-
-
-Parallel options pricing
-========================
-
-An option is a financial contract that gives the buyer of the contract the
-right to buy (a "call") or sell (a "put") a secondary asset (a stock for
-example) at a particular date in the future (the expiration date) for a
-pre-agreed upon price (the strike price). For this right, the buyer pays the
-seller a premium (the option price). There are a wide variety of flavors of
-options (American, European, Asian, etc.) that are useful for different
-purposes: hedging against risk, speculation, etc.
-
-Much of modern finance is driven by the need to price these contracts
-accurately based on what is known about the properties (such as volatility) of
-the underlying asset. One method of pricing options is to use a Monte Carlo
-simulation of the underlying asset price. In this example we use this approach
-to price both European and Asian (path dependent) options for various strike
-prices and volatilities.
-
-The code for this example can be found in the :file:`docs/examples/newparallel`
-directory of the IPython source. The function :func:`price_options` in
-:file:`mcpricer.py` implements the basic Monte Carlo pricing algorithm using
-the NumPy package and is shown here:
-
-.. literalinclude:: ../../examples/newparallel/mcpricer.py
-   :language: python
-
-To run this code in parallel, we will use IPython's :class:`LoadBalancedView` class,
-which distributes work to the engines using dynamic load balancing. This
-view is a wrapper of the :class:`Client` class shown in
-the previous example. The parallel calculation using :class:`LoadBalancedView` can
-be found in the file :file:`mcpricer.py`. The code in this file creates a
-:class:`TaskClient` instance and then submits a set of tasks using
-:meth:`TaskClient.run` that calculate the option prices for different
-volatilities and strike prices. The results are then plotted as a 2D contour
-plot using Matplotlib.
-
-.. literalinclude:: ../../examples/newparallel/mcdriver.py
-   :language: python
-
-To use this code, start an IPython cluster using :command:`ipcluster`, open
-IPython in the pylab mode with the file :file:`mcdriver.py` in your current
-working directory and then type:
-
-.. sourcecode:: ipython
-
-    In [7]: run mcdriver.py
-    Submitted tasks:  [0, 1, 2, ...]
-
-Once all the tasks have finished, the results can be plotted using the
-:func:`plot_options` function. Here we make contour plots of the Asian
-call and Asian put options as function of the volatility and strike price:
-
-.. sourcecode:: ipython
-
-    In [8]: plot_options(sigma_vals, K_vals, prices['acall'])
-
-    In [9]: plt.figure()
-    Out[9]: <matplotlib.figure.Figure object at 0x18c178d0>
-
-    In [10]: plot_options(sigma_vals, K_vals, prices['aput'])
-
-These results are shown in the two figures below. On a 8 core cluster the
-entire calculation (10 strike prices, 10 volatilities, 100,000 paths for each)
-took 30 seconds in parallel, giving a speedup of 7.7x, which is comparable
-to the speedup observed in our previous example.
-
-.. image:: asian_call.*
-
-.. image:: asian_put.*
-
-Conclusion
-==========
-
-To conclude these examples, we summarize the key features of IPython's
-parallel architecture that have been demonstrated:
-
-* Serial code can be parallelized often with only a few extra lines of code.
-  We have used the :class:`DirectView` and :class:`LoadBalancedView` classes
-  for this purpose.
-* The resulting parallel code can be run without ever leaving the IPython's
-  interactive shell.
-* Any data computed in parallel can be explored interactively through 
-  visualization or further numerical calculations.
-* We have run these examples on a cluster running Windows HPC Server 2008.
-  IPython's built in support for the Windows HPC job scheduler makes it
-  easy to get started with IPython's parallel capabilities.
-
-.. note::
-
-    The newparallel code has never been run on Windows HPC Server, so the last
-    conclusion is untested.
diff --git a/docs/source/parallel/parallel_details.txt b/docs/source/parallel/parallel_details.txt
deleted file mode 100644
index ef8d3699395..00000000000
--- a/docs/source/parallel/parallel_details.txt
+++ /dev/null
@@ -1,621 +0,0 @@
-.. _parallel_details:
-
-==========================================
-Details of Parallel Computing with IPython
-==========================================
-
-.. note::
-
-    There are still many sections to fill out
-
-
-Caveats
-=======
-
-First, some caveats about the detailed workings of parallel computing with 0MQ and IPython.
-
-Non-copying sends and numpy arrays
-----------------------------------
-
-When numpy arrays are passed as arguments to apply or via data-movement methods, they are not
-copied. This means that you must be careful if you are sending an array that you intend to work
-on. PyZMQ does allow you to track when a message has been sent so you can know when it is safe
-to edit the buffer, but IPython only allows for this.
-
-It is also important to note that the non-copying receive of a message is *read-only*. That
-means that if you intend to work in-place on an array that you have sent or received, you must
-copy it. This is true for both numpy arrays sent to engines and numpy arrays retrieved as
-results.
-
-The following will fail:
-
-.. sourcecode:: ipython
-
-    In [3]: A = numpy.zeros(2)
-    
-    In [4]: def setter(a):
-       ...: a[0]=1
-       ...: return a
-
-    In [5]: rc[0].apply_sync(setter, A)
-    ---------------------------------------------------------------------------
-    RemoteError                               Traceback (most recent call last)
-    ...
-    RemoteError: RuntimeError(array is not writeable)
-    Traceback (most recent call last):
-      File "/path/to/site-packages/IPython/parallel/streamkernel.py", line 329, in apply_request
-        exec code in working, working
-      File "<string>", line 1, in <module>
-      File "<ipython-input-14-736187483856>", line 2, in setter
-    RuntimeError: array is not writeable
-
-If you do need to edit the array in-place, just remember to copy the array if it's read-only.
-The :attr:`ndarray.flags.writeable` flag will tell you if you can write to an array.
-
-.. sourcecode:: ipython
-
-    In [3]: A = numpy.zeros(2)
-    
-    In [4]: def setter(a):
-       ...:     """only copy read-only arrays"""
-       ...:     if not a.flags.writeable:
-       ...:         a=a.copy()
-       ...:     a[0]=1
-       ...:     return a
-
-    In [5]: rc[0].apply_sync(setter, A)
-    Out[5]: array([ 1.,  0.])
-    
-    # note that results will also be read-only:
-    In [6]: _.flags.writeable
-    Out[6]: False
-
-If you want to safely edit an array in-place after *sending* it, you must use the `track=True` flag.  IPython always performs non-copying sends of arrays, which return immediately.  You
-must instruct IPython track those messages *at send time* in order to know for sure that the send has completed.  AsyncResults have a :attr:`sent` property, and :meth:`wait_on_send` method
-for checking and waiting for 0MQ to finish with a buffer.
-
-.. sourcecode:: ipython
-
-    In [5]: A = numpy.random.random((1024,1024))
-    
-    In [6]: view.track=True
-    
-    In [7]: ar = view.apply_async(lambda x: 2*x, A)
-    
-    In [8]: ar.sent
-    Out[8]: False
-    
-    In [9]: ar.wait_on_send() # blocks until sent is True
-
-
-What is sendable?
------------------
-
-If IPython doesn't know what to do with an object, it will pickle it. There is a short list of
-objects that are not pickled: ``buffers``, ``str/bytes`` objects, and ``numpy``
-arrays. These are handled specially by IPython in order to prevent the copying of data. Sending
-bytes or numpy arrays will result in exactly zero in-memory copies of your data (unless the data
-is very small).
-
-If you have an object that provides a Python buffer interface, then you can always send that
-buffer without copying - and reconstruct the object on the other side in your own code. It is
-possible that the object reconstruction will become extensible, so you can add your own
-non-copying types, but this does not yet exist.
-
-Closures
-********
-
-Just about anything in Python is pickleable. The one notable exception is objects (generally
-functions) with *closures*. Closures can be a complicated topic, but the basic principal is that
-functions that refer to variables in their parent scope have closures.
-
-An example of a function that uses a closure:
-
-.. sourcecode:: python
-
-    def f(a):
-        def inner():
-            # inner will have a closure
-            return a
-        return echo
-    
-    f1 = f(1)
-    f2 = f(2)
-    f1() # returns 1
-    f2() # returns 2
-
-f1 and f2 will have closures referring to the scope in which `inner` was defined, because they
-use the variable 'a'. As a result, you would not be able to send ``f1`` or ``f2`` with IPython.
-Note that you *would* be able to send `f`. This is only true for interactively defined
-functions (as are often used in decorators), and only when there are variables used inside the
-inner function, that are defined in the outer function. If the names are *not* in the outer
-function, then there will not be a closure, and the generated function will look in
-``globals()`` for the name:
-
-.. sourcecode:: python
-
-    def g(b):
-        # note that `b` is not referenced in inner's scope
-        def inner():
-            # this inner will *not* have a closure
-            return a
-        return echo
-    g1 = g(1)
-    g2 = g(2)
-    g1() # raises NameError on 'a'
-    a=5
-    g2() # returns 5
-
-`g1` and `g2` *will* be sendable with IPython, and will treat the engine's namespace as
-globals().  The :meth:`pull` method is implemented based on this principal.  If we did not
-provide pull, you could implement it yourself with `apply`, by simply returning objects out
-of the global namespace:
-
-.. sourcecode:: ipython
-
-    In [10]: view.apply(lambda : a)
-    
-    # is equivalent to
-    In [11]: view.pull('a')
-
-Running Code
-============
-
-There are two principal units of execution in Python: strings of Python code (e.g. 'a=5'),
-and Python functions.  IPython is designed around the use of functions via the core
-Client method, called `apply`.
-
-Apply
------
-
-The principal method of remote execution is :meth:`apply`, of View objects. The Client provides
-the full execution and communication API for engines via its low-level
-:meth:`send_apply_message` method.
-
-f : function
-    The fuction to be called remotely
-args : tuple/list
-    The positional arguments passed to `f`
-kwargs : dict
-    The keyword arguments passed to `f`
-
-flags for all views:
-
-block : bool (default: view.block)
-    Whether to wait for the result, or return immediately.
-    False:
-        returns AsyncResult
-    True:
-        returns actual result(s) of f(*args, **kwargs)
-        if multiple targets:
-            list of results, matching `targets`
-track : bool [default view.track]
-    whether to track non-copying sends.
-
-targets : int,list of ints, 'all', None [default view.targets]
-    Specify the destination of the job.
-    if 'all' or None:
-        Run on all active engines
-    if list:
-        Run on each specified engine
-    if int:
-        Run on single engine
-
-Note that LoadBalancedView uses targets to restrict possible destinations.  LoadBalanced calls
-will always execute in just one location.
-
-flags only in LoadBalancedViews:
-
-after : Dependency or collection of msg_ids
-    Only for load-balanced execution (targets=None)
-    Specify a list of msg_ids as a time-based dependency.
-    This job will only be run *after* the dependencies
-    have been met.
-    
-follow : Dependency or collection of msg_ids
-    Only for load-balanced execution (targets=None)
-    Specify a list of msg_ids as a location-based dependency.
-    This job will only be run on an engine where this dependency
-    is met.
-
-timeout : float/int or None
-    Only for load-balanced execution (targets=None)
-    Specify an amount of time (in seconds) for the scheduler to
-    wait for dependencies to be met before failing with a
-    DependencyTimeout.
-
-execute and run
----------------
-
-For executing strings of Python code, :class:`DirectView`s also provide an :meth:`execute` and a
-:meth:`run` method, which rather than take functions and arguments, take simple strings.
-`execute` simply takes a string of Python code to execute, and sends it to the Engine(s). `run`
-is the same as `execute`, but for a *file*, rather than a string. It is simply a wrapper that
-does something very similar to ``execute(open(f).read())``.
-
-.. note::
-
-    TODO: Example
-
-Views
-=====
-
-The principal extension of the :class:`~parallel.Client` is the
-:class:`~parallel.View` class. The client
-
-
-DirectView
-----------
-
-The :class:`.DirectView` is the class for the IPython :ref:`Multiplexing Interface
-<parallel_multiengine>`.
-
-Creating a DirectView
-*********************
-
-DirectViews can be created in two ways, by index access to a client, or by a client's
-:meth:`view` method.  Index access to a Client works in a few ways.  First, you can create
-DirectViews to single engines simply by accessing the client by engine id:
-
-.. sourcecode:: ipython
-
-    In [2]: rc[0]
-    Out[2]: <DirectView 0>
-
-You can also create a DirectView with a list of engines:
-
-.. sourcecode:: ipython
-
-    In [2]: rc[0,1,2]
-    Out[2]: <DirectView [0,1,2]>
-
-Other methods for accessing elements, such as slicing and negative indexing, work by passing
-the index directly to the client's :attr:`ids` list, so:
-
-.. sourcecode:: ipython
-
-    # negative index
-    In [2]: rc[-1]
-    Out[2]: <DirectView 3>
-    
-    # or slicing:
-    In [3]: rc[::2]
-    Out[3]: <DirectView [0,2]>
-
-are always the same as:
-
-.. sourcecode:: ipython
-
-    In [2]: rc[rc.ids[-1]]
-    Out[2]: <DirectView 3>
-    
-    In [3]: rc[rc.ids[::2]]
-    Out[3]: <DirectView [0,2]>
-
-Also note that the slice is evaluated at the time of construction of the DirectView, so the 
-targets will not change over time if engines are added/removed from the cluster.
-
-Execution via DirectView
-************************
-
-The DirectView is the simplest way to work with one or more engines directly (hence the name).
-
-
-Data movement via DirectView
-****************************
-
-Since a Python namespace is just a :class:`dict`, :class:`DirectView` objects provide
-dictionary-style access by key and methods such as :meth:`get` and
-:meth:`update` for convenience. This make the remote namespaces of the engines
-appear as a local dictionary. Underneath, these methods call :meth:`apply`:
-
-.. sourcecode:: ipython
-
-    In [51]: dview['a']=['foo','bar']
-
-    In [52]: dview['a']
-    Out[52]: [ ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'] ]
-
-Scatter and gather
-------------------
-
-Sometimes it is useful to partition a sequence and push the partitions to
-different engines. In MPI language, this is know as scatter/gather and we
-follow that terminology. However, it is important to remember that in
-IPython's :class:`Client` class, :meth:`scatter` is from the
-interactive IPython session to the engines and :meth:`gather` is from the
-engines back to the interactive IPython session. For scatter/gather operations
-between engines, MPI should be used:
-
-.. sourcecode:: ipython
-
-    In [58]: dview.scatter('a',range(16))
-    Out[58]: [None,None,None,None]
-
-    In [59]: dview['a']
-    Out[59]: [ [0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15] ]
-
-    In [60]: dview.gather('a')
-    Out[60]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
-
-Push and pull
--------------
-
-push
-
-pull
-
-
-
-
-    
-LoadBalancedView
-----------------
-
-The :class:`.LoadBalancedView` 
-
-
-Data Movement
-=============
-
-Reference
-
-Results
-=======
-
-AsyncResults
-------------
-
-Our primary representation is the AsyncResult object, based on the object of the same name in
-the built-in :mod:`multiprocessing.pool` module. Our version provides a superset of that
-interface.
-
-The basic principle of the AsyncResult is the encapsulation of one or more results not yet completed.  Execution methods (including data movement, such as push/pull) will all return
-AsyncResults when `block=False`.
-
-The mp.pool.AsyncResult interface
----------------------------------
-
-The basic interface of the AsyncResult is exactly that of the AsyncResult in :mod:`multiprocessing.pool`, and consists of four methods:
-
-.. AsyncResult spec directly from docs.python.org
-
-.. class:: AsyncResult
-
-   The stdlib AsyncResult spec
-   
-   .. method:: wait([timeout])
-
-      Wait until the result is available or until *timeout* seconds pass. This
-      method always returns ``None``.
-
-   .. method:: ready()
-
-      Return whether the call has completed.
-
-   .. method:: successful()
-
-      Return whether the call completed without raising an exception.  Will
-      raise :exc:`AssertionError` if the result is not ready.
-
-   .. method:: get([timeout])
-
-      Return the result when it arrives.  If *timeout* is not ``None`` and the
-      result does not arrive within *timeout* seconds then
-      :exc:`TimeoutError` is raised.  If the remote call raised
-      an exception then that exception will be reraised as a :exc:`RemoteError`
-      by :meth:`get`.
-
-
-While an AsyncResult is not done, you can check on it with its :meth:`ready` method, which will
-return whether the AR is done. You can also wait on an AsyncResult with its :meth:`wait` method.
-This method blocks until the result arrives. If you don't want to wait forever, you can pass a
-timeout (in seconds) as an argument to :meth:`wait`. :meth:`wait` will *always return None*, and
-should never raise an error.
-
-:meth:`ready` and :meth:`wait` are insensitive to the success or failure of the call. After a
-result is done, :meth:`successful` will tell you whether the call completed without raising an
-exception.
-
-If you actually want the result of the call, you can use :meth:`get`. Initially, :meth:`get`
-behaves just like :meth:`wait`, in that it will block until the result is ready, or until a
-timeout is met. However, unlike :meth:`wait`, :meth:`get` will raise a :exc:`TimeoutError` if
-the timeout is reached and the result is still not ready. If the result arrives before the
-timeout is reached, then :meth:`get` will return the result itself if no exception was raised,
-and will raise an exception if there was.
-
-Here is where we start to expand on the multiprocessing interface. Rather than raising the
-original exception, a RemoteError will be raised, encapsulating the remote exception with some
-metadata. If the AsyncResult represents multiple calls (e.g. any time `targets` is plural), then
-a CompositeError, a subclass of RemoteError, will be raised.
-
-.. seealso::
-
-    For more information on remote exceptions, see :ref:`the section in the Direct Interface
-    <Parallel_exceptions>`.
-
-Extended interface
-******************
-
-
-Other extensions of the AsyncResult interface include convenience wrappers for :meth:`get`.
-AsyncResults have a property, :attr:`result`, with the short alias :attr:`r`, which simply call
-:meth:`get`. Since our object is designed for representing *parallel* results, it is expected
-that many calls (any of those submitted via DirectView) will map results to engine IDs. We
-provide a :meth:`get_dict`, which is also a wrapper on :meth:`get`, which returns a dictionary
-of the individual results, keyed by engine ID.
-
-You can also prevent a submitted job from actually executing, via the AsyncResult's :meth:`abort` method.  This will instruct engines to not execute the job when it arrives.
-
-The larger extension of the AsyncResult API is the :attr:`metadata` attribute.  The metadata
-is a dictionary (with attribute access) that contains, logically enough, metadata about the
-execution.
-
-Metadata keys:
-
-timestamps
-
-submitted
-    When the task left the Client
-started
-    When the task started execution on the engine
-completed
-    When execution finished on the engine
-received
-    When the result arrived on the Client
-    
-    note that it is not known when the result arrived in 0MQ on the client, only when it
-    arrived in Python via :meth:`Client.spin`, so in interactive use, this may not be
-    strictly informative.
-
-Information about the engine
-
-engine_id
-    The integer id
-engine_uuid
-    The UUID of the engine
-
-output of the call
-
-pyerr
-    Python exception, if there was one
-pyout
-    Python output
-stderr
-    stderr stream
-stdout
-    stdout (e.g. print) stream
-
-And some extended information
-
-status
-    either 'ok' or 'error'
-msg_id
-    The UUID of the message
-after
-    For tasks: the time-based msg_id dependencies
-follow
-    For tasks: the location-based msg_id dependencies
-
-While in most cases, the Clients that submitted a request will be the ones using the results,
-other Clients can also request results directly from the Hub. This is done via the Client's
-:meth:`get_result` method. This method will *always* return an AsyncResult object. If the call
-was not submitted by the client, then it will be a subclass, called :class:`AsyncHubResult`.
-These behave in the same way as an AsyncResult, but if the result is not ready, waiting on an
-AsyncHubResult polls the Hub, which is much more expensive than the passive polling used
-in regular AsyncResults.
-
-
-The Client keeps track of all results
-history, results, metadata
-
-Querying the Hub
-================
-
-The Hub sees all traffic that may pass through the schedulers between engines and clients.
-It does this so that it can track state, allowing multiple clients to retrieve results of
-computations submitted by their peers, as well as persisting the state to a database.
-
-queue_status
-
-    You can check the status of the queues of the engines with this command.
-
-result_status
-
-    check on results
-
-purge_results
-
-    forget results (conserve resources)
-
-Controlling the Engines
-=======================
-
-There are a few actions you can do with Engines that do not involve execution.  These
-messages are sent via the Control socket, and bypass any long queues of waiting execution
-jobs
-
-abort
-
-    Sometimes you may want to prevent a job you have submitted from actually running. The method
-    for this is :meth:`abort`. It takes a container of msg_ids, and instructs the Engines to not
-    run the jobs if they arrive. The jobs will then fail with an AbortedTask error.
-
-clear
-
-    You may want to purge the Engine(s) namespace of any data you have left in it.  After
-    running `clear`, there will be no names in the Engine's namespace
-
-shutdown
-
-    You can also instruct engines (and the Controller) to terminate from a Client.  This 
-    can be useful when a job is finished, since you can shutdown all the processes with a
-    single command.
-
-Synchronization
-===============
-
-Since the Client is a synchronous object, events do not automatically trigger in your
-interactive session - you must poll the 0MQ sockets for incoming messages.  Note that 
-this polling *does not* actually make any network requests.  It simply performs a `select`
-operation, to check if messages are already in local memory, waiting to be handled.
-
-The method that handles incoming messages is :meth:`spin`. This method flushes any waiting
-messages on the various incoming sockets, and updates the state of the Client.
-
-If you need to wait for particular results to finish, you can use the :meth:`wait` method,
-which will call :meth:`spin` until the messages are no longer outstanding. Anything that
-represents a collection of messages, such as a list of msg_ids or one or more AsyncResult
-objects, can be passed as argument to wait. A timeout can be specified, which will prevent
-the call from blocking for more than a specified time, but the default behavior is to wait
-forever.
-
-
-
-The client also has an `outstanding` attribute - a ``set`` of msg_ids that are awaiting replies.
-This is the default if wait is called with no arguments - i.e. wait on *all* outstanding
-messages.
-
-
-.. note::
-
-    TODO wait example
-
-Map
-===
-
-Many parallel computing problems can be expressed as a `map`, or running a single program with a
-variety of different inputs. Python has a built-in :py-func:`map`, which does exactly this, and
-many parallel execution tools in Python, such as the built-in :py-class:`multiprocessing.Pool`
-object provide implementations of `map`. All View objects provide a :meth:`map` method as well,
-but the load-balanced and direct implementations differ.
-
-Views' map methods can be called on any number of sequences, but they can also take the `block`
-and `bound` keyword arguments, just like :meth:`~client.apply`, but *only as keywords*.
-
-.. sourcecode:: python
-
-    dview.map(*sequences, block=None)
-
-
-* iter, map_async, reduce
-
-Decorators and RemoteFunctions
-==============================
-
-@parallel
-
-@remote
-
-RemoteFunction
-
-ParallelFunction
-
-Dependencies
-============
-
-@depend
-
-@require
-
-Dependency
diff --git a/docs/source/parallel/parallel_intro.txt b/docs/source/parallel/parallel_intro.txt
deleted file mode 100644
index 507b047effe..00000000000
--- a/docs/source/parallel/parallel_intro.txt
+++ /dev/null
@@ -1,253 +0,0 @@
-.. _ip1par:
-
-============================
-Overview and getting started
-============================
-
-Introduction
-============
-
-This section gives an overview of IPython's sophisticated and powerful
-architecture for parallel and distributed computing. This architecture
-abstracts out parallelism in a very general way, which enables IPython to
-support many different styles of parallelism including:
-
-* Single program, multiple data (SPMD) parallelism.
-* Multiple program, multiple data (MPMD) parallelism.
-* Message passing using MPI.
-* Task farming.
-* Data parallel.
-* Combinations of these approaches.
-* Custom user defined approaches.
-
-Most importantly, IPython enables all types of parallel applications to
-be developed, executed, debugged and monitored *interactively*. Hence,
-the ``I`` in IPython.  The following are some example usage cases for IPython:
-
-* Quickly parallelize algorithms that are embarrassingly parallel
-  using a number of simple approaches.  Many simple things can be
-  parallelized interactively in one or two lines of code.
-
-* Steer traditional MPI applications on a supercomputer from an
-  IPython session on your laptop.
-
-* Analyze and visualize large datasets (that could be remote and/or
-  distributed) interactively using IPython and tools like
-  matplotlib/TVTK.
-
-* Develop, test and debug new parallel algorithms 
-  (that may use MPI) interactively.
-
-* Tie together multiple MPI jobs running on different systems into
-  one giant distributed and parallel system.
-
-* Start a parallel job on your cluster and then have a remote 	
-  collaborator connect to it and pull back data into their 
-  local IPython session for plotting and analysis.
-
-* Run a set of tasks on a set of CPUs using dynamic load balancing.
-
-Architecture overview
-=====================
-
-The IPython architecture consists of four components:
-
-* The IPython engine.
-* The IPython hub.
-* The IPython schedulers.
-* The controller client.
-
-These components live in the :mod:`IPython.parallel` package and are
-installed with IPython.  They do, however, have additional dependencies
-that must be installed.  For more information, see our
-:ref:`installation documentation <install_index>`.
-
-.. TODO: include zmq in install_index
-
-IPython engine
----------------
-
-The IPython engine is a Python instance that takes Python commands over a
-network connection. Eventually, the IPython engine will be a full IPython
-interpreter, but for now, it is a regular Python interpreter. The engine
-can also handle incoming and outgoing Python objects sent over a network
-connection.  When multiple engines are started, parallel and distributed
-computing becomes possible. An important feature of an IPython engine is
-that it blocks while user code is being executed. Read on for how the
-IPython controller solves this problem to expose a clean asynchronous API
-to the user.
-
-IPython controller
-------------------
-
-The IPython controller processes provide an interface for working with a set of engines.
-At a general level, the controller is a collection of processes to which IPython engines
-and clients can connect. The controller is composed of a :class:`Hub` and a collection of
-:class:`Schedulers`. These Schedulers are typically run in separate processes but on the
-same machine as the Hub, but can be run anywhere from local threads or on remote machines.
-
-The controller also provides a single point of contact for users who wish to
-utilize the engines connected to the controller. There are different ways of
-working with a controller. In IPython, all of these models are implemented via
-the client's :meth:`.View.apply` method, with various arguments, or
-constructing :class:`.View` objects to represent subsets of engines. The two
-primary models for interacting with engines are:
-
-* A **Direct** interface, where engines are addressed explicitly.
-* A **LoadBalanced** interface, where the Scheduler is trusted with assigning work to
-  appropriate engines.
-
-Advanced users can readily extend the View models to enable other
-styles of parallelism. 
-
-.. note:: 
-
-    A single controller and set of engines can be used with multiple models
-    simultaneously. This opens the door for lots of interesting things.
-
-
-The Hub
-*******
-
-The center of an IPython cluster is the Hub. This is the process that keeps
-track of engine connections, schedulers, clients, as well as all task requests and
-results. The primary role of the Hub is to facilitate queries of the cluster state, and
-minimize the necessary information required to establish the many connections involved in
-connecting new clients and engines.
-
-
-Schedulers
-**********
-
-All actions that can be performed on the engine go through a Scheduler. While the engines
-themselves block when user code is run, the schedulers hide that from the user to provide
-a fully asynchronous interface to a set of engines.
-
-
-IPython client and views
-------------------------
-
-There is one primary object, the :class:`~.parallel.Client`, for connecting to a cluster.
-For each execution model, there is a corresponding :class:`~.parallel.View`. These views
-allow users to interact with a set of engines through the interface. Here are the two default
-views:
-
-* The :class:`DirectView` class for explicit addressing.
-* The :class:`LoadBalancedView` class for destination-agnostic scheduling.
-
-Security
---------
-
-IPython uses ZeroMQ for networking, which has provided many advantages, but
-one of the setbacks is its utter lack of security [ZeroMQ]_. By default, no IPython
-connections are encrypted, but open ports only listen on localhost. The only
-source of security for IPython is via ssh-tunnel. IPython supports both shell
-(`openssh`) and `paramiko` based tunnels for connections.  There is a key necessary
-to submit requests, but due to the lack of encryption, it does not provide
-significant security if loopback traffic is compromised.
-
-In our architecture, the controller is the only process that listens on
-network ports, and is thus the main point of vulnerability. The standard model
-for secure connections is to designate that the controller listen on
-localhost, and use ssh-tunnels to connect clients and/or
-engines.
-
-To connect and authenticate to the controller an engine or client needs
-some information that the controller has stored in a JSON file.
-Thus, the JSON files need to be copied to a location where
-the clients and engines can find them. Typically, this is the
-:file:`~/.ipython/cluster_default/security` directory on the host where the 
-client/engine is running (which could be a different host than the controller). 
-Once the JSON files are copied over, everything should work fine.
-
-Currently, there are two JSON files that the controller creates:
-
-ipcontroller-engine.json
-    This JSON file has the information necessary for an engine to connect
-    to a controller.
-
-ipcontroller-client.json
-    The client's connection information.  This may not differ from the engine's,
-    but since the controller may listen on different ports for clients and
-    engines, it is stored separately.
-
-More details of how these JSON files are used are given below.
-
-A detailed description of the security model and its implementation in IPython
-can be found :ref:`here <parallelsecurity>`.
-
-.. warning::
-
-    Even at its most secure, the Controller listens on ports on localhost, and
-    every time you make a tunnel, you open a localhost port on the connecting
-    machine that points to the Controller. If localhost on the Controller's
-    machine, or the machine of any client or engine, is untrusted, then your
-    Controller is insecure. There is no way around this with ZeroMQ.
-
-
-
-Getting Started
-===============
-
-To use IPython for parallel computing, you need to start one instance of the
-controller and one or more instances of the engine. Initially, it is best to
-simply start a controller and engines on a single host using the
-:command:`ipcluster` command. To start a controller and 4 engines on your
-localhost, just do::
-
-    $ ipcluster start -n 4
-
-More details about starting the IPython controller and engines can be found
-:ref:`here <parallel_process>`
-
-Once you have started the IPython controller and one or more engines, you
-are ready to use the engines to do something useful. To make sure
-everything is working correctly, try the following commands:
-
-.. sourcecode:: ipython
-
-	In [1]: from IPython.parallel import Client
-	
-	In [2]: c = Client()
-	
-	In [4]: c.ids
-	Out[4]: set([0, 1, 2, 3])
-	
-	In [5]: c[:].apply_sync(lambda : "Hello, World")
-	Out[5]: [ 'Hello, World', 'Hello, World', 'Hello, World', 'Hello, World' ]
-
-
-When a client is created with no arguments, the client tries to find the corresponding JSON file
-in the local `~/.ipython/cluster_default/security` directory. Or if you specified a profile,
-you can use that with the Client.  This should cover most cases:
-
-.. sourcecode:: ipython
-
-    In [2]: c = Client(profile='myprofile')
-
-If you have put the JSON file in a different location or it has a different name, create the
-client like this:
-
-.. sourcecode:: ipython
-
-    In [2]: c = Client('/path/to/my/ipcontroller-client.json')
-
-Remember, a client needs to be able to see the Hub's ports to connect. So if they are on a
-different machine, you may need to use an ssh server to tunnel access to that machine,
-then you would connect to it with:
-
-.. sourcecode:: ipython
-
-    In [2]: c = Client(sshserver='myhub.example.com')
-
-Where 'myhub.example.com' is the url or IP address of the machine on
-which the Hub process is running (or another machine that has direct access to the Hub's ports).
-
-The SSH server may already be specified in ipcontroller-client.json, if the controller was
-instructed at its launch time.
-
-You are now ready to learn more about the :ref:`Direct
-<parallel_multiengine>` and :ref:`LoadBalanced <parallel_task>` interfaces to the
-controller.
-
-.. [ZeroMQ] ZeroMQ.  http://www.zeromq.org
diff --git a/docs/source/parallel/parallel_mpi.txt b/docs/source/parallel/parallel_mpi.txt
deleted file mode 100644
index e0fee30c7db..00000000000
--- a/docs/source/parallel/parallel_mpi.txt
+++ /dev/null
@@ -1,156 +0,0 @@
-.. _parallelmpi:
-
-=======================
-Using MPI with IPython
-=======================
-
-.. note::
-
-    Not adapted to zmq yet
-    This is out of date wrt ipcluster in general as well
-
-Often, a parallel algorithm will require moving data between the engines. One
-way of accomplishing this is by doing a pull and then a push using the
-multiengine client. However, this will be slow as all the data has to go
-through the controller to the client and then back through the controller, to
-its final destination.
-
-A much better way of moving data between engines is to use a message passing
-library, such as the Message Passing Interface (MPI) [MPI]_. IPython's
-parallel computing architecture has been designed from the ground up to
-integrate with MPI. This document describes how to use MPI with IPython.
-
-Additional installation requirements
-====================================
-
-If you want to use MPI with IPython, you will need to install:
-
-* A standard MPI implementation such as OpenMPI [OpenMPI]_ or MPICH.
-* The mpi4py [mpi4py]_ package.
-
-.. note::
-
-    The mpi4py package is not a strict requirement. However, you need to
-    have *some* way of calling MPI from Python. You also need some way of
-    making sure that :func:`MPI_Init` is called when the IPython engines start
-    up. There are a number of ways of doing this and a good number of
-    associated subtleties. We highly recommend just using mpi4py as it
-    takes care of most of these problems. If you want to do something
-    different, let us know and we can help you get started.
-
-Starting the engines with MPI enabled
-=====================================
-
-To use code that calls MPI, there are typically two things that MPI requires.
-
-1. The process that wants to call MPI must be started using
-   :command:`mpiexec` or a batch system (like PBS) that has MPI support.
-2. Once the process starts, it must call :func:`MPI_Init`.
-
-There are a couple of ways that you can start the IPython engines and get
-these things to happen.
-
-Automatic starting using :command:`mpiexec` and :command:`ipcluster`
---------------------------------------------------------------------
-
-The easiest approach is to use the `mpiexec` mode of :command:`ipcluster`,
-which will first start a controller and then a set of engines using
-:command:`mpiexec`::
-
-    $ ipcluster mpiexec -n 4
-
-This approach is best as interrupting :command:`ipcluster` will automatically
-stop and clean up the controller and engines.
-
-Manual starting using :command:`mpiexec`
-----------------------------------------
-
-If you want to start the IPython engines using the :command:`mpiexec`, just
-do::
-
-    $ mpiexec -n 4 ipengine --mpi=mpi4py
-
-This requires that you already have a controller running and that the FURL
-files for the engines are in place. We also have built in support for
-PyTrilinos [PyTrilinos]_, which can be used (assuming is installed) by
-starting the engines with::
-
-    $ mpiexec -n 4 ipengine --mpi=pytrilinos
-
-Automatic starting using PBS and :command:`ipcluster`
-------------------------------------------------------
-
-The :command:`ipcluster` command also has built-in integration with PBS. For
-more information on this approach, see our documentation on :ref:`ipcluster
-<parallel_process>`.
-
-Actually using MPI
-==================
-
-Once the engines are running with MPI enabled, you are ready to go. You can
-now call any code that uses MPI in the IPython engines. And, all of this can
-be done interactively. Here we show a simple example that uses mpi4py
-[mpi4py]_ version 1.1.0 or later.
-
-First, lets define a simply function that uses MPI to calculate the sum of a
-distributed array. Save the following text in a file called :file:`psum.py`:
-
-.. sourcecode:: python
-
-    from mpi4py import MPI
-    import numpy as np
-
-    def psum(a):
-        s = np.sum(a)
-        rcvBuf = np.array(0.0,'d')
-        MPI.COMM_WORLD.Allreduce([s, MPI.DOUBLE],
-            [rcvBuf, MPI.DOUBLE],
-            op=MPI.SUM)
-        return rcvBuf
-
-Now, start an IPython cluster::
-
-    $ ipcluster start -p mpi -n 4
-    
-.. note::
-
-    It is assumed here that the mpi profile has been set up, as described :ref:`here
-    <parallel_process>`.
-
-Finally, connect to the cluster and use this function interactively. In this
-case, we create a random array on each engine and sum up all the random arrays
-using our :func:`psum` function:
-
-.. sourcecode:: ipython
-
-    In [1]: from IPython.parallel import Client
-    
-    In [2]: %load_ext parallel_magic
-    
-    In [3]: c = Client(profile='mpi')
-    
-    In [4]: view = c[:]
-    
-    In [5]: view.activate()
-    
-    # run the contents of the file on each engine:
-    In [6]: view.run('psum.py')
-    
-    In [6]: px a = np.random.rand(100)
-    Parallel execution on engines: [0,1,2,3]
-    
-    In [8]: px s = psum(a)
-    Parallel execution on engines: [0,1,2,3]
-    
-    In [9]: view['s']
-    Out[9]: [187.451545803,187.451545803,187.451545803,187.451545803]
-
-Any Python code that makes calls to MPI can be used in this manner, including
-compiled C, C++ and Fortran libraries that have been exposed to Python.
-
-.. [MPI] Message Passing Interface.  http://www-unix.mcs.anl.gov/mpi/
-.. [mpi4py] MPI for Python. mpi4py: http://mpi4py.scipy.org/
-.. [OpenMPI] Open MPI. http://www.open-mpi.org/
-.. [PyTrilinos] PyTrilinos. http://trilinos.sandia.gov/packages/pytrilinos/
-
-
diff --git a/docs/source/parallel/parallel_multiengine.txt b/docs/source/parallel/parallel_multiengine.txt
deleted file mode 100644
index b25bc9fa04b..00000000000
--- a/docs/source/parallel/parallel_multiengine.txt
+++ /dev/null
@@ -1,843 +0,0 @@
-.. _parallel_multiengine:
-
-==========================
-IPython's Direct interface
-==========================
-
-The direct, or multiengine, interface represents one possible way of working with a set of
-IPython engines. The basic idea behind the multiengine interface is that the
-capabilities of each engine are directly and explicitly exposed to the user.
-Thus, in the multiengine interface, each engine is given an id that is used to
-identify the engine and give it work to do. This interface is very intuitive
-and is designed with interactive usage in mind, and is the best place for
-new users of IPython to begin.
-
-Starting the IPython controller and engines
-===========================================
-
-To follow along with this tutorial, you will need to start the IPython
-controller and four IPython engines. The simplest way of doing this is to use
-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.
-
-Creating a ``Client`` instance
-==============================
-
-The first step is to import the IPython :mod:`IPython.parallel`
-module and then create a :class:`.Client` instance:
-
-.. sourcecode:: ipython
-
-    In [1]: from IPython.parallel import Client
-    
-    In [2]: rc = Client()
-
-This form assumes that the default connection information (stored in
-:file:`ipcontroller-client.json` found in :file:`IPYTHON_DIR/cluster_default/security`) is
-accurate. If the controller was started on a remote machine, you must copy that connection
-file to the client machine, or enter its contents as arguments to the Client constructor:
-
-.. sourcecode:: ipython
-
-    # If you have copied the json connector file from the controller:
-    In [2]: rc = Client('/path/to/ipcontroller-client.json')
-    # or to connect with a specific profile you have set up:
-    In [3]: rc = Client(profile='mpi')
-    
-
-To make sure there are engines connected to the controller, users can get a list
-of engine ids:
-
-.. sourcecode:: ipython
-
-    In [3]: rc.ids
-    Out[3]: [0, 1, 2, 3]
-
-Here we see that there are four engines ready to do work for us.
-
-For direct execution, we will make use of a :class:`DirectView` object, which can be
-constructed via list-access to the client:
-
-.. sourcecode:: ipython
-
-    In [4]: dview = rc[:] # use all engines
-
-.. seealso::
-
-    For more information, see the in-depth explanation of :ref:`Views <parallel_details>`.
-
-
-Quick and easy parallelism
-==========================
-
-In many cases, you simply want to apply a Python function to a sequence of
-objects, but *in parallel*. The client interface provides a simple way
-of accomplishing this: using the DirectView's :meth:`~DirectView.map` method.
-
-Parallel map
-------------
-
-Python's builtin :func:`map` functions allows a function to be applied to a
-sequence element-by-element. This type of code is typically trivial to
-parallelize. In fact, since IPython's interface is all about functions anyway,
-you can just use the builtin :func:`map` with a :class:`RemoteFunction`, or a 
-DirectView's :meth:`map` method:
-
-.. sourcecode:: ipython
-
-    In [62]: serial_result = map(lambda x:x**10, range(32))
-    
-    In [63]: parallel_result = dview.map_sync(lambda x: x**10, range(32))
-
-    In [67]: serial_result==parallel_result
-    Out[67]: True
-
-
-.. note::
-
-    The :class:`DirectView`'s version of :meth:`map` does
-    not do dynamic load balancing. For a load balanced version, use a
-    :class:`LoadBalancedView`.
-
-.. seealso::
-    
-    :meth:`map` is implemented via :class:`ParallelFunction`.
-
-Remote function decorators
---------------------------
-
-Remote functions are just like normal functions, but when they are called,
-they execute on one or more engines, rather than locally. IPython provides
-two decorators:
-
-.. sourcecode:: ipython
-
-    In [10]: @dview.remote(block=True)
-        ...: def getpid():
-        ...:     import os
-        ...:     return os.getpid()
-        ...: 
-
-    In [11]: getpid()
-    Out[11]: [12345, 12346, 12347, 12348]
-
-The ``@parallel`` decorator creates parallel functions, that break up an element-wise
-operations and distribute them, reconstructing the result.
-
-.. sourcecode:: ipython
-
-    In [12]: import numpy as np
-    
-    In [13]: A = np.random.random((64,48))
-    
-    In [14]: @dview.parallel(block=True)
-        ...: def pmul(A,B):
-        ...:     return A*B
-    
-    In [15]: C_local = A*A
-    
-    In [16]: C_remote = pmul(A,A)
-    
-    In [17]: (C_local == C_remote).all()
-    Out[17]: True
-
-.. seealso::
-
-    See the docstrings for the :func:`parallel` and :func:`remote` decorators for
-    options.
-
-Calling Python functions
-========================
-
-The most basic type of operation that can be performed on the engines is to
-execute Python code or call Python functions. Executing Python code can be
-done in blocking or non-blocking mode (non-blocking is default) using the
-:meth:`.View.execute` method, and calling functions can be done via the
-:meth:`.View.apply` method.
-
-apply
------
-
-The main method for doing remote execution (in fact, all methods that
-communicate with the engines are built on top of it), is :meth:`View.apply`.
-
-We strive to provide the cleanest interface we can, so `apply` has the following
-signature:
-
-.. sourcecode:: python
-
-    view.apply(f, *args, **kwargs)
-
-There are various ways to call functions with IPython, and these flags are set as
-attributes of the View.  The ``DirectView`` has just two of these flags:
-
-dv.block : bool
-    whether to wait for the result, or return an :class:`AsyncResult` object
-    immediately
-dv.track : bool
-    whether to instruct pyzmq to track when 
-    This is primarily useful for non-copying sends of numpy arrays that you plan to
-    edit in-place.  You need to know when it becomes safe to edit the buffer
-    without corrupting the message.
-
-
-Creating a view is simple: index-access on a client creates a :class:`.DirectView`.
-
-.. sourcecode:: ipython
-
-    In [4]: view = rc[1:3]
-    Out[4]: <DirectView [1, 2]>
-
-    In [5]: view.apply<tab>
-    view.apply  view.apply_async  view.apply_sync
-
-For convenience, you can set block temporarily for a single call with the extra sync/async methods.
-
-Blocking execution
-------------------
-
-In blocking mode, the :class:`.DirectView` object (called ``dview`` in
-these examples) submits the command to the controller, which places the
-command in the engines' queues for execution. The :meth:`apply` call then
-blocks until the engines are done executing the command:
-
-.. sourcecode:: ipython
-
-    In [2]: dview = rc[:] # A DirectView of all engines
-    In [3]: dview.block=True
-    In [4]: dview['a'] = 5
-
-    In [5]: dview['b'] = 10
-
-    In [6]: dview.apply(lambda x: a+b+x, 27)
-    Out[6]: [42, 42, 42, 42]
-
-You can also select blocking execution on a call-by-call basis with the :meth:`apply_sync`
-method:
-
-    In [7]: dview.block=False
-
-    In [8]: dview.apply_sync(lambda x: a+b+x, 27)
-    Out[8]: [42, 42, 42, 42]
-
-Python commands can be executed as strings on specific engines by using a View's ``execute``
-method:
-
-.. sourcecode:: ipython
-
-    In [6]: rc[::2].execute('c=a+b')
-
-    In [7]: rc[1::2].execute('c=a-b')
-
-    In [8]: dview['c'] # shorthand for dview.pull('c', block=True)
-    Out[8]: [15, -5, 15, -5]
-
-
-Non-blocking execution
-----------------------
-
-In non-blocking mode, :meth:`apply` submits the command to be executed and
-then returns a :class:`AsyncResult` object immediately. The
-:class:`AsyncResult` object gives you a way of getting a result at a later
-time through its :meth:`get` method.
-
-.. Note::
-
-    The :class:`AsyncResult` object provides a superset of the interface in 
-    :py:class:`multiprocessing.pool.AsyncResult`.  See the 
-    `official Python documentation <http://docs.python.org/library/multiprocessing#multiprocessing.pool.AsyncResult>`_
-    for more.
-
-
-This allows you to quickly submit long running commands without blocking your
-local Python/IPython session:
-
-.. sourcecode:: ipython
-    
-    # define our function
-    In [6]: def wait(t):
-       ...:     import time
-       ...:     tic = time.time()
-       ...:     time.sleep(t)
-       ...:     return time.time()-tic
-    
-    # In non-blocking mode
-    In [7]: ar = dview.apply_async(wait, 2)
-
-    # Now block for the result
-    In [8]: ar.get()
-    Out[8]: [2.0006198883056641, 1.9997570514678955, 1.9996809959411621, 2.0003249645233154]
-
-    # Again in non-blocking mode
-    In [9]: ar = dview.apply_async(wait, 10)
-
-    # Poll to see if the result is ready
-    In [10]: ar.ready()
-    Out[10]: False
-    
-    # ask for the result, but wait a maximum of 1 second:
-    In [45]: ar.get(1)
-    ---------------------------------------------------------------------------
-    TimeoutError                              Traceback (most recent call last)
-    /home/you/<ipython-input-45-7cd858bbb8e0> in <module>()
-    ----> 1 ar.get(1)
-
-    /path/to/site-packages/IPython/parallel/asyncresult.pyc in get(self, timeout)
-         62                 raise self._exception
-         63         else:
-    ---> 64             raise error.TimeoutError("Result not ready.")
-         65 
-         66     def ready(self):
-
-    TimeoutError: Result not ready.
-
-.. Note::
-
-    Note the import inside the function. This is a common model, to ensure
-    that the appropriate modules are imported where the task is run. You can
-    also manually import modules into the engine(s) namespace(s) via 
-    :meth:`view.execute('import numpy')`.
-
-Often, it is desirable to wait until a set of :class:`AsyncResult` objects
-are done. For this, there is a the method :meth:`wait`. This method takes a
-tuple of :class:`AsyncResult` objects (or `msg_ids` or indices to the client's History),
-and blocks until all of the associated results are ready:
-
-.. sourcecode:: ipython
-
-    In [72]: dview.block=False
-
-    # A trivial list of AsyncResults objects
-    In [73]: pr_list = [dview.apply_async(wait, 3) for i in range(10)]
-
-    # Wait until all of them are done
-    In [74]: dview.wait(pr_list)
-
-    # Then, their results are ready using get() or the `.r` attribute
-    In [75]: pr_list[0].get()
-    Out[75]: [2.9982571601867676, 2.9982588291168213, 2.9987530708312988, 2.9990990161895752]
-
-
-
-The ``block`` and ``targets`` keyword arguments and attributes
---------------------------------------------------------------
-
-Most DirectView methods (excluding :meth:`apply` and :meth:`map`) accept ``block`` and
-``targets`` as keyword arguments. As we have seen above, these keyword arguments control the
-blocking mode and which engines the command is applied to. The :class:`View` class also has
-:attr:`block` and :attr:`targets` attributes that control the default behavior when the keyword
-arguments are not provided. Thus the following logic is used for :attr:`block` and :attr:`targets`:
-
-* If no keyword argument is provided, the instance attributes are used.
-* Keyword argument, if provided override the instance attributes for
-  the duration of a single call.
-  
-The following examples demonstrate how to use the instance attributes:
-
-.. sourcecode:: ipython
-
-    In [16]: dview.targets = [0,2]
-    
-    In [17]: dview.block = False
-
-    In [18]: ar = dview.apply(lambda : 10)
-
-    In [19]: ar.get()
-    Out[19]: [10, 10]
-
-    In [16]: dview.targets = v.client.ids # all engines (4)
-    
-    In [21]: dview.block = True
-
-    In [22]: dview.apply(lambda : 42)
-    Out[22]: [42, 42, 42, 42]
-
-The :attr:`block` and :attr:`targets` instance attributes of the
-:class:`.DirectView` also determine the behavior of the parallel magic commands.
-
-Parallel magic commands
------------------------
-
-.. warning::
-
-    The magics have not been changed to work with the zeromq system. The
-    magics do work, but *do not* print stdin/out like they used to in IPython.kernel.
-
-We provide a few IPython magic commands (``%px``, ``%autopx`` and ``%result``)
-that make it more pleasant to execute Python commands on the engines
-interactively. These are simply shortcuts to :meth:`execute` and
-:meth:`get_result` of the :class:`DirectView`. The ``%px`` magic executes a single 
-Python command on the engines specified by the :attr:`targets` attribute of the
-:class:`DirectView` instance:
-
-.. sourcecode:: ipython
-
-    # load the parallel magic extension:
-    In [21]: %load_ext parallelmagic
-    
-    # Create a DirectView for all targets
-    In [22]: dv = rc[:]
-    
-    # Make this DirectView active for parallel magic commands
-    In [23]: dv.activate()
-
-    In [24]: dv.block=True
-
-    In [25]: import numpy
-
-    In [26]: %px import numpy
-    Parallel execution on engines: [0, 1, 2, 3]
-
-    In [27]: %px a = numpy.random.rand(2,2)
-    Parallel execution on engines: [0, 1, 2, 3]
-
-    In [28]: %px ev = numpy.linalg.eigvals(a)
-    Parallel execution on engines: [0, 1, 2, 3]
-
-    In [28]: dv['ev']
-    Out[28]: [ array([ 1.09522024, -0.09645227]), 
-               array([ 1.21435496, -0.35546712]), 
-               array([ 0.72180653,  0.07133042]), 
-               array([  1.46384341e+00,   1.04353244e-04])
-             ]
-
-The ``%result`` magic gets the most recent result, or takes an argument
-specifying the index of the result to be requested. It is simply a shortcut to the
-:meth:`get_result` method:
-
-.. sourcecode:: ipython
-    
-    In [29]: dv.apply_async(lambda : ev)
-    
-    In [30]: %result
-    Out[30]: [ [ 1.28167017  0.14197338],
-                [-0.14093616  1.27877273],
-                [-0.37023573  1.06779409],
-                [ 0.83664764 -0.25602658] ]
-
-The ``%autopx`` magic switches to a mode where everything you type is executed
-on the engines given by the :attr:`targets` attribute:
-
-.. sourcecode:: ipython
-
-    In [30]: dv.block=False
-
-    In [31]: %autopx
-    Auto Parallel Enabled
-    Type %autopx to disable
-
-    In [32]: max_evals = []
-    <IPython.parallel.AsyncResult object at 0x17b8a70>
-
-    In [33]: for i in range(100):
-       ....:     a = numpy.random.rand(10,10)
-       ....:     a = a+a.transpose()
-       ....:     evals = numpy.linalg.eigvals(a)
-       ....:     max_evals.append(evals[0].real)
-       ....:
-       ....:
-    <IPython.parallel.AsyncResult object at 0x17af8f0>
-
-    In [34]: %autopx
-    Auto Parallel Disabled
-
-    In [35]: dv.block=True
-
-    In [36]: px ans= "Average max eigenvalue is: %f"%(sum(max_evals)/len(max_evals))
-    Parallel execution on engines: [0, 1, 2, 3]
-    
-    In [37]: dv['ans']
-    Out[37]: [ 'Average max eigenvalue is:  10.1387247332',
-               'Average max eigenvalue is:  10.2076902286',
-               'Average max eigenvalue is:  10.1891484655',
-               'Average max eigenvalue is:  10.1158837784',]
-
-
-Moving Python objects around
-============================
-
-In addition to calling functions and executing code on engines, you can
-transfer Python objects to and from your IPython session and the engines. In
-IPython, these operations are called :meth:`push` (sending an object to the
-engines) and :meth:`pull` (getting an object from the engines).
-
-Basic push and pull
--------------------
-
-Here are some examples of how you use :meth:`push` and :meth:`pull`:
-
-.. sourcecode:: ipython
-
-    In [38]: dview.push(dict(a=1.03234,b=3453))
-    Out[38]: [None,None,None,None]
-
-    In [39]: dview.pull('a')
-    Out[39]: [ 1.03234, 1.03234, 1.03234, 1.03234]
-
-    In [40]: dview.pull('b', targets=0)
-    Out[40]: 3453
-
-    In [41]: dview.pull(('a','b'))
-    Out[41]: [ [1.03234, 3453], [1.03234, 3453], [1.03234, 3453], [1.03234, 3453] ]
-    
-    In [43]: dview.push(dict(c='speed'))
-    Out[43]: [None,None,None,None]
-
-In non-blocking mode :meth:`push` and :meth:`pull` also return
-:class:`AsyncResult` objects:
-
-.. sourcecode:: ipython
-
-    In [48]: ar = dview.pull('a', block=False)
-
-    In [49]: ar.get()
-    Out[49]: [1.03234, 1.03234, 1.03234, 1.03234]
-
-
-Dictionary interface
---------------------
-
-Since a Python namespace is just a :class:`dict`, :class:`DirectView` objects provide
-dictionary-style access by key and methods such as :meth:`get` and
-:meth:`update` for convenience. This make the remote namespaces of the engines
-appear as a local dictionary. Underneath, these methods call :meth:`apply`:
-
-.. sourcecode:: ipython
-
-    In [51]: dview['a']=['foo','bar']
-
-    In [52]: dview['a']
-    Out[52]: [ ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'], ['foo', 'bar'] ]
-
-Scatter and gather
-------------------
-
-Sometimes it is useful to partition a sequence and push the partitions to
-different engines. In MPI language, this is know as scatter/gather and we
-follow that terminology. However, it is important to remember that in
-IPython's :class:`Client` class, :meth:`scatter` is from the
-interactive IPython session to the engines and :meth:`gather` is from the
-engines back to the interactive IPython session. For scatter/gather operations
-between engines, MPI should be used:
-
-.. sourcecode:: ipython
-
-    In [58]: dview.scatter('a',range(16))
-    Out[58]: [None,None,None,None]
-
-    In [59]: dview['a']
-    Out[59]: [ [0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15] ]
-
-    In [60]: dview.gather('a')
-    Out[60]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
-
-Other things to look at
-=======================
-
-How to do parallel list comprehensions
---------------------------------------
-
-In many cases list comprehensions are nicer than using the map function. While
-we don't have fully parallel list comprehensions, it is simple to get the
-basic effect using :meth:`scatter` and :meth:`gather`:
-
-.. sourcecode:: ipython
-
-    In [66]: dview.scatter('x',range(64))
-
-    In [67]: %px y = [i**10 for i in x]
-    Parallel execution on engines: [0, 1, 2, 3]
-    Out[67]:
-
-    In [68]: y = dview.gather('y')
-
-    In [69]: print y
-    [0, 1, 1024, 59049, 1048576, 9765625, 60466176, 282475249, 1073741824,...]
-
-Remote imports
---------------
-
-Sometimes you will want to import packages both in your interactive session
-and on your remote engines.  This can be done with the :class:`ContextManager`
-created by a DirectView's :meth:`sync_imports` method:
-
-.. sourcecode:: ipython
-
-    In [69]: with dview.sync_imports():
-        ...:     import numpy
-    importing numpy on engine(s)
-
-Any imports made inside the block will also be performed on the view's engines.
-sync_imports also takes a `local` boolean flag that defaults to True, which specifies
-whether the local imports should also be performed.  However, support for `local=False`
-has not been implemented, so only packages that can be imported locally will work
-this way.
-
-You can also specify imports via the ``@require`` decorator.  This is a decorator
-designed for use in Dependencies, but can be used to handle remote imports as well.
-Modules or module names passed to ``@require`` will be imported before the decorated
-function is called.  If they cannot be imported, the decorated function will never
-execution, and will fail with an UnmetDependencyError.
-
-.. sourcecode:: ipython
-
-    In [69]: from IPython.parallel import require
-
-    In [70]: @requre('re'):
-        ...: def findall(pat, x):
-        ...:     # re is guaranteed to be available
-        ...:     return re.findall(pat, x)
-          
-    # you can also pass modules themselves, that you already have locally:
-    In [71]: @requre(time):
-        ...: def wait(t):
-        ...:     time.sleep(t)
-        ...:     return t
-
-
-Parallel exceptions
--------------------
-
-In the multiengine interface, parallel commands can raise Python exceptions,
-just like serial commands. But, it is a little subtle, because a single
-parallel command can actually raise multiple exceptions (one for each engine
-the command was run on). To express this idea, we have a
-:exc:`CompositeError` exception class that will be raised in most cases. The
-:exc:`CompositeError` class is a special type of exception that wraps one or
-more other types of exceptions. Here is how it works:
-
-.. sourcecode:: ipython
-
-    In [76]: dview.block=True
-
-    In [77]: dview.execute('1/0')
-    ---------------------------------------------------------------------------
-    CompositeError                            Traceback (most recent call last)
-    /home/you/<ipython-input-10-15c2c22dec39> in <module>()
-    ----> 1 dview.execute('1/0', block=True)
-
-    /path/to/site-packages/IPython/parallel/view.py in execute(self, code, block)
-        460                 default: self.block
-        461         """
-    --> 462         return self.apply_with_flags(util._execute, args=(code,), block=block)
-        463 
-        464     def run(self, filename, block=None):
-
-    /home/you/<string> in apply_with_flags(self, f, args, kwargs, block, track)
-
-    /path/to/site-packages/IPython/parallel/view.py in sync_results(f, self, *args, **kwargs)
-         46 def sync_results(f, self, *args, **kwargs):
-         47     """sync relevant results from self.client to our results attribute."""
-    ---> 48     ret = f(self, *args, **kwargs)
-         49     delta = self.outstanding.difference(self.client.outstanding)
-         50     completed = self.outstanding.intersection(delta)
-
-    /home/you/<string> in apply_with_flags(self, f, args, kwargs, block, track)
-
-    /path/to/site-packages/IPython/parallel/view.py in save_ids(f, self, *args, **kwargs)
-         35     n_previous = len(self.client.history)
-         36     try:
-    ---> 37         ret = f(self, *args, **kwargs)
-         38     finally:
-         39         nmsgs = len(self.client.history) - n_previous
-
-    /path/to/site-packages/IPython/parallel/view.py in apply_with_flags(self, f, args, kwargs, block, track)
-        398         if block:
-        399             try:
-    --> 400                 return ar.get()
-        401             except KeyboardInterrupt:
-        402                 pass
-
-    /path/to/site-packages/IPython/parallel/asyncresult.pyc in get(self, timeout)
-         87                 return self._result
-         88             else:
-    ---> 89                 raise self._exception
-         90         else:
-         91             raise error.TimeoutError("Result not ready.")
-
-    CompositeError: one or more exceptions from call to method: _execute
-    [0:apply]: ZeroDivisionError: integer division or modulo by zero
-    [1:apply]: ZeroDivisionError: integer division or modulo by zero
-    [2:apply]: ZeroDivisionError: integer division or modulo by zero
-    [3:apply]: ZeroDivisionError: integer division or modulo by zero
-
-
-Notice how the error message printed when :exc:`CompositeError` is raised has
-information about the individual exceptions that were raised on each engine.
-If you want, you can even raise one of these original exceptions:
-
-.. sourcecode:: ipython
-
-    In [80]: try:
-       ....:     dview.execute('1/0')
-       ....: except client.CompositeError, e:
-       ....:     e.raise_exception()
-       ....:     
-       ....:     
-    ---------------------------------------------------------------------------
-    ZeroDivisionError                         Traceback (most recent call last)
-
-    /ipython1-client-r3021/docs/examples/<ipython console> in <module>()
-
-    /ipython1-client-r3021/ipython1/kernel/error.pyc in raise_exception(self, excid)
-        156             raise IndexError("an exception with index %i does not exist"%excid)
-        157         else:
-    --> 158             raise et, ev, etb
-        159 
-        160 def collect_exceptions(rlist, method):
-
-    ZeroDivisionError: integer division or modulo by zero
-
-If you are working in IPython, you can simple type ``%debug`` after one of
-these :exc:`CompositeError` exceptions is raised, and inspect the exception
-instance:
-
-.. sourcecode:: ipython
-
-    In [81]: dview.execute('1/0')
-    ---------------------------------------------------------------------------
-    CompositeError                            Traceback (most recent call last)
-    /home/you/<ipython-input-10-15c2c22dec39> in <module>()
-    ----> 1 dview.execute('1/0', block=True)
-
-    /path/to/site-packages/IPython/parallel/view.py in execute(self, code, block)
-        460                 default: self.block
-        461         """
-    --> 462         return self.apply_with_flags(util._execute, args=(code,), block=block)
-        463 
-        464     def run(self, filename, block=None):
-
-    /home/you/<string> in apply_with_flags(self, f, args, kwargs, block, track)
-
-    /path/to/site-packages/IPython/parallel/view.py in sync_results(f, self, *args, **kwargs)
-         46 def sync_results(f, self, *args, **kwargs):
-         47     """sync relevant results from self.client to our results attribute."""
-    ---> 48     ret = f(self, *args, **kwargs)
-         49     delta = self.outstanding.difference(self.client.outstanding)
-         50     completed = self.outstanding.intersection(delta)
-
-    /home/you/<string> in apply_with_flags(self, f, args, kwargs, block, track)
-
-    /path/to/site-packages/IPython/parallel/view.py in save_ids(f, self, *args, **kwargs)
-         35     n_previous = len(self.client.history)
-         36     try:
-    ---> 37         ret = f(self, *args, **kwargs)
-         38     finally:
-         39         nmsgs = len(self.client.history) - n_previous
-
-    /path/to/site-packages/IPython/parallel/view.py in apply_with_flags(self, f, args, kwargs, block, track)
-        398         if block:
-        399             try:
-    --> 400                 return ar.get()
-        401             except KeyboardInterrupt:
-        402                 pass
-
-    /path/to/site-packages/IPython/parallel/asyncresult.pyc in get(self, timeout)
-         87                 return self._result
-         88             else:
-    ---> 89                 raise self._exception
-         90         else:
-         91             raise error.TimeoutError("Result not ready.")
-
-    CompositeError: one or more exceptions from call to method: _execute
-    [0:apply]: ZeroDivisionError: integer division or modulo by zero
-    [1:apply]: ZeroDivisionError: integer division or modulo by zero
-    [2:apply]: ZeroDivisionError: integer division or modulo by zero
-    [3:apply]: ZeroDivisionError: integer division or modulo by zero
-    
-    In [82]: %debug
-    > /path/to/site-packages/IPython/parallel/asyncresult.py(80)get()
-         79             else:
-    ---> 80                 raise self._exception
-         81         else:
-    
-    
-    # With the debugger running, e is the exceptions instance.  We can tab complete
-    # on it and see the extra methods that are available.
-    ipdb> e.
-    e.__class__         e.__getitem__       e.__new__           e.__setstate__      e.args
-    e.__delattr__       e.__getslice__      e.__reduce__        e.__str__           e.elist
-    e.__dict__          e.__hash__          e.__reduce_ex__     e.__weakref__       e.message
-    e.__doc__           e.__init__          e.__repr__          e._get_engine_str   e.print_tracebacks
-    e.__getattribute__  e.__module__        e.__setattr__       e._get_traceback    e.raise_exception
-    ipdb> e.print_tracebacks()
-    [0:apply]: 
-    Traceback (most recent call last):
-      File "/path/to/site-packages/IPython/parallel/streamkernel.py", line 332, in apply_request
-        exec code in working, working
-      File "<string>", line 1, in <module>
-      File "/path/to/site-packages/IPython/parallel/client.py", line 69, in _execute
-        exec code in globals()
-      File "<string>", line 1, in <module>
-    ZeroDivisionError: integer division or modulo by zero
-
-
-    [1:apply]: 
-    Traceback (most recent call last):
-      File "/path/to/site-packages/IPython/parallel/streamkernel.py", line 332, in apply_request
-        exec code in working, working
-      File "<string>", line 1, in <module>
-      File "/path/to/site-packages/IPython/parallel/client.py", line 69, in _execute
-        exec code in globals()
-      File "<string>", line 1, in <module>
-    ZeroDivisionError: integer division or modulo by zero
-
-
-    [2:apply]: 
-    Traceback (most recent call last):
-      File "/path/to/site-packages/IPython/parallel/streamkernel.py", line 332, in apply_request
-        exec code in working, working
-      File "<string>", line 1, in <module>
-      File "/path/to/site-packages/IPython/parallel/client.py", line 69, in _execute
-        exec code in globals()
-      File "<string>", line 1, in <module>
-    ZeroDivisionError: integer division or modulo by zero
-
-
-    [3:apply]: 
-    Traceback (most recent call last):
-      File "/path/to/site-packages/IPython/parallel/streamkernel.py", line 332, in apply_request
-        exec code in working, working
-      File "<string>", line 1, in <module>
-      File "/path/to/site-packages/IPython/parallel/client.py", line 69, in _execute
-        exec code in globals()
-      File "<string>", line 1, in <module>
-    ZeroDivisionError: integer division or modulo by zero
-    
-
-.. note::
-
-    TODO: The above tracebacks are not up to date
-
-
-All of this same error handling magic even works in non-blocking mode:
-
-.. sourcecode:: ipython
-
-    In [83]: dview.block=False
-
-    In [84]: ar = dview.execute('1/0')
-
-    In [85]: ar.get()
-    ---------------------------------------------------------------------------
-    CompositeError                            Traceback (most recent call last)
-    /Users/minrk/<ipython-input-3-8531eb3d26fb> in <module>()
-    ----> 1 ar.get()
-
-    /path/to/site-packages/IPython/parallel/asyncresult.pyc in get(self, timeout)
-         78                 return self._result
-         79             else:
-    ---> 80                 raise self._exception
-         81         else:
-         82             raise error.TimeoutError("Result not ready.")
-
-    CompositeError: one or more exceptions from call to method: _execute
-    [0:apply]: ZeroDivisionError: integer division or modulo by zero
-    [1:apply]: ZeroDivisionError: integer division or modulo by zero
-    [2:apply]: ZeroDivisionError: integer division or modulo by zero
-    [3:apply]: ZeroDivisionError: integer division or modulo by zero
-
diff --git a/docs/source/parallel/parallel_pi.pdf b/docs/source/parallel/parallel_pi.pdf
deleted file mode 100644
index 5ad1fe2068c..00000000000
Binary files a/docs/source/parallel/parallel_pi.pdf and /dev/null differ
diff --git a/docs/source/parallel/parallel_pi.png b/docs/source/parallel/parallel_pi.png
deleted file mode 100644
index 28962ed3e54..00000000000
Binary files a/docs/source/parallel/parallel_pi.png and /dev/null differ
diff --git a/docs/source/parallel/parallel_process.txt b/docs/source/parallel/parallel_process.txt
deleted file mode 100644
index f02ebf8aa40..00000000000
--- a/docs/source/parallel/parallel_process.txt
+++ /dev/null
@@ -1,506 +0,0 @@
-.. _parallel_process:
-
-===========================================
-Starting the IPython controller and engines
-===========================================
-
-To use IPython for parallel computing, you need to start one instance of
-the controller and one or more instances of the engine. The controller
-and each engine can run on different machines or on the same machine.
-Because of this, there are many different possibilities.
-
-Broadly speaking, there are two ways of going about starting a controller and engines:
-
-* In an automated manner using the :command:`ipcluster` command.
-* In a more manual way using the :command:`ipcontroller` and 
-  :command:`ipengine` commands.
-
-This document describes both of these methods. We recommend that new users
-start with the :command:`ipcluster` command as it simplifies many common usage
-cases.
-
-General considerations
-======================
-
-Before delving into the details about how you can start a controller and
-engines using the various methods, we outline some of the general issues that
-come up when starting the controller and engines. These things come up no
-matter which method you use to start your IPython cluster.
-
-Let's say that you want to start the controller on ``host0`` and engines on
-hosts ``host1``-``hostn``. The following steps are then required:
-
-1. Start the controller on ``host0`` by running :command:`ipcontroller` on
-   ``host0``.
-2. Move the JSON file (:file:`ipcontroller-engine.json`) created by the 
-   controller from ``host0`` to hosts ``host1``-``hostn``.
-3. Start the engines on hosts ``host1``-``hostn`` by running 
-   :command:`ipengine`.  This command has to be told where the JSON file 
-   (:file:`ipcontroller-engine.json`) is located.
-
-At this point, the controller and engines will be connected. By default, the JSON files
-created by the controller are put into the :file:`~/.ipython/cluster_default/security`
-directory. If the engines share a filesystem with the controller, step 2 can be skipped as
-the engines will automatically look at that location.
-
-The final step required to actually use the running controller from a client is to move
-the JSON file :file:`ipcontroller-client.json` from ``host0`` to any host where clients
-will be run. If these file are put into the :file:`~/.ipython/cluster_default/security`
-directory of the client's host, they will be found automatically. Otherwise, the full path
-to them has to be passed to the client's constructor.
-
-Using :command:`ipcluster`
-===========================
-
-The :command:`ipcluster` command provides a simple way of starting a
-controller and engines in the following situations:
-
-1. When the controller and engines are all run on localhost. This is useful
-   for testing or running on a multicore computer.
-2. When engines are started using the :command:`mpirun` command that comes 
-   with most MPI [MPI]_ implementations
-3. When engines are started using the PBS [PBS]_ batch system 
-   (or other `qsub` systems, such as SGE).
-4. When the controller is started on localhost and the engines are started on 
-   remote nodes using :command:`ssh`.
-5. When engines are started using the Windows HPC Server batch system.
-
-.. note::
-
-    Currently :command:`ipcluster` requires that the
-    :file:`~/.ipython/cluster_<profile>/security` directory live on a shared filesystem that is
-    seen by both the controller and engines. If you don't have a shared file
-    system you will need to use :command:`ipcontroller` and
-    :command:`ipengine` directly.
-
-Under the hood, :command:`ipcluster` just uses :command:`ipcontroller`
-and :command:`ipengine` to perform the steps described above.
-
-The simplest way to use ipcluster requires no configuration, and will
-launch a controller and a number of engines on the local machine. For instance, 
-to start one controller and 4 engines on localhost, just do::
-
-    $ ipcluster start -n 4
-
-To see other command line options for the local mode, do::
-
-    $ ipcluster -h
-
-
-Configuring an IPython cluster
-==============================
-
-Cluster configurations are stored as `profiles`.  You can create a new profile with::
-
-    $ ipcluster create -p myprofile
-
-This will create the directory :file:`IPYTHONDIR/cluster_myprofile`, and populate it
-with the default configuration files for the three IPython cluster commands. Once
-you edit those files, you can continue to call ipcluster/ipcontroller/ipengine
-with no arguments beyond ``-p myprofile``, and any configuration will be maintained.
-
-There is no limit to the number of profiles you can have, so you can maintain a profile for each
-of your common use cases. The default profile will be used whenever the
-profile argument is not specified, so edit :file:`IPYTHONDIR/cluster_default/*_config.py` to
-represent your most common use case.
-
-The configuration files are loaded with commented-out settings and explanations,
-which should cover most of the available possibilities.
-
-Using various batch systems with :command:`ipcluster`
-------------------------------------------------------
-
-:command:`ipcluster` has a notion of Launchers that can start controllers
-and engines with various remote execution schemes.  Currently supported
-models include `mpiexec`, PBS-style (Torque, SGE), and Windows HPC Server.
-
-.. note::
-
-    The Launchers and configuration are designed in such a way that advanced
-    users can subclass and configure them to fit their own system that we
-    have not yet supported (such as Condor)
-
-Using :command:`ipcluster` in mpiexec/mpirun mode
---------------------------------------------------
-
-
-The mpiexec/mpirun mode is useful if you:
-
-1. Have MPI installed.
-2. Your systems are configured to use the :command:`mpiexec` or
-   :command:`mpirun` commands to start MPI processes.
-
-If these are satisfied, you can create a new profile::
-
-    $ ipcluster create -p mpi
-
-and edit the file :file:`IPYTHONDIR/cluster_mpi/ipcluster_config.py`.
-
-There, instruct ipcluster to use the MPIExec launchers by adding the lines:
-
-.. sourcecode:: python
-
-    c.Global.engine_launcher = 'IPython.parallel.apps.launcher.MPIExecEngineSetLauncher'
-
-If the default MPI configuration is correct, then you can now start your cluster, with::
-
-    $ ipcluster start -n 4 -p mpi
-
-This does the following:
-
-1. Starts the IPython controller on current host.
-2. Uses :command:`mpiexec` to start 4 engines.
-
-If you have a reason to also start the Controller with mpi, you can specify:
-
-.. sourcecode:: python
-
-    c.Global.controller_launcher = 'IPython.parallel.apps.launcher.MPIExecControllerLauncher'
-
-.. note::
-
-    The Controller *will not* be in the same MPI universe as the engines, so there is not
-    much reason to do this unless sysadmins demand it.
-
-On newer MPI implementations (such as OpenMPI), this will work even if you
-don't make any calls to MPI or call :func:`MPI_Init`. However, older MPI
-implementations actually require each process to call :func:`MPI_Init` upon
-starting. The easiest way of having this done is to install the mpi4py
-[mpi4py]_ package and then specify the ``c.MPI.use`` option in :file:`ipengine_config.py`:
-
-.. sourcecode:: python
-
-    c.MPI.use = 'mpi4py'
-
-Unfortunately, even this won't work for some MPI implementations. If you are
-having problems with this, you will likely have to use a custom Python
-executable that itself calls :func:`MPI_Init` at the appropriate time.
-Fortunately, mpi4py comes with such a custom Python executable that is easy to
-install and use. However, this custom Python executable approach will not work
-with :command:`ipcluster` currently.
-
-More details on using MPI with IPython can be found :ref:`here <parallelmpi>`.
-
-
-Using :command:`ipcluster` in PBS mode
----------------------------------------
-
-The PBS mode uses the Portable Batch System [PBS]_ to start the engines. 
-
-As usual, we will start by creating a fresh profile::
-
-    $ ipcluster create -p pbs
-
-And in :file:`ipcluster_config.py`, we will select the PBS launchers for the controller
-and engines:
-
-.. sourcecode:: python
-
-    c.Global.controller_launcher = 'IPython.parallel.apps.launcher.PBSControllerLauncher'
-    c.Global.engine_launcher = 'IPython.parallel.apps.launcher.PBSEngineSetLauncher'
-
-IPython does provide simple default batch templates for PBS and SGE, but you may need
-to specify your own. Here is a sample PBS script template:
-
-.. sourcecode:: bash
-
-    #PBS -N ipython
-    #PBS -j oe
-    #PBS -l walltime=00:10:00
-    #PBS -l nodes=${n/4}:ppn=4
-    #PBS -q $queue
-
-    cd $$PBS_O_WORKDIR
-    export PATH=$$HOME/usr/local/bin
-    export PYTHONPATH=$$HOME/usr/local/lib/python2.7/site-packages
-    /usr/local/bin/mpiexec -n ${n} ipengine --cluster_dir=${cluster_dir}
-
-There are a few important points about this template:
-
-1. This template will be rendered at runtime using IPython's :mod:`Itpl` 
-   template engine.
-
-2. Instead of putting in the actual number of engines, use the notation
-   ``${n}`` to indicate the number of engines to be started. You can also uses
-   expressions like ``${n/4}`` in the template to indicate the number of 
-   nodes. There will always be a ${n} and ${cluster_dir} variable passed to the template.
-   These allow the batch system to know how many engines, and where the configuration
-   files reside. The same is true for the batch queue, with the template variable ``$queue``.
-
-3. Because ``$`` is a special character used by the template engine, you must  
-   escape any ``$`` by using ``$$``.  This is important when referring to 
-   environment variables in the template, or in SGE, where the config lines start
-   with ``#$``, which will have to be ``#$$``.
-
-4. Any options to :command:`ipengine` can be given in the batch script 
-   template, or in :file:`ipengine_config.py`.
-
-5. Depending on the configuration of you system, you may have to set 
-   environment variables in the script template.
-
-The controller template should be similar, but simpler:
-
-.. sourcecode:: bash
-
-    #PBS -N ipython
-    #PBS -j oe
-    #PBS -l walltime=00:10:00
-    #PBS -l nodes=1:ppn=4
-    #PBS -q $queue
-
-    cd $$PBS_O_WORKDIR
-    export PATH=$$HOME/usr/local/bin
-    export PYTHONPATH=$$HOME/usr/local/lib/python2.7/site-packages
-    ipcontroller --cluster_dir=${cluster_dir}
-
-
-Once you have created these scripts, save them with names like
-:file:`pbs.engine.template`. Now you can load them into the :file:`ipcluster_config` with:
-
-.. sourcecode:: python
-
-    c.PBSEngineSetLauncher.batch_template_file = "pbs.engine.template"
-    
-    c.PBSControllerLauncher.batch_template_file = "pbs.controller.template"
-        
-
-Alternately, you can just define the templates as strings inside :file:`ipcluster_config`.
-
-Whether you are using your own templates or our defaults, the extra configurables available are
-the number of engines to launch (``$n``, and the batch system queue to which the jobs are to be
-submitted (``$queue``)). These are configurables, and can be specified in
-:file:`ipcluster_config`:
-
-.. sourcecode:: python
-
-    c.PBSLauncher.queue = 'veryshort.q'
-    c.PBSEngineSetLauncher.n = 64
-
-Note that assuming you are running PBS on a multi-node cluster, the Controller's default behavior
-of listening only on localhost is likely too restrictive.  In this case, also assuming the
-nodes are safely behind a firewall, you can simply instruct the Controller to listen for
-connections on all its interfaces, by adding in :file:`ipcontroller_config`:
-
-.. sourcecode:: python
-
-    c.RegistrationFactory.ip = '*'
-
-You can now run the cluster with::
-
-    $ ipcluster start -p pbs -n 128
-
-Additional configuration options can be found in the PBS section of :file:`ipcluster_config`.
-
-.. note::
-
-    Due to the flexibility of configuration, the PBS launchers work with simple changes
-    to the template for other :command:`qsub`-using systems, such as Sun Grid Engine,
-    and with further configuration in similar batch systems like Condor.
-
-
-Using :command:`ipcluster` in SSH mode
----------------------------------------
-
-
-The SSH mode uses :command:`ssh` to execute :command:`ipengine` on remote
-nodes and :command:`ipcontroller` can be run remotely as well, or on localhost.
-
-.. note::
-
-    When using this mode it highly recommended that you have set up SSH keys
-    and are using ssh-agent [SSH]_ for password-less logins.
-
-As usual, we start by creating a clean profile::
-
-    $ ipcluster create -p ssh
-
-To use this mode, select the SSH launchers in :file:`ipcluster_config.py`:
-
-.. sourcecode:: python
-
-    c.Global.engine_launcher = 'IPython.parallel.apps.launcher.SSHEngineSetLauncher'
-    # and if the Controller is also to be remote:
-    c.Global.controller_launcher = 'IPython.parallel.apps.launcher.SSHControllerLauncher'
-    
-
-The controller's remote location and configuration can be specified:
-
-.. sourcecode:: python
-
-    # Set the user and hostname for the controller
-    # c.SSHControllerLauncher.hostname = 'controller.example.com'
-    # c.SSHControllerLauncher.user = os.environ.get('USER','username')
-
-    # Set the arguments to be passed to ipcontroller
-    # note that remotely launched ipcontroller will not get the contents of 
-    # the local ipcontroller_config.py unless it resides on the *remote host*
-    # in the location specified by the --cluster_dir argument.
-    # c.SSHControllerLauncher.program_args = ['-r', '-ip', '0.0.0.0', '--cluster_dir', '/path/to/cd']
-
-.. note::
-
-    SSH mode does not do any file movement, so you will need to distribute configuration
-    files manually.  To aid in this, the `reuse_files` flag defaults to True for ssh-launched
-    Controllers, so you will only need to do this once, unless you override this flag back
-    to False.
-
-Engines are specified in a dictionary, by hostname and the number of engines to be run
-on that host.
-
-.. sourcecode:: python
-
-    c.SSHEngineSetLauncher.engines = { 'host1.example.com' : 2,
-                'host2.example.com' : 5,
-                'host3.example.com' : (1, ['--cluster_dir', '/home/different/location']),
-                'host4.example.com' : 8 }
-
-* The `engines` dict, where the keys are the host we want to run engines on and
-  the value is the number of engines to run on that host.
-* on host3, the value is a tuple, where the number of engines is first, and the arguments
-  to be passed to :command:`ipengine` are the second element.
-
-For engines without explicitly specified arguments, the default arguments are set in
-a single location:
-
-.. sourcecode:: python
-
-    c.SSHEngineSetLauncher.engine_args = ['--cluster_dir', '/path/to/cluster_ssh']
-
-Current limitations of the SSH mode of :command:`ipcluster` are:
-
-* Untested on Windows. Would require a working :command:`ssh` on Windows.
-  Also, we are using shell scripts to setup and execute commands on remote
-  hosts.
-* No file movement - 
-
-Using the :command:`ipcontroller` and :command:`ipengine` commands
-====================================================================
-
-It is also possible to use the :command:`ipcontroller` and :command:`ipengine`
-commands to start your controller and engines. This approach gives you full
-control over all aspects of the startup process.
-
-Starting the controller and engine on your local machine
---------------------------------------------------------
-
-To use :command:`ipcontroller` and :command:`ipengine` to start things on your
-local machine, do the following.
-
-First start the controller::
-
-    $ ipcontroller
-    
-Next, start however many instances of the engine you want using (repeatedly)
-the command::
-
-    $ ipengine
-
-The engines should start and automatically connect to the controller using the
-JSON files in :file:`~/.ipython/cluster_default/security`. You are now ready to use the
-controller and engines from IPython.
-
-.. warning:: 
-    
-    The order of the above operations may be important.  You *must*
-    start the controller before the engines, unless you are reusing connection
-    information (via `-r`), in which case ordering is not important.
-
-.. note::
-
-    On some platforms (OS X), to put the controller and engine into the
-    background you may need to give these commands in the form ``(ipcontroller
-    &)`` and ``(ipengine &)`` (with the parentheses) for them to work
-    properly.
-
-Starting the controller and engines on different hosts
-------------------------------------------------------
-
-When the controller and engines are running on different hosts, things are
-slightly more complicated, but the underlying ideas are the same:
-
-1. Start the controller on a host using :command:`ipcontroller`.
-2. Copy :file:`ipcontroller-engine.json` from :file:`~/.ipython/cluster_<profile>/security` on
-   the controller's host to the host where the engines will run.
-3. Use :command:`ipengine` on the engine's hosts to start the engines.
-
-The only thing you have to be careful of is to tell :command:`ipengine` where
-the :file:`ipcontroller-engine.json` file is located. There are two ways you
-can do this:
-
-* Put :file:`ipcontroller-engine.json` in the :file:`~/.ipython/cluster_<profile>/security`
-  directory on the engine's host, where it will be found automatically.
-* Call :command:`ipengine` with the ``--file=full_path_to_the_file``
-  flag.
-
-The ``--file`` flag works like this::
-
-    $ ipengine --file=/path/to/my/ipcontroller-engine.json
-
-.. note::
-    
-    If the controller's and engine's hosts all have a shared file system  
-    (:file:`~/.ipython/cluster_<profile>/security` is the same on all of them), then things
-    will just work!
-
-Make JSON files persistent
---------------------------
-
-At fist glance it may seem that that managing the JSON files is a bit
-annoying. Going back to the house and key analogy, copying the JSON around
-each time you start the controller is like having to make a new key every time
-you want to unlock the door and enter your house. As with your house, you want
-to be able to create the key (or JSON file) once, and then simply use it at
-any point in the future.
-
-To do this, the only thing you have to do is specify the `-r` flag, so that
-the connection information in the JSON files remains accurate::
-
-    $ ipcontroller -r
-
-Then, just copy the JSON files over the first time and you are set. You can
-start and stop the controller and engines any many times as you want in the
-future, just make sure to tell the controller to reuse the file.
-
-.. note::
-
-    You may ask the question: what ports does the controller listen on if you
-    don't tell is to use specific ones? The default is to use high random port
-    numbers. We do this for two reasons: i) to increase security through
-    obscurity and ii) to multiple controllers on a given host to start and
-    automatically use different ports.
-
-Log files
----------
-
-All of the components of IPython have log files associated with them.
-These log files can be extremely useful in debugging problems with
-IPython and can be found in the directory :file:`~/.ipython/cluster_<profile>/log`.
-Sending the log files to us will often help us to debug any problems.
-
-
-Configuring `ipcontroller`
----------------------------
-
-Ports and addresses
-*******************
-
-
-Database Backend
-****************
-
-
-.. seealso::
-
-    
-
-Configuring `ipengine`
------------------------
-
-.. note::
-
-    TODO
-
-
-
-.. [PBS] Portable Batch System.  http://www.openpbs.org/
-.. [SSH] SSH-Agent http://en.wikipedia.org/wiki/ssh-agent
diff --git a/docs/source/parallel/parallel_security.txt b/docs/source/parallel/parallel_security.txt
deleted file mode 100644
index 7f65a96312b..00000000000
--- a/docs/source/parallel/parallel_security.txt
+++ /dev/null
@@ -1,324 +0,0 @@
-.. _parallelsecurity:
-
-===========================
-Security details of IPython
-===========================
-
-.. note::
-
-    This section is not thorough, and IPython.zmq needs a thorough security
-    audit.
-
-IPython's :mod:`IPython.zmq` package exposes the full power of the
-Python interpreter over a TCP/IP network for the purposes of parallel
-computing. This feature brings up the important question of IPython's security
-model. This document gives details about this model and how it is implemented
-in IPython's architecture.
-
-Processs and network topology
-=============================
-
-To enable parallel computing, IPython has a number of different processes that
-run. These processes are discussed at length in the IPython documentation and
-are summarized here:
-
-* The IPython *engine*.  This process is a full blown Python
-  interpreter in which user code is executed.  Multiple
-  engines are started to make parallel computing possible.
-* The IPython *hub*.  This process monitors a set of 
-  engines and schedulers, and keeps track of the state of the processes. It listens
-  for registration connections from engines and clients, and monitor connections
-  from schedulers.
-* The IPython *schedulers*. This is a set of processes that relay commands and results
-  between clients and engines. They are typically on the same machine as the controller,
-  and listen for connections from engines and clients, but connect to the Hub.
-* The IPython *client*.  This process is typically an
-  interactive Python process that is used to coordinate the
-  engines to get a parallel computation done.
-
-Collectively, these processes are called the IPython *kernel*, and the hub and schedulers
-together are referred to as the *controller*.
-
-.. note::
-
-    Are these really still referred to as the Kernel?  It doesn't seem so to me.  'cluster'
-    seems more accurate.
-    
-    -MinRK
-
-These processes communicate over any transport supported by ZeroMQ (tcp,pgm,infiniband,ipc)
-with a well defined topology. The IPython hub and schedulers listen on sockets. Upon
-starting, an engine connects to a hub and registers itself, which then informs the engine
-of the connection information for the schedulers, and the engine then connects to the
-schedulers. These engine/hub and engine/scheduler connections persist for the
-lifetime of each engine.
-
-The IPython client also connects to the controller processes using a number of socket
-connections. As of writing, this is one socket per scheduler (4), and 3 connections to the
-hub for a total of 7. These connections persist for the lifetime of the client only.
-
-A given IPython controller and set of engines engines typically has a relatively
-short lifetime. Typically this lifetime corresponds to the duration of a single parallel
-simulation performed by a single user. Finally, the hub, schedulers, engines, and client
-processes typically execute with the permissions of that same user. More specifically, the
-controller and engines are *not* executed as root or with any other superuser permissions.
-
-Application logic
-=================
-
-When running the IPython kernel to perform a parallel computation, a user
-utilizes the IPython client to send Python commands and data through the
-IPython schedulers to the IPython engines, where those commands are executed
-and the data processed. The design of IPython ensures that the client is the
-only access point for the capabilities of the engines. That is, the only way
-of addressing the engines is through a client.
-
-A user can utilize the client to instruct the IPython engines to execute
-arbitrary Python commands. These Python commands can include calls to the
-system shell, access the filesystem, etc., as required by the user's
-application code. From this perspective, when a user runs an IPython engine on
-a host, that engine has the same capabilities and permissions as the user
-themselves (as if they were logged onto the engine's host with a terminal).
-
-Secure network connections
-==========================
-
-Overview
---------
-
-ZeroMQ provides exactly no security. For this reason, users of IPython must be very
-careful in managing connections, because an open TCP/IP socket presents access to
-arbitrary execution as the user on the engine machines. As a result, the default behavior
-of controller processes is to only listen for clients on the loopback interface, and the
-client must establish SSH tunnels to connect to the controller processes.
-
-.. warning:: 
-
-    If the controller's loopback interface is untrusted, then IPython should be considered
-    vulnerable, and this extends to the loopback of all connected clients, which have
-    opened a loopback port that is redirected to the controller's loopback port.
-
-
-SSH
----
-
-Since ZeroMQ provides no security, SSH tunnels are the primary source of secure
-connections. A connector file, such as `ipcontroller-client.json`, will contain
-information for connecting to the controller, possibly including the address of an
-ssh-server through with the client is to tunnel. The Client object then creates tunnels
-using either [OpenSSH]_ or [Paramiko]_, depending on the platform. If users do not wish to
-use OpenSSH or Paramiko, or the tunneling utilities are insufficient, then they may
-construct the tunnels themselves, and simply connect clients and engines as if the
-controller were on loopback on the connecting machine.
-
-.. note::
-
-    There is not currently tunneling available for engines.
-
-Authentication
---------------
-
-To protect users of shared machines, an execution key is used to authenticate all messages.
-
-The Session object that handles the message protocol uses a unique key to verify valid
-messages. This can be any value specified by the user, but the default behavior is a
-pseudo-random 128-bit number, as generated by `uuid.uuid4()`. This key is checked on every
-message everywhere it is unpacked (Controller, Engine, and Client) to ensure that it came
-from an authentic user, and no messages that do not contain this key are acted upon in any
-way.
-
-There is exactly one key per cluster - it must be the same everywhere. Typically, the
-controller creates this key, and stores it in the private connection files
-`ipython-{engine|client}.json`. These files are typically stored in the
-`~/.ipython/cluster_<profile>/security` directory, and are maintained as readable only by
-the owner, just as is common practice with a user's keys in their `.ssh` directory.
-
-.. warning::
-
-    It is important to note that the key authentication, as emphasized by the use of
-    a uuid rather than generating a key with a cryptographic library, provides a 
-    defense against *accidental* messages more than it does against malicious attacks.
-    If loopback is compromised, it would be trivial for an attacker to intercept messages
-    and deduce the key, as there is no encryption.
-
-
-
-Specific security vulnerabilities
-=================================
-
-There are a number of potential security vulnerabilities present in IPython's
-architecture. In this section we discuss those vulnerabilities and detail how
-the security architecture described above prevents them from being exploited.
-
-Unauthorized clients
---------------------
-
-The IPython client can instruct the IPython engines to execute arbitrary
-Python code with the permissions of the user who started the engines. If an
-attacker were able to connect their own hostile IPython client to the IPython
-controller, they could instruct the engines to execute code.
-
-
-On the first level, this attack is prevented by requiring access to the controller's
-ports, which are recommended to only be open on loopback if the controller is on an
-untrusted local network. If the attacker does have access to the Controller's ports, then
-the attack is prevented by the capabilities based client authentication of the execution
-key. The relevant authentication information is encoded into the JSON file that clients
-must present to gain access to the IPython controller. By limiting the distribution of
-those keys, a user can grant access to only authorized persons, just as with SSH keys.
-
-It is highly unlikely that an execution key could be guessed by an attacker
-in a brute force guessing attack. A given instance of the IPython controller
-only runs for a relatively short amount of time (on the order of hours). Thus
-an attacker would have only a limited amount of time to test a search space of
-size 2**128.  
-
-.. warning::
-
-    If the attacker has gained enough access to intercept loopback connections on
-    *either* the controller or client, then the key is easily deduced from network
-    traffic.
-
-
-Unauthorized engines
---------------------
-
-If an attacker were able to connect a hostile engine to a user's controller,
-the user might unknowingly send sensitive code or data to the hostile engine.
-This attacker's engine would then have full access to that code and data.
-
-This type of attack is prevented in the same way as the unauthorized client
-attack, through the usage of the capabilities based authentication scheme.
-
-Unauthorized controllers
-------------------------
-
-It is also possible that an attacker could try to convince a user's IPython
-client or engine to connect to a hostile IPython controller. That controller
-would then have full access to the code and data sent between the IPython
-client and the IPython engines.
-
-Again, this attack is prevented through the capabilities in a connection file, which
-ensure that a client or engine connects to the correct controller. It is also important to
-note that the connection files also encode the IP address and port that the controller is
-listening on, so there is little chance of mistakenly connecting to a controller running
-on a different IP address and port.
-
-When starting an engine or client, a user must specify the key to use
-for that connection. Thus, in order to introduce a hostile controller, the
-attacker must convince the user to use the key associated with the
-hostile controller. As long as a user is diligent in only using keys from
-trusted sources, this attack is not possible.
-
-.. note::
-
-    I may be wrong, the unauthorized controller may be easier to fake than this.
-
-Other security measures
-=======================
-
-A number of other measures are taken to further limit the security risks
-involved in running the IPython kernel.
-
-First, by default, the IPython controller listens on random port numbers.
-While this can be overridden by the user, in the default configuration, an
-attacker would have to do a port scan to even find a controller to attack.
-When coupled with the relatively short running time of a typical controller
-(on the order of hours), an attacker would have to work extremely hard and
-extremely *fast* to even find a running controller to attack.
-
-Second, much of the time, especially when run on supercomputers or clusters,
-the controller is running behind a firewall. Thus, for engines or client to
-connect to the controller:
-
-* The different processes have to all be behind the firewall.
-
-or:
-
-* The user has to use SSH port forwarding to tunnel the
-  connections through the firewall.
-   
-In either case, an attacker is presented with additional barriers that prevent
-attacking or even probing the system.
-
-Summary
-=======
-
-IPython's architecture has been carefully designed with security in mind. The
-capabilities based authentication model, in conjunction with SSH tunneled
-TCP/IP channels, address the core potential vulnerabilities in the system,
-while still enabling user's to use the system in open networks.
-
-Other questions
-===============
-
-.. note::
-
-    this does not apply to ZMQ, but I am sure there will be questions.
-
-About keys
-----------
-
-Can you clarify the roles of the certificate and its keys versus the FURL,
-which is also called a key?
-
-The certificate created by IPython processes is a standard public key x509
-certificate, that is used by the SSL handshake protocol to setup encrypted
-channel between the controller and the IPython engine or client. This public
-and private key associated with this certificate are used only by the SSL
-handshake protocol in setting up this encrypted channel.
-
-The FURL serves a completely different and independent purpose from the
-key pair associated with the certificate. When we refer to a FURL as a
-key, we are using the word "key" in the capabilities based security model
-sense. This has nothing to do with "key" in the public/private key sense used
-in the SSL protocol.
-
-With that said the FURL is used as an cryptographic key, to grant
-IPython engines and clients access to particular capabilities that the
-controller offers.
-
-Self signed certificates
-------------------------
-
-Is the controller creating a self-signed certificate? Is this created for per
-instance/session, one-time-setup or each-time the controller is started?
-
-The Foolscap network protocol, which handles the SSL protocol details, creates
-a self-signed x509 certificate using OpenSSL for each IPython process. The
-lifetime of the certificate is handled differently for the IPython controller
-and the engines/client.
-
-For the IPython engines and client, the certificate is only held in memory for
-the lifetime of its process. It is never written to disk.
-
-For the controller, the certificate can be created anew each time the
-controller starts or it can be created once and reused each time the
-controller starts. If at any point, the certificate is deleted, a new one is
-created the next time the controller starts.
-
-SSL private key
----------------
-
-How the private key (associated with the certificate) is distributed?
-
-In the usual implementation of the SSL protocol, the private key is never
-distributed. We follow this standard always.
-
-SSL versus Foolscap authentication
-----------------------------------
-
-Many SSL connections only perform one sided authentication (the server to the
-client). How is the client authentication in IPython's system related to SSL
-authentication?
-
-We perform a two way SSL handshake in which both parties request and verify
-the certificate of their peer. This mutual authentication is handled by the
-SSL handshake and is separate and independent from the additional
-authentication steps that the CLIENT and SERVER perform after an encrypted
-channel is established.
-
-.. [RFC5246] <http://tools.ietf.org/html/rfc5246>
-
-.. [OpenSSH] <http://www.openssh.com/>
-.. [Paramiko] <http://www.lag.net/paramiko/>
diff --git a/docs/source/parallel/parallel_task.txt b/docs/source/parallel/parallel_task.txt
deleted file mode 100644
index 82d71f78e81..00000000000
--- a/docs/source/parallel/parallel_task.txt
+++ /dev/null
@@ -1,418 +0,0 @@
-.. _parallel_task:
-
-==========================
-The IPython task interface
-==========================
-
-The task interface to the cluster presents the engines as a fault tolerant,
-dynamic load-balanced system of workers. Unlike the multiengine interface, in
-the task interface the user have no direct access to individual engines. By
-allowing the IPython scheduler to assign work, this interface is simultaneously
-simpler and more powerful.
-
-Best of all, the user can use both of these interfaces running at the same time
-to take advantage of their respective strengths. When the user can break up
-the user's work into segments that do not depend on previous execution, the
-task interface is ideal. But it also has more power and flexibility, allowing
-the user to guide the distribution of jobs, without having to assign tasks to
-engines explicitly.
-
-Starting the IPython controller and engines
-===========================================
-
-To follow along with this tutorial, you will need to start the IPython
-controller and four IPython engines. The simplest way of doing this is to use
-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.
-
-Creating a ``Client`` instance
-==============================
-
-The first step is to import the IPython :mod:`IPython.parallel`
-module and then create a :class:`.Client` instance, and we will also be using
-a :class:`LoadBalancedView`, here called `lview`:
-
-.. sourcecode:: ipython
-
-    In [1]: from IPython.parallel import Client
-
-    In [2]: rc = Client()
-    
-
-This form assumes that the controller was started on localhost with default
-configuration. If not, the location of the controller must be given as an
-argument to the constructor:
-
-.. sourcecode:: ipython
-
-    # for a visible LAN controller listening on an external port:
-    In [2]: rc = Client('tcp://192.168.1.16:10101')
-    # or to connect with a specific profile you have set up:
-    In [3]: rc = Client(profile='mpi')
-
-For load-balanced execution, we will make use of a :class:`LoadBalancedView` object, which can
-be constructed via the client's :meth:`load_balanced_view` method:
-
-.. sourcecode:: ipython
-
-    In [4]: lview = rc.load_balanced_view() # default load-balanced view
-
-.. seealso::
-
-    For more information, see the in-depth explanation of :ref:`Views <parallel_details>`.
-
-
-Quick and easy parallelism
-==========================
-
-In many cases, you simply want to apply a Python function to a sequence of
-objects, but *in parallel*. Like the multiengine interface, these can be
-implemented via the task interface. The exact same tools can perform these
-actions in load-balanced ways as well as multiplexed ways: a parallel version
-of :func:`map` and :func:`@parallel` function decorator. If one specifies the
-argument `balanced=True`, then they are dynamically load balanced. Thus, if the
-execution time per item varies significantly, you should use the versions in
-the task interface.
-
-Parallel map
-------------
-
-To load-balance :meth:`map`,simply use a LoadBalancedView:
-
-.. sourcecode:: ipython
-    
-    In [62]: lview.block = True
-    
-	In [63]: serial_result = map(lambda x:x**10, range(32))
-
-	In [64]: parallel_result = lview.map(lambda x:x**10, range(32))
-
-	In [65]: serial_result==parallel_result
-	Out[65]: True
-
-Parallel function decorator
----------------------------
-
-Parallel functions are just like normal function, but they can be called on
-sequences and *in parallel*. The multiengine interface provides a decorator
-that turns any Python function into a parallel function:
-
-.. sourcecode:: ipython
-
-    In [10]: @lview.parallel()
-       ....: def f(x):
-       ....:     return 10.0*x**4
-       ....:
-
-    In [11]: f.map(range(32))    # this is done in parallel
-    Out[11]: [0.0,10.0,160.0,...]
-
-.. _parallel_dependencies:
-
-Dependencies
-============
-
-Often, pure atomic load-balancing is too primitive for your work. In these cases, you
-may want to associate some kind of `Dependency` that describes when, where, or whether
-a task can be run.  In IPython, we provide two types of dependencies: 
-`Functional Dependencies`_ and `Graph Dependencies`_
-
-.. note::
-
-    It is important to note that the pure ZeroMQ scheduler does not support dependencies,
-    and you will see errors or warnings if you try to use dependencies with the pure
-    scheduler.
-
-Functional Dependencies
------------------------
-
-Functional dependencies are used to determine whether a given engine is capable of running
-a particular task.  This is implemented via a special :class:`Exception` class, 
-:class:`UnmetDependency`, found in `IPython.parallel.error`.  Its use is very simple: 
-if a task fails with an UnmetDependency exception, then the scheduler, instead of relaying
-the error up to the client like any other error, catches the error, and submits the task
-to a different engine.  This will repeat indefinitely, and a task will never be submitted
-to a given engine a second time.
-
-You can manually raise the :class:`UnmetDependency` yourself, but IPython has provided 
-some decorators for facilitating this behavior.
-
-There are two decorators and a class used for functional dependencies:
-
-.. sourcecode:: ipython
-
-    In [9]: from IPython.parallel import depend, require, dependent
-
-@require
-********
-
-The simplest sort of dependency is requiring that a Python module is available. The
-``@require`` decorator lets you define a function that will only run on engines where names
-you specify are importable:
-
-.. sourcecode:: ipython
-
-    In [10]: @require('numpy', 'zmq')
-        ...: def myfunc():
-        ...:     return dostuff()
-
-Now, any time you apply :func:`myfunc`, the task will only run on a machine that has
-numpy and pyzmq available, and when :func:`myfunc` is called, numpy and zmq will be imported.
-
-@depend
-*******
-
-The ``@depend`` decorator lets you decorate any function with any *other* function to
-evaluate the dependency. The dependency function will be called at the start of the task,
-and if it returns ``False``, then the dependency will be considered unmet, and the task
-will be assigned to another engine. If the dependency returns *anything other than
-``False``*, the rest of the task will continue.
-
-.. sourcecode:: ipython
-
-    In [10]: def platform_specific(plat):
-        ...:    import sys
-        ...:    return sys.platform == plat
-    
-    In [11]: @depend(platform_specific, 'darwin')
-        ...: def mactask():
-        ...:    do_mac_stuff()
-
-    In [12]: @depend(platform_specific, 'nt')
-        ...: def wintask():
-        ...:    do_windows_stuff()
-    
-In this case, any time you apply ``mytask``, it will only run on an OSX machine.
-``@depend`` is just like ``apply``, in that it has a ``@depend(f,*args,**kwargs)``
-signature.
-
-dependents
-**********
-
-You don't have to use the decorators on your tasks, if for instance you may want
-to run tasks with a single function but varying dependencies, you can directly construct
-the :class:`dependent` object that the decorators use:
-
-.. sourcecode::ipython
-
-    In [13]: def mytask(*args):
-        ...:    dostuff()
-    
-    In [14]: mactask = dependent(mytask, platform_specific, 'darwin')
-    # this is the same as decorating the declaration of mytask with @depend
-    # but you can do it again:
-    
-    In [15]: wintask = dependent(mytask, platform_specific, 'nt')
-    
-    # in general:
-    In [16]: t = dependent(f, g, *dargs, **dkwargs)
-    
-    # is equivalent to:
-    In [17]: @depend(g, *dargs, **dkwargs)
-        ...: def t(a,b,c):
-        ...:     # contents of f
-
-Graph Dependencies
-------------------
-
-Sometimes you want to restrict the time and/or location to run a given task as a function
-of the time and/or location of other tasks. This is implemented via a subclass of
-:class:`set`, called a :class:`Dependency`. A Dependency is just a set of `msg_ids`
-corresponding to tasks, and a few attributes to guide how to decide when the Dependency
-has been met.
-
-The switches we provide for interpreting whether a given dependency set has been met:
-
-any|all
-    Whether the dependency is considered met if *any* of the dependencies are done, or
-    only after *all* of them have finished.  This is set by a Dependency's :attr:`all`
-    boolean attribute, which defaults to ``True``.
-
-success [default: True]
-    Whether to consider tasks that succeeded as fulfilling dependencies.
-
-failure [default : False]
-    Whether to consider tasks that failed as fulfilling dependencies.
-    using `failure=True,success=False` is useful for setting up cleanup tasks, to be run
-    only when tasks have failed.
-
-Sometimes you want to run a task after another, but only if that task succeeded. In this case,
-``success`` should be ``True`` and ``failure`` should be ``False``. However sometimes you may
-not care whether the task succeeds, and always want the second task to run, in which case you
-should use `success=failure=True`. The default behavior is to only use successes.
-
-There are other switches for interpretation that are made at the *task* level.  These are
-specified via keyword arguments to the client's :meth:`apply` method.
-
-after,follow
-    You may want to run a task *after* a given set of dependencies have been run and/or
-    run it *where* another set of dependencies are met. To support this, every task has an
-    `after` dependency to restrict time, and a `follow` dependency to restrict
-    destination.
-
-timeout
-    You may also want to set a time-limit for how long the scheduler should wait before a
-    task's dependencies are met. This is done via a `timeout`, which defaults to 0, which
-    indicates that the task should never timeout. If the timeout is reached, and the
-    scheduler still hasn't been able to assign the task to an engine, the task will fail
-    with a :class:`DependencyTimeout`.
-
-.. note::
-
-    Dependencies only work within the task scheduler. You cannot instruct a load-balanced
-    task to run after a job submitted via the MUX interface.
-
-The simplest form of Dependencies is with `all=True,success=True,failure=False`. In these cases,
-you can skip using Dependency objects, and just pass msg_ids or AsyncResult objects as the
-`follow` and `after` keywords to :meth:`client.apply`:
-
-.. sourcecode:: ipython
-
-    In [14]: client.block=False
-
-    In [15]: ar = lview.apply(f, args, kwargs)
-
-    In [16]: ar2 = lview.apply(f2)
-
-    In [17]: ar3 = lview.apply_with_flags(f3, after=[ar,ar2])
-
-    In [17]: ar4 = lview.apply_with_flags(f3, follow=[ar], timeout=2.5)
-
-
-.. seealso::
-
-    Some parallel workloads can be described as a `Directed Acyclic Graph
-    <http://en.wikipedia.org/wiki/Directed_acyclic_graph>`_, or DAG. See :ref:`DAG
-    Dependencies <dag_dependencies>` for an example demonstrating how to use map a NetworkX DAG
-    onto task dependencies.
-
-
-
-Impossible Dependencies
-***********************
-
-The schedulers do perform some analysis on graph dependencies to determine whether they
-are not possible to be met. If the scheduler does discover that a dependency cannot be
-met, then the task will fail with an :class:`ImpossibleDependency` error. This way, if the
-scheduler realized that a task can never be run, it won't sit indefinitely in the
-scheduler clogging the pipeline.
-
-The basic cases that are checked:
-
-* depending on nonexistent messages
-* `follow` dependencies were run on more than one machine and `all=True`
-* any dependencies failed and `all=True,success=True,failures=False`
-* all dependencies failed and `all=False,success=True,failure=False`
-
-.. warning::
-
-    This analysis has not been proven to be rigorous, so it is likely possible for tasks
-    to become impossible to run in obscure situations, so a timeout may be a good choice.
-
-.. _parallel_schedulers:
-
-Schedulers
-==========
-
-There are a variety of valid ways to determine where jobs should be assigned in a 
-load-balancing situation.  In IPython, we support several standard schemes, and
-even make it easy to define your own.  The scheme can be selected via the ``--scheme``
-argument to :command:`ipcontroller`, or in the :attr:`HubFactory.scheme` attribute
-of a controller config object.
-
-The built-in routing schemes:
-
-To select one of these schemes, simply do::
-
-    $ ipcontroller --scheme <schemename>
-    for instance:
-    $ ipcontroller --scheme lru
-
-lru: Least Recently Used
-
-    Always assign work to the least-recently-used engine.  A close relative of
-    round-robin, it will be fair with respect to the number of tasks, agnostic 
-    with respect to runtime of each task.
-
-plainrandom: Plain Random
-
-    Randomly picks an engine on which to run.
-
-twobin: Two-Bin Random
-
-    **Requires numpy**
-    
-     Pick two engines at random, and use the LRU of the two. This is known to be better
-    than plain random in many cases, but requires a small amount of computation.
-
-leastload: Least Load
-
-    **This is the default scheme**
-
-    Always assign tasks to the engine with the fewest outstanding tasks (LRU breaks tie).
-
-weighted: Weighted Two-Bin Random
-
-    **Requires numpy**
-    
-    Pick two engines at random using the number of outstanding tasks as inverse weights,
-    and use the one with the lower load.
-
-
-Pure ZMQ Scheduler
-------------------
-
-For maximum throughput, the 'pure' scheme is not Python at all, but a C-level
-:class:`MonitoredQueue` from PyZMQ, which uses a ZeroMQ ``XREQ`` socket to perform all
-load-balancing. This scheduler does not support any of the advanced features of the Python
-:class:`.Scheduler`.
-
-Disabled features when using the ZMQ Scheduler:
-
-* Engine unregistration
-    Task farming will be disabled if an engine unregisters.  
-    Further, if an engine is unregistered during computation, the scheduler may not recover.
-* Dependencies
-    Since there is no Python logic inside the Scheduler, routing decisions cannot be made
-    based on message content.
-* Early destination notification
-    The Python schedulers know which engine gets which task, and notify the Hub.  This 
-    allows graceful handling of Engines coming and going.  There is no way to know
-    where ZeroMQ messages have gone, so there is no way to know what tasks are on which
-    engine until they *finish*.  This makes recovery from engine shutdown very difficult.
-
-
-.. note::
-
-    TODO: performance comparisons
-
-
-More details
-============
-
-The :class:`LoadBalancedView` has many more powerful features that allow quite a bit
-of flexibility in how tasks are defined and run. The next places to look are
-in the following classes:
-
-* :class:`~IPython.parallel.client.view.LoadBalancedView`
-* :class:`~IPython.parallel.client.asyncresult.AsyncResult`
-* :meth:`~IPython.parallel.client.view.LoadBalancedView.apply`
-* :mod:`~IPython.parallel.controller.dependency`
-
-The following is an overview of how to use these classes together:
-
-1. Create a :class:`Client` and :class:`LoadBalancedView`
-2. Define some functions to be run as tasks
-3. Submit your tasks to using the :meth:`apply` method of your
-   :class:`LoadBalancedView` instance.
-4. Use :meth:`Client.get_result` to get the results of the
-   tasks, or use the :meth:`AsyncResult.get` method of the results to wait
-   for and then receive the results.
-
-.. seealso::
-
-    A demo of :ref:`DAG Dependencies <dag_dependencies>` with NetworkX and IPython.
diff --git a/docs/source/parallel/parallel_transition.txt b/docs/source/parallel/parallel_transition.txt
deleted file mode 100644
index 06e268e6ee3..00000000000
--- a/docs/source/parallel/parallel_transition.txt
+++ /dev/null
@@ -1,245 +0,0 @@
-.. _parallel_transition:
-
-=====================================================
-Transitioning from IPython.kernel to IPython.parallel
-=====================================================
-
-
-We have rewritten our parallel computing tools to use 0MQ_ and Tornado_.  The redesign
-has resulted in dramatically improved performance, as well as (we think), an improved
-interface for executing code remotely.  This doc is to help users of IPython.kernel
-transition their codes to the new code.
-
-.. _0MQ: http://zeromq.org
-.. _Tornado: https://github.com/facebook/tornado
-
-
-Processes
-=========
-
-The process model for the new parallel code is very similar to that of IPython.kernel. There is
-still a Controller, Engines, and Clients. However, the the Controller is now split into multiple
-processes, and can even be split across multiple machines. There does remain a single
-ipcontroller script for starting all of the controller processes.
-
-
-.. note::
-
-    TODO: fill this out after config system is updated
-
-
-.. seealso::
-
-    Detailed :ref:`Parallel Process <parallel_process>` doc for configuring and launching
-    IPython processes.
-
-Creating a Client
-=================
-
-Creating a client with default settings has not changed much, though the extended options have.
-One significant change is that there are no longer multiple Client classes to represent the
-various execution models. There is just one low-level Client object for connecting to the
-cluster, and View objects are created from that Client that provide the different interfaces for
-execution.
-
-
-To create a new client, and set up the default direct and load-balanced objects:
-
-.. sourcecode:: ipython
-
-    # old
-    In [1]: from IPython.kernel import client as kclient
-    
-    In [2]: mec = kclient.MultiEngineClient()
-
-    In [3]: tc = kclient.TaskClient()
-    
-    # new 
-    In [1]: from IPython.parallel import Client
-    
-    In [2]: rc = Client()
-
-    In [3]: dview = rc[:]
-    
-    In [4]: lbview = rc.load_balanced_view()
-
-Apply
-=====
-
-The main change to the API is the addition of the :meth:`apply` to the View objects. This is a
-method that takes `view.apply(f,*args,**kwargs)`, and calls `f(*args, **kwargs)` remotely on one
-or more engines, returning the result. This means that the natural unit of remote execution
-is no longer a string of Python code, but rather a Python function.
-
-* non-copying sends (track)
-* remote References
-
-The flags for execution have also changed.  Previously, there was only `block` denoting whether
-to wait for results.  This remains, but due to the addition of fully non-copying sends of 
-arrays and buffers, there is also a `track` flag, which instructs PyZMQ to produce a :class:`MessageTracker` that will let you know when it is safe again to edit arrays in-place.
-
-The result of a non-blocking call to `apply` is now an AsyncResult_ object, described below.
-
-MultiEngine to DirectView
-=========================
-
-The multiplexing interface previously provided by the MultiEngineClient is now provided by the
-DirectView. Once you have a Client connected, you can create a DirectView with index-access
-to the client (``view = client[1:5]``). The core methods for
-communicating with engines remain: `execute`, `run`, `push`, `pull`, `scatter`, `gather`. These
-methods all behave in much the same way as they did on a MultiEngineClient.
-
-
-.. sourcecode:: ipython
-
-    # old
-    In [2]: mec.execute('a=5', targets=[0,1,2])
-    
-    # new
-    In [2]: view.execute('a=5', targets=[0,1,2])
-    # or
-    In [2]: rc[0,1,2].execute('a=5')
-    
-
-This extends to any method that communicates with the engines. 
-
-Requests of the Hub (queue status, etc.) are no-longer asynchronous, and do not take a `block`
-argument.
-
-
-* :meth:`get_ids` is now the property :attr:`ids`, which is passively updated by the Hub (no
-  need for network requests for an up-to-date list).
-* :meth:`barrier` has been renamed to :meth:`wait`, and now takes an optional timeout. :meth:`flush` is removed, as it is redundant with :meth:`wait`
-* :meth:`zip_pull` has been removed
-* :meth:`keys` has been removed, but is easily implemented as::
-
-    dview.apply(lambda : globals().keys())
-
-* :meth:`push_function` and :meth:`push_serialized` are removed, as :meth:`push` handles 
-  functions without issue.
- 
-.. seealso::
-
-    :ref:`Our Direct Interface doc <parallel_multiengine>` for a simple tutorial with the 
-    DirectView.
-
-
-The other major difference is the use of :meth:`apply`. When remote work is simply functions,
-the natural return value is the actual Python objects. It is no longer the recommended pattern
-to use stdout as your results, due to stream decoupling and the asynchronous nature of how the
-stdout streams are handled in the new system.
-
-Task to LoadBalancedView
-========================
-
-Load-Balancing has changed more than Multiplexing.  This is because there is no longer a notion
-of a StringTask or a MapTask, there are simply Python functions to call.  Tasks are now
-simpler, because they are no longer composites of push/execute/pull/clear calls, they are
-a single function that takes arguments, and returns objects.
-
-The load-balanced interface is provided by the :class:`LoadBalancedView` class, created by the client:
-
-.. sourcecode:: ipython
-
-    In [10]: lbview = rc.load_balanced_view()
-    
-    # load-balancing can also be restricted to a subset of engines:
-    In [10]: lbview = rc.load_balanced_view([1,2,3])
-
-A simple task would consist of sending some data, calling a function on that data, plus some
-data that was resident on the engine already, and then pulling back some results.  This can
-all be done with a single function.
-
-
-Let's say you want to compute the dot product of two matrices, one of which resides on the
-engine, and another resides on the client.  You might construct a task that looks like this:
-
-.. sourcecode:: ipython
-
-    In [10]: st = kclient.StringTask("""
-                import numpy
-                C=numpy.dot(A,B)
-                """,
-                push=dict(B=B),
-                pull='C'
-                )
-    
-    In [11]: tid = tc.run(st)
-    
-    In [12]: tr = tc.get_task_result(tid)
-    
-    In [13]: C = tc['C']
-
-In the new code, this is simpler:
-
-.. sourcecode:: ipython
-
-    In [10]: import numpy
-    
-    In [11]: from IPython.parallel import Reference
-    
-    In [12]: ar = lbview.apply(numpy.dot, Reference('A'), B)
-    
-    In [13]: C = ar.get()
-
-Note the use of ``Reference`` This is a convenient representation of an object that exists
-in the engine's namespace, so you can pass remote objects as arguments to your task functions.
-
-Also note that in the kernel model, after the task is run, 'A', 'B', and 'C' are all defined on
-the engine. In order to deal with this, there is also a `clear_after` flag for Tasks to prevent
-pollution of the namespace, and bloating of engine memory. This is not necessary with the new
-code, because only those objects explicitly pushed (or set via `globals()`) will be resident on
-the engine beyond the duration of the task.
-
-.. seealso::
-
-    Dependencies also work very differently than in IPython.kernel.  See our :ref:`doc on Dependencies<parallel_dependencies>` for details.
-
-.. seealso::
-
-    :ref:`Our Task Interface doc <parallel_task>` for a simple tutorial with the 
-    LoadBalancedView.
-
-
-PendingResults to AsyncResults
-------------------------------
-
-With the departure from Twisted, we no longer have the :class:`Deferred` class for representing
-unfinished results. For this, we have an AsyncResult object, based on the object of the same
-name in the built-in :mod:`multiprocessing.pool` module. Our version provides a superset of that
-interface.
-
-However, unlike in IPython.kernel, we do not have PendingDeferred, PendingResult, or TaskResult
-objects. Simply this one object, the AsyncResult. Every asynchronous (`block=False`) call
-returns one.
-
-The basic methods of an AsyncResult are:
-
-.. sourcecode:: python
-
-    AsyncResult.wait([timeout]): # wait for the result to arrive
-    AsyncResult.get([timeout]): # wait for the result to arrive, and then return it
-    AsyncResult.metadata: # dict of extra information about execution.
-
-There are still some things that behave the same as IPython.kernel:
-
-.. sourcecode:: ipython
-
-    # old
-    In [5]: pr = mec.pull('a', targets=[0,1], block=False)
-    In [6]: pr.r
-    Out[6]: [5, 5]
-
-    # new
-    In [5]: ar = dview.pull('a', targets=[0,1], block=False)
-    In [6]: ar.r
-    Out[6]: [5, 5]
-
-The ``.r`` or ``.result`` property simply calls :meth:`get`, waiting for and returning the
-result.
-
-.. seealso::
-
-    :ref:`AsyncResult details <AsyncResult>`
-
-
diff --git a/docs/source/parallel/parallel_winhpc.txt b/docs/source/parallel/parallel_winhpc.txt
deleted file mode 100644
index 44ea429b6cf..00000000000
--- a/docs/source/parallel/parallel_winhpc.txt
+++ /dev/null
@@ -1,334 +0,0 @@
-============================================
-Getting started with Windows HPC Server 2008
-============================================
-
-.. note::
-
-    Not adapted to zmq yet
-
-Introduction
-============
-
-The Python programming language is an increasingly popular language for
-numerical computing. This is due to a unique combination of factors. First,
-Python is a high-level and *interactive* language that is well matched to
-interactive numerical work. Second, it is easy (often times trivial) to
-integrate legacy C/C++/Fortran code into Python. Third, a large number of
-high-quality open source projects provide all the needed building blocks for
-numerical computing: numerical arrays (NumPy), algorithms (SciPy), 2D/3D
-Visualization (Matplotlib, Mayavi, Chaco), Symbolic Mathematics (Sage, Sympy)
-and others.
-
-The IPython project is a core part of this open-source toolchain and is
-focused on creating a comprehensive environment for interactive and
-exploratory computing in the Python programming language. It enables all of
-the above tools to be used interactively and consists of two main components:
-
-* An enhanced interactive Python shell with support for interactive plotting
-  and visualization.
-* An architecture for interactive parallel computing.
-
-With these components, it is possible to perform all aspects of a parallel
-computation interactively. This type of workflow is particularly relevant in
-scientific and numerical computing where algorithms, code and data are
-continually evolving as the user/developer explores a problem. The broad
-treads in computing (commodity clusters, multicore, cloud computing, etc.)
-make these capabilities of IPython particularly relevant.
-
-While IPython is a cross platform tool, it has particularly strong support for
-Windows based compute clusters running Windows HPC Server 2008. This document
-describes how to get started with IPython on Windows HPC Server 2008. The
-content and emphasis here is practical: installing IPython, configuring
-IPython to use the Windows job scheduler and running example parallel programs
-interactively. A more complete description of IPython's parallel computing
-capabilities can be found in IPython's online documentation
-(http://ipython.scipy.org/moin/Documentation).
-
-Setting up your Windows cluster
-===============================
-
-This document assumes that you already have a cluster running Windows
-HPC Server 2008. Here is a broad overview of what is involved with setting up
-such a cluster:
-
-1. Install Windows Server 2008 on the head and compute nodes in the cluster.
-2. Setup the network configuration on each host. Each host should have a 
-   static IP address.
-3. On the head node, activate the "Active Directory Domain Services" role 
-   and make the head node the domain controller.
-4. Join the compute nodes to the newly created Active Directory (AD) domain.
-5. Setup user accounts in the domain with shared home directories.
-6. Install the HPC Pack 2008 on the head node to create a cluster.
-7. Install the HPC Pack 2008 on the compute nodes.
-
-More details about installing and configuring Windows HPC Server 2008 can be
-found on the Windows HPC Home Page (http://www.microsoft.com/hpc). Regardless
-of what steps you follow to set up your cluster, the remainder of this
-document will assume that:
-
-* There are domain users that can log on to the AD domain and submit jobs
-  to the cluster scheduler.
-* These domain users have shared home directories. While shared home
-  directories are not required to use IPython, they make it much easier to
-  use IPython.
-
-Installation of IPython and its dependencies
-============================================
-
-IPython and all of its dependencies are freely available and open source.
-These packages provide a powerful and cost-effective approach to numerical and
-scientific computing on Windows. The following dependencies are needed to run
-IPython on Windows:
-
-* Python 2.6 or 2.7 (http://www.python.org)
-* pywin32 (http://sourceforge.net/projects/pywin32/)
-* PyReadline (https://launchpad.net/pyreadline)
-* pyzmq (http://github.com/zeromq/pyzmq/downloads)
-* IPython (http://ipython.scipy.org)
-
-In addition, the following dependencies are needed to run the demos described
-in this document.
-
-* NumPy and SciPy (http://www.scipy.org)
-* Matplotlib (http://matplotlib.sourceforge.net/)
-
-The easiest way of obtaining these dependencies is through the Enthought
-Python Distribution (EPD) (http://www.enthought.com/products/epd.php). EPD is
-produced by Enthought, Inc. and contains all of these packages and others in a
-single installer and is available free for academic users. While it is also
-possible to download and install each package individually, this is a tedious
-process. Thus, we highly recommend using EPD to install these packages on
-Windows.
-
-Regardless of how you install the dependencies, here are the steps you will
-need to follow:
-
-1. Install all of the packages listed above, either individually or using EPD
-   on the head node, compute nodes and user workstations.
-
-2. Make sure that :file:`C:\\Python27` and :file:`C:\\Python27\\Scripts` are
-   in the system :envvar:`%PATH%` variable on each node.
-
-3. Install the latest development version of IPython. This can be done by
-   downloading the the development version from the IPython website
-   (http://ipython.scipy.org) and following the installation instructions.
-
-Further details about installing IPython or its dependencies can be found in
-the online IPython documentation (http://ipython.scipy.org/moin/Documentation)
-Once you are finished with the installation, you can try IPython out by
-opening a Windows Command Prompt and typing ``ipython``. This will
-start IPython's interactive shell and you should see something like the
-following screenshot:
-
-.. image:: ipython_shell.*
-
-Starting an IPython cluster
-===========================
-
-To use IPython's parallel computing capabilities, you will need to start an
-IPython cluster. An IPython cluster consists of one controller and multiple
-engines:
-
-IPython controller
-    The IPython controller manages the engines and acts as a gateway between 
-    the engines and the client, which runs in the user's interactive IPython
-    session. The controller is started using the :command:`ipcontroller`
-    command.
-
-IPython engine
-    IPython engines run a user's Python code in parallel on the compute nodes. 
-    Engines are starting using the :command:`ipengine` command.
-
-Once these processes are started, a user can run Python code interactively and
-in parallel on the engines from within the IPython shell using an appropriate
-client. This includes the ability to interact with, plot and visualize data
-from the engines.
-
-IPython has a command line program called :command:`ipcluster` that automates
-all aspects of starting the controller and engines on the compute nodes.
-:command:`ipcluster` has full support for the Windows HPC job scheduler,
-meaning that :command:`ipcluster` can use this job scheduler to start the
-controller and engines. In our experience, the Windows HPC job scheduler is
-particularly well suited for interactive applications, such as IPython. Once
-:command:`ipcluster` is configured properly, a user can start an IPython
-cluster from their local workstation almost instantly, without having to log
-on to the head node (as is typically required by Unix based job schedulers).
-This enables a user to move seamlessly between serial and parallel
-computations.
-
-In this section we show how to use :command:`ipcluster` to start an IPython
-cluster using the Windows HPC Server 2008 job scheduler. To make sure that
-:command:`ipcluster` is installed and working properly, you should first try
-to start an IPython cluster on your local host. To do this, open a Windows
-Command Prompt and type the following command::
-
-    ipcluster start -n 2
-
-You should see a number of messages printed to the screen, ending with 
-"IPython cluster: started". The result should look something like the following
-screenshot:
-
-.. image:: ipcluster_start.*
-
-At this point, the controller and two engines are running on your local host.
-This configuration is useful for testing and for situations where you want to
-take advantage of multiple cores on your local computer. 
-
-Now that we have confirmed that :command:`ipcluster` is working properly, we
-describe how to configure and run an IPython cluster on an actual compute
-cluster running Windows HPC Server 2008. Here is an outline of the needed
-steps:
-
-1. Create a cluster profile using: ``ipcluster create -p mycluster``
-
-2. Edit configuration files in the directory :file:`.ipython\\cluster_mycluster`
-
-3. Start the cluster using: ``ipcluser start -p mycluster -n 32``
-
-Creating a cluster profile
---------------------------
-
-In most cases, you will have to create a cluster profile to use IPython on a
-cluster. A cluster profile is a name (like "mycluster") that is associated
-with a particular cluster configuration. The profile name is used by
-:command:`ipcluster` when working with the cluster.
-
-Associated with each cluster profile is a cluster directory. This cluster
-directory is a specially named directory (typically located in the
-:file:`.ipython` subdirectory of your home directory) that contains the
-configuration files for a particular cluster profile, as well as log files and
-security keys. The naming convention for cluster directories is:
-:file:`cluster_<profile name>`. Thus, the cluster directory for a profile named
-"foo" would be :file:`.ipython\\cluster_foo`.
-
-To create a new cluster profile (named "mycluster") and the associated cluster
-directory, type the following command at the Windows Command Prompt::
-
-    ipcluster create -p mycluster
-
-The output of this command is shown in the screenshot below. Notice how
-:command:`ipcluster` prints out the location of the newly created cluster
-directory.
-
-.. image:: ipcluster_create.*
-
-Configuring a cluster profile
------------------------------
-
-Next, you will need to configure the newly created cluster profile by editing
-the following configuration files in the cluster directory:
-
-* :file:`ipcluster_config.py`
-* :file:`ipcontroller_config.py`
-* :file:`ipengine_config.py`
-
-When :command:`ipcluster` is run, these configuration files are used to 
-determine how the engines and controller will be started. In most cases,
-you will only have to set a few of the attributes in these files.
-
-To configure :command:`ipcluster` to use the Windows HPC job scheduler, you
-will need to edit the following attributes in the file
-:file:`ipcluster_config.py`::
-
-    # Set these at the top of the file to tell ipcluster to use the
-    # Windows HPC job scheduler.
-    c.Global.controller_launcher = \
-        'IPython.parallel.apps.launcher.WindowsHPCControllerLauncher'
-    c.Global.engine_launcher = \
-        'IPython.parallel.apps.launcher.WindowsHPCEngineSetLauncher'
-
-    # Set these to the host name of the scheduler (head node) of your cluster.
-    c.WindowsHPCControllerLauncher.scheduler = 'HEADNODE'
-    c.WindowsHPCEngineSetLauncher.scheduler = 'HEADNODE'
-
-There are a number of other configuration attributes that can be set, but
-in most cases these will be sufficient to get you started.
-
-.. warning::
-    If any of your configuration attributes involve specifying the location
-    of shared directories or files, you must make sure that you use UNC paths
-    like :file:`\\\\host\\share`. It is also important that you specify
-    these paths using raw Python strings: ``r'\\host\share'`` to make sure
-    that the backslashes are properly escaped.
-
-Starting the cluster profile
-----------------------------
-
-Once a cluster profile has been configured, starting an IPython cluster using
-the profile is simple::
-
-    ipcluster start -p mycluster -n 32
-
-The ``-n`` option tells :command:`ipcluster` how many engines to start (in
-this case 32). Stopping the cluster is as simple as typing Control-C.
-
-Using the HPC Job Manager
--------------------------
-
-When ``ipcluster start`` is run the first time, :command:`ipcluster` creates
-two XML job description files in the cluster directory:
-
-* :file:`ipcontroller_job.xml`
-* :file:`ipengineset_job.xml`
-
-Once these files have been created, they can be imported into the HPC Job
-Manager application. Then, the controller and engines for that profile can be
-started using the HPC Job Manager directly, without using :command:`ipcluster`.
-However, anytime the cluster profile is re-configured, ``ipcluster start``
-must be run again to regenerate the XML job description files. The
-following screenshot shows what the HPC Job Manager interface looks like
-with a running IPython cluster.
-
-.. image:: hpc_job_manager.*
-
-Performing a simple interactive parallel computation
-====================================================
-
-Once you have started your IPython cluster, you can start to use it. To do
-this, open up a new Windows Command Prompt and start up IPython's interactive
-shell by typing::
-
-    ipython
-
-Then you can create a :class:`MultiEngineClient` instance for your profile and
-use the resulting instance to do a simple interactive parallel computation. In
-the code and screenshot that follows, we take a simple Python function and
-apply it to each element of an array of integers in parallel using the
-:meth:`MultiEngineClient.map` method:
-
-.. sourcecode:: ipython
-
-    In [1]: from IPython.parallel import *
-
-    In [2]: c = MultiEngineClient(profile='mycluster')
-
-    In [3]: mec.get_ids()
-    Out[3]: [0, 1, 2, 3, 4, 5, 67, 8, 9, 10, 11, 12, 13, 14]
-
-    In [4]: def f(x):
-       ...:     return x**10
-
-    In [5]: mec.map(f, range(15))  # f is applied in parallel
-    Out[5]:
-    [0,
-     1,
-     1024,
-     59049,
-     1048576,
-     9765625,
-     60466176,
-     282475249,
-     1073741824,
-     3486784401L,
-     10000000000L,
-     25937424601L,
-     61917364224L,
-     137858491849L,
-     289254654976L]
-
-The :meth:`map` method has the same signature as Python's builtin :func:`map`
-function, but runs the calculation in parallel. More involved examples of using
-:class:`MultiEngineClient` are provided in the examples that follow.
-
-.. image:: mec_simple.*
-
diff --git a/docs/source/parallel/simpledag.pdf b/docs/source/parallel/simpledag.pdf
deleted file mode 100644
index 5aadf0dfe27..00000000000
Binary files a/docs/source/parallel/simpledag.pdf and /dev/null differ
diff --git a/docs/source/parallel/simpledag.png b/docs/source/parallel/simpledag.png
deleted file mode 100644
index 907c2becad0..00000000000
Binary files a/docs/source/parallel/simpledag.png and /dev/null differ
diff --git a/docs/source/parallel/single_digits.pdf b/docs/source/parallel/single_digits.pdf
deleted file mode 100644
index d62bf3cd563..00000000000
Binary files a/docs/source/parallel/single_digits.pdf and /dev/null differ
diff --git a/docs/source/parallel/single_digits.png b/docs/source/parallel/single_digits.png
deleted file mode 100644
index 2845c0e28bd..00000000000
Binary files a/docs/source/parallel/single_digits.png and /dev/null differ
diff --git a/docs/source/parallel/two_digit_counts.pdf b/docs/source/parallel/two_digit_counts.pdf
deleted file mode 100644
index 47c11a21dff..00000000000
Binary files a/docs/source/parallel/two_digit_counts.pdf and /dev/null differ
diff --git a/docs/source/parallel/two_digit_counts.png b/docs/source/parallel/two_digit_counts.png
deleted file mode 100644
index 24c68439a48..00000000000
Binary files a/docs/source/parallel/two_digit_counts.png and /dev/null differ
diff --git a/docs/source/parallel/winhpc_index.txt b/docs/source/parallel/winhpc_index.txt
deleted file mode 100644
index d52da22e26a..00000000000
--- a/docs/source/parallel/winhpc_index.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-========================================
-Using IPython on Windows HPC Server 2008
-========================================
-
-
-Contents
-========
-
-.. toctree::
-   :maxdepth: 1
-
-   parallel_winhpc.txt
-   parallel_demos.txt
-
diff --git a/docs/source/sphinx.toml b/docs/source/sphinx.toml
new file mode 100644
index 00000000000..0403cb5af43
--- /dev/null
+++ b/docs/source/sphinx.toml
@@ -0,0 +1,67 @@
+[sphinx]
+templates_path = ["_templates"]
+master_doc = "index"
+project = "IPython"
+copyright = "The IPython Development Team"
+github_project_url = "https://github.com/ipython/ipython"
+exclude_patterns = ["**.ipynb_checkpoints"]
+pygments_style = "sphinx"
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.doctest",
+    "sphinx.ext.inheritance_diagram",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.graphviz",
+    "sphinx.ext.extlinks",  # for easy GitHub links
+    "sphinxcontrib.jquery",
+    "IPython.sphinxext.ipython_console_highlighting",
+    "IPython.sphinxext.ipython_directive",
+    "sphinx.ext.napoleon",  # to preprocess docstrings
+    "magics",
+    "configtraits",
+]
+default_role = "literal"
+modindex_common_prefix = ["IPython."]
+
+[sphinx.source_suffix]
+".rst" = "restructuredtext"
+
+[intersphinx_mapping]
+python = { url = 'https://docs.python.org/3', fallback = '' }
+rpy2 = { url = 'https://rpy2.github.io/doc/latest/html', fallback = '' }
+jupyterclient = { url = 'https://jupyter-client.readthedocs.io/en/latest', fallback = '' }
+jupyter = { url = 'https://jupyter.readthedocs.io/en/latest', fallback = '' }
+jedi = { url = 'https://jedi.readthedocs.io/en/latest', fallback = '' }
+traitlets = { url = 'https://traitlets.readthedocs.io/en/latest', fallback = '' }
+ipykernel = { url = 'https://ipykernel.readthedocs.io/en/latest', fallback = '' }
+prompt_toolkit = { url = 'https://python-prompt-toolkit.readthedocs.io/en/stable', fallback = '' }
+ipywidgets = { url = 'https://ipywidgets.readthedocs.io/en/stable', fallback = '' }
+ipyparallel = { url = 'https://ipyparallel.readthedocs.io/en/stable', fallback = '' }
+pip = { url = 'https://pip.pypa.io/en/stable', fallback = '' }
+
+[html]
+html_theme = "sphinx_rtd_theme"
+html_static_path = ["_static"]
+html_favicon = "_static/favicon.ico"
+html_last_updated_fmt = "%b %d, %Y"
+htmlhelp_basename = "ipythondoc"
+html_additional_pages = [
+    ["interactive/htmlnotebook", "notebook_redirect.html"],
+    ["interactive/notebook", "notebook_redirect.html"],
+    ["interactive/nbconvert", "notebook_redirect.html"],
+    ["interactive/public_server", "notebook_redirect.html"]
+]
+
+[numpydoc]
+numpydoc_show_class_members = "False"
+numpydoc_class_members_toctree = "False"
+warning_is_error = "True"
+
+[latex]
+latex_documents = [
+    ['index', 'ipython.tex', 'IPython Documentation', 'The IPython Development Team', 'manual', 'True'],
+    ['parallel/winhpc_index', 'winhpc_whitepaper.tex', 'Using IPython on Windows HPC Server 2008', "Brian E. Granger", 'manual', 'True']
+]
+latex_use_modindex = "True"
+latex_font_size = "11pt"
diff --git a/docs/source/sphinxext.rst b/docs/source/sphinxext.rst
new file mode 100644
index 00000000000..f9b53606f4d
--- /dev/null
+++ b/docs/source/sphinxext.rst
@@ -0,0 +1,522 @@
+
+.. _ipython_directive:
+
+========================
+IPython Sphinx Directive
+========================
+
+.. note::
+
+   The IPython Sphinx Directive is in 'beta' and currently under
+   active development. Improvements to the code or documentation are welcome!
+
+.. |rst| replace:: reStructured text
+
+The :rst:dir:`ipython` directive is a stateful shell that can be used
+in |rst| files.
+
+It knows about standard ipython prompts, and extracts the input and output
+lines.  These prompts will be renumbered starting at ``1``.  The inputs will be
+fed to an embedded ipython interpreter and the outputs from that interpreter
+will be inserted as well.  For example, code blocks like the following::
+
+  .. ipython::
+
+     In [136]: x = 2
+
+     In [137]: x**3
+     Out[137]: 8
+
+will be rendered as
+
+.. ipython::
+
+   In [136]: x = 2
+
+   In [137]: x**3
+   Out[137]: 8
+
+.. note::
+
+   This tutorial should be read side-by-side with the Sphinx source
+   for this document because otherwise you will see only the rendered
+   output and not the code that generated it.  Excepting the example
+   above, we will not in general be showing the literal ReST in this
+   document that generates the rendered output.
+
+
+Directive and options
+=====================
+
+The IPython directive takes a number of options detailed here.
+
+.. rst:directive:: ipython
+
+   Create an IPython directive.
+
+   .. rst:directive:option:: doctest
+
+      Run a doctest on IPython code blocks in rst.
+
+   .. rst:directive:option:: python
+
+      Used to indicate that the relevant code block does not have IPython prompts.
+
+   .. rst:directive:option:: okexcept
+
+      Allow the code block to raise an exception.
+
+   .. rst:directive:option:: okwarning
+
+      Allow the code block to emit an warning.
+
+   .. rst:directive:option:: suppress
+
+      Silence any warnings or expected errors.
+
+   .. rst:directive:option:: verbatim
+
+      A noop that allows for any text to be syntax highlighted as valid IPython code.
+
+   .. rst:directive:option:: savefig: OUTFILE [IMAGE_OPTIONS]
+
+      Save output from matplotlib to *outfile*.
+
+It's important to note that all of these options can be used for the entire
+directive block or they can decorate individual lines of code as explained
+in :ref:`pseudo-decorators`.
+
+
+Persisting the Python session across IPython directive blocks
+=============================================================
+
+The state from previous sessions is stored, and standard error is
+trapped. At doc build time, ipython's output and std err will be
+inserted, and prompts will be renumbered. So the prompt below should
+be renumbered in the rendered docs, and pick up where the block above
+left off.
+
+.. ipython::
+  :verbatim:
+
+  In [138]: z = x*3   # x is recalled from previous block
+
+  In [139]: z
+  Out[139]: 6
+
+  In [142]: print(z)
+  6
+
+  In [141]: q = z[)   # this is a syntax error -- we trap ipy exceptions
+  ------------------------------------------------------------
+     File "<ipython console>", line 1
+       q = z[)   # this is a syntax error -- we trap ipy exceptions
+	     ^
+  SyntaxError: invalid syntax
+
+
+Adding documentation tests to your IPython directive
+====================================================
+
+The embedded interpreter supports some limited markup.  For example,
+you can put comments in your ipython sessions, which are reported
+verbatim.  There are some handy "pseudo-decorators" that let you
+doctest the output.  The inputs are fed to an embedded ipython
+session and the outputs from the ipython session are inserted into
+your doc.  If the output in your doc and in the ipython session don't
+match on a doctest assertion, an error will occur.
+
+
+.. ipython::
+
+   In [1]: x = 'hello world'
+
+   # this will raise an error if the ipython output is different
+   @doctest
+   In [2]: x.upper()
+   Out[2]: 'HELLO WORLD'
+
+   # some readline features cannot be supported, so we allow
+   # "verbatim" blocks, which are dumped in verbatim except prompts
+   # are continuously numbered
+   @verbatim
+   In [3]: x.st<TAB>
+   x.startswith  x.strip
+
+For more information on @doctest decorator, please refer to the end of this page in Pseudo-Decorators section.
+
+Multi-line input
+================
+
+Multi-line input is supported.
+
+.. ipython::
+   :verbatim:
+
+   In [130]: url = 'http://ichart.finance.yahoo.com/table.csv?s=CROX\
+      .....: &d=9&e=22&f=2009&g=d&a=1&br=8&c=2006&ignore=.csv'
+
+   In [131]: print(url.split('&'))
+   ['http://ichart.finance.yahoo.com/table.csv?s=CROX', 'd=9', 'e=22',
+
+Testing directive outputs
+=========================
+
+The IPython Sphinx Directive makes it possible to test the outputs that you provide with your code. To do this,
+decorate the contents in your directive block with one of the options listed
+above.
+
+If an IPython doctest decorator is found, it will take these steps when your documentation is built:
+
+1. Run the *input* lines in your IPython directive block against the current Python kernel (remember that the session
+persists across IPython directive blocks);
+
+2. Compare the *output* of this with the output text that you've put in the IPython directive block (what comes
+after `Out[NN]`);
+
+3. If there is a difference, the directive will raise an error and your documentation build will fail.
+
+You can do doctesting on multi-line output as well.  Just be careful
+when using non-deterministic inputs like random numbers in the ipython
+directive, because your inputs are run through a live interpreter, so
+if you are doctesting random output you will get an error.  Here we
+"seed" the random number generator for deterministic output, and we
+suppress the seed line so it doesn't show up in the rendered output
+
+.. ipython::
+
+   In [133]: import numpy.random
+
+   @suppress
+   In [134]: numpy.random.seed(2358)
+
+   @doctest
+   In [135]: numpy.random.rand(10,2)
+   Out[135]:
+   array([[0.64524308, 0.59943846],
+          [0.47102322, 0.8715456 ],
+          [0.29370834, 0.74776844],
+          [0.99539577, 0.1313423 ],
+          [0.16250302, 0.21103583],
+          [0.81626524, 0.1312433 ],
+          [0.67338089, 0.72302393],
+          [0.7566368 , 0.07033696],
+          [0.22591016, 0.77731835],
+          [0.0072729 , 0.34273127]])
+
+For more information on @suppress and @doctest decorators, please refer to the end of this file in
+Pseudo-Decorators section.
+
+Another demonstration of multi-line input and output
+
+.. ipython::
+   :verbatim:
+
+   In [106]: print(x)
+   jdh
+
+   In [109]: for i in range(10):
+      .....:     print(i)
+      .....:
+      .....:
+   0
+   1
+   2
+   3
+   4
+   5
+   6
+   7
+   8
+   9
+
+
+Most of the "pseudo-decorators" can be used an options to ipython
+mode.  For example, to setup matplotlib pylab but suppress the output,
+you can do.  When using the matplotlib ``use`` directive, it should
+occur before any import of pylab.  This will not show up in the
+rendered docs, but the commands will be executed in the embedded
+interpreter and subsequent line numbers will be incremented to reflect
+the inputs::
+
+
+  .. ipython::
+     :suppress:
+     :okexcept:
+
+     In [144]: from matplotlib.pylab import *
+
+     In [145]: ion()
+
+.. ipython::
+   :suppress:
+   :okexcept:
+
+   In [144]: from matplotlib.pylab import *
+
+   In [145]: ion()
+
+Likewise, you can set ``:doctest:`` or ``:verbatim:`` to apply these
+settings to the entire block.  For example,
+
+.. ipython::
+   :verbatim:
+
+   In [9]: cd mpl/examples/
+   /home/jdhunter/mpl/examples
+
+   In [10]: pwd
+   Out[10]: '/home/jdhunter/mpl/examples'
+
+
+   In [14]: cd mpl/examples/<TAB>
+   mpl/examples/animation/        mpl/examples/misc/
+   mpl/examples/api/              mpl/examples/mplot3d/
+   mpl/examples/axes_grid/        mpl/examples/pylab_examples/
+   mpl/examples/event_handling/   mpl/examples/widgets
+
+   In [14]: cd mpl/examples/widgets/
+   /home/msierig/mpl/examples/widgets
+
+   In [15]: !wc *
+       2    12    77 README.txt
+      40    97   884 buttons.py
+      26    90   712 check_buttons.py
+      19    52   416 cursor.py
+     180   404  4882 menu.py
+      16    45   337 multicursor.py
+      36   106   916 radio_buttons.py
+      48   226  2082 rectangle_selector.py
+      43   118  1063 slider_demo.py
+      40   124  1088 span_selector.py
+     450  1274 12457 total
+
+You can create one or more pyplot plots and insert them with the
+``@savefig`` decorator.
+
+For more information on @savefig decorator, please refer to the end of this page in Pseudo-Decorators section.
+
+.. ipython::
+
+   @savefig plot_simple.png width=4in
+   In [151]: plot([1,2,3]);
+
+   # use a semicolon to suppress the output
+   @savefig hist_simple.png width=4in
+   In [151]: hist(np.random.randn(10000), 100);
+
+In a subsequent session, we can update the current figure with some
+text, and then resave
+
+.. ipython::
+
+
+   In [151]: ylabel('number')
+
+   In [152]: title('normal distribution')
+
+   @savefig hist_with_text.png width=4in
+   In [153]: grid(True)
+
+You can also have function definitions included in the source.
+
+.. ipython::
+
+   In [3]: def square(x):
+      ...:     """
+      ...:     An overcomplicated square function as an example.
+      ...:     """
+      ...:     if x < 0:
+      ...:         x = abs(x)
+      ...:     y = x * x
+      ...:     return y
+      ...:
+
+Then call it from a subsequent section.
+
+.. ipython::
+
+   In [4]: square(3)
+   Out [4]: 9
+
+   In [5]: square(-2)
+   Out [5]: 4
+
+
+Writing Pure Python Code
+------------------------
+
+Pure python code is supported by the optional argument `python`. In this pure
+python syntax you do not include the output from the python interpreter. The
+following markup::
+
+   .. ipython:: python
+
+      foo = 'bar'
+      print(foo)
+      foo = 2
+      foo**2
+
+Renders as
+
+.. ipython:: python
+
+   foo = 'bar'
+   print(foo)
+   foo = 2
+   foo**2
+
+We can even plot from python, using the savefig decorator, as well as, suppress
+output with a semicolon
+
+.. ipython:: python
+
+   @savefig plot_simple_python.png width=4in
+   plot([1,2,3]);
+
+For more information on @savefig decorator, please refer to the end of this page in Pseudo-Decorators section.
+
+Similarly, std err is inserted
+
+.. ipython:: python
+   :okexcept:
+
+   foo = 'bar'
+   foo[)
+
+Handling Comments
+==================
+
+Comments are handled and state is preserved
+
+.. ipython:: python
+
+   # comments are handled
+   print(foo)
+
+If you don't see the next code block then the options work.
+
+.. ipython:: python
+   :suppress:
+   :okexcept:
+
+   ioff()
+   ion()
+
+Splitting Python statements across lines
+========================================
+
+Multi-line input is handled.
+
+.. ipython:: python
+
+   line = 'Multi\
+           line &\
+           support &\
+           works'
+   print(line.split('&'))
+
+Functions definitions are correctly parsed
+
+.. ipython:: python
+
+   def square(x):
+       """
+       An overcomplicated square function as an example.
+       """
+       if x < 0:
+           x = abs(x)
+       y = x * x
+       return y
+
+And persist across sessions
+
+.. ipython:: python
+
+   print(square(3))
+   print(square(-2))
+
+Pretty much anything you can do with the ipython code, you can do with
+a simple python script. Obviously, though it doesn't make sense
+to use the doctest option.
+
+.. _pseudo-decorators:
+
+Pseudo-Decorators
+=================
+
+Here are the supported decorators, and any optional arguments they
+take.  Some of the decorators can be used as options to the entire
+block (eg ``verbatim`` and ``suppress``), and some only apply to the
+line just below them (eg ``savefig``).
+
+@suppress
+
+    execute the ipython input block, but suppress the input and output
+    block from the rendered output.  Also, can be applied to the entire
+    ``.. ipython`` block as a directive option with ``:suppress:``.
+
+@verbatim
+
+    insert the input and output block in verbatim, but auto-increment
+    the line numbers. Internally, the interpreter will be fed an empty
+    string, so it is a no-op that keeps line numbering consistent.
+    Also, can be applied to the entire ``.. ipython`` block as a
+    directive option with ``:verbatim:``.
+
+@savefig OUTFILE [IMAGE_OPTIONS]
+
+    save the figure to the static directory and insert it into the
+    document, possibly binding it into a minipage and/or putting
+    code/figure label/references to associate the code and the
+    figure. Takes args to pass to the image directive (*scale*,
+    *width*, etc can be kwargs); see `image options
+    <http://docutils.sourceforge.net/docs/ref/rst/directives.html#image>`_
+    for details.
+
+@doctest
+
+    Compare the pasted in output in the ipython block with the output
+    generated at doc build time, and raise errors if they don't
+    match. Also, can be applied to the entire ``.. ipython`` block as a
+    directive option with ``:doctest:``.
+
+Configuration Options
+=====================
+
+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.
+
+
+Automatically generated documentation
+=====================================
+
+.. automodule:: IPython.sphinxext.ipython_directive
+
diff --git a/docs/source/whatsnew/development.rst b/docs/source/whatsnew/development.rst
new file mode 100644
index 00000000000..7c902ce624c
--- /dev/null
+++ b/docs/source/whatsnew/development.rst
@@ -0,0 +1,52 @@
+=====================
+ Development version
+=====================
+
+This document describes in-flight development work.
+
+.. warning::
+
+    Please do not edit this file by hand (doing so will likely cause merge
+    conflicts for other Pull Requests). Instead, create a new file in the
+    `docs/source/whatsnew/pr` folder
+
+
+Development version (unreleased)
+
+
+Need to be updated:
+
+.. toctree::
+   :maxdepth: 2
+   :glob:
+
+   pr/*
+
+
+
+
+
+Gruvbox Dark Theme
+==================
+
+Gruvbox Dark is now available as a terminal syntax theme for IPython.
+
+Respect PYTHONSAFEPATH
+======================
+
+IPython now respects the value of Python's flag ``sys.flags.safe_path``, a flag which is most often set by the ``PYTHONSAFEPATH`` environment variable. Setting this causes Python not to automatically include the current working directory in the sys.path.
+
+IPython can already be configured to do this via the ``--ignore_cwd`` command-line flag or by setting ``c.InteractiveShellApp.ignore_cwd=True``. Now, IPython can also be configured by setting ``PYTHONSAFEPATH=1`` or by calling python with ``-P``.
+
+The behavior of ``safe_path`` was described in `what's new in 3.11`_ and in `PyConfig docs`_.
+
+
+.. _what's new in 3.11: https://docs.python.org/3/whatsnew/3.11.html#whatsnew311-pythonsafepath
+.. _PyConfig docs: https://docs.python.org/3/c-api/init_config.html#c.PyConfig.safe_path
+
+.. DO NOT EDIT THIS LINE BEFORE RELEASE. FEATURE INSERTION POINT.
+
+Backwards incompatible changes
+------------------------------
+
+.. DO NOT EDIT THIS LINE BEFORE RELEASE. INCOMPAT INSERTION POINT.
\ No newline at end of file
diff --git a/docs/source/whatsnew/development.txt b/docs/source/whatsnew/development.txt
deleted file mode 100644
index b6fcb4f6700..00000000000
--- a/docs/source/whatsnew/development.txt
+++ /dev/null
@@ -1,235 +0,0 @@
-================================================
-Development version
-================================================
-
-The changes listed here are a brief summary of the substantial work on IPython
-since the 0.10.x release series. For more details, please consult the actual
-source.
-
-Main `ipython` branch
-=====================
-
-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:
-
-* :class:`IPython.utils.traitlets.HasTraitlets`.
-* :class:`IPython.core.component.Component`.
-* :class:`IPython.core.application.Application`.
-* :class:`IPython.config.loader.ConfigLoader`.
-* :class:`IPython.config.loader.Config`
-
-We are still in the process of writing developer focused documentation about
-these classes, but for now our :ref:`configuration documentation
-<config_overview>` contains a high level overview of the concepts that these
-classes express.
-
-ZMQ 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
-ZeroMQ messaging framework. There is already a Qt console client, which can
-be started by calling ``ipython-qtconsole``. The protocol is :ref:`documented
-<messaging>`.
-
-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.
-
-New features
-------------
-
-* The input history is now written to an SQLite database. The API for
-  retrieving items from the history has also been redesigned.
-
-* The :mod:`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 :ref:`documentation <config_index>` for more details.
-
-* The :class:`~IPython.core.iplib.InteractiveShell` class is now a
-  :class:`~IPython.core.component.Component` 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.iplib.InteractiveShell` have
-  been organized into sections to make it easier to turn more sections
-  of functionality into componenets.
-
-* The embedded shell has been refactored into a truly standalone subclass of
-  :class:`InteractiveShell` called :class:`InteractiveShellEmbed`.  All
-  embedding logic has been taken out of the base class and put into the 
-  embedded subclass.
-
-* I have created methods of :class:`~IPython.core.iplib.InteractiveShell` to
-  help it cleanup after itself. The :meth:`cleanup` method controls this. We
-  couldn't do this in :meth:`__del__` because we have cycles in our object
-  graph that prevent it from being called.
-
-* Created a new module :mod:`IPython.utils.importstring` for resolving
-  strings like ``foo.bar.Bar`` to the actual class.
-
-* Completely refactored the :mod:`IPython.core.prefilter` module into
-  :class:`~IPython.core.component.Component` 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 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`.
-
-* Created a component system (:mod:`IPython.core.component`) that is based on
-  :mod:`IPython.utils.traitlets`. Components are arranged into a runtime
-  containment tree (not inheritance) that i) automatically propagates
-  configuration information and ii) allows components to discover each other
-  in a loosely coupled manner. In the future all parts of IPython will be
-  subclasses of :class:`~IPython.core.component.Component`. All IPython
-  developers should become familiar with the component system.
-
-* Created a new :class:`~IPython.config.loader.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 :class:`~IPython.config.loader.Config` instances recursively and iii) it
-  will automatically create sub-:class:`~IPython.config.loader.Config`
-  instances for attributes that start with an uppercase character.
-
-* Created new configuration loaders in :mod:`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 :mod:`argparse` and plain python
-  files.  These are used to implement the new configuration system.
-
-* Created a top-level :class:`Application` class in
-  :mod:`IPython.core.application` that is designed to encapsulate the starting
-  of any IPython process. An application loads and merges all the
-  configuration objects, constructs the main application :class:`Component`
-  instances and then starts the application running. The default
-  :class:`Application` class has built-in logic for handling the IPython
-  directory as well as profiles.
-
-* The :class:`Type` and :class:`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
-  :class:`~IPython.utils.traitlets.HasTraitlets` is instantiated.
-
-* :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`.
-
-* Added a new module :mod:`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
-  :command:`%gui` magic command.  Type ``%gui?`` at an IPython prompt for
-  documentation.
-
-* The command line options ``-wthread``, ``-qthread`` and
-  ``-gthread`` just call the appropriate :mod:`IPython.lib.inputhook`
-  functions.
-
-* For developers :mod:`IPython.lib.inputhook` provides a simple interface
-  for managing the event loops in their interactive GUI applications.
-  Examples can be found in our :file:`docs/examples/lib` directory.
-
-Backwards incompatible changes
-------------------------------
-
-* The extension loading functions have been renamed to
-  :func:`load_ipython_extension` and :func:`unload_ipython_extension`.
-
-* :class:`~IPython.core.iplib.InteractiveShell` no longer takes an
-  ``embedded`` argument. Instead just use the
-  :class:`~IPython.core.iplib.InteractiveShellEmbed` class.
-
-* ``__IPYTHON__`` is no longer injected into ``__builtin__``.
-
-* :meth:`Struct.__init__` no longer takes `None` as its first argument.  It
-  must be a :class:`dict` or :class:`Struct`.
-
-* :meth:`~IPython.core.iplib.InteractiveShell.ipmagic` has been renamed 
-  :meth:`~IPython.core.iplib.InteractiveShell.magic.`
-
-* The functions :func:`ipmagic` and :func:`ipalias` have been removed from
-  :mod:`__builtins__`.
-
-* The references to the global :class:`~IPython.core.iplib.InteractiveShell`
-  instance (``_ip``, and ``__IP``) have been removed from the user's
-  namespace. They are replaced by a new function called :func:`get_ipython`
-  that returns the current :class:`~IPython.core.iplib.InteractiveShell`
-  instance. This function is injected into the user's namespace and is now the
-  main way of accessing IPython's API.
-
-* Old style configuration files :file:`ipythonrc` and :file:`ipy_user_conf.py`
-  are no longer supported. Users should migrate there configuration files to
-  the new format described :ref:`here <config_overview>` and :ref:`here
-  <configuring_ipython>`.
-
-* The old IPython extension API that relied on :func:`ipapi` has been
-  completely removed. The new extension API is described :ref:`here
-  <configuring_ipython>`.
-
-* Support for ``qt3`` has been dropped.  User's who need this should use
-  previous versions of IPython.
-
-* Removed :mod:`shellglobals` as it was obsolete.
-
-* Removed all the threaded shells in :mod:`IPython.core.shell`. These are no
-  longer needed because of the new capabilities in
-  :mod:`IPython.lib.inputhook`.
-
-* The ``-pylab`` command line flag has been disabled until matplotlib adds
-  support for the new :mod:`IPython.lib.inputhook` approach.  The new stuff
-  does work with matplotlib, but you have to set everything up by hand.
-
-* New top-level sub-packages have been created: :mod:`IPython.core`, 
-  :mod:`IPython.lib`, :mod:`IPython.utils`, :mod:`IPython.deathrow`,
-  :mod:`IPython.quarantine`.  All existing top-level modules have been
-  moved to appropriate sub-packages.  All internal import statements
-  have been updated and tests have been added.  The build system (setup.py
-  and friends) have been updated.  See :ref:`this section <module_reorg>` of the
-  documentation for descriptions of these new sub-packages.
-
-* Compatability modules have been created for :mod:`IPython.Shell`, 
-  :mod:`IPython.ipapi` and :mod:`IPython.iplib` that display warnings
-  and then load the actual implementation from :mod:`IPython.core`.
-
-* :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>`.
-
-* The IPython GUIs in :mod:`IPython.frontend` and :mod:`IPython.gui` are likely
-  broken because of the refactoring in the core.  With proper updates, these
-  should still work.  We probably want to get these so they are not using
-  :mod:`IPython.kernel.core` (which is being phased out).
-
-
-
diff --git a/docs/source/whatsnew/github-stats-0.11.rst b/docs/source/whatsnew/github-stats-0.11.rst
new file mode 100644
index 00000000000..8fd4680c95b
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-0.11.rst
@@ -0,0 +1,528 @@
+.. _issues_list_011:
+
+Issues closed in the 0.11 development cycle
+===========================================
+
+In this cycle, we closed a total of 511 issues, 226 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 (226):
+
+* `620 <https://github.com/ipython/ipython/issues/620>`_: Release notes and updates to GUI support docs for 0.11
+* `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 resetting 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 variables 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 systems: 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 references
+* `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
diff --git a/docs/source/whatsnew/github-stats-0.12.rst b/docs/source/whatsnew/github-stats-0.12.rst
new file mode 100644
index 00000000000..aa7af162186
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-0.12.rst
@@ -0,0 +1,621 @@
+.. _issues_list_012:
+
+Issues closed in the 0.12 development cycle
+===========================================
+
+Issues closed in 0.12.1
+-----------------------
+
+GitHub stats for bugfix release 0.12.1 (12/28/2011-04/16/2012), backporting
+pull requests from 0.13.
+
+We closed a total of 71 issues: 44 pull requests and 27 issues; this is the
+full list (generated with the script `tools/github_stats.py`).
+
+This list is automatically generated, and may be incomplete:
+
+Pull Requests (44):
+
+* :ghpull:`1175`: core.completer: Clean up excessive and unused code.
+* :ghpull:`1187`: misc notebook: connection file cleanup, first heartbeat, startup flush
+* :ghpull:`1190`: Fix link to Chris Fonnesbeck blog post about 0.11 highlights.
+* :ghpull:`1196`: docs: looks like a file path might have been accidentally pasted in the middle of a word
+* :ghpull:`1206`: don't preserve fixConsole output in json
+* :ghpull:`1207`: fix loadpy duplicating newlines
+* :ghpull:`1213`: BUG: Minor typo in history_console_widget.py
+* :ghpull:`1218`: Added -q option to %prun for suppression of the output, along with editing the dochelp string.
+* :ghpull:`1222`: allow Reference as callable in map/apply
+* :ghpull:`1229`: Fix display of SyntaxError in Python 3
+* :ghpull:`1246`: Skip tests that require X, when importing pylab results in RuntimeError.
+* :ghpull:`1253`: set auto_create flag for notebook apps
+* :ghpull:`1257`: use self.kernel_manager_class in qtconsoleapp
+* :ghpull:`1262`: Heartbeat no longer shares the app's Context
+* :ghpull:`1283`: HeartMonitor.period should be an Integer
+* :ghpull:`1284`: a fix for GH 1269
+* :ghpull:`1289`: Make autoreload extension work on Python 3.
+* :ghpull:`1306`: Fix %prun input parsing for escaped characters (closes #1302)
+* :ghpull:`1312`: minor heartbeat tweaks
+* :ghpull:`1318`: make Ctrl-D in qtconsole act same as in terminal (ready to merge)
+* :ghpull:`1341`: Don't attempt to tokenize binary files for tracebacks
+* :ghpull:`1353`: Save notebook as script using unicode file handle.
+* :ghpull:`1363`: Fix some minor color/style config issues in the qtconsole
+* :ghpull:`1364`: avoid jsonlib returning Decimal
+* :ghpull:`1369`: load header with engine id when engine dies in TaskScheduler
+* :ghpull:`1370`: allow draft76 websockets (Safari)
+* :ghpull:`1374`: remove calls to meaningless ZMQStream.on_err
+* :ghpull:`1377`: Saving non-ascii history
+* :ghpull:`1396`: Fix for %tb magic.
+* :ghpull:`1402`: fix symlinked /home issue for FreeBSD
+* :ghpull:`1413`: get_home_dir expands symlinks, adjust test accordingly
+* :ghpull:`1414`: ignore errors in shell.var_expand
+* :ghpull:`1430`: Fix for tornado check for tornado < 1.1.0
+* :ghpull:`1445`: Don't build sphinx docs for sdists
+* :ghpull:`1463`: Fix completion when importing modules in the cwd.
+* :ghpull:`1477`: fix dangling `buffer` in IPython.parallel.util
+* :ghpull:`1495`: BUG: Fix pretty-printing for overzealous objects
+* :ghpull:`1496`: BUG: LBYL when clearing the output history on shutdown.
+* :ghpull:`1514`: DOC: Fix references to IPython.lib.pretty instead of the old location
+* :ghpull:`1517`: Fix indentation bug in IPython/lib/pretty.py
+* :ghpull:`1538`: store git commit hash in utils._sysinfo instead of hidden data file
+* :ghpull:`1599`: Fix for %run -d in Python 3
+* :ghpull:`1602`: Fix %env for Python 3
+* :ghpull:`1607`: cleanup sqlitedb temporary db file after tests
+
+Issues (27):
+
+* :ghissue:`676`: IPython.embed() from ipython crashes twice on exit
+* :ghissue:`846`: Autoreload extension doesn't work with Python 3.2
+* :ghissue:`1187`: misc notebook: connection file cleanup, first heartbeat, startup flush
+* :ghissue:`1191`: profile/startup files not executed with "notebook"
+* :ghissue:`1197`: Interactive shell trying to: from ... import history
+* :ghissue:`1198`: Kernel Has Died error in Notebook
+* :ghissue:`1201`: %env magic fails with Python 3.2
+* :ghissue:`1204`: double newline from %loadpy in python notebook (at least on mac)
+* :ghissue:`1208`: should dv.sync_import print failed imports ?
+* :ghissue:`1225`: SyntaxError display broken in Python 3
+* :ghissue:`1232`: Dead kernel loop
+* :ghissue:`1241`: When our debugger class is used standalone `_oh` key errors are thrown
+* :ghissue:`1254`: typo in notebooklist.js breaks links
+* :ghissue:`1260`: heartbeat failure on long gil-holding operation
+* :ghissue:`1268`: notebook %reset magic fails with StdinNotImplementedError
+* :ghissue:`1269`: Another strange input handling error
+* :ghissue:`1281`: in Hub: registration_timeout must be an integer, but heartmonitor.period is CFloat
+* :ghissue:`1302`: Input parsing with %prun clobbers escapes
+* :ghissue:`1304`: controller/server load can disrupt heartbeat
+* :ghissue:`1317`: Very slow traceback construction from Cython extension
+* :ghissue:`1345`: notebook can't save unicode as script
+* :ghissue:`1375`: %history -g -f file encoding issue
+* :ghissue:`1401`: numpy arrays cannot be used with View.apply() in Python 3
+* :ghissue:`1408`: test_get_home_dir_3 failed on Mac OS X
+* :ghissue:`1412`: Input parsing issue with %prun
+* :ghissue:`1421`: ipython32 %run -d breaks with NameError name 'execfile' is not defined
+* :ghissue:`1484`: unhide .git_commit_info.ini
+
+
+Issues closed in 0.12
+---------------------
+
+In this cycle, from August 1 to December 28 2011, we closed a total of 515
+issues, 257 pull requests and 258 regular issues; this is the full list
+(generated with the script `tools/github_stats.py`).
+
+Pull requests (257):
+
+* `1174 <https://github.com/ipython/ipython/issues/1174>`_: Remove %install_default_config and %install_profiles
+* `1178 <https://github.com/ipython/ipython/issues/1178>`_: Correct string type casting in pinfo.
+* `1096 <https://github.com/ipython/ipython/issues/1096>`_: Show class init and call tooltips in notebook
+* `1176 <https://github.com/ipython/ipython/issues/1176>`_: Modifications to profile list
+* `1173 <https://github.com/ipython/ipython/issues/1173>`_: don't load gui/pylab in console frontend
+* `1168 <https://github.com/ipython/ipython/issues/1168>`_: Add --script flag as shorthand for notebook save_script option.
+* `1165 <https://github.com/ipython/ipython/issues/1165>`_: encode image_tag as utf8 in [x]html export
+* `1161 <https://github.com/ipython/ipython/issues/1161>`_: Allow %loadpy to load remote URLs that don't end in .py
+* `1158 <https://github.com/ipython/ipython/issues/1158>`_: Add coding header when notebook exported to .py file.
+* `1160 <https://github.com/ipython/ipython/issues/1160>`_: don't ignore ctrl-C during `%gui qt`
+* `1159 <https://github.com/ipython/ipython/issues/1159>`_: Add encoding header to Python files downloaded from notebooks.
+* `1155 <https://github.com/ipython/ipython/issues/1155>`_: minor post-execute fixes (#1154)
+* `1153 <https://github.com/ipython/ipython/issues/1153>`_: Pager tearing bug
+* `1152 <https://github.com/ipython/ipython/issues/1152>`_: Add support for displaying maptlotlib axes directly.
+* `1079 <https://github.com/ipython/ipython/issues/1079>`_: Login/out button cleanups
+* `1151 <https://github.com/ipython/ipython/issues/1151>`_: allow access to user_ns in prompt_manager
+* `1120 <https://github.com/ipython/ipython/issues/1120>`_: updated vim-ipython (pending)
+* `1150 <https://github.com/ipython/ipython/issues/1150>`_: BUG: Scrolling pager in vsplit on Mac OSX tears.
+* `1149 <https://github.com/ipython/ipython/issues/1149>`_: #1148 (win32 arg_split)
+* `1147 <https://github.com/ipython/ipython/issues/1147>`_: Put qtconsole foreground when launching
+* `1146 <https://github.com/ipython/ipython/issues/1146>`_: allow saving notebook.py next to notebook.ipynb
+* `1128 <https://github.com/ipython/ipython/issues/1128>`_: fix pylab StartMenu item
+* `1140 <https://github.com/ipython/ipython/issues/1140>`_: Namespaces for embedding
+* `1132 <https://github.com/ipython/ipython/issues/1132>`_: [notebook] read-only: disable name field
+* `1125 <https://github.com/ipython/ipython/issues/1125>`_: notebook : update logo
+* `1135 <https://github.com/ipython/ipython/issues/1135>`_: allow customized template and static file paths for the notebook web app
+* `1122 <https://github.com/ipython/ipython/issues/1122>`_: BUG: Issue #755 qt IPythonWidget.execute_file fails if filename contains...
+* `1137 <https://github.com/ipython/ipython/issues/1137>`_: rename MPIExecLaunchers to MPILaunchers
+* `1130 <https://github.com/ipython/ipython/issues/1130>`_: optionally ignore  shlex's ValueError in arg_split
+* `1116 <https://github.com/ipython/ipython/issues/1116>`_: Shlex unicode
+* `1073 <https://github.com/ipython/ipython/issues/1073>`_: Storemagic plugin
+* `1143 <https://github.com/ipython/ipython/issues/1143>`_: Add post_install script to create start menu entries in Python 3
+* `1138 <https://github.com/ipython/ipython/issues/1138>`_: Fix tests to work when ~/.config/ipython contains a symlink.
+* `1121 <https://github.com/ipython/ipython/issues/1121>`_: Don't transform function calls on IPyAutocall objects
+* `1118 <https://github.com/ipython/ipython/issues/1118>`_: protect CRLF from carriage-return action
+* `1105 <https://github.com/ipython/ipython/issues/1105>`_: Fix for prompts containing newlines.
+* `1126 <https://github.com/ipython/ipython/issues/1126>`_: Totally remove pager when read only (notebook)
+* `1091 <https://github.com/ipython/ipython/issues/1091>`_: qtconsole : allow copy with shortcut in pager
+* `1114 <https://github.com/ipython/ipython/issues/1114>`_: fix magics history in two-process ipython console
+* `1113 <https://github.com/ipython/ipython/issues/1113>`_: Fixing #1112 removing failing asserts for test_carriage_return and test_beep
+* `1089 <https://github.com/ipython/ipython/issues/1089>`_: Support carriage return ('\r') and beep ('\b') characters in the qtconsole
+* `1108 <https://github.com/ipython/ipython/issues/1108>`_: Completer usability 2 (rebased of  pr #1082)
+* `864 <https://github.com/ipython/ipython/issues/864>`_: Two-process terminal frontend (ipython core branch)
+* `1082 <https://github.com/ipython/ipython/issues/1082>`_: usability and cross browser compat for completer
+* `1053 <https://github.com/ipython/ipython/issues/1053>`_: minor improvements to text placement in qtconsole
+* `1106 <https://github.com/ipython/ipython/issues/1106>`_: Fix display of errors in compiled code on Python 3
+* `1077 <https://github.com/ipython/ipython/issues/1077>`_: allow the notebook to run without MathJax
+* `1072 <https://github.com/ipython/ipython/issues/1072>`_: If object has a getdoc() method, override its normal docstring.
+* `1059 <https://github.com/ipython/ipython/issues/1059>`_: Switch to simple `__IPYTHON__` global
+* `1070 <https://github.com/ipython/ipython/issues/1070>`_: Execution count after SyntaxError
+* `1098 <https://github.com/ipython/ipython/issues/1098>`_: notebook: config section UI
+* `1101 <https://github.com/ipython/ipython/issues/1101>`_: workaround spawnb missing from pexpect.__all__
+* `1097 <https://github.com/ipython/ipython/issues/1097>`_: typo, should fix #1095
+* `1099 <https://github.com/ipython/ipython/issues/1099>`_: qtconsole export xhtml/utf8
+* `1083 <https://github.com/ipython/ipython/issues/1083>`_: Prompts
+* `1081 <https://github.com/ipython/ipython/issues/1081>`_: Fix wildcard search for updated namespaces
+* `1084 <https://github.com/ipython/ipython/issues/1084>`_: write busy in notebook window title...
+* `1078 <https://github.com/ipython/ipython/issues/1078>`_: PromptManager fixes
+* `1064 <https://github.com/ipython/ipython/issues/1064>`_: Win32 shlex
+* `1069 <https://github.com/ipython/ipython/issues/1069>`_: As you type completer, fix on Firefox
+* `1039 <https://github.com/ipython/ipython/issues/1039>`_: Base of an as you type completer.
+* `1065 <https://github.com/ipython/ipython/issues/1065>`_: Qtconsole fix racecondition
+* `507 <https://github.com/ipython/ipython/issues/507>`_: Prompt manager
+* `1056 <https://github.com/ipython/ipython/issues/1056>`_: Warning in code. qtconsole ssh -X
+* `1036 <https://github.com/ipython/ipython/issues/1036>`_: Clean up javascript based on js2-mode feedback.
+* `1052 <https://github.com/ipython/ipython/issues/1052>`_: Pylab fix
+* `648 <https://github.com/ipython/ipython/issues/648>`_: Usermod
+* `969 <https://github.com/ipython/ipython/issues/969>`_: Pexpect-u
+* `1007 <https://github.com/ipython/ipython/issues/1007>`_: Fix paste/cpaste bug and refactor/cleanup that code a lot.
+* `506 <https://github.com/ipython/ipython/issues/506>`_: make ENTER on a previous input field replace current input buffer
+* `1040 <https://github.com/ipython/ipython/issues/1040>`_: json/jsonapi cleanup
+* `1042 <https://github.com/ipython/ipython/issues/1042>`_: fix firefox (windows) break line on empty prompt number
+* `1015 <https://github.com/ipython/ipython/issues/1015>`_: emacs freezes when tab is hit in ipython with latest python-mode
+* `1023 <https://github.com/ipython/ipython/issues/1023>`_: flush stdout/stderr at the end of kernel init
+* `956 <https://github.com/ipython/ipython/issues/956>`_: Generate "All magics..." menu live
+* `1038 <https://github.com/ipython/ipython/issues/1038>`_: Notebook: don't change cell when selecting code using shift+up/down.
+* `987 <https://github.com/ipython/ipython/issues/987>`_: Add Tooltip to notebook.
+* `1028 <https://github.com/ipython/ipython/issues/1028>`_: Cleaner minimum version comparison 
+* `998 <https://github.com/ipython/ipython/issues/998>`_: defer to stdlib for path.get_home_dir()
+* `1033 <https://github.com/ipython/ipython/issues/1033>`_: update copyright to 2011/20xx-2011
+* `1032 <https://github.com/ipython/ipython/issues/1032>`_: Intercept <esc> avoid closing websocket on Firefox
+* `1030 <https://github.com/ipython/ipython/issues/1030>`_: use pyzmq tools where appropriate
+* `1029 <https://github.com/ipython/ipython/issues/1029>`_: Restore pspersistence, including %store magic, as an extension.
+* `1025 <https://github.com/ipython/ipython/issues/1025>`_: Dollar escape
+* `999 <https://github.com/ipython/ipython/issues/999>`_: Fix issue #880 - more useful message to user when %paste fails
+* `938 <https://github.com/ipython/ipython/issues/938>`_: changes to get ipython.el to work with the latest python-mode.el
+* `1012 <https://github.com/ipython/ipython/issues/1012>`_: Add logout button.
+* `1020 <https://github.com/ipython/ipython/issues/1020>`_: Dollar formatter for ! shell calls
+* `1019 <https://github.com/ipython/ipython/issues/1019>`_: Use repr() to make quoted strings
+* `1008 <https://github.com/ipython/ipython/issues/1008>`_: don't use crash_handler by default
+* `1003 <https://github.com/ipython/ipython/issues/1003>`_: Drop consecutive duplicates when refilling readline history
+* `997 <https://github.com/ipython/ipython/issues/997>`_: don't unregister interrupted post-exec functions
+* `996 <https://github.com/ipython/ipython/issues/996>`_: add Integer traitlet
+* `1016 <https://github.com/ipython/ipython/issues/1016>`_: Fix password hashing for Python 3
+* `1014 <https://github.com/ipython/ipython/issues/1014>`_: escape minus signs in manpages
+* `1013 <https://github.com/ipython/ipython/issues/1013>`_: [NumPyExampleDocstring] link was pointing to raw file
+* `1011 <https://github.com/ipython/ipython/issues/1011>`_: Add hashed password support.
+* `1005 <https://github.com/ipython/ipython/issues/1005>`_: Quick fix for os.system requiring str parameter
+* `994 <https://github.com/ipython/ipython/issues/994>`_: Allow latex formulas in HTML output
+* `955 <https://github.com/ipython/ipython/issues/955>`_: Websocket Adjustments
+* `979 <https://github.com/ipython/ipython/issues/979>`_: use system_raw in terminal, even on Windows
+* `989 <https://github.com/ipython/ipython/issues/989>`_: fix arguments for commands in _process_posix
+* `991 <https://github.com/ipython/ipython/issues/991>`_: Show traceback, continuing to start kernel if pylab init fails
+* `981 <https://github.com/ipython/ipython/issues/981>`_: Split likely multiline text when writing JSON notebooks
+* `957 <https://github.com/ipython/ipython/issues/957>`_: allow change of png DPI in inline backend
+* `968 <https://github.com/ipython/ipython/issues/968>`_: add wantDirectory to ipdoctest, so that directories will be checked for e
+* `984 <https://github.com/ipython/ipython/issues/984>`_: Do not expose variables defined at startup to %who etc.
+* `985 <https://github.com/ipython/ipython/issues/985>`_: Fixes for parallel code on Python 3
+* `963 <https://github.com/ipython/ipython/issues/963>`_: disable calltips in PySide < 1.0.7 to prevent segfault
+* `976 <https://github.com/ipython/ipython/issues/976>`_: Getting started on what's new
+* `929 <https://github.com/ipython/ipython/issues/929>`_: Multiline history
+* `964 <https://github.com/ipython/ipython/issues/964>`_: Default profile
+* `961 <https://github.com/ipython/ipython/issues/961>`_: Disable the pager for the test suite
+* `953 <https://github.com/ipython/ipython/issues/953>`_: Physics extension
+* `950 <https://github.com/ipython/ipython/issues/950>`_: Add directory for startup files
+* `940 <https://github.com/ipython/ipython/issues/940>`_: allow setting HistoryManager.hist_file with config
+* `948 <https://github.com/ipython/ipython/issues/948>`_: Monkeypatch Tornado 2.1.1 so it works with Google Chrome 16.
+* `916 <https://github.com/ipython/ipython/issues/916>`_: Run p ( https://github.com/ipython/ipython/pull/901 )
+* `923 <https://github.com/ipython/ipython/issues/923>`_: %config magic
+* `920 <https://github.com/ipython/ipython/issues/920>`_: unordered iteration of AsyncMapResults (+ a couple fixes)
+* `941 <https://github.com/ipython/ipython/issues/941>`_: Follow-up to 387dcd6a, `_rl.__doc__` is `None` with pyreadline
+* `931 <https://github.com/ipython/ipython/issues/931>`_: read-only notebook mode
+* `921 <https://github.com/ipython/ipython/issues/921>`_: Show invalid config message on TraitErrors during init
+* `815 <https://github.com/ipython/ipython/issues/815>`_: Fix #481 using custom qt4 input hook
+* `936 <https://github.com/ipython/ipython/issues/936>`_: Start webbrowser in a thread.  Prevents lockup with Chrome.
+* `937 <https://github.com/ipython/ipython/issues/937>`_: add dirty trick for readline import on OSX
+* `913 <https://github.com/ipython/ipython/issues/913>`_: Py3 tests2
+* `933 <https://github.com/ipython/ipython/issues/933>`_: Cancel in qt console closeevent should trigger event.ignore()
+* `930 <https://github.com/ipython/ipython/issues/930>`_: read-only notebook mode
+* `910 <https://github.com/ipython/ipython/issues/910>`_: Make import checks more explicit in %whos
+* `926 <https://github.com/ipython/ipython/issues/926>`_: reincarnate -V cmdline option
+* `928 <https://github.com/ipython/ipython/issues/928>`_: BUG: Set context for font size change shortcuts in ConsoleWidget
+* `901 <https://github.com/ipython/ipython/issues/901>`_:   - There is a bug when running the profiler in the magic command (prun) with python3
+* `912 <https://github.com/ipython/ipython/issues/912>`_: Add magic for cls on windows. Fix for #181.
+* `905 <https://github.com/ipython/ipython/issues/905>`_: enable %gui/%pylab magics in the Kernel
+* `909 <https://github.com/ipython/ipython/issues/909>`_: Allow IPython to run without sqlite3
+* `887 <https://github.com/ipython/ipython/issues/887>`_: Qtconsole menu
+* `895 <https://github.com/ipython/ipython/issues/895>`_: notebook download implies save
+* `896 <https://github.com/ipython/ipython/issues/896>`_: Execfile
+* `899 <https://github.com/ipython/ipython/issues/899>`_: Brian's Notebook work
+* `892 <https://github.com/ipython/ipython/issues/892>`_: don't close figures every cycle with inline matplotlib backend
+* `893 <https://github.com/ipython/ipython/issues/893>`_: Adding clear_output to kernel and HTML notebook
+* `789 <https://github.com/ipython/ipython/issues/789>`_: Adding clear_output to kernel and HTML notebook.
+* `898 <https://github.com/ipython/ipython/issues/898>`_: Don't pass unicode sys.argv with %run or `ipython script.py`
+* `897 <https://github.com/ipython/ipython/issues/897>`_: Add tooltips to the notebook via 'title' attr.
+* `877 <https://github.com/ipython/ipython/issues/877>`_: partial fix for issue #678
+* `838 <https://github.com/ipython/ipython/issues/838>`_: reenable multiline history for terminals
+* `872 <https://github.com/ipython/ipython/issues/872>`_: The constructor of Client() checks for AssertionError in validate_url to open a file instead of connection to a URL if it fails.
+* `884 <https://github.com/ipython/ipython/issues/884>`_: Notebook usability fixes
+* `883 <https://github.com/ipython/ipython/issues/883>`_: User notification if notebook saving fails
+* `889 <https://github.com/ipython/ipython/issues/889>`_: Add drop_by_id method to shell, to remove variables added by extensions.
+* `891 <https://github.com/ipython/ipython/issues/891>`_: Ability to open the notebook in a browser when it starts
+* `813 <https://github.com/ipython/ipython/issues/813>`_: Create menu bar for qtconsole
+* `876 <https://github.com/ipython/ipython/issues/876>`_: protect IPython from bad custom exception handlers
+* `856 <https://github.com/ipython/ipython/issues/856>`_: Backgroundjobs
+* `868 <https://github.com/ipython/ipython/issues/868>`_: Warn user if MathJax can't be fetched from notebook closes #744
+* `878 <https://github.com/ipython/ipython/issues/878>`_: store_history=False default for run_cell
+* `824 <https://github.com/ipython/ipython/issues/824>`_: History access
+* `850 <https://github.com/ipython/ipython/issues/850>`_: Update codemirror to 2.15 and make the code internally more version-agnostic
+* `861 <https://github.com/ipython/ipython/issues/861>`_: Fix for issue #56
+* `819 <https://github.com/ipython/ipython/issues/819>`_: Adding -m option to %run, similar to -m for python interpreter.
+* `855 <https://github.com/ipython/ipython/issues/855>`_: promote aliases and flags, to ensure they have priority over config files
+* `862 <https://github.com/ipython/ipython/issues/862>`_: BUG: Completion widget position and pager focus.
+* `847 <https://github.com/ipython/ipython/issues/847>`_: Allow connection to kernels by files
+* `708 <https://github.com/ipython/ipython/issues/708>`_: Two-process terminal frontend
+* `857 <https://github.com/ipython/ipython/issues/857>`_: make sdist flags work again (e.g. --manifest-only)
+* `835 <https://github.com/ipython/ipython/issues/835>`_: Add Tab key to list of keys that scroll down the paging widget.
+* `859 <https://github.com/ipython/ipython/issues/859>`_: Fix for issue #800
+* `848 <https://github.com/ipython/ipython/issues/848>`_: Python3 setup.py install failure
+* `845 <https://github.com/ipython/ipython/issues/845>`_: Tests on Python 3
+* `802 <https://github.com/ipython/ipython/issues/802>`_: DOC: extensions: add documentation for the bundled extensions
+* `830 <https://github.com/ipython/ipython/issues/830>`_: contiguous stdout/stderr in notebook
+* `761 <https://github.com/ipython/ipython/issues/761>`_: Windows: test runner fails if repo path (e.g. home dir) contains spaces
+* `801 <https://github.com/ipython/ipython/issues/801>`_: Py3 notebook
+* `809 <https://github.com/ipython/ipython/issues/809>`_: use CFRunLoop directly in `ipython kernel --pylab osx`
+* `841 <https://github.com/ipython/ipython/issues/841>`_: updated old scipy.org links, other minor doc fixes
+* `837 <https://github.com/ipython/ipython/issues/837>`_: remove all trailling spaces
+* `834 <https://github.com/ipython/ipython/issues/834>`_: Issue https://github.com/ipython/ipython/issues/832 resolution
+* `746 <https://github.com/ipython/ipython/issues/746>`_: ENH: extensions: port autoreload to current API
+* `828 <https://github.com/ipython/ipython/issues/828>`_: fixed permissions (sub-modules should not be executable) + added shebang  for run_ipy_in_profiler.py
+* `798 <https://github.com/ipython/ipython/issues/798>`_: pexpect & Python 3
+* `804 <https://github.com/ipython/ipython/issues/804>`_: Magic 'range' crash if greater than len(input_hist)
+* `821 <https://github.com/ipython/ipython/issues/821>`_: update tornado dependency to 2.1
+* `807 <https://github.com/ipython/ipython/issues/807>`_: Facilitate ssh tunnel sharing by announcing ports
+* `795 <https://github.com/ipython/ipython/issues/795>`_: Add cluster-id for multiple cluster instances per profile
+* `742 <https://github.com/ipython/ipython/issues/742>`_: Glut
+* `668 <https://github.com/ipython/ipython/issues/668>`_: Greedy completer
+* `776 <https://github.com/ipython/ipython/issues/776>`_: Reworking qtconsole shortcut, add fullscreen
+* `790 <https://github.com/ipython/ipython/issues/790>`_: TST: add future unicode_literals test (#786)
+* `775 <https://github.com/ipython/ipython/issues/775>`_: redirect_in/redirect_out should be constrained to windows only
+* `793 <https://github.com/ipython/ipython/issues/793>`_: Don't use readline in the ZMQShell
+* `743 <https://github.com/ipython/ipython/issues/743>`_: Pyglet
+* `774 <https://github.com/ipython/ipython/issues/774>`_: basic/initial .mailmap for nice shortlog summaries
+* `770 <https://github.com/ipython/ipython/issues/770>`_: #769 (reopened)
+* `784 <https://github.com/ipython/ipython/issues/784>`_: Parse user code to AST using compiler flags.
+* `783 <https://github.com/ipython/ipython/issues/783>`_: always use StringIO, never cStringIO
+* `782 <https://github.com/ipython/ipython/issues/782>`_: flush stdout/stderr on displayhook call
+* `622 <https://github.com/ipython/ipython/issues/622>`_: Make pylab import all configurable 
+* `745 <https://github.com/ipython/ipython/issues/745>`_: Don't assume history requests succeed in qtconsole
+* `725 <https://github.com/ipython/ipython/issues/725>`_: don't assume cursor.selectedText() is a string
+* `778 <https://github.com/ipython/ipython/issues/778>`_: don't override execfile on Python 2
+* `663 <https://github.com/ipython/ipython/issues/663>`_: Python 3 compatilibility work
+* `762 <https://github.com/ipython/ipython/issues/762>`_: qtconsole ipython widget's execute_file fails if filename contains spaces or quotes
+* `763 <https://github.com/ipython/ipython/issues/763>`_: Set context for shortcuts in ConsoleWidget
+* `722 <https://github.com/ipython/ipython/issues/722>`_: PyPy compatibility
+* `757 <https://github.com/ipython/ipython/issues/757>`_: ipython.el is broken in 0.11
+* `764 <https://github.com/ipython/ipython/issues/764>`_: fix "--colors=<color>" option in py-python-command-args.
+* `758 <https://github.com/ipython/ipython/issues/758>`_: use ROUTER/DEALER socket names instead of XREP/XREQ
+* `736 <https://github.com/ipython/ipython/issues/736>`_: enh: added authentication ability for webapp
+* `748 <https://github.com/ipython/ipython/issues/748>`_: Check for tornado before running frontend.html tests.
+* `754 <https://github.com/ipython/ipython/issues/754>`_: restore msg_id/msg_type aliases in top level of msg dict
+* `769 <https://github.com/ipython/ipython/issues/769>`_: Don't treat bytes objects as json-safe
+* `753 <https://github.com/ipython/ipython/issues/753>`_: DOC: msg['msg_type'] removed
+* `766 <https://github.com/ipython/ipython/issues/766>`_: fix "--colors=<color>" option in py-python-command-args.
+* `765 <https://github.com/ipython/ipython/issues/765>`_: fix "--colors=<color>" option in py-python-command-args.
+* `741 <https://github.com/ipython/ipython/issues/741>`_: Run PyOs_InputHook in pager to keep plot windows interactive.
+* `664 <https://github.com/ipython/ipython/issues/664>`_: Remove ipythonrc references from documentation
+* `750 <https://github.com/ipython/ipython/issues/750>`_: Tiny doc fixes
+* `433 <https://github.com/ipython/ipython/issues/433>`_: ZMQ terminal frontend
+* `734 <https://github.com/ipython/ipython/issues/734>`_: Allow %magic argument filenames with spaces to be specified with quotes under win32
+* `731 <https://github.com/ipython/ipython/issues/731>`_: respect encoding of display data from urls
+* `730 <https://github.com/ipython/ipython/issues/730>`_: doc improvements for running notebook via secure protocol
+* `729 <https://github.com/ipython/ipython/issues/729>`_: use null char to start markdown cell placeholder
+* `727 <https://github.com/ipython/ipython/issues/727>`_: Minor fixes to the htmlnotebook
+* `726 <https://github.com/ipython/ipython/issues/726>`_: use bundled argparse if system argparse is < 1.1
+* `705 <https://github.com/ipython/ipython/issues/705>`_: Htmlnotebook
+* `723 <https://github.com/ipython/ipython/issues/723>`_: Add 'import time' to IPython/parallel/apps/launcher.py as time.sleep is called without time being imported
+* `714 <https://github.com/ipython/ipython/issues/714>`_: Install mathjax for offline use
+* `718 <https://github.com/ipython/ipython/issues/718>`_: Underline keyboard shortcut characters on appropriate buttons
+* `717 <https://github.com/ipython/ipython/issues/717>`_: Add source highlighting to markdown snippets
+* `716 <https://github.com/ipython/ipython/issues/716>`_: update EvalFormatter to allow arbitrary expressions
+* `712 <https://github.com/ipython/ipython/issues/712>`_: Reset execution counter after cache is cleared
+* `713 <https://github.com/ipython/ipython/issues/713>`_: Align colons in html notebook help dialog
+* `709 <https://github.com/ipython/ipython/issues/709>`_: Allow usage of '.' in notebook names
+* `706 <https://github.com/ipython/ipython/issues/706>`_: Implement static publishing of HTML notebook
+* `674 <https://github.com/ipython/ipython/issues/674>`_: use argparse to parse aliases & flags
+* `679 <https://github.com/ipython/ipython/issues/679>`_: HistoryManager.get_session_info()
+* `696 <https://github.com/ipython/ipython/issues/696>`_: Fix columnize bug, where tab completion with very long filenames would crash Qt console
+* `686 <https://github.com/ipython/ipython/issues/686>`_: add ssh tunnel support to qtconsole
+* `685 <https://github.com/ipython/ipython/issues/685>`_: Add SSH tunneling to engines
+* `384 <https://github.com/ipython/ipython/issues/384>`_: Allow pickling objects defined interactively.
+* `647 <https://github.com/ipython/ipython/issues/647>`_: My fix rpmlint
+* `587 <https://github.com/ipython/ipython/issues/587>`_: don't special case for py3k+numpy
+* `703 <https://github.com/ipython/ipython/issues/703>`_: make config-loading debug messages more explicit
+* `699 <https://github.com/ipython/ipython/issues/699>`_: make calltips configurable in qtconsole
+* `666 <https://github.com/ipython/ipython/issues/666>`_: parallel tests & extra readline escapes
+* `683 <https://github.com/ipython/ipython/issues/683>`_: BF - allow nose with-doctest setting in environment
+* `689 <https://github.com/ipython/ipython/issues/689>`_: Protect ipkernel from bad messages
+* `702 <https://github.com/ipython/ipython/issues/702>`_: Prevent ipython.py launcher from being imported.
+* `701 <https://github.com/ipython/ipython/issues/701>`_: Prevent ipython.py from being imported by accident
+* `670 <https://github.com/ipython/ipython/issues/670>`_: check for writable dirs, not just existence, in utils.path
+* `579 <https://github.com/ipython/ipython/issues/579>`_: Sessionwork
+* `687 <https://github.com/ipython/ipython/issues/687>`_: add `ipython kernel` for starting just a kernel
+* `627 <https://github.com/ipython/ipython/issues/627>`_: Qt Console history search
+* `646 <https://github.com/ipython/ipython/issues/646>`_: Generate package list automatically in find_packages
+* `660 <https://github.com/ipython/ipython/issues/660>`_: i658
+* `659 <https://github.com/ipython/ipython/issues/659>`_: don't crash on bad config files
+
+Regular issues (258):
+
+* `1177 <https://github.com/ipython/ipython/issues/1177>`_: UnicodeDecodeError in py3compat from "xlrd??"
+* `1094 <https://github.com/ipython/ipython/issues/1094>`_: Tooltip doesn't show constructor docstrings
+* `1170 <https://github.com/ipython/ipython/issues/1170>`_: double pylab greeting with c.InteractiveShellApp.pylab = "tk" in zmqconsole
+* `1166 <https://github.com/ipython/ipython/issues/1166>`_: E-mail cpaste broken
+* `1164 <https://github.com/ipython/ipython/issues/1164>`_: IPython qtconsole (0.12) can't export to html with external png
+* `1103 <https://github.com/ipython/ipython/issues/1103>`_: %loadpy should cut out encoding declaration
+* `1156 <https://github.com/ipython/ipython/issues/1156>`_: Notebooks downloaded as Python files require a header stating the encoding
+* `1157 <https://github.com/ipython/ipython/issues/1157>`_: Ctrl-C not working when GUI/pylab integration is active
+* `1154 <https://github.com/ipython/ipython/issues/1154>`_: We should be less aggressive in de-registering post-execution functions
+* `1134 <https://github.com/ipython/ipython/issues/1134>`_: "select-all, kill" leaves qtconsole in unusable state
+* `1148 <https://github.com/ipython/ipython/issues/1148>`_: A lot of testerrors
+* `803 <https://github.com/ipython/ipython/issues/803>`_: Make doctests work with Python 3
+* `1119 <https://github.com/ipython/ipython/issues/1119>`_: Start menu shortcuts not created in Python 3
+* `1136 <https://github.com/ipython/ipython/issues/1136>`_: The embedding machinery ignores user_ns
+* `607 <https://github.com/ipython/ipython/issues/607>`_: Use the new IPython logo/font in the notebook header
+* `755 <https://github.com/ipython/ipython/issues/755>`_: qtconsole ipython widget's execute_file fails if filename contains spaces or quotes
+* `1115 <https://github.com/ipython/ipython/issues/1115>`_: shlex_split should return unicode
+* `1109 <https://github.com/ipython/ipython/issues/1109>`_: timeit with string ending in space gives "ValueError: No closing quotation"
+* `1142 <https://github.com/ipython/ipython/issues/1142>`_: Install problems
+* `700 <https://github.com/ipython/ipython/issues/700>`_: Some SVG images render incorrectly in htmlnotebook
+* `1117 <https://github.com/ipython/ipython/issues/1117>`_: quit() doesn't work in terminal
+* `1111 <https://github.com/ipython/ipython/issues/1111>`_: ls broken after merge of #1089
+* `1104 <https://github.com/ipython/ipython/issues/1104>`_: Prompt spacing weird
+* `1124 <https://github.com/ipython/ipython/issues/1124>`_: Seg Fault 11 when calling PySide using "run" command
+* `1088 <https://github.com/ipython/ipython/issues/1088>`_: QtConsole : can't copy from pager
+* `568 <https://github.com/ipython/ipython/issues/568>`_: Test error and failure in IPython.core on windows
+* `1112 <https://github.com/ipython/ipython/issues/1112>`_: testfailure in IPython.frontend on windows
+* `1102 <https://github.com/ipython/ipython/issues/1102>`_: magic in IPythonDemo fails when not located at top of demo file
+* `629 <https://github.com/ipython/ipython/issues/629>`_: \r and \b in qtconsole don't behave as expected
+* `1080 <https://github.com/ipython/ipython/issues/1080>`_: Notebook: tab completion should close on "("
+* `973 <https://github.com/ipython/ipython/issues/973>`_: Qt Console close dialog and on-top Qt Console
+* `1087 <https://github.com/ipython/ipython/issues/1087>`_: QtConsole xhtml/Svg export broken ?
+* `1067 <https://github.com/ipython/ipython/issues/1067>`_: Parallel test suite hangs on Python 3
+* `1018 <https://github.com/ipython/ipython/issues/1018>`_: Local mathjax breaks install
+* `993 <https://github.com/ipython/ipython/issues/993>`_: `raw_input` redirection to foreign kernels is extremely brittle
+* `1100 <https://github.com/ipython/ipython/issues/1100>`_: ipython3 traceback unicode issue from extensions
+* `1071 <https://github.com/ipython/ipython/issues/1071>`_: Large html-notebooks hang on load on a slow machine
+* `89 <https://github.com/ipython/ipython/issues/89>`_: %pdoc np.ma.compress shows docstring twice
+* `22 <https://github.com/ipython/ipython/issues/22>`_: Include improvements from anythingipython.el
+* `633 <https://github.com/ipython/ipython/issues/633>`_: Execution count & SyntaxError
+* `1095 <https://github.com/ipython/ipython/issues/1095>`_: Uncaught TypeError: Object has no method 'remove_and_cancell_tooltip'
+* `1075 <https://github.com/ipython/ipython/issues/1075>`_: We're ignoring prompt customizations
+* `1086 <https://github.com/ipython/ipython/issues/1086>`_: Can't open qtconsole from outside source tree
+* `1076 <https://github.com/ipython/ipython/issues/1076>`_: namespace changes broke `foo.*bar*?` syntax
+* `1074 <https://github.com/ipython/ipython/issues/1074>`_: pprinting old-style class objects fails (TypeError: 'tuple' object is not callable)
+* `1063 <https://github.com/ipython/ipython/issues/1063>`_: IPython.utils test error due to missing unicodedata module
+* `592 <https://github.com/ipython/ipython/issues/592>`_: Bug in argument parsing for %run
+* `378 <https://github.com/ipython/ipython/issues/378>`_: Windows path escape issues
+* `1068 <https://github.com/ipython/ipython/issues/1068>`_: Notebook tab completion broken in Firefox
+* `75 <https://github.com/ipython/ipython/issues/75>`_: No tab completion after "/
+* `103 <https://github.com/ipython/ipython/issues/103>`_: customizable cpaste
+* `324 <https://github.com/ipython/ipython/issues/324>`_: Remove code in IPython.testing that is not being used
+* `131 <https://github.com/ipython/ipython/issues/131>`_: Global variables not seen by cprofile.run()
+* `851 <https://github.com/ipython/ipython/issues/851>`_: IPython shell swallows exceptions in certain circumstances
+* `882 <https://github.com/ipython/ipython/issues/882>`_: ipython freezes at start if IPYTHONDIR is on an NFS mount
+* `1057 <https://github.com/ipython/ipython/issues/1057>`_: Blocker: Qt console broken after "all magics" menu became dynamic
+* `1027 <https://github.com/ipython/ipython/issues/1027>`_: ipython does not like white space at end of file
+* `1058 <https://github.com/ipython/ipython/issues/1058>`_: New bug: Notebook asks for confirmation to leave even saved pages.
+* `1061 <https://github.com/ipython/ipython/issues/1061>`_: rep (magic recall) under pypy
+* `1047 <https://github.com/ipython/ipython/issues/1047>`_: Document the notebook format
+* `102 <https://github.com/ipython/ipython/issues/102>`_: Properties accessed twice for classes defined interactively
+* `16 <https://github.com/ipython/ipython/issues/16>`_: %store raises exception when storing compiled regex
+* `67 <https://github.com/ipython/ipython/issues/67>`_: tab expansion should only take one directory level at the time
+* `62 <https://github.com/ipython/ipython/issues/62>`_: Global variables undefined in interactive use of embedded ipython shell
+* `57 <https://github.com/ipython/ipython/issues/57>`_: debugging with ipython does not work well outside ipython
+* `38 <https://github.com/ipython/ipython/issues/38>`_: Line entry edge case error
+* `980 <https://github.com/ipython/ipython/issues/980>`_: Update parallel docs for new parallel architecture
+* `1017 <https://github.com/ipython/ipython/issues/1017>`_: Add small example about ipcluster/ssh startup
+* `1041 <https://github.com/ipython/ipython/issues/1041>`_: Proxy Issues
+* `967 <https://github.com/ipython/ipython/issues/967>`_: KernelManagers don't use zmq eventloop properly
+* `1055 <https://github.com/ipython/ipython/issues/1055>`_: "All Magics" display on Ubuntu 
+* `1054 <https://github.com/ipython/ipython/issues/1054>`_: ipython explodes on syntax error
+* `1051 <https://github.com/ipython/ipython/issues/1051>`_: ipython3 set_next_input() failure
+* `693 <https://github.com/ipython/ipython/issues/693>`_: "run -i" no longer works after %reset in terminal
+* `29 <https://github.com/ipython/ipython/issues/29>`_: cPickle works in standard interpreter, but not in IPython
+* `1050 <https://github.com/ipython/ipython/issues/1050>`_: ipython3 broken by commit 8bb887c8c2c447bf7
+* `1048 <https://github.com/ipython/ipython/issues/1048>`_: Update docs on notebook password
+* `1046 <https://github.com/ipython/ipython/issues/1046>`_: Searies of questions/issues?
+* `1045 <https://github.com/ipython/ipython/issues/1045>`_: crash when exiting - previously launched embedded sub-shell
+* `1043 <https://github.com/ipython/ipython/issues/1043>`_: pylab doesn't work in qtconsole
+* `1044 <https://github.com/ipython/ipython/issues/1044>`_: run -p doesn't work in python 3
+* `1010 <https://github.com/ipython/ipython/issues/1010>`_: emacs freezes when ipython-complete is called
+* `82 <https://github.com/ipython/ipython/issues/82>`_: Update devel docs with discussion about good changelogs
+* `116 <https://github.com/ipython/ipython/issues/116>`_: Update release management scripts and release.revision for git
+* `1022 <https://github.com/ipython/ipython/issues/1022>`_: Pylab banner shows up with first cell to execute
+* `787 <https://github.com/ipython/ipython/issues/787>`_: Keyboard selection of multiple lines in the notebook behaves inconsistently
+* `1037 <https://github.com/ipython/ipython/issues/1037>`_: notepad + jsonlib: TypeError: Only whitespace may be used for indentation.
+* `970 <https://github.com/ipython/ipython/issues/970>`_: Default home not writable, %HOME% does not help (windows)
+* `747 <https://github.com/ipython/ipython/issues/747>`_: HOMESHARE not a good choice for "writable homedir" on Windows
+* `810 <https://github.com/ipython/ipython/issues/810>`_: cleanup utils.path.get_home_dir
+* `2 <https://github.com/ipython/ipython/issues/2>`_: Fix the copyright statement in source code files to be accurate
+* `1031 <https://github.com/ipython/ipython/issues/1031>`_: <esc> on Firefox crash websocket
+* `684 <https://github.com/ipython/ipython/issues/684>`_: %Store eliminated in configuration and magic commands in 0.11
+* `1026 <https://github.com/ipython/ipython/issues/1026>`_: BUG: wrong default parameter in ask_yes_no
+* `880 <https://github.com/ipython/ipython/issues/880>`_: Better error message if %paste fails
+* `1024 <https://github.com/ipython/ipython/issues/1024>`_: autopx magic broken 
+* `822 <https://github.com/ipython/ipython/issues/822>`_: Unicode bug in Itpl when expanding shell variables in syscalls with !
+* `1009 <https://github.com/ipython/ipython/issues/1009>`_: Windows: regression in cd magic handling of paths
+* `833 <https://github.com/ipython/ipython/issues/833>`_: Crash python with matplotlib and unequal length arrays
+* `695 <https://github.com/ipython/ipython/issues/695>`_: Crash handler initialization is too aggressive
+* `1000 <https://github.com/ipython/ipython/issues/1000>`_: Remove duplicates when refilling readline history
+* `992 <https://github.com/ipython/ipython/issues/992>`_: Interrupting certain matplotlib operations leaves the inline backend 'wedged'
+* `942 <https://github.com/ipython/ipython/issues/942>`_: number traits should cast if value doesn't change
+* `1006 <https://github.com/ipython/ipython/issues/1006>`_: ls crashes when run on a UNC path or with non-ascii args
+* `944 <https://github.com/ipython/ipython/issues/944>`_: Decide the default image format for inline figures: SVG or PNG?
+* `842 <https://github.com/ipython/ipython/issues/842>`_: Python 3 on Windows (pyreadline) - expected an object with the buffer interface
+* `1002 <https://github.com/ipython/ipython/issues/1002>`_: ImportError due to incorrect version checking
+* `1001 <https://github.com/ipython/ipython/issues/1001>`_: Ipython "source" command?
+* `954 <https://github.com/ipython/ipython/issues/954>`_: IPython embed doesn't respect namespaces
+* `681 <https://github.com/ipython/ipython/issues/681>`_: pdb freezes inside qtconsole
+* `698 <https://github.com/ipython/ipython/issues/698>`_: crash report "TypeError: can only concatenate list (not "unicode") to list"
+* `978 <https://github.com/ipython/ipython/issues/978>`_: ipython 0.11 buffers external command output till the cmd is done
+* `952 <https://github.com/ipython/ipython/issues/952>`_: Need user-facing warning in the browser if websocket connection fails
+* `988 <https://github.com/ipython/ipython/issues/988>`_: Error using idlsave
+* `990 <https://github.com/ipython/ipython/issues/990>`_: ipython notebook - kernel dies if matplotlib is not installed
+* `752 <https://github.com/ipython/ipython/issues/752>`_: Matplotlib figures showed only once in notebook
+* `54 <https://github.com/ipython/ipython/issues/54>`_: Exception hook should be optional for embedding IPython in GUIs
+* `918 <https://github.com/ipython/ipython/issues/918>`_: IPython.frontend tests fail without tornado
+* `986 <https://github.com/ipython/ipython/issues/986>`_: Views created with c.direct_view() fail
+* `697 <https://github.com/ipython/ipython/issues/697>`_: Filter out from %who names loaded at initialization time
+* `932 <https://github.com/ipython/ipython/issues/932>`_: IPython 0.11 quickref card has superfluous "%recall and"
+* `982 <https://github.com/ipython/ipython/issues/982>`_: png files with executable permissions
+* `914 <https://github.com/ipython/ipython/issues/914>`_: Simpler system for running code after InteractiveShell is initialised
+* `911 <https://github.com/ipython/ipython/issues/911>`_: ipython crashes on startup if readline is missing
+* `971 <https://github.com/ipython/ipython/issues/971>`_: bookmarks created in 0.11 are corrupt in 0.12
+* `974 <https://github.com/ipython/ipython/issues/974>`_: object feature tab-completion crash
+* `939 <https://github.com/ipython/ipython/issues/939>`_: ZMQShell always uses default profile
+* `946 <https://github.com/ipython/ipython/issues/946>`_: Multi-tab Close action should offer option to leave all kernels alone
+* `949 <https://github.com/ipython/ipython/issues/949>`_: Test suite must not require any manual interaction
+* `643 <https://github.com/ipython/ipython/issues/643>`_: enable gui eventloop integration in ipkernel
+* `965 <https://github.com/ipython/ipython/issues/965>`_: ipython is crashed without launch.(python3.2)
+* `958 <https://github.com/ipython/ipython/issues/958>`_: Can't use os X clipboard on with qtconsole
+* `962 <https://github.com/ipython/ipython/issues/962>`_: Don't require tornado in the tests
+* `960 <https://github.com/ipython/ipython/issues/960>`_: crash on syntax error on Windows XP
+* `934 <https://github.com/ipython/ipython/issues/934>`_: The latest ipython branch doesn't work in Chrome
+* `870 <https://github.com/ipython/ipython/issues/870>`_: zmq version detection
+* `943 <https://github.com/ipython/ipython/issues/943>`_: HISTIGNORE for IPython
+* `947 <https://github.com/ipython/ipython/issues/947>`_: qtconsole segfaults at startup
+* `903 <https://github.com/ipython/ipython/issues/903>`_: Expose a magic to control config of the inline pylab backend
+* `908 <https://github.com/ipython/ipython/issues/908>`_: bad user config shouldn't crash IPython
+* `935 <https://github.com/ipython/ipython/issues/935>`_: Typing `break` causes IPython to crash.
+* `869 <https://github.com/ipython/ipython/issues/869>`_: Tab completion of `~/` shows no output post 0.10.x
+* `904 <https://github.com/ipython/ipython/issues/904>`_: whos under pypy1.6
+* `773 <https://github.com/ipython/ipython/issues/773>`_: check_security_dir() and check_pid_dir() fail on network filesystem
+* `915 <https://github.com/ipython/ipython/issues/915>`_: OS X Lion Terminal.app line wrap problem
+* `886 <https://github.com/ipython/ipython/issues/886>`_: Notebook kernel crash when specifying --notebook-dir on commandline
+* `636 <https://github.com/ipython/ipython/issues/636>`_: debugger.py: pydb broken
+* `808 <https://github.com/ipython/ipython/issues/808>`_: Ctrl+C during %reset confirm message crash Qtconsole
+* `927 <https://github.com/ipython/ipython/issues/927>`_: Using return outside a function crashes ipython
+* `919 <https://github.com/ipython/ipython/issues/919>`_: Pop-up segfault when moving cursor out of qtconsole window
+* `181 <https://github.com/ipython/ipython/issues/181>`_: cls command does not work on windows
+* `917 <https://github.com/ipython/ipython/issues/917>`_: documentation typos
+* `818 <https://github.com/ipython/ipython/issues/818>`_: %run does not work with non-ascii characters in path
+* `907 <https://github.com/ipython/ipython/issues/907>`_: Errors in custom completer functions can crash IPython
+* `867 <https://github.com/ipython/ipython/issues/867>`_: doc: notebook password authentication howto
+* `211 <https://github.com/ipython/ipython/issues/211>`_: paste command not working
+* `900 <https://github.com/ipython/ipython/issues/900>`_: Tab key should insert 4 spaces in qt console
+* `513 <https://github.com/ipython/ipython/issues/513>`_: [Qt console] cannot insert new lines into console functions using tab
+* `906 <https://github.com/ipython/ipython/issues/906>`_: qtconsoleapp 'parse_command_line' doen't like --existing anymore
+* `638 <https://github.com/ipython/ipython/issues/638>`_: Qt console --pylab=inline and getfigs(), etc.
+* `710 <https://github.com/ipython/ipython/issues/710>`_: unwanted unicode passed to args
+* `436 <https://github.com/ipython/ipython/issues/436>`_: Users should see tooltips for all buttons in the notebook UI
+* `207 <https://github.com/ipython/ipython/issues/207>`_: ipython crashes if atexit handler raises exception
+* `692 <https://github.com/ipython/ipython/issues/692>`_: use of Tracer() when debugging works but gives error messages
+* `690 <https://github.com/ipython/ipython/issues/690>`_: debugger does not print error message by default in 0.11
+* `571 <https://github.com/ipython/ipython/issues/571>`_: history of multiline entries
+* `749 <https://github.com/ipython/ipython/issues/749>`_: IPython.parallel test failure under Windows 7 and XP
+* `890 <https://github.com/ipython/ipython/issues/890>`_: ipclusterapp.py - helep
+* `885 <https://github.com/ipython/ipython/issues/885>`_: `ws-hostname` alias not recognized by notebook
+* `881 <https://github.com/ipython/ipython/issues/881>`_: Missing manual.pdf?
+* `744 <https://github.com/ipython/ipython/issues/744>`_: cannot create notebook in offline mode if mathjax not installed
+* `865 <https://github.com/ipython/ipython/issues/865>`_: Make tracebacks from %paste show the code
+* `535 <https://github.com/ipython/ipython/issues/535>`_: exception unicode handling in %run is faulty in qtconsole
+* `817 <https://github.com/ipython/ipython/issues/817>`_: IPython crashed
+* `799 <https://github.com/ipython/ipython/issues/799>`_: %edit magic not working on windows xp in qtconsole
+* `732 <https://github.com/ipython/ipython/issues/732>`_: QTConsole wrongly promotes the index of the input line on which user presses Enter
+* `662 <https://github.com/ipython/ipython/issues/662>`_: ipython test failures on Mac OS X Lion
+* `650 <https://github.com/ipython/ipython/issues/650>`_: Handle bad config files better
+* `829 <https://github.com/ipython/ipython/issues/829>`_: We should not insert new lines after all print statements in the notebook
+* `874 <https://github.com/ipython/ipython/issues/874>`_: ipython-qtconsole: pyzmq Version Comparison
+* `640 <https://github.com/ipython/ipython/issues/640>`_: matplotlib macosx windows don't respond in qtconsole
+* `624 <https://github.com/ipython/ipython/issues/624>`_: ipython intermittently segfaults when figure is closed (Mac OS X)
+* `871 <https://github.com/ipython/ipython/issues/871>`_: Notebook crashes if a profile is used
+* `56 <https://github.com/ipython/ipython/issues/56>`_: Have %cpaste accept also Ctrl-D as a termination marker
+* `849 <https://github.com/ipython/ipython/issues/849>`_: Command line options to not override profile options
+* `806 <https://github.com/ipython/ipython/issues/806>`_: Provide single-port connection to kernels
+* `691 <https://github.com/ipython/ipython/issues/691>`_: [wishlist] Automatically find existing kernel
+* `688 <https://github.com/ipython/ipython/issues/688>`_: local security vulnerability: all ports visible to any local user.
+* `866 <https://github.com/ipython/ipython/issues/866>`_: DistributionNotFound on running ipython 0.11 on Windows XP x86
+* `673 <https://github.com/ipython/ipython/issues/673>`_: raw_input appears to be round-robin for qtconsole
+* `863 <https://github.com/ipython/ipython/issues/863>`_: Graceful degradation when home directory not writable
+* `800 <https://github.com/ipython/ipython/issues/800>`_: Timing scripts with run -t -N <N> fails on report output
+* `858 <https://github.com/ipython/ipython/issues/858>`_: Typing 'continue' makes ipython0.11 crash
+* `840 <https://github.com/ipython/ipython/issues/840>`_: all processes run on one CPU core
+* `843 <https://github.com/ipython/ipython/issues/843>`_: "import braces" crashes ipython
+* `836 <https://github.com/ipython/ipython/issues/836>`_: Strange Output after IPython Install
+* `839 <https://github.com/ipython/ipython/issues/839>`_: Qtconsole segfaults when mouse exits window with active tooltip
+* `827 <https://github.com/ipython/ipython/issues/827>`_: Add support for checking several limits before running task on engine
+* `826 <https://github.com/ipython/ipython/issues/826>`_: Add support for creation of parallel task when no engine is running
+* `832 <https://github.com/ipython/ipython/issues/832>`_: Improve error message for %logstop
+* `831 <https://github.com/ipython/ipython/issues/831>`_: %logstart in read-only directory forbid any further command
+* `814 <https://github.com/ipython/ipython/issues/814>`_: ipython does not start -- DistributionNotFound
+* `794 <https://github.com/ipython/ipython/issues/794>`_: Allow >1 controller per profile
+* `820 <https://github.com/ipython/ipython/issues/820>`_: Tab Completion feature
+* `812 <https://github.com/ipython/ipython/issues/812>`_: Qt console crashes on Ubuntu 11.10
+* `816 <https://github.com/ipython/ipython/issues/816>`_: Import error using Python 2.7 and dateutil2.0 No module named _thread
+* `756 <https://github.com/ipython/ipython/issues/756>`_: qtconsole Windows fails to print error message for '%run nonexistent_file'
+* `651 <https://github.com/ipython/ipython/issues/651>`_: Completion doesn't work on element of a list
+* `617 <https://github.com/ipython/ipython/issues/617>`_: [qtconsole] %hist doesn't show anything in qtconsole
+* `786 <https://github.com/ipython/ipython/issues/786>`_: from __future__ import unicode_literals does not work
+* `779 <https://github.com/ipython/ipython/issues/779>`_: Using irunner from virtual evn uses systemwide ipython
+* `768 <https://github.com/ipython/ipython/issues/768>`_: codepage handling of output from scripts and shellcommands are not handled properly by qtconsole
+* `785 <https://github.com/ipython/ipython/issues/785>`_: Don't strip leading whitespace in repr() in notebook
+* `737 <https://github.com/ipython/ipython/issues/737>`_: in pickleshare.py line52 should be "if not os.path.isdir(self.root):"?
+* `738 <https://github.com/ipython/ipython/issues/738>`_: in ipthon_win_post_install.py line 38
+* `777 <https://github.com/ipython/ipython/issues/777>`_: print(…, sep=…) raises SyntaxError
+* `728 <https://github.com/ipython/ipython/issues/728>`_: ipcontroller crash with MPI
+* `780 <https://github.com/ipython/ipython/issues/780>`_: qtconsole Out value prints before the print statements that precede it
+* `632 <https://github.com/ipython/ipython/issues/632>`_: IPython Crash Report (0.10.2)
+* `253 <https://github.com/ipython/ipython/issues/253>`_: Unable to install ipython on windows
+* `80 <https://github.com/ipython/ipython/issues/80>`_: Split IPClusterApp into multiple Application subclasses for each subcommand
+* `34 <https://github.com/ipython/ipython/issues/34>`_: non-blocking pendingResult partial results
+* `739 <https://github.com/ipython/ipython/issues/739>`_: Tests fail if tornado not installed
+* `719 <https://github.com/ipython/ipython/issues/719>`_: Better support Pypy
+* `667 <https://github.com/ipython/ipython/issues/667>`_: qtconsole problem with default pylab profile
+* `661 <https://github.com/ipython/ipython/issues/661>`_: ipythonrc referenced in magic command in 0.11
+* `665 <https://github.com/ipython/ipython/issues/665>`_: Source introspection with ?? is broken
+* `724 <https://github.com/ipython/ipython/issues/724>`_: crash - ipython qtconsole, %quickref
+* `655 <https://github.com/ipython/ipython/issues/655>`_: ipython with qtconsole crashes
+* `593 <https://github.com/ipython/ipython/issues/593>`_: HTML Notebook Prompt can be deleted . . .
+* `563 <https://github.com/ipython/ipython/issues/563>`_: use argparse instead of kvloader for flags&aliases
+* `751 <https://github.com/ipython/ipython/issues/751>`_: Tornado version greater than 2.0 needed for firefox 6
+* `720 <https://github.com/ipython/ipython/issues/720>`_: Crash report when importing easter egg
+* `740 <https://github.com/ipython/ipython/issues/740>`_: Ctrl-Enter clears line in notebook
+* `772 <https://github.com/ipython/ipython/issues/772>`_: ipengine fails on Windows with "XXX lineno: 355, opcode: 0"
+* `771 <https://github.com/ipython/ipython/issues/771>`_: Add python 3 tag to setup.py
+* `767 <https://github.com/ipython/ipython/issues/767>`_: non-ascii in __doc__ string crashes qtconsole kernel when showing tooltip
+* `733 <https://github.com/ipython/ipython/issues/733>`_: In Windows, %run fails to strip quotes from filename
+* `721 <https://github.com/ipython/ipython/issues/721>`_: no completion in emacs by ipython(ipython.el)
+* `669 <https://github.com/ipython/ipython/issues/669>`_: Do not accept an ipython_dir that's not writeable
+* `711 <https://github.com/ipython/ipython/issues/711>`_: segfault on mac os x
+* `500 <https://github.com/ipython/ipython/issues/500>`_: "RuntimeError: Cannot change input buffer during execution" in console_widget.py
+* `707 <https://github.com/ipython/ipython/issues/707>`_: Copy and paste keyboard shortcuts do not work in Qt Console on OS X
+* `478 <https://github.com/ipython/ipython/issues/478>`_: PyZMQ's use of memoryviews breaks reconstruction of numpy arrays
+* `694 <https://github.com/ipython/ipython/issues/694>`_: Turning off callout tips in qtconsole
+* `704 <https://github.com/ipython/ipython/issues/704>`_: return kills IPython
+* `442 <https://github.com/ipython/ipython/issues/442>`_: Users should have intelligent autoindenting in the notebook
+* `615 <https://github.com/ipython/ipython/issues/615>`_: Wireframe and implement a project dashboard page
+* `614 <https://github.com/ipython/ipython/issues/614>`_: Wireframe and implement a notebook dashboard page
+* `606 <https://github.com/ipython/ipython/issues/606>`_: Users should be able to use the notebook to import/export a notebook to .py or .rst
+* `604 <https://github.com/ipython/ipython/issues/604>`_: A user should be able to leave a kernel running in the notebook and reconnect
+* `298 <https://github.com/ipython/ipython/issues/298>`_: Users should be able to save a notebook and then later reload it
+* `649 <https://github.com/ipython/ipython/issues/649>`_: ipython qtconsole (v0.11): setting "c.IPythonWidget.in_prompt = '>>> ' crashes
+* `672 <https://github.com/ipython/ipython/issues/672>`_: What happened to Exit?
+* `658 <https://github.com/ipython/ipython/issues/658>`_: Put the InteractiveShellApp section first in the auto-generated config files
+* `656 <https://github.com/ipython/ipython/issues/656>`_: [suggestion] dependency checking for pyqt for  Windows installer
+* `654 <https://github.com/ipython/ipython/issues/654>`_: broken documentation link on download page
+* `653 <https://github.com/ipython/ipython/issues/653>`_: Test failures in IPython.parallel
diff --git a/docs/source/whatsnew/github-stats-0.13.rst b/docs/source/whatsnew/github-stats-0.13.rst
new file mode 100644
index 00000000000..cdb9415432b
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-0.13.rst
@@ -0,0 +1,1203 @@
+.. _issues_list_013:
+
+Issues closed in the 0.13 development cycle
+===========================================
+
+Issues closed in 0.13
+---------------------
+
+GitHub stats since IPython 0.12 (2011/12/19 - 2012/06/30)
+
+These lists are automatically generated, and may be incomplete or contain
+duplicates.
+
+The following 62 authors contributed 1760 commits.
+
+* Aaron Culich
+* Aaron Meurer
+* Alex Kramer
+* Andrew Giessel
+* Andrew Straw
+* André Matos
+* Aron Ahmadia
+* Ben Edwards
+* Benjamin Ragan-Kelley
+* Bradley M. Froehle
+* Brandon Parsons
+* Brian E. Granger
+* Carlos Cordoba
+* David Hirschfeld
+* David Zderic
+* Ernie French
+* Fernando Perez
+* Ian Murray
+* Jason Grout
+* Jens H Nielsen
+* Jez Ng
+* Jonathan March
+* Jonathan Taylor
+* Julian Taylor
+* Jörgen Stenarson
+* Kent Inverarity
+* Marc Abramowitz
+* Mark Wiebe
+* Matthew Brett
+* Matthias BUSSONNIER
+* Michael Droettboom
+* Mike Hansen
+* Nathan Rice
+* Pankaj Pandey
+* Paul
+* Paul Ivanov
+* Piotr Zolnierczuk
+* Piti Ongmongkolkul
+* Puneeth Chaganti
+* Robert Kern
+* Ross Jones
+* Roy Hyunjin Han
+* Scott Tsai
+* Skipper Seabold
+* Stefan van der Walt
+* Steven Johnson
+* Takafumi Arakaki
+* Ted Wright
+* Thomas Hisch
+* Thomas Kluyver
+* Thomas Spura
+* Thomi Richards
+* Tim Couper
+* Timo Paulssen
+* Toby Gilham
+* Tony S Yu
+* W. Trevor King
+* Walter Doerwald
+* anatoly techtonik
+* fawce
+* mcelrath
+* wilsaj
+
+
+We closed a total of 1115 issues, 373 pull requests and 742 regular issues;
+this is the full list (generated with the script 
+:file:`tools/github_stats.py`):
+
+Pull Requests (373):
+
+* :ghpull:`1943`: add screenshot and link into releasenotes
+* :ghpull:`1954`: update some example notebooks
+* :ghpull:`2048`: move _encode_binary to jsonutil.encode_images
+* :ghpull:`2050`: only add quotes around xunit-file on Windows
+* :ghpull:`2047`: disable auto-scroll on mozilla
+* :ghpull:`2015`: Fixes for %paste with special transformations
+* :ghpull:`2046`: Iptest unicode
+* :ghpull:`1939`: Namespaces
+* :ghpull:`2042`: increase auto-scroll threshold to 100 lines
+* :ghpull:`2043`: move RemoteError import to top-level
+* :ghpull:`2036`: %alias_magic
+* :ghpull:`1968`: Proposal of icons for .ipynb files
+* :ghpull:`2037`: remove `ipython-qtconsole` gui-script
+* :ghpull:`2038`: add extra clear warning to shell doc
+* :ghpull:`2029`: Ship unminified js
+* :ghpull:`2007`: Add custom_control and custom_page_control variables to override the Qt widgets used by qtconsole
+* :ghpull:`2034`: fix&test push/pull recarrays
+* :ghpull:`2028`: Reduce unhelpful information shown by pinfo
+* :ghpull:`2030`: check wxPython version in inputhook
+* :ghpull:`2024`: Make interactive_usage a bit more rst friendly
+* :ghpull:`2031`: disable ^C^C confirmation on Windows
+* :ghpull:`2027`: match stdin encoding in frontend readline test
+* :ghpull:`2025`: Fix parallel test on WinXP - wait for resource cleanup.
+* :ghpull:`2016`: BUG: test runner fails in Windows if filenames contain spaces.
+* :ghpull:`2020`: Fix home path expansion test in Windows.
+* :ghpull:`2021`: Fix Windows pathname issue in 'odd encoding' test.
+* :ghpull:`2022`: don't check writability in test for get_home_dir when HOME is undefined
+* :ghpull:`1996`: frontend test tweaks
+* :ghpull:`2014`: relax profile regex in notebook
+* :ghpull:`2012`: Mono cursor offset
+* :ghpull:`2004`: Clarify generic message spec vs. Python message API in docs
+* :ghpull:`2010`: notebook: Print a warning (but do not abort) if no webbrowser can be found.
+* :ghpull:`2002`: Refactor %magic into a lsmagic_docs API function.
+* :ghpull:`1999`: `%magic` help: display line and cell magics in alphabetical order.
+* :ghpull:`1981`: Clean BG processes created by %%script on kernel exit
+* :ghpull:`1994`: Fix RST misformatting.
+* :ghpull:`1951`: minor notebook startup/notebook-dir adjustments
+* :ghpull:`1974`: Allow path completion on notebook.
+* :ghpull:`1964`: allow multiple instances of a Magic
+* :ghpull:`1991`: fix _ofind attr in %page
+* :ghpull:`1988`: check for active frontend in update_restart_checkbox
+* :ghpull:`1979`: Add support for tox (https://tox.readthedocs.io/) and Travis CI (http://travis-ci.org/)
+* :ghpull:`1970`: dblclick to restore size of images
+* :ghpull:`1978`: Notebook names truncating at the first period
+* :ghpull:`1825`: second attempt at scrolled long output
+* :ghpull:`1934`: Cell/Worksheet metadata
+* :ghpull:`1746`: Confirm restart (configuration option, and checkbox UI)
+* :ghpull:`1944`: [qtconsole] take %,%% prefix into account for completion
+* :ghpull:`1973`: fix another FreeBSD $HOME symlink issue
+* :ghpull:`1967`: Fix psums example description in docs
+* :ghpull:`1965`: fix for #1678, undo no longer clears cells
+* :ghpull:`1952`: avoid duplicate "Websockets closed" dialog on ws close
+* :ghpull:`1962`: Support unicode prompts
+* :ghpull:`1955`: update to latest version of vim-ipython
+* :ghpull:`1945`: Add --proc option to %%script
+* :ghpull:`1956`: move import RemoteError after get_exc_info
+* :ghpull:`1950`: Fix for copy action (Ctrl+C) when there is no pager defined in qtconsole
+* :ghpull:`1948`: Fix help string for InteractiveShell.ast_node_interactivity
+* :ghpull:`1942`: swallow stderr of which in utils.process.find_cmd
+* :ghpull:`1940`: fix completer css on some Chrome versions
+* :ghpull:`1938`: remove remaining references to deprecated XREP/XREQ names
+* :ghpull:`1925`: Fix styling of superscripts and subscripts. Closes #1924.
+* :ghpull:`1936`: increase duration of save messages
+* :ghpull:`1937`: add %save -f
+* :ghpull:`1935`: add version checking to pyreadline import test
+* :ghpull:`1849`: Octave magics
+* :ghpull:`1759`: github, merge PR(s) just by number(s) 
+* :ghpull:`1931`: Win py3fixes
+* :ghpull:`1933`: oinspect.find_file: Additional safety if file cannot be found.
+* :ghpull:`1932`: Fix adding functions to CommandChainDispatcher with equal priority on Py 3
+* :ghpull:`1928`: Select NoDB by default
+* :ghpull:`1923`: Add IPython syntax support to the %timeit magic, in line and cell mode
+* :ghpull:`1926`: Make completer recognize escaped quotes in strings.
+* :ghpull:`1893`: Update Parallel Magics and Exception Display
+* :ghpull:`1921`: magic_arguments: dedent but otherwise preserve indentation.
+* :ghpull:`1919`: Use oinspect in CodeMagics._find_edit_target
+* :ghpull:`1918`: don't warn in iptest if deathrow/quarantine are missing
+* :ghpull:`1917`: Fix for %pdef on Python 3
+* :ghpull:`1913`: Fix for #1428
+* :ghpull:`1911`: temporarily skip autoreload tests
+* :ghpull:`1909`: Fix for #1908, use os.path.normcase for safe filename comparisons
+* :ghpull:`1907`: py3compat fixes for %%script and tests
+* :ghpull:`1906`: ofind finds non-unique cell magics
+* :ghpull:`1845`: Fixes to inspection machinery for magics
+* :ghpull:`1902`: Workaround fix for gh-1632; minimal revert of gh-1424
+* :ghpull:`1900`: Cython libs
+* :ghpull:`1899`: add ScriptMagics to class list for generated config
+* :ghpull:`1898`: minimize manpages
+* :ghpull:`1897`: use glob for bad exclusion warning
+* :ghpull:`1855`: %%script and %%file magics
+* :ghpull:`1870`: add %%capture for capturing stdout/err
+* :ghpull:`1861`: Use dvipng to format sympy.Matrix
+* :ghpull:`1867`: Fix 1px margin bouncing of selected menu item.
+* :ghpull:`1889`: Reconnect when the websocket connection closes unexpectedly
+* :ghpull:`1886`: Fix a bug in renaming notebook
+* :ghpull:`1895`: Fix error in test suite with ip.system()
+* :ghpull:`1762`: add `locate` entry points
+* :ghpull:`1883`: Fix vertical offset due to bold/italics, and bad browser fonts.
+* :ghpull:`1875`: re-write columnize, with intermediate step.
+* :ghpull:`1851`: new completer for qtconsole.
+* :ghpull:`1892`: Remove suspicious quotes in interactiveshell.py
+* :ghpull:`1864`: Rmagic exceptions
+* :ghpull:`1829`: [notebook] don't care about leading prct in completion
+* :ghpull:`1832`: Make svg, jpeg and png images resizable in notebook.
+* :ghpull:`1674`: HTML Notebook carriage-return handling, take 2
+* :ghpull:`1882`: Remove importlib dependency which not available in Python 2.6.
+* :ghpull:`1879`: Correct stack depth for variable expansion in !system commands
+* :ghpull:`1841`: [notebook] deduplicate completion results
+* :ghpull:`1850`: Remove args/kwargs handling in TryNext, fix %paste error messages.
+* :ghpull:`1663`: Keep line-endings in ipynb
+* :ghpull:`1815`: Make : invalid in filenames in the Notebook JS code.
+* :ghpull:`1819`: doc: cleanup the parallel psums example a little
+* :ghpull:`1839`: External cleanup
+* :ghpull:`1782`: fix Magic menu in qtconsole, split in groups
+* :ghpull:`1862`: Minor bind_kernel improvements
+* :ghpull:`1857`: Prevent jumping of window to input when output is clicked.
+* :ghpull:`1856`: Fix 1px jumping of cells and menus in Notebook.
+* :ghpull:`1852`: fix chained resubmissions
+* :ghpull:`1780`: Rmagic extension
+* :ghpull:`1847`: add InlineBackend to ConsoleApp class list
+* :ghpull:`1836`: preserve header for resubmitted tasks
+* :ghpull:`1828`: change default extension to .ipy for %save -r
+* :ghpull:`1800`: Reintroduce recall
+* :ghpull:`1830`: lsmagic lists magics in alphabetical order
+* :ghpull:`1773`: Update SymPy profile: SymPy's latex() can now print set and frozenset
+* :ghpull:`1761`: Edited documentation to use IPYTHONDIR in place of ~/.ipython
+* :ghpull:`1822`: aesthetics pass on AsyncResult.display_outputs
+* :ghpull:`1821`: ENTER submits the rename notebook dialog.
+* :ghpull:`1820`: NotebookApp: Make the number of ports to retry user configurable.
+* :ghpull:`1816`: Always use filename as the notebook name.
+* :ghpull:`1813`: Add assert_in method to nose for Python 2.6
+* :ghpull:`1711`: New Tooltip, New Completer and JS Refactor
+* :ghpull:`1798`: a few simple fixes for docs/parallel
+* :ghpull:`1812`: Ensure AsyncResult.display_outputs doesn't display empty streams
+* :ghpull:`1811`: warn on nonexistent exclusions in iptest
+* :ghpull:`1810`: fix for #1809, failing tests in IPython.zmq
+* :ghpull:`1808`: Reposition alternate upload for firefox [need cross browser/OS/language test]
+* :ghpull:`1742`: Check for custom_exceptions only once
+* :ghpull:`1807`: add missing cython exclusion in iptest
+* :ghpull:`1805`: Fixed a vcvarsall.bat error on win32/Py2.7 when trying to compile with m...
+* :ghpull:`1739`: Dashboard improvement (necessary merge of #1658 and #1676 + fix #1492)
+* :ghpull:`1770`: Cython related magic functions
+* :ghpull:`1707`: Accept --gui=<...> switch in IPython qtconsole.
+* :ghpull:`1797`: Fix comment which breaks Emacs syntax highlighting.
+* :ghpull:`1795`: fix %gui magic
+* :ghpull:`1793`: Raise repr limit for strings to 80 characters (from 30).
+* :ghpull:`1794`: don't use XDG path on OS X
+* :ghpull:`1792`: Unicode-aware logger
+* :ghpull:`1791`: update zmqshell magics
+* :ghpull:`1787`: DOC: Remove regression from qt-console docs.
+* :ghpull:`1758`: test_pr, fallback on http if git protocol fail, and SSL errors...
+* :ghpull:`1748`: Fix some tests for Python 3.3
+* :ghpull:`1755`: test for pygments before running qt tests
+* :ghpull:`1771`: Make default value of interactivity passed to run_ast_nodes configurable
+* :ghpull:`1784`: restore loadpy to load
+* :ghpull:`1768`: Update parallel magics
+* :ghpull:`1779`: Tidy up error raising in magic decorators.
+* :ghpull:`1769`: Allow cell mode timeit without setup code.
+* :ghpull:`1716`: Fix for fake filenames in verbose traceback
+* :ghpull:`1763`: [qtconsole] fix append_plain_html -> append_html
+* :ghpull:`1732`: Refactoring of the magics system and implementation of cell magics
+* :ghpull:`1630`: Merge divergent Kernel implementations
+* :ghpull:`1705`: [notebook] Make pager resizable, and remember size...
+* :ghpull:`1606`: Share code for %pycat and %loadpy, make %pycat aware of URLs
+* :ghpull:`1757`: Open IPython notebook hyperlinks in a new window using target=_blank
+* :ghpull:`1754`: Fix typo enconters->encounters
+* :ghpull:`1753`: Clear window title when kernel is restarted
+* :ghpull:`1449`: Fix for bug #735 : Images missing from XML/SVG export
+* :ghpull:`1743`: Tooltip completer js refactor
+* :ghpull:`1681`: add qt config option to clear_on_kernel_restart
+* :ghpull:`1733`: Tooltip completer js refactor
+* :ghpull:`1727`: terminate kernel after embed_kernel tests
+* :ghpull:`1737`: add HistoryManager to ipapp class list
+* :ghpull:`1686`: ENH: Open a notebook from the command line
+* :ghpull:`1709`: fixes #1708, failing test in arg_split on windows
+* :ghpull:`1718`: Use CRegExp trait for regular expressions.
+* :ghpull:`1729`: Catch failure in repr() for %whos
+* :ghpull:`1726`: use eval for command-line args instead of exec
+* :ghpull:`1724`: fix scatter/gather with targets='all'
+* :ghpull:`1725`: add --no-ff to git pull in test_pr
+* :ghpull:`1721`: Tooltip completer js refactor
+* :ghpull:`1657`: Add `wait` optional argument to `hooks.editor`
+* :ghpull:`1717`: Define generic sys.ps{1,2,3}, for use by scripts.
+* :ghpull:`1691`: Finish PR #1446
+* :ghpull:`1710`: update MathJax CDN url for https
+* :ghpull:`1713`: Make autocall regexp's configurable.
+* :ghpull:`1703`: Allow TryNext to have an error message without it affecting the command chain
+* :ghpull:`1714`: minor adjustments to test_pr
+* :ghpull:`1704`: ensure all needed qt parts can be imported before settling for one
+* :ghpull:`1706`: Mark test_push_numpy_nocopy as a known failure for Python 3
+* :ghpull:`1698`: fix tooltip on token with number
+* :ghpull:`1245`: pythonw py3k fixes for issue #1226
+* :ghpull:`1685`: Add script to test pull request
+* :ghpull:`1693`: deprecate IPYTHON_DIR in favor of IPYTHONDIR
+* :ghpull:`1695`: Avoid deprecated warnings from ipython-qtconsole.desktop.
+* :ghpull:`1694`: Add quote to notebook to allow it to load
+* :ghpull:`1689`: Fix sys.path missing '' as first entry in `ipython kernel`.
+* :ghpull:`1687`: import Binary from bson instead of pymongo
+* :ghpull:`1616`: Make IPython.core.display.Image less notebook-centric
+* :ghpull:`1684`: CLN: Remove redundant function definition.
+* :ghpull:`1670`: Point %pastebin to gist
+* :ghpull:`1669`: handle pyout messages in test_message_spec
+* :ghpull:`1295`: add binary-tree engine interconnect example
+* :ghpull:`1642`: Cherry-picked commits from 0.12.1 release
+* :ghpull:`1659`: Handle carriage return characters ("\r") in HTML notebook output.
+* :ghpull:`1656`: ensure kernels are cleaned up in embed_kernel tests
+* :ghpull:`1664`: InteractiveShell.run_code: Update docstring.
+* :ghpull:`1662`: Delay flushing softspace until after cell finishes
+* :ghpull:`1643`: handle jpg/jpeg in the qtconsole
+* :ghpull:`1652`: add patch_pyzmq() for backporting a few changes from newer pyzmq
+* :ghpull:`1650`: DOC: moving files with SSH launchers
+* :ghpull:`1357`: add IPython.embed_kernel() 
+* :ghpull:`1640`: Finish up embed_kernel
+* :ghpull:`1651`: Remove bundled Itpl module
+* :ghpull:`1634`: incremental improvements to SSH launchers
+* :ghpull:`1649`: move examples/test_embed into examples/tests/embed
+* :ghpull:`1633`: Fix installing extension from local file on Windows
+* :ghpull:`1645`: Exclude UserDict when deep reloading NumPy.
+* :ghpull:`1637`: Removed a ':' which shouldn't have been there
+* :ghpull:`1631`: TST: QApplication doesn't quit early enough with PySide.
+* :ghpull:`1629`: evaluate a few dangling validate_message generators
+* :ghpull:`1621`: clear In[] prompt numbers on "Clear All Output"
+* :ghpull:`1627`: Test the Message Spec
+* :ghpull:`1624`: Fixes for byte-compilation on Python 3
+* :ghpull:`1615`: Add show() method to figure objects.
+* :ghpull:`1625`: Fix deepreload on Python 3
+* :ghpull:`1620`: pyin message now have execution_count
+* :ghpull:`1457`: Update deepreload to use a rewritten knee.py. Fixes dreload(numpy).
+* :ghpull:`1613`: allow map / parallel function for single-engine views
+* :ghpull:`1609`: exit notebook cleanly on SIGINT, SIGTERM
+* :ghpull:`1607`: cleanup sqlitedb temporary db file after tests
+* :ghpull:`1608`: don't rely on timedelta.total_seconds in AsyncResult
+* :ghpull:`1599`: Fix for %run -d on Python 3
+* :ghpull:`1602`: Fix %env magic on Python 3.
+* :ghpull:`1603`: Remove python3 profile
+* :ghpull:`1604`: Exclude IPython.quarantine from installation
+* :ghpull:`1600`: Specify encoding for io.open in notebook_reformat tests
+* :ghpull:`1605`: Small fixes for Animation and Progress notebook
+* :ghpull:`1529`: __all__ feature, improvement to dir2, and tests for both
+* :ghpull:`1548`: add sugar methods/properties to AsyncResult
+* :ghpull:`1535`: Fix pretty printing dispatch
+* :ghpull:`1399`: Use LaTeX to print various built-in types with the SymPy printing extension
+* :ghpull:`1597`: re-enter kernel.eventloop after catching SIGINT
+* :ghpull:`1490`: rename plaintext cell -> raw cell
+* :ghpull:`1480`: Fix %notebook magic, etc. nbformat unicode tests and fixes
+* :ghpull:`1588`: Gtk3 integration with ipython works.
+* :ghpull:`1595`: Examples syntax (avoid errors installing on Python 3)
+* :ghpull:`1526`: Find encoding for Python files
+* :ghpull:`1594`: Fix writing git commit ID to a file on build with Python 3
+* :ghpull:`1556`: shallow-copy DictDB query results
+* :ghpull:`1502`: small changes in response to pyflakes pass
+* :ghpull:`1445`: Don't build sphinx docs for sdists
+* :ghpull:`1538`: store git commit hash in utils._sysinfo instead of hidden data file
+* :ghpull:`1546`: attempt to suppress exceptions in channel threads at shutdown
+* :ghpull:`1559`: update tools/github_stats.py to use GitHub API v3
+* :ghpull:`1563`: clear_output improvements
+* :ghpull:`1560`: remove obsolete discussion of Twisted/trial from testing docs
+* :ghpull:`1569`: BUG: qtconsole -- non-standard handling of \a and \b. [Fixes #1561]
+* :ghpull:`1573`: BUG: Ctrl+C crashes wx pylab kernel in qtconsole.
+* :ghpull:`1568`: fix PR #1567
+* :ghpull:`1567`: Fix: openssh_tunnel did not parse port in `server`
+* :ghpull:`1565`: fix AsyncResult.abort
+* :ghpull:`1552`: use os.getcwdu in NotebookManager
+* :ghpull:`1541`: display_pub flushes stdout/err
+* :ghpull:`1544`: make MultiKernelManager.kernel_manager_class configurable
+* :ghpull:`1517`: Fix indentation bug in IPython/lib/pretty.py
+* :ghpull:`1519`: BUG: Include the name of the exception type in its pretty format.
+* :ghpull:`1489`: Fix zero-copy push
+* :ghpull:`1477`: fix dangling `buffer` in IPython.parallel.util
+* :ghpull:`1514`: DOC: Fix references to IPython.lib.pretty instead of the old location
+* :ghpull:`1481`: BUG: Improve placement of CallTipWidget
+* :ghpull:`1496`: BUG: LBYL when clearing the output history on shutdown.
+* :ghpull:`1508`: fix sorting profiles in clustermanager
+* :ghpull:`1495`: BUG: Fix pretty-printing for overzealous objects
+* :ghpull:`1472`: more general fix for #662
+* :ghpull:`1483`: updated magic_history docstring
+* :ghpull:`1383`: First version of cluster web service.
+* :ghpull:`1398`: fix %tb after SyntaxError
+* :ghpull:`1440`: Fix for failing testsuite when using --with-xml-coverage on windows.
+* :ghpull:`1419`: Add %install_ext magic function.
+* :ghpull:`1424`: Win32 shell interactivity
+* :ghpull:`1468`: Simplify structure of a Job in the TaskScheduler
+* :ghpull:`1447`: 1107 - Tab autocompletion can suggest invalid syntax
+* :ghpull:`1469`: Fix typo in comment (insert space)
+* :ghpull:`1463`: Fix completion when importing modules in the cwd.
+* :ghpull:`1466`: Fix for issue #1437, unfriendly windows qtconsole error handling
+* :ghpull:`1432`: Fix ipython directive
+* :ghpull:`1465`: allow `ipython help subcommand` syntax
+* :ghpull:`1416`: Conditional import of ctypes in inputhook
+* :ghpull:`1462`: expedite parallel tests
+* :ghpull:`1410`: Add javascript library and css stylesheet loading to JS class.
+* :ghpull:`1448`: Fix for #875 Never build unicode error messages
+* :ghpull:`1458`: use eval to uncan References
+* :ghpull:`1450`: load mathjax from CDN via https
+* :ghpull:`1451`: include heading level in JSON
+* :ghpull:`1444`: Fix pyhton -> python typos
+* :ghpull:`1414`: ignore errors in shell.var_expand
+* :ghpull:`1430`: Fix for tornado check for tornado < 1.1.0
+* :ghpull:`1413`: get_home_dir expands symlinks, adjust test accordingly
+* :ghpull:`1385`: updated and prettified magic doc strings
+* :ghpull:`1406`: Browser selection
+* :ghpull:`1377`: Saving non-ascii history
+* :ghpull:`1402`: fix symlinked /home issue for FreeBSD
+* :ghpull:`1405`: Only monkeypatch xunit when the tests are run using it.
+* :ghpull:`1395`: Xunit & KnownFailure
+* :ghpull:`1396`: Fix for %tb magic.
+* :ghpull:`1386`: Jsd3
+* :ghpull:`1388`: Add simple support for running inside a virtualenv
+* :ghpull:`1391`: Improve Hub/Scheduler when no engines are registered
+* :ghpull:`1369`: load header with engine id when engine dies in TaskScheduler
+* :ghpull:`1353`: Save notebook as script using unicode file handle.
+* :ghpull:`1352`: Add '-m mod : run library module as a script' option.
+* :ghpull:`1363`: Fix some minor color/style config issues in the qtconsole
+* :ghpull:`1371`: Adds a quiet keyword to sync_imports
+* :ghpull:`1387`: Fixing Cell menu to update cell type select box.
+* :ghpull:`1296`: Wx gui example: fixes the broken example for `%gui wx`.
+* :ghpull:`1372`: ipcontroller cleans up connection files unless reuse=True
+* :ghpull:`1374`: remove calls to meaningless ZMQStream.on_err
+* :ghpull:`1370`: allow draft76 websockets (Safari)
+* :ghpull:`1368`: Ensure handler patterns are str, not unicode
+* :ghpull:`1361`: Notebook bug fix branch
+* :ghpull:`1364`: avoid jsonlib returning Decimal
+* :ghpull:`1362`: Don't log complete contents of history replies, even in debug
+* :ghpull:`1347`: fix weird magic completion in notebook
+* :ghpull:`1346`: fixups for alternate URL prefix stuff
+* :ghpull:`1336`: crack at making notebook.html use the layout.html template
+* :ghpull:`1331`: RST and heading cells
+* :ghpull:`1247`: fixes a bug causing extra newlines after comments.
+* :ghpull:`1332`: notebook - allow prefixes in URL path.
+* :ghpull:`1341`: Don't attempt to tokenize binary files for tracebacks
+* :ghpull:`1334`: added key handler for control-s to notebook, seems to work pretty well
+* :ghpull:`1338`: Fix see also in docstrings so API docs build
+* :ghpull:`1335`: Notebook toolbar UI
+* :ghpull:`1299`: made notebook.html extend layout.html
+* :ghpull:`1318`: make Ctrl-D in qtconsole act same as in terminal (ready to merge)
+* :ghpull:`1328`: Coverage
+* :ghpull:`1206`: don't preserve fixConsole output in json
+* :ghpull:`1330`: Add linewrapping to text cells (new feature in CodeMirror).
+* :ghpull:`1309`: Inoculate clearcmd extension into %reset functionality
+* :ghpull:`1327`: Updatecm2
+* :ghpull:`1326`: Removing Ace edit capability.
+* :ghpull:`1325`: forgotten selected_cell -> get_selected_cell
+* :ghpull:`1316`: Pass subprocess test runners a suitable location for xunit output
+* :ghpull:`1303`: Updatecm
+* :ghpull:`1312`: minor heartbeat tweaks
+* :ghpull:`1306`: Fix %prun input parsing for escaped characters (closes #1302)
+* :ghpull:`1301`: New "Fix for issue #1202" based on current master.
+* :ghpull:`1289`: Make autoreload extension work on Python 3.
+* :ghpull:`1288`: Don't ask for confirmation when stdin isn't available
+* :ghpull:`1294`: TaskScheduler.hwm default to 1 instead of 0
+* :ghpull:`1283`: HeartMonitor.period should be an Integer
+* :ghpull:`1264`: Aceify
+* :ghpull:`1284`: a fix for GH 1269
+* :ghpull:`1213`: BUG: Minor typo in history_console_widget.py
+* :ghpull:`1267`: add NoDB for non-recording Hub
+* :ghpull:`1222`: allow Reference as callable in map/apply
+* :ghpull:`1257`: use self.kernel_manager_class in qtconsoleapp
+* :ghpull:`1253`: set auto_create flag for notebook apps
+* :ghpull:`1262`: Heartbeat no longer shares the app's Context
+* :ghpull:`1229`: Fix display of SyntaxError in Python 3
+* :ghpull:`1256`: Dewijmoize
+* :ghpull:`1246`: Skip tests that require X, when importing pylab results in RuntimeError.
+* :ghpull:`1211`: serve local files in notebook-dir
+* :ghpull:`1224`: edit text cells on double-click instead of single-click
+* :ghpull:`1187`: misc notebook: connection file cleanup, first heartbeat, startup flush
+* :ghpull:`1207`: fix loadpy duplicating newlines
+* :ghpull:`1129`: Unified setup.py
+* :ghpull:`1199`: Reduce IPython.external.*
+* :ghpull:`1218`: Added -q option to %prun for suppression of the output, along with editing the dochelp string.
+* :ghpull:`1217`: Added -q option to %prun for suppression of the output, along with editing the dochelp string
+* :ghpull:`1175`: core.completer: Clean up excessive and unused code.
+* :ghpull:`1196`: docs: looks like a file path might have been accidentally pasted in the middle of a word
+* :ghpull:`1190`: Fix link to Chris Fonnesbeck blog post about 0.11 highlights.
+
+Issues (742):
+
+* :ghissue:`1943`: add screenshot and link into releasenotes
+* :ghissue:`1570`: [notebook] remove 'left panel' references from example.
+* :ghissue:`1954`: update some example notebooks
+* :ghissue:`2048`: move _encode_binary to jsonutil.encode_images
+* :ghissue:`2050`: only add quotes around xunit-file on Windows
+* :ghissue:`2047`: disable auto-scroll on mozilla
+* :ghissue:`1258`: Magic %paste error
+* :ghissue:`2015`: Fixes for %paste with special transformations
+* :ghissue:`760`: Windows: test runner fails if repo path contains spaces
+* :ghissue:`2046`: Iptest unicode
+* :ghissue:`1939`: Namespaces
+* :ghissue:`2042`: increase auto-scroll threshold to 100 lines
+* :ghissue:`2043`: move RemoteError import to top-level
+* :ghissue:`641`: In %magic help, remove duplicate aliases
+* :ghissue:`2036`: %alias_magic
+* :ghissue:`1968`: Proposal of icons for .ipynb files
+* :ghissue:`825`: keyboardinterrupt crashes gtk gui when gtk.set_interactive is not available
+* :ghissue:`1971`: Remove duplicate magics docs
+* :ghissue:`2040`: Namespaces for cleaner public APIs
+* :ghissue:`2039`: ipython parallel import exception
+* :ghissue:`2035`: Getdefaultencoding test error with sympy 0.7.1_git
+* :ghissue:`2037`: remove `ipython-qtconsole` gui-script
+* :ghissue:`1516`: ipython-qtconsole script isn't installed for Python 2.x
+* :ghissue:`1297`: "ipython -p sh" is in documentation but doesn't work
+* :ghissue:`2038`: add extra clear warning to shell doc
+* :ghissue:`1265`: please ship unminified js and css sources
+* :ghissue:`2029`: Ship unminified js
+* :ghissue:`1920`: Provide an easy way to override the Qt widget used by qtconsole
+* :ghissue:`2007`: Add custom_control and custom_page_control variables to override the Qt widgets used by qtconsole
+* :ghissue:`2009`: In %magic help, remove duplicate aliases
+* :ghissue:`2033`: ipython parallel pushing and pulling recarrays
+* :ghissue:`2034`: fix&test push/pull recarrays
+* :ghissue:`2028`: Reduce unhelpful information shown by pinfo
+* :ghissue:`1992`: Tab completion fails with many spaces in filename 
+* :ghissue:`1885`: handle too old wx
+* :ghissue:`2030`: check wxPython version in inputhook
+* :ghissue:`2024`: Make interactive_usage a bit more rst friendly
+* :ghissue:`2031`: disable ^C^C confirmation on Windows
+* :ghissue:`2023`: Unicode test failure on OS X
+* :ghissue:`2027`: match stdin encoding in frontend readline test
+* :ghissue:`1901`: Windows: parallel test fails assert, leaves 14 python processes alive
+* :ghissue:`2025`: Fix parallel test on WinXP - wait for resource cleanup.
+* :ghissue:`1986`: Line magic function `%R` not found. (Rmagic)
+* :ghissue:`1712`: test failure in ubuntu package daily build
+* :ghissue:`1183`: 0.12 testsuite failures
+* :ghissue:`2016`: BUG: test runner fails in Windows if filenames contain spaces.
+* :ghissue:`1806`: Alternate upload methods in firefox
+* :ghissue:`2019`: Windows: home directory expansion test fails
+* :ghissue:`2020`: Fix home path expansion test in Windows.
+* :ghissue:`2017`: Windows core test error - filename quoting
+* :ghissue:`2021`: Fix Windows pathname issue in 'odd encoding' test.
+* :ghissue:`1998`: call to nt.assert_true(path._writable_dir(home)) returns false in test_path.py
+* :ghissue:`2022`: don't check writability in test for get_home_dir when HOME is undefined
+* :ghissue:`1589`: Test failures and docs don't build on Mac OS X Lion
+* :ghissue:`1996`: frontend test tweaks
+* :ghissue:`2011`: Notebook server can't start cluster with hyphen-containing profile name
+* :ghissue:`2014`: relax profile regex in notebook
+* :ghissue:`2013`: brew install pyqt
+* :ghissue:`2005`: Strange output artifacts in footer of notebook
+* :ghissue:`2012`: Mono cursor offset
+* :ghissue:`2004`: Clarify generic message spec vs. Python message API in docs
+* :ghissue:`2006`: Don't crash when starting notebook server if runnable browser not found
+* :ghissue:`2010`: notebook: Print a warning (but do not abort) if no webbrowser can be found.
+* :ghissue:`2008`: pip install virtualenv
+* :ghissue:`2003`: Wrong case of rmagic in docs
+* :ghissue:`2002`: Refactor %magic into a lsmagic_docs API function.
+* :ghissue:`2000`: kernel.js consistency with generic IPython message format.
+* :ghissue:`1999`: `%magic` help: display line and cell magics in alphabetical order.
+* :ghissue:`1635`: test_prun_quotes fails on Windows
+* :ghissue:`1984`: Cannot restart Notebook when using `%%script --bg`
+* :ghissue:`1981`: Clean BG processes created by %%script on kernel exit
+* :ghissue:`1994`: Fix RST misformatting.
+* :ghissue:`1949`: Introduce Notebook Magics
+* :ghissue:`1985`: Kernels should start in notebook dir when manually specified
+* :ghissue:`1980`: Notebook should check that --notebook-dir exists
+* :ghissue:`1951`: minor notebook startup/notebook-dir adjustments
+* :ghissue:`1969`: tab completion in notebook for paths not triggered
+* :ghissue:`1974`: Allow path completion on notebook.
+* :ghissue:`1964`: allow multiple instances of a Magic
+* :ghissue:`1960`: %page not working
+* :ghissue:`1991`: fix _ofind attr in %page
+* :ghissue:`1982`: Shutdown qtconsole problem?
+* :ghissue:`1988`: check for active frontend in update_restart_checkbox
+* :ghissue:`1979`: Add support for tox (https://tox.readthedocs.io/) and Travis CI (http://travis-ci.org/)
+* :ghissue:`1989`: Parallel: output of %px and %px${suffix} is inconsistent
+* :ghissue:`1966`: ValueError: packer could not serialize a simple message
+* :ghissue:`1987`: Notebook: MathJax offline install not recognized
+* :ghissue:`1970`: dblclick to restore size of images
+* :ghissue:`1983`: Notebook does not save heading level
+* :ghissue:`1978`: Notebook names truncating at the first period
+* :ghissue:`1553`: Limited size of output cells and provide scroll bars for such output cells
+* :ghissue:`1825`: second attempt at scrolled long output
+* :ghissue:`1915`: add cell-level metadata
+* :ghissue:`1934`: Cell/Worksheet metadata
+* :ghissue:`1746`: Confirm restart (configuration option, and checkbox UI)
+* :ghissue:`1790`: Commenting function.
+* :ghissue:`1767`: Tab completion problems with cell magics
+* :ghissue:`1944`: [qtconsole] take %,%% prefix into account for completion
+* :ghissue:`1973`: fix another FreeBSD $HOME symlink issue
+* :ghissue:`1972`: Fix completion of '%tim' in the Qt console
+* :ghissue:`1887`: Make it easy to resize jpeg/png images back to original size.
+* :ghissue:`1967`: Fix psums example description in docs
+* :ghissue:`1678`: ctrl-z clears cell output in notebook when pressed enough times
+* :ghissue:`1965`: fix for #1678, undo no longer clears cells
+* :ghissue:`1952`: avoid duplicate "Websockets closed" dialog on ws close
+* :ghissue:`1961`: UnicodeDecodeError on directory with unicode chars in prompt
+* :ghissue:`1963`: styling prompt, {color.Normal} excepts
+* :ghissue:`1962`: Support unicode prompts
+* :ghissue:`1959`: %page not working on qtconsole for Windows XP 32-bit
+* :ghissue:`1955`: update to latest version of vim-ipython
+* :ghissue:`1945`: Add --proc option to %%script
+* :ghissue:`1957`: fix indentation in kernel.js
+* :ghissue:`1956`: move import RemoteError after get_exc_info
+* :ghissue:`1950`: Fix for copy action (Ctrl+C) when there is no pager defined in qtconsole
+* :ghissue:`1948`: Fix help string for InteractiveShell.ast_node_interactivity
+* :ghissue:`1941`: script magics cause terminal spam
+* :ghissue:`1942`: swallow stderr of which in utils.process.find_cmd
+* :ghissue:`1833`: completer draws slightly too small on Chrome
+* :ghissue:`1940`: fix completer css on some Chrome versions
+* :ghissue:`1938`: remove remaining references to deprecated XREP/XREQ names
+* :ghissue:`1924`: HTML superscripts not shown raised in the notebook
+* :ghissue:`1925`: Fix styling of superscripts and subscripts. Closes #1924.
+* :ghissue:`1461`: User notification if notebook saving fails
+* :ghissue:`1936`: increase duration of save messages
+* :ghissue:`1542`: %save magic fails in clients without stdin if file already exists
+* :ghissue:`1937`: add %save -f
+* :ghissue:`1572`: pyreadline version dependency not correctly checked
+* :ghissue:`1935`: add version checking to pyreadline import test
+* :ghissue:`1849`: Octave magics
+* :ghissue:`1759`: github, merge PR(s) just by number(s) 
+* :ghissue:`1931`: Win py3fixes
+* :ghissue:`1646`: Meaning of restart parameter in client.shutdown() unclear
+* :ghissue:`1933`: oinspect.find_file: Additional safety if file cannot be found.
+* :ghissue:`1916`: %paste doesn't work on py3
+* :ghissue:`1932`: Fix adding functions to CommandChainDispatcher with equal priority on Py 3
+* :ghissue:`1928`: Select NoDB by default
+* :ghissue:`1923`: Add IPython syntax support to the %timeit magic, in line and cell mode
+* :ghissue:`1926`: Make completer recognize escaped quotes in strings.
+* :ghissue:`1929`: Ipython-qtconsole (0.12.1) hangs with Python 2.7.3, Windows 7 64 bit
+* :ghissue:`1409`: [qtconsole] forward delete bring completion into current line
+* :ghissue:`1922`: py3k compatibility for setupegg.py
+* :ghissue:`1598`: document that sync_imports() can't handle "import foo as bar"
+* :ghissue:`1893`: Update Parallel Magics and Exception Display
+* :ghissue:`1890`: Docstrings for magics that use @magic_arguments are rendered wrong
+* :ghissue:`1921`: magic_arguments: dedent but otherwise preserve indentation.
+* :ghissue:`1919`: Use oinspect in CodeMagics._find_edit_target
+* :ghissue:`1918`: don't warn in iptest if deathrow/quarantine are missing
+* :ghissue:`1914`: %pdef failing on python3
+* :ghissue:`1917`: Fix for %pdef on Python 3
+* :ghissue:`1428`: Failing test that prun does not clobber string escapes
+* :ghissue:`1913`: Fix for #1428
+* :ghissue:`1911`: temporarily skip autoreload tests
+* :ghissue:`1549`: autoreload extension crashes ipython
+* :ghissue:`1908`: find_file errors on windows
+* :ghissue:`1909`: Fix for #1908, use os.path.normcase for safe filename comparisons
+* :ghissue:`1907`: py3compat fixes for %%script and tests
+* :ghissue:`1904`: %%px? doesn't work, shows info for %px, general cell magic problem
+* :ghissue:`1906`: ofind finds non-unique cell magics
+* :ghissue:`1894`: Win64 binary install fails
+* :ghissue:`1799`: Source file not found for magics
+* :ghissue:`1845`: Fixes to inspection machinery for magics
+* :ghissue:`1774`: Some magics seems broken
+* :ghissue:`1586`: Clean up tight coupling between Notebook, CodeCell and Kernel Javascript objects
+* :ghissue:`1632`: Win32 shell interactivity apparently broke qtconsole "cd" magic
+* :ghissue:`1902`: Workaround fix for gh-1632; minimal revert of gh-1424
+* :ghissue:`1900`: Cython libs
+* :ghissue:`1503`: Cursor is offset in notebook in Chrome 17 on Linux
+* :ghissue:`1426`: Qt console doesn't handle the `--gui` flag correctly.
+* :ghissue:`1180`: Can't start IPython kernel in Spyder
+* :ghissue:`581`: test IPython.zmq
+* :ghissue:`1593`: Name embedded in notebook overrides filename
+* :ghissue:`1899`: add ScriptMagics to class list for generated config
+* :ghissue:`1618`: generate or minimize manpages
+* :ghissue:`1898`: minimize manpages
+* :ghissue:`1896`: Windows: apparently spurious warning 'Excluding nonexistent file' ... test_exampleip
+* :ghissue:`1897`: use glob for bad exclusion warning
+* :ghissue:`1215`: updated %quickref to show short-hand for %sc and %sx
+* :ghissue:`1855`: %%script and %%file magics
+* :ghissue:`1863`: Ability to silence a cell in the notebook
+* :ghissue:`1870`: add %%capture for capturing stdout/err
+* :ghissue:`1861`: Use dvipng to format sympy.Matrix
+* :ghissue:`1867`: Fix 1px margin bouncing of selected menu item.
+* :ghissue:`1889`: Reconnect when the websocket connection closes unexpectedly
+* :ghissue:`1577`: If a notebook loses its network connection WebSockets won't reconnect
+* :ghissue:`1886`: Fix a bug in renaming notebook
+* :ghissue:`1895`: Fix error in test suite with ip.system()
+* :ghissue:`1762`: add `locate` entry points
+* :ghissue:`1883`: Fix vertical offset due to bold/italics, and bad browser fonts.
+* :ghissue:`1875`: re-write columnize, with intermediate step.
+* :ghissue:`1860`: IPython.utils.columnize sometime wrong...
+* :ghissue:`1851`: new completer for qtconsole.
+* :ghissue:`1892`: Remove suspicious quotes in interactiveshell.py
+* :ghissue:`1854`: Class `%hierarchy` and graphiz `%%dot` magics
+* :ghissue:`1827`: Sending tracebacks over ZMQ should protect against unicode failure
+* :ghissue:`1864`: Rmagic exceptions
+* :ghissue:`1829`: [notebook] don't care about leading prct in completion
+* :ghissue:`1832`: Make svg, jpeg and png images resizable in notebook.
+* :ghissue:`1674`: HTML Notebook carriage-return handling, take 2
+* :ghissue:`1874`: cython_magic uses importlib, which doesn't ship with py2.6
+* :ghissue:`1882`: Remove importlib dependency which not available in Python 2.6.
+* :ghissue:`1878`: shell access using ! will not fill class or function scope vars
+* :ghissue:`1879`: Correct stack depth for variable expansion in !system commands
+* :ghissue:`1840`: New JS completer should merge completions before display
+* :ghissue:`1841`: [notebook] deduplicate completion results
+* :ghissue:`1736`: no good error message on missing tkinter and %paste
+* :ghissue:`1741`: Display message from TryNext error in magic_paste
+* :ghissue:`1850`: Remove args/kwargs handling in TryNext, fix %paste error messages.
+* :ghissue:`1663`: Keep line-endings in ipynb
+* :ghissue:`1872`: Matplotlib window freezes using intreractive plot in qtconsole
+* :ghissue:`1869`: Improve CodeMagics._find_edit_target
+* :ghissue:`1781`: Colons in notebook name causes notebook deletion without warning
+* :ghissue:`1815`: Make : invalid in filenames in the Notebook JS code.
+* :ghissue:`1819`: doc: cleanup the parallel psums example a little
+* :ghissue:`1838`: externals cleanup
+* :ghissue:`1839`: External cleanup
+* :ghissue:`1782`: fix Magic menu in qtconsole, split in groups
+* :ghissue:`1862`: Minor bind_kernel improvements
+* :ghissue:`1859`: kernmagic during console startup
+* :ghissue:`1857`: Prevent jumping of window to input when output is clicked.
+* :ghissue:`1856`: Fix 1px jumping of cells and menus in Notebook.
+* :ghissue:`1848`: task fails with "AssertionError: not enough buffers!" after second resubmit
+* :ghissue:`1852`: fix chained resubmissions
+* :ghissue:`1780`: Rmagic extension
+* :ghissue:`1853`: Fix jumpy notebook behavior
+* :ghissue:`1842`: task with UnmetDependency error still owned by engine
+* :ghissue:`1847`: add InlineBackend to ConsoleApp class list
+* :ghissue:`1846`: Exceptions within multiprocessing crash Ipython notebook kernel
+* :ghissue:`1843`: Notebook does not exist and permalinks
+* :ghissue:`1837`: edit magic broken in head
+* :ghissue:`1834`: resubmitted tasks doesn't have same session name
+* :ghissue:`1836`: preserve header for resubmitted tasks
+* :ghissue:`1776`: fix magic menu in qtconsole
+* :ghissue:`1828`: change default extension to .ipy for %save -r
+* :ghissue:`1800`: Reintroduce recall
+* :ghissue:`1671`: __future__ environments
+* :ghissue:`1830`: lsmagic lists magics in alphabetical order
+* :ghissue:`1835`: Use Python import in ipython profile config
+* :ghissue:`1773`: Update SymPy profile: SymPy's latex() can now print set and frozenset
+* :ghissue:`1761`: Edited documentation to use IPYTHONDIR in place of ~/.ipython
+* :ghissue:`1772`: notebook autocomplete fail when typing number
+* :ghissue:`1822`: aesthetics pass on AsyncResult.display_outputs
+* :ghissue:`1460`: Redirect http to https for notebook
+* :ghissue:`1287`: Refactor the notebook tab completion/tooltip
+* :ghissue:`1596`: In rename dialog, <return> should submit
+* :ghissue:`1821`: ENTER submits the rename notebook dialog.
+* :ghissue:`1750`: Let the user disable random port selection
+* :ghissue:`1820`: NotebookApp: Make the number of ports to retry user configurable.
+* :ghissue:`1816`: Always use filename as the notebook name.
+* :ghissue:`1775`: assert_in not present on Python 2.6
+* :ghissue:`1813`: Add assert_in method to nose for Python 2.6
+* :ghissue:`1498`: Add tooltip keyboard shortcuts
+* :ghissue:`1711`: New Tooltip, New Completer and JS Refactor
+* :ghissue:`1798`: a few simple fixes for docs/parallel
+* :ghissue:`1818`: possible bug with latex / markdown
+* :ghissue:`1647`: Aborted parallel tasks can't be resubmitted
+* :ghissue:`1817`: Change behavior of ipython notebook --port=...
+* :ghissue:`1738`: IPython.embed_kernel issues
+* :ghissue:`1610`: Basic bold and italic in HTML output cells
+* :ghissue:`1576`: Start and stop kernels from the notebook dashboard
+* :ghissue:`1515`: impossible to shutdown notebook kernels
+* :ghissue:`1812`: Ensure AsyncResult.display_outputs doesn't display empty streams
+* :ghissue:`1811`: warn on nonexistent exclusions in iptest
+* :ghissue:`1809`: test suite error in IPython.zmq on windows
+* :ghissue:`1810`: fix for #1809, failing tests in IPython.zmq
+* :ghissue:`1808`: Reposition alternate upload for firefox [need cross browser/OS/language test]
+* :ghissue:`1742`: Check for custom_exceptions only once
+* :ghissue:`1802`: cythonmagic tests should be skipped if Cython not available
+* :ghissue:`1062`: warning message in IPython.extensions test
+* :ghissue:`1807`: add missing cython exclusion in iptest
+* :ghissue:`1805`: Fixed a vcvarsall.bat error on win32/Py2.7 when trying to compile with m...
+* :ghissue:`1803`: MPI parallel %px bug 
+* :ghissue:`1804`: Fixed a vcvarsall.bat error on win32/Py2.7 when trying to compile with mingw.
+* :ghissue:`1492`: Drag target very small if IPython Dashboard has no notebooks
+* :ghissue:`1562`: Offer a method other than drag-n-drop to upload notebooks
+* :ghissue:`1739`: Dashboard improvement (necessary merge of #1658 and #1676 + fix #1492)
+* :ghissue:`1770`: Cython related magic functions
+* :ghissue:`1532`: qtconsole does not accept --gui switch
+* :ghissue:`1707`: Accept --gui=<...> switch in IPython qtconsole.
+* :ghissue:`1797`: Fix comment which breaks Emacs syntax highlighting.
+* :ghissue:`1796`: %gui magic broken
+* :ghissue:`1795`: fix %gui magic
+* :ghissue:`1788`: extreme truncating of return values
+* :ghissue:`1793`: Raise repr limit for strings to 80 characters (from 30).
+* :ghissue:`1794`: don't use XDG path on OS X
+* :ghissue:`1777`: ipython crash on wrong encoding
+* :ghissue:`1792`: Unicode-aware logger
+* :ghissue:`1791`: update zmqshell magics
+* :ghissue:`1787`: DOC: Remove regression from qt-console docs.
+* :ghissue:`1785`: IPython.utils.tests.test_process.SubProcessTestCase
+* :ghissue:`1758`: test_pr, fallback on http if git protocol fail, and SSL errors...
+* :ghissue:`1786`: Make notebook save failures more salient
+* :ghissue:`1748`: Fix some tests for Python 3.3
+* :ghissue:`1755`: test for pygments before running qt tests
+* :ghissue:`1771`: Make default value of interactivity passed to run_ast_nodes configurable
+* :ghissue:`1783`: part of PR #1606 (loadpy -> load) erased by magic refactoring.
+* :ghissue:`1784`: restore loadpy to load
+* :ghissue:`1768`: Update parallel magics
+* :ghissue:`1778`: string exception in IPython/core/magic.py:232
+* :ghissue:`1779`: Tidy up error raising in magic decorators.
+* :ghissue:`1769`: Allow cell mode timeit without setup code.
+* :ghissue:`1716`: Fix for fake filenames in verbose traceback
+* :ghissue:`1763`: [qtconsole] fix append_plain_html -> append_html
+* :ghissue:`1766`: Test failure in IPython.parallel
+* :ghissue:`1611`: IPEP1: Cell magics and general cleanup of the Magic system
+* :ghissue:`1732`: Refactoring of the magics system and implementation of cell magics
+* :ghissue:`1765`: test_pr should clearn PYTHONPATH for the subprocesses
+* :ghissue:`1630`: Merge divergent Kernel implementations
+* :ghissue:`1705`: [notebook] Make pager resizable, and remember size...
+* :ghissue:`1606`: Share code for %pycat and %loadpy, make %pycat aware of URLs
+* :ghissue:`1720`: Adding interactive inline plotting to notebooks with flot
+* :ghissue:`1701`: [notebook] Open HTML links in a new window by default
+* :ghissue:`1757`: Open IPython notebook hyperlinks in a new window using target=_blank
+* :ghissue:`1735`: Open IPython notebook hyperlinks in a new window using target=_blank
+* :ghissue:`1754`: Fix typo enconters->encounters
+* :ghissue:`1753`: Clear window title when kernel is restarted
+* :ghissue:`735`: Images missing from XML/SVG export (for me)
+* :ghissue:`1449`: Fix for bug #735 : Images missing from XML/SVG export
+* :ghissue:`1752`: Reconnect Websocket when it closes unexpectedly
+* :ghissue:`1751`: Reconnect Websocket when it closes unexpectedly
+* :ghissue:`1749`: Load MathJax.js using HTTPS when IPython notebook server is HTTPS
+* :ghissue:`1743`: Tooltip completer js refactor
+* :ghissue:`1700`: A module for sending custom user messages from the kernel.
+* :ghissue:`1745`: htmlnotebook: Cursor is off
+* :ghissue:`1728`: ipython crash with matplotlib during picking
+* :ghissue:`1681`: add qt config option to clear_on_kernel_restart
+* :ghissue:`1733`: Tooltip completer js refactor
+* :ghissue:`1676`: Kernel status/shutdown from dashboard
+* :ghissue:`1658`: Alternate notebook upload methods
+* :ghissue:`1727`: terminate kernel after embed_kernel tests
+* :ghissue:`1737`: add HistoryManager to ipapp class list
+* :ghissue:`945`: Open a notebook from the command line
+* :ghissue:`1686`: ENH: Open a notebook from the command line
+* :ghissue:`1709`: fixes #1708, failing test in arg_split on windows
+* :ghissue:`1718`: Use CRegExp trait for regular expressions.
+* :ghissue:`1729`: Catch failure in repr() for %whos
+* :ghissue:`1726`: use eval for command-line args instead of exec
+* :ghissue:`1723`: scatter/gather fail with targets='all'
+* :ghissue:`1724`: fix scatter/gather with targets='all'
+* :ghissue:`1725`: add --no-ff to git pull in test_pr
+* :ghissue:`1722`: unicode exception when evaluating expression with non-ascii characters
+* :ghissue:`1721`: Tooltip completer js refactor
+* :ghissue:`1657`: Add `wait` optional argument to `hooks.editor`
+* :ghissue:`123`: Define sys.ps{1,2}
+* :ghissue:`1717`: Define generic sys.ps{1,2,3}, for use by scripts.
+* :ghissue:`1442`: cache-size issue in qtconsole
+* :ghissue:`1691`: Finish PR #1446
+* :ghissue:`1446`: Fixing Issue #1442
+* :ghissue:`1710`: update MathJax CDN url for https
+* :ghissue:`81`: Autocall fails if first function argument begins with "-" or "+
+* :ghissue:`1713`: Make autocall regexp's configurable.
+* :ghissue:`211`: paste command not working
+* :ghissue:`1703`: Allow TryNext to have an error message without it affecting the command chain
+* :ghissue:`1714`: minor adjustments to test_pr
+* :ghissue:`1509`: New tooltip for notebook
+* :ghissue:`1697`: Major refactoring of the Notebook, Kernel and CodeCell JavaScript.
+* :ghissue:`788`: Progress indicator in the notebook (and perhaps the Qt console)
+* :ghissue:`1034`: Single process Qt console
+* :ghissue:`1557`: magic function conflict while using --pylab
+* :ghissue:`1476`: Pylab figure objects not properly updating
+* :ghissue:`1704`: ensure all needed qt parts can be imported before settling for one
+* :ghissue:`1708`: test failure in arg_split on windows
+* :ghissue:`1706`: Mark test_push_numpy_nocopy as a known failure for Python 3
+* :ghissue:`1696`: notebook tooltip fail on function with number
+* :ghissue:`1698`: fix tooltip on token with number
+* :ghissue:`1226`: Windows GUI only (pythonw) bug for IPython on Python 3.x
+* :ghissue:`1245`: pythonw py3k fixes for issue #1226
+* :ghissue:`1417`: Notebook Completer Class
+* :ghissue:`1690`: [Bogus] Deliberately make a test fail
+* :ghissue:`1685`: Add script to test pull request
+* :ghissue:`1167`: Settle on a choice for $IPYTHONDIR
+* :ghissue:`1693`: deprecate IPYTHON_DIR in favor of IPYTHONDIR
+* :ghissue:`1672`: ipython-qtconsole.desktop is using a deprecated format
+* :ghissue:`1695`: Avoid deprecated warnings from ipython-qtconsole.desktop.
+* :ghissue:`1694`: Add quote to notebook to allow it to load
+* :ghissue:`1240`: sys.path missing `''` as first entry when kernel launched without interface
+* :ghissue:`1689`: Fix sys.path missing '' as first entry in `ipython kernel`.
+* :ghissue:`1683`: Parallel controller failing with Pymongo 2.2
+* :ghissue:`1687`: import Binary from bson instead of pymongo
+* :ghissue:`1614`: Display Image in Qtconsole
+* :ghissue:`1616`: Make IPython.core.display.Image less notebook-centric
+* :ghissue:`1684`: CLN: Remove redundant function definition.
+* :ghissue:`1655`: Add %open magic command to open editor in non-blocking manner
+* :ghissue:`1677`: middle-click paste broken in notebook
+* :ghissue:`1670`: Point %pastebin to gist
+* :ghissue:`1667`: Test failure in test_message_spec
+* :ghissue:`1668`: Test failure in IPython.zmq.tests.test_message_spec.test_complete "'pyout' != 'status'"
+* :ghissue:`1669`: handle pyout messages in test_message_spec
+* :ghissue:`1295`: add binary-tree engine interconnect example
+* :ghissue:`1642`: Cherry-picked commits from 0.12.1 release
+* :ghissue:`1659`: Handle carriage return characters ("\r") in HTML notebook output.
+* :ghissue:`1313`: Figure out MathJax 2 support
+* :ghissue:`1653`: Test failure in IPython.zmq
+* :ghissue:`1656`: ensure kernels are cleaned up in embed_kernel tests
+* :ghissue:`1666`: pip install ipython==dev installs version 0.8 from an old svn repo
+* :ghissue:`1664`: InteractiveShell.run_code: Update docstring.
+* :ghissue:`1512`: `print stuff,` should avoid newline
+* :ghissue:`1662`: Delay flushing softspace until after cell finishes
+* :ghissue:`1643`: handle jpg/jpeg in the qtconsole
+* :ghissue:`966`: dreload fails on Windows XP with IPython 0.11 "Unexpected Error"
+* :ghissue:`1500`: dreload doesn't seem to exclude numpy
+* :ghissue:`1520`: kernel crash when showing tooltip (?)
+* :ghissue:`1652`: add patch_pyzmq() for backporting a few changes from newer pyzmq
+* :ghissue:`1650`: DOC: moving files with SSH launchers
+* :ghissue:`1357`: add IPython.embed_kernel() 
+* :ghissue:`1640`: Finish up embed_kernel
+* :ghissue:`1651`: Remove bundled Itpl module
+* :ghissue:`1634`: incremental improvements to SSH launchers
+* :ghissue:`1649`: move examples/test_embed into examples/tests/embed
+* :ghissue:`1171`: Recognise virtualenvs
+* :ghissue:`1479`: test_extension failing in Windows
+* :ghissue:`1633`: Fix installing extension from local file on Windows
+* :ghissue:`1644`: Update copyright date to 2012
+* :ghissue:`1636`: Test_deepreload breaks pylab irunner tests
+* :ghissue:`1645`: Exclude UserDict when deep reloading NumPy.
+* :ghissue:`1454`: make it possible to start engine in 'disabled' mode and 'enable' later
+* :ghissue:`1641`: Escape code for the current time in PromptManager
+* :ghissue:`1638`: ipython console clobbers custom sys.path
+* :ghissue:`1637`: Removed a ':' which shouldn't have been there
+* :ghissue:`1536`: ipython 0.12 embed shell won't run startup scripts
+* :ghissue:`1628`: error: QApplication already exists in TestKillRing
+* :ghissue:`1631`: TST: QApplication doesn't quit early enough with PySide.
+* :ghissue:`1629`: evaluate a few dangling validate_message generators
+* :ghissue:`1621`: clear In[] prompt numbers on "Clear All Output"
+* :ghissue:`1627`: Test the Message Spec
+* :ghissue:`1470`: SyntaxError on setup.py install with Python 3
+* :ghissue:`1624`: Fixes for byte-compilation on Python 3
+* :ghissue:`1612`: pylab=inline fig.show() non-existent in notebook
+* :ghissue:`1615`: Add show() method to figure objects.
+* :ghissue:`1622`: deepreload fails on Python 3
+* :ghissue:`1625`: Fix deepreload on Python 3
+* :ghissue:`1626`: Failure in new `dreload` tests under Python 3.2
+* :ghissue:`1623`: IPython / matplotlib Memory error with imshow
+* :ghissue:`1619`: pyin messages should have execution_count
+* :ghissue:`1620`: pyin message now have execution_count
+* :ghissue:`32`: dreload produces spurious traceback when numpy is involved
+* :ghissue:`1457`: Update deepreload to use a rewritten knee.py. Fixes dreload(numpy).
+* :ghissue:`1613`: allow map / parallel function for single-engine views
+* :ghissue:`1609`: exit notebook cleanly on SIGINT, SIGTERM
+* :ghissue:`1531`: Function keyword completion fails if cursor is in the middle of the complete parentheses
+* :ghissue:`1607`: cleanup sqlitedb temporary db file after tests
+* :ghissue:`1608`: don't rely on timedelta.total_seconds in AsyncResult
+* :ghissue:`1421`: ipython32 %run -d breaks with NameError name 'execfile' is not defined
+* :ghissue:`1599`: Fix for %run -d on Python 3
+* :ghissue:`1201`: %env magic fails with Python 3.2
+* :ghissue:`1602`: Fix %env magic on Python 3.
+* :ghissue:`1603`: Remove python3 profile
+* :ghissue:`1604`: Exclude IPython.quarantine from installation
+* :ghissue:`1601`: Security file is not removed after shutdown by Ctrl+C or kill -INT
+* :ghissue:`1600`: Specify encoding for io.open in notebook_reformat tests
+* :ghissue:`1605`: Small fixes for Animation and Progress notebook
+* :ghissue:`1452`: Bug fix for approval
+* :ghissue:`13`: Improve robustness and debuggability of test suite
+* :ghissue:`70`: IPython should prioritize __all__ during tab completion
+* :ghissue:`1529`: __all__ feature, improvement to dir2, and tests for both
+* :ghissue:`1475`: Custom namespace for %run
+* :ghissue:`1564`: calling .abort on AsyncMapResult  results in traceback
+* :ghissue:`1548`: add sugar methods/properties to AsyncResult
+* :ghissue:`1535`: Fix pretty printing dispatch
+* :ghissue:`1522`: Discussion: some potential Qt console refactoring
+* :ghissue:`1399`: Use LaTeX to print various built-in types with the SymPy printing extension
+* :ghissue:`1597`: re-enter kernel.eventloop after catching SIGINT
+* :ghissue:`1490`: rename plaintext cell -> raw cell
+* :ghissue:`1487`: %notebook fails in qtconsole
+* :ghissue:`1545`: trailing newline not preserved in splitline ipynb
+* :ghissue:`1480`: Fix %notebook magic, etc. nbformat unicode tests and fixes
+* :ghissue:`1588`: Gtk3 integration with ipython works.
+* :ghissue:`1595`: Examples syntax (avoid errors installing on Python 3)
+* :ghissue:`1526`: Find encoding for Python files
+* :ghissue:`1594`: Fix writing git commit ID to a file on build with Python 3
+* :ghissue:`1556`: shallow-copy DictDB query results
+* :ghissue:`1499`: various pyflakes issues
+* :ghissue:`1502`: small changes in response to pyflakes pass
+* :ghissue:`1445`: Don't build sphinx docs for sdists
+* :ghissue:`1484`: unhide .git_commit_info.ini
+* :ghissue:`1538`: store git commit hash in utils._sysinfo instead of hidden data file
+* :ghissue:`1546`: attempt to suppress exceptions in channel threads at shutdown
+* :ghissue:`1524`: unhide git_commit_info.ini
+* :ghissue:`1559`: update tools/github_stats.py to use GitHub API v3
+* :ghissue:`1563`: clear_output improvements
+* :ghissue:`1558`: Ipython testing documentation still mentions twisted and trial
+* :ghissue:`1560`: remove obsolete discussion of Twisted/trial from testing docs
+* :ghissue:`1561`: Qtconsole - nonstandard \a and \b
+* :ghissue:`1569`: BUG: qtconsole -- non-standard handling of \a and \b. [Fixes #1561]
+* :ghissue:`1574`: BUG: Ctrl+C crashes wx pylab kernel in qtconsole
+* :ghissue:`1573`: BUG: Ctrl+C crashes wx pylab kernel in qtconsole.
+* :ghissue:`1590`: 'IPython3 qtconsole' doesn't work in Windows 7
+* :ghissue:`602`: User test the html notebook
+* :ghissue:`613`: Implement Namespace panel section
+* :ghissue:`879`: How to handle Javascript output in the notebook
+* :ghissue:`1255`: figure.show() raises an error with the inline backend
+* :ghissue:`1467`: Document or bundle a git-integrated facility for stripping VCS-unfriendly binary data
+* :ghissue:`1237`: Kernel status and logout button overlap
+* :ghissue:`1319`: Running a cell with ctrl+Enter selects text in cell
+* :ghissue:`1571`: module member autocomplete should respect __all__
+* :ghissue:`1566`: ipython3 doesn't run in Win7 with Python 3.2 
+* :ghissue:`1568`: fix PR #1567
+* :ghissue:`1567`: Fix: openssh_tunnel did not parse port in `server`
+* :ghissue:`1565`: fix AsyncResult.abort
+* :ghissue:`1550`: Crash when starting notebook in a non-ascii path
+* :ghissue:`1552`: use os.getcwdu in NotebookManager
+* :ghissue:`1554`: wrong behavior of the all function on iterators
+* :ghissue:`1541`: display_pub flushes stdout/err
+* :ghissue:`1539`: Asynchrous issue when using clear_display and print x,y,z
+* :ghissue:`1544`: make MultiKernelManager.kernel_manager_class configurable
+* :ghissue:`1494`: Untrusted Secure Websocket broken on latest chrome dev
+* :ghissue:`1521`: only install ipython-qtconsole gui script on Windows
+* :ghissue:`1528`: Tab completion optionally respects __all__ (+ dir2() cleanup)
+* :ghissue:`1527`: Making a progress bar work in IPython Notebook
+* :ghissue:`1497`: __all__ functionality added to dir2(obj)
+* :ghissue:`1518`: Pretty printing exceptions is broken
+* :ghissue:`811`: Fixes for ipython unhandeled OSError exception on failure of os.getcwdu()
+* :ghissue:`1517`: Fix indentation bug in IPython/lib/pretty.py
+* :ghissue:`1519`: BUG: Include the name of the exception type in its pretty format.
+* :ghissue:`1525`: A hack for auto-complete numpy recarray
+* :ghissue:`1489`: Fix zero-copy push
+* :ghissue:`1401`: numpy arrays cannot be used with View.apply() in Python 3
+* :ghissue:`1477`: fix dangling `buffer` in IPython.parallel.util
+* :ghissue:`1514`: DOC: Fix references to IPython.lib.pretty instead of the old location
+* :ghissue:`1511`: Version comparison error ( '2.1.11' < '2.1.4' ==> True)
+* :ghissue:`1506`: "Fixing" the Notebook scroll to help in visually comparing outputs
+* :ghissue:`1481`: BUG: Improve placement of CallTipWidget
+* :ghissue:`1241`: When our debugger class is used standalone `_oh` key errors are thrown
+* :ghissue:`676`: IPython.embed() from ipython crashes twice on exit
+* :ghissue:`1496`: BUG: LBYL when clearing the output history on shutdown.
+* :ghissue:`1507`: python3 notebook: TypeError: unorderable types
+* :ghissue:`1508`: fix sorting profiles in clustermanager
+* :ghissue:`1495`: BUG: Fix pretty-printing for overzealous objects
+* :ghissue:`1505`: SQLite objects created in a thread can only be used in that same thread
+* :ghissue:`1482`: %history documentation out of date?
+* :ghissue:`1501`: dreload doesn't seem to exclude numpy
+* :ghissue:`1472`: more general fix for #662
+* :ghissue:`1486`: save state of qtconsole
+* :ghissue:`1485`: add history search to qtconsole
+* :ghissue:`1483`: updated magic_history docstring
+* :ghissue:`1383`: First version of cluster web service.
+* :ghissue:`482`: test_run.test_tclass fails on Windows
+* :ghissue:`1398`: fix %tb after SyntaxError
+* :ghissue:`1478`: key function or lambda in sorted function doesn't find global variables
+* :ghissue:`1415`: handle exit/quit/exit()/quit() variants in zmqconsole
+* :ghissue:`1440`: Fix for failing testsuite when using --with-xml-coverage on windows.
+* :ghissue:`1419`: Add %install_ext magic function.
+* :ghissue:`1424`: Win32 shell interactivity
+* :ghissue:`1434`: Controller should schedule tasks of multiple clients at the same time
+* :ghissue:`1268`: notebook %reset magic fails with StdinNotImplementedError
+* :ghissue:`1438`: from cherrypy import expose fails when running script form parent directory
+* :ghissue:`1468`: Simplify structure of a Job in the TaskScheduler
+* :ghissue:`875`: never build unicode error messages
+* :ghissue:`1107`: Tab autocompletion can suggest invalid syntax
+* :ghissue:`1447`: 1107 - Tab autocompletion can suggest invalid syntax
+* :ghissue:`1469`: Fix typo in comment (insert space)
+* :ghissue:`1463`: Fix completion when importing modules in the cwd.
+* :ghissue:`1437`: unfriendly error handling with pythonw and ipython-qtconsole
+* :ghissue:`1466`: Fix for issue #1437, unfriendly windows qtconsole error handling
+* :ghissue:`1432`: Fix ipython directive
+* :ghissue:`1465`: allow `ipython help subcommand` syntax
+* :ghissue:`1394`: Wishlist: Remove hard dependency on ctypes
+* :ghissue:`1416`: Conditional import of ctypes in inputhook
+* :ghissue:`1462`: expedite parallel tests
+* :ghissue:`1418`: Strict mode in javascript
+* :ghissue:`1410`: Add javascript library and css stylesheet loading to JS class.
+* :ghissue:`1427`: #922 again
+* :ghissue:`1448`: Fix for #875 Never build unicode error messages
+* :ghissue:`1458`: use eval to uncan References
+* :ghissue:`1455`: Python3 install fails
+* :ghissue:`1450`: load mathjax from CDN via https
+* :ghissue:`1182`: Qtconsole, multiwindow
+* :ghissue:`1439`: Notebook not storing heading celltype information
+* :ghissue:`1451`: include heading level in JSON
+* :ghissue:`1444`: Fix pyhton -> python typos
+* :ghissue:`1412`: Input parsing issue with %prun
+* :ghissue:`1414`: ignore errors in shell.var_expand
+* :ghissue:`1441`: (1) Enable IPython.notebook.kernel.execute to publish display_* even it is not called with a code cell and (2) remove empty html element when execute "display_*"
+* :ghissue:`1431`: Beginner Error: ipython qtconsole
+* :ghissue:`1436`: "ipython-qtconsole --gui qt" hangs on 64-bit win7
+* :ghissue:`1433`: websocket connection fails on Chrome
+* :ghissue:`1430`: Fix for tornado check for tornado < 1.1.0
+* :ghissue:`1408`: test_get_home_dir_3 failed on Mac OS X
+* :ghissue:`1413`: get_home_dir expands symlinks, adjust test accordingly
+* :ghissue:`1420`: fixes #922
+* :ghissue:`823`: KnownFailure tests appearing as errors
+* :ghissue:`1385`: updated and prettified magic doc strings
+* :ghissue:`1406`: Browser selection
+* :ghissue:`1411`: ipcluster starts 8 engines "successfully" but Client only finds two
+* :ghissue:`1375`: %history -g -f file encoding issue
+* :ghissue:`1377`: Saving non-ascii history
+* :ghissue:`797`: Source introspection needs to be smarter in python 3.2
+* :ghissue:`846`: Autoreload extension doesn't work with Python 3.2
+* :ghissue:`1360`: IPython notebook not starting on winXP
+* :ghissue:`1407`: Qtconsole segfaults on OSX when displaying some pop-up function tooltips
+* :ghissue:`1402`: fix symlinked /home issue for FreeBSD
+* :ghissue:`1403`: pyreadline cyclic dependency with pdb++/pdbpp module
+* :ghissue:`1405`: Only monkeypatch xunit when the tests are run using it.
+* :ghissue:`1404`: Feature Request: List/Dictionary tab completion
+* :ghissue:`1395`: Xunit & KnownFailure
+* :ghissue:`1396`: Fix for %tb magic.
+* :ghissue:`1397`: Stay or leave message not working, Safari session lost.
+* :ghissue:`1389`: pylab=inline inoperant through ssh tunnelling?
+* :ghissue:`1386`: Jsd3
+* :ghissue:`1388`: Add simple support for running inside a virtualenv
+* :ghissue:`826`: Add support for creation of parallel task when no engine is running
+* :ghissue:`1391`: Improve Hub/Scheduler when no engines are registered
+* :ghissue:`1369`: load header with engine id when engine dies in TaskScheduler
+* :ghissue:`1345`: notebook can't save unicode as script
+* :ghissue:`1353`: Save notebook as script using unicode file handle.
+* :ghissue:`1352`: Add '-m mod : run library module as a script' option.
+* :ghissue:`1363`: Fix some minor color/style config issues in the qtconsole
+* :ghissue:`1371`: Adds a quiet keyword to sync_imports
+* :ghissue:`1390`: Blank screen for notebooks on Safari
+* :ghissue:`1387`: Fixing Cell menu to update cell type select box.
+* :ghissue:`645`: Standalone WX GUI support is broken
+* :ghissue:`1296`: Wx gui example: fixes the broken example for `%gui wx`.
+* :ghissue:`1254`: typo in notebooklist.js breaks links
+* :ghissue:`781`: Users should be able to clone a notebook
+* :ghissue:`1372`: ipcontroller cleans up connection files unless reuse=True
+* :ghissue:`1374`: remove calls to meaningless ZMQStream.on_err
+* :ghissue:`1382`: Update RO for Notebook
+* :ghissue:`1370`: allow draft76 websockets (Safari)
+* :ghissue:`1368`: Ensure handler patterns are str, not unicode
+* :ghissue:`1379`: Sage link on website homepage broken
+* :ghissue:`1376`: FWIW does not work with Chrome 16.0.912.77 Ubuntu 10.10
+* :ghissue:`1358`: Cannot install ipython on Windows 7 64-bit
+* :ghissue:`1367`: Ctrl - m  t does not toggle output in chrome
+* :ghissue:`1359`: [sympyprinting] MathJax can't render \root{m}{n}
+* :ghissue:`1337`: Tab in the notebook after `(` should not indent, only give a tooltip
+* :ghissue:`1339`: Notebook printing broken
+* :ghissue:`1344`: Ctrl + M + L does not toggle line numbering in htmlnotebook
+* :ghissue:`1348`: Ctrl + M + M does not switch to markdown cell
+* :ghissue:`1361`: Notebook bug fix branch
+* :ghissue:`1364`: avoid jsonlib returning Decimal
+* :ghissue:`1362`: Don't log complete contents of history replies, even in debug
+* :ghissue:`888`: ReST support in notebooks
+* :ghissue:`1205`: notebook stores HTML escaped text in the file
+* :ghissue:`1351`: add IPython.embed_kernel() 
+* :ghissue:`1243`: magic commands without % are not completed properly in htmlnotebook
+* :ghissue:`1347`: fix weird magic completion in notebook
+* :ghissue:`1355`: notebook.html extends layout.html now
+* :ghissue:`1354`: min and max in the notebook
+* :ghissue:`1346`: fixups for alternate URL prefix stuff
+* :ghissue:`1336`: crack at making notebook.html use the layout.html template
+* :ghissue:`1331`: RST and heading cells
+* :ghissue:`1350`: Add '-m mod : run library module as a script' option
+* :ghissue:`1247`: fixes a bug causing extra newlines after comments.
+* :ghissue:`1329`: add base_url to notebook configuration options
+* :ghissue:`1332`: notebook - allow prefixes in URL path.
+* :ghissue:`1317`: Very slow traceback construction from Cython extension
+* :ghissue:`1341`: Don't attempt to tokenize binary files for tracebacks
+* :ghissue:`1300`: Cell Input collapse
+* :ghissue:`1334`: added key handler for control-s to notebook, seems to work pretty well
+* :ghissue:`1338`: Fix see also in docstrings so API docs build
+* :ghissue:`1335`: Notebook toolbar UI
+* :ghissue:`1299`: made notebook.html extend layout.html
+* :ghissue:`1318`: make Ctrl-D in qtconsole act same as in terminal (ready to merge)
+* :ghissue:`873`: ReST support in notebook frontend
+* :ghissue:`1139`: Notebook webkit notification
+* :ghissue:`1314`: Insertcell
+* :ghissue:`1328`: Coverage
+* :ghissue:`1206`: don't preserve fixConsole output in json
+* :ghissue:`1330`: Add linewrapping to text cells (new feature in CodeMirror).
+* :ghissue:`1309`: Inoculate clearcmd extension into %reset functionality
+* :ghissue:`1327`: Updatecm2
+* :ghissue:`1326`: Removing Ace edit capability.
+* :ghissue:`1325`: forgotten selected_cell -> get_selected_cell
+* :ghissue:`1316`: Pass subprocess test runners a suitable location for xunit output
+* :ghissue:`1315`: Collect results from subprocess runners and spit out Xunit XML output.
+* :ghissue:`1233`: Update CodeMirror to the latest version
+* :ghissue:`1234`: Refactor how the notebook focuses cells
+* :ghissue:`1235`: After upgrading CodeMirror check the status of some bugs
+* :ghissue:`1236`: Review how select is called when notebook cells are inserted
+* :ghissue:`1303`: Updatecm
+* :ghissue:`1311`: Fixing CM related indentation problems.
+* :ghissue:`1304`: controller/server load can disrupt heartbeat
+* :ghissue:`1312`: minor heartbeat tweaks
+* :ghissue:`1302`: Input parsing with %prun clobbers escapes
+* :ghissue:`1306`: Fix %prun input parsing for escaped characters (closes #1302)
+* :ghissue:`1251`: IPython-0.12 can't import map module on Python 3.1
+* :ghissue:`1202`: Pyreadline install exclusion for 64 bit windows no longer required,  version dependency not correctly specified.
+* :ghissue:`1301`: New "Fix for issue #1202" based on current master.
+* :ghissue:`1242`: changed key map name to match changes to python mode
+* :ghissue:`1203`: Fix for issue #1202
+* :ghissue:`1289`: Make autoreload extension work on Python 3.
+* :ghissue:`1263`: Different 'C-x' for shortcut, 'C-m c' not toCodeCell anymore
+* :ghissue:`1259`: Replace "from (.|..) import" with absolute imports.
+* :ghissue:`1278`: took a crack at making notebook.html extend layout.html
+* :ghissue:`1210`: Add 'quiet' option to suppress screen output during %prun calls, edited dochelp
+* :ghissue:`1288`: Don't ask for confirmation when stdin isn't available
+* :ghissue:`1290`: Cell-level cut & paste overwrites multiple cells
+* :ghissue:`1291`: Minor, but important fixes to cut/copy/paste.
+* :ghissue:`1293`: TaskScheduler.hwm default value
+* :ghissue:`1294`: TaskScheduler.hwm default to 1 instead of 0
+* :ghissue:`1281`: in Hub: registration_timeout must be an integer, but heartmonitor.period is CFloat
+* :ghissue:`1283`: HeartMonitor.period should be an Integer
+* :ghissue:`1162`: Allow merge/split adjacent cells in notebook
+* :ghissue:`1264`: Aceify
+* :ghissue:`1261`: Mergesplit
+* :ghissue:`1269`: Another strange input handling error
+* :ghissue:`1284`: a fix for GH 1269
+* :ghissue:`1232`: Dead kernel loop
+* :ghissue:`1279`: ImportError: cannot import name S1 (from logging)
+* :ghissue:`1276`: notebook menu item to send a KeyboardInterrupt to the kernel
+* :ghissue:`1213`: BUG: Minor typo in history_console_widget.py
+* :ghissue:`1248`: IPython notebook doesn't work with lastest version of tornado
+* :ghissue:`1267`: add NoDB for non-recording Hub
+* :ghissue:`1222`: allow Reference as callable in map/apply
+* :ghissue:`1257`: use self.kernel_manager_class in qtconsoleapp
+* :ghissue:`1220`: Open a new notebook while connecting to an existing kernel (opened by qtconsole or terminal or standalone)
+* :ghissue:`1253`: set auto_create flag for notebook apps
+* :ghissue:`1260`: heartbeat failure on long gil-holding operation
+* :ghissue:`1262`: Heartbeat no longer shares the app's Context
+* :ghissue:`1225`: SyntaxError display broken in Python 3
+* :ghissue:`1229`: Fix display of SyntaxError in Python 3
+* :ghissue:`1256`: Dewijmoize
+* :ghissue:`1246`: Skip tests that require X, when importing pylab results in RuntimeError.
+* :ghissue:`1250`: Wijmoize
+* :ghissue:`1244`: can not imput chinese word "造" , exit right now
+* :ghissue:`1194`: Adding Opera 11 as a compatible browser for ipython notebook
+* :ghissue:`1198`: Kernel Has Died error in Notebook
+* :ghissue:`1211`: serve local files in notebook-dir
+* :ghissue:`1224`: edit text cells on double-click instead of single-click
+* :ghissue:`1187`: misc notebook: connection file cleanup, first heartbeat, startup flush
+* :ghissue:`1207`: fix loadpy duplicating newlines
+* :ghissue:`1060`: Always save the .py file to disk next to the .ipynb
+* :ghissue:`1066`: execute cell in place should preserve the current insertion-point in the notebook
+* :ghissue:`1141`: "In" numbers are not invalidated when restarting kernel
+* :ghissue:`1231`: pip on OSX tries to install files in /System directory.
+* :ghissue:`1129`: Unified setup.py
+* :ghissue:`1199`: Reduce IPython.external.*
+* :ghissue:`1219`: Make all the static files path absolute.
+* :ghissue:`1218`: Added -q option to %prun for suppression of the output, along with editing the dochelp string.
+* :ghissue:`1217`: Added -q option to %prun for suppression of the output, along with editing the dochelp string
+* :ghissue:`1216`: Pdb tab completion does not work in QtConsole
+* :ghissue:`1197`: Interactive shell trying to: from ... import history
+* :ghissue:`1175`: core.completer: Clean up excessive and unused code.
+* :ghissue:`1208`: should dv.sync_import print failed imports ?
+* :ghissue:`1186`: payloadpage.py not used by qtconsole
+* :ghissue:`1204`: double newline from %loadpy in python notebook (at least on mac)
+* :ghissue:`1192`: Invalid JSON data
+* :ghissue:`1196`: docs: looks like a file path might have been accidentally pasted in the middle of a word
+* :ghissue:`1189`: Right justify of 'in' prompt in variable prompt size configurations
+* :ghissue:`1185`: ipython console not work proper with stdout...
+* :ghissue:`1191`: profile/startup files not executed with "notebook"
+* :ghissue:`1190`: Fix link to Chris Fonnesbeck blog post about 0.11 highlights.
+* :ghissue:`1174`: Remove %install_default_config and %install_profiles
diff --git a/docs/source/whatsnew/github-stats-1.0.rst b/docs/source/whatsnew/github-stats-1.0.rst
new file mode 100644
index 00000000000..17d127e75d7
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-1.0.rst
@@ -0,0 +1,1883 @@
+.. _issues_list_100:
+
+Issues closed in the 1.0 development cycle
+==========================================
+
+
+Issues closed in 1.2
+--------------------
+
+GitHub stats for 2013/09/09 - 2014/02/21
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 13 authors contributed 84 commits.
+
+* Benjamin Ragan-Kelley
+* Daryl Herzmann
+* Doug Blank
+* Fernando Perez
+* James Porter
+* Juergen Hasch
+* Julian Taylor
+* Kyle Kelley
+* Lawrence Fu
+* Matthias Bussonnier
+* Paul Ivanov
+* Pascal Schetelat
+* Puneeth Chaganti
+* Takeshi Kanmae
+* Thomas Kluyver
+
+We closed a total of 55 issues, 38 pull requests and 17 regular issues;
+this is the full list (generated with the script :file:`tools/github_stats.py`):
+
+Pull Requests (38):
+
+1.2.1:
+
+* :ghpull:`4372`: Don't assume that SyntaxTB is always called with a SyntaxError
+* :ghpull:`5166`: remove mktemp usage
+* :ghpull:`5163`: Simplify implementation of TemporaryWorkingDirectory.
+* :ghpull:`5105`: add index to format to support py2.6
+
+1.2.0:
+
+* :ghpull:`4972`: Work around problem in doctest discovery in Python 3.4 with PyQt
+* :ghpull:`4934`: `ipython profile create` respects `--ipython-dir`
+* :ghpull:`4845`: Add Origin Checking.
+* :ghpull:`4928`: use importlib.machinery when available
+* :ghpull:`4849`: Various unicode fixes (mostly on Windows)
+* :ghpull:`4880`: set profile name from profile_dir
+* :ghpull:`4908`: detect builtin docstrings in oinspect
+* :ghpull:`4909`: sort dictionary keys before comparison, ordering is not guaranteed
+* :ghpull:`4903`: use https for all embeds
+* :ghpull:`4868`: Static path fixes
+* :ghpull:`4820`: fix regex for cleaning old logs with ipcluster
+* :ghpull:`4840`: Error in Session.send_raw()
+* :ghpull:`4762`: whitelist alphanumeric characters for cookie_name
+* :ghpull:`4748`: fix race condition in profiledir creation.
+* :ghpull:`4720`: never use ssh multiplexer in tunnels
+* :ghpull:`4738`: don't inject help into user_ns
+* :ghpull:`4722`: allow purging local results as long as they are not outstanding
+* :ghpull:`4668`: Make non-ASCII docstring unicode
+* :ghpull:`4639`: Minor import fix to get qtconsole with --pylab=qt working
+* :ghpull:`4453`: Play nice with App Nap
+* :ghpull:`4609`: Fix bytes regex for Python 3.
+* :ghpull:`4488`: fix typo in message spec doc
+* :ghpull:`4346`: getpass() on Windows & Python 2 needs bytes prompt
+* :ghpull:`4230`: Switch correctly to the user's default matplotlib backend after inline.
+* :ghpull:`4214`: engine ID metadata should be unicode, not bytes
+* :ghpull:`4232`: no highlight if no language specified
+* :ghpull:`4218`: Fix display of SyntaxError when .py file is modified
+* :ghpull:`4217`: avoid importing numpy at the module level
+* :ghpull:`4213`: fixed dead link in examples/notebooks readme to Part 3
+* :ghpull:`4183`: ESC should be handled by CM if tooltip is not on
+* :ghpull:`4193`: Update for #3549: Append Firefox overflow-x fix
+* :ghpull:`4205`: use TextIOWrapper when communicating with pandoc subprocess
+* :ghpull:`4204`: remove some extraneous print statements from IPython.parallel
+* :ghpull:`4201`: HeadingCells cannot be split or merged
+
+1.2.1:
+
+* :ghissue:`5101`: IPython 1.2.0: notebook fail with "500 Internal Server Error"
+
+1.2.0:
+
+* :ghissue:`4892`: IPython.qt test failure with python3.4
+* :ghissue:`4810`: ipcluster bug in clean_logs flag
+* :ghissue:`4765`: missing build script for highlight.js
+* :ghissue:`4761`: ipv6 address triggers cookie exception
+* :ghissue:`4721`: purge_results with jobid crashing - looking for insight
+* :ghissue:`4602`: "ipcluster stop" fails after "ipcluster start --daemonize" using python3.3
+* :ghissue:`3386`: Magic %paste not working in Python 3.3.2. TypeError: Type str doesn't support the buffer API
+* :ghissue:`4485`: Incorrect info in "Messaging in IPython" documentation. 
+* :ghissue:`4351`: /parallel/apps/launcher.py error
+* :ghissue:`4334`: NotebookApp.webapp_settings static_url_prefix causes crash
+* :ghissue:`4039`: Celltoolbar example issue
+* :ghissue:`4256`: IPython no longer handles unicode file names 
+* :ghissue:`4122`: Nbconvert [windows]: Inconsistent line endings in markdown cells exported to latex 
+* :ghissue:`3819`: nbconvert add extra blank line to code block on Windows.
+* :ghissue:`4203`: remove spurious print statement from parallel annoted functions
+* :ghissue:`4200`: Notebook: merging a heading cell and markdown cell cannot be undone
+
+
+Issues closed in 1.1
+--------------------
+
+GitHub stats for 2013/08/08 - 2013/09/09 (since 1.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 25 authors contributed 337 commits.
+
+* Benjamin Ragan-Kelley
+* Bing Xia
+* Bradley M. Froehle
+* Brian E. Granger
+* Damián Avila
+* dhirschfeld
+* Dražen Lu�anin
+* gmbecker
+* Jake Vanderplas
+* Jason Grout
+* Jonathan Frederic
+* Kevin Burke
+* Kyle Kelley
+* Matt Henderson
+* Matthew Brett
+* Matthias Bussonnier
+* Pankaj Pandey
+* Paul Ivanov
+* rossant
+* Samuel Ainsworth
+* Stephan Rave
+* stonebig
+* Thomas Kluyver
+* Yaroslav Halchenko
+* Zachary Sailer
+
+
+We closed a total of 76 issues, 58 pull requests and 18 regular issues;
+this is the full list (generated with the script :file:`tools/github_stats.py`):
+
+Pull Requests (58):
+
+* :ghpull:`4188`: Allow user_ns trait to be None
+* :ghpull:`4189`: always fire LOCAL_IPS.extend(PUBLIC_IPS)
+* :ghpull:`4174`: various issues in markdown and rst templates
+* :ghpull:`4178`: add missing data_javascript
+* :ghpull:`4181`: nbconvert: Fix, sphinx template not removing new lines from headers
+* :ghpull:`4043`: don't 'restore_bytes' in from_JSON
+* :ghpull:`4163`: Fix for incorrect default encoding on Windows.
+* :ghpull:`4136`: catch javascript errors in any output
+* :ghpull:`4171`: add nbconvert config file when creating profiles
+* :ghpull:`4125`: Basic exercise of `ipython [subcommand] -h` and help-all
+* :ghpull:`4085`: nbconvert: Fix sphinx preprocessor date format string for Windows
+* :ghpull:`4159`: don't split `.cell` and `div.cell` CSS
+* :ghpull:`4158`: generate choices for `--gui` configurable from real mapping
+* :ghpull:`4065`: do not include specific css in embedable one
+* :ghpull:`4092`: nbconvert: Fix for unicode html headers, Windows + Python 2.x
+* :ghpull:`4074`: close Client sockets if connection fails
+* :ghpull:`4064`: Store default codemirror mode in only 1 place
+* :ghpull:`4104`: Add way to install MathJax to a particular profile
+* :ghpull:`4144`: help_end transformer shouldn't pick up ? in multiline string
+* :ghpull:`4143`: update example custom.js
+* :ghpull:`4142`: DOC: unwrap openssl line in public_server doc
+* :ghpull:`4141`: add files with a separate `add` call in backport_pr
+* :ghpull:`4137`: Restore autorestore option for storemagic
+* :ghpull:`4098`: pass profile-dir instead of profile name to Kernel
+* :ghpull:`4120`: support `input` in Python 2 kernels
+* :ghpull:`4088`: nbconvert: Fix coalescestreams line with incorrect nesting causing strange behavior
+* :ghpull:`4060`: only strip continuation prompts if regular prompts seen first
+* :ghpull:`4132`: Fixed name error bug in function safe_unicode in module py3compat.
+* :ghpull:`4121`: move test_kernel from IPython.zmq to IPython.kernel
+* :ghpull:`4118`: ZMQ heartbeat channel: catch EINTR exceptions and continue.
+* :ghpull:`4054`: use unicode for HTML export
+* :ghpull:`4106`: fix a couple of default block values
+* :ghpull:`4115`: Update docs on declaring a magic function
+* :ghpull:`4101`: restore accidentally removed EngineError
+* :ghpull:`4096`: minor docs changes
+* :ghpull:`4056`: respect `pylab_import_all` when `--pylab` specified at the command-line
+* :ghpull:`4091`: Make Qt console banner configurable
+* :ghpull:`4086`: fix missing errno import
+* :ghpull:`4030`: exclude `.git` in MANIFEST.in
+* :ghpull:`4047`: Use istype() when checking if canned object is a dict
+* :ghpull:`4031`: don't close_fds on Windows
+* :ghpull:`4029`: bson.Binary moved
+* :ghpull:`4035`: Fixed custom jinja2 templates being ignored when setting template_path
+* :ghpull:`4026`: small doc fix in nbconvert
+* :ghpull:`4016`: Fix IPython.start_* functions
+* :ghpull:`4021`: Fix parallel.client.View map() on numpy arrays
+* :ghpull:`4022`: DOC: fix links to matplotlib, notebook docs
+* :ghpull:`4018`: Fix warning when running IPython.kernel tests
+* :ghpull:`4019`: Test skipping without unicode paths
+* :ghpull:`4008`: Transform code before %prun/%%prun runs
+* :ghpull:`4014`: Fix typo in ipapp
+* :ghpull:`3987`: get files list in backport_pr
+* :ghpull:`3974`: nbconvert: Fix app tests on Window7 w/ Python 3.3
+* :ghpull:`3978`: fix `--existing` with non-localhost IP
+* :ghpull:`3939`: minor checkpoint cleanup
+* :ghpull:`3981`: BF: fix nbconvert rst input prompt spacing
+* :ghpull:`3960`: Don't make sphinx a dependency for importing nbconvert
+* :ghpull:`3973`: logging.Formatter is not new-style in 2.6
+
+Issues (18):
+
+* :ghissue:`4024`: nbconvert markdown issues
+* :ghissue:`4095`: Catch js error in append html in stream/pyerr
+* :ghissue:`4156`: Specifying --gui=tk at the command line
+* :ghissue:`3818`: nbconvert can't handle Heading with Chinese characters on Japanese Windows OS.
+* :ghissue:`4134`: multi-line parser fails on ''' in comment, qtconsole and notebook.
+* :ghissue:`3998`: sample custom.js needs to be updated
+* :ghissue:`4078`: StoreMagic.autorestore not working in 1.0.0
+* :ghissue:`3990`: Builtin `input` doesn't work over zmq
+* :ghissue:`4015`: nbconvert fails to convert all the content of a notebook
+* :ghissue:`4059`: Issues with Ellipsis literal in Python 3
+* :ghissue:`4103`: Wrong default argument of DirectView.clear
+* :ghissue:`4100`: parallel.client.client references undefined error.EngineError
+* :ghissue:`4005`: IPython.start_kernel doesn't work.
+* :ghissue:`4020`: IPython parallel map fails on numpy arrays
+* :ghissue:`3945`: nbconvert: commandline tests fail Win7x64 Py3.3
+* :ghissue:`3977`: unable to complete remote connections for two-process 
+* :ghissue:`3980`: nbconvert rst output lacks needed blank lines
+* :ghissue:`3968`: TypeError: super() argument 1 must be type, not classobj (Python 2.6.6)
+
+Issues closed in 1.0
+--------------------
+
+GitHub stats for 2012/06/30 - 2013/08/08 (since 0.13)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 155 authors contributed 4258 commits.
+
+* Aaron Meurer
+* Adam Davis
+* Ahmet Bakan
+* Alberto Valverde
+* Allen Riddell
+* Anders Hovmöller
+* Andrea Bedini
+* Andrew Spiers
+* Andrew Vandever
+* Anthony Scopatz
+* Anton Akhmerov
+* Anton I. Sipos
+* Antony Lee
+* Aron Ahmadia
+* Benedikt Sauer
+* Benjamin Jones
+* Benjamin Ragan-Kelley
+* Benjie Chen
+* Boris de Laage
+* Brad Reisfeld
+* Bradley M. Froehle
+* Brian E. Granger
+* Cameron Bates
+* Cavendish McKay
+* chapmanb
+* Chris Beaumont
+* Chris Laumann
+* Christoph Gohlke
+* codebraker
+* codespaced
+* Corran Webster
+* DamianHeard
+* Damián Avila
+* Dan Kilman
+* Dan McDougall
+* Danny Staple
+* David Hirschfeld
+* David P. Sanders
+* David Warde-Farley
+* David Wolever
+* David Wyde
+* debjan
+* Diane Trout
+* dkua
+* Dominik Dabrowski
+* Donald Curtis
+* Dražen Lu�anin
+* drevicko
+* Eric O. LEBIGOT
+* Erik M. Bray
+* Erik Tollerud
+* Eugene Van den Bulke
+* Evan Patterson
+* Fernando Perez
+* Francesco Montesano
+* Frank Murphy
+* Greg Caporaso
+* Guy Haskin Fernald
+* guziy
+* Hans Meine
+* Harry Moreno
+* henryiii
+* Ivan Djokic
+* Jack Feser
+* Jake Vanderplas
+* jakobgager
+* James Booth
+* Jan Schulz
+* Jason Grout
+* Jeff Knisley
+* Jens Hedegaard Nielsen
+* jeremiahbuddha
+* Jerry Fowler
+* Jessica B. Hamrick
+* Jez Ng
+* John Zwinck
+* Jonathan Frederic
+* Jonathan Taylor
+* Joon Ro
+* Joseph Lansdowne
+* Juergen Hasch
+* Julian Taylor
+* Jussi Sainio
+* Jörgen Stenarson
+* kevin
+* klonuo
+* Konrad Hinsen
+* Kyle Kelley
+* Lars Solberg
+* Lessandro Mariano
+* Mark Sienkiewicz at STScI
+* Martijn Vermaat
+* Martin Spacek
+* Matthias Bussonnier
+* Maxim Grechkin
+* Maximilian Albert
+* MercuryRising
+* Michael Droettboom
+* Michael Shuffett
+* Michał Górny
+* Mikhail Korobov
+* mr.Shu
+* Nathan Goldbaum
+* ocefpaf
+* Ohad Ravid
+* Olivier Grisel
+* Olivier Verdier
+* Owen Healy
+* Pankaj Pandey
+* Paul Ivanov
+* Pawel Jasinski
+* Pietro Berkes
+* Piti Ongmongkolkul
+* Puneeth Chaganti
+* Rich Wareham
+* Richard Everson
+* Rick Lupton
+* Rob Young
+* Robert Kern
+* Robert Marchman
+* Robert McGibbon
+* Rui Pereira
+* Rustam Safin
+* Ryan May
+* s8weber
+* Samuel Ainsworth
+* Sean Vig
+* Siyu Zhang
+* Skylar Saveland
+* slojo404
+* smithj1
+* Stefan Karpinski
+* Stefan van der Walt
+* Steven Silvester
+* Takafumi Arakaki
+* Takeshi Kanmae
+* tcmulcahy
+* teegaar
+* Thomas Kluyver
+* Thomas Robitaille
+* Thomas Spura
+* Thomas Weißschuh
+* Timothy O'Donnell
+* Tom Dimiduk
+* ugurthemaster
+* urielshaolin
+* v923z
+* Valentin Haenel
+* Victor Zverovich
+* W. Trevor King
+* y-p
+* Yoav Ram
+* Zbigniew Jędrzejewski-Szmek
+* Zoltán Vörös
+
+
+We closed a total of 1484 issues, 793 pull requests and 691 regular issues;
+this is the full list (generated with the script 
+:file:`tools/github_stats.py`):
+
+Pull Requests (793):
+
+* :ghpull:`3958`: doc update
+* :ghpull:`3965`: Fix ansi color code for background yellow
+* :ghpull:`3964`: Fix casing of message.
+* :ghpull:`3942`: Pass on install docs
+* :ghpull:`3962`: exclude IPython.lib.kernel in iptest
+* :ghpull:`3961`: Longpath test fix
+* :ghpull:`3905`: Remove references to 0.11 and 0.12 from config/overview.rst
+* :ghpull:`3951`: nbconvert: fixed latex characters not escaped properly in nbconvert
+* :ghpull:`3949`: log fatal error when PDF conversion fails
+* :ghpull:`3947`: nbconvert: Make writer & post-processor aliases case insensitive.
+* :ghpull:`3938`: Recompile css.
+* :ghpull:`3948`: sphinx and PDF tweaks
+* :ghpull:`3943`: nbconvert: Serve post-processor Windows fix
+* :ghpull:`3934`: nbconvert: fix logic of verbose flag in PDF post processor
+* :ghpull:`3929`: swallow enter event in rename dialog
+* :ghpull:`3924`: nbconvert: Backport fixes
+* :ghpull:`3925`: Replace --pylab flag with --matplotlib in usage
+* :ghpull:`3910`: Added explicit error message for missing configuration arguments.
+* :ghpull:`3913`: grffile to support spaces in notebook names
+* :ghpull:`3918`: added check_for_tornado, closes #3916
+* :ghpull:`3917`: change docs/examples refs to be just examples
+* :ghpull:`3908`: what's new tweaks
+* :ghpull:`3896`: two column quickhelp dialog, closes #3895
+* :ghpull:`3911`: explicitly load python mode before IPython mode
+* :ghpull:`3901`: don't force . relative path, fix #3897
+* :ghpull:`3891`: fix #3889
+* :ghpull:`3892`: Fix documentation of Kernel.stop_channels
+* :ghpull:`3888`: posixify paths for Windows latex
+* :ghpull:`3882`: quick fix for #3881
+* :ghpull:`3877`: don't use `shell=True` in PDF export
+* :ghpull:`3878`: minor template loading cleanup
+* :ghpull:`3855`: nbconvert: Filter tests
+* :ghpull:`3879`: finish 3870
+* :ghpull:`3870`: Fix for converting notebooks that contain unicode characters.
+* :ghpull:`3876`: Update parallel_winhpc.rst
+* :ghpull:`3872`: removing vim-ipython, since it has it's own repo
+* :ghpull:`3871`: updating docs
+* :ghpull:`3873`: remove old examples
+* :ghpull:`3868`: update CodeMirror component to 3.15
+* :ghpull:`3865`: Escape filename for pdflatex in nbconvert
+* :ghpull:`3861`: remove old external.js
+* :ghpull:`3864`: add keyboard shortcut to docs
+* :ghpull:`3834`: This PR fixes a few issues with nbconvert tests
+* :ghpull:`3840`: prevent profile_dir from being undefined
+* :ghpull:`3859`: Add "An Afternoon Hack" to docs
+* :ghpull:`3854`: Catch errors filling readline history on startup
+* :ghpull:`3857`: Delete extra auto
+* :ghpull:`3845`: nbconvert: Serve from original build directory
+* :ghpull:`3846`: Add basic logging to nbconvert
+* :ghpull:`3850`: add missing store_history key to Notebook execute_requests
+* :ghpull:`3844`: update payload source
+* :ghpull:`3830`: mention metadata / display_data similarity in pyout spec
+* :ghpull:`3848`: fix incorrect `empty-docstring`
+* :ghpull:`3836`: Parse markdown correctly when mathjax is disabled
+* :ghpull:`3849`: skip a failing test on windows
+* :ghpull:`3828`: signature_scheme lives in Session
+* :ghpull:`3831`: update nbconvert doc with new CLI
+* :ghpull:`3822`: add output flag to nbconvert
+* :ghpull:`3780`: Added serving the output directory if html-based format are selected.
+* :ghpull:`3764`: Cleanup nbconvert templates
+* :ghpull:`3829`: remove now-duplicate 'this is dev' note
+* :ghpull:`3814`: add `ConsoleWidget.execute_on_complete_input` flag
+* :ghpull:`3826`: try rtfd
+* :ghpull:`3821`: add sphinx prolog
+* :ghpull:`3817`: relax timeouts in terminal console and tests
+* :ghpull:`3825`: fix more tests that fail when pandoc is missing
+* :ghpull:`3824`: don't set target on internal markdown links
+* :ghpull:`3816`: s/pylab/matplotlib in docs
+* :ghpull:`3812`: Describe differences between start_ipython and embed
+* :ghpull:`3805`: Print View has been removed
+* :ghpull:`3820`: Make it clear that 1.0 is not released yet
+* :ghpull:`3784`: nbconvert: Export flavors & PDF writer (ipy dev meeting)
+* :ghpull:`3800`: semantic-versionify version number for non-releases
+* :ghpull:`3802`: Documentation .txt to .rst
+* :ghpull:`3765`: cleanup terminal console iopub handling
+* :ghpull:`3720`: Fix for #3719
+* :ghpull:`3787`: re-raise KeyboardInterrupt in raw_input
+* :ghpull:`3770`: Organizing reveal's templates.
+* :ghpull:`3751`: Use link(2) when possible in nbconvert
+* :ghpull:`3792`: skip tests that require pandoc
+* :ghpull:`3782`: add Importing Notebooks example
+* :ghpull:`3752`: nbconvert: Add cwd to sys.path
+* :ghpull:`3789`: fix raw_input in qtconsole
+* :ghpull:`3756`: document the wire protocol
+* :ghpull:`3749`: convert IPython syntax to Python syntax in nbconvert python template
+* :ghpull:`3793`: Closes #3788
+* :ghpull:`3794`: Change logo link to ipython.org
+* :ghpull:`3746`: Raise a named exception when pandoc is missing
+* :ghpull:`3781`: comply with the message spec in the notebook
+* :ghpull:`3779`: remove bad `if logged_in` preventing new-notebook without login
+* :ghpull:`3743`: remove notebook read-only view
+* :ghpull:`3732`: add delay to autosave in beforeunload
+* :ghpull:`3761`: Added rm_math_space to markdown cells in the basichtml.tpl to be rendered ok by mathjax after the nbconvertion.
+* :ghpull:`3758`: nbconvert: Filter names cleanup
+* :ghpull:`3769`: Add configurability to  tabcompletion timeout
+* :ghpull:`3771`: Update px pylab test to match new output of pylab
+* :ghpull:`3741`: better message when notebook format is not supported
+* :ghpull:`3753`: document Ctrl-C not working in ipython kernel
+* :ghpull:`3766`: handle empty metadata in pyout messages more gracefully.
+* :ghpull:`3736`: my attempt to fix #3735
+* :ghpull:`3759`: nbconvert: Provide a more useful error for invalid use case.
+* :ghpull:`3760`: nbconvert: Allow notebook filenames without their extensions
+* :ghpull:`3750`: nbconvert: Add cwd to default templates search path.
+* :ghpull:`3748`: Update nbconvert docs
+* :ghpull:`3734`: Nbconvert: Export extracted files into `nbname_files` subdirectory
+* :ghpull:`3733`: Nicer message when pandoc is missing, closes #3730
+* :ghpull:`3722`: fix two failing test in IPython.lib
+* :ghpull:`3704`: Start what's new for 1.0
+* :ghpull:`3705`: Complete rewrite of IPython Notebook documentation: docs/source/interactive/htmlnotebook.txt
+* :ghpull:`3709`: Docs cleanup
+* :ghpull:`3716`: raw_input fixes for kernel restarts
+* :ghpull:`3683`: use `%matplotlib` in example notebooks
+* :ghpull:`3686`: remove quarantine
+* :ghpull:`3699`: svg2pdf unicode fix
+* :ghpull:`3695`: fix SVG2PDF
+* :ghpull:`3685`: fix Pager.detach
+* :ghpull:`3675`: document new dependencies
+* :ghpull:`3690`: Fixing some css minors in full_html and reveal.
+* :ghpull:`3671`: nbconvert tests
+* :ghpull:`3692`: Fix rename notebook - show error with invalid name
+* :ghpull:`3409`: Prevent qtconsole frontend freeze on lots of output.
+* :ghpull:`3660`: refocus active cell on dialog close
+* :ghpull:`3598`: Statelessify mathjaxutils
+* :ghpull:`3673`: enable comment/uncomment selection
+* :ghpull:`3677`: remove special-case in get_home_dir for frozen dists
+* :ghpull:`3674`: add CONTRIBUTING.md
+* :ghpull:`3670`: use Popen command list for ipexec
+* :ghpull:`3568`: pylab import adjustments
+* :ghpull:`3559`: add create.Cell and delete.Cell js events
+* :ghpull:`3606`: push cell magic to the head of the transformer line
+* :ghpull:`3607`: NbConvert: Writers, No YAML, and stuff...
+* :ghpull:`3665`: Pywin32 skips
+* :ghpull:`3669`: set default client_class for QtKernelManager
+* :ghpull:`3662`: add strip_encoding_cookie transformer
+* :ghpull:`3641`: increase patience for slow kernel startup in tests
+* :ghpull:`3651`: remove a bunch of unused `default_config_file` assignments
+* :ghpull:`3630`: CSS adjustments
+* :ghpull:`3645`: Don't require HistoryManager to have a shell
+* :ghpull:`3643`: don't assume tested ipython is on the PATH
+* :ghpull:`3654`: fix single-result AsyncResults
+* :ghpull:`3601`: Markdown in heading cells (take 2)
+* :ghpull:`3652`: Remove old `docs/examples`
+* :ghpull:`3621`: catch any exception appending output
+* :ghpull:`3585`: don't blacklist builtin names
+* :ghpull:`3647`: Fix `frontend` deprecation warnings in several examples
+* :ghpull:`3649`: fix AsyncResult.get_dict for single result
+* :ghpull:`3648`: Fix store magic test 
+* :ghpull:`3650`: Fix, config_file_name was ignored
+* :ghpull:`3640`: Gcf.get_active() can return None
+* :ghpull:`3571`: Added shortcuts to split cell, merge cell above and merge cell below.
+* :ghpull:`3635`: Added missing slash to print-pdf call.
+* :ghpull:`3487`: Drop patch for compatibility with pyreadline 1.5
+* :ghpull:`3338`: Allow filename with extension in find_cmd in Windows.
+* :ghpull:`3628`: Fix test for Python 3 on Windows.
+* :ghpull:`3642`: Fix typo in docs
+* :ghpull:`3627`: use DEFAULT_STATIC_FILES_PATH in a test instead of package dir
+* :ghpull:`3624`: fix some unicode in zmqhandlers
+* :ghpull:`3460`: Set calling program to UNKNOWN, when argv not in sys
+* :ghpull:`3632`: Set calling program to UNKNOWN, when argv not in sys (take #2)
+* :ghpull:`3629`: Use new entry point for python -m IPython
+* :ghpull:`3626`: passing cell to showInPager, closes #3625
+* :ghpull:`3618`: expand terminal color support
+* :ghpull:`3623`: raise UsageError for unsupported GUI backends
+* :ghpull:`3071`: Add magic function %drun to run code in debugger
+* :ghpull:`3608`: a nicer error message when using %pylab magic
+* :ghpull:`3592`: add extra_config_file
+* :ghpull:`3612`: updated .mailmap
+* :ghpull:`3616`: Add examples for interactive use of MPI.
+* :ghpull:`3615`: fix regular expression for ANSI escapes
+* :ghpull:`3586`: Corrected a typo in the format string for strftime the sphinx.py transformer of nbconvert
+* :ghpull:`3611`: check for markdown no longer needed, closes #3610
+* :ghpull:`3555`: Simplify caching of modules with %run
+* :ghpull:`3583`: notebook small things
+* :ghpull:`3594`: Fix duplicate completion in notebook
+* :ghpull:`3600`: parallel: Improved logging for errors during BatchSystemLauncher.stop
+* :ghpull:`3595`: Revert "allow markdown in heading cells"
+* :ghpull:`3538`: add IPython.start_ipython
+* :ghpull:`3562`: Allow custom nbconvert template loaders
+* :ghpull:`3582`: pandoc adjustments
+* :ghpull:`3560`: Remove max_msg_size
+* :ghpull:`3591`: Refer to Setuptools instead of Distribute
+* :ghpull:`3590`: IPython.sphinxext needs an __init__.py
+* :ghpull:`3581`: Added the possibility to read a custom.css file for tweaking the final html in full_html and reveal templates.
+* :ghpull:`3576`: Added support for markdown in heading cells when they are nbconverted.
+* :ghpull:`3575`: tweak `run -d` message to 'continue execution'
+* :ghpull:`3569`: add PYTHONSTARTUP to startup files
+* :ghpull:`3567`: Trigger a single event on js app initialized
+* :ghpull:`3565`: style.min.css should always exist...
+* :ghpull:`3531`: allow markdown in heading cells
+* :ghpull:`3577`: Simplify codemirror ipython-mode
+* :ghpull:`3495`: Simplified regexp, and suggestions for clearer regexps.
+* :ghpull:`3578`: Use adjustbox to specify figure size in nbconvert -> latex
+* :ghpull:`3572`: Skip import irunner test on Windows.
+* :ghpull:`3574`: correct static path for CM modes autoload
+* :ghpull:`3558`: Add IPython.sphinxext
+* :ghpull:`3561`: mention double-control-C to stop notebook server
+* :ghpull:`3566`: fix event names
+* :ghpull:`3564`: Remove trivial nbconvert example
+* :ghpull:`3540`: allow cython cache dir to be deleted
+* :ghpull:`3527`: cleanup stale, unused exceptions in parallel.error
+* :ghpull:`3529`: ensure raw_input returns str in zmq shell
+* :ghpull:`3541`: respect image size metadata in qtconsole
+* :ghpull:`3550`: Fixing issue preventing the correct read of images by full_html and reveal exporters.
+* :ghpull:`3557`: open markdown links in new tabs
+* :ghpull:`3556`: remove mention of nonexistent `_margv` in macro
+* :ghpull:`3552`: set overflow-x: hidden on Firefox only
+* :ghpull:`3554`: Fix missing import os in latex exporter.
+* :ghpull:`3546`: Don't hardcode **latex** posix paths in nbconvert
+* :ghpull:`3551`: fix path prefix in nbconvert
+* :ghpull:`3533`: Use a CDN to get reveal.js library.
+* :ghpull:`3498`: When a notebook is written to file, name the metadata name u''.
+* :ghpull:`3548`: Change to standard save icon in Notebook toolbar
+* :ghpull:`3539`: Don't hardcode posix paths in nbconvert
+* :ghpull:`3508`: notebook supports raw_input and %debug now
+* :ghpull:`3526`: ensure 'default' is first in cluster profile list
+* :ghpull:`3525`: basic timezone info
+* :ghpull:`3532`: include nbconvert templates in installation
+* :ghpull:`3515`: update CodeMirror component to 3.14
+* :ghpull:`3513`: add 'No Checkpoints' to Revert menu
+* :ghpull:`3536`: format positions are required in Python 2.6.x
+* :ghpull:`3521`: Nbconvert fix, silent fail if template doesn't exist
+* :ghpull:`3530`: update %store magic docstring
+* :ghpull:`3528`: fix local mathjax with custom base_project_url
+* :ghpull:`3518`: Clear up unused imports
+* :ghpull:`3506`: %store -r restores saved aliases and directory history, as well as variables
+* :ghpull:`3516`: make css highlight style configurable
+* :ghpull:`3523`: Exclude frontend shim from docs build
+* :ghpull:`3514`: use bootstrap `disabled` instead of `ui-state-disabled`
+* :ghpull:`3520`: Added relative import of RevealExporter to __init__.py inside exporters module
+* :ghpull:`3507`: fix HTML capitalization in nbconvert exporter classes
+* :ghpull:`3512`: fix nbconvert filter validation
+* :ghpull:`3511`: Get Tracer working after ipapi.get replaced with get_ipython
+* :ghpull:`3510`: use `window.onbeforeunload=` for nav-away warning
+* :ghpull:`3504`: don't use parent=self in handlers
+* :ghpull:`3500`: Merge nbconvert into IPython
+* :ghpull:`3478`: restore "unsaved changes" warning on unload
+* :ghpull:`3493`: add a dialog when the kernel is auto-restarted
+* :ghpull:`3488`: Add test suite for autoreload extension
+* :ghpull:`3484`: Catch some pathological cases inside oinspect
+* :ghpull:`3481`: Display R errors without Python traceback
+* :ghpull:`3468`: fix `%magic` output
+* :ghpull:`3430`: add parent to Configurable
+* :ghpull:`3491`: Remove unexpected keyword parameter to remove_kernel
+* :ghpull:`3485`: SymPy has changed its recommended way to initialize printing
+* :ghpull:`3486`: Add test for non-ascii characters in docstrings
+* :ghpull:`3483`: Inputtransformer: Allow classic prompts without space
+* :ghpull:`3482`: Use an absolute path to iptest, because the tests are not always run from $IPYTHONDIR.
+* :ghpull:`3381`: enable 2x (retina) display
+* :ghpull:`3450`: Flatten IPython.frontend
+* :ghpull:`3477`: pass config to subapps
+* :ghpull:`3466`: Kernel fails to start when username has non-ascii characters
+* :ghpull:`3465`: Add HTCondor bindings to IPython.parallel
+* :ghpull:`3463`: fix typo, closes #3462
+* :ghpull:`3456`: Notice for users who disable javascript
+* :ghpull:`3453`: fix cell execution in firefox, closes #3447
+* :ghpull:`3393`: [WIP] bootstrapify
+* :ghpull:`3440`: Fix installing mathjax from downloaded file via command line
+* :ghpull:`3431`: Provide means for starting the Qt console maximized and with the menu bar hidden
+* :ghpull:`3425`: base IPClusterApp inherits from BaseIPythonApp
+* :ghpull:`3433`: Update IPython\external\path\__init__.py
+* :ghpull:`3298`: Some fixes in IPython Sphinx directive
+* :ghpull:`3428`: process escapes in mathjax
+* :ghpull:`3420`: thansk -> thanks
+* :ghpull:`3416`: Fix doc: "principle" not "principal"
+* :ghpull:`3413`: more unique filename for test
+* :ghpull:`3364`: Inject requirejs in notebook and start using it.
+* :ghpull:`3390`: Fix %paste with blank lines
+* :ghpull:`3403`: fix creating config objects from dicts
+* :ghpull:`3401`: rollback #3358
+* :ghpull:`3373`: make cookie_secret configurable
+* :ghpull:`3307`: switch default ws_url logic to js side
+* :ghpull:`3392`: Restore anchor link on h2-h6
+* :ghpull:`3369`: Use different threshold for (auto)scroll in output
+* :ghpull:`3370`: normalize unicode notebook filenames
+* :ghpull:`3372`: base default cookie name on request host+port
+* :ghpull:`3378`: disable CodeMirror drag/drop on Safari
+* :ghpull:`3358`: workaround spurious CodeMirror scrollbars
+* :ghpull:`3371`: make setting the notebook dirty flag an event
+* :ghpull:`3366`: remove long-dead zmq frontend.py and completer.py
+* :ghpull:`3382`: cull Session digest history
+* :ghpull:`3330`: Fix get_ipython_dir when $HOME is /
+* :ghpull:`3319`: IPEP 13: user-expressions and user-variables
+* :ghpull:`3384`: comments in tools/gitwash_dumper.py changed (''' to """)
+* :ghpull:`3387`: Make submodule checks work under Python 3.
+* :ghpull:`3357`: move anchor-link off of heading text
+* :ghpull:`3351`: start basic tests of ipcluster Launchers
+* :ghpull:`3377`: allow class.__module__ to be None
+* :ghpull:`3340`: skip submodule check in package managers
+* :ghpull:`3328`: decode subprocess output in launchers
+* :ghpull:`3368`: Reenable bracket matching
+* :ghpull:`3356`: Mpr fixes
+* :ghpull:`3336`: Use new input transformation API in %time magic
+* :ghpull:`3325`: Organize the JS and less files by component.
+* :ghpull:`3342`: fix test_find_cmd_python
+* :ghpull:`3354`: catch socket.error in utils.localinterfaces
+* :ghpull:`3341`: fix default cluster count
+* :ghpull:`3286`: don't use `get_ipython` from builtins in library code
+* :ghpull:`3333`: notebookapp: add missing whitespace to warnings
+* :ghpull:`3323`: Strip prompts even if the prompt isn't present on the first line.
+* :ghpull:`3321`: Reorganize the python/server side of the notebook
+* :ghpull:`3320`: define `__file__` in config files
+* :ghpull:`3317`: rename `%%file` to `%%writefile`
+* :ghpull:`3304`: set unlimited HWM for all relay devices
+* :ghpull:`3315`: Update Sympy_printing extension load
+* :ghpull:`3310`: further clarify Image docstring
+* :ghpull:`3285`: load extensions in builtin trap
+* :ghpull:`3308`: Speed up AsyncResult._wait_for_outputs(0)
+* :ghpull:`3294`: fix callbacks as optional in js kernel.execute
+* :ghpull:`3276`: Fix: "python ABS/PATH/TO/ipython.py" fails
+* :ghpull:`3301`: allow python3 tests without python installed
+* :ghpull:`3282`: allow view.map to work with a few more things
+* :ghpull:`3284`: remove `ipython.py` entry point
+* :ghpull:`3281`: fix ignored IOPub messages with no parent
+* :ghpull:`3275`: improve submodule messages / git hooks
+* :ghpull:`3239`: Allow "x" icon and esc key to close pager in notebook
+* :ghpull:`3290`: Improved heartbeat controller to engine monitoring for long running tasks
+* :ghpull:`3142`: Better error message when CWD doesn't exist on startup
+* :ghpull:`3066`: Add support for relative import to %run -m (fixes #2727)
+* :ghpull:`3269`: protect highlight.js against unknown languages
+* :ghpull:`3267`: add missing return
+* :ghpull:`3101`: use marked / highlight.js instead of pagedown and prettify
+* :ghpull:`3264`: use https url for submodule
+* :ghpull:`3263`: fix set_last_checkpoint when no checkpoint
+* :ghpull:`3258`: Fix submodule location in setup.py
+* :ghpull:`3254`: fix a few URLs from previous PR
+* :ghpull:`3240`: remove js components from the repo
+* :ghpull:`3158`: IPEP 15: autosave the notebook
+* :ghpull:`3252`: move images out of _static folder into _images
+* :ghpull:`3251`: Fix for cell magics in Qt console
+* :ghpull:`3250`: Added a simple __html__() method to the HTML class
+* :ghpull:`3249`: remove copy of sphinx inheritance_diagram.py
+* :ghpull:`3235`: Remove the unused print notebook view
+* :ghpull:`3238`: Improve the design of the tab completion UI
+* :ghpull:`3242`: Make changes of Application.log_format effective
+* :ghpull:`3219`: Workaround so only one CTRL-C is required for a new prompt in --gui=qt
+* :ghpull:`3190`: allow formatters to specify metadata
+* :ghpull:`3231`: improve discovery of public IPs
+* :ghpull:`3233`: check prefixes for swallowing kernel args
+* :ghpull:`3234`: Removing old autogrow JS code.
+* :ghpull:`3232`: Update to CodeMirror 3 and start to ship our components
+* :ghpull:`3229`: The HTML output type accidentally got removed from the OutputArea.
+* :ghpull:`3228`: Typo in IPython.Parallel documentation
+* :ghpull:`3226`: Text in rename dialog was way too big - making it <p>.
+* :ghpull:`3225`: Removing old restuctured text handler and web service.
+* :ghpull:`3222`: make BlockingKernelClient the default Client
+* :ghpull:`3223`: add missing mathjax_url to new settings dict
+* :ghpull:`3089`: add stdin to the notebook
+* :ghpull:`3221`: Remove references to HTMLCell (dead code)
+* :ghpull:`3205`: add ignored ``*args`` to HasTraits constructor
+* :ghpull:`3088`: cleanup IPython handler settings
+* :ghpull:`3201`: use much faster regexp for ansi coloring
+* :ghpull:`3220`: avoid race condition in profile creation
+* :ghpull:`3011`: IPEP 12: add KernelClient
+* :ghpull:`3217`: informative error when trying to load directories
+* :ghpull:`3174`: Simple class
+* :ghpull:`2979`: CM configurable Take 2
+* :ghpull:`3215`: Updates storemagic extension to allow for specifying variable name to load
+* :ghpull:`3181`: backport If-Modified-Since fix from tornado
+* :ghpull:`3200`: IFrame (VimeoVideo, ScribdDocument, ...) 
+* :ghpull:`3186`: Fix small inconsistency in nbconvert: etype -> ename
+* :ghpull:`3212`: Fix issue #2563, "core.profiledir.check_startup_dir() doesn't work inside py2exe'd installation"
+* :ghpull:`3211`: Fix inheritance_diagram Sphinx extension for Sphinx 1.2
+* :ghpull:`3208`: Update link to extensions index
+* :ghpull:`3203`: Separate InputSplitter for transforming whole cells
+* :ghpull:`3189`: Improve completer
+* :ghpull:`3194`: finish up PR #3116
+* :ghpull:`3188`: Add new keycodes
+* :ghpull:`2695`: Key the root modules cache by sys.path entries.
+* :ghpull:`3182`: clarify %%file docstring
+* :ghpull:`3163`: BUG: Fix the set and frozenset pretty printer to handle the empty case correctly
+* :ghpull:`3180`: better UsageError for cell magic with no body
+* :ghpull:`3184`: Cython cache
+* :ghpull:`3175`: Added missing s
+* :ghpull:`3173`: Little bits of documentation cleanup
+* :ghpull:`2635`: Improve Windows start menu shortcuts (#2)
+* :ghpull:`3172`: Add missing import in IPython parallel magics example
+* :ghpull:`3170`: default application logger shouldn't propagate
+* :ghpull:`3159`: Autocompletion for zsh
+* :ghpull:`3105`: move DEFAULT_STATIC_FILES_PATH to IPython.html
+* :ghpull:`3144`: minor bower tweaks
+* :ghpull:`3141`: Default color output for ls on OSX
+* :ghpull:`3137`: fix dot syntax error in inheritance diagram
+* :ghpull:`3072`: raise UnsupportedOperation on iostream.fileno()
+* :ghpull:`3147`: Notebook support for a reverse proxy which handles SSL
+* :ghpull:`3152`: make qtconsole size at startup configurable
+* :ghpull:`3162`: adding stream kwarg to current.new_output
+* :ghpull:`2981`: IPEP 10: kernel side filtering of display formats
+* :ghpull:`3058`: add redirect handler for notebooks by name
+* :ghpull:`3041`: support non-modules in @require
+* :ghpull:`2447`: Stateful line transformers
+* :ghpull:`3108`: fix some O(N) and O(N^2) operations in parallel.map
+* :ghpull:`2791`: forward stdout from forked processes
+* :ghpull:`3157`: use Python 3-style for pretty-printed sets
+* :ghpull:`3148`: closes #3045, #3123 for tornado < version 3.0
+* :ghpull:`3143`: minor heading-link tweaks
+* :ghpull:`3136`: Strip useless ANSI escape codes in notebook
+* :ghpull:`3126`: Prevent errors when pressing arrow keys in an empty notebook
+* :ghpull:`3135`: quick dev installation instructions
+* :ghpull:`2889`: Push pandas dataframes to R magic
+* :ghpull:`3068`: Don't monkeypatch doctest during IPython startup.
+* :ghpull:`3133`: fix argparse version check
+* :ghpull:`3102`: set `spellcheck=false` in CodeCell inputarea
+* :ghpull:`3064`: add anchors to heading cells
+* :ghpull:`3097`: PyQt 4.10: use self._document = self.document()
+* :ghpull:`3117`: propagate automagic change to shell
+* :ghpull:`3118`: don't give up on weird os names
+* :ghpull:`3115`: Fix example
+* :ghpull:`2640`: fix quarantine/ipy_editors.py
+* :ghpull:`3070`: Add info make target that was missing in old Sphinx
+* :ghpull:`3082`: A few small patches to image handling
+* :ghpull:`3078`: fix regular expression for detecting links in stdout
+* :ghpull:`3054`: restore default behavior for automatic cluster size
+* :ghpull:`3073`: fix ipython usage text
+* :ghpull:`3083`: fix DisplayMagics.html docstring
+* :ghpull:`3080`: noted sub_channel being renamed to iopub_channel
+* :ghpull:`3079`: actually use IPKernelApp.kernel_class
+* :ghpull:`3076`: Improve notebook.js documentation
+* :ghpull:`3063`: add missing `%%html` magic
+* :ghpull:`3075`: check for SIGUSR1 before using it, closes #3074
+* :ghpull:`3051`: add width:100% to vbox for webkit / FF consistency
+* :ghpull:`2999`: increase registration timeout
+* :ghpull:`2997`: fix DictDB default size limit
+* :ghpull:`3033`: on resume, print server info again
+* :ghpull:`3062`: test double pyximport
+* :ghpull:`3046`: cast kernel cwd to bytes on Python 2 on Windows
+* :ghpull:`3038`: remove xml from notebook magic docstrings
+* :ghpull:`3032`: fix time format to international time format
+* :ghpull:`3022`: Fix test for Windows
+* :ghpull:`3024`: changed instances of 'outout' to 'output' in alt texts
+* :ghpull:`3013`: py3 workaround for reload in cythonmagic
+* :ghpull:`2961`: time magic: shorten unnecessary output on windows
+* :ghpull:`2987`: fix local files examples in markdown
+* :ghpull:`2998`: fix css in .output_area pre
+* :ghpull:`3003`: add $include /etc/inputrc to suggested ~/.inputrc
+* :ghpull:`2957`: Refactor qt import logic. Fixes #2955
+* :ghpull:`2994`: expanduser on %%file targets
+* :ghpull:`2983`: fix run-all (that-> this)
+* :ghpull:`2964`: fix count when testing composite error output
+* :ghpull:`2967`: shows entire session history when only startsess is given
+* :ghpull:`2942`: Move CM IPython theme out of codemirror folder
+* :ghpull:`2929`: Cleanup cell insertion
+* :ghpull:`2933`: Minordocupdate
+* :ghpull:`2968`: fix notebook deletion.
+* :ghpull:`2966`: Added assert msg to extract_hist_ranges()
+* :ghpull:`2959`: Add command to trim the history database.
+* :ghpull:`2681`: Don't enable pylab mode, when matplotlib is not importable
+* :ghpull:`2901`: Fix inputhook_wx on osx
+* :ghpull:`2871`: truncate potentially long CompositeErrors
+* :ghpull:`2951`: use istype on lists/tuples
+* :ghpull:`2946`: fix qtconsole history logic for end-of-line
+* :ghpull:`2954`: fix logic for append_javascript
+* :ghpull:`2941`: fix baseUrl
+* :ghpull:`2903`: Specify toggle value on cell line number
+* :ghpull:`2911`: display order in output area configurable
+* :ghpull:`2897`: Don't rely on BaseProjectUrl data in body tag
+* :ghpull:`2894`: Cm configurable
+* :ghpull:`2927`: next release will be 1.0
+* :ghpull:`2932`: Simplify using notebook static files from external code
+* :ghpull:`2915`: added small config section to notebook docs page
+* :ghpull:`2924`: safe_run_module: Silence SystemExit codes 0 and None.
+* :ghpull:`2906`: Unpatch/Monkey patch CM
+* :ghpull:`2921`: add menu item for undo delete cell
+* :ghpull:`2917`: Don't add logging handler if one already exists.
+* :ghpull:`2910`: Respect DB_IP and DB_PORT in mongodb tests
+* :ghpull:`2926`: Don't die if stderr/stdout do not support set_parent() #2925
+* :ghpull:`2885`: get monospace pager back
+* :ghpull:`2876`: fix celltoolbar layout on FF
+* :ghpull:`2904`: Skip remaining IPC test on Windows
+* :ghpull:`2908`: fix last remaining KernelApp reference
+* :ghpull:`2905`: fix a few remaining KernelApp/IPKernelApp changes
+* :ghpull:`2900`: Don't assume test case for %time will finish in 0 time
+* :ghpull:`2893`: exclude fabfile from tests
+* :ghpull:`2884`: Correct import for kernelmanager on Windows
+* :ghpull:`2882`: Utils cleanup
+* :ghpull:`2883`: Don't call ast.fix_missing_locations unless the AST could have been modified
+* :ghpull:`2855`: time(it) magic: Implement minutes/hour formatting and "%%time" cell magic
+* :ghpull:`2874`: Empty cell warnings
+* :ghpull:`2819`: tweak history prefix search (up/^p) in qtconsole
+* :ghpull:`2868`: Import performance
+* :ghpull:`2877`: minor css fixes
+* :ghpull:`2880`: update examples docs with kernel move
+* :ghpull:`2878`: Pass host environment on to kernel
+* :ghpull:`2599`: func_kw_complete for builtin and cython with embededsignature=True using docstring
+* :ghpull:`2792`: Add key "unique" to history_request protocol
+* :ghpull:`2872`: fix payload keys
+* :ghpull:`2869`: Fixing styling of toolbar selects on FF.
+* :ghpull:`2708`: Less css
+* :ghpull:`2854`: Move kernel code into IPython.kernel
+* :ghpull:`2864`: Fix %run -t -N<N> TypeError
+* :ghpull:`2852`: future pyzmq compatibility
+* :ghpull:`2863`: whatsnew/version0.9.txt: Fix '~./ipython' -> '~/.ipython' typo
+* :ghpull:`2861`: add missing KernelManager to ConsoleApp class list
+* :ghpull:`2850`: Consolidate host IP detection in utils.localinterfaces
+* :ghpull:`2859`: Correct docstring of ipython.py
+* :ghpull:`2831`: avoid string version comparisons in external.qt
+* :ghpull:`2844`: this should address the failure in #2732
+* :ghpull:`2849`: utils/data: Use list comprehension for uniq_stable()
+* :ghpull:`2839`: add jinja to install docs / setup.py
+* :ghpull:`2841`: Miscellaneous docs fixes
+* :ghpull:`2811`: Still more KernelManager cleanup
+* :ghpull:`2820`: add '=' to greedy completer delims
+* :ghpull:`2818`: log user tracebacks in the kernel (INFO-level)
+* :ghpull:`2828`: Clean up notebook Javascript
+* :ghpull:`2829`: avoid comparison error in dictdb hub history
+* :ghpull:`2830`: BUG: Opening parenthesis after non-callable raises ValueError
+* :ghpull:`2718`: try to fallback to pysqlite2.dbapi2 as sqlite3 in core.history
+* :ghpull:`2816`: in %edit, don't save "last_call" unless last call succeeded
+* :ghpull:`2817`: change ol format order
+* :ghpull:`2537`: Organize example notebooks
+* :ghpull:`2815`: update release/authors
+* :ghpull:`2808`: improve patience for slow Hub in client tests
+* :ghpull:`2812`: remove nonfunctional `-la` short arg in cython magic
+* :ghpull:`2810`: remove dead utils.upgradedir
+* :ghpull:`1671`: __future__ environments
+* :ghpull:`2804`: skip ipc tests on Windows
+* :ghpull:`2789`: Fixing styling issues with CellToolbar.
+* :ghpull:`2805`: fix KeyError creating ZMQStreams in notebook
+* :ghpull:`2775`: General cleanup of kernel manager code.
+* :ghpull:`2340`: Initial Code to reduce parallel.Client caching
+* :ghpull:`2799`: Exit code
+* :ghpull:`2800`: use `type(obj) is cls` as switch when canning
+* :ghpull:`2801`: Fix a breakpoint bug
+* :ghpull:`2795`: Remove outdated code from extensions.autoreload
+* :ghpull:`2796`: P3K: fix cookie parsing under Python 3.x (+ duplicate import is removed)
+* :ghpull:`2724`: In-process kernel support (take 3)
+* :ghpull:`2687`: [WIP] Metaui slideshow
+* :ghpull:`2788`: Chrome frame awareness
+* :ghpull:`2649`: Add version_request/reply messaging protocol
+* :ghpull:`2753`: add `%%px --local` for local execution
+* :ghpull:`2783`: Prefilter shouldn't touch execution_count
+* :ghpull:`2333`: UI For Metadata
+* :ghpull:`2396`: create a ipynbv3 json schema and a validator
+* :ghpull:`2757`: check for complete pyside presence before trying to import
+* :ghpull:`2782`: Allow the %run magic with '-b' to specify a file.
+* :ghpull:`2778`: P3K: fix DeprecationWarning under Python 3.x 
+* :ghpull:`2776`: remove non-functional View.kill method
+* :ghpull:`2755`: can interactively defined classes
+* :ghpull:`2774`: Removing unused code in the notebook MappingKernelManager.
+* :ghpull:`2773`: Fixed minor typo causing AttributeError to be thrown.
+* :ghpull:`2609`: Add 'unique' option to history_request messaging protocol
+* :ghpull:`2769`: Allow shutdown when no engines are registered
+* :ghpull:`2766`: Define __file__ when we %edit a real file.
+* :ghpull:`2476`: allow %edit <variable> to work when interactively defined
+* :ghpull:`2763`: Reset readline delimiters after loading rmagic.
+* :ghpull:`2460`: Better handling of `__file__` when running scripts.
+* :ghpull:`2617`: Fix for `units` argument. Adds a `res` argument.
+* :ghpull:`2738`: Unicode content crashes the pager (console)
+* :ghpull:`2749`: Tell Travis CI to test on Python 3.3 as well
+* :ghpull:`2744`: Don't show 'try %paste' message while using magics
+* :ghpull:`2728`: shift tab for tooltip
+* :ghpull:`2741`: Add note to `%cython` Black-Scholes example warning of missing erf.
+* :ghpull:`2743`: BUG: Octavemagic inline plots not working on Windows: Fixed
+* :ghpull:`2740`: Following #2737 this error is now a name error
+* :ghpull:`2737`: Rmagic: error message when moving an non-existant variable from python to R
+* :ghpull:`2723`: diverse fixes for project url
+* :ghpull:`2731`: %Rpush: Look for variables in the local scope first.
+* :ghpull:`2544`: Infinite loop when multiple debuggers have been attached.
+* :ghpull:`2726`: Add qthelp docs creation
+* :ghpull:`2730`: added blockquote CSS
+* :ghpull:`2729`: Fix Read the doc build, Again
+* :ghpull:`2446`: [alternate 2267] Offline mathjax
+* :ghpull:`2716`: remove unexisting headings level
+* :ghpull:`2717`: One liner to fix debugger printing stack traces when lines of context are larger than source.
+* :ghpull:`2713`: Doc bugfix: user_ns is not an attribute of Magic objects.
+* :ghpull:`2690`: Fix 'import '... completion for py3 & egg files.
+* :ghpull:`2691`: Document OpenMP in %%cython magic
+* :ghpull:`2699`: fix jinja2 rendering for password protected notebooks
+* :ghpull:`2700`: Skip notebook testing if jinja2 is not available.
+* :ghpull:`2692`: Add %%cython magics to generated documentation.
+* :ghpull:`2685`: Fix pretty print of types when `__module__` is not available.
+* :ghpull:`2686`: Fix tox.ini
+* :ghpull:`2604`: Backslashes are misinterpreted as escape-sequences by the R-interpreter.
+* :ghpull:`2689`: fix error in doc (arg->kwarg) and pep-8
+* :ghpull:`2683`: for downloads, replaced window.open with window.location.assign
+* :ghpull:`2659`: small bugs in js are fixed
+* :ghpull:`2363`: Refactor notebook templates to use Jinja2
+* :ghpull:`2662`: qtconsole: wrap argument list in tooltip to match width of text body
+* :ghpull:`2328`: addition of classes to generate a link or list of links from files local to the IPython HTML notebook
+* :ghpull:`2668`: pylab_not_importable: Catch all exceptions, not just RuntimeErrors.
+* :ghpull:`2663`: Fix issue #2660: parsing of help and version arguments
+* :ghpull:`2656`: Fix irunner tests when $PYTHONSTARTUP is set
+* :ghpull:`2312`: Add bracket matching to code cells in notebook
+* :ghpull:`2571`: Start to document Javascript
+* :ghpull:`2641`: undefinied that -> this
+* :ghpull:`2638`: Fix %paste in Python 3 on Mac
+* :ghpull:`2301`: Ast transfomers
+* :ghpull:`2616`: Revamp API docs
+* :ghpull:`2572`: Make 'Paste Above' the default paste behavior.
+* :ghpull:`2574`: Fix #2244
+* :ghpull:`2582`: Fix displaying history when output cache is disabled.
+* :ghpull:`2591`: Fix for Issue #2584 
+* :ghpull:`2526`: Don't kill paramiko tunnels when receiving ^C
+* :ghpull:`2559`: Add psource, pfile, pinfo2 commands to ipdb.
+* :ghpull:`2546`: use 4 Pythons to build 4 Windows installers
+* :ghpull:`2561`: Fix display of plain text containing multiple carriage returns before line feed
+* :ghpull:`2549`: Add a simple 'undo' for cell deletion.
+* :ghpull:`2525`: Add event to kernel execution/shell reply.
+* :ghpull:`2554`: Avoid stopping in ipdb until we reach the main script.
+* :ghpull:`2404`: Option to limit search result in history magic command
+* :ghpull:`2294`: inputhook_qt4: Use QEventLoop instead of starting up the QCoreApplication
+* :ghpull:`2233`: Refactored Drag and Drop Support in Qt Console
+* :ghpull:`1747`: switch between hsplit and vsplit paging (request for feedback)
+* :ghpull:`2530`: Adding time offsets to the video
+* :ghpull:`2542`: Allow starting IPython as `python -m IPython`.
+* :ghpull:`2534`: Do not unescape backslashes in Windows (shellglob)
+* :ghpull:`2517`: Improved MathJax, bug fixes
+* :ghpull:`2511`: trigger default remote_profile_dir when profile_dir is set
+* :ghpull:`2491`: color is supported in ironpython
+* :ghpull:`2462`: Track which extensions are loaded
+* :ghpull:`2464`: Locate URLs in text output and convert them to hyperlinks.
+* :ghpull:`2490`: add ZMQInteractiveShell to IPEngineApp class list
+* :ghpull:`2498`: Don't catch tab press when something selected
+* :ghpull:`2527`: Run All Above and Run All Below
+* :ghpull:`2513`: add GitHub uploads to release script
+* :ghpull:`2529`: Windows aware tests for shellglob
+* :ghpull:`2478`: Fix doctest_run_option_parser for Windows
+* :ghpull:`2519`: clear In[ ] prompt numbers again
+* :ghpull:`2467`: Clickable links
+* :ghpull:`2500`: Add `encoding` attribute to `OutStream` class.
+* :ghpull:`2349`: ENH: added StackExchange-style MathJax filtering
+* :ghpull:`2503`: Fix traceback handling of SyntaxErrors without line numbers.
+* :ghpull:`2492`: add missing 'qtconsole' extras_require
+* :ghpull:`2480`: Add deprecation warnings for sympyprinting
+* :ghpull:`2334`: Make the ipengine monitor the ipcontroller heartbeat and die if the ipcontroller goes down
+* :ghpull:`2479`: use new _winapi instead of removed _subprocess
+* :ghpull:`2474`: fix bootstrap name conflicts
+* :ghpull:`2469`: Treat __init__.pyc same as __init__.py in module_list
+* :ghpull:`2165`: Add -g option to %run to glob expand arguments
+* :ghpull:`2468`: Tell git to ignore __pycache__ directories.
+* :ghpull:`2421`: Some notebook tweaks.
+* :ghpull:`2291`: Remove old plugin system
+* :ghpull:`2127`: Ability to build toolbar in JS 
+* :ghpull:`2445`: changes for ironpython
+* :ghpull:`2420`: Pass ipython_dir to __init__() method of TerminalInteractiveShell's superclass.
+* :ghpull:`2432`: Revert #1831, the `__file__` injection in safe_execfile / safe_execfile_ipy.
+* :ghpull:`2216`: Autochange highlight with cell magics
+* :ghpull:`1946`: Add image message handler in ZMQTerminalInteractiveShell
+* :ghpull:`2424`: skip find_cmd when setting up script magics
+* :ghpull:`2389`: Catch sqlite DatabaseErrors in more places when reading the history database
+* :ghpull:`2395`: Don't catch ImportError when trying to unpack module functions
+* :ghpull:`1868`: enable IPC transport for kernels
+* :ghpull:`2437`: don't let log cleanup prevent engine start
+* :ghpull:`2441`: `sys.maxsize` is the maximum length of a container.
+* :ghpull:`2442`: allow iptest to be interrupted
+* :ghpull:`2240`: fix message built for engine dying during task
+* :ghpull:`2369`: Block until kernel termination after sending a kill signal
+* :ghpull:`2439`: Py3k: Octal (0777 -> 0o777)
+* :ghpull:`2326`: Detachable pager in notebook.
+* :ghpull:`2377`: Fix installation of man pages in Python 3
+* :ghpull:`2407`: add IPython version to message headers
+* :ghpull:`2408`: Fix Issue #2366
+* :ghpull:`2405`: clarify TaskScheduler.hwm doc
+* :ghpull:`2399`: IndentationError display
+* :ghpull:`2400`: Add scroll_to_cell(cell_number) to the notebook
+* :ghpull:`2401`: unmock read-the-docs modules
+* :ghpull:`2311`: always perform requested trait assignments
+* :ghpull:`2393`: New option `n` to limit history search hits
+* :ghpull:`2386`: Adapt inline backend to changes in matplotlib
+* :ghpull:`2392`: Remove suspicious double quote
+* :ghpull:`2387`: Added -L library search path to cythonmagic cell magic
+* :ghpull:`2370`: qtconsole: Create a prompt newline by inserting a new block (w/o formatting)
+* :ghpull:`1715`: Fix for #1688, traceback-unicode issue
+* :ghpull:`2378`: use Singleton.instance() for embed() instead of manual global
+* :ghpull:`2373`: fix missing imports in core.interactiveshell
+* :ghpull:`2368`: remove notification widget leftover
+* :ghpull:`2327`: Parallel: Support get/set of nested objects in view (e.g. dv['a.b'])
+* :ghpull:`2362`: Clean up ProgressBar class in example notebook
+* :ghpull:`2346`: Extra xterm identification in set_term_title
+* :ghpull:`2352`: Notebook: Store the username in a cookie whose name is unique.
+* :ghpull:`2358`: add backport_pr to tools
+* :ghpull:`2365`: fix names of notebooks for download/save
+* :ghpull:`2364`: make clients use 'location' properly (fixes #2361)
+* :ghpull:`2354`: Refactor notebook templates to use Jinja2
+* :ghpull:`2339`: add bash completion example
+* :ghpull:`2345`: Remove references to 'version' no longer in argparse. Github issue #2343.
+* :ghpull:`2347`: adjust division error message checking to account for Python 3
+* :ghpull:`2305`: RemoteError._render_traceback_ calls self.render_traceback
+* :ghpull:`2338`: Normalize line endings for ipexec_validate, fix for #2315.
+* :ghpull:`2192`: Introduce Notification Area
+* :ghpull:`2329`: Better error messages for common magic commands.
+* :ghpull:`2337`: ENH: added StackExchange-style MathJax filtering
+* :ghpull:`2331`: update css for qtconsole in doc
+* :ghpull:`2317`: adding cluster_id to parallel.Client.__init__
+* :ghpull:`2130`: Add -l option to %R magic to allow passing in of local namespace
+* :ghpull:`2196`: Fix for bad command line argument to latex
+* :ghpull:`2300`: bug fix: was crashing when sqlite3 is not installed
+* :ghpull:`2184`: Expose store_history to execute_request messages.
+* :ghpull:`2308`: Add welcome_message option to enable_pylab
+* :ghpull:`2302`: Fix variable expansion on 'self'
+* :ghpull:`2299`: Remove code from prefilter that duplicates functionality in inputsplitter
+* :ghpull:`2295`: allow pip install from github repository directly
+* :ghpull:`2280`: fix SSH passwordless check for OpenSSH
+* :ghpull:`2290`: nbmanager
+* :ghpull:`2288`: s/assertEquals/assertEqual (again)
+* :ghpull:`2287`: Removed outdated dev docs.
+* :ghpull:`2218`: Use redirect for new notebooks
+* :ghpull:`2277`: nb: up/down arrow keys move to begin/end of line at top/bottom of cell
+* :ghpull:`2045`: Refactoring notebook managers and adding Azure backed storage.
+* :ghpull:`2271`: use display instead of send_figure in inline backend hooks
+* :ghpull:`2278`: allow disabling SQLite history
+* :ghpull:`2225`: Add "--annotate" option to `%%cython` magic.
+* :ghpull:`2246`: serialize individual args/kwargs rather than the containers
+* :ghpull:`2274`: CLN: Use name to id mapping of notebooks instead of searching.
+* :ghpull:`2270`: SSHLauncher tweaks
+* :ghpull:`2269`: add missing location when disambiguating controller IP
+* :ghpull:`2263`: Allow docs to build on https://readthedocs.io/
+* :ghpull:`2256`: Adding data publication example notebook.
+* :ghpull:`2255`: better flush iopub with AsyncResults
+* :ghpull:`2261`: Fix: longest_substr([]) -> ''
+* :ghpull:`2260`: fix mpr again
+* :ghpull:`2242`: Document globbing in `%history -g <pattern>`.
+* :ghpull:`2250`: fix html in notebook example
+* :ghpull:`2245`: Fix regression in embed() from pull-request #2096.
+* :ghpull:`2248`: track sha of master in test_pr messages
+* :ghpull:`2238`: Fast tests
+* :ghpull:`2211`: add data publication message
+* :ghpull:`2236`: minor test_pr tweaks
+* :ghpull:`2231`: Improve Image format validation and add html width,height
+* :ghpull:`2232`: Reapply monkeypatch to inspect.findsource()
+* :ghpull:`2235`: remove spurious print statement from setupbase.py
+* :ghpull:`2222`: adjust how canning deals with import strings
+* :ghpull:`2224`: fix css typo
+* :ghpull:`2223`: Custom tracebacks
+* :ghpull:`2214`: use KernelApp.exec_lines/files in IPEngineApp
+* :ghpull:`2199`: Wrap JS published by %%javascript in try/catch
+* :ghpull:`2212`: catch errors in markdown javascript
+* :ghpull:`2190`: Update code mirror 2.22 to 2.32
+* :ghpull:`2200`: documentation build broken in bb429da5b
+* :ghpull:`2194`: clean nan/inf in json_clean
+* :ghpull:`2198`: fix mpr for earlier git version
+* :ghpull:`2175`: add FileFindHandler for Notebook static files
+* :ghpull:`1990`: can func_defaults
+* :ghpull:`2069`: start improving serialization in parallel code
+* :ghpull:`2202`: Create a unique & temporary IPYTHONDIR for each testing group.
+* :ghpull:`2204`: Work around lack of os.kill in win32.
+* :ghpull:`2148`: win32 iptest: Use subprocess.Popen() instead of os.system().
+* :ghpull:`2179`: Pylab switch
+* :ghpull:`2124`: Add an API for registering magic aliases.
+* :ghpull:`2169`: ipdb: pdef, pdoc, pinfo magics all broken
+* :ghpull:`2174`: Ensure consistent indentation in `%magic`.
+* :ghpull:`1930`: add size-limiting to the DictDB backend
+* :ghpull:`2189`: Fix IPython.lib.latextools for Python 3
+* :ghpull:`2186`: removed references to h5py dependence in octave magic documentation
+* :ghpull:`2183`: Include the kernel object in the event object passed to kernel events
+* :ghpull:`2185`: added test for %store, fixed storemagic
+* :ghpull:`2138`: Use breqn.sty in dvipng backend if possible
+* :ghpull:`2182`: handle undefined param in notebooklist
+* :ghpull:`1831`: fix #1814 set __file__ when running .ipy files
+* :ghpull:`2051`: Add a metadata attribute to messages
+* :ghpull:`1471`: simplify IPython.parallel connections and enable Controller Resume
+* :ghpull:`2181`: add %%javascript, %%svg, and %%latex display magics
+* :ghpull:`2116`: different images in 00_notebook-tour
+* :ghpull:`2092`: %prun: Restore `stats.stream` after running `print_stream`.
+* :ghpull:`2159`: show message on notebook list if server is unreachable
+* :ghpull:`2176`: fix git mpr
+* :ghpull:`2152`: [qtconsole] Namespace not empty at startup
+* :ghpull:`2177`: remove numpy install from travis/tox scripts
+* :ghpull:`2090`: New keybinding for code cell execution + cell insertion
+* :ghpull:`2160`: Updating the parallel options pricing example
+* :ghpull:`2168`: expand line in cell magics
+* :ghpull:`2170`: Fix tab completion with IPython.embed_kernel().
+* :ghpull:`2096`: embed(): Default to the future compiler flags of the calling frame.
+* :ghpull:`2163`: fix 'remote_profie_dir' typo in SSH launchers
+* :ghpull:`2158`: [2to3 compat ] Tuple params in func defs
+* :ghpull:`2089`: Fix unittest DeprecationWarnings
+* :ghpull:`2142`: Refactor test_pr.py
+* :ghpull:`2140`: 2to3: Apply `has_key` fixer.
+* :ghpull:`2131`: Add option append (-a) to %save
+* :ghpull:`2117`: use explicit url in notebook example
+* :ghpull:`2133`: Tell git that ``*.py`` files contain Python code, for use in word-diffs.
+* :ghpull:`2134`: Apply 2to3 `next` fix.
+* :ghpull:`2126`: ipcluster broken with any batch launcher (PBS/LSF/SGE)
+* :ghpull:`2104`: Windows make file for Sphinx documentation
+* :ghpull:`2074`: Make BG color of inline plot configurable
+* :ghpull:`2123`: BUG: Look up the `_repr_pretty_` method on the class within the MRO rath...
+* :ghpull:`2100`: [in progress] python 2 and 3 compatibility without 2to3, second try
+* :ghpull:`2128`: open notebook copy in different tabs
+* :ghpull:`2073`: allows password and prefix for notebook
+* :ghpull:`1993`: Print View
+* :ghpull:`2086`: re-aliad %ed to %edit in qtconsole
+* :ghpull:`2110`: Fixes and improvements to the input splitter
+* :ghpull:`2101`: fix completer deletting newline
+* :ghpull:`2102`: Fix logging on interactive shell.
+* :ghpull:`2088`: Fix (some) Python 3.2 ResourceWarnings
+* :ghpull:`2064`: conform to pep 3110
+* :ghpull:`2076`: Skip notebook 'static' dir in test suite.
+* :ghpull:`2063`: Remove umlauts so py3 installations on LANG=C systems succeed.
+* :ghpull:`2068`: record sysinfo in sdist
+* :ghpull:`2067`: update tools/release_windows.py
+* :ghpull:`2065`: Fix parentheses typo
+* :ghpull:`2062`: Remove duplicates and auto-generated files from repo.
+* :ghpull:`2061`: use explicit tuple in exception
+* :ghpull:`2060`: change minus to \- or \(hy in manpages
+
+Issues (691):
+
+* :ghissue:`3940`: Install process documentation overhaul 
+* :ghissue:`3946`: The PDF option for `--post` should work with lowercase 
+* :ghissue:`3957`: Notebook help page broken in Firefox
+* :ghissue:`3894`: nbconvert test failure
+* :ghissue:`3887`: 1.0.0a1 shows blank screen in both firefox and chrome (windows 7)
+* :ghissue:`3703`: `nbconvert`: Output options -- names and documentation
+* :ghissue:`3931`: Tab completion not working during debugging in the notebook
+* :ghissue:`3936`: Ipcluster plugin is not working with Ipython 1.0dev
+* :ghissue:`3941`: IPython Notebook kernel crash on Win7x64
+* :ghissue:`3926`: Ending Notebook renaming dialog with return creates new-line
+* :ghissue:`3932`: Incorrect empty docstring
+* :ghissue:`3928`: Passing variables to script from the workspace
+* :ghissue:`3774`: Notebooks with spaces in their names breaks nbconvert latex graphics
+* :ghissue:`3916`: tornado needs its own check
+* :ghissue:`3915`: Link to Parallel examples "found on GitHub" broken in docs
+* :ghissue:`3895`: Keyboard shortcuts box in notebook doesn't fit the screen
+* :ghissue:`3912`: IPython.utils fails automated test for RC1 1.0.0
+* :ghissue:`3636`: Code cell missing highlight on load
+* :ghissue:`3897`: under Windows, "ipython3 nbconvert "C:/blabla/first_try.ipynb" --to latex --post PDF" POST processing action fails because of a bad parameter
+* :ghissue:`3900`: python3 install syntax errors (OS X 10.8.4)
+* :ghissue:`3899`: nbconvert to latex fails on notebooks with spaces in file name
+* :ghissue:`3881`: Temporary Working Directory Test Fails
+* :ghissue:`2750`: A way to freeze code cells in the notebook
+* :ghissue:`3893`: Resize Local Image Files in Notebook doesn't work
+* :ghissue:`3823`: nbconvert on windows: tex and paths
+* :ghissue:`3885`: under Windows, "ipython3 nbconvert "C:/blabla/first_try.ipynb" --to latex" write "\" instead of "/" to reference file path in the .tex file
+* :ghissue:`3889`: test_qt fails due to assertion error 'qt4' != 'qt'
+* :ghissue:`3890`: double post, disregard this issue
+* :ghissue:`3689`: nbconvert, remaining tests
+* :ghissue:`3874`: Up/Down keys don't work to "Search previous command history" (besides Ctrl-p/Ctrl-n)
+* :ghissue:`3853`: CodeMirror locks up in the notebook
+* :ghissue:`3862`: can only connect to an ipcluster started with v1.0.0-dev (master branch) using an older ipython (v0.13.2), but cannot connect using ipython (v1.0.0-dev)
+* :ghissue:`3869`: custom css not working. 
+* :ghissue:`2960`: Keyboard shortcuts
+* :ghissue:`3795`: ipcontroller process goes to 100% CPU, ignores connection requests
+* :ghissue:`3553`: Ipython and pylab crashes in windows and canopy
+* :ghissue:`3837`: Cannot set custom mathjax url, crash notebook server.
+* :ghissue:`3808`: "Naming" releases ?
+* :ghissue:`2431`: TypeError: must be string without null bytes, not str
+* :ghissue:`3856`: `?` at end of comment causes line to execute
+* :ghissue:`3731`: nbconvert: add logging for the different steps of nbconvert
+* :ghissue:`3835`: Markdown cells do not render correctly when mathjax is disabled
+* :ghissue:`3843`: nbconvert to rst: leftover "In[ ]"
+* :ghissue:`3799`: nbconvert: Ability to specify name of output file
+* :ghissue:`3726`: Document when IPython.start_ipython() should be used versus IPython.embed()
+* :ghissue:`3778`: Add no more readonly view in what's new
+* :ghissue:`3754`: No Print View in Notebook in 1.0dev
+* :ghissue:`3798`: IPython 0.12.1 Crashes on autocompleting sqlalchemy.func.row_number properties
+* :ghissue:`3811`: Opening notebook directly from the command line with multi-directory support installed
+* :ghissue:`3775`: Annoying behavior when clicking on cell after execution (Ctrl+Enter)
+* :ghissue:`3809`: Possible to add some bpython features?
+* :ghissue:`3810`: Printing the contents of an image file messes up shell text
+* :ghissue:`3702`: `nbconvert`: Default help message should be that of --help
+* :ghissue:`3735`: Nbconvert 1.0.0a1 does not take into account the pdf extensions in graphs
+* :ghissue:`3719`: Bad strftime format, for windows, in nbconvert exporter 
+* :ghissue:`3786`: Zmq errors appearing with `Ctrl-C` in console/qtconsole
+* :ghissue:`3019`: disappearing scrollbar on tooltip in Chrome 24 on Ubuntu 12.04
+* :ghissue:`3785`: ipdb completely broken in Qt console
+* :ghissue:`3796`: Document the meaning of milestone/issues-tags for users.
+* :ghissue:`3788`: Do not auto show tooltip if docstring empty.
+* :ghissue:`1366`: [Web page] No link to front page from documentation
+* :ghissue:`3739`: nbconvert (to slideshow) misses some of the math in markdown cells
+* :ghissue:`3768`: increase and make timeout configurable in console completion.
+* :ghissue:`3724`: ipcluster only running on one cpu
+* :ghissue:`1592`: better message for unsupported nbformat
+* :ghissue:`2049`: Can not stop "ipython kernel" on windows
+* :ghissue:`3757`: Need direct entry point to given notebook 
+* :ghissue:`3745`: ImportError: cannot import name check_linecache_ipython
+* :ghissue:`3701`: `nbconvert`: Final output file should be in same directory as input file
+* :ghissue:`3738`: history -o works but history with -n produces identical results
+* :ghissue:`3740`: error when attempting to run 'make' in docs directory
+* :ghissue:`3737`: ipython nbconvert crashes with ValueError: Invalid format string.
+* :ghissue:`3730`: nbconvert: unhelpful error when pandoc isn't installed
+* :ghissue:`3718`: markdown cell cursor misaligned in notebook
+* :ghissue:`3710`: multiple input fields for %debug in the notebook after resetting the kernel
+* :ghissue:`3713`: PyCharm has problems with IPython working inside PyPy created by virtualenv
+* :ghissue:`3712`: Code completion: Complete on dictionary keys
+* :ghissue:`3680`: --pylab and --matplotlib flag
+* :ghissue:`3698`: nbconvert: Unicode error with minus sign
+* :ghissue:`3693`: nbconvert does not process SVGs into PDFs
+* :ghissue:`3688`: nbconvert, figures not extracting with Python 3.x
+* :ghissue:`3542`: note new dependencies in docs / setup.py
+* :ghissue:`2556`: [pagedown] do not target_blank anchor link
+* :ghissue:`3684`: bad message when %pylab fails due import *other* than matplotlib
+* :ghissue:`3682`: ipython notebook pylab inline  import_all=False 
+* :ghissue:`3596`: MathjaxUtils race condition?
+* :ghissue:`1540`: Comment/uncomment selection in notebook
+* :ghissue:`2702`: frozen setup: permission denied for default ipython_dir
+* :ghissue:`3672`: allow_none on Number-like traits.
+* :ghissue:`2411`: add CONTRIBUTING.md
+* :ghissue:`481`: IPython terminal issue with Qt4Agg on XP SP3
+* :ghissue:`2664`: How to preserve user variables from import clashing?
+* :ghissue:`3436`: enable_pylab(import_all=False) still imports np
+* :ghissue:`2630`: lib.pylabtools.figsize : NameError when using Qt4Agg backend and %pylab magic. 
+* :ghissue:`3154`: Notebook: no event triggered when a Cell is created
+* :ghissue:`3579`: Nbconvert: SVG are not transformed to PDF anymore
+* :ghissue:`3604`: MathJax rendering problem in `%%latex` cell
+* :ghissue:`3668`: AttributeError: 'BlockingKernelClient' object has no attribute 'started_channels'
+* :ghissue:`3245`: SyntaxError: encoding declaration in Unicode string
+* :ghissue:`3639`: %pylab inline in IPYTHON notebook throws "RuntimeError: Cannot activate multiple GUI eventloops"
+* :ghissue:`3663`: frontend deprecation warnings
+* :ghissue:`3661`: run -m not behaving like python -m 
+* :ghissue:`3597`: re-do PR #3531 - allow markdown in Header cell
+* :ghissue:`3053`: Markdown in header cells is not rendered
+* :ghissue:`3655`: IPython finding its way into pasted strings. 
+* :ghissue:`3620`: uncaught errors in HTML output
+* :ghissue:`3646`: get_dict() error
+* :ghissue:`3004`: `%load_ext rmagic` fails when legacy ipy_user_conf.py is installed (in ipython 0.13.1 / OSX 10.8)
+* :ghissue:`3638`: setp() issue in ipython notebook with figure references
+* :ghissue:`3634`: nbconvert reveal to pdf conversion ignores styling, prints only a single page.
+* :ghissue:`1307`: Remove pyreadline workarounds, we now require pyreadline >= 1.7.1
+* :ghissue:`3316`: find_cmd test failure on Windows
+* :ghissue:`3494`: input() in notebook doesn't work in Python 3
+* :ghissue:`3427`: Deprecate `$` as mathjax delimiter
+* :ghissue:`3625`: Pager does not open from button
+* :ghissue:`3149`: Miscellaneous small nbconvert feedback
+* :ghissue:`3617`: 256 color escapes support
+* :ghissue:`3609`: %pylab inline blows up for single process ipython
+* :ghissue:`2934`: Publish the Interactive MPI Demo Notebook
+* :ghissue:`3614`: ansi escapes broken in master (ls --color)
+* :ghissue:`3610`: If you don't have markdown, python setup.py install says no pygments
+* :ghissue:`3547`: %run modules clobber each other
+* :ghissue:`3602`: import_item fails when one tries to use DottedObjectName instead of a string
+* :ghissue:`3563`: Duplicate tab completions in the notebook
+* :ghissue:`3599`: Problems trying to run IPython on python3 without installing...
+* :ghissue:`2937`: too long completion in notebook
+* :ghissue:`3479`: Write empty name for the notebooks
+* :ghissue:`3505`: nbconvert: Failure in specifying user filter
+* :ghissue:`1537`: think a bit about namespaces
+* :ghissue:`3124`: Long multiline strings in Notebook
+* :ghissue:`3464`: run -d message unclear
+* :ghissue:`2706`: IPython 0.13.1 ignoring $PYTHONSTARTUP
+* :ghissue:`3587`: LaTeX escaping bug in nbconvert when exporting to HTML
+* :ghissue:`3213`: Long running notebook died with a coredump
+* :ghissue:`3580`: Running ipython with pypy on windows
+* :ghissue:`3573`: custom.js not working
+* :ghissue:`3544`: IPython.lib test failure on Windows
+* :ghissue:`3352`: Install Sphinx extensions
+* :ghissue:`2971`: [notebook]user needs to press ctrl-c twice to stop notebook server should be put into terminal window
+* :ghissue:`2413`: ipython3 qtconsole fails to install: ipython 0.13 has no such extra feature 'qtconsole' 
+* :ghissue:`2618`: documentation is incorrect for install process
+* :ghissue:`2595`: mac 10.8 qtconsole export history
+* :ghissue:`2586`: cannot store aliases
+* :ghissue:`2714`: ipython qtconsole print unittest messages in console instead his own window. 
+* :ghissue:`2669`: cython magic failing to work with openmp.
+* :ghissue:`3256`: Vagrant pandas instance of IPython Notebook does not respect additional plotting arguments
+* :ghissue:`3010`: cython magic fail if cache dir is deleted while in session
+* :ghissue:`2044`: prune unused names from parallel.error
+* :ghissue:`1145`: Online help utility broken in QtConsole
+* :ghissue:`3439`: Markdown links no longer open in new window (with change from pagedown to marked)
+* :ghissue:`3476`:  _margv  for macros seems to be missing
+* :ghissue:`3499`: Add reveal.js library (version 2.4.0) inside IPython
+* :ghissue:`2771`: Wiki Migration to GitHub
+* :ghissue:`2887`: ipcontroller purging some engines during connect
+* :ghissue:`626`: Enable Resuming Controller
+* :ghissue:`2824`: Kernel restarting after message "Kernel XXXX failed to respond to heartbeat"
+* :ghissue:`2823`: %%cython magic gives ImportError: dlopen(long_file_name.so, 2): image not found
+* :ghissue:`2891`: In IPython for Python 3, system site-packages comes before user site-packages
+* :ghissue:`2928`: Add magic "watch" function (example)
+* :ghissue:`2931`: Problem rendering pandas dataframe in  Firefox for Windows
+* :ghissue:`2939`: [notebook] Figure legend not shown in inline backend if ouside the box of the axes
+* :ghissue:`2972`: [notebook] in Markdown mode, press Enter key at the end of <some http link>, the next line is indented unexpectly
+* :ghissue:`3069`: Instructions for installing IPython notebook on Windows
+* :ghissue:`3444`: Encoding problem: cannot use if user's name is not ascii?
+* :ghissue:`3335`: Reenable bracket matching
+* :ghissue:`3386`: Magic %paste not working in Python 3.3.2. TypeError: Type str doesn't support the buffer API
+* :ghissue:`3543`: Exception shutting down kernel from notebook dashboard (0.13.1)
+* :ghissue:`3549`: Codecell size changes with selection
+* :ghissue:`3445`: Adding newlines in %%latex cell
+* :ghissue:`3237`: [notebook] Can't close a notebook without errors
+* :ghissue:`2916`: colon invokes auto(un)indent in markdown cells
+* :ghissue:`2167`: Indent and dedent in htmlnotebook
+* :ghissue:`3545`: Notebook save button icon not clear
+* :ghissue:`3534`: nbconvert incompatible with Windows?
+* :ghissue:`3489`: Update example notebook that raw_input is allowed
+* :ghissue:`3396`: Notebook checkpoint time is displayed an hour out
+* :ghissue:`3261`: Empty revert to checkpoint menu if no checkpoint...
+* :ghissue:`2984`: "print" magic does not work in Python 3
+* :ghissue:`3524`: Issues with pyzmq and ipython on EPD update
+* :ghissue:`2434`: %store magic not auto-restoring
+* :ghissue:`2720`: base_url and static path
+* :ghissue:`2234`: Update various low resolution graphics for retina displays
+* :ghissue:`2842`: Remember passwords for pw-protected notebooks
+* :ghissue:`3244`: qtconsole: ValueError('close_fds is not supported on Windows platforms if you redirect stdin/stdout/stderr',)
+* :ghissue:`2215`: AsyncResult.wait(0) can hang waiting for the client to get results?
+* :ghissue:`2268`: provide mean to retrieve static data path
+* :ghissue:`1905`: Expose UI for worksheets within each notebook
+* :ghissue:`2380`: Qt inputhook prevents modal dialog boxes from displaying
+* :ghissue:`3185`: prettify on double //
+* :ghissue:`2821`: Test failure: IPython.parallel.tests.test_client.test_resubmit_header
+* :ghissue:`2475`: [Notebook] Line is deindented when typing eg a colon in markdown mode
+* :ghissue:`2470`: Do not destroy valid notebooks
+* :ghissue:`860`: Allow the standalone export of a notebook to HTML
+* :ghissue:`2652`: notebook with qt backend crashes at save image location popup
+* :ghissue:`1587`: Improve kernel restarting in the notebook
+* :ghissue:`2710`: Saving a plot in Mac OS X backend crashes IPython
+* :ghissue:`2596`: notebook "Last saved:" is misleading on file opening.
+* :ghissue:`2671`: TypeError :NoneType when executed "ipython qtconsole" in windows console
+* :ghissue:`2703`: Notebook scrolling breaks after pager is shown
+* :ghissue:`2803`: KernelManager and KernelClient should be two separate objects
+* :ghissue:`2693`: TerminalIPythonApp configuration fails without ipython_config.py
+* :ghissue:`2531`: IPython 0.13.1 python 2 32-bit installer includes 64-bit ipython*.exe launchers in the scripts folder
+* :ghissue:`2520`: Control-C kills port forwarding
+* :ghissue:`2279`: Setting `__file__` to None breaks Mayavi import
+* :ghissue:`2161`: When logged into notebook, long titles are incorrectly positioned
+* :ghissue:`1292`: Notebook, Print view should not be editable...
+* :ghissue:`1731`: test parallel launchers
+* :ghissue:`3227`: Improve documentation of ipcontroller and possible BUG
+* :ghissue:`2896`: IPController very unstable
+* :ghissue:`3517`: documentation build broken in head
+* :ghissue:`3522`: UnicodeDecodeError: 'ascii' codec can't decode byte on Pycharm on Windows
+* :ghissue:`3448`: Please include MathJax fonts with IPython Notebook
+* :ghissue:`3519`: IPython Parallel map mysteriously turns pandas Series into numpy ndarray
+* :ghissue:`3345`: IPython embedded shells ask if I want to exit, but I set confirm_exit = False
+* :ghissue:`3509`: IPython won't close without asking "Are you sure?" in Firefox 
+* :ghissue:`3471`: Notebook jinja2/markupsafe dependencies in manual
+* :ghissue:`3502`: Notebook broken in master
+* :ghissue:`3302`: autoreload does not work in ipython 0.13.x, python 3.3
+* :ghissue:`3475`: no warning when leaving/closing notebook on master without saved changes
+* :ghissue:`3490`: No obvious feedback when kernel crashes
+* :ghissue:`1912`: Move all autoreload tests to their own group
+* :ghissue:`2577`: sh.py and ipython for python 3.3
+* :ghissue:`3467`: %magic doesn't work
+* :ghissue:`3501`: Editing markdown cells that wrap has off-by-one errors in cursor positioning
+* :ghissue:`3492`: IPython for Python3
+* :ghissue:`3474`: unexpected keyword argument to remove_kernel
+* :ghissue:`2283`: TypeError when using '?' after a string in a %logstart session
+* :ghissue:`2787`: rmagic and pandas DataFrame
+* :ghissue:`2605`: Ellipsis literal triggers AttributeError
+* :ghissue:`1179`: Test unicode source in pinfo
+* :ghissue:`2055`: drop Python 3.1 support
+* :ghissue:`2293`: IPEP 2: Input transformations
+* :ghissue:`2790`: %paste and %cpaste not removing "..." lines
+* :ghissue:`3480`: Testing fails because iptest.py cannot be found
+* :ghissue:`2580`: will not run within PIL build directory
+* :ghissue:`2797`: RMagic, Dataframe Conversion Problem 
+* :ghissue:`2838`: Empty lines disappear from triple-quoted literals.
+* :ghissue:`3050`: Broken link on IPython.core.display page
+* :ghissue:`3473`: Config not passed down to subcommands
+* :ghissue:`3462`: Setting log_format in config file results in error (and no format changes)
+* :ghissue:`3311`: Notebook (occasionally) not working on windows (Sophos AV)
+* :ghissue:`3461`: Cursor positioning off by a character in auto-wrapped lines
+* :ghissue:`3454`:  _repr_html_ error
+* :ghissue:`3457`: Space in long Paragraph Markdown cell with Chinese or Japanese
+* :ghissue:`3447`: Run Cell Does not Work
+* :ghissue:`1373`: Last lines in long cells are hidden
+* :ghissue:`1504`: Revisit serialization in IPython.parallel
+* :ghissue:`1459`: Can't connect to 2 HTTPS notebook servers on the same host
+* :ghissue:`678`: Input prompt stripping broken with multiline data structures
+* :ghissue:`3001`: IPython.notebook.dirty flag is not set when a cell has unsaved changes
+* :ghissue:`3077`: Multiprocessing semantics in parallel.view.map
+* :ghissue:`3056`: links across notebooks
+* :ghissue:`3120`: Tornado 3.0
+* :ghissue:`3156`: update pretty to use Python 3 style for sets
+* :ghissue:`3197`: Can't escape multiple dollar signs in a markdown cell
+* :ghissue:`3309`: `Image()` signature/doc improvements
+* :ghissue:`3415`: Bug in IPython/external/path/__init__.py 
+* :ghissue:`3446`: Feature suggestion: Download matplotlib figure to client browser
+* :ghissue:`3295`: autoexported notebooks: only export explicitly marked cells
+* :ghissue:`3442`: Notebook: Summary table extracted from markdown headers
+* :ghissue:`3438`: Zooming notebook in chrome is broken in master 
+* :ghissue:`1378`: Implement autosave in notebook
+* :ghissue:`3437`: Highlighting matching parentheses
+* :ghissue:`3435`: module search segfault
+* :ghissue:`3424`: ipcluster --version
+* :ghissue:`3434`: 0.13.2 Ipython/genutils.py doesn't exist
+* :ghissue:`3426`: Feature request: Save by cell and not by line #: IPython %save magic
+* :ghissue:`3412`: Non Responsive Kernel: Running a Django development server from an IPython Notebook
+* :ghissue:`3408`: Save cell toolbar and slide type metadata in notebooks
+* :ghissue:`3246`: %paste regression with blank lines
+* :ghissue:`3404`: Weird error with $variable and grep in command line magic (!command)
+* :ghissue:`3405`: Key auto-completion in dictionaries?
+* :ghissue:`3259`: Codemirror linenumber css broken
+* :ghissue:`3397`: Vertical text misalignment in Markdown cells
+* :ghissue:`3391`: Revert #3358 once fix integrated into CM
+* :ghissue:`3360`: Error 500 while saving IPython notebook
+* :ghissue:`3375`: Frequent Safari/Webkit crashes
+* :ghissue:`3365`: zmq frontend
+* :ghissue:`2654`: User_expression issues
+* :ghissue:`3389`: Store history as plain text
+* :ghissue:`3388`: Ipython parallel: open TCP connection created for each result returned from engine
+* :ghissue:`3385`: setup.py failure on Python 3
+* :ghissue:`3376`: Setting `__module__` to None breaks pretty printing
+* :ghissue:`3374`: ipython qtconsole does not display the prompt on OSX
+* :ghissue:`3380`: simple call to kernel
+* :ghissue:`3379`: TaskRecord key 'started' not set
+* :ghissue:`3241`: notebook connection time out
+* :ghissue:`3334`: magic interpreter interprets non magic commands?
+* :ghissue:`3326`: python3.3: Type error when launching SGE cluster in IPython notebook
+* :ghissue:`3349`: pip3 doesn't run 2to3?
+* :ghissue:`3347`: Longlist support in ipdb
+* :ghissue:`3343`: Make pip install / easy_install faster
+* :ghissue:`3337`: git submodules broke nightly PPA builds
+* :ghissue:`3206`: Copy/Paste Regression in QtConsole
+* :ghissue:`3329`: Buggy linewrap in Mac OSX Terminal (Mountain Lion)
+* :ghissue:`3327`: Qt version check broken
+* :ghissue:`3303`: parallel tasks never finish under heavy load
+* :ghissue:`1381`: '\\' for equation continuations require an extra '\' in markdown cells
+* :ghissue:`3314`: Error launching IPython
+* :ghissue:`3306`: Test failure when running on a Vagrant VM
+* :ghissue:`3280`: IPython.utils.process.getoutput returns stderr
+* :ghissue:`3299`: variables named _ or __ exhibit incorrect behavior
+* :ghissue:`3196`: add an "x" or similar to htmlnotebook pager
+* :ghissue:`3293`: Several 404 errors for js files Firefox
+* :ghissue:`3292`: syntax highlighting in chrome on OSX 10.8.3
+* :ghissue:`3288`: Latest dev version hangs on page load
+* :ghissue:`3283`: ipython dev retains directory information after directory change
+* :ghissue:`3279`: custom.css is not overridden in the dev IPython (1.0)
+* :ghissue:`2727`: %run -m doesn't support relative imports
+* :ghissue:`3268`: GFM triple backquote and unknown language
+* :ghissue:`3273`: Suppressing all plot related outputs
+* :ghissue:`3272`: Backspace while completing load previous page
+* :ghissue:`3260`: Js error in savewidget
+* :ghissue:`3247`: scrollbar in notebook when not needed?
+* :ghissue:`3243`: notebook: option to view json source from browser
+* :ghissue:`3265`: 404 errors when running IPython 1.0dev 
+* :ghissue:`3257`: setup.py not finding submodules
+* :ghissue:`3253`: Incorrect Qt and PySide version comparison
+* :ghissue:`3248`: Cell magics broken in Qt console
+* :ghissue:`3012`: Problems with the less based style.min.css
+* :ghissue:`2390`: Image width/height don't work in embedded images
+* :ghissue:`3236`: cannot set TerminalIPythonApp.log_format
+* :ghissue:`3214`: notebook kernel dies if started with invalid parameter
+* :ghissue:`2980`: Remove HTMLCell ?
+* :ghissue:`3128`: qtconsole hangs on importing pylab (using X forwarding)
+* :ghissue:`3198`: Hitting recursive depth causing all notebook pages to hang
+* :ghissue:`3218`: race conditions in profile directory creation
+* :ghissue:`3177`: OverflowError execption in handlers.py
+* :ghissue:`2563`: core.profiledir.check_startup_dir() doesn't work inside py2exe'd installation
+* :ghissue:`3207`: [Feature] folders for ipython notebook dashboard
+* :ghissue:`3178`: cell magics do not work with empty lines after #2447
+* :ghissue:`3204`: Default plot() colors unsuitable for red-green colorblind users
+* :ghissue:`1789`: ``:\n/*foo`` turns into ``:\n*(foo)`` in triple-quoted strings.
+* :ghissue:`3202`: File cell magic fails with blank lines
+* :ghissue:`3199`: %%cython -a stopped working?
+* :ghissue:`2688`: obsolete imports in import autocompletion
+* :ghissue:`3192`: Python2, Unhandled exception, __builtin__.True = False
+* :ghissue:`3179`: script magic error message loop
+* :ghissue:`3009`: use XDG_CACHE_HOME for cython objects
+* :ghissue:`3059`: Bugs in 00_notebook_tour example.
+* :ghissue:`3104`: Integrate a javascript file manager into the notebook front end
+* :ghissue:`3176`: Particular equation not rendering  (notebook)
+* :ghissue:`1133`: [notebook] readonly and upload files/UI
+* :ghissue:`2975`: [notebook] python file and cell toolbar
+* :ghissue:`3017`: SciPy.weave broken in IPython notebook/ qtconsole 
+* :ghissue:`3161`: paste macro not reading spaces correctly
+* :ghissue:`2835`: %paste not working on WinXpSP3/ipython-0.13.1.py2-win32-PROPER.exe/python27
+* :ghissue:`2628`: Make transformers work for lines following decorators
+* :ghissue:`2612`: Multiline String containing ":\n?foo\n" confuses interpreter to replace ?foo with get_ipython().magic(u'pinfo foo')
+* :ghissue:`2539`: Request: Enable cell magics inside of .ipy scripts
+* :ghissue:`2507`: Multiline string does not work (includes `...`) with doctest type input in IPython notebook
+* :ghissue:`2164`: Request: Line breaks in line magic command
+* :ghissue:`3106`: poor parallel performance with many jobs
+* :ghissue:`2438`: print inside multiprocessing crashes Ipython kernel
+* :ghissue:`3155`: Bad md5 hash for package 0.13.2
+* :ghissue:`3045`: [Notebook] Ipython Kernel does not start if disconnected from internet(/network?)
+* :ghissue:`3146`: Using celery in python 3.3
+* :ghissue:`3145`: The notebook viewer is down
+* :ghissue:`2385`: grep --color not working well with notebook
+* :ghissue:`3131`: Quickly install from source in a clean virtualenv?
+* :ghissue:`3139`: Rolling log for ipython
+* :ghissue:`3127`: notebook with pylab=inline appears to call figure.draw twice
+* :ghissue:`3129`: Walking up and down the call stack
+* :ghissue:`3123`: Notebook crashed if unplugged ethernet cable
+* :ghissue:`3121`: NB should use normalize.css? was #3049
+* :ghissue:`3087`: Disable spellchecking in notebook
+* :ghissue:`3084`: ipython pyqt 4.10 incompatibilty, QTextBlockUserData
+* :ghissue:`3113`: Fails to install under Jython 2.7 beta
+* :ghissue:`3110`: Render of h4 headers is not correct in notebook (error in renderedhtml.css)
+* :ghissue:`3109`: BUG: read_csv: dtype={'id' : np.str}: Datatype not understood
+* :ghissue:`3107`: Autocompletion of object attributes in arrays
+* :ghissue:`3103`: Reset locale setting in qtconsole
+* :ghissue:`3090`: python3.3 Entry Point not found
+* :ghissue:`3081`: UnicodeDecodeError when using Image(data="some.jpeg")
+* :ghissue:`2834`: url regexp only finds one link
+* :ghissue:`3091`: qtconsole breaks doctest.testmod() in Python 3.3
+* :ghissue:`3074`: SIGUSR1 not available on Windows
+* :ghissue:`2996`: registration::purging stalled registration high occurrence in small clusters 
+* :ghissue:`3065`: diff-ability of notebooks
+* :ghissue:`3067`: Crash with pygit2
+* :ghissue:`3061`: Bug handling Ellipsis
+* :ghissue:`3049`: NB css inconsistent behavior between ff and webkit
+* :ghissue:`3039`: unicode errors when opening a new notebook
+* :ghissue:`3048`: Installning ipython qtConsole should be easyer att Windows
+* :ghissue:`3042`: Profile creation fails on 0.13.2 branch
+* :ghissue:`3035`: docstring typo/inconsistency: mention of an xml notebook format?
+* :ghissue:`3031`: HDF5 library segfault (possibly due to mismatching headers?)
+* :ghissue:`2991`: In notebook importing sympy closes ipython kernel
+* :ghissue:`3027`: f.__globals__ causes an error in Python 3.3
+* :ghissue:`3020`: Failing test test_interactiveshell.TestAstTransform on Windows
+* :ghissue:`3023`: alt text for "click to expand output" has typo in alt text
+* :ghissue:`2963`: %history to print all input history of a  previous session when line range is omitted
+* :ghissue:`3018`: IPython installed within virtualenv. WARNING "Please install IPython inside the virtualtenv"
+* :ghissue:`2484`: Completion in Emacs *Python* buffer causes prompt to be increased.
+* :ghissue:`3014`: Ctrl-C finishes notebook immediately
+* :ghissue:`3007`: cython_pyximport reload broken in python3
+* :ghissue:`2955`: Incompatible Qt imports when running inprocess_qtconsole
+* :ghissue:`3006`: [IPython 0.13.1] The check of PyQt version is wrong
+* :ghissue:`3005`: Renaming a notebook to an existing notebook name overwrites the other file
+* :ghissue:`2940`: Abort trap in IPython Notebook after installing matplotlib
+* :ghissue:`3000`: issue #3000
+* :ghissue:`2995`: ipython_directive.py fails on multiline when prompt number < 100
+* :ghissue:`2993`: File magic (%%file) does not work with paths beginning with tilde (e.g., ~/anaconda/stuff.txt)
+* :ghissue:`2992`: Cell-based input for console and qt frontends?
+* :ghissue:`2425`: Liaise with Spyder devs to integrate newer IPython
+* :ghissue:`2986`: requesting help in a loop can damage a notebook
+* :ghissue:`2978`: v1.0-dev build errors on Arch with Python 3.
+* :ghissue:`2557`: [refactor] Insert_cell_at_index()
+* :ghissue:`2969`: ipython command does not work in terminal
+* :ghissue:`2762`: OSX wxPython (osx_cocoa, 64bit) command "%gui wx" blocks the interpreter
+* :ghissue:`2956`: Silent importing of submodules differs from standard Python3.2 interpreter's behavior
+* :ghissue:`2943`: Up arrow key history search gets stuck in QTConsole
+* :ghissue:`2953`: using 'nonlocal' declaration in global scope causes ipython3 crash
+* :ghissue:`2952`: qtconsole ignores exec_lines
+* :ghissue:`2949`: ipython crashes due to atexit()
+* :ghissue:`2947`: From rmagic to  an R console
+* :ghissue:`2938`: docstring pane not showing in notebook
+* :ghissue:`2936`: Tornado assumes invalid signature for parse_qs on Python 3.1
+* :ghissue:`2935`: unable to find python after easy_install / pip install
+* :ghissue:`2920`: Add undo-cell deletion menu
+* :ghissue:`2914`: BUG:saving a modified .py file after loading a module kills the kernel
+* :ghissue:`2925`: BUG: kernel dies if user sets sys.stderr or sys.stdout to a file object
+* :ghissue:`2909`: LaTeX sometimes fails to render in markdown cells with some curly bracket + underscore combinations
+* :ghissue:`2898`: Skip ipc tests on Windows
+* :ghissue:`2902`: ActiveState attempt to build ipython 0.12.1 for python 3.2.2 for Mac OS failed
+* :ghissue:`2899`: Test failure in IPython.core.tests.test_magic.test_time
+* :ghissue:`2890`: Test failure when fabric not installed
+* :ghissue:`2892`: IPython tab completion bug for paths
+* :ghissue:`1340`: Allow input cells to be collapsed
+* :ghissue:`2881`: ? command in notebook does not show help in Safari
+* :ghissue:`2751`: %%timeit should use minutes to format running time in long running cells
+* :ghissue:`2879`: When importing a module with a wrong name, ipython crashes
+* :ghissue:`2862`: %%timeit should warn of empty contents
+* :ghissue:`2485`: History navigation breaks in qtconsole
+* :ghissue:`2785`: gevent input hook
+* :ghissue:`2843`: Sliently running code in clipboard (with paste, cpaste and variants)
+* :ghissue:`2784`: %run -t -N<N> error
+* :ghissue:`2732`: Test failure with FileLinks class on Windows
+* :ghissue:`2860`: ipython help notebook -> KeyError: 'KernelManager'
+* :ghissue:`2858`: Where is the installed `ipython` script?
+* :ghissue:`2856`: Edit code entered from ipython in external editor
+* :ghissue:`2722`: IPC transport option not taking effect ?
+* :ghissue:`2473`: Better error messages in ipengine/ipcontroller
+* :ghissue:`2836`: Cannot send builtin module definitions to IP engines
+* :ghissue:`2833`: Any reason not to use super() ? 
+* :ghissue:`2781`: Cannot interrupt infinite loops in the notebook
+* :ghissue:`2150`: clippath_demo.py in matplotlib example does not work with inline backend
+* :ghissue:`2634`: Numbered list in notebook markdown cell renders with Roman numerals instead of numbers
+* :ghissue:`2230`: IPython crashing during startup with "AttributeError: 'NoneType' object has no attribute 'rstrip'"
+* :ghissue:`2483`: nbviewer bug? with multi-file gists
+* :ghissue:`2466`: mistyping `ed -p` breaks `ed -p`
+* :ghissue:`2477`: Glob expansion tests fail on Windows
+* :ghissue:`2622`: doc issue: notebooks that ship with Ipython .13 are written for python 2.x
+* :ghissue:`2626`: Add "Cell -> Run All Keep Going" for notebooks
+* :ghissue:`1223`: Show last modification date of each notebook
+* :ghissue:`2621`: user request: put link to example notebooks in Dashboard
+* :ghissue:`2564`: grid blanks plots in ipython pylab inline mode (interactive)
+* :ghissue:`2532`: Django shell (IPython) gives NameError on dict comprehensions
+* :ghissue:`2188`: ipython crashes on ctrl-c
+* :ghissue:`2391`: Request: nbformat API to load/save without changing version
+* :ghissue:`2355`: Restart kernel message even though kernel is perfectly alive
+* :ghissue:`2306`: Garbled input text after reverse search on Mac OS X
+* :ghissue:`2297`: ipdb with separate kernel/client pushing stdout to kernel process only
+* :ghissue:`2180`: Have [kernel busy] overridden only by [kernel idle]
+* :ghissue:`1188`: Pylab with OSX backend keyboard focus issue and hang
+* :ghissue:`2107`: test_octavemagic.py[everything] fails 
+* :ghissue:`1212`: Better understand/document browser compatibility
+* :ghissue:`1585`: Refactor notebook templates to use Jinja2 and make each page a separate directory
+* :ghissue:`1443`: xticks scaling factor partially obscured with qtconsole and inline plotting 
+* :ghissue:`1209`: can't make %result work as in doc.
+* :ghissue:`1200`: IPython 0.12 Windows install fails on Vista
+* :ghissue:`1127`: Interactive test scripts for Qt/nb issues
+* :ghissue:`959`: Matplotlib figures hide
+* :ghissue:`2071`: win32 installer issue on Windows XP
+* :ghissue:`2610`: ZMQInteractiveShell.colors being ignored
+* :ghissue:`2505`: Markdown Cell incorrectly highlighting after "<"
+* :ghissue:`165`: Installer fails to create Start Menu entries on Windows
+* :ghissue:`2356`: failing traceback in terminal ipython for first exception
+* :ghissue:`2145`: Have dashboad show when server disconect
+* :ghissue:`2098`: Do not crash on kernel shutdow if json file is missing
+* :ghissue:`2813`: Offline MathJax is broken on 0.14dev
+* :ghissue:`2807`: Test failure: IPython.parallel.tests.test_client.TestClient.test_purge_everything
+* :ghissue:`2486`: Readline's history search in ipython console does not clear properly after cancellation with Ctrl+C
+* :ghissue:`2709`: Cython -la doesn't work
+* :ghissue:`2767`: What is IPython.utils.upgradedir ?
+* :ghissue:`2210`: Placing matplotlib legend outside axis bounds causes inline display to clip it
+* :ghissue:`2553`: IPython Notebooks not robust against client failures
+* :ghissue:`2536`: ImageDraw in Ipython notebook not drawing lines
+* :ghissue:`2264`: Feature request: Versioning messaging protocol
+* :ghissue:`2589`: Creation of ~300+ MPI-spawned engines causes instability in ipcluster
+* :ghissue:`2672`: notebook: inline option without pylab
+* :ghissue:`2673`: Indefinite Articles & Traitlets
+* :ghissue:`2705`: Notebook crashes Safari with select and drag
+* :ghissue:`2721`: dreload kills ipython when it hits zmq
+* :ghissue:`2806`: ipython.parallel doesn't discover globals under Python 3.3
+* :ghissue:`2794`: _exit_code behaves differently in terminal vs ZMQ frontends
+* :ghissue:`2793`: IPython.parallel issue with pushing pandas TimeSeries
+* :ghissue:`1085`: In process kernel for Qt frontend
+* :ghissue:`2760`: IndexError: list index out of range with Python 3.2
+* :ghissue:`2780`: Save and load notebooks from github
+* :ghissue:`2772`: AttributeError: 'Client' object has no attribute 'kill'
+* :ghissue:`2754`: Fail to send class definitions from interactive session to engines namespaces
+* :ghissue:`2764`: TypeError while using 'cd'
+* :ghissue:`2765`: name '__file__' is not defined
+* :ghissue:`2540`: Wrap tooltip if line exceeds threshold?
+* :ghissue:`2394`: Startup error on ipython qtconsole (version 0.13 and 0.14-dev
+* :ghissue:`2440`: IPEP 4: Python 3 Compatibility
+* :ghissue:`1814`: __file__ is not defined when file end with .ipy
+* :ghissue:`2759`: R magic extension interferes with tab completion
+* :ghissue:`2615`: Small change needed to rmagic extension.
+* :ghissue:`2748`: collapse parts of a html notebook
+* :ghissue:`1661`: %paste still bugs about IndentationError and says to use %paste
+* :ghissue:`2742`: Octavemagic fails to deliver inline images in IPython (on Windows)
+* :ghissue:`2739`: wiki.ipython.org contaminated with prescription drug spam
+* :ghissue:`2588`: Link error while executing code from cython example notebook
+* :ghissue:`2550`: Rpush magic doesn't find local variables and doesn't support comma separated lists of variables
+* :ghissue:`2675`: Markdown/html blockquote need css.
+* :ghissue:`2419`: TerminalInteractiveShell.__init__() ignores value of ipython_dir argument
+* :ghissue:`1523`: Better LaTeX printing in the qtconsole with the sympy profile
+* :ghissue:`2719`: ipython fails with `pkg_resources.DistributionNotFound: ipython==0.13`
+* :ghissue:`2715`: url crashes nbviewer.ipython.org
+* :ghissue:`2555`: "import" module completion on MacOSX
+* :ghissue:`2707`: Problem installing the new version of IPython in Windows
+* :ghissue:`2696`: SymPy magic bug in IPython Notebook
+* :ghissue:`2684`: pretty print broken for types created with PyType_FromSpec
+* :ghissue:`2533`: rmagic breaks on Windows
+* :ghissue:`2661`: Qtconsole tooltip is too wide when the function has many arguments
+* :ghissue:`2679`: ipython3 qtconsole via Homebrew on Mac OS X 10.8 - pyqt/pyside import error
+* :ghissue:`2646`: pylab_not_importable
+* :ghissue:`2587`: cython magic pops 2 CLI windows upon execution on Windows
+* :ghissue:`2660`: Certain arguments (-h, --help, --version) never passed to scripts run with ipython
+* :ghissue:`2665`: Missing docs for rmagic and some other extensions
+* :ghissue:`2611`: Travis wants to drop 3.1 support
+* :ghissue:`2658`: Incorrect parsing of raw multiline strings
+* :ghissue:`2655`: Test fails if `from __future__ import print_function` in .pythonrc.py
+* :ghissue:`2651`: nonlocal with no existing variable produces too many errors
+* :ghissue:`2645`: python3 is a pain (minor unicode bug)
+* :ghissue:`2637`: %paste in Python 3 on Mac doesn't work
+* :ghissue:`2624`: Error on launching IPython on Win 7 and Python 2.7.3
+* :ghissue:`2608`: disk IO activity on cursor press
+* :ghissue:`1275`: Markdown parses LaTeX math symbols as its formatting syntax in notebook
+* :ghissue:`2613`: display(Math(...)) doesn't render \tau correctly
+* :ghissue:`925`: Tab-completion in Qt console needn't use pager
+* :ghissue:`2607`: %load_ext sympy.interactive.ipythonprinting  dammaging output
+* :ghissue:`2593`: Toolbar button to open qtconsole from notebook
+* :ghissue:`2602`: IPython html documentation for downloading
+* :ghissue:`2598`: ipython notebook --pylab=inline replaces built-in any()
+* :ghissue:`2244`: small issue: wrong printout
+* :ghissue:`2590`: add easier way to execute scripts in the current directory
+* :ghissue:`2581`: %hist does not work when InteractiveShell.cache_size = 0
+* :ghissue:`2584`: No file COPYING
+* :ghissue:`2578`: AttributeError: 'module' object has no attribute 'TestCase'
+* :ghissue:`2576`: One of my notebooks won't load any more -- is there a maximum notebook size?
+* :ghissue:`2560`: Notebook output is invisible when printing strings with \r\r\n line endings
+* :ghissue:`2566`: if pyside partially present ipython qtconsole fails to load even if pyqt4 present
+* :ghissue:`1308`: ipython qtconsole  --ssh=server --existing ... hangs
+* :ghissue:`1679`: List command doesn't work in ipdb debugger the first time
+* :ghissue:`2545`: pypi win32 installer creates 64bit executibles
+* :ghissue:`2080`: Event loop issues with IPython 0.12 and PyQt4 (``QDialog.exec_`` and more)
+* :ghissue:`2541`: Allow `python -m IPython`
+* :ghissue:`2508`: subplots_adjust() does not work correctly in ipython notebook
+* :ghissue:`2289`: Incorrect mathjax rendering of certain arrays of equations
+* :ghissue:`2487`: Selecting and indenting
+* :ghissue:`2521`: more fine-grained 'run' controls, such as 'run from here' and 'run until here'
+* :ghissue:`2535`: Funny bounding box when plot with text
+* :ghissue:`2523`: History not working
+* :ghissue:`2514`: Issue with zooming in qtconsole
+* :ghissue:`2220`: No sys.stdout.encoding in kernel based IPython
+* :ghissue:`2512`: ERROR: Internal Python error in the inspect module.
+* :ghissue:`2496`: Function passwd does not work in QtConsole
+* :ghissue:`1453`: make engines reconnect/die when controller was restarted
+* :ghissue:`2481`: ipython notebook -- clicking in a code cell's output moves the screen to the top of the code cell
+* :ghissue:`2488`: Undesired plot outputs in Notebook inline mode
+* :ghissue:`2482`: ipython notebook -- download may not get the latest notebook
+* :ghissue:`2471`: _subprocess module removed in Python 3.3
+* :ghissue:`2374`: Issues with man pages
+* :ghissue:`2316`: parallel.Client.__init__ should take cluster_id kwarg
+* :ghissue:`2457`: Can a R library wrapper be created with Rmagic?
+* :ghissue:`1575`: Fallback frontend for console when connecting pylab=inlnie -enabled kernel?
+* :ghissue:`2097`: Do not crash if history db is corrupted
+* :ghissue:`2435`: ipengines fail if clean_logs enabled
+* :ghissue:`2429`: Using warnings.warn() results in TypeError
+* :ghissue:`2422`: Multiprocessing in ipython notebook kernel crash
+* :ghissue:`2426`: ipython crashes with the following message. I do not what went wrong. Can you help me identify the problem?
+* :ghissue:`2423`: Docs typo?
+* :ghissue:`2257`: pip install -e fails
+* :ghissue:`2418`: rmagic can't run R's read.csv on data files with NA data
+* :ghissue:`2417`: HTML notebook: Backspace sometimes deletes multiple characters
+* :ghissue:`2275`: notebook: "Down_Arrow" on last line of cell should move to end of line
+* :ghissue:`2414`: 0.13.1 does not work with current EPD 7.3-2
+* :ghissue:`2409`: there is a redundant None
+* :ghissue:`2410`: Use /usr/bin/python3 instead of /usr/bin/python
+* :ghissue:`2366`: Notebook Dashboard --notebook-dir and fullpath
+* :ghissue:`2406`: Inability to get docstring in debugger
+* :ghissue:`2398`: Show line number for IndentationErrors
+* :ghissue:`2314`: HTML lists seem to interfere with the QtConsole display
+* :ghissue:`1688`: unicode exception when using %run with failing script
+* :ghissue:`1884`: IPython.embed changes color on error
+* :ghissue:`2381`: %time doesn't work for multiline statements
+* :ghissue:`1435`: Add size keywords in Image class
+* :ghissue:`2372`: interactiveshell.py misses urllib and io_open imports
+* :ghissue:`2371`: IPython not working
+* :ghissue:`2367`: Tab expansion moves to next cell in notebook
+* :ghissue:`2359`: nbviever alters the order of print and display() output
+* :ghissue:`2227`: print name for IPython Notebooks has become uninformative
+* :ghissue:`2361`: client doesn't use connection file's 'location' in disambiguating 'interface'
+* :ghissue:`2357`: failing traceback in terminal ipython for first exception
+* :ghissue:`2343`: Installing in a python 3.3b2 or python 3.3rc1 virtual environment.
+* :ghissue:`2315`: Failure in test: "Test we're not loading modules on startup that we shouldn't." 
+* :ghissue:`2351`: Multiple Notebook Apps: cookies not port specific, clash with each other
+* :ghissue:`2350`: running unittest from qtconsole prints output to terminal
+* :ghissue:`2303`:  remote tracebacks broken since 952d0d6 (PR #2223)
+* :ghissue:`2330`: qtconsole does not highlight tab-completion suggestion with custom stylesheet
+* :ghissue:`2325`: Parsing Tex formula fails in Notebook
+* :ghissue:`2324`: Parsing Tex formula fails
+* :ghissue:`1474`: Add argument to `run -n` for custom namespace
+* :ghissue:`2318`: C-m n/p don't work in Markdown cells in the notebook
+* :ghissue:`2309`: time.time() in ipython notebook producing impossible results
+* :ghissue:`2307`: schedule tasks on newly arrived engines
+* :ghissue:`2313`: Allow Notebook HTML/JS to send messages to Python code
+* :ghissue:`2304`: ipengine throws KeyError: url
+* :ghissue:`1878`: shell access using ! will not fill class or function scope vars
+* :ghissue:`2253`: %paste does not retrieve clipboard contents under screen/tmux on OS X
+* :ghissue:`1510`: Add-on (or Monkey-patch) infrastructure for HTML notebook
+* :ghissue:`2273`: triple quote and %s at beginning of line with %paste
+* :ghissue:`2243`: Regression in .embed()
+* :ghissue:`2266`: SSH passwordless check with OpenSSH checks for the wrong thing
+* :ghissue:`2217`: Change NewNotebook handler to use 30x redirect
+* :ghissue:`2276`: config option for disabling history store
+* :ghissue:`2239`: can't use parallel.Reference in view.map
+* :ghissue:`2272`: Sympy piecewise messed up rendering
+* :ghissue:`2252`: %paste throws an exception with empty clipboard
+* :ghissue:`2259`: git-mpr is currently broken
+* :ghissue:`2247`: Variable expansion in shell commands should work in substrings
+* :ghissue:`2026`: Run 'fast' tests only
+* :ghissue:`2241`: read a list of notebooks on server and bring into browser only notebook
+* :ghissue:`2237`: please put python and text editor in the web only ipython
+* :ghissue:`2053`: Improvements to the IPython.display.Image object
+* :ghissue:`1456`: ERROR: Internal Python error in the inspect module.
+* :ghissue:`2221`: Avoid importing from IPython.parallel in core
+* :ghissue:`2213`: Can't trigger startup code in Engines
+* :ghissue:`1464`: Strange behavior for backspace with lines ending with more than 4 spaces in notebook 
+* :ghissue:`2187`: NaN in object_info_reply JSON causes parse error
+* :ghissue:`214`: system command requiring administrative privileges  
+* :ghissue:`2195`: Unknown option `no-edit` in git-mpr
+* :ghissue:`2201`: Add documentation build to tools/test_pr.py
+* :ghissue:`2205`: Command-line option for default Notebook output collapsing behavior
+* :ghissue:`1927`: toggle between inline and floating figures
+* :ghissue:`2171`: Can't start StarCluster after upgrading to IPython 0.13
+* :ghissue:`2173`: oct2py v >= 0.3.1 doesn't need h5py anymore
+* :ghissue:`2099`: storemagic needs to use self.shell
+* :ghissue:`2166`: DirectView map_sync() with Lambdas Using Generators
+* :ghissue:`2091`: Unable to use print_stats after %prun -r in notebook
+* :ghissue:`2132`: Add fail-over for pastebin
+* :ghissue:`2156`: Make it possible to install ipython without nasty gui dependencies
+* :ghissue:`2154`: Scrolled long output should be off in print view by default
+* :ghissue:`2162`: Tab completion does not work with IPython.embed_kernel()
+* :ghissue:`2157`: IPython 0.13 / github-master cannot create logfile from scratch
+* :ghissue:`2151`: missing newline when a magic is called from the qtconsole menu
+* :ghissue:`2139`: 00_notebook_tour Image example broken on master
+* :ghissue:`2143`: Add a %%cython_annotate magic
+* :ghissue:`2135`: Running IPython from terminal
+* :ghissue:`2093`: Makefile for building Sphinx documentation on Windows 
+* :ghissue:`2122`: Bug in pretty printing
+* :ghissue:`2120`: Notebook "Make a Copy..." keeps opening duplicates in the same tab
+* :ghissue:`1997`: password cannot be used with url prefix
+* :ghissue:`2129`: help/doc displayed multiple times if requested in loop
+* :ghissue:`2121`: ipdb does not support input history in qtconsole
+* :ghissue:`2114`: %logstart doesn't log
+* :ghissue:`2085`: %ed magic fails in qtconsole
+* :ghissue:`2119`: IPython fails to run on MacOS Lion 
+* :ghissue:`2052`: %pylab inline magic does not work on windows
+* :ghissue:`2111`: Ipython won't start on W7
+* :ghissue:`2112`: Strange internal traceback
+* :ghissue:`2108`: Backslash (\) at the end of the line behavior different from default Python
+* :ghissue:`1425`: Ampersands can't be typed sometimes in notebook cells
+* :ghissue:`1513`: Add expand/collapse support for long output elements like stdout and tracebacks
+* :ghissue:`2087`: error when starting ipython
+* :ghissue:`2103`: Ability to run notebook file from commandline
+* :ghissue:`2082`: Qt Console output spacing
+* :ghissue:`2083`: Test failures with Python 3.2 and PYTHONWARNINGS="d"
+* :ghissue:`2094`: about inline
+* :ghissue:`2077`: Starting IPython3 on the terminal
+* :ghissue:`1760`: easy_install ipython fails on py3.2-win32
+* :ghissue:`2075`: Local Mathjax install causes iptest3 error under python3
+* :ghissue:`2057`: setup fails for python3 with LANG=C
+* :ghissue:`2070`: shebang on Windows
+* :ghissue:`2054`: sys_info missing git hash in sdists
+* :ghissue:`2059`: duplicate and modified files in documentation
+* :ghissue:`2056`: except-shadows-builtin osm.py:687
+* :ghissue:`2058`: hyphen-used-as-minus-sign in manpages
diff --git a/docs/source/whatsnew/github-stats-2.0.rst b/docs/source/whatsnew/github-stats-2.0.rst
new file mode 100644
index 00000000000..eadef8310c8
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-2.0.rst
@@ -0,0 +1,1607 @@
+.. _issues_list_200:
+
+Issues closed in the 2.x development cycle
+==========================================
+
+Issues closed in 2.4.1
+----------------------
+
+GitHub stats for 2014/11/01 - 2015/01/30
+
+.. note::
+
+    IPython 2.4.0 was released without a few of the backports listed below.
+    2.4.1 has the correct patches intended for 2.4.0.
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 7 authors contributed 35 commits.
+
+* Benjamin Ragan-Kelley
+* Carlos Cordoba
+* Damon Allen
+* Jessica B. Hamrick
+* Mateusz Paprocki
+* Peter Würtz
+* Thomas Kluyver
+
+We closed 10 issues and merged 6 pull requests;
+this is the full list (generated with the script 
+:file:`tools/github_stats.py`):
+
+Pull Requests (10):
+
+* :ghpull:`7106`: Changed the display order of rich output in the live notebook.
+* :ghpull:`6878`: Update pygments monkeypatch for compatibility with Pygments 2.0
+* :ghpull:`6778`: backport nbformat v4 to 2.x
+* :ghpull:`6761`: object_info_reply field is oname, not name
+* :ghpull:`6653`: Fix IPython.utils.ansispan() to ignore stray [0m
+* :ghpull:`6706`: Correctly display prompt numbers that are ``None``
+* :ghpull:`6634`: don't use contains in SelectWidget item_query
+* :ghpull:`6593`: note how to start the qtconsole
+* :ghpull:`6281`: more minor fixes to release scripts
+* :ghpull:`5458`: Add support for PyQt5.
+
+Issues (6):
+
+* :ghissue:`7272`: qtconsole problems with pygments
+* :ghissue:`7049`: Cause TypeError: 'NoneType' object is not callable in qtconsole 
+* :ghissue:`6877`: Qt console doesn't work with pygments 2.0rc1
+* :ghissue:`6689`: Problem with string containing two or more question marks
+* :ghissue:`6702`: Cell numbering after ``ClearOutput`` preprocessor
+* :ghissue:`6633`: selectwidget doesn't display 1 as a selection choice when passed in as a member of values list
+
+
+Issues closed in 2.3.1
+----------------------
+
+Just one bugfix: fixed bad CRCRLF line-endings in notebooks on Windows
+
+Pull Requests (1):
+
+* :ghpull:`6911`: don't use text mode in mkstemp
+
+Issues (1):
+
+* :ghissue:`6599`: Notebook.ipynb CR+LF turned into CR+CR+LF
+
+
+Issues closed in 2.3.0
+----------------------
+
+GitHub stats for 2014/08/06 - 2014/10/01
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 6 authors contributed 31 commits.
+
+* Benjamin Ragan-Kelley
+* David Hirschfeld
+* Eric Firing
+* Jessica B. Hamrick
+* Matthias Bussonnier
+* Thomas Kluyver
+
+We closed 16 issues and merged 9 pull requests;
+this is the full list (generated with the script 
+:file:`tools/github_stats.py`):
+
+Pull Requests (16):
+
+* :ghpull:`6587`: support ``%matplotlib qt5`` and ``%matplotlib nbagg``
+* :ghpull:`6583`: Windows symlink test fixes
+* :ghpull:`6585`: fixes :ghissue:`6473`
+* :ghpull:`6581`: Properly mock winreg functions for test
+* :ghpull:`6556`: Use some more informative asserts in inprocess kernel tests
+* :ghpull:`6514`: Fix for copying metadata flags
+* :ghpull:`6453`: Copy file metadata in atomic save
+* :ghpull:`6480`: only compare host:port in Websocket.check_origin
+* :ghpull:`6483`: Trim anchor link in heading cells, fixes :ghissue:`6324`
+* :ghpull:`6410`: Fix relative import in appnope
+* :ghpull:`6395`: update mathjax CDN url in nbconvert template
+* :ghpull:`6269`: Implement atomic save
+* :ghpull:`6374`: Rename ``abort_queues`` --> ``_abort_queues``
+* :ghpull:`6321`: Use appnope in qt and wx gui support from the terminal; closes :ghissue:`6189`
+* :ghpull:`6318`: use write_error instead of get_error_html
+* :ghpull:`6303`: Fix error message when failing to load a notebook
+
+Issues (9):
+
+* :ghissue:`6057`: ``%matplotlib`` + qt5
+* :ghissue:`6518`: Test failure in atomic save on Windows
+* :ghissue:`6473`: Switching between "Raw Cell Format" and "Edit Metadata" does not work
+* :ghissue:`6405`: Creating a notebook should respect directory permissions; saving should respect prior permissions
+* :ghissue:`6324`: Anchors in Heading don't work.
+* :ghissue:`6409`: No module named '_dummy'
+* :ghissue:`6392`: Mathjax library link broken
+* :ghissue:`6329`: IPython Notebook Server URL now requires "tree" at the end of the URL? (version 2.2)
+* :ghissue:`6189`: ipython console freezes for increasing no of seconds in %pylab mode
+
+Issues closed in 2.2.0
+----------------------
+
+GitHub stats for 2014/05/21 - 2014/08/06 (tag: rel-2.1.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 13 authors contributed 36 commits.
+
+* Adam Hodgen
+* Benjamin Ragan-Kelley
+* Björn Grüning
+* Dara Adib
+* Eric Galloway
+* Jonathan Frederic
+* Kyle Kelley
+* Matthias Bussonnier
+* Paul Ivanov
+* Shayne Hodge
+* Steven Anton
+* Thomas Kluyver
+* Zahari
+
+We closed 23 issues and merged 11 pull requests;
+this is the full list (generated with the script 
+:file:`tools/github_stats.py`):
+
+Pull Requests (23):
+
+* :ghpull:`6279`: minor updates to release scripts
+* :ghpull:`6273`: Upgrade default mathjax version.
+* :ghpull:`6249`: always use HTTPS getting mathjax from CDN
+* :ghpull:`6114`: update hmac signature comparison
+* :ghpull:`6195`: Close handle on new temporary files before returning filename
+* :ghpull:`6143`: pin tornado to < 4 on travis js tests
+* :ghpull:`6134`: remove rackcdn https workaround for mathjax cdn
+* :ghpull:`6120`: Only allow iframe embedding on same origin.
+* :ghpull:`6117`: Remove / from route of TreeRedirectHandler.
+* :ghpull:`6105`: only set allow_origin_pat if defined
+* :ghpull:`6102`: Add newline if missing to end of script magic cell
+* :ghpull:`6077`: allow unicode keys in dicts in json_clean
+* :ghpull:`6061`: make CORS configurable
+* :ghpull:`6081`: don’t modify dict keys while iterating through them
+* :ghpull:`5803`: unify visual line handling
+* :ghpull:`6005`: Changed right arrow key movement function to mirror left arrow key
+* :ghpull:`6029`: add pickleutil.PICKLE_PROTOCOL
+* :ghpull:`6003`: Set kernel_id before checking websocket
+* :ghpull:`5994`: Fix ssh tunnel for Python3
+* :ghpull:`5973`: Do not create checkpoint_dir relative to current dir
+* :ghpull:`5933`: fix qt_loader import hook signature
+* :ghpull:`5944`: Markdown rendering bug fix.
+* :ghpull:`5917`: use shutil.move instead of os.rename
+
+Issues (11):
+
+* :ghissue:`6246`: Include MathJax by default or access the CDN over a secure connection
+* :ghissue:`5525`: Websocket origin check fails when used with Apache WS proxy
+* :ghissue:`5901`: 2 test failures in Python 3.4 in parallel group
+* :ghissue:`5926`: QT console: text selection cannot be made from left to right with keyboard
+* :ghissue:`5998`: use_dill does not work in Python 3.4
+* :ghissue:`5964`: Traceback on Qt console exit
+* :ghissue:`5787`: Error in Notebook-Generated latex (nbconvert)
+* :ghissue:`5950`: qtconsole truncates help
+* :ghissue:`5943`: 2.x: notebook fails to load when using HTML comments
+* :ghissue:`5932`: Qt ImportDenier Does Not Adhere to PEP302
+* :ghissue:`5898`: OSError when moving configuration file
+
+Issues closed in 2.1.0
+----------------------
+
+GitHub stats for 2014/04/02 - 2014/05/21 (since 2.0.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 35 authors contributed 145 commits.
+
+* Adrian Price-Whelan
+* Aron Ahmadia
+* Benjamin Ragan-Kelley
+* Benjamin Schultz
+* Björn Linse
+* Blake Griffith
+* chebee7i
+* Damián Avila
+* Dav Clark
+* dexterdev
+* Erik Tollerud
+* Grzegorz Rożniecki
+* Jakob Gager
+* jdavidheiser
+* Jessica B. Hamrick
+* Jim Garrison
+* Jonathan Frederic
+* Matthias Bussonnier
+* Maximilian Albert
+* Mohan Raj Rajamanickam
+* ncornette
+* Nikolay Koldunov
+* Nile Geisinger
+* Pankaj Pandey
+* Paul Ivanov
+* Pierre Haessig
+* Raffaele De Feo
+* Renaud Richardet
+* Spencer Nelson
+* Steve Chan
+* sunny
+* Susan Tan
+* Thomas Kluyver
+* Yaroslav Halchenko
+* zah
+
+We closed a total of 129 issues, 92 pull requests and 37 regular issues;
+this is the full list (generated with the script 
+:file:`tools/github_stats.py --milestone 2.1`):
+
+Pull Requests (92):
+
+* :ghpull:`5871`: specify encoding in msgpack.unpackb
+* :ghpull:`5869`: Catch more errors from clipboard access on Windows
+* :ghpull:`5866`: Make test robust against differences in line endings
+* :ghpull:`5605`: Two cell toolbar fixes.
+* :ghpull:`5843`: remove Firefox-specific CSS workaround
+* :ghpull:`5845`: Pass Windows interrupt event to kernels as an environment variable
+* :ghpull:`5835`: fix typo in v2 convert
+* :ghpull:`5841`: Fix writing history with output to a file in Python 2
+* :ghpull:`5842`: fix typo in nbconvert help
+* :ghpull:`5846`: Fix typos in Cython example
+* :ghpull:`5839`: Close graphics dev in finally clause
+* :ghpull:`5837`: pass on install docs
+* :ghpull:`5832`: Fixed example to work with python3
+* :ghpull:`5826`: allow notebook tour instantiation to fail
+* :ghpull:`5560`: Minor expansion of Cython example
+* :ghpull:`5818`: interpret any exception in getcallargs as not callable
+* :ghpull:`5816`: Add output to IPython directive when in verbatim mode.
+* :ghpull:`5822`: Don't overwrite widget description in interact
+* :ghpull:`5782`: Silence exception thrown by completer when dir() does not return a list
+* :ghpull:`5807`: Drop log level to info for Qt console shutdown
+* :ghpull:`5814`: Remove -i options from mv, rm and cp aliases
+* :ghpull:`5812`: Fix application name when printing subcommand help.
+* :ghpull:`5804`: remove an inappropriate ``!``
+* :ghpull:`5805`: fix engine startup files
+* :ghpull:`5806`: Don't auto-move .config/ipython if symbolic link
+* :ghpull:`5716`: Add booktabs package to latex base.tplx
+* :ghpull:`5669`: allows threadsafe sys.stdout.flush from background threads
+* :ghpull:`5668`: allow async output on the most recent request
+* :ghpull:`5768`: fix cursor keys in long lines wrapped in markdown
+* :ghpull:`5788`: run cells with ``silent=True`` in ``%run nb.ipynb``
+* :ghpull:`5715`: log all failed ajax API requests
+* :ghpull:`5769`: Don't urlescape the text that goes into a title tag
+* :ghpull:`5762`: Fix check for pickling closures
+* :ghpull:`5766`: View.map with empty sequence should return empty list
+* :ghpull:`5758`: Applied bug fix: using fc and ec did not properly set the figure canvas ...
+* :ghpull:`5754`: Format command name into subcommand_description at run time, not import
+* :ghpull:`5744`: Describe using PyPI/pip to distribute & install extensions
+* :ghpull:`5712`: monkeypatch inspect.findsource only when we use it
+* :ghpull:`5708`: create checkpoints dir in notebook subdirectories
+* :ghpull:`5714`: log error message when API requests fail
+* :ghpull:`5732`: Quick typo fix in nbformat/convert.py
+* :ghpull:`5713`: Fix a NameError in IPython.parallel
+* :ghpull:`5704`: Update nbconvertapp.py
+* :ghpull:`5534`: cleanup some ``pre`` css inheritance
+* :ghpull:`5699`: don't use common names in require decorators
+* :ghpull:`5692`: Update notebook.rst fixing broken reference to notebook examples readme
+* :ghpull:`5693`: Update parallel_intro.rst to fix a broken link to examples
+* :ghpull:`5486`: disambiguate to location when no IPs can be determined
+* :ghpull:`5574`: Remove the outdated keyboard shortcuts from notebook docs
+* :ghpull:`5568`: Use ``__qualname__`` in pretty reprs for Python 3
+* :ghpull:`5678`: Fix copy & paste error in docstring of ImageWidget class
+* :ghpull:`5677`: Fix %bookmark -l for Python 3
+* :ghpull:`5670`: nbconvert: Fix CWD imports
+* :ghpull:`5647`: Mention git hooks in install documentation
+* :ghpull:`5671`: Fix blank slides issue in Reveal slideshow pdf export
+* :ghpull:`5657`: use 'localhost' as default for the notebook server
+* :ghpull:`5584`: more semantic icons
+* :ghpull:`5594`: update components with marked-0.3.2
+* :ghpull:`5500`: check for Python 3.2
+* :ghpull:`5582`: reset readline after running PYTHONSTARTUP
+* :ghpull:`5630`: Fixed Issue :ghissue:`4012` Added Help menubar link to Github markdown doc
+* :ghpull:`5613`: Fixing bug :ghissue:`5607`
+* :ghpull:`5633`: Provide more help if lessc is not found.
+* :ghpull:`5620`: fixed a typo in IPython.core.formatters
+* :ghpull:`5619`: Fix typo in storemagic module docstring
+* :ghpull:`5592`: add missing ``browser`` to notebook_aliases list
+* :ghpull:`5506`: Fix ipconfig regex pattern
+* :ghpull:`5581`: Fix rmagic for cells ending in comment.
+* :ghpull:`5576`: only process cr if it's found
+* :ghpull:`5478`: Add git-hooks install script. Update README.md
+* :ghpull:`5546`: do not shutdown notebook if 'n' is part of answer
+* :ghpull:`5527`: Don't remove upload items from nav tree unless explicitly requested.
+* :ghpull:`5501`: remove inappropriate wheel tag override
+* :ghpull:`5548`: FileNotebookManager: Use shutil.move() instead of os.rename()
+* :ghpull:`5524`: never use ``for (var i in array)``
+* :ghpull:`5459`: Fix interact animation page jump FF
+* :ghpull:`5559`: Minor typo fix in "Cython Magics.ipynb"
+* :ghpull:`5507`: Fix typo in interactive widgets examples index notebook
+* :ghpull:`5554`: Make HasTraits pickleable
+* :ghpull:`5535`: fix n^2 performance issue in coalesce_streams preprocessor
+* :ghpull:`5522`: fix iteration over Client
+* :ghpull:`5488`: Added missing require and jquery from cdn.
+* :ghpull:`5516`: ENH: list generated config files in generated, and rm them upon clean
+* :ghpull:`5493`: made a minor fix to one of the widget examples
+* :ghpull:`5512`: Update tooltips to refer to shift-tab
+* :ghpull:`5505`: Make backport_pr work on Python 3
+* :ghpull:`5503`: check explicitly for 'dev' before adding the note to docs
+* :ghpull:`5498`: use milestones to indicate backport
+* :ghpull:`5492`: Polish whatsnew docs
+* :ghpull:`5495`: Fix various broken things in docs
+* :ghpull:`5496`: Exclude whatsnew/pr directory from docs builds
+* :ghpull:`5489`: Fix required Python versions
+
+Issues (37):
+
+* :ghissue:`5364`: Horizontal scrollbar hides cell's last line on Firefox
+* :ghissue:`5192`: horizontal scrollbar overlaps output or touches next cell
+* :ghissue:`5840`: Third-party Windows kernels don't get interrupt signal
+* :ghissue:`2412`: print history to file using qtconsole and notebook
+* :ghissue:`5703`: Notebook doesn't render with "ask me every time" cookie setting in Firefox
+* :ghissue:`5817`: calling mock object in IPython 2.0.0 under Python 3.4.0 raises AttributeError
+* :ghissue:`5499`: Error running widgets nbconvert example
+* :ghissue:`5654`: Broken links from ipython documentation
+* :ghissue:`5019`: print in QT event callback doesn't show up in ipython notebook.
+* :ghissue:`5800`: Only last In prompt number set ?
+* :ghissue:`5801`: startup_command specified in ipengine_config.py is not executed
+* :ghissue:`5690`: ipython 2.0.0 and pandoc 1.12.2.1 problem
+* :ghissue:`5408`: Add checking/flushing of background output from kernel in mainloop
+* :ghissue:`5407`: clearing message handlers on status=idle loses async output
+* :ghissue:`5467`: Incorrect behavior of up/down keyboard arrows in code cells on wrapped lines
+* :ghissue:`3085`: nicer notebook error message when lacking permissions
+* :ghissue:`5765`: map_sync over empty list raises IndexError
+* :ghissue:`5553`: Notebook matplotlib inline backend: can't set figure facecolor
+* :ghissue:`5710`: inspect.findsource monkeypatch raises wrong exception for C extensions
+* :ghissue:`5706`: Multi-Directory notebooks overwrite each other's checkpoints
+* :ghissue:`5698`: can't require a function named ``f``
+* :ghissue:`5569`: Keyboard shortcuts in documentation are out of date
+* :ghissue:`5566`: Function name printing should use ``__qualname__`` instead of ``__name__`` (Python 3)
+* :ghissue:`5676`: "bookmark -l" not working in ipython 2.0
+* :ghissue:`5555`: Differentiate more clearly between Notebooks and Folders in new UI
+* :ghissue:`5590`: Marked double escape 
+* :ghissue:`5514`: import tab-complete fail with ipython 2.0 shell
+* :ghissue:`4012`: Notebook: link to markdown formatting reference
+* :ghissue:`5611`: Typo in 'storemagic' documentation
+* :ghissue:`5589`: Kernel start fails when using --browser argument
+* :ghissue:`5491`: Bug in Windows ipconfig ip address regular expression  
+* :ghissue:`5579`: rmagic extension throws 'Error while parsing the string.' when last line is comment
+* :ghissue:`5518`: Ipython2 will not open ipynb in example directory
+* :ghissue:`5561`: New widget documentation has missing notebook link
+* :ghissue:`5128`: Page jumping when output from widget interaction replaced
+* :ghissue:`5519`: IPython.parallel.Client behavior as iterator
+* :ghissue:`5510`: Tab-completion for function argument list
+
+
+Issues closed in 2.0.0
+----------------------
+
+
+GitHub stats for 2013/08/09 - 2014/04/01 (since 1.0.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+The following 94 authors contributed 3949 commits.
+
+* Aaron Meurer
+* Abhinav Upadhyay
+* Adam Riggall
+* Alex Rudy
+* Andrew Mark
+* Angus Griffith
+* Antony Lee
+* Aron Ahmadia
+* Arun Persaud
+* Benjamin Ragan-Kelley
+* Bing Xia
+* Blake Griffith
+* Bouke van der Bijl
+* Bradley M. Froehle
+* Brian E. Granger
+* Carlos Cordoba
+* chapmanb
+* chebee7i
+* Christoph Gohlke
+* Christophe Pradal
+* Cyrille Rossant
+* Damián Avila
+* Daniel B. Vasquez
+* Dav Clark
+* David Hirschfeld
+* David P. Sanders
+* David Wyde
+* David Österberg
+* Doug Blank
+* Dražen Lu�anin
+* epifanio
+* Fernando Perez
+* Gabriel Becker
+* Geert Barentsen
+* Hans Meine
+* Ingolf Becker
+* Jake Vanderplas
+* Jakob Gager
+* James Porter
+* Jason Grout
+* Jeffrey Tratner
+* Jonah Graham
+* Jonathan Frederic
+* Joris Van den Bossche
+* Juergen Hasch
+* Julian Taylor
+* Katie Silverio
+* Kevin Burke
+* Kieran O'Mahony
+* Konrad Hinsen
+* Kyle Kelley
+* Lawrence Fu
+* Marc Molla
+* Martín Gaitán
+* Matt Henderson
+* Matthew Brett
+* Matthias Bussonnier
+* Michael Droettboom
+* Mike McKerns
+* Nathan Goldbaum
+* Pablo de Oliveira
+* Pankaj Pandey
+* Pascal Schetelat
+* Paul Ivanov
+* Paul Moore
+* Pere Vilas
+* Peter Davis
+* Philippe Mallet-Ladeira
+* Preston Holmes
+* Puneeth Chaganti
+* Richard Everson
+* Roberto Bonvallet
+* Samuel Ainsworth
+* Sean Vig
+* Shashi Gowda
+* Skipper Seabold
+* Stephan Rave
+* Steve Fox
+* Steven Silvester
+* stonebig
+* Susan Tan
+* Sylvain Corlay
+* Takeshi Kanmae
+* Ted Drain
+* Thomas A Caswell
+* Thomas Kluyver
+* Théophile Studer
+* Volker Braun
+* Wieland Hoffmann
+* Yaroslav Halchenko
+* Yoval P.
+* Yung Siang Liau
+* Zachary Sailer
+* zah
+
+
+We closed a total of 1121 issues, 687 pull requests and 434 regular issues;
+this is the full list (generated with the script 
+:file:`tools/github_stats.py`):
+
+Pull Requests (687):
+
+* :ghpull:`5487`: remove weird unicode space in the new copyright header
+* :ghpull:`5476`: For 2.0: Fix links in Notebook Help Menu
+* :ghpull:`5337`: Examples reorganization
+* :ghpull:`5436`: CodeMirror shortcuts in QuickHelp
+* :ghpull:`5444`: Fix numeric verification for Int and Float text widgets.
+* :ghpull:`5449`: Stretch keyboard shortcut dialog
+* :ghpull:`5473`: Minor corrections of git-hooks setup instructions
+* :ghpull:`5471`: Add coding magic comment to nbconvert Python template
+* :ghpull:`5452`: print_figure returns unicode for svg
+* :ghpull:`5450`: proposal: remove codename
+* :ghpull:`5462`: DOC : fixed minor error in using topological sort
+* :ghpull:`5463`: make spin_thread tests more forgiving of slow VMs
+* :ghpull:`5464`: Fix starting notebook server with file/directory at command line.
+* :ghpull:`5453`: remove gitwash
+* :ghpull:`5454`: Improve history API docs
+* :ghpull:`5431`: update github_stats and gh_api for 2.0
+* :ghpull:`5290`: Add dual mode JS tests
+* :ghpull:`5451`: check that a handler is actually registered in ShortcutManager.handles
+* :ghpull:`5447`: Add %%python2 cell magic
+* :ghpull:`5439`: Point to the stable SymPy docs, not the dev docs
+* :ghpull:`5437`: Install jquery-ui images
+* :ghpull:`5434`: fix check for empty cells in rst template
+* :ghpull:`5432`: update links in notebook help menu
+* :ghpull:`5435`: Update whatsnew (notebook tour)
+* :ghpull:`5433`: Document extraction of octave and R magics
+* :ghpull:`5428`: Update COPYING.txt
+* :ghpull:`5426`: Separate get_session_info between HistoryAccessor and HistoryManager
+* :ghpull:`5419`: move prompts from margin to main column on small screens
+* :ghpull:`5430`: Make sure `element` is correct in the context of displayed JS
+* :ghpull:`5396`: prevent saving of partially loaded notebooks
+* :ghpull:`5429`: Fix tooltip pager feature
+* :ghpull:`5330`: Updates to shell reference doc
+* :ghpull:`5404`: Fix broken accordion widget
+* :ghpull:`5339`: Don't use fork to start the notebook in js tests
+* :ghpull:`5320`: Fix for Tooltip & completer click focus bug.
+* :ghpull:`5421`: Move configuration of Python test controllers into setup()
+* :ghpull:`5418`: fix typo in ssh launcher send_file
+* :ghpull:`5403`: remove alt-- shortcut
+* :ghpull:`5389`: better log message in deprecated files/ redirect
+* :ghpull:`5333`: Fix filenbmanager.list_dirs fails for Windows user profile directory
+* :ghpull:`5390`: finish PR #5333
+* :ghpull:`5326`: Some gardening on iptest result reporting
+* :ghpull:`5375`: remove unnecessary onload hack from mathjax macro
+* :ghpull:`5368`: Flexbox classes specificity fixes
+* :ghpull:`5331`: fix raw_input CSS
+* :ghpull:`5395`: urlencode images for rst files
+* :ghpull:`5049`: update quickhelp on adding and removing shortcuts
+* :ghpull:`5391`: Fix Gecko (Netscape) keyboard handling
+* :ghpull:`5387`: Respect '\r' characters in nbconvert.
+* :ghpull:`5399`: Revert PR #5388
+* :ghpull:`5388`: Suppress output even when a comment follows ;. Fixes #4525.
+* :ghpull:`5394`: nbconvert doc update
+* :ghpull:`5359`: do not install less sources
+* :ghpull:`5346`: give hint on where to find custom.js
+* :ghpull:`5357`: catch exception in copystat
+* :ghpull:`5380`: Remove DefineShortVerb... line from latex base template
+* :ghpull:`5376`: elide long containers in pretty
+* :ghpull:`5310`: remove raw cell placeholder on focus, closes #5238
+* :ghpull:`5332`: semantic names for indicator icons
+* :ghpull:`5386`: Fix import of socketserver on Python 3
+* :ghpull:`5360`: remove some redundant font-family: monospace
+* :ghpull:`5379`: don't instantiate Application just for default logger
+* :ghpull:`5372`: Don't autoclose strings
+* :ghpull:`5296`: unify keyboard shortcut and codemirror interaction
+* :ghpull:`5349`: Make Hub.registration_timeout configurable
+* :ghpull:`5340`: install bootstrap-tour css
+* :ghpull:`5335`: Update docstring for deepreload module
+* :ghpull:`5321`: Improve assignment regex to match more tuple unpacking syntax
+* :ghpull:`5325`: add NotebookNotary to NotebookApp's class list
+* :ghpull:`5313`: avoid loading preprocessors twice
+* :ghpull:`5308`: fix HTML capitalization in Highlight2HTML
+* :ghpull:`5295`: OutputArea.append_type functions are not prototype methods
+* :ghpull:`5318`: Fix local import of select_figure_formats
+* :ghpull:`5300`: Fix NameError: name '_rl' is not defined
+* :ghpull:`5292`: focus next cell on shift+enter
+* :ghpull:`5291`: debug occasional error in test_queue_status
+* :ghpull:`5289`: Finishing up #5274 (widget paths fixes)
+* :ghpull:`5232`: Make nbconvert html full output like notebook's html.
+* :ghpull:`5288`: Correct initial state of kernel status indicator
+* :ghpull:`5253`: display any output from this session in terminal console
+* :ghpull:`4802`: Tour of the notebook UI (was UI elements inline with highlighting)
+* :ghpull:`5285`: Update signature presentation in pinfo classes
+* :ghpull:`5268`: Refactoring Notebook.command_mode
+* :ghpull:`5226`: Don't run PYTHONSTARTUP file if a file or code is passed
+* :ghpull:`5283`: Remove Widget.closed attribute
+* :ghpull:`5279`: nbconvert: Make sure node is atleast version 0.9.12
+* :ghpull:`5281`: fix a typo introduced by a rebased PR
+* :ghpull:`5280`: append Firefox overflow-x fix
+* :ghpull:`5277`: check that PIL can save JPEG to BytesIO
+* :ghpull:`5044`: Store timestamps for modules to autoreload
+* :ghpull:`5278`: Update whatsnew doc from pr files
+* :ghpull:`5276`: Fix kernel restart in case connection file is deleted.
+* :ghpull:`5272`: allow highlighting language to be set from notebook metadata
+* :ghpull:`5158`: log refusal to serve hidden directories
+* :ghpull:`5188`: New events system
+* :ghpull:`5265`: Missing class def for TimeoutError
+* :ghpull:`5267`: normalize unicode in notebook API tests
+* :ghpull:`5076`: Refactor keyboard handling
+* :ghpull:`5241`: Add some tests for utils
+* :ghpull:`5261`: Don't allow edit mode up arrow to continue past index == 0
+* :ghpull:`5223`: use on-load event to trigger resizable images
+* :ghpull:`5252`: make one strptime call at import of jsonutil
+* :ghpull:`5153`: Dashboard sorting
+* :ghpull:`5169`: Allow custom header
+* :ghpull:`5242`: clear _reply_content cache before using it
+* :ghpull:`5194`: require latex titles to be ascii
+* :ghpull:`5244`: try to avoid EADDRINUSE errors on travis
+* :ghpull:`5245`: support extracted output in HTML template
+* :ghpull:`5209`: make input_area css generic to cells
+* :ghpull:`5246`: less %pylab, more cowbell!
+* :ghpull:`4895`: Improvements to %run completions
+* :ghpull:`5243`: Add JavaScript to base display priority list.
+* :ghpull:`5175`: Audit .html() calls take #2
+* :ghpull:`5146`: Dual mode bug fixes.
+* :ghpull:`5207`: Children fire event
+* :ghpull:`5215`: Dashboard "Running" Tab
+* :ghpull:`5240`: Remove unused IPython.nbconvert.utils.console module
+* :ghpull:`5239`: Fix exclusion of tests directories from coverage reports
+* :ghpull:`5203`: capture some logging/warning output in some tests
+* :ghpull:`5216`: fixup positional arg handling in notebook app
+* :ghpull:`5229`: get _ipython_display_ method safely
+* :ghpull:`5234`: DOC : modified docs is HasTraits.traits and HasTraits.class_traits
+* :ghpull:`5221`: Change widget children List to Tuple.
+* :ghpull:`5231`: don't forget base_url when updating address bar in rename
+* :ghpull:`5173`: Moved widget files into static/widgets/*
+* :ghpull:`5222`: Unset PYTHONWARNINGS envvar before running subprocess tests.
+* :ghpull:`5172`: Prevent page breaks when printing notebooks via print-view.
+* :ghpull:`4985`: Add automatic Closebrackets function to Codemirror.
+* :ghpull:`5220`: Make traitlets notify check more robust against classes redefining equality and bool
+* :ghpull:`5197`: If there is an error comparing traitlet values when setting a trait, default to go ahead and notify of the new value.
+* :ghpull:`5210`: fix pyreadline import in rlineimpl
+* :ghpull:`5212`: Wrap nbconvert Markdown/Heading cells in live divs
+* :ghpull:`5200`: Allow to pass option to jinja env
+* :ghpull:`5202`: handle nodejs executable on debian
+* :ghpull:`5112`: band-aid for completion
+* :ghpull:`5187`: handle missing output metadata in nbconvert
+* :ghpull:`5181`: use gnureadline on OS X
+* :ghpull:`5136`: set default value from signature defaults in interact
+* :ghpull:`5132`: remove application/pdf->pdf transform in javascript
+* :ghpull:`5116`: reorganize who knows what about paths
+* :ghpull:`5165`: Don't introspect __call__ for simple callables
+* :ghpull:`5170`: Added msg_throttle sync=True widget traitlet
+* :ghpull:`5191`: Translate markdown link to rst
+* :ghpull:`5037`: FF Fix: alignment and scale of text widget
+* :ghpull:`5179`: remove websocket url
+* :ghpull:`5110`: add InlineBackend.print_figure_kwargs
+* :ghpull:`5147`: Some template URL changes
+* :ghpull:`5100`: remove base_kernel_url
+* :ghpull:`5163`: Simplify implementation of TemporaryWorkingDirectory.
+* :ghpull:`5166`: remove mktemp usage
+* :ghpull:`5133`: don't use combine option on ucs package
+* :ghpull:`5089`: Remove legacy azure nbmanager
+* :ghpull:`5159`: remove append_json reference
+* :ghpull:`5095`: handle image size metadata in nbconvert html
+* :ghpull:`5156`: fix IPython typo, closes #5155
+* :ghpull:`5150`: fix a link that was broken
+* :ghpull:`5114`: use non-breaking space for button with no description
+* :ghpull:`4778`: add APIs for installing notebook extensions
+* :ghpull:`5125`: Fix the display of functions with keyword-only arguments on Python 3.
+* :ghpull:`5097`: minor notebook logging changes
+* :ghpull:`5047`: only validate package_data when it might be used
+* :ghpull:`5121`: fix remove event in KeyboardManager.register_events
+* :ghpull:`5119`: Removed 'list' view from Variable Inspector example
+* :ghpull:`4925`: Notebook manager api fixes
+* :ghpull:`4996`: require print_method to be a bound method
+* :ghpull:`5108`: require specifying the version for gh-pages
+* :ghpull:`5111`: Minor typo in docstring of IPython.parallel DirectView
+* :ghpull:`5098`: mostly debugging changes for IPython.parallel
+* :ghpull:`5087`: trust cells with no output
+* :ghpull:`5059`: Fix incorrect `Patch` logic in widget code
+* :ghpull:`5075`: More flexible box model fixes
+* :ghpull:`5091`: Provide logging messages in ipcluster log when engine or controllers fail to start
+* :ghpull:`5090`: Print a warning when iptest is run from the IPython source directory
+* :ghpull:`5077`: flush replies when entering an eventloop
+* :ghpull:`5055`: Minimal changes to import IPython from IronPython
+* :ghpull:`5078`: Updating JS tests README.md
+* :ghpull:`5083`: don't create js test directories unless they are being used
+* :ghpull:`5062`: adjust some events in nb_roundtrip
+* :ghpull:`5043`: various unicode / url fixes
+* :ghpull:`5066`: remove (almost) all mentions of pylab from our examples
+* :ghpull:`4977`: ensure scp destination directories exist (with mkdir -p)
+* :ghpull:`5053`: Move&rename JS tests
+* :ghpull:`5067`: show traceback in widget handlers
+* :ghpull:`4920`: Adding PDFFormatter and kernel side handling of PDF display data
+* :ghpull:`5048`: Add edit/command mode indicator
+* :ghpull:`5061`: make execute button in menu bar match shift-enter
+* :ghpull:`5052`: Add q to toggle the pager.
+* :ghpull:`5070`: fix flex: auto
+* :ghpull:`5065`: Add example of using annotations in interact
+* :ghpull:`5063`: another pass on Interact example notebooks
+* :ghpull:`5051`: FF Fix: code cell missing hscroll (2)
+* :ghpull:`4960`: Interact/Interactive for widget
+* :ghpull:`5045`: Clear timeout in multi-press keyboard shortcuts.
+* :ghpull:`5060`: Change 'bind' to 'link'
+* :ghpull:`5039`: Expose kernel_info method on inprocess kernel client
+* :ghpull:`5058`: Fix iopubwatcher.py example script.
+* :ghpull:`5035`: FF Fix: code cell missing hscroll
+* :ghpull:`5040`: Polishing some docs
+* :ghpull:`5001`: Add directory navigation to dashboard
+* :ghpull:`5042`: Remove duplicated Channel ABC classes.
+* :ghpull:`5036`: FF Fix: ext link icon same line as link text in help menu
+* :ghpull:`4975`: setup.py changes for 2.0
+* :ghpull:`4774`: emit event on appended element on dom
+* :ghpull:`5023`: Widgets- add ability to pack and unpack arrays on JS side.
+* :ghpull:`5003`: Fix pretty reprs of super() objects
+* :ghpull:`4974`: make paste focus the pasted cell
+* :ghpull:`5012`: Make `SelectionWidget.values` a dict
+* :ghpull:`5018`: Prevent 'iptest IPython' from trying to run.
+* :ghpull:`5025`: citation2latex filter (using HTMLParser)
+* :ghpull:`5027`: pin lessc to 1.4
+* :ghpull:`4952`: Widget test inconsistencies
+* :ghpull:`5014`: Fix command mode & popup view bug
+* :ghpull:`4842`: more subtle kernel indicator
+* :ghpull:`5017`: Add notebook examples link to help menu.
+* :ghpull:`5015`: don't write cell.trusted to disk
+* :ghpull:`5007`: Update whatsnew doc from PR files
+* :ghpull:`5010`: Fixes for widget alignment in FF
+* :ghpull:`4901`: Add a convenience class to sync traitlet attributes
+* :ghpull:`5008`: updated explanation of 'pyin' messages
+* :ghpull:`5004`: Fix widget vslider spacing
+* :ghpull:`4933`: Small Widget inconsistency fixes
+* :ghpull:`4979`: add versioning notes to small message spec changes
+* :ghpull:`4893`: add font-awesome 3.2.1
+* :ghpull:`4982`: Live readout for slider widgets
+* :ghpull:`4813`: make help menu a template
+* :ghpull:`4939`: Embed qtconsole docs (continued)
+* :ghpull:`4964`: remove shift-= merge keyboard shortcut
+* :ghpull:`4504`: Allow input transformers to raise SyntaxError
+* :ghpull:`4929`: Fixing various modal/focus related bugs
+* :ghpull:`4971`: Fixing issues with js tests
+* :ghpull:`4972`: Work around problem in doctest discovery in Python 3.4 with PyQt
+* :ghpull:`4937`: pickle arrays with dtype=object
+* :ghpull:`4934`: `ipython profile create` respects `--ipython-dir`
+* :ghpull:`4954`: generate unicode filename
+* :ghpull:`4845`: Add Origin Checking.
+* :ghpull:`4916`: Fine tuning the behavior of the modal UI
+* :ghpull:`4966`: Ignore sys.argv for NotebookNotary in tests
+* :ghpull:`4967`: Fix typo in warning about web socket being closed
+* :ghpull:`4965`: Remove mention of iplogger from setup.py
+* :ghpull:`4962`: Fixed typos in quick-help text
+* :ghpull:`4953`: add utils.wait_for_idle in js tests
+* :ghpull:`4870`: ipython_directive, report except/warn in block and add :okexcept: :okwarning: options to suppress
+* :ghpull:`4662`: Menu cleanup
+* :ghpull:`4824`: sign notebooks
+* :ghpull:`4943`: Docs shotgun 4
+* :ghpull:`4848`: avoid import of nearby temporary with %edit
+* :ghpull:`4950`: Two fixes for file upload related bugs
+* :ghpull:`4927`: there shouldn't be a 'files/' prefix in FileLink[s]
+* :ghpull:`4928`: use importlib.machinery when available
+* :ghpull:`4949`: Remove the docscrape modules, which are part of numpydoc
+* :ghpull:`4849`: Various unicode fixes (mostly on Windows)
+* :ghpull:`4932`: always point py3compat.input to builtin_mod.input
+* :ghpull:`4807`: Correct handling of ansi colour codes when nbconverting to latex
+* :ghpull:`4922`: Python nbconvert output shouldn't have output
+* :ghpull:`4912`: Skip some Windows io failures
+* :ghpull:`4919`: flush output before showing tracebacks
+* :ghpull:`4915`: ZMQCompleter inherits from IPCompleter
+* :ghpull:`4890`: better cleanup channel FDs
+* :ghpull:`4880`: set profile name from profile_dir
+* :ghpull:`4853`: fix setting image height/width from metadata
+* :ghpull:`4786`: Reduce spacing of heading cells
+* :ghpull:`4680`: Minimal pandoc version warning
+* :ghpull:`4908`: detect builtin docstrings in oinspect
+* :ghpull:`4911`: Don't use `python -m package` on Windows Python 2
+* :ghpull:`4909`: sort dictionary keys before comparison, ordering is not guaranteed
+* :ghpull:`4374`: IPEP 23: Backbone.js Widgets
+* :ghpull:`4903`: use https for all embeds
+* :ghpull:`4894`: Shortcut changes
+* :ghpull:`4897`: More detailed documentation about kernel_cmd
+* :ghpull:`4891`: Squash a few Sphinx warnings from nbconvert.utils.lexers docstrings
+* :ghpull:`4679`: JPG compression for inline pylab
+* :ghpull:`4708`: Fix indent and center
+* :ghpull:`4789`: fix IPython.embed
+* :ghpull:`4655`: prefer marked to pandoc for markdown2html
+* :ghpull:`4876`: don't show tooltip if object is not found
+* :ghpull:`4873`: use 'combine' option to ucs package
+* :ghpull:`4732`: Accents in notebook names and in command-line (nbconvert)
+* :ghpull:`4867`: Update URL for Lawrence Hall of Science webcam image
+* :ghpull:`4868`: Static path fixes
+* :ghpull:`4858`: fix tb_offset when running a file
+* :ghpull:`4826`: some $.html( -> $.text(
+* :ghpull:`4847`: add js kernel_info request
+* :ghpull:`4832`: allow NotImplementedError in formatters
+* :ghpull:`4803`: BUG: fix cython magic support in ipython_directive
+* :ghpull:`4865`: `build` listed twice in .gitignore. Removing one.
+* :ghpull:`4851`: fix tooltip token regex for single-character names
+* :ghpull:`4846`: Remove some leftover traces of irunner
+* :ghpull:`4820`: fix regex for cleaning old logs with ipcluster
+* :ghpull:`4844`: adjustments to notebook app logging
+* :ghpull:`4840`: Error in Session.send_raw()
+* :ghpull:`4819`: update CodeMirror to 3.21
+* :ghpull:`4823`: Minor fixes for typos/inconsistencies in parallel docs
+* :ghpull:`4811`: document code mirror tab and shift-tab
+* :ghpull:`4795`: merge reveal templates
+* :ghpull:`4796`: update components
+* :ghpull:`4806`: Correct order of packages for unicode in nbconvert to LaTeX
+* :ghpull:`4800`: Qt frontend: Handle 'aborted' prompt replies.
+* :ghpull:`4794`: Compatibility fix for Python3 (Issue #4783 )
+* :ghpull:`4799`: minor js test fix
+* :ghpull:`4788`: warn when notebook is started in pylab mode
+* :ghpull:`4772`: Notebook server info files
+* :ghpull:`4797`: be conservative about kernel_info implementation
+* :ghpull:`4787`: non-python kernels run python code with qtconsole
+* :ghpull:`4565`: various display type validations
+* :ghpull:`4703`: Math macro in jinja templates.
+* :ghpull:`4781`: Fix "Source" text for the "Other Syntax" section of the "Typesetting Math" notebook
+* :ghpull:`4776`: Manually document py3compat module.
+* :ghpull:`4533`: propagate display metadata to all mimetypes
+* :ghpull:`4785`: Replacing a for-in loop by an index loop on an array
+* :ghpull:`4780`: Updating CSS for UI example.
+* :ghpull:`3605`: Modal UI
+* :ghpull:`4758`: Python 3.4 fixes
+* :ghpull:`4735`: add some HTML error pages
+* :ghpull:`4775`: Update whatsnew doc from PR files
+* :ghpull:`4760`: Make examples and docs more Python 3 aware
+* :ghpull:`4773`: Don't wait forever for notebook server to launch/die for tests
+* :ghpull:`4768`: Qt console: Fix _prompt_pos accounting on timer flush output.
+* :ghpull:`4727`: Remove Nbconvert template loading magic
+* :ghpull:`4763`: Set numpydoc options to produce fewer Sphinx warnings.
+* :ghpull:`4770`: always define aliases, even if empty
+* :ghpull:`4766`: add `python -m` entry points for everything
+* :ghpull:`4767`: remove manpages for irunner, iplogger
+* :ghpull:`4751`: Added --post-serve explanation into the nbconvert docs.
+* :ghpull:`4762`: whitelist alphanumeric characters for cookie_name
+* :ghpull:`4625`: Deprecate %profile magic
+* :ghpull:`4745`: warn on failed formatter calls
+* :ghpull:`4746`: remove redundant cls alias on Windows
+* :ghpull:`4749`: Fix bug in determination of public ips.
+* :ghpull:`4715`: restore use of tornado static_url in templates
+* :ghpull:`4748`: fix race condition in profiledir creation.
+* :ghpull:`4720`: never use ssh multiplexer in tunnels
+* :ghpull:`4658`: Bug fix for #4643: Regex object needs to be reset between calls in toolt...
+* :ghpull:`4561`: Add Formatter.pop(type)
+* :ghpull:`4712`: Docs shotgun 3
+* :ghpull:`4713`: Fix saving kernel history in Python 2
+* :ghpull:`4744`: don't use lazily-evaluated rc.ids in wait_for_idle
+* :ghpull:`4740`: %env can't set variables
+* :ghpull:`4737`: check every link when detecting virtualenv
+* :ghpull:`4738`: don't inject help into user_ns
+* :ghpull:`4739`: skip html nbconvert tests when their dependencies are missing
+* :ghpull:`4730`: Fix stripping continuation prompts when copying from Qt console
+* :ghpull:`4725`: Doc fixes
+* :ghpull:`4656`: Nbconvert HTTP service
+* :ghpull:`4710`: make @interactive decorator friendlier with dill
+* :ghpull:`4722`: allow purging local results as long as they are not outstanding
+* :ghpull:`4549`: Updated IPython console lexers.
+* :ghpull:`4570`: Update IPython directive
+* :ghpull:`4719`: Fix comment typo in prefilter.py
+* :ghpull:`4575`: make sure to encode URL components for API requests
+* :ghpull:`4718`: Fixed typo in displaypub
+* :ghpull:`4716`: Remove input_prefilter hook
+* :ghpull:`4691`: survive failure to bind to localhost in zmq.iostream
+* :ghpull:`4696`: don't do anything if add_anchor fails
+* :ghpull:`4711`: some typos in the docs
+* :ghpull:`4700`: use if main block in entry points
+* :ghpull:`4692`: setup.py symlink improvements
+* :ghpull:`4265`: JSON configuration file
+* :ghpull:`4505`: Nbconvert latex markdown images2
+* :ghpull:`4608`: transparent background match ... all colors
+* :ghpull:`4678`: allow ipython console to handle text/plain display
+* :ghpull:`4706`: remove irunner, iplogger
+* :ghpull:`4701`: Delete an old dictionary available for selecting the aligment of text.
+* :ghpull:`4702`: Making reveal font-size a relative unit.
+* :ghpull:`4649`: added a quiet option to %cpaste to suppress output
+* :ghpull:`4690`: Option to spew subprocess streams during tests
+* :ghpull:`4688`: Fixed various typos in docstrings.
+* :ghpull:`4645`: CasperJs utility functions.
+* :ghpull:`4670`: Stop bundling the numpydoc Sphinx extension
+* :ghpull:`4675`: common IPython prefix for ModIndex
+* :ghpull:`4672`: Remove unused 'attic' module
+* :ghpull:`4671`: Fix docstrings in utils.text
+* :ghpull:`4669`: add missing help strings to HistoryManager configurables
+* :ghpull:`4668`: Make non-ASCII docstring unicode
+* :ghpull:`4650`: added a note about sharing of nbconvert templates
+* :ghpull:`4646`: Fixing various output related things:
+* :ghpull:`4665`: check for libedit in readline on OS X
+* :ghpull:`4606`: Make running PYTHONSTARTUP optional
+* :ghpull:`4654`: Fixing left padding of text cells to match that of code cells.
+* :ghpull:`4306`: add raw_mimetype metadata to raw cells
+* :ghpull:`4576`: Tighten up the vertical spacing on cells and make the padding of cells more consistent
+* :ghpull:`4353`: Don't reset the readline completer after each prompt
+* :ghpull:`4567`: Adding prompt area to non-CodeCells to indent content.
+* :ghpull:`4446`: Use SVG plots in OctaveMagic by default due to lack of Ghostscript on Windows Octave
+* :ghpull:`4613`: remove configurable.created
+* :ghpull:`4631`: Use argument lists for command help tests
+* :ghpull:`4633`: Modifies test_get_long_path_name_winr32() to allow for long path names in temp dir
+* :ghpull:`4642`: Allow docs to build without PyQt installed.
+* :ghpull:`4641`: Don't check for wx in the test suite.
+* :ghpull:`4622`: make QtConsole Lexer configurable
+* :ghpull:`4594`: Fixed #2923 Move Save Away from Cut in toolbar
+* :ghpull:`4593`: don't interfere with set_next_input contents in qtconsole
+* :ghpull:`4640`: Support matplotlib's Gtk3 backend in --pylab mode
+* :ghpull:`4639`: Minor import fix to get qtconsole with --pylab=qt working
+* :ghpull:`4637`: Fixed typo in links.txt.
+* :ghpull:`4634`: Fix nbrun in notebooks with non-code cells.
+* :ghpull:`4632`: Restore the ability to run tests from a function.
+* :ghpull:`4624`: Fix crash when $EDITOR is non-ASCII
+* :ghpull:`4453`: Play nice with App Nap
+* :ghpull:`4541`: relax ipconfig matching on Windows
+* :ghpull:`4552`: add pickleutil.use_dill
+* :ghpull:`4590`: Font awesome for IPython slides
+* :ghpull:`4589`: Inherit the width of pre code inside the input code cells.
+* :ghpull:`4588`: Update reveal.js CDN to 2.5.0.
+* :ghpull:`4569`: store cell toolbar preset in notebook metadata
+* :ghpull:`4609`: Fix bytes regex for Python 3.
+* :ghpull:`4581`: Writing unicode to stdout
+* :ghpull:`4591`: Documenting codemirror shorcuts.
+* :ghpull:`4607`: Tutorial doc should link to user config intro
+* :ghpull:`4601`: test that rename fails with 409 if it would clobber
+* :ghpull:`4599`: re-cast int/float subclasses to int/float in json_clean
+* :ghpull:`4542`: new `ipython history clear` subcommand
+* :ghpull:`4568`: don't use lazily-evaluated rc.ids in wait_for_idle
+* :ghpull:`4572`: DOC: %profile docstring should reference %prun
+* :ghpull:`4571`: no longer need 3 suffix on travis, tox
+* :ghpull:`4566`: Fixing cell_type in CodeCell constructor.
+* :ghpull:`4563`: Specify encoding for reading notebook file.
+* :ghpull:`4452`: support notebooks in %run
+* :ghpull:`4546`: fix warning condition on notebook startup
+* :ghpull:`4540`: Apidocs3
+* :ghpull:`4553`: Fix Python 3 handling of urllib
+* :ghpull:`4543`: make hiding of initial namespace optional
+* :ghpull:`4517`: send shutdown_request on exit of `ipython console`
+* :ghpull:`4528`: improvements to bash completion
+* :ghpull:`4532`: Hide dynamically defined metaclass base from Sphinx.
+* :ghpull:`4515`: Spring Cleaning, and  Load speedup
+* :ghpull:`4529`: note routing identities needed for input requests
+* :ghpull:`4514`: allow restart in `%run -d`
+* :ghpull:`4527`: add redirect for 1.0-style 'files/' prefix links
+* :ghpull:`4526`: Allow unicode arguments to passwd_check on Python 2
+* :ghpull:`4403`: Global highlight language selection.
+* :ghpull:`4250`: outputarea.js: Wrap inline SVGs inside an iframe
+* :ghpull:`4521`: Read wav files in binary mode
+* :ghpull:`4444`: Css cleaning
+* :ghpull:`4523`: Use username and password for MongoDB on ShiningPanda
+* :ghpull:`4510`: Update whatsnew from PR files
+* :ghpull:`4441`: add ``setup.py jsversion``
+* :ghpull:`4518`: Fix for race condition in url file decoding.
+* :ghpull:`4497`: don't automatically unpack datetime objects in the message spec
+* :ghpull:`4506`: wait for empty queues as well as load-balanced tasks
+* :ghpull:`4492`: Configuration docs refresh
+* :ghpull:`4508`: Fix some uses of map() in Qt console completion code.
+* :ghpull:`4498`: Daemon StreamCapturer
+* :ghpull:`4499`: Skip clipboard test on unix systems if headless.
+* :ghpull:`4460`: Better clipboard handling, esp. with pywin32
+* :ghpull:`4496`: Pass nbformat object to write call to save .py script
+* :ghpull:`4466`: various pandoc latex fixes
+* :ghpull:`4473`: Setup for Python 2/3
+* :ghpull:`4459`: protect against broken repr in lib.pretty
+* :ghpull:`4457`: Use ~/.ipython as default config directory
+* :ghpull:`4489`: check realpath of env in init_virtualenv
+* :ghpull:`4490`: fix possible race condition in test_await_data
+* :ghpull:`4476`: Fix: Remove space added by display(JavaScript) on page reload
+* :ghpull:`4398`: [Notebook] Deactivate tooltip on tab by default.
+* :ghpull:`4480`: Docs shotgun 2
+* :ghpull:`4488`: fix typo in message spec doc
+* :ghpull:`4479`: yet another JS race condition fix
+* :ghpull:`4477`: Allow incremental builds of the html_noapi docs target
+* :ghpull:`4470`: Various Config object cleanups
+* :ghpull:`4410`: make close-and-halt work on new tabs in Chrome
+* :ghpull:`4469`: Python 3 & getcwdu
+* :ghpull:`4451`: fix: allow JS test to run after shutdown test
+* :ghpull:`4456`: Simplify StreamCapturer for subprocess testing
+* :ghpull:`4464`: Correct description for Bytes traitlet type
+* :ghpull:`4465`: Clean up MANIFEST.in
+* :ghpull:`4461`: Correct TypeError message in svg2pdf
+* :ghpull:`4458`: use signalstatus if exit status is undefined
+* :ghpull:`4438`: Single codebase Python 3 support (again)
+* :ghpull:`4198`: Version conversion, support for X to Y even if Y < X (nbformat)
+* :ghpull:`4415`: More tooltips in the Notebook menu
+* :ghpull:`4450`: remove monkey patch for older versions of tornado
+* :ghpull:`4423`: Fix progress bar and scrolling bug.
+* :ghpull:`4435`: raise 404 on not found static file
+* :ghpull:`4442`: fix and add shim for change introduce by #4195
+* :ghpull:`4436`: allow `require("nbextensions/extname")` to load from IPYTHONDIR/nbextensions
+* :ghpull:`4437`: don't compute etags in static file handlers
+* :ghpull:`4427`: notebooks should always have one checkpoint
+* :ghpull:`4425`: fix js pythonisme
+* :ghpull:`4195`: IPEP 21:  widget messages
+* :ghpull:`4434`: Fix broken link for Dive Into Python.
+* :ghpull:`4428`: bump minimum tornado version to 3.1.0
+* :ghpull:`4302`: Add an Audio display class
+* :ghpull:`4285`: Notebook javascript test suite using CasperJS
+* :ghpull:`4420`: Allow checking for backports via milestone
+* :ghpull:`4426`: set kernel cwd to notebook's directory
+* :ghpull:`4389`: By default, Magics inherit from Configurable
+* :ghpull:`4393`: Capture output from subprocs during test, and display on failure
+* :ghpull:`4419`: define InlineBackend configurable in its own file
+* :ghpull:`4303`: Multidirectory support for the Notebook
+* :ghpull:`4371`: Restored ipython profile locate dir and fixed typo. (Fixes #3708).
+* :ghpull:`4414`: Specify unicode type properly in rmagic
+* :ghpull:`4413`: don't instantiate IPython shell as class attr
+* :ghpull:`4400`: Remove 5s wait on inactivity on GUI inputhook loops
+* :ghpull:`4412`: Fix traitlet _notify_trait by-ref issue
+* :ghpull:`4378`: split adds new cell above, rather than below
+* :ghpull:`4405`: Bring display of builtin types and functions in line with Py 2
+* :ghpull:`4367`: clean up of documentation files
+* :ghpull:`4401`: Provide a name of the HistorySavingThread
+* :ghpull:`4384`: fix menubar height measurement
+* :ghpull:`4377`: fix tooltip cancel
+* :ghpull:`4293`: Factorise code in tooltip for julia monkeypatching
+* :ghpull:`4292`: improve js-completer logic.
+* :ghpull:`4363`: set_next_input: keep only last input when repeatedly called in a single cell
+* :ghpull:`4382`: Use safe_hasattr in dir2
+* :ghpull:`4379`: fix (CTRL-M -) shortcut for splitting cell in FF
+* :ghpull:`4380`: Test and fixes for localinterfaces
+* :ghpull:`4372`: Don't assume that SyntaxTB is always called with a SyntaxError
+* :ghpull:`4342`: Return value directly from the try block and avoid a variable
+* :ghpull:`4154`: Center LaTeX and figures in markdown
+* :ghpull:`4311`: %load -s to load specific functions or classes
+* :ghpull:`4350`: WinHPC launcher fixes
+* :ghpull:`4345`: Make irunner compatible with upcoming pexpect 3.0 interface
+* :ghpull:`4276`: Support container methods in config
+* :ghpull:`4359`: test_pylabtools also needs to modify matplotlib.rcParamsOrig
+* :ghpull:`4355`: remove hardcoded box-orient
+* :ghpull:`4333`: Add Edit Notebook Metadata to Edit menu
+* :ghpull:`4349`: Script to update What's New file
+* :ghpull:`4348`: Call PDF viewer after latex compiling (nbconvert)
+* :ghpull:`4346`: getpass() on Windows & Python 2 needs bytes prompt
+* :ghpull:`4304`: use netifaces for faster IPython.utils.localinterfaces
+* :ghpull:`4305`: Add even more ways to populate localinterfaces
+* :ghpull:`4313`: remove strip_math_space
+* :ghpull:`4325`: Some changes to improve readability.
+* :ghpull:`4281`: Adjust tab completion widget if too close to bottom of page.
+* :ghpull:`4347`: Remove pycolor script
+* :ghpull:`4322`: Scroll to the top after change of slides in the IPython slides
+* :ghpull:`4289`: Fix scrolling output (not working post clear_output changes)
+* :ghpull:`4343`: Make parameters for kernel start method more general
+* :ghpull:`4237`: Keywords should shadow magic functions
+* :ghpull:`4338`: adjust default value of level in sync_imports
+* :ghpull:`4328`: Remove unused loop variable.
+* :ghpull:`4340`: fix mathjax download url to new GitHub format
+* :ghpull:`4336`: use simple replacement rather than string formatting in format_kernel_cmd
+* :ghpull:`4264`: catch unicode error listing profiles
+* :ghpull:`4314`: catch EACCES when binding notebook app
+* :ghpull:`4324`: Remove commented addthis toolbar
+* :ghpull:`4327`: Use the with statement to open a file.
+* :ghpull:`4318`: fix initial sys.path
+* :ghpull:`4315`: Explicitly state what version of Pandoc is supported in docs/install
+* :ghpull:`4316`: underscore missing on notebook_p4
+* :ghpull:`4295`: Implement boundary option for load magic (#1093) 
+* :ghpull:`4300`: traits defauts are strings not object
+* :ghpull:`4297`: Remove an unreachable return statement.
+* :ghpull:`4260`: Use subprocess for system_raw
+* :ghpull:`4277`: add nbextensions
+* :ghpull:`4294`: don't require tornado 3 in `--post serve`
+* :ghpull:`4270`: adjust Scheduler timeout logic
+* :ghpull:`4278`: add `-a` to easy_install command in libedit warning
+* :ghpull:`4282`: Enable automatic line breaks in MathJax.
+* :ghpull:`4279`: Fixing line-height of list items in tree view.
+* :ghpull:`4253`: fixes #4039.
+* :ghpull:`4131`: Add module's name argument in %%cython magic
+* :ghpull:`4269`: Add mathletters option and longtable package to latex_base.tplx
+* :ghpull:`4230`: Switch correctly to the user's default matplotlib backend after inline.
+* :ghpull:`4271`: Hopefully fix ordering of output on ShiningPanda
+* :ghpull:`4239`: more informative error message for bad serialization
+* :ghpull:`4263`: Fix excludes for IPython.testing
+* :ghpull:`4112`: nbconvert: Latex template refactor
+* :ghpull:`4261`: Fixing a formatting error in the custom display example notebook.
+* :ghpull:`4259`: Fix Windows test exclusions
+* :ghpull:`4229`: Clear_output: Animation & widget related changes.
+* :ghpull:`4151`: Refactor alias machinery
+* :ghpull:`4153`: make timeit return an object that contains values
+* :ghpull:`4258`: to-backport label is now 1.2
+* :ghpull:`4242`: Allow passing extra arguments to iptest through for nose
+* :ghpull:`4257`: fix unicode argv parsing
+* :ghpull:`4166`: avoid executing code in utils.localinterfaces at import time
+* :ghpull:`4214`: engine ID metadata should be unicode, not bytes
+* :ghpull:`4232`: no highlight if no language specified
+* :ghpull:`4218`: Fix display of SyntaxError when .py file is modified
+* :ghpull:`4207`: add ``setup.py css`` command
+* :ghpull:`4224`: clear previous callbacks on execute
+* :ghpull:`4180`: Iptest refactoring
+* :ghpull:`4105`: JS output area misaligned
+* :ghpull:`4220`: Various improvements to docs formatting
+* :ghpull:`4187`: Select adequate highlighter for cell magic languages
+* :ghpull:`4228`: update -dev docs to reflect latest stable version
+* :ghpull:`4219`: Drop bundled argparse
+* :ghpull:`3851`: Adds an explicit newline for pretty-printing.
+* :ghpull:`3622`: Drop fakemodule
+* :ghpull:`4080`: change default behavior of database task storage
+* :ghpull:`4197`: enable cython highlight in notebook
+* :ghpull:`4225`: Updated docstring for core.display.Image
+* :ghpull:`4175`: nbconvert: Jinjaless exporter base
+* :ghpull:`4208`: Added a lightweight "htmlcore" Makefile entry
+* :ghpull:`4209`: Magic doc fixes
+* :ghpull:`4217`: avoid importing numpy at the module level
+* :ghpull:`4213`: fixed dead link in examples/notebooks readme to Part 3
+* :ghpull:`4183`: ESC should be handled by CM if tooltip is not on
+* :ghpull:`4193`: Update for #3549: Append Firefox overflow-x fix
+* :ghpull:`4205`: use TextIOWrapper when communicating with pandoc subprocess
+* :ghpull:`4204`: remove some extraneous print statements from IPython.parallel
+* :ghpull:`4201`: HeadingCells cannot be split or merged
+* :ghpull:`4048`: finish up speaker-notes PR
+* :ghpull:`4079`: trigger `Kernel.status_started` after websockets open
+* :ghpull:`4186`: moved DummyMod to proper namespace to enable dill pickling
+* :ghpull:`4190`: update version-check message in setup.py and IPython.__init__
+* :ghpull:`4188`: Allow user_ns trait to be None
+* :ghpull:`4189`: always fire LOCAL_IPS.extend(PUBLIC_IPS)
+* :ghpull:`4174`: various issues in markdown and rst templates
+* :ghpull:`4178`: add missing data_javascript
+* :ghpull:`4168`: Py3 failing tests
+* :ghpull:`4181`: nbconvert: Fix, sphinx template not removing new lines from headers
+* :ghpull:`4043`: don't 'restore_bytes' in from_JSON
+* :ghpull:`4149`: reuse more kernels in kernel tests
+* :ghpull:`4163`: Fix for incorrect default encoding on Windows.
+* :ghpull:`4136`: catch javascript errors in any output
+* :ghpull:`4171`: add nbconvert config file when creating profiles
+* :ghpull:`4172`: add ability to check what PRs should be backported in backport_pr
+* :ghpull:`4167`: --fast flag for test suite!
+* :ghpull:`4125`: Basic exercise of `ipython [subcommand] -h` and help-all
+* :ghpull:`4085`: nbconvert: Fix sphinx preprocessor date format string for Windows
+* :ghpull:`4159`: don't split `.cell` and `div.cell` CSS
+* :ghpull:`4165`: Remove use of parametric tests
+* :ghpull:`4158`: generate choices for `--gui` configurable from real mapping
+* :ghpull:`4083`: Implement a better check for hidden values for %who etc.
+* :ghpull:`4147`: Reference notebook examples, fixes #4146.
+* :ghpull:`4065`: do not include specific css in embedable one
+* :ghpull:`4092`: nbconvert: Fix for unicode html headers, Windows + Python 2.x
+* :ghpull:`4074`: close Client sockets if connection fails
+* :ghpull:`4064`: Store default codemirror mode in only 1 place
+* :ghpull:`4104`: Add way to install MathJax to a particular profile
+* :ghpull:`4161`: Select name when renaming a notebook
+* :ghpull:`4160`: Add quotes around ".[notebook]" in readme
+* :ghpull:`4144`: help_end transformer shouldn't pick up ? in multiline string
+* :ghpull:`4090`: Add LaTeX citation handling to nbconvert
+* :ghpull:`4143`: update example custom.js
+* :ghpull:`4142`: DOC: unwrap openssl line in public_server doc
+* :ghpull:`4126`: update tox.ini
+* :ghpull:`4141`: add files with a separate `add` call in backport_pr
+* :ghpull:`4137`: Restore autorestore option for storemagic
+* :ghpull:`4098`: pass profile-dir instead of profile name to Kernel
+* :ghpull:`4120`: support `input` in Python 2 kernels
+* :ghpull:`4088`: nbconvert: Fix coalescestreams line with incorrect nesting causing strange behavior
+* :ghpull:`4060`: only strip continuation prompts if regular prompts seen first
+* :ghpull:`4132`: Fixed name error bug in function safe_unicode in module py3compat.
+* :ghpull:`4121`: move test_kernel from IPython.zmq to IPython.kernel
+* :ghpull:`4118`: ZMQ heartbeat channel: catch EINTR exceptions and continue.
+* :ghpull:`4070`: New changes should go into pr/ folder
+* :ghpull:`4054`: use unicode for HTML export
+* :ghpull:`4106`: fix a couple of default block values
+* :ghpull:`4107`: update parallel magic tests with capture_output API
+* :ghpull:`4102`: Fix clashes between debugger tests and coverage.py
+* :ghpull:`4115`: Update docs on declaring a magic function
+* :ghpull:`4101`: restore accidentally removed EngineError
+* :ghpull:`4096`: minor docs changes
+* :ghpull:`4094`: Update target branch before backporting PR
+* :ghpull:`4069`: Drop monkeypatch for pre-1.0 nose
+* :ghpull:`4056`: respect `pylab_import_all` when `--pylab` specified at the command-line
+* :ghpull:`4091`: Make Qt console banner configurable
+* :ghpull:`4086`: fix missing errno import
+* :ghpull:`4084`: Use msvcrt.getwch() for Windows pager.
+* :ghpull:`4073`: rename ``post_processors`` submodule to ``postprocessors``
+* :ghpull:`4075`: Update supported Python versions in tools/test_pr
+* :ghpull:`4068`: minor bug fix, define 'cell' in dialog.js.
+* :ghpull:`4044`: rename call methods to transform and postprocess
+* :ghpull:`3744`: capture rich output as well as stdout/err in capture_output
+* :ghpull:`3969`: "use strict" in most (if not all) our javascript
+* :ghpull:`4030`: exclude `.git` in MANIFEST.in
+* :ghpull:`4047`: Use istype() when checking if canned object is a dict
+* :ghpull:`4031`: don't close_fds on Windows
+* :ghpull:`4029`: bson.Binary moved
+* :ghpull:`3883`: skip test on unix when x11 not available
+* :ghpull:`3863`: Added working speaker notes for slides.
+* :ghpull:`4035`: Fixed custom jinja2 templates being ignored when setting template_path
+* :ghpull:`4002`: Drop Python 2.6 and 3.2
+* :ghpull:`4026`: small doc fix in nbconvert
+* :ghpull:`4016`: Fix IPython.start_* functions
+* :ghpull:`4021`: Fix parallel.client.View map() on numpy arrays
+* :ghpull:`4022`: DOC: fix links to matplotlib, notebook docs
+* :ghpull:`4018`: Fix warning when running IPython.kernel tests
+* :ghpull:`4017`: Add REPL-like printing of final/return value to %%R cell magic
+* :ghpull:`4019`: Test skipping without unicode paths
+* :ghpull:`4008`: Transform code before %prun/%%prun runs
+* :ghpull:`4014`: Fix typo in ipapp
+* :ghpull:`3997`: DOC: typos + rewording in examples/notebooks/Cell Magics.ipynb
+* :ghpull:`3914`: nbconvert: Transformer tests
+* :ghpull:`3987`: get files list in backport_pr
+* :ghpull:`3923`: nbconvert: Writer tests
+* :ghpull:`3974`: nbconvert: Fix app tests on Window7 w/ Python 3.3
+* :ghpull:`3937`: make tab visible in codemirror and light red background
+* :ghpull:`3933`: nbconvert: Post-processor tests
+* :ghpull:`3978`: fix `--existing` with non-localhost IP
+* :ghpull:`3939`: minor checkpoint cleanup
+* :ghpull:`3955`: complete on % for magic in notebook
+* :ghpull:`3981`: BF: fix nbconert rst input prompt spacing
+* :ghpull:`3960`: Don't make sphinx a dependency for importing nbconvert
+* :ghpull:`3973`: logging.Formatter is not new-style in 2.6
+
+Issues (434):
+
+* :ghissue:`5476`: For 2.0: Fix links in Notebook Help Menu
+* :ghissue:`5337`: Examples reorganization
+* :ghissue:`5436`: CodeMirror shortcuts in QuickHelp
+* :ghissue:`5444`: Fix numeric verification for Int and Float text widgets.
+* :ghissue:`5443`: Int and Float Widgets don't allow negative signs
+* :ghissue:`5449`: Stretch keyboard shortcut dialog
+* :ghissue:`5471`: Add coding magic comment to nbconvert Python template
+* :ghissue:`5470`: UTF-8 Issue When Converting Notebook to a Script.
+* :ghissue:`5369`: FormatterWarning for SVG matplotlib output in notebook
+* :ghissue:`5460`: Can't start the notebook server specifying a notebook
+* :ghissue:`2918`: CodeMirror related issues.
+* :ghissue:`5431`: update github_stats and gh_api for 2.0
+* :ghissue:`4887`: Add tests for modal UI
+* :ghissue:`5290`: Add dual mode JS tests
+* :ghissue:`5448`: Cmd+/ shortcut doesn't work in IPython master
+* :ghissue:`5447`: Add %%python2 cell magic
+* :ghissue:`5442`: Make a "python2" alias or rename the "python"cell magic.
+* :ghissue:`2495`: non-ascii characters in the path
+* :ghissue:`4554`: dictDB: Exception due to str to datetime comparission
+* :ghissue:`5006`: Comm code is not run in the same context as notebook code
+* :ghissue:`5118`: Weird interact behavior
+* :ghissue:`5401`: Empty code cells in nbconvert rst output cause problems
+* :ghissue:`5434`: fix check for empty cells in rst template
+* :ghissue:`4944`: Trouble finding ipynb path in Windows 8
+* :ghissue:`4605`: Change the url of Editor Shorcuts in the notebook menu.
+* :ghissue:`5425`: Update COPYING.txt
+* :ghissue:`5348`: BUG: HistoryAccessor.get_session_info(0) - exception
+* :ghissue:`5293`: Javascript("element.append()") looks broken.
+* :ghissue:`5363`: Disable saving if notebook has stopped loading
+* :ghissue:`5189`: Tooltip pager mode is broken
+* :ghissue:`5330`: Updates to shell reference doc
+* :ghissue:`5397`: Accordion widget broken
+* :ghissue:`5106`: Flexbox CSS specificity bugs
+* :ghissue:`5297`: tooltip triggers focus bug
+* :ghissue:`5417`: scp checking for existence of directories: directory names are incorrect
+* :ghissue:`5302`: Parallel engine registration fails for slow engines
+* :ghissue:`5334`: notebook's split-cell shortcut dangerous / incompatible with Neo layout (for instance)
+* :ghissue:`5324`: Style of `raw_input` UI is off in notebook
+* :ghissue:`5350`: Converting notebooks with spaces in their names to RST gives broken images
+* :ghissue:`5049`: update quickhelp on adding and removing shortcuts
+* :ghissue:`4941`: Eliminating display of intermediate stages in progress bars
+* :ghissue:`5345`: nbconvert to markdown does not use backticks
+* :ghissue:`5357`: catch exception in copystat
+* :ghissue:`5351`: Notebook saving fails on smb share
+* :ghissue:`4946`: TeX produced cannot be converted to PDF
+* :ghissue:`5347`: pretty print list too slow
+* :ghissue:`5238`: Raw cell placeholder is not removed when you edit the cell
+* :ghissue:`5382`: Qtconsole doesn't run in Python 3
+* :ghissue:`5378`: Unexpected and new conflict between PyFileConfigLoader and IPythonQtConsoleApp
+* :ghissue:`4945`: Heading/cells positioning problem and cell output wrapping
+* :ghissue:`5084`: Consistent approach for HTML/JS output on nbviewer
+* :ghissue:`4902`: print preview does not work, custom.css not found
+* :ghissue:`5336`: TypeError in bootstrap-tour.min.js
+* :ghissue:`5303`: Changed Hub.registration_timeout to be a config input.
+* :ghissue:`995`: Paste-able mode in terminal
+* :ghissue:`5305`: Tuple unpacking for shell escape
+* :ghissue:`5232`: Make nbconvert html full output like notebook's html.
+* :ghissue:`5224`: Audit nbconvert HTML output
+* :ghissue:`5253`: display any output from this session in terminal console
+* :ghissue:`5251`: ipython console ignoring some stream messages?
+* :ghissue:`4802`: Tour of the notebook UI (was UI elements inline with highlighting)
+* :ghissue:`5103`: Moving Constructor definition to the top like a Function definition
+* :ghissue:`5264`: Test failures on master with Anaconda
+* :ghissue:`4833`: Serve /usr/share/javascript at /_sysassets/javascript/ in notebook
+* :ghissue:`5071`: Prevent %pylab from clobbering interactive
+* :ghissue:`5282`: Exception in widget __del__ methods in Python 3.4.
+* :ghissue:`5280`: append Firefox overflow-x fix
+* :ghissue:`5120`: append Firefox overflow-x fix, again
+* :ghissue:`4127`: autoreload shouldn't rely on .pyc modification times
+* :ghissue:`5272`: allow highlighting language to be set from notebook metadata
+* :ghissue:`5050`: Notebook cells truncated with Firefox
+* :ghissue:`4839`: Error in Session.send_raw()
+* :ghissue:`5188`: New events system
+* :ghissue:`5076`: Refactor keyboard handling
+* :ghissue:`4886`: Refactor and consolidate different keyboard logic in JavaScript code
+* :ghissue:`5002`: the green cell border moving forever in Chrome, when there are many code cells.
+* :ghissue:`5259`: Codemirror still active in command mode
+* :ghissue:`5219`: Output images appear as small thumbnails (Notebook)
+* :ghissue:`4829`: Not able to connect qtconsole in Windows 8
+* :ghissue:`5152`: Hide __pycache__ in dashboard directory list
+* :ghissue:`5151`: Case-insesitive sort for dashboard list
+* :ghissue:`4603`: Warn when overwriting a notebook with upload
+* :ghissue:`4895`: Improvements to %run completions
+* :ghissue:`3459`: Filename completion when run script with %run
+* :ghissue:`5225`: Add JavaScript to nbconvert HTML display priority
+* :ghissue:`5034`: Audit the places where we call `.html(something)`
+* :ghissue:`5094`: Dancing cells in notebook
+* :ghissue:`4999`: Notebook focus effects
+* :ghissue:`5149`: Clicking on a TextBoxWidget in FF completely breaks dual mode.
+* :ghissue:`5207`: Children fire event
+* :ghissue:`5227`: display_method of objects with custom __getattr__
+* :ghissue:`5236`: Cursor keys do not work to leave Markdown cell while it's being edited
+* :ghissue:`5205`: Use CTuple traitlet for Widget children
+* :ghissue:`5230`: notebook rename does not respect url prefix
+* :ghissue:`5218`: Test failures with Python 3 and enabled warnings
+* :ghissue:`5115`: Page Breaks for Print Preview Broken by display: flex - Simple CSS Fix
+* :ghissue:`5024`: Make nbconvert HTML output smart about page breaking
+* :ghissue:`4985`: Add automatic Closebrackets function to Codemirror.
+* :ghissue:`5184`: print '\xa' crashes the interactive shell
+* :ghissue:`5214`: Downloading notebook as Python (.py) fails
+* :ghissue:`5211`: AttributeError: 'module' object has no attribute '_outputfile'
+* :ghissue:`5206`: [CSS?] Inconsistencies in nbconvert divs and IPython Notebook divs?
+* :ghissue:`5201`: node != nodejs within Debian packages
+* :ghissue:`5112`: band-aid for completion
+* :ghissue:`4860`: Completer As-You-Type Broken
+* :ghissue:`5116`: reorganize who knows what about paths
+* :ghissue:`4973`: Adding security.js with 1st attempt at is_safe
+* :ghissue:`5164`: test_oinspect.test_calltip_builtin failure with python3.4
+* :ghissue:`5127`: Widgets: skip intermediate callbacks during throttling
+* :ghissue:`5013`: Widget alignment differs between FF and Chrome
+* :ghissue:`5141`: tornado error static file
+* :ghissue:`5160`: TemporaryWorkingDirectory incompatible with python3.4
+* :ghissue:`5140`: WIP: %kernels magic
+* :ghissue:`4987`: Widget lifecycle problems
+* :ghissue:`5129`: UCS package break latex export on non-ascii 
+* :ghissue:`4986`: Cell horizontal scrollbar is missing in FF but not in Chrome
+* :ghissue:`4685`: nbconvert ignores image size metadata
+* :ghissue:`5155`: Notebook logout button does not work (source typo)
+* :ghissue:`2678`: Ctrl-m keyboard shortcut clash on Chrome OS
+* :ghissue:`5113`: ButtonWidget without caption wrong height.
+* :ghissue:`4778`: add APIs for installing notebook extensions
+* :ghissue:`5046`: python setup.py failed vs git submodule update worked
+* :ghissue:`4925`: Notebook manager api fixes
+* :ghissue:`5073`: Cannot align widgets horizontally in the notebook
+* :ghissue:`4996`: require print_method to be a bound method
+* :ghissue:`4990`: _repr_html_ exception reporting corner case when using type(foo)
+* :ghissue:`5099`: Notebook: Changing base_project_url results in failed WebSockets call
+* :ghissue:`5096`: Client.map is not fault tolerant
+* :ghissue:`4997`: Inconsistent %matplotlib qt behavior
+* :ghissue:`5041`: Remove more .html(...) calls.
+* :ghissue:`5078`: Updating JS tests README.md
+* :ghissue:`4977`: ensure scp destination directories exist (with mkdir -p)
+* :ghissue:`3411`: ipython parallel: scp failure.
+* :ghissue:`5064`: Errors during interact display at the terminal, not anywhere in the notebook
+* :ghissue:`4921`: Add PDF formatter and handling
+* :ghissue:`4920`: Adding PDFFormatter and kernel side handling of PDF display data
+* :ghissue:`5048`: Add edit/command mode indicator
+* :ghissue:`4889`: Add UI element for indicating command/edit modes
+* :ghissue:`5052`: Add q to toggle the pager.
+* :ghissue:`5000`: Closing pager with keyboard in modal UI
+* :ghissue:`5069`: Box model changes broke the Keyboard Shortcuts help modal
+* :ghissue:`4960`: Interact/Interactive for widget
+* :ghissue:`4883`: Implement interact/interactive for widgets
+* :ghissue:`5038`: Fix multiple press keyboard events
+* :ghissue:`5054`: UnicodeDecodeError: 'ascii' codec can't decode byte 0xc6 in position 1: ordinal not in range(128)
+* :ghissue:`5031`: Bug during integration of IPython console in Qt application
+* :ghissue:`5057`: iopubwatcher.py example is broken.
+* :ghissue:`4747`: Add event for output_area adding an output
+* :ghissue:`5001`: Add directory navigation to dashboard
+* :ghissue:`5016`: Help menu external-link icons break layout in FF
+* :ghissue:`4885`: Modal UI behavior changes
+* :ghissue:`5009`: notebook signatures don't work
+* :ghissue:`4975`: setup.py changes for 2.0
+* :ghissue:`4774`: emit event on appended element on dom
+* :ghissue:`5020`: Python Lists translated to javascript objects in widgets
+* :ghissue:`5003`: Fix pretty reprs of super() objects
+* :ghissue:`5012`: Make `SelectionWidget.values` a dict
+* :ghissue:`4961`: Bug when constructing a selection widget with both values and labels
+* :ghissue:`4283`: A `<` in a markdown cell strips cell content when converting to latex
+* :ghissue:`4006`: iptest IPython broken
+* :ghissue:`4251`: & escaped to &amp; in tex ?
+* :ghissue:`5027`: pin lessc to 1.4
+* :ghissue:`4323`: Take 2: citation2latex filter (using HTMLParser)
+* :ghissue:`4196`: Printing notebook from browser gives 1-page truncated output
+* :ghissue:`4842`: more subtle kernel indicator
+* :ghissue:`4057`: No path to notebook examples from Help menu
+* :ghissue:`5015`: don't write cell.trusted to disk
+* :ghissue:`4617`: Changed url link in Help dropdown menu.
+* :ghissue:`4976`: Container widget layout broken on Firefox
+* :ghissue:`4981`: Vertical slider layout broken
+* :ghissue:`4793`: Message spec changes related to `clear_output`
+* :ghissue:`4982`: Live readout for slider widgets
+* :ghissue:`4813`: make help menu a template
+* :ghissue:`4989`: Filename tab completion completely broken
+* :ghissue:`1380`: Tab should insert 4 spaces in # comment lines
+* :ghissue:`2888`: spaces vs tabs
+* :ghissue:`1193`: Allow resizing figures in notebook
+* :ghissue:`4504`: Allow input transformers to raise SyntaxError
+* :ghissue:`4697`: Problems with height after toggling header and toolbar...
+* :ghissue:`4951`: TextWidget to code cell command mode bug.
+* :ghissue:`4809`: Arbitrary scrolling (jumping) in clicks in modal UI for notebook
+* :ghissue:`4971`: Fixing issues with js tests
+* :ghissue:`4972`: Work around problem in doctest discovery in Python 3.4 with PyQt
+* :ghissue:`4892`: IPython.qt test failure with python3.4
+* :ghissue:`4863`: BUG: cannot create an OBJECT array from memory buffer
+* :ghissue:`4704`: Subcommand `profile` ignores --ipython-dir 
+* :ghissue:`4845`: Add Origin Checking.
+* :ghissue:`4870`: ipython_directive, report except/warn in block and add :okexcept: :okwarning: options to suppress
+* :ghissue:`4956`: Shift-Enter does not move to next cell
+* :ghissue:`4662`: Menu cleanup
+* :ghissue:`4824`: sign notebooks
+* :ghissue:`4848`: avoid import of nearby temporary with %edit
+* :ghissue:`4731`: %edit files mistakenly import modules in /tmp
+* :ghissue:`4950`: Two fixes for file upload related bugs
+* :ghissue:`4871`: Notebook upload fails after Delete
+* :ghissue:`4825`: File Upload URL set incorrectly
+* :ghissue:`3867`: display.FileLinks should work in the exported html verion of a notebook
+* :ghissue:`4948`: reveal: ipython css overrides reveal themes
+* :ghissue:`4947`: reveal: slides that are too big?
+* :ghissue:`4051`: Test failures with Python 3 and enabled warnings
+* :ghissue:`3633`: outstanding issues over in ipython/nbconvert repo
+* :ghissue:`4087`: Sympy printing in the example notebook
+* :ghissue:`4627`: Document various QtConsole embedding approaches.
+* :ghissue:`4849`: Various unicode fixes (mostly on Windows)
+* :ghissue:`3653`: autocompletion in "from package import <tab>"
+* :ghissue:`4583`: overwrite? prompt gets EOFError in 2 process
+* :ghissue:`4807`: Correct handling of ansi colour codes when nbconverting to latex
+* :ghissue:`4611`: Document how to compile .less files in dev docs.
+* :ghissue:`4618`: "Editor Shortcuts" link is broken in help menu dropdown notebook
+* :ghissue:`4522`: DeprecationWarning: the sets module is deprecated
+* :ghissue:`4368`: No symlink from ipython to ipython3 when inside a python3 virtualenv
+* :ghissue:`4234`: Math without $$ doesn't show up when converted to slides
+* :ghissue:`4194`: config.TerminalIPythonApp.nosep does not work
+* :ghissue:`1491`: prefilter not called for multi-line notebook cells
+* :ghissue:`4001`: Windows IPython executable /scripts/ipython not working
+* :ghissue:`3959`: think more carefully about text wrapping in nbconvert
+* :ghissue:`4907`: Test for traceback depth fails on Windows
+* :ghissue:`4906`: Test for IPython.embed() fails on Windows
+* :ghissue:`4912`: Skip some Windows io failures
+* :ghissue:`3700`: stdout/stderr should be flushed printing exception output... 
+* :ghissue:`1181`: greedy completer bug in terminal console
+* :ghissue:`2032`: check for a few places we should be using DEFAULT_ENCODING
+* :ghissue:`4882`: Too many files open when starting and stopping kernel repeatedly
+* :ghissue:`4880`: set profile name from profile_dir
+* :ghissue:`4238`: parallel.Client() not using profile that notebook was run with?
+* :ghissue:`4853`: fix setting image height/width from metadata
+* :ghissue:`4786`: Reduce spacing of heading cells
+* :ghissue:`4680`: Minimal pandoc version warning
+* :ghissue:`3707`: nbconvert: Remove IPython magic commands from --format="python" output
+* :ghissue:`4130`: PDF figures as links from png or svg figures
+* :ghissue:`3919`: Allow --profile to be passed a dir.
+* :ghissue:`2136`: Handle hard newlines in pretty printer
+* :ghissue:`4790`: Notebook modal UI: "merge cell below" key binding, `shift+=`, does not work with some keyboard layouts
+* :ghissue:`4884`: Keyboard shortcut changes
+* :ghissue:`1184`: slow handling of keyboard input
+* :ghissue:`4913`: Mathjax, Markdown, tex, env* and italic
+* :ghissue:`3972`: nbconvert: Template output testing
+* :ghissue:`4903`: use https for all embeds
+* :ghissue:`4874`: --debug does not work if you set .kernel_cmd
+* :ghissue:`4679`: JPG compression for inline pylab
+* :ghissue:`4708`: Fix indent and center
+* :ghissue:`4789`: fix IPython.embed
+* :ghissue:`4759`: Application._load_config_files log parameter default fails
+* :ghissue:`3153`: docs / file menu: explain how to exit the notebook
+* :ghissue:`4791`: Did updates to ipython_directive bork support for cython magic snippets?
+* :ghissue:`4385`: "Part 4 - Markdown Cells.ipynb" nbviewer example seems not well referenced in current online documentation page https://ipython.org/ipython-doc/stable/interactive/notebook.htm
+* :ghissue:`4655`: prefer marked to pandoc for markdown2html
+* :ghissue:`3441`: Fix focus related problems in the notebook
+* :ghissue:`3402`: Feature Request: Save As (latex, html,..etc) as a menu option in Notebook rather than explicit need to invoke nbconvert
+* :ghissue:`3224`: Revisit layout of notebook area
+* :ghissue:`2746`: rerunning a cell with long output (exception) scrolls to much (html notebook)
+* :ghissue:`2667`: can't save opened notebook if accidentally delete the notebook in the dashboard
+* :ghissue:`3026`: Reporting errors from _repr_<type>_ methods
+* :ghissue:`1844`: Notebook does not exist and permalinks
+* :ghissue:`2450`: [closed PR] Prevent jumping of window to input when output is clicked.
+* :ghissue:`3166`: IPEP 16: Notebook multi directory dashboard and URL mapping
+* :ghissue:`3691`: Slight misalignment of Notebook menu bar with focus box
+* :ghissue:`4875`: Empty tooltip with `object_found = false` still being shown
+* :ghissue:`4432`: The SSL cert for the MathJax CDN is invalid and URL is not protocol agnostic
+* :ghissue:`2633`: Help text should leave current cell active
+* :ghissue:`3976`: DOC: Pandas link on the notebook help menu?
+* :ghissue:`4082`: /new handler redirect cached by browser
+* :ghissue:`4298`: Slow ipython --pylab and ipython notebook startup
+* :ghissue:`4545`: %store magic not working
+* :ghissue:`4610`: toolbar UI enhancements
+* :ghissue:`4782`: New modal UI
+* :ghissue:`4732`: Accents in notebook names and in command-line (nbconvert)
+* :ghissue:`4752`: link broken in docs/examples
+* :ghissue:`4835`: running ipython on python files adds an extra traceback frame
+* :ghissue:`4792`: repr_html exception warning on qtconsole with pandas  #4745 
+* :ghissue:`4834`: function tooltip issues
+* :ghissue:`4808`: Docstrings in Notebook not displayed properly and introspection
+* :ghissue:`4846`: Remove some leftover traces of irunner
+* :ghissue:`4810`: ipcluster bug in clean_logs flag
+* :ghissue:`4812`: update CodeMirror for the notebook
+* :ghissue:`671`: add migration guide for old IPython config
+* :ghissue:`4783`: ipython 2dev  under windows / (win)python 3.3 experiment
+* :ghissue:`4772`: Notebook server info files
+* :ghissue:`4765`: missing build script for highlight.js
+* :ghissue:`4787`: non-python kernels run python code with qtconsole
+* :ghissue:`4703`: Math macro in jinja templates.
+* :ghissue:`4595`: ipython notebook XSS vulnerable
+* :ghissue:`4776`: Manually document py3compat module.
+* :ghissue:`4686`: For-in loop on an array in cell.js
+* :ghissue:`3605`: Modal UI
+* :ghissue:`4769`: Ipython 2.0 will not startup on py27 on windows
+* :ghissue:`4482`: reveal.js converter not including CDN by default?
+* :ghissue:`4761`: ipv6 address triggers cookie exception
+* :ghissue:`4580`: rename or remove %profile magic
+* :ghissue:`4643`: Docstring does not open properly
+* :ghissue:`4714`: Static URLs are not auto-versioned
+* :ghissue:`2573`: document code mirror keyboard shortcuts
+* :ghissue:`4717`: hang in parallel.Client when using SSHAgent
+* :ghissue:`4544`: Clarify the requirement for pyreadline on Windows
+* :ghissue:`3451`: revisit REST /new handler to avoid systematic crawling.
+* :ghissue:`2922`: File => Save as '.py' saves magic as code 
+* :ghissue:`4728`: Copy/Paste stripping broken in version > 0.13.x in QTConsole
+* :ghissue:`4539`: Nbconvert: Latex to PDF conversion fails on notebooks with accented letters
+* :ghissue:`4721`: purge_results with jobid crashing - looking for insight
+* :ghissue:`4620`: Notebook with ? in title defies autosave, renaming and deletion.
+* :ghissue:`4574`: Hash character in notebook name breaks a lot of things
+* :ghissue:`4709`: input_prefilter hook not called
+* :ghissue:`1680`: qtconsole should support --no-banner and custom banner
+* :ghissue:`4689`: IOStream IP address configurable
+* :ghissue:`4698`: Missing "if __name__ == '__main__':" check in /usr/bin/ipython
+* :ghissue:`4191`: NBConvert: markdown inline and locally referenced files have incorrect file location for latex 
+* :ghissue:`2865`: %%!? does not display the shell execute docstring
+* :ghissue:`1551`: Notebook should be saved before printing
+* :ghissue:`4612`: remove `Configurable.created` ?
+* :ghissue:`4629`: Lots of tests fail due to space in sys.executable
+* :ghissue:`4644`: Fixed URLs for notebooks
+* :ghissue:`4621`: IPython 1.1.0 Qtconsole syntax highlighting highlights python 2 only built-ins when using python 3
+* :ghissue:`2923`: Move Delete Button Away from Save Button in the HTML notebook toolbar
+* :ghissue:`4615`: UnicodeDecodeError
+* :ghissue:`4431`: ipython slow in os x mavericks?
+* :ghissue:`4538`: DOC: document how to change ipcontroller-engine.json in case controller was started with --ip="*"
+* :ghissue:`4551`: Serialize methods and closures
+* :ghissue:`4081`: [Nbconvert][reveal] link to font awesome ?
+* :ghissue:`4602`: "ipcluster stop" fails after "ipcluster start --daemonize" using python3.3
+* :ghissue:`4578`: NBconvert fails with unicode errors when `--stdout` and file redirection is specified and HTML entities are present
+* :ghissue:`4600`: Renaming new notebook to an exist name silently deletes the old one
+* :ghissue:`4598`: Qtconsole docstring pop-up fails on method containing defaulted enum argument
+* :ghissue:`951`: Remove Tornado monkeypatch
+* :ghissue:`4564`: Notebook save failure
+* :ghissue:`4562`: nbconvert: Default encoding problem on OS X
+* :ghissue:`1675`: add file_to_run=file.ipynb capability to the notebook
+* :ghissue:`4516`: `ipython console` doesn't send a `shutdown_request`
+* :ghissue:`3043`: can't restart pdb session in ipython
+* :ghissue:`4524`: Fix bug with non ascii passwords in notebook login
+* :ghissue:`1866`: problems rendering an SVG?
+* :ghissue:`4520`: unicode error when trying Audio('data/Bach Cello Suite #3.wav') 
+* :ghissue:`4493`: Qtconsole cannot print an ISO8601 date at nanosecond precision
+* :ghissue:`4502`: intermittent parallel test failure test_purge_everything 
+* :ghissue:`4495`: firefox 25.0: notebooks report "Notebook save failed", .py script save fails, but .ipynb save succeeds
+* :ghissue:`4245`: nbconvert latex: code highlighting causes error
+* :ghissue:`4486`: Test for whether inside virtualenv does not work if directory is symlinked
+* :ghissue:`4485`: Incorrect info in "Messaging in IPython" documentation. 
+* :ghissue:`4447`: Ipcontroller broken in current HEAD on windows
+* :ghissue:`4241`: Audio display object
+* :ghissue:`4463`: Error on empty c.Session.key
+* :ghissue:`4454`: UnicodeDecodeError when starting Ipython notebook on a directory containing a file with a non-ascii character
+* :ghissue:`3801`: Autocompletion: Fix issue #3723 -- ordering of completions for magic commands and variables with same name
+* :ghissue:`3723`: Code completion: 'matplotlib' and '%matplotlib'
+* :ghissue:`4396`: Always checkpoint al least once ?
+* :ghissue:`2524`: [Notebook] Clear kernel queue
+* :ghissue:`2292`: Client side tests for the notebook
+* :ghissue:`4424`: Dealing with images in multidirectory environment
+* :ghissue:`4388`: Make writing configurable magics easier
+* :ghissue:`852`: Notebook should be saved before downloading
+* :ghissue:`3708`: ipython profile locate should also work
+* :ghissue:`1349`: `?` may generate hundreds of cell 
+* :ghissue:`4381`: Using hasattr for trait_names instead of just looking for it directly/using __dir__?
+* :ghissue:`4361`: Crash Ultratraceback/ session history
+* :ghissue:`3044`: IPython notebook autocomplete for filename string converts multiple spaces to a single space
+* :ghissue:`3346`: Up arrow history search shows duplicates in Qtconsole
+* :ghissue:`3496`: Fix import errors when running tests from the source directory
+* :ghissue:`4114`: If default profile doesn't exist, can't install mathjax to any location
+* :ghissue:`4335`: TestPylabSwitch.test_qt fails
+* :ghissue:`4291`: serve like option for nbconvert --to latex
+* :ghissue:`1824`: Exception before prompting for password during ssh connection
+* :ghissue:`4309`: Error in nbconvert - closing </code> tag is not inserted in HTML under some circumstances
+* :ghissue:`4351`: /parallel/apps/launcher.py error
+* :ghissue:`3603`: Upcoming issues with nbconvert
+* :ghissue:`4296`: sync_imports() fails in python 3.3
+* :ghissue:`4339`: local mathjax install doesn't work
+* :ghissue:`4334`: NotebookApp.webapp_settings static_url_prefix causes crash
+* :ghissue:`4308`: Error when use "ipython notebook" in win7 64 with python2.7.3 64.
+* :ghissue:`4317`: Relative imports broken in the notebook (Windows)
+* :ghissue:`3658`: Saving Notebook clears "Kernel Busy" status from the page and titlebar
+* :ghissue:`4312`: Link broken on ipython-doc stable
+* :ghissue:`1093`: Add boundary options to %load
+* :ghissue:`3619`: Multi-dir webservice design
+* :ghissue:`4299`: Nbconvert, default_preprocessors to list of dotted name not list of obj
+* :ghissue:`3210`: IPython.parallel tests seem to hang on ShiningPanda
+* :ghissue:`4280`: MathJax Automatic Line Breaking
+* :ghissue:`4039`: Celltoolbar example issue
+* :ghissue:`4247`: nbconvert --to latex: error when converting greek letter
+* :ghissue:`4273`: %%capture not capturing rich objects like plots (IPython 1.1.0)
+* :ghissue:`3866`: Vertical offsets in LaTeX output for nbconvert
+* :ghissue:`3631`: xkcd mode for the IPython notebook
+* :ghissue:`4243`: Test exclusions not working on Windows
+* :ghissue:`4256`: IPython no longer handles unicode file names 
+* :ghissue:`3656`: Audio displayobject
+* :ghissue:`4223`: Double output on Ctrl-enter-enter
+* :ghissue:`4184`: nbconvert: use r pygmentize backend when highlighting "%%R" cells 
+* :ghissue:`3851`: Adds an explicit newline for pretty-printing.
+* :ghissue:`3622`: Drop fakemodule
+* :ghissue:`4122`: Nbconvert [windows]: Inconsistent line endings in markdown cells exported to latex 
+* :ghissue:`3819`: nbconvert add extra blank line to code block on Windows.
+* :ghissue:`4203`: remove spurious print statement from parallel annoted functions
+* :ghissue:`4200`: Notebook: merging a heading cell and markdown cell cannot be undone
+* :ghissue:`3747`: ipynb -> ipynb transformer
+* :ghissue:`4024`: nbconvert markdown issues
+* :ghissue:`3903`: on Windows, 'ipython3 nbconvert "C:/blabla/first_try.ipynb" --to slides' gives an unexpected result, and '--post serve' fails
+* :ghissue:`4095`: Catch js error in append html in stream/pyerr
+* :ghissue:`1880`: Add parallelism to test_pr 
+* :ghissue:`4085`: nbconvert: Fix sphinx preprocessor date format string for Windows
+* :ghissue:`4156`: Specifying --gui=tk at the command line
+* :ghissue:`4146`: Having to prepend 'files/' to markdown image paths is confusing 
+* :ghissue:`3818`: nbconvert can't handle Heading with Chinese characters on Japanese Windows OS.
+* :ghissue:`4134`: multi-line parser fails on ''' in comment, qtconsole and notebook.
+* :ghissue:`3998`: sample custom.js needs to be updated
+* :ghissue:`4078`: StoreMagic.autorestore not working in 1.0.0
+* :ghissue:`3990`: Buitlin `input` doesn't work over zmq
+* :ghissue:`4015`: nbconvert fails to convert all the content of a notebook
+* :ghissue:`4059`: Issues with Ellipsis literal in Python 3
+* :ghissue:`2310`: "ZMQError: Interrupted system call" from RichIPythonWidget
+* :ghissue:`3807`: qtconsole ipython 0.13.2 - html/xhtml export fails
+* :ghissue:`4103`: Wrong default argument of DirectView.clear
+* :ghissue:`4100`: parallel.client.client references undefined error.EngineError
+* :ghissue:`484`: Drop nosepatch
+* :ghissue:`3350`: Added longlist support in ipdb.
+* :ghissue:`1591`: Keying 'q' doesn't quit the interactive help in Wins7
+* :ghissue:`40`: The tests in test_process fail under Windows
+* :ghissue:`3744`: capture rich output as well as stdout/err in capture_output
+* :ghissue:`3742`: %%capture to grab rich display outputs
+* :ghissue:`3863`: Added working speaker notes for slides.
+* :ghissue:`4013`: Iptest fails in dual python installation
+* :ghissue:`4005`: IPython.start_kernel doesn't work.
+* :ghissue:`4020`: IPython parallel map fails on numpy arrays
+* :ghissue:`3914`: nbconvert: Transformer tests
+* :ghissue:`3923`: nbconvert: Writer tests
+* :ghissue:`3945`: nbconvert: commandline tests fail Win7x64 Py3.3
+* :ghissue:`3937`: make tab visible in codemirror and light red background
+* :ghissue:`3935`: No feedback for mixed tabs and spaces
+* :ghissue:`3933`: nbconvert: Post-processor tests
+* :ghissue:`3977`: unable to complete remote connections for two-process 
+* :ghissue:`3939`: minor checkpoint cleanup
+* :ghissue:`3955`: complete on % for magic in notebook
+* :ghissue:`3954`: all magics should be listed when completing on %
+* :ghissue:`3980`: nbconvert rst output lacks needed blank lines
+* :ghissue:`3968`: TypeError: super() argument 1 must be type, not classobj (Python 2.6.6)
+* :ghissue:`3880`: nbconvert: R&D remaining tests
+* :ghissue:`2440`: IPEP 4: Python 3 Compatibility
diff --git a/docs/source/whatsnew/github-stats-3.rst b/docs/source/whatsnew/github-stats-3.rst
new file mode 100644
index 00000000000..c4fb3dff9e4
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-3.rst
@@ -0,0 +1,269 @@
+.. _issues_list_3:
+
+Issues closed in the 3.x development cycle
+==========================================
+
+
+Issues closed in 3.2.1
+----------------------
+
+GitHub stats for 2015/06/22 - 2015/07/12 (since 3.2)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 1 issue and merged 3 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.2.1>`__
+
+The following 5 authors contributed 9 commits.
+
+* Benjamin Ragan-Kelley
+* Matthias Bussonnier
+* Nitin Dahyabhai
+* Sebastiaan Mathot
+* Thomas Kluyver
+
+
+Issues closed in 3.2
+--------------------
+
+GitHub stats for 2015/04/03 - 2015/06/21 (since 3.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 7 issues and merged 30 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.2>`__
+
+The following 15 authors contributed 74 commits.
+
+* Benjamin Ragan-Kelley
+* Brian Gough
+* Damián Avila
+* Ian Barfield
+* Jason Grout
+* Jeff Hussmann
+* Jessica B. Hamrick
+* Kyle Kelley
+* Matthias Bussonnier
+* Nicholas Bollweg
+* Randy Lai
+* Scott Sanderson
+* Sylvain Corlay
+* Thomas A Caswell
+* Thomas Kluyver
+
+
+Issues closed in 3.1
+--------------------
+
+GitHub stats for 2015/02/27 - 2015/04/03 (since 3.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 46 issues and merged 133 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.1>`__.
+
+The following 33 authors contributed 344 commits:
+
+* Abe Guerra
+* Adal Chiriliuc
+* Benjamin Ragan-Kelley
+* Brian Drawert
+* Fernando Perez
+* Gareth Elston
+* Gert-Ludwig Ingold
+* Giuseppe Venturini
+* Jakob Gager
+* Jan Schulz
+* Jason Grout
+* Jessica B. Hamrick
+* Jonathan Frederic
+* Justin Tyberg
+* Lorena Pantano
+* mashenjun
+* Mathieu
+* Matthias Bussonnier
+* Morten Enemark Lund
+* Naveen Nathan
+* Nicholas Bollweg
+* onesandzeroes
+* Patrick Snape
+* Peter Parente
+* RickWinter
+* Robert Smith
+* Ryan Nelson
+* Scott Sanderson
+* Sylvain Corlay
+* Thomas Kluyver
+* tmtabor
+* Wieland Hoffmann
+* Yuval Langer
+
+
+Issues closed in 3.0
+--------------------
+
+GitHub stats for 2014/04/02 - 2015/02/13 (since 2.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 469 issues and merged 925 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestones/3.0>`__.
+
+The following 155 authors contributed 5975 commits.
+
+* A.J. Holyoake
+* abalkin
+* Adam Hodgen
+* Adrian Price-Whelan
+* Amin Bandali
+* Andreas Amann
+* Andrew Dawes
+* Andrew Jesaitis
+* Andrew Payne
+* AnneTheAgile
+* Aron Ahmadia
+* Ben Duffield
+* Benjamin ABEL
+* Benjamin Ragan-Kelley
+* Benjamin Schultz
+* Björn Grüning
+* Björn Linse
+* Blake Griffith
+* Boris Egorov
+* Brian E. Granger
+* bsvh
+* Carlos Cordoba
+* Cedric GESTES
+* cel
+* chebee7i
+* Christoph Gohlke
+* CJ Carey
+* Cyrille Rossant
+* Dale Jung
+* Damián Avila
+* Damon Allen
+* Daniel B. Vasquez
+* Daniel Rocco
+* Daniel Wehner
+* Dav Clark
+* David Hirschfeld
+* David Neto
+* dexterdev
+* Dimitry Kloper
+* dongweiming
+* Doug Blank
+* drevicko
+* Dustin Rodriguez
+* Eric Firing
+* Eric Galloway
+* Erik M. Bray
+* Erik Tollerud
+* Ezequiel (Zac) Panepucci
+* Fernando Perez
+* foogunlana
+* Francisco de la Peña
+* George Titsworth
+* Gordon Ball
+* gporras
+* Grzegorz Rożniecki
+* Helen ST
+* immerrr
+* Ingolf Becker
+* Jakob Gager
+* James Goppert
+* James Porter
+* Jan Schulz
+* Jason Goad
+* Jason Gors
+* Jason Grout
+* Jason Newton
+* jdavidheiser
+* Jean-Christophe Jaskula
+* Jeff Hemmelgarn
+* Jeffrey Bush
+* Jeroen Demeyer
+* Jessica B. Hamrick
+* Jessica Frazelle
+* jhemmelg
+* Jim Garrison
+* Joel Nothman
+* Johannes Feist
+* John Stowers
+* John Zwinck
+* jonasc
+* Jonathan Frederic
+* Juergen Hasch
+* Julia Evans
+* Justyna Ilczuk
+* Jörg Dietrich
+* K.-Michael Aye
+* Kalibri
+* Kester Tong
+* Kyle Kelley
+* Kyle Rawlins
+* Lev Abalkin
+* Manuel Riel
+* Martin Bergtholdt
+* Martin Spacek
+* Mateusz Paprocki
+* Mathieu
+* Matthias Bussonnier
+* Maximilian Albert
+* mbyt
+* MechCoder
+* Mohan Raj Rajamanickam
+* mvr
+* Narahari
+* Nathan Goldbaum
+* Nathan Heijermans
+* Nathaniel J. Smith
+* ncornette
+* Nicholas Bollweg
+* Nick White
+* Nikolay Koldunov
+* Nile Geisinger
+* Olga Botvinnik
+* Osada Paranaliyanage
+* Pankaj Pandey
+* Pascal Bugnion
+* patricktokeeffe
+* Paul Ivanov
+* Peter Odding
+* Peter Parente
+* Peter Würtz
+* Phil Elson
+* Phillip Nordwall
+* Pierre Gerold
+* Pierre Haessig
+* Raffaele De Feo
+* Ramiro Gómez
+* Reggie Pierce
+* Remi Rampin
+* Renaud Richardet
+* Richard Everson
+* Scott Sanderson
+* Silvia Vinyes
+* Simon Guillot
+* Spencer Nelson
+* Stefan Zimmermann
+* Steve Chan
+* Steven Anton
+* Steven Silvester
+* sunny
+* Susan Tan
+* Sylvain Corlay
+* Tarun Gaba
+* Thomas Ballinger
+* Thomas Kluyver
+* Thomas Robitaille
+* Thomas Spura
+* Tobias Oberstein
+* Torsten Bittner
+* unknown
+* v923z
+* vaibhavsagar
+* W. Trevor King
+* weichm
+* Xiuming Chen
+* Yaroslav Halchenko
+* zah
diff --git a/docs/source/whatsnew/github-stats-4.rst b/docs/source/whatsnew/github-stats-4.rst
new file mode 100644
index 00000000000..b7410fafe02
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-4.rst
@@ -0,0 +1,178 @@
+.. _issues_list_4:
+
+Issues closed in the 4.x development cycle
+==========================================
+
+
+Issues closed in 4.2
+--------------------
+
+GitHub stats for 2015/02/02 - 2016/04/20 (since 4.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 10 issues and merged 22 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A4.2+>`__
+
+The following 10 authors contributed 27 commits.
+
+* Benjamin Ragan-Kelley
+* Carlos Cordoba
+* Gökhan Karabulut
+* Jonas Rauber
+* Matthias Bussonnier
+* Paul Ivanov
+* Sebastian Bank
+* Thomas A Caswell
+* Thomas Kluyver
+* Vincent Woo
+
+
+Issues closed in 4.1
+--------------------
+
+GitHub stats for 2015/08/12 - 2016/02/02 (since 4.0.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 60 issues and merged 148 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A4.1+>`__
+
+The following 52 authors contributed 468 commits.
+
+* Aaron Meurer
+* Alexandre Avanian
+* Anthony Sottile
+* Antony Lee
+* Arthur Loder
+* Ben Kasel
+* Ben Rousch
+* Benjamin Ragan-Kelley
+* bollwyvl
+* Carol Willing
+* Christopher Roach
+* Douglas La Rocca
+* Fairly
+* Fernando Perez
+* Frank Sachsenheim
+* Guillaume DOUMENC
+* Gábor Luk
+* Hoyt Koepke
+* Ivan Timokhin
+* Jacob Niehus
+* JamshedVesuna
+* Jan Schulz
+* Jan-Philip Gehrcke
+* jc
+* Jessica B. Hamrick
+* jferrara
+* John Bohannon
+* John Kirkham
+* Jonathan Frederic
+* Kyle Kelley
+* Lev Givon
+* Lilian Besson
+* lingxz
+* Matthias Bussonnier
+* memeplex
+* Michael Droettboom
+* naught101
+* Peter Waller
+* Pierre Gerold
+* Rémy Léone
+* Scott Sanderson
+* Shanzhuo Zhang
+* Sylvain Corlay
+* Tayfun Sen
+* Thomas A Caswell
+* Thomas Ballinger
+* Thomas Kluyver
+* Vincent Legoll
+* Wouter Bolsterlee
+* xconverge
+* Yuri Numerov
+* Zachary Pincus
+
+
+Issues closed in 4.0
+--------------------
+
+
+GitHub stats for 2015/02/27 - 2015/08/11 (since 3.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 35 issues and merged 125 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/milestone/21>`__
+
+The following 69 authors contributed 1186 commits.
+
+* Abe Guerra
+* Adal Chiriliuc
+* Alexander Belopolsky
+* Andrew Murray
+* Antonio Russo
+* Benjamin Ragan-Kelley
+* Björn Linse
+* Brian Drawert
+* chebee7i
+* Daniel Rocco
+* Donny Winston
+* Drekin
+* Erik Hvatum
+* Fernando Perez
+* Francisco de la Peña
+* Frazer McLean
+* Gareth Elston
+* Gert-Ludwig Ingold
+* Giuseppe Venturini
+* Ian Barfield
+* Ivan Pozdeev
+* Jakob Gager
+* Jan Schulz
+* Jason Grout
+* Jeff Hussmann
+* Jessica B. Hamrick
+* Joe Borg
+* Joel Nothman
+* Johan Forsberg
+* Jonathan Frederic
+* Justin Tyberg
+* Koen van Besien
+* Kyle Kelley
+* Lorena Pantano
+* Lucretiel
+* Marin Gilles
+* mashenjun
+* Mathieu
+* Matthias Bussonnier
+* Merlijn van Deen
+* Mikhail Korobov
+* Naveen Nathan
+* Nicholas Bollweg
+* nottaanibot
+* Omer Katz
+* onesandzeroes
+* Patrick Snape
+* patter001
+* Peter Parente
+* Pietro Battiston
+* RickWinter
+* Robert Smith
+* Ryan Nelson
+* Scott Sanderson
+* Sebastiaan Mathot
+* Sylvain Corlay
+* thethomask
+* Thomas A Caswell
+* Thomas Adriaan Hellinger
+* Thomas Kluyver
+* Tianhui Michael Li
+* tmtabor
+* unknown
+* Victor Ramirez
+* Volker Braun
+* Wieland Hoffmann
+* Yuval Langer
+* Zoltán Vörös
+* Élie Michel
diff --git a/docs/source/whatsnew/github-stats-5.rst b/docs/source/whatsnew/github-stats-5.rst
new file mode 100644
index 00000000000..97893cce1c6
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-5.rst
@@ -0,0 +1,201 @@
+.. _issues_list_5:
+
+Issues closed in the 5.x development cycle
+==========================================
+
+Issues closed in 5.6
+--------------------
+
+GitHub stats for 2017/09/15 - 2018/04/02 (tag: 5.5.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 2 issues and merged 28 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A5.6>`__
+
+The following 10 authors contributed 47 commits.
+
+* Benjamin Ragan-Kelley
+* Henry Fredrick Schreiner
+* Joris Van den Bossche
+* Matthias Bussonnier
+* Mradul Dubey
+* Roshan Rao
+* Samuel Lelièvre
+* Teddy Rendahl
+* Thomas A Caswell
+* Thomas Kluyver
+
+Issues closed in 5.4
+--------------------
+
+GitHub stats for 2017/02/24 - 2017/05/30 (tag: 5.3.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 8 issues and merged 43 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A5.4+>`__
+
+The following 11 authors contributed 64 commits.
+
+* Benjamin Ragan-Kelley
+* Carol Willing
+* Kyle Kelley
+* Leo Singer
+* Luke Pfister
+* Lumir Balhar
+* Matthias Bussonnier
+* meeseeksdev[bot]
+* memeplex
+* Thomas Kluyver
+* Ximin Luo
+
+Issues closed in 5.3
+--------------------
+
+GitHub stats for 2017/02/24 - 2017/05/30 (tag: 5.3.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 6 issues and merged 28 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A5.3+>`__
+
+The following 11 authors contributed 53 commits.
+
+* Benjamin Ragan-Kelley
+* Carol Willing
+* Justin Jent
+* Kyle Kelley
+* Lumir Balhar
+* Matthias Bussonnier
+* meeseeksdev[bot]
+* Segev Finer
+* Steven Maude
+* Thomas A Caswell
+* Thomas Kluyver
+
+
+Issues closed in 5.2
+--------------------
+
+GitHub stats for 2016/08/13 - 2017/01/29 (tag: 5.1.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 30 issues and merged 74 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A5.2+>`__
+
+The following 40 authors contributed 434 commits.
+
+* Adam Eury
+* anantkaushik89
+* anatoly techtonik
+* Benjamin Ragan-Kelley
+* Bibo Hao
+* Carl Smith
+* Carol Willing
+* Chilaka Ramakrishna
+* Christopher Welborn
+* Denis S. Tereshchenko
+* Diego Garcia
+* fatData
+* Fermi paradox
+* Fernando Perez
+* fuho
+* Hassan Kibirige
+* Jamshed Vesuna
+* Jens Hedegaard Nielsen
+* Jeroen Demeyer
+* kaushikanant
+* Kenneth Hoste
+* Keshav Ramaswamy
+* Kyle Kelley
+* Matteo
+* Matthias Bussonnier
+* mbyt
+* memeplex
+* Moez Bouhlel
+* Pablo Galindo
+* Paul Ivanov
+* pietvo
+* Piotr Przetacznik
+* Rounak Banik
+* sachet-mittal
+* Srinivas Reddy Thatiparthy
+* Tamir Bahar
+* Thomas A Caswell
+* Thomas Kluyver
+* tillahoffmann
+* Yuri Numerov
+
+
+Issues closed in 5.1
+--------------------
+
+GitHub stats for 2016/07/08 - 2016/08/13 (tag: 5.0.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 33 issues and merged 43 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A5.1+>`__
+
+The following 17 authors contributed 129 commits.
+
+* Antony Lee
+* Benjamin Ragan-Kelley
+* Carol Willing
+* Danilo J. S. Bellini
+* �明 (`dongweiming <https://github.com/dongweiming>`__)
+* Fernando Perez
+* Gavin Cooper
+* Gil Forsyth
+* Jacob Niehus
+* Julian Kuhlmann
+* Matthias Bussonnier
+* Michael Pacer
+* Nik Nyby
+* Pavol Juhas
+* Luke Deen Taylor
+* Thomas Kluyver
+* Tamir Bahar
+
+
+Issues closed in 5.0
+--------------------
+
+GitHub stats for 2016/07/05 - 2016/07/07 (tag: 5.0.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 95 issues and merged 191 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A5.0+>`__
+
+The following 27 authors contributed 229 commits.
+
+* Adam Greenhall
+* Adrian
+* Antony Lee
+* Benjamin Ragan-Kelley
+* Carlos Cordoba
+* Carol Willing
+* Chris
+* Craig Citro
+* Dmitry Zotikov
+* Fernando Perez
+* Gil Forsyth
+* Jason Grout
+* Jonathan Frederic
+* Jonathan Slenders
+* Justin Zymbaluk
+* Kelly Liu
+* klonuo
+* Matthias Bussonnier
+* nvdv
+* Pavol Juhas
+* Pierre Gerold
+* sukisuki
+* Sylvain Corlay
+* Thomas A Caswell
+* Thomas Kluyver
+* Trevor Bekolay
+* Yuri Numerov
diff --git a/docs/source/whatsnew/github-stats-6.rst b/docs/source/whatsnew/github-stats-6.rst
new file mode 100644
index 00000000000..f926ed7427f
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-6.rst
@@ -0,0 +1,184 @@
+Issues closed in the 6.x development cycle
+==========================================
+
+Issues closed in 6.3
+--------------------
+
+
+GitHub stats for 2017/09/15 - 2018/04/02 (tag: 6.2.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 10 issues and merged 50 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A6.3>`__
+
+The following 35 authors contributed 253 commits.
+
+* Anatoly Techtonik
+* Antony Lee
+* Benjamin Ragan-Kelley
+* Corey McCandless
+* Craig Citro
+* Cristian Ciupitu
+* David Cottrell
+* David Straub
+* Doug Latornell
+* Fabio Niephaus
+* Gergely Nagy
+* Henry Fredrick Schreiner
+* Hugo
+* Ismael Venegas Castelló
+* Ivan Gonzalez
+* J Forde
+* Jeremy Sikes
+* Joris Van den Bossche
+* Lesley Cordero
+* luzpaz
+* madhu94
+* Matthew R. Scott
+* Matthias Bussonnier
+* Matthias Geier
+* Olesya Baranova
+* Peter Williams
+* Rastislav Barlik
+* Roshan Rao
+* rs2
+* Samuel Lelièvre
+* Shailyn javier Ortiz jimenez
+* Sjoerd de Vries
+* Teddy Rendahl
+* Thomas A Caswell
+* Thomas Kluyver
+
+Issues closed in 6.2
+--------------------
+
+GitHub stats for 2017/05/31 - 2017/09/15 (tag: 6.1.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 3 issues and merged 37 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A6.2+>`__
+
+The following 32 authors contributed 196 commits.
+
+* adityausathe
+* Antony Lee
+* Benjamin Ragan-Kelley
+* Carl Smith
+* Eren Halici
+* Erich Spaker
+* Grant Nestor
+* Jean Cruypenynck
+* Jeroen Demeyer
+* jfbu
+* jlstevens
+* jus1tin
+* Kyle Kelley
+* M Pacer
+* Marc Richter
+* Marius van Niekerk
+* Matthias Bussonnier
+* mpacer
+* Mradul Dubey
+* ormung
+* pepie34
+* Ritesh Kadmawala
+* ryan thielke
+* Segev Finer
+* Srinath
+* Srinivas Reddy Thatiparthy
+* Steven Maude
+* Sudarshan Raghunathan
+* Sudarshan Rangarajan
+* Thomas A Caswell
+* Thomas Ballinger
+* Thomas Kluyver
+
+
+Issues closed in 6.1
+--------------------
+
+GitHub stats for 2017/04/19 - 2017/05/30 (tag: 6.0.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 10 issues and merged 43 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A6.1+>`__
+
+The following 26 authors contributed 116 commits.
+
+* Alex Alekseyev
+* Benjamin Ragan-Kelley
+* Brian E. Granger
+* Christopher C. Aycock
+* Dave Willmer
+* David Bradway
+* ICanWaitAndFishAllDay
+* Ignat Shining
+* Jarrod Janssen
+* Joshua Storck
+* Luke Pfister
+* Matthias Bussonnier
+* Matti Remes
+* meeseeksdev[bot]
+* memeplex
+* Ming Zhang
+* Nick Weseman
+* Paul Ivanov
+* Piotr Zielinski
+* ryan thielke
+* sagnak
+* Sang Min Park
+* Srinivas Reddy Thatiparthy
+* Steve Bartz
+* Thomas Kluyver
+* Tory Haavik
+
+
+Issues closed in 6.0
+--------------------
+
+GitHub stats for 2017/04/10 - 2017/04/19 (milestone: 6.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 49 issues and merged 145 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A6.0+>`__
+
+The following 34 authors contributed 176 commits.
+
+* Adam Eury
+* anantkaushik89
+* Antonino Ingargiola
+* Benjamin Ragan-Kelley
+* Carol Willing
+* Chilaka Ramakrishna
+* chillaranand
+* Denis S. Tereshchenko
+* Diego Garcia
+* fatData
+* Fermi paradox
+* fuho
+* Grant Nestor
+* Ian Rose
+* Jeroen Demeyer
+* kaushikanant
+* Keshav Ramaswamy
+* Matteo
+* Matthias Bussonnier
+* mbyt
+* Michael Käufl
+* michaelpacer
+* Moez Bouhlel
+* Pablo Galindo
+* Paul Ivanov
+* Piotr Przetacznik
+* Rounak Banik
+* sachet-mittal
+* Srinivas Reddy Thatiparthy
+* Tamir Bahar
+* Thomas Hisch
+* Thomas Kluyver
+* Utkarsh Upadhyay
+* Yuri Numerov
diff --git a/docs/source/whatsnew/github-stats-7.rst b/docs/source/whatsnew/github-stats-7.rst
new file mode 100644
index 00000000000..76a2c236a1e
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-7.rst
@@ -0,0 +1,544 @@
+Issues closed in the 7.x development cycle
+==========================================
+
+Stats are not collected after version 7.17, all contribution will show up as part of the 8.0 release.
+
+Issues closed in 7.17
+---------------------
+
+GitHub stats for 2020/06/26 - 2020/07/31 (tag: 7.16.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 2 issues and merged 19 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.17>`__
+
+The following 3 authors contributed 31 commits.
+
+* Maor Kleinberger
+* Matthias Bussonnier
+* Quentin Peter
+
+
+
+Issues closed in 7.16
+---------------------
+
+GitHub stats for 2020/05/29 - 2020/06/26 (tag: 7.15.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 0 issues and merged 18 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.16>`__
+
+The following 7 authors contributed 22 commits.
+
+* Benjamin Ragan-Kelley
+* dalthviz
+* Frank Tobia
+* Matthias Bussonnier
+* palewire
+* Paul McCarthy
+* Talley Lambert
+
+
+Issues closed in 7.15
+---------------------
+
+GitHub stats for 2020/05/01 - 2020/05/29 (tag: 7.14.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 1 issues and merged 29 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.15>`__
+
+The following 6 authors contributed 31 commits.
+
+* Blake Griffin
+* Inception95
+* Marcio Mazza
+* Matthias Bussonnier
+* Talley Lambert
+* Thomas
+
+Issues closed in 7.14
+---------------------
+
+GitHub stats for 2020/02/29 - 2020/05/01 (tag: 7.13.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 0 issues and merged 30 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.14>`__
+
+The following 10 authors contributed 47 commits.
+
+* Eric Wieser
+* foobarbyte
+* Ian Castleden
+* Itamar Turner-Trauring
+* Lumir Balhar
+* Markus Wageringel
+* Matthias Bussonnier
+* Matthieu Ancellin
+* Quentin Peter
+* Theo Ouzhinski
+
+Issues closed in 7.13
+---------------------
+
+
+GitHub stats for 2020/02/01 - 2020/02/28 (tag: 7.12.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 1 issues and merged 24 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.13>`__
+
+The following 12 authors contributed 108 commits.
+
+* Alex Hall
+* Augusto
+* Coon, Ethan T
+* Daniel Hahler
+* Inception95
+* Itamar Turner-Trauring
+* Jonas Haag
+* Jonathan Slenders
+* linar-jether
+* Matthias Bussonnier
+* Nathan Goldbaum
+* Terry Davis
+
+Issues closed in 7.12
+---------------------
+
+GitHub stats for 2020/01/01 - 2020/01/31 (tag: 7.11.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 2 issues and merged 14 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.12>`__
+
+The following 11 authors contributed 48 commits.
+
+* Augusto
+* Eric Wieser
+* Jeff Potter
+* Mark E. Haase
+* Matthias Bussonnier
+* ossdev07
+* ras44
+* takuya fujiwara
+* Terry Davis
+* Thomas A Caswell
+* yangyang
+
+Issues closed in 7.11
+---------------------
+
+GitHub stats for 2019/12/01 - 2019/12/27 (tag: 7.10.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 4 issues and merged 36 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.11>`__
+
+The following 16 authors contributed 114 commits.
+
+* Augusto
+* Benjamin Ragan-Kelley
+* Chemss Eddine Ben Hassine
+* Danny Hermes
+* Dominik Miedziński
+* Jonathan Feinberg
+* Jonathan Slenders
+* Joseph Kahn
+* kousik
+* Kousik Mitra
+* Marc Hernandez Cabot
+* Matthias Bussonnier
+* Naveen Honest Raj K
+* Pratyay Pandey
+* Quentin Peter
+* takuya fujiwara
+
+
+Issues closed in 7.10.2
+-----------------------
+
+
+GitHub stats for 2019/12/01 - 2019/12/14 (tag: 7.10.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 3 issues and merged 10 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.10.2>`__
+
+The following 3 authors contributed 11 commits.
+
+* Jonathan Slenders
+* Joseph Kahn
+* Matthias Bussonnier
+
+Issues closed in 7.10.1
+-----------------------
+
+GitHub stats for 2019/11/27 - 2019/12/01 (tag: 7.10.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 5 issues and merged 7 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.10.1>`__
+
+The following 2 authors contributed 14 commits.
+
+* Jonathan Slenders
+* Matthias Bussonnier
+
+Issues closed in 7.10
+---------------------
+
+GitHub stats for 2019/10/25 - 2019/11/27 (tag: 7.9.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 4 issues and merged 22 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.10>`__
+
+The following 15 authors contributed 101 commits.
+
+* anatoly techtonik
+* Ben Lewis
+* Benjamin Ragan-Kelley
+* Gerrit Buss
+* grey275
+* Gökcen Eraslan
+* Jonathan Slenders
+* Joris Van den Bossche
+* kousik
+* Matthias Bussonnier
+* Nicholas Bollweg
+* Paul McCarthy
+* Srinivas Reddy Thatiparthy
+* Timo Kaufmann
+* Tony Fast
+
+Issues closed in 7.9
+--------------------
+
+GitHub stats for 2019/08/30 - 2019/10/25 (tag: 7.8.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 1 issues and merged 9 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.9>`__
+
+The following 8 authors contributed 20 commits.
+
+* Benjamin Ragan-Kelley
+* Hugo
+* Matthias Bussonnier
+* mfh92
+* Mohammad Hossein Sekhavat
+* Niclas
+* Vidar Tonaas Fauske
+* Георгий Фролов
+
+Issues closed in 7.8
+--------------------
+
+GitHub stats for 2019/07/26 - 2019/08/30 (tag: 7.7.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 1 issues and merged 4 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.8>`__
+
+The following 5 authors contributed 27 commits.
+
+* Dan Allan
+* Matthias Bussonnier
+* Min ho Kim
+* Oscar Gustafsson
+* Terry Davis
+
+Issues closed in 7.7
+--------------------
+
+GitHub stats for 2019/07/03 - 2019/07/26 (tag: 7.6.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 5 issues and merged 9 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.7>`__
+
+The following 8 authors contributed 26 commits.
+
+* Brandon T. Willard
+* juanis2112
+* lllf
+* Matthias Bussonnier
+* Min ho Kim
+* Oriol (Prodesk)
+* Po-Chuan Hsieh
+* techassetskris
+
+Issues closed in 7.6
+--------------------
+
+GitHub stats for 2019/04/24 - 2019/06/28 (tag: 7.5.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 9 issues and merged 43 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.6>`__
+
+The following 19 authors contributed 144 commits.
+
+* Alok Singh
+* Andreas
+* Antony Lee
+* Daniel Hahler
+* Ed OBrien
+* Kevin Sheppard
+* Luciana da Costa Marques
+* Maor Kleinberger
+* Matthias Bussonnier
+* Miro Hron�ok
+* Niclas
+* Nikita Bezdolniy
+* Oriol Abril
+* Piers Titus van der Torren
+* Pragnya Srinivasan
+* Robin Gustafsson
+* stonebig
+* Thomas A Caswell
+* zzzz-qq
+
+
+Issues closed in 7.5
+--------------------
+
+GitHub stats for 2019/03/21 - 2019/04/24 (tag: 7.4.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 2 issues and merged 9 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.5>`__
+
+The following 7 authors contributed 28 commits.
+
+* Akshay Paropkari
+* Benjamin Ragan-Kelley
+* Ivan Tham
+* Matthias Bussonnier
+* Nick Tallant
+* Sebastian Witowski
+* stef-ubuntu
+
+
+Issues closed in 7.4
+--------------------
+
+GitHub stats for 2019/02/18 - 2019/03/21 (tag: 7.3.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 9 issues and merged 20 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.3>`__
+
+The following 23 authors contributed 69 commits.
+
+* anatoly techtonik
+* Benjamin Ragan-Kelley
+* bnables
+* Frédéric Chapoton
+* Gabriel Potter
+* Ian Bell
+* Jake VanderPlas
+* Jan S. (Milania1)
+* Jesse Widner
+* jsnydes
+* Kyungdahm Yun
+* Laurent Gautier
+* Luciana da Costa Marques
+* Matan Gover
+* Matthias Bussonnier
+* memeplex
+* Mickaël Schoentgen
+* Partha P. Mukherjee
+* Philipp A
+* Sanyam Agarwal
+* Steve Nicholson
+* Tony Fast
+* Wouter Overmeire
+
+
+Issues closed in 7.3
+--------------------
+
+GitHub stats for 2018/11/30 - 2019/02/18 (tag: 7.2.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 4 issues and merged 20 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.3>`__
+
+The following 17 authors contributed 99 commits.
+
+* anatoly techtonik
+* Benjamin Ragan-Kelley
+* Gabriel Potter
+* Ian Bell
+* Jake VanderPlas
+* Jan S. (Milania1)
+* Jesse Widner
+* Kyungdahm Yun
+* Laurent Gautier
+* Matthias Bussonnier
+* memeplex
+* Mickaël Schoentgen
+* Partha P. Mukherjee
+* Philipp A
+* Sanyam Agarwal
+* Steve Nicholson
+* Tony Fast
+
+Issues closed in 7.2
+--------------------
+
+GitHub stats for 2018/10/28 - 2018/11/29 (tag: 7.1.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 2 issues and merged 18 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.2>`__
+
+The following 16 authors contributed 95 commits.
+
+* Antony Lee
+* Benjamin Ragan-Kelley
+* CarsonGSmith
+* Chris Mentzel
+* Christopher Brown
+* Dan Allan
+* Elliott Morgan Jobson
+* is-this-valid
+* kd2718
+* Kevin Hess
+* Martin Bergtholdt
+* Matthias Bussonnier
+* Nicholas Bollweg
+* Pavel Karateev
+* Philipp A
+* Reuben Morais
+
+Issues closed in 7.1
+--------------------
+
+GitHub stats for 2018/09/27 - 2018/10/27 (since tag: 7.0.1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 31 issues and merged 54 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.1>`__
+
+The following 33 authors contributed 254 commits.
+
+* ammarmallik
+* Audrey Dutcher
+* Bart Skowron
+* Benjamin Ragan-Kelley
+* BinaryCrochet
+* Chris Barker
+* Christopher Moura
+* Dedipyaman Das
+* Dominic Kuang
+* Elyashiv
+* Emil Hessman
+* felixzhuologist
+* hongshaoyang
+* Hugo
+* kd2718
+* kory donati
+* Kory Donati
+* koryd
+* luciana
+* luz.paz
+* Massimo Santini
+* Matthias Bussonnier
+* Matthias Geier
+* meeseeksdev[bot]
+* Michael Penkov
+* Mukesh Bhandarkar
+* Nguyen Duy Hai
+* Roy Wellington â…£
+* Sha Liu
+* Shao Yang
+* Shashank Kumar
+* Tony Fast
+* wim glenn
+
+
+Issues closed in 7.0
+--------------------
+
+GitHub stats for 2018/07/29 - 2018/09/27 (since tag: 6.5.0)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 20 issues and merged 76 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A7.0>`__
+
+The following 49 authors contributed 471 commits.
+
+* alphaCTzo7G
+* Alyssa Whitwell
+* Anatol Ulrich
+* apunisal
+* Benjamin Ragan-Kelley
+* Chaz Reid
+* Christoph
+* Dale Jung
+* Dave Hirschfeld
+* dhirschf
+* Doug Latornell
+* Fernando Perez
+* Fred Mitchell
+* Gabriel Potter
+* gpotter2
+* Grant Nestor
+* hongshaoyang
+* Hugo
+* J Forde
+* Jonathan Slenders
+* Jörg Dietrich
+* Kyle Kelley
+* luz.paz
+* M Pacer
+* Matthew R. Scott
+* Matthew Seal
+* Matthias Bussonnier
+* meeseeksdev[bot]
+* Michael Käufl
+* Olesya Baranova
+* oscar6echo
+* Paul Ganssle
+* Paul Ivanov
+* Peter Parente
+* prasanth
+* Shailyn javier Ortiz jimenez
+* Sourav Singh
+* Srinivas Reddy Thatiparthy
+* Steven Silvester
+* stonebig
+* Subhendu Ranjan Mishra
+* Takafumi Arakaki
+* Thomas A Caswell
+* Thomas Kluyver
+* Todd
+* Wei Yen
+* Yarko Tymciurak
+* Yutao Yuan
+* Zi Chong Kao
diff --git a/docs/source/whatsnew/github-stats-8.rst b/docs/source/whatsnew/github-stats-8.rst
new file mode 100644
index 00000000000..0c8589cb308
--- /dev/null
+++ b/docs/source/whatsnew/github-stats-8.rst
@@ -0,0 +1,111 @@
+Issues closed in the 8.x development cycle
+==========================================
+
+GitHub stats for 2022/01/05 - 2022/01/12 (tag: 8.0.0rc1)
+
+These lists are automatically generated, and may be incomplete or contain duplicates.
+
+We closed 26 issues and merged 307 pull requests.
+The full list can be seen `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A8.0>`__
+
+The following 99 authors contributed 372 commits.
+
+* 007vedant
+* Adam Hackbarth
+* Aditya Sathe
+* Ahmed Fasih
+* Albert Zhang
+* Alex Hall
+* Andrew Port
+* Ankitsingh6299
+* Arthur Moreira
+* Ashwin Vishnu
+* Augusto
+* BaoGiang HoangVu
+* bar-hen
+* Bart Skowron
+* Bartosz Telenczuk
+* Bastian Ebeling
+* Benjamin Ragan-Kelley
+* Blazej Michalik
+* blois
+* Boyuan Liu
+* Brendan Gerrity
+* Carol Willing
+* Coco Bennett
+* Coco Mishra
+* Corentin Cadiou
+* Daniel Goldfarb
+* Daniel Mietchen
+* Daniel Shimon
+* digitalvirtuoso
+* Dimitri Papadopoulos
+* dswij
+* Eric Wieser
+* Erik
+* Ethan Madden
+* Faris A Chugthai
+* farisachugthai
+* Gal B
+* gorogoroumaru
+* Hussaina Begum Nandyala
+* Inception95
+* Iwan Briquemont
+* Jake VanderPlas
+* Jakub Klus
+* James Morris
+* Jay Qi
+* Jeroen Bédorf
+* Joyce Er
+* juacrumar
+* Juan Luis Cano Rodríguez
+* Julien Rabinow
+* Justin Palmer
+* Krzysztof Cybulski
+* L0uisJ0shua
+* lbennett
+* LeafyLi
+* Lightyagami1
+* Lumir Balhar
+* Mark Schmitz
+* Martin Skarzynski
+* martinRenou
+* Matt Wozniski
+* Matthias Bussonnier
+* Meysam Azad
+* Michael T
+* Michael Tiemann
+* Naelson Douglas
+* Nathan Goldbaum
+* Nick Muoh
+* nicolaslazo
+* Nikita Kniazev
+* NotWearingPants
+* Paul Ivanov
+* Paulo S. Costa
+* Pete Blois
+* Peter Corke
+* PhanatosZou
+* Piers Titus van der Torren
+* Rakessh Roshan
+* Ram Rachum
+* rchiodo
+* Reilly Tucker Siemens
+* Romulo Filho
+* rushabh-v
+* Sammy Al Hashemi
+* Samreen Zarroug
+* Samuel Gaist
+* Sanjana-03
+* Scott Sanderson
+* skalaydzhiyski
+* sleeping
+* Snir Broshi
+* Spas Kalaydzhisyki
+* Sylvain Corlay
+* Terry Davis
+* Timur Kushukov
+* Tobias Bengfort
+* Tomasz KÅ‚oczko
+* Yonatan Goldschmidt
+* 谭�鼎
diff --git a/docs/source/whatsnew/index.rst b/docs/source/whatsnew/index.rst
new file mode 100644
index 00000000000..448395c9f25
--- /dev/null
+++ b/docs/source/whatsnew/index.rst
@@ -0,0 +1,68 @@
+.. Developers should add in this file, during each release cycle, information
+.. about important changes they've made, in a summary format that's meant for
+.. end users.  For each release we normally have three sections: features,  bug
+.. fixes and api breakage.
+.. Please remember to credit the authors of the contributions by name,
+.. especially when they are new users or developers who do not regularly
+.. participate  in IPython's development.
+
+.. _whatsnew_index:
+
+=====================
+What's new in IPython
+=====================
+
+..
+    this will appear in the docs if we are not releasing a version (ie if
+    `_version_extra` in release.py is an empty string)
+
+.. only:: ipydev
+
+   Development version in-progress features:
+
+   .. toctree::
+      :maxdepth: 1
+
+      development
+
+
+This section documents the changes that have been made in various versions of
+IPython. Users should consult these pages to learn about new features, bug
+fixes and backwards incompatibilities. Developers should summarize the
+development work they do here in a user friendly format.
+
+.. toctree::
+   :maxdepth: 1
+
+   version9
+   version8
+   github-stats-8
+   version7
+   github-stats-7
+   version6
+   github-stats-6
+   version5
+   github-stats-5
+   version4
+   github-stats-4
+   version3
+   github-stats-3
+   version3_widget_migration
+   version2.0
+   github-stats-2.0
+   version1.0
+   github-stats-1.0
+   version0.13
+   github-stats-0.13
+   version0.12
+   github-stats-0.12
+   version0.11
+   github-stats-0.11
+   version0.10
+   version0.9
+   version0.8
+
+..
+   The development.rst is included in the ipydev toctree above.
+   For stable builds, it's automatically excluded by the only directive,
+   so no hidden toctree is needed here.
diff --git a/docs/source/whatsnew/index.txt b/docs/source/whatsnew/index.txt
deleted file mode 100644
index ed606f6f695..00000000000
--- a/docs/source/whatsnew/index.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-.. Developers should add in this file, during each release cycle, information
-.. about important changes they've made, in a summary format that's meant for
-.. end users.  For each release we normally have three sections: features,  bug
-.. fixes and api breakage.
-.. Please remember to credit the authors of the contributions by name,
-.. especially when they are new users or developers who do not regularly
-.. participate  in IPython's development.
-
-.. _whatsnew_index:
-
-=====================
-What's new in IPython
-=====================
-
-This section documents the changes that have been made in various versions of
-IPython. Users should consult these pages to learn about new features, bug
-fixes and backwards incompatibilities. Developers should summarize the
-development work they do here in a user friendly format.
-
-.. toctree::
-   :maxdepth: 1
-
-   development
-   version0.10
-   version0.9
-   version0.8
-
-
diff --git a/docs/source/whatsnew/pr/README.md b/docs/source/whatsnew/pr/README.md
new file mode 100644
index 00000000000..54561824eaa
--- /dev/null
+++ b/docs/source/whatsnew/pr/README.md
@@ -0,0 +1,20 @@
+Documenting What's New
+----------------------
+
+When making a new pull request that either adds a new feature, or makes a
+backwards-incompatible change to IPython, please add a new `.rst` file in this
+directory documenting this change as a part of your Pull Request.
+
+This will allow multiple Pull Requests to do the same without conflicting with
+one another. Periodically, IPython developers with commit rights will run a
+script and populate [development.rst](../development.rst)
+with the contents of this directory, and clean it up.
+
+Files which describe new features can have any name, such as
+`antigravity-feature.rst`, whereas backwards incompatible changes **must have**
+have a filename starting with `incompat-`, such as
+`incompat-switching-to-perl.rst`.  Our "What's new" files always have two
+sections,  and this prefix scheme will make sure that the backwards incompatible
+changes get routed to their proper section.
+
+To merge these files into :file:`whatsnew/development.rst`, run the script :file:`tools/update_whatsnew.py`.
diff --git a/docs/source/whatsnew/pr/antigravity-feature.rst b/docs/source/whatsnew/pr/antigravity-feature.rst
new file mode 100644
index 00000000000..a53f8c7417c
--- /dev/null
+++ b/docs/source/whatsnew/pr/antigravity-feature.rst
@@ -0,0 +1,5 @@
+Antigravity feature
+===================
+
+Example new antigravity feature. Try ``import antigravity`` in a Python 3
+console.
diff --git a/docs/source/whatsnew/pr/incompat-switching-to-perl.rst b/docs/source/whatsnew/pr/incompat-switching-to-perl.rst
new file mode 100644
index 00000000000..ddd1d49f686
--- /dev/null
+++ b/docs/source/whatsnew/pr/incompat-switching-to-perl.rst
@@ -0,0 +1,7 @@
+Incompatible change switch to perl
+----------------------------------
+
+Document which filename start with ``incompat-`` will be gathers in their own
+incompatibility section.
+
+Starting with IPython 42, only perl code execution is allowed. See :ghpull:`42`
diff --git a/docs/source/whatsnew/version0.10.rst b/docs/source/whatsnew/version0.10.rst
new file mode 100644
index 00000000000..1ffbaa2e465
--- /dev/null
+++ b/docs/source/whatsnew/version0.10.rst
@@ -0,0 +1,360 @@
+=============
+ 0.10 series
+=============
+
+Release 0.10.2
+==============
+
+IPython 0.10.2 was released April 9, 2011.  This is a minor bugfix release that
+preserves backward compatibility.  At this point, all IPython development
+resources are focused on the 0.11 series that includes a complete architectural
+restructuring of the project as well as many new capabilities, so this is
+likely to be the last release of the 0.10.x series.  We have tried to fix all
+major bugs in this series so that it remains a viable platform for those not
+ready yet to transition to the 0.11 and newer codebase (since that will require
+some porting effort, as a number of APIs have changed).
+
+Thus, we are not opening a 0.10.3 active development branch yet, but if the
+user community requires new patches and is willing to maintain/release such a
+branch, we'll be happy to host it on the IPython github repositories.
+
+Highlights of this release:
+
+- The main one is the closing of github ticket #185, a major regression we had
+  in 0.10.1 where pylab mode with GTK (or gthread) was not working correctly,
+  hence plots were blocking with GTK.  Since this is the default matplotlib
+  backend on Unix systems, this was a major annoyance for many users.  Many
+  thanks to Paul Ivanov for helping resolve this issue.
+  
+- Fix IOError bug on Windows when used with -gthread.
+- Work robustly if $HOME is missing from environment.
+- Better POSIX support in ssh scripts (remove bash-specific idioms).
+- Improved support for non-ascii characters in log files.
+- Work correctly in environments where GTK can be imported but not started
+  (such as a linux text console without X11).
+  
+For this release we merged 24 commits, contributed by the following people
+(please let us know if we omitted your name and we'll gladly fix this in the
+notes for the future):
+
+* Fernando Perez
+* MinRK
+* Paul Ivanov
+* Pieter Cristiaan de Groot
+* TvrtkoM
+
+Release 0.10.1
+==============
+
+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.
+
+.. _github site: http://github.com/ipython
+
+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 reStructuredText documents as containing IPython
+  syntax (including figures) and the will be executed during the build:
+
+  .. sourcecode:: ipython
+
+      In [2]: plt.figure()  # ensure a fresh figure
+
+      @savefig psimple.png width=4in
+      In [3]: plt.plot([1,2,3])
+      Out[3]: [<matplotlib.lines.Line2D object at 0x9b74d8c>]
+
+- Various fixes to the standalone ipython-wx application.
+
+- We now ship internally the excellent argparse library, graciously licensed
+  under BSD terms by Steven Bethard.  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.
+
+The following people contributed to this release (please let us know if we
+omitted your name and we'll gladly fix this in the notes for the future):
+
+* Beni Cherniavsky
+* Boyd Waters.
+* David Warde-Farley
+* Fernando Perez
+* Gökhan Sever
+* John Hunter
+* Justin Riley
+* Kiorky
+* Laurent Dufrechou
+* Mark E. Smith
+* Matthieu Brucher
+* Satrajit Ghosh
+* Sebastian Busch
+* Václav Šmilauer
+
+Release 0.10
+============
+
+This release brings months of slow but steady development, and will be the last
+before a major restructuring and cleanup of IPython's internals that is already
+under way.  For this reason, we hope that 0.10 will be a stable and robust
+release so that while users adapt to some of the API changes that will come
+with the refactoring that will become IPython 0.11, they can safely use 0.10 in
+all existing projects with minimal changes (if any).
+
+IPython 0.10 is now a medium-sized project, with roughly (as reported by David
+Wheeler's :command:`sloccount` utility) 40750 lines of Python code, and a diff
+between 0.9.1 and this release that contains almost 28000 lines of code and
+documentation.  Our documentation, in PDF format, is a 495-page long PDF
+document (also available in HTML format, both generated from the same sources).
+
+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):
+
+* Alexander Clausen: fix #341726.
+* Brian Granger: lots of work everywhere (features, bug fixes, etc).
+* Daniel Ashbrook: bug report on MemoryError during compilation, now fixed.
+* Darren Dale: improvements to documentation build system, feedback, design
+  ideas.
+* Fernando Perez: various places.
+* Gaël Varoquaux: core code, ipythonx GUI, design discussions, etc. Lots...
+* John Hunter: suggestions, bug fixes, feedback.
+* Jorgen Stenarson: work on many fronts, tests, fixes, win32 support, etc.
+* Laurent Dufréchou: many improvements to ipython-wx standalone app.
+* Lukasz Pankowski: prefilter, `%edit`, demo improvements.
+* Matt Foster: TextMate support in `%edit`.
+* Nathaniel Smith: fix #237073.
+* Pauli Virtanen: fixes and improvements to extensions, documentation.
+* Prabhu Ramachandran: improvements to `%timeit`.
+* Robert Kern: several extensions.
+* Sameer D'Costa: help on critical bug #269966.
+* Stephan Peijnik: feedback on Debian compliance and many man pages.
+* Steven Bethard: we are now shipping his :mod:`argparse` module.
+* Tom Fetherston: many improvements to :mod:`IPython.demo` module.
+* Ville Vainio: lots of work everywhere (features, bug fixes, etc).
+* Vishal Vasta: ssh support in ipcluster.
+* Walter Doerwald: work on the :mod:`IPython.ipipe` system.
+
+Below we give an overview of new features, bug fixes and backwards-incompatible
+changes.  For a detailed account of every change made, feel free to view the
+project log with :command:`bzr log`.
+
+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.  A very useful new
+  feature contributed by Robert Kern.
+
+* IPython 'demos', created with the :mod:`IPython.demo` module, can now be
+  created from files on disk or strings in memory.  Other fixes and
+  improvements to the demo system, by Tom Fetherston.
+
+* Added :func:`find_cmd` function to :mod:`IPython.platutils` module, to find
+  commands in a cross-platform manner.
+
+* Many improvements and fixes to Gaël Varoquaux's :command:`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.
+
+* :class:`MultiengineClient` objects now have a :meth:`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 :mod:`IPython.Extensions.ipy_pretty` extension by Robert Kern
+  provides configurable pretty-printing.
+
+* Many improvements to the :command:`ipython-wx` standalone WX-based IPython
+  application by Laurent Dufréchou.  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
+  :mod:`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 :command:`trial` runner
+  to ensure proper management of Twisted-using code.  The test suite degrades
+  gracefully if optional dependencies are not available, so that the
+  :command:`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.  Thanks to Vishal Vatsa for implementing this!
+
+* The wonderful TextMate editor can now be used with %edit 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 :command:`bzr` and Launchpad.
+  
+* Fully refactored :command:`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 :command:`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 '%edit pasted_block', pasted_block variable gets updated
+  with new data (so repeated editing makes sense)
+
+.. _Numpy Documentation Standard: https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt#docstring-standard
+
+.. _argparse: http://code.google.com/p/argparse/
+
+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, thanks to Alexander Clausen.
+
+* 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.  Special thanks to John Hunter and Sameer D'Costa for their
+  help with this bug.
+
+* 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 :func:`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 :command:`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 :command:`easy_install ipython-extension` to
+  get it.  (done to decouple it from ipython release cycle)
+
diff --git a/docs/source/whatsnew/version0.10.txt b/docs/source/whatsnew/version0.10.txt
deleted file mode 100644
index 5761b42a6fe..00000000000
--- a/docs/source/whatsnew/version0.10.txt
+++ /dev/null
@@ -1,360 +0,0 @@
-=============
- 0.10 series
-=============
-
-Release 0.10.2
-==============
-
-IPython 0.10.2 was released April 9, 2011.  This is a minor bugfix release that
-preserves backward compatibility.  At this point, all IPython development
-resources are focused on the 0.11 series that includes a complete architectural
-restructuring of the project as well as many new capabilities, so this is
-likely to be the last release of the 0.10.x series.  We have tried to fix all
-major bugs in this series so that it remains a viable platform for those not
-ready yet to transition to the 0.11 and newer codebase (since that will require
-some porting effort, as a number of APIs have changed).
-
-Thus, we are not opening a 0.10.3 active development branch yet, but if the
-user community requires new patches and is willing to maintain/release such a
-branch, we'll be happy to host it on the IPython github repositories.
-
-Highlights of this release:
-
-- The main one is the closing of github ticket #185, a major regression we had
-  in 0.10.1 where pylab mode with GTK (or gthread) was not working correctly,
-  hence plots were blocking with GTK.  Since this is the default matplotlib
-  backend on Unix systems, this was a major annoyance for many users.  Many
-  thanks to Paul Ivanov for helping resolve this issue.
-  
-- Fix IOError bug on Windows when used with -gthread.
-- Work robustly if $HOME is missing from environment.
-- Better POSIX support in ssh scripts (remove bash-specific idioms).
-- Improved support for non-ascii characters in log files.
-- Work correctly in environments where GTK can be imported but not started
-  (such as a linux text console without X11).
-  
-For this release we merged 24 commits, contributed by the following people
-(please let us know if we ommitted your name and we'll gladly fix this in the
-notes for the future):
-
-* Fernando Perez
-* MinRK
-* Paul Ivanov
-* Pieter Cristiaan de Groot
-* TvrtkoM
-
-Release 0.10.1
-==============
-
-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.
-
-.. _github site: http://github.com/ipython
-
-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:
-
-  .. sourcecode:: ipython
-
-      In [2]: plt.figure()  # ensure a fresh figure
-
-      @savefig psimple.png width=4in
-      In [3]: plt.plot([1,2,3])
-      Out[3]: [<matplotlib.lines.Line2D object at 0x9b74d8c>]
-
-- Various fixes to the standalone ipython-wx application.
-
-- We now ship internally the excellent argparse library, graciously licensed
-  under BSD terms by Steven Bethard.  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.
-
-The following people contributed to this release (please let us know if we
-omitted your name and we'll gladly fix this in the notes for the future):
-
-* Beni Cherniavsky
-* Boyd Waters.
-* David Warde-Farley
-* Fernando Perez
-* Gökhan Sever
-* John Hunter
-* Justin Riley
-* Kiorky
-* Laurent Dufrechou
-* Mark E. Smith
-* Matthieu Brucher
-* Satrajit Ghosh
-* Sebastian Busch
-* Václav Šmilauer
-
-Release 0.10
-============
-
-This release brings months of slow but steady development, and will be the last
-before a major restructuring and cleanup of IPython's internals that is already
-under way.  For this reason, we hope that 0.10 will be a stable and robust
-release so that while users adapt to some of the API changes that will come
-with the refactoring that will become IPython 0.11, they can safely use 0.10 in
-all existing projects with minimal changes (if any).
-
-IPython 0.10 is now a medium-sized project, with roughly (as reported by David
-Wheeler's :command:`sloccount` utility) 40750 lines of Python code, and a diff
-between 0.9.1 and this release that contains almost 28000 lines of code and
-documentation.  Our documentation, in PDF format, is a 495-page long PDF
-document (also available in HTML format, both generated from the same sources).
-
-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):
-
-* Alexander Clausen: fix #341726.
-* Brian Granger: lots of work everywhere (features, bug fixes, etc).
-* Daniel Ashbrook: bug report on MemoryError during compilation, now fixed.
-* Darren Dale: improvements to documentation build system, feedback, design
-  ideas.
-* Fernando Perez: various places.
-* Gaël Varoquaux: core code, ipythonx GUI, design discussions, etc. Lots...
-* John Hunter: suggestions, bug fixes, feedback.
-* Jorgen Stenarson: work on many fronts, tests, fixes, win32 support, etc.
-* Laurent Dufréchou: many improvements to ipython-wx standalone app.
-* Lukasz Pankowski: prefilter, `%edit`, demo improvements.
-* Matt Foster: TextMate support in `%edit`.
-* Nathaniel Smith: fix #237073.
-* Pauli Virtanen: fixes and improvements to extensions, documentation.
-* Prabhu Ramachandran: improvements to `%timeit`.
-* Robert Kern: several extensions.
-* Sameer D'Costa: help on critical bug #269966.
-* Stephan Peijnik: feedback on Debian compliance and many man pages.
-* Steven Bethard: we are now shipping his :mod:`argparse` module.
-* Tom Fetherston: many improvements to :mod:`IPython.demo` module.
-* Ville Vainio: lots of work everywhere (features, bug fixes, etc).
-* Vishal Vasta: ssh support in ipcluster.
-* Walter Doerwald: work on the :mod:`IPython.ipipe` system.
-
-Below we give an overview of new features, bug fixes and backwards-incompatible
-changes.  For a detailed account of every change made, feel free to view the
-project log with :command:`bzr log`.
-
-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.  A very useful new
-  feature contributed by Robert Kern.
-
-* IPython 'demos', created with the :mod:`IPython.demo` module, can now be
-  created from files on disk or strings in memory.  Other fixes and
-  improvements to the demo system, by Tom Fetherston.
-
-* Added :func:`find_cmd` function to :mod:`IPython.platutils` module, to find
-  commands in a cross-platform manner.
-
-* Many improvements and fixes to Gaël Varoquaux's :command:`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.
-
-* :class:`MultiengineClient` objects now have a :meth:`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 :mod:`IPython.Extensions.ipy_pretty` extension by Robert Kern
-  provides configurable pretty-printing.
-
-* Many improvements to the :command:`ipython-wx` standalone WX-based IPython
-  application by Laurent Dufréchou.  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
-  :mod:`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 :command:`trial` runner
-  to ensure proper management of Twisted-using code.  The test suite degrades
-  gracefully if optional dependencies are not available, so that the
-  :command:`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.  Thanks to Vishal Vatsa for implementing this!
-
-* The wonderful TextMate editor can now be used with %edit 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 :command:`bzr` and Launchpad.
-  
-* Fully refactored :command:`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 :command:`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 '%edit pasted_block', pasted_block variable gets updated
-  with new data (so repeated editing makes sense)
-
-.. _Numpy Documentation Standard: http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines#docstring-standard
-
-.. _argparse: http://code.google.com/p/argparse/
-
-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, thanks to Alexander Clausen.
-
-* 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.  Special thanks to John Hunter and Sameer D'Costa for their
-  help with this bug.
-
-* 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 :func:`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 :command:`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 :command:`easy_install ipython-extension` to
-  get it.  (done to decouple it from ipython release cycle)
-
diff --git a/docs/source/whatsnew/version0.11.rst b/docs/source/whatsnew/version0.11.rst
new file mode 100644
index 00000000000..b21faa66796
--- /dev/null
+++ b/docs/source/whatsnew/version0.11.rst
@@ -0,0 +1,765 @@
+=============
+ 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.  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/post/innovations-in-ipython
+
+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 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 :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`__, more details :ref:`below
+  <parallel_011>`.
+
+.. __: 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 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 :ref:`well-documented messaging protocol <messaging>` 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
+  information 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 
+  integratron 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>
+
+
+Development summary: moving to Git and Github
+---------------------------------------------
+
+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.
+Feel free to use our little Launchpad to Github issues `porting script`_ if you
+need to make a similar transition.
+
+.. __: http://mail.scipy.org/pipermail/ipython-dev/2010-April/005944.html
+.. _porting script: https://gist.github.com/835577
+
+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 ~2200 commits make up this cycle::
+
+    git diff $(git merge-base 0.10.2 HEAD)  | wc -l
+    288019
+
+    git log $(git merge-base 0.10.2 HEAD)..HEAD --oneline | wc -l
+    2200
+
+Since our move to github, 511 issues were closed, 226 of which were pull
+requests and 285 regular issues (:ref:`a full list with links
+<issues_list_011>` is available for those interested in the details).  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:: ../_images/qtconsole.png
+    :width: 400px
+    :alt: IPython Qt console with embedded plots
+    :align: center
+    :target: ../_images/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 `Jupyter Qt Console site <https://jupyter.org/qtconsole>`_ for a detailed
+description of the console's features and use.
+
+
+.. _parallel_011:
+
+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 a full description of how to use IPython for parallel
+computing, 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 this release, a significant 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:`traitlets.HasTraits`.
+* :class:`traitlets.config.configurable.Configurable`.
+* :class:`traitlets.config.application.Application`.
+* :class:`traitlets.config.loader.ConfigLoader`.
+* :class:`traitlets.config.loader.Config`
+
+We are still in the process of writing developer focused documentation about
+these classes, but for now our :ref:`configuration documentation
+<config_overview>` contains a high level overview of the concepts that these
+classes express.
+
+The biggest user-visible change is likely the move to using the config system
+to determine the command-line arguments for IPython applications. The benefit
+of this is that *all* configurable values in IPython are exposed on the
+command-line, but the syntax for specifying values has changed. The gist is
+that assigning values is pure Python assignment.  Simple flags exist for
+commonly used options, these are always prefixed with '--'.
+
+The IPython command-line help has the details of all the options (via
+``ipython --help``), but a simple example should clarify things; the ``pylab``
+flag can be used to start in pylab mode with the qt4 backend::
+
+  ipython --pylab=qt
+
+which is equivalent to using the fully qualified form::
+
+  ipython --TerminalIPythonApp.pylab=qt
+
+The long-form options can be listed via ``ipython --help-all``.
+
+
+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
+ZeroMQ messaging framework. There is already a Qt console client, which can
+be started by calling ``ipython qtconsole``. The protocol is :ref:`documented
+<messaging>`.
+
+The parallel computing framework has also been rewritten using ZMQ. The
+protocol is described in the ipyparallel documentation, and the code is in the
+new :mod:`IPython.parallel` module.
+
+.. _python3_011:
+
+Python 3 support
+----------------
+
+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.  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.
+
+.. _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:: ../_images/ms_visual_studio.png
+    :width: 500px
+    :alt: IPython console embedded in Microsoft Visual Studio.
+    :align: center
+    :target: ../_images/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
+  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:
+
+.. sourcecode:: python
+
+    from traitlets.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 :func:`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 :mod:`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 :ref:`documentation <config_index>` for more details.
+
+* The :class:`~IPython.core.interactiveshell.InteractiveShell` class is now a
+  :class:`~traitlets.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
+  of functionality into components.
+
+* The embedded shell has been refactored into a truly standalone subclass of
+  :class:`InteractiveShell` called :class:`InteractiveShellEmbed`.  All
+  embedding logic has been taken out of the base class and put into the 
+  embedded subclass.
+
+* Added methods of :class:`~IPython.core.interactiveshell.InteractiveShell` to
+  help it cleanup after itself. The :meth:`cleanup` method controls this. We
+  couldn't do this in :meth:`__del__` because we have cycles in our object
+  graph that prevent it from being called.
+
+* Created a new module :mod:`IPython.utils.importstring` for resolving
+  strings like ``foo.bar.Bar`` to the actual class.
+
+* Completely refactored the :mod:`IPython.core.prefilter` module into
+  :class:`~traitlets.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`).
+
+* New top level :func:`~IPython.frontend.terminal.embed.embed` function that can
+  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`.
+
+* Created a configuration system (:mod:`traitlets.config.configurable`) that is
+  based on :mod:`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 :class:`~traitlets.config.configurable.Configurable`. All IPython
+  developers should become familiar with the config system.
+
+* Created a new :class:`~traitlets.config.loader.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 :class:`~traitlets.config.loader.Config` instances recursively and iii) it
+  will automatically create sub-:class:`~traitlets.config.loader.Config`
+  instances for attributes that start with an uppercase character.
+
+* Created new configuration loaders in :mod:`traitlets.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 :mod:`argparse` and plain python
+  files.  These are used to implement the new configuration system.
+
+* Created a top-level :class:`Application` class in
+  :mod:`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 :class:`Configurable`
+  instances and then starts the application running. An extended
+  :class:`BaseIPythonApplication` class adds logic for handling the
+  IPython directory as well as profiles, and all IPython entry points
+  extend it.
+
+* The :class:`Type` and :class:`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
+  :class:`~traitlets.HasTraitlets` is instantiated.
+
+* :mod:`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 :mod:`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
+  module or the main IPython docs for details.
+
+* For users, GUI event loop integration is now handled through the new
+  :command:`%gui` magic command.  Type ``%gui?`` at an IPython prompt for
+  documentation.
+
+* For developers :mod:`IPython.lib.inputhook` provides a simple interface
+  for managing the event loops in their interactive GUI applications.
+  Examples can be found in our :file:`examples/lib` directory.
+
+Backwards incompatible changes
+------------------------------
+
+* The Twisted-based :mod:`IPython.kernel` has been removed, and completely
+  rewritten as :mod:`IPython.parallel`, using ZeroMQ.
+
+* Profiles are now directories. Instead of a profile being a single config file,
+  profiles are now self-contained directories. By default, profiles get their
+  own IPython history, log files, and everything. To create a new profile, do
+  ``ipython profile create <name>``.
+
+* All IPython applications have been rewritten to use
+  :class:`~traitlets.config.loader.KeyValueConfigLoader`. This means that
+  command-line options have changed. Now, all configurable values are accessible
+  from the command-line with the same syntax as in a configuration file.
+
+* The command line options ``-wthread``, ``-qthread`` and
+  ``-gthread`` have been removed. Use ``--gui=wx``, ``--gui=qt``, ``--gui=gtk``
+  instead.
+
+* The extension loading functions have been renamed to
+  :func:`load_ipython_extension` and :func:`unload_ipython_extension`.
+
+* :class:`~IPython.core.interactiveshell.InteractiveShell` no longer takes an
+  ``embedded`` argument. Instead just use the
+  :class:`~IPython.core.interactiveshell.InteractiveShellEmbed` class.
+
+* ``__IPYTHON__`` is no longer injected into ``__builtin__``.
+
+* :meth:`Struct.__init__` no longer takes `None` as its first argument.  It
+  must be a :class:`dict` or :class:`Struct`.
+
+* :meth:`~IPython.core.interactiveshell.InteractiveShell.ipmagic` has been
+  renamed :meth:`~IPython.core.interactiveshell.InteractiveShell.magic.`
+
+* The functions :func:`ipmagic` and :func:`ipalias` have been removed from
+  :mod:`__builtins__`.
+
+* The references to the global
+  :class:`~IPython.core.interactivehell.InteractiveShell` instance (``_ip``, and
+  ``__IP``) have been removed from the user's namespace. They are replaced by a
+  new function called :func:`get_ipython` that returns the current
+  :class:`~IPython.core.interactiveshell.InteractiveShell` instance. This
+  function is injected into the user's namespace and is now the main way of
+  accessing the running IPython.
+
+* Old style configuration files :file:`ipythonrc` and :file:`ipy_user_conf.py`
+  are no longer supported. Users should migrate there configuration files to
+  the new format described :doc:`here </config/intro>` and
+  :ref:`here <config_overview>`.
+
+* The old IPython extension API that relied on :func:`ipapi` has been
+  completely removed. The new extension API is described :ref:`here
+  <extensions_overview>`.
+
+* Support for ``qt3`` has been dropped.  Users who need this should use
+  previous versions of IPython.
+
+* Removed :mod:`shellglobals` as it was obsolete.
+
+* Removed all the threaded shells in :mod:`IPython.core.shell`. These are no
+  longer needed because of the new capabilities in
+  :mod:`IPython.lib.inputhook`.
+
+* New top-level sub-packages have been created: :mod:`IPython.core`, 
+  :mod:`IPython.lib`, :mod:`IPython.utils`, :mod:`IPython.deathrow`,
+  :mod:`IPython.quarantine`.  All existing top-level modules have been
+  moved to appropriate sub-packages.  All internal import statements
+  have been updated and tests have been added.  The build system (setup.py
+  and friends) have been updated. See :doc:`/api/index` for details of these
+  new sub-packages.
+
+* :mod:`IPython.ipapi` has been moved to :mod:`IPython.core.ipapi`.
+  :mod:`IPython.Shell` and :mod:`IPython.iplib` have been split and removed as
+  part of the refactor.
+
+* :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.
+
+* 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
+  refactoring in the core. With proper updates, these should still work.
+
+
+Known Regressions
+-----------------
+
+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
+purposes 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.
diff --git a/docs/source/whatsnew/version0.12.rst b/docs/source/whatsnew/version0.12.rst
new file mode 100644
index 00000000000..5d27504d4bc
--- /dev/null
+++ b/docs/source/whatsnew/version0.12.rst
@@ -0,0 +1,369 @@
+=============
+ 0.12 Series
+=============
+
+Release 0.12.1
+==============
+
+IPython 0.12.1 is a bugfix release of 0.12, pulling only bugfixes and minor
+cleanup from 0.13, timed for the Ubuntu 12.04 LTS release.
+
+See the :ref:`list of fixed issues <issues_list_012>` for specific backported issues.
+
+
+Release 0.12
+============
+
+IPython 0.12 contains several major new features, as well as a large amount of
+bug and regression fixes.  The 0.11 release brought with it a lot of new
+functionality and major refactorings of the codebase; by and large this has
+proven to be a success as the number of contributions to the project has
+increased dramatically, proving that the code is now much more approachable.
+But in the refactoring inevitably some bugs were introduced, and we have also
+squashed many of those as well as recovered some functionality that had been
+temporarily disabled due to the API changes.
+
+The following major new features appear in this version.
+
+
+An interactive browser-based Notebook with rich media support
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A powerful new interface puts IPython in your browser. You can start it with
+the command ``ipython notebook``:
+
+.. figure:: ../_images/notebook_specgram.png
+    :width: 400px
+    :alt: The IPython notebook with embedded text, code, math and figures.
+    :align: center
+    :target: ../_images/notebook_specgram.png
+
+    The new IPython notebook showing text, mathematical expressions in LaTeX,
+    code, results and embedded figures created with Matplotlib.
+
+This new interface maintains all the features of IPython you are used to, as it
+is a new client that communicates with the same IPython kernels used by the
+terminal and Qt console.  But the web notebook provides for a different
+workflow where you can integrate, along with code execution, also text,
+mathematical expressions, graphics, video, and virtually any content that a
+modern browser is capable of displaying.
+
+You can save your work sessions as documents that retain all these elements and
+which can be version controlled, emailed to colleagues or saved as HTML or PDF
+files for printing or publishing statically on the web.  The internal storage
+format is a JSON file that can be easily manipulated for manual exporting to
+other formats.
+
+This Notebook is a major milestone for IPython, as for years we have tried to
+build this kind of system.  We were inspired originally by the excellent
+implementation in Mathematica, we made a number of attempts using older
+technologies in earlier Summer of Code projects in 2005 (both students and
+Robert Kern developed early prototypes), and in recent years we have seen the
+excellent implementation offered by the `Sage <http://sagemath.org>` system.
+But we continued to work on something that would be consistent with the rest of
+IPython's design, and it is clear now that the effort was worth it: based on
+the ZeroMQ communications architecture introduced in version 0.11, the notebook
+can now retain 100% of the features of the real IPython.  But it can also
+provide the rich media support and high quality Javascript libraries that were
+not available in browsers even one or two years ago (such as high-quality
+mathematical rendering or built-in video).
+
+The notebook has too many useful and important features to describe in these
+release notes; our documentation now contains a directory called
+``examples/notebooks`` with several notebooks that illustrate various aspects
+of the system.  You should start by reading those named
+``00_notebook_tour.ipynb`` and ``01_notebook_introduction.ipynb`` first, and
+then can proceed to read the others in any order you want.
+
+To start the notebook server, go to a directory containing the notebooks you
+want to open (or where you want to create new ones) and type::
+
+  ipython notebook
+
+You can see all the relevant options with::
+
+  ipython notebook --help
+  ipython notebook --help-all  # even more
+
+and just like the Qt console, you can start the notebook server with pylab
+support by using::
+  
+  ipython notebook --pylab
+
+for floating matplotlib windows or::
+  
+  ipython notebook --pylab inline
+
+for plotting support with automatically inlined figures.  Note that it is now
+possible also to activate pylab support at runtime via ``%pylab``, so you do
+not need to make this decision when starting the server.
+
+
+.. _two_process_console:
+
+Two-process terminal console
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Based on the same architecture as the notebook and the Qt console, we also have
+now a terminal-based console that can connect to an external IPython kernel
+(the same kernels used by the Qt console or the notebook, in fact).  While this
+client behaves almost identically to the usual IPython terminal application,
+this capability can be very useful to attach an interactive console to an
+existing kernel that was started externally.  It lets you use the interactive
+``%debug`` facilities in a notebook, for example (the web browser can't
+interact directly with the debugger) or debug a third-party code where you may
+have embedded an IPython kernel.
+
+This is also something that we have wanted for a long time, and which is a
+culmination (as a team effort) of the work started last year during the 2010
+Google Summer of Code project.
+  
+Tabbed QtConsole
+~~~~~~~~~~~~~~~~
+
+The QtConsole now supports starting multiple kernels in tabs, and has a
+menubar, so it looks and behaves more like a real application.  Keyboard
+enthusiasts can disable the menubar with ctrl-shift-M (:ghpull:`887`).
+
+.. figure:: ../_images/qtconsole_tabbed.png
+    :width: 400px
+    :alt: Tabbed IPython Qt console with embedded plots and menus.
+    :align: center
+    :target: ../_images/qtconsole_tabbed.png
+
+    The improved Qt console for IPython, now with tabs to control multiple
+    kernels and full menu support.
+
+
+Full Python 3 compatibility
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+IPython can now be installed from a single codebase on Python 2 and
+Python 3. The installation process for Python 3 automatically runs 2to3. The
+same 'default' profile is now used for Python 2 and 3 (the previous version had
+a separate 'python3' profile).
+
+Standalone Kernel
+~~~~~~~~~~~~~~~~~
+
+The ``ipython kernel`` subcommand has been added, to allow starting a
+standalone kernel, that can be used with various frontends.  You can then later
+connect a Qt console or a terminal console to this kernel by typing e.g.::
+
+  ipython qtconsole --existing
+
+if it's the only one running, or by passing explicitly the connection
+parameters (printed by the kernel at startup).
+
+
+PyPy support
+~~~~~~~~~~~~
+
+The terminal interface to IPython now runs under `PyPy <http://pypy.org/>`_.
+We will continue to monitor PyPy's progress, and hopefully before long at least
+we'll be able to also run the notebook.  The Qt console may take longer, as Qt
+is a very complex set of bindings to a huge C++ library, and that is currently
+the area where PyPy still lags most behind.  But for everyday interactive use
+at the terminal, with this release and PyPy 1.7, things seem to work quite well
+from our admittedly limited testing.
+
+  
+Other important new features
+----------------------------
+
+* **SSH Tunnels**: In 0.11, the :mod:`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 :class:`~IPython.core.history.HistoryManager` class
+  for interacting with your IPython SQLite history database has been split,
+  adding a parent :class:`~IPython.core.history.HistoryAccessor` class, so that
+  users can write code to access and search their IPython history without being
+  in an IPython session (:ghpull:`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 (:ghpull:`923`).
+
+* **Multiline History**: Multiline readline history has been restored to the
+  Terminal frontend by default (:ghpull:`838`).
+
+* **%store**: The ``%store`` magic from earlier versions has been updated and
+  re-enabled (:ref:`extensions_storemagic`; :ghpull:`1029`). To autorestore
+  stored variables on startup, specify ``c.StoreMagic.autorestore = True`` in
+  :file:`ipython_config.py`.
+
+
+Major Bugs fixed
+----------------
+
+In this cycle, we have :ref:`closed over 500 issues <issues_list_012>`, 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 :ghissue:`704`.
+
+* IPython path utils, such as :func:`~IPython.utils.path.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 (:ghissue:`669`).
+
+* :func:`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) (:ghissue:`673`).
+
+* :mod:`zmq` version detection no longer uses simple lexicographical comparison
+  to check minimum version, which prevents 0.11 from working with pyzmq-2.1.10
+  (:ghpull:`758`).
+
+* A bug in PySide < 1.0.7 caused crashes on OSX when tooltips were shown
+  (:ghissue:`711`). these tooltips are now disabled on old PySide
+  (:ghpull:`963`).
+
+* IPython no longer crashes when started on recent versions of Python 3 in
+  Windows (:ghissue:`737`).
+
+* Instances of classes defined interactively can now be pickled (:ghissue:`29`;
+  :ghpull:`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 :mod:`IPython.lib.kernel`, for easier connecting to existing
+  kernels.
+
+* :class:`~IPython.zmq.kernelmanager.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,
+  :class:`~IPython.core.prompts.PromptManager`, which has traits for
+  :attr:`in_template`, :attr:`in2_template` (the ``...:`` continuation prompt),
+  :attr:`out_template` and :attr:`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 :file:`IPython/core/prompts.py`.
+
+* The class inheritance of the Launchers in
+  :mod:`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 deprecated 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
+  :func:`~IPython.frontend.terminal.embed.embed` with no arguments still works
+  as before.
+
+
+Development summary and credits
+-------------------------------
+
+The previous version (IPython 0.11) was released on July 31 2011, so this
+release cycle was roughly 4 1/2 months long, we closed a total of 515 issues,
+257 pull requests and 258 regular issues (a :ref:`detailed list
+<issues_list_012>` is available).
+
+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
+had commits from the following 45 contributors, a mix of new and regular names
+(in alphabetical order by first name):
+
+* Alcides <alcides-at-do-not-span-me.com>
+* Ben Edwards <bedwards-at-cs.unm.edu>
+* Benjamin Ragan-Kelley <benjaminrk-at-gmail.com>
+* Benjamin Thyreau <benjamin.thyreau-at-gmail.com>
+* Bernardo B. Marques <bernardo.fire-at-gmail.com>
+* Bernard Paulus <bprecyclebin-at-gmail.com>
+* Bradley M. Froehle <brad.froehle-at-gmail.com>
+* Brian E. Granger <ellisonbg-at-gmail.com>
+* Christian Boos <cboos-at-bct-technology.com>
+* Daniel Velkov <danielv-at-mylife.com>
+* Erik Tollerud <erik.tollerud-at-gmail.com>
+* Evan Patterson <epatters-at-enthought.com>
+* Felix Werner <Felix.Werner-at-kit.edu>
+* Fernando Perez <Fernando.Perez-at-berkeley.edu>
+* Gabriel <g2p.code-at-gmail.com>
+* Grahame Bowland <grahame-at-angrygoats.net>
+* Hannes Schulz <schulz-at-ais.uni-bonn.de>
+* Jens Hedegaard Nielsen <jenshnielsen-at-gmail.com>
+* Jonathan March <jmarch-at-enthought.com>
+* Jörgen Stenarson <jorgen.stenarson-at-bostream.nu>
+* Julian Taylor <jtaylor.debian-at-googlemail.com>
+* Kefu Chai <tchaikov-at-gmail.com>
+* macgyver <neil.rabinowitz-at-merton.ox.ac.uk>
+* Matt Cottingham <matt.cottingham-at-gmail.com>
+* Matthew Brett <matthew.brett-at-gmail.com>
+* Matthias BUSSONNIER <bussonniermatthias-at-gmail.com>
+* Michael Droettboom <mdboom-at-gmail.com>
+* Nicolas Rougier <Nicolas.Rougier-at-inria.fr>
+* Olivier Verdier <olivier.verdier-at-gmail.com>
+* Omar Andres Zapata Mesa <andresete.chaos-at-gmail.com>
+* Pablo Winant <pablo.winant-at-gmail.com>
+* Paul Ivanov <pivanov314-at-gmail.com>
+* Pauli Virtanen <pav-at-iki.fi>
+* Pete Aykroyd <aykroyd-at-gmail.com>
+* Prabhu Ramachandran <prabhu-at-enthought.com>
+* Puneeth Chaganti <punchagan-at-gmail.com>
+* Robert Kern <robert.kern-at-gmail.com>
+* Satrajit Ghosh <satra-at-mit.edu>
+* Stefan van der Walt <stefan-at-sun.ac.za>
+* Szabolcs Horvát <szhorvat-at-gmail.com>
+* Thomas Kluyver <takowl-at-gmail.com>
+* Thomas Spura <thomas.spura-at-gmail.com>
+* Timo Paulssen <timonator-at-perpetuum-immobile.de>
+* Valentin Haenel <valentin.haenel-at-gmx.de>
+* Yaroslav Halchenko <debian-at-onerussian.com>
+   
+.. note::
+
+    This list was generated with the output of
+    ``git log rel-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.
diff --git a/docs/source/whatsnew/version0.13.rst b/docs/source/whatsnew/version0.13.rst
new file mode 100644
index 00000000000..63140125a5a
--- /dev/null
+++ b/docs/source/whatsnew/version0.13.rst
@@ -0,0 +1,670 @@
+=============
+ 0.13 Series
+=============
+
+Release 0.13
+============
+
+IPython 0.13 contains several major new features, as well as a large amount of
+bug and regression fixes.  The previous version (0.12) was released on December
+19 2011, and in this development cycle we had:
+
+- ~6 months of work.
+- 373 pull requests merged.
+- 742 issues closed (non-pull requests).
+- contributions from 62 authors.
+- 1760 commits.
+- a diff of 114226 lines.
+
+The amount of work included in this release is so large, that we can only cover
+here the main highlights; please see our :ref:`detailed release statistics
+<issues_list_013>` for links to every issue and pull request closed on GitHub
+as well as a full list of individual contributors.
+
+
+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:
+
+.. image:: ../_images/ipy_013_notebook_spectrogram.png
+    :width: 460px
+    :alt: New user interface for Notebook
+    :align: center
+    :target: ../_images/ipy_013_notebook_spectrogram.png
+
+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:
+
+.. image:: ../_images/ipy_013_notebook_long_out.png
+    :width: 460px
+    :alt: Scrolling and hiding of long output in the notebook.
+    :align: center
+    :target: ../_images/ipy_013_notebook_long_out.png
+
+.. note::
+
+   The auto-folding of long outputs is disabled in Firefox due to bugs in its
+   scrolling behavior.  See :ghpull:`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 (:ghpull:`1739`):
+
+.. image:: ../_images/ipy_013_dashboard.png
+    :width: 460px
+    :alt: Improved dashboard
+    :align: center
+    :target: ../_images/ipy_013_dashboard.png
+
+
+Cluster management
+~~~~~~~~~~~~~~~~~~
+
+The notebook dashboard can now also start and stop clusters, thanks to a new
+tab in the dashboard user interface:
+
+.. image:: ../_images/ipy_013_dashboard_cluster.png
+    :width: 460px
+    :alt: Cluster management from the notebook dashboard
+    :align: center
+    :target: ../_images/ipy_013_dashboard_cluster.png
+
+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.
+
+.. _converters: https://github.com/ipython/nbconvert
+
+.. 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.
+
+.. _simple script: https://gist.github.com/1935808
+
+
+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. :ghpull:`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
+:file:`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
+:file:`01_notebook_introduction.ipynb`.
+
+.. figure:: ../_images/ipy_013_notebook_tooltip.png
+    :width: 460px
+    :alt: Improved tooltips in the notebook.
+    :align: center
+    :target: ../_images/ipy_013_notebook_tooltip.png
+
+    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 Resizable by dragging its
+  divider handle, a feature that had been requested many times by just about
+  anyone who had used the notebook system.  :ghpull:`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.  :ghpull:`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``; :ghpull:`1965`.
+  
+* Text (markdown) cells now line wrap correctly in the notebook, making them
+  much easier to edit :ghpull:`1330`.
+  
+* PNG and JPEG figures returned from plots can be interactively resized in the
+  notebook, by dragging them from their lower left corner. :ghpull:`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. :ghpull:`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.  :ghpull:`1609`.
+
+* Using ``Ctrl-S`` (or ``Cmd-S`` on a Mac) actually saves the notebook rather
+  than providing the fairly useless browser html save dialog.  :ghpull:`1334`.
+  
+* Allow accessing local files from the notebook (in urls), by serving any local
+  file as the url ``files/<relativepath>``.  This makes it possible to, for
+  example, embed local images in a notebook.  :ghpull:`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 (:ghpull:`1732`).  Now, a separate base
+class is provided in :class:`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
+:ref:`magic` docs for further details.
+
+All builtin magics now exist in a few subclasses that group together related
+functionality, and the new :mod:`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**2
+
+This 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:
+
+.. image:: ../_images/ipy_013_notebook_script_cells.png
+    :width: 460px
+    :alt: Cluster management from the notebook dashboard
+    :align: center
+    :target: ../_images/ipy_013_notebook_script_cells.png
+  
+In addition, we have also a number of :ref:`extensions <extensions_overview>`
+that provide specialized magics.  These typically require additional software
+to run and must be manually loaded via ``%load_ext <extension name>``, 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:
+
+.. image:: ../_images/ipy_013_notebook_cythonmagic.png
+    :width: 460px
+    :alt: Cython magic
+    :align: center
+    :target: ../_images/ipy_013_notebook_cythonmagic.png
+
+.. _cython: http://cython.org
+
+**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:
+
+.. image:: ../_images/ipy_013_notebook_octavemagic.png
+    :width: 460px
+    :alt: Octave magic
+    :align: center
+    :target: ../_images/ipy_013_notebook_octavemagic.png
+
+.. _octave: http://www.gnu.org/software/octave
+.. _oct2py: http://pypi.python.org/pypi/oct2py
+
+**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:
+
+.. image:: ../_images/ipy_013_notebook_rmagic.png
+    :width: 460px
+    :alt: R magic
+    :align: center
+    :target: ../_images/ipy_013_notebook_rmagic.png
+
+.. _R: http://www.r-project.org
+.. _rpy2: http://rpy.sourceforge.net/rpy2.html
+
+
+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 (:ghpull:`1851`).
+
+.. figure:: ../_images/ipy_013_qtconsole_completer.png
+    :width: 460px
+    :alt: ncurses-like completer, with highlighted selection.
+    :align: center
+    :target: ../_images/ipy_013_qtconsole_completer.png
+
+    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 
+(:ghpull:`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.<tab>``, if True: only those names
+in ``obj.__all__`` will be included.  When False [default]: the ``__all__``
+attribute is ignored. :ghpull:`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_ (:ghpull:`2007`, :ghpull:`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). :ghpull:`1782`.
+
+* Allow for restarting kernels without clearing the qtconsole, while leaving a
+  visible indication that the kernel has restarted. :ghpull:`1681`.
+  
+* Allow the native display of jpeg images in the qtconsole. :ghpull:`1643`.
+
+.. _spyder: https://code.google.com/p/spyderlib
+
+
+  
+Parallel
+--------
+
+The parallel tools have been improved and fine-tuned on multiple fronts.  Now,
+the creation of an :class:`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 :meth:`.Client.activate`
+method, to conveniently execute code on any subset of engines. :ghpull:`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:
+
+.. image::  ../_images/ipy_013_par_tb.png
+    :width: 460px
+    :alt: Improved parallel exceptions.
+    :align: center
+    :target: ../_images/ipy_013_par_tb.png
+
+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.
+
+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. :ghpull:`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 (:ghpull:`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 :meth:`.Client.spin_thread` / :meth:`~.Client.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. :ghpull:`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::
+
+    %%px
+    %%R
+    ... R code goes here
+  
+* It is possible to embed not only an interactive shell with the
+  :func:`IPython.embed` call as always, but now you can also embed a *kernel*
+  with :func:`IPython.embed_kernel()`.  Embedding an IPython kernel in an
+  application is useful when you want to use :func:`IPython.embed` but don't
+  have a terminal attached on stdin and stdout.
+
+* The new :func:`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 :mod:`IPython.display` module that
+aggregates all display routines, and the :mod:`traitlets.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.
+
+	  
+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. :ghpull:`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 :envvar:`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 :ghpull:`1167`, the complexity and confusion of
+  migrating to this variable is not worth the aesthetic improvement. Please use
+  the historical :envvar:`IPYTHONDIR` environment variable instead.
+
+* The default value of *interactivity* passed from
+  :meth:`~IPython.core.interactiveshell.InteractiveShell.run_cell` to
+  :meth:`~IPython.core.interactiveshell.InteractiveShell.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.  :ghpull:`2038`.
+
+* Improved continuous integration for IPython.  We now have automated test runs
+  on `Shining Panda <https://jenkins.shiningpanda.com/ipython>`_ and `Travis-CI
+  <http://travis-ci.org/#!/ipython/ipython>`_, as well as `Tox support
+  <http://tox.testrun.org>`_.
+
+* The `vim-ipython`_ functionality (externally developed) has been updated to
+  the latest version.
+
+.. _vim-ipython: https://github.com/ivanov/vim-ipython
+
+* 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. :ghpull:`1937`.
+
+* Use dvipng to format sympy.Matrix, enabling display of matrices in the Qt
+  console with the sympy printing extension. :ghpull:`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.  :ghpull:`1627`.
+
+* Use LaTeX to display, on output, various built-in types with the SymPy
+  printing extension. :ghpull:`1399`.
+
+* Add Gtk3 event loop integration and example. :ghpull:`1588`.
+
+* ``clear_output`` improvements, which allow things like progress bars and other
+  simple animations to work well in the notebook (:ghpull:`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. :ghpull:`1388`.
+
+  
+Major Bugs fixed
+----------------
+
+In this cycle, we have :ref:`closed over 740 issues <issues_list_013>`, 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. :ghpull:`1670`.
+
+* Fix ``%paste`` that would reject certain valid inputs. :ghpull:`1258`.
+
+* Fix sending and receiving of Numpy structured arrays (those with composite
+  dtypes, often used as recarrays). :ghpull:`2034`.
+
+* Reconnect when the websocket connection closes unexpectedly. :ghpull:`1577`.
+
+* Fix truncated representation of objects in the debugger by showing at least
+  80 characters' worth of information.  :ghpull:`1793`.
+
+* Fix logger to be Unicode-aware: logging could crash ipython if there was
+  unicode in the input. :ghpull:`1792`.
+
+* Fix images missing from XML/SVG export in the Qt console. :ghpull:`1449`.
+
+* Fix deepreload on Python 3. :ghpull:`1625`, as well as having a much cleaner
+  and more robust implementation of deepreload in general. :ghpull:`1457`.
+
+
+Backwards incompatible changes
+------------------------------
+
+* The exception :exc:`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.
diff --git a/docs/source/whatsnew/version0.8.txt b/docs/source/whatsnew/version0.8.rst
similarity index 100%
rename from docs/source/whatsnew/version0.8.txt
rename to docs/source/whatsnew/version0.8.rst
diff --git a/docs/source/whatsnew/version0.9.rst b/docs/source/whatsnew/version0.9.rst
new file mode 100644
index 00000000000..d7d11efe884
--- /dev/null
+++ b/docs/source/whatsnew/version0.9.rst
@@ -0,0 +1,283 @@
+========================================
+0.9 series
+========================================
+
+Release 0.9.1
+=============
+
+This release was quickly made to restore compatibility with Python 2.4, which
+version 0.9 accidentally broke.  No new features were introduced, other than
+some additional testing support for internal use.
+
+
+Release 0.9
+===========
+
+New features
+------------
+
+* All furl files and security certificates are now put in a read-only
+  directory named ~/.ipython/security.
+
+* A single function :func:`get_ipython_dir`, in :mod:`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 architecture 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 :command:`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:
+  :class:`IPython.kernel.task.StringTask` (this is the old `Task` object, but
+  renamed) and the new :class:`IPython.kernel.task.MapTask`, which is based on
+  a function.
+
+* A new interface, :class:`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
+  :class:`IPython.kernel.mapper.IMapper` for different controllers.  Both the
+  multiengine and task controller now have mapping capabilities.
+
+* 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 multiple 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:
+  :mod:`IPython.kernel`, :mod:`IPython.kernel.core`, :mod:`traitlets.config`,
+  :mod:`IPython.tools` and :mod:`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
+  :mod:`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 :mod:`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 :command:`ipcluster` command has been
+  removed as it was not working and it will be replaced soon by something much
+  more robust.
+
+* The :mod:`IPython.kernel` configuration now properly find the user's
+  IPython directory.
+
+* In ipapi, the :func:`make_user_ns` function has been replaced with
+  :func:`make_user_namespaces`, to support dict subclasses in namespace
+  creation.
+
+* :class:`IPython.kernel.client.Task` has been renamed
+  :class:`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 :class:`IPython.kernel.client.MultiEngineClient` and 
+  :class:`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 :mod:`IPython.kernel.asyncclient` are now created 
+  using the factory functions :func:`get_multiengine_client` and 
+  :func:`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.
+
+Changes merged in from IPython1
+-------------------------------
+
+New features
+............
+
+* Much improved ``setup.py`` and ``setupegg.py`` scripts.  Because Twisted and
+  zope.interface are now easy installable, we can declare them as dependencies
+  in our setupegg.py script.
+
+* IPython is now compatible with Twisted 2.5.0 and 8.x.
+
+* Added a new example of how to use :mod:`ipython1.kernel.asynclient`.
+
+* Initial draft of a process daemon in :mod:`ipython1.daemon`.  This has not
+  been merged into IPython and is still in `ipython1-dev`.
+  
+* The ``TaskController`` now has methods for getting the queue status.
+
+* The ``TaskResult`` objects not have information about how long the task
+  took to run.
+  
+* We are attaching additional attributes to exceptions ``(_ipython_*)`` that 
+  we use to carry additional info around.
+  
+* New top-level module :mod:`asyncclient` that has asynchronous versions (that
+  return deferreds) of the client classes.  This is designed to users who want
+  to run their own Twisted reactor.
+  
+* All the clients in :mod:`client` are now based on Twisted.  This is done by 
+  running the Twisted reactor in a separate thread and using the
+  :func:`blockingCallFromThread` function that is in recent versions of Twisted.
+
+* Functions can now be pushed/pulled to/from engines using
+  :meth:`MultiEngineClient.push_function` and
+  :meth:`MultiEngineClient.pull_function`.
+
+* Gather/scatter are now implemented in the client to reduce the work load
+  of the controller and improve performance.
+
+* Complete rewrite of the IPython documentation.  All of the documentation
+  from the IPython website has been moved into docs/source as restructured
+  text documents.  PDF and HTML documentation are being generated using 
+  Sphinx.
+
+* New developer oriented documentation: development guidelines and roadmap. 
+
+* Traditional ``ChangeLog`` has been changed to a more useful ``changes.txt``
+  file that is organized by release and is meant to provide something more
+  relevant for users.
+
+Bug fixes
+.........
+
+* Created a proper ``MANIFEST.in`` file to create source distributions.
+
+* Fixed a bug in the ``MultiEngine`` interface.  Previously, multi-engine 
+  actions were being collected with a :class:`DeferredList` with 
+  ``fireononeerrback=1``.  This meant that methods were returning 
+  before all engines had given their results.  This was causing extremely odd 
+  bugs in certain cases. To fix this problem, we have 1) set 
+  ``fireononeerrback=0`` to make sure all results (or exceptions) are in 
+  before returning and 2) introduced a :exc:`CompositeError` exception 
+  that wraps all of the engine exceptions.  This is a huge change as it means 
+  that users will have to catch :exc:`CompositeError` rather than the actual
+  exception.
+
+Backwards incompatible changes
+..............................
+
+* All names have been renamed to conform to the lowercase_with_underscore
+  convention.  This will require users to change references to all names like
+  ``queueStatus`` to ``queue_status``.
+
+* Previously, methods like :meth:`MultiEngineClient.push` and
+  :meth:`MultiEngineClient.push` used ``*args`` and ``**kwargs``.  This was
+  becoming a problem as we weren't able to introduce new keyword arguments into
+  the API.  Now these methods simple take a dict or sequence.  This has also
+  allowed us to get rid of the ``*All`` methods like :meth:`pushAll` and
+  :meth:`pullAll`.  These things are now handled with the ``targets`` keyword
+  argument that defaults to ``'all'``.
+
+* The :attr:`MultiEngineClient.magicTargets` has been renamed to
+  :attr:`MultiEngineClient.targets`. 
+
+* All methods in the MultiEngine interface now accept the optional keyword
+  argument ``block``.
+
+* Renamed :class:`RemoteController` to :class:`MultiEngineClient` and 
+  :class:`TaskController` to :class:`TaskClient`.
+
+* Renamed the top-level module from :mod:`api` to :mod:`client`.
+
+* Most methods in the multiengine interface now raise a :exc:`CompositeError`
+  exception that wraps the user's exceptions, rather than just raising the raw
+  user's exception.
+
+* Changed the ``setupNS`` and ``resultNames`` in the ``Task`` class to ``push`` 
+  and ``pull``.
+
diff --git a/docs/source/whatsnew/version0.9.txt b/docs/source/whatsnew/version0.9.txt
deleted file mode 100644
index 5887c5e7078..00000000000
--- a/docs/source/whatsnew/version0.9.txt
+++ /dev/null
@@ -1,283 +0,0 @@
-========================================
-0.9 series
-========================================
-
-Release 0.9.1
-=============
-
-This release was quickly made to restore compatibility with Python 2.4, which
-version 0.9 accidentally broke.  No new features were introduced, other than
-some additional testing support for internal use.
-
-
-Release 0.9
-===========
-
-New features
-------------
-
-* All furl files and security certificates are now put in a read-only
-  directory named ~./ipython/security.
-
-* A single function :func:`get_ipython_dir`, in :mod:`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 :command:`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:
-  :class:`IPython.kernel.task.StringTask` (this is the old `Task` object, but
-  renamed) and the new :class:`IPython.kernel.task.MapTask`, which is based on
-  a function.
-
-* A new interface, :class:`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
-  :class:`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:
-  :mod:`IPython.kernel`, :mod:`IPython.kernel.core`, :mod:`IPython.config`,
-  :mod:`IPython.tools` and :mod:`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
-  :mod:`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 :mod:`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 :command:`ipcluster` command has been
-  removed as it was not working and it will be replaced soon by something much
-  more robust.
-
-* The :mod:`IPython.kernel` configuration now properly find the user's
-  IPython directory.
-
-* In ipapi, the :func:`make_user_ns` function has been replaced with
-  :func:`make_user_namespaces`, to support dict subclasses in namespace
-  creation.
-
-* :class:`IPython.kernel.client.Task` has been renamed
-  :class:`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 :class:`IPython.kernel.client.MultiEngineClient` and 
-  :class:`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 :mod:`IPython.kernel.asyncclient` are now created 
-  using the factory functions :func:`get_multiengine_client` and 
-  :func:`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.
-
-Changes merged in from IPython1
--------------------------------
-
-New features
-............
-
-* Much improved ``setup.py`` and ``setupegg.py`` scripts.  Because Twisted and
-  zope.interface are now easy installable, we can declare them as dependencies
-  in our setupegg.py script.
-
-* IPython is now compatible with Twisted 2.5.0 and 8.x.
-
-* Added a new example of how to use :mod:`ipython1.kernel.asynclient`.
-
-* Initial draft of a process daemon in :mod:`ipython1.daemon`.  This has not
-  been merged into IPython and is still in `ipython1-dev`.
-  
-* The ``TaskController`` now has methods for getting the queue status.
-
-* The ``TaskResult`` objects not have information about how long the task
-  took to run.
-  
-* We are attaching additional attributes to exceptions ``(_ipython_*)`` that 
-  we use to carry additional info around.
-  
-* New top-level module :mod:`asyncclient` that has asynchronous versions (that
-  return deferreds) of the client classes.  This is designed to users who want
-  to run their own Twisted reactor.
-  
-* All the clients in :mod:`client` are now based on Twisted.  This is done by 
-  running the Twisted reactor in a separate thread and using the
-  :func:`blockingCallFromThread` function that is in recent versions of Twisted.
-
-* Functions can now be pushed/pulled to/from engines using
-  :meth:`MultiEngineClient.push_function` and
-  :meth:`MultiEngineClient.pull_function`.
-
-* Gather/scatter are now implemented in the client to reduce the work load
-  of the controller and improve performance.
-
-* Complete rewrite of the IPython docuementation.  All of the documentation
-  from the IPython website has been moved into docs/source as restructured
-  text documents.  PDF and HTML documentation are being generated using 
-  Sphinx.
-
-* New developer oriented documentation: development guidelines and roadmap. 
-
-* Traditional ``ChangeLog`` has been changed to a more useful ``changes.txt``
-  file that is organized by release and is meant to provide something more
-  relevant for users.
-
-Bug fixes
-.........
-
-* Created a proper ``MANIFEST.in`` file to create source distributions.
-
-* Fixed a bug in the ``MultiEngine`` interface.  Previously, multi-engine 
-  actions were being collected with a :class:`DeferredList` with 
-  ``fireononeerrback=1``.  This meant that methods were returning 
-  before all engines had given their results.  This was causing extremely odd 
-  bugs in certain cases. To fix this problem, we have 1) set 
-  ``fireononeerrback=0`` to make sure all results (or exceptions) are in 
-  before returning and 2) introduced a :exc:`CompositeError` exception 
-  that wraps all of the engine exceptions.  This is a huge change as it means 
-  that users will have to catch :exc:`CompositeError` rather than the actual
-  exception.
-
-Backwards incompatible changes
-..............................
-
-* All names have been renamed to conform to the lowercase_with_underscore
-  convention.  This will require users to change references to all names like
-  ``queueStatus`` to ``queue_status``.
-
-* Previously, methods like :meth:`MultiEngineClient.push` and
-  :meth:`MultiEngineClient.push` used ``*args`` and ``**kwargs``.  This was
-  becoming a problem as we weren't able to introduce new keyword arguments into
-  the API.  Now these methods simple take a dict or sequence.  This has also
-  allowed us to get rid of the ``*All`` methods like :meth:`pushAll` and
-  :meth:`pullAll`.  These things are now handled with the ``targets`` keyword
-  argument that defaults to ``'all'``.
-
-* The :attr:`MultiEngineClient.magicTargets` has been renamed to
-  :attr:`MultiEngineClient.targets`. 
-
-* All methods in the MultiEngine interface now accept the optional keyword
-  argument ``block``.
-
-* Renamed :class:`RemoteController` to :class:`MultiEngineClient` and 
-  :class:`TaskController` to :class:`TaskClient`.
-
-* Renamed the top-level module from :mod:`api` to :mod:`client`.
-
-* Most methods in the multiengine interface now raise a :exc:`CompositeError`
-  exception that wraps the user's exceptions, rather than just raising the raw
-  user's exception.
-
-* Changed the ``setupNS`` and ``resultNames`` in the ``Task`` class to ``push`` 
-  and ``pull``.
-
diff --git a/docs/source/whatsnew/version1.0.rst b/docs/source/whatsnew/version1.0.rst
new file mode 100644
index 00000000000..6911b869cd1
--- /dev/null
+++ b/docs/source/whatsnew/version1.0.rst
@@ -0,0 +1,302 @@
+============
+ 1.0 Series
+============
+
+Release 1.0.0: An Afternoon Hack
+================================
+
+
+IPython 1.0 requires Python ≥ 2.6.5 or ≥ 3.2.1.
+It does not support Python 3.0, 3.1, or 2.5.
+
+This is a big release.  The principal milestone is the addition of :mod:`IPython.nbconvert`,
+but there has been a great deal of work improving all parts of IPython as well.
+
+The previous version (0.13) was released on June 30, 2012,
+and in this development cycle we had:
+
+- ~12 months of work.
+- ~700 pull requests merged.
+- ~600 issues closed (non-pull requests).
+- contributions from ~150 authors.
+- ~4000 commits.
+
+The amount of work included in this release is so large that we can only cover
+here the main highlights; please see our :ref:`detailed release statistics
+<issues_list_100>` for links to every issue and pull request closed on GitHub
+as well as a full list of individual contributors.
+It includes
+
+Reorganization
+--------------
+
+There have been two major reorganizations in IPython 1.0:
+
+- Added :mod:`IPython.kernel` for all kernel-related code.
+  This means that :mod:`IPython.zmq` has been removed,
+  and much of it is now in :mod:`IPython.kernel.zmq`,
+  some of it being in the top-level :mod:`IPython.kernel`.
+- We have removed the `frontend` subpackage,
+  as it caused unnecessary depth.  So what was :mod:`IPython.frontend.qt`
+  is now :mod:`IPython.qt`, and so on.  The one difference is that
+  the notebook has been further flattened, so that
+  :mod:`IPython.frontend.html.notebook` is now just `IPython.html`.
+  There is a shim module, so :mod:`IPython.frontend` is still
+  importable in 1.0, but there will be a warning.
+- The IPython sphinx directives are now installed in :mod:`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:
+
+.. sourcecode:: python
+
+    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).
+:func:`IPython.embed()` is used for embedding IPython into the calling namespace,
+similar to calling :func:`Pdb.set_trace`, whereas :func:`start_ipython`
+will start a plain IPython session, loading config and startup files as normal.
+
+We also have added:
+
+.. sourcecode:: python
+
+    from IPython import get_ipython
+
+
+Which is a *library* function for getting the current IPython instance,
+and will return :py:data:`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:
+
+.. sourcecode:: python
+
+    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 :doc:`/config/inputtransforms`.
+- 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, :command:`iptest` will exclude various slow tests.
+  All tests can be run with :command:`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 :meth:`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 :mod:`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 :mod:`IPython.lib.inputhook` to control integration with GUI
+  event loops are no longer exposed in the top level of :mod:`IPython.lib`.
+  Code calling these should make sure to import them from
+  :mod:`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
+  :func:`IPython.utils.doctestreload.doctest_reload` to make doctests run 
+  correctly inside IPython. Python releases since those versions are unaffected.
+  For details, see :ghpull:`3068` and `Python issue 8048 <http://bugs.python.org/issue8048>`_.
+- The ``InteractiveShell.cache_main_mod()`` method has been removed, and
+  :meth:`~IPython.core.interactiveshell.InteractiveShell.new_main_mod` has a
+  different signature, expecting a filename where earlier versions expected
+  a namespace. See :ghpull:`3555` for details.
+- The short-lived plugin system has been removed. Extensions are the way to go.
+
+
+.. _nbconvert1:
+
+NbConvert
+---------
+
+The major milestone for IPython 1.0 is the addition of :mod:`IPython.nbconvert` - tools for converting
+IPython notebooks to various other formats.
+
+.. warning::
+
+    nbconvert is α-level preview code in 1.0
+
+To use nbconvert to convert various file formats::
+
+    ipython nbconvert --to html *.ipynb
+
+See ``ipython nbconvert --help`` for more information.
+nbconvert depends on `pandoc`_ for many of the translations to and from various formats.
+
+.. _pandoc: http://johnmacfarlane.net/pandoc/
+
+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 :func:`raw_input` / :func:`input`, and thus also ``%debug``,
+  and many other Python calls that expect user input.
+- You can load custom javascript and CSS in the notebook by editing the files
+  :file:`$(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 :ref:`IPython config file <config_overview>` 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 :file:`static/css/style.min.css`
+  (all style, including bootstrap), and :file:`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 :ref:`ipython
+  nbconvert <nbconvert1>` 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 :class:`~.KernelManager` and a :class:`~.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``.
+
diff --git a/docs/source/whatsnew/version2.0.rst b/docs/source/whatsnew/version2.0.rst
new file mode 100644
index 00000000000..3aca6a62b1e
--- /dev/null
+++ b/docs/source/whatsnew/version2.0.rst
@@ -0,0 +1,381 @@
+============
+ 2.x Series
+============
+
+Release 2.4
+===========
+
+January, 2014
+
+.. note::
+
+    Some of the patches marked for 2.4 were left out of 2.4.0.
+    Please use 2.4.1.
+
+- backport read support for nbformat v4 from IPython 3
+- support for PyQt5 in the kernel (not QtConsole)
+- support for Pygments 2.0
+
+For more information on what fixes have been backported to 2.4,
+see our :ref:`detailed release info <issues_list_200>`.
+
+
+Release 2.3.1
+=============
+
+November, 2014
+
+- Fix CRCRLF line-ending bug in notebooks on Windows
+
+For more information on what fixes have been backported to 2.3.1,
+see our :ref:`detailed release info <issues_list_200>`.
+
+Release 2.3.0
+=============
+
+October, 2014
+
+- improve qt5 support
+- prevent notebook data loss with atomic writes
+
+For more information on what fixes have been backported to 2.3,
+see our :ref:`detailed release info <issues_list_200>`.
+
+Release 2.2.0
+=============
+
+August, 2014
+
+- Add CORS configuration
+
+For more information on what fixes have been backported to 2.2,
+see our :ref:`detailed release info <issues_list_200>`.
+
+Release 2.1.0
+=============
+
+May, 2014
+
+IPython 2.1 is the first bugfix release for 2.0.
+For more information on what fixes have been backported to 2.1,
+see our :ref:`detailed release info
+<issues_list_200>`.
+
+
+Release 2.0.0
+=============
+
+April, 2014
+
+IPython 2.0 requires Python ≥ 2.7.2 or ≥ 3.3.0.
+It does not support Python 3.0, 3.1, 3.2, 2.5, or 2.6.
+
+The principal milestones of 2.0 are:
+
+- interactive widgets for the notebook
+- directory navigation in the notebook dashboard
+- persistent URLs for notebooks
+- a new modal user interface in the notebook
+- a security model for notebooks
+
+Contribution summary since IPython 1.0 in August, 2013:
+
+- ~8 months of work
+- ~650 pull requests merged
+- ~400 issues closed (non-pull requests)
+- contributions from ~100 authors
+- ~4000 commits
+
+The amount of work included in this release is so large that we can only cover
+here the main highlights; please see our :ref:`detailed release statistics
+<issues_list_200>` for links to every issue and pull request closed on GitHub
+as well as a full list of individual contributors.
+
+New stuff in the IPython notebook
+---------------------------------
+
+Directory navigation
+********************
+
+.. image:: /_images/2.0/treeview.png
+    :width: 392px
+    :alt: Directory navigation
+    :align: center
+
+The IPython notebook dashboard allows navigation into subdirectories.
+URLs are persistent based on the notebook's path and name,
+so no more random UUID URLs.
+
+Serving local files no longer needs the ``files/`` prefix.
+Relative links across notebooks and other files should work just as if notebooks were regular HTML files.
+
+Interactive widgets
+*******************
+
+.. image:: /_images/2.0/widgets.png
+    :width: 392px
+    :alt: Interactive widgets
+    :align: center
+
+IPython 2.0 adds :mod:`IPython.html.widgets`, for manipulating
+Python objects in the kernel with GUI controls in the notebook.
+IPython comes with a few built-in widgets for simple data types,
+and an API designed for developers to build more complex widgets.
+See the `widget docs`_ for more information.
+
+.. _widget docs: http://nbviewer.ipython.org/github/ipython/ipython/blob/2.x/examples/Interactive%20Widgets/Index.ipynb
+
+
+Modal user interface
+********************
+
+The notebook has added separate Edit and Command modes,
+allowing easier keyboard commands and making keyboard shortcut customization possible.
+See the new `User Interface notebook`_ for more information.
+
+.. _User Interface Notebook: http://nbviewer.ipython.org/github/ipython/ipython/blob/2.x/examples/Notebook/User%20Interface.ipynb
+
+
+You can familiarize yourself with the updated notebook user interface, including an
+explanation of Edit and Command modes, by going through the short guided tour
+which can be started from the Help menu.
+
+.. image:: /_images/2.0/user-interface.png
+    :width: 392px
+    :alt: Interface tour
+    :align: center
+
+
+Security
+********
+
+2.0 introduces a security model for notebooks,
+to prevent untrusted code from executing on users' behalf when notebooks open.
+A quick summary of the model:
+
+- Trust is determined by signing notebooks.
+- Untrusted HTML output is sanitized.
+- Untrusted Javascript is never executed.
+- HTML and Javascript in Markdown are never trusted.
+
+Dashboard "Running" tab
+***********************
+
+.. image:: /_images/2.0/running-crop.png
+    :width: 392px
+    :alt: Running tab
+    :align: center
+
+The dashboard now has a "Running" tab which shows all of the running notebooks.
+
+Single codebase Python 3 support
+--------------------------------
+
+IPython previously supported Python 3 by running 2to3 during setup. We
+have now switched to a single codebase which runs natively on Python 2.7
+and 3.3.
+
+Selecting matplotlib figure formats
+-----------------------------------
+
+Deprecate single-format ``InlineBackend.figure_format``
+configurable in favor of ``InlineBackend.figure_formats``,
+which is a set, supporting multiple simultaneous figure formats (e.g. png, pdf).
+
+This is available at runtime with the new API function :func:`IPython.display.set_matplotlib_formats`.
+
+clear_output changes
+--------------------
+
+* There is no longer a 500ms delay when calling ``clear_output``.
+* The ability to clear stderr and stdout individually was removed.
+* A new ``wait`` flag that prevents ``clear_output`` from being executed until new
+  output is available.  This eliminates animation flickering by allowing the
+  user to double buffer the output.
+* The output div height is remembered when the ``wait=True`` flag is used.
+
+Extending configurable containers
+---------------------------------
+
+Some configurable traits are containers (list, dict, set)
+Config objects now support calling ``extend``, ``update``, ``insert``, etc.
+on traits in config files, which will ultimately result in calling
+those methods on the original object.
+
+The effect being that you can now add to containers without having to copy/paste
+the initial value::
+
+    c = get_config()
+    c.InlineBackend.rc.update({ 'figure.figsize' : (6, 4) })
+
+Changes to hidden namespace on startup
+--------------------------------------
+
+Previously, all names declared in code run at startup
+(startup files, ``ipython -i script.py``, etc.)
+were added to the hidden namespace, which hides the names from tools like ``%whos``.
+There are two changes to this behavior:
+
+1. Scripts run on the command-line ``ipython -i script.py``now behave the same as if they were
+   passed to ``%run``, so their variables are never hidden.
+2. A boolean config flag ``InteractiveShellApp.hide_initial_ns`` has been added to optionally
+   disable the hidden behavior altogether. The default behavior is unchanged.
+
+Using dill to expand serialization support
+------------------------------------------
+
+The new function :func:`~IPython.utils.pickleutil.use_dill` allows
+dill to extend serialization support in :mod:`IPython.parallel` (closures, etc.).
+A :meth:`DirectView.use_dill` convenience method was also added, to enable dill
+locally and on all engines with one call.
+
+New IPython console lexer
+-------------------------
+
+The IPython console lexer has been rewritten and now supports tracebacks
+and customized input/output prompts.
+
+DisplayFormatter changes
+------------------------
+
+There was no official way to query or remove callbacks in the Formatter API.
+To remedy this, the following methods are added to :class:`BaseFormatter`:
+
+- ``lookup(instance)`` - return appropriate callback or a given object
+- ``lookup_by_type(type_or_str)`` - return appropriate callback for a given type or ``'mod.name'`` type string
+- ``pop(type_or_str)`` - remove a type (by type or string).
+  Pass a second argument to avoid KeyError (like dict).
+
+All of the above methods raise a KeyError if no match is found.
+
+And the following methods are changed:
+
+- ``for_type(type_or_str)`` - behaves the same as before, only adding support for ``'mod.name'``
+  type strings in addition to plain types. This removes the need for ``for_type_by_name()``,
+  but it remains for backward compatibility.
+
+Formatters can now raise NotImplementedError in addition to returning None
+to indicate that they cannot format a given object.
+
+Exceptions and Warnings
+***********************
+
+Exceptions are no longer silenced when formatters fail.
+Instead, these are turned into a :class:`~IPython.core.formatters.FormatterWarning`.
+A FormatterWarning will also be issued if a formatter returns data of an invalid type
+(e.g. an integer for 'image/png').
+
+
+Other changes
+-------------
+
+* `%%capture` cell magic now captures the rich display output, not just
+  stdout/stderr
+
+* In notebook, Showing tooltip on tab has been disables to avoid conflict with
+  completion, Shift-Tab could still be used to invoke tooltip when inside
+  function signature and/or on selection.
+
+* ``object_info_request`` has been replaced by ``object_info`` for consistency in the javascript API.
+  ``object_info`` is a simpler interface to register callback that is incompatible with ``object_info_request``.
+
+* Previous versions of IPython on Linux would use the XDG config directory,
+  creating :file:`~/.config/ipython` by default. We have decided to go
+  back to :file:`~/.ipython` for consistency among systems. IPython will
+  issue a warning if it finds the XDG location, and will move it to the new
+  location if there isn't already a directory there.
+
+* Equations, images and tables are now centered in Markdown cells.
+* Multiline equations are now centered in output areas; single line equations
+  remain left justified.
+
+* IPython config objects can be loaded from and serialized to JSON.
+  JSON config file have the same base name as their ``.py`` counterpart,
+  and will be loaded with higher priority if found.
+
+* bash completion updated with support for all ipython subcommands and flags, including nbconvert
+
+* ``ipython history trim``: added ``--keep=<N>`` as an alias for the more verbose
+  ``--HistoryTrim.keep=<N>``
+* New ``ipython history clear`` subcommand, which is the same as the newly supported
+  ``ipython history trim --keep=0``
+
+* You can now run notebooks in an interactive session via ``%run notebook.ipynb``.
+
+* Print preview is back in the notebook menus, along with options to
+  download the open notebook in various formats. This is powered by
+  nbconvert.
+
+* :exc:`~IPython.nbconvert.utils.pandoc.PandocMissing` exceptions will be
+  raised if Pandoc is unavailable, and warnings will be printed if the version
+  found is too old. The recommended Pandoc version for use with nbconvert is
+  1.12.1.
+
+* The InlineBackend.figure_format now supports JPEG output if PIL/Pillow is available.
+
+* Input transformers (see :doc:`/config/inputtransforms`) may now raise
+  :exc:`SyntaxError` if they determine that input is invalid. The input
+  transformation machinery in IPython will handle displaying the exception to
+  the user and resetting state.
+
+* Calling ``container.show()`` on javascript display is deprecated and will
+  trigger errors on future IPython notebook versions. ``container`` now show
+  itself as soon as non-empty
+
+* Added ``InlineBackend.print_figure_kwargs`` to allow passing keyword arguments
+  to matplotlib's ``Canvas.print_figure``. This can be used to change the value of
+  ``bbox_inches``, which is 'tight' by default, or set the quality of JPEG figures.
+
+* A new callback system has been introduced. For details, see :doc:`/config/callbacks`.
+
+* jQuery and require.js are loaded from CDNs in the default HTML template,
+  so javascript is available in static HTML export (e.g. nbviewer).
+
+Backwards incompatible changes
+------------------------------
+
+* Python 2.6 and 3.2 are no longer supported: the minimum required
+  Python versions are now 2.7 and 3.3.
+* The Transformer classes have been renamed to Preprocessor in nbconvert and
+  their ``call`` methods have been renamed to ``preprocess``.
+* The ``call`` methods of nbconvert post-processors have been renamed to
+  ``postprocess``.
+
+* The module ``IPython.core.fakemodule`` has been removed.
+
+* The alias system has been reimplemented to use magic functions. There should be little
+  visible difference while automagics are enabled, as they are by default, but parts of the
+  :class:`~IPython.core.alias.AliasManager` API have been removed.
+
+* We fixed an issue with switching between matplotlib inline and GUI backends,
+  but the fix requires matplotlib 1.1 or newer.  So from now on, we consider
+  matplotlib 1.1 to be the minimally supported version for IPython. Older
+  versions for the most part will work, but we make no guarantees about it.
+
+* The :command:`pycolor` command has been removed. We recommend the much more capable
+  :command:`pygmentize` command from the `Pygments <http://pygments.org/>`_ project.
+  If you need to keep the exact output of :command:`pycolor`, you can still use
+  ``python -m IPython.utils.PyColorize foo.py``.
+
+* :mod:`IPython.lib.irunner` and its command-line entry point have been removed.
+  It had fallen out of use long ago.
+
+* The ``input_prefilter`` hook has been removed, as it was never
+  actually used by the code. The input transformer system offers much
+  more powerful APIs to work with input code. See
+  :doc:`/config/inputtransforms` for details.
+
+* :class:`IPython.core.inputsplitter.IPythonInputSplitter` no longer has a method
+  ``source_raw_reset()``, but gains :meth:`~IPython.core.inputsplitter.IPythonInputSplitter.raw_reset`
+  instead. Use of ``source_raw_reset`` can be replaced with::
+
+      raw = isp.source_raw
+      transformed = isp.source_reset()
+
+* The Azure notebook manager was removed as it was no longer compatible with the notebook storage scheme.
+
+* Simplifying configurable URLs
+
+  - base_project_url is renamed to base_url (base_project_url is kept as a deprecated alias, for now)
+  - base_kernel_url configurable is removed (use base_url)
+  - websocket_url configurable is removed (use base_url)
diff --git a/docs/source/whatsnew/version3.rst b/docs/source/whatsnew/version3.rst
new file mode 100644
index 00000000000..491a90590f6
--- /dev/null
+++ b/docs/source/whatsnew/version3.rst
@@ -0,0 +1,391 @@
+============
+ 3.x Series
+============
+
+IPython 3.2.3
+=============
+
+Fixes compatibility with Python 3.4.4.
+
+IPython 3.2.2
+=============
+
+Address vulnerabilities when files have maliciously crafted filenames (CVE-2015-6938),
+or vulnerability when opening text files with malicious binary content (CVE pending).
+
+Users are **strongly** encouraged to upgrade immediately.
+There are also a few small unicode and nbconvert-related fixes.
+
+
+IPython 3.2.1
+=============
+
+IPython 3.2.1 is a small bugfix release, primarily for cross-site security fixes in the notebook.
+Users are **strongly** encouraged to upgrade immediately.
+There are also a few small unicode and nbconvert-related fixes.
+
+See :ref:`issues_list_3` for details.
+
+
+IPython 3.2
+===========
+
+IPython 3.2 contains important security fixes. Users are **strongly** encouraged to upgrade immediately.
+
+Highlights:
+
+- Address cross-site scripting vulnerabilities CVE-2015-4706, CVE-2015-4707
+- A security improvement that set the secure attribute to login cookie to prevent them to be sent over http
+- Revert the face color of matplotlib axes in the inline backend to not be transparent.
+- Enable mathjax safe mode by default
+- Fix XSS vulnerability in JSON error messages
+- Various widget-related fixes
+
+See :ref:`issues_list_3` for details.
+
+
+IPython 3.1
+===========
+
+Released April 3, 2015
+
+The first 3.x bugfix release, with 33 contributors and 344 commits.
+This primarily includes bugfixes to notebook layout and focus problems.
+
+
+Highlights:
+
+- Various focus jumping and scrolling fixes in the notebook.
+- Various message ordering and widget fixes in the notebook.
+- Images in markdown and output are confined to the notebook width.
+  An `.unconfined` CSS class is added to disable this behavior per-image.
+  The resize handle on output images is removed.
+- Improved ordering of tooltip content for Python functions, putting the signature at the top.
+- Fix UnicodeErrors when displaying some objects with unicode reprs on Python 2.
+- Set the kernel's working directory to the notebook directory when running ``nbconvert --execute``,
+  so that behavior matches the live notebook.
+- Allow setting custom SSL options for the tornado server with ``NotebookApp.ssl_options``,
+  and protect against POODLE with default settings by disabling SSLv3.
+- Fix memory leak in the IPython.parallel Controller on Python 3.
+
+
+See :ref:`issues_list_3` for details.
+
+
+Release 3.0
+===========
+
+Released February 27, 2015
+
+This is a really big release. Over 150 contributors, and almost 6000 commits in a bit under a year.
+Support for languages other than Python is greatly improved,
+notebook UI has been significantly redesigned,
+and a lot of improvement has happened in the experimental interactive widgets.
+The message protocol and document format have both been updated,
+while maintaining better compatibility with previous versions than prior updates.
+The notebook webapp now enables editing of any text file, and even
+a web-based terminal (on Unix platforms).
+
+3.x will be the last monolithic release of IPython,
+as the next release cycle will see the growing project split into its Python-specific and language-agnostic components.
+Language-agnostic projects (notebook, qtconsole, etc.) will move under the umbrella of the new Project Jupyter name,
+while Python-specific projects (interactive Python shell, Python kernel, IPython.parallel)
+will remain under IPython, and be split into a few smaller packages.
+To reflect this, IPython is in a bit of a transition state.
+The logo on the notebook is now the Jupyter logo.
+When installing kernels system-wide, they go in a `jupyter` directory.
+We are going to do our best to ease this transition for users and developers.
+
+Big changes are ahead.
+
+
+Using different kernels
+-----------------------
+
+.. image:: ../_images/kernel_selector_screenshot.png
+   :alt: Screenshot of 'new' dropdown showing different kernels
+   :align: center
+
+You can now choose a kernel for a notebook within the user interface, rather
+than starting up a separate notebook server for each kernel you want to use. The
+syntax highlighting adapts to match the language you're working in.
+
+Information about the kernel is stored in the notebook file, so when you open a
+notebook, it will automatically start the correct kernel.
+
+It is also easier to use the Qt console and the terminal console with other
+kernels, using the --kernel flag::
+
+    ipython qtconsole --kernel bash
+    ipython console --kernel bash
+
+    # To list available kernels
+    ipython kernelspec list
+
+Kernel authors should see :ref:`kernelspecs` for how to register their kernels
+with IPython so that these mechanisms work.
+
+Typing unicode identifiers
+--------------------------
+
+.. image:: /_images/unicode_completion.png
+
+Complex expressions can be much cleaner when written with a wider choice of
+characters. Python 3 allows unicode identifiers, and IPython 3 makes it easier
+to type those, using a feature from Julia. Type a backslash followed by a LaTeX
+style short name, such as ``\alpha``. Press tab, and it will turn into α.
+
+Widget migration guide
+----------------------
+The widget framework has a lot of backwards incompatible changes.
+For information about migrating widget notebooks and custom widgets to 3.0 refer
+to the :doc:`widget migration guide<version3_widget_migration>`.
+
+Other new features
+------------------
+
+* :class:`~.TextWidget` and :class:`~.TextareaWidget` objects now include a
+  ``placeholder`` attribute, for displaying placeholder text before the
+  user has typed anything.
+
+* The :magic:`load` magic can now find the source for objects in the user namespace.
+  To enable searching the namespace, use the ``-n`` option.
+
+  .. sourcecode:: ipython
+
+      In [1]: %load -n my_module.some_function
+
+* :class:`~.DirectView` objects have a new :meth:`~.DirectView.use_cloudpickle`
+  method, which works like ``view.use_dill()``, but causes the ``cloudpickle``
+  module from PiCloud's `cloud`__ library to be used rather than dill or the
+  builtin pickle module.
+
+  __ https://pypi.python.org/pypi/cloud
+
+* Added a .ipynb exporter to nbconvert.  It can be used by passing `--to notebook`
+  as a commandline argument to nbconvert.
+
+* New nbconvert preprocessor called :class:`~.ClearOutputPreprocessor`. This
+  clears the output from IPython notebooks.
+
+* New preprocessor for nbconvert that executes all the code cells in a notebook.
+  To run a notebook and save its output in a new notebook::
+
+      ipython nbconvert InputNotebook --ExecutePreprocessor.enabled=True --to notebook --output Executed
+
+* Consecutive stream (stdout/stderr) output is merged into a single output
+  in the notebook document.
+  Previously, all output messages were preserved as separate output fields in the JSON.
+  Now, the same merge is applied to the stored output as the displayed output,
+  improving document load time for notebooks with many small outputs.
+
+* ``NotebookApp.webapp_settings`` is deprecated and replaced with
+  the more informatively named ``NotebookApp.tornado_settings``.
+
+* Using :magic:`timeit` prints warnings if there is at least a 4x difference in timings
+  between the slowest and fastest runs, since this might meant that the multiple
+  runs are not independent of one another.
+
+* It's now possible to provide mechanisms to integrate IPython with other event
+  loops, in addition to the ones we already support. This lets you run GUI code
+  in IPython with an interactive prompt, and to embed the IPython
+  kernel in GUI applications. See :doc:`/config/eventloops` for details. As part
+  of this, the direct ``enable_*`` and ``disable_*`` functions for various GUIs
+  in :mod:`IPython.lib.inputhook` have been deprecated in favour of
+  :meth:`~.InputHookManager.enable_gui` and :meth:`~.InputHookManager.disable_gui`.
+
+* A ``ScrollManager`` was added to the notebook.  The ``ScrollManager`` controls how the notebook document is scrolled using keyboard.  Users can inherit from the ``ScrollManager`` or ``TargetScrollManager`` to customize how their notebook scrolls.  The default ``ScrollManager`` is the ``SlideScrollManager``, which tries to scroll to the nearest slide or sub-slide cell.
+
+* The function :func:`~IPython.html.widgets.interaction.interact_manual` has been
+  added which behaves similarly to :func:`~IPython.html.widgets.interaction.interact`,
+  but adds a button to explicitly run the interacted-with function, rather than
+  doing it automatically for every change of the parameter widgets. This should
+  be useful for long-running functions.
+
+* The ``%cython`` magic is now part of the Cython module. Use `%load_ext Cython` with a version of Cython >= 0.21 to have access to the magic now.
+
+* The Notebook application now offers integrated terminals on Unix platforms,
+  intended for when it is used on a remote server. To enable these, install
+  the ``terminado`` Python package.
+
+* The Notebook application can now edit any plain text files, via a full-page CodeMirror instance.
+
+* Setting the default highlighting language for nbconvert with the config option
+  ``NbConvertBase.default_language`` is deprecated. Nbconvert now respects
+  metadata stored in the :ref:`kernel spec <kernelspecs>`.
+
+* IPython can now be configured systemwide, with files in :file:`/etc/ipython`
+  or :file:`/usr/local/etc/ipython` on Unix systems,
+  or :file:`{%PROGRAMDATA%}\\ipython` on Windows.
+
+* Added support for configurable user-supplied `Jinja
+  <http://jinja.pocoo.org/>`_ HTML templates for the notebook.  Paths to
+  directories containing template files can be specified via
+  ``NotebookApp.extra_template_paths``.  User-supplied template directories
+  searched first by the notebook, making it possible to replace existing
+  templates with your own files.
+
+  For example, to replace the notebook's built-in ``error.html`` with your own,
+  create a directory like ``/home/my_templates`` and put your override template
+  at ``/home/my_templates/error.html``.  To start the notebook with your custom
+  error page enabled, you would run::
+
+      ipython notebook '--extra_template_paths=["/home/my_templates/"]'
+
+  It's also possible to override a template while also `inheriting
+  <http://jinja.pocoo.org/docs/dev/templates/#template-inheritance>`_ from that
+  template, by prepending ``templates/`` to the ``{% extends %}`` target of
+  your child template.  This is useful when you only want to override a
+  specific block of a template.  For example, to add additional CSS to the
+  built-in ``error.html``, you might create an override that looks like::
+
+    {% extends "templates/error.html" %}
+
+    {% block stylesheet %}
+    {{super()}}
+    <style type="text/css">
+      /* My Awesome CSS */
+    </style>
+    {% endblock %}
+
+* Added a widget persistence API.  This allows you to persist your notebooks interactive widgets.
+  Two levels of control are provided:
+  1. Higher level- ``WidgetManager.set_state_callbacks`` allows you to register callbacks for loading and saving widget state.  The callbacks you register are automatically called when necessary.
+  2. Lower level- the ``WidgetManager`` Javascript class now has ``get_state`` and ``set_state`` methods that allow you to get and set the state of the widget runtime.
+
+  Example code for persisting your widget state to session data::
+
+    %%javascript
+    require(['widgets/js/manager'], function(manager) {
+        manager.WidgetManager.set_state_callbacks(function() { // Load
+            return JSON.parse(sessionStorage.widgets_state || '{}');
+        }, function(state) { // Save
+            sessionStorage.widgets_state = JSON.stringify(state);
+        });
+    });
+
+* Enhanced support for :magic:`env` magic.  As before, :magic:`env` with no
+  arguments displays all environment variables and values.  Additionally,
+  :magic:`env` can be used to get or set individual environment variables. To
+  display an individual value, use the `%env var` syntax. To set a value, use
+  `env var val` or `env var=val`. Python value expansion using `$` works as usual.
+
+
+Backwards incompatible changes
+------------------------------
+
+* The :ref:`message protocol <messaging>` has been updated from version 4 to version 5.
+  Adapters are included, so IPython frontends can still talk to kernels that
+  implement protocol version 4.
+
+* The notebook format has been updated from version 3 to version 4.
+  Read-only support for v4 notebooks has been backported to IPython 2.4.
+  Notable changes:
+  
+  * heading cells are removed in favor or markdown headings
+  * notebook outputs and output messages are more consistent with each other
+  * use :func:`IPython.nbformat.read` and :func:`~IPython.nbformat.write`
+    to read and write notebook files
+    instead of the deprecated :mod:`IPython.nbformat.current` APIs.
+
+  You can downgrade a notebook to v3 via ``nbconvert``::
+  
+      ipython nbconvert --to notebook --nbformat 3 <notebook>
+  
+  which will create :file:`notebook.v3.ipynb`, a copy of the notebook in v3 format.
+
+* :func:`IPython.core.oinspect.getsource` call specification has changed:
+
+  * `oname` keyword argument has been added for property source formatting
+  * `is_binary` keyword argument has been dropped, passing :py:data:`True` had
+    previously short-circuited the function to return :py:data:`None` unconditionally
+
+* Removed the octavemagic extension: it is now available as ``oct2py.ipython``.
+
+* Creating PDFs with LaTeX no longer uses a post processor.
+  Use `nbconvert --to pdf` instead of `nbconvert --to latex --post pdf`.
+
+* Used https://github.com/jdfreder/bootstrap2to3 to migrate the Notebook to Bootstrap 3.
+
+  Additional changes:
+
+  - Set `.tab-content .row` `0px;` left and right margin (bootstrap default is `-15px;`)
+  - Removed `height: @btn_mini_height;` from `.list_header>div, .list_item>div` in `tree.less`
+  - Set `#header` div `margin-bottom: 0px;`
+  - Set `#menus` to `float: left;`
+  - Set `#maintoolbar .navbar-text` to `float: none;`
+  - Added no-padding convenience class.
+  - Set border of #maintoolbar to 0px
+
+* Accessing the `container` DOM object when displaying javascript has been
+  deprecated in IPython 2.0 in favor of accessing `element`. Starting with
+  IPython 3.0 trying to access `container` will raise an error in browser
+  javascript console.
+
+* ``IPython.utils.py3compat.open`` was removed: :func:`io.open` provides all
+  the same functionality.
+
+* The NotebookManager and ``/api/notebooks`` service has been replaced by
+  a more generic ContentsManager and ``/api/contents`` service,
+  which supports all kinds of files.
+* The Dashboard now lists all files, not just notebooks and directories.
+* The ``--script`` hook for saving notebooks to Python scripts is removed,
+  use :samp:`ipython nbconvert --to python {notebook}` instead.
+
+* The ``rmagic`` extension is deprecated, as it is now part of rpy2. See
+  :mod:`rpy2.ipython.rmagic`.
+
+* :meth:`~.KernelManager.start_kernel` and :meth:`~.KernelManager.format_kernel_cmd`
+  no longer accept a ``executable`` parameter. Use the kernelspec machinery instead.
+
+* The widget classes have been renamed from `*Widget` to `*`.  The old names are
+  still functional, but are deprecated.  i.e. `IntSliderWidget` has been renamed
+  to `IntSlider`.
+* The ContainerWidget was renamed to Box and no longer defaults as a flexible
+  box in the web browser.  A new FlexBox widget was added, which allows you to
+  use the flexible box model.
+
+* The notebook now uses a single websocket at `/kernels/<kernel-id>/channels` instead of separate
+  `/kernels/<kernel-id>/{shell|iopub|stdin}` channels. Messages on each channel are identified by a
+  `channel` key in the message dict, for both send and recv.
+
+
+Content Security Policy
+```````````````````````
+
+The Content Security Policy is a web standard for adding a layer of security to
+detect and mitigate certain classes of attacks, including Cross Site Scripting
+(XSS) and data injection attacks. This was introduced into the notebook to
+ensure that the IPython Notebook and its APIs (by default) can only be embedded
+in an iframe on the same origin.
+
+Override ``headers['Content-Security-Policy']`` within your notebook
+configuration to extend for alternate domains and security settings.::
+
+    c.NotebookApp.tornado_settings = {
+        'headers': {
+            'Content-Security-Policy': "frame-ancestors 'self'"
+        }
+    }
+
+Example policies::
+
+    Content-Security-Policy: default-src 'self' https://*.jupyter.org
+
+Matches embeddings on any subdomain of jupyter.org, so long as they are served
+over SSL.
+
+There is a `report-uri <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/report-uri>`_ endpoint available for logging CSP violations, located at
+``/api/security/csp-report``. To use it, set ``report-uri`` as part of the CSP::
+
+    c.NotebookApp.tornado_settings = {
+        'headers': {
+            'Content-Security-Policy': "frame-ancestors 'self'; report-uri /api/security/csp-report"
+        }
+    }
+
+It simply provides the CSP report as a warning in IPython's logs. The default
+CSP sets this report-uri relative to the ``base_url`` (not shown above).
+
+For a more thorough and accurate guide on Content Security Policies, check out
+`MDN's Using Content Security Policy <https://developer.mozilla.org/en-US/docs/Web/Security/CSP/Using_Content_Security_Policy>`_ for more examples.
diff --git a/docs/source/whatsnew/version3_widget_migration.rst b/docs/source/whatsnew/version3_widget_migration.rst
new file mode 100644
index 00000000000..1daeb7e91b5
--- /dev/null
+++ b/docs/source/whatsnew/version3_widget_migration.rst
@@ -0,0 +1,322 @@
+Migrating Widgets to IPython 3
+==============================
+
+Upgrading Notebooks
+-------------------
+
+1. The first thing you'll notice when upgrading an IPython 2.0 widget
+   notebook to IPython 3.0 is the "Notebook converted" dialog. Click
+   "ok".
+2. All of the widgets distributed with IPython have been renamed. The
+   "Widget" suffix was removed from the end of the class name. i.e.
+   ``ButtonWidget`` is now ``Button``.
+3. ``ContainerWidget`` was renamed to ``Box``.
+4. ``PopupWidget`` was removed from IPython, because bootstrapjs was 
+   problematic (creates global variables, etc.). If you use the
+   ``PopupWidget``, try using a ``Box`` widget instead. If your notebook
+   can't live without the popup functionality, subclass the ``Box``
+   widget (both in Python and JS) and use JQuery UI's ``draggable()``
+   and ``resizable()`` methods to mimic the behavior.
+5. ``add_class`` and ``remove_class`` were removed. More often than not
+   a new attribute exists on the widget that allows you to achieve the
+   same explicitly. i.e. the ``Button`` widget now has a
+   ``button_style`` attribute which you can set to 'primary', 'success',
+   'info', 'warning', 'danger', or '' instead of using ``add_class`` to
+   add the bootstrap class. ``VBox`` and ``HBox`` classes (flexible
+   ``Box`` subclasses) were added that allow you to avoid using
+   ``add_class`` and ``remove_class`` to make flexible box model
+   layouts. As a last resort, if you can't find a built in attribute for
+   the class you want to use, a new ``_dom_classes`` list trait was
+   added, which combines ``add_class`` and ``remove_class`` into one
+   stateful list.
+6. ``set_css`` and ``get_css`` were removed in favor of explicit style
+   attributes - ``visible``, ``width``, ``height``, ``padding``,
+   ``margin``, ``color``, ``background_color``, ``border_color``,
+   ``border_width``, ``border_radius``, ``border_style``,
+   ``font_style``, ``font_weight``, ``font_size``, and ``font_family``
+   are a few. If you can't find a trait to see the css attribute you
+   need, you can, in order of preference, (A) subclass to create your
+   own custom widget, (B) use CSS and the ``_dom_classes`` trait to set
+   ``_dom_classes``, or (C) use the ``_css`` dictionary to set CSS
+   styling like ``set_css`` and ``get_css``.
+7. For selection widgets, such as ``Dropdown``, the ``values`` argument
+   has been renamed to ``options``.
+
+Upgrading Custom Widgets
+------------------------
+
+Javascript
+~~~~~~~~~~
+
+1. If you are distributing your widget and decide to use the deferred
+   loading technique (preferred), you can remove all references to the
+   WidgetManager and the register model/view calls (see the Python
+   section below for more information).
+2. In 2.0 require.js was used incorrectly, that has been fixed and now
+   loading works more like Python's import. Requiring
+   ``widgets/js/widget`` doesn't import the ``WidgetManager`` class,
+   instead it imports a dictionary that exposes the classes within that
+   module:
+
+   .. code:: javascript
+
+       {
+       'WidgetModel': WidgetModel,
+       'WidgetView': WidgetView,
+       'DOMWidgetView': DOMWidgetView,
+       'ViewList': ViewList,
+       }
+
+   If you decide to continue to use the widget registry (by registering
+   your widgets with the manager), you can import a dictionary with a
+   handle to the WidgetManager class by requiring
+   ``widgets/js/manager``. Doing so will import:
+
+   .. code:: javascript
+
+       {'WidgetManager': WidgetManager}
+
+3. Don't rely on the ``IPython`` namespace for anything. To inherit from
+   the DOMWidgetView, WidgetView, or WidgetModel, require
+   ``widgets/js/widget`` as ``widget``. If you were inheriting from
+   DOMWidgetView, and the code looked like this:
+
+   .. code:: javascript
+
+       IPython.DOMWidgetView.extend({...})
+
+   It would become this:
+
+   .. code:: javascript
+
+       widget.DOMWidgetView.extend({...})
+
+4. Custom models are encouraged. When possible, it's recommended to move
+   your code into a custom model, so actions are performed 1 time,
+   instead of N times where N is the number of displayed views.
+
+Python
+~~~~~~
+
+Generally, custom widget Python code can remain unchanged. If you
+distribute your custom widget, you may be using ``display`` and
+``Javascript`` to publish the widget's Javascript to the front-end. That
+is no longer the recommended way of distributing widget Javascript.
+Instead have the user install the Javascript to his/her nbextension
+directory or their profile's static directory. Then use the new
+``_view_module`` and ``_model_module`` traitlets in combination with
+``_view_name`` and ``_model_name`` to instruct require.js on how to load
+the widget's Javascript. The Javascript is then loaded when the widget
+is used for the first time.
+
+Details
+-------
+
+Asynchronous
+~~~~~~~~~~~~
+
+In the IPython 2.x series the only way to register custom widget views
+and models was to use the registry in the widget manager. Unfortunately,
+using this method made distributing and running custom widgets difficult. The widget
+maintainer had to either use the rich display framework to push the
+widget's Javascript to the notebook or instruct the users to install the
+Javascript by hand in a custom profile. With the first method, the
+maintainer would have to be careful about when the Javascript was pushed
+to the front-end. If the Javascript was pushed on Python widget
+``import``, the widgets wouldn't work after page refresh. This is
+because refreshing the page does not restart the kernel, and the Python
+``import`` statement only runs once in a given kernel instance (unless
+you reload the Python modules, which isn't straight forward). This meant
+the maintainer would have to have a separate ``push_js()`` method that
+the user would have to call after importing the widget's Python code.
+
+Our solution was to add support for loading widget views and models
+using require.js paths. Thus the comm and widget frameworks now support
+lazy loading. To do so, everything had to be converted to asynchronous
+code. HTML5 promises are used to accomplish that
+(`#6818 <https://github.com/ipython/ipython/pull/6818>`__,
+`#6914 <https://github.com/ipython/ipython/pull/6914>`__).
+
+Symmetry
+~~~~~~~~
+
+In IPython 3.0, widgets can be instantiated from the front-end
+(`#6664 <https://github.com/ipython/ipython/pull/6664>`__). On top of
+this, a widget persistence API was added
+(`#7163 <https://github.com/ipython/ipython/pull/7163>`__,
+`#7227 <https://github.com/ipython/ipython/pull/7227>`__). With the
+widget persistence API, you can persist your widget instances using
+Javascript. This makes it easy to persist your widgets to your notebook
+document (with a small amount of custom JS). By default, the widgets are
+persisted to your web browsers local storage which makes them reappear
+when your refresh the page.
+
+Smaller Changes
+~~~~~~~~~~~~~~~
+
+-  Latex math is supported in widget ``description``\ s
+   (`#5937 <https://github.com/ipython/ipython/pull/5937>`__).
+-  Widgets can be display more than once within a single container
+   widget (`#5963 <https://github.com/ipython/ipython/pull/5963>`__,
+   `#6990 <https://github.com/ipython/ipython/pull/6990>`__).
+-  ``FloatRangeSlider`` and ``IntRangeSlider`` were added
+   (`#6050 <https://github.com/ipython/ipython/pull/6050>`__).
+-  "Widget" was removed from the ends of all of the widget class names
+   (`#6125 <https://github.com/ipython/ipython/pull/6125>`__).
+-  ``ContainerWidget`` was renamed to ``Box``
+   (`#6125 <https://github.com/ipython/ipython/pull/6125>`__).
+-  ``HBox`` and ``VBox`` widgets were added
+   (`#6125 <https://github.com/ipython/ipython/pull/6125>`__).
+-  ``add\_class`` and ``remove\_class`` were removed in favor of a
+   ``_dom_classes`` list
+   (`#6235 <https://github.com/ipython/ipython/pull/6235>`__).
+-  ``get\_css`` and ``set\_css`` were removed in favor of explicit
+   traits for widget styling
+   (`#6235 <https://github.com/ipython/ipython/pull/6235>`__).
+-  ``jslink`` and ``jsdlink`` were added
+   (`#6454 <https://github.com/ipython/ipython/pull/6454>`__,
+   `#7468 <https://github.com/ipython/ipython/pull/7468>`__).
+-  An ``Output`` widget was added, which allows you to ``print`` and
+   ``display`` within widgets
+   (`#6670 <https://github.com/ipython/ipython/pull/6670>`__).
+-  ``PopupWidget`` was removed
+   (`#7341 <https://github.com/ipython/ipython/pull/7341>`__).
+-  A visual cue was added for widgets with 'dead' comms
+   (`#7227 <https://github.com/ipython/ipython/pull/7227>`__).
+-  A ``SelectMultiple`` widget was added (a ``Select`` widget that
+   allows multiple things to be selected at once)
+   (`#6890 <https://github.com/ipython/ipython/pull/6890>`__).
+-  A class was added to help manage children views
+   (`#6990 <https://github.com/ipython/ipython/pull/6990>`__).
+-  A warning was added that shows on widget import because it's expected
+   that the API will change again by IPython 4.0. This warning can be
+   suppressed (`#7107 <https://github.com/ipython/ipython/pull/7107>`__,
+   `#7200 <https://github.com/ipython/ipython/pull/7200>`__,
+   `#7201 <https://github.com/ipython/ipython/pull/7201>`__,
+   `#7204 <https://github.com/ipython/ipython/pull/7204>`__).
+
+Comm and Widget PR Index
+------------------------
+
+Here is a chronological list of PRs affecting the widget and comm frameworks for IPython 3.0. Note that later PRs may revert changes
+made in earlier PRs:
+
+- Add placeholder attribute to text widgets
+  `#5652 <https://github.com/ipython/ipython/pull/5652>`__
+- Add latex support in widget labels,
+  `#5937 <https://github.com/ipython/ipython/pull/5937>`__
+- Allow widgets to display more than once within container widgets.
+  `#5963 <https://github.com/ipython/ipython/pull/5963>`__
+- use require.js,
+  `#5980 <https://github.com/ipython/ipython/pull/5980>`__
+- Range widgets
+  `#6050 <https://github.com/ipython/ipython/pull/6050>`__
+- Interact on\_demand option
+  `#6051 <https://github.com/ipython/ipython/pull/6051>`__
+- Allow text input on slider widgets
+  `#6106 <https://github.com/ipython/ipython/pull/6106>`__
+- support binary buffers in comm messages
+  `#6110 <https://github.com/ipython/ipython/pull/6110>`__
+- Embrace the flexible box model in the widgets
+  `#6125 <https://github.com/ipython/ipython/pull/6125>`__
+- Widget trait serialization
+  `#6128 <https://github.com/ipython/ipython/pull/6128>`__
+- Make Container widgets take children as the first positional
+  argument `#6153 <https://github.com/ipython/ipython/pull/6153>`__
+- once-displayed
+  `#6168 <https://github.com/ipython/ipython/pull/6168>`__
+- Validate slider value, when limits change
+  `#6171 <https://github.com/ipython/ipython/pull/6171>`__
+- Unregistering comms in Comm Manager
+  `#6216 <https://github.com/ipython/ipython/pull/6216>`__
+- Add EventfulList and EventfulDict trait types.
+  `#6228 <https://github.com/ipython/ipython/pull/6228>`__
+- Remove add/remove\_class and set/get\_css.
+  `#6235 <https://github.com/ipython/ipython/pull/6235>`__
+- avoid unregistering widget model twice
+  `#6250 <https://github.com/ipython/ipython/pull/6250>`__
+- Widget property lock should compare json states, not python states
+  `#6332 <https://github.com/ipython/ipython/pull/6332>`__
+- Strip the IPY\_MODEL\_ prefix from widget IDs before referencing
+  them. `#6377 <https://github.com/ipython/ipython/pull/6377>`__
+- "event" is not defined error in Firefox
+  `#6437 <https://github.com/ipython/ipython/pull/6437>`__
+- Javascript link
+  `#6454 <https://github.com/ipython/ipython/pull/6454>`__
+- Bulk update of widget attributes
+  `#6463 <https://github.com/ipython/ipython/pull/6463>`__
+- Creating a widget registry on the Python side.
+  `#6493 <https://github.com/ipython/ipython/pull/6493>`__
+- Allow widget views to be loaded from require modules
+  `#6494 <https://github.com/ipython/ipython/pull/6494>`__
+- Fix Issue #6530
+  `#6532 <https://github.com/ipython/ipython/pull/6532>`__
+- Make comm manager (mostly) independent of InteractiveShell
+  `#6540 <https://github.com/ipython/ipython/pull/6540>`__
+- Add semantic classes to top-level containers for single widgets
+  `#6609 <https://github.com/ipython/ipython/pull/6609>`__
+- Selection Widgets: forcing 'value' to be in 'values'
+  `#6617 <https://github.com/ipython/ipython/pull/6617>`__
+- Allow widgets to be constructed from Javascript
+  `#6664 <https://github.com/ipython/ipython/pull/6664>`__
+- Output widget
+  `#6670 <https://github.com/ipython/ipython/pull/6670>`__
+- Minor change in widgets.less to fix alignment issue
+  `#6681 <https://github.com/ipython/ipython/pull/6681>`__
+- Make Selection widgets respect values order.
+  `#6747 <https://github.com/ipython/ipython/pull/6747>`__
+- Widget persistence API
+  `#6789 <https://github.com/ipython/ipython/pull/6789>`__
+- Add promises to the widget framework.
+  `#6818 <https://github.com/ipython/ipython/pull/6818>`__
+- SelectMultiple widget
+  `#6890 <https://github.com/ipython/ipython/pull/6890>`__
+- Tooltip on toggle button
+  `#6923 <https://github.com/ipython/ipython/pull/6923>`__
+- Allow empty text box \*while typing\* for numeric widgets
+  `#6943 <https://github.com/ipython/ipython/pull/6943>`__
+- Ignore failure of widget MathJax typesetting
+  `#6948 <https://github.com/ipython/ipython/pull/6948>`__
+- Refactor the do\_diff and manual child view lists into a separate
+  ViewList object
+  `#6990 <https://github.com/ipython/ipython/pull/6990>`__
+- Add warning to widget namespace import.
+  `#7107 <https://github.com/ipython/ipython/pull/7107>`__
+- lazy load widgets
+  `#7120 <https://github.com/ipython/ipython/pull/7120>`__
+- Fix padding of widgets.
+  `#7139 <https://github.com/ipython/ipython/pull/7139>`__
+- Persist widgets across page refresh
+  `#7163 <https://github.com/ipython/ipython/pull/7163>`__
+- Make the widget experimental error a real python warning
+  `#7200 <https://github.com/ipython/ipython/pull/7200>`__
+- Make the widget error message shorter and more understandable.
+  `#7201 <https://github.com/ipython/ipython/pull/7201>`__
+- Make the widget warning brief and easy to filter
+  `#7204 <https://github.com/ipython/ipython/pull/7204>`__
+- Add visual cue for widgets with dead comms
+  `#7227 <https://github.com/ipython/ipython/pull/7227>`__
+- Widget values as positional arguments
+  `#7260 <https://github.com/ipython/ipython/pull/7260>`__
+- Remove the popup widget
+  `#7341 <https://github.com/ipython/ipython/pull/7341>`__
+- document and validate link, dlink
+  `#7468 <https://github.com/ipython/ipython/pull/7468>`__
+- Document interact 5637
+  `#7525 <https://github.com/ipython/ipython/pull/7525>`__
+- Update some broken examples of using widgets
+  `#7547 <https://github.com/ipython/ipython/pull/7547>`__
+- Use Output widget with Interact
+  `#7554 <https://github.com/ipython/ipython/pull/7554>`__
+- don't send empty execute\_result messages
+  `#7560 <https://github.com/ipython/ipython/pull/7560>`__
+- Validation on the python side
+  `#7602 <https://github.com/ipython/ipython/pull/7602>`__
+- only show prompt overlay if there's a prompt
+  `#7661 <https://github.com/ipython/ipython/pull/7661>`__
+- Allow predictate to be used for comparison in selection widgets
+  `#7674 <https://github.com/ipython/ipython/pull/7674>`__
+- Fix widget view persistence.
+  `#7680 <https://github.com/ipython/ipython/pull/7680>`__
+- Revert "Use Output widget with Interact"
+  `#7703 <https://github.com/ipython/ipython/pull/7703>`__
diff --git a/docs/source/whatsnew/version4.rst b/docs/source/whatsnew/version4.rst
new file mode 100644
index 00000000000..6150a8668cd
--- /dev/null
+++ b/docs/source/whatsnew/version4.rst
@@ -0,0 +1,84 @@
+============
+ 4.x Series
+============
+
+IPython 4.2
+===========
+
+IPython 4.2 (April, 2016) includes various bugfixes and improvements over 4.1.
+
+- Fix ``ipython -i`` on errors, which was broken in 4.1.
+- The delay meant to highlight deprecated commands that have moved to jupyter has been removed.
+- Improve compatibility with future versions of traitlets and matplotlib.
+- Use stdlib :func:`python:shutil.get_terminal_size` to measure terminal width when displaying tracebacks
+  (provided by ``backports.shutil_get_terminal_size`` on Python 2).
+
+You can see the rest `on GitHub <https://github.com/ipython/ipython/issues?q=milestone%3A4.2>`__.
+
+
+IPython 4.1
+===========
+
+IPython 4.1.2 (March, 2016) fixes installation issues with some versions of setuptools.
+
+Released February, 2016. IPython 4.1 contains mostly bug fixes,
+though there are a few improvements.
+
+
+- IPython debugger (IPdb) now supports the number of context lines for the
+  ``where`` (and ``w``) commands. The `context` keyword is also available in
+  various APIs. See PR :ghpull:`9097`
+- YouTube video will now show thumbnail when exported to a media that do not
+  support video. (:ghpull:`9086`)
+- Add warning when running `ipython <subcommand>` when subcommand is
+  deprecated. `jupyter` should now be used.
+- Code in `%pinfo` (also known as `??`) are now highlighter (:ghpull:`8947`)
+- `%aimport` now support module completion. (:ghpull:`8884`)
+- `ipdb` output is now colored ! (:ghpull:`8842`)
+- Add ability to transpose columns for completion: (:ghpull:`8748`)
+
+Many many docs improvements and bug fixes, you can see the
+`list of changes <https://github.com/ipython/ipython/compare/4.0.0...4.1.0>`_
+
+IPython 4.0
+===========
+
+Released August, 2015
+
+IPython 4.0 is the first major release after the Big Split.
+IPython no longer contains the notebook, qtconsole, etc. which have moved to
+`jupyter <https://jupyter.readthedocs.io>`_.
+IPython subprojects, such as `IPython.parallel <https://ipyparallel.readthedocs.io>`_ and `widgets <https://ipywidgets.readthedocs.io>`_ have moved to their own repos as well.
+
+The following subpackages are deprecated:
+
+- IPython.kernel (now jupyter_client and ipykernel)
+- IPython.consoleapp (now jupyter_client.consoleapp)
+- IPython.nbformat (now nbformat)
+- IPython.nbconvert (now nbconvert)
+- IPython.html (now notebook)
+- IPython.parallel (now ipyparallel)
+- IPython.utils.traitlets (now traitlets)
+- IPython.config (now traitlets.config)
+- IPython.qt (now qtconsole)
+- IPython.terminal.console (now jupyter_console)
+
+and a few other utilities.
+
+Shims for the deprecated subpackages have been added,
+so existing code should continue to work with a warning about the new home.
+
+There are few changes to the code beyond the reorganization and some bugfixes.
+
+IPython highlights:
+
+- Public APIs for discovering IPython paths is moved from :mod:`IPython.utils.path` to :mod:`IPython.paths`.
+  The old function locations continue to work with deprecation warnings.
+- Code raising ``DeprecationWarning``
+  entered by the user in an interactive session will now display the warning by
+  default. See :ghpull:`8480` an :ghissue:`8478`.
+- The `--deep-reload` flag and the corresponding options to inject `dreload` or
+  `reload` into the interactive namespace have been deprecated, and will be
+  removed in future versions. You should now explicitly import `reload` from
+  `IPython.lib.deepreload` to use it.
+
diff --git a/docs/source/whatsnew/version5.rst b/docs/source/whatsnew/version5.rst
new file mode 100644
index 00000000000..1c238179161
--- /dev/null
+++ b/docs/source/whatsnew/version5.rst
@@ -0,0 +1,445 @@
+============
+ 5.x Series
+============
+
+.. _whatsnew580:
+
+IPython 5.8.0
+=============
+
+* Update inspecting function/methods for future-proofing. :ghpull:`11139`
+
+.. _whatsnew570:
+
+IPython 5.7
+===========
+
+* Fix IPython trying to import non-existing matplotlib backends :ghpull:`11087`
+* fix for display hook not publishing object metadata :ghpull:`11101`
+
+.. _whatsnew560:
+
+IPython 5.6
+===========
+
+* In Python 3.6 and above, dictionaries preserve the order items were added to
+  them. On these versions, IPython will display dictionaries in their native
+  order, rather than sorting by the keys (:ghpull:`10958`).
+* :class:`~.IPython.display.ProgressBar` can now be used as an iterator
+  (:ghpull:`10813`).
+* The shell object gains a :meth:`~.InteractiveShell.check_complete` method,
+  to allow a smoother transition to new input processing machinery planned for
+  IPython 7 (:ghpull:`11044`).
+* IPython should start faster, as it no longer looks for all available pygments
+  styles on startup (:ghpull:`10859`).
+
+You can see all the PR marked for the `5.6. milestone <https://github.com/ipython/ipython/pulls?utf8=%E2%9C%93&q=is%3Apr+milestone%3A5.6+is%3Aclosed+NOT+%22Backport+PR%22+>`_,
+and all the `backport versions <https://github.com/ipython/ipython/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.6%20is%3Aclosed%20%22Backport%20PR%22%20>`__.
+
+.. _whatsnew550:
+
+IPython 5.5
+===========
+
+System Wide config
+------------------
+
+- IPython now looks for config files in ``{sys.prefix}/etc/ipython``
+  for environment-specific configuration.
+- Startup files can be found in ``/etc/ipython/startup`` or ``{sys.prefix}/etc/ipython/startup``
+  in addition to the profile directory, for system-wide or env-specific startup files.
+
+See :ghpull:`10644`
+
+ProgressBar
+-----------
+
+
+IPython now has built-in support for progressbars::
+
+    In[1]: from IPython.display import ProgressBar
+    ...  : pb = ProgressBar(100)
+    ...  : pb
+
+    In[2]: pb.progress = 50
+
+    # progress bar in cell 1 updates.
+
+See :ghpull:`10755`
+
+
+Misc
+----
+
+ - Fix ``IPython.core.display:Pretty._repr_pretty_`` had the wrong signature.
+   (:ghpull:`10625`)
+ - :magic:`timeit` now give a correct ``SyntaxError`` if naked ``return`` used.
+   (:ghpull:`10637`)
+ - Prepare the ``:ipython:`` directive to be compatible with Sphinx 1.7.
+   (:ghpull:`10668`)
+ - Make IPython work with OpenSSL in FIPS mode; change hash algorithm of input
+   from md5 to sha1. (:ghpull:`10696`)
+ - Clear breakpoints before running any script with debugger. (:ghpull:`10699`)
+ - Document that :magic:`profile` is deprecated, not to be confused with :magic:`prun`. (:ghpull:`10707`)
+ - Limit default number of returned completions to 500. (:ghpull:`10743`)
+
+You can see all the PR marked for the `5.5. milestone <https://github.com/ipython/ipython/pulls?q=is%3Apr%20milestone%3A5.5%20is%3Aclosed%20NOT%20%22Backport%20PR%22>`_,
+and all the `backport versions <https://github.com/ipython/ipython/pulls?utf8=%E2%9C%93&q=is%3Apr%20milestone%3A5.5%20is%3Aclosed%20%22Backport%20PR%22%20>`_.
+
+IPython 5.4.1
+=============
+Released a few hours after 5.4, fix a crash when
+``backports.shutil-get-terminal-size`` is not installed. :ghissue:`10629`
+
+.. _whatsnew540:
+
+IPython 5.4
+===========
+
+IPython 5.4-LTS is the first release of IPython after the release of the 6.x
+series which is Python 3 only. It backports most of the new exposed API
+additions made in IPython 6.0 and 6.1 and avoid having to write conditional
+logics depending of the version of IPython.
+
+Please upgrade to pip 9 or greater before upgrading IPython. 
+Failing to do so on Python 2 may lead to a broken IPython install.
+
+Configurable TerminalInteractiveShell
+-------------------------------------
+
+Backported from the 6.x branch as an exceptional new feature. See
+:ghpull:`10373` and :ghissue:`10364`
+
+IPython gained a new ``c.TerminalIPythonApp.interactive_shell_class`` option
+that allow to customize the class used to start the terminal frontend. This
+should allow user to use custom interfaces, like reviving the former readline
+interface which is now a separate package not maintained by the core team.
+
+Define ``_repr_mimebundle_``
+----------------------------
+
+Object can now define `_repr_mimebundle_` in place of multiple `_repr_*_`
+methods and return a full mimebundle. This greatly simplify many implementation
+and allow to publish custom mimetypes (like geojson, plotly, dataframes....).
+See the ``Custom Display Logic`` example notebook for more information.
+
+Execution Heuristics
+--------------------
+
+The heuristic for execution in the command line interface is now more biased
+toward executing for single statement. While in IPython 4.x and before a single
+line would be executed when enter is pressed, IPython 5.x would insert a new
+line. For single line statement this is not true anymore and if a single line is
+valid Python, IPython will execute it regardless of the cursor position. Use
+:kbd:`Ctrl-O` to insert a new line. :ghpull:`10489`
+
+
+Implement Display IDs
+---------------------
+
+Implement display id and ability to update a given display. This should greatly
+simplify a lot of code by removing the need for widgets and allow other frontend
+to implement things like progress-bars.  See :ghpull:`10048`
+
+Display function
+----------------
+
+The :func:`display() <IPython.display.display>` function is now available by
+default in an IPython session, meaning users can call it on any object to see
+their rich representation. This should allow for better interactivity both at
+the REPL and in notebook environment.
+
+Scripts and library that rely on display and may be run outside of IPython still
+need to import the display function using ``from IPython.display import
+display``. See :ghpull:`10596`
+
+
+Miscs
+-----
+
+* ``_mp_main_`` is not reloaded which fixes issues with multiprocessing.
+  :ghpull:`10523`
+* Use user colorscheme in Pdb as well :ghpull:`10479`
+* Faster shutdown. :ghpull:`10408` 
+* Fix a crash in reverse search. :ghpull:`10371`
+* added ``Completer.backslash_combining_completions`` boolean option to
+  deactivate backslash-tab completion that may conflict with windows path. 
+
+IPython 5.3
+===========
+
+Released on February 24th, 2017. Remarkable changes and fixes:
+
+* Fix a bug in ``set_next_input`` leading to a crash of terminal IPython.
+  :ghpull:`10231`, :ghissue:`10296`, :ghissue:`10229`
+* Always wait for editor inputhook for terminal IPython :ghpull:`10239`,
+  :ghpull:`10240`
+* Disable ``_ipython_display_`` in terminal :ghpull:`10249`, :ghpull:`10274`
+* Update terminal colors to be more visible by default on windows
+  :ghpull:`10260`, :ghpull:`10238`, :ghissue:`10281`
+* Add Ctrl-Z shortcut (suspend) in terminal debugger :ghpull:`10254`,
+  :ghissue:`10273`
+* Indent on new line by looking at the text before the cursor :ghpull:`10264`,
+  :ghpull:`10275`, :ghissue:`9283`
+* Update QtEventloop integration to fix some matplotlib integration issues
+  :ghpull:`10201`, :ghpull:`10311`, :ghissue:`10201`
+* Respect completions display style in terminal debugger :ghpull:`10305`,
+  :ghpull:`10313`
+* Add a config option ``TerminalInteractiveShell.extra_open_editor_shortcuts``
+  to enable extra shortcuts to open the input in an editor. These are :kbd:`v`
+  in vi mode, and :kbd:`C-X C-E` in emacs mode (:ghpull:`10330`).
+  The :kbd:`F2` shortcut is always enabled.
+
+IPython 5.2.2
+=============
+
+* Fix error when starting with ``IPCompleter.limit_to__all__`` configured.
+
+IPython 5.2.1
+=============
+
+* Fix tab completion in the debugger. :ghpull:`10223`
+
+IPython 5.2
+===========
+
+Released on January 29th, 2017. Remarkable changes and fixes:
+
+* restore IPython's debugger to raise on quit. :ghpull:`10009`
+* The configuration value ``c.TerminalInteractiveShell.highlighting_style`` can
+  now directly take a class argument for custom color style. :ghpull:`9848`
+* Correctly handle matplotlib figures dpi :ghpull:`9868`
+* Deprecate ``-e`` flag for the ``%notebook`` magic that had no effects.
+  :ghpull:`9872`
+* You can now press F2 while typing at a terminal prompt to edit the contents
+  in your favourite terminal editor. Set the :envvar:`EDITOR` environment
+  variable to pick which editor is used. :ghpull:`9929`
+* sdists will now only be ``.tar.gz`` as per upstream PyPI requirements.
+  :ghpull:`9925`
+* :any:`IPython.core.debugger` have gained a ``set_trace()`` method for
+  convenience. :ghpull:`9947`
+* The 'smart command mode' added to the debugger in 5.0 was removed, as more
+  people preferred the previous behaviour. Therefore, debugger commands such as
+  ``c`` will act as debugger commands even when ``c`` is defined as a variable.
+  :ghpull:`10050`
+* Fixes OS X event loop issues at startup, :ghpull:`10150`
+* Deprecate the ``%autoindent`` magic. :ghpull:`10176`
+* Emit a :py:exc:`DeprecationWarning` when setting the deprecated
+  ``limit_to_all`` option of the completer. :ghpull:`10198`
+* The :cellmagic:`capture` magic can now capture the result of a cell (from an
+  expression on the last line), as well as printed and displayed output.
+  :ghpull:`9851`.
+
+
+Changes of behavior to :any:`InteractiveShellEmbed`.
+
+:any:`InteractiveShellEmbed` interactive behavior have changed a bit in between
+5.1 and 5.2. By default ``%kill_embedded`` magic will prevent further invocation
+of the current ``call location`` instead of preventing further invocation of
+the current instance creation location. For most use case this will not change
+much for you, though previous behavior was confusing and less consistent with
+previous IPython versions.
+
+You can now deactivate instances by using ``%kill_embedded --instance`` flag,
+(or ``-i`` in short). The ``%kill_embedded`` magic also gained a
+``--yes``/``-y`` option which skip confirmation step, and  ``-x``/``--exit``
+which also exit the current embedded call without asking for confirmation.
+
+See :ghpull:`10207`.
+
+
+
+IPython 5.1
+===========
+
+* Broken ``%timeit`` on Python2 due to the use of ``__qualname__``. :ghpull:`9804`
+* Restore ``%gui qt`` to create and return a ``QApplication`` if necessary. :ghpull:`9789`
+* Don't set terminal title by default. :ghpull:`9801`
+* Preserve indentation when inserting newlines with ``Ctrl-O``. :ghpull:`9770`
+* Restore completion in debugger. :ghpull:`9785`
+* Deprecate ``IPython.core.debugger.Tracer()`` in favor of simpler, newer, APIs. :ghpull:`9731`
+* Restore ``NoOpContext`` context manager removed by mistake, and add `DeprecationWarning`. :ghpull:`9765`
+* Add option allowing ``Prompt_toolkit`` to use 24bits colors. :ghpull:`9736`
+* Fix for closing interactive matplotlib windows on OS X. :ghpull:`9854`
+* An embedded interactive shell instance can be used more than once. :ghpull:`9843`
+* More robust check for whether IPython is in a terminal. :ghpull:`9833`
+* Better pretty-printing of dicts on PyPy. :ghpull:`9827`
+* Some coloured output now looks better on dark background command prompts in Windows.
+  :ghpull:`9838`
+* Improved tab completion of paths on Windows . :ghpull:`9826`
+* Fix tkinter event loop integration on Python 2 with ``future`` installed. :ghpull:`9824`
+* Restore ``Ctrl-\`` as a shortcut to quit IPython.
+* Make ``get_ipython()`` accessible when modules are imported by startup files. :ghpull:`9818`
+* Add support for running directories containing a ``__main__.py`` file with the
+  ``ipython`` command. :ghpull:`9813`
+
+
+True Color feature
+------------------
+
+``prompt_toolkit`` uses pygments styles for syntax highlighting. By default, the
+colors specified in the style are approximated using a standard 256-color
+palette. ``prompt_toolkit`` also supports 24bit, a.k.a. "true", a.k.a. 16-million
+color escape sequences which enable compatible terminals to display the exact
+colors specified instead of an approximation. This true_color option exposes
+that capability in prompt_toolkit to the IPython shell.
+
+Here is a good source for the current state of true color support in various
+terminal emulators and software projects: https://gist.github.com/XVilka/8346728
+
+
+
+IPython 5.0
+===========
+
+Released July 7, 2016
+
+New terminal interface
+----------------------
+
+IPython 5 features a major upgrade to the terminal interface, bringing live
+syntax highlighting as you type, proper multiline editing and multiline paste,
+and tab completions that don't clutter up your history.
+
+.. image:: ../_images/ptshell_features.png
+    :alt: New terminal interface features
+    :align: center
+    :target: ../_images/ptshell_features.png
+
+These features are provided by the Python library `prompt_toolkit
+<https://python-prompt-toolkit.readthedocs.io/en/stable/>`__, which replaces
+``readline`` throughout our terminal interface.
+
+Relying on this pure-Python, cross platform module also makes it simpler to
+install IPython. We have removed dependencies on ``pyreadline`` for Windows and
+``gnureadline`` for Mac.
+
+Backwards incompatible changes
+------------------------------
+
+- The ``%install_ext`` magic function, deprecated since 4.0, has now been deleted.
+  You can distribute and install extensions as packages on PyPI.
+- Callbacks registered while an event is being handled will now only be called
+  for subsequent events; previously they could be called for the current event.
+  Similarly, callbacks removed while handling an event *will* always get that
+  event. See :ghissue:`9447` and :ghpull:`9453`.
+- Integration with pydb has been removed since pydb development has been stopped
+  since 2012, and pydb is not installable from PyPI.
+- The ``autoedit_syntax`` option has apparently been broken for many years.
+  It has been removed.
+
+New terminal interface
+~~~~~~~~~~~~~~~~~~~~~~
+
+The overhaul of the terminal interface will probably cause a range of minor
+issues for existing users.
+This is inevitable for such a significant change, and we've done our best to
+minimise these issues.
+Some changes that we're aware of, with suggestions on how to handle them:
+
+IPython no longer uses readline configuration (``~/.inputrc``). We hope that
+the functionality you want (e.g. vi input mode) will be available by configuring
+IPython directly (see :doc:`/config/options/terminal`).
+If something's missing, please file an issue.
+
+The ``PromptManager`` class has been removed, and the prompt machinery simplified.
+See :ref:`custom_prompts` to customise prompts with the new machinery.
+
+:mod:`IPython.core.debugger` now provides a plainer interface.
+:mod:`IPython.terminal.debugger` contains the terminal debugger using
+prompt_toolkit.
+
+There are new options to configure the colours used in syntax highlighting.
+We have tried to integrate them with our classic  ``--colors`` option and
+``%colors`` magic, but there's a mismatch in possibilities, so some configurations
+may produce unexpected results. See :ref:`termcolour` for more information.
+
+The new interface is not compatible with Emacs 'inferior-shell' feature. To
+continue using this, add the ``--simple-prompt`` flag to the command Emacs
+runs. This flag disables most IPython features, relying on Emacs to provide
+things like tab completion.
+
+Provisional Changes
+-------------------
+
+Provisional changes are experimental functionality that may, or may not, make
+it into a future version of IPython, and which API may change without warnings.
+Activating these features and using these API are at your own risk, and may have
+security implication for your system, especially if used with the Jupyter notebook,
+
+When running via the Jupyter notebook interfaces, or other compatible client,
+you can enable rich documentation experimental functionality:
+
+When the ``docrepr`` package is installed setting the boolean flag
+``InteractiveShell.sphinxify_docstring`` to ``True``, will process the various
+object through sphinx before displaying them (see the ``docrepr`` package
+documentation for more information.
+
+You need to also enable the IPython pager display rich HTML representation
+using the ``InteractiveShell.enable_html_pager`` boolean configuration option.
+As usual you can set these configuration options globally in your configuration
+files, alternatively you can turn them on dynamically using the following
+snippet:
+
+.. code-block:: python
+
+    ip = get_ipython()
+    ip.sphinxify_docstring = True
+    ip.enable_html_pager = True
+
+
+You can test the effect of various combinations of the above configuration in
+the Jupyter notebook, with things example like :
+
+.. code-block:: ipython
+
+    import numpy as np
+    np.histogram?
+
+
+This is part of an effort to make Documentation in Python richer and provide in
+the long term if possible dynamic examples that can contain math, images,
+widgets... As stated above this is nightly experimental feature with a lot of
+(fun) problem to solve. We would be happy to get your feedback and expertise on
+it.
+
+
+
+Deprecated Features
+-------------------
+
+Some deprecated features are listed in this section. Don't forget to enable
+``DeprecationWarning`` as an error if you are using IPython in a Continuous
+Integration setup or in your testing in general:
+
+.. code-block:: python
+
+    import warnings
+    warnings.filterwarnings('error', '.*', DeprecationWarning, module='yourmodule.*')
+
+
+- ``hooks.fix_error_editor`` seems unused and is pending deprecation.
+- `IPython/core/excolors.py:ExceptionColors` is  deprecated.
+- `IPython.core.InteractiveShell:write()` is deprecated; use `sys.stdout` instead.
+- `IPython.core.InteractiveShell:write_err()` is deprecated; use `sys.stderr` instead.
+- The `formatter` keyword argument to `Inspector.info` in `IPython.core.oinspec` has no effect.
+- The `global_ns` keyword argument of IPython Embed was deprecated, and has no effect. Use `module` keyword argument instead.
+
+
+Known Issues:
+-------------
+
+- ``<Esc>`` Key does not dismiss the completer and does not clear the current
+  buffer. This is an on purpose modification due to current technical
+  limitation. Cf :ghpull:`9572`. Escape the control character which is used
+  for other shortcut, and there is no practical way to distinguish. Use Ctr-G
+  or Ctrl-C as an alternative.
+
+- Cannot use ``Shift-Enter`` and ``Ctrl-Enter`` to submit code in terminal. cf
+  :ghissue:`9587` and :ghissue:`9401`. In terminal there is no practical way to
+  distinguish these key sequences from a normal new line return.
+
+- ``PageUp`` and ``pageDown`` do not move through completion menu.
+
+- Color styles might not adapt to terminal emulator themes. This will need new
+  version of Pygments to be released, and can be mitigated with custom themes.
diff --git a/docs/source/whatsnew/version6.rst b/docs/source/whatsnew/version6.rst
new file mode 100644
index 00000000000..7a82af4b76a
--- /dev/null
+++ b/docs/source/whatsnew/version6.rst
@@ -0,0 +1,364 @@
+============
+ 6.x Series
+============
+
+.. _whatsnew650:
+
+IPython 6.5.0
+=============
+
+Miscellaneous bug fixes and compatibility with Python 3.7.
+
+* Autocompletion fix for modules with out ``__init__.py`` :ghpull:`11227`
+* update the ``%pastebin`` magic to use ``dpaste.com`` instead og GitHub Gist
+  which now requires authentication :ghpull:`11182`
+* Fix crash with multiprocessing :ghpull:`11185`
+
+.. _whatsnew640:
+
+IPython 6.4.0
+=============
+
+Everything new in :ref:`IPython 5.7 <whatsnew570>`
+
+* Fix display object not emitting metadata :ghpull:`11106`
+* Comments failing Jedi test :ghpull:`11110` 
+
+
+.. _whatsnew631:
+
+IPython 6.3.1
+=============
+
+This is a bugfix release to switch the default completions back to IPython's
+own completion machinery. We discovered some problems with the completions
+from Jedi, including completing column names on pandas data frames.
+
+You can switch the completions source with the config option
+:configtrait:`Completer.use_jedi`.
+
+.. _whatsnew630:
+
+IPython 6.3
+===========
+
+IPython 6.3 contains all the bug fixes and features in
+:ref:`IPython 5.6 <whatsnew560>`. In addition:
+
+* A new display class :class:`IPython.display.Code` can be used to display
+  syntax highlighted code in a notebook (:ghpull:`10978`).
+* The :cellmagic:`html` magic now takes a ``--isolated`` option to put the
+  content in an iframe (:ghpull:`10962`).
+* The code to find completions using the Jedi library has had various
+  adjustments. This is still a work in progress, but we hope this version has
+  fewer annoyances (:ghpull:`10956`, :ghpull:`10969`, :ghpull:`10999`,
+  :ghpull:`11035`, :ghpull:`11063`, :ghpull:`11065`).
+* The *post* event callbacks are now always called, even when the execution failed
+  (for example because of a ``SyntaxError``).
+* The execution info and result objects are now made available in the
+  corresponding *pre* or *post* ``*_run_cell`` :doc:`event callbacks </config/callbacks>`
+  in a backward compatible manner (:ghissue:`10774` and :ghpull:`10795`).
+* Performance with very long code cells (hundreds of lines) is greatly improved
+  (:ghpull:`10898`). Further improvements are planned for IPython 7.
+
+You can see all `pull requests for the 6.3 milestone
+<https://github.com/ipython/ipython/pulls?utf8=%E2%9C%93&q=is%3Apr+milestone%3A6.3+is%3Aclosed>`__.
+
+.. _whatsnew620:
+
+IPython 6.2
+===========
+
+IPython 6.2 contains all the bugs fixes and features :ref:`available in IPython 5.5 <whatsnew550>`,
+like built in progress bar support, and system-wide configuration
+
+The following features are specific to IPython 6.2:
+
+Function signature in completions
+---------------------------------
+
+Terminal IPython will now show the signature of the function while completing.
+Only the currently highlighted function will show its signature on the line
+below the completer by default. This functionality is recent, so it might be
+limited; we welcome bug reports and requests for enhancements. :ghpull:`10507`
+
+Assignments return values
+-------------------------
+
+IPython can now trigger the display hook on the last assignment of cells.
+Up until 6.2 the following code wouldn't show the value of the assigned
+variable::
+
+    In[1]: xyz = "something"
+    # nothing shown
+
+You would have to actually make it the last statement::
+
+    In [2]: xyz = "something else"
+    ...   : xyz
+    Out[2]: "something else"
+
+With the option ``InteractiveShell.ast_node_interactivity='last_expr_or_assign'``
+you can now do::
+
+    In [2]: xyz = "something else"
+    Out[2]: "something else"
+
+This option can be toggled at runtime with the ``%config`` magic, and will
+trigger on assignment ``a = 1``, augmented assignment ``+=``, ``-=``, ``|=`` ...
+as well as type annotated assignments: ``a:int = 2``.
+
+See :ghpull:`10598`
+
+Recursive Call of ipdb
+----------------------
+
+Advanced users of the debugger can now correctly recursively enter ipdb. This is
+thanks to ``@segevfiner`` on :ghpull:`10721`.
+
+.. _whatsnew610:
+
+IPython 6.1
+===========
+
+- Quotes in a filename are always escaped during tab-completion on non-Windows.
+  :ghpull:`10069`
+
+- Variables now shadow magics in autocompletion. See :ghissue:`4877` and :ghpull:`10542`.
+
+- Added the ability to add parameters to alias_magic. For example::
+
+    In [2]: %alias_magic hist history --params "-l 2" --line
+    Created `%hist` as an alias for `%history -l 2`.
+
+    In [3]: hist
+    %alias_magic hist history --params "-l 30" --line
+    %alias_magic hist history --params "-l 2" --line
+
+  Previously it was only possible to have an alias attached to a single function,
+  and you would have to pass in the given parameters every time::
+
+    In [4]: %alias_magic hist history --line
+    Created `%hist` as an alias for `%history`.
+
+    In [5]: hist -l 2
+    hist
+    %alias_magic hist history --line
+
+- To suppress log state messages, you can now either use ``%logstart -q``, pass
+  ``--LoggingMagics.quiet=True`` on the command line, or set
+  ``c.LoggingMagics.quiet=True`` in your configuration file.
+
+- An additional flag ``--TerminalInteractiveShell.term_title_format`` is
+  introduced to allow the user to control the format of the terminal title.  It
+  is specified as a python format string, and currently the only variable it
+  will format is ``{cwd}``.
+
+- ``??``/``%pinfo2`` will now show object docstrings if the source can't be retrieved. :ghpull:`10532`
+- ``IPython.display`` has gained a ``%markdown`` cell magic. :ghpull:`10563`
+- ``%config`` options can now be tab completed. :ghpull:`10555`
+- ``%config`` with no arguments are now unique and sorted. :ghpull:`10548`
+- Completion on keyword arguments does not duplicate ``=`` sign if already present. :ghpull:`10547`
+- ``%run -m <module>`` now ``<module>`` passes extra arguments to ``<module>``. :ghpull:`10546`
+- completer now understand "snake case auto complete": if ``foo_bar_kittens`` is
+  a valid completion, I can type ``f_b<tab>`` will complete to it. :ghpull:`10537`
+- tracebacks are better standardized and will compress `/path/to/home` to `~`. :ghpull:`10515`
+
+The following changes were also added to IPython 5.4, see :ref:`what's new in IPython 5.4 <whatsnew540>`
+for more detail description:
+
+- ``TerminalInteractiveShell`` is configurable and can be configured to
+  (re)-use the readline interface.
+
+- objects can now define a ``_repr_mimebundle_``
+
+- Execution heuristics improve for single line statements
+- ``display()`` can now return a display id to update display areas.
+
+
+.. _whatsnew600:
+
+IPython 6.0
+===========
+
+Released April 19th, 2017
+
+IPython 6 features 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 for a non-exhaustive list of new features.
+
+Make sure you have pip > 9.0 before upgrading.
+You should be able to update by using:
+
+.. code::
+
+    pip install ipython --upgrade
+
+
+.. note::
+
+    If your pip version is greater than or equal to pip 9.0.1 you will automatically get
+    the most recent version of IPython compatible with your system: on Python 2 you 
+    will get the latest IPython 5.x bugfix, while in Python 3
+    you will get the latest 6.x stable version.
+
+New completion API and Interface
+--------------------------------
+
+The completer Completion API has seen an overhaul, and the new completer has
+plenty of improvements both from the end users of terminal IPython and for
+consumers of the API.
+
+This new API is capable of pulling completions from :mod:`jedi`, thus allowing
+type inference on non-executed code. If :mod:`jedi` is installed, completions like
+the following are now possible without code evaluation:
+
+    >>> data = ['Number of users', 123_456]
+    ... data[0].<tab>
+
+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 bug-fixes and more completions
+are already available on the development version of :mod:`jedi` if you are curious.
+
+With the help of prompt toolkit, types of completions can be shown in the
+completer interface:
+
+.. image:: ../_images/jedi_type_inference_60.png
+    :alt: Jedi showing ability to do type inference
+    :align: center
+    :width: 400px
+    :target: ../_images/jedi_type_inference_60.png
+
+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 fixes a number of bugs
+like case-insensitive completion and completion after division operator: See
+:ghpull:`10182`.
+
+Extra patches and updates will be needed to the :mod:`ipykernel` package for
+this feature to be available to other clients like Jupyter Notebook, Lab,
+Nteract, Hydrogen...
+
+The use of Jedi should be barely noticeable on recent machines, but 
+can be slower on older ones.  To tweak the performance, 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 the near future. Feedback on
+the current state of the API and suggestions are 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 has led to upstream patches in pip,
+pypi and warehouse to make sure Python 2 systems still upgrade to the latest
+compatible Python version.
+
+We remind our Python 2 users that IPython 5 is still compatible with Python 2.7,
+still maintained and will get regular releases. Using pip 9+, upgrading IPython will
+automatically upgrade to the latest version compatible with your system.
+
+.. warning::
+
+  If you are on a system using an older version of pip on Python 2, pip may
+  still install IPython 6.0 on your system, and IPython will refuse to start.
+  You can fix this by upgrading pip, and reinstalling ipython, or forcing pip to
+  install an earlier version: ``pip install 'ipython<6'``
+
+The ability to use only Python 3 on the code base of IPython brings a number
+of advantages. Most of the newly written code make use of `optional function type
+annotation <https://peps.python.org/pep-0484/>`_ 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 of the Python2/Python3 shim layer has made the code quite a lot clearer and
+more idiomatic in a number of locations, and much friendlier to work with and
+understand. We hope to further embrace Python 3 capabilities in the next release
+cycle and introduce more of the Python 3 only idioms (yield from, kwarg only,
+general unpacking) in the IPython code base, and see if we can take advantage
+of these 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
+<https://github.com/ipython/rlipython>`_.
+
+This change will be backported to the IPython 5.x series.
+
+Misc improvements
+-----------------
+
+
+- The :cellmagic:`capture` magic can now capture the result of a cell (from
+  an expression on the last line), as well as printed and displayed output.
+  :ghpull:`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 :ghissue:`10232` and :ghpull:`10316`
+
+- IPython.display has gained a :any:`GeoJSON <IPython.display.GeoJSON>` object.
+  :ghpull:`10288` and :ghpull:`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 :mod:`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.
+  :ghpull:`10104`
+
+Backward incompatible changes
+------------------------------
+
+Functions Removed in 6.x Development cycle
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The following functions have been removed in the
+development cycle marked for Milestone 6.0.
+
+- ``IPython/utils/process.py`` - ``is_cmd_found``
+- ``IPython/utils/process.py`` - ``pycmd2argv``
+
+- The `--deep-reload` flag and the corresponding options to inject `dreload` or
+  `reload` into the interactive namespace have been removed. You have to
+  explicitly import `reload` from `IPython.lib.deepreload` to use it.
+
+- The :magic:`profile` used to print the current IPython profile, and which
+  was deprecated in IPython 2.0 does now raise a `DeprecationWarning` error when
+  used. It is often confused with the :magic:`prun` and the deprecation removal
+  should free up the ``profile`` name in future versions.
diff --git a/docs/source/whatsnew/version7.rst b/docs/source/whatsnew/version7.rst
new file mode 100644
index 00000000000..4f031d28709
--- /dev/null
+++ b/docs/source/whatsnew/version7.rst
@@ -0,0 +1,1798 @@
+============
+ 7.x Series
+============
+
+.. _version 7.34:
+
+IPython 7.34
+============
+
+This version contains a single fix:  fix uncaught BdbQuit exceptions on ipdb
+exit :ghpull:`13668`
+
+
+.. _version 7.33:
+
+IPython 7.33
+============
+
+ - Allow IPython hooks to receive current cell ids when frontend support it. See
+   :ghpull:`13600`
+
+ - ``?`` does not trigger the insertion of a new cell anymore as most frontend
+   allow proper multiline edition. :ghpull:`13625`
+
+
+.. _version 7.32:
+
+IPython 7.32
+============
+
+
+
+Autoload magic lazily
+---------------------
+
+The ability to configure magics to be lazily loaded has been added to IPython.
+See the ``ipython --help-all`` section on ``MagicsManager.lazy_magic``.
+One can now use::
+
+    c.MagicsManager.lazy_magics = {
+              "my_magic": "slow.to.import",
+              "my_other_magic": "also.slow",
+    }
+
+And on first use of ``%my_magic``, or corresponding cell magic, or other line magic,
+the corresponding ``load_ext`` will be called just before trying to invoke the magic.
+
+Misc
+----
+
+ - Update sphinxify  for Docrepr 0.2.0  :ghpull:`13503`.
+ - Set co_name for cells run line by line (to fix debugging with Python 3.10)
+   :ghpull:`13535`
+
+
+Many thanks to all the contributors to this release. You can find all individual
+contributions to this milestone `on github
+<https://github.com/ipython/ipython/milestone/99>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 7.31:
+
+IPython 7.31
+============
+
+IPython 7.31 brings a couple of backports and fixes from the 8.0 branches,
+it is likely one of the last releases of the 7.x series, as 8.0 will probably be released
+between this release and what would have been 7.32.
+
+Please test 8.0 beta/rc releases in addition to this release.
+
+This Releases:
+ - Backport some fixes for Python 3.10 (:ghpull:`13412`)
+ - use full-alpha transparency on dvipng rendered LaTeX (:ghpull:`13372`)
+
+Many thanks to all the contributors to this release. You can find all individual
+contributions to this milestone `on github
+<https://github.com/ipython/ipython/milestone/95>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 7.30:
+
+IPython 7.30
+============
+
+IPython 7.30 fixes a couple of bugs introduce in previous releases (in
+particular with respect to path handling), and introduce a few features and
+improvements:
+
+Notably we will highlight :ghpull:`13267` "Document that ``%run`` can execute
+notebooks and ipy scripts.", which is the first commit of Fernando Pérez since
+mid 2016 (IPython 5.1). If you are new to IPython, Fernando created IPython in
+2001. The other most recent contribution of Fernando to IPython itself was
+May 2018, by reviewing and merging PRs. I want to note that Fernando is still
+active but mostly as a mentor and leader of the whole Jupyter organisation, but
+we're still happy to see him contribute code !
+
+:ghpull:`13290` "Use sphinxify (if available) in object_inspect_mime path"
+should allow richer Repr of docstrings when using jupyterlab inspector.
+
+:ghpull:`13311` make the debugger use ``ThreadPoolExecutor`` for debugger cmdloop.
+This should fix some issues/infinite loop, but let us know if you come across
+any regressions. In particular this fixes issues with `kmaork/madbg <https://github.com/kmaork/madbg>`_,
+a remote debugger for IPython.
+
+Note that this is likely the ante-penultimate release of IPython 7.x as a stable
+branch, as I hope to release IPython 8.0 as well as IPython 7.31 next
+month/early 2022.
+
+IPython 8.0 will drop support for Python 3.7, removed nose as a dependency, and
+7.x will only get critical bug fixes with 8.x becoming the new stable. This will
+not be possible without `NumFOCUS Small Development Grants
+<https://numfocus.org/programs/small-development-grants>`_ Which allowed us to
+hire `Nikita Kniazev <https://github.com/Kojoley>`_ who provide Python and C++
+help and contracting work.
+
+
+Many thanks to all the contributors to this release. You can find all individual
+contributions to this milestone `on github
+<https://github.com/ipython/ipython/milestone/94?closed=1>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 7.29:
+
+IPython 7.29
+============
+
+
+IPython 7.29 brings a couple of new functionalities to IPython and a number of bugfixes.
+It is one of the largest recent release, relatively speaking, with close to 15 Pull Requests.
+
+
+ - fix an issue where base64 was returned instead of bytes when showing figures :ghpull:`13162`
+ - fix compatibility with PyQt6, PySide 6 :ghpull:`13172`. This may be of
+   interest if you are running on Apple Silicon as only qt6.2+ is natively
+   compatible.
+ - fix matplotlib qtagg eventloop :ghpull:`13179`
+ - Multiple docs fixes, typos, ... etc.
+ - Debugger will now exit by default on SigInt :ghpull:`13218`, this will be
+   useful in notebook/lab if you forgot to exit the debugger. "Interrupt Kernel"
+   will now exist the debugger.
+
+It give Pdb the ability to skip code in decorators. If functions contain a
+special value names ``__debuggerskip__ = True|False``, the function will not be
+stepped into, and Pdb will step into lower frames only if the value is set to
+``False``. The exact behavior is still likely to have corner cases and will be
+refined in subsequent releases. Feedback welcome. See the debugger module
+documentation for more info. Thanks to the `D. E. Shaw
+group <https://deshaw.com/>`__ for funding this feature.
+
+The main branch of IPython is receiving a number of changes as we received a
+`NumFOCUS SDG <https://numfocus.org/programs/small-development-grants>`__
+($4800), to help us finish replacing ``nose`` by ``pytest``, and make IPython
+future proof with an 8.0 release.
+
+
+Many thanks to all the contributors to this release. You can find all individual
+contributions to this milestone `on github
+<https://github.com/ipython/ipython/milestone/93>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 7.28:
+
+IPython 7.28
+============
+
+
+IPython 7.28 is again a minor release that mostly bring bugfixes, and couple of
+improvement. Many thanks to MrMino, who again did all the work this month, and
+made a number of documentation improvements.
+
+Here is a non-exhaustive list of changes,
+
+Fixes:
+
+ - async with doesn't allow newlines :ghpull:`13090`
+ - Dynamically changing to vi mode via %config magic) :ghpull:`13091`
+
+Virtualenv handling fixes:
+
+ - init_virtualenv now uses Pathlib :ghpull:`12548`
+ - Fix Improper path comparison of virtualenv directories :ghpull:`13140`
+ - Fix virtual environment user warning for lower case paths :ghpull:`13094`
+ - Adapt to all sorts of drive names for cygwin :ghpull:`13153`
+
+New Features:
+
+ - enable autoplay in embed YouTube player :ghpull:`13133`
+
+ Documentation:
+
+ - Fix formatting for the core.interactiveshell documentation :ghpull:`13118`
+ - Fix broken ipyparallel's refs :ghpull:`13138`
+ - Improve formatting of %time documentation :ghpull:`13125`
+ - Reword the YouTubeVideo autoplay WN :ghpull:`13147`
+
+
+Highlighted features
+--------------------
+
+
+``YouTubeVideo`` autoplay and the ability to add extra attributes to ``IFrame``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can add any extra attributes to the ``<iframe>`` tag using the new
+``extras`` argument in the ``IFrame`` class. For example::
+
+    In [1]: from IPython.display import IFrame
+
+    In [2]: IFrame(src="src", width=300, height=300, extras=['loading="eager"'])
+
+The above cells will result in the following HTML code being displayed in a
+notebook::
+
+    <iframe
+        width="300"
+        height="300"
+        src="src"
+        frameborder="0"
+        allowfullscreen
+        loading="eager"
+    ></iframe>
+
+Related to the above, the ``YouTubeVideo`` class now takes an
+``allow_autoplay`` flag, which sets up the iframe of the embedded YouTube video
+such that it allows autoplay.
+
+.. note::
+    Whether this works depends on the autoplay policy of the browser rendering
+    the HTML allowing it. It also could get blocked by some browser extensions.
+
+Try it out!
+
+::
+
+    In [1]: from IPython.display import YouTubeVideo
+
+    In [2]: YouTubeVideo("dQw4w9WgXcQ", allow_autoplay=True)
+
+
+
+Thanks
+------
+
+Many thanks to all the contributors to this release. You can find all individual
+contributions to this milestone `on github
+<https://github.com/ipython/ipython/milestone/92>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 7.27:
+
+IPython 7.27
+============
+
+IPython 7.27 is a minor release that fixes a couple of issues and compatibility.
+
+- Add support for GTK4 :ghpull:`131011`
+- Add support for Qt6 :ghpull:`13085`
+- Fix an issue with pip magic on windows :ghpull:`13093`
+
+Thanks
+------
+
+Many thanks to all the contributors to this release. You can find all individual
+contributions to this milestone `on github
+<https://github.com/ipython/ipython/milestone/91>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 7.26:
+
+IPython 7.26
+============
+
+IPython 7.26 is a minor release that fixes a couple of issues, updates in API
+and Copyright/Licenses issues around various part of the codebase.
+
+We'll highlight `this issue <https://github.com/ipython/ipython/issues/13039>`
+pointing out we were including and refereeing to code from Stack Overflow which
+was CC-BY-SA, hence incompatible with the BSD license of IPython. This lead us
+to a rewriting of the corresponding logic which in our case was done in a more
+efficient way (in our case we were searching string prefixes instead of full
+strings).
+
+You will notice also a number of documentation improvements and cleanup.
+
+Of particular interest are the following Pull-requests:
+
+
+ - The IPython directive now uses Sphinx logging for warnings. :ghpull:`13030`.
+ - Add expiry days option to pastebin magic and change http protocol to https.
+   :ghpull:`13056`
+ - Make Ipython.utils.timing work with jupyterlite :ghpull:`13050`.
+
+Pastebin magic expiry days option
+---------------------------------
+
+The Pastebin magic now has ``-e`` option to determine 
+the number of days for paste expiration. For example
+the paste that created with ``%pastebin -e 20 1`` magic will
+be available for next 20 days.
+
+
+
+
+
+Thanks
+------
+
+Many thanks to all the contributors to this release and in particular MrMino who
+is doing most of the work those days. You can find all individual contributions
+to this milestone `on github <https://github.com/ipython/ipython/milestone/90>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 7.25:
+
+IPython 7.25
+============
+
+IPython 7.25 is a minor release that contains a single bugfix, which is highly
+recommended for all users of ipdb, ipython debugger %debug magic and similar.
+
+Issuing commands like ``where`` from within the debugger would reset the
+local variables changes made by the user. It is interesting to look at the root
+cause of the issue as accessing an attribute (``frame.f_locals``) would trigger
+this side effects.
+
+Thanks in particular to the patience from the reporters at D.E. Shaw for their
+initial bug report that was due to a similar coding oversight in an extension,
+and who took time to debug and narrow down the problem.
+
+Thanks
+------
+
+Many thanks to all the contributors to this release you can find all individual
+contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/89>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 7.24:
+
+IPython 7.24
+============
+
+Third release of IPython for 2021, mostly containing bug fixes. A couple of not
+typical updates:
+
+Misc
+----
+
+
+ - Fix an issue where ``%recall`` would both succeeded and print an error message
+   it failed. :ghpull:`12952`
+ - Drop support for NumPy 1.16 – practically has no effect beyond indicating in
+   package metadata that we do not support it. :ghpull:`12937`
+
+Debugger improvements
+---------------------
+
+The debugger (and ``%debug`` magic) have been improved and can skip or hide frames
+originating from files that are not writable to the user, as these are less
+likely to be the source of errors, or be part of system files this can be a useful
+addition when debugging long errors.
+
+In addition to the global ``skip_hidden True|False`` command, the debugger has
+gained finer grained control of predicates as to whether to a frame should be
+considered hidden. So far 3 predicates are available :
+
+  - ``tbhide``: frames containing the local variable ``__tracebackhide__`` set to
+    True.
+  - ``readonly``: frames originating from readonly files, set to False.
+  - ``ipython_internal``: frames that are likely to be from IPython internal
+    code, set to True.
+
+You can toggle individual predicates during a session with
+
+.. code-block::
+
+   ipdb> skip_predicates readonly True
+
+Read-only files will now be considered hidden frames.
+
+
+You can call ``skip_predicates`` without arguments to see the states of current
+predicates:
+
+.. code-block::
+
+    ipdb> skip_predicates
+    current predicates:
+        tbhide : True
+        readonly : False
+        ipython_internal : True
+
+If all predicates are set to ``False``,  ``skip_hidden`` will practically have
+no effect. We attempt to warn you when all predicates are False.
+
+Note that the ``readonly`` predicate may increase disk access as we check for
+file access permission for all frames on many command invocation, but is usually
+cached by operating systems. Let us know if you encounter any issues.
+
+As the IPython debugger does not use the traitlets infrastructure for
+configuration, by editing your ``.pdbrc`` files and appending commands you would
+like to be executed just before entering the interactive prompt. For example:
+
+
+.. code::
+
+    # file : ~/.pdbrc
+    skip_predicates readonly True
+    skip_predicates tbhide False
+
+Will hide read only frames by default and show frames marked with
+``__tracebackhide__``.
+
+
+
+
+Thanks
+------
+
+Many thanks to all the contributors to this release you can find all individual
+contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/87>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries, in particular above mentioned
+improvements to the debugger.
+
+
+
+
+.. _version 7.23:
+
+IPython 7.23 and 7.23.1
+=======================
+
+
+Third release of IPython for 2021, mostly containing bug fixes. A couple of not
+typical updates:
+
+ - We moved to GitHub actions away from Travis-CI, the transition may not be
+   100% complete (not testing on nightly anymore), but as we ran out of
+   Travis-Ci hours on the IPython organisation that was a necessary step.
+   :ghpull:`12900`.
+
+ - We have a new dependency: ``matplotlib-inline``, which try to extract
+   matplotlib inline backend specific behavior. It is available on PyPI and
+   conda-forge thus should not be a problem to upgrade to this version. If you
+   are a package maintainer that might be an extra dependency to package first.
+   :ghpull:`12817` (IPython 7.23.1 fix a typo that made this change fail)
+
+In the addition/new feature category, ``display()`` now have a ``clear=True``
+option to clear the display if any further outputs arrives, allowing users to
+avoid having to use ``clear_output()`` directly. :ghpull:`12823`.
+
+In bug fixes category, this release fix an issue when printing tracebacks
+containing Unicode characters :ghpull:`12758`.
+
+In code cleanup category :ghpull:`12932` remove usage of some deprecated
+functionality for compatibility with Python 3.10.
+
+
+
+Thanks
+------
+
+Many thanks to all the contributors to this release you can find all individual
+contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/86>`__.
+In particular MrMino for responding to almost all new issues, and triaging many
+of the old ones, as well as takluyver, minrk, willingc for reacting quikly when
+we ran out of CI Hours.
+
+Thanks as well to organisations, QuantStack (martinRenou and SylvainCorlay) for
+extracting matplotlib inline backend into its own package, and the `D. E. Shaw group
+<https://deshaw.com/>`__ for sponsoring work on IPython and related libraries.
+
+
+.. _version 7.22:
+
+IPython 7.22
+============
+
+Second release of IPython for 2021, mostly containing bug fixes. Here is a quick
+rundown of the few changes.
+
+- Fix some ``sys.excepthook`` shenanigan when embedding with qt, recommended if
+  you – for example – use `napari <https://napari.org>`__. :ghpull:`12842`.
+- Fix bug when using the new ipdb ``%context`` magic :ghpull:`12844`
+- Couples of deprecation cleanup :ghpull:`12868`
+- Update for new dpast.com api if you use the ``%pastbin`` magic. :ghpull:`12712`
+- Remove support for numpy before 1.16. :ghpull:`12836`
+
+
+Thanks
+------
+
+We have a new team member that you should see more often on the IPython
+repository, Błażej Michalik (@MrMino) have been doing regular contributions to
+IPython, and spent time replying to many issues and guiding new users to the
+codebase; they now have triage permissions to the IPython repository and we'll
+work toward giving them more permission in the future.
+
+Many thanks to all the contributors to this release you can find all individual
+contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/84>`__.
+
+Thanks as well to organisations, QuantStack for working on debugger
+compatibility for Xeus_python, and the `D. E. Shaw group
+<https://deshaw.com/>`__ for sponsoring work on IPython and related libraries.
+
+.. _version 721:
+
+IPython 7.21
+============
+
+IPython 7.21 is the first release we have back on schedule of one release every
+month; it contains a number of minor fixes and improvements, notably, the new
+context command for ipdb
+
+
+New "context" command in ipdb
+-----------------------------
+
+It is now possible to change the number of lines shown in the backtrace
+information in ipdb using "context" command. :ghpull:`12826`
+
+(thanks @MrMino, there are other improvement from them on master).
+
+Other notable changes in IPython 7.21
+-------------------------------------
+
+- Fix some issues on new osx-arm64 :ghpull:`12804`, :ghpull:`12807`. 
+- Compatibility with Xeus-Python for debugger protocol, :ghpull:`12809`
+- Misc docs fixes for compatibility and uniformity with Numpydoc.
+  :ghpull:`12824`
+
+
+Thanks
+------
+
+Many thanks to all the contributors to this release you can find all individual
+contribution to this milestone `on github <https://github.com/ipython/ipython/milestone/83>`__.
+
+
+.. _version 720:
+
+IPython 7.20
+============
+
+IPython 7.20 is the accumulation of 3 month of work on IPython, spacing between
+IPython release have been increased from the usual once a month for various
+reason.
+
+   - Mainly as I'm too busy and the effectively sole maintainer, and
+   - Second because not much changes happened before mid December.
+
+The main driver for this release was the new version of Jedi 0.18 breaking API;
+which was taken care of in the master branch early in 2020 but not in 7.x as I
+though that by now 8.0 would be out.
+
+The inclusion of a resolver in pip did not help and actually made things worse.
+If usually I would have simply pinned Jedi to ``<0.18``; this is not a solution
+anymore as now pip is free to install Jedi 0.18, and downgrade IPython.
+
+I'll do my best to keep the regular release, but as the 8.0-dev branch and 7.x
+are starting to diverge this is becoming difficult in particular with my limited
+time, so if you have any cycles to spare I'll appreciate your help to respond to
+issues and pushing 8.0 forward.
+
+Here are thus some of the changes for IPython 7.20.
+
+  - Support for PyQt5 >= 5.11 :ghpull:`12715`
+  - ``%reset`` remove imports more aggressively :ghpull:`12718`
+  - fix the ``%conda`` magic :ghpull:`12739`
+  - compatibility with Jedi 0.18, and bump minimum Jedi version. :ghpull:`12793`
+
+
+.. _version 719:
+
+IPython 7.19
+============
+
+IPython 7.19 accumulative two month of works, bug fixes and improvements, there
+was exceptionally no release last month.
+
+  - Fix to restore the ability to specify more than one extension using command
+    line flags when using traitlets 5.0 :ghpull:`12543`
+  - Docs docs formatting that make the install commands work on zsh
+    :ghpull:`12587`
+  - Always display the last frame in tracebacks even if hidden with
+    ``__tracebackhide__`` :ghpull:`12601`
+  - Avoid an issue where a callback can be registered multiple times.
+    :ghpull:`12625`
+  - Avoid an issue in debugger mode where frames changes could be lost.
+    :ghpull:`12627`
+
+  - Never hide the frames that invoke a debugger, even if marked as hidden by
+    ``__tracebackhide__`` :ghpull:`12631`
+  - Fix calling the debugger in a recursive manner :ghpull:`12659`
+
+
+A number of code changes have landed on master and we are getting close to
+enough new features and codebase improvement that a 8.0 start to make sens.
+For downstream packages, please start working on migrating downstream testing
+away from iptest and using pytest, as nose will not work on Python 3.10 and we
+will likely start removing it as a dependency for testing.
+
+.. _version 718:
+
+IPython 7.18
+============
+
+IPython 7.18 is a minor release that mostly contains bugfixes.
+
+ - ``CRLF`` is now handled by magics my default; solving some issues due to copy
+   pasting on windows. :ghpull:`12475`
+
+ - Requiring pexpect ``>=4.3`` as we are Python 3.7+ only and earlier version of
+   pexpect will be incompatible. :ghpull:`12510`
+
+ - Minimum jedi version is now 0.16. :ghpull:`12488`
+
+
+
+.. _version 717:
+
+IPython 7.17
+============
+
+IPython 7.17 brings a couple of new improvements to API and a couple of user
+facing changes to make the terminal experience more user friendly.
+
+:ghpull:`12407` introduces the ability to pass extra argument to the IPython
+debugger class; this is to help a new project from ``kmaork``
+(https://github.com/kmaork/madbg) to feature a fully remote debugger.
+
+:ghpull:`12410` finally remove support for 3.6, while the codebase is still
+technically compatible; IPython will not install on Python 3.6.
+
+lots of work on the debugger and hidden frames from ``@impact27`` in
+:ghpull:`12437`, :ghpull:`12445`, :ghpull:`12460` and in particular
+:ghpull:`12453` which make the debug magic more robust at handling spaces.
+
+Biggest API addition is code transformation which is done before code execution;
+IPython allows a number of hooks to catch non-valid Python syntax (magic, prompt
+stripping...etc). Transformers are usually called many time; typically:
+
+ - When trying to figure out whether the code is complete and valid (should we
+   insert a new line or execute ?)
+ - During actual code execution pass before giving the code to Python's
+   ``exec``.
+
+This lead to issues when transformer might have had side effects; or do external
+queries. Starting with IPython 7.17 you can expect your transformer to be called
+less time.
+
+Input transformers are now called only once in the execution path of
+`InteractiveShell`, allowing to register transformer that potentially have side
+effects (note that this is not recommended). Internal methods `should_run_async`, and
+`run_cell_async` now take a recommended optional `transformed_cell`, and
+`preprocessing_exc_tuple` parameters that will become mandatory at some point in
+the future; that is to say cells need to be explicitly transformed to be valid
+Python syntax ahead of trying to run them. :ghpull:`12440`;
+
+``input_transformers`` can now also have an attribute ``has_side_effects`` set
+to `True`, when this attribute is present; this  will prevent the transformers
+from being ran when IPython is trying to guess whether the user input is
+complete. Note that this may means you will need to explicitly execute in some
+case where your transformations are now not ran; but will not affect users with
+no custom extensions.
+
+
+API Changes
+-----------
+
+Change of API and exposed objects automatically detected using `frappuccino
+<https://pypi.org/project/frappuccino/>`_
+
+
+ The following items are new since 7.16.0::
+
+     + IPython.core.interactiveshell.InteractiveShell.get_local_scope(self, stack_depth)
+
+ The following signatures differ since 7.16.0::
+
+     - IPython.core.interactiveshell.InteractiveShell.run_cell_async(self, raw_cell, store_history=False, silent=False, shell_futures=True)
+     + IPython.core.interactiveshell.InteractiveShell.run_cell_async(self, raw_cell, store_history=False, silent=False, shell_futures=True, *, transformed_cell=None, preprocessing_exc_tuple=None)
+
+     - IPython.core.interactiveshell.InteractiveShell.should_run_async(self, raw_cell)
+     + IPython.core.interactiveshell.InteractiveShell.should_run_async(self, raw_cell, *, transformed_cell=None, preprocessing_exc_tuple=None)
+
+     - IPython.terminal.debugger.TerminalPdb.pt_init(self)
+     + IPython.terminal.debugger.TerminalPdb.pt_init(self, pt_session_options=None)
+
+This method was added::
+
+     + IPython.core.interactiveshell.InteractiveShell.get_local_scope
+
+Which is now also present on subclasses::
+
+     + IPython.terminal.embed.InteractiveShellEmbed.get_local_scope
+     + IPython.terminal.interactiveshell.TerminalInteractiveShell.get_local_scope
+
+
+.. _version 716:
+
+IPython 7.16.1, 7.16.2
+======================
+
+IPython 7.16.1 was release immediately after 7.16.0 to fix a conda packaging issue.
+The source is identical to 7.16.0 but the file permissions in the tar are different.
+
+IPython 7.16.2 pins jedi dependency to "<=0.17.2" which should prevent some
+issues for users still on python 3.6. This may not be sufficient as pip may
+still allow to downgrade IPython.
+
+Compatibility with Jedi > 0.17.2 was not added as this would have meant bumping
+the minimal version to >0.16.
+
+IPython 7.16
+============
+
+
+The default traceback mode will now skip frames that are marked with
+``__tracebackhide__ = True`` and show how many traceback frames have been
+skipped. This can be toggled by using :magic:`xmode` with the ``--show`` or
+``--hide`` attribute. It will have no effect on non verbose traceback modes.
+
+The ipython debugger also now understands ``__tracebackhide__`` as well and will
+skip hidden frames when displaying. Movement up and down the stack will skip the
+hidden frames and will show how many frames were hidden. Internal IPython frames
+are also now hidden by default. The behavior can be changed with the
+``skip_hidden`` while in the debugger, command and accepts "yes", "no", "true"
+and "false" case insensitive parameters.
+
+
+Misc Noticeable changes:
+------------------------
+
+- Exceptions are now (re)raised when running notebooks via the :magic:`%run`, helping to catch issues in workflows and
+  pipelines. :ghpull:`12301`
+- Fix inputhook for qt 5.15.0 :ghpull:`12355`
+- Fix wx inputhook :ghpull:`12375`
+- Add handling for malformed pathext env var (Windows) :ghpull:`12367`
+- use $SHELL in system_piped :ghpull:`12360` for uniform behavior with
+  ipykernel.
+
+Reproducible Build
+------------------
+
+IPython 7.15 reproducible build did not work, so we try again this month
+:ghpull:`12358`.
+
+
+API Changes
+-----------
+
+Change of API and exposed objects automatically detected using `frappuccino
+<https://pypi.org/project/frappuccino/>`_ (still in beta):
+
+
+The following items are new and mostly related to understanding ``__tracebackhide__``::
+
+    + IPython.core.debugger.Pdb.do_down(self, arg)
+    + IPython.core.debugger.Pdb.do_skip_hidden(self, arg)
+    + IPython.core.debugger.Pdb.do_up(self, arg)
+    + IPython.core.debugger.Pdb.hidden_frames(self, stack)
+    + IPython.core.debugger.Pdb.stop_here(self, frame)
+
+
+The following items have been removed::
+
+    - IPython.core.debugger.Pdb.new_do_down
+    - IPython.core.debugger.Pdb.new_do_up
+
+Those were implementation details.
+
+
+.. _version 715:
+
+IPython 7.15
+============
+
+IPython 7.15 brings a number of bug fixes and user facing improvements.
+
+Misc Noticeable changes:
+------------------------
+
+ - Long completion name have better elision in terminal :ghpull:`12284`
+ - I've started to test on Python 3.9 :ghpull:`12307` and fix some errors.
+ - Hi DPI scaling of figures when using qt eventloop :ghpull:`12314`
+ - Document the ability to have systemwide configuration for IPython.
+   :ghpull:`12328`
+ - Fix issues with input autoformatting :ghpull:`12336`
+ - ``IPython.core.debugger.Pdb`` is now interruptible (:ghpull:`12168`, in 7.14
+   but forgotten in release notes)
+ - Video HTML attributes (:ghpull:`12212`, in 7.14 but forgotten in release
+   notes)
+
+Reproducible Build
+------------------
+
+Starting with IPython 7.15, I am attempting to provide reproducible builds,
+that is to say you should be able from the source tree to generate an sdist
+and wheel that are identical byte for byte with the publish version on PyPI.
+
+I've only tested on a couple of machines so far and the process is relatively
+straightforward, so this mean that IPython not only have a deterministic build
+process, but also I have either removed, or put under control all effects of
+the build environments on the final artifact.  I encourage you to attempt the
+build process on your machine as documented in :ref:`core_developer_guide`
+and let me know if you do not obtain an identical artifact.
+
+While reproducible builds is critical to check that the supply chain of (open
+source) software has not been compromised, it can also help to speedup many
+of the build processes in large environment (conda, apt...) by allowing
+better caching of intermediate build steps.
+
+Learn more on `<https://reproducible-builds.org/>`_. `Reflections on trusting
+trust <https://dl.acm.org/doi/10.1145/358198.358210>`_ is also one of the
+cornerstone and recommended reads on this subject.
+
+.. note::
+
+   The build commit from which the sdist is generated is also `signed
+   <https://en.wikipedia.org/wiki/Digital_signature>`_, so you should be able to
+   check it has not been compromised, and the git repository is a `merkle-tree
+   <https://en.wikipedia.org/wiki/Merkle_tree>`_, you can check the consistency
+   with `git-fsck <https://git-scm.com/docs/git-fsck>`_ which you likely `want
+   to enable by default
+   <https://gist.github.com/mbbx6spp/14b86437e794bffb4120>`_.
+
+NEP29: Last version to support Python 3.6
+-----------------------------------------
+
+IPython 7.15 will be the Last IPython version to officially support Python
+3.6, as stated by `NumPy Enhancement Proposal 29
+<https://numpy.org/neps/nep-0029-deprecation_policy.html>`_. Starting with
+next minor version of IPython I may stop testing on Python 3.6 and may stop
+publishing release artifacts that install on Python 3.6
+
+Highlighted features
+--------------------
+
+Highlighted features are not new, but seem to not be widely known, this
+section will help you discover in more narrative form what you can do with
+IPython.
+
+Increase Tab Completion Menu Height
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In terminal IPython it is possible to increase the height of the tab-completion
+menu. To do so set the value of
+:configtrait:`TerminalInteractiveShell.space_for_menu`, this will reserve more
+space at the bottom of the screen for various kind of menus in IPython including
+tab completion and searching in history. 
+
+Autoformat Code in the terminal
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If you have a preferred code formatter, you can configure IPython to
+reformat your code. Set the value of
+:configtrait:`TerminalInteractiveShell.autoformatter` to for example ``'black'``
+and IPython will auto format your code when possible.
+
+
+.. _version 714:
+
+IPython 7.14
+============
+
+IPython  7.14 is a minor release that fix a couple of bugs and prepare
+compatibility with new or future versions of some libraries. 
+
+Important changes:
+------------------
+
+ - Fix compatibility with Sphinx 3+ :ghpull:`12235`
+ - Remove deprecated matplotlib parameter usage, compatibility with matplotlib
+   3.3+ :`122250`
+
+Misc Changes
+------------
+
+ - set ``.py`` extension when editing current buffer in vi/emacs. :ghpull:`12167`
+ - support for unicode identifiers in ``?``/``??`` :ghpull:`12208`
+ - add extra options to the ``Video`` Rich objects :ghpull:`12212`
+ - add pretty-printing to ``SimpleNamespace`` :ghpull:`12230`
+
+IPython.core.debugger.Pdb is now interruptible
+----------------------------------------------
+
+A ``KeyboardInterrupt`` will now interrupt IPython's extended debugger, in order to make Jupyter able to interrupt it. (:ghpull:`12168`)
+
+Video HTML attributes
+---------------------
+
+Add an option to `IPython.display.Video` to change the attributes of the HTML display of the video (:ghpull:`12212`)
+
+
+Pending deprecated imports
+--------------------------
+
+Many object present in ``IPython.core.display`` are there for internal use only,
+and should  already been imported from ``IPython.display`` by users and external
+libraries. Trying to import those from ``IPython.core.display`` is still possible
+but will trigger a
+deprecation warning in later versions of IPython and will become errors in the
+future. 
+
+This will simplify compatibility with other Python kernels (like Xeus-Python),
+and simplify code base. 
+
+
+
+
+.. _version 713:
+
+IPython 7.13
+============
+
+IPython 7.13 is the final release of the 7.x branch since master is diverging
+toward an 8.0. Exiting new features have already been merged in 8.0 and will
+not be available on the 7.x branch. All the changes below have been backported
+from the master branch.
+
+
+ - Fix inability to run PDB when inside an event loop :ghpull:`12141`
+ - Fix ability to interrupt some processes on windows :ghpull:`12137`
+ - Fix debugger shortcuts :ghpull:`12132`
+ - improve tab completion when inside a string by removing irrelevant elements :ghpull:`12128`
+ - Fix display of filename tab completion when the path is long :ghpull:`12122`
+ - Many removal of Python 2 specific code path :ghpull:`12110`
+ - displaying wav files do not require NumPy anymore, and is 5x to 30x faster :ghpull:`12113`
+
+See the list of all closed issues and pull request on `github
+<https://github.com/ipython/ipython/pulls?q=is%3Aclosed+milestone%3A7.13>`_.
+
+.. _version 712:
+
+IPython 7.12
+============
+
+IPython 7.12 is a minor update that mostly brings code cleanup, removal of
+longtime deprecated function and a couple update to documentation cleanup as well.
+
+Notable changes are the following:
+
+ - Exit non-zero when ipython is given a file path to run that doesn't exist :ghpull:`12074`
+ - Test PR on ARM64 with Travis-CI :ghpull:`12073`
+ - Update CI to work with latest Pytest :ghpull:`12086`
+ - Add infrastructure to run ipykernel eventloop via trio :ghpull:`12097`
+ - Support git blame ignore revs :ghpull:`12091`
+ - Start multi-line ``__repr__`` s on their own line :ghpull:`12099`
+
+.. _version 7111:
+
+IPython 7.11.1
+==============
+
+A couple of deprecated functions (no-op) have been reintroduces in py3compat as
+Cython was still relying on them, and will be removed in a couple of versions.
+
+.. _version 711:
+
+IPython 7.11
+============
+
+IPython 7.11 received a couple of compatibility fixes and code cleanup.
+
+A number of function in the ``py3compat`` have been removed; a number of types
+in the IPython code base are now non-ambiguous and now always ``unicode``
+instead of ``Union[Unicode,bytes]``; many of the relevant code path have thus
+been simplified/cleaned and types annotation added.
+
+IPython support several verbosity level from exceptions. ``xmode plain`` now
+support chained exceptions. :ghpull:`11999`
+
+We are starting to remove ``shell=True`` in some usages of subprocess. While not directly
+a security issue (as IPython is made to run arbitrary code anyway) it is not good
+practice and we'd like to show the example. :ghissue:`12023`. This discussion
+was started by ``@mschwager`` thanks to a new auditing tool they are working on
+with duo-labs (`dlint <https://github.com/duo-labs/dlint>`_).
+
+Work around some bugs in Python 3.9 tokenizer :ghpull:`12057`
+
+IPython will now print its version after a crash. :ghpull:`11986`
+
+This is likely the last release from the 7.x series that will see new feature.
+The master branch will soon accept large code changes and thrilling new
+features; the 7.x branch will only start to accept critical bug fixes, and
+update dependencies.
+
+.. _version 7102:
+
+IPython 7.10.2
+==============
+
+IPython 7.10.2 fix a couple of extra incompatibility between IPython, ipdb,
+asyncio and Prompt Toolkit 3.
+
+.. _version 7101:
+
+IPython 7.10.1
+==============
+
+IPython 7.10.1 fix a couple of incompatibilities with Prompt toolkit 3 (please
+update Prompt toolkit to 3.0.2 at least), and fixes some interaction with
+headless IPython.
+
+.. _version 7100:
+
+IPython 7.10.0
+==============
+
+IPython 7.10 is the first double digit minor release in the  last decade, and
+first since the release of IPython 1.0, previous double digit minor release was
+in August 2009.
+
+We've been trying to give you regular release on the last Friday of every month
+for a guaranty of rapid access to bug fixes and new features.
+
+Unlike the previous first few releases that have seen only a couple of code
+changes, 7.10 bring a number of changes, new features and bugfixes.
+
+Stop Support for Python 3.5 – Adopt NEP 29
+------------------------------------------
+
+IPython has decided to follow the informational `NEP 29
+<https://numpy.org/neps/nep-0029-deprecation_policy.html>`_ which layout a clear
+policy as to which version of (C)Python and NumPy are supported.
+
+We thus dropped support for Python 3.5, and cleaned up a number of code path
+that were Python-version dependent. If you are on 3.5 or earlier pip should
+automatically give you the latest compatible version of IPython so you do not
+need to pin to a given version.
+
+Support for Prompt Toolkit 3.0
+------------------------------
+
+Prompt Toolkit 3.0 was release a week before IPython 7.10 and introduces a few
+breaking changes. We believe IPython 7.10 should be compatible with both Prompt
+Toolkit 2.x and 3.x, though it has not been extensively tested with 3.x so
+please report any issues.
+
+
+Prompt Rendering Performance improvements
+-----------------------------------------
+
+Pull Request :ghpull:`11933` introduced an optimisation in the prompt rendering
+logic that should decrease the resource usage of IPython when using the
+_default_ configuration but could potentially introduce a regression of
+functionalities if you are using a custom prompt.
+
+We know assume if you haven't changed the default keybindings that the prompt
+**will not change** during the duration of your input – which is for example
+not true when using vi insert mode that switches between `[ins]` and `[nor]`
+for the current mode.
+
+If you are experiencing any issue let us know.
+
+Code autoformatting
+-------------------
+
+The IPython terminal can now auto format your code just before entering a new
+line or executing a command. To do so use the
+``--TerminalInteractiveShell.autoformatter`` option and set it to ``'black'``;
+if black is installed IPython will use black to format your code when possible.
+
+IPython cannot always properly format your code; in particular it will
+auto formatting with *black* will only work if:
+
+   - Your code does not contains magics or special python syntax.
+
+   - There is no code after your cursor.
+
+The Black API is also still in motion; so this may not work with all versions of
+black.
+
+It should be possible to register custom formatter, though the API is till in
+flux.
+
+Arbitrary Mimetypes Handing in Terminal (Aka inline images in terminal)
+-----------------------------------------------------------------------
+
+When using IPython terminal it is now possible to register function to handle
+arbitrary mimetypes. While rendering non-text based representation was possible in
+many jupyter frontend; it was not possible in terminal IPython, as usually
+terminal are limited to displaying text. As many terminal these days provide
+escape sequences to display non-text; bringing this loved feature to IPython CLI
+made a lot of sens. This functionality will not only allow inline images; but
+allow opening of external program; for example ``mplayer`` to "display" sound
+files.
+
+So far only the hooks necessary for this are in place, but no default mime
+renderers added; so inline images will only be available via extensions. We will
+progressively enable these features by default in the next few releases, and
+contribution is welcomed.
+
+We welcome any feedback on the API. See :ref:`shell_mimerenderer` for more
+information.
+
+This is originally based on work form in :ghpull:`10610` from @stephanh42
+started over two years ago, and still a lot need to be done.
+
+MISC
+----
+
+ - Completions can define their own ordering :ghpull:`11855`
+ - Enable Plotting in the same cell than the one that import matplotlib
+   :ghpull:`11916`
+ - Allow to store and restore multiple variables at once :ghpull:`11930`
+
+You can see `all pull-requests <https://github.com/ipython/ipython/pulls?q=is%3Apr+milestone%3A7.10+is%3Aclosed>`_ for this release.
+
+API Changes
+-----------
+
+Change of API and exposed objects automatically detected using `frappuccino <https://pypi.org/project/frappuccino/>`_ (still in beta):
+
+The following items are new in IPython 7.10::
+
+    + IPython.terminal.shortcuts.reformat_text_before_cursor(buffer, document, shell)
+    + IPython.terminal.interactiveshell.PTK3
+    + IPython.terminal.interactiveshell.black_reformat_handler(text_before_cursor)
+    + IPython.terminal.prompts.RichPromptDisplayHook.write_format_data(self, format_dict, md_dict='None')
+
+The following items have been removed in 7.10::
+
+    - IPython.lib.pretty.DICT_IS_ORDERED
+
+The following signatures differ between versions::
+
+    - IPython.extensions.storemagic.restore_aliases(ip)
+    + IPython.extensions.storemagic.restore_aliases(ip, alias='None')
+
+Special Thanks
+--------------
+
+ - @stephanh42 who started the work on inline images in terminal 2 years ago
+ - @augustogoulart who spent a lot of time triaging issues and responding to
+   users.
+ - @con-f-use who is my (@Carreau) first sponsor on GitHub, as a reminder if you
+   like IPython, Jupyter and many other library of the SciPy stack you can
+   donate to numfocus.org non profit
+
+.. _version 790:
+
+IPython 7.9.0
+=============
+
+IPython 7.9 is a small release with a couple of improvement and bug fixes.
+
+ - Xterm terminal title should be restored on exit :ghpull:`11910`
+ - special variables ``_``,``__``, ``___`` are not set anymore when cache size
+   is 0 or less.  :ghpull:`11877`
+ - Autoreload should have regained some speed by using a new heuristic logic to
+   find all objects needing reload. This should avoid large objects traversal
+   like pandas dataframes. :ghpull:`11876`
+ - Get ready for Python 4. :ghpull:`11874`
+ - `%env` Magic now has heuristic to hide potentially sensitive values :ghpull:`11896`
+
+This is a small release despite a number of Pull Request Pending that need to
+be reviewed/worked on. Many of the core developers have been busy outside of
+IPython/Jupyter and we thanks all contributor for their patience; we'll work on
+these as soon as we have time.
+
+
+.. _version780:
+
+IPython 7.8.0
+=============
+
+IPython 7.8.0 contain a few bugfix and 2 new APIs:
+
+ - Enable changing the font color for LaTeX rendering :ghpull:`11840`
+ - and Re-Expose some PDB API (see below)
+
+Expose Pdb API
+--------------
+
+Expose the built-in ``pdb.Pdb`` API. ``Pdb`` constructor arguments are generically
+exposed, regardless of python version.
+Newly exposed arguments:
+
+- ``skip`` - Python 3.1+
+- ``nosiginnt`` - Python 3.2+
+- ``readrc`` - Python 3.6+
+
+Try it out::
+
+    from IPython.terminal.debugger import TerminalPdb
+    pdb = TerminalPdb(skip=["skipthismodule"])
+
+
+See :ghpull:`11840`
+
+.. _version770:
+
+IPython 7.7.0
+=============
+
+IPython 7.7.0 contain multiple bug fixes and documentation updates; Here are a
+few of the outstanding issue fixed:
+
+   - Fix a bug introduced in 7.6 where the ``%matplotlib`` magic would fail on
+     previously acceptable arguments :ghpull:`11814`.
+   - Fix the manage location on freebsd :ghpull:`11808`.
+   - Fix error message about aliases after ``%reset`` call in ipykernel
+     :ghpull:`11806`
+   - Fix Duplication completions in emacs :ghpull:`11803`
+
+We are planning to adopt `NEP29 <https://github.com/numpy/numpy/pull/14086>`_
+(still currently in draft) which may make this minor version of IPython the
+last one to support Python 3.5 and will make the code base more aggressive
+toward removing compatibility with older versions of Python.
+
+GitHub now support to give only "Triage" permissions to users; if you'd like to
+help close stale issues and labels issues please reach to us with your GitHub
+Username and we'll add you to the triage team. It is a great way to start
+contributing and a path toward getting commit rights.
+
+.. _version761:
+
+IPython 7.6.1
+=============
+
+IPython 7.6.1 contain a critical bugfix in the ``%timeit`` magic, which would
+crash on some inputs as a side effect of :ghpull:`11716`. See :ghpull:`11812`
+
+
+.. _whatsnew760:
+
+IPython 7.6.0
+=============
+
+IPython 7.6.0 contains a couple of bug fixes and number of small features
+additions as well as some compatibility with the current development version of
+Python 3.8.
+
+   - Add a ``-l`` option to :magic:`psearch` to list the available search
+     types. :ghpull:`11672`
+   - Support ``PathLike`` for ``DisplayObject`` and ``Image``. :ghpull:`11764`
+   - Configurability of timeout in the test suite for slow platforms.
+     :ghpull:`11756`
+   - Accept any casing for matplotlib backend. :ghpull:`121748`
+   - Properly skip test that requires numpy to be installed :ghpull:`11723`
+   - More support for Python 3.8 and positional only arguments (pep570)
+     :ghpull:`11720`
+   - Unicode names for the completion are loaded lazily on first use which
+     should decrease startup time. :ghpull:`11693`
+   - Autoreload now update the types of reloaded objects; this for example allow
+     pickling of reloaded objects. :ghpull:`11644`
+   - Fix a bug where ``%%time`` magic would suppress cell output. :ghpull:`11716`
+
+
+Prepare migration to pytest (instead of nose) for testing
+---------------------------------------------------------
+
+Most of the work between 7.5 and 7.6 was to prepare the migration from our
+testing framework to pytest. Most of the test suite should now work by simply
+issuing ``pytest`` from the root of the repository.
+
+The migration to pytest is just at its beginning. Many of our test still rely
+on IPython-specific plugins for nose using pytest (doctest using IPython syntax
+is one example of this where test appear as "passing", while no code has been
+ran). Many test also need to be updated like ``yield-test`` to be properly
+parametrized tests.
+
+Migration to pytest allowed me to discover a number of issues in our test
+suite; which was hiding a number of subtle issues – or not actually running
+some of the tests in our test suite – I have thus corrected many of those; like
+improperly closed resources; or used of deprecated features. I also made use of
+the ``pytest --durations=...`` to find some of our slowest test and speed them
+up (our test suite can now be up to 10% faster). Pytest as also a variety of
+plugins and flags which will make the code quality of IPython and the testing
+experience better.
+
+Misc
+----
+
+We skipped the release of 7.6 at the end of May, but will attempt to get back
+on schedule. We are starting to think about making introducing backward
+incompatible change and start the 8.0 series.
+
+Special Thanks to Gabriel (@gpotter2 on GitHub), who among other took care many
+of the remaining task for 7.4 and 7.5, like updating the website.
+
+.. _whatsnew750:
+
+IPython 7.5.0
+=============
+
+IPython 7.5.0 consist mostly of bug-fixes, and documentation updates, with one
+minor new feature. The `Audio` display element can now be assigned an element
+id when displayed in browser. See :ghpull:`11670`
+
+The major outstanding bug fix correct a change of behavior that was introduce
+in 7.4.0 where some cell magics would not be able to access or modify global
+scope when using the ``@needs_local_scope`` decorator. This was typically
+encountered with the ``%%time`` and ``%%timeit`` magics. See :ghissue:`11659`
+and :ghpull:`11698`.
+
+.. _whatsnew740:
+
+IPython 7.4.0
+=============
+
+Unicode name completions
+------------------------
+
+Previously, we provided completion for a unicode name with its relative symbol.
+With this, now IPython provides complete suggestions to unicode name symbols.
+
+As on the PR, if user types ``\LAT<tab>``, IPython provides a list of
+possible completions. In this case, it would be something like::
+
+   'LATIN CAPITAL LETTER A',
+   'LATIN CAPITAL LETTER B',
+   'LATIN CAPITAL LETTER C',
+   'LATIN CAPITAL LETTER D',
+   ....
+
+This help to type unicode character that do not have short latex aliases, and
+have long unicode names. for example ``Í°``, ``\GREEK CAPITAL LETTER HETA``.
+
+This feature was contributed by Luciana Marques :ghpull:`11583`.
+
+Make audio normalization optional
+---------------------------------
+
+Added 'normalize' argument to `IPython.display.Audio`. This argument applies
+when audio data is given as an array of samples. The default of `normalize=True`
+preserves prior behavior of normalizing the audio to the maximum possible range.
+Setting to `False` disables normalization.
+
+
+Miscellaneous
+-------------
+
+ - Fix improper acceptation of ``return`` outside of functions. :ghpull:`11641`.
+ - Fixed PyQt 5.11 backwards incompatibility causing sip import failure.
+   :ghpull:`11613`.
+ - Fix Bug where ``type?`` would crash IPython. :ghpull:`1608`.
+ - Allow to apply ``@needs_local_scope`` to cell magics for convenience.
+   :ghpull:`11542`.
+
+.. _whatsnew730:
+
+IPython 7.3.0
+=============
+
+
+IPython 7.3.0 bring several bug fixes and small improvements that you will
+described below.
+
+The biggest change to this release is the implementation of the ``%conda`` and
+``%pip`` magics, that will attempt to install packages in the **current
+environment**. You may still need to restart your interpreter or kernel for the
+change to be taken into account, but it should simplify installation of packages
+into remote environment. Installing using pip/conda from the command line is
+still the prefer method.
+
+The ``%pip`` magic was already present, but was only printing a warning; now it
+will actually forward commands to pip. 
+
+Misc bug fixes and improvements:
+
+ - Compatibility with Python 3.8.
+ - Do not expand shell variable in execution magics, and added the
+   ``no_var_expand`` decorator for magic requiring a similar functionality
+   :ghpull:`11516`
+ - Add ``%pip`` and ``%conda`` magic :ghpull:`11524`
+ - Re-initialize posix aliases after a ``%reset`` :ghpull:`11528`
+ - Allow the IPython command line to run ``*.ipynb`` files :ghpull:`11529`
+
+.. _whatsnew720:
+   
+IPython 7.2.0
+=============
+
+IPython 7.2.0 brings minor bugfixes, improvements, and new configuration options:
+
+ - Fix a bug preventing PySide2 GUI integration from working :ghpull:`11464`
+ - Run CI on Mac OS ! :ghpull:`11471`
+ - Fix IPython "Demo" mode. :ghpull:`11498`
+ - Fix ``%run`` magic  with path in name :ghpull:`11499`
+ - Fix: add CWD to sys.path *after* stdlib :ghpull:`11502`
+ - Better rendering of signatures, especially long ones. :ghpull:`11505`
+ - Re-enable jedi by default if it's installed :ghpull:`11506`
+ - Add New ``minimal`` exception reporting mode (useful for educational purpose). See :ghpull:`11509`
+
+
+Added ability to show subclasses when using pinfo and other utilities
+---------------------------------------------------------------------
+
+When using ``?``/``??`` on a class, IPython will now list the first 10 subclasses.
+
+Special Thanks to Chris Mentzel of the Moore Foundation for this feature. Chris
+is one of the people who played a critical role in IPython/Jupyter getting
+funding.
+
+We are grateful for all the help Chris has given us over the years,
+and we're now proud to have code contributed by Chris in IPython.
+
+OSMagics.cd_force_quiet configuration option
+--------------------------------------------
+
+You can set this option to force the %cd magic to behave as if ``-q`` was passed::
+
+    In [1]: cd /
+    /
+
+    In [2]: %config OSMagics.cd_force_quiet = True
+
+    In [3]: cd /tmp
+
+    In [4]:
+
+See :ghpull:`11491`
+
+In vi editing mode, whether the prompt includes the current vi mode can now be configured
+-----------------------------------------------------------------------------------------
+
+Set the ``TerminalInteractiveShell.prompt_includes_vi_mode`` to a boolean value
+(default: True) to control this feature. See :ghpull:`11492`
+
+.. _whatsnew710:
+
+IPython 7.1.0
+=============
+
+IPython 7.1.0 is the first minor release after 7.0.0 and mostly brings fixes to
+new features, internal refactoring, and fixes for regressions that happened during the 6.x->7.x
+transition. It also brings **Compatibility with Python 3.7.1**, as we're
+unwillingly relying on a bug in CPython.
+
+New Core Dev:
+
+ - We welcome Jonathan Slenders to the committers. Jonathan has done a fantastic
+   work on prompt_toolkit, and we'd like to recognise his impact by giving him
+   commit rights. :ghissue:`11397`
+
+Notable 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 daefault), has new configuration options,
+   has a brand new documentation page :ref:`ipython_directive` (which needs
+   some cleanup). It is also now *tested* so we hope to have less regressions.
+   :ghpull:`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. :ghpull:`11353`
+
+ - Warn when using ``HTML('<iframe>')`` instead of ``IFrame`` :ghpull:`11350`
+
+ - Allow Dynamic switching of editing mode between vi/emacs and show
+   normal/input mode in prompt when using vi. :ghpull:`11390`. Use ``%config
+   TerminalInteractiveShell.editing_mode = 'vi'`` or ``%config
+   TerminalInteractiveShell.editing_mode = 'emacs'`` to dynamically switch
+   between modes.
+
+
+Notable Fixes:
+
+ - Fix entering of **multi-line blocks in terminal** IPython, and various
+   crashes in the new input transformation machinery :ghpull:`11354`,
+   :ghpull:`11356`, :ghpull:`11358`. These also fix a **Compatibility bug
+   with Python 3.7.1**.
+
+ - Fix moving through generator stack in ipdb :ghpull:`11266`
+
+ - %Magic command arguments now support quoting. :ghpull:`11330`
+
+ - Re-add ``rprint`` and ``rprinte`` aliases. :ghpull:`11331`
+
+ - Remove implicit dependency on ``ipython_genutils`` :ghpull:`11317`
+
+ - Make ``nonlocal`` raise ``SyntaxError`` instead of silently failing in async
+   mode. :ghpull:`11382`
+
+ - Fix mishandling of magics and ``= !`` assignment just after a dedent in
+   nested code blocks :ghpull:`11418`
+
+ - Fix instructions for custom shortcuts :ghpull:`11426`
+
+
+Notable Internals improvements:
+
+ - Use of ``os.scandir`` (Python 3 only) to speed up some file system operations.
+   :ghpull:`11365`
+
+ - use ``perf_counter`` instead of ``clock`` for more precise
+   timing results with ``%time`` :ghpull:`11376`
+
+Many thanks to all the contributors and in particular to ``bartskowron`` and
+``tonyfast`` who handled some pretty complicated bugs in the input machinery. We
+had a number of first time contributors and maybe hacktoberfest participants 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
+<https://github.com/ipython/ipython/issues?utf8=%E2%9C%93&q=+is%3Aclosed+milestone%3A7.1+>`_.
+
+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 sequences 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 sequences 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 characters 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 gives ``ɛ`` (GREEK SMALL LETTER EPSILON) instead of ``ε`` (GREEK LUNATE EPSILON SYMBOL),
+ - ``\underbar`` now gives U+0331 (COMBINING MACRON BELOW) instead of U+0332 (COMBINING LOW LINE).
+
+
+.. _whatsnew700:
+
+IPython 7.0.0
+=============
+
+Released Thursday September 27th, 2018
+
+IPython 7 includes major feature improvements.
+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
+<https://github.com/ipython/ipython/pulls?page=3&q=is%3Apr+sort%3Aupdated-desc+author%3Aapp%2Fmeeseeksdev++5.x&utf8=%E2%9C%93>`_, but there are still many PRs that required manual work. This is an area of the project where you can easily contribute by looking for `PRs that still need manual backport <https://github.com/ipython/ipython/issues?q=label%3A%22Still+Needs+Manual+Backport%22+is%3Aclosed+sort%3Aupdated-desc>`_
+
+The 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 running:
+
+.. code::
+
+    pip install ipython --upgrade
+
+.. only:: ipydev
+
+  If you are trying to install or update an ``alpha``, ``beta``, or ``rc``
+  version, use pip ``--pre`` flag.
+
+  .. code::
+
+      pip install ipython --upgrade --pre
+
+
+Or, if you have conda installed: 
+
+.. code::
+   
+   conda install ipython
+
+
+
+Prompt Toolkit 2.0
+------------------
+
+IPython 7.0+ now uses ``prompt_toolkit 2.0``. If you still need to use an earlier
+``prompt_toolkit`` version, you may need to pin IPython to ``<7.0``.
+
+Autowait: Asynchronous REPL
+---------------------------
+
+Staring with IPython 7.0 on Python 3.6+, IPython can automatically ``await``
+top level code. You should not need to access an event loop or runner
+yourself. To learn more, read the :ref:`autoawait` section of our docs, see
+:ghpull:`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 :ref:`autoawait` for more information.
+
+
+Asynchronous code in a Notebook interface or any other frontend using the
+Jupyter Protocol will require further updates to 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 :magic:`%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 an event loop is specified.
+
+Effects on Magics
+~~~~~~~~~~~~~~~~~
+
+Some magics will not work with async until they're updated.
+Contributions welcome.
+
+Expected Future changes
+~~~~~~~~~~~~~~~~~~~~~~~
+
+We expect more internal but public IPython functions to become ``async``, and
+will likely end up having a persistent event loop while IPython is running.
+
+Thanks
+~~~~~~
+
+This release took more than a year in the making.
+The code was rebased a number of
+times; 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-cases: dalejung, danielballan, ellisonbg, fperez, gnestor,
+minrk, njsmith, pganssle, tacaswell, takluyver , vidartf ... And many others.
+
+
+Autoreload Improvement
+----------------------
+
+The magic :magic:`%autoreload 2 <autoreload>` 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`` is saved on
+disk.
+
+
+.. code::
+
+   # notebook
+
+   from mymodule import MyClass
+   first = MyClass(5)
+
+.. code::
+
+   # 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 :ghpull:`11257`
+
+Make :magic:`%run -n -i ... <run>` work correctly. Earlier, if :magic:`%run` was
+passed both arguments, ``-n`` would be silently ignored. See :ghpull:`10308`
+
+
+The :cellmagic:`%%script` (as well as :cellmagic:`%%bash`,
+:cellmagic:`%%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 functions 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: any custom input transformations will need to be
+  rewritten. See :doc:`/config/inputtransforms` for details of the new API.
diff --git a/docs/source/whatsnew/version8.rst b/docs/source/whatsnew/version8.rst
new file mode 100644
index 00000000000..346ee53ae6c
--- /dev/null
+++ b/docs/source/whatsnew/version8.rst
@@ -0,0 +1,2633 @@
+============
+ 8.x Series
+============
+
+.. _version 8.37:
+
+IPython 8.37
+============
+
+This release includes fixes for the tab completer and LLM completer backported from IPython 9.4:
+
+- :ghpull:`14910` Eliminate startup delay when LLM completion provider is configured
+- :ghpull:`14898` Fix attribute completion for expressions with comparison operators
+
+.. _version 8.36:
+
+IPython 8.36
+============
+
+This is a small release with minor changes in the context passed to the LLM completion
+provider and a fix for interruption of execution magics:
+
+- :ghpull:`14890` Fixed interruption of ``%%time`` and ``%%debug`` magics
+- :ghpull:`14877` Removed spurious empty lines from ``prefix`` passed to LLM, and separated part after cursor into the ``suffix``
+
+.. _version 8.35:
+
+IPython 8.35
+============
+
+This small early April release includes a few backports of bug fixes for tab and LLM completions:
+
+- :ghpull:`14838` Fixed tab-completion of global variables in lines with a dot when jedi is off
+- :ghpull:`14846` Fixed LLM request number always being set to zero and removed spurious logging
+- :ghpull:`14851` Passes current input history to LLMs
+
+
+.. _version 8.34:
+
+IPython 8.34
+============
+
+This tiny beginning of March release included two bug fixes:
+
+- :ghpull:`14823` Fixed right arrow incorrectly accepting invisible auto-suggestions
+- :ghpull:`14828` Fixed Qt backend crash
+
+along with a backport of improved documentation and configurability of LLM completions.
+
+.. _version 8.33:
+
+IPython 8.33
+============
+
+This small end of February release included a few backports of bug fixes and minor enhancements:
+
+- :ghpull:`14717` Fixed auto-suggestion on Prompt Toolkit < 3.0.49
+- :ghpull:`14738` Fixed Python 3.13 compatibility of ``local_ns``
+- :ghpull:`14700` Improved Qt object management and performance
+- :ghpull:`14790` Better documentation and configurability of LLM completions
+
+
+.. _version 8.32:
+
+IPython 8.32
+============
+
+Medium release of IPython for this end of January and this new year 2025.
+This is now a different branch than the main branch, and will only accumulate
+bugfixes and small improvements and requested backports, while 9.0 forges ahead.
+
+
+We'll note 4 bugfixes and an and unstable preview feature.
+
+- :ghpull:`14640` Fixes an error were a warning about virtualenvs was incorrectly triggered.
+
+- :ghpull:`14684` Fixes an issue on Python 3.12+ with post mortem debugging.
+- :ghpull:`14693` Fixes a bug where magics were ignoring SIGINT
+- :ghpull:`14695` Fixes an issue where magics would not display all subprocess output.
+
+
+As a preview feature, look into the ``examples`` folder on how to configure
+autosuggestion using a large language model. This is not yet ready for
+production use, has only partial documentation and can change without warning,
+but should allow you to hook in a Jupyter-ai LLM provider to suggest code in the
+CLI (currently only via a keyboard shortcut). See :ghpull:`14623` for more details
+until further documentation is available in 9.0. 
+
+
+As usual you can find the full list of PRs on GitHub under `the 8.32
+<https://github.com/ipython/ipython/milestone/140?closed=1>`__ milestone.
+
+For something completely different
+----------------------------------
+
+`Dora Rudolfine Richter <https://en.wikipedia.org/wiki/Dora_Richter>`__
+1892–1966 was a German trans woman and the first known person to undergo
+complete male-to-female gender-affirming surgery. After fleeing Nazi Germany,
+she lived in Czechoslovakia where she obtained her full legal name change in
+April 1934. She moved back to Germany in 1946 with the expulsion of Germans from
+Czechoslovakia where she lived until her death at the age of 74 in April 1966.
+
+Thanks
+------
+
+Thanks to everyone who helped with the 8.32 release and working toward 9.0.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries, in particular the work around LLM
+integration.
+
+.. _version 8.31:
+
+IPython 8.31
+============
+
+Small release for this end of December; This release contains only two notable changes:
+
+  - :ghpull:`14594` Fix completion in tuples, where the completion was
+    suggesting tuples methods instead of methods and attributes of the current
+    element.
+  - :ghpull:`14598` Fix  pdb issue with Python 3.13.1, this fix is not perfect
+    (see :ghissue:`14620`) but should be sufficient for now.
+
+
+As usual you can find the full list of PRs on GitHub under `the 8.31
+<https://github.com/ipython/ipython/milestone/138?closed=1>`__ milestone.
+
+
+Road to 9.0
+-----------
+
+The current main branch is now on it's way to be 9.0; do not expect many new
+features but a large codebase refactor, and cleanup with many deprecated code
+removed, and more aggressive codestyle enforcement.
+
+For something completely different
+----------------------------------
+
+`Emmy Noether <https://en.wikipedia.org/wiki/Emmy_Noether>`__ was a German
+mathematician who made groundbreaking contributions to abstract algebra and
+theoretical physics. Her work on Noether's theorem, which describes the
+relationship between symmetries and conservation laws, has had a profound impact
+on the development of modern physics. Noether's work was largely overlooked
+during her lifetime, but her legacy as one of the most important mathematicians
+of the 20th century has been recognized and celebrated in recent years.
+
+Thanks
+------
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.30:
+
+IPython 8.30
+============
+
+Small release for this end of november;
+
+ - :ghpull:`14579` improve the documentatation for custom IPython formatters, and how
+   you can register formatters for custom mime types.
+ - :ghpull:`14580` fix a bug in which commands that were not assigned a shortcut
+   could not be assigned one.
+ - :ghpull:`12690` fix a bug in which a single ``/`` on an empty line would not be
+   an error. This is due to the ``autocall`` behavior that we are thinking of
+   deprecating.
+
+The rest of the PRs are mostly maintenance and documentation improvements.
+
+As usual you can find the full list of PRs on GitHub under `the 8.30
+<https://github.com/ipython/ipython/milestone/137?closed=1>`__ milestone.
+
+
+For something completely different
+----------------------------------
+
+`Ada Lovelace <https://en.wikipedia.org/wiki/Ada_Lovelace>`__ is considered the
+first computer programmer. In the 1840s, she wrote what is recognized as the
+first algorithm intended to be processed by a machine - Charles Babbage's
+proposed Analytical Engine. Her notes included what would today be called a
+computer program, making her the first programmer in history. She also uniquely
+understood that computers could go beyond mere calculation and could be used to
+create music or art - a visionary insight that was far ahead of her time.
+Despite living in an era when women had limited access to scientific education,
+she made groundbreaking contributions that laid the foundation for modern
+computing.
+
+Thanks
+------
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.29:
+
+IPython 8.29
+============
+
+Medium release for this end of october;
+
+ - Misc Python 3.13 compatibility :ghpull:`14536`, :ghpull:`14559`
+ - Add a ``uv`` line magic :ghpull:`14537`
+ - Add support for WEBP to ``IPython.display.Image``. :ghpull:`14526`
+ - And many more bugfixes and quality of life improvements.
+
+As usual you can find the full list of PRs on GitHub under `the 8.29
+<https://github.com/ipython/ipython/milestone/136?closed=1>`__ milestone.
+
+Preparing for 9.0
+-----------------
+
+IPython 3.13 was released earlier this month, and this means that according to
+`Spec-0 <https://scientific-python.org/specs/spec-0000/>`__, support for 3.10
+will end soon.
+
+There have been many minor version of IPython 8.x, so it is likely that one of
+the next version will simply bump to 9.0 and remove a lot of code mark as
+deprecated, and documentation/examples not relevant for terminal IPython.
+
+The frequency of release and my time reviewing will also likely decrease more
+than it has already.
+
+
+For something completely different
+----------------------------------
+
+`Rosalind Franklin <https://en.wikipedia.org/wiki/Rosalind_Franklin>`__ made
+some of the biggest contribution to the discovery of the helix structure of DNA.
+Unfortunately her work was `not recognized
+<https://www.nature.com/scitable/topicpage/rosalind-franklin-a-crucial-contribution-6538012/>`__
+
+Thanks
+------
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.28:
+
+IPython 8.28
+============
+
+Slight delay of this September release as I was busy at Pydata Paris last week.
+Not many user visible changes for this release, a couple of bug fixes and
+workaround:
+
+ - :ghpull:`14480` AssertionError: assert _xterm_term_title_saved in WSL – It is
+   unclear why the terminal title is not saved in WSL, if you've WSL experience
+   we'd love your feedback and help to not just ignore an error
+ - :ghpull:`14510` Fix use of pyside6 >= 6.7.0
+ - :ghpull:`14518` Make values public (_tb_highlight & _tb_highlight_style)
+ - :ghpull:`14515` Use environment variable to identify conda / mamba
+
+
+As usual you can find the full list of PRs on GitHub under `the 8.28
+<https://github.com/ipython/ipython/milestone/135?closed=1>`__ milestone.
+
+For something completely different
+----------------------------------
+
+One of the first works of Science Fiction (`Frankenstein
+<https://en.wikipedia.org/wiki/Frankenstein>`__), was written by `Mary Shelley
+<https://en.wikipedia.org/wiki/Mary_Shelley>`__ when she was 18, before being
+published in London on 1 January 1818 when she was 20. This is often overlooked,
+and the role of founders of science fiction attribute to Edgar Allan Poe and
+Jules Verne despite being published later.
+
+Thanks
+------
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.27:
+
+IPython 8.27
+============
+
+New release of IPython after a month off (not enough changes). We can see a few
+important changes for this release.
+
+ - autocall was being  call getitem, :ghpull:`14486`
+ - Only copy files in startup dir if we just created it. :ghpull:`14497`
+ - Fix some tests on Python 3.13 RC1 :ghpull:`14504`; this one I guess make this
+   the first IPython release officially compatible with Python 3.13; you will
+   need the most recent ``executing`` and ``stack_data``, we won't pin to avoid
+   forcing user of older Python version to upgrade.
+
+
+As usual you can find the full list of PRs on GitHub under `the 8.27
+<https://github.com/ipython/ipython/milestone/134?closed=1>`__ milestone.
+
+Thanks
+------
+
+Many thanks to `@Kleirre <https://github.com/Kleirre>`__ our June intern for
+doing her first contribution to open source, doing the releases notes and
+release. I guess you didn't even notice it was not me who released :-). I wish
+her all the best in her future endeavor and look forward for her work in
+astrophysics.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.26:
+
+IPython 8.26
+============
+
+Hey, the release of IPython for this month is here! (I know you were waiting for it)
+
+- :ghpull:`14453` bugfix for call to structured_traceback
+
+- :ghpull:`14466` fixed honoring custom repr for NamedTuple if assigned by partialmethod
+
+- :ghpull:`14451` Convert matplotlib gui name in enable_gui
+
+As usual you can find the full list of PRs on GitHub under `the 8.26
+<https://github.com/ipython/ipython/milestone/133?closed=1>`__ milestone.
+
+Thanks
+------
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.25:
+
+IPython 8.25
+============
+
+Mostly internal changes for this end of may release of IPython.
+
+We'll count about a dozen PRs for this moth, with small bugfixes related to
+matplotlib fixes.
+
+Of notable interest,
+
+ - :ghpull:`14426` replaces the unicode micro symbol with greek letter mu,
+   visually identical but should fix nfkc normalisations issues.
+
+ - :ghpull:`14444` introduces ``intersphinx_registry``  as a new dependency
+   which is recommended only to build documentation.
+
+As usual you can find the full list of PRs on GitHub under `the 8.25
+<https://github.com/ipython/ipython/milestone/132?closed=1>`__ milestone.
+
+Thanks
+------
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.24:
+
+IPython 8.24
+============
+
+Back on regular release schedule, as usual month releases are relatively tiny.
+
+The biggest change is the move of the matplotlib backend handling from IPython
+to matplotlib. :ghpull:`14371` :ghpull:`14403`.
+
+We will note:
+
+ - pytest 8 compatibility :ghpull:`14413`
+ - ``typing-extension`` now needs 4.6 or newer. It was already the case, but not
+   explicated. :ghpull:`14380`
+ - Attempt to speed running code under debugger in some cases. :ghpull:`14386`
+   :ghpull:`14418`.
+ - Multiple fixes to documentation for ipyparallel, simple_prompt and emacs
+   :ghpull:`14384` :ghpull:`14404` :ghpull:`14407`
+ - Maintenance and cleanup of debugger :ghpull:`14387` :ghpull:`14393`
+
+As usual you can find the full list of PRs on GitHub under `the 8.24
+<https://github.com/ipython/ipython/milestone/131?closed=1>`__ milestone.
+
+Thanks
+------
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.23:
+
+IPython 8.23
+============
+
+Super tiny release of IPython on Sunday – a bit later than usual, which is also
+`���⚧� International Transgender Day of Visibility���⚧�
+<https://en.wikipedia.org/wiki/International_Transgender_Day_of_Visibility>`_ –
+so a though for you on this day, you matter and you are valid [1]_.
+
+This is a minuscule release with only 5 Pull requests.
+
+Main change is :ghpull:`14357` which improve inference from return type
+annotations in completer and the introduction of the optional target
+``ipython[matplotlib]`` to explicitly request the matplotlib optional
+dependencies.
+
+As usual you can find the full list of PRs on GitHub under `the 8.23
+<https://github.com/ipython/ipython/milestone/130?closed=1>`__ milestone.
+
+Thanks
+------
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.22:
+
+IPython 8.22, 8.22.1 and 8.22.2
+===============================
+
+Quick release of IPython for this short month of February, with quite a bit of
+activity with more than 15 PRs.
+
+I am not going to details all the changes, but among other we have :
+
+ - More compatibility with emscripten :ghpull:`14316`, :ghpull:`14318`,
+ - Test more downstream project to avoid breakage :ghpull:`14317`
+ - Fix recently introduced bug with the ``store`` magic.
+ - Fix issues with multiple call to ``matplotlib.pyplot.switch_backend``
+ - Fix crashing IPython when some tracebacks encounter dynamically evaluated
+   code.
+
+IPython 8.22.1 increase the minimal traitlets version, and 8.22.2 fix a critical
+bug on emscripten  preventing to use some magics like ``%matplotlib`` on
+jupyter-light.
+
+API changes
+-----------
+
+One of the largest change is the update the mimehooks and inspector API, see
+:ghpull:`14342`. It should be backward compatible, but many hooks now receive a
+single object with many fields allowing us flexibility to update the API later.
+
+
+Packaging changes
+-----------------
+
+Thanks to `@mkoppe <https://github.com/mkoeppe>`__, we are slowly getting rid of
+setup.py finally migrating to ``pyproject.toml``. There is still quite a bit of
+work, and please open an issue if you encounter any problem.
+
+
+Deprecation
+-----------
+
+A number of unused functions have been marked deprecated or pending deprecation.
+Please let us know if you encounter any of those deprecation messages for us to
+adjust the removal timeline.
+
+
+Thanks
+------
+
+Many thanks to `@mkoppe <https://github.com/mkoeppe>`__ and `@krassowski
+<https://github.com/krassowski>`__ for their multiple contributions and codebase
+cleanup.
+
+As usual you can find the full list of PRs on GitHub under `the 8.22
+<https://github.com/ipython/ipython/milestone/129?closed=1>`__ milestone.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.21:
+
+IPython 8.21
+============
+
+More substantial release of IPython slightly out of schedule as it was not
+possible for me to make a release last Friday.
+
+Few new features are present, but the codebase has been cleaned, and a couple
+of API are _considered_ for deprecation. They are not deprecated yet, but as
+they do not seem to be quite used, they may emit a warning, in which case please
+comment on the relevant issue to inform me of _which_ project use those feature
+and how you use them. Depending on the feedback I might change the timeline for
+deprecation.
+
+This release saw 14 PRs, with more outside contribution than usual,
+I'll note in particular PRs related to making IPython work on emscripten.
+
+I also want to point that we are _trying_ to keep compatibility with Python 3.13,
+but it's a cat and mouse game. Plus I am low on time, so I would appreciate any
+help with that.
+
+Deprecations
+------------
+
+ - :ghpull:`14307` Pending Deprecation of
+   ``ColorSchemeTable.set_active_scheme(...)``'s ``case_sensitive`` Parameter.
+ - :ghpull:`14305` Pending Deprecation of constructing ``ColorScheme`` via
+   ``kwargs``, in favor passing a single dict.
+
+
+Fixes
+-----
+
+ - :ghpull:`14284` TerminalIPythonApp's would warn that ``auto_create`` option is not
+   recognized.
+ - :ghpull:`14286` Fix a crash with ``NotOneValueFound`` when rendering complex
+   tracebacks.
+
+ - :ghpull:`14287` Partial Python 3.13 compatibility
+ - :ghpull:`14290` Docs/Typos.
+
+Changes
+~~~~~~~
+
+ - :ghpull:`14289` ``ipdb.set_trace()`` now accepts ``header=`` for better
+   compatibility with ``pdb.set_trace()``
+
+ - :ghpull:`14300` and :ghpull:`14301` Add hooking ability to produce
+   mimebundle.
+
+We'll outline :ghpull:`14300`, it is now possible to extend the ``?/??``
+operator to return more mimetypes to render richer help in frontends that
+support it. In particular you could send a json representation of the help that
+could be displayed in a customizable way.
+
+Miscellaneous
+-------------
+
+ - :ghpull:`14291` Misc Refactor of Color handling
+ - :ghpull:`14295` Misc test skip on problematic Pypy versions.
+
+
+Thanks
+~~~~~~
+
+Special thanks to all our contributors, and to the Pypy team that was extremely
+reactive in helping to investigate a fixing a rare unicode+windows bug.
+
+As usual you can find the full list of PRs on GitHub under `the 8.21
+<https://github.com/ipython/ipython/milestone/128?closed=1>`__ milestone.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.20:
+
+IPython 8.20
+============
+
+Quick IPython release in this beginning of 2024, barely 2 weeks after the previous
+release.
+
+This is mostly to fix a backward compatibility issue, I would have done a  patch
+release earlier if I could. As a few other cleanup are also part of this
+release, this will get a minor version bump.
+
+
+The crux of this release is :ghpull:`14274` (Inspect continuation prompt
+signature and pass only viable arguments), the rest of the changes are mostly
+type annotation, and a few compatibility issues with Python 3.13 that are
+getting addressed.
+
+Python 3.13 compatibility is still not complete (help welcomed).
+
+As usual you can find the full list of PRs on GitHub under `the 8.20
+<https://github.com/ipython/ipython/milestone/127?closed=1>`__ milestone.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.19:
+
+IPython 8.19
+============
+
+New release of IPython a bit before the end of the month, and end of the year.
+
+Mostly cleanup and deprecation, due to upstream deprecation and removal.
+
+Remove of Python 3.9 support
+----------------------------
+
+A bit later than originally plan, IPython 8.19 does not support Python 3.9
+anymore, as well as the few conditional code that were executing only on Python
+3.9. :ghpull:`14254`
+
+We used the opportunity to deprecate ``IPython.utils.tz`` :ghpull:`14256`, due
+to upstream deprecation of some timezone utilities. It will be removed at a later
+date.
+
+We now also run CI on Python 3.12 (what I likely should have done before), but
+running on too many Python version uses a lot of CI time.
+
+Absolute and relative Line Numbers in Prompts
+---------------------------------------------
+
+Thanks to the contribution of ``cohml``, IPython CLI now support absolute and
+relative line numbers in both vi and emacs prompt, use for example
+``c.TerminalInteractiveShell.prompt_line_number_format='{line: 4d}/{rel_line:+03d} | '``
+configuration option to display both in a custom format.
+
+Miscellaneous
+-------------
+
+In addition to various bugfixes, I unpinned pytest, let me know if there are any
+issues and we'll re-pin.
+
+See you in 2024
+---------------
+
+As usual you can find the full list of PRs on GitHub under `the 8.19
+<https://github.com/ipython/ipython/milestone/126?closed=1>`__ milestone.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.18:
+
+IPython 8.18 and 8.18.1
+=======================
+
+8.18.1 is identical to 8.18 but pin ``prompt_toolkit`` to greater than ``3.0.41``
+
+Small release of IPython that fixes a small number of inconveniences.
+
+ - :ghpull:`14251` Fix a memory leak in qt event loop integration by setting
+   the Loop parent to None.
+ - :ghpull:`14252` Pickleshare was made an optional dependency in 8.17, this
+   leads to warnings in some installations when using modules completions. The
+   warning has been silenced.
+ - :ghpull:`14241` Update event loop code for compatibility with more recent
+   ``prompt_toolkit`` due to deprecations in Python 3.12.
+ - :ghpull:`14245` Fix doc example on Pygments styles
+ - :ghpull:`14238` Remove dependency on app_nope, this is actually only a
+   dependency of IPykernel.
+
+As usual you can find the full list of PRs on GitHub under `the 8.18
+<https://github.com/ipython/ipython/milestone/125?closed=1>`__ milestone.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.17.1:
+.. _version 8.17:
+
+IPython 8.17, 8.17.1
+====================
+
+Medium-sized release of IPython that includes some cleanup (backcall, python2 leftovers)
+and some refactoring improvements (typing, pathlib) and a fix on completion.
+
+  - :ghpull:`14216` remove backcall dependency
+  - :ghpull:`14217` make pickleshare dependency optional
+  - :ghpull:`14185` support completion based on type annotations of calls
+
+Reverted in 8.17.1:
+
+  - :ghpull:`14190` remove support for python 2 in lexers (reverted in 8.17.1 as it is imported by qtconsole/spyder)
+
+
+Mamba and Micromamba magic commands
+------------------------------------
+
+In addition to the ``%conda`` magic command for calling ``conda`` in IPython,
+the ``%mamba`` and ``%micromamba`` magic commands now
+call ``mamba`` and ``micromamba`` if they are on ``sys.path``.
+
+.. code::
+
+   %mamba install pkgname
+   %micromamba install pkgname
+   %conda install pkgname
+   %pip install pkgname
+
+   %mamba --help
+   %micromamba --help
+   %conda --help
+   %pip --help    # works w/ JupyterLite
+   !pip --help
+
+
+:ghpull:`14191`
+
+----
+
+As usual you can find the full list of PRs on GitHub under `the 8.17
+<https://github.com/ipython/ipython/milestone/123?closed=1>`__ milestone.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.16:
+.. _version 8.16.1:
+
+IPython 8.16, 8.16.1
+====================
+
+Small double release of IPython (with the 8.12.3 release notes just below).
+Mostly bug fixes and cleanups, and type annotations. Of interest for users:
+
+ - :ghpull:`14153` Fix a bug of the new iPdb chained traceback where some
+   Exception would not have any traceback. (see upstream fix in CPython for more
+   details).
+ - :ghpull:`14168` Fix case with spurious message about event loops when using
+   matplotlib.
+
+This PR is in 8.16.0 but reverted in 8.16.1, we'll  rework the fix for 8.17
+
+ - :ghpull:`14163` Fix an error where semicolon would not suppress output.
+
+As usual you can find the full list of PRs on GitHub under `the 8.16
+<https://github.com/ipython/ipython/milestone/121?closed=1>`__ and `8.16.1 milestone
+<https://github.com/ipython/ipython/milestone/124?closed=1>`__.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.12.3:
+
+IPython 8.12.3
+==============
+
+Tiny release of 8.12.3 that backport a small number of fixes for users still
+using Python 3.8.
+
+ - :ghpull:`14080` add passthrough filter shortcuts
+ - :ghpull:`14169` Fix `InteractiveShellEmbed`
+
+.. _version 8.15:
+
+IPython 8.15
+============
+
+Medium release of IPython after a couple of month hiatus, and a bit
+off-schedule.
+
+Among other, IPython 8.15:
+
+ - Improve compatibility with future version of Python 3.12/3.13
+   :ghpull:`14107`, :ghpull:`14139`,
+ - Improve support for ``ExceptionGroups``, :ghpull:`14108`
+ - Fix hangs in ``%gui osx``, :ghpull:`14125`
+ - Fix memory lead with ``%reset``, :ghpull:`14133`
+ - Unstable config option to modify traceback highlighting that is sometime hard
+   to read :ghpull:`14138`
+ - Support ``.`` in ``ipdb`` as an argument to the ``list`` command
+   :ghpull:`14121`
+ - Workroud ``parso`` showing warning message when the default logger level is
+   changed :ghpull:`14119`
+ - Fix multiple issues with matplotlib interactive mode, qt5/qt6 :ghpull:`14128`
+
+Support for PEP-678 Exception Notes
+-----------------------------------
+
+Ultratb now shows :pep:`678` notes, improving your debugging experience on
+Python 3.11+ or with libraries such as Pytest and Hypothesis.
+
+Native fallback for displaying ExceptionGroup
+---------------------------------------------
+ExceptionGroups are now displayed with ``traceback.print_exc``, as a temporary fix until UltraTB properly supports displaying child exceptions.
+
+
+We have two larger features:
+
+AST-based macros
+----------------
+
+:ghpull:`14100` introduce a new and efficient way to modify each execution block
+(cell) using an template-ast-based transform. Unlike IPython pre and post code
+execution hooks, this actually transform the code that is execute with as
+minimal as possible overhead. While it was already technically possible to
+register ast transformers for IPython this was far from evident.
+
+This should make it trivial to hook into IPython to implement custom hooks, that
+for example time or profile your code, catch exceptions to provide error
+messages for students or do any other kind of transformations.
+
+In addition to programmatic API there is also a magic to quickly register
+hooks::
+
+   In [1]: %%code_wrap before_after
+      ...: print('before')
+      ...: __code__
+      ...: print('after')
+      ...: __ret__
+
+This mean that  for any subsequent execution code will be executed.
+You can modify the above to print the date, compute the execution time,
+retry the code in a for loop....
+
+
+Allow IPdb/Pdb to move between chained exceptions
+-------------------------------------------------
+
+The main change is the addition of the ability to move between chained
+exceptions when using IPdb, this feature was also contributed to upstream Pdb
+and is thus native to CPython in Python 3.13+ Though ipdb should support this
+feature in older version of Python. I invite you to look at the `CPython changes
+and docs <https://github.com/python/cpython/pull/106676>`__ for more details.
+
+In short, once in post-mortem debugger (``%debug``), you can use the ipdb
+``exceptions`` command to switch exceptions, for example:
+
+.. code-block:: ipython
+
+    In [1]: def foo(x):
+        ...:     try:
+        ...:         bar(x)
+        ...:     except Exception as e:
+        ...:         raise ValueError("foo (): bar failed") from e
+        ...:
+        ...: def bar(x):
+        ...:     1 / X
+        ...:
+
+    In [2]: foo(0)
+    ---------------------------------------------------------------------------
+    NameError                                 Traceback (most recent call last)
+    Cell In[1], line 3, in foo(x)
+          2 try:
+    ----> 3     bar(x)
+          4 except Exception as e:
+
+    Cell In[1], line 9, in bar(x)
+          8 def bar(x):
+    ----> 9     1 / X
+
+    NameError: name 'X' is not defined
+
+    The above exception was the direct cause of the following exception:
+
+    ValueError                                Traceback (most recent call last)
+    Cell In[2], line 1
+    ----> 1 foo(0)
+
+    Cell In[1], line 5, in foo(x)
+          3     bar(x)
+          4 except Exception as e:
+    ----> 5     raise ValueError("foo (): bar failed") from e
+
+    ValueError: foo (): bar failed
+
+    In [3]: %debug
+    > <ipython-input-1-b0bbdc271ffb>(5)foo()
+          3         bar(x)
+          4     except Exception as e:
+    ----> 5         raise ValueError("foo (): bar failed") from e
+
+In previous ipdb you could not go into the bar error, now from within pdb you
+can use ``exceptions``:
+
+.. code-block:: ipython
+
+    ipdb> exceptions
+        0 NameError("name 'X' is not defined")
+    >   1 ValueError('foo (): bar failed')
+
+    ipdb> exceptions 0
+    > <ipython-input-1-b0bbdc271ffb>(9)bar()
+          6
+          7
+          8 def bar(x):
+    ----> 9     1 / X
+         10
+
+    ipdb>
+
+In particular I want to thank the `D.E. Shaw group <https://www.deshaw.com/>`__
+for suggesting and funding the two largest feature as well as many bug fixes of
+this release.
+
+As usual you can find the full list of PRs on GitHub under `the 8.15 milestone
+<https://github.com/ipython/ipython/milestone/120?closed=1>`__.
+
+
+
+.. _version 8.14:
+
+IPython 8.14
+============
+
+Small release of IPython.
+
+ - :ghpull:`14080` fixes some shortcuts issues.
+ - :ghpull:`14056` Add option to ``%autoreload`` to hide errors when reloading code. This will be the default for spyder
+   user is my understanding.
+ - :ghpull:`14039` (and :ghpull:`14040`) to show exception notes in tracebacks.
+
+ - :ghpull:`14076` Add option to EventManager to prevent printing
+
+
+SPEC 0 and SPEC 4
+-----------------
+
+You've heard about the NEPs, (NumPy enhancement Proposal), having a NEP for something non-numpy specific was sometime confusing.
+Long live the `SPECs <https://scientific-python.org/specs/>`_.
+
+We are now trying to follow SPEC 0 (aka old NEP 29) for support of upstream libraries.
+
+We also now try to follow SPEC 4 (test and publish nightly on a centralized nightly repository).
+We encourage you to do so as well in order to report breakage, and contribute to the SPEC process !
+
+
+Python 3.12 compatibility ?
+---------------------------
+
+Python 3.12 changed its tokenizer to have better support for f-strings and allow arbitrary expression.
+This is a great new feature and performance improvement in Python 3.12.
+
+Unfortunately this means the new tokenizer does not support incomplete or invalid Python which will
+break many features of IPython. Thus compatibility of IPython with Python 3.12 is not guaranteed.
+It is unclear to which extent IPython is affected, and whether we can/should try to still support magics, shell
+escape (``! ....``), ...,  as well as how to do it if we can.
+
+In addition even if we there is technical feasibility to do so, it is no clear we have the resources to do it.
+We are thus looking for your help if you can _test_ on Python 3.12 to see to which extent this affects users and which
+features are critical.
+
+We are not going to pin IPython to Python ``<3.12`` as otherwise on install pip would downgrade/resolve to IPython 8.13,
+so if you plan to update to Python 3.12 after its release, we encourage for extra care.
+
+
+.. _version 8.13.1:
+.. _version 8.13.2:
+.. _version 8.12.2:
+
+IPython 8.13.1, 8.13.2 and 8.12.2
+=================================
+
+3 quick in succession patch release of IPython in addition to IPython 8.13.0
+having been yanked.
+
+IPython 8.13.0 was improperly tagged as still compatible with Python 3.8, and
+still had some mention of compatibility with 3.8. IPython 8.13.1 is identical to
+8.13 but with the exception of being correctly tagged. This release and yank was
+mostly done to fix CI.
+
+IPython 8.12.2 and 8.13.2 contain UI fixes, with respect to right arrow not
+working in some case in the terminal, and 8.12.2 contain also a requested
+backport of :ghpull:`14029` (Allow safe access to the ``__getattribute__``
+method of modules) for tab completion.
+
+.. _version 8.13:
+
+IPython 8.13
+============
+
+As usual for the end of the month, minor release of IPython. This release is
+significant in that it not only has a number of bugfixes, but also drop support
+for Python 3.8 as per NEP 29 (:ghpull:`14023`).
+
+All the critical bugfixes have been backported onto the 8.12.1 release (see
+below). In addition to that went into 8.12.1 you'll find:
+
+ - Pretty representation for ``Counter`` has been fixed to match the Python one
+   and be in decreasing order. :ghpull:`14032`
+ - Module completion is better when jedi is disabled :ghpull:`14029`.
+ - Improvement of ``%%bash`` magic that would get stuck :ghpull:`14019`
+
+
+We hope you enjoy this release an will maybe see you at JupyterCon in less than
+two weeks.
+
+As usual you can find the full list of PRs on GitHub under `the 8.13 milestone
+<https://github.com/ipython/ipython/milestone/115?closed=1>`__.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.12.1:
+
+IPython 8.12.1
+==============
+
+This is the twin release of IPython 8.13 that contain only critical UI and bug
+fixes. The next minor version of IPython has dropped support for Python 3.8 – as
+per Nep 29 and this IPython 8.12.x will now only receive bugfixes.
+
+
+ - :ghpull:`14004` Fix a bug introduced in IPython 8.12 that crash when
+   inspecting some docstrings.
+ - :ghpull:`14010` Fix fast traceback code that was not working in some case.
+ - :ghpull:`14014` Fix ``%page`` magic broken in some case.
+ - :ghpull:`14026`, :ghpull:`14027` Tweak default shortcut with respect to
+   autosuggestions.
+ - :ghpull:`14033` add back the ability to use ``.get()`` on OInfo object for
+   backward compatibility with h5py (this will be re-deprecated later, and h5py
+   will also get a fix).
+
+As usual you can find the full list of PRs on GitHub under `the 8.12.1 milestone
+<https://github.com/ipython/ipython/milestone/116?closed=1>`__.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.12.0:
+
+IPython 8.12
+============
+
+Hopefully slightly early release for IPython 8.12. Last Thursday of the month,
+even if I guess it's likely already Friday somewhere in the pacific ocean.
+
+A number of PRs and bug fixes this month with close to 20 PRs merged !
+
+
+The IPython repo reached :ghpull:`14000` !! Actually the PR that create those exact release
+note is :ghpull:`14000`. Ok, more issues and PR is not always better, and I'd
+love to have more time to close issues and Pull Requests.
+
+Let's note that in less than 2 month JupyterCon is back, in Paris please visit
+`jupytercon.com <https://jupytercon.com>`__, and looking forward to see you
+there.
+
+Packagers should take note that ``typing_extension`` is now a mandatory dependency
+for Python versions ``<3.10``.
+
+
+
+Let's note also that according to `NEP29
+<https://numpy.org/neps/nep-0029-deprecation_policy.html>`__, It is soon time to
+stop support for Python 3.8 that will be release more than 3 and 1/2 years ago::
+
+    On Apr 14, 2023 drop support for Python 3.8 (initially released on Oct 14, 2019)
+
+Thus I am likely to stop advertising support for Python 3.8 in the next
+release at the end of April.
+
+
+Here are some miscellaneous updates of interest:
+
+ - :ghpull:`13957` brings updates to the Qt integration, particularly for Qt6.
+ - :ghpull:`13960` fixes the %debug magic command to give access to the local
+   scope.
+ - :ghpull:`13964` fixes some crashes with the new fast traceback code. Note that
+   there are still some issues with the fast traceback code, and I a, likely
+   to fix and tweak behavior.
+ - :ghpull:`13973` We are slowly migrating IPython internals to use proper type
+   objects/dataclasses instead of dictionaries to allow static typing checks.
+   These are technically public API and could lead to breakage, so please let us
+   know if that's the case and I'll mitigate.
+ - :ghpull:`13990`, :ghpull:`13991`, :ghpull:`13994` all improve keybinding and
+   shortcut configurability.
+
+As usual you can find the full list of PRs on GitHub under `the 8.12 milestone
+<https://github.com/ipython/ipython/milestone/114?closed=1>`__.
+
+We want to thank the D.E. Shaw group for requesting and sponsoring the work on
+the following big feature. We had productive discussions on how to best expose
+this feature
+
+Dynamic documentation dispatch
+------------------------------
+
+We are experimenting with dynamic documentation dispatch for object attribute.
+See :ghissue:`13860`. The goal is to allow object to define documentation for
+their attributes, properties, even when those are dynamically defined with
+`__getattr__`.
+
+In particular when those objects are base types it can be useful to show the
+documentation
+
+
+.. code-block:: ipython
+
+
+    In [1]: class User:
+       ...:
+       ...:     __custom_documentations__ = {
+       ...:         "first": "The first name of the user.",
+       ...:         "last": "The last name of the user.",
+       ...:     }
+       ...:
+       ...:     first:str
+       ...:     last:str
+       ...:
+       ...:     def __init__(self, first, last):
+       ...:         self.first = first
+       ...:         self.last = last
+       ...:
+       ...:     @property
+       ...:     def full(self):
+       ...:         """`self.first` and `self.last` joined by a space."""
+       ...:         return self.first + " " + self.last
+       ...:
+       ...:
+       ...: user = Person('Jane', 'Doe')
+
+    In [2]: user.first?
+    Type:            str
+    String form:     Jane
+    Length:          4
+    Docstring:       the first name of a the person object, a str
+    Class docstring:
+    ....
+
+    In [3]: user.last?
+    Type:            str
+    String form:     Doe
+    Length:          3
+    Docstring:       the last name, also a str
+    ...
+
+
+We can see here the symmetry with IPython looking for the docstring on the
+properties:
+
+.. code-block:: ipython
+
+
+    In [4]: user.full?
+    HERE
+    Type:        property
+    String form: <property object at 0x102bb15d0>
+    Docstring:   first and last join by a space
+
+
+Note that while in the above example we use a static dictionary, libraries may
+decide to use a custom object that define ``__getitem__``, we caution against
+using objects that would trigger computation to show documentation, but it is
+sometime preferable for highly dynamic code that for example export an API as
+object.
+
+
+
+.. _version 8.11.0:
+
+IPython 8.11
+============
+
+Back on almost regular monthly schedule for IPython with end-of-month
+really-late-Friday release to make sure some bugs are properly fixed.
+Small addition of with a few new features, bugfix and UX improvements.
+
+This is a non-exhaustive list, but among other you will find:
+
+Faster Traceback Highlighting
+-----------------------------
+
+Resurrection of pre-IPython-8 traceback highlighting code.
+
+Really long and complicated files were slow to highlight in traceback with
+IPython 8 despite upstream improvement that make many case better. Therefore
+starting with IPython 8.11 when one of the highlighted file is more than 10 000
+line long by default, we'll fallback to a faster path that does not have all the
+features of highlighting failing AST nodes.
+
+This can be configures by setting the value of
+``IPython.code.ultratb.FAST_THRESHOLD`` to an arbitrary low or large value.
+
+
+Autoreload verbosity
+--------------------
+
+We introduce more descriptive names for the ``%autoreload`` parameter:
+
+- ``%autoreload now`` (also ``%autoreload``) - perform autoreload immediately.
+- ``%autoreload off`` (also ``%autoreload 0``) - turn off autoreload.
+- ``%autoreload explicit`` (also ``%autoreload 1``) - turn on autoreload only for modules
+  whitelisted by ``%aimport`` statements.
+- ``%autoreload all`` (also ``%autoreload 2``) - turn on autoreload for all modules except those
+  blacklisted by ``%aimport`` statements.
+- ``%autoreload complete`` (also ``%autoreload 3``) - all the features of ``all`` but also adding new
+  objects from the imported modules (see
+  IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects).
+
+The original designations (e.g. "2") still work, and these new ones are case-insensitive.
+
+Additionally, the option ``--print`` or ``-p`` can be added to the line to print the names of
+modules being reloaded. Similarly, ``--log`` or ``-l`` will output the names to the logger at INFO
+level. Both can be used simultaneously.
+
+The parsing logic for ``%aimport`` is now improved such that modules can be whitelisted and
+blacklisted in the same line, e.g. it's now possible to call ``%aimport os, -math`` to include
+``os`` for ``%autoreload explicit`` and exclude ``math`` for modes ``all`` and ``complete``.
+
+Terminal shortcuts customization
+--------------------------------
+
+Previously modifying shortcuts was only possible by hooking into startup files
+and practically limited to adding new shortcuts or removing all shortcuts bound
+to a specific key. This release enables users to override existing terminal
+shortcuts, disable them or add new keybindings.
+
+For example, to set the :kbd:`right` to accept a single character of auto-suggestion
+you could use::
+
+    my_shortcuts = [
+        {
+            "command": "IPython:auto_suggest.accept_character",
+            "new_keys": ["right"]
+        }
+    ]
+    %config TerminalInteractiveShell.shortcuts = my_shortcuts
+
+You can learn more in :std:configtrait:`TerminalInteractiveShell.shortcuts`
+configuration reference.
+
+Miscellaneous
+-------------
+
+ - ``%gui`` should now support PySide6. :ghpull:`13864`
+ - Cli shortcuts can now be configured :ghpull:`13928`, see above.
+   (note that there might be an issue with prompt_toolkit 3.0.37 and shortcut configuration).
+
+ - Capture output should now respect ``;`` semicolon to suppress output.
+   :ghpull:`13940`
+ - Base64 encoded images (in jupyter frontend), will not have trailing newlines.
+   :ghpull:`13941`
+
+As usual you can find the full list of PRs on GitHub under `the 8.11 milestone
+<https://github.com/ipython/ipython/milestone/113?closed=1>`__.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.10.0:
+
+IPython 8.10
+============
+
+Out of schedule release of IPython with minor fixes to patch a potential CVE-2023-24816.
+This is a really low severity CVE that you most likely are not affected by unless:
+
+ - You are on windows.
+ - You have a custom build of Python without ``_ctypes``
+ - You cd or start IPython or Jupyter in untrusted directory which names may be
+   valid shell commands.
+
+You can read more on `the advisory
+<https://github.com/ipython/ipython/security/advisories/GHSA-29gw-9793-fvw7>`__.
+
+In addition to fixing this CVE we also fix a couple of outstanding bugs and issues.
+
+As usual you can find the full list of PRs on GitHub under `the 8.10 milestone
+<https://github.com/ipython/ipython/milestone/112?closed=1>`__.
+
+In Particular:
+
+ - bump minimum numpy to `>=1.21` version following NEP29. :ghpull:`13930`
+ - fix for compatibility with MyPy 1.0. :ghpull:`13933`
+ - fix nbgrader stalling when IPython's ``showtraceback`` function is
+   monkeypatched. :ghpull:`13934`
+
+
+
+As this release also contains those minimal changes in addition to fixing the
+CVE I decided to bump the minor version anyway.
+
+This will not affect the normal release schedule, so IPython 8.11 is due in
+about 2 weeks.
+
+.. _version 8.9.0:
+
+IPython 8.9.0
+=============
+
+Second release of IPython in 2023, last Friday of the month, we are back on
+track. This is a small release with a few bug-fixes, and improvements, mostly
+with respect to terminal shortcuts.
+
+
+The biggest improvement for 8.9 is a drastic amelioration of the
+auto-suggestions sponsored by D.E. Shaw and implemented by the more and more
+active contributor `@krassowski <https://github.com/krassowski>`__.
+
+- ``right`` accepts a single character from suggestion
+- ``ctrl+right`` accepts a semantic token (macos default shortcuts take
+  precedence and need to be disabled to make this work)
+- ``backspace`` deletes a character and resumes hinting autosuggestions
+- ``ctrl-left`` accepts suggestion and moves cursor left one character.
+- ``backspace`` deletes a character and resumes hinting autosuggestions
+- ``down`` moves to suggestion to later in history when no lines are present below the cursors.
+- ``up`` moves to suggestion from earlier in history when no lines are present above the cursor.
+
+This is best described by the Gif posted by `@krassowski
+<https://github.com/krassowski>`__, and in the PR itself :ghpull:`13888`.
+
+.. image:: ../_images/autosuggest.gif
+
+Please report any feedback in order for us to improve the user experience.
+In particular we are also working on making the shortcuts configurable.
+
+If you are interested in better terminal shortcuts, I also invite you to
+participate in issue `13879
+<https://github.com/ipython/ipython/issues/13879>`__.
+
+
+As we follow `NEP29
+<https://numpy.org/neps/nep-0029-deprecation_policy.html>`__, next version of
+IPython will officially stop supporting numpy 1.20, and will stop supporting
+Python 3.8 after April release.
+
+As usual you can find the full list of PRs on GitHub under `the 8.9 milestone
+<https://github.com/ipython/ipython/milestone/111?closed=1>`__.
+
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.8.0:
+
+IPython 8.8.0
+=============
+
+First release of IPython in 2023 as there was no release at the end of
+December.
+
+This is an unusually big release (relatively speaking) with more than 15 Pull
+Requests merged.
+
+Of particular interest are:
+
+ - :ghpull:`13852` that replaces the greedy completer and improves
+   completion, in particular for dictionary keys.
+ - :ghpull:`13858` that adds ``py.typed`` to ``setup.cfg`` to make sure it is
+   bundled in wheels.
+ - :ghpull:`13869` that implements tab completions for IPython options in the
+   shell when using `argcomplete <https://github.com/kislyuk/argcomplete>`. I
+   believe this also needs a recent version of Traitlets.
+ - :ghpull:`13865` makes the ``inspector`` class of `InteractiveShell`
+   configurable.
+ - :ghpull:`13880` that removes minor-version entrypoints as the minor version
+   entry points that would be included in the wheel would be the one of the
+   Python version that was used to build the ``whl`` file.
+
+In no particular order, the rest of the changes update the test suite to be
+compatible with Pygments 2.14, various docfixes, testing on more recent python
+versions and various updates.
+
+As usual you can find the full list of PRs on GitHub under `the 8.8 milestone
+<https://github.com/ipython/ipython/milestone/110>`__.
+
+Many thanks to @krassowski for the many PRs and @jasongrout for reviewing and
+merging contributions.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.7.0:
+
+IPython 8.7.0
+=============
+
+
+Small release of IPython with a couple of bug fixes and new features for this
+month. Next month is the end of year, it is unclear if there will be a release
+close to the new year's eve, or if the next release will be at the end of January.
+
+Here are a few of the relevant fixes,
+as usual you can find the full list of PRs on GitHub under `the 8.7 milestone
+<https://github.com/ipython/ipython/pulls?q=milestone%3A8.7>`__.
+
+
+   - :ghpull:`13834` bump the minimum prompt toolkit to 3.0.11.
+   - IPython shipped with the ``py.typed`` marker now, and we are progressively
+     adding more types. :ghpull:`13831`
+   - :ghpull:`13817` add configuration of code blacks formatting.
+
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.6.0:
+
+IPython 8.6.0
+=============
+
+Back to a more regular release schedule (at least I try), as Friday is
+already over by more than 24h hours. This is a slightly bigger release with a
+few new features that contain no less than 25 PRs.
+
+We'll notably found a couple of non negligible changes:
+
+The ``install_ext`` and related functions have been removed after being
+deprecated for years. You can use pip to install extensions. ``pip`` did not
+exist when ``install_ext`` was introduced. You can still load local extensions
+without installing them. Just set your ``sys.path`` for example. :ghpull:`13744`
+
+IPython now has extra entry points that use the major *and minor* version of
+python. For some of you this means that you can do a quick ``ipython3.10`` to
+launch IPython from the Python 3.10 interpreter, while still using Python 3.11
+as your main Python. :ghpull:`13743`
+
+The completer matcher API has been improved. See :ghpull:`13745`. This should
+improve the type inference and improve dict keys completions in many use case.
+Thanks ``@krassowski`` for all the work, and the D.E. Shaw group for sponsoring
+it.
+
+The color of error nodes in tracebacks can now be customized. See
+:ghpull:`13756`. This is a private attribute until someone finds the time to
+properly add a configuration option. Note that with Python 3.11 that also shows
+the relevant nodes in traceback, it would be good to leverage this information
+(plus the "did you mean" info added on attribute errors). But that's likely work
+I won't have time to do before long, so contributions welcome.
+
+As we follow NEP 29, we removed support for numpy 1.19 :ghpull:`13760`.
+
+
+The ``open()`` function present in the user namespace by default will now refuse
+to open the file descriptors 0,1,2 (stdin, out, err), to avoid crashing IPython.
+This mostly occurs in teaching context when incorrect values get passed around.
+
+
+The ``?``, ``??``, and corresponding ``pinfo``, ``pinfo2`` magics can now find
+objects inside arrays. That is to say, the following now works::
+
+
+   >>> def my_func(*arg, **kwargs):pass
+   >>> container = [my_func]
+   >>> container[0]?
+
+
+If ``container`` define a custom ``getitem``, this __will__ trigger the custom
+method. So don't put side effects in your ``getitems``. Thanks to the D.E. Shaw
+group for the request and sponsoring the work.
+
+
+As usual you can find the full list of PRs on GitHub under `the 8.6 milestone
+<https://github.com/ipython/ipython/pulls?q=milestone%3A8.6>`__.
+
+Thanks to all hacktoberfest contributors, please contribute to
+`closember.org <https://closember.org/>`__.
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.5.0:
+
+IPython 8.5.0
+=============
+
+First release since a couple of month due to various reasons and timing preventing
+me for sticking to the usual monthly release the last Friday of each month. This
+is of non negligible size as it has more than two dozen PRs with various fixes
+an bug fixes.
+
+Many thanks to everybody who contributed PRs for your patience in review and
+merges.
+
+Here is a non-exhaustive list of changes that have been implemented for IPython
+8.5.0. As usual you can find the full list of issues and PRs tagged with `the
+8.5 milestone
+<https://github.com/ipython/ipython/pulls?q=is%3Aclosed+milestone%3A8.5+>`__.
+
+ - Added a shortcut for accepting auto suggestion. The End key shortcut for
+   accepting auto-suggestion This binding works in Vi mode too, provided
+   ``TerminalInteractiveShell.emacs_bindings_in_vi_insert_mode`` is set to be
+   ``True`` :ghpull:`13566`.
+
+ - No popup in window for latex generation when generating latex (e.g. via
+   `_latex_repr_`) no popup window is shows under Windows. :ghpull:`13679`
+
+ - Fixed error raised when attempting to tab-complete an input string with
+   consecutive periods or forward slashes (such as "file:///var/log/...").
+   :ghpull:`13675`
+
+ - Relative filenames in Latex rendering :
+   The `latex_to_png_dvipng` command internally generates input and output file
+   arguments to `latex` and `dvipis`. These arguments are now generated as
+   relative files to the current working directory instead of absolute file
+   paths. This solves a problem where the current working directory contains
+   characters that are not handled properly by `latex` and `dvips`. There are
+   no changes to the user API. :ghpull:`13680`
+
+ - Stripping decorators bug: Fixed bug which meant that ipython code blocks in
+   restructured text documents executed with the ipython-sphinx extension
+   skipped any lines of code containing python decorators. :ghpull:`13612`
+
+ - Allow some modules with frozen dataclasses to be reloaded. :ghpull:`13732`
+ - Fix paste magic on wayland. :ghpull:`13671`
+ - show maxlen in deque's repr. :ghpull:`13648`
+
+Restore line numbers for Input
+------------------------------
+
+Line number information in tracebacks from input are restored.
+Line numbers from input were removed during the transition to v8 enhanced traceback reporting.
+
+So, instead of::
+
+    ---------------------------------------------------------------------------
+    ZeroDivisionError                         Traceback (most recent call last)
+    Input In [3], in <cell line: 1>()
+    ----> 1 myfunc(2)
+
+    Input In [2], in myfunc(z)
+          1 def myfunc(z):
+    ----> 2     foo.boo(z-1)
+
+    File ~/code/python/ipython/foo.py:3, in boo(x)
+          2 def boo(x):
+    ----> 3     return 1/(1-x)
+
+    ZeroDivisionError: division by zero
+
+The error traceback now looks like::
+
+      ---------------------------------------------------------------------------
+      ZeroDivisionError                         Traceback (most recent call last)
+      Cell In [3], line 1
+      ----> 1 myfunc(2)
+
+      Cell In [2], line 2, in myfunc(z)
+            1 def myfunc(z):
+      ----> 2     foo.boo(z-1)
+
+      File ~/code/python/ipython/foo.py:3, in boo(x)
+            2 def boo(x):
+      ----> 3     return 1/(1-x)
+
+      ZeroDivisionError: division by zero
+
+or, with xmode=Plain::
+
+    Traceback (most recent call last):
+      Cell In [12], line 1
+        myfunc(2)
+      Cell In [6], line 2 in myfunc
+        foo.boo(z-1)
+      File ~/code/python/ipython/foo.py:3 in boo
+        return 1/(1-x)
+    ZeroDivisionError: division by zero
+
+:ghpull:`13560`
+
+New setting to silence warning if working inside a virtual environment
+----------------------------------------------------------------------
+
+Previously, when starting IPython in a virtual environment without IPython installed (so IPython from the global environment is used), the following warning was printed:
+
+    Attempting to work in a virtualenv. If you encounter problems, please install IPython inside the virtualenv.
+
+This warning can be permanently silenced by setting ``c.InteractiveShell.warn_venv`` to ``False`` (the default is ``True``).
+
+:ghpull:`13706`
+
+-------
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.4.0:
+
+IPython 8.4.0
+=============
+
+As for 7.34, this version contains a single fix:  fix uncaught BdbQuit exceptions on ipdb
+exit :ghpull:`13668`, and a single typo fix in documentation: :ghpull:`13682`
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+
+.. _version 8.3.0:
+
+IPython 8.3.0
+=============
+
+ - :ghpull:`13625`, using ``?``, ``??``, ``*?`` will not call
+   ``set_next_input`` as most frontend allow proper multiline editing and it was
+   causing issues for many users of multi-cell frontends. This has been backported to 7.33
+
+
+ - :ghpull:`13600`, ``pre_run_*``-hooks will now have a ``cell_id`` attribute on
+   the info object when frontend provides it. This has been backported to 7.33
+
+ - :ghpull:`13624`, fixed :kbd:`End` key being broken after accepting an
+   auto-suggestion.
+
+ - :ghpull:`13657` fixed an issue where history from different sessions would be mixed.
+
+.. _version 8.2.0:
+
+IPython 8.2.0
+=============
+
+IPython 8.2 mostly bring bugfixes to IPython.
+
+ - Auto-suggestion can now be elected with the ``end`` key. :ghpull:`13566`
+ - Some traceback issues with ``assert etb is not None`` have been fixed. :ghpull:`13588`
+ - History is now pulled from the sqitel database and not from in-memory.
+   In particular when using the ``%paste`` magic, the content of the pasted text will
+   be part of the history and not the verbatim text ``%paste`` anymore. :ghpull:`13592`
+ - Fix ``Ctrl-\\`` exit cleanup :ghpull:`13603`
+ - Fixes to ``ultratb`` ipdb support when used outside of IPython. :ghpull:`13498`
+
+
+I am still trying to fix and investigate :ghissue:`13598`, which seems to be
+random, and would appreciate help if you find a reproducible minimal case. I've
+tried to make various changes to the codebase to mitigate it, but a proper fix
+will be difficult without understanding the cause.
+
+
+All the issues on pull-requests for this release can be found in the `8.2
+milestone. <https://github.com/ipython/ipython/milestone/100>`__ . And some
+documentation only PR can be found as part of the `7.33 milestone
+<https://github.com/ipython/ipython/milestone/101>`__ (currently not released).
+
+Thanks to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries.
+
+.. _version 8.1.1:
+
+IPython 8.1.1
+=============
+
+Fix an issue with virtualenv and Python 3.8 introduced in 8.1
+
+Revert :ghpull:`13537` (fix an issue with symlinks in virtualenv) that raises an
+error in Python 3.8, and fixed in a different way in :ghpull:`13559`.
+
+.. _version 8.1:
+
+IPython 8.1.0
+=============
+
+IPython 8.1 is the first minor release after 8.0 and fixes a number of bugs and
+updates a few behaviors that were problematic with the 8.0 as with many new major
+release.
+
+Note that beyond the changes listed here, IPython 8.1.0 also contains all the
+features listed in :ref:`version 7.32`.
+
+ - Misc and multiple fixes around quotation auto-closing. It is now disabled by
+   default. Run with ``TerminalInteractiveShell.auto_match=True`` to re-enabled
+ - Require pygments>=2.4.0 :ghpull:`13459`, this was implicit in the code, but
+   is now explicit in ``setup.cfg``/``setup.py``
+ - Docs improvement of ``core.magic_arguments`` examples. :ghpull:`13433`
+ - Multi-line edit executes too early with await. :ghpull:`13424`
+
+ - ``black``  is back as an optional dependency, and autoformatting disabled by
+   default until some fixes are implemented (black improperly reformat magics).
+   :ghpull:`13471` Additionally the ability to use ``yapf`` as a code
+   reformatter has been added :ghpull:`13528` . You can use
+   ``TerminalInteractiveShell.autoformatter="black"``,
+   ``TerminalInteractiveShell.autoformatter="yapf"`` to re-enable auto formatting
+   with black, or switch to yapf.
+
+ - Fix and issue where ``display`` was not defined.
+
+ - Auto suggestions are now configurable. Currently only
+   ``AutoSuggestFromHistory`` (default) and ``None``. new provider contribution
+   welcomed. :ghpull:`13475`
+
+ - multiple packaging/testing improvement to simplify downstream packaging
+   (xfail with reasons, try to not access network...).
+
+ - Update deprecation. ``InteractiveShell.magic`` internal method has been
+   deprecated for many years but did not emit a warning until now.
+
+ - internal ``appended_to_syspath`` context manager has been deprecated.
+
+ - fix an issue with symlinks in virtualenv :ghpull:`13537` (Reverted in 8.1.1)
+
+ - Fix an issue with vim mode, where cursor would not be reset on exit :ghpull:`13472`
+
+ - ipython directive now remove only known pseudo-decorators :ghpull:`13532`
+
+ - ``IPython/lib/security`` which used to be used for jupyter notebook has been
+   removed.
+
+ - Fix an issue where ``async with`` would execute on new lines. :ghpull:`13436`
+
+
+We want to remind users that IPython is part of the Jupyter organisations, and
+thus governed by a Code of Conduct. Some of the behavior we have seen on GitHub is not acceptable.
+Abuse and non-respectful comments on discussion will not be tolerated.
+
+Many thanks to all the contributors to this release, many of the above fixed issues and
+new features were done by first time contributors, showing there is still
+plenty of easy contribution possible in IPython
+. You can find all individual contributions
+to this milestone `on github <https://github.com/ipython/ipython/milestone/91>`__.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
+work on IPython and related libraries. In particular the Lazy autoloading of
+magics that you will find described in the 7.32 release notes.
+
+
+.. _version 8.0.1:
+
+IPython 8.0.1 (CVE-2022-21699)
+==============================
+
+IPython 8.0.1, 7.31.1 and 5.11 are security releases that change some default
+values in order to prevent potential Execution with Unnecessary Privileges.
+
+Almost all version of IPython looks for configuration and profiles in current
+working directory. Since IPython was developed before pip and environments
+existed it was used a convenient way to load code/packages in a project
+dependent way.
+
+In 2022, it is not necessary anymore, and can lead to confusing behavior where
+for example cloning a repository and starting IPython or loading a notebook from
+any Jupyter-Compatible interface that has ipython set as a kernel can lead to
+code execution.
+
+
+I did not find any standard way for packaged to advertise CVEs they fix, I'm
+thus trying to add a ``__patched_cves__`` attribute to the IPython module that
+list the CVEs that should have been fixed. This attribute is informational only
+as if a executable has a flaw, this value can always be changed by an attacker.
+
+.. code::
+
+    In [1]: import IPython
+
+    In [2]: IPython.__patched_cves__
+    Out[2]: {'CVE-2022-21699'}
+
+    In [3]: 'CVE-2022-21699' in IPython.__patched_cves__
+    Out[3]: True
+
+Thus starting with this version:
+
+ - The current working directory is not searched anymore for profiles or
+   configurations files.
+ - Added a ``__patched_cves__`` attribute (set of strings) to IPython module that contain
+   the list of fixed CVE. This is informational only.
+
+Further details can be read on the `GitHub Advisory <https://github.com/ipython/ipython/security/advisories/GHSA-pq7m-3gw7-gq5x>`__
+
+
+.. _version 8.0:
+
+IPython 8.0
+===========
+
+IPython 8.0 is bringing a large number of new features and improvements to both the
+user of the terminal and of the kernel via Jupyter. The removal of compatibility
+with an older version of Python is also the opportunity to do a couple of
+performance improvements in particular with respect to startup time.
+The 8.x branch started diverging from its predecessor around IPython 7.12
+(January 2020).
+
+This release contains 250+ pull requests, in addition to many of the features
+and backports that have made it to the 7.x branch. Please see the
+`8.0 milestone <https://github.com/ipython/ipython/milestone/73?closed=1>`__ for the full list of pull requests.
+
+Please feel free to send pull requests to update those notes after release,
+I have likely forgotten a few things reviewing 250+ PRs.
+
+Dependencies changes/downstream packaging
+-----------------------------------------
+
+Most of our building steps have been changed to be (mostly) declarative
+and follow PEP 517. We are trying to completely remove ``setup.py`` (:ghpull:`13238`) and are
+looking for help to do so.
+
+ - minimum supported ``traitlets`` version is now 5+
+ - we now require ``stack_data``
+ - minimal Python is now 3.8
+ - ``nose`` is not a testing requirement anymore
+ - ``pytest`` replaces nose.
+ - ``iptest``/``iptest3`` cli entrypoints do not exist anymore.
+ - the minimum officially ​supported ``numpy`` version has been bumped, but this should
+   not have much effect on packaging.
+
+
+Deprecation and removal
+-----------------------
+
+We removed almost all features, arguments, functions, and modules that were
+marked as deprecated between IPython 1.0 and 5.0. As a reminder, 5.0 was released
+in 2016, and 1.0 in 2013. Last release of the 5 branch was 5.10.0, in May 2020.
+The few remaining deprecated features we left have better deprecation warnings
+or have been turned into explicit errors for better error messages.
+
+I will use this occasion to add the following requests to anyone emitting a
+deprecation warning:
+
+ - Please add at least ``stacklevel=2`` so that the warning is emitted into the
+   caller context, and not the callee one.
+ - Please add **since which version** something is deprecated.
+
+As a side note, it is much easier to conditionally compare version
+numbers rather than using ``try/except`` when functionality changes with a version.
+
+I won't list all the removed features here, but modules like ``IPython.kernel``,
+which was just a shim module around ``ipykernel`` for the past 8 years, have been
+removed, and so many other similar things that pre-date the name **Jupyter**
+itself.
+
+We no longer need to add ``IPython.extensions`` to the PYTHONPATH because that is being
+handled by ``load_extension``.
+
+We are also removing ``Cythonmagic``, ``sympyprinting`` and ``rmagic`` as they are now in
+other packages and no longer need to be inside IPython.
+
+
+Documentation
+-------------
+
+The majority of our docstrings have now been reformatted and automatically fixed by
+the experimental `Vélin <https://pypi.org/project/velin/>`_ project to conform
+to numpydoc.
+
+Type annotations
+----------------
+
+While IPython itself is highly dynamic and can't be completely typed, many of
+the functions now have type annotations, and part of the codebase is now checked
+by mypy.
+
+
+Featured changes
+----------------
+
+Here is a features list of changes in IPython 8.0. This is of course non-exhaustive.
+Please note as well that many features have been added in the 7.x branch as well
+(and hence why you want to read the 7.x what's new notes), in particular
+features contributed by QuantStack (with respect to debugger protocol and Xeus
+Python), as well as many debugger features that I was pleased to implement as
+part of my work at QuanSight and sponsored by DE Shaw.
+
+Traceback improvements
+~~~~~~~~~~~~~~~~~~~~~~
+
+Previously, error tracebacks for errors happening in code cells were showing a
+hash, the one used for compiling the Python AST::
+
+    In [1]: def foo():
+    ...:     return 3 / 0
+    ...:
+
+    In [2]: foo()
+    ---------------------------------------------------------------------------
+    ZeroDivisionError                         Traceback (most recent call last)
+    <ipython-input-2-c19b6d9633cf> in <module>
+    ----> 1 foo()
+
+    <ipython-input-1-1595a74c32d5> in foo()
+        1 def foo():
+    ----> 2     return 3 / 0
+        3
+
+    ZeroDivisionError: division by zero
+
+The error traceback is now correctly formatted, showing the cell number in which the error happened::
+
+    In [1]: def foo():
+    ...:     return 3 / 0
+    ...:
+
+    Input In [2]: foo()
+    ---------------------------------------------------------------------------
+    ZeroDivisionError                         Traceback (most recent call last)
+    input In [2], in <module>
+    ----> 1 foo()
+
+    Input In [1], in foo()
+        1 def foo():
+    ----> 2     return 3 / 0
+
+    ZeroDivisionError: division by zero
+
+The ``stack_data`` package has been integrated, which provides smarter information in the traceback;
+in particular it will highlight the AST node where an error occurs which can help to quickly narrow down errors.
+
+For example in the following snippet::
+
+    def foo(i):
+        x = [[[0]]]
+        return x[0][i][0]
+
+
+    def bar():
+        return foo(0) + foo(
+            1
+        ) + foo(2)
+
+
+calling ``bar()`` would raise an ``IndexError`` on the return line of ``foo``,
+and IPython 8.0 is capable of telling you where the index error occurs::
+
+
+    IndexError
+    Input In [2], in <module>
+    ----> 1 bar()
+            ^^^^^
+
+    Input In [1], in bar()
+          6 def bar():
+    ----> 7     return foo(0) + foo(
+                                ^^^^
+          8         1
+             ^^^^^^^^
+          9     ) + foo(2)
+             ^^^^
+
+    Input In [1], in foo(i)
+          1 def foo(i):
+          2     x = [[[0]]]
+    ----> 3     return x[0][i][0]
+                       ^^^^^^^
+
+The corresponding locations marked here with ``^`` will show up highlighted in
+the terminal and notebooks.
+
+Finally, a colon ``::`` and line number is appended after a filename in
+traceback::
+
+
+    ZeroDivisionError               Traceback (most recent call last)
+    File ~/error.py:4, in <module>
+          1 def f():
+          2     1/0
+    ----> 4 f()
+
+    File ~/error.py:2, in f()
+          1 def f():
+    ----> 2     1/0
+
+Many terminals and editors have integrations enabling you to directly jump to the
+relevant file/line when this syntax is used, so this small addition may have a high
+impact on productivity.
+
+
+Autosuggestions
+~~~~~~~~~~~~~~~
+
+Autosuggestion is a very useful feature available in `fish <https://fishshell.com/>`__, `zsh <https://en.wikipedia.org/wiki/Z_shell>`__, and `prompt-toolkit <https://python-prompt-toolkit.readthedocs.io/en/master/pages/asking_for_input.html#auto-suggestion>`__.
+
+`Ptpython <https://github.com/prompt-toolkit/ptpython#ptpython>`__ allows users to enable this feature in
+`ptpython/config.py <https://github.com/prompt-toolkit/ptpython/blob/master/examples/ptpython_config/config.py#L90>`__.
+
+This feature allows users to accept autosuggestions with ctrl e, ctrl f,
+or right arrow as described below.
+
+1. Start ipython
+
+.. image:: ../_images/8.0/auto_suggest_1_prompt_no_text.png
+
+2. Run ``print("hello")``
+
+.. image:: ../_images/8.0/auto_suggest_2_print_hello_suggest.png
+
+3. start typing ``print`` again to see the autosuggestion
+
+.. image:: ../_images/8.0/auto_suggest_3_print_hello_suggest.png
+
+4. Press ``ctrl-f``, or ``ctrl-e``, or ``right-arrow`` to accept the suggestion
+
+.. image:: ../_images/8.0/auto_suggest_4_print_hello.png
+
+You can also complete word by word:
+
+1. Run ``def say_hello(): print("hello")``
+
+.. image:: ../_images/8.0/auto_suggest_second_prompt.png
+
+2. Start typing  the first letter if ``def`` to see the autosuggestion
+
+.. image:: ../_images/8.0/auto_suggest_d_phantom.png
+
+3. Press ``alt-f`` (or ``escape`` followed by ``f``), to accept the first word of the suggestion
+
+.. image:: ../_images/8.0/auto_suggest_def_phantom.png
+
+Importantly, this feature does not interfere with tab completion:
+
+1. After running ``def say_hello(): print("hello")``, press d
+
+.. image:: ../_images/8.0/auto_suggest_d_phantom.png
+
+2. Press Tab to start tab completion
+
+.. image:: ../_images/8.0/auto_suggest_d_completions.png
+
+3A. Press Tab again to select the first option
+
+.. image:: ../_images/8.0/auto_suggest_def_completions.png
+
+3B. Press ``alt f`` (``escape``, ``f``) to accept to accept the first word of the suggestion
+
+.. image:: ../_images/8.0/auto_suggest_def_phantom.png
+
+3C. Press ``ctrl-f`` or ``ctrl-e`` to accept the entire suggestion
+
+.. image:: ../_images/8.0/auto_suggest_match_parens.png
+
+
+Currently, autosuggestions are only shown in the emacs or vi insert editing modes:
+
+- The ctrl e, ctrl f, and alt f shortcuts work by default in emacs mode.
+- To use these shortcuts in vi insert mode, you will have to create `custom keybindings in your config.py <https://github.com/mskar/setup/commit/2892fcee46f9f80ef7788f0749edc99daccc52f4/>`__.
+
+
+Show pinfo information in ipdb using "?" and "??"
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In IPDB, it is now possible to show the information about an object using "?"
+and "??", in much the same way that it can be done when using the IPython prompt::
+
+    ipdb> partial?
+    Init signature: partial(self, /, *args, **kwargs)
+    Docstring:
+    partial(func, *args, **keywords) - new function with partial application
+    of the given arguments and keywords.
+    File:           ~/.pyenv/versions/3.8.6/lib/python3.8/functools.py
+    Type:           type
+    Subclasses:
+
+Previously, ``pinfo`` or ``pinfo2`` command had to be used for this purpose.
+
+
+Autoreload 3 feature
+~~~~~~~~~~~~~~~~~~~~
+
+Example: When an IPython session is run with the 'autoreload' extension loaded,
+you will now have the option '3' to select, which means the following:
+
+    1. replicate all functionality from option 2
+    2. autoload all new funcs/classes/enums/globals from the module when they are added
+    3. autoload all newly imported funcs/classes/enums/globals from external modules
+
+Try ``%autoreload 3`` in an IPython session after running ``%load_ext autoreload``.
+
+For more information please see the following unit test : ``extensions/tests/test_autoreload.py:test_autoload_newly_added_objects``
+
+Auto formatting with black in the CLI
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This feature was present in 7.x, but disabled by default.
+
+In 8.0, input was automatically reformatted with Black when black was installed.
+This feature has been reverted for the time being.
+You can re-enable it by setting ``TerminalInteractiveShell.autoformatter`` to ``"black"``
+
+History Range Glob feature
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Previously, when using ``%history``, users could specify either
+a range of sessions and lines, for example:
+
+.. code-block:: python
+
+   ~8/1-~6/5   # see history from the first line of 8 sessions ago,
+               # to the fifth line of 6 sessions ago.``
+
+Or users could specify a glob pattern:
+
+.. code-block:: python
+
+   -g <pattern>  # glob ALL history for the specified pattern.
+
+However users could *not* specify both.
+
+If a user *did* specify both a range and a glob pattern,
+then the glob pattern would be used (globbing *all* history) *and the range would be ignored*.
+
+With this enhancement, if a user specifies both a range and a glob pattern, then the glob pattern will be applied to the specified range of history.
+
+Don't start a multi-line cell with sunken parenthesis
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+From now on, IPython will not ask for the next line of input when given a single
+line with more closing than opening brackets. For example, this means that if
+you (mis)type ``]]`` instead of ``[]``, a ``SyntaxError`` will show up, instead of
+the ``...:`` prompt continuation.
+
+IPython shell for ipdb interact
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ipdb ``interact`` starts an IPython shell instead of Python's built-in ``code.interact()``.
+
+Automatic Vi prompt stripping
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When pasting code into IPython, it will strip the leading prompt characters if
+there are any. For example, you can paste the following code into the console -
+it will still work, even though each line is prefixed with prompts (``In``,
+``Out``)::
+
+    In [1]: 2 * 2 == 4
+    Out[1]: True
+
+    In [2]: print("This still works as pasted")
+
+
+Previously, this was not the case for the Vi-mode prompts::
+
+    In [1]: [ins] In [13]: 2 * 2 == 4
+       ...: Out[13]: True
+       ...:
+      File "<ipython-input-1-727bb88eaf33>", line 1
+        [ins] In [13]: 2 * 2 == 4
+              ^
+    SyntaxError: invalid syntax
+
+This is now fixed, and Vi prompt prefixes - ``[ins]`` and ``[nav]`` -  are
+skipped just as the normal ``In`` would be.
+
+IPython shell can be started in the Vi mode using ``ipython --TerminalInteractiveShell.editing_mode=vi``,
+You should be able to change mode dynamically with ``%config TerminalInteractiveShell.editing_mode='vi'``
+
+Empty History Ranges
+~~~~~~~~~~~~~~~~~~~~
+
+A number of magics that take history ranges can now be used with an empty
+range. These magics are:
+
+ * ``%save``
+ * ``%load``
+ * ``%pastebin``
+ * ``%pycat``
+
+Using them this way will make them take the history of the current session up
+to the point of the magic call (such that the magic itself will not be
+included).
+
+Therefore it is now possible to save the whole history to a file using
+``%save <filename>``, load and edit it using ``%load`` (makes for a nice usage
+when followed with :kbd:`F2`), send it to `dpaste.org <http://dpast.org>`_ using
+``%pastebin``, or view the whole thing syntax-highlighted with a single
+``%pycat``.
+
+
+Windows timing implementation: Switch to process_time
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Timing on Windows, for example with ``%%time``,  was changed from being based on ``time.perf_counter``
+(which counted time even when the process was sleeping) to being based on ``time.process_time`` instead
+(which only counts CPU time). This brings it closer to the behavior on Linux. See :ghpull:`12984`.
+
+Miscellaneous
+~~~~~~~~~~~~~
+ - Non-text formatters are not disabled in the terminal, which should simplify
+   writing extensions displaying images or other mimetypes in supporting terminals.
+   :ghpull:`12315`
+ - It is now possible to automatically insert matching brackets in Terminal IPython using the
+   ``TerminalInteractiveShell.auto_match=True`` option. :ghpull:`12586`
+ - We are thinking of deprecating the current ``%%javascript`` magic in favor of a better replacement. See :ghpull:`13376`.
+ - ``~`` is now expanded when part of a path in most magics :ghpull:`13385`
+ - ``%/%%timeit`` magic now adds a comma every thousands to make reading a long number easier :ghpull:`13379`
+ - ``"info"`` messages can now be customised to hide some fields :ghpull:`13343`
+ - ``collections.UserList`` now pretty-prints :ghpull:`13320`
+ - The debugger now has a persistent history, which should make it less
+   annoying to retype commands :ghpull:`13246`
+ - ``!pip`` ``!conda`` ``!cd`` or ``!ls`` are likely doing the wrong thing. We
+   now warn users if they use one of those commands. :ghpull:`12954`
+ - Make ``%precision`` work for ``numpy.float64`` type :ghpull:`12902`
+
+Re-added support for XDG config directories
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+XDG support through the years comes and goes. There is a tension between having
+an identical location for configuration in all platforms versus having simple instructions.
+After initial failures a couple of years ago, IPython was modified to automatically migrate XDG
+config files back into ``~/.ipython``. That migration code has now been removed.
+IPython now checks the XDG locations, so if you _manually_ move your config
+files to your preferred location, IPython will not move them back.
+
+
+Preparing for Python 3.10
+-------------------------
+
+To prepare for Python 3.10, we have started working on removing reliance and
+any dependency that is not compatible with Python 3.10. This includes migrating our
+test suite to pytest and starting to remove nose. This also means that the
+``iptest`` command is now gone and all testing is via pytest.
+
+This was in large part thanks to the NumFOCUS Small Developer grant, which enabled us to
+allocate \$4000 to hire `Nikita Kniazev (@Kojoley) <https://github.com/Kojoley>`_,
+who did a fantastic job at updating our code base, migrating to pytest, pushing
+our coverage, and fixing a large number of bugs. I highly recommend contacting
+them if you need help with C++ and Python projects.
+
+You can find all relevant issues and PRs with `the SDG 2021 tag <https://github.com/ipython/ipython/issues?q=label%3A%22Numfocus+SDG+2021%22+>`__
+
+Removing support for older Python versions
+------------------------------------------
+
+
+We are removing support for Python up through 3.7, allowing internal code to use the more
+efficient ``pathlib`` and to make better use of type annotations.
+
+.. image:: ../_images/8.0/pathlib_pathlib_everywhere.jpg
+   :alt: "Meme image of Toy Story with Woody and Buzz, with the text 'pathlib, pathlib everywhere'"
+
+
+We had about 34 PRs only to update some logic to update some functions from managing strings to
+using Pathlib.
+
+The completer has also seen significant updates and now makes use of newer Jedi APIs,
+offering faster and more reliable tab completion.
+
+Misc Statistics
+---------------
+
+Here are some numbers::
+
+    7.x: 296 files, 12561 blank lines, 20282 comments, 35142 line of code.
+    8.0: 252 files, 12053 blank lines, 19232 comments, 34505 line of code.
+
+    $ git diff --stat 7.x...master  | tail -1
+    340 files changed, 13399 insertions(+), 12421 deletions(-)
+
+We have commits from 162 authors, who contributed 1916 commits in 23 month, excluding merges (to not bias toward
+maintainers pushing buttons).::
+
+   $ git shortlog  -s --no-merges  7.x...master | sort -nr
+   535	Matthias Bussonnier
+    86	Nikita Kniazev
+    69	Blazej Michalik
+    49	Samuel Gaist
+    27	Itamar Turner-Trauring
+    18	Spas Kalaydzhisyki
+    17	Thomas Kluyver
+    17	Quentin Peter
+    17	James Morris
+    17	Artur Svistunov
+    15	Bart Skowron
+    14	Alex Hall
+    13	rushabh-v
+    13	Terry Davis
+    13	Benjamin Ragan-Kelley
+     8	martinRenou
+     8	farisachugthai
+     7	dswij
+     7	Gal B
+     7	Corentin Cadiou
+     6	yuji96
+     6	Martin Skarzynski
+     6	Justin Palmer
+     6	Daniel Goldfarb
+     6	Ben Greiner
+     5	Sammy Al Hashemi
+     5	Paul Ivanov
+     5	Inception95
+     5	Eyenpi
+     5	Douglas Blank
+     5	Coco Mishra
+     5	Bibo Hao
+     5	André A. Gomes
+     5	Ahmed Fasih
+     4	takuya fujiwara
+     4	palewire
+     4	Thomas A Caswell
+     4	Talley Lambert
+     4	Scott Sanderson
+     4	Ram Rachum
+     4	Nick Muoh
+     4	Nathan Goldbaum
+     4	Mithil Poojary
+     4	Michael T
+     4	Jakub Klus
+     4	Ian Castleden
+     4	Eli Rykoff
+     4	Ashwin Vishnu
+     3	谭�鼎
+     3	sleeping
+     3	Sylvain Corlay
+     3	Peter Corke
+     3	Paul Bissex
+     3	Matthew Feickert
+     3	Fernando Perez
+     3	Eric Wieser
+     3	Daniel Mietchen
+     3	Aditya Sathe
+     3	007vedant
+     2	rchiodo
+     2	nicolaslazo
+     2	luttik
+     2	gorogoroumaru
+     2	foobarbyte
+     2	bar-hen
+     2	Theo Ouzhinski
+     2	Strawkage
+     2	Samreen Zarroug
+     2	Pete Blois
+     2	Meysam Azad
+     2	Matthieu Ancellin
+     2	Mark Schmitz
+     2	Maor Kleinberger
+     2	MRCWirtz
+     2	Lumir Balhar
+     2	Julien Rabinow
+     2	Juan Luis Cano Rodríguez
+     2	Joyce Er
+     2	Jakub
+     2	Faris A Chugthai
+     2	Ethan Madden
+     2	Dimitri Papadopoulos
+     2	Diego Fernandez
+     2	Daniel Shimon
+     2	Coco Bennett
+     2	Carlos Cordoba
+     2	Boyuan Liu
+     2	BaoGiang HoangVu
+     2	Augusto
+     2	Arthur Svistunov
+     2	Arthur Moreira
+     2	Ali Nabipour
+     2	Adam Hackbarth
+     1	richard
+     1	linar-jether
+     1	lbennett
+     1	juacrumar
+     1	gpotter2
+     1	digitalvirtuoso
+     1	dalthviz
+     1	Yonatan Goldschmidt
+     1	Tomasz KÅ‚oczko
+     1	Tobias Bengfort
+     1	Timur Kushukov
+     1	Thomas
+     1	Snir Broshi
+     1	Shao Yang Hong
+     1	Sanjana-03
+     1	Romulo Filho
+     1	Rodolfo Carvalho
+     1	Richard Shadrach
+     1	Reilly Tucker Siemens
+     1	Rakessh Roshan
+     1	Piers Titus van der Torren
+     1	PhanatosZou
+     1	Pavel Safronov
+     1	Paulo S. Costa
+     1	Paul McCarthy
+     1	NotWearingPants
+     1	Naelson Douglas
+     1	Michael Tiemann
+     1	Matt Wozniski
+     1	Markus Wageringel
+     1	Marcus Wirtz
+     1	Marcio Mazza
+     1	Lumír 'Frenzy' Balhar
+     1	Lightyagami1
+     1	Leon Anavi
+     1	LeafyLi
+     1	L0uisJ0shua
+     1	Kyle Cutler
+     1	Krzysztof Cybulski
+     1	Kevin Kirsche
+     1	KIU Shueng Chuan
+     1	Jonathan Slenders
+     1	Jay Qi
+     1	Jake VanderPlas
+     1	Iwan Briquemont
+     1	Hussaina Begum Nandyala
+     1	Gordon Ball
+     1	Gabriel Simonetto
+     1	Frank Tobia
+     1	Erik
+     1	Elliott Sales de Andrade
+     1	Daniel Hahler
+     1	Dan Green-Leipciger
+     1	Dan Green
+     1	Damian Yurzola
+     1	Coon, Ethan T
+     1	Carol Willing
+     1	Brian Lee
+     1	Brendan Gerrity
+     1	Blake Griffin
+     1	Bastian Ebeling
+     1	Bartosz Telenczuk
+     1	Ankitsingh6299
+     1	Andrew Port
+     1	Andrew J. Hesford
+     1	Albert Zhang
+     1	Adam Johnson
+
+This does not, of course, represent non-code contributions, for which we are also grateful.
+
+
+API Changes using Frappuccino
+-----------------------------
+
+This is an experimental exhaustive API difference using `Frappuccino <https://pypi.org/project/frappuccino/>`_
+
+
+The following items are new in IPython 8.0 ::
+
+    + IPython.core.async_helpers.get_asyncio_loop()
+    + IPython.core.completer.Dict
+    + IPython.core.completer.Pattern
+    + IPython.core.completer.Sequence
+    + IPython.core.completer.__skip_doctest__
+    + IPython.core.debugger.Pdb.precmd(self, line)
+    + IPython.core.debugger.__skip_doctest__
+    + IPython.core.display.__getattr__(name)
+    + IPython.core.display.warn
+    + IPython.core.display_functions
+    + IPython.core.display_functions.DisplayHandle
+    + IPython.core.display_functions.DisplayHandle.display(self, obj, **kwargs)
+    + IPython.core.display_functions.DisplayHandle.update(self, obj, **kwargs)
+    + IPython.core.display_functions.__all__
+    + IPython.core.display_functions.__builtins__
+    + IPython.core.display_functions.__cached__
+    + IPython.core.display_functions.__doc__
+    + IPython.core.display_functions.__file__
+    + IPython.core.display_functions.__loader__
+    + IPython.core.display_functions.__name__
+    + IPython.core.display_functions.__package__
+    + IPython.core.display_functions.__spec__
+    + IPython.core.display_functions.b2a_hex
+    + IPython.core.display_functions.clear_output(wait=False)
+    + IPython.core.display_functions.display(*objs, include='None', exclude='None', metadata='None', transient='None', display_id='None', raw=False, clear=False, **kwargs)
+    + IPython.core.display_functions.publish_display_data(data, metadata='None', source='<deprecated>', *, transient='None', **kwargs)
+    + IPython.core.display_functions.update_display(obj, *, display_id, **kwargs)
+    + IPython.core.extensions.BUILTINS_EXTS
+    + IPython.core.inputtransformer2.has_sunken_brackets(tokens)
+    + IPython.core.interactiveshell.Callable
+    + IPython.core.interactiveshell.__annotations__
+    + IPython.core.ultratb.List
+    + IPython.core.ultratb.Tuple
+    + IPython.lib.pretty.CallExpression
+    + IPython.lib.pretty.CallExpression.factory(name)
+    + IPython.lib.pretty.RawStringLiteral
+    + IPython.lib.pretty.RawText
+    + IPython.terminal.debugger.TerminalPdb.do_interact(self, arg)
+    + IPython.terminal.embed.Set
+
+The following items have been removed (or moved to superclass)::
+
+    - IPython.core.application.BaseIPythonApplication.initialize_subcommand
+    - IPython.core.completer.Sentinel
+    - IPython.core.completer.skip_doctest
+    - IPython.core.debugger.Tracer
+    - IPython.core.display.DisplayHandle
+    - IPython.core.display.DisplayHandle.display
+    - IPython.core.display.DisplayHandle.update
+    - IPython.core.display.b2a_hex
+    - IPython.core.display.clear_output
+    - IPython.core.display.display
+    - IPython.core.display.publish_display_data
+    - IPython.core.display.update_display
+    - IPython.core.excolors.Deprec
+    - IPython.core.excolors.ExceptionColors
+    - IPython.core.history.warn
+    - IPython.core.hooks.late_startup_hook
+    - IPython.core.hooks.pre_run_code_hook
+    - IPython.core.hooks.shutdown_hook
+    - IPython.core.interactiveshell.InteractiveShell.init_deprecation_warnings
+    - IPython.core.interactiveshell.InteractiveShell.init_readline
+    - IPython.core.interactiveshell.InteractiveShell.write
+    - IPython.core.interactiveshell.InteractiveShell.write_err
+    - IPython.core.interactiveshell.get_default_colors
+    - IPython.core.interactiveshell.removed_co_newlocals
+    - IPython.core.magics.execution.ExecutionMagics.profile_missing_notice
+    - IPython.core.magics.script.PIPE
+    - IPython.core.prefilter.PrefilterManager.init_transformers
+    - IPython.core.release.classifiers
+    - IPython.core.release.description
+    - IPython.core.release.keywords
+    - IPython.core.release.long_description
+    - IPython.core.release.name
+    - IPython.core.release.platforms
+    - IPython.core.release.url
+    - IPython.core.ultratb.VerboseTB.format_records
+    - IPython.core.ultratb.find_recursion
+    - IPython.core.ultratb.findsource
+    - IPython.core.ultratb.fix_frame_records_filenames
+    - IPython.core.ultratb.inspect_error
+    - IPython.core.ultratb.is_recursion_error
+    - IPython.core.ultratb.with_patch_inspect
+    - IPython.external.__all__
+    - IPython.external.__builtins__
+    - IPython.external.__cached__
+    - IPython.external.__doc__
+    - IPython.external.__file__
+    - IPython.external.__loader__
+    - IPython.external.__name__
+    - IPython.external.__package__
+    - IPython.external.__path__
+    - IPython.external.__spec__
+    - IPython.kernel.KernelConnectionInfo
+    - IPython.kernel.__builtins__
+    - IPython.kernel.__cached__
+    - IPython.kernel.__warningregistry__
+    - IPython.kernel.pkg
+    - IPython.kernel.protocol_version
+    - IPython.kernel.protocol_version_info
+    - IPython.kernel.src
+    - IPython.kernel.version_info
+    - IPython.kernel.warn
+    - IPython.lib.backgroundjobs
+    - IPython.lib.backgroundjobs.BackgroundJobBase
+    - IPython.lib.backgroundjobs.BackgroundJobBase.run
+    - IPython.lib.backgroundjobs.BackgroundJobBase.traceback
+    - IPython.lib.backgroundjobs.BackgroundJobExpr
+    - IPython.lib.backgroundjobs.BackgroundJobExpr.call
+    - IPython.lib.backgroundjobs.BackgroundJobFunc
+    - IPython.lib.backgroundjobs.BackgroundJobFunc.call
+    - IPython.lib.backgroundjobs.BackgroundJobManager
+    - IPython.lib.backgroundjobs.BackgroundJobManager.flush
+    - IPython.lib.backgroundjobs.BackgroundJobManager.new
+    - IPython.lib.backgroundjobs.BackgroundJobManager.remove
+    - IPython.lib.backgroundjobs.BackgroundJobManager.result
+    - IPython.lib.backgroundjobs.BackgroundJobManager.status
+    - IPython.lib.backgroundjobs.BackgroundJobManager.traceback
+    - IPython.lib.backgroundjobs.__builtins__
+    - IPython.lib.backgroundjobs.__cached__
+    - IPython.lib.backgroundjobs.__doc__
+    - IPython.lib.backgroundjobs.__file__
+    - IPython.lib.backgroundjobs.__loader__
+    - IPython.lib.backgroundjobs.__name__
+    - IPython.lib.backgroundjobs.__package__
+    - IPython.lib.backgroundjobs.__spec__
+    - IPython.lib.kernel.__builtins__
+    - IPython.lib.kernel.__cached__
+    - IPython.lib.kernel.__doc__
+    - IPython.lib.kernel.__file__
+    - IPython.lib.kernel.__loader__
+    - IPython.lib.kernel.__name__
+    - IPython.lib.kernel.__package__
+    - IPython.lib.kernel.__spec__
+    - IPython.lib.kernel.__warningregistry__
+    - IPython.paths.fs_encoding
+    - IPython.terminal.debugger.DEFAULT_BUFFER
+    - IPython.terminal.debugger.cursor_in_leading_ws
+    - IPython.terminal.debugger.emacs_insert_mode
+    - IPython.terminal.debugger.has_selection
+    - IPython.terminal.debugger.vi_insert_mode
+    - IPython.terminal.interactiveshell.DISPLAY_BANNER_DEPRECATED
+    - IPython.terminal.ipapp.TerminalIPythonApp.parse_command_line
+    - IPython.testing.test
+    - IPython.utils.contexts.NoOpContext
+    - IPython.utils.io.IOStream
+    - IPython.utils.io.IOStream.close
+    - IPython.utils.io.IOStream.write
+    - IPython.utils.io.IOStream.writelines
+    - IPython.utils.io.__warningregistry__
+    - IPython.utils.io.atomic_writing
+    - IPython.utils.io.stderr
+    - IPython.utils.io.stdin
+    - IPython.utils.io.stdout
+    - IPython.utils.io.unicode_std_stream
+    - IPython.utils.path.get_ipython_cache_dir
+    - IPython.utils.path.get_ipython_dir
+    - IPython.utils.path.get_ipython_module_path
+    - IPython.utils.path.get_ipython_package_dir
+    - IPython.utils.path.locate_profile
+    - IPython.utils.path.unquote_filename
+    - IPython.utils.py3compat.PY2
+    - IPython.utils.py3compat.PY3
+    - IPython.utils.py3compat.buffer_to_bytes
+    - IPython.utils.py3compat.builtin_mod_name
+    - IPython.utils.py3compat.cast_bytes
+    - IPython.utils.py3compat.getcwd
+    - IPython.utils.py3compat.isidentifier
+    - IPython.utils.py3compat.u_format
+
+The following signatures differ between 7.x and 8.0::
+
+    - IPython.core.completer.IPCompleter.unicode_name_matches(self, text)
+    + IPython.core.completer.IPCompleter.unicode_name_matches(text)
+
+    - IPython.core.completer.match_dict_keys(keys, prefix, delims)
+    + IPython.core.completer.match_dict_keys(keys, prefix, delims, extra_prefix='None')
+
+    - IPython.core.interactiveshell.InteractiveShell.object_inspect_mime(self, oname, detail_level=0)
+    + IPython.core.interactiveshell.InteractiveShell.object_inspect_mime(self, oname, detail_level=0, omit_sections='()')
+
+    - IPython.core.interactiveshell.InteractiveShell.set_hook(self, name, hook, priority=50, str_key='None', re_key='None', _warn_deprecated=True)
+    + IPython.core.interactiveshell.InteractiveShell.set_hook(self, name, hook, priority=50, str_key='None', re_key='None')
+
+    - IPython.core.oinspect.Inspector.info(self, obj, oname='', formatter='None', info='None', detail_level=0)
+    + IPython.core.oinspect.Inspector.info(self, obj, oname='', info='None', detail_level=0)
+
+    - IPython.core.oinspect.Inspector.pinfo(self, obj, oname='', formatter='None', info='None', detail_level=0, enable_html_pager=True)
+    + IPython.core.oinspect.Inspector.pinfo(self, obj, oname='', formatter='None', info='None', detail_level=0, enable_html_pager=True, omit_sections='()')
+
+    - IPython.core.profiledir.ProfileDir.copy_config_file(self, config_file, path='None', overwrite=False)
+    + IPython.core.profiledir.ProfileDir.copy_config_file(self, config_file, path, overwrite=False)
+
+    - IPython.core.ultratb.VerboseTB.format_record(self, frame, file, lnum, func, lines, index)
+    + IPython.core.ultratb.VerboseTB.format_record(self, frame_info)
+
+    - IPython.terminal.embed.InteractiveShellEmbed.mainloop(self, local_ns='None', module='None', stack_depth=0, display_banner='None', global_ns='None', compile_flags='None')
+    + IPython.terminal.embed.InteractiveShellEmbed.mainloop(self, local_ns='None', module='None', stack_depth=0, compile_flags='None')
+
+    - IPython.terminal.embed.embed(**kwargs)
+    + IPython.terminal.embed.embed(*, header='', compile_flags='None', **kwargs)
+
+    - IPython.terminal.interactiveshell.TerminalInteractiveShell.interact(self, display_banner='<object object at 0xffffff>')
+    + IPython.terminal.interactiveshell.TerminalInteractiveShell.interact(self)
+
+    - IPython.terminal.interactiveshell.TerminalInteractiveShell.mainloop(self, display_banner='<object object at 0xffffff>')
+    + IPython.terminal.interactiveshell.TerminalInteractiveShell.mainloop(self)
+
+    - IPython.utils.path.get_py_filename(name, force_win32='None')
+    + IPython.utils.path.get_py_filename(name)
+
+The following are new attributes (that might be inherited)::
+
+    + IPython.core.completer.IPCompleter.unicode_names
+    + IPython.core.debugger.InterruptiblePdb.precmd
+    + IPython.core.debugger.Pdb.precmd
+    + IPython.core.ultratb.AutoFormattedTB.has_colors
+    + IPython.core.ultratb.ColorTB.has_colors
+    + IPython.core.ultratb.FormattedTB.has_colors
+    + IPython.core.ultratb.ListTB.has_colors
+    + IPython.core.ultratb.SyntaxTB.has_colors
+    + IPython.core.ultratb.TBTools.has_colors
+    + IPython.core.ultratb.VerboseTB.has_colors
+    + IPython.terminal.debugger.TerminalPdb.do_interact
+    + IPython.terminal.debugger.TerminalPdb.precmd
+
+The following attribute/methods have been removed::
+
+    - IPython.core.application.BaseIPythonApplication.deprecated_subcommands
+    - IPython.core.ultratb.AutoFormattedTB.format_records
+    - IPython.core.ultratb.ColorTB.format_records
+    - IPython.core.ultratb.FormattedTB.format_records
+    - IPython.terminal.embed.InteractiveShellEmbed.init_deprecation_warnings
+    - IPython.terminal.embed.InteractiveShellEmbed.init_readline
+    - IPython.terminal.embed.InteractiveShellEmbed.write
+    - IPython.terminal.embed.InteractiveShellEmbed.write_err
+    - IPython.terminal.interactiveshell.TerminalInteractiveShell.init_deprecation_warnings
+    - IPython.terminal.interactiveshell.TerminalInteractiveShell.init_readline
+    - IPython.terminal.interactiveshell.TerminalInteractiveShell.write
+    - IPython.terminal.interactiveshell.TerminalInteractiveShell.write_err
+    - IPython.terminal.ipapp.LocateIPythonApp.deprecated_subcommands
+    - IPython.terminal.ipapp.LocateIPythonApp.initialize_subcommand
+    - IPython.terminal.ipapp.TerminalIPythonApp.deprecated_subcommands
+    - IPython.terminal.ipapp.TerminalIPythonApp.initialize_subcommand
+
+------
+
+.. [1] If this make you uncomfortable feel free to not use IPython 8.23.
diff --git a/docs/source/whatsnew/version9.rst b/docs/source/whatsnew/version9.rst
new file mode 100644
index 00000000000..879e381ee97
--- /dev/null
+++ b/docs/source/whatsnew/version9.rst
@@ -0,0 +1,587 @@
+============
+ 9.x Series
+============
+
+
+.. _version 9.10:
+
+IPython 9.10
+============
+
+This release includes improvements to history management during forking and formatting fixes.
+
+- :ghpull:`15110` Fix Removing leading indentation when stripping prompt
+- :ghpull:`15115` Stop HistorySavingThread before fork
+- :ghpull:`15118` Add debug info for autoreload
+
+
+History Thread Management Improvements
+---------------------------------------
+
+The `HistorySavingThread` is now properly stopped before process forking,
+preventing threading issues in child processes. This ensures that history
+operations work correctly when IPython is used in applications that perform
+process forking.
+
+
+Thanks
+------
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`_ for sponsoring
+work on IPython.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.10
+<https://github.com/ipython/ipython/milestone/159?closed=1>`__ milestone.
+
+
+.. _version 9.9:
+
+IPython 9.9
+===========
+
+This release includes several bug fixes and improvements across completions,
+type annotations, and developer experience.
+
+- :ghpull:`15092` Fix formatting for completion suggestions section
+- :ghpull:`15057` Reduce types in splitinput.py
+- :ghpull:`15096` Use Any type in traceback tuple
+- :ghpull:`15099` Fix filename of CVE test
+- :ghpull:`15091` Skip downstream CI if only docs changes
+- :ghpull:`15093` Replace sphinxext/github with extlink configuration
+- :ghpull:`15103` Tips and docs about argcomplete
+- :ghpull:`15105` Add prompt_toolkit's unix_word_rubout to assignable commands for shortcuts
+- :ghpull:`15095` Enable pretty-printing for PEP-649 annotated functions
+- :ghpull:`15106` Fix completions for methods starting with ``_``
+- :ghpull:`15111` Stop assuming that memory addresses are signed
+- :ghpull:`15102` Bump macOS runner version in GitHub Actions
+- :ghpull:`15101` Fix crash on literal with surrogate
+
+Improvements to PEP-649 Support
+-------------------------------
+
+IPython now properly pretty-prints functions with PEP-649 style annotations.
+This improves the display of functions in interactive sessions when using Python
+3.14+ annotation semantics.
+
+
+Shell Shortcuts Enhancement
+-----------------------------
+
+The ``unix_word_rubout`` command from prompt_toolkit is now available as an
+assignable command for terminal shortcuts, giving users more flexibility in
+customizing their keybindings.
+
+
+Type Annotation Improvements
+----------------------------
+
+Various type annotation improvements have been made throughout the codebase for
+better static analysis support, including fixes for tracebacks and improved type
+inference in the completion engine.
+
+
+Thanks
+------
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`_ for sponsoring
+work on IPython.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.9
+<https://github.com/ipython/ipython/milestone/157?closed=1>`__ milestone.
+
+
+.. _version 9.8:
+
+IPython 9.8
+===========
+
+This release brings improvements to concurrent execution, history commands, tab
+completion, and debugger performance.
+
+
+- :ghpull:`15037` Fix some ruff issues with import
+- :ghpull:`15060` Stricter typing for many utils files
+- :ghpull:`15066` Strict typing of a few more files
+- :ghpull:`15067` Fix self import of deprecated items
+- :ghpull:`15069` Document :magic:`history` usage with all lines of a session
+- :ghpull:`15070` Allow session number without trailing slash in :magic:`history` magic
+- :ghpull:`15074` Use values for tab completion of variables created using annotated assignment
+- :ghpull:`15076` Fix error on tab completions
+- :ghpull:`15078` Show completions for annotated union types
+- :ghpull:`15079` Fallback to type annotations for attribute completions
+- :ghpull:`15081` Strictly suppress file completions in attribute completion context
+- :ghpull:`15083` Minor performance improvements in debugger
+- :ghpull:`15084` Documentation updates
+- :ghpull:`15088` Make :any:`run_cell_async` reenterable for concurrent cell execution
+
+
+Concurrent Cell Execution
+--------------------------
+
+The :any:`run_cell_async` method is now reenterable, making the execution count
+more atomic and preventing session resets when cells are executed concurrently.
+This allows frontends to run multiple cells in parallel without interfering with
+each other's execution context or history tracking. The execution count is now
+incremented before running the user code, ensuring consistent behavior across
+concurrent executions.
+
+
+History Magic Improvements
+---------------------------
+
+The :magic:`history` magic now supports open-ended line ranges using ``-`` as the end
+marker. For example, you can use ``%history 1/10-`` to retrieve all commands from
+line 10 onwards in session 1, or ``%history ~5-`` to get the last 5 commands and
+onwards from the current session. This makes it easier to retrieve ranges of
+commands without needing to know the exact ending line number.
+
+
+Tab Completion Enhancements
+----------------------------
+
+Several improvements were made to the tab completer, particularly when jedi is
+disabled:
+
+- Variables created with annotated assignment (e.g., ``x: int = 5``) now use
+  their runtime values for completion suggestions, providing more accurate
+  attribute completions.
+
+- File path completions are now strictly suppressed when completing attributes,
+  preventing confusion when typing patterns like ``obj.file``.
+
+- Union types in annotations (e.g., ``x: int | str``) are now properly handled
+  for completion suggestions.
+
+- The completer now falls back to type annotations when runtime evaluation is
+  not available, improving completion accuracy for typed code.
+
+
+Thanks
+------
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`_ for sponsoring
+work on IPython.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.8
+<https://github.com/ipython/ipython/milestone/156?closed=1>`__ milestone.
+
+
+.. _version 9.7:
+
+IPython 9.7
+===========
+
+As ususal this new version of IPython brings a number of bugfixes:
+
+
+- :ghpull:`15012` Fix ``Exception.text`` may be None
+- :ghpull:`15007` Start Testign on free-threaded Python
+- :ghpull:`15036` Suppress file completions in context of attributes/methods
+- :ghpull:`15056` Completion in loops and conditionals
+- :ghpull:`15048` Support completions for lambdas and ``async`` functions
+- :ghpull:`15042` Support subscript assignment in completions
+- :ghpull:`15027` Infer type from return value and improve attribute completions
+- :ghpull:`15020` Fix tab completion for subclasses of trusted classes
+- :ghpull:`15022` Prevent trusting modules with matching prefix
+
+
+Gruvbox Dark Theme
+------------------
+
+Gruvbox Dark is now available as a terminal syntax theme for IPython.
+
+Respect PYTHONSAFEPATH
+----------------------
+
+IPython now respects the value of Python's flag ``sys.flags.safe_path``, a flag which is most often set by the ``PYTHONSAFEPATH`` environment variable. Setting this causes Python not to automatically include the current working directory in the sys.path.
+
+IPython can already be configured to do this via the ``--ignore_cwd`` command-line flag or by setting ``c.InteractiveShellApp.ignore_cwd=True``. Now, IPython can also be configured by setting ``PYTHONSAFEPATH=1`` or by calling python with ``-P``.
+
+The behavior of ``safe_path`` was described in `what's new in 3.11`_ and in `PyConfig.safe_path <https://docs.python.org/3/c-api/init_config.html#c.PyConfig.safe_path>`_.
+
+
+.. _what's new in 3.11: https://docs.python.org/3/whatsnew/3.11.html#whatsnew311-pythonsafepath
+
+
+Tab Completion
+--------------
+
+Multiple improvements were made to the tab completer.
+The tab completions now work for more complex code, even when jedi is disabled, using a hybrid evaluation procedure
+which infers available completions from both the typing information, runtime values, and static code analysis.
+The paths to hidden files are no longer suggested when attempting attribute completion.
+
+
+As usual, you can find the full list of PRs on GitHub under `the 9.7
+<https://github.com/ipython/ipython/milestone/155?closed=1>`__ milestone.
+
+
+.. _version 9.6:
+
+IPython 9.6
+===========
+
+This version brings improvements to tab completion, ``%notebook`` magic, module ignoring functionality to debugger.
+
+- :ghpull:`14973` Add module ignoring functionality to debugger
+- :ghpull:`14982` Extract code from line magics for attribute completion
+- :ghpull:`14998` Fix matplotlib plots displaying in wrong cells during ``%notebook`` export
+- :ghpull:`14996` Respect ``DisplayFormatter.active_types`` trait configuration
+- :ghpull:`15001` Fix ``%notebook`` magic creating multiple display_data outputs for single widgets
+- :ghpull:`14997` Make ``%notebook`` magic notarise exported notebooks (mark as trusted)
+- :ghpull:`14993` Type-guided partial evaluation for completion of uninitialized variables
+- :ghpull:`14978` deduperreload: patch NULL for empty closure rather than None
+- :ghpull:`14994` Bump minimum version (spec-0) and whitespace update
+
+The ``%notebook`` magic can now reliably export plots generated by ``matplotlib``, whether with the default ``inline`` or the interactive ``ipympl`` backend.
+For the plots to display when using the ``inline`` backend the ``c.DisplayFormatter.active_types`` needs to include ``image/png`` (or another image media type, depending on the backend configuration).
+
+Tab completion now works on multi-line buffers with unevaluated code even when jedi is disabled.
+Additionally, completion works when writing code as an argument to ``%timeit`` and ``%debug``.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.6
+<https://github.com/ipython/ipython/milestone/154?closed=1>`__ milestone.
+
+
+.. _version 9.5:
+
+IPython 9.5
+===========
+
+Featuring improvements for numerous magics (``%autoreload``, ``%whos``, ``%%script``, ``%%notebook``), a streaming performance regression fix, completer policy overrides improvements, and initial support for Python 3.14.
+
+- :ghpull:`14938` Fix printing long strings in ``%whos`` magic command
+- :ghpull:`14941` Fix performance of streaming long text
+- :ghpull:`14943` Simplify overriding selective evaluation policy settings for modules
+- :ghpull:`14955` Populate notebook metadata when exporting with ``%notebook`` magic
+- :ghpull:`14960` Better handling in deduperreload for patching functions with freevars
+- :ghpull:`14964` Fix traceback logic for non-SyntaxError exceptions in plain mode
+- :ghpull:`14966` Do not warn repeatedly if policy overrides are not applicable
+- :ghpull:`14967` Support Python 3.14.0rc2, test on CI
+- :ghpull:`14969` Fix truncated output in ``%script`` magic
+- :ghpull:`14970` Fix exceptions in ``%whos`` magic command
+
+The ``%notebook`` magic now stores the language and kernel information in notebook metadata, allowing users to quickly open the exported notebook with syntax highlighting and an appropriate kernel.
+
+The completer :std:configtrait:`Completer.policy_overrides` traitlet handling was improved.
+It no longer repeatedly warns on each completion after switching away to a policy that does not support previously specified overrides.
+Allow-listing attribute access on all objects in a given library is now possible.
+The specification now also accepts dotted strings (rather than requiring tuples to specify the path) which should make configuration easier and less error-prone.
+
+.. code::
+
+    c.Completer.policy_overrides = {
+        "allowed_getattr_external": {
+            "my_trusted_library"
+        }
+    }
+
+A number of recent regressions were fixed:
+
+- ``%autoreload`` now again shows the correct module name in traceback
+- standard output/error streaming of long text/logs is now as fast as in IPython 9.0
+- in the ``%whos`` magic handling of long strings and class objects that implement ``__len__`` was fixed.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.5
+<https://github.com/ipython/ipython/milestone/153?closed=1>`__ milestone.
+
+
+.. _version 9.4:
+
+IPython 9.4
+===========
+
+Featuring ``%autoreload``, ``%whos``, ``%%script``, ``%%time`` magic improvements, along with a fix for use of list comprehensions and generators in the interactive debugger (and ipdb).
+
+- :ghpull:`14922` Improved reloading of decorated functions when using ``%autoreload``
+- :ghpull:`14872` Do not always import all variables with ``%autoreload 3``
+- :ghpull:`14906` Changed behaviour of ``%time`` magic to always interrupt execution on exception and always show execution time
+- :ghpull:`14926` Support data frames, series, and objects with ``__len__`` in the ``%whos`` magic
+- :ghpull:`14933` List comprehensions and generators now work reliably in debugger on all supported Python versions
+- :ghpull:`14931` Fix streaming multi-byte Unicode characters in the ``%script`` magic and its derivatives
+
+The ``%time`` magic no longer swallows exceptions raised by the measured code, and always prints the time of execution. If you wish the execution to continue after measuring time to execute code that is meant to raise an exception, pass the new ``--no-raise-error`` flag.
+The ``--no-raise-error`` flag does not affect ``KeyboardInterrupt`` as this exception is used to signal intended interruption of execution flow.
+
+Previously the debugger (ipdb) evaluation of list comprehensions and generators could fail with ``NameError`` due to generator implementation detail in CPython. This was recently fixed in Python 3.13. Because IPython is often used for interactive debugging, this release includes a backport of that fix, providing users who cannot yet update from Python 3.11 or 3.12 with a smoother debugging experience.
+
+The ``%autoreload`` magic is now more reliable. The behaviour around decorators has been improved and `%autoreload 3` no longer imports all symbols when reloading the module, however, the heuristic used to determine which symbols to reload can sometimes lead to addition of imports from non-evaluated code branches, see `issue #14934 <https://github.com/ipython/ipython/issues/14934>`__.
+
+
+As usual, you can find the full list of PRs on GitHub under `the 9.4
+<https://github.com/ipython/ipython/milestone/151?closed=1>`__ milestone.
+
+
+
+.. _version 9.3:
+
+IPython 9.3
+===========
+
+This release includes improvements to the tab and LLM completer, along with typing improvements:
+
+- :ghpull:`14911` Implement auto-import and evaluation policy overrides
+- :ghpull:`14910` Eliminate startup delay when LLM completion provider is configured
+- :ghpull:`14898` Fix attribute completion for expressions with comparison operators
+- :ghpull:`14908` Fix typing of `error_before_exec`, enhance ``mypy`` coverage
+
+Notably, the native completer can now suggest attribute completion on not-yet-imported modules.
+This is particularly useful when writing code which includes an import and the use of the imported
+module in the same line or in the same cell; the default implementation does not insert
+the imported module into the user namespace, for which an actual execution is required.
+
+The auto-import of modules by completer is turned off and requires opting-in using
+a new :std:configtrait:`Completer.policy_overrides` traitlet.
+To enable auto-import on completion specify:
+
+.. code-block::
+
+    ipython --Completer.policy_overrides='{"allow_auto_import": True}' --Completer.use_jedi=False
+
+This change aligns the capability of both jedi-powered and the native completer.
+The function used for auto-import can be configured using :std:configtrait:`Completer.auto_import_method` traitlet.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.3
+<https://github.com/ipython/ipython/milestone/149?closed=1>`__ milestone.
+
+
+.. _version 9.2:
+
+IPython 9.2
+===========
+
+This is a small release with minor changes in the context passed to the LLM completion
+provider along few other bug fixes and documentation improvements:
+
+- :ghpull:`14890` Fixed interruption of ``%%time`` and ``%%debug`` magics
+- :ghpull:`14877` Removed spurious empty lines from ``prefix`` passed to LLM, and separated part after cursor into the ``suffix``
+- :ghpull:`14876` Fixed syntax warning in Python 3.14 (remove return from finally block)
+- :ghpull:`14887` Documented the recommendation to use ``ipykernel.embed.embed_kernel()`` over ``ipython.embed``.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.2
+<https://github.com/ipython/ipython/milestone/146?closed=1>`__ milestone.
+
+.. _version 9.1:
+
+IPython 9.1
+===========
+
+This is a small release that introduces enhancements to ``%notebook`` and ``%%timeit`` magics,
+and a number of bug fixes related to colors/formatting, performance, and completion.
+
+``%notebook`` saves outputs
+---------------------------
+
+The ``%notebook`` magic can be used to create a Jupyter notebook from the
+commands executed in the current IPython session (since the interpreter startup).
+
+Prior to IPython 9.1, the resulting notebook did not include the outputs,
+streams, or exceptions. IPython 9.1 completes the implementation of this
+magic allowing for an easier transition from an interactive IPython session
+to a Jupyter notebook.
+
+To capture streams (stdio/stderr), IPython temporarily swaps the `write`
+method of the active stream class during code execution. This ensures
+compatibility with ipykernel which swaps the entire stream implementation
+and requires it to remain an instance of ``IOStream`` subclass.
+If this leads to undesired behaviour in any downstream applications,
+your feedback and suggestions would be greatly appreciated.
+
+
+``%%timeit -v`` argument
+------------------------
+
+New ``-v`` argument allows users to save the timing result
+directly to a specified variable, e.g.
+
+.. code::
+
+   %%timeit -v timing_result
+   2**32
+
+
+Completer improvements
+----------------------
+
+The LLM-based completer will now receive the request number for each subsequent
+execution.
+
+The tab completer used when jedi is turned off now correctly completes
+variables in lines where it previously was incorrectly attempting to complete
+attributes due to simplistic context detection based on the presence of a dot.
+
+Thanks
+------
+
+A big thank you to everyone who contributed towards the 9.1 release,
+including new contributors: @Darshan808, @kwinkunks, @carschandler,
+returning contributors (shout out to @wjandrea!), and of course
+@Carreau whom I would like to thank for the guidance in the preparation
+of this release and stewardship of IPython over the years - Mike.
+
+As usual, you can find the full list of PRs on GitHub under `the 9.1
+<https://github.com/ipython/ipython/milestone/142?closed=1>`__ milestone.
+
+
+.. _version90:
+
+IPython 9.0
+===========
+
+Welcome to IPython 9.0. As with any version of IPython before this release, it
+should not be majorly different from the previous version, at least on the surface. 
+We still hope you can upgrade as soon as possible and look forward to your feedback.
+
+I take the opportunity of this new release to remind you that IPython is
+governed by the `Jupyter code of conduct
+<https://jupyter.org/governance/conduct/code_of_conduct.html>`_. And that even
+beyond so we strive to be an inclusive, accepting and progressive community,
+Here is a relevant extract from the COC.
+
+    We strive to be a community that welcomes and supports people of all backgrounds
+    and identities. This includes, but is not limited to, members of any race,
+    ethnicity, culture, national origin, color, immigration status, social and
+    economic class, educational level, sex, sexual orientation, gender identity and
+    expression, age, physical appearance, family status, technological or
+    professional choices, academic discipline, religion, mental ability, and
+    physical ability.
+
+
+As a short overview of the changes in 9.0, we have over 100 PRs merged since 8.x,
+many of which are refactors, cleanups and simplifications.
+
+ - (optional) LLM integration in the CLI. 
+ - Complete rewrite of color and theme handling, which now supports more colors and symbols. 
+ - Move tests out of tree in the wheel with a massive reduction in file size. 
+ - Tips at startup
+ - Removal of (almost) all deprecated functionalities and options.
+ - Stricter and more stable codebase.
+
+
+Removal and deprecation
+-----------------------
+
+I am not going to list the removals and deprecations, but anything deprecated since before IPython 8.16 is gone, 
+including many shim modules and indirect imports that would just re-expose IPykernel, qtconsole, etc. 
+
+A number of new deprecations have been added (run your test suites with `-Werror`), as those will be removed in the future. 
+
+
+Color and theme rewrite
+-----------------------
+
+IPython's color handling had grown many options through the years, and it was
+quite entrenched in the codebase, directly emitting ansi escape sequences deep
+in traceback printing and other places. 
+
+This made developing new color schemes difficult, and limited us to the 16 colors
+of the original ansi standard defined by your terminal. 
+
+Syntax highlighting was also inconsistent, and not all syntax elements were
+always using the same theme.
+
+Using (style, token) pairs 
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Starting with 9.0, the color and theme handling has been rewritten, and
+internally all the printing is done by yielding pairs of Style and token objects
+(compatible with pygments and prompt_toolkit), then as much as possible, IPython
+formats these objects at the last moment, using the current theme.
+
+256-bit colors and unicode symbols
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This means that new themes can now use all of pygments's color names and
+functionalities, and you can define for each token style, the foreground,
+background, underline, bold, italic and likely a few other options. 
+
+In addition, themes now provide a number of `symbols`, that can be used when
+rendering traceback or debugger prompts. This let you customize the appearance a
+bit more. For example, instead of using dash and greater-than sign, The arrow
+pointing the current frame can actually use horizontal line and right arrow
+unicode symbol, for a more refined experience.
+
+
+New themes using colors and symbols
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+All the existing themes (Linux, LightBG, Neutral and NoColor) should not see any
+changes, but I added two new *pride themes*, that show the use of 256bits colors
+and unicode symbols. I'm not a designer, so feel free to suggest updates and new
+themes to add. 
+
+Themes  currently still require writing a bit of Python, but I hope to get
+contributions for IPython to be able to load them from text files, for easier
+redistribution.
+
+Tips at startup
+---------------
+
+IPython now displays a few tips at startup (1 line), to help you discover new features.
+All those are in the codebase, and can be displayed randomly or based on date. 
+You can disable it via a configuration option or the ``--no-tips`` flag. 
+
+Please contribute more tips by sending pull requests!
+
+Out-of-tree tests
+-----------------
+
+And more generally I have changed the folder structure and what is packaged in
+the wheel to reduce the file size. The wheel is down from 825kb to 590kb
+(-235kb) which is about a 28% reduction. This should help when you run IPython
+via Pyodide – when your browser needs to download it.
+
+According to https://pypistats.org/packages/ipython, IPython is downloaded about
+13 million times per week, so this should reduce PyPI bandwidth by about 2Tb each
+week, which is small compared to the total download, but still, trying to reduce
+resource usage is a worthy goal.
+
+Integration with Jupyter-AI LLM
+-------------------------------
+
+This feature allow IPython CLI to make use of Jupyter-AI provider to use LLM for
+suggestion, and completing the current text. Unlike many features
+of IPython this is disabled by default, and need several configuration options to
+be set to work:
+
+ - Choose a provider in ``jupyter-ai`` and set it as default one:
+   ``c.TerminalInteractiveShell.llm_provider_class = <fully qualified path>``
+   You likely need to setup your provider with API key or other things.
+ - Choose and available shortcut (I'll take ``Ctrl-Q`` as an example) and bind
+   to trigger ``llm_autosuggestion`` only while typing.
+
+.. code::
+   
+   c.TerminalInteractiveShell.shortcuts = [
+        {
+            "new_keys": ["c-q"],
+            "command": "IPython:auto_suggest.llm_autosuggestion",
+            "new_filter": "navigable_suggestions & default_buffer_focused",
+            "create": True,
+        },
+    ]
+
+See :ref:`llm_suggestions` for more.
+
+Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`_ for sponsoring
+this work.
+
+
+For something completely different
+----------------------------------
+
+Ruth Bader Ginsburg 1933-2020 was an American lawyer and jurist who served on
+the Supreme Court of the United States. Ginsburg spent much of her legal career
+as an advocate for gender equality, women's rights, abortion rights, and religious
+freedom.
+
+Thanks
+------
+
+Thanks to everyone who helped with the 9.0 release and working toward 9.0.
+
+As usual you can find the full list of PRs on GitHub under `the 9.0
+<https://github.com/ipython/ipython/milestone/138?closed=1>`__ milestone.
+
+
+
diff --git a/docs/sphinxext/apigen.py b/docs/sphinxext/apigen.py
index 12374096ec7..fc6543d9165 100644
--- a/docs/sphinxext/apigen.py
+++ b/docs/sphinxext/apigen.py
@@ -17,12 +17,64 @@
 PyMVPA project, which we've adapted for NIPY use.  PyMVPA is an MIT-licensed
 project."""
 
+
 # Stdlib imports
+import ast
+import inspect
 import os
 import re
+from importlib import import_module
+from types import SimpleNamespace as Obj
+
+
+class FuncClsScanner(ast.NodeVisitor):
+    """Scan a module for top-level functions and classes.
+    
+    Skips objects with an @undoc decorator, or a name starting with '_'.
+    """
+    def __init__(self):
+        ast.NodeVisitor.__init__(self)
+        self.classes = []
+        self.classes_seen = set()
+        self.functions = []
+
+    @staticmethod
+    def has_undoc_decorator(node):
+        return any(isinstance(d, ast.Name) and d.id == 'undoc' \
+                                for d in node.decorator_list)
+
+    def visit_If(self, node):
+        if isinstance(node.test, ast.Compare) \
+                and isinstance(node.test.left, ast.Name) \
+                and node.test.left.id == '__name__':
+            return   # Ignore classes defined in "if __name__ == '__main__':"
+
+        self.generic_visit(node)
+    
+    def visit_FunctionDef(self, node):
+        if not (node.name.startswith('_') or self.has_undoc_decorator(node)) \
+                and node.name not in self.functions:
+            self.functions.append(node.name)
+    
+    def visit_ClassDef(self, node):
+        if (
+            not (node.name.startswith("_") or self.has_undoc_decorator(node))
+            and node.name not in self.classes_seen
+        ):
+            cls = Obj(name=node.name, sphinx_options={})
+            cls.has_init = any(
+                isinstance(n, ast.FunctionDef) and n.name == "__init__"
+                for n in node.body
+            )
+            self.classes.append(cls)
+            self.classes_seen.add(node.name)
+    
+    def scan(self, mod):
+        self.visit(mod)
+        return self.functions, self.classes
 
 # Functions and classes
-class ApiDocWriter(object):
+class ApiDocWriter:
     ''' Class for automatic detection and parsing of API docs
     to Sphinx-parsable reST format'''
 
@@ -34,6 +86,7 @@ def __init__(self,
                  rst_extension='.rst',
                  package_skip_patterns=None,
                  module_skip_patterns=None,
+                 names_from__all__=None,
                  ):
         ''' Initialize package for parsing
 
@@ -51,7 +104,7 @@ def __init__(self,
             if *package_name* is ``sphinx``, then ``sphinx.util`` will
             result in ``.util`` being passed for earching by these
             regexps.  If is None, gives default. Default is:
-            ['\.tests$']
+            ['\\.tests$']
         module_skip_patterns : None or sequence
             Sequence of strings giving URIs of modules to be excluded
             Operates on the module name including preceding URI path,
@@ -59,7 +112,13 @@ def __init__(self,
             ``sphinx.util.console`` results in the string to search of
             ``.util.console``
             If is None, gives default. Default is:
-            ['\.setup$', '\._']
+            ['\\.setup$', '\\._']
+        names_from__all__ : set, optional
+            Modules listed in here will be scanned by doing ``from mod import *``,
+            rather than finding function and class definitions by scanning the
+            AST. This is intended for API modules which expose things defined in
+            other files. Modules listed here must define ``__all__`` to avoid
+            exposing everything they import.
         '''
         if package_skip_patterns is None:
             package_skip_patterns = ['\\.tests$']
@@ -69,6 +128,7 @@ def __init__(self,
         self.rst_extension = rst_extension
         self.package_skip_patterns = package_skip_patterns
         self.module_skip_patterns = module_skip_patterns
+        self.names_from__all__ = names_from__all__ or set()
 
     def get_package_name(self):
         return self._package_name
@@ -87,28 +147,13 @@ def set_package_name(self, package_name):
         '''
         # It's also possible to imagine caching the module parsing here
         self._package_name = package_name
-        self.root_module = __import__(package_name)
+        self.root_module = import_module(package_name)
         self.root_path = self.root_module.__path__[0]
         self.written_modules = None
 
     package_name = property(get_package_name, set_package_name, None,
                             'get/set package_name')
 
-    def _get_object_name(self, line):
-        ''' Get second token in line
-        >>> docwriter = ApiDocWriter('sphinx')
-        >>> docwriter._get_object_name("  def func():  ")
-        'func'
-        >>> docwriter._get_object_name("  class Klass(object):  ")
-        'Klass'
-        >>> docwriter._get_object_name("  class Klass:  ")
-        'Klass'
-        '''
-        name = line.split()[1].split('(')[0].strip()
-        # in case we have classes which are not derived from object
-        # ie. old style classes
-        return name.rstrip(':')
-
     def _uri2path(self, uri):
         ''' Convert uri to absolute filepath
 
@@ -164,31 +209,36 @@ def _parse_module(self, uri):
         if filename is None:
             # nothing that we could handle here.
             return ([],[])
-        f = open(filename, 'rt')
-        functions, classes = self._parse_lines(f)
-        f.close()
-        return functions, classes
-    
-    def _parse_lines(self, linesource):
-        ''' Parse lines of text for functions and classes '''
-        functions = []
-        classes = []
-        for line in linesource:
-            if line.startswith('def ') and line.count('('):
-                # exclude private stuff
-                name = self._get_object_name(line)
-                if not name.startswith('_'):
-                    functions.append(name)
-            elif line.startswith('class '):
-                # exclude private stuff
-                name = self._get_object_name(line)
-                if not name.startswith('_'):
-                    classes.append(name)
-            else:
-                pass
-        functions.sort()
-        classes.sort()
-        return functions, classes
+        with open(filename, 'rb') as f:
+            mod = ast.parse(f.read())
+        return FuncClsScanner().scan(mod)
+
+    def _import_funcs_classes(self, uri):
+        """Import * from uri, and separate out functions and classes."""
+        ns = {}
+        exec('from %s import *' % uri, ns)
+        funcs, classes = [], []
+        for name, obj in ns.items():
+            if inspect.isclass(obj):
+                cls = Obj(
+                    name=name,
+                    has_init="__init__" in obj.__dict__,
+                    sphinx_options=getattr(obj, "_sphinx_options", {}),
+                )
+                classes.append(cls)
+            elif inspect.isfunction(obj):
+                funcs.append(name)
+
+        return sorted(funcs), sorted(classes, key=lambda x: x.name)
+
+    def find_funcs_classes(self, uri):
+        """Find the functions and classes defined in the module ``uri``"""
+        if uri in self.names_from__all__:
+            # For API modules which expose things defined elsewhere, import them
+            return self._import_funcs_classes(uri)
+        else:
+            # For other modules, scan their AST to see what they define
+            return self._parse_module(uri)
 
     def generate_api_doc(self, uri):
         '''Make autodoc documentation template string for a module
@@ -204,62 +254,53 @@ def generate_api_doc(self, uri):
             Contents of API doc
         '''
         # get the names of all classes and functions
-        functions, classes = self._parse_module(uri)
+        functions, classes = self.find_funcs_classes(uri)
         if not len(functions) and not len(classes):
-            print 'WARNING: Empty -',uri  # dbg
+            #print ('WARNING: Empty -', uri)  # dbg
             return ''
 
         # Make a shorter version of the uri that omits the package name for
-        # titles 
+        # titles
         uri_short = re.sub(r'^%s\.' % self.package_name,'',uri)
-        
-        ad = '.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n'
 
-        chap_title = uri_short
-        ad += (chap_title+'\n'+ self.rst_section_levels[1] * len(chap_title)
-               + '\n\n')
+        ad = '.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n'
 
-        # Set the chapter title to read 'module' for all modules except for the
+        # Set the chapter title to read 'Module:' for all modules except for the
         # main packages
         if '.' in uri:
-            title = 'Module: :mod:`' + uri_short + '`'
+            chap_title = 'Module: :mod:`' + uri_short + '`'
         else:
-            title = ':mod:`' + uri_short + '`'
-        ad += title + '\n' + self.rst_section_levels[2] * len(title)
-
-        if len(classes):
-            ad += '\nInheritance diagram for ``%s``:\n\n' % uri
-            ad += '.. inheritance-diagram:: %s \n' % uri
-            ad += '   :parts: 3\n'
+            chap_title = ':mod:`' + uri_short + '`'
+        ad += chap_title + '\n' + self.rst_section_levels[1] * len(chap_title)
 
         ad += '\n.. automodule:: ' + uri + '\n'
         ad += '\n.. currentmodule:: ' + uri + '\n'
-        multi_class = len(classes) > 1
-        multi_fx = len(functions) > 1
-        if multi_class:
-            ad += '\n' + 'Classes' + '\n' + \
-                  self.rst_section_levels[2] * 7 + '\n'
-        elif len(classes) and multi_fx:
-            ad += '\n' + 'Class' + '\n' + \
-                  self.rst_section_levels[2] * 5 + '\n'
+        
+        if classes:
+            subhead = str(len(classes)) + (' Classes' if len(classes) > 1 else ' Class')
+            ad += '\n'+ subhead + '\n' + \
+                  self.rst_section_levels[2] * len(subhead) + '\n'
+
         for c in classes:
-            ad += '\n:class:`' + c + '`\n' \
-                  + self.rst_section_levels[multi_class + 2 ] * \
-                  (len(c)+9) + '\n\n'
-            ad += '\n.. autoclass:: ' + c + '\n'
+            opts = c.sphinx_options
+            ad += "\n.. autoclass:: " + c.name + "\n"
             # must NOT exclude from index to keep cross-refs working
-            ad += '  :members:\n' \
-                  '  :undoc-members:\n' \
-                  '  :show-inheritance:\n' \
-                  '  :inherited-members:\n' \
-                  '\n' \
-                  '  .. automethod:: __init__\n'
-        if multi_fx:
-            ad += '\n' + 'Functions' + '\n' + \
-                  self.rst_section_levels[2] * 9 + '\n\n'
-        elif len(functions) and multi_class:
-            ad += '\n' + 'Function' + '\n' + \
-                  self.rst_section_levels[2] * 8 + '\n\n'
+            ad += "  :members:\n"
+            if opts.get("show_inheritance", True):
+                ad += "  :show-inheritance:\n"
+            if opts.get("show_inherited_members", False):
+                exclusions_list = opts.get("exclude_inherited_from", [])
+                exclusions = (
+                    (" " + " ".join(exclusions_list)) if exclusions_list else ""
+                )
+                ad += f"  :inherited-members:{exclusions}\n"
+            if c.has_init:
+                  ad += '\n  .. automethod:: __init__\n'
+        
+        if functions:
+            subhead = str(len(functions)) + (' Functions' if len(functions) > 1 else ' Function')
+            ad += '\n'+ subhead + '\n' + \
+                  self.rst_section_levels[2] * len(subhead) + '\n'
         for f in functions:
             # must NOT exclude from index to keep cross-refs working
             ad += '\n.. autofunction:: ' + uri + '.' + f + '\n\n'
@@ -291,7 +332,7 @@ def _survives_exclude(self, matchstr, match_type):
         elif match_type == 'package':
             patterns = self.package_skip_patterns
         else:
-            raise ValueError('Cannot interpret match type "%s"' 
+            raise ValueError('Cannot interpret match type "%s"'
                              % match_type)
         # Match to URI without package name
         L = len(self.package_name)
@@ -307,7 +348,7 @@ def _survives_exclude(self, matchstr, match_type):
         return True
 
     def discover_modules(self):
-        ''' Return module sequence discovered from ``self.package_name`` 
+        ''' Return module sequence discovered from ``self.package_name``
 
 
         Parameters
@@ -325,10 +366,10 @@ def discover_modules(self):
         >>> mods = dw.discover_modules()
         >>> 'sphinx.util' in mods
         True
-        >>> dw.package_skip_patterns.append('\.util$')
+        >>> dw.package_skip_patterns.append('\\.util$')
         >>> 'sphinx.util' in dw.discover_modules()
         False
-        >>> 
+        >>>
         '''
         modules = [self.package_name]
         # raw directory parsing
@@ -351,7 +392,7 @@ def discover_modules(self):
                     self._survives_exclude(module_uri, 'module')):
                     modules.append(module_uri)
         return sorted(modules)
-    
+
     def write_modules_api(self, modules,outdir):
         # write the list
         written_modules = []
@@ -360,11 +401,9 @@ def write_modules_api(self, modules,outdir):
             if not api_str:
                 continue
             # write out to file
-            outfile = os.path.join(outdir,
-                                   m + self.rst_extension)
-            fileobj = open(outfile, 'wt')
-            fileobj.write(api_str)
-            fileobj.close()
+            outfile = os.path.join(outdir, m + self.rst_extension)
+            with open(outfile, "wt", encoding="utf-8") as fileobj:
+                fileobj.write(api_str)
             written_modules.append(m)
         self.written_modules = written_modules
 
@@ -376,7 +415,7 @@ def write_api_docs(self, outdir):
         outdir : string
             Directory name in which to store files
             We create automatic filenames for each module
-            
+
         Returns
         -------
         None
@@ -390,19 +429,16 @@ def write_api_docs(self, outdir):
         # compose list of modules
         modules = self.discover_modules()
         self.write_modules_api(modules,outdir)
-        
-    def write_index(self, outdir, froot='gen', relative_to=None):
+
+    def write_index(self, outdir, path='gen.rst', relative_to=None):
         """Make a reST API index file from written files
 
         Parameters
         ----------
-        path : string
-            Filename to write index to
         outdir : string
             Directory to which to write generated index file
-        froot : string, optional
-            root (filename without extension) of filename to write to
-            Defaults to 'gen'.  We add ``self.rst_extension``.
+        path : string
+            Filename to write index to
         relative_to : string
             path to which written filenames are relative.  This
             component of the written file path will be removed from
@@ -412,16 +448,16 @@ def write_index(self, outdir, froot='gen', relative_to=None):
         if self.written_modules is None:
             raise ValueError('No modules written')
         # Get full filename path
-        path = os.path.join(outdir, froot+self.rst_extension)
+        path = os.path.join(outdir, path)
         # Path written into index is relative to rootpath
         if relative_to is not None:
             relpath = outdir.replace(relative_to + os.path.sep, '')
         else:
             relpath = outdir
-        idx = open(path,'wt')
-        w = idx.write
-        w('.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n')
-        w('.. toctree::\n\n')
-        for f in self.written_modules:
-            w('   %s\n' % os.path.join(relpath,f))
-        idx.close()
+        with open(path, "wt", encoding="utf-8") as idx:
+            w = idx.write
+            w('.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n')
+            w('.. autosummary::\n'
+            '   :toctree: %s\n\n' % relpath)
+            for mod in self.written_modules:
+                w('   %s\n' % mod)
diff --git a/docs/sphinxext/configtraits.py b/docs/sphinxext/configtraits.py
new file mode 100644
index 00000000000..2bfd93c4e4b
--- /dev/null
+++ b/docs/sphinxext/configtraits.py
@@ -0,0 +1,16 @@
+"""Directives and roles for documenting traitlets config options.
+
+::
+
+    .. configtrait:: Application.log_datefmt
+
+        Description goes here.
+
+    Cross reference like this: :configtrait:`Application.log_datefmt`.
+"""
+
+
+def setup(app):
+    app.add_object_type("configtrait", "configtrait", objname="Config option")
+    metadata = {"parallel_read_safe": True, "parallel_write_safe": True}
+    return metadata
diff --git a/docs/sphinxext/docscrape.py b/docs/sphinxext/docscrape.py
deleted file mode 100644
index 3999cc934c7..00000000000
--- a/docs/sphinxext/docscrape.py
+++ /dev/null
@@ -1,497 +0,0 @@
-"""Extract reference documentation from the NumPy source tree.
-
-"""
-
-import inspect
-import textwrap
-import re
-import pydoc
-from StringIO import StringIO
-from warnings import warn
-
-class Reader(object):
-    """A line-based string reader.
-
-    """
-    def __init__(self, data):
-        """
-        Parameters
-        ----------
-        data : str
-           String with lines separated by '\n'.
-
-        """
-        if isinstance(data,list):
-            self._str = data
-        else:
-            self._str = data.split('\n') # store string as list of lines
-
-        self.reset()
-
-    def __getitem__(self, n):
-        return self._str[n]
-
-    def reset(self):
-        self._l = 0 # current line nr
-
-    def read(self):
-        if not self.eof():
-            out = self[self._l]
-            self._l += 1
-            return out
-        else:
-            return ''
-
-    def seek_next_non_empty_line(self):
-        for l in self[self._l:]:
-            if l.strip():
-                break
-            else:
-                self._l += 1
-
-    def eof(self):
-        return self._l >= len(self._str)
-
-    def read_to_condition(self, condition_func):
-        start = self._l
-        for line in self[start:]:
-            if condition_func(line):
-                return self[start:self._l]
-            self._l += 1
-            if self.eof():
-                return self[start:self._l+1]
-        return []
-
-    def read_to_next_empty_line(self):
-        self.seek_next_non_empty_line()
-        def is_empty(line):
-            return not line.strip()
-        return self.read_to_condition(is_empty)
-
-    def read_to_next_unindented_line(self):
-        def is_unindented(line):
-            return (line.strip() and (len(line.lstrip()) == len(line)))
-        return self.read_to_condition(is_unindented)
-
-    def peek(self,n=0):
-        if self._l + n < len(self._str):
-            return self[self._l + n]
-        else:
-            return ''
-
-    def is_empty(self):
-        return not ''.join(self._str).strip()
-
-
-class NumpyDocString(object):
-    def __init__(self,docstring):
-        docstring = textwrap.dedent(docstring).split('\n')
-
-        self._doc = Reader(docstring)
-        self._parsed_data = {
-            'Signature': '',
-            'Summary': [''],
-            'Extended Summary': [],
-            'Parameters': [],
-            'Returns': [],
-            'Raises': [],
-            'Warns': [],
-            'Other Parameters': [],
-            'Attributes': [],
-            'Methods': [],
-            'See Also': [],
-            'Notes': [],
-            'Warnings': [],
-            'References': '',
-            'Examples': '',
-            'index': {}
-            }
-
-        self._parse()
-
-    def __getitem__(self,key):
-        return self._parsed_data[key]
-
-    def __setitem__(self,key,val):
-        if not self._parsed_data.has_key(key):
-            warn("Unknown section %s" % key)
-        else:
-            self._parsed_data[key] = val
-
-    def _is_at_section(self):
-        self._doc.seek_next_non_empty_line()
-
-        if self._doc.eof():
-            return False
-
-        l1 = self._doc.peek().strip()  # e.g. Parameters
-
-        if l1.startswith('.. index::'):
-            return True
-
-        l2 = self._doc.peek(1).strip() #    ---------- or ==========
-        return l2.startswith('-'*len(l1)) or l2.startswith('='*len(l1))
-
-    def _strip(self,doc):
-        i = 0
-        j = 0
-        for i,line in enumerate(doc):
-            if line.strip(): break
-
-        for j,line in enumerate(doc[::-1]):
-            if line.strip(): break
-
-        return doc[i:len(doc)-j]
-
-    def _read_to_next_section(self):
-        section = self._doc.read_to_next_empty_line()
-
-        while not self._is_at_section() and not self._doc.eof():
-            if not self._doc.peek(-1).strip(): # previous line was empty
-                section += ['']
-
-            section += self._doc.read_to_next_empty_line()
-
-        return section
-
-    def _read_sections(self):
-        while not self._doc.eof():
-            data = self._read_to_next_section()
-            name = data[0].strip()
-
-            if name.startswith('..'): # index section
-                yield name, data[1:]
-            elif len(data) < 2:
-                yield StopIteration
-            else:
-                yield name, self._strip(data[2:])
-
-    def _parse_param_list(self,content):
-        r = Reader(content)
-        params = []
-        while not r.eof():
-            header = r.read().strip()
-            if ' : ' in header:
-                arg_name, arg_type = header.split(' : ')[:2]
-            else:
-                arg_name, arg_type = header, ''
-
-            desc = r.read_to_next_unindented_line()
-            desc = dedent_lines(desc)
-
-            params.append((arg_name,arg_type,desc))
-
-        return params
-
-    
-    _name_rgx = re.compile(r"^\s*(:(?P<role>\w+):`(?P<name>[a-zA-Z0-9_.-]+)`|"
-                           r" (?P<name2>[a-zA-Z0-9_.-]+))\s*", re.X)
-    def _parse_see_also(self, content):
-        """
-        func_name : Descriptive text
-            continued text
-        another_func_name : Descriptive text
-        func_name1, func_name2, :meth:`func_name`, func_name3
-
-        """
-        items = []
-
-        def parse_item_name(text):
-            """Match ':role:`name`' or 'name'"""
-            m = self._name_rgx.match(text)
-            if m:
-                g = m.groups()
-                if g[1] is None:
-                    return g[3], None
-                else:
-                    return g[2], g[1]
-            raise ValueError("%s is not a item name" % text)
-
-        def push_item(name, rest):
-            if not name:
-                return
-            name, role = parse_item_name(name)
-            items.append((name, list(rest), role))
-            del rest[:]
-
-        current_func = None
-        rest = []
-        
-        for line in content:
-            if not line.strip(): continue
-
-            m = self._name_rgx.match(line)
-            if m and line[m.end():].strip().startswith(':'):
-                push_item(current_func, rest)
-                current_func, line = line[:m.end()], line[m.end():]
-                rest = [line.split(':', 1)[1].strip()]
-                if not rest[0]:
-                    rest = []
-            elif not line.startswith(' '):
-                push_item(current_func, rest)
-                current_func = None
-                if ',' in line:
-                    for func in line.split(','):
-                        push_item(func, [])
-                elif line.strip():
-                    current_func = line
-            elif current_func is not None:
-                rest.append(line.strip())
-        push_item(current_func, rest)
-        return items
-
-    def _parse_index(self, section, content):
-        """
-        .. index: default
-           :refguide: something, else, and more
-
-        """
-        def strip_each_in(lst):
-            return [s.strip() for s in lst]
-
-        out = {}
-        section = section.split('::')
-        if len(section) > 1:
-            out['default'] = strip_each_in(section[1].split(','))[0]
-        for line in content:
-            line = line.split(':')
-            if len(line) > 2:
-                out[line[1]] = strip_each_in(line[2].split(','))
-        return out
-    
-    def _parse_summary(self):
-        """Grab signature (if given) and summary"""
-        if self._is_at_section():
-            return
-
-        summary = self._doc.read_to_next_empty_line()
-        summary_str = " ".join([s.strip() for s in summary]).strip()
-        if re.compile('^([\w., ]+=)?\s*[\w\.]+\(.*\)$').match(summary_str):
-            self['Signature'] = summary_str
-            if not self._is_at_section():
-                self['Summary'] = self._doc.read_to_next_empty_line()
-        else:
-            self['Summary'] = summary
-
-        if not self._is_at_section():
-            self['Extended Summary'] = self._read_to_next_section()
-    
-    def _parse(self):
-        self._doc.reset()
-        self._parse_summary()
-
-        for (section,content) in self._read_sections():
-            if not section.startswith('..'):
-                section = ' '.join([s.capitalize() for s in section.split(' ')])
-            if section in ('Parameters', 'Attributes', 'Methods',
-                           'Returns', 'Raises', 'Warns'):
-                self[section] = self._parse_param_list(content)
-            elif section.startswith('.. index::'):
-                self['index'] = self._parse_index(section, content)
-            elif section == 'See Also':
-                self['See Also'] = self._parse_see_also(content)
-            else:
-                self[section] = content
-
-    # string conversion routines
-
-    def _str_header(self, name, symbol='-'):
-        return [name, len(name)*symbol]
-
-    def _str_indent(self, doc, indent=4):
-        out = []
-        for line in doc:
-            out += [' '*indent + line]
-        return out
-
-    def _str_signature(self):
-        if self['Signature']:
-            return [self['Signature'].replace('*','\*')] + ['']
-        else:
-            return ['']
-
-    def _str_summary(self):
-        if self['Summary']:
-            return self['Summary'] + ['']
-        else:
-            return []
-
-    def _str_extended_summary(self):
-        if self['Extended Summary']:
-            return self['Extended Summary'] + ['']
-        else:
-            return []
-
-    def _str_param_list(self, name):
-        out = []
-        if self[name]:
-            out += self._str_header(name)
-            for param,param_type,desc in self[name]:
-                out += ['%s : %s' % (param, param_type)]
-                out += self._str_indent(desc)
-            out += ['']
-        return out
-
-    def _str_section(self, name):
-        out = []
-        if self[name]:
-            out += self._str_header(name)
-            out += self[name]
-            out += ['']
-        return out
-
-    def _str_see_also(self, func_role):
-        if not self['See Also']: return []
-        out = []
-        out += self._str_header("See Also")
-        last_had_desc = True
-        for func, desc, role in self['See Also']:
-            if role:
-                link = ':%s:`%s`' % (role, func)
-            elif func_role:
-                link = ':%s:`%s`' % (func_role, func)
-            else:
-                link = "`%s`_" % func
-            if desc or last_had_desc:
-                out += ['']
-                out += [link]
-            else:
-                out[-1] += ", %s" % link
-            if desc:
-                out += self._str_indent([' '.join(desc)])
-                last_had_desc = True
-            else:
-                last_had_desc = False
-        out += ['']
-        return out
-
-    def _str_index(self):
-        idx = self['index']
-        out = []
-        out += ['.. index:: %s' % idx.get('default','')]
-        for section, references in idx.iteritems():
-            if section == 'default':
-                continue
-            out += ['   :%s: %s' % (section, ', '.join(references))]
-        return out
-
-    def __str__(self, func_role=''):
-        out = []
-        out += self._str_signature()
-        out += self._str_summary()
-        out += self._str_extended_summary()
-        for param_list in ('Parameters','Returns','Raises'):
-            out += self._str_param_list(param_list)
-        out += self._str_section('Warnings')
-        out += self._str_see_also(func_role)
-        for s in ('Notes','References','Examples'):
-            out += self._str_section(s)
-        out += self._str_index()
-        return '\n'.join(out)
-
-
-def indent(str,indent=4):
-    indent_str = ' '*indent
-    if str is None:
-        return indent_str
-    lines = str.split('\n')
-    return '\n'.join(indent_str + l for l in lines)
-
-def dedent_lines(lines):
-    """Deindent a list of lines maximally"""
-    return textwrap.dedent("\n".join(lines)).split("\n")
-
-def header(text, style='-'):
-    return text + '\n' + style*len(text) + '\n'
-
-
-class FunctionDoc(NumpyDocString):
-    def __init__(self, func, role='func', doc=None):
-        self._f = func
-        self._role = role # e.g. "func" or "meth"
-        if doc is None:
-            doc = inspect.getdoc(func) or ''
-        try:
-            NumpyDocString.__init__(self, doc)
-        except ValueError, e:
-            print '*'*78
-            print "ERROR: '%s' while parsing `%s`" % (e, self._f)
-            print '*'*78
-            #print "Docstring follows:"
-            #print doclines
-            #print '='*78
-
-        if not self['Signature']:
-            func, func_name = self.get_func()
-            try:
-                # try to read signature
-                argspec = inspect.getargspec(func)
-                argspec = inspect.formatargspec(*argspec)
-                argspec = argspec.replace('*','\*')
-                signature = '%s%s' % (func_name, argspec)
-            except TypeError, e:
-                signature = '%s()' % func_name
-            self['Signature'] = signature
-
-    def get_func(self):
-        func_name = getattr(self._f, '__name__', self.__class__.__name__)
-        if inspect.isclass(self._f):
-            func = getattr(self._f, '__call__', self._f.__init__)
-        else:
-            func = self._f
-        return func, func_name
-            
-    def __str__(self):
-        out = ''
-
-        func, func_name = self.get_func()
-        signature = self['Signature'].replace('*', '\*')
-
-        roles = {'func': 'function',
-                 'meth': 'method'}
-
-        if self._role:
-            if not roles.has_key(self._role):
-                print "Warning: invalid role %s" % self._role
-            out += '.. %s:: %s\n    \n\n' % (roles.get(self._role,''),
-                                             func_name)
-
-        out += super(FunctionDoc, self).__str__(func_role=self._role)
-        return out
-
-
-class ClassDoc(NumpyDocString):
-    def __init__(self,cls,modulename='',func_doc=FunctionDoc,doc=None):
-        if not inspect.isclass(cls):
-            raise ValueError("Initialise using a class. Got %r" % cls)
-        self._cls = cls
-
-        if modulename and not modulename.endswith('.'):
-            modulename += '.'
-        self._mod = modulename
-        self._name = cls.__name__
-        self._func_doc = func_doc
-
-        if doc is None:
-            doc = pydoc.getdoc(cls)
-
-        NumpyDocString.__init__(self, doc)
-
-    @property
-    def methods(self):
-        return [name for name,func in inspect.getmembers(self._cls)
-                if not name.startswith('_') and callable(func)]
-
-    def __str__(self):
-        out = ''
-        out += super(ClassDoc, self).__str__()
-        out += "\n\n"
-
-        #for m in self.methods:
-        #    print "Parsing `%s`" % m
-        #    out += str(self._func_doc(getattr(self._cls,m), 'meth')) + '\n\n'
-        #    out += '.. index::\n   single: %s; %s\n\n' % (self._name, m)
-
-        return out
-
-
diff --git a/docs/sphinxext/docscrape_sphinx.py b/docs/sphinxext/docscrape_sphinx.py
deleted file mode 100644
index 77ed271b0f5..00000000000
--- a/docs/sphinxext/docscrape_sphinx.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import re, inspect, textwrap, pydoc
-from docscrape import NumpyDocString, FunctionDoc, ClassDoc
-
-class SphinxDocString(NumpyDocString):
-    # string conversion routines
-    def _str_header(self, name, symbol='`'):
-        return ['.. rubric:: ' + name, '']
-
-    def _str_field_list(self, name):
-        return [':' + name + ':']
-
-    def _str_indent(self, doc, indent=4):
-        out = []
-        for line in doc:
-            out += [' '*indent + line]
-        return out
-
-    def _str_signature(self):
-        return ['']
-        if self['Signature']:
-            return ['``%s``' % self['Signature']] + ['']
-        else:
-            return ['']
-
-    def _str_summary(self):
-        return self['Summary'] + ['']
-
-    def _str_extended_summary(self):
-        return self['Extended Summary'] + ['']
-
-    def _str_param_list(self, name):
-        out = []
-        if self[name]:
-            out += self._str_field_list(name)
-            out += ['']
-            for param,param_type,desc in self[name]:
-                out += self._str_indent(['**%s** : %s' % (param.strip(),
-                                                          param_type)])
-                out += ['']
-                out += self._str_indent(desc,8)
-                out += ['']
-        return out
-
-    def _str_section(self, name):
-        out = []
-        if self[name]:
-            out += self._str_header(name)
-            out += ['']
-            content = textwrap.dedent("\n".join(self[name])).split("\n")
-            out += content
-            out += ['']
-        return out
-
-    def _str_see_also(self, func_role):
-        out = []
-        if self['See Also']:
-            see_also = super(SphinxDocString, self)._str_see_also(func_role)
-            out = ['.. seealso::', '']
-            out += self._str_indent(see_also[2:])
-        return out
-
-    def _str_warnings(self):
-        out = []
-        if self['Warnings']:
-            out = ['.. warning::', '']
-            out += self._str_indent(self['Warnings'])
-        return out
-
-    def _str_index(self):
-        idx = self['index']
-        out = []
-        if len(idx) == 0:
-            return out
-
-        out += ['.. index:: %s' % idx.get('default','')]
-        for section, references in idx.iteritems():
-            if section == 'default':
-                continue
-            elif section == 'refguide':
-                out += ['   single: %s' % (', '.join(references))]
-            else:
-                out += ['   %s: %s' % (section, ','.join(references))]
-        return out
-
-    def _str_references(self):
-        out = []
-        if self['References']:
-            out += self._str_header('References')
-            if isinstance(self['References'], str):
-                self['References'] = [self['References']]
-            out.extend(self['References'])
-            out += ['']
-        return out
-
-    def __str__(self, indent=0, func_role="obj"):
-        out = []
-        out += self._str_signature()
-        out += self._str_index() + ['']
-        out += self._str_summary()
-        out += self._str_extended_summary()
-        for param_list in ('Parameters', 'Attributes', 'Methods',
-                           'Returns','Raises'):
-            out += self._str_param_list(param_list)
-        out += self._str_warnings()
-        out += self._str_see_also(func_role)
-        out += self._str_section('Notes')
-        out += self._str_references()
-        out += self._str_section('Examples')
-        out = self._str_indent(out,indent)
-        return '\n'.join(out)
-
-class SphinxFunctionDoc(SphinxDocString, FunctionDoc):
-    pass
-
-class SphinxClassDoc(SphinxDocString, ClassDoc):
-    pass
-
-def get_doc_object(obj, what=None, doc=None):
-    if what is None:
-        if inspect.isclass(obj):
-            what = 'class'
-        elif inspect.ismodule(obj):
-            what = 'module'
-        elif callable(obj):
-            what = 'function'
-        else:
-            what = 'object'
-    if what == 'class':
-        return SphinxClassDoc(obj, '', func_doc=SphinxFunctionDoc, doc=doc)
-    elif what in ('function', 'method'):
-        return SphinxFunctionDoc(obj, '', doc=doc)
-    else:
-        if doc is None:
-            doc = pydoc.getdoc(obj)
-        return SphinxDocString(doc)
-
diff --git a/docs/sphinxext/inheritance_diagram.py b/docs/sphinxext/inheritance_diagram.py
deleted file mode 100644
index 407fc13ffb1..00000000000
--- a/docs/sphinxext/inheritance_diagram.py
+++ /dev/null
@@ -1,407 +0,0 @@
-"""
-Defines a docutils directive for inserting inheritance diagrams.
-
-Provide the directive with one or more classes or modules (separated
-by whitespace).  For modules, all of the classes in that module will
-be used.
-
-Example::
-
-   Given the following classes:
-
-   class A: pass
-   class B(A): pass
-   class C(A): pass
-   class D(B, C): pass
-   class E(B): pass
-
-   .. inheritance-diagram: D E
-
-   Produces a graph like the following:
-
-               A
-              / \
-             B   C
-            / \ /
-           E   D
-
-The graph is inserted as a PNG+image map into HTML and a PDF in
-LaTeX.
-"""
-
-import inspect
-import os
-import re
-import subprocess
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5
-
-from docutils.nodes import Body, Element
-from docutils.parsers.rst import directives
-from sphinx.roles import xfileref_role
-
-def my_import(name):
-    """Module importer - taken from the python documentation.
-
-    This function allows importing names with dots in them."""
-    
-    mod = __import__(name)
-    components = name.split('.')
-    for comp in components[1:]:
-        mod = getattr(mod, comp)
-    return mod
-
-class DotException(Exception):
-    pass
-
-class InheritanceGraph(object):
-    """
-    Given a list of classes, determines the set of classes that
-    they inherit from all the way to the root "object", and then
-    is able to generate a graphviz dot graph from them.
-    """
-    def __init__(self, class_names, show_builtins=False):
-        """
-        *class_names* is a list of child classes to show bases from.
-
-        If *show_builtins* is True, then Python builtins will be shown
-        in the graph.
-        """
-        self.class_names = class_names
-        self.classes = self._import_classes(class_names)
-        self.all_classes = self._all_classes(self.classes)
-        if len(self.all_classes) == 0:
-            raise ValueError("No classes found for inheritance diagram")
-        self.show_builtins = show_builtins
-
-    py_sig_re = re.compile(r'''^([\w.]*\.)?    # class names
-                           (\w+)  \s* $        # optionally arguments
-                           ''', re.VERBOSE)
-
-    def _import_class_or_module(self, name):
-        """
-        Import a class using its fully-qualified *name*.
-        """
-        try:
-            path, base = self.py_sig_re.match(name).groups()
-        except:
-            raise ValueError(
-                "Invalid class or module '%s' specified for inheritance diagram" % name)
-        fullname = (path or '') + base
-        path = (path and path.rstrip('.'))
-        if not path:
-            path = base
-        try:
-            module = __import__(path, None, None, [])
-            # We must do an import of the fully qualified name.  Otherwise if a
-            # subpackage 'a.b' is requested where 'import a' does NOT provide
-            # 'a.b' automatically, then 'a.b' will not be found below.  This
-            # second call will force the equivalent of 'import a.b' to happen
-            # after the top-level import above.
-            my_import(fullname)
-            
-        except ImportError:
-            raise ValueError(
-                "Could not import class or module '%s' specified for inheritance diagram" % name)
-
-        try:
-            todoc = module
-            for comp in fullname.split('.')[1:]:
-                todoc = getattr(todoc, comp)
-        except AttributeError:
-            raise ValueError(
-                "Could not find class or module '%s' specified for inheritance diagram" % name)
-
-        # If a class, just return it
-        if inspect.isclass(todoc):
-            return [todoc]
-        elif inspect.ismodule(todoc):
-            classes = []
-            for cls in todoc.__dict__.values():
-                if inspect.isclass(cls) and cls.__module__ == todoc.__name__:
-                    classes.append(cls)
-            return classes
-        raise ValueError(
-            "'%s' does not resolve to a class or module" % name)
-
-    def _import_classes(self, class_names):
-        """
-        Import a list of classes.
-        """
-        classes = []
-        for name in class_names:
-            classes.extend(self._import_class_or_module(name))
-        return classes
-
-    def _all_classes(self, classes):
-        """
-        Return a list of all classes that are ancestors of *classes*.
-        """
-        all_classes = {}
-
-        def recurse(cls):
-            all_classes[cls] = None
-            for c in cls.__bases__:
-                if c not in all_classes:
-                    recurse(c)
-
-        for cls in classes:
-            recurse(cls)
-
-        return all_classes.keys()
-
-    def class_name(self, cls, parts=0):
-        """
-        Given a class object, return a fully-qualified name.  This
-        works for things I've tested in matplotlib so far, but may not
-        be completely general.
-        """
-        module = cls.__module__
-        if module == '__builtin__':
-            fullname = cls.__name__
-        else:
-            fullname = "%s.%s" % (module, cls.__name__)
-        if parts == 0:
-            return fullname
-        name_parts = fullname.split('.')
-        return '.'.join(name_parts[-parts:])
-
-    def get_all_class_names(self):
-        """
-        Get all of the class names involved in the graph.
-        """
-        return [self.class_name(x) for x in self.all_classes]
-
-    # These are the default options for graphviz
-    default_graph_options = {
-        "rankdir": "LR",
-        "size": '"8.0, 12.0"'
-        }
-    default_node_options = {
-        "shape": "box",
-        "fontsize": 10,
-        "height": 0.25,
-        "fontname": "Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",
-        "style": '"setlinewidth(0.5)"'
-        }
-    default_edge_options = {
-        "arrowsize": 0.5,
-        "style": '"setlinewidth(0.5)"'
-        }
-
-    def _format_node_options(self, options):
-        return ','.join(["%s=%s" % x for x in options.items()])
-    def _format_graph_options(self, options):
-        return ''.join(["%s=%s;\n" % x for x in options.items()])
-
-    def generate_dot(self, fd, name, parts=0, urls={},
-                     graph_options={}, node_options={},
-                     edge_options={}):
-        """
-        Generate a graphviz dot graph from the classes that
-        were passed in to __init__.
-
-        *fd* is a Python file-like object to write to.
-
-        *name* is the name of the graph
-
-        *urls* is a dictionary mapping class names to http urls
-
-        *graph_options*, *node_options*, *edge_options* are
-        dictionaries containing key/value pairs to pass on as graphviz
-        properties.
-        """
-        g_options = self.default_graph_options.copy()
-        g_options.update(graph_options)
-        n_options = self.default_node_options.copy()
-        n_options.update(node_options)
-        e_options = self.default_edge_options.copy()
-        e_options.update(edge_options)
-
-        fd.write('digraph %s {\n' % name)
-        fd.write(self._format_graph_options(g_options))
-
-        for cls in self.all_classes:
-            if not self.show_builtins and cls in __builtins__.values():
-                continue
-
-            name = self.class_name(cls, parts)
-
-            # Write the node
-            this_node_options = n_options.copy()
-            url = urls.get(self.class_name(cls))
-            if url is not None:
-                this_node_options['URL'] = '"%s"' % url
-            fd.write('  "%s" [%s];\n' %
-                     (name, self._format_node_options(this_node_options)))
-
-            # Write the edges
-            for base in cls.__bases__:
-                if not self.show_builtins and base in __builtins__.values():
-                    continue
-
-                base_name = self.class_name(base, parts)
-                fd.write('  "%s" -> "%s" [%s];\n' %
-                         (base_name, name,
-                          self._format_node_options(e_options)))
-        fd.write('}\n')
-
-    def run_dot(self, args, name, parts=0, urls={},
-                graph_options={}, node_options={}, edge_options={}):
-        """
-        Run graphviz 'dot' over this graph, returning whatever 'dot'
-        writes to stdout.
-
-        *args* will be passed along as commandline arguments.
-
-        *name* is the name of the graph
-
-        *urls* is a dictionary mapping class names to http urls
-
-        Raises DotException for any of the many os and
-        installation-related errors that may occur.
-        """
-        try:
-            dot = subprocess.Popen(['dot'] + list(args),
-                                   stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                                   close_fds=True)
-        except OSError:
-            raise DotException("Could not execute 'dot'.  Are you sure you have 'graphviz' installed?")
-        except ValueError:
-            raise DotException("'dot' called with invalid arguments")
-        except:
-            raise DotException("Unexpected error calling 'dot'")
-
-        self.generate_dot(dot.stdin, name, parts, urls, graph_options,
-                          node_options, edge_options)
-        dot.stdin.close()
-        result = dot.stdout.read()
-        returncode = dot.wait()
-        if returncode != 0:
-            raise DotException("'dot' returned the errorcode %d" % returncode)
-        return result
-
-class inheritance_diagram(Body, Element):
-    """
-    A docutils node to use as a placeholder for the inheritance
-    diagram.
-    """
-    pass
-
-def inheritance_diagram_directive(name, arguments, options, content, lineno,
-                                  content_offset, block_text, state,
-                                  state_machine):
-    """
-    Run when the inheritance_diagram directive is first encountered.
-    """
-    node = inheritance_diagram()
-
-    class_names = arguments
-
-    # Create a graph starting with the list of classes
-    graph = InheritanceGraph(class_names)
-
-    # Create xref nodes for each target of the graph's image map and
-    # add them to the doc tree so that Sphinx can resolve the
-    # references to real URLs later.  These nodes will eventually be
-    # removed from the doctree after we're done with them.
-    for name in graph.get_all_class_names():
-        refnodes, x = xfileref_role(
-            'class', ':class:`%s`' % name, name, 0, state)
-        node.extend(refnodes)
-    # Store the graph object so we can use it to generate the
-    # dot file later
-    node['graph'] = graph
-    # Store the original content for use as a hash
-    node['parts'] = options.get('parts', 0)
-    node['content'] = " ".join(class_names)
-    return [node]
-
-def get_graph_hash(node):
-    return md5(node['content'] + str(node['parts'])).hexdigest()[-10:]
-
-def html_output_graph(self, node):
-    """
-    Output the graph for HTML.  This will insert a PNG with clickable
-    image map.
-    """
-    graph = node['graph']
-    parts = node['parts']
-
-    graph_hash = get_graph_hash(node)
-    name = "inheritance%s" % graph_hash
-    path = '_images'
-    dest_path = os.path.join(setup.app.builder.outdir, path)
-    if not os.path.exists(dest_path):
-        os.makedirs(dest_path)
-    png_path = os.path.join(dest_path, name + ".png")
-    path = setup.app.builder.imgpath
-
-    # Create a mapping from fully-qualified class names to URLs.
-    urls = {}
-    for child in node:
-        if child.get('refuri') is not None:
-            urls[child['reftitle']] = child.get('refuri')
-        elif child.get('refid') is not None:
-            urls[child['reftitle']] = '#' + child.get('refid')
-
-    # These arguments to dot will save a PNG file to disk and write
-    # an HTML image map to stdout.
-    image_map = graph.run_dot(['-Tpng', '-o%s' % png_path, '-Tcmapx'],
-                              name, parts, urls)
-    return ('<img src="%s/%s.png" usemap="#%s" class="inheritance"/>%s' %
-            (path, name, name, image_map))
-
-def latex_output_graph(self, node):
-    """
-    Output the graph for LaTeX.  This will insert a PDF.
-    """
-    graph = node['graph']
-    parts = node['parts']
-
-    graph_hash = get_graph_hash(node)
-    name = "inheritance%s" % graph_hash
-    dest_path = os.path.abspath(os.path.join(setup.app.builder.outdir, '_images'))
-    if not os.path.exists(dest_path):
-        os.makedirs(dest_path)
-    pdf_path = os.path.abspath(os.path.join(dest_path, name + ".pdf"))
-
-    graph.run_dot(['-Tpdf', '-o%s' % pdf_path],
-                  name, parts, graph_options={'size': '"6.0,6.0"'})
-    return '\n\\includegraphics{%s}\n\n' % pdf_path
-
-def visit_inheritance_diagram(inner_func):
-    """
-    This is just a wrapper around html/latex_output_graph to make it
-    easier to handle errors and insert warnings.
-    """
-    def visitor(self, node):
-        try:
-            content = inner_func(self, node)
-        except DotException, e:
-            # Insert the exception as a warning in the document
-            warning = self.document.reporter.warning(str(e), line=node.line)
-            warning.parent = node
-            node.children = [warning]
-        else:
-            source = self.document.attributes['source']
-            self.body.append(content)
-            node.children = []
-    return visitor
-
-def do_nothing(self, node):
-    pass
-
-def setup(app):
-    setup.app = app
-    setup.confdir = app.confdir
-
-    app.add_node(
-        inheritance_diagram,
-        latex=(visit_inheritance_diagram(latex_output_graph), do_nothing),
-        html=(visit_inheritance_diagram(html_output_graph), do_nothing))
-    app.add_directive(
-        'inheritance-diagram', inheritance_diagram_directive,
-        False, (1, 100, 0), parts = directives.nonnegative_int)
diff --git a/docs/sphinxext/ipython_console_highlighting.py b/docs/sphinxext/ipython_console_highlighting.py
deleted file mode 100644
index 217b779dda7..00000000000
--- a/docs/sphinxext/ipython_console_highlighting.py
+++ /dev/null
@@ -1,114 +0,0 @@
-"""reST directive for syntax-highlighting ipython interactive sessions.
-
-XXX - See what improvements can be made based on the new (as of Sept 2009)
-'pycon' lexer for the python console.  At the very least it will give better
-highlighted tracebacks.
-"""
-
-#-----------------------------------------------------------------------------
-# Needed modules
-
-# Standard library
-import re
-
-# Third party
-from pygments.lexer import Lexer, do_insertions
-from pygments.lexers.agile import (PythonConsoleLexer, PythonLexer, 
-                                   PythonTracebackLexer)
-from pygments.token import Comment, Generic
-
-from sphinx import highlighting
-
-#-----------------------------------------------------------------------------
-# Global constants
-line_re = re.compile('.*?\n')
-
-#-----------------------------------------------------------------------------
-# Code begins - classes and functions
-
-class IPythonConsoleLexer(Lexer):
-    """
-    For IPython console output or doctests, such as:
-
-    .. sourcecode:: ipython
-
-      In [1]: a = 'foo'
-
-      In [2]: a
-      Out[2]: 'foo'
-
-      In [3]: print a
-      foo
-
-      In [4]: 1 / 0
-
-    Notes:
-
-      - Tracebacks are not currently supported.
-
-      - It assumes the default IPython prompts, not customized ones.
-    """
-    
-    name = 'IPython console session'
-    aliases = ['ipython']
-    mimetypes = ['text/x-ipython-console']
-    input_prompt = re.compile("(In \[[0-9]+\]: )|(   \.\.\.+:)")
-    output_prompt = re.compile("(Out\[[0-9]+\]: )|(   \.\.\.+:)")
-    continue_prompt = re.compile("   \.\.\.+:")
-    tb_start = re.compile("\-+")
-
-    def get_tokens_unprocessed(self, text):
-        pylexer = PythonLexer(**self.options)
-        tblexer = PythonTracebackLexer(**self.options)
-
-        curcode = ''
-        insertions = []
-        for match in line_re.finditer(text):
-            line = match.group()
-            input_prompt = self.input_prompt.match(line)
-            continue_prompt = self.continue_prompt.match(line.rstrip())
-            output_prompt = self.output_prompt.match(line)
-            if line.startswith("#"):
-                insertions.append((len(curcode),
-                                   [(0, Comment, line)]))
-            elif input_prompt is not None:
-                insertions.append((len(curcode),
-                                   [(0, Generic.Prompt, input_prompt.group())]))
-                curcode += line[input_prompt.end():]
-            elif continue_prompt is not None:
-                insertions.append((len(curcode),
-                                   [(0, Generic.Prompt, continue_prompt.group())]))
-                curcode += line[continue_prompt.end():]
-            elif output_prompt is not None:
-                # Use the 'error' token for output.  We should probably make
-                # our own token, but error is typicaly in a bright color like
-                # red, so it works fine for our output prompts.
-                insertions.append((len(curcode),
-                                   [(0, Generic.Error, output_prompt.group())]))
-                curcode += line[output_prompt.end():]
-            else:
-                if curcode:
-                    for item in do_insertions(insertions,
-                                              pylexer.get_tokens_unprocessed(curcode)):
-                        yield item
-                        curcode = ''
-                        insertions = []
-                yield match.start(), Generic.Output, line
-        if curcode:
-            for item in do_insertions(insertions,
-                                      pylexer.get_tokens_unprocessed(curcode)):
-                yield item
-
-
-def setup(app):
-    """Setup as a sphinx extension."""
-
-    # This is only a lexer, so adding it below to pygments appears sufficient.
-    # But if somebody knows that the right API usage should be to do that via
-    # sphinx, by all means fix it here.  At least having this setup.py
-    # suppresses the sphinx warning we'd get without it.
-    pass
-
-#-----------------------------------------------------------------------------
-# Register the extension as a valid pygments lexer
-highlighting.lexers['ipython'] = IPythonConsoleLexer()
diff --git a/docs/sphinxext/ipython_directive.py b/docs/sphinxext/ipython_directive.py
deleted file mode 100644
index cc914ee18de..00000000000
--- a/docs/sphinxext/ipython_directive.py
+++ /dev/null
@@ -1,635 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Sphinx directive to support embedded IPython code.
-
-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.
-
-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("   \.\.\.+:")
-
-
-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
--------
-
-- John D Hunter: orignal author.
-- Fernando Perez: refactoring, documentation, cleanups, port to 0.11.
-- VáclavŠmilauer <eudoxos-AT-arcig.cz>: Prompt generalizations.
-"""
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-# Stdlib
-import cStringIO
-import os
-import re
-import sys
-
-# To keep compatibility with various python versions
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5
-
-# Third-party
-import matplotlib
-import sphinx
-from docutils.parsers.rst import directives
-
-matplotlib.use('Agg')
-
-# Our own
-from IPython import Config, InteractiveShell
-from IPython.utils.io import Term
-
-#-----------------------------------------------------------------------------
-# 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]])
-
-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):
-    """
-    part is a string of ipython text, comprised of at most one
-    input, one ouput, comments, and blank lines.  The block parser
-    parses the text into a list of::
-
-      blocks = [ (TOKEN0, data0), (TOKEN1, data1), ...]
-
-    where TOKEN is one of [COMMENT | INPUT | OUTPUT ] and
-    data is, depending on the type of token::
-
-      COMMENT : the comment string
-
-      INPUT: the (DECORATOR, INPUT_LINE, REST) where
-         DECORATOR: the input decorator (or None)
-         INPUT_LINE: the input as string (possibly multi-line)
-         REST : any stdout generated by the input line (not OUTPUT)
-
-
-      OUTPUT: the output string, possibly multi-line
-    """
-
-    block = []
-    lines = part.split('\n')
-    N = len(lines)
-    i = 0
-    decorator = None
-    while 1:
-
-        if i==N:
-            # nothing left to parse -- the last line
-            break
-
-        line = lines[i]
-        i += 1
-        line_stripped = line.strip()
-        if line_stripped.startswith('#'):
-            block.append((COMMENT, line))
-            continue
-
-        if line_stripped.startswith('@'):
-            # we're assuming at most one decorator -- may need to
-            # rethink
-            decorator = line_stripped
-            continue
-
-        # does this look like an input line?
-        matchin = rgxin.match(line)
-        if matchin:
-            lineno, inputline = int(matchin.group(1)), matchin.group(2)
-
-            # the ....: continuation string
-            continuation = '   %s:'%''.join(['.']*(len(str(lineno))+2))
-            Nc = len(continuation)
-            # input lines can continue on for more than one line, if
-            # we have a '\' line continuation char or a function call
-            # echo line 'print'.  The input line can only be
-            # terminated by the end of the block or an output line, so
-            # we parse out the rest of the input line if it is
-            # multiline as well as any echo text
-
-            rest = []
-            while i<N:
-
-                # look ahead; if the next line is blank, or a comment, or
-                # an output line, we're done
-
-                nextline = lines[i]
-                matchout = rgxout.match(nextline)
-                #print "nextline=%s, continuation=%s, starts=%s"%(nextline, continuation, nextline.startswith(continuation))
-                if matchout or nextline.startswith('#'):
-                    break
-                elif nextline.startswith(continuation):
-                    inputline += '\n' + nextline[Nc:]
-                else:
-                    rest.append(nextline)
-                i+= 1
-
-            block.append((INPUT, (decorator, inputline, '\n'.join(rest))))
-            continue
-
-        # if it looks like an output line grab all the text to the end
-        # of the block
-        matchout = rgxout.match(line)
-        if matchout:
-            lineno, output = int(matchout.group(1)), matchout.group(2)
-            if i<N-1:
-                output = '\n'.join([output] + lines[i:])
-
-            block.append((OUTPUT, output))
-            break
-
-    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()
-        config.Global.display_banner = False
-        config.Global.exec_lines = ['import numpy as np',
-                                    'from pylab import *'
-                                    ]
-        config.InteractiveShell.autocall = False
-        config.InteractiveShell.autoindent = False
-        config.InteractiveShell.colors = 'NoColor'
-
-        # Create and initialize ipython, but don't start its mainloop
-        IP = InteractiveShell.instance(config=config)
-
-        # 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 = ''
-
-        self.is_verbatim = False
-        self.is_doctest = False
-        self.is_suppress = False
-
-        # on the first call to the savefig decorator, we'll import
-        # 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')
-        self.cout.seek(0)
-        self.cout.truncate(0)
-
-    def process_input_line(self, line):
-        """process the input, capturing stdout"""
-        #print "input='%s'"%self.input
-        stdout = sys.stdout
-        try:
-            sys.stdout = self.cout
-            self.IP.push_line(line)
-        finally:
-            sys.stdout = stdout
-
-    # 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
-        #print 'INPUT:', data  # dbg
-        is_verbatim = decorator=='@verbatim' or self.is_verbatim
-        is_doctest = decorator=='@doctest' or self.is_doctest
-        is_suppress = decorator=='@suppress' or self.is_suppress
-        is_savefig = decorator is not None and \
-                     decorator.startswith('@savefig')
-
-        input_lines = input.split('\n')
-
-        continuation = '   %s:'%''.join(['.']*(len(str(lineno))+2))
-        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))
-
-        ret = []
-        is_semicolon = False
-
-        for i, line in enumerate(input_lines):
-            if line.endswith(';'):
-                is_semicolon = True
-
-            if i==0:
-                # process the first input line
-                if is_verbatim:
-                    self.process_input_line('')
-                else:
-                    # only submit the line in non-verbatim mode
-                    self.process_input_line(line)
-                formatted_line = '%s %s'%(input_prompt, line)
-            else:
-                # process a continuation line
-                if not is_verbatim:
-                    self.process_input_line(line)
-
-                formatted_line = '%s %s'%(continuation, line)
-
-            if not is_suppress:
-                ret.append(formatted_line)
-
-        if not is_suppress:
-            if len(rest.strip()):
-                if is_verbatim:
-                    # the "rest" is the standard output of the
-                    # input, which needs to be added in
-                    # verbatim mode
-                    ret.append(rest)
-
-        self.cout.seek(0)
-        output = self.cout.read()
-        if not is_suppress and not is_semicolon:
-            ret.append(output)
-
-        self.cout.truncate(0)
-        return ret, input_lines, output, is_doctest, image_file
-        #print 'OUTPUT', output  # dbg
-
-    def process_output(self, data, output_prompt,
-                       input_lines, output, is_doctest, image_file):
-        """Process data block for OUTPUT token."""
-        if is_doctest:
-            submitted = data.strip()
-            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()
-
-                if found!=submitted:
-                    e = ('doctest failure for input_lines="%s" with '
-                         'found_output="%s" and submitted output="%s"' %
-                         (input_lines, found, submitted) )
-                    raise RuntimeError(e)
-                #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."""
-        if not self.is_suppress:
-            return [data]
-
-    def process_block(self, block):
-        """
-        process block from the block_parser and return a list of processed lines
-        """
-
-        ret = []
-        output = None
-        input_lines = None
-
-        m = rgxin.match(str(self.IP.outputcache.prompt1).strip())
-        lineno = int(m.group(1))
-
-        input_prompt = fmtin%lineno
-        output_prompt = fmtout%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= \
-                          self.process_input(data, input_prompt, lineno)
-            elif token==OUTPUT:
-                out_data = \
-                    self.process_output(data, output_prompt,
-                                        input_lines, output, is_doctest,
-                                        image_file)
-            if out_data:
-                ret.extend(out_data)
-
-        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)
-        return ret, image_directive
-
-    def ensure_pyplot(self):
-        if self._pyplot_imported:
-            return
-        self.process_input_line('import matplotlib.pyplot as plt')
-
-# A global instance used below. XXX: not sure why this can't be created inside
-# ipython_directive itself.
-shell = EmbeddedSphinxShell()
-
-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 ipython_directive(name, arguments, options, content, lineno,
-                      content_offset, block_text, state, state_machine,
-                      ):
-
-    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')
-
-    #print 'ipy', shell.is_suppress, options
-    parts = '\n'.join(content).split('\n\n')
-    lines = ['.. sourcecode:: ipython', '']
-
-    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')])
-
-            if figure is not None:
-                figures.append(figure)
-
-    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:
-            #print 'INSERTING %d lines'%len(lines)
-            state_machine.insert_input(
-                lines, state_machine.input_lines.source(0))
-
-    return []
-
-ipython_directive.DEBUG = False
-ipython_directive.DEBUG = True  # dbg
-
-# 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)
-
-
-# Simple smoke test, needs to be converted to a proper automatic test.
-def test():
-
-    examples = [
-        r"""
-In [9]: pwd
-Out[9]: '/home/jdhunter/py4science/book'
-
-In [10]: cd bookdata/
-/home/jdhunter/py4science/book/bookdata
-
-In [2]: from pylab import *
-
-In [2]: ion()
-
-In [3]: im = imread('stinkbug.png')
-
-@savefig mystinkbug.png width=4in
-In [4]: imshow(im)
-Out[4]: <matplotlib.image.AxesImage object at 0x39ea850>
-        
-""",
-        r"""
-
-In [1]: x = 'hello world'
-
-# string methods can be
-# used to alter the string
-@doctest
-In [2]: x.upper()
-Out[2]: 'HELLO WORLD'
-
-@verbatim
-In [3]: x.st<TAB>
-x.startswith  x.strip
-""",
-    r"""
-
-In [130]: url = 'http://ichart.finance.yahoo.com/table.csv?s=CROX\
-   .....: &d=9&e=22&f=2009&g=d&a=1&br=8&c=2006&ignore=.csv'
-
-In [131]: print url.split('&')
-['http://ichart.finance.yahoo.com/table.csv?s=CROX', 'd=9', 'e=22', 'f=2009', 'g=d', 'a=1', 'b=8', 'c=2006', 'ignore=.csv']
-
-In [60]: import urllib
-
-""",
-    r"""\
-
-In [133]: import numpy.random
-
-@suppress
-In [134]: numpy.random.seed(2358)
-
-@doctest
-In [135]: np.random.rand(10,2)
-Out[135]:
-array([[ 0.64524308,  0.59943846],
-       [ 0.47102322,  0.8715456 ],
-       [ 0.29370834,  0.74776844],
-       [ 0.99539577,  0.1313423 ],
-       [ 0.16250302,  0.21103583],
-       [ 0.81626524,  0.1312433 ],
-       [ 0.67338089,  0.72302393],
-       [ 0.7566368 ,  0.07033696],
-       [ 0.22591016,  0.77731835],
-       [ 0.0072729 ,  0.34273127]])
-
-""",
-
-    r"""
-In [106]: print x
-jdh
-
-In [109]: for i in range(10):
-   .....:     print i
-   .....:
-   .....:
-0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-""",
-
-        r"""
-
-In [144]: from pylab import *
-
-In [145]: ion()
-
-# use a semicolon to suppress the output
-@savefig test_hist.png width=4in
-In [151]: hist(np.random.randn(10000), 100);
-
-
-@savefig test_plot.png width=4in
-In [151]: plot(np.random.randn(10000), 'o');
-   """,
-
-        r"""
-# use a semicolon to suppress the output
-In [151]: plt.clf()
-
-@savefig plot_simple.png width=4in
-In [151]: plot([1,2,3])
-
-@savefig hist_simple.png width=4in
-In [151]: hist(np.random.randn(10000), 100);
-
-""",
-     r"""
-# update the current fig
-In [151]: ylabel('number')
-
-In [152]: title('normal distribution')
-
-
-@savefig hist_with_text.png
-In [153]: grid(True)
-
-        """,
-        ]
-
-    #ipython_directive.DEBUG = True  # dbg
-    #options = dict(suppress=True)  # dbg
-    options = dict()
-    for example in examples:
-        content = example.split('\n')
-        ipython_directive('debug', arguments=None, options=options,
-                          content=content, lineno=0,
-                          content_offset=None, block_text=None,
-                          state=None, state_machine=None,
-                          )
-
-# Run test suite as a script
-if __name__=='__main__':
-    if not os.path.isdir('_static'):
-        os.mkdir('_static')
-    test()
-    print 'All OK? Check figures in _static/'
diff --git a/docs/sphinxext/magics.py b/docs/sphinxext/magics.py
new file mode 100644
index 00000000000..d96b41c6e17
--- /dev/null
+++ b/docs/sphinxext/magics.py
@@ -0,0 +1,46 @@
+import re
+from sphinx import addnodes
+from sphinx.domains.std import StandardDomain
+from sphinx.roles import XRefRole
+
+name_re = re.compile(r"[\w_]+")
+
+def parse_magic(env, sig, signode):
+    m = name_re.match(sig)
+    if not m:
+        raise Exception("Invalid magic command: %s" % sig)
+    name = "%" + sig
+    signode += addnodes.desc_name(name, name)
+    return m.group(0)
+
+class LineMagicRole(XRefRole):
+    """Cross reference role displayed with a % prefix"""
+    prefix = "%"
+
+    def process_link(self, env, refnode, has_explicit_title, title, target):
+        if not has_explicit_title:
+            title = self.prefix + title.lstrip("%")
+        target = target.lstrip("%")
+        return title, target
+
+def parse_cell_magic(env, sig, signode):
+    m = name_re.match(sig)
+    if not m:
+        raise ValueError("Invalid cell magic: %s" % sig)
+    name = "%%" + sig
+    signode += addnodes.desc_name(name, name)
+    return m.group(0)
+
+class CellMagicRole(LineMagicRole):
+    """Cross reference role displayed with a %% prefix"""
+    prefix = "%%"
+
+def setup(app):
+    app.add_object_type('magic', 'magic', 'pair: %s; magic command', parse_magic)
+    app.add_role_to_domain('std', 'magic', LineMagicRole(), override=True)
+
+    app.add_object_type('cellmagic', 'cellmagic', 'pair: %s; cell magic', parse_cell_magic)
+    app.add_role_to_domain('std', 'cellmagic', CellMagicRole(), override=True)
+
+    metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
+    return metadata
diff --git a/docs/sphinxext/numpydoc.py b/docs/sphinxext/numpydoc.py
deleted file mode 100644
index ada1ca4047d..00000000000
--- a/docs/sphinxext/numpydoc.py
+++ /dev/null
@@ -1,117 +0,0 @@
-"""
-========
-numpydoc
-========
-
-Sphinx extension that handles docstrings in the Numpy standard format. [1]
-
-It will:
-
-- Convert Parameters etc. sections to field lists.
-- Convert See Also section to a See also entry.
-- Renumber references.
-- Extract the signature from the docstring, if it can't be determined otherwise.
-
-.. [1] http://projects.scipy.org/scipy/numpy/wiki/CodingStyleGuidelines#docstring-standard
-
-"""
-
-import os, re, pydoc
-from docscrape_sphinx import get_doc_object, SphinxDocString
-import inspect
-
-def mangle_docstrings(app, what, name, obj, options, lines,
-                      reference_offset=[0]):
-    if what == 'module':
-        # Strip top title
-        title_re = re.compile(r'^\s*[#*=]{4,}\n[a-z0-9 -]+\n[#*=]{4,}\s*',
-                              re.I|re.S)
-        lines[:] = title_re.sub('', "\n".join(lines)).split("\n")
-    else:
-        doc = get_doc_object(obj, what, "\n".join(lines))
-        lines[:] = str(doc).split("\n")
-
-    if app.config.numpydoc_edit_link and hasattr(obj, '__name__') and \
-           obj.__name__:
-        if hasattr(obj, '__module__'):
-            v = dict(full_name="%s.%s" % (obj.__module__, obj.__name__))
-        else:
-            v = dict(full_name=obj.__name__)
-        lines += ['', '.. htmlonly::', '']
-        lines += ['    %s' % x for x in
-                  (app.config.numpydoc_edit_link % v).split("\n")]
-
-    # replace reference numbers so that there are no duplicates
-    references = []
-    for l in lines:
-        l = l.strip()
-        if l.startswith('.. ['):
-            try:
-                references.append(int(l[len('.. ['):l.index(']')]))
-            except ValueError:
-                print "WARNING: invalid reference in %s docstring" % name
-
-    # Start renaming from the biggest number, otherwise we may
-    # overwrite references.
-    references.sort()
-    if references:
-        for i, line in enumerate(lines):
-            for r in references:
-                new_r = reference_offset[0] + r
-                lines[i] = lines[i].replace('[%d]_' % r,
-                                            '[%d]_' % new_r)
-                lines[i] = lines[i].replace('.. [%d]' % r,
-                                            '.. [%d]' % new_r)
-
-    reference_offset[0] += len(references)
-
-def mangle_signature(app, what, name, obj, options, sig, retann):
-    # Do not try to inspect classes that don't define `__init__`
-    if (inspect.isclass(obj) and
-        (not hasattr(obj, '__init__') or
-        'initializes x; see ' in pydoc.getdoc(obj.__init__))):
-        return '', ''
-
-    if not (callable(obj) or hasattr(obj, '__argspec_is_invalid_')): return
-    if not hasattr(obj, '__doc__'): return
-
-    doc = SphinxDocString(pydoc.getdoc(obj))
-    if doc['Signature']:
-        sig = re.sub("^[^(]*", "", doc['Signature'])
-        return sig, ''
-
-def initialize(app):
-    try:
-        app.connect('autodoc-process-signature', mangle_signature)
-    except:
-        monkeypatch_sphinx_ext_autodoc()
-
-def setup(app, get_doc_object_=get_doc_object):
-    global get_doc_object
-    get_doc_object = get_doc_object_
-    
-    app.connect('autodoc-process-docstring', mangle_docstrings)
-    app.connect('builder-inited', initialize)
-    app.add_config_value('numpydoc_edit_link', None, True)
-
-#------------------------------------------------------------------------------
-# Monkeypatch sphinx.ext.autodoc to accept argspecless autodocs (Sphinx < 0.5)
-#------------------------------------------------------------------------------
-
-def monkeypatch_sphinx_ext_autodoc():
-    global _original_format_signature
-    import sphinx.ext.autodoc
-
-    if sphinx.ext.autodoc.format_signature is our_format_signature:
-        return
-
-    print "[numpydoc] Monkeypatching sphinx.ext.autodoc ..."
-    _original_format_signature = sphinx.ext.autodoc.format_signature
-    sphinx.ext.autodoc.format_signature = our_format_signature
-
-def our_format_signature(what, obj):
-    r = mangle_signature(None, what, None, obj, None, None, None)
-    if r is not None:
-        return r[0]
-    else:
-        return _original_format_signature(what, obj)
diff --git a/docs/update_version.sh b/docs/update_version.sh
deleted file mode 100755
index 4e09ef0117e..00000000000
--- a/docs/update_version.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/sh
-ver=`ipython -V`
-sed "s/__version__/${ver}/" manual_base.lyx > manual.lyx
diff --git a/examples/Embedding/embed_class_long.py b/examples/Embedding/embed_class_long.py
new file mode 100755
index 00000000000..0cd09d0247a
--- /dev/null
+++ b/examples/Embedding/embed_class_long.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+"""An example of how to embed an IPython shell into a running program.
+
+Please see the documentation in the IPython.Shell module for more details.
+
+The accompanying file embed_class_short.py has quick code fragments for
+embedding which you can cut and paste in your code once you understand how
+things work.
+
+The code in this file is deliberately extra-verbose, meant for learning."""
+
+# The basics to get you going:
+
+# IPython injects get_ipython into builtins, so you can know if you have nested
+# copies running.
+
+# Try running this code both at the command line and from inside IPython (with
+# %run example-embed.py)
+
+from IPython.terminal.prompts import Prompts, Token
+from traitlets.config.loader import Config
+
+class CustomPrompt(Prompts):
+
+    def in_prompt_tokens(self):
+
+        return [
+            (Token.Prompt, 'In <'),
+            (Token.PromptNum, str(self.shell.execution_count)),
+            (Token.Prompt, '>: '),
+            ]
+
+    def out_prompt_tokens(self):
+        return [
+            (Token.OutPrompt, 'Out<'),
+            (Token.OutPromptNum, str(self.shell.execution_count)),
+            (Token.OutPrompt, '>: '),
+        ]
+ 
+
+try:
+    get_ipython
+except NameError:
+    nested = 0
+    cfg = Config()
+    cfg.TerminalInteractiveShell.prompts_class=CustomPrompt
+else:
+    print("Running nested copies of IPython.")
+    print("The prompts for the nested copy have been modified")
+    cfg = Config()
+    nested = 1
+
+# First import the embeddable shell class
+from IPython.terminal.embed import InteractiveShellEmbed
+
+# Now create an instance of the embeddable shell. The first argument is a
+# string with options exactly as you would type them if you were starting
+# IPython at the system command line. Any parameters you want to define for
+# configuration can thus be specified here.
+ipshell = InteractiveShellEmbed(config=cfg,
+                       banner1 = 'Dropping into IPython',
+                       exit_msg = 'Leaving Interpreter, back to program.')
+
+# Make a second instance, you can have as many as you want.
+ipshell2 = InteractiveShellEmbed(config=cfg,
+                        banner1 = 'Second IPython instance.')
+
+print('\nHello. This is printed from the main controller program.\n')
+
+# You can then call ipshell() anywhere you need it (with an optional
+# message):
+ipshell('***Called from top level. '
+        'Hit Ctrl-D to exit interpreter and continue program.\n'
+        'Note that if you use %kill_embedded, you can fully deactivate\n'
+        'This embedded instance so it will never turn on again')
+
+print('\nBack in caller program, moving along...\n')
+
+#---------------------------------------------------------------------------
+# More details:
+
+# InteractiveShellEmbed instances don't print the standard system banner and
+# messages. The IPython banner (which actually may contain initialization
+# messages) is available as get_ipython().banner in case you want it.
+
+# InteractiveShellEmbed instances print the following information every time they
+# start:
+
+# - A global startup banner.
+
+# - A call-specific header string, which you can use to indicate where in the
+# execution flow the shell is starting.
+
+# They also print an exit message every time they exit.
+
+# Both the startup banner and the exit message default to None, and can be set
+# either at the instance constructor or at any other time with the
+# by setting the banner and exit_msg attributes.
+
+# The shell instance can be also put in 'dummy' mode globally or on a per-call
+# basis. This gives you fine control for debugging without having to change
+# code all over the place.
+
+# The code below illustrates all this.
+
+
+# This is how the global banner and exit_msg can be reset at any point
+ipshell.banner2 = 'Entering interpreter - New Banner'
+ipshell.exit_msg = 'Leaving interpreter - New exit_msg'
+
+def foo(m):
+    s = 'spam'
+    ipshell('***In foo(). Try %whos, or print s or m:')
+    print('foo says m = ',m)
+
+def bar(n):
+    s = 'eggs'
+    ipshell('***In bar(). Try %whos, or print s or n:')
+    print('bar says n = ',n)
+    
+# Some calls to the above functions which will trigger IPython:
+print('Main program calling foo("eggs")\n')
+foo('eggs')
+
+# The shell can be put in 'dummy' mode where calls to it silently return. This
+# allows you, for example, to globally turn off debugging for a program with a
+# single call.
+ipshell.dummy_mode = True
+print('\nTrying to call IPython which is now "dummy":')
+ipshell()
+print('Nothing happened...')
+# The global 'dummy' mode can still be overridden for a single call
+print('\nOverriding dummy mode manually:')
+ipshell(dummy=False)
+
+# Reactivate the IPython shell
+ipshell.dummy_mode = False
+
+print('You can even have multiple embedded instances:')
+ipshell2()
+
+print('\nMain program calling bar("spam")\n')
+bar('spam')
+
+print('Main program finished. Bye!')
diff --git a/examples/Embedding/embed_class_short.py b/examples/Embedding/embed_class_short.py
new file mode 100644
index 00000000000..07cef1df657
--- /dev/null
+++ b/examples/Embedding/embed_class_short.py
@@ -0,0 +1,45 @@
+"""Quick code snippets for embedding IPython into other programs.
+
+See embed_class_long.py for full details, this file has the bare minimum code for
+cut and paste use once you understand how to use the system."""
+
+#---------------------------------------------------------------------------
+# This code loads IPython but modifies a few things if it detects it's running
+# embedded in another IPython session (helps avoid confusion)
+
+try:
+    get_ipython
+except NameError:
+    banner=exit_msg=''
+else:
+    banner = '*** Nested interpreter ***'
+    exit_msg = '*** Back in main IPython ***'
+
+# First import the embed function
+from IPython.terminal.embed import InteractiveShellEmbed
+# Now create the IPython shell instance. Put ipshell() anywhere in your code
+# where you want it to open.
+ipshell = InteractiveShellEmbed(banner1=banner, exit_msg=exit_msg)
+
+#---------------------------------------------------------------------------
+# This code will load an embeddable IPython shell always with no changes for
+# nested embededings.
+
+from IPython import embed
+# Now embed() will open IPython anywhere in the code.
+
+#---------------------------------------------------------------------------
+# This code loads an embeddable shell only if NOT running inside
+# IPython. Inside IPython, the embeddable shell variable ipshell is just a
+# dummy function.
+
+try:
+    get_ipython
+except NameError:
+    from IPython.terminal.embed import InteractiveShellEmbed
+    ipshell = InteractiveShellEmbed()
+    # Now ipshell() will open IPython anywhere in the code
+else:
+    # Define a dummy ipshell() so the same code doesn't crash inside an
+    # interactive IPython
+    def ipshell(): pass
diff --git a/examples/Embedding/embed_function.py b/examples/Embedding/embed_function.py
new file mode 100644
index 00000000000..8b74afa3504
--- /dev/null
+++ b/examples/Embedding/embed_function.py
@@ -0,0 +1,16 @@
+"""Embed IPython using the simple embed function rather than the class API."""
+
+from IPython import embed
+
+a = 10
+b = 20
+
+embed(header="First time", banner1="")
+
+c = 30
+d = 40
+
+try:
+    raise Exception("adsfasdf")
+except:
+    embed(header="The second time")
diff --git a/examples/Embedding/start_ipython_config.py b/examples/Embedding/start_ipython_config.py
new file mode 100755
index 00000000000..36d232649d7
--- /dev/null
+++ b/examples/Embedding/start_ipython_config.py
@@ -0,0 +1,22 @@
+"""Quick snippet explaining how to set config options when using start_ipython."""
+
+# First create a config object from the traitlets library
+from traitlets.config import Config
+c = Config()
+
+# Now we can set options as we would in a config file: 
+#   c.Class.config_value = value
+# For example, we can set the exec_lines option of the InteractiveShellApp
+# class to run some code when the IPython REPL starts
+c.InteractiveShellApp.exec_lines = [
+    'print("\\nimporting some things\\n")',
+    'import math',
+    "math"
+]
+c.InteractiveShell.colors = "lightbg"
+c.InteractiveShell.confirm_exit = False
+c.TerminalIPythonApp.display_banner = False
+
+# Now we start ipython with our configuration
+import IPython
+IPython.start_ipython(config=c)
diff --git a/examples/IPython Kernel/example-demo.py b/examples/IPython Kernel/example-demo.py
new file mode 100644
index 00000000000..89e37412825
--- /dev/null
+++ b/examples/IPython Kernel/example-demo.py	
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""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.
+
+This is a unicode test, åäö
+"""
+
+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.
+# <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!')
diff --git a/examples/IPython Kernel/gui/gui-glut.py b/examples/IPython Kernel/gui/gui-glut.py
new file mode 100755
index 00000000000..573690b48d1
--- /dev/null
+++ b/examples/IPython Kernel/gui/gui-glut.py	
@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+"""Simple GLUT example to manually test event loop integration.
+
+This is meant to run tests manually in ipython as:
+
+In [5]: %gui glut
+
+In [6]: %run gui-glut.py
+
+In [7]: gl.glClearColor(1,1,1,1)
+"""
+
+#!/usr/bin/env python
+import sys
+import OpenGL.GL as gl
+import OpenGL.GLUT as glut
+
+def close():
+    glut.glutDestroyWindow(glut.glutGetWindow())
+
+def display():
+    gl.glClear (gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
+    glut.glutSwapBuffers()
+
+def resize(width,height):
+    gl.glViewport(0, 0, width, height+4)
+    gl.glMatrixMode(gl.GL_PROJECTION)
+    gl.glLoadIdentity()
+    gl.glOrtho(0, width, 0, height+4, -1, 1)
+    gl.glMatrixMode(gl.GL_MODELVIEW)
+
+if glut.glutGetWindow() > 0:
+    interactive = True
+    glut.glutInit(sys.argv)
+    glut.glutInitDisplayMode(glut.GLUT_DOUBLE |
+                             glut.GLUT_RGBA   |
+                             glut.GLUT_DEPTH)
+else:
+    interactive = False
+
+glut.glutCreateWindow(b'gui-glut')
+glut.glutDisplayFunc(display)
+glut.glutReshapeFunc(resize)
+# This is necessary on osx to be able to close the window
+#  (else the close button is disabled)
+if sys.platform == 'darwin' and not bool(glut.HAVE_FREEGLUT):
+    glut.glutWMCloseFunc(close)
+gl.glClearColor(0,0,0,1)
+
+if not interactive:
+    glut.glutMainLoop()
diff --git a/examples/IPython Kernel/gui/gui-gtk4.py b/examples/IPython Kernel/gui/gui-gtk4.py
new file mode 100644
index 00000000000..44ff1d97ed4
--- /dev/null
+++ b/examples/IPython Kernel/gui/gui-gtk4.py	
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+"""Simple Gtk example to manually test event loop integration.
+
+This is meant to run tests manually in ipython as:
+
+In [1]: %gui gtk4
+
+In [2]: %run gui-gtk4.py
+"""
+
+import gi
+
+gi.require_version("Gtk", "4.0")
+from gi.repository import Gtk, GLib  # noqa
+
+
+def hello_world(widget, data=None):
+    print("Hello World")
+
+
+def close_request_cb(widget, data=None):
+    global running
+    running = False
+
+
+running = True
+window = Gtk.Window()
+window.connect("close-request", close_request_cb)
+button = Gtk.Button(label="Hello World")
+button.connect("clicked", hello_world, None)
+
+window.set_child(button)
+window.show()
+
+context = GLib.MainContext.default()
+while running:
+    context.iteration(True)
diff --git a/docs/examples/lib/gui-qt.py b/examples/IPython Kernel/gui/gui-qt.py
similarity index 90%
rename from docs/examples/lib/gui-qt.py
rename to examples/IPython Kernel/gui/gui-qt.py
index 4a0b935510a..abb6fb8ab34 100755
--- a/docs/examples/lib/gui-qt.py
+++ b/examples/IPython Kernel/gui/gui-qt.py	
@@ -10,7 +10,6 @@
 Ref: Modified from http://zetcode.com/tutorials/pyqt4/firstprograms/
 """
 
-import sys
 from PyQt4 import QtGui, QtCore
 
 class SimpleWindow(QtGui.QWidget):
@@ -35,6 +34,7 @@ def __init__(self, parent=None):
     sw.show()
 
     try:
-        from IPython import appstart_qt4; appstart_qt4(app)
+        from IPython.lib.guisupport import start_event_loop_qt4
+        start_event_loop_qt4(app)
     except ImportError:
         app.exec_()
diff --git a/examples/IPython Kernel/ipython-completion.bash b/examples/IPython Kernel/ipython-completion.bash
new file mode 100644
index 00000000000..30eafdf95c8
--- /dev/null
+++ b/examples/IPython Kernel/ipython-completion.bash	
@@ -0,0 +1,137 @@
+# load with: . ipython-completion.bash
+
+if [[ -n ${ZSH_VERSION-} ]]; then
+    autoload -Uz bashcompinit && bashcompinit
+fi
+
+_ipython_get_flags()
+{
+    local url=$1
+    local var=$2
+    local dash=$3
+    if [[ "$url $var" == $__ipython_complete_last ]]; then
+        opts=$__ipython_complete_last_res
+        return
+    fi
+    # matplotlib and profile don't need the = and the
+    # version without simplifies the special cased completion
+    opts=$(ipython ${url} --help-all | grep -E "^-{1,2}[^-]" | sed -e "s/<.*//" -e "s/[^=]$/& /" -e "s/^--matplotlib=$//" -e "s/^--profile=$/--profile /"  -e "$ s/^/\n-h\n--help\n--help-all\n/")
+    __ipython_complete_last="$url $var"
+    __ipython_complete_last_res="$opts"
+}
+
+_ipython()
+{
+    local cur=${COMP_WORDS[COMP_CWORD]}
+    local prev=${COMP_WORDS[COMP_CWORD - 1]}
+    local subcommands="kernel profile locate history"
+    local opts="help"
+    if [ -z "$__ipython_complete_baseopts" ]; then
+        _ipython_get_flags baseopts
+        __ipython_complete_baseopts="${opts}"
+    fi
+    local baseopts="$__ipython_complete_baseopts"
+    local mode=""
+    for i in "${COMP_WORDS[@]}"; do
+        [ "$cur" = "$i" ] && break
+        if [[ ${subcommands} == *${i}* ]]; then
+            mode="$i"
+            break
+        elif [[ ${i} == "--"* ]]; then
+            mode="nosubcommand"
+            break
+        fi
+    done
+
+
+    if [[ ${cur} == -* ]]; then
+        case $mode in
+             "kernel")
+                _ipython_get_flags $mode
+                opts=$"${opts} ${baseopts}"
+                ;;
+            "locate" | "profile")
+                _ipython_get_flags $mode
+                ;;
+            "history")
+                if [[ $COMP_CWORD -ge 3 ]]; then
+                    # 'history trim' and 'history clear' covered by next line
+                    _ipython_get_flags $mode\ "${COMP_WORDS[2]}"
+                else
+                    _ipython_get_flags $mode
+
+                fi
+                opts=$"${opts}"
+                ;;
+            *)
+                opts=$baseopts
+        esac
+        # don't drop the trailing space
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+        return 0
+    elif [[ $mode == "profile" ]]; then
+        opts="list 	create 	locate "
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    elif [[ $mode == "history" ]]; then
+        if [[ $COMP_CWORD -ge 3 ]]; then
+            # drop into flags
+            opts="--"
+        else
+            opts="trim 	clear "
+        fi
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    elif [[ $mode == "locate" ]]; then
+        if [[ $COMP_CWORD -ge 3 ]]; then
+            # drop into flags
+            opts="--"
+        else
+            opts="profile "
+        fi
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+    elif [[ ${prev} == "--matplotlib"* ]] || [[ ${prev} == "--gui"* ]]; then
+        if [ -z "$__ipython_complete_matplotlib" ]; then
+            __ipython_complete_matplotlib=`cat <<EOF | python -
+try:
+    import IPython.core.shellapp as mod;
+    for k in mod.InteractiveShellApp.matplotlib.values:
+        print "%s " % k
+except:
+    pass
+EOF
+        `
+        fi
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${__ipython_complete_matplotlib}" -- ${cur}) )
+    elif [[ ${prev} == "--profile"* ]]; then
+        if [ -z  "$__ipython_complete_profiles" ]; then
+        __ipython_complete_profiles=`cat <<EOF | python -
+try:
+    import IPython.core.profileapp
+    for k in IPython.core.profileapp.list_bundled_profiles():
+        print "%s " % k
+    p = IPython.core.profileapp.ProfileList()
+    for k in IPython.core.profileapp.list_profiles_in(p.ipython_dir):
+        print "%s " % k
+except:
+    pass
+EOF
+        `
+        fi
+        local IFS=$'\t\n'
+        COMPREPLY=( $(compgen -W "${__ipython_complete_profiles}" -- ${cur}) )
+    else
+        if [ "$COMP_CWORD" == 1 ]; then
+            local IFS=$'\t\n'
+            local sub=$(echo $subcommands | sed -e "s/ / \t/g")
+            COMPREPLY=( $(compgen -W "${sub}" -- ${cur}) )
+        else
+            COMPREPLY=( $(compgen -f -- ${cur}) )
+        fi
+    fi
+
+}
+complete -o default -o nospace -F _ipython ipython
diff --git a/examples/IPython Kernel/ipython-get-history.py b/examples/IPython Kernel/ipython-get-history.py
new file mode 100755
index 00000000000..ee0ed17074e
--- /dev/null
+++ b/examples/IPython Kernel/ipython-get-history.py	
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+"""Extract a session from the IPython input history.
+
+Usage:
+  ipython-get-history.py sessionnumber [outputfile]
+
+If outputfile is not given, the relevant history is written to stdout. If
+outputfile has a .py extension, the translated history (without IPython's
+special syntax) will be extracted.
+
+Example:
+  ./ipython-get-history.py 57 record.ipy
+
+
+This script is a simple demonstration of HistoryAccessor. It should be possible
+to build much more flexible and powerful tools to browse and pull from the
+history database.
+"""
+
+import sys
+from pathlib import Path
+
+from IPython.core.history import HistoryAccessor
+
+session_number = int(sys.argv[1])
+if len(sys.argv) > 2:
+    filepath = Path(sys.argv[2])
+    dest = open(filepath, "w", encoding="utf-8")
+    raw = not filepath.name.endswith(".py")
+else:
+    dest = sys.stdout
+    raw = True
+
+with dest:
+    dest.write("# coding: utf-8\n")
+
+    # Profiles other than 'default' can be specified here with a profile= argument:
+    hist = HistoryAccessor()
+
+    for session, lineno, cell in hist.get_range(session=session_number, raw=raw):
+        dest.write(cell + "\n")
diff --git a/docs/examples/core/ipython.desktop b/examples/IPython Kernel/ipython.desktop
similarity index 77%
rename from docs/examples/core/ipython.desktop
rename to examples/IPython Kernel/ipython.desktop
index 98793bff947..4d9d310870b 100644
--- a/docs/examples/core/ipython.desktop
+++ b/examples/IPython Kernel/ipython.desktop	
@@ -7,16 +7,9 @@ Exec=ipython
 GenericName[en_US]=IPython
 GenericName=IPython
 Icon=gnome-netstatus-idle
-MimeType=
 Name[en_US]=ipython
 Name=ipython
-Path=
 Categories=Development;Utility;
 StartupNotify=false
 Terminal=true
-TerminalOptions=
 Type=Application
-X-DBUS-ServiceName=
-X-DBUS-StartupType=none
-X-KDE-SubstituteUID=false
-X-KDE-Username=
diff --git a/examples/auto_suggest_llm.py b/examples/auto_suggest_llm.py
new file mode 100644
index 00000000000..d137241eff4
--- /dev/null
+++ b/examples/auto_suggest_llm.py
@@ -0,0 +1,174 @@
+"""
+This is an example of Fake LLM Completer for IPython, as
+well as example on how to configure IPython for LLMs.
+
+8.32 – this is provisional and may change.
+
+To test this you can run the following command from the root of IPython
+directory:
+
+    $ ipython --TerminalInteractiveShell.llm_provider_class=examples.auto_suggest_llm.ExampleCompletionProvider
+
+Or you can set the value in your config file, which also allows you to set a
+keyboard shortcut::
+
+    c.TerminalInteractiveShell.llm_provider_class = "examples.auto_suggest_llm.ExampleCompletionProvider"
+    c.TerminalInteractiveShell.shortcuts = [
+        {
+            "new_keys": ["c-q"],
+            "command": "IPython:auto_suggest.llm_autosuggestion",
+            "new_filter": "navigable_suggestions & default_buffer_focused",
+            "create": True,
+        },
+    ]
+
+
+You can use the following configuration option to::
+
+    c.TerminalInteractiveShell.llm_constructor_kwargs = {"model_id": "mymodel"}
+
+
+For convenience and testing you can bind a  shortcut at runtime::
+
+    In [1]: from examples.auto_suggest_llm import setup_shortcut
+       ...: setup_shortcut('c-q')
+
+
+Getting access to history content
+---------------------------------
+
+This uses the same providers as Jupyter AI,  In JupyterAI, providers may get
+access to the current notebook content to pass as to the LLM as context.
+
+Here Jupyter AI documents how to get such context.
+
+https://jupyter-ai.readthedocs.io/en/latest/developers/index.html
+
+
+When reusing these models you may want to pass them more context as well in
+IPython to do so you can set the
+`c.TerminalInteractiveShell.llm_prefix_from_history` to `"no_prefix"`,
+`"input_history"` or a fully qualified name of a function that will get
+imported, get passed a `HistoryManager`, and return a prefix to be added the LLM
+context.
+
+
+For more flexibility, subclass the provider, and access the history of IPython
+via:
+
+    ```
+    ip = get_ipython()
+    hm = ip.history_manager()
+    hm.get_range(...) # will let you select how many input/output... etc.
+    ```
+
+"""
+
+import asyncio
+import textwrap
+from typing import Any
+from collections.abc import AsyncIterable, AsyncIterator
+
+from jupyter_ai_magics.models.completion import (
+    InlineCompletionList,
+    InlineCompletionReply,
+    InlineCompletionRequest,
+    InlineCompletionStreamChunk,
+)
+from jupyter_ai_magics.providers import BaseProvider
+from langchain_community.llms import FakeListLLM
+
+
+from IPython.terminal.shortcuts.filters import (
+    navigable_suggestions,
+    default_buffer_focused,
+)
+from IPython.terminal.shortcuts.auto_suggest import llm_autosuggestion
+
+
+def setup_shortcut(seq):
+    import IPython
+
+    ip = IPython.get_ipython()
+    ip.pt_app.key_bindings.add_binding(
+        seq, filter=(navigable_suggestions & default_buffer_focused)
+    )(llm_autosuggestion),
+
+
+class ExampleCompletionProvider(BaseProvider, FakeListLLM):  # type: ignore[misc, valid-type]
+    """
+    This is an example Fake LLM provider for IPython
+
+    As of 8.32 this is provisional and may change without any warnings
+    """
+
+    id = "my_provider"
+    name = "My Provider"
+    model_id_key = "model"
+    models = ["model_a"]
+
+    def __init__(self, **kwargs: Any):
+        kwargs["responses"] = ["This fake response will not be used for completion"]
+        kwargs["model_id"] = "model_a"
+        super().__init__(**kwargs)
+
+    async def generate_inline_completions(
+        self, request: InlineCompletionRequest
+    ) -> InlineCompletionReply:
+        raise ValueError("IPython 8.32 only support streaming models for now.")
+
+    async def stream_inline_completions(
+        self, request: InlineCompletionRequest
+    ) -> AsyncIterator[InlineCompletionStreamChunk]:
+        token_1 = f"t{request.number}s0"
+
+        yield InlineCompletionReply(
+            list=InlineCompletionList(
+                items=[
+                    {"insertText": "It", "isIncomplete": True, "token": token_1},
+                ]
+            ),
+            reply_to=request.number,
+        )
+
+        reply: InlineCompletionStreamChunk
+        async for reply in self._stream(
+            textwrap.dedent(
+                """
+                was then that the fox appeared.
+                “Good morning,� said the fox.
+                “Good morning,� the little prince responded politely, although when he turned around he saw nothing.
+                “I am right here,� the voice said, “under the apple tree.�
+                “Who are you?� asked the little prince, and added, “You are very pretty to look at.�
+                “I am a fox,� said the fox.
+                “Come and play with me,� proposed the little prince. “I am so unhappy.�
+                """
+            ).strip(),
+            request.number,
+            token_1,
+            start_with="It",
+        ):
+            yield reply
+
+    async def _stream(
+        self, sentence: str, request_number: int, token: str, start_with: str = ""
+    ) -> AsyncIterable[InlineCompletionStreamChunk]:
+        suggestion = start_with
+
+        for fragment in sentence.split(" "):
+            await asyncio.sleep(0.05)
+            suggestion += " " + fragment
+            yield InlineCompletionStreamChunk(
+                type="stream",
+                response={"insertText": suggestion, "token": token},
+                reply_to=request_number,
+                done=False,
+            )
+
+        # finally, send a message confirming that we are done
+        yield InlineCompletionStreamChunk(
+            type="stream",
+            response={"insertText": suggestion, "token": token},
+            reply_to=request_number,
+            done=True,
+        )
diff --git a/examples/utils/cwd_prompt.py b/examples/utils/cwd_prompt.py
new file mode 100644
index 00000000000..6accf4db212
--- /dev/null
+++ b/examples/utils/cwd_prompt.py
@@ -0,0 +1,22 @@
+"""This is an example that shows how to create new prompts for IPython"""
+
+from IPython.terminal.prompts import Prompts, Token
+import os
+
+
+class MyPrompt(Prompts):
+    def in_prompt_tokens(self):
+        return [(Token, os.getcwd()), (Token.Prompt, ">>>")]
+
+
+def load_ipython_extension(shell):
+    new_prompts = MyPrompt(shell)
+    new_prompts.old_prompts = shell.prompts
+    shell.prompts = new_prompts
+
+
+def unload_ipython_extension(shell):
+    if not hasattr(shell.prompts, "old_prompts"):
+        print("cannot unload")
+    else:
+        shell.prompts = shell.prompts.old_prompts
diff --git a/examples/utils/list_pyfiles.ipy b/examples/utils/list_pyfiles.ipy
new file mode 100644
index 00000000000..71a9e5d75ce
--- /dev/null
+++ b/examples/utils/list_pyfiles.ipy
@@ -0,0 +1,6 @@
+# A simple IPython script that provides Notebook links to .py files in the cwd
+
+from IPython.display import FileLink, display
+files =!ls *.py
+for f in files:
+    display(FileLink(f))
\ No newline at end of file
diff --git a/examples/utils/list_subdirs.ipy b/examples/utils/list_subdirs.ipy
new file mode 100644
index 00000000000..a1bbb74ca9d
--- /dev/null
+++ b/examples/utils/list_subdirs.ipy
@@ -0,0 +1,7 @@
+# A simple IPython script that lists files in all subdirs
+
+from IPython.display import FileLinks, display
+dirs =!ls -d */
+for d in dirs:
+    if d != '__pycache__/':
+        display(FileLinks(d))
\ No newline at end of file
diff --git a/ipython.py b/ipython.py
deleted file mode 100755
index 7c739489298..00000000000
--- a/ipython.py
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""IPython -- An enhanced Interactive Python
-
-The actual ipython script to be installed with 'python setup.py install' is
-in './scripts' directory. This file is here (ipython source root directory)
-to facilitate non-root 'zero-installation' (just copy the source tree
-somewhere and run ipython.py) and development. """
-
-# Ensure that the imported IPython is the local one, not a system-wide one
-import os, sys
-this_dir = os.path.dirname(sys.argv[0])
-sys.path.insert(0, this_dir)
-
-# Now proceed with execution
-execfile(os.path.join(
-    this_dir, 'IPython', 'scripts', 'ipython'
-))
diff --git a/long_description.rst b/long_description.rst
new file mode 100644
index 00000000000..6fabbd207c8
--- /dev/null
+++ b/long_description.rst
@@ -0,0 +1,37 @@
+IPython provides a rich toolkit to help you make the most out of using Python
+interactively.  Its main components are:
+
+ * A powerful interactive Python shell
+ * A `Jupyter <https://jupyter.org/>`_ kernel to work with Python code in Jupyter
+   notebooks and other interactive frontends.
+
+The enhanced interactive Python shells have the following main features:
+
+ * Comprehensive object introspection.
+
+ * Input history, persistent across sessions.
+
+ * Caching of output results during a session with automatically generated
+   references.
+
+ * Extensible tab completion, with support by default for completion of python
+   variables and keywords, filenames and function keywords.
+
+ * Extensible system of 'magic' commands for controlling the environment and
+   performing many tasks related either to IPython or the operating system.
+
+ * A rich configuration system with easy switching between different setups
+   (simpler than changing $PYTHONSTARTUP environment variables every time).
+
+ * Session logging and reloading.
+
+ * Extensible syntax processing for special purpose situations.
+
+ * Access to the system shell with user-extensible alias system.
+
+ * Easily embeddable in other Python programs and GUIs.
+
+ * Integrated access to the pdb debugger and the Python profiler.
+
+The latest development version is always available from IPython's `GitHub
+site <http://github.com/ipython>`_.
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000000..cfd8a567012
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,498 @@
+[build-system]
+requires = ["setuptools>=80.0"]
+# We need access to the 'setupbase' module at build time.
+# Hence we declare a custom build backend.
+build-backend = "_build_meta"  # just re-exports setuptools.build_meta definitions
+backend-path = ["."]
+
+[project]
+name = "ipython"
+description = "IPython: Productive Interactive Computing"
+keywords = ["Interactive", "Interpreter", "Shell", "Embedding"]
+classifiers = [
+    "Framework :: IPython",
+    "Framework :: Jupyter",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: System :: Shells",
+]
+license = "BSD-3-Clause"
+license-files = ["LICENSE", "COPYING.rst"]
+requires-python = ">=3.12"
+dependencies = [
+    'colorama>=0.4.4; sys_platform == "win32"',
+    "decorator>=5.1.0",
+    "ipython-pygments-lexers>=1.0.0",
+    "jedi>=0.18.2",
+    "matplotlib-inline>=0.1.6",
+    'pexpect>4.6; sys_platform != "win32" and sys_platform != "emscripten"',
+    "prompt_toolkit>=3.0.41,<3.1.0",
+    "pygments>=2.14.0", # wheel
+    "stack_data>=0.6.0",
+    "traitlets>=5.13.0",
+]
+dynamic = ["authors", "version"]
+
+[project.scripts]
+ipython = "IPython:start_ipython"
+ipython3 = "IPython:start_ipython"
+
+[project.readme]
+file = "long_description.rst"
+content-type = "text/x-rst"
+
+[project.urls]
+Homepage = "https://ipython.org"
+Documentation = "https://ipython.readthedocs.io/"
+Funding = "https://jupyter.org/about#donate"
+Source = "https://github.com/ipython/ipython"
+Tracker = "https://github.com/ipython/ipython/issues"
+
+[project.optional-dependencies]
+black = [
+    "black",
+]
+doc = [
+    "docrepr",
+    "exceptiongroup",
+    "intersphinx_registry",
+    "ipykernel",
+    "ipython[test,matplotlib]",
+    "setuptools>=80.0",
+    "sphinx_toml==0.0.4",
+    "sphinx-rtd-theme>=0.1.8", # wheel
+    "sphinx>=8.0",
+    "typing_extensions",
+]
+test = [
+    "pytest>=7.0.0", # keep in sync with tool.pytest.ini_options.minversion
+    "pytest-asyncio>=1.0.0",
+    "testpath>=0.2",
+    "packaging>=23.0.0",
+    "setuptools>=80.0",
+]
+test_extra = [
+    "ipython[test]",
+    "curio",
+    "jupyter_ai",
+    "ipython[matplotlib]",
+    "nbformat",
+    "nbclient",
+    "ipykernel>6.30",
+    "numpy>=2.0",
+    "pandas>2.1",
+    "trio>=0.22.0",
+]
+matplotlib = [
+   "matplotlib>3.9"
+]
+all = [
+    "ipython[doc,matplotlib,terminal,test,test_extra]",
+    "argcomplete>=3.0",
+    "types-decorator"
+]
+
+
+[tool.mypy]
+python_version = "3.12"
+ignore_missing_imports = true
+follow_imports = 'silent'
+exclude = [
+   'test_\.+\.py',
+   'IPython.utils.tests.test_wildcard',
+   'testing',
+   'tests',
+   '_process_win32_controller.py',
+   'IPython/core/application.py',
+   'IPython/core/profileapp.py',
+   'IPython/lib/deepreload.py',
+   'IPython/sphinxext/ipython_directive.py',
+   'IPython/terminal/ipapp.py',
+   'IPython/utils/path.py',
+   'IPython/core/debugger_backport.py',
+]
+check_untyped_defs = true
+# disallow_untyped_calls = true
+# disallow_untyped_decorators = true
+# ignore_errors = false
+# ignore_missing_imports = false
+disallow_incomplete_defs = true
+disallow_untyped_defs = true
+warn_redundant_casts = true
+enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
+#warn_unreachable = true
+#strict = true
+
+[[tool.mypy.overrides]]
+module = [
+    "IPython.core.events",
+    "IPython.core.magic",
+]
+# Strictest configuration, everything turned up to the max
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+disallow_any_generics = true
+disallow_subclassing_any = true
+warn_return_any = true
+warn_unused_ignores = true
+warn_unreachable = true
+strict_equality = true
+no_implicit_optional = true
+ignore_errors = false
+ignore_missing_imports = false
+
+[[tool.mypy.overrides]]
+module = [
+    "IPython.core.ultratb",
+]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_untyped_calls = false
+disallow_untyped_decorators = true
+disallow_untyped_defs = false
+ignore_errors = false
+ignore_missing_imports = false
+
+[[tool.mypy.overrides]]
+module = [
+    "IPython.core.crashhandler",
+    "IPython.utils.text",
+    "IPython.utils.PyColorize",
+    "IPython.utils.sentinel",
+    "IPython.utils.data",
+    "IPython.utils.importstring",
+    "IPython.utils.syspathcontext",
+    "IPython.utils.generics",
+    "IPython.utils.encoding",
+    "IPython.utils.module_paths",
+]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+ignore_errors = false
+ignore_missing_imports = false
+
+[[tool.mypy.overrides]]
+module = [
+    "IPython.core.debugger",
+]
+disallow_untyped_defs = false
+ignore_errors = false
+ignore_missing_imports = true
+disallow_untyped_calls = false
+disallow_incomplete_defs = false
+check_untyped_defs = true
+disallow_untyped_decorators = true
+
+[[tool.mypy.overrides]]
+module = [
+    "IPython.core.interactiveshell",
+]
+disallow_untyped_defs = false
+ignore_errors = false
+ignore_missing_imports = true
+disallow_untyped_calls = false
+disallow_incomplete_defs = false
+check_untyped_defs = true
+disallow_untyped_decorators = false
+disable_error_code = [
+  "arg-type",
+  "assignment",
+  "attr-defined",
+  "index",
+  "var-annotated",
+  "union-attr"
+]
+
+# gloabl ignore error
+[[tool.mypy.overrides]]
+module = [
+    "IPython",
+    "IPython.conftest",
+    "IPython.core.alias",
+    "IPython.core.async_helpers",
+    "IPython.core.autocall",
+    "IPython.core.builtin_trap",
+    "IPython.core.compilerop",
+    "IPython.core.completer",
+    "IPython.core.completerlib",
+    "IPython.core.display",
+    "IPython.core.display_functions",
+    "IPython.core.display_trap",
+    "IPython.core.displayhook",
+    "IPython.core.displaypub",
+    "IPython.core.extensions",
+    "IPython.core.formatters",
+    "IPython.core.getipython",
+    "IPython.core.guarded_eval",
+    "IPython.core.historyapp",
+    "IPython.core.hooks",
+    "IPython.core.inputtransformer2",
+    "IPython.core.logger",
+    "IPython.core.macro",
+    "IPython.core.magic_arguments",
+    "IPython.core.magics.ast_mod",
+    "IPython.core.magics.auto",
+    "IPython.core.magics.basic",
+    "IPython.core.magics.code",
+    "IPython.core.magics.config",
+    "IPython.core.magics.display",
+    "IPython.core.magics.execution",
+    "IPython.core.magics.extension",
+    "IPython.core.magics.history",
+    "IPython.core.magics.logging",
+    "IPython.core.magics.namespace",
+    "IPython.core.magics.osm",
+    "IPython.core.magics.packaging",
+    "IPython.core.magics.pylab",
+    "IPython.core.magics.script",
+    "IPython.core.oinspect",
+    "IPython.core.page",
+    "IPython.core.payload",
+    "IPython.core.payloadpage",
+    "IPython.core.prefilter",
+    "IPython.core.profiledir",
+    "IPython.core.prompts",
+    "IPython.core.pylabtools",
+    "IPython.core.shellapp",
+    "IPython.core.splitinput",
+    "IPython.extensions.autoreload",
+    "IPython.extensions.storemagic",
+    "IPython.external.pickleshare",
+    "IPython.external.qt_for_kernel",
+    "IPython.external.qt_loaders",
+    "IPython.lib.backgroundjobs",
+    "IPython.lib.clipboard",
+    "IPython.lib.demo",
+    "IPython.lib.display",
+    "IPython.lib.editorhooks",
+    "IPython.lib.guisupport",
+    "IPython.lib.latextools",
+    "IPython.lib.lexers",
+    "IPython.lib.pretty",
+    "IPython.paths",
+    "IPython.sphinxext.ipython_console_highlighting",
+    "IPython.terminal.debugger",
+    "IPython.terminal.embed",
+    "IPython.terminal.interactiveshell",
+    "IPython.terminal.magics",
+    "IPython.terminal.prompts",
+    "IPython.terminal.pt_inputhooks",
+    "IPython.terminal.pt_inputhooks.asyncio",
+    "IPython.terminal.pt_inputhooks.glut",
+    "IPython.terminal.pt_inputhooks.gtk",
+    "IPython.terminal.pt_inputhooks.gtk3",
+    "IPython.terminal.pt_inputhooks.gtk4",
+    "IPython.terminal.pt_inputhooks.osx",
+    "IPython.terminal.pt_inputhooks.pyglet",
+    "IPython.terminal.pt_inputhooks.qt",
+    "IPython.terminal.pt_inputhooks.tk",
+    "IPython.terminal.pt_inputhooks.wx",
+    "IPython.terminal.ptutils",
+    "IPython.terminal.shortcuts",
+    "IPython.terminal.shortcuts.auto_match",
+    "IPython.terminal.shortcuts.auto_suggest",
+    "IPython.terminal.shortcuts.filters",
+    "IPython.utils._process_cli",
+    "IPython.utils._process_common",
+    "IPython.utils._process_emscripten",
+    "IPython.utils.capture",
+    "IPython.utils.coloransi",
+    "IPython.utils.contexts",
+    "IPython.utils.decorators",
+    "IPython.utils.dir2",
+    "IPython.utils.frame",
+    "IPython.utils.io",
+    "IPython.utils.ipstruct",
+    "IPython.utils.openpy",
+    "IPython.utils.process",
+    "IPython.utils.py3compat",
+    "IPython.utils.strdispatch",
+    "IPython.utils.sysinfo",
+    "IPython.utils.tempdir",
+    "IPython.utils.terminal",
+    "IPython.utils.timing",
+    "IPython.utils.tokenutil",
+    "IPython.utils.version",
+    "IPython.utils.wildcard",
+
+]
+disallow_untyped_defs = false
+ignore_errors = true
+ignore_missing_imports = true
+disallow_untyped_calls = false
+disallow_incomplete_defs = false
+check_untyped_defs = true
+disallow_untyped_decorators = false
+
+[tool.pytest.ini_options]
+minversion = "7" # keep in sync with project.optional-dependencies.test
+addopts = [
+   "--durations=10",
+   "-pIPython.testing.plugin.pytest_ipdoctest",
+   "--ipdoctest-modules",
+   "--ignore=docs",
+   "--ignore=examples",
+   "--ignore=htmlcov",
+   "--ignore=ipython_kernel",
+   "--ignore=ipython_parallel",
+   "--ignore=results",
+   "--ignore=tmp",
+   "--ignore=tools",
+   "--ignore=traitlets",
+   "--ignore=tests/fake_ext_dir/",
+   "--ignore=IPython/sphinxext",
+   "--ignore=IPython/terminal/pt_inputhooks",
+   "--ignore=IPython/__main__.py",
+   "--ignore=IPython/external/qt_for_kernel.py",
+   "--ignore=IPython/html/widgets/widget_link.py",
+   "--ignore=IPython/html/widgets/widget_output.py",
+   "--ignore=IPython/terminal/console.py",
+   "--ignore=IPython/utils/_process_cli.py",
+   "--ignore=IPython/utils/_process_posix.py",
+   "--ignore=IPython/utils/_process_win32_controller.py",
+   "--ignore=IPython/utils/daemonize.py",
+   "--ignore=IPython/utils/eventful.py",
+   "--ignore=IPython/kernel",
+   "--ignore=IPython/consoleapp.py",
+   "--ignore=IPython/lib/kernel.py",
+   "--ignore=IPython/utils/jsonutil.py",
+   "--ignore=IPython/utils/log.py",
+   "--ignore=IPython/utils/signatures.py",
+   "--ignore=IPython/utils/version.py"
+]
+doctest_optionflags = [
+   "NORMALIZE_WHITESPACE",
+   "ELLIPSIS"
+]
+ipdoctest_optionflags = [
+   "NORMALIZE_WHITESPACE",
+   "ELLIPSIS"
+]
+asyncio_mode = "strict"
+
+[tool.pyright]
+pythonPlatform="All"
+
+[tool.setuptools]
+zip-safe = false
+platforms = ["Linux", "Mac OSX", "Windows"]
+include-package-data = false
+
+[tool.setuptools.packages.find]
+include = ["IPython*"]
+exclude = ["setupext", "tests*"]
+namespaces = false
+
+[tool.setuptools.package-data]
+"IPython" = ["py.typed"]
+"IPython.core" = ["profile/README*"]
+"IPython.testing.plugin" = ["*.txt"]
+
+[tool.setuptools.dynamic]
+version = {attr = "IPython.core.release.__version__"}
+
+[tool.coverage.run]
+omit = [
+    # omit everything in /tmp as we run tempfile
+    "/tmp/*",
+]
+
+[tool.ruff.lint]
+extend-select = [
+    #  "B",           # flake8-bugbear
+    #  "I",           # isort
+    # that will be a problem for pytest fixture unless you swap with the usefixture decorator https://docs.pytest.org/en/7.1.x/how-to/fixtures.html#use-fixtures-in-classes-and-modules-with-usefixtures
+    #  "ARG",         # flake8-unused-arguments
+    #  "C4",          # flake8-comprehensions
+    #  "EM",          # flake8-errmsg
+    #  "ICN",         # flake8-import-conventions
+    #  "G",           # flake8-logging-format
+    #  "PGH",         # pygrep-hooks
+    #  "PIE",         # flake8-pie
+    #  "PL",          # pylint
+    #  "PTH",         # flake8-use-pathlib
+    #  "PT",          # flake8-pytest-style
+    #  "RET",         # flake8-return
+    #  "RUF",         # Ruff-specific
+    #  "SIM",         # flake8-simplify
+    #  "T20",         # flake8-print
+    #    "UP",          # pyupgrade
+    "UP004",       #  1   [*] Class `...` inherits from `object`
+    # "UP006",        #  1   [*] Use `list` instead of `t.List` for type annotation
+    # "UP006",        #  1   [*] Use `tuple` instead of `t.Tuple` for type annotation
+    # "UP010",        #  1   [*] Unnecessary `__future__` import `print_function` for target Python version
+    "UP011",        #  1   [*] Unnecessary parentheses to `functools.lru_cache`
+    "UP018",        #  1   [*] Unnecessary `bool` call (rewrite as a literal)
+    # "UP006",        #182   [*] Use `...` instead of `...` for type annotation
+    # "UP007",        #  5   Use `X | Y` for type annotations
+    # "UP007",        #149   [*] Use `X | Y` for type annotations
+    # "UP008",        # 63   Use `super()` instead of `super(__class__, self)`
+    # "UP009",        # 61   [*] UTF-8 encoding declaration is unnecessary
+    # "UP015",        #  2   [*] Unnecessary modes, use `w`
+    # "UP015",        #  4   [*] Unnecessary mode argument
+    # "UP017",        #  2   [*] Use `datetime.UTC` alias
+    # "UP020",        # 15   [*] Use builtin `open`
+    # "UP024",        # 16   [*] Replace aliased errors with `OSError`
+    # "UP025",        # 91   [*] Remove unicode literals from strings
+    "UP028",        #  3   Replace `yield` over `for` loop with `yield from`
+    "UP029",        #  1   Unnecessary builtin import
+    # "UP030",        # 28   Use implicit references for positional format fields
+    # "UP031",        #386   Use format specifiers instead of percent format
+    # "UP032",        # 75   [*] Use f-string instead of `format` call
+    "UP034",        #  1   [*] Avoid extraneous parentheses
+    # "UP035",        #  1   [*] Import from `re` instead
+    # "UP035",        #  2   [*] Import from `typing` instead
+    # "UP035",        #  2   `typing.Type` is deprecated, use `type` instead
+    # "UP035",        #  4   `typing.Set` is deprecated, use `set` instead
+    # "UP035",        # 11   `typing.Dict` is deprecated, use `dict` instead
+    # "UP035",        # 12   `typing.Tuple` is deprecated, use `tuple` instead
+    # "UP035",        # 14   `typing.List` is deprecated, use `list` instead
+    # "UP035",        # 18   [*] Import from `collections.abc` instead
+    # "UP036",        #  3   Version block is outdated for minimum Python version
+    "UP037",        #  1   [*] Remove quotes from type annotation
+    # "UP038",        # 21   Use `X | Y` in `isinstance` call instead of `(X, Y)`
+    #  "YTT",         # flake8-2020
+    #  "EXE",         # flake8-executable
+    #  "PYI",         # flake8-pyi
+    #  "S",           # flake8-bandit
+]
+ignore = [
+    #  "E501",     # E501 Line too long (158 > 100 characters)
+    #  "SIM105",   # SIM105 Use `contextlib.suppress(...)`
+    #  "PLR",      # Design related pylint codes
+    #  "S101",     # Use of `assert` detected
+    "E713", #   1      Test for membership should be `not in`
+    "F601", #   3      Dictionary key literal `True` repeated (`True` hashes to the same value as `1`)
+    "E702", #   3      Multiple statements on one line (semicolon)
+    "E721", #   3      Use `is` and `is not` for type comparisons, or `isinstance()` for isinstance checks
+    "E401", #   5      Multiple imports on one line
+    "E711", #  14      Comparison to `None` should be `cond is None`
+    "E701", #  19      Multiple statements on one line (colon)
+    "E741", #  25      Ambiguous variable name: `<one letter>`
+    "E731", #  27      Do not assign a `lambda` expression, use a `def`
+    "E402", #  28      Module level import not at top of file
+    "E722", #  75      Do not use bare `except`
+    "F523", #   1      ; at end of line
+    "F403", #   7      import *` used; unable to detect undefined names
+    "F841", #  38      Local variable `...` is assigned to but never used
+    "F401", #  69      imported but unused
+    "F821", # 624      Undefined name
+]
+unfixable = [
+    # Don't touch print statements
+    "T201",
+    # Don't touch noqa lines
+    "RUF100",
+]
+
+[tool.ruff]
+extend-exclude = ["tests"]
diff --git a/scripts/ipython.ico b/scripts/ipython.ico
new file mode 100644
index 00000000000..2d4ac507a30
Binary files /dev/null and b/scripts/ipython.ico differ
diff --git a/scripts/ipython_nb.ico b/scripts/ipython_nb.ico
new file mode 100644
index 00000000000..68440d9a8b6
Binary files /dev/null and b/scripts/ipython_nb.ico differ
diff --git a/scripts/ipython_win_post_install.py b/scripts/ipython_win_post_install.py
deleted file mode 100755
index 4f633fc4f75..00000000000
--- a/scripts/ipython_win_post_install.py
+++ /dev/null
@@ -1,100 +0,0 @@
-#!python
-"""Windows-specific part of the installation"""
-
-import os, sys, shutil
-pjoin = os.path.join
-
-def mkshortcut(target,description,link_file,*args,**kw):
-    """make a shortcut if it doesn't exist, and register its creation"""
-    
-    create_shortcut(target, description, link_file,*args,**kw)
-    file_created(link_file)
-
-def install():
-    """Routine to be run by the win32 installer with the -install switch."""
-    
-    from IPython.core.release import version
-    
-    # Get some system constants
-    prefix = sys.prefix
-    python = pjoin(prefix, 'python.exe')
-    
-    # Lookup path to common startmenu ...
-    ip_start_menu = pjoin(get_special_folder_path('CSIDL_COMMON_PROGRAMS'), 'IPython')
-    # Create IPython entry ...
-    if not os.path.isdir(ip_start_menu):
-        os.mkdir(ip_start_menu)
-        directory_created(ip_start_menu)
-    
-    # Create .py and .bat files to make things available from
-    # the Windows command line.  Thanks to the Twisted project
-    # for this logic!
-    programs = [
-        'ipython',
-        'iptest',
-        'ipcontroller',
-        'ipengine',
-        'ipcluster',
-        'irunner'
-    ]
-    scripts = pjoin(prefix,'scripts')
-    for program in programs:
-        raw = pjoin(scripts, program)
-        bat = raw + '.bat'
-        py = raw + '.py'
-        # Create .py versions of the scripts
-        shutil.copy(raw, py)
-        # Create .bat files for each of the scripts
-        bat_file = file(bat,'w')
-        bat_file.write("@%s %s %%*" % (python, py))
-        bat_file.close()
-            
-    # Now move onto setting the Start Menu up
-    ipybase = pjoin(scripts, 'ipython')
-    if 'setuptools' in sys.modules:
-        # let setuptools take care of the scripts:
-        ipybase = ipybase + '-script.py'
-    workdir = "%HOMEDRIVE%%HOMEPATH%"
-
-    link = pjoin(ip_start_menu, 'IPython.lnk')
-    cmd = '"%s"' % ipybase
-    mkshortcut(python, 'IPython', link, cmd, workdir)
-    
-    link = pjoin(ip_start_menu, 'pysh.lnk')
-    cmd = '"%s" -p sh' % ipybase
-    mkshortcut(python, 'IPython (command prompt mode)', link, cmd, workdir)
-    
-    link = pjoin(ip_start_menu, 'scipy.lnk')
-    cmd = '"%s" -p scipy' % ipybase
-    mkshortcut(python, 'IPython (scipy profile)', link, cmd, workdir)
-        
-    link = pjoin(ip_start_menu, 'ipcontroller.lnk')
-    cmd = '"%s" -xy' % pjoin(scripts, 'ipcontroller')
-    mkshortcut(python, 'IPython controller', link, cmd, workdir)
-    
-    link = pjoin(ip_start_menu, 'ipengine.lnk')
-    cmd = '"%s"' % pjoin(scripts, 'ipengine')
-    mkshortcut(python, 'IPython engine', link, cmd, workdir)
-    
-    # Create documentation shortcuts ...
-    t = prefix + r'\share\doc\ipython\manual\ipython.pdf'
-    f = ip_start_menu + r'\Manual in PDF.lnk'
-    mkshortcut(t,r'IPython Manual - PDF-Format',f)
-    
-    t = prefix + r'\share\doc\ipython\manual\html\index.html'
-    f = ip_start_menu + r'\Manual in HTML.lnk'
-    mkshortcut(t,'IPython Manual - HTML-Format',f)
-    
-    
-def remove():
-    """Routine to be run by the win32 installer with the -remove switch."""
-    pass
-
-# main()
-if len(sys.argv) > 1:
-    if sys.argv[1] == '-install':
-        install()
-    elif sys.argv[1] == '-remove':
-        remove()
-    else:
-        print "Script was called with option %s" % sys.argv[1]
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 00000000000..35e570dfcac
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,7 @@
+[velin]
+ignore_patterns =
+   IPython/core/tests
+   IPython/testing
+
+[tool.black]
+exclude = 'timing\.py'
diff --git a/setup.py b/setup.py
old mode 100755
new mode 100644
index 25ab94d1447..b80499537ff
--- a/setup.py
+++ b/setup.py
@@ -1,105 +1,38 @@
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """Setup script for IPython.
 
-Under Posix environments it works like a typical setup.py script. 
-Under Windows, the command sdist is not supported, since IPython 
+Under Posix environments it works like a typical setup.py script.
+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 <fernando.perez@colorado.edu>
 #  Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
 #  Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
 #
 #  Distributed under the terms of the Modified BSD License.
 #
-#  The full license is in the file COPYING.txt, distributed with this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Minimal Python version sanity check
+#  The full license is in the file COPYING.rst, distributed with this software.
 #-----------------------------------------------------------------------------
 
+import os
 import sys
 
-# This check is also made in IPython/__init__, don't forget to update both when
-# changing Python version requirements.
-if sys.version[0:3] < '2.6':
-    error = """\
-ERROR: 'IPython requires Python Version 2.6 or above.'
-Exiting."""
-    print >> sys.stderr, error
-    sys.exit(1)
-
 # At least we're on the python version we need, move on.
 
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-# Stdlib imports
-import os
-import shutil
-
-from glob import glob
-
-# BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
-# update it when the contents of directories change.
-if os.path.exists('MANIFEST'): os.remove('MANIFEST')
-
-from distutils.core import setup
+from setuptools import setup
 
 # Our own imports
-from IPython.utils.path import target_update
+
+from setupbase import target_update
 
 from setupbase import (
-    setup_args, 
-    find_packages, 
-    find_package_data, 
-    find_scripts,
+    setup_args,
+    check_package_data_first,
     find_data_files,
-    check_for_dependencies,
-    record_commit_info,
+    git_prebuild,
 )
-from setupext import setupext
-
-isfile = os.path.isfile
-pjoin = os.path.join
-
-#-----------------------------------------------------------------------------
-# Function definitions
-#-----------------------------------------------------------------------------
-
-def cleanup():
-    """Clean up the junk left around by the build process"""
-    if "develop" not in sys.argv:
-        try:
-            shutil.rmtree('ipython.egg-info')
-        except:
-            try:
-                os.unlink('ipython.egg-info')
-            except:
-                pass
-
-#-------------------------------------------------------------------------------
-# Handle OS specific things
-#-------------------------------------------------------------------------------
-
-if os.name == 'posix':
-    os_name = 'posix'
-elif os.name in ['nt','dos']:
-    os_name = 'windows'
-else:
-    print 'Unsupported operating system:',os.name
-    sys.exit(1)
-
-# Under Windows, 'sdist' has not been supported.  Now that the docs build with
-# Sphinx it might work, but let's not turn it on until someone confirms that it
-# actually works.
-if os_name == 'windows' and 'sdist' in sys.argv:
-    print 'The sdist command is not available under Windows.  Exiting.'
-    sys.exit(1)
 
 #-------------------------------------------------------------------------------
 # Things related to the IPython documentation
@@ -107,157 +40,43 @@ def cleanup():
 
 # update the manuals when building a source dist
 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
-    import textwrap
 
     # List of things to be updated. Each entry is a triplet of args for
     # target_update()
     to_update = [
-                  # FIXME - Disabled for now: we need to redo an automatic way
-                  # of generating the magic info inside the rst.                
-                  #('docs/magic.tex',
-                  #['IPython/Magic.py'],
-                  #"cd doc && ./update_magic.sh" ),
-
-                 ('docs/man/ipcluster.1.gz',
-                  ['docs/man/ipcluster.1'],
-                  'cd docs/man && gzip -9c ipcluster.1 > ipcluster.1.gz'),
-
-                 ('docs/man/ipcontroller.1.gz',
-                  ['docs/man/ipcontroller.1'],
-                  'cd docs/man && gzip -9c ipcontroller.1 > ipcontroller.1.gz'),
-
-                 ('docs/man/ipengine.1.gz',
-                  ['docs/man/ipengine.1'],
-                  'cd docs/man && gzip -9c ipengine.1 > ipengine.1.gz'),
-
-                 ('docs/man/ipython.1.gz',
-                  ['docs/man/ipython.1'],
-                  'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
-
-                 ('docs/man/ipython-wx.1.gz',
-                  ['docs/man/ipython-wx.1'],
-                  'cd docs/man && gzip -9c ipython-wx.1 > ipython-wx.1.gz'),
-
-                 ('docs/man/ipythonx.1.gz',
-                  ['docs/man/ipythonx.1'],
-                  'cd docs/man && gzip -9c ipythonx.1 > ipythonx.1.gz'),
-
-                 ('docs/man/irunner.1.gz',
-                  ['docs/man/irunner.1'],
-                  'cd docs/man && gzip -9c irunner.1 > irunner.1.gz'),
+        (
+            "docs/man/ipython.1.gz",
+            ["docs/man/ipython.1"],
+            "cd docs/man && python -m gzip --best ipython.1",
+        ),
+    ]
 
-                 ('docs/man/pycolor.1.gz',
-                  ['docs/man/pycolor.1'],
-                  'cd docs/man && gzip -9c pycolor.1 > pycolor.1.gz'),
-                 ]
 
-    # Only build the docs if sphinx is present
-    try:
-        import sphinx
-    except ImportError:
-        pass
-    else:
-        # The Makefile calls the do_sphinx scripts to build html and pdf, so
-        # just one target is enough to cover all manual generation
-
-        # First, compute all the dependencies that can force us to rebuild the
-        # docs.  Start with the main release file that contains metadata
-        docdeps = ['IPython/core/release.py']
-        # Inculde all the reST sources
-        pjoin = os.path.join
-        for dirpath,dirnames,filenames in os.walk('docs/source'):
-            if dirpath in ['_static','_templates']:
-                continue
-            docdeps += [ pjoin(dirpath,f) for f in filenames
-                         if f.endswith('.txt') ]
-        # and the examples
-        for dirpath,dirnames,filenames in os.walk('docs/example'):
-            docdeps += [ pjoin(dirpath,f) for f in filenames
-                         if not f.endswith('~') ]
-        # then, make them all dependencies for the main PDF (the html will get
-        # auto-generated as well).
-        to_update.append(
-            ('docs/dist/ipython.pdf',
-             docdeps,
-             "cd docs && make dist")
-            )
-        
     [ target_update(*t) for t in to_update ]
-    
+
 #---------------------------------------------------------------------------
 # Find all the packages, package data, and data_files
 #---------------------------------------------------------------------------
 
-packages = find_packages()
-package_data = find_package_data()
 data_files = find_data_files()
 
+setup_args['data_files'] = data_files
+
 #---------------------------------------------------------------------------
-# Handle scripts, dependencies, and setuptools specific things
+# custom distutils commands
 #---------------------------------------------------------------------------
+# imports here, so they are after setuptools import if there was one
+from setuptools.command.sdist import sdist
 
-# For some commands, use setuptools.  Note that we do NOT list install here!
-# If you want a setuptools-enhanced install, just run 'setupegg.py install'
-if len(set(('develop', 'sdist', 'release', 'bdist_egg', 'bdist_rpm',
-           'bdist', 'bdist_dumb', 'bdist_wininst', 'install_egg_info',
-           'build_sphinx', 'egg_info', 'easy_install', 'upload',
-            )).intersection(sys.argv)) > 0:
-    import setuptools
-
-# This dict is used for passing extra arguments that are setuptools 
-# specific to setup
-setuptools_extra_args = {}
-
-if 'setuptools' in sys.modules:
-    setuptools_extra_args['zip_safe'] = False
-    setuptools_extra_args['entry_points'] = {
-        'console_scripts': find_scripts(True)
-    }
-    setup_args['extras_require'] = dict(
-        parallel = 'pyzmq>=2.1.4',
-        zmq = 'pyzmq>=2.0.10.1',
-        doc='Sphinx>=0.3',
-        test='nose>=0.10.1',
-    )
-    requires = setup_args.setdefault('install_requires', [])
-    setupext.display_status = False
-    if not setupext.check_for_readline():
-        if sys.platform == 'darwin':
-            requires.append('readline')
-        elif sys.platform.startswith('win'):
-            requires.append('pyreadline')
-        else:
-            pass
-            # do we want to install readline here?
-    
-    # Script to be run by the windows binary installer after the default setup
-    # routine, to add shortcuts and similar windows-only things.  Windows
-    # post-install scripts MUST reside in the scripts/ dir, otherwise distutils
-    # doesn't find them.
-    if 'bdist_wininst' in sys.argv:
-        if len(sys.argv) > 2 and \
-               ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
-            print >> sys.stderr, "ERROR: bdist_wininst must be run alone. Exiting."
-            sys.exit(1)
-        setup_args['scripts'] = [pjoin('scripts','ipython_win_post_install.py')]
-else:
-    # If we are running without setuptools, call this function which will
-    # check for dependencies an inform the user what is needed.  This is
-    # just to make life easy for users.
-    check_for_dependencies()
-    setup_args['scripts'] = find_scripts(False)
+setup_args['cmdclass'] = {
+    'build_py': \
+            check_package_data_first(git_prebuild('IPython')),
+    'sdist' : git_prebuild('IPython', sdist),
+}
 
 #---------------------------------------------------------------------------
 # Do the actual setup now
 #---------------------------------------------------------------------------
 
-setup_args['cmdclass'] = {'build_py': record_commit_info('IPython')}
-setup_args['packages'] = packages
-setup_args['package_data'] = package_data
-setup_args['data_files'] = data_files
-setup_args.update(setuptools_extra_args)
-
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     setup(**setup_args)
-    cleanup()
diff --git a/setupbase.py b/setupbase.py
index 4cd353fd325..50246b461ec 100644
--- a/setupbase.py
+++ b/setupbase.py
@@ -8,381 +8,205 @@
     * Functions for finding things like packages, package data, etc.
     * A function for checking dependencies.
 """
-from __future__ import print_function
 
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
 import os
+from pathlib import Path
+import re
 import sys
-
-from ConfigParser import ConfigParser
-from distutils.command.build_py import build_py
 from glob import glob
+from logging import log
+
+from setuptools import Command
+from setuptools.command.build_py import build_py
+
+from setuptools.command.install import install
+from setuptools.command.install_scripts import install_scripts
 
-from setupext import install_data_ext
 
 #-------------------------------------------------------------------------------
 # Useful globals and utility functions
 #-------------------------------------------------------------------------------
 
 # A few handy globals
-isfile = os.path.isfile
-pjoin = os.path.join
-
-def oscmd(s):
-    print(">", s)
-    os.system(s)
-
-# A little utility we'll need below, since glob() does NOT allow you to do
-# exclusion on multiple endings!
-def file_doesnt_endwith(test,endings):
-    """Return true if test is a file and its name does NOT end with any
-    of the strings listed in endings."""
-    if not isfile(test):
-        return False
-    for e in endings:
-        if test.endswith(e):
-            return False
-    return True
+repo_root = Path(__file__).resolve().parent
+
+def execfile(path, globs, locs=None):
+    locs = locs or globs
+    with path.open(encoding="utf-8") as f:
+        exec(compile(f.read(), str(path), "exec"), globs, locs)
 
 #---------------------------------------------------------------------------
 # Basic project information
 #---------------------------------------------------------------------------
 
 # release.py contains version, authors, license, url, keywords, etc.
-execfile(pjoin('IPython','core','release.py'))
+execfile(Path(repo_root, "IPython", "core", "release.py"), globals())
 
 # Create a dict with the basic information
 # This dict is eventually passed to setup after additional keys are added.
 setup_args = dict(
-      name             = name,
-      version          = version,
-      description      = description,
-      long_description = long_description,
       author           = author,
       author_email     = author_email,
-      url              = url,
-      download_url     = download_url,
       license          = license,
-      platforms        = platforms,
-      keywords         = keywords,
-      cmdclass         = {'install_data': install_data_ext},
       )
 
-
 #---------------------------------------------------------------------------
-# Find packages
+# Check package data
 #---------------------------------------------------------------------------
 
-def add_package(packages,pname,config=False,tests=False,scripts=False,
-                others=None):
-    """
-    Add a package to the list of packages, including certain subpackages.
-    """
-    packages.append('.'.join(['IPython',pname]))
-    if config:
-        packages.append('.'.join(['IPython',pname,'config']))
-    if tests:
-        packages.append('.'.join(['IPython',pname,'tests']))
-    if scripts:
-        packages.append('.'.join(['IPython',pname,'scripts']))
-    if others is not None:
-        for o in others:
-            packages.append('.'.join(['IPython',pname,o]))
-
-def find_packages():
-    """
-    Find all of IPython's packages.
-    """
-    packages = ['IPython']
-    add_package(packages, 'config', tests=True, others=['default','profile'])
-    add_package(packages, 'core', tests=True)
-    add_package(packages, 'deathrow', tests=True)
-    add_package(packages, 'extensions')
-    add_package(packages, 'external')
-    add_package(packages, 'external.argparse')
-    add_package(packages, 'external.configobj')
-    add_package(packages, 'external.decorator')
-    add_package(packages, 'external.decorators')
-    add_package(packages, 'external.guid')
-    add_package(packages, 'external.Itpl')
-    add_package(packages, 'external.mglob')
-    add_package(packages, 'external.path')
-    add_package(packages, 'external.pexpect')
-    add_package(packages, 'external.pyparsing')
-    add_package(packages, 'external.simplegeneric')
-    add_package(packages, 'external.ssh')
-    add_package(packages, 'external.validate')
-    add_package(packages, 'kernel')
-    add_package(packages, 'frontend')
-    add_package(packages, 'frontend.qt')
-    add_package(packages, 'frontend.qt.console', tests=True)
-    add_package(packages, 'frontend.terminal', tests=True)    
-    add_package(packages, 'lib', tests=True)
-    add_package(packages, 'parallel', tests=True, scripts=True, 
-                                    others=['apps','engine','client','controller'])
-    add_package(packages, 'quarantine', tests=True)
-    add_package(packages, 'scripts')
-    add_package(packages, 'testing', tests=True)
-    add_package(packages, 'testing.plugin', tests=False)
-    add_package(packages, 'utils', tests=True)
-    add_package(packages, 'zmq')
-    add_package(packages, 'zmq.pylab')
-    add_package(packages, 'zmq.gui')
-    return packages
+def check_package_data(package_data):
+    """verify that package_data globs make sense"""
+    print("checking package data")
+    for pkg, data in package_data.items():
+        pkg_root = Path(*pkg.split("."))
+        for d in data:
+            path = pkg_root / d
+            if "*" in str(path):
+                assert len(glob(str(path))) > 0, "No files match pattern %s" % path
+            else:
+                assert path.exists(), f"Missing package data: {path}"
 
-#---------------------------------------------------------------------------
-# Find package data
-#---------------------------------------------------------------------------
 
-def find_package_data():
-    """
-    Find IPython's package_data.
+def check_package_data_first(command):
+    """decorator for checking package_data before running a given command
+
+    Probably only needs to wrap build_py
     """
-    # This is not enough for these things to appear in an sdist.
-    # We need to muck with the MANIFEST to get this to work
-    package_data = {
-        'IPython.config.userconfig' : ['*'],
-        'IPython.testing' : ['*.txt']
-    }
-    return package_data
+    class DecoratedCommand(command):
+        def run(self):
+            check_package_data(self.package_data)
+            command.run(self)
+    return DecoratedCommand
 
 
 #---------------------------------------------------------------------------
 # Find data files
 #---------------------------------------------------------------------------
 
-def make_dir_struct(tag,base,out_base):
-    """Make the directory structure of all files below a starting dir.
-
-    This is just a convenience routine to help build a nested directory
-    hierarchy because distutils is too stupid to do this by itself.
-
-    XXX - this needs a proper docstring!
-    """
-    
-    # we'll use these a lot below
-    lbase = len(base)
-    pathsep = os.path.sep
-    lpathsep = len(pathsep)
-    
-    out = []
-    for (dirpath,dirnames,filenames) in os.walk(base):
-        # we need to strip out the dirpath from the base to map it to the
-        # output (installation) path.  This requires possibly stripping the
-        # path separator, because otherwise pjoin will not work correctly
-        # (pjoin('foo/','/bar') returns '/bar').
-        
-        dp_eff = dirpath[lbase:]
-        if dp_eff.startswith(pathsep):
-            dp_eff = dp_eff[lpathsep:]
-        # The output path must be anchored at the out_base marker    
-        out_path = pjoin(out_base,dp_eff)
-        # Now we can generate the final filenames. Since os.walk only produces
-        # filenames, we must join back with the dirpath to get full valid file
-        # paths:
-        pfiles = [pjoin(dirpath,f) for f in filenames]
-        # Finally, generate the entry we need, which is a pari of (output
-        # path, files) for use as a data_files parameter in install_data.
-        out.append((out_path, pfiles))
-
-    return out
-    
-
 def find_data_files():
     """
     Find IPython's data_files.
 
-    Most of these are docs.
+    Just man pages at this point.
     """
-    
-    docdirbase  = pjoin('share', 'doc', 'ipython')
-    manpagebase = pjoin('share', 'man', 'man1')
-    
+
+    if "freebsd" in sys.platform:
+        manpagebase = Path("man") / "man1"
+    else:
+        manpagebase = Path("share") / "man" / "man1"
+
     # Simple file lists can be made by hand
-    manpages  = filter(isfile, glob(pjoin('docs','man','*.1.gz')))
-    igridhelpfiles = filter(isfile,
-                            glob(pjoin('IPython','extensions','igrid_help.*')))
-
-    # For nested structures, use the utility above
-    example_files = make_dir_struct(
-        'data',
-        pjoin('docs','examples'),
-        pjoin(docdirbase,'examples')
-    )
-    manual_files = make_dir_struct(
-        'data',
-        pjoin('docs','dist'),
-        pjoin(docdirbase,'manual')
-    )
+    manpages = [f for f in Path("docs/man").glob("*.1.gz") if f.is_file()]
+    if not manpages:
+        # When running from a source tree, the manpages aren't gzipped
+        manpages = [f for f in Path("docs/man").glob("*.1") if f.is_file()]
 
     # And assemble the entire output list
-    data_files = [ (manpagebase, manpages),
-                   (pjoin(docdirbase, 'extensions'), igridhelpfiles),
-                   ] + manual_files + example_files
+    data_files = [(str(manpagebase), [str(f) for f in manpages])]
 
     return data_files
 
 
-def make_man_update_target(manpage):
-    """Return a target_update-compliant tuple for the given manpage.
+# The two functions below are copied from IPython.utils.path, so we don't need
+# to import IPython during setup, which fails on Python 3.
 
-    Parameters
-    ----------
-    manpage : string
-      Name of the manpage, must include the section number (trailing number).
+def target_outdated(target, deps):
+    """Determine whether a target is out of date.
 
-    Example
-    -------
+    target_outdated(target,deps) -> 1/0
 
-    >>> make_man_update_target('ipython.1') #doctest: +NORMALIZE_WHITESPACE
-    ('docs/man/ipython.1.gz',
-     ['docs/man/ipython.1'],
-     'cd docs/man && gzip -9c ipython.1 > ipython.1.gz')
-    """
-    man_dir = pjoin('docs', 'man')
-    manpage_gz = manpage + '.gz'
-    manpath = pjoin(man_dir, manpage)
-    manpath_gz = pjoin(man_dir, manpage_gz)
-    gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %
-               locals() )
-    return (manpath_gz, [manpath], gz_cmd)
-    
-#---------------------------------------------------------------------------
-# Find scripts
-#---------------------------------------------------------------------------
+    deps: list of filenames which MUST exist.
+    target: single filename which may or may not exist.
 
-def find_scripts(entry_points=False):
-    """Find IPython's scripts.
-    
-    if entry_points is True:
-        return setuptools entry_point-style definitions
-    else:
-        return file paths of plain scripts [default]
-    
+    If target doesn't exist or is older than any file listed in deps, return
+    true, otherwise return false.
     """
-    if entry_points:
-        scripts = [
-            'ipython = IPython.frontend.terminal.ipapp:launch_new_instance',
-            'ipython-qtconsole = IPython.frontend.qt.console.ipythonqt:main',
-            'pycolor = IPython.utils.PyColorize:main',
-            'ipcontroller = IPython.parallel.apps.ipcontrollerapp:launch_new_instance',
-            'ipengine = IPython.parallel.apps.ipengineapp:launch_new_instance',
-            'iplogger = IPython.parallel.apps.iploggerapp:launch_new_instance',
-            'ipcluster = IPython.parallel.apps.ipclusterapp:launch_new_instance',
-            'iptest = IPython.testing.iptest:main',
-            'irunner = IPython.lib.irunner:main'
-        ]
-    else:
-        parallel_scripts = pjoin('IPython','parallel','scripts')
-        main_scripts = pjoin('IPython','scripts')
-        scripts = [
-                   pjoin(parallel_scripts, 'ipengine'),
-                   pjoin(parallel_scripts, 'ipcontroller'),
-                   pjoin(parallel_scripts, 'ipcluster'),
-                   pjoin(parallel_scripts, 'iplogger'),
-                   pjoin(main_scripts, 'ipython'),
-                   pjoin(main_scripts, 'ipython-qtconsole'),
-                   pjoin(main_scripts, 'pycolor'),
-                   pjoin(main_scripts, 'irunner'),
-                   pjoin(main_scripts, 'iptest')
-                  ]
-    
-    return scripts
+    try:
+        target_time = Path(target).stat().st_mtime
+    except FileNotFoundError:
+        return 1
+    for dep in deps:
+        dep_time = Path(dep).stat().st_mtime
+        if dep_time > target_time:
+            # print("For target",target,"Dep failed:",dep)  # dbg
+            # print("times (dep,tar):",dep_time,target_time)  # dbg
+            return 1
+    return 0
+
+
+def target_update(target, deps, cmd):
+    """Update a target with a given command given a list of dependencies.
+
+    target_update(target,deps,cmd) -> runs cmd if target is outdated.
+
+    This is just a wrapper around target_outdated() which calls the given
+    command if target is outdated."""
+
+    if target_outdated(target, deps):
+        os.system(cmd)
 
 #---------------------------------------------------------------------------
-# Verify all dependencies
+# VCS related
 #---------------------------------------------------------------------------
 
-def check_for_dependencies():
-    """Check for IPython's dependencies.
-    
-    This function should NOT be called if running under setuptools!
-    """
-    from setupext.setupext import (
-        print_line, print_raw, print_status,
-        check_for_sphinx, check_for_pygments,
-        check_for_nose, check_for_pexpect,
-        check_for_pyzmq, check_for_readline
-    )
-    print_line()
-    print_raw("BUILDING IPYTHON")
-    print_status('python', sys.version)
-    print_status('platform', sys.platform)
-    if sys.platform == 'win32':
-        print_status('Windows version', sys.getwindowsversion())
-    
-    print_raw("")
-    print_raw("OPTIONAL DEPENDENCIES")
-
-    check_for_sphinx()
-    check_for_pygments()
-    check_for_nose()
-    check_for_pexpect()
-    check_for_pyzmq()
-    check_for_readline()
-
-def record_commit_info(pkg_dir, build_cmd=build_py):
-    """ Return extended build command class for recording commit
-
-    The extended command tries to run git to find the current commit, getting
-    the empty string if it fails.  It then writes the commit hash into a file
-    in the `pkg_dir` path, named ``.git_commit_info.ini``.
-
-    In due course this information can be used by the package after it is
-    installed, to tell you what commit it was installed from if known.
-
-    To make use of this system, you need a package with a .git_commit_info.ini
-    file - e.g. ``myproject/.git_commit_info.ini`` - that might well look like
-    this::
-
-        # This is an ini file that may contain information about the code state
-        [commit hash]
-        # The line below may contain a valid hash if it has been substituted
-        # during 'git archive'
-        archive_subst_hash=$Format:%h$
-        # This line may be modified by the install process
-        install_hash=
-
-    The .git_commit_info file above is also designed to be used with git
-    substitution - so you probably also want a ``.gitattributes`` file in the
-    root directory of your working tree that contains something like this::
-
-       myproject/.git_commit_info.ini export-subst
-
-    That will cause the ``.git_commit_info.ini`` file to get filled in by ``git
-    archive`` - useful in case someone makes such an archive - for example with
-    via the github 'download source' button.
-
-    Although all the above will work as is, you might consider having something
-    like a ``get_info()`` function in your package to display the commit
-    information at the terminal.  See the ``pkg_info.py`` module in the nipy
-    package for an example.
+def git_prebuild(pkg_dir, build_cmd=build_py):
+    """Return extended build or sdist command class for recording commit
+
+    records git commit in IPython.utils._sysinfo.commit
+
+    for use in IPython.utils.sysinfo.sys_info() calls after installation.
     """
+
     class MyBuildPy(build_cmd):
         ''' Subclass to write commit data into installation tree '''
         def run(self):
-            build_py.run(self)
+            # loose as `.dev` is suppose to be invalid
+            print("check version number")
+            loose_pep440re = re.compile(r'^(\d+)\.(\d+)\.(\d+((a|b|rc)\d+)?)(\.post\d+)?(\.dev\d*)?$')
+            if not loose_pep440re.match(version):
+                raise ValueError("Version number '%s' is not valid (should match [N!]N(.N)*[{a|b|rc}N][.postN][.devN])" % version)
+
+
+            build_cmd.run(self)
+            # this one will only fire for build commands
+            if hasattr(self, 'build_lib'):
+                self._record_commit(self.build_lib)
+
+        def make_release_tree(self, base_dir, files):
+            # this one will fire for sdist
+            build_cmd.make_release_tree(self, base_dir, files)
+            self._record_commit(base_dir)
+
+        def _record_commit(self, base_dir):
             import subprocess
             proc = subprocess.Popen('git rev-parse --short HEAD',
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE,
                                     shell=True)
             repo_commit, _ = proc.communicate()
-            # We write the installation commit even if it's empty
-            cfg_parser = ConfigParser()
-            cfg_parser.read(pjoin(pkg_dir, '.git_commit_info.ini'))
-            cfg_parser.set('commit hash', 'install_hash', repo_commit)
-            out_pth = pjoin(self.build_lib, pkg_dir, '.git_commit_info.ini')
-            out_file = open(out_pth, 'wt')
-            cfg_parser.write(out_file)
-            out_file.close()
+            repo_commit = repo_commit.strip().decode("ascii")
+
+            out_pth = Path(base_dir) / pkg_dir / "utils" / "_sysinfo.py"
+            if out_pth.is_file() and not repo_commit:
+                # nothing to write, don't clobber
+                return
+
+            print(f"writing git commit '{repo_commit}' to {out_pth}")
+
+            # remove to avoid overwriting original via hard link
+            try:
+                out_pth.unlink()
+            except FileNotFoundError:
+                pass
+            with out_pth.open("w", encoding="utf-8") as out_file:
+                out_file.writelines(
+                    [
+                        "# GENERATED BY setup.py\n",
+                        f'commit = "{repo_commit}"\n',
+                    ]
+                )
+
     return MyBuildPy
diff --git a/setupegg.py b/setupegg.py
deleted file mode 100755
index d9c31b983c9..00000000000
--- a/setupegg.py
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/usr/bin/env python
-"""Wrapper to run setup.py using setuptools."""
-
-# Import setuptools and call the actual setup
-import setuptools
-execfile('setup.py')
diff --git a/setupext/__init__.py b/setupext/__init__.py
deleted file mode 100644
index 5f93fe17c85..00000000000
--- a/setupext/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-# load extended setup modules for distuils
-
-from install_data_ext import install_data_ext
diff --git a/setupext/install_data_ext.py b/setupext/install_data_ext.py
deleted file mode 100644
index f2ce8944bde..00000000000
--- a/setupext/install_data_ext.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# install_data_ext.py
-#
-# Subclass of normal distutils install_data command to allow more
-# configurable installation of data files.
-
-import os
-from distutils.command.install_data import install_data
-from distutils.util import change_root, convert_path
-
-class install_data_ext(install_data):
-
-    def initialize_options(self):
-        self.install_base = None
-        self.install_platbase = None
-        self.install_purelib = None
-        self.install_headers = None
-        self.install_lib = None
-        self.install_scripts = None
-        self.install_data = None
-
-        self.outfiles = []
-        self.root = None
-        self.force = 0
-        self.data_files = self.distribution.data_files
-        self.warn_dir = 1
-        
-
-    def finalize_options(self):
-        self.set_undefined_options('install',
-                                   ('root', 'root'),
-                                   ('force', 'force'),
-                                   ('install_base', 'install_base'),
-                                   ('install_platbase',
-                                    'install_platbase'),
-                                   ('install_purelib',
-                                    'install_purelib'),
-                                   ('install_headers',
-                                    'install_headers'),
-                                   ('install_lib', 'install_lib'),
-                                   ('install_scripts',
-                                    'install_scripts'),
-                                   ('install_data', 'install_data'))
-                                   
-
-    def run(self):
-        """
-        This is where the meat is.  Basically the data_files list must
-        now be a list of tuples of 3 entries.  The first
-        entry is one of 'base', 'platbase', etc, which indicates which
-        base to install from.  The second entry is the path to install
-        too.  The third entry is a list of files to install.
-        """
-        for lof in self.data_files:
-            if lof[0]:
-                base = getattr(self, 'install_' + lof[0])
-            else:
-                base = getattr(self, 'install_base')
-            dir = convert_path(lof[1])
-            if not os.path.isabs(dir):
-                dir = os.path.join(base, dir)
-            elif self.root:
-                dir = change_root(self.root, dir)
-            self.mkpath(dir)
-
-            files = lof[2]
-            if len(files) == 0:
-                # If there are no files listed, the user must be
-                # trying to create an empty directory, so add the the
-                # directory to the list of output files.
-                self.outfiles.append(dir)
-            else:
-                # Copy files, adding them to the list of output files.
-                for f in files:
-                    f = convert_path(f)
-                    (out, _) = self.copy_file(f, dir)
-                    #print "DEBUG: ", out  # dbg
-                    self.outfiles.append(out)
-                    
-
-        return self.outfiles
diff --git a/setupext/setupext.py b/setupext/setupext.py
deleted file mode 100644
index ed8ae349848..00000000000
--- a/setupext/setupext.py
+++ /dev/null
@@ -1,163 +0,0 @@
-# encoding: utf-8
-
-__docformat__ = "restructuredtext en"
-
-#-------------------------------------------------------------------------------
-#  Copyright (C) 2008  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-------------------------------------------------------------------------------
-
-#-------------------------------------------------------------------------------
-# Imports
-#-------------------------------------------------------------------------------
-
-import sys, os
-from textwrap import fill
-
-display_status=True
-
-def check_display(f):
-    """decorator to allow display methods to be muted by mod.display_status"""
-    def maybe_display(*args, **kwargs):
-        if display_status:
-            return f(*args, **kwargs)
-    return maybe_display
-
-@check_display
-def print_line(char='='):
-    print char * 76
-
-@check_display
-def print_status(package, status):
-    initial_indent = "%22s: " % package
-    indent = ' ' * 24
-    print fill(str(status), width=76,
-               initial_indent=initial_indent,
-               subsequent_indent=indent)
-
-@check_display
-def print_message(message):
-    indent = ' ' * 24 + "* "
-    print fill(str(message), width=76,
-               initial_indent=indent,
-               subsequent_indent=indent)
-
-@check_display
-def print_raw(section):
-    print section
-
-#-------------------------------------------------------------------------------
-# Tests for specific packages
-#-------------------------------------------------------------------------------
-
-def check_for_ipython():
-    try:
-        import IPython
-    except ImportError:
-        print_status("IPython", "Not found")
-        return False
-    else:
-        print_status("IPython", IPython.__version__)
-        return True
-
-def check_for_sphinx():
-    try:
-        import sphinx
-    except ImportError:
-        print_status('sphinx', "Not found (required for building documentation)")
-        return False
-    else:
-        print_status('sphinx', sphinx.__version__) 
-        return True
-
-def check_for_pygments():
-    try:
-        import pygments
-    except ImportError:
-        print_status('pygments', "Not found (required for syntax highlighting documentation)")
-        return False
-    else:
-        print_status('pygments', pygments.__version__)
-        return True
-
-def check_for_nose():
-    try:
-        import nose
-    except ImportError:
-        print_status('nose', "Not found (required for running the test suite)")
-        return False
-    else:
-        print_status('nose', nose.__version__)
-        return True
-
-def check_for_pexpect():
-    try:
-        import pexpect
-    except ImportError:
-        print_status("pexpect", "no (required for running standalone doctests)")
-        return False
-    else:
-        print_status("pexpect", pexpect.__version__)
-        return True
-
-def check_for_httplib2():
-    try:
-        import httplib2
-    except ImportError:
-        print_status("httplib2", "no (required for blocking http clients)")
-        return False
-    else:
-        print_status("httplib2","yes")
-        return True
-
-def check_for_sqlalchemy():
-    try:
-        import sqlalchemy
-    except ImportError:
-        print_status("sqlalchemy", "no (required for the ipython1 notebook)")
-        return False
-    else:
-        print_status("sqlalchemy","yes")
-        return True
-
-def check_for_simplejson():
-    try:
-        import simplejson
-    except ImportError:
-        print_status("simplejson", "no (required for the ipython1 notebook)")
-        return False
-    else:
-        print_status("simplejson","yes")
-        return True
-
-def check_for_pyzmq():
-    try:
-        import zmq
-    except ImportError:
-        print_status('pyzmq', "no (required for qtconsole and parallel computing capabilities)")
-        return False
-    else:
-        if zmq.__version__ < '2.0.10':
-            print_status('pyzmq', "no (require >= 2.0.10 for qtconsole and parallel computing capabilities)")
-            
-        else:
-            print_status("pyzmq", zmq.__version__)
-            return True
-
-def check_for_readline():
-    try:
-        import readline
-    except ImportError:
-        try:
-            import pyreadline
-        except ImportError:
-            print_status('readline', "no (required for good interactive behavior)")
-            return False
-        else:
-            print_status('readline', "yes pyreadline-"+pyreadline.release.version)
-            return True
-    else:
-        print_status('readline', "yes")
-        return True
diff --git a/tests/2x2.jpg b/tests/2x2.jpg
new file mode 100644
index 00000000000..3d176625fc5
Binary files /dev/null and b/tests/2x2.jpg differ
diff --git a/tests/2x2.png b/tests/2x2.png
new file mode 100644
index 00000000000..99d131317bb
Binary files /dev/null and b/tests/2x2.png differ
diff --git a/IPython/deathrow/__init__.py b/tests/__init__.py
similarity index 100%
rename from IPython/deathrow/__init__.py
rename to tests/__init__.py
diff --git a/tests/bad_all.py b/tests/bad_all.py
new file mode 100644
index 00000000000..0d50bf01ffe
--- /dev/null
+++ b/tests/bad_all.py
@@ -0,0 +1,18 @@
+"""Module with bad __all__
+
+To test https://github.com/ipython/ipython/issues/9678
+"""
+
+
+def evil():
+    pass
+
+
+def puppies():
+    pass
+
+
+__all__ = [
+    evil,  # Bad
+    "puppies",  # Good
+]
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 00000000000..6368d342804
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,81 @@
+import builtins
+import inspect
+import os
+import pathlib
+import shutil
+import sys
+import types
+
+import pytest
+
+# Must register before it gets imported
+pytest.register_assert_rewrite("IPython.testing.tools")
+
+from IPython.testing import tools
+
+
+def get_ipython():
+    from IPython.terminal.interactiveshell import TerminalInteractiveShell
+
+    if TerminalInteractiveShell._instance:
+        return TerminalInteractiveShell.instance()
+
+    config = tools.default_config()
+    config.TerminalInteractiveShell.simple_prompt = True
+
+    # Create and initialize our test-friendly IPython instance.
+    shell = TerminalInteractiveShell.instance(config=config)
+    return shell
+
+
+@pytest.fixture(scope="session", autouse=True)
+def work_path():
+    path = pathlib.Path("./tmp-ipython-pytest-profiledir")
+    os.environ["IPYTHONDIR"] = str(path.absolute())
+    if path.exists():
+        raise ValueError(
+            "IPython dir temporary path already exists ! Did previous test run exit successfully ?"
+        )
+    path.mkdir()
+    yield
+    shutil.rmtree(str(path.resolve()))
+
+
+def nopage(strng, start=0, screen_lines=0, pager_cmd=None):
+    if isinstance(strng, dict):
+        strng = strng.get("text/plain", "")
+    print(strng)
+
+
+def xsys(self, cmd):
+    """Replace the default system call with a capturing one for doctest."""
+    # We use getoutput, but we need to strip it because pexpect captures
+    # the trailing newline differently from commands.getoutput
+    print(self.getoutput(cmd, split=False, depth=1).rstrip(), end="", file=sys.stdout)
+    sys.stdout.flush()
+
+
+# for things to work correctly we would need this as a session fixture;
+# unfortunately this will fail on some test that get executed as _collection_
+# time (before the fixture run), in particular parametrized test that contain
+# yields. so for now execute at import time.
+# @pytest.fixture(autouse=True, scope='session')
+def inject():
+    builtins.get_ipython = get_ipython
+    builtins._ip = get_ipython()
+    builtins.ip = get_ipython()
+    builtins.ip.system = types.MethodType(xsys, ip)
+    builtins.ip.builtin_trap.activate()
+    from IPython.core import page
+
+    page.pager_page = nopage
+
+    from IPython.core.history import HistoryManager
+
+    # ensure we don't leak History managers
+    if os.name != "nt":
+        HistoryManager._max_inst = 1
+    # yield
+
+
+inject()
diff --git a/tests/fake_ext_dir/daft_extension.py b/tests/fake_ext_dir/daft_extension.py
new file mode 100644
index 00000000000..415e136d4e9
--- /dev/null
+++ b/tests/fake_ext_dir/daft_extension.py
@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+"""
+Useless IPython extension to test installing and loading extensions.
+"""
+some_vars = {"arq": 185}
+
+
+def load_ipython_extension(ip):
+    # set up simplified quantity input
+    ip.push(some_vars)
+
+
+def unload_ipython_extension(ip):
+    ip.drop_by_id(some_vars)
diff --git a/tests/fake_llm.py b/tests/fake_llm.py
new file mode 100644
index 00000000000..ceacc5a8ea5
--- /dev/null
+++ b/tests/fake_llm.py
@@ -0,0 +1,102 @@
+import asyncio
+from time import sleep
+
+try:
+    from jupyter_ai_magics.providers import BaseProvider
+    from langchain_community.llms import FakeListLLM
+except ImportError:
+
+    class BaseProvider:
+        pass
+
+    class FakeListLLM:
+        pass
+
+
+FIBONACCI = """\
+def fib(n):
+    if n < 2: return n
+    return fib(n - 1) + fib(n - 2)
+"""
+
+
+class FibonacciCompletionProvider(BaseProvider, FakeListLLM):  # type: ignore[misc, valid-type]
+    id = "my_provider"
+    name = "My Provider"
+    model_id_key = "model"
+    models = ["model_a"]
+
+    def __init__(self, **kwargs):
+        kwargs["responses"] = ["This fake response will not be used for completion"]
+        kwargs["model_id"] = "model_a"
+        super().__init__(**kwargs)
+
+    async def generate_inline_completions(self, request):
+        raise ValueError("IPython only supports streaming models.")
+
+    async def stream_inline_completions(self, request):
+        from jupyter_ai.completions.models import (
+            InlineCompletionList,
+            InlineCompletionReply,
+        )
+
+        assert request.number > 0
+        token = f"t{request.number}s0"
+        last_line = request.prefix.splitlines()[-1]
+
+        if not FIBONACCI.startswith(last_line):
+            return
+
+        yield InlineCompletionReply(
+            list=InlineCompletionList(
+                items=[
+                    {"insertText": "", "isIncomplete": True, "token": token},
+                ]
+            ),
+            reply_to=request.number,
+        )
+
+        async for reply in self._stream(
+            FIBONACCI[len(last_line) :],
+            request.number,
+            token,
+        ):
+            yield reply
+
+    async def _stream(self, sentence, request_number, token, start_with=""):
+        from jupyter_ai.completions.models import InlineCompletionStreamChunk
+
+        suggestion = start_with
+
+        for fragment in sentence.split(" "):
+            await asyncio.sleep(0.05)
+            if suggestion:
+                suggestion += " "
+            suggestion += fragment
+            yield InlineCompletionStreamChunk(
+                type="stream",
+                response={"insertText": suggestion, "token": token},
+                reply_to=request_number,
+                done=False,
+            )
+
+        # finally, send a message confirming that we are done
+        yield InlineCompletionStreamChunk(
+            type="stream",
+            response={"insertText": suggestion, "token": token},
+            reply_to=request_number,
+            done=True,
+        )
+
+
+class SlowStartingCompletionProvider(BaseProvider, FakeListLLM):  # type: ignore[misc, valid-type]
+    id = "slow_provider"
+    name = "Slow Provider"
+    model_id_key = "model"
+    models = ["model_a"]
+
+    def __init__(self, **kwargs):
+        kwargs["responses"] = ["This fake response will be used for completion"]
+        kwargs["model_id"] = "model_a"
+        sleep(10)
+        super().__init__(**kwargs)
diff --git a/tests/nonascii.py b/tests/nonascii.py
new file mode 100644
index 00000000000..12738e3adc2
--- /dev/null
+++ b/tests/nonascii.py
@@ -0,0 +1,4 @@
+# coding: iso-8859-5
+# (Unlikely to be the default encoding for most testers.)
+# ±¶ÿàáâãäåæçèéêëìíîï <- Cyrillic characters
+u = "®âðÄ"
diff --git a/tests/nonascii2.py b/tests/nonascii2.py
new file mode 100644
index 00000000000..b87ceb0a1b8
--- /dev/null
+++ b/tests/nonascii2.py
@@ -0,0 +1,4 @@
+# coding: iso-8859-5
+# (Unlikely to be the default encoding for most testers.)
+# ±¶ÿàáâãäåæçèéêëìíîï <- Cyrillic characters
+"®âðÄ"
diff --git a/tests/print_argv.py b/tests/print_argv.py
new file mode 100644
index 00000000000..4ec9e2799ed
--- /dev/null
+++ b/tests/print_argv.py
@@ -0,0 +1,3 @@
+import sys
+
+print(sys.argv[1:])
diff --git a/tests/refbug.py b/tests/refbug.py
new file mode 100644
index 00000000000..07aa6acdc99
--- /dev/null
+++ b/tests/refbug.py
@@ -0,0 +1,45 @@
+"""Minimal script to reproduce our nasty reference counting bug.
+
+The problem is related to https://github.com/ipython/ipython/issues/141
+
+The original fix for that appeared to work, but John D. Hunter found a
+matplotlib example which, when run twice in a row, would break.  The problem
+were references held by open figures to internals of Tkinter.
+
+This code reproduces the problem that John saw, without matplotlib.
+
+This script is meant to be called by other parts of the test suite that call it
+via %run as if it were executed interactively by the user. As of 2011-05-29,
+test_run.py calls it.
+"""
+
+# -----------------------------------------------------------------------------
+# Module imports
+# -----------------------------------------------------------------------------
+
+from IPython import get_ipython
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+
+# This needs to be here because nose and other test runners will import
+# this module. Importing this module has potential side effects that we
+# want to prevent.
+if __name__ == "__main__":
+    ip = get_ipython()
+
+    if not "_refbug_cache" in ip.user_ns:
+        ip.user_ns["_refbug_cache"] = []
+
+    aglobal = "Hello"
+
+    def f():
+        return aglobal
+
+    cache = ip.user_ns["_refbug_cache"]
+    cache.append(f)
+
+    def call_f():
+        for func in cache:
+            print("lowercased:", func().lower())
diff --git a/tests/simpleerr.py b/tests/simpleerr.py
new file mode 100644
index 00000000000..28464c329d2
--- /dev/null
+++ b/tests/simpleerr.py
@@ -0,0 +1,37 @@
+"""Error script. DO NOT EDIT FURTHER! It will break exception doctests!!!"""
+
+import sys
+
+
+def div0():
+    "foo"
+    x = 1
+    y = 0
+    x / y
+
+
+def sysexit(stat, mode):
+    raise SystemExit(stat, f"Mode = {mode}")
+
+
+def bar(mode):
+    "bar"
+    if mode == "div":
+        div0()
+    elif mode == "exit":
+        try:
+            stat = int(sys.argv[2])
+        except:
+            stat = 1
+        sysexit(stat, mode)
+    else:
+        raise ValueError("Unknown mode")
+
+
+if __name__ == "__main__":
+    try:
+        mode = sys.argv[1]
+    except IndexError:
+        mode = "div"
+
+    bar(mode)
diff --git a/IPython/core/tests/tclass.py b/tests/tclass.py
similarity index 75%
rename from IPython/core/tests/tclass.py
rename to tests/tclass.py
index 38b3a5ab03c..5160e171b23 100644
--- a/IPython/core/tests/tclass.py
+++ b/tests/tclass.py
@@ -4,29 +4,32 @@
 
 import sys
 
+
 # We want to ensure that while objects remain available for immediate access,
 # objects from *previous* runs of the same script get collected, to avoid
 # accumulating massive amounts of old references.
 class C(object):
-    def __init__(self,name):
+    def __init__(self, name):
         self.name = name
+        self.p = print
         self.flush_stdout = sys.stdout.flush
-        
+
     def __del__(self):
-        print 'tclass.py: deleting object:',self.name
+        self.p("tclass.py: deleting object:", self.name)
         self.flush_stdout()
 
+
 try:
     name = sys.argv[1]
 except IndexError:
     pass
 else:
-    if name.startswith('C'):
+    if name.startswith("C"):
         c = C(name)
 
-#print >> sys.stderr, "ARGV:", sys.argv  # dbg
+# print("ARGV:", sys.argv, file=sys.stderr)  # dbg
 
 # This next print statement is NOT debugging, we're making the check on a
 # completely separate process so we verify by capturing stdout:
-print 'ARGV 1-:', sys.argv[1:]
+print("ARGV 1-:", sys.argv[1:])
 sys.stdout.flush()
diff --git a/tests/test.wav b/tests/test.wav
new file mode 100644
index 00000000000..aa74fc5bd27
Binary files /dev/null and b/tests/test.wav differ
diff --git a/tests/test_alias.py b/tests/test_alias.py
new file mode 100644
index 00000000000..c92aa839460
--- /dev/null
+++ b/tests/test_alias.py
@@ -0,0 +1,68 @@
+from IPython.utils.capture import capture_output
+
+import pytest
+
+
+def test_alias_lifecycle():
+    name = "test_alias1"
+    cmd = 'echo "Hello"'
+    am = _ip.alias_manager
+    am.clear_aliases()
+    am.define_alias(name, cmd)
+    assert am.is_alias(name)
+    assert am.retrieve_alias(name) == cmd
+    assert (name, cmd) in am.aliases
+
+    # Test running the alias
+    orig_system = _ip.system
+    result = []
+    _ip.system = result.append
+    try:
+        _ip.run_cell("%{}".format(name))
+        result = [c.strip() for c in result]
+        assert result == [cmd]
+    finally:
+        _ip.system = orig_system
+
+    # Test removing the alias
+    am.undefine_alias(name)
+    assert not am.is_alias(name)
+    with pytest.raises(ValueError):
+        am.retrieve_alias(name)
+    assert (name, cmd) not in am.aliases
+
+
+def test_alias_args_error():
+    """Error expanding with wrong number of arguments"""
+    _ip.alias_manager.define_alias("parts", "echo first %s second %s")
+    # capture stderr:
+    with capture_output() as cap:
+        _ip.run_cell("parts 1")
+
+    assert cap.stderr.split(":")[0] == "UsageError"
+
+
+def test_alias_args_commented():
+    """Check that alias correctly ignores 'commented out' args"""
+    _ip.run_line_magic("alias", "commentarg echo this is %%s a commented out arg")
+
+    with capture_output() as cap:
+        _ip.run_cell("commentarg")
+
+    # strip() is for pytest compat; testing via iptest patch IPython shell
+    # in testing.globalipapp and replace the system call which messed up the
+    # \r\n
+    assert cap.stdout.strip() == "this is %s a commented out arg"
+
+
+def test_alias_args_commented_nargs():
+    """Check that alias correctly counts args, excluding those commented out"""
+    am = _ip.alias_manager
+    alias_name = "comargcount"
+    cmd = "echo this is %%s a commented out arg and this is not %s"
+
+    am.define_alias(alias_name, cmd)
+    assert am.is_alias(alias_name)
+
+    thealias = am.get_alias(alias_name)
+    assert thealias.nargs == 1
diff --git a/tests/test_application.py b/tests/test_application.py
new file mode 100644
index 00000000000..96232f5b903
--- /dev/null
+++ b/tests/test_application.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+"""Tests for IPython.core.application"""
+
+import os
+import tempfile
+
+from tempfile import TemporaryDirectory
+from traitlets import Unicode
+
+from IPython.core.application import BaseIPythonApplication
+from IPython.testing import decorators as dec
+
+
+@dec.onlyif_unicode_paths
+def test_unicode_cwd():
+    """Check that IPython starts with non-ascii characters in the path."""
+    wd = tempfile.mkdtemp(suffix="€")
+
+    old_wd = os.getcwd()
+    os.chdir(wd)
+    # raise Exception(repr(os.getcwd()))
+    try:
+        app = BaseIPythonApplication()
+        # The lines below are copied from Application.initialize()
+        app.init_profile_dir()
+        app.init_config_files()
+        app.load_config_file(suppress_errors=False)
+    finally:
+        os.chdir(old_wd)
+
+
+@dec.onlyif_unicode_paths
+def test_unicode_ipdir():
+    """Check that IPython starts with non-ascii characters in the IP dir."""
+    ipdir = tempfile.mkdtemp(suffix="€")
+
+    # Create the config file, so it tries to load it.
+    with open(os.path.join(ipdir, "ipython_config.py"), "w", encoding="utf-8") as f:
+        pass
+
+    old_ipdir1 = os.environ.pop("IPYTHONDIR", None)
+    old_ipdir2 = os.environ.pop("IPYTHON_DIR", None)
+    os.environ["IPYTHONDIR"] = ipdir
+    try:
+        app = BaseIPythonApplication()
+        # The lines below are copied from Application.initialize()
+        app.init_profile_dir()
+        app.init_config_files()
+        app.load_config_file(suppress_errors=False)
+    finally:
+        if old_ipdir1:
+            os.environ["IPYTHONDIR"] = old_ipdir1
+        if old_ipdir2:
+            os.environ["IPYTHONDIR"] = old_ipdir2
+
+
+def test_cli_priority():
+    with TemporaryDirectory() as td:
+
+        class TestApp(BaseIPythonApplication):
+            test = Unicode().tag(config=True)
+
+        # Create the config file, so it tries to load it.
+        with open(os.path.join(td, "ipython_config.py"), "w", encoding="utf-8") as f:
+            f.write("c.TestApp.test = 'config file'")
+
+        app = TestApp()
+        app.initialize(["--profile-dir", td])
+        assert app.test == "config file"
+        app = TestApp()
+        app.initialize(["--profile-dir", td, "--TestApp.test=cli"])
+        assert app.test == "cli"
diff --git a/tests/test_async_helpers.py b/tests/test_async_helpers.py
new file mode 100644
index 00000000000..73ce2f7b410
--- /dev/null
+++ b/tests/test_async_helpers.py
@@ -0,0 +1,459 @@
+"""
+Test for async helpers.
+
+Should only trigger on python 3.5+ or will have syntax errors.
+"""
+
+import sys
+from itertools import chain, repeat
+from textwrap import dedent, indent
+from typing import TYPE_CHECKING
+from unittest import TestCase
+
+import pytest
+
+from IPython.core.async_helpers import _should_be_async
+from IPython.testing.decorators import skip_without
+
+if TYPE_CHECKING:
+    from IPython import get_ipython
+
+    ip = get_ipython()
+
+
+def iprc(x):
+    return ip.run_cell(dedent(x)).raise_error()
+
+
+def iprc_nr(x):
+    return ip.run_cell(dedent(x))
+
+
+class AsyncTest(TestCase):
+    def test_should_be_async(self):
+        self.assertFalse(_should_be_async("False"))
+        self.assertTrue(_should_be_async("await bar()"))
+        self.assertTrue(_should_be_async("x = await bar()"))
+        self.assertFalse(
+            _should_be_async(
+                dedent(
+                    """
+            async def awaitable():
+                pass
+        """
+                )
+            )
+        )
+
+        self.assertFalse(_should_be_async("return await foo()"))
+        self.assertFalse(_should_be_async("return bar()"))
+        self.assertFalse(_should_be_async("some invalid Python code"))
+
+        self.assertFalse(_should_be_async("'\\ud800'"))
+        
+        if sys.version_info >= (3, 13):
+            # Note: the next assert assumes the tests run without the `-OO` flag
+            self.assertFalse(_should_be_async("'\\ud800'\nawait foo"))
+
+    def _get_top_level_cases(self):
+        # These are test cases that should be valid in a function
+        # but invalid outside of a function.
+        test_cases = []
+        test_cases.append(("basic", "{val}"))
+
+        # Note, in all conditional cases, I use True instead of
+        # False so that the peephole optimizer won't optimize away
+        # the return, so CPython will see this as a syntax error:
+        #
+        # while True:
+        #    break
+        #    return
+        #
+        # But not this:
+        #
+        # while False:
+        #    return
+        #
+        # See https://bugs.python.org/issue1875
+
+        test_cases.append(
+            (
+                "if",
+                dedent(
+                    """
+        if True:
+            {val}
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "while",
+                dedent(
+                    """
+        while True:
+            {val}
+            break
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "try",
+                dedent(
+                    """
+        try:
+            {val}
+        except:
+            pass
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "except",
+                dedent(
+                    """
+        try:
+            pass
+        except:
+            {val}
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "finally",
+                dedent(
+                    """
+        try:
+            pass
+        except:
+            pass
+        finally:
+            {val}
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "for",
+                dedent(
+                    """
+        for _ in range(4):
+            {val}
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "nested",
+                dedent(
+                    """
+        if True:
+            while True:
+                {val}
+                break
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "deep-nested",
+                dedent(
+                    """
+        if True:
+            while True:
+                break
+                for x in range(3):
+                    if True:
+                        while True:
+                            for x in range(3):
+                                {val}
+        """
+                ),
+            )
+        )
+
+        return test_cases
+
+    def _get_ry_syntax_errors(self):
+        # This is a mix of tests that should be a syntax error if
+        # return or yield whether or not they are in a function
+
+        test_cases = []
+
+        test_cases.append(
+            (
+                "class",
+                dedent(
+                    """
+        class V:
+            {val}
+        """
+                ),
+            )
+        )
+
+        test_cases.append(
+            (
+                "nested-class",
+                dedent(
+                    """
+        class V:
+            class C:
+                {val}
+        """
+                ),
+            )
+        )
+
+        return test_cases
+
+    def test_top_level_return_error(self):
+        tl_err_test_cases = self._get_top_level_cases()
+        tl_err_test_cases.extend(self._get_ry_syntax_errors())
+
+        vals = (
+            "return",
+            "yield",
+            "yield from (_ for _ in range(3))",
+            dedent(
+                """
+                    def f():
+                        pass
+                    return
+                    """
+            ),
+        )
+
+        for test_name, test_case in tl_err_test_cases:
+            # This example should work if 'pass' is used as the value
+            with self.subTest((test_name, "pass")):
+                iprc(test_case.format(val="pass"))
+
+            # It should fail with all the values
+            for val in vals:
+                with self.subTest((test_name, val)):
+                    msg = "Syntax error not raised for %s, %s" % (test_name, val)
+                    with self.assertRaises(SyntaxError, msg=msg):
+                        iprc(test_case.format(val=val))
+
+    def test_in_func_no_error(self):
+        # Test that the implementation of top-level return/yield
+        # detection isn't *too* aggressive, and works inside a function
+        func_contexts = []
+
+        func_contexts.append(
+            (
+                "func",
+                False,
+                dedent(
+                    """
+        def f():"""
+                ),
+            )
+        )
+
+        func_contexts.append(
+            (
+                "method",
+                False,
+                dedent(
+                    """
+        class MyClass:
+            def __init__(self):
+        """
+                ),
+            )
+        )
+
+        func_contexts.append(
+            (
+                "async-func",
+                True,
+                dedent(
+                    """
+        async def f():"""
+                ),
+            )
+        )
+
+        func_contexts.append(
+            (
+                "async-method",
+                True,
+                dedent(
+                    """
+        class MyClass:
+            async def f(self):"""
+                ),
+            )
+        )
+
+        func_contexts.append(
+            (
+                "closure",
+                False,
+                dedent(
+                    """
+        def f():
+            def g():
+        """
+                ),
+            )
+        )
+
+        def nest_case(context, case):
+            # Detect indentation
+            lines = context.strip().splitlines()
+            prefix_len = 0
+            for c in lines[-1]:
+                if c != " ":
+                    break
+                prefix_len += 1
+
+            indented_case = indent(case, " " * (prefix_len + 4))
+            return context + "\n" + indented_case
+
+        # Gather and run the tests
+
+        # yield is allowed in async functions, starting in Python 3.6,
+        # and yield from is not allowed in any version
+        vals = ("return", "yield", "yield from (_ for _ in range(3))")
+
+        success_tests = zip(self._get_top_level_cases(), repeat(False))
+        failure_tests = zip(self._get_ry_syntax_errors(), repeat(True))
+
+        tests = chain(success_tests, failure_tests)
+
+        for context_name, async_func, context in func_contexts:
+            for (test_name, test_case), should_fail in tests:
+                nested_case = nest_case(context, test_case)
+
+                for val in vals:
+                    test_id = (context_name, test_name, val)
+                    cell = nested_case.format(val=val)
+
+                    with self.subTest(test_id):
+                        if should_fail:
+                            msg = "SyntaxError not raised for %s" % str(test_id)
+                            with self.assertRaises(SyntaxError, msg=msg):
+                                iprc(cell)
+
+                                print(cell)
+                        else:
+                            iprc(cell)
+
+    def test_nonlocal(self):
+        # fails if outer scope is not a function scope or if var not defined
+        with self.assertRaises(SyntaxError):
+            iprc("nonlocal x")
+            iprc(
+                """
+            x = 1
+            def f():
+                nonlocal x
+                x = 10000
+                yield x
+            """
+            )
+            iprc(
+                """
+            def f():
+                def g():
+                    nonlocal x
+                    x = 10000
+                    yield x
+            """
+            )
+
+        # works if outer scope is a function scope and var exists
+        iprc(
+            """
+        def f():
+            x = 20
+            def g():
+                nonlocal x
+                x = 10000
+                yield x
+        """
+        )
+
+    def test_execute(self):
+        iprc(
+            """
+        import asyncio
+        await asyncio.sleep(0.001)
+        """
+        )
+
+    def test_autoawait(self):
+        iprc("%autoawait False")
+        iprc("%autoawait True")
+        iprc(
+            """
+        from asyncio import sleep
+        await sleep(0.1)
+        """
+        )
+
+    def test_memory_error(self):
+        """
+        The pgen parser in 3.8 or before use to raise MemoryError on too many
+        nested parens anymore"""
+
+        iprc("(" * 200 + ")" * 200)
+
+    @pytest.mark.xfail(reason="fail on curio 1.6 and before on Python 3.12")
+    @pytest.mark.skip(
+        reason="skip_without(curio) fails on 3.12 for now even with other skip so must uncond skip"
+    )
+    # @skip_without("curio")
+    def test_autoawait_curio(self):
+        iprc("%autoawait curio")
+
+    @skip_without("trio")
+    def test_autoawait_trio(self):
+        iprc("%autoawait trio")
+
+    @skip_without("trio")
+    def test_autoawait_trio_wrong_sleep(self):
+        iprc("%autoawait trio")
+        res = iprc_nr(
+            """
+        import asyncio
+        await asyncio.sleep(0)
+        """
+        )
+        with self.assertRaises(TypeError):
+            res.raise_error()
+
+    @skip_without("trio")
+    def test_autoawait_asyncio_wrong_sleep(self):
+        iprc("%autoawait asyncio")
+        res = iprc_nr(
+            """
+        import trio
+        await trio.sleep(0)
+        """
+        )
+        with self.assertRaises(RuntimeError):
+            res.raise_error()
+
+    def tearDown(self):
+        ip.loop_runner = "asyncio"
diff --git a/tests/test_autocall.py b/tests/test_autocall.py
new file mode 100644
index 00000000000..f371a4bf750
--- /dev/null
+++ b/tests/test_autocall.py
@@ -0,0 +1,68 @@
+"""These kinds of tests are less than ideal, but at least they run.
+
+This was an old test that was being run interactively in the top-level tests/
+directory, which we are removing.  For now putting this here ensures at least
+we do run the test, though ultimately this functionality should all be tested
+with better-isolated tests that don't rely on the global instance in iptest.
+"""
+
+from IPython.core.splitinput import LineInfo
+from IPython.core.prefilter import AutocallChecker
+
+
+def doctest_autocall():
+    """
+    In [1]: def f1(a,b,c):
+       ...:     return a+b+c
+       ...:
+
+    In [2]: def f2(a):
+       ...:     return a + a
+       ...:
+
+    In [3]: def r(x):
+       ...:     return True
+       ...:
+
+    In [4]: ;f2 a b c
+    Out[4]: 'a b ca b c'
+
+    In [5]: assert _ == "a b ca b c"
+
+    In [6]: ,f1 a b c
+    Out[6]: 'abc'
+
+    In [7]: assert _ == 'abc'
+
+    In [8]: print(_)
+    abc
+
+    In [9]: /f1 1,2,3
+    Out[9]: 6
+
+    In [10]: assert _ == 6
+
+    In [11]: /f2 4
+    Out[11]: 8
+
+    In [12]: assert _ == 8
+
+    In [12]: del f1, f2
+
+    In [13]: ,r a
+    Out[13]: True
+
+    In [14]: assert _ == True
+
+    In [15]: r'a'
+    Out[15]: 'a'
+
+    In [16]: assert _ == 'a'
+    """
+
+
+def test_autocall_should_ignore_raw_strings():
+    line_info = LineInfo("r'a'")
+    pm = ip.prefilter_manager
+    ac = AutocallChecker(shell=pm.shell, prefilter_manager=pm, config=pm.config)
+    assert ac.check(line_info) is None
diff --git a/tests/test_backgroundjobs.py b/tests/test_backgroundjobs.py
new file mode 100644
index 00000000000..119c68728b3
--- /dev/null
+++ b/tests/test_backgroundjobs.py
@@ -0,0 +1,87 @@
+"""Tests for pylab tools module."""
+
+# -----------------------------------------------------------------------------
+# Copyright (c) 2011, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+# Stdlib imports
+import time
+
+# Our own imports
+from IPython.lib import backgroundjobs as bg
+
+# -----------------------------------------------------------------------------
+# Globals and constants
+# -----------------------------------------------------------------------------
+t_short = 0.0001  # very short interval to wait on jobs
+
+
+# -----------------------------------------------------------------------------
+# Local utilities
+# -----------------------------------------------------------------------------
+def sleeper(interval=t_short, *a, **kw):
+    args = dict(interval=interval, other_args=a, kw_args=kw)
+    time.sleep(interval)
+    return args
+
+
+def crasher(interval=t_short, *a, **kw):
+    time.sleep(interval)
+    raise Exception("Dead job with interval %s" % interval)
+
+
+# -----------------------------------------------------------------------------
+# Classes and functions
+# -----------------------------------------------------------------------------
+
+
+def test_result():
+    """Test job submission and result retrieval"""
+    jobs = bg.BackgroundJobManager()
+    j = jobs.new(sleeper)
+    j.join()
+    assert j.result["interval"] == t_short
+
+
+def test_flush():
+    """Test job control"""
+    jobs = bg.BackgroundJobManager()
+    j = jobs.new(sleeper)
+    j.join()
+    assert len(jobs.completed) == 1
+    assert len(jobs.dead) == 0
+    jobs.flush()
+    assert len(jobs.completed) == 0
+
+
+def test_dead():
+    """Test control of dead jobs"""
+    jobs = bg.BackgroundJobManager()
+    j = jobs.new(crasher)
+    j.join()
+    assert len(jobs.completed) == 0
+    assert len(jobs.dead) == 1
+    jobs.flush()
+    assert len(jobs.dead) == 0
+
+
+def test_longer():
+    """Test control of longer-running jobs"""
+    jobs = bg.BackgroundJobManager()
+    # Sleep for long enough for the following two checks to still report the
+    # job as running, but not so long that it makes the test suite noticeably
+    # slower.
+    j = jobs.new(sleeper, 0.1)
+    assert len(jobs.running) == 1
+    assert len(jobs.completed) == 0
+    j.join()
+    assert len(jobs.running) == 0
+    assert len(jobs.completed) == 1
diff --git a/tests/test_capture.py b/tests/test_capture.py
new file mode 100644
index 00000000000..e822c3e0314
--- /dev/null
+++ b/tests/test_capture.py
@@ -0,0 +1,170 @@
+# encoding: utf-8
+"""Tests for IPython.utils.capture"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2013 The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+
+import sys
+
+import pytest
+
+from IPython.utils import capture
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+
+_mime_map = dict(
+    _repr_png_="image/png",
+    _repr_jpeg_="image/jpeg",
+    _repr_svg_="image/svg+xml",
+    _repr_html_="text/html",
+    _repr_json_="application/json",
+    _repr_javascript_="application/javascript",
+)
+
+basic_data = {
+    "image/png": b"binarydata",
+    "text/html": "<b>bold</b>",
+}
+basic_metadata = {
+    "image/png": {
+        "width": 10,
+        "height": 20,
+    },
+}
+
+full_data = {
+    "image/png": b"binarydata",
+    "image/jpeg": b"binarydata",
+    "image/svg+xml": "<svg>",
+    "text/html": "<b>bold</b>",
+    "application/javascript": "alert();",
+    "application/json": "{}",
+}
+full_metadata = {
+    "image/png": {"png": "exists"},
+    "image/jpeg": {"jpeg": "exists"},
+    "image/svg+xml": {"svg": "exists"},
+    "text/html": {"html": "exists"},
+    "application/javascript": {"js": "exists"},
+    "application/json": {"json": "exists"},
+}
+
+hello_stdout = "hello, stdout"
+hello_stderr = "hello, stderr"
+
+
+# -----------------------------------------------------------------------------
+# Test Functions
+# -----------------------------------------------------------------------------
+@pytest.mark.parametrize("method_mime", _mime_map.items())
+def test_rich_output_empty(method_mime):
+    """RichOutput with no args"""
+    rich = capture.RichOutput()
+    method, mime = method_mime
+    assert getattr(rich, method)() is None
+
+
+def test_rich_output():
+    """test RichOutput basics"""
+    data = basic_data
+    metadata = basic_metadata
+    rich = capture.RichOutput(data=data, metadata=metadata)
+    assert rich._repr_html_() == data["text/html"]
+    assert rich._repr_png_() == (data["image/png"], metadata["image/png"])
+    assert rich._repr_latex_() is None
+    assert rich._repr_javascript_() is None
+    assert rich._repr_svg_() is None
+
+
+@pytest.mark.parametrize("method_mime", _mime_map.items())
+def test_rich_output_no_metadata(method_mime):
+    """test RichOutput with no metadata"""
+    data = full_data
+    rich = capture.RichOutput(data=data)
+    method, mime = method_mime
+    assert getattr(rich, method)() == data[mime]
+
+
+@pytest.mark.parametrize("method_mime", _mime_map.items())
+def test_rich_output_metadata(method_mime):
+    """test RichOutput with metadata"""
+    data = full_data
+    metadata = full_metadata
+    rich = capture.RichOutput(data=data, metadata=metadata)
+    method, mime = method_mime
+    assert getattr(rich, method)() == (data[mime], metadata[mime])
+
+
+def test_rich_output_display():
+    """test RichOutput.display
+
+    This is a bit circular, because we are actually using the capture code we are testing
+    to test itself.
+    """
+    data = full_data
+    rich = capture.RichOutput(data=data)
+    with capture.capture_output() as cap:
+        rich.display()
+    assert len(cap.outputs) == 1
+    rich2 = cap.outputs[0]
+    assert rich2.data == rich.data
+    assert rich2.metadata == rich.metadata
+
+
+def test_capture_output():
+    """capture_output works"""
+    rich = capture.RichOutput(data=full_data)
+    with capture.capture_output() as cap:
+        print(hello_stdout, end="")
+        print(hello_stderr, end="", file=sys.stderr)
+        rich.display()
+    assert hello_stdout == cap.stdout
+    assert hello_stderr == cap.stderr
+
+
+def test_capture_output_no_stdout():
+    """test capture_output(stdout=False)"""
+    rich = capture.RichOutput(data=full_data)
+    with capture.capture_output(stdout=False) as cap:
+        print(hello_stdout, end="")
+        print(hello_stderr, end="", file=sys.stderr)
+        rich.display()
+    assert "" == cap.stdout
+    assert hello_stderr == cap.stderr
+    assert len(cap.outputs) == 1
+
+
+def test_capture_output_no_stderr():
+    """test capture_output(stderr=False)"""
+    rich = capture.RichOutput(data=full_data)
+    # add nested capture_output so stderr doesn't make it to nose output
+    with capture.capture_output(), capture.capture_output(stderr=False) as cap:
+        print(hello_stdout, end="")
+        print(hello_stderr, end="", file=sys.stderr)
+        rich.display()
+    assert hello_stdout == cap.stdout
+    assert "" == cap.stderr
+    assert len(cap.outputs) == 1
+
+
+def test_capture_output_no_display():
+    """test capture_output(display=False)"""
+    rich = capture.RichOutput(data=full_data)
+    with capture.capture_output(display=False) as cap:
+        print(hello_stdout, end="")
+        print(hello_stderr, end="", file=sys.stderr)
+        rich.display()
+    assert hello_stdout == cap.stdout
+    assert hello_stderr == cap.stderr
+    assert cap.outputs == []
diff --git a/tests/test_clipboard.py b/tests/test_clipboard.py
new file mode 100644
index 00000000000..6597c946b57
--- /dev/null
+++ b/tests/test_clipboard.py
@@ -0,0 +1,20 @@
+from IPython.core.error import TryNext
+from IPython.lib.clipboard import ClipboardEmpty
+from IPython.testing.decorators import skip_if_no_x11
+
+
+@skip_if_no_x11
+def test_clipboard_get():
+    # Smoketest for clipboard access - we can't easily guarantee that the
+    # clipboard is accessible and has something on it, but this tries to
+    # exercise the relevant code anyway.
+    try:
+        a = get_ipython().hooks.clipboard_get()
+    except ClipboardEmpty:
+        # Nothing in clipboard to get
+        pass
+    except TryNext:
+        # No clipboard access API available
+        pass
+    else:
+        assert isinstance(a, str)
diff --git a/tests/test_compilerop.py b/tests/test_compilerop.py
new file mode 100644
index 00000000000..0667a1236a6
--- /dev/null
+++ b/tests/test_compilerop.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Tests for the compilerop module."""
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2010-2011 The IPython Development Team.
+#
+#  Distributed under the terms of the BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+# Stdlib imports
+import linecache
+import sys
+
+# Our own imports
+from IPython.core import compilerop
+
+# -----------------------------------------------------------------------------
+# Test functions
+# -----------------------------------------------------------------------------
+
+
+def test_code_name():
+    code = "x=1"
+    name = compilerop.code_name(code)
+    assert name.startswith("<ipython-input-0")
+
+
+def test_code_name2():
+    code = "x=1"
+    name = compilerop.code_name(code, 9)
+    assert name.startswith("<ipython-input-9")
+
+
+def test_cache():
+    """Test the compiler correctly compiles and caches inputs"""
+    cp = compilerop.CachingCompiler()
+    ncache = len(linecache.cache)
+    cp.cache("x=1")
+    assert len(linecache.cache) > ncache
+
+
+def test_proper_default_encoding():
+    # Check we're in a proper Python 2 environment (some imports, such
+    # as GTK, can change the default encoding, which can hide bugs.)
+    assert sys.getdefaultencoding() == "utf-8"
+
+
+def test_cache_unicode():
+    cp = compilerop.CachingCompiler()
+    ncache = len(linecache.cache)
+    cp.cache("t = 'žć�šđ'")
+    assert len(linecache.cache) > ncache
+
+
+def test_compiler_check_cache():
+    """Test the compiler properly manages the cache."""
+    # Rather simple-minded tests that just exercise the API
+    cp = compilerop.CachingCompiler()
+    cp.cache("x=1", 99)
+    # Ensure now that after clearing the cache, our entries survive
+    linecache.checkcache()
+    assert any(
+        k.startswith("<ipython-input-99") for k in linecache.cache
+    ), "Entry for input-99 missing from linecache"
diff --git a/tests/test_completer.py b/tests/test_completer.py
new file mode 100644
index 00000000000..391457df37d
--- /dev/null
+++ b/tests/test_completer.py
@@ -0,0 +1,2895 @@
+# encoding: utf-8
+"""Tests for the IPython tab-completion machinery."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import pytest
+import sys
+import textwrap
+import types
+import unittest
+import random
+
+from importlib.metadata import version
+
+from contextlib import contextmanager
+
+from traitlets.config.loader import Config
+from IPython import get_ipython
+from IPython.core import completer
+from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
+from IPython.utils.generics import complete_object
+from IPython.testing import decorators as dec
+from IPython.core.latex_symbols import latex_symbols
+
+from IPython.core.completer import (
+    Completion,
+    provisionalcompleter,
+    match_dict_keys,
+    _deduplicate_completions,
+    _match_number_in_dict_key_prefix,
+    completion_matcher,
+    SimpleCompletion,
+    CompletionContext,
+    _unicode_name_compute,
+    _UNICODE_RANGES,
+)
+
+from packaging.version import parse
+
+
+@contextmanager
+def jedi_status(status: bool):
+    completer = get_ipython().Completer
+    try:
+        old = completer.use_jedi
+        completer.use_jedi = status
+        yield
+    finally:
+        completer.use_jedi = old
+
+
+# -----------------------------------------------------------------------------
+# Test functions
+# -----------------------------------------------------------------------------
+
+
+def recompute_unicode_ranges():
+    """
+    utility to recompute the largest unicode range without any characters
+
+    use to recompute the gap in the global _UNICODE_RANGES of completer.py
+    """
+    import itertools
+    import unicodedata
+
+    valid = []
+    for c in range(0, 0x10FFFF + 1):
+        try:
+            unicodedata.name(chr(c))
+        except ValueError:
+            continue
+        valid.append(c)
+
+    def ranges(i):
+        for a, b in itertools.groupby(enumerate(i), lambda pair: pair[1] - pair[0]):
+            b = list(b)
+            yield b[0][1], b[-1][1]
+
+    rg = list(ranges(valid))
+    lens = []
+    gap_lens = []
+    _pstart, pstop = 0, 0
+    for start, stop in rg:
+        lens.append(stop - start)
+        gap_lens.append(
+            (
+                start - pstop,
+                hex(pstop + 1),
+                hex(start),
+                f"{round((start - pstop)/0xe01f0*100)}%",
+            )
+        )
+        _pstart, pstop = start, stop
+
+    return sorted(gap_lens)[-1]
+
+
+def test_unicode_range():
+    """
+    Test that the ranges we test for unicode names give the same number of
+    results than testing the full length.
+    """
+
+    expected_list = _unicode_name_compute([(0, 0x110000)])
+    test = _unicode_name_compute(_UNICODE_RANGES)
+    len_exp = len(expected_list)
+    len_test = len(test)
+
+    # do not inline the len() or on error pytest will try to print the 130 000 +
+    # elements.
+    message = None
+    if len_exp != len_test or len_exp > 131808:
+        size, start, stop, prct = recompute_unicode_ranges()
+        message = f"""_UNICODE_RANGES likely wrong and need updating. This is
+        likely due to a new release of Python. We've find that the biggest gap
+        in unicode characters has reduces in size to be {size} characters
+        ({prct}), from {start}, to {stop}. In completer.py likely update to
+
+            _UNICODE_RANGES = [(32, {start}), ({stop}, 0xe01f0)]
+
+        And update the assertion below to use
+
+            len_exp <= {len_exp}
+        """
+    assert len_exp == len_test, message
+
+    # fail if new unicode symbols have been added.
+    assert len_exp <= 153626, message
+
+
+@contextmanager
+def greedy_completion():
+    ip = get_ipython()
+    greedy_original = ip.Completer.greedy
+    try:
+        ip.Completer.greedy = True
+        yield
+    finally:
+        ip.Completer.greedy = greedy_original
+
+
+@contextmanager
+def evaluation_policy(evaluation: str, **overrides):
+    ip = get_ipython()
+    evaluation_original = ip.Completer.evaluation
+    overrides_original = ip.Completer.policy_overrides
+    try:
+        ip.Completer.evaluation = evaluation
+        ip.Completer.policy_overrides = overrides
+        yield
+    finally:
+        ip.Completer.evaluation = evaluation_original
+        ip.Completer.policy_overrides = overrides_original
+
+
+@contextmanager
+def custom_matchers(matchers):
+    ip = get_ipython()
+    try:
+        ip.Completer.custom_matchers.extend(matchers)
+        yield
+    finally:
+        ip.Completer.custom_matchers.clear()
+
+
+if sys.platform == "win32":
+    pairs = [
+        ("abc", "abc"),
+        (" abc", '" abc"'),
+        ("a bc", '"a bc"'),
+        ("a  bc", '"a  bc"'),
+        ("  bc", '"  bc"'),
+    ]
+else:
+    pairs = [
+        ("abc", "abc"),
+        (" abc", r"\ abc"),
+        ("a bc", r"a\ bc"),
+        ("a  bc", r"a\ \ bc"),
+        ("  bc", r"\ \ bc"),
+        # On posix, we also protect parens and other special characters.
+        ("a(bc", r"a\(bc"),
+        ("a)bc", r"a\)bc"),
+        ("a( )bc", r"a\(\ \)bc"),
+        ("a[1]bc", r"a\[1\]bc"),
+        ("a{1}bc", r"a\{1\}bc"),
+        ("a#bc", r"a\#bc"),
+        ("a?bc", r"a\?bc"),
+        ("a=bc", r"a\=bc"),
+        ("a\\bc", r"a\\bc"),
+        ("a|bc", r"a\|bc"),
+        ("a;bc", r"a\;bc"),
+        ("a:bc", r"a\:bc"),
+        ("a'bc", r"a\'bc"),
+        ("a*bc", r"a\*bc"),
+        ('a"bc', r"a\"bc"),
+        ("a^bc", r"a\^bc"),
+        ("a&bc", r"a\&bc"),
+    ]
+
+
+@pytest.mark.parametrize("s1,expected", pairs)
+def test_protect_filename(s1, expected):
+    assert completer.protect_filename(s1) == expected
+
+
+def check_line_split(splitter, test_specs):
+    for part1, part2, split in test_specs:
+        cursor_pos = len(part1)
+        line = part1 + part2
+        out = splitter.split_line(line, cursor_pos)
+        assert out == split
+
+
+def test_line_split():
+    """Basic line splitter test with default specs."""
+    sp = completer.CompletionSplitter()
+    # The format of the test specs is: part1, part2, expected answer.  Parts 1
+    # and 2 are joined into the 'line' sent to the splitter, as if the cursor
+    # was at the end of part1.  So an empty part2 represents someone hitting
+    # tab at the end of the line, the most common case.
+    t = [
+        ("run some/script", "", "some/script"),
+        ("run scripts/er", "ror.py foo", "scripts/er"),
+        ("echo $HOM", "", "HOM"),
+        ("print sys.pa", "", "sys.pa"),
+        ("print(sys.pa", "", "sys.pa"),
+        ("execfile('scripts/er", "", "scripts/er"),
+        ("a[x.", "", "x."),
+        ("a[x.", "y", "x."),
+        ('cd "some_file/', "", "some_file/"),
+    ]
+    check_line_split(sp, t)
+    # Ensure splitting works OK with unicode by re-running the tests with
+    # all inputs turned into unicode
+    check_line_split(sp, [map(str, p) for p in t])
+
+
+class NamedInstanceClass:
+    instances = {}
+
+    def __init__(self, name):
+        self.instances[name] = self
+
+    @classmethod
+    def _ipython_key_completions_(cls):
+        return cls.instances.keys()
+
+
+class KeyCompletable:
+    def __init__(self, things=()):
+        self.things = things
+
+    def _ipython_key_completions_(self):
+        return list(self.things)
+
+
+class TestCompleter(unittest.TestCase):
+    def setUp(self):
+        """
+        We want to silence all PendingDeprecationWarning when testing the completer
+        """
+        self._assertwarns = self.assertWarns(PendingDeprecationWarning)
+        self._assertwarns.__enter__()
+
+    def tearDown(self):
+        try:
+            self._assertwarns.__exit__(None, None, None)
+        except AssertionError:
+            pass
+
+    def test_custom_completion_error(self):
+        """Test that errors from custom attribute completers are silenced."""
+        ip = get_ipython()
+
+        class A:
+            pass
+
+        ip.user_ns["x"] = A()
+
+        @complete_object.register(A)
+        def complete_A(a, existing_completions):
+            raise TypeError("this should be silenced")
+
+        ip.complete("x.")
+
+    def test_custom_completion_ordering(self):
+        """Test that errors from custom attribute completers are silenced."""
+        ip = get_ipython()
+
+        _, matches = ip.complete("in")
+        assert matches.index("input") < matches.index("int")
+
+        def complete_example(a):
+            return ["example2", "example1"]
+
+        ip.Completer.custom_completers.add_re("ex*", complete_example)
+        _, matches = ip.complete("ex")
+        assert matches.index("example2") < matches.index("example1")
+
+    def test_unicode_completions(self):
+        ip = get_ipython()
+        # Some strings that trigger different types of completion.  Check them both
+        # in str and unicode forms
+        s = ["ru", "%ru", "cd /", "floa", "float(x)/"]
+        for t in s + list(map(str, s)):
+            # We don't need to check exact completion values (they may change
+            # depending on the state of the namespace, but at least no exceptions
+            # should be thrown and the return value should be a pair of text, list
+            # values.
+            text, matches = ip.complete(t)
+            self.assertIsInstance(text, str)
+            self.assertIsInstance(matches, list)
+
+    def test_latex_completions(self):
+        ip = get_ipython()
+        # Test some random unicode symbols
+        keys = random.sample(sorted(latex_symbols), 10)
+        for k in keys:
+            text, matches = ip.complete(k)
+            self.assertEqual(text, k)
+            self.assertEqual(matches, [latex_symbols[k]])
+        # Test a more complex line
+        text, matches = ip.complete("print(\\alpha")
+        self.assertEqual(text, "\\alpha")
+        self.assertEqual(matches[0], latex_symbols["\\alpha"])
+        # Test multiple matching latex symbols
+        text, matches = ip.complete("\\al")
+        self.assertIn("\\alpha", matches)
+        self.assertIn("\\aleph", matches)
+
+    def test_latex_no_results(self):
+        """
+        forward latex should really return nothing in either field if nothing is found.
+        """
+        ip = get_ipython()
+        text, matches = ip.Completer.latex_matches("\\really_i_should_match_nothing")
+        self.assertEqual(text, "")
+        self.assertEqual(matches, ())
+
+    def test_back_latex_completion(self):
+        ip = get_ipython()
+
+        # do not return more than 1 matches for \beta, only the latex one.
+        name, matches = ip.complete("\\β")
+        self.assertEqual(matches, ["\\beta"])
+
+    def test_back_unicode_completion(self):
+        ip = get_ipython()
+
+        name, matches = ip.complete("\\â…¤")
+        self.assertEqual(matches, ["\\ROMAN NUMERAL FIVE"])
+
+    def test_forward_unicode_completion(self):
+        ip = get_ipython()
+
+        name, matches = ip.complete("\\ROMAN NUMERAL FIVE")
+        self.assertEqual(matches, ["â…¤"])  # This is not a V
+        self.assertEqual(matches, ["\u2164"])  # same as above but explicit.
+
+    def test_delim_setting(self):
+        sp = completer.CompletionSplitter()
+        sp.delims = " "
+        self.assertEqual(sp.delims, " ")
+        self.assertEqual(sp._delim_expr, r"[\ ]")
+
+    def test_spaces(self):
+        """Test with only spaces as split chars."""
+        sp = completer.CompletionSplitter()
+        sp.delims = " "
+        t = [("foo", "", "foo"), ("run foo", "", "foo"), ("run foo", "bar", "foo")]
+        check_line_split(sp, t)
+
+    def test_has_open_quotes1(self):
+        for s in ["'", "'''", "'hi' '"]:
+            self.assertEqual(completer.has_open_quotes(s), "'")
+
+    def test_has_open_quotes2(self):
+        for s in ['"', '"""', '"hi" "']:
+            self.assertEqual(completer.has_open_quotes(s), '"')
+
+    def test_has_open_quotes3(self):
+        for s in ["''", "''' '''", "'hi' 'ipython'"]:
+            self.assertFalse(completer.has_open_quotes(s))
+
+    def test_has_open_quotes4(self):
+        for s in ['""', '""" """', '"hi" "ipython"']:
+            self.assertFalse(completer.has_open_quotes(s))
+
+    @pytest.mark.xfail(
+        sys.platform == "win32", reason="abspath completions fail on Windows"
+    )
+    def test_abspath_file_completions(self):
+        ip = get_ipython()
+        with TemporaryDirectory() as tmpdir:
+            prefix = os.path.join(tmpdir, "foo")
+            suffixes = ["1", "2"]
+            names = [prefix + s for s in suffixes]
+            for n in names:
+                open(n, "w", encoding="utf-8").close()
+
+            # Check simple completion
+            c = ip.complete(prefix)[1]
+            self.assertEqual(c, names)
+
+            # Now check with a function call
+            cmd = 'a = f("%s' % prefix
+            c = ip.complete(prefix, cmd)[1]
+            comp = [prefix + s for s in suffixes]
+            self.assertEqual(c, comp)
+
+    def test_local_file_completions(self):
+        ip = get_ipython()
+        with TemporaryWorkingDirectory():
+            prefix = "./foo"
+            suffixes = ["1", "2"]
+            names = [prefix + s for s in suffixes]
+            for n in names:
+                open(n, "w", encoding="utf-8").close()
+
+            # Check simple completion
+            c = ip.complete(prefix)[1]
+            self.assertEqual(c, names)
+
+            test_cases = {
+                "function call": 'a = f("',
+                "shell bang": "!ls ",
+                "ls magic": r"%ls ",
+                "alias ls": "ls ",
+            }
+            for name, code in test_cases.items():
+                cmd = f"{code}{prefix}"
+                c = ip.complete(prefix, cmd)[1]
+                comp = {prefix + s for s in suffixes}
+                self.assertTrue(comp.issubset(set(c)), msg=f"completes in {name}")
+
+    def test_quoted_file_completions(self):
+        ip = get_ipython()
+
+        def _(text):
+            return ip.Completer._complete(
+                cursor_line=0, cursor_pos=len(text), full_text=text
+            )["IPCompleter.file_matcher"]["completions"]
+
+        with TemporaryWorkingDirectory():
+            name = "foo'bar"
+            open(name, "w", encoding="utf-8").close()
+
+            # Don't escape Windows
+            escaped = name if sys.platform == "win32" else "foo\\'bar"
+
+            # Single quote matches embedded single quote
+            c = _("open('foo")[0]
+            self.assertEqual(c.text, escaped)
+
+            # Double quote requires no escape
+            c = _('open("foo')[0]
+            self.assertEqual(c.text, name)
+
+            # No quote requires an escape
+            c = _("%ls foo")[0]
+            self.assertEqual(c.text, escaped)
+
+    @pytest.mark.xfail(
+        sys.version_info.releaselevel in ("alpha",),
+        reason="Parso does not yet parse 3.13",
+    )
+    def test_all_completions_dups(self):
+        """
+        Make sure the output of `IPCompleter.all_completions` does not have
+        duplicated prefixes.
+        """
+        ip = get_ipython()
+        c = ip.Completer
+        ip.ex("class TestClass():\n\ta=1\n\ta1=2")
+        for jedi_status in [True, False]:
+            with provisionalcompleter():
+                ip.Completer.use_jedi = jedi_status
+                matches = c.all_completions("TestCl")
+                assert matches == ["TestClass"], (jedi_status, matches)
+                matches = c.all_completions("TestClass.")
+                assert len(matches) > 2, (jedi_status, matches)
+                matches = c.all_completions("TestClass.a")
+                if jedi_status:
+                    assert matches == ["TestClass.a", "TestClass.a1"], jedi_status
+                else:
+                    assert matches == [".a", ".a1"], jedi_status
+
+    @pytest.mark.xfail(
+        sys.version_info.releaselevel in ("alpha",),
+        reason="Parso does not yet parse 3.13",
+    )
+    def test_jedi(self):
+        """
+        A couple of issue we had with Jedi
+        """
+        ip = get_ipython()
+
+        def _test_complete(reason, s, comp, start=None, end=None):
+            l = len(s)
+            start = start if start is not None else l
+            end = end if end is not None else l
+            with provisionalcompleter():
+                ip.Completer.use_jedi = True
+                completions = set(ip.Completer.completions(s, l))
+                ip.Completer.use_jedi = False
+                assert Completion(start, end, comp) in completions, reason
+
+        def _test_not_complete(reason, s, comp):
+            l = len(s)
+            with provisionalcompleter():
+                ip.Completer.use_jedi = True
+                completions = set(ip.Completer.completions(s, l))
+                ip.Completer.use_jedi = False
+                assert Completion(l, l, comp) not in completions, reason
+
+        import jedi
+
+        jedi_version = tuple(int(i) for i in jedi.__version__.split(".")[:3])
+        if jedi_version > (0, 10):
+            _test_complete("jedi >0.9 should complete and not crash", "a=1;a.", "real")
+        _test_complete("can infer first argument", 'a=(1,"foo");a[0].', "real")
+        _test_complete("can infer second argument", 'a=(1,"foo");a[1].', "capitalize")
+        _test_complete("cover duplicate completions", "im", "import", 0, 2)
+
+        _test_not_complete("does not mix types", 'a=(1,"foo");a[0].', "capitalize")
+
+    @pytest.mark.xfail(
+        sys.version_info.releaselevel in ("alpha",),
+        reason="Parso does not yet parse 3.13",
+    )
+    def test_completion_have_signature(self):
+        """
+        Lets make sure jedi is capable of pulling out the signature of the function we are completing.
+        """
+        ip = get_ipython()
+        with provisionalcompleter():
+            ip.Completer.use_jedi = True
+            completions = ip.Completer.completions("ope", 3)
+            c = next(completions)  # should be `open`
+            ip.Completer.use_jedi = False
+        assert "file" in c.signature, "Signature of function was not found by completer"
+        assert (
+            "encoding" in c.signature
+        ), "Signature of function was not found by completer"
+
+    @pytest.mark.xfail(
+        sys.version_info.releaselevel in ("alpha",),
+        reason="Parso does not yet parse 3.13",
+    )
+    def test_completions_have_type(self):
+        """
+        Lets make sure matchers provide completion type.
+        """
+        ip = get_ipython()
+        with provisionalcompleter():
+            ip.Completer.use_jedi = False
+            completions = ip.Completer.completions("%tim", 3)
+            c = next(completions)  # should be `%time` or similar
+        assert c.type == "magic", "Type of magic was not assigned by completer"
+
+    @pytest.mark.xfail(
+        parse(version("jedi")) <= parse("0.18.0"),
+        reason="Known failure on jedi<=0.18.0",
+        strict=True,
+    )
+    def test_deduplicate_completions(self):
+        """
+        Test that completions are correctly deduplicated (even if ranges are not the same)
+        """
+        ip = get_ipython()
+        ip.ex(
+            textwrap.dedent(
+                """
+        class Z:
+            zoo = 1
+        """
+            )
+        )
+        with provisionalcompleter():
+            ip.Completer.use_jedi = True
+            l = list(
+                _deduplicate_completions("Z.z", ip.Completer.completions("Z.z", 3))
+            )
+            ip.Completer.use_jedi = False
+
+        assert len(l) == 1, "Completions (Z.z<tab>) correctly deduplicate: %s " % l
+        assert l[0].text == "zoo"  # and not `it.accumulate`
+
+    @pytest.mark.xfail(
+        sys.version_info.releaselevel in ("alpha",),
+        reason="Parso does not yet parse 3.13",
+    )
+    def test_greedy_completions(self):
+        """
+        Test the capability of the Greedy completer.
+
+        Most of the test here does not really show off the greedy completer, for proof
+        each of the text below now pass with Jedi. The greedy completer is capable of more.
+
+        See the :any:`test_dict_key_completion_contexts`
+
+        """
+        ip = get_ipython()
+        ip.ex("a=list(range(5))")
+        ip.ex("b,c = 1, 1.2")
+        ip.ex("d = {'a b': str}")
+        ip.ex("x=y='a'")
+        _, c = ip.complete(".", line="a[0].")
+        self.assertFalse(".real" in c, "Shouldn't have completed on a[0]: %s" % c)
+
+        def _(line, cursor_pos, expect, message, completion):
+            with greedy_completion(), provisionalcompleter():
+                ip.Completer.use_jedi = False
+                _, c = ip.complete(".", line=line, cursor_pos=cursor_pos)
+                self.assertIn(expect, c, message % c)
+
+                ip.Completer.use_jedi = True
+                with provisionalcompleter():
+                    completions = ip.Completer.completions(line, cursor_pos)
+                self.assertIn(completion, list(completions))
+
+        with provisionalcompleter():
+            _(
+                "a[0].",
+                5,
+                ".real",
+                "Should have completed on a[0].: %s",
+                Completion(5, 5, "real"),
+            )
+            _(
+                "a[0].r",
+                6,
+                ".real",
+                "Should have completed on a[0].r: %s",
+                Completion(5, 6, "real"),
+            )
+            _(
+                "a[0].from_",
+                10,
+                ".from_bytes",
+                "Should have completed on a[0].from_: %s",
+                Completion(5, 10, "from_bytes"),
+            )
+            _(
+                "assert str.star",
+                14,
+                ".startswith",
+                "Should have completed on `assert str.star`: %s",
+                Completion(11, 14, "startswith"),
+            )
+            _(
+                "d['a b'].str",
+                12,
+                ".strip",
+                "Should have completed on `d['a b'].str`: %s",
+                Completion(9, 12, "strip"),
+            )
+            _(
+                "a.app",
+                4,
+                ".append",
+                "Should have completed on `a.app`: %s",
+                Completion(2, 4, "append"),
+            )
+            _(
+                "x.upper() == y.",
+                15,
+                ".upper",
+                "Should have completed on `x.upper() == y.`: %s",
+                Completion(15, 15, "upper"),
+            )
+            _(
+                "(x.upper() == y.",
+                16,
+                ".upper",
+                "Should have completed on `(x.upper() == y.`: %s",
+                Completion(16, 16, "upper"),
+            )
+            _(
+                "(x.upper() == y).",
+                17,
+                ".bit_length",
+                "Should have completed on `(x.upper() == y).`: %s",
+                Completion(17, 17, "bit_length"),
+            )
+            _(
+                "{'==', 'abc'}.",
+                14,
+                ".add",
+                "Should have completed on `{'==', 'abc'}.`: %s",
+                Completion(14, 14, "add"),
+            )
+            _(
+                "b + c.",
+                6,
+                ".hex",
+                "Should have completed on `b + c.`: %s",
+                Completion(6, 6, "hex"),
+            )
+
+    def test_omit__names(self):
+        # also happens to test IPCompleter as a configurable
+        ip = get_ipython()
+        ip._hidden_attr = 1
+        ip._x = {}
+        c = ip.Completer
+        ip.ex("ip=get_ipython()")
+        cfg = Config()
+        cfg.IPCompleter.omit__names = 0
+        c.update_config(cfg)
+        with provisionalcompleter():
+            c.use_jedi = False
+            s, matches = c.complete("ip.")
+            self.assertIn(".__str__", matches)
+            self.assertIn("._hidden_attr", matches)
+
+            # c.use_jedi = True
+            # completions = set(c.completions('ip.', 3))
+            # self.assertIn(Completion(3, 3, '__str__'), completions)
+            # self.assertIn(Completion(3,3, "_hidden_attr"), completions)
+
+        cfg = Config()
+        cfg.IPCompleter.omit__names = 1
+        c.update_config(cfg)
+        with provisionalcompleter():
+            c.use_jedi = False
+            s, matches = c.complete("ip.")
+            self.assertNotIn(".__str__", matches)
+            # self.assertIn('ip._hidden_attr', matches)
+
+            # c.use_jedi = True
+            # completions = set(c.completions('ip.', 3))
+            # self.assertNotIn(Completion(3,3,'__str__'), completions)
+            # self.assertIn(Completion(3,3, "_hidden_attr"), completions)
+
+        cfg = Config()
+        cfg.IPCompleter.omit__names = 2
+        c.update_config(cfg)
+        with provisionalcompleter():
+            c.use_jedi = False
+            s, matches = c.complete("ip.")
+            self.assertNotIn(".__str__", matches)
+            self.assertNotIn("._hidden_attr", matches)
+
+            # c.use_jedi = True
+            # completions = set(c.completions('ip.', 3))
+            # self.assertNotIn(Completion(3,3,'__str__'), completions)
+            # self.assertNotIn(Completion(3,3, "_hidden_attr"), completions)
+
+        with provisionalcompleter():
+            c.use_jedi = False
+            s, matches = c.complete("ip._x.")
+            self.assertIn(".keys", matches)
+
+            # c.use_jedi = True
+            # completions = set(c.completions('ip._x.', 6))
+            # self.assertIn(Completion(6,6, "keys"), completions)
+
+        del ip._hidden_attr
+        del ip._x
+
+    def test_limit_to__all__False_ok(self):
+        """
+        Limit to all is deprecated, once we remove it this test can go away.
+        """
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+        ip.ex("class D: x=24")
+        ip.ex("d=D()")
+        cfg = Config()
+        cfg.IPCompleter.limit_to__all__ = False
+        c.update_config(cfg)
+        s, matches = c.complete("d.")
+        self.assertIn(".x", matches)
+
+    def test_get__all__entries_ok(self):
+        class A:
+            __all__ = ["x", 1]
+
+        words = completer.get__all__entries(A())
+        self.assertEqual(words, ["x"])
+
+    def test_get__all__entries_no__all__ok(self):
+        class A:
+            pass
+
+        words = completer.get__all__entries(A())
+        self.assertEqual(words, [])
+
+    def test_completes_globals_as_args_of_methods(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+        ip.ex("long_variable_name = 1")
+        ip.ex("a = []")
+        s, matches = c.complete(None, "a.sort(lo")
+        self.assertIn("long_variable_name", matches)
+
+    def test_completes_attributes_in_fstring_expressions(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+
+        class CustomClass:
+            def method_one(self):
+                pass
+
+        ip.user_ns["custom_obj"] = CustomClass()
+
+        # Test completion inside f-string expressions
+        s, matches = c.complete(None, "f'{custom_obj.meth")
+        self.assertIn(".method_one", matches)
+
+    def test_completes_in_dict_expressions(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+        ip.ex("class Test: pass")
+        ip.ex("test_obj = Test()")
+        ip.ex("test_obj.attribute = 'value'")
+
+        # Test completion in dictionary expressions
+        s, matches = c.complete(None, "d = {'key': test_obj.attr")
+        self.assertIn(".attribute", matches)
+
+        # Test global completion in dictionary expressions with dots
+        s, matches = c.complete(None, "d = {'k.e.y': Te")
+        self.assertIn("Test", matches)
+
+    def test_func_kw_completions(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+        ip.ex("def myfunc(a=1,b=2): return a+b")
+        s, matches = c.complete(None, "myfunc(1,b")
+        self.assertIn("b=", matches)
+        # Simulate completing with cursor right after b (pos==10):
+        s, matches = c.complete(None, "myfunc(1,b)", 10)
+        self.assertIn("b=", matches)
+        s, matches = c.complete(None, 'myfunc(a="escaped\\")string",b')
+        self.assertIn("b=", matches)
+        # builtin function
+        s, matches = c.complete(None, "min(k, k")
+        self.assertIn("key=", matches)
+
+    def test_default_arguments_from_docstring(self):
+        ip = get_ipython()
+        c = ip.Completer
+        kwd = c._default_arguments_from_docstring("min(iterable[, key=func]) -> value")
+        self.assertEqual(kwd, ["key"])
+        # with cython type etc
+        kwd = c._default_arguments_from_docstring(
+            "Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"
+        )
+        self.assertEqual(kwd, ["ncall", "resume", "nsplit"])
+        # white spaces
+        kwd = c._default_arguments_from_docstring(
+            "\n Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)\n"
+        )
+        self.assertEqual(kwd, ["ncall", "resume", "nsplit"])
+
+    def test_line_magics(self):
+        ip = get_ipython()
+        c = ip.Completer
+        s, matches = c.complete(None, "lsmag")
+        self.assertIn("%lsmagic", matches)
+        s, matches = c.complete(None, "%lsmag")
+        self.assertIn("%lsmagic", matches)
+
+    def test_cell_magics(self):
+        from IPython.core.magic import register_cell_magic
+
+        @register_cell_magic
+        def _foo_cellm(line, cell):
+            pass
+
+        ip = get_ipython()
+        c = ip.Completer
+
+        s, matches = c.complete(None, "_foo_ce")
+        self.assertIn("%%_foo_cellm", matches)
+        s, matches = c.complete(None, "%%_foo_ce")
+        self.assertIn("%%_foo_cellm", matches)
+
+    def test_line_cell_magics(self):
+        from IPython.core.magic import register_line_cell_magic
+
+        @register_line_cell_magic
+        def _bar_cellm(line, cell):
+            pass
+
+        ip = get_ipython()
+        c = ip.Completer
+
+        # The policy here is trickier, see comments in completion code.  The
+        # returned values depend on whether the user passes %% or not explicitly,
+        # and this will show a difference if the same name is both a line and cell
+        # magic.
+        s, matches = c.complete(None, "_bar_ce")
+        self.assertIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
+        s, matches = c.complete(None, "%_bar_ce")
+        self.assertIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
+        s, matches = c.complete(None, "%%_bar_ce")
+        self.assertNotIn("%_bar_cellm", matches)
+        self.assertIn("%%_bar_cellm", matches)
+
+    def test_line_magics_with_code_argument(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+
+        # attribute completion
+        text, matches = c.complete("%timeit -n 2 -r 1 float.as_integer")
+        self.assertEqual(matches, [".as_integer_ratio"])
+
+        text, matches = c.complete("%debug --breakpoint test float.as_integer")
+        self.assertEqual(matches, [".as_integer_ratio"])
+
+        text, matches = c.complete("%time --no-raise-error float.as_integer")
+        self.assertEqual(matches, [".as_integer_ratio"])
+
+        text, matches = c.complete("%prun -l 0.5 -r float.as_integer")
+        self.assertEqual(matches, [".as_integer_ratio"])
+
+        # implicit magics
+        text, matches = c.complete("timeit -n 2 -r 1 float.as_integer")
+        self.assertEqual(matches, [".as_integer_ratio"])
+
+        # built-ins completion
+        text, matches = c.complete("%timeit -n 2 -r 1 flo")
+        self.assertEqual(matches, ["float"])
+
+        # dict completion
+        text, matches = c.complete("%timeit -n 2 -r 1 {'my_key': 1}['my")
+        self.assertEqual(matches, ["my_key"])
+
+        # invalid arguments - should not throw
+        text, matches = c.complete("%timeit -n 2 -r 1 -invalid float.as_integer")
+        self.assertEqual(matches, [])
+
+        text, matches = c.complete("%debug --invalid float.as_integer")
+        self.assertEqual(matches, [])
+
+    def test_line_magics_with_code_argument_shadowing(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+
+        # shadow
+        ip.run_cell("timeit = 1")
+
+        # should not suggest on implict magic when shadowed
+        text, matches = c.complete("timeit -n 2 -r 1 flo")
+        self.assertEqual(matches, [])
+
+        # should suggest on explicit magic
+        text, matches = c.complete("%timeit -n 2 -r 1 flo")
+        self.assertEqual(matches, ["float"])
+
+        # remove shadow
+        del ip.user_ns["timeit"]
+
+        # should suggest on implicit magic after shadow removal
+        text, matches = c.complete("timeit -n 2 -r 1 flo")
+        self.assertEqual(matches, ["float"])
+
+    def test_magic_completion_order(self):
+        ip = get_ipython()
+        c = ip.Completer
+
+        # Test ordering of line and cell magics.
+        text, matches = c.complete("timeit")
+        self.assertEqual(matches, ["%timeit", "%%timeit"])
+
+    def test_magic_completion_shadowing(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = False
+
+        # Before importing matplotlib, %matplotlib magic should be the only option.
+        text, matches = c.complete("mat")
+        self.assertEqual(matches, ["%matplotlib"])
+
+        # The newly introduced name should shadow the magic.
+        ip.run_cell("matplotlib = 1")
+        text, matches = c.complete("mat")
+        self.assertEqual(matches, ["matplotlib"])
+
+        # After removing matplotlib from namespace, the magic should again be
+        # the only option.
+        del ip.user_ns["matplotlib"]
+        text, matches = c.complete("mat")
+        self.assertEqual(matches, ["%matplotlib"])
+
+    def test_magic_completion_shadowing_explicit(self):
+        """
+        If the user try to complete a shadowed magic, and explicit % start should
+        still return the completions.
+        """
+        ip = get_ipython()
+        c = ip.Completer
+
+        # Before importing matplotlib, %matplotlib magic should be the only option.
+        text, matches = c.complete("%mat")
+        self.assertEqual(matches, ["%matplotlib"])
+
+        ip.run_cell("matplotlib = 1")
+
+        # After removing matplotlib from namespace, the magic should still be
+        # the only option.
+        text, matches = c.complete("%mat")
+        self.assertEqual(matches, ["%matplotlib"])
+
+    def test_magic_config(self):
+        ip = get_ipython()
+        c = ip.Completer
+
+        s, matches = c.complete(None, "conf")
+        self.assertIn("%config", matches)
+        s, matches = c.complete(None, "conf")
+        self.assertNotIn("AliasManager", matches)
+        s, matches = c.complete(None, "config ")
+        self.assertIn("AliasManager", matches)
+        s, matches = c.complete(None, "%config ")
+        self.assertIn("AliasManager", matches)
+        s, matches = c.complete(None, "config Ali")
+        self.assertListEqual(["AliasManager"], matches)
+        s, matches = c.complete(None, "%config Ali")
+        self.assertListEqual(["AliasManager"], matches)
+        s, matches = c.complete(None, "config AliasManager")
+        self.assertListEqual(["AliasManager"], matches)
+        s, matches = c.complete(None, "%config AliasManager")
+        self.assertListEqual(["AliasManager"], matches)
+        s, matches = c.complete(None, "config AliasManager.")
+        self.assertIn("AliasManager.default_aliases", matches)
+        s, matches = c.complete(None, "%config AliasManager.")
+        self.assertIn("AliasManager.default_aliases", matches)
+        s, matches = c.complete(None, "config AliasManager.de")
+        self.assertListEqual(["AliasManager.default_aliases"], matches)
+        s, matches = c.complete(None, "config AliasManager.de")
+        self.assertListEqual(["AliasManager.default_aliases"], matches)
+
+    def test_magic_color(self):
+        ip = get_ipython()
+        c = ip.Completer
+
+        s, matches = c.complete(None, "colo")
+        assert "%colors" in matches
+        s, matches = c.complete(None, "colo")
+        assert "nocolor" not in matches
+        s, matches = c.complete(None, "%colors")  # No trailing space
+        assert "nocolor" not in matches
+        s, matches = c.complete(None, "colors ")
+        assert "nocolor" in matches
+        s, matches = c.complete(None, "%colors ")
+        assert "nocolor" in matches
+        s, matches = c.complete(None, "colors noco")
+        assert ["nocolor"] == matches
+        s, matches = c.complete(None, "%colors noco")
+        assert ["nocolor"] == matches
+
+    def test_match_dict_keys(self):
+        """
+        Test that match_dict_keys works on a couple of use case does return what
+        expected, and does not crash
+        """
+        delims = " \t\n`!@#$^&*()=+[{]}\\|;:'\",<>?"
+
+        def match(*args, **kwargs):
+            quote, offset, matches = match_dict_keys(*args, delims=delims, **kwargs)
+            return quote, offset, list(matches)
+
+        keys = ["foo", b"far"]
+        assert match(keys, "b'") == ("'", 2, ["far"])
+        assert match(keys, "b'f") == ("'", 2, ["far"])
+        assert match(keys, 'b"') == ('"', 2, ["far"])
+        assert match(keys, 'b"f') == ('"', 2, ["far"])
+
+        assert match(keys, "'") == ("'", 1, ["foo"])
+        assert match(keys, "'f") == ("'", 1, ["foo"])
+        assert match(keys, '"') == ('"', 1, ["foo"])
+        assert match(keys, '"f') == ('"', 1, ["foo"])
+
+        # Completion on first item of tuple
+        keys = [("foo", 1111), ("foo", 2222), (3333, "bar"), (3333, "test")]
+        assert match(keys, "'f") == ("'", 1, ["foo"])
+        assert match(keys, "33") == ("", 0, ["3333"])
+
+        # Completion on numbers
+        keys = [
+            0xDEADBEEF,
+            1111,
+            1234,
+            "1999",
+            0b10101,
+            22,
+        ]  # 0xDEADBEEF = 3735928559; 0b10101 = 21
+        assert match(keys, "0xdead") == ("", 0, ["0xdeadbeef"])
+        assert match(keys, "1") == ("", 0, ["1111", "1234"])
+        assert match(keys, "2") == ("", 0, ["21", "22"])
+        assert match(keys, "0b101") == ("", 0, ["0b10101", "0b10110"])
+
+        # Should yield on variables
+        assert match(keys, "a_variable") == ("", 0, [])
+
+        # Should pass over invalid literals
+        assert match(keys, "'' ''") == ("", 0, [])
+
+    def test_match_dict_keys_tuple(self):
+        """
+        Test that match_dict_keys called with extra prefix works on a couple of use case,
+        does return what expected, and does not crash.
+        """
+        delims = " \t\n`!@#$^&*()=+[{]}\\|;:'\",<>?"
+
+        keys = [("foo", "bar"), ("foo", "oof"), ("foo", b"bar"), ("other", "test")]
+
+        def match(*args, extra=None, **kwargs):
+            quote, offset, matches = match_dict_keys(
+                *args, delims=delims, extra_prefix=extra, **kwargs
+            )
+            return quote, offset, list(matches)
+
+        # Completion on first key == "foo"
+        assert match(keys, "'", extra=("foo",)) == ("'", 1, ["bar", "oof"])
+        assert match(keys, '"', extra=("foo",)) == ('"', 1, ["bar", "oof"])
+        assert match(keys, "'o", extra=("foo",)) == ("'", 1, ["oof"])
+        assert match(keys, '"o', extra=("foo",)) == ('"', 1, ["oof"])
+        assert match(keys, "b'", extra=("foo",)) == ("'", 2, ["bar"])
+        assert match(keys, 'b"', extra=("foo",)) == ('"', 2, ["bar"])
+        assert match(keys, "b'b", extra=("foo",)) == ("'", 2, ["bar"])
+        assert match(keys, 'b"b', extra=("foo",)) == ('"', 2, ["bar"])
+
+        # No Completion
+        assert match(keys, "'", extra=("no_foo",)) == ("'", 1, [])
+        assert match(keys, "'", extra=("fo",)) == ("'", 1, [])
+
+        keys = [("foo1", "foo2", "foo3", "foo4"), ("foo1", "foo2", "bar", "foo4")]
+        assert match(keys, "'foo", extra=("foo1",)) == ("'", 1, ["foo2"])
+        assert match(keys, "'foo", extra=("foo1", "foo2")) == ("'", 1, ["foo3"])
+        assert match(keys, "'foo", extra=("foo1", "foo2", "foo3")) == ("'", 1, ["foo4"])
+        assert match(keys, "'foo", extra=("foo1", "foo2", "foo3", "foo4")) == (
+            "'",
+            1,
+            [],
+        )
+
+        keys = [("foo", 1111), ("foo", "2222"), (3333, "bar"), (3333, 4444)]
+        assert match(keys, "'", extra=("foo",)) == ("'", 1, ["2222"])
+        assert match(keys, "", extra=("foo",)) == ("", 0, ["1111", "'2222'"])
+        assert match(keys, "'", extra=(3333,)) == ("'", 1, ["bar"])
+        assert match(keys, "", extra=(3333,)) == ("", 0, ["'bar'", "4444"])
+        assert match(keys, "'", extra=("3333",)) == ("'", 1, [])
+        assert match(keys, "33") == ("", 0, ["3333"])
+
+    def test_dict_key_completion_closures(self):
+        ip = get_ipython()
+        complete = ip.Completer.complete
+        ip.Completer.auto_close_dict_keys = True
+
+        ip.user_ns["d"] = {
+            # tuple only
+            ("aa", 11): None,
+            # tuple and non-tuple
+            ("bb", 22): None,
+            "bb": None,
+            # non-tuple only
+            "cc": None,
+            # numeric tuple only
+            (77, "x"): None,
+            # numeric tuple and non-tuple
+            (88, "y"): None,
+            88: None,
+            # numeric non-tuple only
+            99: None,
+        }
+
+        _, matches = complete(line_buffer="d[")
+        # should append `, ` if matches a tuple only
+        self.assertIn("'aa', ", matches)
+        # should not append anything if matches a tuple and an item
+        self.assertIn("'bb'", matches)
+        # should append `]` if matches and item only
+        self.assertIn("'cc']", matches)
+
+        # should append `, ` if matches a tuple only
+        self.assertIn("77, ", matches)
+        # should not append anything if matches a tuple and an item
+        self.assertIn("88", matches)
+        # should append `]` if matches and item only
+        self.assertIn("99]", matches)
+
+        _, matches = complete(line_buffer="d['aa', ")
+        # should restrict matches to those matching tuple prefix
+        self.assertIn("11]", matches)
+        self.assertNotIn("'bb'", matches)
+        self.assertNotIn("'bb', ", matches)
+        self.assertNotIn("'bb']", matches)
+        self.assertNotIn("'cc'", matches)
+        self.assertNotIn("'cc', ", matches)
+        self.assertNotIn("'cc']", matches)
+        ip.Completer.auto_close_dict_keys = False
+
+    def test_dict_key_completion_string(self):
+        """Test dictionary key completion for string keys"""
+        ip = get_ipython()
+        complete = ip.Completer.complete
+
+        ip.user_ns["d"] = {"abc": None}
+
+        # check completion at different stages
+        _, matches = complete(line_buffer="d[")
+        self.assertIn("'abc'", matches)
+        self.assertNotIn("'abc']", matches)
+
+        _, matches = complete(line_buffer="d['")
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc']", matches)
+
+        _, matches = complete(line_buffer="d['a")
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc']", matches)
+
+        # check use of different quoting
+        _, matches = complete(line_buffer='d["')
+        self.assertIn("abc", matches)
+        self.assertNotIn('abc"]', matches)
+
+        _, matches = complete(line_buffer='d["a')
+        self.assertIn("abc", matches)
+        self.assertNotIn('abc"]', matches)
+
+        # check sensitivity to following context
+        _, matches = complete(line_buffer="d[]", cursor_pos=2)
+        self.assertIn("'abc'", matches)
+
+        _, matches = complete(line_buffer="d['']", cursor_pos=3)
+        self.assertIn("abc", matches)
+        self.assertNotIn("abc'", matches)
+        self.assertNotIn("abc']", matches)
+
+        # check multiple solutions are correctly returned and that noise is not
+        ip.user_ns["d"] = {
+            "abc": None,
+            "abd": None,
+            "bad": None,
+            object(): None,
+            5: None,
+            ("abe", None): None,
+            (None, "abf"): None,
+        }
+
+        _, matches = complete(line_buffer="d['a")
+        self.assertIn("abc", matches)
+        self.assertIn("abd", matches)
+        self.assertNotIn("bad", matches)
+        self.assertNotIn("abe", matches)
+        self.assertNotIn("abf", matches)
+        assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
+
+        # check escaping and whitespace
+        ip.user_ns["d"] = {"a\nb": None, "a'b": None, 'a"b': None, "a word": None}
+        _, matches = complete(line_buffer="d['a")
+        self.assertIn("a\\nb", matches)
+        self.assertIn("a\\'b", matches)
+        self.assertIn('a"b', matches)
+        self.assertIn("a word", matches)
+        assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
+
+        # - can complete on non-initial word of the string
+        _, matches = complete(line_buffer="d['a w")
+        self.assertIn("word", matches)
+
+        # - understands quote escaping
+        _, matches = complete(line_buffer="d['a\\'")
+        self.assertIn("b", matches)
+
+        # - default quoting should work like repr
+        _, matches = complete(line_buffer="d[")
+        self.assertIn('"a\'b"', matches)
+
+        # - when opening quote with ", possible to match with unescaped apostrophe
+        _, matches = complete(line_buffer="d[\"a'")
+        self.assertIn("b", matches)
+
+        # need to not split at delims that readline won't split at
+        if "-" not in ip.Completer.splitter.delims:
+            ip.user_ns["d"] = {"before-after": None}
+            _, matches = complete(line_buffer="d['before-af")
+            self.assertIn("before-after", matches)
+
+        # check completion on tuple-of-string keys at different stage - on first key
+        ip.user_ns["d"] = {("foo", "bar"): None}
+        _, matches = complete(line_buffer="d[")
+        self.assertIn("'foo'", matches)
+        self.assertNotIn("'foo']", matches)
+        self.assertNotIn("'bar'", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("bar", matches)
+
+        # - match the prefix
+        _, matches = complete(line_buffer="d['f")
+        self.assertIn("foo", matches)
+        self.assertNotIn("foo']", matches)
+        self.assertNotIn('foo"]', matches)
+        _, matches = complete(line_buffer="d['foo")
+        self.assertIn("foo", matches)
+
+        # - can complete on second key
+        _, matches = complete(line_buffer="d['foo', ")
+        self.assertIn("'bar'", matches)
+        _, matches = complete(line_buffer="d['foo', 'b")
+        self.assertIn("bar", matches)
+        self.assertNotIn("foo", matches)
+
+        # - does not propose missing keys
+        _, matches = complete(line_buffer="d['foo', 'f")
+        self.assertNotIn("bar", matches)
+        self.assertNotIn("foo", matches)
+
+        # check sensitivity to following context
+        _, matches = complete(line_buffer="d['foo',]", cursor_pos=8)
+        self.assertIn("'bar'", matches)
+        self.assertNotIn("bar", matches)
+        self.assertNotIn("'foo'", matches)
+        self.assertNotIn("foo", matches)
+
+        _, matches = complete(line_buffer="d['']", cursor_pos=3)
+        self.assertIn("foo", matches)
+        assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
+
+        _, matches = complete(line_buffer='d[""]', cursor_pos=3)
+        self.assertIn("foo", matches)
+        assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
+
+        _, matches = complete(line_buffer='d["foo","]', cursor_pos=9)
+        self.assertIn("bar", matches)
+        assert not any(m.endswith(("]", '"', "'")) for m in matches), matches
+
+        _, matches = complete(line_buffer='d["foo",]', cursor_pos=8)
+        self.assertIn("'bar'", matches)
+        self.assertNotIn("bar", matches)
+
+        # Can complete with longer tuple keys
+        ip.user_ns["d"] = {("foo", "bar", "foobar"): None}
+
+        # - can complete second key
+        _, matches = complete(line_buffer="d['foo', 'b")
+        self.assertIn("bar", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("foobar", matches)
+
+        # - can complete third key
+        _, matches = complete(line_buffer="d['foo', 'bar', 'fo")
+        self.assertIn("foobar", matches)
+        self.assertNotIn("foo", matches)
+        self.assertNotIn("bar", matches)
+
+    def test_dict_key_completion_numbers(self):
+        ip = get_ipython()
+        complete = ip.Completer.complete
+
+        ip.user_ns["d"] = {
+            0xDEADBEEF: None,  # 3735928559
+            1111: None,
+            1234: None,
+            "1999": None,
+            0b10101: None,  # 21
+            22: None,
+        }
+        _, matches = complete(line_buffer="d[1")
+        self.assertIn("1111", matches)
+        self.assertIn("1234", matches)
+        self.assertNotIn("1999", matches)
+        self.assertNotIn("'1999'", matches)
+
+        _, matches = complete(line_buffer="d[0xdead")
+        self.assertIn("0xdeadbeef", matches)
+
+        _, matches = complete(line_buffer="d[2")
+        self.assertIn("21", matches)
+        self.assertIn("22", matches)
+
+        _, matches = complete(line_buffer="d[0b101")
+        self.assertIn("0b10101", matches)
+        self.assertIn("0b10110", matches)
+
+    def test_dict_key_completion_contexts(self):
+        """Test expression contexts in which dict key completion occurs"""
+        ip = get_ipython()
+        complete = ip.Completer.complete
+        d = {"abc": None}
+        ip.user_ns["d"] = d
+
+        class C:
+            data = d
+
+        ip.user_ns["C"] = C
+        ip.user_ns["get"] = lambda: d
+        ip.user_ns["nested"] = {"x": d}
+
+        def assert_no_completion(**kwargs):
+            _, matches = complete(**kwargs)
+            self.assertNotIn("abc", matches)
+            self.assertNotIn("abc'", matches)
+            self.assertNotIn("abc']", matches)
+            self.assertNotIn("'abc'", matches)
+            self.assertNotIn("'abc']", matches)
+
+        def assert_completion(**kwargs):
+            _, matches = complete(**kwargs)
+            self.assertIn("'abc'", matches)
+            self.assertNotIn("'abc']", matches)
+
+        # no completion after string closed, even if reopened
+        assert_no_completion(line_buffer="d['a'")
+        assert_no_completion(line_buffer='d["a"')
+        assert_no_completion(line_buffer="d['a' + ")
+        assert_no_completion(line_buffer="d['a' + '")
+
+        # completion in non-trivial expressions
+        assert_completion(line_buffer="+ d[")
+        assert_completion(line_buffer="(d[")
+        assert_completion(line_buffer="C.data[")
+
+        # nested dict completion
+        assert_completion(line_buffer="nested['x'][")
+
+        with evaluation_policy("minimal"):
+            with pytest.raises(AssertionError):
+                assert_completion(line_buffer="nested['x'][")
+
+        # greedy flag
+        def assert_completion(**kwargs):
+            _, matches = complete(**kwargs)
+            self.assertIn("get()['abc']", matches)
+
+        assert_no_completion(line_buffer="get()[")
+        with greedy_completion():
+            assert_completion(line_buffer="get()[")
+            assert_completion(line_buffer="get()['")
+            assert_completion(line_buffer="get()['a")
+            assert_completion(line_buffer="get()['ab")
+            assert_completion(line_buffer="get()['abc")
+
+    def test_completion_autoimport(self):
+        ip = get_ipython()
+        complete = ip.Completer.complete
+        with (
+            evaluation_policy("limited", allow_auto_import=True),
+            jedi_status(False),
+        ):
+            _, matches = complete(line_buffer="math.")
+            self.assertIn(".pi", matches)
+
+    def test_completion_no_autoimport(self):
+        ip = get_ipython()
+        complete = ip.Completer.complete
+        with (
+            evaluation_policy("limited", allow_auto_import=False),
+            jedi_status(False),
+        ):
+            _, matches = complete(line_buffer="math.")
+            self.assertNotIn(".pi", matches)
+
+    def test_completion_allow_custom_getattr_per_module(self):
+        factory_code = textwrap.dedent(
+            """
+        class ListFactory:
+            def __getattr__(self, attr):
+                return []
+        """
+        )
+
+        safe_lib = types.ModuleType("my.safe.lib")
+        sys.modules["my.safe.lib"] = safe_lib
+        exec(factory_code, safe_lib.__dict__)
+
+        unsafe_lib = types.ModuleType("my.unsafe.lib")
+        sys.modules["my.unsafe.lib"] = unsafe_lib
+        exec(factory_code, unsafe_lib.__dict__)
+
+        fake_safe_lib = types.ModuleType("my_fake_lib")
+        sys.modules["my_fake_lib"] = fake_safe_lib
+        exec(factory_code, fake_safe_lib.__dict__)
+
+        ip = get_ipython()
+        ip.user_ns["safe_list_factory"] = safe_lib.ListFactory()
+        ip.user_ns["unsafe_list_factory"] = unsafe_lib.ListFactory()
+        ip.user_ns["fake_safe_factory"] = fake_safe_lib.ListFactory()
+        complete = ip.Completer.complete
+        with (
+            evaluation_policy("limited", allowed_getattr_external={"my.safe.lib"}),
+            jedi_status(False),
+        ):
+            _, matches = complete(line_buffer="safe_list_factory.example.")
+            self.assertIn(".append", matches)
+            # this also checks against https://github.com/ipython/ipython/issues/14916
+            # because removing "un" would cause this test to incorrectly pass
+            _, matches = complete(line_buffer="unsafe_list_factory.example.")
+            self.assertNotIn(".append", matches)
+
+        sys.modules["my"] = types.ModuleType("my")
+
+        with (
+            evaluation_policy("limited", allowed_getattr_external={"my"}),
+            jedi_status(False),
+        ):
+            _, matches = complete(line_buffer="safe_list_factory.example.")
+            self.assertIn(".append", matches)
+            _, matches = complete(line_buffer="unsafe_list_factory.example.")
+            self.assertIn(".append", matches)
+            _, matches = complete(line_buffer="fake_safe_factory.example.")
+            self.assertNotIn(".append", matches)
+
+        with (
+            evaluation_policy("limited"),
+            jedi_status(False),
+        ):
+            _, matches = complete(line_buffer="safe_list_factory.example.")
+            self.assertNotIn(".append", matches)
+            _, matches = complete(line_buffer="unsafe_list_factory.example.")
+            self.assertNotIn(".append", matches)
+
+    def test_completion_allow_subclass_of_trusted_module(self):
+        factory_code = textwrap.dedent(
+            """
+            class ListFactory:
+                def __getattr__(self, attr):
+                    return []
+            """
+        )
+        trusted_lib = types.ModuleType("my.trusted.lib")
+        sys.modules["my.trusted.lib"] = trusted_lib
+        exec(factory_code, trusted_lib.__dict__)
+
+        ip = get_ipython()
+        # Create a subclass in __main__ (untrusted namespace)
+        subclass_code = textwrap.dedent(
+            """
+            class SubclassFactory(trusted_lib.ListFactory):
+                pass
+            """
+        )
+        ip.user_ns["trusted_lib"] = trusted_lib
+        exec(subclass_code, ip.user_ns)
+        ip.user_ns["subclass_factory"] = ip.user_ns["SubclassFactory"]()
+        complete = ip.Completer.complete
+        with (
+            evaluation_policy("limited", allowed_getattr_external={"my.trusted.lib"}),
+            jedi_status(False),
+        ):
+            _, matches = complete(line_buffer="subclass_factory.example.")
+            self.assertIn(".append", matches)
+
+        # Test that overriding __getattr__ in subclass in untrusted namespace prevents completion
+        overriding_subclass_code = textwrap.dedent(
+            """
+            class OverridingSubclass(trusted_lib.ListFactory):
+                def __getattr__(self, attr):
+                    return {}
+            """
+        )
+        exec(overriding_subclass_code, ip.user_ns)
+        ip.user_ns["overriding_factory"] = ip.user_ns["OverridingSubclass"]()
+
+        with (
+            evaluation_policy("limited", allowed_getattr_external={"my.trusted.lib"}),
+            jedi_status(False),
+        ):
+            _, matches = complete(line_buffer="overriding_factory.example.")
+            self.assertNotIn(".append", matches)
+            self.assertNotIn(".keys", matches)
+
+    def test_completion_fallback_to_annotation_for_attribute(self):
+        code = textwrap.dedent(
+            """
+            class StringMethods:
+                def a():
+                    pass
+
+            class Test:
+                str: StringMethods
+                def __init__(self):
+                    self.str = StringMethods()
+                def __getattr__(self, name):
+                    raise AttributeError(f"{name} not found")
+            """
+        )
+
+        repro = types.ModuleType("repro")
+        sys.modules["repro"] = repro
+        exec(code, repro.__dict__)
+
+        ip = get_ipython()
+        ip.user_ns["repro"] = repro
+        exec("r = repro.Test()", ip.user_ns)
+
+        complete = ip.Completer.complete
+        try:
+            with evaluation_policy("limited"), jedi_status(False):
+                _, matches = complete(line_buffer="r.str.")
+                self.assertIn(".a", matches)
+        finally:
+            sys.modules.pop("repro", None)
+            ip.user_ns.pop("r", None)
+
+    def test_policy_warnings(self):
+        with self.assertWarns(
+            UserWarning,
+            msg="Override 'allowed_getattr_external' is not valid with 'unsafe' evaluation policy",
+        ):
+            with evaluation_policy("unsafe", allowed_getattr_external=[]):
+                pass
+
+        with self.assertWarns(
+            UserWarning,
+            msg="Override 'test' is not valid with 'limited' evaluation policy",
+        ):
+            with evaluation_policy("limited", test=[]):
+                pass
+
+    def test_dict_key_completion_bytes(self):
+        """Test handling of bytes in dict key completion"""
+        ip = get_ipython()
+        complete = ip.Completer.complete
+
+        ip.user_ns["d"] = {"abc": None, b"abd": None}
+
+        _, matches = complete(line_buffer="d[")
+        self.assertIn("'abc'", matches)
+        self.assertIn("b'abd'", matches)
+
+        if False:  # not currently implemented
+            _, matches = complete(line_buffer="d[b")
+            self.assertIn("b'abd'", matches)
+            self.assertNotIn("b'abc'", matches)
+
+            _, matches = complete(line_buffer="d[b'")
+            self.assertIn("abd", matches)
+            self.assertNotIn("abc", matches)
+
+            _, matches = complete(line_buffer="d[B'")
+            self.assertIn("abd", matches)
+            self.assertNotIn("abc", matches)
+
+            _, matches = complete(line_buffer="d['")
+            self.assertIn("abc", matches)
+            self.assertNotIn("abd", matches)
+
+    def test_dict_key_completion_unicode_py3(self):
+        """Test handling of unicode in dict key completion"""
+        ip = get_ipython()
+        complete = ip.Completer.complete
+
+        ip.user_ns["d"] = {"a\u05d0": None}
+
+        # query using escape
+        if sys.platform != "win32":
+            # Known failure on Windows
+            _, matches = complete(line_buffer="d['a\\u05d0")
+            self.assertIn("u05d0", matches)  # tokenized after \\
+
+        # query using character
+        _, matches = complete(line_buffer="d['a\u05d0")
+        self.assertIn("a\u05d0", matches)
+
+        with greedy_completion():
+            # query using escape
+            _, matches = complete(line_buffer="d['a\\u05d0")
+            self.assertIn("d['a\\u05d0']", matches)  # tokenized after \\
+
+            # query using character
+            _, matches = complete(line_buffer="d['a\u05d0")
+            self.assertIn("d['a\u05d0']", matches)
+
+    @dec.skip_without("numpy")
+    def test_struct_array_key_completion(self):
+        """Test dict key completion applies to numpy struct arrays"""
+        import numpy
+
+        ip = get_ipython()
+        complete = ip.Completer.complete
+        ip.user_ns["d"] = numpy.array([], dtype=[("hello", "f"), ("world", "f")])
+        _, matches = complete(line_buffer="d['")
+        self.assertIn("hello", matches)
+        self.assertIn("world", matches)
+        # complete on the numpy struct itself
+        dt = numpy.dtype(
+            [("my_head", [("my_dt", ">u4"), ("my_df", ">u4")]), ("my_data", ">f4", 5)]
+        )
+        x = numpy.zeros(2, dtype=dt)
+        ip.user_ns["d"] = x[1]
+        _, matches = complete(line_buffer="d['")
+        self.assertIn("my_head", matches)
+        self.assertIn("my_data", matches)
+
+        def completes_on_nested():
+            ip.user_ns["d"] = numpy.zeros(2, dtype=dt)
+            _, matches = complete(line_buffer="d[1]['my_head']['")
+            self.assertTrue(any(["my_dt" in m for m in matches]))
+            self.assertTrue(any(["my_df" in m for m in matches]))
+
+        # complete on a nested level
+        with greedy_completion():
+            completes_on_nested()
+
+        with evaluation_policy("limited"):
+            completes_on_nested()
+
+        with evaluation_policy("minimal"):
+            with pytest.raises(AssertionError):
+                completes_on_nested()
+
+    @dec.skip_without("pandas")
+    def test_dataframe_key_completion(self):
+        """Test dict key completion applies to pandas DataFrames"""
+        import pandas
+
+        ip = get_ipython()
+        complete = ip.Completer.complete
+        ip.user_ns["d"] = pandas.DataFrame({"hello": [1], "world": [2]})
+        _, matches = complete(line_buffer="d['")
+        self.assertIn("hello", matches)
+        self.assertIn("world", matches)
+        _, matches = complete(line_buffer="d.loc[:, '")
+        self.assertIn("hello", matches)
+        self.assertIn("world", matches)
+        _, matches = complete(line_buffer="d.loc[1:, '")
+        self.assertIn("hello", matches)
+        _, matches = complete(line_buffer="d.loc[1:1, '")
+        self.assertIn("hello", matches)
+        _, matches = complete(line_buffer="d.loc[1:1:-1, '")
+        self.assertIn("hello", matches)
+        _, matches = complete(line_buffer="d.loc[::, '")
+        self.assertIn("hello", matches)
+
+    def test_dict_key_completion_invalids(self):
+        """Smoke test cases dict key completion can't handle"""
+        ip = get_ipython()
+        complete = ip.Completer.complete
+
+        ip.user_ns["no_getitem"] = None
+        ip.user_ns["no_keys"] = []
+        ip.user_ns["cant_call_keys"] = dict
+        ip.user_ns["empty"] = {}
+        ip.user_ns["d"] = {"abc": 5}
+
+        _, matches = complete(line_buffer="no_getitem['")
+        _, matches = complete(line_buffer="no_keys['")
+        _, matches = complete(line_buffer="cant_call_keys['")
+        _, matches = complete(line_buffer="empty['")
+        _, matches = complete(line_buffer="name_error['")
+        _, matches = complete(line_buffer="d['\\")  # incomplete escape
+
+    def test_object_key_completion(self):
+        ip = get_ipython()
+        ip.user_ns["key_completable"] = KeyCompletable(["qwerty", "qwick"])
+
+        _, matches = ip.Completer.complete(line_buffer="key_completable['qw")
+        self.assertIn("qwerty", matches)
+        self.assertIn("qwick", matches)
+
+    def test_class_key_completion(self):
+        ip = get_ipython()
+        NamedInstanceClass("qwerty")
+        NamedInstanceClass("qwick")
+        ip.user_ns["named_instance_class"] = NamedInstanceClass
+
+        _, matches = ip.Completer.complete(line_buffer="named_instance_class['qw")
+        self.assertIn("qwerty", matches)
+        self.assertIn("qwick", matches)
+
+    def test_tryimport(self):
+        """
+        Test that try-import don't crash on trailing dot, and import modules before
+        """
+        from IPython.core.completerlib import try_import
+
+        assert try_import("IPython.")
+
+    def test_aimport_module_completer(self):
+        ip = get_ipython()
+        _, matches = ip.complete("i", "%aimport i")
+        self.assertIn("io", matches)
+        self.assertNotIn("int", matches)
+
+    def test_nested_import_module_completer(self):
+        ip = get_ipython()
+        _, matches = ip.complete(None, "import IPython.co", 17)
+        self.assertIn("IPython.core", matches)
+        self.assertNotIn("import IPython.core", matches)
+        self.assertNotIn("IPython.display", matches)
+
+    def test_import_module_completer(self):
+        ip = get_ipython()
+        _, matches = ip.complete("i", "import i")
+        self.assertIn("io", matches)
+        self.assertNotIn("int", matches)
+
+    def test_from_module_completer(self):
+        ip = get_ipython()
+        _, matches = ip.complete("B", "from io import B", 16)
+        self.assertIn("BytesIO", matches)
+        self.assertNotIn("BaseException", matches)
+
+    def test_snake_case_completion(self):
+        ip = get_ipython()
+        ip.Completer.use_jedi = False
+        ip.user_ns["some_three"] = 3
+        ip.user_ns["some_four"] = 4
+        _, matches = ip.complete("s_", "print(s_f")
+        self.assertIn("some_three", matches)
+        self.assertIn("some_four", matches)
+
+    def test_mix_terms(self):
+        ip = get_ipython()
+        from textwrap import dedent
+
+        ip.Completer.use_jedi = False
+        ip.ex(
+            dedent(
+                """
+            class Test:
+                def meth(self, meth_arg1):
+                    print("meth")
+
+                def meth_1(self, meth1_arg1, meth1_arg2):
+                    print("meth1")
+
+                def meth_2(self, meth2_arg1, meth2_arg2):
+                    print("meth2")
+            test = Test()
+            """
+            )
+        )
+        _, matches = ip.complete(None, "test.meth(")
+        self.assertIn("meth_arg1=", matches)
+        self.assertNotIn("meth2_arg1=", matches)
+
+    def test_percent_symbol_restrict_to_magic_completions(self):
+        ip = get_ipython()
+        completer = ip.Completer
+        text = "%a"
+
+        with provisionalcompleter():
+            completer.use_jedi = True
+            completions = completer.completions(text, len(text))
+            for c in completions:
+                self.assertEqual(c.text[0], "%")
+
+    def test_fwd_unicode_restricts(self):
+        ip = get_ipython()
+        completer = ip.Completer
+        text = "\\ROMAN NUMERAL FIVE"
+
+        with provisionalcompleter():
+            completer.use_jedi = True
+            completions = [
+                completion.text for completion in completer.completions(text, len(text))
+            ]
+            self.assertEqual(completions, ["\u2164"])
+
+    def test_dict_key_restrict_to_dicts(self):
+        """Test that dict key suppresses non-dict completion items"""
+        ip = get_ipython()
+        c = ip.Completer
+        d = {"abc": None}
+        ip.user_ns["d"] = d
+
+        text = 'd["a'
+
+        def _():
+            with provisionalcompleter():
+                c.use_jedi = True
+                return [
+                    completion.text for completion in c.completions(text, len(text))
+                ]
+
+        completions = _()
+        self.assertEqual(completions, ["abc"])
+
+        # check that it can be disabled in granular manner:
+        cfg = Config()
+        cfg.IPCompleter.suppress_competing_matchers = {
+            "IPCompleter.dict_key_matcher": False
+        }
+        c.update_config(cfg)
+
+        completions = _()
+        self.assertIn("abc", completions)
+        self.assertGreater(len(completions), 1)
+
+    def test_matcher_suppression(self):
+        @completion_matcher(identifier="a_matcher")
+        def a_matcher(text):
+            return ["completion_a"]
+
+        @completion_matcher(identifier="b_matcher", api_version=2)
+        def b_matcher(context: CompletionContext):
+            text = context.token
+            result = {"completions": [SimpleCompletion("completion_b")]}
+
+            if text == "suppress c":
+                result["suppress"] = {"c_matcher"}
+
+            if text.startswith("suppress all"):
+                result["suppress"] = True
+                if text == "suppress all but c":
+                    result["do_not_suppress"] = {"c_matcher"}
+                if text == "suppress all but a":
+                    result["do_not_suppress"] = {"a_matcher"}
+
+            return result
+
+        @completion_matcher(identifier="c_matcher")
+        def c_matcher(text):
+            return ["completion_c"]
+
+        with custom_matchers([a_matcher, b_matcher, c_matcher]):
+            ip = get_ipython()
+            c = ip.Completer
+
+            def _(text, expected):
+                c.use_jedi = False
+                s, matches = c.complete(text)
+                self.assertEqual(expected, matches)
+
+            _("do not suppress", ["completion_a", "completion_b", "completion_c"])
+            _("suppress all", ["completion_b"])
+            _("suppress all but a", ["completion_a", "completion_b"])
+            _("suppress all but c", ["completion_b", "completion_c"])
+
+            def configure(suppression_config):
+                cfg = Config()
+                cfg.IPCompleter.suppress_competing_matchers = suppression_config
+                c.update_config(cfg)
+
+            # test that configuration takes priority over the run-time decisions
+
+            configure(False)
+            _("suppress all", ["completion_a", "completion_b", "completion_c"])
+
+            configure({"b_matcher": False})
+            _("suppress all", ["completion_a", "completion_b", "completion_c"])
+
+            configure({"a_matcher": False})
+            _("suppress all", ["completion_b"])
+
+            configure({"b_matcher": True})
+            _("do not suppress", ["completion_b"])
+
+            configure(True)
+            _("do not suppress", ["completion_a"])
+
+    def test_matcher_suppression_with_iterator(self):
+        @completion_matcher(identifier="matcher_returning_iterator")
+        def matcher_returning_iterator(text):
+            return iter(["completion_iter"])
+
+        @completion_matcher(identifier="matcher_returning_list")
+        def matcher_returning_list(text):
+            return ["completion_list"]
+
+        with custom_matchers([matcher_returning_iterator, matcher_returning_list]):
+            ip = get_ipython()
+            c = ip.Completer
+
+            def _(text, expected):
+                c.use_jedi = False
+                s, matches = c.complete(text)
+                self.assertEqual(expected, matches)
+
+            def configure(suppression_config):
+                cfg = Config()
+                cfg.IPCompleter.suppress_competing_matchers = suppression_config
+                c.update_config(cfg)
+
+            configure(False)
+            _("---", ["completion_iter", "completion_list"])
+
+            configure(True)
+            _("---", ["completion_iter"])
+
+            configure(None)
+            _("--", ["completion_iter", "completion_list"])
+
+    @pytest.mark.xfail(
+        sys.version_info.releaselevel in ("alpha",),
+        reason="Parso does not yet parse 3.13",
+    )
+    def test_matcher_suppression_with_jedi(self):
+        ip = get_ipython()
+        c = ip.Completer
+        c.use_jedi = True
+
+        def configure(suppression_config):
+            cfg = Config()
+            cfg.IPCompleter.suppress_competing_matchers = suppression_config
+            c.update_config(cfg)
+
+        def _():
+            with provisionalcompleter():
+                matches = [completion.text for completion in c.completions("dict.", 5)]
+                self.assertIn("keys", matches)
+
+        configure(False)
+        _()
+
+        configure(True)
+        _()
+
+        configure(None)
+        _()
+
+    def test_matcher_disabling(self):
+        @completion_matcher(identifier="a_matcher")
+        def a_matcher(text):
+            return ["completion_a"]
+
+        @completion_matcher(identifier="b_matcher")
+        def b_matcher(text):
+            return ["completion_b"]
+
+        def _(expected):
+            s, matches = c.complete("completion_")
+            self.assertEqual(expected, matches)
+
+        with custom_matchers([a_matcher, b_matcher]):
+            ip = get_ipython()
+            c = ip.Completer
+
+            _(["completion_a", "completion_b"])
+
+            cfg = Config()
+            cfg.IPCompleter.disable_matchers = ["b_matcher"]
+            c.update_config(cfg)
+
+            _(["completion_a"])
+
+            cfg.IPCompleter.disable_matchers = []
+            c.update_config(cfg)
+
+    def test_matcher_priority(self):
+        @completion_matcher(identifier="a_matcher", priority=0, api_version=2)
+        def a_matcher(text):
+            return {"completions": [SimpleCompletion("completion_a")], "suppress": True}
+
+        @completion_matcher(identifier="b_matcher", priority=2, api_version=2)
+        def b_matcher(text):
+            return {"completions": [SimpleCompletion("completion_b")], "suppress": True}
+
+        def _(expected):
+            s, matches = c.complete("completion_")
+            self.assertEqual(expected, matches)
+
+        with custom_matchers([a_matcher, b_matcher]):
+            ip = get_ipython()
+            c = ip.Completer
+
+            _(["completion_b"])
+            a_matcher.matcher_priority = 3
+            _(["completion_a"])
+
+    def test_private_attr_completions(self):
+        ip = get_ipython()
+        ip.user_ns["Test"] = type("Test", (), {"_test1": 1, "__test2": 2})
+        ip.user_ns["t"] = ip.user_ns["Test"]()
+        ip.Completer.use_jedi = False
+
+        try:
+            with provisionalcompleter():
+                completions = list(ip.Completer.completions(text="t._", offset=3))
+                completion_texts = [c.text for c in completions]
+
+                assert (
+                    "._test1" in completion_texts
+                ), f"_test1 not found in {completion_texts}"
+                assert (
+                    ".__test2" in completion_texts
+                ), f"__test2 not found in {completion_texts}"
+        finally:
+            del ip.user_ns["Test"]
+            del ip.user_ns["t"]
+
+
+@pytest.mark.parametrize(
+    "use_jedi,evaluation",
+    [
+        [True, "minimal"],
+        [False, "limited"],
+    ],
+)
+@pytest.mark.parametrize(
+    "code,insert_text",
+    [
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def my_method(self) -> str:",
+                    "        return 1",
+                    "my_instance = NotYetDefined()",
+                    "my_insta",
+                ]
+            ),
+            "my_instance",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def my_method(self) -> str:",
+                    "        return 1",
+                    "instance = NotYetDefined()",
+                    "instance.",
+                ]
+            ),
+            "my_method",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def my_method(self) -> str:",
+                    "        return 1",
+                    "my_instance = NotYetDefined()",
+                    "my_instance.my_method().",
+                ]
+            ),
+            "capitalize",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def my_method(self):",
+                    "        return []",
+                    "my_instance = NotYetDefined()",
+                    "my_instance.my_method().",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    @property",
+                    "    def my_property(self):",
+                    "        return 1.1",
+                    "my_instance = NotYetDefined()",
+                    "my_instance.my_property.",
+                ]
+            ),
+            "as_integer_ratio",
+        ],
+        [
+            "\n".join(
+                [
+                    "my_instance = 1.1",
+                    "assert my_instance.",
+                ]
+            ),
+            "as_integer_ratio",
+        ],
+        [
+            "\n".join(
+                [
+                    "def my_test() -> float:",
+                    "    pass",
+                    "my_test().",
+                ]
+            ),
+            "as_integer_ratio",
+        ],
+        [
+            "\n".join(
+                [
+                    "def my_test():",
+                    "    return {}",
+                    "my_test().",
+                ]
+            ),
+            "keys",
+        ],
+        [
+            "\n".join(
+                [
+                    "l = []",
+                    "def my_test():",
+                    "    return l",
+                    "my_test().",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "num = {1: 'one'}",
+                    "num[2] = 'two'",
+                    "num.",
+                ]
+            ),
+            "keys",
+        ],
+        [
+            "\n".join(
+                [
+                    "num = {1: 'one'}",
+                    "num[2] = ['two']",
+                    "num[2].",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "l = []",
+                    "class NotYetDefined:",
+                    "    def my_method(self):",
+                    "        return l",
+                    "my_instance = NotYetDefined()",
+                    "my_instance.my_method().",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "def string_or_int(flag):",
+                    "    if flag:",
+                    "        return 'test'",
+                    "    return 1",
+                    "string_or_int().",
+                ]
+            ),
+            ["capitalize", "as_integer_ratio"],
+        ],
+        [
+            "\n".join(
+                [
+                    "def foo():",
+                    "    l = []",
+                    "    return l",
+                    "foo().",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def __init__(self):",
+                    "        self.test = []",
+                    "instance = NotYetDefined()",
+                    "instance.",
+                ]
+            ),
+            "test",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def __init__(instance):",
+                    "        instance.test = []",
+                    "instance = NotYetDefined()",
+                    "instance.test.",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def __init__(this):",
+                    "        this.test:str = []",
+                    "instance = NotYetDefined()",
+                    "instance.test.",
+                ]
+            ),
+            "capitalize",
+        ],
+        [
+            "\n".join(
+                [
+                    "l = []",
+                    "class NotYetDefined:",
+                    "    def __init__(me):",
+                    "        me.test = l",
+                    "instance = NotYetDefined()",
+                    "instance.test.",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def test(self):",
+                    "        self.l = []",
+                    "        return self.l",
+                    "instance = NotYetDefined()",
+                    "instance.test().",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def test():",
+                    "        return []",
+                    "instance = NotYetDefined()",
+                    "instance.test().",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "def foo():",
+                    "    if some_condition:",
+                    "        return {'top':{'mid':{'leaf': 2}}}",
+                    "    return {'top': {'mid':[]}}",
+                    "foo()['top']['mid'].",
+                ]
+            ),
+            ["keys", "append"],
+        ],
+        [
+            "\n".join(
+                [
+                    "def foo():",
+                    "    if some_condition:",
+                    "        return {'top':{'mid':{'leaf': 2}}}",
+                    "    return {'top': {'mid':[]}}",
+                    "foo()['top']['mid']['leaf'].",
+                ]
+            ),
+            "as_integer_ratio",
+        ],
+        [
+            "\n".join(
+                [
+                    "async def async_func():",
+                    "    return []",
+                    "async_func().",
+                ]
+            ),
+            "cr_await",
+        ],
+        [
+            "\n".join(
+                [
+                    "async def async_func():",
+                    "    return []",
+                    "(await async_func()).",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(["t = []", "if some_condition:", "    t."]),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "if some_condition:",
+                    "    t = 'string'",
+                    "t.",
+                ]
+            ),
+            ["append", "capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "if some_condition:",
+                    "    t = 'string'",
+                    "else:",
+                    "    t.",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "if some_condition:",
+                    "    t = 'string'",
+                    "else:",
+                    "    t = 1",
+                    "t.",
+                ]
+            ),
+            ["append", "capitalize", "as_integer_ratio"],
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "if condition_1:",
+                    "    t = 'string'",
+                    "elif condition_2:",
+                    "    t = 1",
+                    "elif condition_3:",
+                    "    t.",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "if condition_1:",
+                    "    t = 'string'",
+                    "elif condition_2:",
+                    "    t = 1",
+                    "elif condition_3:",
+                    "    t = {}",
+                    "t.",
+                ]
+            ),
+            ["append", "capitalize", "as_integer_ratio", "keys"],
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "if condition_1:",
+                    "    if condition_2:",
+                    "        t = 'nested'",
+                    "t.",
+                ]
+            ),
+            ["append", "capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "a = []",
+                    "while condition:",
+                    "    a.",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "while condition:",
+                    "    t = 'str'",
+                    "t.",
+                ]
+            ),
+            ["append", "capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "t = []",
+                    "while condition_1:",
+                    "    while condition_2:",
+                    "        t = 'str'",
+                    "t.",
+                ]
+            ),
+            ["append", "capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "for i in range(10):",
+                    "    i.",
+                ]
+            ),
+            "bit_length",
+        ],
+        [
+            "\n".join(
+                [
+                    "for i in range(10):",
+                    "    if i % 2 == 0:",
+                    "        i.",
+                ]
+            ),
+            "bit_length",
+        ],
+        [
+            "\n".join(
+                [
+                    "for item in ['a', 'b', 'c']:",
+                    "    item.",
+                ]
+            ),
+            "capitalize",
+        ],
+        [
+            "\n".join(
+                [
+                    "for key, value in {'a': 1, 'b': 2}.items():",
+                    "    key.",
+                ]
+            ),
+            "capitalize",
+        ],
+        [
+            "\n".join(
+                [
+                    "for key, value in {'a': 1, 'b': 2}.items():",
+                    "    value.",
+                ]
+            ),
+            "bit_length",
+        ],
+        [
+            "\n".join(
+                [
+                    "for sublist in [[1, 2], [3, 4]]:",
+                    "    sublist.",
+                ]
+            ),
+            "append",
+        ],
+        [
+            "\n".join(
+                [
+                    "for sublist in [[1, 2], [3, 4]]:",
+                    "    for item in sublist:",
+                    "        item.",
+                ]
+            ),
+            "bit_length",
+        ],
+        [
+            "\n".join(
+                [
+                    "t: list[str]",
+                    "t[0].",
+                ]
+            ),
+            ["capitalize"],
+        ],
+    ],
+)
+def test_undefined_variables(use_jedi, evaluation, code, insert_text):
+    offset = len(code)
+    ip.Completer.use_jedi = use_jedi
+    ip.Completer.evaluation = evaluation
+
+    with provisionalcompleter():
+        completions = list(ip.Completer.completions(text=code, offset=offset))
+        insert_texts = insert_text if isinstance(insert_text, list) else [insert_text]
+        for text in insert_texts:
+            match = [c for c in completions if c.text.lstrip(".") == text]
+            message_on_fail = f"{text} not found among {[c.text for c in completions]}"
+            assert len(match) == 1, message_on_fail
+
+
+@pytest.mark.parametrize(
+    "code,insert_text",
+    [
+        [
+            "\n".join(
+                [
+                    "t: dict = {'a': []}",
+                    "t['a'].",
+                ]
+            ),
+            ["append"],
+        ],
+        [
+          "\n".join(
+                [
+                    "t: int | dict = {'a': []}",
+                    "t.",
+                ]
+            ),
+            ["keys", "bit_length"],
+        ],
+        [
+            "\n".join(
+                [
+                    "t: int | dict = {'a': []}",
+                    "t['a'].",
+                ]
+            ),
+            "append",
+        ],
+        # Test union types
+        [
+            "\n".join(
+                [
+                    "t: int | str",
+                    "t.",
+                ]
+            ),
+            ["bit_length", "capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "def func() -> int | str: pass",
+                    "func().",
+                ]
+            ),
+            ["bit_length", "capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "t: list = ['test']",
+                    "t[0].",
+                ]
+            ),
+            ["capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "class T:",
+                    "   @property",
+                    "   def p(self) -> int | str: pass",
+                    "t = T()",
+                    "t.p.",
+                ]
+            ),
+            ["bit_length", "capitalize"],
+        ],
+    ],
+)
+def test_undefined_variables_without_jedi(code, insert_text):
+    offset = len(code)
+    ip.Completer.use_jedi = False
+    ip.Completer.evaluation = "limited"
+
+    with provisionalcompleter():
+        completions = list(ip.Completer.completions(text=code, offset=offset))
+        insert_texts = insert_text if isinstance(insert_text, list) else [insert_text]
+        for text in insert_texts:
+            match = [c for c in completions if c.text.lstrip(".") == text]
+            message_on_fail = f"{text} not found among {[c.text for c in completions]}"
+            assert len(match) == 1, message_on_fail
+
+
+@pytest.mark.parametrize(
+    "code",
+    [
+        "\n".join(
+            [
+                "def my_test() -> float:",
+                "    return 1.1",
+                "my_test().",
+            ]
+        ),
+        "\n".join(
+            [
+                "class MyClass():",
+                "    b: list[str]",
+                "x = MyClass()",
+                "x.b[0].",
+            ]
+        ),
+        "\n".join(
+            [
+                "class MyClass():",
+                "    b: list[str]",
+                "x = MyClass()",
+                "x.fake_attr().",
+            ]
+        ),
+    ],
+)
+def test_no_file_completions_in_attr_access(code):
+    """Test that files are not suggested during attribute/method completion."""
+    with TemporaryWorkingDirectory():
+        open(".hidden", "w", encoding="utf-8").close()
+        offset = len(code)
+        for use_jedi in (True, False):
+            with provisionalcompleter(), jedi_status(use_jedi):
+                completions = list(ip.Completer.completions(text=code, offset=offset))
+                matches = [c for c in completions if c.text.lstrip(".") == "hidden"]
+                assert (
+                    len(matches) == 0
+                ), f"File '.hidden' should not appear in attribute completion"
+
+
+@pytest.mark.parametrize(
+    "line,expected",
+    [
+        # Basic test cases
+        ("np.", "attribute"),
+        ("np.ran", "attribute"),
+        ("np.random.rand(np.random.ran", "attribute"),
+        ("np.random.rand(n", "global"),
+        ("d['k.e.y.'](ran", "global"),
+        ("d[0].k", "attribute"),
+        ("a = { 'a': np.ran", "attribute"),
+        ("n", "global"),
+        ("", "global"),
+        # Dots in string literals
+        ('some_var = "this is a string with a dot.', "global"),
+        ("text = 'another string with a dot.", "global"),
+        ('f"greeting {user.na', "attribute"),  # Cursor in f-string expression
+        ('t"welcome {guest.na', "attribute"),  # Cursor in t-string expression
+        ('f"hello {name} worl', "global"),  # Cursor in f-string outside expression
+        ('f"hello {{a.', "global"),
+        ('f"hello {{{a.', "attribute"),
+        # Backslash escapes in strings
+        ('var = "string with \\"escaped quote and a dot.', "global"),
+        ("escaped = 'single \\'quote\\' with a dot.", "global"),
+        # Multi-line strings
+        ('multi = """This is line one\nwith a dot.', "global"),
+        ("multi_single = '''Another\nmulti-line\nwith a dot.", "global"),
+        # Inline comments
+        ("x = 5  # This is a comment", "global"),
+        ("y = obj.method()  # Comment after dot.method", "global"),
+        # Hash symbol within string literals should not be treated as comments
+        ("d['#'] = np.", "attribute"),
+        # Nested parentheses with dots
+        ("complex_expr = (func((obj.method(param.attr", "attribute"),
+        ("multiple_nesting = {key: [value.attr", "attribute"),
+        # Numbers
+        ("3.", "global"),
+        ("3.14", "global"),
+        ("-42.14", "global"),
+        ("x = func(3.14", "global"),
+        ("x = func(a3.", "attribute"),
+        ("x = func(a3.12", "global"),
+        ("3.1.", "attribute"),
+        ("-3.1.", "attribute"),
+        ("(3).", "attribute"),
+        # Additional cases
+        ("", "global"),
+        ('str_with_code = "x.attr', "global"),
+        ('f"formatted {obj.attr', "attribute"),
+        ('f"formatted {obj.attr}', "global"),
+        ("dict_with_dots = {'key.with.dots': value.attr", "attribute"),
+        ("d[f'{a}']['{a.", "global"),
+        ("ls .", "global"),
+        ("t._", "attribute"),
+        ("t.__a", "attribute"),
+    ],
+)
+def test_completion_context(line, expected):
+    """Test completion context"""
+    ip = get_ipython()
+    get_context = ip.Completer._determine_completion_context
+    result = get_context(line)
+    assert result.value == expected, f"Failed on input: '{line}'"
+
+
+@pytest.mark.parametrize(
+    "line,expected,expected_after_assignment",
+    [
+        ("test_alias file", True, False),  # overshadowed by variable
+        ("test_alias .", True, False),
+        ("test_alias file.", True, False),
+        ("%test_alias .file.ext", True, True),  # magic, not affected by variable
+        ("!test_alias file.", True, True),  # bang, not affected by variable
+    ],
+)
+def test_completion_in_cli_context(line, expected, expected_after_assignment):
+    """Test completion context with and without variable overshadowing"""
+    ip = get_ipython()
+    ip.run_cell("alias test_alias echo test_alias")
+    get_context = ip.Completer._is_completing_in_cli_context
+
+    # Normal case
+    result = get_context(line)
+    assert result == expected, f"Failed on input: '{line}'"
+
+    # Test with alias assigned as a variable
+    try:
+        ip.user_ns["test_alias"] = "some_value"
+        result_after_assignment = get_context(line)
+        assert (
+            result_after_assignment == expected_after_assignment
+        ), f"Failed after assigning 'ls' as a variable for input: '{line}'"
+    finally:
+        ip.user_ns.pop("test_alias", None)
+
+
+@pytest.mark.xfail(reason="Completion context not yet supported")
+@pytest.mark.parametrize(
+    "line, expected",
+    [
+        ("f'{f'a.", "global"),  # Nested f-string
+        ("3a.", "global"),  # names starting with numbers or other symbols
+        ("$).", "global"),  # random things with dot at end
+    ],
+)
+def test_unsupported_completion_context(line, expected):
+    """Test unsupported completion context"""
+    ip = get_ipython()
+    get_context = ip.Completer._determine_completion_context
+    result = get_context(line)
+    assert result.value == expected, f"Failed on input: '{line}'"
+
+
+@pytest.mark.parametrize(
+    "setup,code,expected,not_expected",
+    [
+        ('a="str"; b=1', "(a, b.", [".bit_count", ".conjugate"], [".count"]),
+        ('a="str"; b=1', "(a, b).", [".count"], [".bit_count", ".capitalize"]),
+        ('x="str"; y=1', "x = {1, y.", [".bit_count"], [".count"]),
+        ('x="str"; y=1', "x = [1, y.", [".bit_count"], [".count"]),
+        ('x="str"; y=1; fun=lambda x:x', "x = fun(1, y.", [".bit_count"], [".count"]),
+    ],
+)
+def test_misc_no_jedi_completions(setup, code, expected, not_expected):
+    ip = get_ipython()
+    c = ip.Completer
+    ip.ex(setup)
+    with provisionalcompleter(), jedi_status(False):
+        matches = c.all_completions(code)
+        assert set(expected) - set(matches) == set(), set(matches)
+        assert set(matches).intersection(set(not_expected)) == set()
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        (" (a, b", "b"),
+        ("(a, b", "b"),
+        ("(a, b)", ""),  # trim always start by trimming
+        (" (a, b)", "(a, b)"),
+        (" [a, b]", "[a, b]"),
+        (" a, b", "b"),
+        ("x = {1, y", "y"),
+        ("x = [1, y", "y"),
+        ("x = fun(1, y", "y"),
+        (" assert a", "a"),
+    ],
+)
+def test_trim_expr(code, expected):
+    c = get_ipython().Completer
+    assert c._trim_expr(code) == expected
+
+
+@pytest.mark.parametrize(
+    "input, expected",
+    [
+        ["1.234", "1.234"],
+        # should match signed numbers
+        ["+1", "+1"],
+        ["-1", "-1"],
+        ["-1.0", "-1.0"],
+        ["-1.", "-1."],
+        ["+1.", "+1."],
+        [".1", ".1"],
+        # should not match non-numbers
+        ["1..", None],
+        ["..", None],
+        [".1.", None],
+        # should match after comma
+        [",1", "1"],
+        [", 1", "1"],
+        [", .1", ".1"],
+        [", +.1", "+.1"],
+        # should not match after trailing spaces
+        [".1 ", None],
+        # some complex cases
+        ["0b_0011_1111_0100_1110", "0b_0011_1111_0100_1110"],
+        ["0xdeadbeef", "0xdeadbeef"],
+        ["0b_1110_0101", "0b_1110_0101"],
+        # should not match if in an operation
+        ["1 + 1", None],
+        [", 1 + 1", None],
+    ],
+)
+def test_match_numeric_literal_for_dict_key(input, expected):
+    assert _match_number_in_dict_key_prefix(input) == expected
diff --git a/tests/test_completerlib.py b/tests/test_completerlib.py
new file mode 100644
index 00000000000..8b9daf6bfa8
--- /dev/null
+++ b/tests/test_completerlib.py
@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+"""Tests for completerlib."""
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from os.path import join
+
+from tempfile import TemporaryDirectory
+
+from IPython.core.completerlib import magic_run_completer, module_completion, try_import
+from IPython.testing.decorators import onlyif_unicode_paths
+
+
+class MockEvent(object):
+    def __init__(self, line):
+        self.line = line
+
+
+# -----------------------------------------------------------------------------
+# Test functions begin
+# -----------------------------------------------------------------------------
+class Test_magic_run_completer(unittest.TestCase):
+    files = ["aao.py", "a.py", "b.py", "aao.txt"]
+    dirs = ["adir/", "bdir/"]
+
+    def setUp(self):
+        self.BASETESTDIR = tempfile.mkdtemp()
+        for fil in self.files:
+            with open(join(self.BASETESTDIR, fil), "w", encoding="utf-8") as sfile:
+                sfile.write("pass\n")
+        for d in self.dirs:
+            os.mkdir(join(self.BASETESTDIR, d))
+
+        self.oldpath = os.getcwd()
+        os.chdir(self.BASETESTDIR)
+
+    def tearDown(self):
+        os.chdir(self.oldpath)
+        shutil.rmtree(self.BASETESTDIR)
+
+    def test_1(self):
+        """Test magic_run_completer, should match two alternatives"""
+        event = MockEvent("%run a")
+        mockself = None
+        match = set(magic_run_completer(mockself, event))
+        self.assertEqual(match, {"a.py", "aao.py", "adir/"})
+
+    def test_2(self):
+        """Test magic_run_completer, should match one alternative"""
+        event = MockEvent("%run aa")
+        mockself = None
+        match = set(magic_run_completer(mockself, event))
+        self.assertEqual(match, {"aao.py"})
+
+    def test_3(self):
+        """Test magic_run_completer with unterminated " """
+        event = MockEvent('%run "a')
+        mockself = None
+        match = set(magic_run_completer(mockself, event))
+        self.assertEqual(match, {"a.py", "aao.py", "adir/"})
+
+    def test_completion_more_args(self):
+        event = MockEvent("%run a.py ")
+        match = set(magic_run_completer(None, event))
+        self.assertEqual(match, set(self.files + self.dirs))
+
+    def test_completion_in_dir(self):
+        # Github issue #3459
+        event = MockEvent("%run a.py {}".format(join(self.BASETESTDIR, "a")))
+        print(repr(event.line))
+        match = set(magic_run_completer(None, event))
+        # We specifically use replace here rather than normpath, because
+        # at one point there were duplicates 'adir' and 'adir/', and normpath
+        # would hide the failure for that.
+        self.assertEqual(
+            match,
+            {
+                join(self.BASETESTDIR, f).replace("\\", "/")
+                for f in ("a.py", "aao.py", "aao.txt", "adir/")
+            },
+        )
+
+
+class Test_magic_run_completer_nonascii(unittest.TestCase):
+    @onlyif_unicode_paths
+    def setUp(self):
+        self.BASETESTDIR = tempfile.mkdtemp()
+        for fil in ["aaø.py", "a.py", "b.py"]:
+            with open(join(self.BASETESTDIR, fil), "w", encoding="utf-8") as sfile:
+                sfile.write("pass\n")
+        self.oldpath = os.getcwd()
+        os.chdir(self.BASETESTDIR)
+
+    def tearDown(self):
+        os.chdir(self.oldpath)
+        shutil.rmtree(self.BASETESTDIR)
+
+    @onlyif_unicode_paths
+    def test_1(self):
+        """Test magic_run_completer, should match two alternatives"""
+        event = MockEvent("%run a")
+        mockself = None
+        match = set(magic_run_completer(mockself, event))
+        self.assertEqual(match, {"a.py", "aaø.py"})
+
+    @onlyif_unicode_paths
+    def test_2(self):
+        """Test magic_run_completer, should match one alternative"""
+        event = MockEvent("%run aa")
+        mockself = None
+        match = set(magic_run_completer(mockself, event))
+        self.assertEqual(match, {"aaø.py"})
+
+    @onlyif_unicode_paths
+    def test_3(self):
+        """Test magic_run_completer with unterminated " """
+        event = MockEvent('%run "a')
+        mockself = None
+        match = set(magic_run_completer(mockself, event))
+        self.assertEqual(match, {"a.py", "aaø.py"})
+
+
+# module_completer:
+
+
+def test_import_invalid_module():
+    """Testing of issue https://github.com/ipython/ipython/issues/1107"""
+    invalid_module_names = {"foo-bar", "foo:bar", "10foo"}
+    valid_module_names = {"foobar"}
+    with TemporaryDirectory() as tmpdir:
+        sys.path.insert(0, tmpdir)
+        for name in invalid_module_names | valid_module_names:
+            filename = os.path.join(tmpdir, name + ".py")
+            open(filename, "w", encoding="utf-8").close()
+
+        s = set(module_completion("import foo"))
+        intersection = s.intersection(invalid_module_names)
+        assert intersection == set()
+
+        assert valid_module_names.issubset(s), valid_module_names.intersection(s)
+
+
+def test_bad_module_all():
+    """Test module with invalid __all__
+
+    https://github.com/ipython/ipython/issues/9678
+    """
+    testsdir = os.path.dirname(__file__)
+    sys.path.insert(0, testsdir)
+    try:
+        results = module_completion("from bad_all import ")
+        assert "puppies" in results
+        for r in results:
+            assert isinstance(r, str)
+
+        # bad_all doesn't contain submodules, but this completion
+        # should finish without raising an exception:
+        results = module_completion("import bad_all.")
+        assert results == []
+    finally:
+        sys.path.remove(testsdir)
+
+
+def test_module_without_init():
+    """
+    Test module without __init__.py.
+
+    https://github.com/ipython/ipython/issues/11226
+    """
+    fake_module_name = "foo_xder_134"
+    with TemporaryDirectory() as tmpdir:
+        sys.path.insert(0, tmpdir)
+        try:
+            os.makedirs(os.path.join(tmpdir, fake_module_name))
+            s = try_import(mod=fake_module_name)
+            assert s == [], f"for module {fake_module_name}"
+        finally:
+            sys.path.remove(tmpdir)
+
+
+def test_valid_exported_submodules():
+    """
+    Test checking exported (__all__) objects are submodules
+    """
+    results = module_completion("import os.pa")
+    # ensure we get a valid submodule:
+    assert "os.path" in results
+    # ensure we don't get objects that aren't submodules:
+    assert "os.pathconf" not in results
diff --git a/tests/test_cve.py b/tests/test_cve.py
new file mode 100644
index 00000000000..fab11b4bd89
--- /dev/null
+++ b/tests/test_cve.py
@@ -0,0 +1,66 @@
+"""
+Test that CVEs stay fixed.
+"""
+
+from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
+from pathlib import Path
+import random
+import sys
+import os
+import string
+import subprocess
+
+
+def test_cve_2022_21699():
+    """
+    Here we test CVE-2022-21699.
+
+    We create a temporary directory, cd into it.
+    Make a profile file that should not be executed and start IPython in a subprocess,
+    checking for the value.
+
+
+
+    """
+
+    dangerous_profile_dir = Path("profile_default")
+
+    dangerous_startup_dir = dangerous_profile_dir / "startup"
+    dangerous_expected = "CVE-2022-21699-" + "".join(
+        [random.choice(string.ascii_letters) for i in range(10)]
+    )
+
+    with TemporaryWorkingDirectory() as t:
+        dangerous_startup_dir.mkdir(parents=True)
+        (dangerous_startup_dir / "foo.py").write_text(
+            f'print("{dangerous_expected}")', encoding="utf-8"
+        )
+        # 1 sec to make sure FS is flushed.
+        # time.sleep(1)
+        cmd = [sys.executable, "-m", "IPython"]
+        env = os.environ.copy()
+        env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+
+        # First we fake old behavior, making sure the profile is/was actually dangerous
+        p_dangerous = subprocess.Popen(
+            cmd + [f"--profile-dir={dangerous_profile_dir}"],
+            env=env,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        out_dangerous, err_dangerouns = p_dangerous.communicate(b"exit\r")
+        assert dangerous_expected in out_dangerous.decode()
+
+        # Now that we know it _would_ have been dangerous, we test it's not loaded
+        p = subprocess.Popen(
+            cmd,
+            env=env,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        out, err = p.communicate(b"exit\r")
+        assert b"IPython" in out
+        assert dangerous_expected not in out.decode()
+        assert err == b""
diff --git a/tests/test_debug_magic.py b/tests/test_debug_magic.py
new file mode 100644
index 00000000000..425ecb5b5f2
--- /dev/null
+++ b/tests/test_debug_magic.py
@@ -0,0 +1,87 @@
+"""Test embedding of IPython"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2013 The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import os
+import sys
+from IPython.testing.decorators import skip_win32
+from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+@skip_win32
+def test_debug_magic_passes_through_generators():
+    """
+    This test that we can correctly pass through frames of a generator post-mortem.
+    """
+    import pexpect
+    import re
+
+    in_prompt = re.compile(rb"In ?\[\d+\]:")
+    ipdb_prompt = "ipdb>"
+    env = os.environ.copy()
+    child = pexpect.spawn(
+        sys.executable,
+        ["-m", "IPython", "--colors=nocolor", "--simple-prompt"],
+        env=env,
+    )
+    child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+
+    child.expect(in_prompt)
+
+    child.timeout = 2 * IPYTHON_TESTING_TIMEOUT_SCALE
+
+    child.sendline("def f(x):")
+    child.sendline("    raise Exception")
+    child.sendline("")
+
+    child.expect(in_prompt)
+    child.sendline("gen = (f(x) for x in [0])")
+    child.sendline("")
+
+    child.expect(in_prompt)
+    child.sendline("for x in gen:")
+    child.sendline("    pass")
+    child.sendline("")
+
+    child.timeout = 10 * IPYTHON_TESTING_TIMEOUT_SCALE
+
+    child.expect("Exception:")
+
+    child.expect(in_prompt)
+    child.sendline(r"%debug")
+    child.expect("----> 2     raise Exception")
+
+    child.expect(ipdb_prompt)
+    child.sendline("u")
+    child.expect_exact(r"----> 1 gen = (f(x) for x in [0])")
+
+    child.expect(ipdb_prompt)
+    child.sendline("u")
+    child.expect_exact("----> 1 for x in gen:")
+
+    child.expect(ipdb_prompt)
+    child.sendline("u")
+    child.expect_exact(
+        "*** all frames above skipped (hidden frames and ignored modules). Use `skip_hidden False` for hidden frames or unignore_module for ignored modules."
+    )
+
+    child.expect(ipdb_prompt)
+    child.sendline("exit")
+
+    child.expect(in_prompt)
+    child.sendline("exit")
+
+    child.close()
diff --git a/tests/test_debugger.py b/tests/test_debugger.py
new file mode 100644
index 00000000000..acfabe76060
--- /dev/null
+++ b/tests/test_debugger.py
@@ -0,0 +1,939 @@
+"""Tests for debugging machinery."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import builtins
+import os
+import sys
+import platform
+from pathlib import Path
+
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+from textwrap import dedent
+from unittest.mock import patch
+
+from IPython.core import debugger
+from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
+from IPython.testing.decorators import skip_win32
+import pytest
+
+# -----------------------------------------------------------------------------
+# Helper classes, from CPython's Pdb test suite
+# -----------------------------------------------------------------------------
+
+
+class _FakeInput(object):
+    """
+    A fake input stream for pdb's interactive debugger.  Whenever a
+    line is read, print it (to simulate the user typing it), and then
+    return it.  The set of lines to return is specified in the
+    constructor; they should not have trailing newlines.
+    """
+
+    def __init__(self, lines):
+        self.lines = iter(lines)
+
+    def readline(self):
+        line = next(self.lines)
+        print(line)
+        return line + "\n"
+
+
+class PdbTestInput(object):
+    """Context manager that makes testing Pdb in doctests easier."""
+
+    def __init__(self, input):
+        self.input = input
+
+    def __enter__(self):
+        self.real_stdin = sys.stdin
+        sys.stdin = _FakeInput(self.input)
+
+    def __exit__(self, *exc):
+        sys.stdin = self.real_stdin
+
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+def test_ipdb_magics():
+    '''Test calling some IPython magics from ipdb.
+
+    First, set up some test functions and classes which we can inspect.
+
+    In [1]: class ExampleClass(object):
+       ...:    """Docstring for ExampleClass."""
+       ...:    def __init__(self):
+       ...:        """Docstring for ExampleClass.__init__"""
+       ...:        pass
+       ...:    def __str__(self):
+       ...:        return "ExampleClass()"
+
+    In [2]: def example_function(x, y, z="hello"):
+       ...:     """Docstring for example_function."""
+       ...:     pass
+
+    In [3]: old_trace = sys.gettrace()
+
+    Create a function which triggers ipdb.
+
+    In [4]: def trigger_ipdb():
+       ...:    a = ExampleClass()
+       ...:    debugger.Pdb().set_trace()
+
+    Run ipdb with faked input & check output. Because of a difference between
+    Python 3.13 & older versions, the first bit of the output is inconsistent.
+    We need to use ... to accommodate that, so the examples have to use IPython
+    prompts so that ... is distinct from the Python PS2 prompt.
+
+    In [5]: with PdbTestInput([
+       ...:    'pdef example_function',
+       ...:    'pdoc ExampleClass',
+       ...:    'up',
+       ...:    'down',
+       ...:    'list',
+       ...:    'pinfo a',
+       ...:    'll',
+       ...:    'continue',
+       ...: ]):
+       ...:     trigger_ipdb()
+    ...> <doctest ...>(3)trigger_ipdb()
+          1 def trigger_ipdb():
+          2    a = ExampleClass()
+    ----> 3    debugger.Pdb().set_trace()
+    <BLANKLINE>
+    ipdb> pdef example_function
+     example_function(x, y, z='hello')
+     ipdb> pdoc ExampleClass
+    Class docstring:
+        Docstring for ExampleClass.
+    Init docstring:
+        Docstring for ExampleClass.__init__
+    ipdb> up
+    > <doctest ...>(11)<module>()
+          7    'pinfo a',
+          8    'll',
+          9    'continue',
+         10 ]):
+    ---> 11     trigger_ipdb()
+    <BLANKLINE>
+    ipdb> down...
+    > <doctest ...>(3)trigger_ipdb()
+          1 def trigger_ipdb():
+          2    a = ExampleClass()
+    ----> 3    debugger.Pdb().set_trace()
+    <BLANKLINE>
+    ipdb> list
+          1 def trigger_ipdb():
+          2    a = ExampleClass()
+    ----> 3    debugger.Pdb().set_trace()
+    <BLANKLINE>
+    ipdb> pinfo a
+    Type:           ExampleClass
+    String form:    ExampleClass()
+    Namespace:      Local...
+    Docstring:      Docstring for ExampleClass.
+    Init docstring: Docstring for ExampleClass.__init__
+    ipdb> ll
+          1 def trigger_ipdb():
+          2    a = ExampleClass()
+    ----> 3    debugger.Pdb().set_trace()
+    <BLANKLINE>
+    ipdb> continue
+
+    Restore previous trace function, e.g. for coverage.py
+
+    In [6]: sys.settrace(old_trace)
+    '''
+
+
+def test_ipdb_closure():
+    """Test evaluation of expressions which depend on closure.
+
+    In [1]: old_trace = sys.gettrace()
+
+    Create a function which triggers ipdb.
+
+    In [2]: def trigger_ipdb():
+       ...:    debugger.Pdb().set_trace()
+
+    In [3]: with PdbTestInput([
+       ...:    'x = 1; sum(x * i for i in range(5))',
+       ...:    'continue',
+       ...: ]):
+       ...:     trigger_ipdb()
+    ...> <doctest ...>(2)trigger_ipdb()
+          1 def trigger_ipdb():
+    ----> 2    debugger.Pdb().set_trace()
+    <BLANKLINE>
+    ipdb> x = 1; sum(x * i for i in range(5))
+    ipdb> continue
+
+    Restore previous trace function, e.g. for coverage.py
+
+    In [4]: sys.settrace(old_trace)
+    """
+
+
+def test_ipdb_magics2():
+    """Test ipdb with a very short function.
+
+    >>> old_trace = sys.gettrace()
+
+    >>> def bar():
+    ...     pass
+
+    Run ipdb.
+
+    >>> with PdbTestInput([
+    ...    'continue',
+    ... ]):
+    ...     debugger.Pdb().runcall(bar)
+    > <doctest ...>(2)bar()
+          1 def bar():
+    ----> 2    pass
+    <BLANKLINE>
+    ipdb> continue
+
+    Restore previous trace function, e.g. for coverage.py
+
+    >>> sys.settrace(old_trace)
+    """
+
+
+def can_quit():
+    """Test that quit work in ipydb
+
+    >>> old_trace = sys.gettrace()
+
+    >>> def bar():
+    ...     pass
+
+    >>> with PdbTestInput([
+    ...    'quit',
+    ... ]):
+    ...     debugger.Pdb().runcall(bar)
+    > <doctest ...>(2)bar()
+            1 def bar():
+    ----> 2    pass
+    <BLANKLINE>
+    ipdb> quit
+
+    Restore previous trace function, e.g. for coverage.py
+
+    >>> sys.settrace(old_trace)
+    """
+
+
+def can_exit():
+    """Test that quit work in ipydb
+
+    >>> old_trace = sys.gettrace()
+
+    >>> def bar():
+    ...     pass
+
+    >>> with PdbTestInput([
+    ...    'exit',
+    ... ]):
+    ...     debugger.Pdb().runcall(bar)
+    > <doctest ...>(2)bar()
+            1 def bar():
+    ----> 2    pass
+    <BLANKLINE>
+    ipdb> exit
+
+    Restore previous trace function, e.g. for coverage.py
+
+    >>> sys.settrace(old_trace)
+    """
+
+
+def test_interruptible_core_debugger():
+    """The debugger can be interrupted.
+
+    The presumption is there is some mechanism that causes a KeyboardInterrupt
+    (this is implemented in ipykernel).  We want to ensure the
+    KeyboardInterrupt cause debugging to cease.
+    """
+
+    def raising_input(msg="", called=[0]):
+        called[0] += 1
+        assert called[0] == 1, "input() should only be called once!"
+        raise KeyboardInterrupt()
+
+    tracer_orig = sys.gettrace()
+    try:
+        with patch.object(builtins, "input", raising_input):
+            debugger.InterruptiblePdb().set_trace()
+            # The way this test will fail is by set_trace() never exiting,
+            # resulting in a timeout by the test runner. The alternative
+            # implementation would involve a subprocess, but that adds issues
+            # with interrupting subprocesses that are rather complex, so it's
+            # simpler just to do it this way.
+    finally:
+        # restore the original trace function
+        sys.settrace(tracer_orig)
+
+
+@skip_win32
+def test_xmode_skip():
+    """that xmode skip frames
+
+    Not as a doctest as pytest does not run doctests.
+    """
+    import pexpect
+
+    env = os.environ.copy()
+    env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+
+    child = pexpect.spawn(
+        sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
+    )
+    child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+
+    child.expect("IPython")
+    child.expect("\n")
+    child.expect_exact("In [1]")
+
+    block = dedent(
+        """
+    def f():
+        __tracebackhide__ = True
+        g()
+
+    def g():
+        raise ValueError
+
+    f()
+    """
+    )
+
+    for line in block.splitlines():
+        child.sendline(line)
+        child.expect_exact(line)
+    child.expect_exact("skipping")
+
+    block = dedent(
+        """
+    def f():
+        __tracebackhide__ = True
+        g()
+
+    def g():
+        from IPython.core.debugger import set_trace
+        set_trace()
+
+    f()
+    """
+    )
+
+    for line in block.splitlines():
+        child.sendline(line)
+        child.expect_exact(line)
+
+    child.expect("ipdb>")
+    child.sendline("w")
+    child.expect("hidden")
+    child.expect("ipdb>")
+    child.sendline("skip_hidden false")
+    child.sendline("w")
+    child.expect("__traceba")
+    child.expect("ipdb>")
+
+    child.close()
+
+
+skip_decorators_blocks = (
+    """
+    def helpers_helper():
+        pass # should not stop here except breakpoint
+    """,
+    """
+    def helper_1():
+        helpers_helper() # should not stop here
+    """,
+    """
+    def helper_2():
+        pass # should not stop here
+    """,
+    """
+    def pdb_skipped_decorator2(function):
+        def wrapped_fn(*args, **kwargs):
+            __debuggerskip__ = True
+            helper_2()
+            __debuggerskip__ = False
+            result = function(*args, **kwargs)
+            __debuggerskip__ = True
+            helper_2()
+            return result
+        return wrapped_fn
+    """,
+    """
+    def pdb_skipped_decorator(function):
+        def wrapped_fn(*args, **kwargs):
+            __debuggerskip__ = True
+            helper_1()
+            __debuggerskip__ = False
+            result = function(*args, **kwargs)
+            __debuggerskip__ = True
+            helper_2()
+            return result
+        return wrapped_fn
+    """,
+    """
+    @pdb_skipped_decorator
+    @pdb_skipped_decorator2
+    def bar(x, y):
+        return x * y
+    """,
+    """import IPython.terminal.debugger as ipdb""",
+    """
+    def f():
+        ipdb.set_trace()
+        bar(3, 4)
+    """,
+    """
+    f()
+    """,
+)
+
+
+def _decorator_skip_setup():
+    import pexpect
+
+    env = os.environ.copy()
+    env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+    env["PROMPT_TOOLKIT_NO_CPR"] = "1"
+
+    child = pexpect.spawn(
+        sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
+    )
+    child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+
+    child.expect("IPython")
+    child.expect("\n")
+
+    child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
+    child.str_last_chars = 500
+
+    dedented_blocks = [dedent(b).strip() for b in skip_decorators_blocks]
+    in_prompt_number = 1
+    for cblock in dedented_blocks:
+        child.expect_exact(f"In [{in_prompt_number}]:")
+        in_prompt_number += 1
+        for line in cblock.splitlines():
+            child.sendline(line)
+            child.expect_exact(line)
+        child.sendline("")
+    return child
+
+
+@pytest.mark.skip(reason="recently fail for unknown reason on CI")
+@skip_win32
+def test_decorator_skip():
+    """test that decorator frames can be skipped."""
+
+    child = _decorator_skip_setup()
+
+    child.expect_exact("ipython-input-8")
+    child.expect_exact("3     bar(3, 4)")
+    child.expect("ipdb>")
+
+    child.expect("ipdb>")
+    child.sendline("step")
+    child.expect_exact("step")
+    child.expect_exact("--Call--")
+    child.expect_exact("ipython-input-6")
+
+    child.expect_exact("1 @pdb_skipped_decorator")
+
+    child.sendline("s")
+    child.expect_exact("return x * y")
+
+    child.close()
+
+
+@pytest.mark.skip(reason="recently fail for unknown reason on CI")
+@pytest.mark.skipif(platform.python_implementation() == "PyPy", reason="issues on PyPy")
+@skip_win32
+def test_decorator_skip_disabled():
+    """test that decorator frame skipping can be disabled"""
+
+    child = _decorator_skip_setup()
+
+    child.expect_exact("3     bar(3, 4)")
+
+    for input_, expected in [
+        ("skip_predicates debuggerskip False", ""),
+        ("skip_predicates", "debuggerskip : False"),
+        ("step", "---> 2     def wrapped_fn"),
+        ("step", "----> 3         __debuggerskip__"),
+        ("step", "----> 4         helper_1()"),
+        ("step", "---> 1 def helper_1():"),
+        ("next", "----> 2     helpers_helper()"),
+        ("next", "--Return--"),
+        ("next", "----> 5         __debuggerskip__ = False"),
+    ]:
+        child.expect("ipdb>")
+        child.sendline(input_)
+        child.expect_exact(input_)
+        child.expect_exact(expected)
+
+    child.close()
+
+
+@pytest.mark.skip(reason="recently fail for unknown reason on CI")
+@pytest.mark.skipif(platform.python_implementation() == "PyPy", reason="issues on PyPy")
+@skip_win32
+def test_decorator_skip_with_breakpoint():
+    """test that decorator frame skipping can be disabled"""
+
+    import pexpect
+
+    env = os.environ.copy()
+    env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+    env["PROMPT_TOOLKIT_NO_CPR"] = "1"
+
+    child = pexpect.spawn(
+        sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
+    )
+    child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+    child.str_last_chars = 500
+
+    child.expect("IPython")
+    child.expect("\n")
+
+    child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
+
+    ### we need a filename, so we need to exec the full block with a filename
+    with NamedTemporaryFile(suffix=".py", dir=".", delete=True) as tf:
+        name = tf.name[:-3].split("/")[-1]
+        tf.write("\n".join([dedent(x) for x in skip_decorators_blocks[:-1]]).encode())
+        tf.flush()
+        codeblock = f"from {name} import f"
+
+        dedented_blocks = [
+            codeblock,
+            "f()",
+        ]
+
+        in_prompt_number = 1
+        for cblock in dedented_blocks:
+            child.expect_exact(f"In [{in_prompt_number}]:")
+            in_prompt_number += 1
+            for line in cblock.splitlines():
+                child.sendline(line)
+                child.expect_exact(line)
+            child.sendline("")
+
+        # From 3.13, set_trace()/breakpoint() stop on the line where they're
+        # called, instead of the next line.
+        if sys.version_info >= (3, 14):
+            child.expect_exact("     46     ipdb.set_trace()")
+            extra_step = [("step", "--> 47     bar(3, 4)")]
+        elif sys.version_info >= (3, 13):
+            child.expect_exact("--> 46     ipdb.set_trace()")
+            extra_step = [("step", "--> 47     bar(3, 4)")]
+        else:
+            child.expect_exact("--> 47     bar(3, 4)")
+            extra_step = []
+
+        for input_, expected in (
+            [
+                (f"b {name}.py:3", ""),
+            ]
+            + extra_step
+            + [
+                ("step", "1---> 3     pass # should not stop here except"),
+                ("step", "---> 38 @pdb_skipped_decorator"),
+                ("continue", ""),
+            ]
+        ):
+            child.expect("ipdb>")
+            child.sendline(input_)
+            child.expect_exact(input_)
+            child.expect_exact(expected)
+
+    child.close()
+
+
+@skip_win32
+def test_where_erase_value():
+    """Test that `where` does not access f_locals and erase values."""
+    import pexpect
+
+    env = os.environ.copy()
+    env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+
+    child = pexpect.spawn(
+        sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
+    )
+    child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+
+    child.expect("IPython")
+    child.expect("\n")
+    child.expect_exact("In [1]")
+
+    block = dedent(
+        """
+    def simple_f():
+         myvar = 1
+         print(myvar)
+         1/0
+         print(myvar)
+    simple_f()    """
+    )
+
+    for line in block.splitlines():
+        child.sendline(line)
+        child.expect_exact(line)
+    child.expect_exact("ZeroDivisionError")
+    child.expect_exact("In [2]:")
+
+    child.sendline("%debug")
+
+    ##
+    child.expect("ipdb>")
+
+    child.sendline("myvar")
+    child.expect("1")
+
+    ##
+    child.expect("ipdb>")
+
+    child.sendline("myvar = 2")
+
+    ##
+    child.expect_exact("ipdb>")
+
+    child.sendline("myvar")
+
+    child.expect_exact("2")
+
+    ##
+    child.expect("ipdb>")
+    child.sendline("where")
+
+    ##
+    child.expect("ipdb>")
+    child.sendline("myvar")
+
+    child.expect_exact("2")
+    child.expect("ipdb>")
+
+    child.close()
+
+
+@skip_win32
+def test_ignore_module_basic_functionality():
+    """Test basic ignore/unignore functionality and error handling."""
+    import pexpect
+
+    env = os.environ.copy()
+    env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+
+    with TemporaryDirectory() as temp_dir:
+        main_path = create_test_modules(temp_dir)
+
+        child = pexpect.spawn(sys.executable, [main_path], env=env, cwd=temp_dir)
+        child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+        child.expect("ipdb>")
+
+        # Test listing modules when none are ignored
+        child.sendline("ignore_module")
+        child.expect_exact("No modules are currently ignored.")
+        child.expect("ipdb>")
+
+        # Test ignoring a module
+        child.sendline("ignore_module level2_module")
+        child.expect("ipdb>")
+
+        # Test listing ignored modules
+        child.sendline("ignore_module")
+        child.expect_exact("Currently ignored modules: ['level2_module']")
+        child.expect("ipdb>")
+
+        # Test wildcard pattern
+        child.sendline("ignore_module testpkg.*")
+        child.expect("ipdb>")
+
+        child.sendline("ignore_module")
+        child.expect_exact("Currently ignored modules: ['level2_module', 'testpkg.*']")
+        child.expect("ipdb>")
+
+        # Test error handling - removing non-existent module
+        child.sendline("unignore_module nonexistent")
+        child.expect_exact("Module nonexistent is not currently ignored")
+        child.expect("ipdb>")
+
+        # Test successful removal
+        child.sendline("unignore_module level2_module")
+        child.expect("ipdb>")
+
+        child.sendline("ignore_module")
+        child.expect_exact("Currently ignored modules: ['testpkg.*']")
+        child.expect("ipdb>")
+
+        # Test removing already removed module
+        child.sendline("unignore_module level2_module")
+        child.expect_exact("Module level2_module is not currently ignored")
+        child.expect("ipdb>")
+
+        # Remove wildcard pattern
+        child.sendline("unignore_module testpkg.*")
+        child.expect("ipdb>")
+
+        child.sendline("ignore_module")
+        child.expect_exact("No modules are currently ignored.")
+        child.expect("ipdb>")
+
+        child.sendline("continue")
+        child.close()
+
+
+# Helper function for creating temporary modules
+def create_test_modules(temp_dir):
+    """Create a comprehensive module hierarchy for testing all debugger commands."""
+
+    temp_path = Path(temp_dir)
+
+    # Create package structure for wildcard testing
+    package_dir = temp_path / "testpkg"
+    package_dir.mkdir()
+
+    # Package __init__.py
+    (package_dir / "__init__.py").write_text("# Test package")
+
+    # testpkg/submod1.py
+    (package_dir / "submod1.py").write_text(
+        dedent(
+            """
+        def submod1_func():
+            x = 1
+            y = 2
+            return x + y
+        """
+        )
+    )
+
+    # testpkg/submod2.py
+    (package_dir / "submod2.py").write_text(
+        dedent(
+            """
+        def submod2_func():
+            z = 10
+            return z * 2
+        """
+        )
+    )
+
+    # Level 1 (top level module)
+    (temp_path / "level1_module.py").write_text(
+        dedent(
+            """
+        from level2_module import level2_func
+
+        def level1_func():
+            return level2_func()
+        """
+        )
+    )
+
+    # Level 2 (middle level module)
+    (temp_path / "level2_module.py").write_text(
+        dedent(
+            """
+        from level3_module import level3_func
+        from testpkg.submod1 import submod1_func
+        from testpkg.submod2 import submod2_func
+
+        def level2_func():
+            # Call package functions for step/next testing
+            result1 = submod1_func()
+            result2 = submod2_func()
+            return level3_func() + result1 + result2
+        """
+        )
+    )
+
+    # Level 3 (bottom level with debugger)
+    (temp_path / "level3_module.py").write_text(
+        dedent(
+            """
+        from level4_module import level4_func
+
+        from IPython.core.debugger import set_trace
+
+        def level3_func():
+            set_trace()
+            pass
+            result = level4_func()
+            return result
+        """
+        )
+    )
+
+    # Level 4 (bottom level with debugger)
+    (temp_path / "level4_module.py").write_text(
+        dedent(
+            """
+        def level4_func():
+            a = 70
+            b = 30
+            return a + b
+        """
+        )
+    )
+
+    # Main runner
+    main_path = temp_path / "main_runner.py"
+    main_path.write_text(
+        dedent(
+            """
+        import sys
+        sys.path.insert(0, '.')
+        from level1_module import level1_func
+
+        if __name__ == "__main__":
+            result = level1_func()
+            print(f"Final result: {result}")
+        """
+        )
+    )
+
+    return str(main_path)
+
+
+@skip_win32
+def test_ignore_module_all_commands():
+    """Comprehensive test for all debugger commands (up/down/step/next) with ignore functionality."""
+    import pexpect
+
+    env = os.environ.copy()
+    env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+
+    with TemporaryDirectory() as temp_dir:
+        main_path = create_test_modules(temp_dir)
+
+        # Test UP and DOWN commands
+        child = pexpect.spawn(sys.executable, [main_path], env=env, cwd=temp_dir)
+        child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+        child.expect("ipdb>")
+
+        # Test up without ignores (baseline)
+        child.sendline("up")
+        child.expect("ipdb>")
+        child.sendline("__name__")
+        child.expect_exact("level2_module")
+        child.expect("ipdb>")
+
+        # Reset position
+        child.sendline("down")
+        child.expect("ipdb>")
+
+        # Test up with single module ignore
+        child.sendline("ignore_module level2_module")
+        child.expect("ipdb>")
+        child.sendline("up")
+        child.expect_exact(
+            "[... skipped 1 frame(s): 0 hidden frames + 1 ignored modules]"
+        )
+        child.expect("ipdb>")
+        child.sendline("__name__")
+        child.expect_exact("level1_module")
+        child.expect("ipdb>")
+
+        # Test up with wildcard ignore
+        child.sendline("down")
+        child.expect_exact(
+            "[... skipped 1 frame(s): 0 hidden frames + 1 ignored modules]"
+        )
+        child.expect("ipdb>")
+        child.sendline("unignore_module level2_module")
+        child.expect("ipdb>")
+        child.sendline("ignore_module level*")
+        child.expect("ipdb>")
+        child.sendline("up")
+        child.expect_exact(
+            "[... skipped 2 frame(s): 0 hidden frames + 2 ignored modules]"
+        )
+        child.expect("ipdb>")
+        child.sendline("__name__")
+        child.expect_exact("__main__")
+        child.expect("ipdb>")
+
+        child.sendline("continue")
+        child.close()
+
+        # Test STEP command
+        child = pexpect.spawn(sys.executable, [main_path], env=env, cwd=temp_dir)
+        child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+        child.expect("ipdb>")
+
+        # Test step without ignores (should step into module)
+        child.sendline("until 9")
+        child.expect("ipdb>")
+        child.sendline("step")
+        child.expect("ipdb>")
+        child.sendline("__name__")
+        child.expect_exact("level4_module")
+        child.expect("ipdb>")
+
+        child.sendline("continue")
+        child.close()
+
+        # Test step with single module ignore
+        child = pexpect.spawn(sys.executable, [main_path], env=env, cwd=temp_dir)
+        child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+        child.expect("ipdb>")
+
+        child.sendline("ignore_module level4_module")
+        child.expect("ipdb>")
+        child.sendline("until 9")
+        child.expect("ipdb>")
+        child.sendline("step")
+        child.expect_exact("[... skipped 1 ignored module(s)]")
+        child.expect("ipdb>")
+        child.sendline("__name__")
+        child.expect_exact("level3_module")
+        child.expect("ipdb>")
+
+        child.sendline("continue")
+        child.close()
+
+        # Test NEXT command
+        child = pexpect.spawn(sys.executable, [main_path], env=env, cwd=temp_dir)
+        child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+        child.expect("ipdb>")
+
+        # Test next without ignores
+        child.sendline("until 9")
+        child.expect("ipdb>")
+        child.sendline("next")
+        child.expect("ipdb>")
+        child.sendline("__name__")
+        child.expect_exact("level3_module")
+        child.expect("ipdb>")
+
+        child.sendline("continue")
+        child.close()
+
+        # Test next with module ignore
+        child = pexpect.spawn(sys.executable, [main_path], env=env, cwd=temp_dir)
+        child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+        child.expect("ipdb>")
+
+        child.sendline("ignore_module level2_module")
+        child.expect("ipdb>")
+        child.sendline("return")
+        child.expect("ipdb>")
+        child.sendline("next")
+        child.expect_exact("[... skipped 1 ignored module(s)]")
+        child.expect("ipdb>")
+
+        child.sendline("continue")
+        child.close()
diff --git a/tests/test_decorators.py b/tests/test_decorators.py
new file mode 100644
index 00000000000..cd4854a2301
--- /dev/null
+++ b/tests/test_decorators.py
@@ -0,0 +1,154 @@
+"""Tests for the decorators we've created for IPython."""
+
+# Module imports
+# Std lib
+import inspect
+import sys
+
+# Our own
+from IPython.testing import decorators as dec
+from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.text import dedent
+
+# -----------------------------------------------------------------------------
+# Utilities
+
+
+# Note: copied from OInspect, kept here so the testing stuff doesn't create
+# circular dependencies and is easier to reuse.
+def getargspec(obj):
+    """Get the names and default values of a function's arguments.
+
+    A tuple of four things is returned: (args, varargs, varkw, defaults).
+    'args' is a list of the argument names (it may contain nested lists).
+    'varargs' and 'varkw' are the names of the * and ** arguments or None.
+    'defaults' is an n-tuple of the default values of the last n arguments.
+
+    Modified version of inspect.getargspec from the Python Standard
+    Library."""
+
+    if inspect.isfunction(obj):
+        func_obj = obj
+    elif inspect.ismethod(obj):
+        func_obj = obj.__func__
+    else:
+        raise TypeError("arg is not a Python function")
+    args, varargs, varkw = inspect.getargs(func_obj.__code__)
+    return args, varargs, varkw, func_obj.__defaults__
+
+
+# -----------------------------------------------------------------------------
+# Testing functions
+
+
+def test_trivial():
+    """A trivial test"""
+    pass
+
+
+@dec.skip()
+def test_deliberately_broken():
+    """A deliberately broken test - we want to skip this one."""
+    1 / 0
+
+
+@dec.skip("Testing the skip decorator")
+def test_deliberately_broken2():
+    """Another deliberately broken test - we want to skip this one."""
+    1 / 0
+
+
+# Verify that we can correctly skip the doctest for a function at will, but
+# that the docstring itself is NOT destroyed by the decorator.
+@skip_doctest
+def doctest_bad(x, y=1, **k):
+    """A function whose doctest we need to skip.
+
+    >>> 1+1
+    3
+    """
+    print("x:", x)
+    print("y:", y)
+    print("k:", k)
+
+
+def call_doctest_bad():
+    """Check that we can still call the decorated functions.
+
+    >>> doctest_bad(3,y=4)
+    x: 3
+    y: 4
+    k: {}
+    """
+    pass
+
+
+def test_skip_dt_decorator():
+    """Doctest-skipping decorator should preserve the docstring."""
+    # Careful: 'check' must be a *verbatim* copy of the doctest_bad docstring!
+    check = """A function whose doctest we need to skip.
+
+    >>> 1+1
+    3
+    """
+
+    # Fetch the docstring from doctest_bad after decoration.
+    val = doctest_bad.__doc__
+
+    assert dedent(check) == dedent(val), "doctest_bad docstrings don't match"
+
+
+# Doctest skipping should work for class methods too
+class FooClass(object):
+    """FooClass
+
+    Example:
+
+    >>> 1+1
+    2
+    """
+
+    @skip_doctest
+    def __init__(self, x):
+        """Make a FooClass.
+
+        Example:
+
+        >>> f = FooClass(3)
+        junk
+        """
+        print("Making a FooClass.")
+        self.x = x
+
+    @skip_doctest
+    def bar(self, y):
+        """Example:
+
+        >>> ff = FooClass(3)
+        >>> ff.bar(0)
+        boom!
+        >>> 1/0
+        bam!
+        """
+        return 1 / y
+
+    def baz(self, y):
+        """Example:
+
+        >>> ff2 = FooClass(3)
+        Making a FooClass.
+        >>> ff2.baz(3)
+        True
+        """
+        return self.x == y
+
+
+def test_skip_dt_decorator2():
+    """Doctest-skipping decorator should preserve function signature."""
+    # Hardcoded correct answer
+    dtargs = (["x", "y"], None, "k", (1,))
+    # Introspect out the value
+    dtargsr = getargspec(doctest_bad)
+    assert dtargsr == dtargs, "Incorrectly reconstructed args for doctest_bad: %s" % (
+        dtargsr,
+    )
diff --git a/tests/test_decorators_2.py b/tests/test_decorators_2.py
new file mode 100644
index 00000000000..04c87b6594b
--- /dev/null
+++ b/tests/test_decorators_2.py
@@ -0,0 +1,11 @@
+from IPython.utils import decorators
+
+
+def test_flag_calls():
+    @decorators.flag_calls
+    def f():
+        pass
+
+    assert not f.called
+    f()
+    assert f.called
diff --git a/tests/test_deepreload.py b/tests/test_deepreload.py
new file mode 100644
index 00000000000..5da606cb8b7
--- /dev/null
+++ b/tests/test_deepreload.py
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""Test suite for the deepreload module."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import types
+from pathlib import Path
+
+import pytest
+from tempfile import TemporaryDirectory
+
+from IPython.lib.deepreload import modules_reloading
+from IPython.lib.deepreload import reload as dreload
+from IPython.utils.syspathcontext import prepended_to_syspath
+
+
+def test_deepreload():
+    "Test that dreload does deep reloads and skips excluded modules."
+    with TemporaryDirectory() as tmpdir:
+        with prepended_to_syspath(tmpdir):
+            tmpdirpath = Path(tmpdir)
+            with open(tmpdirpath / "A.py", "w", encoding="utf-8") as f:
+                f.write("class Object:\n    pass\nok = True\n")
+            with open(tmpdirpath / "B.py", "w", encoding="utf-8") as f:
+                f.write("import A\nassert A.ok, 'we are fine'\n")
+            import A
+            import B
+
+            # Test that A is not reloaded.
+            obj = A.Object()
+            dreload(B, exclude=["A"])
+            assert isinstance(obj, A.Object) is True
+
+            # Test that an import failure will not blow-up us.
+            A.ok = False
+            with pytest.raises(AssertionError, match="we are fine"):
+                dreload(B, exclude=["A"])
+            assert len(modules_reloading) == 0
+            assert not A.ok
+
+            # Test that A is reloaded.
+            obj = A.Object()
+            A.ok = False
+            dreload(B)
+            assert A.ok
+            assert isinstance(obj, A.Object) is False
+
+
+def test_not_module():
+    pytest.raises(TypeError, dreload, "modulename")
+
+
+def test_not_in_sys_modules():
+    fake_module = types.ModuleType("fake_module")
+    with pytest.raises(ImportError, match="not in sys.modules"):
+        dreload(fake_module)
diff --git a/tests/test_dir2.py b/tests/test_dir2.py
new file mode 100644
index 00000000000..bf7f5e57ea2
--- /dev/null
+++ b/tests/test_dir2.py
@@ -0,0 +1,66 @@
+from IPython.utils.dir2 import dir2
+
+import pytest
+
+
+class Base(object):
+    x = 1
+    z = 23
+
+
+def test_base():
+    res = dir2(Base())
+    assert "x" in res
+    assert "z" in res
+    assert "y" not in res
+    assert "__class__" in res
+    assert res.count("x") == 1
+    assert res.count("__class__") == 1
+
+
+def test_SubClass():
+    class SubClass(Base):
+        y = 2
+
+    res = dir2(SubClass())
+    assert "y" in res
+    assert res.count("y") == 1
+    assert res.count("x") == 1
+
+
+def test_SubClass_with_trait_names_attr():
+    # usecase: trait_names is used in a class describing psychological classification
+
+    class SubClass(Base):
+        y = 2
+        trait_names = 44
+
+    res = dir2(SubClass())
+    assert "trait_names" in res
+
+
+def test_misbehaving_object_without_trait_names():
+    # dir2 shouldn't raise even when objects are dumb and raise
+    # something other than AttribteErrors on bad getattr.
+
+    class MisbehavingGetattr:
+        def __getattr__(self, attr):
+            raise KeyError("I should be caught")
+
+        def some_method(self):
+            return True
+
+    class SillierWithDir(MisbehavingGetattr):
+        def __dir__(self):
+            return ["some_method"]
+
+    for bad_klass in (MisbehavingGetattr, SillierWithDir):
+        obj = bad_klass()
+
+        assert obj.some_method()
+
+        with pytest.raises(KeyError):
+            obj.other_method()
+
+        res = dir2(obj)
+        assert "some_method" in res
diff --git a/tests/test_display.py b/tests/test_display.py
new file mode 100644
index 00000000000..10e25de98d7
--- /dev/null
+++ b/tests/test_display.py
@@ -0,0 +1,279 @@
+"""Tests for IPython.lib.display."""
+
+# -----------------------------------------------------------------------------
+# Copyright (c) 2012, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from tempfile import NamedTemporaryFile, mkdtemp
+from os.path import split, join as pjoin, dirname
+import pathlib
+from unittest import TestCase, mock
+import struct
+import wave
+from io import BytesIO
+
+# Third-party imports
+import pytest
+
+try:
+    import numpy
+except ImportError:
+    pass
+
+# Our own imports
+from IPython.lib import display
+
+from IPython.testing.decorators import skipif_not_numpy
+
+# -----------------------------------------------------------------------------
+# Classes and functions
+# -----------------------------------------------------------------------------
+
+# --------------------------
+# FileLink tests
+# --------------------------
+
+
+def test_instantiation_FileLink():
+    """FileLink: Test class can be instantiated"""
+    fl = display.FileLink("example.txt")
+    # TODO: remove if when only Python >= 3.6 is supported
+    fl = display.FileLink(pathlib.PurePath("example.txt"))
+
+
+def test_warning_on_non_existent_path_FileLink():
+    """FileLink: Calling _repr_html_ on non-existent files returns a warning"""
+    fl = display.FileLink("example.txt")
+    assert fl._repr_html_().startswith("Path (<tt>example.txt</tt>)")
+
+
+def test_existing_path_FileLink():
+    """FileLink: Calling _repr_html_ functions as expected on existing filepath"""
+    tf = NamedTemporaryFile()
+    fl = display.FileLink(tf.name)
+    actual = fl._repr_html_()
+    expected = "<a href='%s' target='_blank'>%s</a><br>" % (tf.name, tf.name)
+    assert actual == expected
+
+
+def test_existing_path_FileLink_repr():
+    """FileLink: Calling repr() functions as expected on existing filepath"""
+    tf = NamedTemporaryFile()
+    fl = display.FileLink(tf.name)
+    actual = repr(fl)
+    expected = tf.name
+    assert actual == expected
+
+
+def test_error_on_directory_to_FileLink():
+    """FileLink: Raises error when passed directory"""
+    td = mkdtemp()
+    pytest.raises(ValueError, display.FileLink, td)
+
+
+# --------------------------
+# FileLinks tests
+# --------------------------
+
+
+def test_instantiation_FileLinks():
+    """FileLinks: Test class can be instantiated"""
+    fls = display.FileLinks("example")
+
+
+def test_warning_on_non_existent_path_FileLinks():
+    """FileLinks: Calling _repr_html_ on non-existent files returns a warning"""
+    fls = display.FileLinks("example")
+    assert fls._repr_html_().startswith("Path (<tt>example</tt>)")
+
+
+def test_existing_path_FileLinks():
+    """FileLinks: Calling _repr_html_ functions as expected on existing dir"""
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+    fl = display.FileLinks(td)
+    actual = fl._repr_html_()
+    actual = actual.split("\n")
+    actual.sort()
+    # the links should always have forward slashes, even on windows, so replace
+    # backslashes with forward slashes here
+    expected = [
+        "%s/<br>" % td,
+        "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>"
+        % (tf2.name.replace("\\", "/"), split(tf2.name)[1]),
+        "&nbsp;&nbsp;<a href='%s' target='_blank'>%s</a><br>"
+        % (tf1.name.replace("\\", "/"), split(tf1.name)[1]),
+    ]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_existing_path_FileLinks_alt_formatter():
+    """FileLinks: Calling _repr_html_ functions as expected w/ an alt formatter"""
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+
+    def fake_formatter(dirname, fnames, included_suffixes):
+        return ["hello", "world"]
+
+    fl = display.FileLinks(td, notebook_display_formatter=fake_formatter)
+    actual = fl._repr_html_()
+    actual = actual.split("\n")
+    actual.sort()
+    expected = ["hello", "world"]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_existing_path_FileLinks_repr():
+    """FileLinks: Calling repr() functions as expected on existing directory"""
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+    fl = display.FileLinks(td)
+    actual = repr(fl)
+    actual = actual.split("\n")
+    actual.sort()
+    expected = ["%s/" % td, "  %s" % split(tf1.name)[1], "  %s" % split(tf2.name)[1]]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_existing_path_FileLinks_repr_alt_formatter():
+    """FileLinks: Calling repr() functions as expected w/ alt formatter"""
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    tf2 = NamedTemporaryFile(dir=td)
+
+    def fake_formatter(dirname, fnames, included_suffixes):
+        return ["hello", "world"]
+
+    fl = display.FileLinks(td, terminal_display_formatter=fake_formatter)
+    actual = repr(fl)
+    actual = actual.split("\n")
+    actual.sort()
+    expected = ["hello", "world"]
+    expected.sort()
+    # We compare the sorted list of links here as that's more reliable
+    assert actual == expected
+
+
+def test_error_on_file_to_FileLinks():
+    """FileLinks: Raises error when passed file"""
+    td = mkdtemp()
+    tf1 = NamedTemporaryFile(dir=td)
+    pytest.raises(ValueError, display.FileLinks, tf1.name)
+
+
+def test_recursive_FileLinks():
+    """FileLinks: Does not recurse when recursive=False"""
+    td = mkdtemp()
+    tf = NamedTemporaryFile(dir=td)
+    subtd = mkdtemp(dir=td)
+    subtf = NamedTemporaryFile(dir=subtd)
+    fl = display.FileLinks(td)
+    actual = str(fl)
+    actual = actual.split("\n")
+    assert len(actual) == 4, actual
+    fl = display.FileLinks(td, recursive=False)
+    actual = str(fl)
+    actual = actual.split("\n")
+    assert len(actual) == 2, actual
+
+
+def test_audio_from_file():
+    path = pjoin(dirname(__file__), "test.wav")
+    display.Audio(filename=path)
+
+
+class TestAudioDataWithNumpy(TestCase):
+    @skipif_not_numpy
+    def test_audio_from_numpy_array(self):
+        test_tone = get_test_tone()
+        audio = display.Audio(test_tone, rate=44100)
+        assert len(read_wav(audio.data)) == len(test_tone)
+
+    @skipif_not_numpy
+    def test_audio_from_list(self):
+        test_tone = get_test_tone()
+        audio = display.Audio(list(test_tone), rate=44100)
+        assert len(read_wav(audio.data)) == len(test_tone)
+
+    @skipif_not_numpy
+    def test_audio_from_numpy_array_without_rate_raises(self):
+        self.assertRaises(ValueError, display.Audio, get_test_tone())
+
+    @skipif_not_numpy
+    def test_audio_data_normalization(self):
+        expected_max_value = numpy.iinfo(numpy.int16).max
+        for scale in [1, 0.5, 2]:
+            audio = display.Audio(get_test_tone(scale), rate=44100)
+            actual_max_value = numpy.max(numpy.abs(read_wav(audio.data)))
+            assert actual_max_value == expected_max_value
+
+    @skipif_not_numpy
+    def test_audio_data_without_normalization(self):
+        max_int16 = numpy.iinfo(numpy.int16).max
+        for scale in [1, 0.5, 0.2]:
+            test_tone = get_test_tone(scale)
+            test_tone_max_abs = numpy.max(numpy.abs(test_tone))
+            expected_max_value = int(max_int16 * test_tone_max_abs)
+            audio = display.Audio(test_tone, rate=44100, normalize=False)
+            actual_max_value = numpy.max(numpy.abs(read_wav(audio.data)))
+            assert actual_max_value == expected_max_value
+
+    def test_audio_data_without_normalization_raises_for_invalid_data(self):
+        self.assertRaises(
+            ValueError, lambda: display.Audio([1.001], rate=44100, normalize=False)
+        )
+        self.assertRaises(
+            ValueError, lambda: display.Audio([-1.001], rate=44100, normalize=False)
+        )
+
+
+def simulate_numpy_not_installed():
+    try:
+        import numpy
+
+        return mock.patch("numpy.array", mock.MagicMock(side_effect=ImportError))
+    except ModuleNotFoundError:
+        return lambda x: x
+
+
+@simulate_numpy_not_installed()
+class TestAudioDataWithoutNumpy(TestAudioDataWithNumpy):
+    # All tests from `TestAudioDataWithNumpy` are inherited.
+
+    @skipif_not_numpy
+    def test_audio_raises_for_nested_list(self):
+        stereo_signal = [list(get_test_tone())] * 2
+        self.assertRaises(TypeError, lambda: display.Audio(stereo_signal, rate=44100))
+
+
+@skipif_not_numpy
+def get_test_tone(scale=1):
+    return numpy.sin(2 * numpy.pi * 440 * numpy.linspace(0, 1, 44100)) * scale
+
+
+def read_wav(data):
+    with wave.open(BytesIO(data)) as wave_file:
+        wave_data = wave_file.readframes(wave_file.getnframes())
+        num_samples = wave_file.getnframes() * wave_file.getnchannels()
+        return struct.unpack("<%sh" % num_samples, wave_data)
+
+
+def test_code_from_file():
+    c = display.Code(filename=__file__)
+    assert c._repr_html_().startswith("<style>")
diff --git a/tests/test_display_2.py b/tests/test_display_2.py
new file mode 100644
index 00000000000..5b8b1263bad
--- /dev/null
+++ b/tests/test_display_2.py
@@ -0,0 +1,565 @@
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import json
+import os
+import warnings
+
+from unittest import mock
+
+import pytest
+
+from IPython import display
+from IPython.core.getipython import get_ipython
+from IPython.utils.io import capture_output
+from IPython.utils.tempdir import NamedFileInTemporaryDirectory
+from IPython import paths as ipath
+from IPython.testing.tools import AssertNotPrints
+
+import IPython.testing.decorators as dec
+
+
+def test_image_size():
+    """Simple test for display.Image(args, width=x,height=y)"""
+    thisurl = "http://www.google.fr/images/srpr/logo3w.png"
+    img = display.Image(url=thisurl, width=200, height=200)
+    assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
+    img = display.Image(url=thisurl, metadata={"width": 200, "height": 200})
+    assert '<img src="%s" width="200" height="200"/>' % (thisurl) == img._repr_html_()
+    img = display.Image(url=thisurl, width=200)
+    assert '<img src="%s" width="200"/>' % (thisurl) == img._repr_html_()
+    img = display.Image(url=thisurl)
+    assert '<img src="%s"/>' % (thisurl) == img._repr_html_()
+    img = display.Image(url=thisurl, unconfined=True)
+    assert '<img src="%s" class="unconfined"/>' % (thisurl) == img._repr_html_()
+
+
+def test_image_mimes():
+    fmt = get_ipython().display_formatter.format
+    for format in display.Image._ACCEPTABLE_EMBEDDINGS:
+        mime = display.Image._MIMETYPES[format]
+        img = display.Image(b"garbage", format=format)
+        data, metadata = fmt(img)
+        assert sorted(data) == sorted([mime, "text/plain"])
+
+
+def test_geojson():
+    gj = display.GeoJSON(
+        data={
+            "type": "Feature",
+            "geometry": {"type": "Point", "coordinates": [-81.327, 296.038]},
+            "properties": {"name": "Inca City"},
+        },
+        url_template="http://s3-eu-west-1.amazonaws.com/whereonmars.cartodb.net/{basemap_id}/{z}/{x}/{y}.png",
+        layer_options={
+            "basemap_id": "celestia_mars-shaded-16k_global",
+            "attribution": "Celestia/praesepe",
+            "minZoom": 0,
+            "maxZoom": 18,
+        },
+    )
+    assert "<IPython.core.display.GeoJSON object>" == str(gj)
+
+
+def test_retina_png():
+    here = os.path.dirname(__file__)
+    img = display.Image(os.path.join(here, "2x2.png"), retina=True)
+    assert img.height == 1
+    assert img.width == 1
+    data, md = img._repr_png_()
+    assert md["width"] == 1
+    assert md["height"] == 1
+
+
+def test_embed_svg_url():
+    import gzip
+    from io import BytesIO
+
+    svg_data = b'<svg><circle x="0" y="0" r="1"/></svg>'
+    url = "http://test.com/circle.svg"
+
+    gzip_svg = BytesIO()
+    with gzip.open(gzip_svg, "wb") as fp:
+        fp.write(svg_data)
+    gzip_svg = gzip_svg.getvalue()
+
+    def mocked_urlopen(*args, **kwargs):
+        class MockResponse:
+            def __init__(self, svg):
+                self._svg_data = svg
+                self.headers = {"content-type": "image/svg+xml"}
+
+            def read(self):
+                return self._svg_data
+
+        if args[0] == url:
+            return MockResponse(svg_data)
+        elif args[0] == url + "z":
+            ret = MockResponse(gzip_svg)
+            ret.headers["content-encoding"] = "gzip"
+            return ret
+        return MockResponse(None)
+
+    with mock.patch("urllib.request.urlopen", side_effect=mocked_urlopen):
+        svg = display.SVG(url=url)
+        assert svg._repr_svg_().startswith("<svg") is True
+        svg = display.SVG(url=url + "z")
+        assert svg._repr_svg_().startswith("<svg") is True
+
+
+def test_retina_jpeg():
+    here = os.path.dirname(__file__)
+    img = display.Image(os.path.join(here, "2x2.jpg"), retina=True)
+    assert img.height == 1
+    assert img.width == 1
+    data, md = img._repr_jpeg_()
+    assert md["width"] == 1
+    assert md["height"] == 1
+
+
+def test_base64image():
+    display.Image(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAWJLR0QAiAUdSAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB94BCRQnOqNu0b4AAAAKSURBVAjXY2AAAAACAAHiIbwzAAAAAElFTkSuQmCC"
+    )
+
+
+def test_image_filename_defaults():
+    """test format constraint, and validity of jpeg and png"""
+    tpath = ipath.get_ipython_package_dir()
+    pytest.raises(
+        ValueError,
+        display.Image,
+        filename=os.path.join(tpath, "testing/tests/badformat.zip"),
+        embed=True,
+    )
+    pytest.raises(ValueError, display.Image)
+    pytest.raises(
+        ValueError,
+        display.Image,
+        data="this is not an image",
+        format="badformat",
+        embed=True,
+    )
+
+
+def _get_inline_config():
+    from matplotlib_inline.config import InlineBackend
+
+    return InlineBackend.instance()
+
+
+@dec.skip_without("matplotlib")
+def test_set_matplotlib_close():
+    from matplotlib_inline.backend_inline import set_matplotlib_close
+
+    cfg = _get_inline_config()
+    cfg.close_figures = False
+
+    set_matplotlib_close()
+    assert cfg.close_figures
+    set_matplotlib_close(False)
+    assert not cfg.close_figures
+
+
+_fmt_mime_map = {
+    "png": "image/png",
+    "jpeg": "image/jpeg",
+    "pdf": "application/pdf",
+    "retina": "image/png",
+    "svg": "image/svg+xml",
+}
+
+
+@dec.skip_without("matplotlib")
+def test_set_matplotlib_formats():
+    from matplotlib.figure import Figure
+    from matplotlib_inline.backend_inline import set_matplotlib_formats
+
+    formatters = get_ipython().display_formatter.formatters
+    for formats in [
+        ("png",),
+        ("pdf", "svg"),
+        ("jpeg", "retina", "png"),
+        (),
+    ]:
+        active_mimes = {_fmt_mime_map[fmt] for fmt in formats}
+        set_matplotlib_formats(*formats)
+        for mime, f in formatters.items():
+            if mime in active_mimes:
+                assert Figure in f
+            else:
+                assert Figure not in f
+
+
+@dec.skip_without("matplotlib")
+def test_set_matplotlib_formats_kwargs():
+    from matplotlib.figure import Figure
+    from matplotlib_inline.backend_inline import set_matplotlib_formats
+
+    ip = get_ipython()
+    cfg = _get_inline_config()
+    cfg.print_figure_kwargs.update(dict(foo="bar"))
+    kwargs = dict(dpi=150)
+    try:
+        set_matplotlib_formats("png", **kwargs)
+        formatter = ip.display_formatter.formatters["image/png"]
+        f = formatter.lookup_by_type(Figure)
+        formatter_kwargs = f.keywords
+        expected = kwargs
+        expected["base64"] = True
+        expected["fmt"] = "png"
+        expected.update(cfg.print_figure_kwargs)
+        assert formatter_kwargs == expected
+    finally:
+        cfg.print_figure_kwargs.clear()
+
+
+@dec.skip_without("matplotlib")
+def test_matplotlib_positioning():
+    _ip = get_ipython()
+
+    prev_active_types = _ip.display_formatter.active_types.copy()
+    prev_execution_count = _ip.execution_count
+    prev_user_ns_underscore = _ip.user_ns.get("_", None)
+
+    _ip.history_manager.reset()
+    _ip.display_formatter.active_types = ["text/plain", "image/png"]
+
+    _ip.run_cell("import matplotlib")
+    prev_mpl_backend = _ip.run_cell("matplotlib.get_backend()").result
+
+    try:
+        _ip.run_line_magic("matplotlib", "inline")
+        _ip.execution_count = 1
+        _ip.run_cell("'no plot here'", store_history=True)
+
+        # Cell 2: No manual flush
+        _ip.run_cell(
+            "import matplotlib.pyplot as plt;plt.plot([0, 1])", store_history=True
+        )
+
+        _ip.run_cell("'no plot here'", store_history=True)
+
+        # Cell 4: Manual flush
+        _ip.run_cell("plt.plot([1, 0])\nplt.show()", store_history=True)
+
+        _ip.run_cell("'no plot here'", store_history=True)
+
+        outputs = _ip.history_manager.outputs
+
+        # Only cells 2 and 4 should have plots
+        for cell_num in [1, 3, 5]:
+            assert not any(
+                "image/png" in out.bundle for out in outputs.get(cell_num, [])
+            ), f"Cell {cell_num} should not have plot"
+
+        cell_2_has_plot = any("image/png" in out.bundle for out in outputs.get(2, []))
+        cell_4_has_plot = any("image/png" in out.bundle for out in outputs.get(4, []))
+
+        assert cell_2_has_plot, "Cell 2 should have plot (auto-flush)"
+        assert cell_4_has_plot, "Cell 4 should have plot (manual flush)"
+
+    finally:
+        _ip.run_cell("plt.close('all')")
+        _ip.run_line_magic("matplotlib", prev_mpl_backend)
+        _ip.history_manager.reset()
+        _ip.display_formatter.active_types = prev_active_types
+        _ip.displayhook.flush()
+
+        _ip.execution_count = prev_execution_count
+        if prev_user_ns_underscore is not None:
+            _ip.user_ns["_"] = prev_user_ns_underscore
+        elif "_" in _ip.user_ns:
+            del _ip.user_ns["_"]
+
+
+def test_display_available():
+    """
+    Test that display is available without import
+
+    We don't really care if it's in builtin or anything else, but it should
+    always be available.
+    """
+    ip = get_ipython()
+    with AssertNotPrints("NameError"):
+        ip.run_cell("display")
+    try:
+        ip.run_cell("del display")
+    except NameError:
+        pass  # it's ok, it might be in builtins
+    # even if deleted it should be back
+    with AssertNotPrints("NameError"):
+        ip.run_cell("display")
+
+
+def test_textdisplayobj_pretty_repr():
+    p = display.Pretty("This is a simple test")
+    assert repr(p) == "<IPython.core.display.Pretty object>"
+    assert p.data == "This is a simple test"
+
+    p._show_mem_addr = True
+    assert repr(p) == object.__repr__(p)
+
+
+def test_displayobject_repr():
+    h = display.HTML("<br />")
+    assert repr(h) == "<IPython.core.display.HTML object>"
+    h._show_mem_addr = True
+    assert repr(h) == object.__repr__(h)
+    h._show_mem_addr = False
+    assert repr(h) == "<IPython.core.display.HTML object>"
+
+    j = display.Javascript("")
+    assert repr(j) == "<IPython.core.display.Javascript object>"
+    j._show_mem_addr = True
+    assert repr(j) == object.__repr__(j)
+    j._show_mem_addr = False
+    assert repr(j) == "<IPython.core.display.Javascript object>"
+
+
+@mock.patch("warnings.warn")
+def test_encourage_iframe_over_html(m_warn):
+    display.HTML()
+    m_warn.assert_not_called()
+
+    display.HTML("<br />")
+    m_warn.assert_not_called()
+
+    display.HTML(
+        '<html><p>Lots of content here</p><iframe src="http://a.com"></iframe>'
+    )
+    m_warn.assert_not_called()
+
+    display.HTML('<iframe src="http://a.com"></iframe>')
+    m_warn.assert_called_with("Consider using IPython.display.IFrame instead")
+
+    m_warn.reset_mock()
+    display.HTML('<IFRAME SRC="http://a.com"></IFRAME>')
+    m_warn.assert_called_with("Consider using IPython.display.IFrame instead")
+
+
+def test_progress():
+    p = display.ProgressBar(10)
+    assert "0/10" in repr(p)
+    p.html_width = "100%"
+    p.progress = 5
+    assert (
+        p._repr_html_() == "<progress style='width:100%' max='10' value='5'></progress>"
+    )
+
+
+def test_progress_iter():
+    with capture_output(display=False) as captured:
+        for i in display.ProgressBar(5):
+            out = captured.stdout
+            assert "{0}/5".format(i) in out
+    out = captured.stdout
+    assert "5/5" in out
+
+
+def test_json():
+    d = {"a": 5}
+    lis = [d]
+    metadata = [
+        {"expanded": False, "root": "root"},
+        {"expanded": True, "root": "root"},
+        {"expanded": False, "root": "custom"},
+        {"expanded": True, "root": "custom"},
+    ]
+    json_objs = [
+        display.JSON(d),
+        display.JSON(d, expanded=True),
+        display.JSON(d, root="custom"),
+        display.JSON(d, expanded=True, root="custom"),
+    ]
+    for j, md in zip(json_objs, metadata):
+        assert j._repr_json_() == (d, md)
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        j = display.JSON(json.dumps(d))
+        assert len(w) == 1
+        assert j._repr_json_() == (d, metadata[0])
+
+    json_objs = [
+        display.JSON(lis),
+        display.JSON(lis, expanded=True),
+        display.JSON(lis, root="custom"),
+        display.JSON(lis, expanded=True, root="custom"),
+    ]
+    for j, md in zip(json_objs, metadata):
+        assert j._repr_json_() == (lis, md)
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        j = display.JSON(json.dumps(lis))
+        assert len(w) == 1
+        assert j._repr_json_() == (lis, metadata[0])
+
+
+def test_video_embedding():
+    """use a tempfile, with dummy-data, to ensure that video embedding doesn't crash"""
+    v = display.Video("http://ignored")
+    assert not v.embed
+    html = v._repr_html_()
+    assert 'src="data:' not in html
+    assert 'src="http://ignored"' in html
+
+    with pytest.raises(ValueError):
+        v = display.Video(b"abc")
+
+    with NamedFileInTemporaryDirectory("test.mp4", "wb") as f:
+        f.write(b"abc")
+        f.close()
+
+        v = display.Video(f.name)
+        assert not v.embed
+        html = v._repr_html_()
+        assert 'src="data:' not in html
+
+        v = display.Video(f.name, embed=True)
+        html = v._repr_html_()
+        assert 'src="data:video/mp4;base64,YWJj"' in html
+
+        v = display.Video(f.name, embed=True, mimetype="video/other")
+        html = v._repr_html_()
+        assert 'src="data:video/other;base64,YWJj"' in html
+
+        v = display.Video(b"abc", embed=True, mimetype="video/mp4")
+        html = v._repr_html_()
+        assert 'src="data:video/mp4;base64,YWJj"' in html
+
+        v = display.Video("YWJj", embed=True, mimetype="video/xyz")
+        html = v._repr_html_()
+        assert 'src="data:video/xyz;base64,YWJj"' in html
+
+
+def test_html_metadata():
+    s = "<h1>Test</h1>"
+    h = display.HTML(s, metadata={"isolated": True})
+    assert h._repr_html_() == (s, {"isolated": True})
+
+
+def test_display_id():
+    ip = get_ipython()
+    with mock.patch.object(ip.display_pub, "publish") as pub:
+        handle = display.display("x")
+        assert handle is None
+        handle = display.display("y", display_id="secret")
+        assert isinstance(handle, display.DisplayHandle)
+        handle2 = display.display("z", display_id=True)
+        assert isinstance(handle2, display.DisplayHandle)
+    assert handle.display_id != handle2.display_id
+
+    assert pub.call_count == 3
+    args, kwargs = pub.call_args_list[0]
+    assert args == ()
+    assert kwargs == {
+        "data": {"text/plain": repr("x")},
+        "metadata": {},
+    }
+    args, kwargs = pub.call_args_list[1]
+    assert args == ()
+    assert kwargs == {
+        "data": {"text/plain": repr("y")},
+        "metadata": {},
+        "transient": {
+            "display_id": handle.display_id,
+        },
+    }
+    args, kwargs = pub.call_args_list[2]
+    assert args == ()
+    assert kwargs == {
+        "data": {"text/plain": repr("z")},
+        "metadata": {},
+        "transient": {
+            "display_id": handle2.display_id,
+        },
+    }
+
+
+def test_update_display():
+    ip = get_ipython()
+    with mock.patch.object(ip.display_pub, "publish") as pub:
+        with pytest.raises(TypeError):
+            display.update_display("x")
+        display.update_display("x", display_id="1")
+        display.update_display("y", display_id="2")
+    args, kwargs = pub.call_args_list[0]
+    assert args == ()
+    assert kwargs == {
+        "data": {"text/plain": repr("x")},
+        "metadata": {},
+        "transient": {
+            "display_id": "1",
+        },
+        "update": True,
+    }
+    args, kwargs = pub.call_args_list[1]
+    assert args == ()
+    assert kwargs == {
+        "data": {"text/plain": repr("y")},
+        "metadata": {},
+        "transient": {
+            "display_id": "2",
+        },
+        "update": True,
+    }
+
+
+def test_display_handle():
+    ip = get_ipython()
+    handle = display.DisplayHandle()
+    assert isinstance(handle.display_id, str)
+    handle = display.DisplayHandle("my-id")
+    assert handle.display_id == "my-id"
+    with mock.patch.object(ip.display_pub, "publish") as pub:
+        handle.display("x")
+        handle.update("y")
+
+    args, kwargs = pub.call_args_list[0]
+    assert args == ()
+    assert kwargs == {
+        "data": {"text/plain": repr("x")},
+        "metadata": {},
+        "transient": {
+            "display_id": handle.display_id,
+        },
+    }
+    args, kwargs = pub.call_args_list[1]
+    assert args == ()
+    assert kwargs == {
+        "data": {"text/plain": repr("y")},
+        "metadata": {},
+        "transient": {
+            "display_id": handle.display_id,
+        },
+        "update": True,
+    }
+
+
+def test_image_alt_tag():
+    """Simple test for display.Image(args, alt=x,)"""
+    thisurl = "http://example.com/image.png"
+    img = display.Image(url=thisurl, alt="an image")
+    assert '<img src="%s" alt="an image"/>' % (thisurl) == img._repr_html_()
+    img = display.Image(url=thisurl, unconfined=True, alt="an image")
+    assert (
+        '<img src="%s" class="unconfined" alt="an image"/>' % (thisurl)
+        == img._repr_html_()
+    )
+    img = display.Image(url=thisurl, alt='>"& <')
+    assert '<img src="%s" alt="&gt;&quot;&amp; &lt;"/>' % (thisurl) == img._repr_html_()
+
+    img = display.Image(url=thisurl, metadata={"alt": "an image"})
+    assert img.alt == "an image"
+    here = os.path.dirname(__file__)
+    img = display.Image(os.path.join(here, "2x2.png"), alt="an image")
+    assert img.alt == "an image"
+    _, md = img._repr_png_()
+    assert md["alt"] == "an image"
+
+
+def test_image_bad_filename_raises_proper_exception():
+    with pytest.raises(FileNotFoundError):
+        display.Image("/this/file/does/not/exist/")._repr_png_()
diff --git a/tests/test_displayhook.py b/tests/test_displayhook.py
new file mode 100644
index 00000000000..894631b8701
--- /dev/null
+++ b/tests/test_displayhook.py
@@ -0,0 +1,116 @@
+import sys
+from IPython.testing.tools import AssertPrints, AssertNotPrints
+from IPython.core.displayhook import CapturingDisplayHook
+from IPython.utils.capture import CapturedIO
+
+
+def test_output_displayed():
+    """Checking to make sure that output is displayed"""
+
+    with AssertPrints("2"):
+        ip.run_cell("1+1", store_history=True)
+
+    with AssertPrints("2"):
+        ip.run_cell("1+1 # comment with a semicolon;", store_history=True)
+
+    with AssertPrints("2"):
+        ip.run_cell("1+1\n#commented_out_function();", store_history=True)
+
+
+def test_output_quiet():
+    """Checking to make sure that output is quiet"""
+
+    with AssertNotPrints("2"):
+        ip.run_cell("1+1;", store_history=True)
+
+    with AssertNotPrints("2"):
+        ip.run_cell("1+1; # comment with a semicolon", store_history=True)
+
+    with AssertNotPrints("2"):
+        ip.run_cell("1+1;\n#commented_out_function()", store_history=True)
+
+
+def test_underscore_no_overwrite_user():
+    ip.run_cell("_ = 42", store_history=True)
+    ip.run_cell("1+1", store_history=True)
+
+    with AssertPrints("42"):
+        ip.run_cell("print(_)", store_history=True)
+
+    ip.run_cell("del _", store_history=True)
+    ip.run_cell("6+6", store_history=True)
+    with AssertPrints("12"):
+        ip.run_cell("_", store_history=True)
+
+
+def test_underscore_no_overwrite_builtins():
+    ip.run_cell("import gettext ; gettext.install('foo')", store_history=True)
+    ip.run_cell("3+3", store_history=True)
+
+    with AssertPrints("gettext"):
+        ip.run_cell("print(_)", store_history=True)
+
+    ip.run_cell('_ = "userset"', store_history=True)
+
+    with AssertPrints("userset"):
+        ip.run_cell("print(_)", store_history=True)
+    ip.run_cell("import builtins; del builtins._")
+
+
+def test_interactivehooks_ast_modes():
+    """
+    Test that ast nodes can be triggered with different modes
+    """
+    saved_mode = ip.ast_node_interactivity
+    ip.ast_node_interactivity = "last_expr_or_assign"
+
+    try:
+        with AssertPrints("2"):
+            ip.run_cell("a = 1+1", store_history=True)
+
+        with AssertPrints("9"):
+            ip.run_cell("b = 1+8 # comment with a semicolon;", store_history=False)
+
+        with AssertPrints("7"):
+            ip.run_cell("c = 1+6\n#commented_out_function();", store_history=True)
+
+        ip.run_cell("d = 11", store_history=True)
+        with AssertPrints("12"):
+            ip.run_cell("d += 1", store_history=True)
+
+        with AssertNotPrints("42"):
+            ip.run_cell("(u,v) = (41+1, 43-1)")
+
+    finally:
+        ip.ast_node_interactivity = saved_mode
+
+
+def test_interactivehooks_ast_modes_semi_suppress():
+    """
+    Test that ast nodes can be triggered with different modes and suppressed
+    by semicolon
+    """
+    saved_mode = ip.ast_node_interactivity
+    ip.ast_node_interactivity = "last_expr_or_assign"
+
+    try:
+        with AssertNotPrints("2"):
+            ip.run_cell("x = 1+1;", store_history=True)
+
+        with AssertNotPrints("7"):
+            ip.run_cell("y = 1+6; # comment with a semicolon", store_history=True)
+
+        with AssertNotPrints("9"):
+            ip.run_cell("z = 1+8;\n#commented_out_function()", store_history=True)
+
+    finally:
+        ip.ast_node_interactivity = saved_mode
+
+
+def test_capture_display_hook_format():
+    """Tests that the capture display hook conforms to the CapturedIO output format"""
+    hook = CapturingDisplayHook(ip)
+    hook({"foo": "bar"})
+    captured = CapturedIO(sys.stdout, sys.stderr, hook.outputs)
+    # Should not raise with RichOutput transformation error
+    captured.outputs
diff --git a/tests/test_editorhooks.py b/tests/test_editorhooks.py
new file mode 100644
index 00000000000..67cbb1cdeea
--- /dev/null
+++ b/tests/test_editorhooks.py
@@ -0,0 +1,38 @@
+"""Test installing editor hooks"""
+
+import sys
+from unittest import mock
+
+from IPython import get_ipython
+from IPython.lib import editorhooks
+
+
+def test_install_editor():
+    called = []
+
+    def fake_popen(*args, **kwargs):
+        called.append(
+            {
+                "args": args,
+                "kwargs": kwargs,
+            }
+        )
+        return mock.MagicMock(**{"wait.return_value": 0})
+
+    editorhooks.install_editor("foo -l {line} -f {filename}", wait=False)
+
+    with mock.patch("subprocess.Popen", fake_popen):
+        get_ipython().hooks.editor("the file", 64)
+
+    assert len(called) == 1
+    args = called[0]["args"]
+    kwargs = called[0]["kwargs"]
+
+    assert kwargs == {"shell": True}
+
+    if sys.platform.startswith("win"):
+        expected = ["foo", "-l", "64", "-f", "the file"]
+    else:
+        expected = "foo -l 64 -f 'the file'"
+    cmd = args[0]
+    assert cmd == expected
diff --git a/tests/test_embed.py b/tests/test_embed.py
new file mode 100644
index 00000000000..f76f2c0f0c9
--- /dev/null
+++ b/tests/test_embed.py
@@ -0,0 +1,149 @@
+"""Test embedding of IPython"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2013 The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import os
+import subprocess
+import sys
+
+from IPython.utils.tempdir import NamedFileInTemporaryDirectory
+from IPython.testing.decorators import skip_win32
+from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+_sample_embed = """
+import IPython
+
+a = 3
+b = 14
+print(a, '.', b)
+
+IPython.embed()
+
+print('bye!')
+"""
+
+_exit = "exit\r"
+
+
+def test_ipython_embed():
+    """test that `IPython.embed()` works"""
+    with NamedFileInTemporaryDirectory("file_with_embed.py", "w") as f:
+        f.write(_sample_embed)
+        f.flush()
+        f.close()  # otherwise msft won't be able to read the file
+
+        # run `python file_with_embed.py`
+        cmd = [sys.executable, f.name]
+        env = os.environ.copy()
+        env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+
+        p = subprocess.Popen(
+            cmd,
+            env=env,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="UTF-8",
+        )
+        std, err = p.communicate(_exit)
+        assert isinstance(std, str), (std, err, p.returncode)
+
+        assert p.returncode == 0, (p.returncode, std)
+        assert "3 . 14" in std
+        if os.name != "nt":
+            # TODO: Fix up our different stdout references, see issue gh-14
+            assert "IPython" in std
+        assert "bye!" in std
+
+
+@skip_win32
+def test_nest_embed():
+    """test that `IPython.embed()` is nestable"""
+    import pexpect
+
+    ipy_prompt = r"]:"  # ansi color codes give problems matching beyond this
+    env = os.environ.copy()
+    env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+
+    child = pexpect.spawn(
+        sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
+    )
+    child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+    child.expect(ipy_prompt)
+    child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
+    child.sendline("import IPython")
+    child.sendline("from IPython.core.history import HistoryManager")
+    child.sendline("HistoryManager._max_inst = 3")
+    child.expect(ipy_prompt)
+    child.sendline("ip0 = get_ipython()")
+    # enter first nested embed
+    child.sendline("IPython.embed()")
+    # skip the banner until we get to a prompt
+    try:
+        prompted = -1
+        while prompted != 0:
+            prompted = child.expect([ipy_prompt, "\r\n"])
+    except pexpect.TIMEOUT as e:
+        print(e)
+        # child.interact()
+    child.sendline("embed1 = get_ipython()")
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if embed1 is not ip0 else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if IPython.get_ipython() is embed1 else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    # enter second nested embed
+    child.sendline("IPython.embed()")
+    # skip the banner until we get to a prompt
+    try:
+        prompted = -1
+        while prompted != 0:
+            prompted = child.expect([ipy_prompt, "\r\n"])
+    except pexpect.TIMEOUT as e:
+        print(e)
+        # child.interact()
+    child.sendline("embed2 = get_ipython()")
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if embed2 is not embed1 else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if embed2 is IPython.get_ipython() else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    child.sendline("exit")
+    # back at first embed
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if get_ipython() is embed1 else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if IPython.get_ipython() is embed1 else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    child.sendline("exit")
+    # back at launching scope
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if get_ipython() is ip0 else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    child.sendline("print('true' if IPython.get_ipython() is ip0 else 'false')")
+    assert child.expect(["true\r\n", "false\r\n"]) == 0
+    child.expect(ipy_prompt)
+    child.sendline("exit")
+    child.close()
diff --git a/tests/test_events.py b/tests/test_events.py
new file mode 100644
index 00000000000..1d76063b925
--- /dev/null
+++ b/tests/test_events.py
@@ -0,0 +1,82 @@
+import unittest
+from unittest.mock import Mock
+
+from IPython.core import events
+import IPython.testing.tools as tt
+
+
+@events._define_event
+def ping_received():
+    pass
+
+
+@events._define_event
+def event_with_argument(argument):
+    pass
+
+
+class CallbackTests(unittest.TestCase):
+    def setUp(self):
+        self.em = events.EventManager(
+            get_ipython(),
+            {
+                "ping_received": ping_received,
+                "event_with_argument": event_with_argument,
+            },
+        )
+
+    def test_register_unregister(self):
+        cb = Mock()
+
+        self.em.register("ping_received", cb)
+        self.em.trigger("ping_received")
+        self.assertEqual(cb.call_count, 1)
+
+        self.em.unregister("ping_received", cb)
+        self.em.trigger("ping_received")
+        self.assertEqual(cb.call_count, 1)
+
+    def test_bare_function_missed_unregister(self):
+        def cb1():
+            ...
+
+        def cb2():
+            ...
+
+        self.em.register("ping_received", cb1)
+        self.assertRaises(ValueError, self.em.unregister, "ping_received", cb2)
+        self.em.unregister("ping_received", cb1)
+
+    def test_cb_error(self):
+        cb = Mock(side_effect=ValueError)
+        self.em.register("ping_received", cb)
+        with tt.AssertPrints("Error in callback"):
+            self.em.trigger("ping_received")
+
+    def test_cb_keyboard_interrupt(self):
+        cb = Mock(side_effect=KeyboardInterrupt)
+        self.em.register("ping_received", cb)
+        with tt.AssertPrints("Error in callback"):
+            self.em.trigger("ping_received")
+
+    def test_unregister_during_callback(self):
+        invoked = [False] * 3
+
+        def func1(*_):
+            invoked[0] = True
+            self.em.unregister("ping_received", func1)
+            self.em.register("ping_received", func3)
+
+        def func2(*_):
+            invoked[1] = True
+            self.em.unregister("ping_received", func2)
+
+        def func3(*_):
+            invoked[2] = True
+
+        self.em.register("ping_received", func1)
+        self.em.register("ping_received", func2)
+
+        self.em.trigger("ping_received")
+        self.assertEqual([True, True, False], invoked)
+        self.assertEqual([func3], self.em.callbacks["ping_received"])
diff --git a/tests/test_exceptiongroup_tb.py b/tests/test_exceptiongroup_tb.py
new file mode 100644
index 00000000000..4efa3d3c64f
--- /dev/null
+++ b/tests/test_exceptiongroup_tb.py
@@ -0,0 +1,108 @@
+import unittest
+import re
+from IPython.utils.capture import capture_output
+import sys
+import pytest
+from tempfile import TemporaryDirectory
+from IPython.testing import tools as tt
+
+
+def _exceptiongroup_common(
+    outer_chain: str,
+    inner_chain: str,
+    native: bool,
+) -> None:
+    pre_raise = "exceptiongroup." if not native else ""
+    filestr = f"""
+    {"import exceptiongroup" if not native else ""}
+    import pytest
+
+    def f(): raise ValueError("From f()")
+    def g(): raise BaseException("From g()")
+
+    def inner(inner_chain):
+        excs = []
+        for callback in [f, g]:
+            try:
+                callback()
+            except BaseException as err:
+                excs.append(err)
+        if excs:
+            if inner_chain == "none":
+                raise {pre_raise}BaseExceptionGroup("Oops", excs)
+            try:
+                raise SyntaxError()
+            except SyntaxError as e:
+                if inner_chain == "from":
+                    raise {pre_raise}BaseExceptionGroup("Oops", excs) from e
+                else:
+                    raise {pre_raise}BaseExceptionGroup("Oops", excs)
+
+    def outer(outer_chain, inner_chain):
+        try:
+            inner(inner_chain)
+        except BaseExceptionGroup as e:
+            if outer_chain == "none":
+                raise
+            if outer_chain == "from":
+                raise IndexError() from e
+            else:
+                raise IndexError
+
+
+    outer("{outer_chain}", "{inner_chain}")
+    """
+    with capture_output() as cap:
+        ip.run_cell(filestr)
+
+    match_lines = []
+    if inner_chain == "another":
+        match_lines += [
+            "During handling of the above exception, another exception occurred:",
+        ]
+    elif inner_chain == "from":
+        match_lines += [
+            "The above exception was the direct cause of the following exception:",
+        ]
+
+    match_lines += [
+        "  + Exception Group Traceback (most recent call last):",
+        "  | BaseExceptionGroup: Oops (2 sub-exceptions)",
+        "    | ValueError: From f()",
+        "    | BaseException: From g()",
+    ]
+
+    if outer_chain == "another":
+        match_lines += [
+            "During handling of the above exception, another exception occurred:",
+            "IndexError",
+        ]
+    elif outer_chain == "from":
+        match_lines += [
+            "The above exception was the direct cause of the following exception:",
+            "IndexError",
+        ]
+
+    error_lines = cap.stderr.split("\n")
+
+    err_index = match_index = 0
+    for expected in match_lines:
+        for i, actual in enumerate(error_lines):
+            if actual == expected:
+                error_lines = error_lines[i + 1 :]
+                break
+        else:
+            assert False, f"{expected} not found in cap.stderr"
+
+
+@pytest.mark.parametrize("outer_chain", ["none", "from", "another"])
+@pytest.mark.parametrize("inner_chain", ["none", "from", "another"])
+def test_native_exceptiongroup(outer_chain, inner_chain) -> None:
+    _exceptiongroup_common(outer_chain, inner_chain, native=True)
+
+
+@pytest.mark.parametrize("outer_chain", ["none", "from", "another"])
+@pytest.mark.parametrize("inner_chain", ["none", "from", "another"])
+def test_native_exceptiongroup(outer_chain, inner_chain) -> None:
+    pytest.importorskip("exceptiongroup")
+    _exceptiongroup_common(outer_chain, inner_chain, native=False)
diff --git a/tests/test_extension.py b/tests/test_extension.py
new file mode 100644
index 00000000000..942c26684ac
--- /dev/null
+++ b/tests/test_extension.py
@@ -0,0 +1,96 @@
+import os.path
+
+from tempfile import TemporaryDirectory
+
+import IPython.testing.tools as tt
+from IPython.utils.syspathcontext import prepended_to_syspath
+
+ext1_content = """
+def load_ipython_extension(ip):
+    print("Running ext1 load")
+
+def unload_ipython_extension(ip):
+    print("Running ext1 unload")
+"""
+
+ext2_content = """
+def load_ipython_extension(ip):
+    print("Running ext2 load")
+"""
+
+ext3_content = """
+def load_ipython_extension(ip):
+    ip2 = get_ipython()
+    print(ip is ip2)
+"""
+
+
+def test_extension_loading():
+    em = get_ipython().extension_manager
+    with TemporaryDirectory() as td:
+        ext1 = os.path.join(td, "ext1.py")
+        with open(ext1, "w", encoding="utf-8") as f:
+            f.write(ext1_content)
+
+        ext2 = os.path.join(td, "ext2.py")
+        with open(ext2, "w", encoding="utf-8") as f:
+            f.write(ext2_content)
+
+        with prepended_to_syspath(td):
+            assert "ext1" not in em.loaded
+            assert "ext2" not in em.loaded
+
+            # Load extension
+            with tt.AssertPrints("Running ext1 load"):
+                assert em.load_extension("ext1") is None
+            assert "ext1" in em.loaded
+
+            # Should refuse to load it again
+            with tt.AssertNotPrints("Running ext1 load"):
+                assert em.load_extension("ext1") == "already loaded"
+
+            # Reload
+            with tt.AssertPrints("Running ext1 unload"):
+                with tt.AssertPrints("Running ext1 load", suppress=False):
+                    em.reload_extension("ext1")
+
+            # Unload
+            with tt.AssertPrints("Running ext1 unload"):
+                assert em.unload_extension("ext1") is None
+
+            # Can't unload again
+            with tt.AssertNotPrints("Running ext1 unload"):
+                assert em.unload_extension("ext1") == "not loaded"
+            assert em.unload_extension("ext2") == "not loaded"
+
+            # Load extension 2
+            with tt.AssertPrints("Running ext2 load"):
+                assert em.load_extension("ext2") is None
+
+            # Can't unload this
+            assert em.unload_extension("ext2") == "no unload function"
+
+            # But can reload it
+            with tt.AssertPrints("Running ext2 load"):
+                em.reload_extension("ext2")
+
+
+def test_extension_builtins():
+    em = get_ipython().extension_manager
+    with TemporaryDirectory() as td:
+        ext3 = os.path.join(td, "ext3.py")
+        with open(ext3, "w", encoding="utf-8") as f:
+            f.write(ext3_content)
+
+        assert "ext3" not in em.loaded
+
+        with prepended_to_syspath(td):
+            # Load extension
+            with tt.AssertPrints("True"):
+                assert em.load_extension("ext3") is None
+            assert "ext3" in em.loaded
+
+
+def test_non_extension():
+    em = get_ipython().extension_manager
+    assert em.load_extension("sys") == "no load function"
diff --git a/tests/test_formatters.py b/tests/test_formatters.py
new file mode 100644
index 00000000000..074d1f7521d
--- /dev/null
+++ b/tests/test_formatters.py
@@ -0,0 +1,609 @@
+"""Tests for the Formatters."""
+
+from math import pi
+
+try:
+    import numpy
+except:
+    numpy = None
+import pytest
+
+from IPython import get_ipython
+from traitlets.config import Config
+from IPython.core.formatters import (
+    PlainTextFormatter,
+    HTMLFormatter,
+    PDFFormatter,
+    _mod_name_key,
+    DisplayFormatter,
+    JSONFormatter,
+)
+from IPython.utils.io import capture_output
+
+
+class A(object):
+    def __repr__(self):
+        return "A()"
+
+
+class B(A):
+    def __repr__(self):
+        return "B()"
+
+
+class C:
+    pass
+
+
+class BadRepr(object):
+    def __repr__(self):
+        raise ValueError("bad repr")
+
+
+class BadPretty(object):
+    _repr_pretty_ = None
+
+
+class GoodPretty(object):
+    def _repr_pretty_(self, pp, cycle):
+        pp.text("foo")
+
+    def __repr__(self):
+        return "GoodPretty()"
+
+
+def foo_printer(obj, pp, cycle):
+    pp.text("foo")
+
+
+def test_display_formatter_active_types_config():
+    from IPython.terminal.interactiveshell import TerminalInteractiveShell
+    from IPython.core.history import HistoryManager
+    from traitlets.config import Config
+
+    # Clear HistoryManager instances to bypass singleton limit before creating new shell
+    prev_instances = HistoryManager._instances.copy()
+    HistoryManager._instances.clear()
+
+    try:
+        c = Config()
+        c.DisplayFormatter.active_types = ["text/plain", "image/png"]
+        # Disable history
+        c.HistoryManager.enabled = False
+
+        ip = TerminalInteractiveShell(config=c)
+
+        active_types = ip.display_formatter.active_types
+        assert "text/plain" in active_types
+        assert "image/png" in active_types
+
+        # Ensure only the expected types are active
+        assert set(active_types) == {"text/plain", "image/png"}
+
+    finally:
+        # Clean up the new instance and restore previous state
+        HistoryManager._instances.clear()
+        HistoryManager._instances.update(prev_instances)
+
+
+def test_pretty():
+    f = PlainTextFormatter()
+    f.for_type(A, foo_printer)
+    assert f(A()) == "foo"
+    assert f(B()) == "B()"
+    assert f(GoodPretty()) == "foo"
+    # Just don't raise an exception for the following:
+    f(BadPretty())
+
+    f.pprint = False
+    assert f(A()) == "A()"
+    assert f(B()) == "B()"
+    assert f(GoodPretty()) == "GoodPretty()"
+
+
+def test_deferred():
+    f = PlainTextFormatter()
+
+
+def test_precision():
+    """test various values for float_precision."""
+    f = PlainTextFormatter()
+    assert f(pi) == repr(pi)
+    f.float_precision = 0
+    if numpy:
+        po = numpy.get_printoptions()
+        assert po["precision"] == 0
+    assert f(pi) == "3"
+    f.float_precision = 2
+    if numpy:
+        po = numpy.get_printoptions()
+        assert po["precision"] == 2
+    assert f(pi) == "3.14"
+    f.float_precision = "%g"
+    if numpy:
+        po = numpy.get_printoptions()
+        assert po["precision"] == 2
+    assert f(pi) == "3.14159"
+    f.float_precision = "%e"
+    assert f(pi) == "3.141593e+00"
+    f.float_precision = ""
+    if numpy:
+        po = numpy.get_printoptions()
+        assert po["precision"] == 8
+    assert f(pi) == repr(pi)
+
+
+def test_bad_precision():
+    """test various invalid values for float_precision."""
+    f = PlainTextFormatter()
+
+    def set_fp(p):
+        f.float_precision = p
+
+    pytest.raises(ValueError, set_fp, "%")
+    pytest.raises(ValueError, set_fp, "%.3f%i")
+    pytest.raises(ValueError, set_fp, "foo")
+    pytest.raises(ValueError, set_fp, -1)
+
+
+def test_for_type():
+    f = PlainTextFormatter()
+
+    # initial return, None
+    assert f.for_type(C, foo_printer) is None
+    # no func queries
+    assert f.for_type(C) is foo_printer
+    # shouldn't change anything
+    assert f.for_type(C) is foo_printer
+    # None should do the same
+    assert f.for_type(C, None) is foo_printer
+    assert f.for_type(C, None) is foo_printer
+
+
+def test_for_type_string():
+    f = PlainTextFormatter()
+
+    type_str = "%s.%s" % (C.__module__, "C")
+
+    # initial return, None
+    assert f.for_type(type_str, foo_printer) is None
+    # no func queries
+    assert f.for_type(type_str) is foo_printer
+    assert _mod_name_key(C) in f.deferred_printers
+    assert f.for_type(C) is foo_printer
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
+
+
+def test_for_type_by_name():
+    f = PlainTextFormatter()
+
+    mod = C.__module__
+
+    # initial return, None
+    assert f.for_type_by_name(mod, "C", foo_printer) is None
+    # no func queries
+    assert f.for_type_by_name(mod, "C") is foo_printer
+    # shouldn't change anything
+    assert f.for_type_by_name(mod, "C") is foo_printer
+    # None should do the same
+    assert f.for_type_by_name(mod, "C", None) is foo_printer
+    assert f.for_type_by_name(mod, "C", None) is foo_printer
+
+
+def test_lookup():
+    f = PlainTextFormatter()
+
+    f.for_type(C, foo_printer)
+    assert f.lookup(C()) is foo_printer
+    with pytest.raises(KeyError):
+        f.lookup(A())
+
+
+def test_lookup_string():
+    f = PlainTextFormatter()
+    type_str = "%s.%s" % (C.__module__, "C")
+
+    f.for_type(type_str, foo_printer)
+    assert f.lookup(C()) is foo_printer
+    # should move from deferred to imported dict
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
+
+
+def test_lookup_by_type():
+    f = PlainTextFormatter()
+    f.for_type(C, foo_printer)
+    assert f.lookup_by_type(C) is foo_printer
+    with pytest.raises(KeyError):
+        f.lookup_by_type(A)
+
+
+def test_lookup_by_type_string():
+    f = PlainTextFormatter()
+    type_str = "%s.%s" % (C.__module__, "C")
+    f.for_type(type_str, foo_printer)
+
+    # verify insertion
+    assert _mod_name_key(C) in f.deferred_printers
+    assert C not in f.type_printers
+
+    assert f.lookup_by_type(type_str) is foo_printer
+    # lookup by string doesn't cause import
+    assert _mod_name_key(C) in f.deferred_printers
+    assert C not in f.type_printers
+
+    assert f.lookup_by_type(C) is foo_printer
+    # should move from deferred to imported dict
+    assert _mod_name_key(C) not in f.deferred_printers
+    assert C in f.type_printers
+
+
+def test_in_formatter():
+    f = PlainTextFormatter()
+    f.for_type(C, foo_printer)
+    type_str = "%s.%s" % (C.__module__, "C")
+    assert C in f
+    assert type_str in f
+
+
+def test_string_in_formatter():
+    f = PlainTextFormatter()
+    type_str = "%s.%s" % (C.__module__, "C")
+    f.for_type(type_str, foo_printer)
+    assert type_str in f
+    assert C in f
+
+
+def test_pop():
+    f = PlainTextFormatter()
+    f.for_type(C, foo_printer)
+    assert f.lookup_by_type(C) is foo_printer
+    assert f.pop(C, None) is foo_printer
+    f.for_type(C, foo_printer)
+    assert f.pop(C) is foo_printer
+    with pytest.raises(KeyError):
+        f.lookup_by_type(C)
+    with pytest.raises(KeyError):
+        f.pop(C)
+    with pytest.raises(KeyError):
+        f.pop(A)
+    assert f.pop(A, None) is None
+
+
+def test_pop_string():
+    f = PlainTextFormatter()
+    type_str = "%s.%s" % (C.__module__, "C")
+
+    with pytest.raises(KeyError):
+        f.pop(type_str)
+
+    f.for_type(type_str, foo_printer)
+    f.pop(type_str)
+    with pytest.raises(KeyError):
+        f.lookup_by_type(C)
+    with pytest.raises(KeyError):
+        f.pop(type_str)
+
+    f.for_type(C, foo_printer)
+    assert f.pop(type_str, None) is foo_printer
+    with pytest.raises(KeyError):
+        f.lookup_by_type(C)
+    with pytest.raises(KeyError):
+        f.pop(type_str)
+    assert f.pop(type_str, None) is None
+
+
+def test_error_method():
+    f = HTMLFormatter()
+
+    class BadHTML(object):
+        def _repr_html_(self):
+            raise ValueError("Bad HTML")
+
+    bad = BadHTML()
+    with capture_output() as captured:
+        result = f(bad)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "Bad HTML" in captured.stdout
+    assert "_repr_html_" in captured.stdout
+
+
+def test_nowarn_notimplemented():
+    f = HTMLFormatter()
+
+    class HTMLNotImplemented(object):
+        def _repr_html_(self):
+            raise NotImplementedError
+
+    h = HTMLNotImplemented()
+    with capture_output() as captured:
+        result = f(h)
+    assert result is None
+    assert "" == captured.stderr
+    assert "" == captured.stdout
+
+
+def test_warn_error_for_type():
+    f = HTMLFormatter()
+    f.for_type(int, lambda i: name_error)
+    with capture_output() as captured:
+        result = f(5)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "NameError" in captured.stdout
+    assert "name_error" in captured.stdout
+
+
+def test_error_pretty_method():
+    f = PlainTextFormatter()
+
+    class BadPretty(object):
+        def _repr_pretty_(self):
+            return "hello"
+
+    bad = BadPretty()
+    with capture_output() as captured:
+        result = f(bad)
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "_repr_pretty_" in captured.stdout
+    assert "given" in captured.stdout
+    assert "argument" in captured.stdout
+
+
+def test_bad_repr_traceback():
+    f = PlainTextFormatter()
+    bad = BadRepr()
+    with capture_output() as captured:
+        result = f(bad)
+    # catches error, returns None
+    assert result is None
+    assert "Traceback" in captured.stdout
+    assert "__repr__" in captured.stdout
+    assert "ValueError" in captured.stdout
+
+
+class MakePDF(object):
+    def _repr_pdf_(self):
+        return "PDF"
+
+
+def test_pdf_formatter():
+    pdf = MakePDF()
+    f = PDFFormatter()
+    assert f(pdf) == "PDF"
+
+
+def test_print_method_bound():
+    f = HTMLFormatter()
+
+    class MyHTML(object):
+        def _repr_html_(self):
+            return "hello"
+
+    with capture_output() as captured:
+        result = f(MyHTML)
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
+
+    with capture_output() as captured:
+        result = f(MyHTML())
+    assert result == "hello"
+    assert captured.stderr == ""
+
+
+def test_print_method_weird():
+    class TextMagicHat(object):
+        def __getattr__(self, key):
+            return key
+
+    f = HTMLFormatter()
+
+    text_hat = TextMagicHat()
+    assert text_hat._repr_html_ == "_repr_html_"
+    with capture_output() as captured:
+        result = f(text_hat)
+
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
+
+    class CallableMagicHat(object):
+        def __getattr__(self, key):
+            return lambda: key
+
+    call_hat = CallableMagicHat()
+    with capture_output() as captured:
+        result = f(call_hat)
+
+    assert result is None
+
+    class BadReprArgs(object):
+        def _repr_html_(self, extra, args):
+            return "html"
+
+    bad = BadReprArgs()
+    with capture_output() as captured:
+        result = f(bad)
+
+    assert result is None
+    assert "FormatterWarning" not in captured.stderr
+
+
+def test_format_config():
+    """config objects don't pretend to support fancy reprs with lazy attrs"""
+    f = HTMLFormatter()
+    cfg = Config()
+    with capture_output() as captured:
+        result = f(cfg)
+    assert result is None
+    assert captured.stderr == ""
+
+    with capture_output() as captured:
+        result = f(Config)
+    assert result is None
+    assert captured.stderr == ""
+
+
+def test_pretty_max_seq_length():
+    f = PlainTextFormatter(max_seq_length=1)
+    lis = list(range(3))
+    text = f(lis)
+    assert text == "[0, ...]"
+    f.max_seq_length = 0
+    text = f(lis)
+    assert text == "[0, 1, 2]"
+    text = f(list(range(1024)))
+    lines = text.splitlines()
+    assert len(lines) == 1024
+
+
+def test_ipython_display_formatter():
+    """Objects with _ipython_display_ defined bypass other formatters"""
+    f = get_ipython().display_formatter
+    catcher = []
+
+    class SelfDisplaying(object):
+        def _ipython_display_(self):
+            catcher.append(self)
+
+    class NotSelfDisplaying(object):
+        def __repr__(self):
+            return "NotSelfDisplaying"
+
+        def _ipython_display_(self):
+            raise NotImplementedError
+
+    save_enabled = f.ipython_display_formatter.enabled
+    f.ipython_display_formatter.enabled = True
+
+    yes = SelfDisplaying()
+    no = NotSelfDisplaying()
+
+    d, md = f.format(no)
+    assert d == {"text/plain": repr(no)}
+    assert md == {}
+    assert catcher == []
+
+    d, md = f.format(yes)
+    assert d == {}
+    assert md == {}
+    assert catcher == [yes]
+
+    f.ipython_display_formatter.enabled = save_enabled
+
+
+def test_repr_mime():
+    class HasReprMime(object):
+        def _repr_mimebundle_(self, include=None, exclude=None):
+            return {
+                "application/json+test.v2": {"x": "y"},
+                "plain/text": "<HasReprMime>",
+                "image/png": "i-overwrite",
+            }
+
+        def _repr_png_(self):
+            return "should-be-overwritten"
+
+        def _repr_html_(self):
+            return "<b>hi!</b>"
+
+    f = get_ipython().display_formatter
+    html_f = f.formatters["text/html"]
+    save_enabled = html_f.enabled
+    html_f.enabled = True
+    obj = HasReprMime()
+    d, md = f.format(obj)
+    html_f.enabled = save_enabled
+
+    assert sorted(d) == [
+        "application/json+test.v2",
+        "image/png",
+        "plain/text",
+        "text/html",
+        "text/plain",
+    ]
+    assert md == {}
+
+    d, md = f.format(obj, include={"image/png"})
+    assert list(d.keys()) == [
+        "image/png"
+    ], "Include should filter out even things from repr_mimebundle"
+
+    assert d["image/png"] == "i-overwrite", "_repr_mimebundle_ take precedence"
+
+
+def test_pass_correct_include_exclude():
+    class Tester(object):
+        def __init__(self, include=None, exclude=None):
+            self.include = include
+            self.exclude = exclude
+
+        def _repr_mimebundle_(self, include, exclude, **kwargs):
+            if include and (include != self.include):
+                raise ValueError("include got modified: display() may be broken.")
+            if exclude and (exclude != self.exclude):
+                raise ValueError("exclude got modified: display() may be broken.")
+
+            return None
+
+    include = {"a", "b", "c"}
+    exclude = {"c", "e", "f"}
+
+    f = get_ipython().display_formatter
+    f.format(Tester(include=include, exclude=exclude), include=include, exclude=exclude)
+    f.format(Tester(exclude=exclude), exclude=exclude)
+    f.format(Tester(include=include), include=include)
+
+
+def test_repr_mime_meta():
+    class HasReprMimeMeta(object):
+        def _repr_mimebundle_(self, include=None, exclude=None):
+            data = {
+                "image/png": "base64-image-data",
+            }
+            metadata = {
+                "image/png": {
+                    "width": 5,
+                    "height": 10,
+                }
+            }
+            return (data, metadata)
+
+    f = get_ipython().display_formatter
+    obj = HasReprMimeMeta()
+    d, md = f.format(obj)
+    assert sorted(d) == ["image/png", "text/plain"]
+    assert md == {
+        "image/png": {
+            "width": 5,
+            "height": 10,
+        }
+    }
+
+
+def test_repr_mime_failure():
+    class BadReprMime(object):
+        def _repr_mimebundle_(self, include=None, exclude=None):
+            raise RuntimeError
+
+    f = get_ipython().display_formatter
+    obj = BadReprMime()
+    d, md = f.format(obj)
+    assert "text/plain" in d
+
+
+def test_custom_repr_namedtuple_partialmethod():
+    from functools import partialmethod
+    from typing import NamedTuple
+
+    class Foo(NamedTuple):
+        ...
+
+    Foo.__repr__ = partialmethod(lambda obj: "Hello World")
+    foo = Foo()
+
+    f = PlainTextFormatter()
+    assert f.pprint
+    assert f(foo) == "Hello World"
diff --git a/tests/test_guarded_eval.py b/tests/test_guarded_eval.py
new file mode 100644
index 00000000000..01869000946
--- /dev/null
+++ b/tests/test_guarded_eval.py
@@ -0,0 +1,1028 @@
+import sys
+from contextlib import contextmanager
+from importlib import import_module
+from typing import (
+    Annotated,
+    AnyStr,
+    NamedTuple,
+    Literal,
+    NewType,
+    Optional,
+    Protocol,
+    TypeGuard,
+    Union,
+    TypedDict,
+    TypeVar,
+    List,
+    Callable,
+    Any,
+    Dict,
+)
+from functools import partial
+from IPython.core.guarded_eval import (
+    EvaluationContext,
+    GuardRejection,
+    guarded_eval,
+    _unbind_method,
+)
+from IPython.testing import decorators as dec
+import pytest
+from IPython.core.guarded_eval import _is_type_annotation
+
+
+from typing import Self, LiteralString
+
+from typing import TypeAliasType
+
+
+def create_context(evaluation: str, **kwargs):
+    return EvaluationContext(locals=kwargs, globals={}, evaluation=evaluation)
+
+
+forbidden = partial(create_context, "forbidden")
+minimal = partial(create_context, "minimal")
+limited = partial(create_context, "limited")
+unsafe = partial(create_context, "unsafe")
+dangerous = partial(create_context, "dangerous")
+
+LIMITED_OR_HIGHER = [limited, unsafe, dangerous]
+MINIMAL_OR_HIGHER = [minimal, *LIMITED_OR_HIGHER]
+
+
+@contextmanager
+def module_not_installed(module: str):
+    import sys
+
+    try:
+        to_restore = sys.modules[module]
+        del sys.modules[module]
+    except KeyError:
+        to_restore = None
+    try:
+        yield
+    finally:
+        sys.modules[module] = to_restore
+
+
+def test_external_not_installed():
+    """
+    Because attribute check requires checking if object is not of allowed
+    external type, this tests logic for absence of external module.
+    """
+
+    class Custom:
+        def __init__(self):
+            self.test = 1
+
+        def __getattr__(self, key):
+            return key
+
+    with module_not_installed("pandas"):
+        context = limited(x=Custom())
+        with pytest.raises(GuardRejection):
+            guarded_eval("x.test", context)
+
+
+@dec.skip_without("pandas")
+def test_external_changed_api(monkeypatch):
+    """Check that the execution rejects if external API changed paths"""
+    import pandas as pd
+
+    series = pd.Series([1], index=["a"])
+
+    with monkeypatch.context() as m:
+        m.delattr(pd, "Series")
+        context = limited(data=series)
+        with pytest.raises(GuardRejection):
+            guarded_eval("data.iloc[0]", context)
+
+
+@dec.skip_without("pandas")
+def test_pandas_series_iloc():
+    import pandas as pd
+
+    series = pd.Series([1], index=["a"])
+    context = limited(data=series)
+    assert guarded_eval("data.iloc[0]", context) == 1
+
+
+def test_rejects_custom_properties():
+    class BadProperty:
+        @property
+        def iloc(self):
+            return [None]
+
+    series = BadProperty()
+    context = limited(data=series)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("data.iloc[0]", context)
+
+
+@dec.skip_without("pandas")
+def test_accepts_non_overriden_properties():
+    import pandas as pd
+
+    class GoodProperty(pd.Series):
+        pass
+
+    series = GoodProperty([1], index=["a"])
+    context = limited(data=series)
+
+    assert guarded_eval("data.iloc[0]", context) == 1
+
+
+@dec.skip_without("pandas")
+def test_pandas_series():
+    import pandas as pd
+
+    context = limited(data=pd.Series([1], index=["a"]))
+    assert guarded_eval('data["a"]', context) == 1
+    with pytest.raises(KeyError):
+        guarded_eval('data["c"]', context)
+
+
+@dec.skip_without("pandas")
+def test_pandas_bad_series():
+    import pandas as pd
+
+    class BadItemSeries(pd.Series):
+        def __getitem__(self, key):
+            return "CUSTOM_ITEM"
+
+    class BadAttrSeries(pd.Series):
+        def __getattr__(self, key):
+            return "CUSTOM_ATTR"
+
+    bad_series = BadItemSeries([1], index=["a"])
+    context = limited(data=bad_series)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval('data["a"]', context)
+    with pytest.raises(GuardRejection):
+        guarded_eval('data["c"]', context)
+
+    # note: here result is a bit unexpected because
+    # pandas `__getattr__` calls `__getitem__`;
+    # FIXME - special case to handle it?
+    assert guarded_eval("data.a", context) == "CUSTOM_ITEM"
+
+    context = unsafe(data=bad_series)
+    assert guarded_eval('data["a"]', context) == "CUSTOM_ITEM"
+
+    bad_attr_series = BadAttrSeries([1], index=["a"])
+    context = limited(data=bad_attr_series)
+    assert guarded_eval('data["a"]', context) == 1
+    with pytest.raises(GuardRejection):
+        guarded_eval("data.a", context)
+
+
+@dec.skip_without("pandas")
+def test_pandas_dataframe_loc():
+    import pandas as pd
+    from pandas.testing import assert_series_equal
+
+    data = pd.DataFrame([{"a": 1}])
+    context = limited(data=data)
+    assert_series_equal(guarded_eval('data.loc[:, "a"]', context), data["a"])
+
+
+def test_named_tuple():
+    class GoodNamedTuple(NamedTuple):
+        a: str
+        pass
+
+    class BadNamedTuple(NamedTuple):
+        a: str
+
+        def __getitem__(self, key):
+            return None
+
+    good = GoodNamedTuple(a="x")
+    bad = BadNamedTuple(a="x")
+
+    context = limited(data=good)
+    assert guarded_eval("data[0]", context) == "x"
+
+    context = limited(data=bad)
+    with pytest.raises(GuardRejection):
+        guarded_eval("data[0]", context)
+
+
+def test_dict():
+    context = limited(data={"a": 1, "b": {"x": 2}, ("x", "y"): 3})
+    assert guarded_eval('data["a"]', context) == 1
+    assert guarded_eval('data["b"]', context) == {"x": 2}
+    assert guarded_eval('data["b"]["x"]', context) == 2
+    assert guarded_eval('data["x", "y"]', context) == 3
+
+    assert guarded_eval("data.keys", context)
+
+
+def test_set():
+    context = limited(data={"a", "b"})
+    assert guarded_eval("data.difference", context)
+
+
+def test_list():
+    context = limited(data=[1, 2, 3])
+    assert guarded_eval("data[1]", context) == 2
+    assert guarded_eval("data.copy", context)
+
+
+def test_dict_literal():
+    context = limited()
+    assert guarded_eval("{}", context) == {}
+    assert guarded_eval('{"a": 1}', context) == {"a": 1}
+
+
+def test_list_literal():
+    context = limited()
+    assert guarded_eval("[]", context) == []
+    assert guarded_eval('[1, "a"]', context) == [1, "a"]
+
+
+def test_set_literal():
+    context = limited()
+    assert guarded_eval("set()", context) == set()
+    assert guarded_eval('{"a"}', context) == {"a"}
+
+
+def test_evaluates_if_expression():
+    context = limited()
+    assert guarded_eval("2 if True else 3", context) == 2
+    assert guarded_eval("4 if False else 5", context) == 5
+
+
+def test_object():
+    obj = object()
+    context = limited(obj=obj)
+    assert guarded_eval("obj.__dir__", context) == obj.__dir__
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["int.numerator", int.numerator],
+        ["float.is_integer", float.is_integer],
+        ["complex.real", complex.real],
+    ],
+)
+def test_number_attributes(code, expected):
+    assert guarded_eval(code, limited()) == expected
+
+
+def test_method_descriptor():
+    context = limited()
+    assert guarded_eval("list.copy.__name__", context) == "copy"
+
+
+class HeapType:
+    pass
+
+
+class CallCreatesHeapType:
+    def __call__(self) -> HeapType:
+        return HeapType()
+
+
+class CallCreatesBuiltin:
+    def __call__(self) -> frozenset:
+        return frozenset()
+
+
+class HasStaticMethod:
+    @staticmethod
+    def static_method() -> HeapType:
+        return HeapType()
+
+
+class InitReturnsFrozenset:
+    def __new__(self) -> frozenset:  # type:ignore[misc]
+        return frozenset()
+
+
+class StringAnnotation:
+    def heap(self) -> "HeapType":
+        return HeapType()
+
+    def copy(self) -> "StringAnnotation":
+        return StringAnnotation()
+
+
+CustomIntType = NewType("CustomIntType", int)
+CustomHeapType = NewType("CustomHeapType", HeapType)
+IntTypeAlias = TypeAliasType("IntTypeAlias", int)
+HeapTypeAlias = TypeAliasType("HeapTypeAlias", HeapType)
+
+
+class ProtocolTest(Protocol):
+    def test_method(self) -> bool:
+        pass
+
+
+class ProtocolTestImplementer(ProtocolTest):
+    def test_method(self) -> bool:
+        return True
+
+
+class TypedClass:
+    def test_method(self) -> bool:
+        return True
+
+
+class Movie(TypedDict):
+    name: str
+    year: int
+
+
+class SpecialTyping:
+    def custom_int_type(self) -> CustomIntType:
+        return CustomIntType(1)
+
+    def custom_heap_type(self) -> CustomHeapType:
+        return CustomHeapType(HeapType())
+
+    def int_type_alias(self) -> IntTypeAlias:
+        return 1
+
+    def heap_type_alias(self) -> HeapTypeAlias:
+        return 1
+
+    def literal(self) -> Literal[False]:
+        return False
+
+    def literal_string(self) -> LiteralString:
+        return "test"
+
+    def self(self) -> Self:
+        return self
+
+    def any_str(self, x: AnyStr) -> AnyStr:
+        return x
+
+    def with_kwargs(self, a=1, b=2, c=3) -> int:
+        return a + b + c
+
+    def annotated(self) -> Annotated[float, "positive number"]:
+        return 1
+
+    def annotated_self(self) -> Annotated[Self, "self with metadata"]:
+        self._metadata = "test"
+        return self
+
+    def int_type_guard(self, x) -> TypeGuard[int]:
+        return isinstance(x, int)
+
+    def optional_float(self) -> Optional[float]:
+        return 1.0
+
+    def union_str_and_int(self) -> Union[str, int]:
+        return ""
+
+    def protocol(self) -> ProtocolTest:
+        return ProtocolTestImplementer()
+
+    def typed_dict(self) -> Movie:
+        return {"name": "The Matrix", "year": 1999}
+
+
+@pytest.mark.parametrize(
+    "data,code,expected,equality",
+    [
+        [[1, 2, 3], "data.index(2)", 1, True],
+        [{"a": 1}, "data.keys().isdisjoint({})", True, True],
+        [StringAnnotation(), "data.heap()", HeapType, False],
+        [StringAnnotation(), "data.copy()", StringAnnotation, False],
+        # test cases for `__call__`
+        [CallCreatesHeapType(), "data()", HeapType, False],
+        [CallCreatesBuiltin(), "data()", frozenset, False],
+        # Test cases for `__init__`
+        [HeapType, "data()", HeapType, False],
+        [InitReturnsFrozenset, "data()", frozenset, False],
+        [HeapType(), "data.__class__()", HeapType, False],
+        # supported special cases for typing
+        [SpecialTyping(), "data.custom_int_type()", int, False],
+        [SpecialTyping(), "data.custom_heap_type()", HeapType, False],
+        [SpecialTyping(), "data.int_type_alias()", int, False],
+        [SpecialTyping(), "data.heap_type_alias()", HeapType, False],
+        [SpecialTyping(), "data.self()", SpecialTyping, False],
+        [SpecialTyping(), "data.literal()", False, True],
+        [SpecialTyping(), "data.literal_string()", str, False],
+        [SpecialTyping(), "data.any_str('a')", str, False],
+        [SpecialTyping(), "data.any_str(b'a')", bytes, False],
+        [SpecialTyping(), "data.with_kwargs(b=3)", int, False],
+        [SpecialTyping(), "data.annotated()", float, False],
+        [SpecialTyping(), "data.annotated_self()", SpecialTyping, False],
+        [SpecialTyping(), "data.int_type_guard()", int, False],
+        # test cases for static methods
+        [HasStaticMethod, "data.static_method()", HeapType, False],
+    ],
+)
+def test_evaluates_calls(data, code, expected, equality):
+    context = limited(data=data, HeapType=HeapType, StringAnnotation=StringAnnotation)
+    value = guarded_eval(code, context)
+    if equality:
+        assert value == expected
+    else:
+        assert isinstance(value, expected)
+
+
+@pytest.mark.parametrize(
+    "data,code,expected_attributes",
+    [
+        [SpecialTyping(), "data.optional_float()", ["is_integer"]],
+        [
+            SpecialTyping(),
+            "data.union_str_and_int()",
+            ["capitalize", "as_integer_ratio"],
+        ],
+        [SpecialTyping(), "data.protocol()", ["test_method"]],
+        [SpecialTyping(), "data.typed_dict()", ["keys", "values", "items"]],
+    ],
+)
+def test_mocks_attributes_of_call_results(data, code, expected_attributes):
+    context = limited(data=data, HeapType=HeapType, StringAnnotation=StringAnnotation)
+    result = guarded_eval(code, context)
+    for attr in expected_attributes:
+        assert hasattr(result, attr)
+        assert attr in dir(result)
+
+
+@pytest.mark.parametrize(
+    "data,code,expected_items",
+    [
+        [SpecialTyping(), "data.typed_dict()", {"year": int, "name": str}],
+    ],
+)
+def test_mocks_items_of_call_results(data, code, expected_items):
+    context = limited(data=data, HeapType=HeapType, StringAnnotation=StringAnnotation)
+    result = guarded_eval(code, context)
+    ipython_keys = result._ipython_key_completions_()
+    for key, value in expected_items.items():
+        assert isinstance(result[key], value)
+        assert key in ipython_keys
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["\n".join(["instance = TypedClass()", "instance.test_method()"]), bool],
+        ["\n".join(["def func() -> int:", "    pass", "func()"]), int],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def method(self) -> str:",
+                    "        pass",
+                    "instance = NotYetDefined()",
+                    "instance.method()",
+                ]
+            ),
+            str,
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def method(self, argument) -> int:",
+                    "        pass",
+                    "instance = NotYetDefined()",
+                    "instance.method()",
+                ]
+            ),
+            int,
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    @property",
+                    "    def my_prop(self) -> int:",
+                    "        pass",
+                    "instance = NotYetDefined()",
+                    "instance.my_prop",
+                ]
+            ),
+            int,
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    @unkown_decorator",
+                    "    @property",
+                    "    def my_prop(self) -> int:",
+                    "        pass",
+                    "instance = NotYetDefined()",
+                    "instance.my_prop",
+                ]
+            ),
+            int,
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    attribute = 42",
+                    "instance = NotYetDefined()",
+                    "instance.attribute",
+                ]
+            ),
+            int,
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def any_str(self, argument: AnyStr) -> AnyStr:",
+                    "        pass",
+                    "instance = NotYetDefined()",
+                    "instance.any_str(b'test')",
+                ]
+            ),
+            bytes,
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def any_str(self, argument: AnyStr) -> AnyStr:",
+                    "        pass",
+                    "instance = NotYetDefined()",
+                    "instance.any_str('test')",
+                ]
+            ),
+            str,
+        ],
+        [
+            "\n".join(
+                [
+                    "async def async_func():",
+                    "    return []",
+                    "(await async_func())",
+                ]
+            ),
+            list,
+        ],
+        [
+            "\n".join(
+                [
+                    "make_list = lambda:[]",
+                    "make_list()",
+                ]
+            ),
+            list,
+        ],
+    ],
+)
+def test_mock_class_and_func_instances(code, expected):
+    context = limited(TypedClass=TypedClass, AnyStr=AnyStr)
+    value = guarded_eval(code, context)
+    assert isinstance(value, expected)
+
+
+@pytest.mark.parametrize(
+    "annotation,expected",
+    [
+        # Basic types
+        (int, True),
+        (str, True),
+        (list, True),
+        # Typing generics
+        (list[str], True),
+        (dict[str, int], True),
+        (Optional[int], True),
+        (Union[int, str], True),
+        # Special forms
+        (AnyStr, True),
+        (TypeVar("T"), True),
+        (Callable[[int], str], True),
+        (Literal["GET", "POST"], True),
+        (Any, True),
+        (str | int, True),
+        # Nested
+        (List[Dict[str, int]], True),
+        # Non-annotations
+        (42, False),
+        ("string", False),
+        ([1, 2, 3], False),
+        (None, False),
+    ],
+)
+def test_is_type_annotation(annotation, expected):
+    assert _is_type_annotation(annotation) == expected
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["\n".join(["a = True", "a"]), bool],
+        ["\n".join(["a, b, c = 1, 'b', 3.0", "a"]), int],
+        ["\n".join(["a, b, c = 1, 'b', 3.0", "b"]), str],
+        ["\n".join(["a, b, c = 1, 'b', 3.0", "c"]), float],
+        ["\n".join(["a, *rest = 1, 'b', 3.0", "a"]), int],
+        ["\n".join(["a, *rest = 1, 'b', 3.0", "rest"]), list],
+    ],
+)
+def test_evaluates_assignments(code, expected):
+    context = limited()
+    value = guarded_eval(code, context)
+    assert isinstance(value, expected)
+
+
+def equals(a, b):
+    return a == b
+
+
+def quacks_like(test_duck, reference_duck):
+    return set(dir(reference_duck)) - set(dir(test_duck)) == set()
+
+
+@pytest.mark.parametrize(
+    "code,expected,check",
+    [
+        ["\n".join(["a: Literal[True]", "a"]), True, equals],
+        ["\n".join(["a: bool", "a"]), bool, isinstance],
+        ["\n".join(["a: str", "a"]), str, isinstance],
+        # for lists we need quacking as we do not know:
+        # - how many elements in the list
+        # - which element is of which type
+        ["\n".join(["a: list[str]", "a"]), list, quacks_like],
+        ["\n".join(["a: list[str]", "a[0]"]), str, quacks_like],
+        ["\n".join(["a: list[str]", "a[999]"]), str, quacks_like],
+        # set
+        ["\n".join(["a: set[str]", "a"]), set, quacks_like],
+        # for tuples we do know which element is which
+        ["\n".join(["a: tuple[str, int]", "a"]), tuple, isinstance],
+        ["\n".join(["a: tuple[str, int]", "a[0]"]), str, isinstance],
+        ["\n".join(["a: tuple[str, int]", "a[1]"]), int, isinstance],
+    ],
+)
+def test_evaluates_type_assignments(code, expected, check):
+    context = limited(Literal=Literal)
+    value = guarded_eval(code, context)
+    assert check(value, expected)
+
+
+@pytest.mark.parametrize(
+    "data,bad",
+    [
+        [[1, 2, 3], "data.append(4)"],
+        [{"a": 1}, "data.update()"],
+    ],
+)
+def test_rejects_calls_with_side_effects(data, bad):
+    context = limited(data=data)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval(bad, context)
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["(1\n+\n1)", 2],
+        ["list(range(10))[-1:]", [9]],
+        ["list(range(20))[3:-2:3]", [3, 6, 9, 12, 15]],
+    ],
+)
+@pytest.mark.parametrize("context", LIMITED_OR_HIGHER)
+def test_evaluates_complex_cases(code, expected, context):
+    assert guarded_eval(code, context()) == expected
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["1", 1],
+        ["1.0", 1.0],
+        ["0xdeedbeef", 0xDEEDBEEF],
+        ["True", True],
+        ["None", None],
+        ["{}", {}],
+        ["[]", []],
+    ],
+)
+@pytest.mark.parametrize("context", MINIMAL_OR_HIGHER)
+def test_evaluates_literals(code, expected, context):
+    assert guarded_eval(code, context()) == expected
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["-5", -5],
+        ["+5", +5],
+        ["~5", -6],
+    ],
+)
+@pytest.mark.parametrize("context", LIMITED_OR_HIGHER)
+def test_evaluates_unary_operations(code, expected, context):
+    assert guarded_eval(code, context()) == expected
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["1 + 1", 2],
+        ["3 - 1", 2],
+        ["2 * 3", 6],
+        ["5 // 2", 2],
+        ["5 / 2", 2.5],
+        ["5**2", 25],
+        ["2 >> 1", 1],
+        ["2 << 1", 4],
+        ["1 | 2", 3],
+        ["1 & 1", 1],
+        ["1 & 2", 0],
+    ],
+)
+@pytest.mark.parametrize("context", LIMITED_OR_HIGHER)
+def test_evaluates_binary_operations(code, expected, context):
+    assert guarded_eval(code, context()) == expected
+
+
+@pytest.mark.parametrize(
+    "code,expected",
+    [
+        ["2 > 1", True],
+        ["2 < 1", False],
+        ["2 <= 1", False],
+        ["2 <= 2", True],
+        ["1 >= 2", False],
+        ["2 >= 2", True],
+        ["2 == 2", True],
+        ["1 == 2", False],
+        ["1 != 2", True],
+        ["1 != 1", False],
+        ["1 < 4 < 3", False],
+        ["(1 < 4) < 3", True],
+        ["4 > 3 > 2 > 1", True],
+        ["4 > 3 > 2 > 9", False],
+        ["1 < 2 < 3 < 4", True],
+        ["9 < 2 < 3 < 4", False],
+        ["1 < 2 > 1 > 0 > -1 < 1", True],
+        ["1 in [1] in [[1]]", True],
+        ["1 in [1] in [[2]]", False],
+        ["1 in [1]", True],
+        ["0 in [1]", False],
+        ["1 not in [1]", False],
+        ["0 not in [1]", True],
+        ["True is True", True],
+        ["False is False", True],
+        ["True is False", False],
+        ["True is not True", False],
+        ["False is not True", True],
+    ],
+)
+@pytest.mark.parametrize("context", LIMITED_OR_HIGHER)
+def test_evaluates_comparisons(code, expected, context):
+    assert guarded_eval(code, context()) == expected
+
+
+def test_guards_comparisons():
+    class GoodEq(int):
+        pass
+
+    class BadEq(int):
+        def __eq__(self, other):
+            assert False
+
+    context = limited(bad=BadEq(1), good=GoodEq(1))
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("bad == 1", context)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("bad != 1", context)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("1 == bad", context)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("1 != bad", context)
+
+    assert guarded_eval("good == 1", context) is True
+    assert guarded_eval("good != 1", context) is False
+    assert guarded_eval("1 == good", context) is True
+    assert guarded_eval("1 != good", context) is False
+
+
+def test_guards_unary_operations():
+    class GoodOp(int):
+        pass
+
+    class BadOpInv(int):
+        def __inv__(self, other):
+            assert False
+
+    class BadOpInverse(int):
+        def __inv__(self, other):
+            assert False
+
+    context = limited(good=GoodOp(1), bad1=BadOpInv(1), bad2=BadOpInverse(1))
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("~bad1", context)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("~bad2", context)
+
+
+def test_guards_binary_operations():
+    class GoodOp(int):
+        pass
+
+    class BadOp(int):
+        def __add__(self, other):
+            assert False
+
+    context = limited(good=GoodOp(1), bad=BadOp(1))
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("1 + bad", context)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("bad + 1", context)
+
+    assert guarded_eval("good + 1", context) == 2
+    assert guarded_eval("1 + good", context) == 2
+
+
+def test_guards_attributes():
+    class GoodAttr(float):
+        pass
+
+    class BadAttr1(float):
+        def __getattr__(self, key):
+            assert False
+
+    class BadAttr2(float):
+        def __getattribute__(self, key):
+            assert False
+
+    context = limited(good=GoodAttr(0.5), bad1=BadAttr1(0.5), bad2=BadAttr2(0.5))
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("bad1.as_integer_ratio", context)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("bad2.as_integer_ratio", context)
+
+    assert guarded_eval("good.as_integer_ratio()", context) == (1, 2)
+
+
+@pytest.mark.parametrize("context", MINIMAL_OR_HIGHER)
+def test_access_builtins(context):
+    assert guarded_eval("round", context()) == round
+
+
+def test_access_builtins_fails():
+    context = limited()
+    with pytest.raises(NameError):
+        guarded_eval("this_is_not_builtin", context)
+
+
+def test_rejects_forbidden():
+    context = forbidden()
+    with pytest.raises(GuardRejection):
+        guarded_eval("1", context)
+
+
+def test_guards_locals_and_globals():
+    context = EvaluationContext(
+        locals={"local_a": "a"}, globals={"global_b": "b"}, evaluation="minimal"
+    )
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("local_a", context)
+
+    with pytest.raises(GuardRejection):
+        guarded_eval("global_b", context)
+
+
+def test_access_locals_and_globals():
+    context = EvaluationContext(
+        locals={"local_a": "a"}, globals={"global_b": "b"}, evaluation="limited"
+    )
+    assert guarded_eval("local_a", context) == "a"
+    assert guarded_eval("global_b", context) == "b"
+
+
+@pytest.mark.parametrize(
+    "code",
+    ["x += 1", "del x"],
+)
+@pytest.mark.parametrize("context", [minimal(x=1), limited(x=1), unsafe(x=1)])
+def test_does_not_modify_namespace(code, context):
+    guarded_eval(code, context)
+    assert context.locals["x"] == 1
+
+
+@pytest.mark.parametrize(
+    "code",
+    ["def test(): pass", "class test: pass", "import ast as test"],
+)
+@pytest.mark.parametrize("context", [minimal(), limited(), unsafe()])
+def test_does_not_populate_namespace(code, context):
+    guarded_eval(code, context)
+    assert "test" not in context.locals
+    assert "test" not in context.globals
+
+
+def test_subscript():
+    context = EvaluationContext(
+        locals={}, globals={}, evaluation="limited", in_subscript=True
+    )
+    empty_slice = slice(None, None, None)
+    assert guarded_eval("", context) == tuple()
+    assert guarded_eval(":", context) == empty_slice
+    assert guarded_eval("1:2:3", context) == slice(1, 2, 3)
+    assert guarded_eval(':, "a"', context) == (empty_slice, "a")
+
+
+def test_unbind_method():
+    class X(list):
+        def index(self, k):
+            return "CUSTOM"
+
+    x = X()
+    assert _unbind_method(x.index) is X.index
+    assert _unbind_method([].index) is list.index
+    assert _unbind_method(list.index) is None
+
+
+def test_assumption_instance_attr_do_not_matter():
+    """This is semi-specified in Python documentation.
+
+    However, since the specification says 'not guaranteed
+    to work' rather than 'is forbidden to work', future
+    versions could invalidate this assumptions. This test
+    is meant to catch such a change if it ever comes true.
+    """
+
+    class T:
+        def __getitem__(self, k):
+            return "a"
+
+        def __getattr__(self, k):
+            return "a"
+
+    def f(self):
+        return "b"
+
+    t = T()
+    t.__getitem__ = f
+    t.__getattr__ = f
+    assert t[1] == "a"
+    assert t[1] == "a"
+
+
+def test_assumption_named_tuples_share_getitem():
+    """Check assumption on named tuples sharing __getitem__"""
+    from typing import NamedTuple
+
+    class A(NamedTuple):
+        pass
+
+    class B(NamedTuple):
+        pass
+
+    assert A.__getitem__ == B.__getitem__
+
+
+@dec.skip_without("numpy")
+def test_module_access():
+    import numpy
+
+    context = limited(numpy=numpy)
+    assert guarded_eval("numpy.linalg.norm", context) == numpy.linalg.norm
+
+    context = minimal(numpy=numpy)
+    with pytest.raises(GuardRejection):
+        guarded_eval("np.linalg.norm", context)
+
+
+def test_autoimport_module():
+    context = EvaluationContext(
+        locals={},
+        globals={},
+        evaluation="limited",
+        auto_import=import_module,
+        policy_overrides={"allow_auto_import": True},
+    )
+    pi = guarded_eval("math.pi", context)
+    assert round(pi, 2) == 3.14
+
+
+def test_autoimport_deep_module():
+    context = EvaluationContext(
+        locals={},
+        globals={},
+        evaluation="limited",
+        auto_import=import_module,
+        policy_overrides={"allow_auto_import": True},
+    )
+    ElementTree = guarded_eval("xml.etree.ElementTree", context)
+    assert hasattr(ElementTree, "ElementTree")
diff --git a/tests/test_handlers.py b/tests/test_handlers.py
new file mode 100644
index 00000000000..3958872c1ce
--- /dev/null
+++ b/tests/test_handlers.py
@@ -0,0 +1,79 @@
+"""Tests for input handlers."""
+
+# -----------------------------------------------------------------------------
+# Module imports
+# -----------------------------------------------------------------------------
+
+# our own packages
+from IPython.core import autocall
+from IPython.testing import tools as tt
+import pytest
+from collections.abc import Callable
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+
+# Test functions
+# -----------------------------------------------------------------------------
+
+
+class CallableIndexable(object):
+    def __getitem__(self, idx):
+        return True
+
+    def __call__(self, *args, **kws):
+        return True
+
+
+class Autocallable(autocall.IPyAutocall):
+    def __call__(self):
+        return "called"
+
+
+@pytest.mark.parametrize(
+    "autocall, input, output",
+    [
+        # For many of the below, we're also checking that leading whitespace
+        # turns off the esc char, which it should unless there is a continuation
+        # line.
+        ("1", '"no change"', '"no change"'),  # normal
+        ("1", "lsmagic", "get_ipython().run_line_magic('lsmagic', '')"),  # magic
+        # Only explicit escapes or instances of IPyAutocallable should get
+        # expanded
+        ("0", 'len "abc"', 'len "abc"'),
+        ("0", "autocallable", "autocallable()"),
+        # Don't add extra brackets (gh-1117)
+        ("0", "autocallable()", "autocallable()"),
+        ("1", 'len "abc"', 'len("abc")'),
+        ("1", 'len "abc";', 'len("abc");'),  # ; is special -- moves out of parens
+        # Autocall is turned off if first arg is [] and the object
+        # is both callable and indexable.  Like so:
+        ("1", "len [1,2]", "len([1,2])"),  # len doesn't support __getitem__...
+        ("1", "call_idx [1]", "call_idx [1]"),  # call_idx *does*..
+        ("1", "call_idx 1", "call_idx(1)"),
+        ("1", "len", "len"),  # only at 2 does it auto-call on single args
+        ("2", 'len "abc"', 'len("abc")'),
+        ("2", 'len "abc";', 'len("abc");'),
+        ("2", "len [1,2]", "len([1,2])"),
+        ("2", "call_idx [1]", "call_idx [1]"),
+        ("2", "call_idx 1", "call_idx(1)"),
+        # T his is what's different:
+        ("2", "len", "len()"),  # only at 2 does it auto-call on single args
+        ("0", "Callable[[int], None]", "Callable[[int], None]"),
+        ("1", "Callable[[int], None]", "Callable[[int], None]"),
+        ("1", "Callable[[int], None]", "Callable[[int], None]"),
+    ],
+)
+def test_handlers_I(autocall, input, output):
+    autocallable = Autocallable()
+    ip.user_ns["autocallable"] = autocallable
+
+    call_idx = CallableIndexable()
+    ip.user_ns["call_idx"] = call_idx
+
+    ip.user_ns["Callable"] = Callable
+
+    ip.run_line_magic("autocall", autocall)
+    assert ip.prefilter_manager.prefilter_lines(input) == output
+    ip.run_line_magic("autocall", "1")
diff --git a/tests/test_help.py b/tests/test_help.py
new file mode 100644
index 00000000000..3937edb22ec
--- /dev/null
+++ b/tests/test_help.py
@@ -0,0 +1,36 @@
+"""Test help output of various IPython entry points"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import pytest
+import IPython.testing.tools as tt
+
+
+def test_ipython_help():
+    tt.help_all_output_test()
+
+
+def test_profile_help():
+    tt.help_all_output_test("profile")
+
+
+def test_profile_list_help():
+    tt.help_all_output_test("profile list")
+
+
+def test_profile_create_help():
+    tt.help_all_output_test("profile create")
+
+
+def test_locate_help():
+    tt.help_all_output_test("locate")
+
+
+def test_locate_profile_help():
+    tt.help_all_output_test("locate profile")
+
+
+def test_trust_help():
+    pytest.importorskip("nbformat")
+    tt.help_all_output_test("trust")
diff --git a/tests/test_history.py b/tests/test_history.py
new file mode 100644
index 00000000000..afe625682b5
--- /dev/null
+++ b/tests/test_history.py
@@ -0,0 +1,403 @@
+# coding: utf-8
+"""Tests for the IPython tab-completion machinery."""
+# -----------------------------------------------------------------------------
+# Module imports
+# -----------------------------------------------------------------------------
+
+# stdlib
+import io
+import gc
+import os
+import sys
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+from tempfile import TemporaryDirectory
+
+# our own packages
+from traitlets.config.loader import Config
+
+from IPython.core.history import HistoryAccessor, HistoryManager, extract_hist_ranges
+
+import pytest
+
+
+def test_proper_default_encoding():
+    assert sys.getdefaultencoding() == "utf-8"
+
+
+def hmmax_instance_maker(N: int):
+    if os.name == "nt":
+
+        @pytest.fixture()
+        def inner():
+            pass
+
+    else:
+
+        @pytest.fixture()
+        def inner():
+            assert HistoryManager._max_inst == 1
+            HistoryManager._max_inst = N
+            lh = len(HistoryManager._instances)
+            try:
+                yield
+                gc.collect()
+                assert len(HistoryManager._instances) == lh
+            finally:
+                HistoryManager._max_inst = 1
+
+    return inner
+
+
+hmmax2 = hmmax_instance_maker(2)
+hmmax3 = hmmax_instance_maker(3)
+
+
+def test_history(hmmax2):
+    ip = get_ipython()
+    with TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        hist_manager_ori = ip.history_manager
+        hist_file = tmp_path / "history_test_history1.sqlite"
+        try:
+            ip.history_manager = HistoryManager(shell=ip, hist_file=hist_file)
+            hist = ["a=1", "def f():\n    test = 1\n    return test", "b='€Æ¾÷ß'"]
+            for i, h in enumerate(hist, start=1):
+                ip.history_manager.store_inputs(i, h)
+
+            ip.history_manager.db_log_output = True
+            # Doesn't match the input, but we'll just check it's stored.
+            ip.history_manager.output_hist_reprs[3] = "spam"
+            ip.history_manager.store_output(3)
+
+            assert ip.history_manager.input_hist_raw == [""] + hist
+
+            # Detailed tests for _get_range_session
+            grs = ip.history_manager._get_range_session
+            assert list(grs(start=2, stop=-1)) == list(zip([0], [2], hist[1:-1]))
+            assert list(grs(start=-2)) == list(zip([0, 0], [2, 3], hist[-2:]))
+            assert list(grs(output=True)) == list(
+                zip([0, 0, 0], [1, 2, 3], zip(hist, [None, None, "spam"]))
+            )
+
+            # Check whether specifying a range beyond the end of the current
+            # session results in an error (gh-804)
+            ip.run_line_magic("hist", "2-500")
+
+            # Check that we can write non-ascii characters to a file
+            ip.run_line_magic("hist", "-f %s" % (tmp_path / "test1"))
+            ip.run_line_magic("hist", "-pf %s" % (tmp_path / "test2"))
+            ip.run_line_magic("hist", "-nf %s" % (tmp_path / "test3"))
+            ip.run_line_magic("save", "%s 1-10" % (tmp_path / "test4"))
+
+            # New session
+            ip.history_manager.reset()
+            newcmds = ["z=5", "class X(object):\n    pass", "k='p'", "z=5"]
+            for i, cmd in enumerate(newcmds, start=1):
+                ip.history_manager.store_inputs(i, cmd)
+            gothist = ip.history_manager.get_range(start=1, stop=4)
+            assert list(gothist) == list(zip([0, 0, 0], [1, 2, 3], newcmds))
+            # Previous session:
+            gothist = ip.history_manager.get_range(-1, 1, 4)
+            assert list(gothist) == list(zip([1, 1, 1], [1, 2, 3], hist))
+
+            newhist = [(2, i, c) for (i, c) in enumerate(newcmds, 1)]
+
+            # Check get_hist_tail
+            gothist = ip.history_manager.get_tail(5, output=True, include_latest=True)
+            expected = [(1, 3, (hist[-1], "spam"))] + [
+                (s, n, (c, None)) for (s, n, c) in newhist
+            ]
+            assert list(gothist) == expected
+
+            gothist = ip.history_manager.get_tail(2)
+            expected = newhist[-3:-1]
+            assert list(gothist) == expected
+
+            # Check get_hist_search
+
+            gothist = ip.history_manager.search("*test*")
+            assert list(gothist) == [(1, 2, hist[1])]
+
+            gothist = ip.history_manager.search("*=*")
+            assert list(gothist) == [
+                (1, 1, hist[0]),
+                (1, 2, hist[1]),
+                (1, 3, hist[2]),
+                newhist[0],
+                newhist[2],
+                newhist[3],
+            ]
+
+            gothist = ip.history_manager.search("*=*", n=4)
+            assert list(gothist) == [
+                (1, 3, hist[2]),
+                newhist[0],
+                newhist[2],
+                newhist[3],
+            ]
+
+            gothist = ip.history_manager.search("*=*", unique=True)
+            assert list(gothist) == [
+                (1, 1, hist[0]),
+                (1, 2, hist[1]),
+                (1, 3, hist[2]),
+                newhist[2],
+                newhist[3],
+            ]
+
+            gothist = ip.history_manager.search("*=*", unique=True, n=3)
+            assert list(gothist) == [(1, 3, hist[2]), newhist[2], newhist[3]]
+
+            gothist = ip.history_manager.search("b*", output=True)
+            assert list(gothist) == [(1, 3, (hist[2], "spam"))]
+
+            # Cross testing: check that magic %save can get previous session.
+            testfilename = (tmp_path / "test.py").resolve()
+            ip.run_line_magic("save", str(testfilename) + " ~1/1-3")
+            with io.open(testfilename, encoding="utf-8") as testfile:
+                assert testfile.read() == "# coding: utf-8\n" + "\n".join(hist) + "\n"
+
+            # Duplicate line numbers - check that it doesn't crash, and
+            # gets a new session
+            ip.history_manager.store_inputs(1, "rogue")
+            ip.history_manager.writeout_cache()
+            assert ip.history_manager.session_number == 3
+
+            # Check that session and line values are not just max values
+            sessid, lineno, entry = newhist[-1]
+            assert lineno > 1
+            ip.history_manager.reset()
+            lineno = 1
+            ip.history_manager.store_inputs(lineno, entry)
+            gothist = ip.history_manager.search("*=*", unique=True)
+            hist = list(gothist)[-1]
+            assert sessid < hist[0]
+            assert hist[1:] == (lineno, entry)
+        finally:
+            # Ensure saving thread is shut down before we try to clean up the files
+            ip.history_manager.end_session()
+            # Forcibly close database rather than relying on garbage collection
+            ip.history_manager.save_thread.stop()
+            ip.history_manager.db.close()
+            # swap back
+            ip.history_manager = hist_manager_ori
+
+
+def test_extract_hist_ranges():
+    instr = "1 2/3 ~4/5-6 ~4/7-~4/9 ~9/2-~7/5 ~10/"
+    expected = [
+        (0, 1, 2),  # 0 == current session
+        (2, 3, 4),
+        (-4, 5, 7),
+        (-4, 7, 10),
+        (-9, 2, None),  # None == to end
+        (-8, 1, None),
+        (-7, 1, 6),
+        (-10, 1, None),
+    ]
+    actual = list(extract_hist_ranges(instr))
+    assert actual == expected
+
+
+def test_extract_hist_ranges_empty_str():
+    instr = ""
+    expected = [(0, 1, None)]  # 0 == current session, None == to end
+    actual = list(extract_hist_ranges(instr))
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "instr,expected,description",
+    [
+        ("21-23", [(0, 21, 24)], "Just line numbers"),
+        ("25-", [(0, 25, None)], "Line start, no end"),
+        ("~4/", [(-4, 1, None)], "with trailing slash"),
+        # ("~4", [(-4, 1, None)], "without trailing slash"),
+        ("~4/1-5", [(-4, 1, 6)], "with line ranges and trailing slash"),
+        (
+            "~4/1- ~5/ ~6/1-3",
+            [(-4, 1, None), (-5, 1, None), (-6, 1, 4)],
+            "multiple sessions with mixed syntax",
+        ),
+        ("~10/ ~20/", [(-10, 1, None), (-20, 1, None)], "larger session numbers"),
+        # ("~1", [(-1, 1, None)], "single digit session without slash"),
+        ("~1/", [(-1, 1, None)], "single digit session with slash"),
+        # ("~2", [(-2, 1, None)], "backward compatibility without slash"),
+        ("~2/", [(-2, 1, None)], "backward compatibility with slash"),
+        ("4-", [(0, 4, None)], "from line 4 onward in current session"),
+        ("~4/4-", [(-4, 4, None)], "from line 4 onward in session 4"),
+        ("2/4-", [(2, 4, None)], "from line 4 onward in session 2"),
+        ("~5/10-", [(-5, 10, None)], "from line 10 onward in session 5"),
+    ],
+)
+def test_misc_extract_hist_ranges(instr, expected, description):
+    actual = list(extract_hist_ranges(instr))
+    assert (
+        actual == expected
+    ), f"Failed for '{instr}' ({description}): expected {expected}, got {actual}"
+
+
+def test_magic_rerun():
+    """Simple test for %rerun (no args -> rerun last line)"""
+    ip = get_ipython()
+    ip.run_cell("a = 10", store_history=True)
+    ip.run_cell("a += 1", store_history=True)
+    assert ip.user_ns["a"] == 11
+    ip.run_cell("%rerun", store_history=True)
+    assert ip.user_ns["a"] == 12
+
+
+def test_timestamp_type():
+    ip = get_ipython()
+    info = ip.history_manager.get_session_info()
+    assert isinstance(info[1], datetime)
+
+
+def test_hist_file_config(hmmax3):
+    cfg = Config()
+    tfile = tempfile.NamedTemporaryFile(delete=False)
+    cfg.HistoryManager.hist_file = Path(tfile.name)
+    try:
+        hm = HistoryManager(shell=get_ipython(), config=cfg)
+        assert hm.hist_file == cfg.HistoryManager.hist_file
+    finally:
+        try:
+            Path(tfile.name).unlink()
+        except OSError:
+            # same catch as in testing.tools.TempFileMixin
+            # On Windows, even though we close the file, we still can't
+            # delete it.  I have no clue why
+            pass
+            HistoryManager.__max_inst = 1
+
+
+def test_histmanager_disabled(hmmax2):
+    """Ensure that disabling the history manager doesn't create a database."""
+    cfg = Config()
+    cfg.HistoryAccessor.enabled = False
+
+    ip = get_ipython()
+    with TemporaryDirectory() as tmpdir:
+        hist_manager_ori = ip.history_manager
+        hist_file = Path(tmpdir) / "history.sqlite"
+        cfg.HistoryManager.hist_file = hist_file
+        try:
+            ip.history_manager = HistoryManager(shell=ip, config=cfg)
+            hist = ["a=1", "def f():\n    test = 1\n    return test", "b='€Æ¾÷ß'"]
+            for i, h in enumerate(hist, start=1):
+                ip.history_manager.store_inputs(i, h)
+            assert ip.history_manager.input_hist_raw == [""] + hist
+            ip.history_manager.reset()
+            ip.history_manager.end_session()
+        finally:
+            ip.history_manager = hist_manager_ori
+
+    # hist_file should not be created
+    assert hist_file.exists() is False
+
+
+def test_get_tail_session_awareness(hmmax3):
+    """Test .get_tail() is:
+        - session specific in HistoryManager
+        - session agnostic in HistoryAccessor
+    same for .get_last_session_id()
+    """
+    with TemporaryDirectory() as tmpdir:
+        ip = get_ipython()
+        tmp_path = Path(tmpdir)
+        hist_file = tmp_path / "history.sqlite"
+        get_source = lambda x: x[2]
+        hm1 = None
+        hm2 = None
+        ha = None
+        try:
+            # hm1 creates a new session and adds history entries,
+            # ha catches up
+            hm1 = HistoryManager(shell=ip, hist_file=hist_file)
+            hm1_last_sid = hm1.get_last_session_id
+            ha = HistoryAccessor(hist_file=hist_file)
+            ha_last_sid = ha.get_last_session_id
+
+            hist1 = ["a=1", "b=1", "c=1"]
+            for i, h in enumerate(hist1 + [""], start=1):
+                hm1.store_inputs(i, h)
+            assert list(map(get_source, hm1.get_tail())) == hist1
+            assert list(map(get_source, ha.get_tail())) == hist1
+            sid1 = hm1_last_sid()
+            assert sid1 is not None
+            assert ha_last_sid() == sid1
+
+            # hm2 creates a new session and adds entries,
+            # ha catches up
+            hm2 = HistoryManager(shell=ip, hist_file=hist_file)
+            hm2_last_sid = hm2.get_last_session_id
+
+            hist2 = ["a=2", "b=2", "c=2"]
+            for i, h in enumerate(hist2 + [""], start=1):
+                hm2.store_inputs(i, h)
+            tail = hm2.get_tail(n=3)
+            assert list(map(get_source, tail)) == hist2
+            tail = ha.get_tail(n=3)
+            assert list(map(get_source, tail)) == hist2
+            sid2 = hm2_last_sid()
+            assert sid2 is not None
+            assert ha_last_sid() == sid2
+            assert sid2 != sid1
+
+            # but hm1 still maintains its point of reference
+            # and adding more entries to it doesn't change others
+            # immediate perspective
+            assert hm1_last_sid() == sid1
+            tail = hm1.get_tail(n=3)
+            assert list(map(get_source, tail)) == hist1
+
+            hist3 = ["a=3", "b=3", "c=3"]
+            for i, h in enumerate(hist3 + [""], start=5):
+                hm1.store_inputs(i, h)
+            tail = hm1.get_tail(n=7)
+            assert list(map(get_source, tail)) == hist1 + [""] + hist3
+            tail = hm2.get_tail(n=3)
+            assert list(map(get_source, tail)) == hist2
+            tail = ha.get_tail(n=3)
+            assert list(map(get_source, tail)) == hist2
+            assert hm1_last_sid() == sid1
+            assert hm2_last_sid() == sid2
+            assert ha_last_sid() == sid2
+        finally:
+            if hm1:
+                hm1.save_thread.stop()
+                hm1.db.close()
+            if hm2:
+                hm2.save_thread.stop()
+                hm2.db.close()
+            if ha:
+                ha.db.close()
+
+
+def test_calling_run_cell(hmmax2):
+    ip = get_ipython()
+    with TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir)
+        hist_manager_ori = ip.history_manager
+        hist_file = tmp_path / "history_test_history1.sqlite"
+        try:
+            ip.history_manager = HistoryManager(shell=ip, hist_file=hist_file)
+            import time
+    
+            session_number = ip.history_manager.session_number
+            ip.run_cell(raw_cell="get_ipython().run_cell(raw_cell='1', store_history=True)", store_history=True)
+            while ip.history_manager.db_input_cache:
+                time.sleep(0)
+            new_session_number = ip.history_manager.session_number
+        finally:
+            # Ensure saving thread is shut down before we try to clean up the files
+            ip.history_manager.end_session()
+            # Forcibly close database rather than relying on garbage collection
+            ip.history_manager.save_thread.stop()
+            ip.history_manager.db.close()
+
+            ip.history_manager = hist_manager_ori
+    assert session_number == new_session_number, ValueError(f"{session_number} != {new_session_number}")
diff --git a/tests/test_hooks.py b/tests/test_hooks.py
new file mode 100644
index 00000000000..4aba9a4fdee
--- /dev/null
+++ b/tests/test_hooks.py
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""Tests for CommandChainDispatcher."""
+
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import pytest
+from IPython.core.error import TryNext
+from IPython.core.hooks import CommandChainDispatcher
+
+# -----------------------------------------------------------------------------
+# Local utilities
+# -----------------------------------------------------------------------------
+
+
+# Define two classes, one which succeeds and one which raises TryNext. Each
+# sets the attribute `called` to True when it is called.
+class Okay(object):
+    def __init__(self, message):
+        self.message = message
+        self.called = False
+
+    def __call__(self):
+        self.called = True
+        return self.message
+
+
+class Fail(object):
+    def __init__(self, message):
+        self.message = message
+        self.called = False
+
+    def __call__(self):
+        self.called = True
+        raise TryNext(self.message)
+
+
+# -----------------------------------------------------------------------------
+# Test functions
+# -----------------------------------------------------------------------------
+
+
+def test_command_chain_dispatcher_ff():
+    """Test two failing hooks"""
+    fail1 = Fail("fail1")
+    fail2 = Fail("fail2")
+    dp = CommandChainDispatcher([(0, fail1), (10, fail2)])
+
+    with pytest.raises(TryNext) as e:
+        dp()
+    assert str(e.value) == "fail2"
+
+    assert fail1.called is True
+    assert fail2.called is True
+
+
+def test_command_chain_dispatcher_fofo():
+    """Test a mixture of failing and succeeding hooks."""
+    fail1 = Fail("fail1")
+    fail2 = Fail("fail2")
+    okay1 = Okay("okay1")
+    okay2 = Okay("okay2")
+
+    dp = CommandChainDispatcher(
+        [
+            (0, fail1),
+            # (5, okay1), # add this later
+            (10, fail2),
+            (15, okay2),
+        ]
+    )
+    dp.add(okay1, 5)
+
+    assert dp() == "okay1"
+
+    assert fail1.called is True
+    assert okay1.called is True
+    assert fail2.called is False
+    assert okay2.called is False
+
+
+def test_command_chain_dispatcher_eq_priority():
+    okay1 = Okay("okay1")
+    okay2 = Okay("okay2")
+    dp = CommandChainDispatcher([(1, okay1)])
+    dp.add(okay2, 1)
diff --git a/tests/test_imports.py b/tests/test_imports.py
new file mode 100644
index 00000000000..515cd4a8a58
--- /dev/null
+++ b/tests/test_imports.py
@@ -0,0 +1,14 @@
+# encoding: utf-8
+from IPython.testing import decorators as dec
+
+
+def test_import_backgroundjobs():
+    from IPython.lib import backgroundjobs
+
+
+def test_import_deepreload():
+    from IPython.lib import deepreload
+
+
+def test_import_demo():
+    from IPython.lib import demo
diff --git a/tests/test_importstring.py b/tests/test_importstring.py
new file mode 100644
index 00000000000..03d9540313f
--- /dev/null
+++ b/tests/test_importstring.py
@@ -0,0 +1,41 @@
+"""Tests for IPython.utils.importstring."""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2013  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import pytest
+
+from IPython.utils.importstring import import_item
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+def test_import_plain():
+    "Test simple imports"
+    import os
+
+    os2 = import_item("os")
+    assert os is os2
+
+
+def test_import_nested():
+    "Test nested imports from the stdlib"
+    from os import path
+
+    path2 = import_item("os.path")
+    assert path is path2
+
+
+def test_import_raises():
+    "Test that failing imports raise the right exception"
+    pytest.raises(ImportError, import_item, "IPython.foobar")
diff --git a/tests/test_inputtransformer2.py b/tests/test_inputtransformer2.py
new file mode 100644
index 00000000000..32a96f9a036
--- /dev/null
+++ b/tests/test_inputtransformer2.py
@@ -0,0 +1,440 @@
+"""Tests for the token-based transformers in IPython.core.inputtransformer2
+
+Line-based transformers are the simpler ones; token-based transformers are
+more complex. See test_inputtransformer2_line for tests for line-based
+transformations.
+"""
+
+import platform
+import string
+import sys
+from textwrap import dedent
+
+import pytest
+
+from IPython.core import inputtransformer2 as ipt2
+from IPython.core.inputtransformer2 import _find_assign_op, make_tokens_by_line
+
+MULTILINE_MAGIC = (
+    """\
+a = f()
+%foo \\
+bar
+g()
+""".splitlines(
+        keepends=True
+    ),
+    (2, 0),
+    """\
+a = f()
+get_ipython().run_line_magic('foo', ' bar')
+g()
+""".splitlines(
+        keepends=True
+    ),
+)
+
+INDENTED_MAGIC = (
+    """\
+for a in range(5):
+    %ls
+""".splitlines(
+        keepends=True
+    ),
+    (2, 4),
+    """\
+for a in range(5):
+    get_ipython().run_line_magic('ls', '')
+""".splitlines(
+        keepends=True
+    ),
+)
+
+CRLF_MAGIC = (
+    ["a = f()\n", "%ls\r\n", "g()\n"],
+    (2, 0),
+    ["a = f()\n", "get_ipython().run_line_magic('ls', '')\n", "g()\n"],
+)
+
+MULTILINE_MAGIC_ASSIGN = (
+    """\
+a = f()
+b = %foo \\
+  bar
+g()
+""".splitlines(
+        keepends=True
+    ),
+    (2, 4),
+    """\
+a = f()
+b = get_ipython().run_line_magic('foo', '   bar')
+g()
+""".splitlines(
+        keepends=True
+    ),
+)
+
+MULTILINE_SYSTEM_ASSIGN = (
+    """\
+a = f()
+b = !foo \\
+  bar
+g()
+""".splitlines(
+        keepends=True
+    ),
+    (2, 4),
+    """\
+a = f()
+b = get_ipython().getoutput('foo    bar')
+g()
+""".splitlines(
+        keepends=True
+    ),
+)
+
+#####
+
+MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT = (
+    """\
+def test():
+  for i in range(1):
+    print(i)
+  res =! ls
+""".splitlines(
+        keepends=True
+    ),
+    (4, 7),
+    """\
+def test():
+  for i in range(1):
+    print(i)
+  res =get_ipython().getoutput(\' ls\')
+""".splitlines(
+        keepends=True
+    ),
+)
+
+######
+
+AUTOCALL_QUOTE = ([",f 1 2 3\n"], (1, 0), ['f("1", "2", "3")\n'])
+
+AUTOCALL_QUOTE2 = ([";f 1 2 3\n"], (1, 0), ['f("1 2 3")\n'])
+
+AUTOCALL_PAREN = (["/f 1 2 3\n"], (1, 0), ["f(1, 2, 3)\n"])
+
+SIMPLE_HELP = (["foo?\n"], (1, 0), ["get_ipython().run_line_magic('pinfo', 'foo')\n"])
+
+DETAILED_HELP = (
+    ["foo??\n"],
+    (1, 0),
+    ["get_ipython().run_line_magic('pinfo2', 'foo')\n"],
+)
+
+MAGIC_HELP = (["%foo?\n"], (1, 0), ["get_ipython().run_line_magic('pinfo', '%foo')\n"])
+
+HELP_IN_EXPR = (
+    ["a = b + c?\n"],
+    (1, 0),
+    ["get_ipython().run_line_magic('pinfo', 'c')\n"],
+)
+
+HELP_CONTINUED_LINE = (
+    """\
+a = \\
+zip?
+""".splitlines(
+        keepends=True
+    ),
+    (1, 0),
+    [r"get_ipython().run_line_magic('pinfo', 'zip')" + "\n"],
+)
+
+HELP_MULTILINE = (
+    """\
+(a,
+b) = zip?
+""".splitlines(
+        keepends=True
+    ),
+    (1, 0),
+    [r"get_ipython().run_line_magic('pinfo', 'zip')" + "\n"],
+)
+
+HELP_UNICODE = (
+    ["Ï€.foo?\n"],
+    (1, 0),
+    ["get_ipython().run_line_magic('pinfo', 'Ï€.foo')\n"],
+)
+
+
+def null_cleanup_transformer(lines):
+    """
+    A cleanup transform that returns an empty list.
+    """
+    return []
+
+
+def test_check_make_token_by_line_never_ends_empty():
+    """
+    Check that not sequence of single or double characters ends up leading to en empty list of tokens
+    """
+    from string import printable
+
+    for c in printable:
+        assert make_tokens_by_line(c)[-1] != []
+        for k in printable:
+            assert make_tokens_by_line(c + k)[-1] != []
+
+
+def check_find(transformer, case, match=True):
+    sample, expected_start, _ = case
+    tbl = make_tokens_by_line(sample)
+    res = transformer.find(tbl)
+    if match:
+        # start_line is stored 0-indexed, expected values are 1-indexed
+        assert (res.start_line + 1, res.start_col) == expected_start
+        return res
+    else:
+        assert res is None
+
+
+def check_transform(transformer_cls, case):
+    lines, start, expected = case
+    transformer = transformer_cls(start)
+    assert transformer.transform(lines) == expected
+
+
+def test_continued_line():
+    lines = MULTILINE_MAGIC_ASSIGN[0]
+    assert ipt2.find_end_of_continued_line(lines, 1) == 2
+
+    assert ipt2.assemble_continued_line(lines, (1, 5), 2) == "foo    bar"
+
+
+def test_find_assign_magic():
+    check_find(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN)
+    check_find(ipt2.MagicAssign, MULTILINE_SYSTEM_ASSIGN, match=False)
+    check_find(ipt2.MagicAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT, match=False)
+
+
+def test_transform_assign_magic():
+    check_transform(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN)
+
+
+def test_find_assign_system():
+    check_find(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN)
+    check_find(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT)
+    check_find(ipt2.SystemAssign, (["a =  !ls\n"], (1, 5), None))
+    check_find(ipt2.SystemAssign, (["a=!ls\n"], (1, 2), None))
+    check_find(ipt2.SystemAssign, MULTILINE_MAGIC_ASSIGN, match=False)
+
+
+def test_transform_assign_system():
+    check_transform(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN)
+    check_transform(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT)
+
+
+def test_find_magic_escape():
+    check_find(ipt2.EscapedCommand, MULTILINE_MAGIC)
+    check_find(ipt2.EscapedCommand, INDENTED_MAGIC)
+    check_find(ipt2.EscapedCommand, MULTILINE_MAGIC_ASSIGN, match=False)
+
+
+def test_transform_magic_escape():
+    check_transform(ipt2.EscapedCommand, MULTILINE_MAGIC)
+    check_transform(ipt2.EscapedCommand, INDENTED_MAGIC)
+    check_transform(ipt2.EscapedCommand, CRLF_MAGIC)
+
+
+def test_find_autocalls():
+    for case in [AUTOCALL_QUOTE, AUTOCALL_QUOTE2, AUTOCALL_PAREN]:
+        print("Testing %r" % case[0])
+        check_find(ipt2.EscapedCommand, case)
+
+
+def test_transform_autocall():
+    for case in [AUTOCALL_QUOTE, AUTOCALL_QUOTE2, AUTOCALL_PAREN]:
+        print("Testing %r" % case[0])
+        check_transform(ipt2.EscapedCommand, case)
+
+
+def test_find_help():
+    for case in [SIMPLE_HELP, DETAILED_HELP, MAGIC_HELP, HELP_IN_EXPR]:
+        check_find(ipt2.HelpEnd, case)
+
+    tf = check_find(ipt2.HelpEnd, HELP_CONTINUED_LINE)
+    assert tf.q_line == 1
+    assert tf.q_col == 3
+
+    tf = check_find(ipt2.HelpEnd, HELP_MULTILINE)
+    assert tf.q_line == 1
+    assert tf.q_col == 8
+
+    # ? in a comment does not trigger help
+    check_find(ipt2.HelpEnd, (["foo # bar?\n"], None, None), match=False)
+    # Nor in a string
+    check_find(ipt2.HelpEnd, (["foo = '''bar?\n"], None, None), match=False)
+
+
+def test_transform_help():
+    tf = ipt2.HelpEnd((1, 0), (1, 9))
+    assert tf.transform(HELP_IN_EXPR[0]) == HELP_IN_EXPR[2]
+
+    tf = ipt2.HelpEnd((1, 0), (2, 3))
+    assert tf.transform(HELP_CONTINUED_LINE[0]) == HELP_CONTINUED_LINE[2]
+
+    tf = ipt2.HelpEnd((1, 0), (2, 8))
+    assert tf.transform(HELP_MULTILINE[0]) == HELP_MULTILINE[2]
+
+    tf = ipt2.HelpEnd((1, 0), (1, 0))
+    assert tf.transform(HELP_UNICODE[0]) == HELP_UNICODE[2]
+
+
+def test_find_assign_op_dedent():
+    """
+    be careful that empty token like dedent are not counted as parens
+    """
+
+    class Tk:
+        def __init__(self, s):
+            self.string = s
+
+    assert _find_assign_op([Tk(s) for s in ("", "a", "=", "b")]) == 2
+    assert (
+        _find_assign_op([Tk(s) for s in ("", "(", "a", "=", "b", ")", "=", "5")]) == 6
+    )
+
+
+extra_closing_paren_param = (
+    pytest.param("(\n))", "invalid", None)
+    if sys.version_info >= (3, 12)
+    else pytest.param("(\n))", "incomplete", 0)
+)
+examples = [
+    pytest.param("a = 1", "complete", None),
+    pytest.param("for a in range(5):", "incomplete", 4),
+    pytest.param("for a in range(5):\n    if a > 0:", "incomplete", 8),
+    pytest.param("raise = 2", "invalid", None),
+    pytest.param("a = [1,\n2,", "incomplete", 0),
+    extra_closing_paren_param,
+    pytest.param("\\\r\n", "incomplete", 0),
+    pytest.param("a = '''\n   hi", "incomplete", 3),
+    pytest.param("def a():\n x=1\n global x", "invalid", None),
+    pytest.param("a \\ ", "invalid", None),  # Nothing allowed after backslash,
+    pytest.param("1\\\n+2", "complete", None),
+]
+
+
+@pytest.mark.parametrize("code, expected, number", examples)
+def test_check_complete_param(code, expected, number):
+    cc = ipt2.TransformerManager().check_complete
+    assert cc(code) == (expected, number)
+
+
+@pytest.mark.xfail(platform.python_implementation() == "PyPy", reason="fail on pypy")
+def test_check_complete():
+    cc = ipt2.TransformerManager().check_complete
+
+    example = dedent(
+        """
+        if True:
+            a=1"""
+    )
+
+    assert cc(example) == ("incomplete", 4)
+    assert cc(example + "\n") == ("complete", None)
+    assert cc(example + "\n    ") == ("complete", None)
+
+    # no need to loop on all the letters/numbers.
+    short = "12abAB" + string.printable[62:]
+    for c in short:
+        # test does not raise:
+        cc(c)
+        for k in short:
+            cc(c + k)
+
+    assert cc("def f():\n  x=0\n  \\\n  ") == ("incomplete", 2)
+
+
+@pytest.mark.xfail(platform.python_implementation() == "PyPy", reason="fail on pypy")
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        ('''def foo():\n    """''', ("incomplete", 4)),
+        ("""async with example:\n    pass""", ("incomplete", 4)),
+        ("""async with example:\n    pass\n    """, ("complete", None)),
+    ],
+)
+def test_check_complete_II(value, expected):
+    """
+    Test that multiple line strings are properly handled.
+
+    Separate test function for convenience
+
+    """
+    cc = ipt2.TransformerManager().check_complete
+    assert cc(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        (")", ("invalid", None)),
+        ("]", ("invalid", None)),
+        ("}", ("invalid", None)),
+        (")(", ("invalid", None)),
+        ("][", ("invalid", None)),
+        ("}{", ("invalid", None)),
+        ("]()(", ("invalid", None)),
+        ("())(", ("invalid", None)),
+        (")[](", ("invalid", None)),
+        ("()](", ("invalid", None)),
+    ],
+)
+def test_check_complete_invalidates_sunken_brackets(value, expected):
+    """
+    Test that a single line with more closing brackets than the opening ones is
+    interpreted as invalid
+    """
+    cc = ipt2.TransformerManager().check_complete
+    assert cc(value) == expected
+
+
+def test_null_cleanup_transformer():
+    manager = ipt2.TransformerManager()
+    manager.cleanup_transforms.insert(0, null_cleanup_transformer)
+    assert manager.transform_cell("") == ""
+
+
+def test_side_effects_I():
+    count = 0
+
+    def counter(lines):
+        nonlocal count
+        count += 1
+        return lines
+
+    counter.has_side_effects = True
+
+    manager = ipt2.TransformerManager()
+    manager.cleanup_transforms.insert(0, counter)
+    assert manager.check_complete("a=1\n") == ("complete", None)
+    assert count == 0
+
+
+def test_side_effects_II():
+    count = 0
+
+    def counter(lines):
+        nonlocal count
+        count += 1
+        return lines
+
+    counter.has_side_effects = True
+
+    manager = ipt2.TransformerManager()
+    manager.line_transforms.insert(0, counter)
+    assert manager.check_complete("b=1\n") == ("complete", None)
+    assert count == 0
diff --git a/tests/test_inputtransformer2_line.py b/tests/test_inputtransformer2_line.py
new file mode 100644
index 00000000000..a3b0160488a
--- /dev/null
+++ b/tests/test_inputtransformer2_line.py
@@ -0,0 +1,307 @@
+"""Tests for the line-based transformers in IPython.core.inputtransformer2
+
+Line-based transformers are the simpler ones; token-based transformers are
+more complex. See test_inputtransformer2 for tests for token-based transformers.
+"""
+
+import pytest
+
+from IPython.core import inputtransformer2 as ipt2
+
+CELL_MAGIC = (
+    """\
+%%foo arg
+body 1
+body 2
+""",
+    """\
+get_ipython().run_cell_magic('foo', 'arg', 'body 1\\nbody 2\\n')
+""",
+)
+
+
+def test_cell_magic():
+    for sample, expected in [CELL_MAGIC]:
+        assert ipt2.cell_magic(sample.splitlines(keepends=True)) == expected.splitlines(
+            keepends=True
+        )
+
+
+CLASSIC_PROMPT = (
+    """\
+>>> for a in range(5):
+...     print(a)
+""",
+    """\
+for a in range(5):
+    print(a)
+""",
+)
+
+CLASSIC_PROMPT_L2 = (
+    """\
+for a in range(5):
+...     print(a)
+...     print(a ** 2)
+""",
+    """\
+for a in range(5):
+...     print(a)
+...     print(a ** 2)
+""",
+)
+
+CLASSIC_PROMPT_L3 = (
+    """\
+>>> \"\"\"
+... This code is inside a triple-quoted string.
+... >>> for a in range(5):
+... ...     print(a)
+... \"\"\"
+>>> for a in range(5):
+...     print(a)
+""",
+    """\
+>>> \"\"\"
+... This code is inside a triple-quoted string.
+... >>> for a in range(5):
+... ...     print(a)
+... \"\"\"
+for a in range(5):
+    print(a)
+""",
+)
+
+CLASSIC_PROMPT_DEDENT_SINGLE_LINE = (
+    ">>>     print(1)\n",
+    "print(1)\n",
+)
+
+CLASSIC_PROMPT_DEDENT_LEADING_WS = (
+    "    >>>     print(1)\n",
+    "print(1)\n",
+)
+
+CLASSIC_PROMPT_MULTILINE_DOCTEST = (
+    """\
+>>> for i in range(2):
+...     print(i)
+""",
+    """\
+for i in range(2):
+    print(i)
+""",
+)
+
+CLASSIC_PROMPT_STANDALONE_CONTINUATION = (
+    "...     print(1)\n",
+    "...     print(1)\n",
+)
+
+
+def test_classic_prompt():
+    for sample, expected in [
+        CLASSIC_PROMPT,
+        CLASSIC_PROMPT_L2,
+        CLASSIC_PROMPT_L3,
+        CLASSIC_PROMPT_DEDENT_SINGLE_LINE,
+        CLASSIC_PROMPT_DEDENT_LEADING_WS,
+        CLASSIC_PROMPT_MULTILINE_DOCTEST,
+        CLASSIC_PROMPT_STANDALONE_CONTINUATION,
+    ]:
+        assert ipt2.classic_prompt(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
+
+
+IPYTHON_PROMPT = (
+    """\
+In [1]: for a in range(5):
+   ...:     print(a)
+""",
+    """\
+for a in range(5):
+    print(a)
+""",
+)
+
+IPYTHON_PROMPT_L2 = (
+    """\
+for a in range(5):
+   ...:     print(a)
+   ...:     print(a ** 2)
+""",
+    """\
+for a in range(5):
+    print(a)
+    print(a ** 2)
+""",
+)
+
+
+IPYTHON_PROMPT_VI_INS = (
+    """\
+[ins] In [11]: def a():
+          ...:     123
+          ...:
+          ...: 123
+""",
+    """\
+def a():
+    123
+
+123
+""",
+)
+
+IPYTHON_PROMPT_VI_NAV = (
+    """\
+[nav] In [11]: def a():
+          ...:     123
+          ...:
+          ...: 123
+""",
+    """\
+def a():
+    123
+
+123
+""",
+)
+
+
+def test_ipython_prompt():
+    for sample, expected in [
+        IPYTHON_PROMPT,
+        IPYTHON_PROMPT_L2,
+        IPYTHON_PROMPT_VI_INS,
+        IPYTHON_PROMPT_VI_NAV,
+    ]:
+        assert ipt2.ipython_prompt(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
+
+
+INDENT_SPACES = (
+    """\
+     if True:
+        a = 3
+""",
+    """\
+if True:
+   a = 3
+""",
+)
+
+INDENT_TABS = (
+    """\
+\tif True:
+\t\tb = 4
+""",
+    """\
+if True:
+\tb = 4
+""",
+)
+
+
+def test_leading_indent():
+    for sample, expected in [INDENT_SPACES, INDENT_TABS]:
+        assert ipt2.leading_indent(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
+
+
+INDENT_SPACES_COMMENT = (
+    """\
+    # comment
+if True:
+    a = 3
+""",
+    """\
+    # comment
+if True:
+    a = 3
+""",
+)
+
+INDENT_TABS_COMMENT = (
+    """\
+\t# comment
+if True:
+\tb = 4
+""",
+    """\
+\t# comment
+if True:
+\tb = 4
+""",
+)
+
+
+INDENTED_CODE_WITH_ALIGNED_COMMENT = (
+    """\
+    # comment
+    x = 1
+    print(x)
+""",
+    """\
+# comment
+x = 1
+print(x)
+""",
+)
+
+
+@pytest.mark.parametrize(
+    "sample, expected",
+    [INDENT_SPACES_COMMENT, INDENT_TABS_COMMENT, INDENTED_CODE_WITH_ALIGNED_COMMENT],
+)
+def test_leading_indent_comment(sample, expected):
+    assert ipt2.leading_indent(sample.splitlines(keepends=True)) == expected.splitlines(
+        keepends=True
+    )
+
+
+LEADING_EMPTY_LINES = (
+    """\
+    \t
+
+if True:
+    a = 3
+
+b = 4
+""",
+    """\
+if True:
+    a = 3
+
+b = 4
+""",
+)
+
+ONLY_EMPTY_LINES = (
+    """\
+    \t
+
+""",
+    """\
+    \t
+
+""",
+)
+
+
+def test_leading_empty_lines():
+    for sample, expected in [LEADING_EMPTY_LINES, ONLY_EMPTY_LINES]:
+        assert ipt2.leading_empty_lines(
+            sample.splitlines(keepends=True)
+        ) == expected.splitlines(keepends=True)
+
+
+CRLF_MAGIC = (["%%ls\r\n"], ["get_ipython().run_cell_magic('ls', '', '')\n"])
+
+
+def test_crlf_magic():
+    for sample, expected in [CRLF_MAGIC]:
+        assert ipt2.cell_magic(sample) == expected
diff --git a/tests/test_interactiveshell.py b/tests/test_interactiveshell.py
new file mode 100644
index 00000000000..a66172e46a1
--- /dev/null
+++ b/tests/test_interactiveshell.py
@@ -0,0 +1,1264 @@
+# -*- coding: utf-8 -*-
+"""Tests for the key interactiveshell module.
+
+Historically the main classes in interactiveshell have been under-tested.  This
+module should grow as many single-method tests as possible to trap many of the
+recurring bugs we seem to encounter with high-level interaction.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import asyncio
+import ast
+import os
+import signal
+import shutil
+import sys
+import tempfile
+import time
+import unittest
+import pytest
+from unittest import mock
+
+from os.path import join
+
+from IPython.core.error import InputRejected
+from IPython.core import interactiveshell
+from IPython.core.oinspect import OInfo
+from IPython.testing.decorators import (
+    skipif,
+    skip_win32,
+    onlyif_unicode_paths,
+    onlyif_cmds_exist,
+    skip_if_not_osx,
+)
+from IPython.testing import tools as tt
+from IPython.utils.process import find_cmd
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+# This is used by every single test, no point repeating it ad nauseam
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+class DerivedInterrupt(KeyboardInterrupt):
+    pass
+
+
+def test_stream_performance(capsys) -> None:
+    """It should be fast to execute."""
+    src = "for i in range(250_000): print(i)"
+    start = time.perf_counter()
+    ip.run_cell(src)
+    end = time.perf_counter()
+    # We try to read as otherwise on failure, pytest will print the 250k lines to stdout.
+    capsys.readouterr()
+    duration = end - start
+    assert duration < 10
+
+
+class InteractiveShellTestCase(unittest.TestCase):
+    def test_naked_string_cells(self):
+        """Test that cells with only naked strings are fully executed"""
+        # First, single-line inputs
+        ip.run_cell('"a"\n')
+        self.assertEqual(ip.user_ns["_"], "a")
+        # And also multi-line cells
+        ip.run_cell('"""a\nb"""\n')
+        self.assertEqual(ip.user_ns["_"], "a\nb")
+
+    def test_run_empty_cell(self):
+        """Just make sure we don't get a horrible error with a blank
+        cell of input. Yes, I did overlook that."""
+        old_xc = ip.execution_count
+        res = ip.run_cell("")
+        self.assertEqual(ip.execution_count, old_xc)
+        self.assertEqual(res.execution_count, None)
+
+    def test_run_cell_multiline(self):
+        """Multi-block, multi-line cells must execute correctly."""
+        src = "\n".join(
+            [
+                "x=1",
+                "y=2",
+                "if 1:",
+                "    x += 1",
+                "    y += 1",
+            ]
+        )
+        res = ip.run_cell(src)
+        self.assertEqual(ip.user_ns["x"], 2)
+        self.assertEqual(ip.user_ns["y"], 3)
+        self.assertEqual(res.success, True)
+        self.assertEqual(res.result, None)
+
+    def test_multiline_string_cells(self):
+        "Code sprinkled with multiline strings should execute (GH-306)"
+        ip.run_cell("tmp=0")
+        self.assertEqual(ip.user_ns["tmp"], 0)
+        res = ip.run_cell('tmp=1;"""a\nb"""\n')
+        self.assertEqual(ip.user_ns["tmp"], 1)
+        self.assertEqual(res.success, True)
+        self.assertEqual(res.result, "a\nb")
+
+    def test_dont_cache_with_semicolon(self):
+        "Ending a line with semicolon should not cache the returned object (GH-307)"
+        oldlen = len(ip.user_ns["Out"])
+        for cell in ["1;", "1;1;"]:
+            res = ip.run_cell(cell, store_history=True)
+            newlen = len(ip.user_ns["Out"])
+            self.assertEqual(oldlen, newlen)
+            self.assertIsNone(res.result)
+        i = 0
+        # also test the default caching behavior
+        for cell in ["1", "1;1"]:
+            ip.run_cell(cell, store_history=True)
+            newlen = len(ip.user_ns["Out"])
+            i += 1
+            self.assertEqual(oldlen + i, newlen)
+
+    def test_syntax_error(self):
+        res = ip.run_cell("raise = 3")
+        self.assertIsInstance(res.error_before_exec, SyntaxError)
+
+    def test_open_standard_input_stream(self):
+        res = ip.run_cell("open(0)")
+        self.assertIsInstance(res.error_in_exec, ValueError)
+
+    def test_open_standard_output_stream(self):
+        res = ip.run_cell("open(1)")
+        self.assertIsInstance(res.error_in_exec, ValueError)
+
+    def test_open_standard_error_stream(self):
+        res = ip.run_cell("open(2)")
+        self.assertIsInstance(res.error_in_exec, ValueError)
+
+    def test_In_variable(self):
+        "Verify that In variable grows with user input (GH-284)"
+        oldlen = len(ip.user_ns["In"])
+        ip.run_cell("1;", store_history=True)
+        newlen = len(ip.user_ns["In"])
+        self.assertEqual(oldlen + 1, newlen)
+        self.assertEqual(ip.user_ns["In"][-1], "1;")
+
+    def test_magic_names_in_string(self):
+        ip.run_cell('a = """\n%exit\n"""')
+        self.assertEqual(ip.user_ns["a"], "\n%exit\n")
+
+    def test_trailing_newline(self):
+        """test that running !(command) does not raise a SyntaxError"""
+        ip.run_cell("!(true)\n", False)
+        ip.run_cell("!(true)\n\n\n", False)
+
+    def test_gh_597(self):
+        """Pretty-printing lists of objects with non-ascii reprs may cause
+        problems."""
+
+        class Spam(object):
+            def __repr__(self):
+                return "\xe9" * 50
+
+        import IPython.core.formatters
+
+        f = IPython.core.formatters.PlainTextFormatter()
+        f([Spam(), Spam()])
+
+    def test_future_flags(self):
+        """Check that future flags are used for parsing code (gh-777)"""
+        ip.run_cell("from __future__ import barry_as_FLUFL")
+        try:
+            ip.run_cell("prfunc_return_val = 1 <> 2")
+            assert "prfunc_return_val" in ip.user_ns
+        finally:
+            # Reset compiler flags so we don't mess up other tests.
+            ip.compile.reset_compiler_flags()
+
+    def test_can_pickle(self):
+        "Can we pickle objects defined interactively (GH-29)"
+        ip = get_ipython()
+        ip.reset()
+        ip.run_cell(
+            (
+                "class Mylist(list):\n"
+                "    def __init__(self,x=[]):\n"
+                "        list.__init__(self,x)"
+            )
+        )
+        ip.run_cell("w=Mylist([1,2,3])")
+
+        from pickle import dumps
+
+        # We need to swap in our main module - this is only necessary
+        # inside the test framework, because IPython puts the interactive module
+        # in place (but the test framework undoes this).
+        _main = sys.modules["__main__"]
+        sys.modules["__main__"] = ip.user_module
+        try:
+            res = dumps(ip.user_ns["w"])
+        finally:
+            sys.modules["__main__"] = _main
+        self.assertTrue(isinstance(res, bytes))
+
+    def test_global_ns(self):
+        "Code in functions must be able to access variables outside them."
+        ip = get_ipython()
+        ip.run_cell("a = 10")
+        ip.run_cell(("def f(x):\n" "    return x + a"))
+        ip.run_cell("b = f(12)")
+        self.assertEqual(ip.user_ns["b"], 22)
+
+    def test_bad_custom_tb(self):
+        """Check that InteractiveShell is protected from bad custom exception handlers"""
+        ip.set_custom_exc((IOError,), lambda etype, value, tb: 1 / 0)
+        self.assertEqual(ip.custom_exceptions, (IOError,))
+        with tt.AssertPrints("Custom TB Handler failed", channel="stderr"):
+            ip.run_cell('raise IOError("foo")')
+        self.assertEqual(ip.custom_exceptions, ())
+
+    def test_bad_custom_tb_return(self):
+        """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
+        ip.set_custom_exc((NameError,), lambda etype, value, tb, tb_offset=None: 1)
+        self.assertEqual(ip.custom_exceptions, (NameError,))
+        with tt.AssertPrints("Custom TB Handler failed", channel="stderr"):
+            ip.run_cell("a=abracadabra")
+        self.assertEqual(ip.custom_exceptions, ())
+
+    def test_drop_by_id(self):
+        myvars = {"a": object(), "b": object(), "c": object()}
+        ip.push(myvars, interactive=False)
+        for name in myvars:
+            assert name in ip.user_ns, name
+            assert name in ip.user_ns_hidden, name
+        ip.user_ns["b"] = 12
+        ip.drop_by_id(myvars)
+        for name in ["a", "c"]:
+            assert name not in ip.user_ns, name
+            assert name not in ip.user_ns_hidden, name
+        assert ip.user_ns["b"] == 12
+        ip.reset()
+
+    def test_var_expand(self):
+        ip.user_ns["f"] = "Ca\xf1o"
+        self.assertEqual(ip.var_expand("echo $f"), "echo Ca\xf1o")
+        self.assertEqual(ip.var_expand("echo {f}"), "echo Ca\xf1o")
+        self.assertEqual(ip.var_expand("echo {f[:-1]}"), "echo Ca\xf1")
+        self.assertEqual(ip.var_expand("echo {1*2}"), "echo 2")
+
+        self.assertEqual(
+            ip.var_expand("grep x | awk '{print $1}'"), "grep x | awk '{print $1}'"
+        )
+
+        ip.user_ns["f"] = b"Ca\xc3\xb1o"
+        # This should not raise any exception:
+        ip.var_expand("echo $f")
+
+    def test_var_expand_local(self):
+        """Test local variable expansion in !system and %magic calls"""
+        # !system
+        ip.run_cell(
+            "def test():\n"
+            '    lvar = "ttt"\n'
+            "    ret = !echo {lvar}\n"
+            "    return ret[0]\n"
+        )
+        res = ip.user_ns["test"]()
+        self.assertIn("ttt", res)
+
+        # %magic
+        ip.run_cell(
+            "def makemacro():\n"
+            '    macroname = "macro_var_expand_locals"\n'
+            "    %macro {macroname} codestr\n"
+        )
+        ip.user_ns["codestr"] = "str(12)"
+        ip.run_cell("makemacro()")
+        self.assertIn("macro_var_expand_locals", ip.user_ns)
+
+    def test_var_expand_self(self):
+        """Test variable expansion with the name 'self', which was failing.
+
+        See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218
+        """
+        ip.run_cell(
+            "class cTest:\n"
+            '  classvar="see me"\n'
+            "  def test(self):\n"
+            "    res = !echo Variable: {self.classvar}\n"
+            "    return res[0]\n"
+        )
+        self.assertIn("see me", ip.user_ns["cTest"]().test())
+
+    def test_bad_var_expand(self):
+        """var_expand on invalid formats shouldn't raise"""
+        # SyntaxError
+        self.assertEqual(ip.var_expand("{'a':5}"), "{'a':5}")
+        # NameError
+        self.assertEqual(ip.var_expand("{asdf}"), "{asdf}")
+        # ZeroDivisionError
+        self.assertEqual(ip.var_expand("{1/0}"), "{1/0}")
+
+    def test_silent_postexec(self):
+        """run_cell(silent=True) doesn't invoke pre/post_run_cell callbacks"""
+        pre_explicit = mock.Mock()
+        pre_always = mock.Mock()
+        post_explicit = mock.Mock()
+        post_always = mock.Mock()
+        all_mocks = [pre_explicit, pre_always, post_explicit, post_always]
+
+        ip.events.register("pre_run_cell", pre_explicit)
+        ip.events.register("pre_execute", pre_always)
+        ip.events.register("post_run_cell", post_explicit)
+        ip.events.register("post_execute", post_always)
+
+        try:
+            ip.run_cell("1", silent=True)
+            assert pre_always.called
+            assert not pre_explicit.called
+            assert post_always.called
+            assert not post_explicit.called
+            # double-check that non-silent exec did what we expected
+            # silent to avoid
+            ip.run_cell("1")
+            assert pre_explicit.called
+            assert post_explicit.called
+            (info,) = pre_explicit.call_args[0]
+            (result,) = post_explicit.call_args[0]
+            self.assertEqual(info, result.info)
+            # check that post hooks are always called
+            [m.reset_mock() for m in all_mocks]
+            ip.run_cell("syntax error")
+            assert pre_always.called
+            assert pre_explicit.called
+            assert post_always.called
+            assert post_explicit.called
+            (info,) = pre_explicit.call_args[0]
+            (result,) = post_explicit.call_args[0]
+            self.assertEqual(info, result.info)
+        finally:
+            # remove post-exec
+            ip.events.unregister("pre_run_cell", pre_explicit)
+            ip.events.unregister("pre_execute", pre_always)
+            ip.events.unregister("post_run_cell", post_explicit)
+            ip.events.unregister("post_execute", post_always)
+
+    def test_silent_noadvance(self):
+        """run_cell(silent=True) doesn't advance execution_count"""
+        ec = ip.execution_count
+        # silent should force store_history=False
+        ip.run_cell("1", store_history=True, silent=True)
+
+        self.assertEqual(ec, ip.execution_count)
+        # double-check that non-silent exec did what we expected
+        # silent to avoid
+        ip.run_cell("1", store_history=True)
+        self.assertEqual(ec + 1, ip.execution_count)
+
+    def test_silent_nodisplayhook(self):
+        """run_cell(silent=True) doesn't trigger displayhook"""
+        d = dict(called=False)
+
+        trap = ip.display_trap
+        save_hook = trap.hook
+
+        def failing_hook(*args, **kwargs):
+            d["called"] = True
+
+        try:
+            trap.hook = failing_hook
+            res = ip.run_cell("1", silent=True)
+            self.assertFalse(d["called"])
+            self.assertIsNone(res.result)
+            # double-check that non-silent exec did what we expected
+            # silent to avoid
+            ip.run_cell("1")
+            self.assertTrue(d["called"])
+        finally:
+            trap.hook = save_hook
+
+    def test_ofind_line_magic(self):
+        from IPython.core.magic import register_line_magic
+
+        @register_line_magic
+        def lmagic(line):
+            "A line magic"
+
+        # Get info on line magic
+        lfind = ip._ofind("lmagic")
+        info = OInfo(
+            found=True,
+            isalias=False,
+            ismagic=True,
+            namespace="IPython internal",
+            obj=lmagic,
+            parent=None,
+        )
+        self.assertEqual(lfind, info)
+
+    def test_ofind_cell_magic(self):
+        from IPython.core.magic import register_cell_magic
+
+        @register_cell_magic
+        def cmagic(line, cell):
+            "A cell magic"
+
+        # Get info on cell magic
+        find = ip._ofind("cmagic")
+        info = OInfo(
+            found=True,
+            isalias=False,
+            ismagic=True,
+            namespace="IPython internal",
+            obj=cmagic,
+            parent=None,
+        )
+        self.assertEqual(find, info)
+
+    def test_ofind_property_with_error(self):
+        class A(object):
+            @property
+            def foo(self):
+                raise NotImplementedError()  # pragma: no cover
+
+        a = A()
+
+        found = ip._ofind("a.foo", [("locals", locals())])
+        info = OInfo(
+            found=True,
+            isalias=False,
+            ismagic=False,
+            namespace="locals",
+            obj=A.foo,
+            parent=a,
+        )
+        self.assertEqual(found, info)
+
+    def test_ofind_multiple_attribute_lookups(self):
+        class A(object):
+            @property
+            def foo(self):
+                raise NotImplementedError()  # pragma: no cover
+
+        a = A()
+        a.a = A()
+        a.a.a = A()
+
+        found = ip._ofind("a.a.a.foo", [("locals", locals())])
+        info = OInfo(
+            found=True,
+            isalias=False,
+            ismagic=False,
+            namespace="locals",
+            obj=A.foo,
+            parent=a.a.a,
+        )
+        self.assertEqual(found, info)
+
+    def test_ofind_slotted_attributes(self):
+        class A(object):
+            __slots__ = ["foo"]
+
+            def __init__(self):
+                self.foo = "bar"
+
+        a = A()
+        found = ip._ofind("a.foo", [("locals", locals())])
+        info = OInfo(
+            found=True,
+            isalias=False,
+            ismagic=False,
+            namespace="locals",
+            obj=a.foo,
+            parent=a,
+        )
+        self.assertEqual(found, info)
+
+        found = ip._ofind("a.bar", [("locals", locals())])
+        expected = OInfo(
+            found=False,
+            isalias=False,
+            ismagic=False,
+            namespace=None,
+            obj=None,
+            parent=a,
+        )
+        assert found == expected
+
+    def test_ofind_prefers_property_to_instance_level_attribute(self):
+        class A(object):
+            @property
+            def foo(self):
+                return "bar"
+
+        a = A()
+        a.__dict__["foo"] = "baz"
+        self.assertEqual(a.foo, "bar")
+        found = ip._ofind("a.foo", [("locals", locals())])
+        self.assertIs(found.obj, A.foo)
+
+    def test_custom_syntaxerror_exception(self):
+        called = []
+
+        def my_handler(shell, etype, value, tb, tb_offset=None):
+            called.append(etype)
+            shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
+
+        ip.set_custom_exc((SyntaxError,), my_handler)
+        try:
+            ip.run_cell("1f")
+            # Check that this was called, and only once.
+            self.assertEqual(called, [SyntaxError])
+        finally:
+            # Reset the custom exception hook
+            ip.set_custom_exc((), None)
+
+    def test_custom_exception(self):
+        called = []
+
+        def my_handler(shell, etype, value, tb, tb_offset=None):
+            called.append(etype)
+            shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
+
+        ip.set_custom_exc((ValueError,), my_handler)
+        try:
+            res = ip.run_cell("raise ValueError('test')")
+            # Check that this was called, and only once.
+            self.assertEqual(called, [ValueError])
+            # Check that the error is on the result object
+            self.assertIsInstance(res.error_in_exec, ValueError)
+        finally:
+            # Reset the custom exception hook
+            ip.set_custom_exc((), None)
+
+    @mock.patch("builtins.print")
+    def test_showtraceback_with_surrogates(self, mocked_print):
+        values = []
+
+        def mock_print_func(value, sep=" ", end="\n", file=sys.stdout, flush=False):
+            values.append(value)
+            if value == chr(0xD8FF):
+                raise UnicodeEncodeError("utf-8", chr(0xD8FF), 0, 1, "")
+
+        # mock builtins.print
+        mocked_print.side_effect = mock_print_func
+
+        # ip._showtraceback() is replaced in globalipapp.py.
+        # Call original method to test.
+        interactiveshell.InteractiveShell._showtraceback(ip, None, None, chr(0xD8FF))
+
+        self.assertEqual(mocked_print.call_count, 2)
+        self.assertEqual(values, [chr(0xD8FF), "\\ud8ff"])
+
+    def test_mktempfile(self):
+        filename = ip.mktempfile()
+        # Check that we can open the file again on Windows
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write("abc")
+
+        filename = ip.mktempfile(data="blah")
+        with open(filename, "r", encoding="utf-8") as f:
+            self.assertEqual(f.read(), "blah")
+
+    def test_new_main_mod(self):
+        # Smoketest to check that this accepts a unicode module name
+        name = "jiefmw"
+        mod = ip.new_main_mod("%s.py" % name, name)
+        self.assertEqual(mod.__name__, name)
+
+    def test_get_exception_only(self):
+        try:
+            raise KeyboardInterrupt
+        except KeyboardInterrupt:
+            msg = ip.get_exception_only()
+        self.assertEqual(msg, "KeyboardInterrupt\n")
+
+        try:
+            raise DerivedInterrupt("foo")
+        except KeyboardInterrupt:
+            msg = ip.get_exception_only()
+        self.assertEqual(msg, "tests.test_interactiveshell.DerivedInterrupt: foo\n")
+
+    def test_inspect_text(self):
+        ip.run_cell("a = 5")
+        text = ip.object_inspect_text("a")
+        self.assertIsInstance(text, str)
+
+    def test_last_execution_result(self):
+        """Check that last execution result gets set correctly (GH-10702)"""
+        result = ip.run_cell("a = 5; a")
+        self.assertTrue(ip.last_execution_succeeded)
+        self.assertEqual(ip.last_execution_result.result, 5)
+
+        result = ip.run_cell("a = x_invalid_id_x")
+        self.assertFalse(ip.last_execution_succeeded)
+        self.assertFalse(ip.last_execution_result.success)
+        self.assertIsInstance(ip.last_execution_result.error_in_exec, NameError)
+
+    def test_reset_aliasing(self):
+        """Check that standard posix aliases work after %reset."""
+        if os.name != "posix":
+            return
+
+        ip.reset()
+        for cmd in ("clear", "more", "less", "man"):
+            res = ip.run_cell("%" + cmd)
+            self.assertEqual(res.success, True)
+
+
+@pytest.mark.skipif(
+    sys.implementation.name == "pypy"
+    and ((7, 3, 13) < sys.implementation.version < (7, 3, 16)),
+    reason="Unicode issues with scandir on PyPy, see https://github.com/pypy/pypy/issues/4860",
+)
+class TestSafeExecfileNonAsciiPath(unittest.TestCase):
+    @onlyif_unicode_paths
+    def setUp(self):
+        self.BASETESTDIR = tempfile.mkdtemp()
+        self.TESTDIR = join(self.BASETESTDIR, "åäö")
+        os.mkdir(self.TESTDIR)
+        with open(
+            join(self.TESTDIR, "åäötestscript.py"), "w", encoding="utf-8"
+        ) as sfile:
+            sfile.write("pass\n")
+        self.oldpath = os.getcwd()
+        os.chdir(self.TESTDIR)
+        self.fname = "åäötestscript.py"
+
+    def tearDown(self):
+        os.chdir(self.oldpath)
+        shutil.rmtree(self.BASETESTDIR)
+
+    @onlyif_unicode_paths
+    def test_1(self):
+        """Test safe_execfile with non-ascii path"""
+        ip.safe_execfile(self.fname, {}, raise_exceptions=True)
+
+
+class ExitCodeChecks(tt.TempFileMixin):
+    def setUp(self):
+        self.system = ip.system_raw
+
+    def test_exit_code_ok(self):
+        self.system("exit 0")
+        self.assertEqual(ip.user_ns["_exit_code"], 0)
+
+    def test_exit_code_error(self):
+        self.system("exit 1")
+        self.assertEqual(ip.user_ns["_exit_code"], 1)
+
+    @skipif(not hasattr(signal, "SIGALRM"))
+    def test_exit_code_signal(self):
+        self.mktmp(
+            "import signal, time\n"
+            "signal.setitimer(signal.ITIMER_REAL, 0.1)\n"
+            "time.sleep(1)\n"
+        )
+        self.system("%s %s" % (sys.executable, self.fname))
+        self.assertEqual(ip.user_ns["_exit_code"], -signal.SIGALRM)
+
+    @onlyif_cmds_exist("csh")
+    def test_exit_code_signal_csh(self):  # pragma: no cover
+        SHELL = os.environ.get("SHELL", None)
+        os.environ["SHELL"] = find_cmd("csh")
+        try:
+            self.test_exit_code_signal()
+        finally:
+            if SHELL is not None:
+                os.environ["SHELL"] = SHELL
+            else:
+                del os.environ["SHELL"]
+
+
+class TestSystemRaw(ExitCodeChecks):
+    def setUp(self):
+        super().setUp()
+        self.system = ip.system_raw
+
+    @onlyif_unicode_paths
+    def test_1(self):
+        """Test system_raw with non-ascii cmd"""
+        cmd = """python -c "'åäö'"   """
+        ip.system_raw(cmd)
+
+    @mock.patch("subprocess.call", side_effect=KeyboardInterrupt)
+    @mock.patch("os.system", side_effect=KeyboardInterrupt)
+    def test_control_c(self, *mocks):
+        try:
+            self.system("sleep 1 # won't happen")
+        except KeyboardInterrupt:  # pragma: no cove
+            self.fail(
+                "system call should intercept "
+                "keyboard interrupt from subprocess.call"
+            )
+        self.assertEqual(ip.user_ns["_exit_code"], -signal.SIGINT)
+
+
+@pytest.mark.parametrize("magic_cmd", ["pip", "conda", "cd"])
+def test_magic_warnings(magic_cmd):
+    if sys.platform == "win32":
+        to_mock = "os.system"
+        expected_arg, expected_kwargs = magic_cmd, dict()
+    else:
+        to_mock = "subprocess.call"
+        expected_arg, expected_kwargs = magic_cmd, dict(
+            shell=True, executable=os.environ.get("SHELL", None)
+        )
+
+    with mock.patch(to_mock, return_value=0) as mock_sub:
+        with pytest.warns(Warning, match=r"You executed the system command"):
+            ip.system_raw(magic_cmd)
+        mock_sub.assert_called_once_with(expected_arg, **expected_kwargs)
+
+
+# TODO: Exit codes are currently ignored on Windows.
+class TestSystemPipedExitCode(ExitCodeChecks):
+    def setUp(self):
+        super().setUp()
+        self.system = ip.system_piped
+
+    @skip_win32
+    def test_exit_code_ok(self):
+        ExitCodeChecks.test_exit_code_ok(self)
+
+    @skip_win32
+    def test_exit_code_error(self):
+        ExitCodeChecks.test_exit_code_error(self)
+
+    @skip_win32
+    def test_exit_code_signal(self):
+        ExitCodeChecks.test_exit_code_signal(self)
+
+
+class TestModules(tt.TempFileMixin):
+    def test_extraneous_loads(self):
+        """Test we're not loading modules on startup that we shouldn't."""
+        self.mktmp(
+            "import sys\n"
+            "print('numpy' in sys.modules)\n"
+            "print('ipyparallel' in sys.modules)\n"
+            "print('ipykernel' in sys.modules)\n"
+        )
+        out = "False\nFalse\nFalse\n"
+        tt.ipexec_validate(self.fname, out)
+
+
+class Negator(ast.NodeTransformer):
+    """Negates all number literals in an AST."""
+
+    def visit_Num(self, node):
+        node.value = -node.value
+        return node
+
+    def visit_Constant(self, node):
+        if isinstance(node.value, int):
+            return self.visit_Num(node)
+        return node
+
+
+class TestAstTransform(unittest.TestCase):
+    def setUp(self):
+        self.negator = Negator()
+        ip.ast_transformers.append(self.negator)
+
+    def tearDown(self):
+        ip.ast_transformers.remove(self.negator)
+
+    def test_non_int_const(self):
+        with tt.AssertPrints("hello"):
+            ip.run_cell('print("hello")')
+
+    def test_run_cell(self):
+        with tt.AssertPrints("-34"):
+            ip.run_cell("print(12 + 22)")
+
+        # A named reference to a number shouldn't be transformed.
+        ip.user_ns["n"] = 55
+        with tt.AssertNotPrints("-55"):
+            ip.run_cell("print(n)")
+
+    def test_timeit(self):
+        called = set()
+
+        def f(x):
+            called.add(x)
+
+        ip.push({"f": f})
+
+        with tt.AssertPrints("std. dev. of"):
+            ip.run_line_magic("timeit", "-n1 f(1)")
+        self.assertEqual(called, {-1})
+        called.clear()
+
+        with tt.AssertPrints("std. dev. of"):
+            ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
+        self.assertEqual(called, {-2, -3})
+
+    def test_time(self):
+        called = []
+
+        def f(x):
+            called.append(x)
+
+        ip.push({"f": f})
+
+        # Test with an expression
+        with tt.AssertPrints("Wall time: "):
+            ip.run_line_magic("time", "f(5+9)")
+        self.assertEqual(called, [-14])
+        called[:] = []
+
+        # Test with a statement (different code path)
+        with tt.AssertPrints("Wall time: "):
+            ip.run_line_magic("time", "a = f(-3 + -2)")
+        self.assertEqual(called, [5])
+
+    def test_macro(self):
+        ip.push({"a": 10})
+        # The AST transformation makes this do a+=-1
+        ip.define_macro("amacro", "a+=1\nprint(a)")
+
+        with tt.AssertPrints("9"):
+            ip.run_cell("amacro")
+        with tt.AssertPrints("8"):
+            ip.run_cell("amacro")
+
+
+class TestMiscTransform(unittest.TestCase):
+    def test_transform_only_once(self):
+        cleanup = 0
+        line_t = 0
+
+        def count_cleanup(lines):
+            nonlocal cleanup
+            cleanup += 1
+            return lines
+
+        def count_line_t(lines):
+            nonlocal line_t
+            line_t += 1
+            return lines
+
+        ip.input_transformer_manager.cleanup_transforms.append(count_cleanup)
+        ip.input_transformer_manager.line_transforms.append(count_line_t)
+
+        ip.run_cell("1")
+
+        assert cleanup == 1
+        assert line_t == 1
+
+
+class IntegerWrapper(ast.NodeTransformer):
+    """Wraps all integers in a call to Integer()"""
+
+    # for Python 3.7 and earlier
+    def visit_Num(self, node):
+        if isinstance(node.value, int):
+            return ast.Call(
+                func=ast.Name(id="Integer", ctx=ast.Load()), args=[node], keywords=[]
+            )
+        return node
+
+    # For Python 3.8+
+    def visit_Constant(self, node):
+        if isinstance(node.value, int):
+            return self.visit_Num(node)
+        return node
+
+
+class TestAstTransform2(unittest.TestCase):
+    def setUp(self):
+        self.intwrapper = IntegerWrapper()
+        ip.ast_transformers.append(self.intwrapper)
+
+        self.calls = []
+
+        def Integer(*args):
+            self.calls.append(args)
+            return args
+
+        ip.push({"Integer": Integer})
+
+    def tearDown(self):
+        ip.ast_transformers.remove(self.intwrapper)
+        del ip.user_ns["Integer"]
+
+    def test_run_cell(self):
+        ip.run_cell("n = 2")
+        self.assertEqual(self.calls, [(2,)])
+
+        # This shouldn't throw an error
+        ip.run_cell("o = 2.0")
+        self.assertEqual(ip.user_ns["o"], 2.0)
+
+    def test_run_cell_non_int(self):
+        ip.run_cell("n = 'a'")
+        assert self.calls == []
+
+    def test_timeit(self):
+        called = set()
+
+        def f(x):
+            called.add(x)
+
+        ip.push({"f": f})
+
+        with tt.AssertPrints("std. dev. of"):
+            ip.run_line_magic("timeit", "-n1 f(1)")
+        self.assertEqual(called, {(1,)})
+        called.clear()
+
+        with tt.AssertPrints("std. dev. of"):
+            ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
+        self.assertEqual(called, {(2,), (3,)})
+
+
+class ErrorTransformer(ast.NodeTransformer):
+    """Throws an error when it sees a number."""
+
+    def visit_Constant(self, node):
+        if isinstance(node.value, int):
+            raise ValueError("test")
+        return node
+
+
+class TestAstTransformError(unittest.TestCase):
+    def test_unregistering(self):
+        err_transformer = ErrorTransformer()
+        ip.ast_transformers.append(err_transformer)
+
+        with self.assertWarnsRegex(UserWarning, "It will be unregistered"):
+            ip.run_cell("1 + 2")
+
+        # This should have been removed.
+        self.assertNotIn(err_transformer, ip.ast_transformers)
+
+
+class StringRejector(ast.NodeTransformer):
+    """Throws an InputRejected when it sees a string literal.
+
+    Used to verify that NodeTransformers can signal that a piece of code should
+    not be executed by throwing an InputRejected.
+    """
+
+    def visit_Constant(self, node):
+        if isinstance(node.value, str):
+            raise InputRejected("test")
+        return node
+
+
+class TestAstTransformInputRejection(unittest.TestCase):
+    def setUp(self):
+        self.transformer = StringRejector()
+        ip.ast_transformers.append(self.transformer)
+
+    def tearDown(self):
+        ip.ast_transformers.remove(self.transformer)
+
+    def test_input_rejection(self):
+        """Check that NodeTransformers can reject input."""
+
+        expect_exception_tb = tt.AssertPrints("InputRejected: test")
+        expect_no_cell_output = tt.AssertNotPrints("'unsafe'", suppress=False)
+
+        # Run the same check twice to verify that the transformer is not
+        # disabled after raising.
+        with expect_exception_tb, expect_no_cell_output:
+            ip.run_cell("'unsafe'")
+
+        with expect_exception_tb, expect_no_cell_output:
+            res = ip.run_cell("'unsafe'")
+
+        self.assertIsInstance(res.error_before_exec, InputRejected)
+
+
+def test__IPYTHON__():
+    # This shouldn't raise a NameError, that's all
+    __IPYTHON__
+
+
+class DummyRepr(object):
+    def __repr__(self):
+        return "DummyRepr"
+
+    def _repr_html_(self):
+        return "<b>dummy</b>"
+
+    def _repr_javascript_(self):
+        return "console.log('hi');", {"key": "value"}
+
+
+def test_user_variables():
+    # enable all formatters
+    ip.display_formatter.active_types = ip.display_formatter.format_types
+
+    ip.user_ns["dummy"] = d = DummyRepr()
+    keys = {"dummy", "doesnotexist"}
+    r = ip.user_expressions({key: key for key in keys})
+
+    assert keys == set(r.keys())
+    dummy = r["dummy"]
+    assert {"status", "data", "metadata"} == set(dummy.keys())
+    assert dummy["status"] == "ok"
+    data = dummy["data"]
+    metadata = dummy["metadata"]
+    assert data.get("text/html") == d._repr_html_()
+    js, jsmd = d._repr_javascript_()
+    assert data.get("application/javascript") == js
+    assert metadata.get("application/javascript") == jsmd
+
+    dne = r["doesnotexist"]
+    assert dne["status"] == "error"
+    assert dne["ename"] == "NameError"
+
+    # back to text only
+    ip.display_formatter.active_types = ["text/plain"]
+
+
+def test_user_expression():
+    # enable all formatters
+    ip.display_formatter.active_types = ip.display_formatter.format_types
+    query = {
+        "a": "1 + 2",
+        "b": "1/0",
+    }
+    r = ip.user_expressions(query)
+    import pprint
+
+    pprint.pprint(r)
+    assert set(r.keys()) == set(query.keys())
+    a = r["a"]
+    assert {"status", "data", "metadata"} == set(a.keys())
+    assert a["status"] == "ok"
+    data = a["data"]
+    metadata = a["metadata"]
+    assert data.get("text/plain") == "3"
+
+    b = r["b"]
+    assert b["status"] == "error"
+    assert b["ename"] == "ZeroDivisionError"
+
+    # back to text only
+    ip.display_formatter.active_types = ["text/plain"]
+
+
+class TestSyntaxErrorTransformer(unittest.TestCase):
+    """Check that SyntaxError raised by an input transformer is handled by run_cell()"""
+
+    @staticmethod
+    def transformer(lines):
+        for line in lines:
+            pos = line.find("syntaxerror")
+            if pos >= 0:
+                e = SyntaxError('input contains "syntaxerror"')
+                e.text = line
+                e.offset = pos + 1
+                raise e
+        return lines
+
+    def setUp(self):
+        ip.input_transformers_post.append(self.transformer)
+
+    def tearDown(self):
+        ip.input_transformers_post.remove(self.transformer)
+
+    def test_syntaxerror_input_transformer(self):
+        with tt.AssertPrints("1234"):
+            ip.run_cell("1234")
+        with tt.AssertPrints("SyntaxError: invalid syntax"):
+            ip.run_cell("1 2 3")  # plain python syntax error
+        with tt.AssertPrints('SyntaxError: input contains "syntaxerror"'):
+            ip.run_cell("2345  # syntaxerror")  # input transformer syntax error
+        with tt.AssertPrints("3456"):
+            ip.run_cell("3456")
+
+
+class TestWarningSuppression(unittest.TestCase):
+    def test_warning_suppression(self):
+        ip.run_cell("import warnings")
+        try:
+            with self.assertWarnsRegex(UserWarning, "asdf"):
+                ip.run_cell("warnings.warn('asdf')")
+            # Here's the real test -- if we run that again, we should get the
+            # warning again. Traditionally, each warning was only issued once per
+            # IPython session (approximately), even if the user typed in new and
+            # different code that should have also triggered the warning, leading
+            # to much confusion.
+            with self.assertWarnsRegex(UserWarning, "asdf"):
+                ip.run_cell("warnings.warn('asdf')")
+        finally:
+            ip.run_cell("del warnings")
+
+    def test_deprecation_warning(self):
+        ip.run_cell(
+            """
+import warnings
+def wrn():
+    warnings.warn(
+        "I AM  A WARNING",
+        DeprecationWarning
+    )
+        """
+        )
+        try:
+            with self.assertWarnsRegex(DeprecationWarning, "I AM  A WARNING"):
+                ip.run_cell("wrn()")
+        finally:
+            ip.run_cell("del warnings")
+            ip.run_cell("del wrn")
+
+
+class TestImportNoDeprecate(tt.TempFileMixin):
+    def setUp(self):
+        """Make a valid python temp file."""
+        self.mktmp(
+            """
+import warnings
+def wrn():
+    warnings.warn(
+        "I AM  A WARNING",
+        DeprecationWarning
+    )
+"""
+        )
+        super().setUp()
+
+    def test_no_dep(self):
+        """
+        No deprecation warning should be raised from imported functions
+        """
+        ip.run_cell("from {} import wrn".format(self.fname))
+
+        with tt.AssertNotPrints("I AM  A WARNING"):
+            ip.run_cell("wrn()")
+        ip.run_cell("del wrn")
+
+
+def test_custom_exc_count():
+    hook = mock.Mock(return_value=None)
+    ip.set_custom_exc((SyntaxError,), hook)
+    before = ip.execution_count
+    ip.run_cell("def foo()", store_history=True)
+    # restore default excepthook
+    ip.set_custom_exc((), None)
+    assert hook.call_count == 1
+    assert ip.execution_count == before + 1
+
+
+def test_run_cell_async():
+    ip.run_cell("import asyncio")
+    coro = ip.run_cell_async("await asyncio.sleep(0.01)\n5")
+    assert asyncio.iscoroutine(coro)
+    loop = asyncio.new_event_loop()
+    result = loop.run_until_complete(coro)
+    assert isinstance(result, interactiveshell.ExecutionResult)
+    assert result.result == 5
+
+
+def test_run_cell_await():
+    ip.run_cell("import asyncio")
+    result = ip.run_cell("await asyncio.sleep(0.01); 10")
+    assert ip.user_ns["_"] == 10
+
+
+def test_run_cell_asyncio_run():
+    ip.run_cell("import asyncio")
+    result = ip.run_cell("await asyncio.sleep(0.01); 1")
+    assert ip.user_ns["_"] == 1
+    result = ip.run_cell("asyncio.run(asyncio.sleep(0.01)); 2")
+    assert ip.user_ns["_"] == 2
+    result = ip.run_cell("await asyncio.sleep(0.01); 3")
+    assert ip.user_ns["_"] == 3
+
+
+def test_should_run_async():
+    assert not ip.should_run_async("a = 5", transformed_cell="a = 5")
+    assert ip.should_run_async("await x", transformed_cell="await x")
+    assert ip.should_run_async(
+        "import asyncio; await asyncio.sleep(1)",
+        transformed_cell="import asyncio; await asyncio.sleep(1)",
+    )
+
+
+def test_set_custom_completer():
+    num_completers = len(ip.Completer.matchers)
+
+    def foo(*args, **kwargs):
+        return "I'm a completer!"
+
+    ip.set_custom_completer(foo, 0)
+
+    # check that we've really added a new completer
+    assert len(ip.Completer.matchers) == num_completers + 1
+
+    # check that the first completer is the function we defined
+    assert ip.Completer.matchers[0]() == "I'm a completer!"
+
+    # clean up
+    ip.Completer.custom_matchers.pop()
+
+
+class TestShowTracebackAttack(unittest.TestCase):
+    """Test that the interactive shell is resilient against the client attack of
+    manipulating the showtracebacks method. These attacks shouldn't result in an
+    unhandled exception in the kernel."""
+
+    def setUp(self):
+        self.orig_showtraceback = interactiveshell.InteractiveShell.showtraceback
+
+    def tearDown(self):
+        interactiveshell.InteractiveShell.showtraceback = self.orig_showtraceback
+
+    def test_set_show_tracebacks_none(self):
+        """Test the case of the client setting showtracebacks to None"""
+
+        result = ip.run_cell(
+            """
+            import IPython.core.interactiveshell
+            IPython.core.interactiveshell.InteractiveShell.showtraceback = None
+
+            assert False, "This should not raise an exception"
+        """
+        )
+        print(result)
+
+        assert result.result is None
+        assert isinstance(result.error_in_exec, TypeError)
+        assert str(result.error_in_exec) == "'NoneType' object is not callable"
+
+    def test_set_show_tracebacks_noop(self):
+        """Test the case of the client setting showtracebacks to a no op lambda"""
+
+        result = ip.run_cell(
+            """
+            import IPython.core.interactiveshell
+            IPython.core.interactiveshell.InteractiveShell.showtraceback = lambda *args, **kwargs: None
+
+            assert False, "This should not raise an exception"
+        """
+        )
+        print(result)
+
+        assert result.result is None
+        assert isinstance(result.error_in_exec, AssertionError)
+        assert str(result.error_in_exec) == "This should not raise an exception"
+
+
+@skip_if_not_osx
+def test_enable_gui_osx():
+    simple_prompt = ip.simple_prompt
+    ip.simple_prompt = False
+
+    ip.enable_gui("osx")
+    assert ip.active_eventloop == "osx"
+    ip.enable_gui()
+
+    # The following line fails for IPython <= 8.25.0
+    ip.enable_gui("macosx")
+    assert ip.active_eventloop == "osx"
+    ip.enable_gui()
+
+    ip.simple_prompt = simple_prompt
diff --git a/tests/test_interactivshell.py b/tests/test_interactivshell.py
new file mode 100644
index 00000000000..7819537fb33
--- /dev/null
+++ b/tests/test_interactivshell.py
@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+"""Tests for the TerminalInteractiveShell and related pieces."""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import sys
+import unittest
+import os
+
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+
+
+from IPython.testing import tools as tt
+
+from IPython.terminal.ptutils import _elide, _adjust_completion_text_based_on_context
+from IPython.terminal.shortcuts.auto_suggest import NavigableAutoSuggestFromHistory
+
+
+class TestAutoSuggest(unittest.TestCase):
+    def test_changing_provider(self):
+        ip = get_ipython()
+        ip.autosuggestions_provider = None
+        self.assertEqual(ip.auto_suggest, None)
+        ip.autosuggestions_provider = "AutoSuggestFromHistory"
+        self.assertIsInstance(ip.auto_suggest, AutoSuggestFromHistory)
+        ip.autosuggestions_provider = "NavigableAutoSuggestFromHistory"
+        self.assertIsInstance(ip.auto_suggest, NavigableAutoSuggestFromHistory)
+
+
+def test_elide():
+    _elide("concatenate((a1, a2, ...), axis", "", min_elide=30)  # do not raise
+    _elide("concatenate((a1, a2, ..), . axis", "", min_elide=30)  # do not raise
+    assert (
+        _elide("aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh", "", min_elide=30)
+        == "aaaa.b…g.hhhhhh"
+    )
+
+    test_string = os.sep.join(["", 10 * "a", 10 * "b", 10 * "c", ""])
+    expect_string = os.sep + "a" + "\N{HORIZONTAL ELLIPSIS}" + "b" + os.sep + 10 * "c"
+    assert _elide(test_string, "", min_elide=30) == expect_string
+
+
+def test_elide_typed_normal():
+    assert (
+        _elide(
+            "the quick brown fox jumped over the lazy dog",
+            "the quick brown fox",
+            min_elide=10,
+        )
+        == "the…fox jumped over the lazy dog"
+    )
+
+
+def test_elide_typed_short_match():
+    """
+    if the match is too short we don't elide.
+    avoid the "the...the"
+    """
+    assert (
+        _elide("the quick brown fox jumped over the lazy dog", "the", min_elide=10)
+        == "the quick brown fox jumped over the lazy dog"
+    )
+
+
+def test_elide_typed_no_match():
+    """
+    if the match is too short we don't elide.
+    avoid the "the...the"
+    """
+    # here we typed red instead of brown
+    assert (
+        _elide(
+            "the quick brown fox jumped over the lazy dog",
+            "the quick red fox",
+            min_elide=10,
+        )
+        == "the quick brown fox jumped over the lazy dog"
+    )
+
+
+class TestContextAwareCompletion(unittest.TestCase):
+    def test_adjust_completion_text_based_on_context(self):
+        # Adjusted case
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a=)", 7), "arg1"
+        )
+
+        # Untouched cases
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a)", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("%magic", "func1(a=)", 7), "%magic"
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("func2", "func1(a=)", 7), "func2"
+        )
+
+
+# Decorator for interaction loop tests -----------------------------------------
+
+
+class mock_input_helper(object):
+    """Machinery for tests of the main interact loop.
+
+    Used by the mock_input decorator.
+    """
+
+    def __init__(self, testgen):
+        self.testgen = testgen
+        self.exception = None
+        self.ip = get_ipython()
+
+    def __enter__(self):
+        self.orig_prompt_for_code = self.ip.prompt_for_code
+        self.ip.prompt_for_code = self.fake_input
+        return self
+
+    def __exit__(self, etype, value, tb):
+        self.ip.prompt_for_code = self.orig_prompt_for_code
+
+    def fake_input(self):
+        try:
+            return next(self.testgen)
+        except StopIteration:
+            self.ip.keep_running = False
+            return ""
+        except:
+            self.exception = sys.exc_info()
+            self.ip.keep_running = False
+            return ""
+
+
+def mock_input(testfunc):
+    """Decorator for tests of the main interact loop.
+
+    Write the test as a generator, yield-ing the input strings, which IPython
+    will see as if they were typed in at the prompt.
+    """
+
+    def test_method(self):
+        testgen = testfunc(self)
+        with mock_input_helper(testgen) as mih:
+            mih.ip.interact()
+
+        if mih.exception is not None:
+            # Re-raise captured exception
+            etype, value, tb = mih.exception
+            import traceback
+
+            traceback.print_tb(tb, file=sys.stdout)
+            del tb  # Avoid reference loop
+            raise value
+
+    return test_method
+
+
+# Test classes -----------------------------------------------------------------
+
+
+class InteractiveShellTestCase(unittest.TestCase):
+    def rl_hist_entries(self, rl, n):
+        """Get last n readline history entries as a list"""
+        return [
+            rl.get_history_item(rl.get_current_history_length() - x)
+            for x in range(n - 1, -1, -1)
+        ]
+
+    @mock_input
+    def test_inputtransformer_syntaxerror(self):
+        ip = get_ipython()
+        ip.input_transformers_post.append(syntax_error_transformer)
+
+        try:
+            # raise Exception
+            with tt.AssertPrints("4", suppress=False):
+                yield "print(2*2)"
+
+            with tt.AssertPrints("SyntaxError: input contains", suppress=False):
+                yield "print(2345) # syntaxerror"
+
+            with tt.AssertPrints("16", suppress=False):
+                yield "print(4*4)"
+
+        finally:
+            ip.input_transformers_post.remove(syntax_error_transformer)
+
+    def test_repl_not_plain_text(self):
+        ip = get_ipython()
+        formatter = ip.display_formatter
+        assert formatter.active_types == ["text/plain"]
+
+        # terminal may have arbitrary mimetype handler to open external viewer
+        # or inline images.
+        assert formatter.ipython_display_formatter.enabled
+
+        class Test(object):
+            def __repr__(self):
+                return "<Test %i>" % id(self)
+
+            def _repr_html_(self):
+                return "<html>"
+
+        # verify that HTML repr isn't computed
+        obj = Test()
+        data, _ = formatter.format(obj)
+        self.assertEqual(data, {"text/plain": repr(obj)})
+
+        class Test2(Test):
+            def _ipython_display_(self):
+                from IPython.display import display, HTML
+
+                display(HTML("<custom>"))
+
+        # verify that mimehandlers are called
+        called = False
+
+        def handler(data, metadata):
+            print("Handler called")
+            nonlocal called
+            called = True
+
+        ip.display_formatter.active_types.append("text/html")
+        ip.display_formatter.formatters["text/html"].enabled = True
+        ip.mime_renderers["text/html"] = handler
+        try:
+            obj = Test()
+            display(obj)
+        finally:
+            ip.display_formatter.formatters["text/html"].enabled = False
+            del ip.mime_renderers["text/html"]
+
+        assert called == True
+
+
+def syntax_error_transformer(lines):
+    """Transformer that throws SyntaxError if 'syntaxerror' is in the code."""
+    for line in lines:
+        pos = line.find("syntaxerror")
+        if pos >= 0:
+            e = SyntaxError('input contains "syntaxerror"')
+            e.text = line
+            e.offset = pos + 1
+            raise e
+    return lines
+
+
+class TerminalMagicsTestCase(unittest.TestCase):
+    def test_paste_magics_blankline(self):
+        """Test that code with a blank line doesn't get split (gh-3246)."""
+        ip = get_ipython()
+        s = "def pasted_func(a):\n" "    b = a+1\n" "\n" "    return b"
+
+        tm = ip.magics_manager.registry["TerminalMagics"]
+        tm.store_or_execute(s, name=None)
+
+        self.assertEqual(ip.user_ns["pasted_func"](54), 55)
diff --git a/tests/test_io.py b/tests/test_io.py
new file mode 100644
index 00000000000..24afea4e5e8
--- /dev/null
+++ b/tests/test_io.py
@@ -0,0 +1,60 @@
+# encoding: utf-8
+"""Tests for io.py"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import sys
+from io import StringIO
+
+import unittest
+
+from IPython.utils.io import Tee, capture_output
+
+
+def test_tee_simple():
+    "Very simple check with stdout only"
+    chan = StringIO()
+    text = "Hello"
+    tee = Tee(chan, channel="stdout")
+    print(text, file=chan)
+    assert chan.getvalue() == text + "\n"
+    tee.close()
+
+
+class TeeTestCase(unittest.TestCase):
+    def tchan(self, channel):
+        trap = StringIO()
+        chan = StringIO()
+        text = "Hello"
+
+        std_ori = getattr(sys, channel)
+        setattr(sys, channel, trap)
+
+        tee = Tee(chan, channel=channel)
+
+        print(text, end="", file=chan)
+        trap_val = trap.getvalue()
+        self.assertEqual(chan.getvalue(), text)
+
+        tee.close()
+
+        setattr(sys, channel, std_ori)
+        assert getattr(sys, channel) == std_ori
+
+    def test(self):
+        for chan in ["stdout", "stderr"]:
+            self.tchan(chan)
+
+
+class TestIOStream(unittest.TestCase):
+    def test_capture_output(self):
+        """capture_output() context works"""
+
+        with capture_output() as io:
+            print("hi, stdout")
+            print("hi, stderr", file=sys.stderr)
+
+        self.assertEqual(io.stdout, "hi, stdout\n")
+        self.assertEqual(io.stderr, "hi, stderr\n")
diff --git a/tests/test_iplib.py b/tests/test_iplib.py
new file mode 100644
index 00000000000..5aa614b1af0
--- /dev/null
+++ b/tests/test_iplib.py
@@ -0,0 +1,247 @@
+"""Tests for the key interactiveshell module, where the main ipython class is defined."""
+
+import stack_data
+import sys
+
+SV_VERSION = tuple([int(x) for x in stack_data.__version__.split(".")[0:2]])
+
+
+def test_reset():
+    """reset must clear most namespaces."""
+
+    # Check that reset runs without error
+    ip.reset()
+
+    # Once we've reset it (to clear of any junk that might have been there from
+    # other tests, we can count how many variables are in the user's namespace
+    nvars_user_ns = len(ip.user_ns)
+    nvars_hidden = len(ip.user_ns_hidden)
+
+    # Now add a few variables to user_ns, and check that reset clears them
+    ip.user_ns["x"] = 1
+    ip.user_ns["y"] = 1
+    ip.reset()
+
+    # Finally, check that all namespaces have only as many variables as we
+    # expect to find in them:
+    assert len(ip.user_ns) == nvars_user_ns
+    assert len(ip.user_ns_hidden) == nvars_hidden
+
+
+# Tests for reporting of exceptions in various modes, handling of SystemExit,
+# and %tb functionality.  This is really a mix of testing ultraTB and interactiveshell.
+
+# fmt: off
+
+def doctest_tb_plain():
+    """
+    In [18]: xmode plain
+    Exception reporting mode: Plain
+
+    In [19]: run simpleerr.py
+    Traceback (most recent call last):
+      File ...:...
+        bar(mode)
+      File ...:... in bar
+        div0()
+      File ...:... in div0
+        x / y
+    ZeroDivisionError: ...
+    """
+
+
+def doctest_tb_context():
+    """
+    In [3]: xmode context
+    Exception reporting mode: Context
+
+    In [4]: run simpleerr.py
+    ---------------------------------------------------------------------------
+    ZeroDivisionError                         Traceback (most recent call last)
+    <BLANKLINE>
+    ...
+         34     except IndexError:
+         35         mode = "div"
+    ---> 37     bar(mode)
+    <BLANKLINE>
+    ... in bar(mode)
+         18     "bar"
+         19     if mode == "div":
+    ---> 20         div0()
+         21     elif mode == "exit":
+         22         try:
+    <BLANKLINE>
+    ... in div0()
+          8     x = 1
+          9     y = 0
+    ---> 10     x / y
+    <BLANKLINE>
+    ZeroDivisionError: ..."""
+
+
+def doctest_tb_verbose():
+    """
+    In [5]: xmode verbose
+    Exception reporting mode: Verbose
+
+    In [6]: run simpleerr.py
+    ---------------------------------------------------------------------------
+    ZeroDivisionError                         Traceback (most recent call last)
+    <BLANKLINE>
+    ...
+         34     except IndexError:
+         35         mode = "div"
+    ---> 37     bar(mode)
+            mode = 'div'
+    <BLANKLINE>
+    ... in bar(mode='div')
+         18     "bar"
+         19     if mode == "div":
+    ---> 20         div0()
+         21     elif mode == "exit":
+         22         try:
+    <BLANKLINE>
+    ... in div0()
+          8     x = 1
+          9     y = 0
+    ---> 10     x / y
+            x = 1
+            y = 0
+    <BLANKLINE>
+    ZeroDivisionError: ...
+    """
+
+
+def doctest_tb_sysexit():
+    """
+    In [17]: %xmode plain
+    Exception reporting mode: Plain
+
+    In [18]: %run simpleerr.py exit
+    An exception has occurred, use %tb to see the full traceback.
+    SystemExit: (1, 'Mode = exit')
+
+    In [19]: %run simpleerr.py exit 2
+    An exception has occurred, use %tb to see the full traceback.
+    SystemExit: (2, 'Mode = exit')
+
+    In [20]: %tb
+    Traceback (most recent call last):
+      File ...:... in execfile
+        exec(compiler(f.read(), fname, "exec"), glob, loc)
+      File ...:...
+        bar(mode)
+      File ...:... in bar
+        sysexit(stat, mode)
+      File ...:... in sysexit
+        raise SystemExit(stat, f"Mode = {mode}")
+    SystemExit: (2, 'Mode = exit')
+
+    In [21]: %xmode context
+    Exception reporting mode: Context
+
+    In [22]: %tb
+    ---------------------------------------------------------------------------
+    SystemExit                                Traceback (most recent call last)
+    File ..., in execfile(fname, glob, loc, compiler)
+         ... with open(fname, "rb") as f:
+         ...     compiler = compiler or compile
+    ---> ...     exec(compiler(f.read(), fname, "exec"), glob, loc)
+    ...
+         34     except IndexError:
+         35         mode = "div"
+    ---> 37     bar(mode)
+    <BLANKLINE>
+    ...bar(mode)
+         24         except:
+         25             stat = 1
+    ---> 26         sysexit(stat, mode)
+         27     else:
+         28         raise ValueError("Unknown mode")
+    <BLANKLINE>
+    ...sysexit(stat, mode)
+         13 def sysexit(stat, mode):
+    ---> 14     raise SystemExit(stat, f"Mode = {mode}")
+    <BLANKLINE>
+    SystemExit: (2, 'Mode = exit')
+    """
+
+
+if SV_VERSION < (0, 6):
+
+    def doctest_tb_sysexit_verbose_stack_data_05():
+        """
+        In [18]: %run simpleerr.py exit
+        An exception has occurred, use %tb to see the full traceback.
+        SystemExit: (1, 'Mode = exit')
+
+        In [19]: %run simpleerr.py exit 2
+        An exception has occurred, use %tb to see the full traceback.
+        SystemExit: (2, 'Mode = exit')
+
+        In [23]: %xmode verbose
+        Exception reporting mode: Verbose
+
+        In [24]: %tb
+        ---------------------------------------------------------------------------
+        SystemExit                                Traceback (most recent call last)
+        <BLANKLINE>
+        ...
+             34     except IndexError:
+             35         mode = "div"
+        ---> 37     bar(mode)
+                mode = "exit"
+        <BLANKLINE>
+        ... in bar(mode="exit")
+             ...     except:
+             ...         stat = 1
+        ---> ...     sysexit(stat, mode)
+                mode = "exit"
+                stat = 2
+            ...     else:
+            ...         raise ValueError("Unknown mode")
+        <BLANKLINE>
+        ... in sysexit(stat=2, mode="exit")
+             13 def sysexit(stat, mode):
+        ---> 14     raise SystemExit(stat, f"Mode = {mode}")
+                stat = 2
+        <BLANKLINE>
+        SystemExit: (2, 'Mode = exit')
+        """
+
+
+def test_run_cell():
+    import textwrap
+
+    ip.run_cell("a = 10\na+=1")
+    ip.run_cell("assert a == 11\nassert 1")
+
+    assert ip.user_ns["a"] == 11
+    complex = textwrap.dedent(
+        """
+    if 1:
+        print "hello"
+        if 1:
+            print "world"
+        
+    if 2:
+        print "foo"
+
+    if 3:
+        print "bar"
+
+    if 4:
+        print "bar"
+    
+    """
+    )
+    # Simply verifies that this kind of input is run
+    ip.run_cell(complex)
+    
+
+def test_db():
+    """Test the internal database used for variable persistence."""
+    ip.db["__unittest_"] = 12
+    assert ip.db["__unittest_"] == 12
+    del ip.db["__unittest_"]
+    assert "__unittest_" not in ip.db
diff --git a/tests/test_ipunittest.py b/tests/test_ipunittest.py
new file mode 100644
index 00000000000..9636883436b
--- /dev/null
+++ b/tests/test_ipunittest.py
@@ -0,0 +1,135 @@
+"""Tests for IPython's test support utilities.
+
+These are decorators that allow standalone functions and docstrings to be seen
+as tests by unittest, replicating some of nose's functionality.  Additionally,
+IPython-syntax docstrings can be auto-converted to '>>>' so that ipython
+sessions can be copy-pasted as tests.
+
+This file can be run as a script, and it will call unittest.main().  We must
+check that it works with unittest as well as with nose...
+
+
+Notes:
+
+- Using nosetests --with-doctest --doctest-tests testfile.py
+  will find docstrings as tests wherever they are, even in methods.  But
+  if we use ipython syntax in the docstrings, they must be decorated with
+  @ipdocstring.  This is OK for test-only code, but not for user-facing
+  docstrings where we want to keep the ipython syntax.
+
+- Using nosetests --with-doctest file.py
+  also finds doctests if the file name doesn't have 'test' in it, because it is
+  treated like a normal module.  But if nose treats the file like a test file,
+  then for normal classes to be doctested the extra --doctest-tests is
+  necessary.
+
+- running this script with python (it has a __main__ section at the end) misses
+  one docstring test, the one embedded in the Foo object method.  Since our
+  approach relies on using decorators that create standalone TestCase
+  instances, it can only be used for functions, not for methods of objects.
+Authors
+-------
+
+- Fernando Perez <Fernando.Perez@berkeley.edu>
+"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2009-2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+from IPython.testing.ipunittest import ipdoctest, ipdocstring
+
+# -----------------------------------------------------------------------------
+# Test classes and functions
+# -----------------------------------------------------------------------------
+
+# we do not want docstring reformatting here
+# fmt: off
+
+@ipdoctest
+def simple_dt():
+    """
+    >>> print(1+1)
+    2
+    """
+
+
+@ipdoctest
+def ipdt_flush():
+    """
+In [20]: print(1)
+1
+
+In [26]: for i in range(4):
+   ....:     print(i)
+   ....:     
+   ....: 
+0
+1
+2
+3
+
+In [27]: 3+4
+Out[27]: 7
+"""
+
+
+@ipdoctest
+def ipdt_indented_test():
+    """
+    In [20]: print(1)
+    1
+
+    In [26]: for i in range(4):
+       ....:     print(i)
+       ....:     
+       ....: 
+    0
+    1
+    2
+    3
+
+    In [27]: 3+4
+    Out[27]: 7
+    """
+
+
+class Foo(object):
+    """For methods, the normal decorator doesn't work.
+
+    But rewriting the docstring with ip2py does, *but only if using nose
+    --with-doctest*.  Do we want to have that as a dependency?
+    """
+
+    @ipdocstring
+    def ipdt_method(self):
+        """
+        In [20]: print(1)
+        1
+
+        In [26]: for i in range(4):
+           ....:     print(i)
+           ....:     
+           ....: 
+        0
+        1
+        2
+        3
+
+        In [27]: 3+4
+        Out[27]: 7
+        """
+
+    def normaldt_method(self):
+        """
+        >>> print(1+1)
+        2
+        """
diff --git a/tests/test_latextools.py b/tests/test_latextools.py
new file mode 100644
index 00000000000..879ed57008f
--- /dev/null
+++ b/tests/test_latextools.py
@@ -0,0 +1,209 @@
+"""Tests for IPython.utils.path.py"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from contextlib import contextmanager
+from unittest.mock import patch
+
+import pytest
+
+from IPython.lib import latextools
+from IPython.testing.decorators import (
+    onlyif_cmds_exist,
+    skipif_not_matplotlib,
+)
+from IPython.utils.process import FindCmdError
+
+
+@pytest.mark.parametrize("command", ["latex", "dvipng"])
+def test_check_latex_to_png_dvipng_fails_when_no_cmd(command):
+    def mock_find_cmd(arg):
+        if arg == command:
+            raise FindCmdError
+
+    with patch.object(latextools, "find_cmd", mock_find_cmd):
+        assert latextools.latex_to_png_dvipng("whatever", True) is None
+
+
+@contextmanager
+def no_op(*args, **kwargs):
+    yield
+
+
+@onlyif_cmds_exist("latex", "dvipng")
+@pytest.mark.parametrize("s, wrap", [("$$x^2$$", False), ("x^2", True)])
+def test_latex_to_png_dvipng_runs(s, wrap):
+    """
+    Test that latex_to_png_dvipng just runs without error.
+    """
+
+    def mock_kpsewhich(filename):
+        assert filename == "breqn.sty"
+        return None
+
+    latextools.latex_to_png_dvipng(s, wrap)
+
+    with patch_latextool(mock_kpsewhich):
+        latextools.latex_to_png_dvipng(s, wrap)
+
+
+def mock_kpsewhich(filename):
+    assert filename == "breqn.sty"
+    return None
+
+
+@contextmanager
+def patch_latextool(mock=mock_kpsewhich):
+    with patch.object(latextools, "kpsewhich", mock):
+        yield
+
+
+@pytest.mark.parametrize("context", [no_op, patch_latextool])
+@pytest.mark.parametrize("s_wrap", [("$x^2$", False), ("x^2", True)])
+def test_latex_to_png_mpl_runs(s_wrap, context):
+    """
+    Test that latex_to_png_mpl just runs without error.
+    """
+    try:
+        import matplotlib
+    except ImportError:
+        pytest.skip("This needs matplotlib to be available")
+        return
+    s, wrap = s_wrap
+    with context():
+        latextools.latex_to_png_mpl(s, wrap)
+
+
+@skipif_not_matplotlib
+def test_latex_to_html():
+    img = latextools.latex_to_html("$x^2$")
+    assert "data:image/png;base64,iVBOR" in img
+
+
+def test_genelatex_no_wrap():
+    """
+    Test genelatex with wrap=False.
+    """
+
+    def mock_kpsewhich(filename):
+        assert False, "kpsewhich should not be called " "(called with {0})".format(
+            filename
+        )
+
+    with patch_latextool(mock_kpsewhich):
+        assert (
+            "\n".join(latextools.genelatex("body text", False))
+            == r"""\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amsthm}
+\usepackage{amssymb}
+\usepackage{bm}
+\pagestyle{empty}
+\begin{document}
+body text
+\end{document}"""
+        )
+
+
+def test_genelatex_wrap_with_breqn():
+    """
+    Test genelatex with wrap=True for the case breqn.sty is installed.
+    """
+
+    def mock_kpsewhich(filename):
+        assert filename == "breqn.sty"
+        return "path/to/breqn.sty"
+
+    with patch_latextool(mock_kpsewhich):
+        assert (
+            "\n".join(latextools.genelatex("x^2", True))
+            == r"""\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amsthm}
+\usepackage{amssymb}
+\usepackage{bm}
+\usepackage{breqn}
+\pagestyle{empty}
+\begin{document}
+\begin{dmath*}
+x^2
+\end{dmath*}
+\end{document}"""
+        )
+
+
+def test_genelatex_wrap_without_breqn():
+    """
+    Test genelatex with wrap=True for the case breqn.sty is not installed.
+    """
+
+    def mock_kpsewhich(filename):
+        assert filename == "breqn.sty"
+        return None
+
+    with patch_latextool(mock_kpsewhich):
+        assert (
+            "\n".join(latextools.genelatex("x^2", True))
+            == r"""\documentclass{article}
+\usepackage{amsmath}
+\usepackage{amsthm}
+\usepackage{amssymb}
+\usepackage{bm}
+\pagestyle{empty}
+\begin{document}
+$$x^2$$
+\end{document}"""
+        )
+
+
+@skipif_not_matplotlib
+@onlyif_cmds_exist("latex", "dvipng")
+def test_latex_to_png_color():
+    """
+    Test color settings for latex_to_png.
+    """
+    latex_string = "$x^2$"
+    default_value = latextools.latex_to_png(latex_string, wrap=False)
+    default_hexblack = latextools.latex_to_png(
+        latex_string, wrap=False, color="#000000"
+    )
+    dvipng_default = latextools.latex_to_png_dvipng(latex_string, False)
+    dvipng_black = latextools.latex_to_png_dvipng(latex_string, False, "Black")
+    assert dvipng_default == dvipng_black
+    mpl_default = latextools.latex_to_png_mpl(latex_string, False)
+    mpl_black = latextools.latex_to_png_mpl(latex_string, False, "Black")
+    assert mpl_default == mpl_black
+    assert default_value in [dvipng_black, mpl_black]
+    assert default_hexblack in [dvipng_black, mpl_black]
+
+    # Test that dvips name colors can be used without error
+    dvipng_maroon = latextools.latex_to_png_dvipng(latex_string, False, "Maroon")
+    # And that it doesn't return the black one
+    assert dvipng_black != dvipng_maroon
+
+    mpl_maroon = latextools.latex_to_png_mpl(latex_string, False, "Maroon")
+    assert mpl_black != mpl_maroon
+    mpl_white = latextools.latex_to_png_mpl(latex_string, False, "White")
+    mpl_hexwhite = latextools.latex_to_png_mpl(latex_string, False, "#FFFFFF")
+    assert mpl_white == mpl_hexwhite
+
+    mpl_white_scale = latextools.latex_to_png_mpl(latex_string, False, "White", 1.2)
+    assert mpl_white != mpl_white_scale
+
+
+def test_latex_to_png_invalid_hex_colors():
+    """
+    Test that invalid hex colors provided to dvipng gives an exception.
+    """
+    latex_string = "$x^2$"
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(
+            latex_string, backend="dvipng", color="#f00bar"
+        ),
+    )
+    pytest.raises(
+        ValueError,
+        lambda: latextools.latex_to_png(latex_string, backend="dvipng", color="#f00"),
+    )
diff --git a/tests/test_logger.py b/tests/test_logger.py
new file mode 100644
index 00000000000..256a86e1abf
--- /dev/null
+++ b/tests/test_logger.py
@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+"""Test IPython.core.logger"""
+
+import os.path
+
+import pytest
+from tempfile import TemporaryDirectory
+
+
+def test_logstart_inaccessible_file():
+    with pytest.raises(IOError):
+        _ip.logger.logstart(logfname="/")  # Opening that filename will fail.
+
+    try:
+        _ip.run_cell("a=1")  # Check it doesn't try to log this
+    finally:
+        _ip.logger.log_active = False  # If this fails, don't let later tests fail
+
+
+def test_logstart_unicode():
+    with TemporaryDirectory() as tdir:
+        logfname = os.path.join(tdir, "test_unicode.log")
+        _ip.run_cell("'abc€'")
+        try:
+            _ip.run_line_magic("logstart", "-to %s" % logfname)
+            _ip.run_cell("'abc€'")
+        finally:
+            _ip.logger.logstop()
diff --git a/tests/test_magic.py b/tests/test_magic.py
new file mode 100644
index 00000000000..f10d303d75e
--- /dev/null
+++ b/tests/test_magic.py
@@ -0,0 +1,1956 @@
+# -*- coding: utf-8 -*-
+"""Tests for various magic functions."""
+
+import collections
+import gc
+import io
+import json
+import os
+import platform
+import re
+import shlex
+import signal
+import sys
+import warnings
+from importlib import invalidate_caches
+from io import StringIO
+from pathlib import Path
+from time import sleep
+from threading import Thread
+from subprocess import CalledProcessError
+from textwrap import dedent
+from unittest import TestCase, mock
+
+import pytest
+
+from IPython import get_ipython
+from IPython.core import magic
+from IPython.core.error import UsageError
+from IPython.core.magic import (
+    Magics,
+    cell_magic,
+    line_magic,
+    magics_class,
+    register_cell_magic,
+    register_line_magic,
+)
+from IPython.core.magics import code, execution, logging, osm, script
+from IPython.core.history import HistoryOutput
+from IPython.testing import decorators as dec
+from IPython.testing import tools as tt
+from IPython.utils.io import capture_output
+from IPython.utils.process import find_cmd
+from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
+from IPython.utils.syspathcontext import prepended_to_syspath
+
+from .test_debugger import PdbTestInput
+
+from tempfile import NamedTemporaryFile
+
+
+@magic.magics_class
+class DummyMagics(magic.Magics):
+    pass
+
+
+def test_extract_code_ranges():
+    instr = "1 3 5-6 7-9 10:15 17: :10 10- -13 :"
+    expected = [
+        (0, 1),
+        (2, 3),
+        (4, 6),
+        (6, 9),
+        (9, 14),
+        (16, None),
+        (None, 9),
+        (9, None),
+        (None, 13),
+        (None, None),
+    ]
+    actual = list(code.extract_code_ranges(instr))
+    assert actual == expected
+
+
+def test_extract_symbols():
+    source = """import foo\na = 10\ndef b():\n    return 42\n\n\nclass A: pass\n\n\n"""
+    symbols_args = ["a", "b", "A", "A,b", "A,a", "z"]
+    expected = [
+        ([], ["a"]),
+        (["def b():\n    return 42\n"], []),
+        (["class A: pass\n"], []),
+        (["class A: pass\n", "def b():\n    return 42\n"], []),
+        (["class A: pass\n"], ["a"]),
+        ([], ["z"]),
+    ]
+    for symbols, exp in zip(symbols_args, expected):
+        assert code.extract_symbols(source, symbols) == exp
+
+
+def test_extract_symbols_raises_exception_with_non_python_code():
+    source = "=begin A Ruby program :)=end\n" "def hello\n" "puts 'Hello world'\n" "end"
+    with pytest.raises(SyntaxError):
+        code.extract_symbols(source, "hello")
+
+
+def test_magic_not_found():
+    # magic not found raises UsageError
+    with pytest.raises(UsageError):
+        _ip.run_line_magic("doesntexist", "")
+
+    # ensure result isn't success when a magic isn't found
+    result = _ip.run_cell("%doesntexist")
+    assert isinstance(result.error_in_exec, UsageError)
+
+
+def test_cell_magic_not_found():
+    # magic not found raises UsageError
+    with pytest.raises(UsageError):
+        _ip.run_cell_magic("doesntexist", "line", "cell")
+
+    # ensure result isn't success when a magic isn't found
+    result = _ip.run_cell("%%doesntexist")
+    assert isinstance(result.error_in_exec, UsageError)
+
+
+def test_magic_error_status():
+    def fail(shell):
+        1 / 0
+
+    _ip.register_magic_function(fail)
+    result = _ip.run_cell("%fail")
+    assert isinstance(result.error_in_exec, ZeroDivisionError)
+
+
+def test_config():
+    """test that config magic does not raise
+    can happen if Configurable init is moved too early into
+    Magics.__init__ as then a Config object will be registered as a
+    magic.
+    """
+    ## should not raise.
+    _ip.run_line_magic("config", "")
+
+
+def test_config_available_configs():
+    """test that config magic prints available configs in unique and
+    sorted order."""
+    with capture_output() as captured:
+        _ip.run_line_magic("config", "")
+
+    stdout = captured.stdout
+    config_classes = stdout.strip().split("\n")[1:]
+    assert config_classes == sorted(set(config_classes))
+
+
+def test_config_print_class():
+    """test that config with a classname prints the class's options."""
+    with capture_output() as captured:
+        _ip.run_line_magic("config", "TerminalInteractiveShell")
+
+    stdout = captured.stdout
+    assert re.match(
+        "TerminalInteractiveShell.* options", stdout.splitlines()[0]
+    ), f"{stdout}\n\n1st line of stdout not like 'TerminalInteractiveShell.* options'"
+
+
+def test_rehashx():
+    # clear up everything
+    _ip.alias_manager.clear_aliases()
+    del _ip.db["syscmdlist"]
+
+    _ip.run_line_magic("rehashx", "")
+    # Practically ALL ipython development systems will have more than 10 aliases
+
+    assert len(_ip.alias_manager.aliases) > 10
+    for name, cmd in _ip.alias_manager.aliases:
+        # we must strip dots from alias names
+        assert "." not in name
+
+    # rehashx must fill up syscmdlist
+    scoms = _ip.db["syscmdlist"]
+    assert len(scoms) > 10
+
+
+def test_magic_parse_options():
+    """Test that we don't mangle paths when parsing magic options."""
+    ip = get_ipython()
+    path = "c:\\x"
+    m = DummyMagics(ip)
+    opts = m.parse_options("-f %s" % path, "f:")[0]
+    # argv splitting is os-dependent
+    if os.name == "posix":
+        expected = "c:x"
+    else:
+        expected = path
+    assert opts["f"] == expected
+
+
+def test_magic_parse_long_options():
+    """Magic.parse_options can handle --foo=bar long options"""
+    ip = get_ipython()
+    m = DummyMagics(ip)
+    opts, _ = m.parse_options("--foo --bar=bubble", "a", "foo", "bar=")
+    assert "foo" in opts
+    assert "bar" in opts
+    assert opts["bar"] == "bubble"
+
+
+def doctest_hist_f():
+    """Test %hist -f with temporary filename.
+
+    In [9]: import tempfile, os
+
+    In [10]: fd, tfile = tempfile.mkstemp('.py','tmp-ipython-')
+    In [11]: os.close(fd)
+
+    In [12]: %history -nl -y -f $tfile 3
+
+    In [14]: import os; os.unlink(tfile)
+    """
+
+
+def doctest_hist_op():
+    """Test %hist -op
+
+    In [1]: class b(float):
+       ...:     pass
+       ...:
+
+    In [2]: class s(object):
+       ...:     def __str__(self):
+       ...:         return 's'
+       ...:
+
+    In [3]:
+
+    In [4]: class r(b):
+       ...:     def __repr__(self):
+       ...:         return 'r'
+       ...:
+
+    In [5]: class sr(s,r): pass
+       ...:
+
+    In [6]:
+
+    In [7]: bb=b()
+
+    In [8]: ss=s()
+
+    In [9]: rr=r()
+
+    In [10]: ssrr=sr()
+
+    In [11]: 4.5
+    Out[11]: 4.5
+
+    In [12]: str(ss)
+    Out[12]: 's'
+
+    In [13]:
+
+    In [14]: %hist -op
+    >>> class b:
+    ...     pass
+    ...
+    >>> class s(b):
+    ...     def __str__(self):
+    ...         return 's'
+    ...
+    >>>
+    >>> class r(b):
+    ...     def __repr__(self):
+    ...         return 'r'
+    ...
+    >>> class sr(s,r): pass
+    >>>
+    >>> bb=b()
+    >>> ss=s()
+    >>> rr=r()
+    >>> ssrr=sr()
+    >>> 4.5
+    4.5
+    >>> str(ss)
+    's'
+    >>>
+    """
+
+
+def test_hist_pof():
+    ip = get_ipython()
+    ip.run_cell("1+2", store_history=True)
+    # raise Exception(ip.history_manager.session_number)
+    # raise Exception(list(ip.history_manager._get_range_session()))
+    with TemporaryDirectory() as td:
+        tf = os.path.join(td, "hist.py")
+        ip.run_line_magic("history", "-pof %s" % tf)
+        assert os.path.isfile(tf)
+
+
+def test_macro():
+    ip = get_ipython()
+    ip.history_manager.reset()  # Clear any existing history.
+    cmds = ["a=1", "def b():\n  return a**2", "print(a,b())"]
+    for i, cmd in enumerate(cmds, start=1):
+        ip.history_manager.store_inputs(i, cmd)
+    ip.run_line_magic("macro", "test 1-3")
+    assert ip.user_ns["test"].value == "\n".join(cmds) + "\n"
+
+    # List macros
+    assert "test" in ip.run_line_magic("macro", "")
+
+
+def test_macro_run():
+    """Test that we can run a multi-line macro successfully."""
+    ip = get_ipython()
+    ip.history_manager.reset()
+    cmds = ["a=10", "a+=1", "print(a)", "%macro test 2-3"]
+    for cmd in cmds:
+        ip.run_cell(cmd, store_history=True)
+    assert ip.user_ns["test"].value == "a+=1\nprint(a)\n"
+    with tt.AssertPrints("12"):
+        ip.run_cell("test")
+    with tt.AssertPrints("13"):
+        ip.run_cell("test")
+
+
+def test_magic_magic():
+    """Test %magic"""
+    ip = get_ipython()
+    with capture_output() as captured:
+        ip.run_line_magic("magic", "")
+
+    stdout = captured.stdout
+    assert "%magic" in stdout
+    assert "IPython" in stdout
+    assert "Available" in stdout
+
+
+@dec.skipif_not_numpy
+def test_numpy_reset_array_undec():
+    "Test '%reset array' functionality"
+    _ip.ex("import numpy as np")
+    _ip.ex("a = np.empty(2)")
+    assert "a" in _ip.user_ns
+    _ip.run_line_magic("reset", "-f array")
+    assert "a" not in _ip.user_ns
+
+
+@pytest.fixture()
+def underscore_not_in_builtins():
+    import builtins
+
+    if "_" in builtins.__dict__:
+        del builtins.__dict__["_"]
+
+
+def test_reset_out(underscore_not_in_builtins):
+    "Test '%reset out' magic"
+    _ip.run_cell("parrot = 'dead'", store_history=True)
+    # test '%reset -f out', make an Out prompt
+    _ip.run_cell("parrot", store_history=True)
+    assert "dead" in [_ip.user_ns[x] for x in ("_", "__", "___")]
+    _ip.run_line_magic("reset", "-f out")
+    assert "dead" not in [_ip.user_ns[x] for x in ("_", "__", "___")]
+    assert len(_ip.user_ns["Out"]) == 0
+
+
+def test_reset_in():
+    "Test '%reset in' magic"
+    # test '%reset -f in'
+    _ip.run_cell("parrot", store_history=True)
+    assert "parrot" in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
+    _ip.run_line_magic("reset", "-f in")
+    assert "parrot" not in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
+    assert len(set(_ip.user_ns["In"])) == 1
+
+
+def test_reset_dhist():
+    "Test '%reset dhist' magic"
+    _ip.run_cell("tmp = [d for d in _dh]")  # copy before clearing
+    _ip.run_line_magic("cd", os.path.dirname(pytest.__file__))
+    _ip.run_line_magic("cd", "-")
+    assert len(_ip.user_ns["_dh"]) > 0
+    _ip.run_line_magic("reset", "-f dhist")
+    assert len(_ip.user_ns["_dh"]) == 0
+    _ip.run_cell("_dh = [d for d in tmp]")  # restore
+
+
+def test_reset_in_length():
+    "Test that '%reset in' preserves In[] length"
+    _ip.run_cell("print 'foo'")
+    _ip.run_cell("reset -f in")
+    assert len(_ip.user_ns["In"]) == _ip.displayhook.prompt_count + 1
+
+
+class TestResetErrors(TestCase):
+    def test_reset_redefine(self):
+        @magics_class
+        class KernelMagics(Magics):
+            @line_magic
+            def less(self, shell):
+                pass
+
+        _ip.register_magics(KernelMagics)
+
+        with self.assertLogs() as cm:
+            # hack, we want to just capture logs, but assertLogs fails if not
+            # logs get produce.
+            # so log one things we ignore.
+            import logging as log_mod
+
+            log = log_mod.getLogger()
+            log.info("Nothing")
+            # end hack.
+            _ip.run_cell("reset -f")
+
+        assert len(cm.output) == 1
+        for out in cm.output:
+            assert "Invalid alias" not in out
+
+
+def test_tb_syntaxerror():
+    """test %tb after a SyntaxError"""
+    ip = get_ipython()
+    ip.run_cell("for")
+
+    # trap and validate stdout
+    save_stdout = sys.stdout
+    try:
+        sys.stdout = StringIO()
+        ip.run_cell("%tb")
+        out = sys.stdout.getvalue()
+    finally:
+        sys.stdout = save_stdout
+    # trim output, and only check the last line
+    last_line = out.rstrip().splitlines()[-1].strip()
+    assert last_line == "SyntaxError: invalid syntax"
+
+
+def test_time():
+    ip = get_ipython()
+
+    with tt.AssertPrints("Wall time: "):
+        ip.run_cell("%time None")
+
+    ip.run_cell("def f(kmjy):\n" "    %time print (2*kmjy)")
+
+    with tt.AssertPrints("Wall time: "):
+        with tt.AssertPrints("hihi", suppress=False):
+            ip.run_cell("f('hi')")
+
+    with tt.AssertPrints("a space"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell('%time print("a space")')
+
+
+# ';' at the end of %time prevents instruction value to be printed.
+# This tests fix for #13837.
+def test_time_no_output_with_semicolon():
+    ip = get_ipython()
+
+    # Test %time cases
+    with tt.AssertPrints(" 123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%time 123000+456")
+
+    with tt.AssertNotPrints(" 123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%time 123000+456;")
+
+    with tt.AssertPrints(" 123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%time 123000+456 # Comment")
+
+    with tt.AssertNotPrints(" 123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%time 123000+456; # Comment")
+
+    with tt.AssertPrints(" 123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%time 123000+456 # ;Comment")
+
+    # Test %%time cases
+    with tt.AssertPrints("123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%%time\n123000+456\n\n\n")
+
+    with tt.AssertNotPrints("123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%%time\n123000+456;\n\n\n")
+
+    with tt.AssertPrints("123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%%time\n123000+456  # Comment\n\n\n")
+
+    with tt.AssertNotPrints("123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%%time\n123000+456;  # Comment\n\n\n")
+
+    with tt.AssertPrints("123456"):
+        with tt.AssertPrints("Wall time: ", suppress=False):
+            with tt.AssertPrints("CPU times: ", suppress=False):
+                ip.run_cell("%%time\n123000+456  # ;Comment\n\n\n")
+
+
+def test_time_last_not_expression():
+    ip.run_cell("%%time\n" "var_1 = 1\n" "var_2 = 2\n")
+    assert ip.user_ns["var_1"] == 1
+    del ip.user_ns["var_1"]
+    assert ip.user_ns["var_2"] == 2
+    del ip.user_ns["var_2"]
+
+
+@dec.skip_win32
+def test_time2():
+    ip = get_ipython()
+
+    with tt.AssertPrints("CPU times: user "):
+        ip.run_cell("%time None")
+
+
+def test_time3():
+    """Erroneous magic function calls, issue gh-3334"""
+    ip = get_ipython()
+    ip.user_ns.pop("run", None)
+
+    with tt.AssertNotPrints("not found", channel="stderr"):
+        ip.run_cell("%%time\n" "run = 0\n" "run += 1")
+
+
+def test_multiline_time(underscore_not_in_builtins):
+    """Make sure last statement from time return a value."""
+    ip = get_ipython()
+    ip.user_ns.pop("run", None)
+
+    ip.run_cell(
+        dedent(
+            """\
+        %%time
+        a = "ho"
+        b = "hey"
+        a+b
+        """
+        )
+    )
+    assert ip.user_ns_hidden["_"] == "hohey"
+
+
+def test_time_local_ns():
+    """
+    Test that local_ns is actually global_ns when running a cell magic
+    """
+    ip = get_ipython()
+    ip.run_cell("%%time\n" "myvar = 1")
+    assert ip.user_ns["myvar"] == 1
+    del ip.user_ns["myvar"]
+
+
+def test_time_microseconds_display():
+    """Ensure ASCII is used when necessary"""
+    with mock.patch("sys.stdout", io.TextIOWrapper(StringIO(), encoding="utf-8")):
+        assert execution._format_time(0.000001) == "1 \u03bcs"
+    with mock.patch("sys.stdout", io.TextIOWrapper(StringIO(), encoding="ascii")):
+        assert execution._format_time(0.000001) == "1 us"
+
+
+# Test %%capture magic. Added to test issue #13926
+def test_capture():
+    ip = get_ipython()
+
+    # Test %%capture nominal case
+    ip.run_cell("%%capture abc\n1+2")
+    with tt.AssertPrints("True", suppress=False):
+        ip.run_cell("'abc' in locals()")
+    with tt.AssertPrints("True", suppress=False):
+        ip.run_cell("'outputs' in dir(abc)")
+    with tt.AssertPrints("3", suppress=False):
+        ip.run_cell("abc.outputs[0]")
+
+    # Test %%capture with ';' at end of expression
+    ip.run_cell("%%capture abc\n7+8;")
+    with tt.AssertPrints("False", suppress=False):
+        ip.run_cell("'abc' in locals()")
+
+
+def test_doctest_mode():
+    "Toggle doctest_mode twice, it should be a no-op and run without error"
+    _ip.run_line_magic("doctest_mode", "")
+    _ip.run_line_magic("doctest_mode", "")
+
+
+def test_parse_options():
+    """Tests for basic options parsing in magics."""
+    # These are only the most minimal of tests, more should be added later.  At
+    # the very least we check that basic text/unicode calls work OK.
+    m = DummyMagics(_ip)
+    assert m.parse_options("foo", "")[1] == "foo"
+    assert m.parse_options("foo", "")[1] == "foo"
+
+
+def test_parse_options_preserve_non_option_string():
+    """Test to assert preservation of non-option part of magic-block, while parsing magic options."""
+    m = DummyMagics(_ip)
+    opts, stmt = m.parse_options(
+        " -n1  -r 13 _ = 314 + foo", "n:r:", preserve_non_opts=True
+    )
+    assert opts == {"n": "1", "r": "13"}
+    assert stmt == "_ = 314 + foo"
+
+
+def test_run_magic_preserve_code_block():
+    """Test to assert preservation of non-option part of magic-block, while running magic."""
+    _ip.user_ns["spaces"] = []
+    _ip.run_line_magic(
+        "timeit", "-n1 -r1 spaces.append([s.count(' ') for s in ['document']])"
+    )
+    assert _ip.user_ns["spaces"] == [[0]]
+
+
+def test_dirops():
+    """Test various directory handling operations."""
+    # curpath = lambda :os.path.splitdrive(os.getcwd())[1].replace('\\','/')
+    curpath = os.getcwd
+    startdir = os.getcwd()
+    ipdir = os.path.realpath(_ip.ipython_dir)
+    try:
+        _ip.run_line_magic("cd", '"%s"' % ipdir)
+        assert curpath() == ipdir
+        _ip.run_line_magic("cd", "-")
+        assert curpath() == startdir
+        _ip.run_line_magic("pushd", '"%s"' % ipdir)
+        assert curpath() == ipdir
+        _ip.run_line_magic("popd", "")
+        assert curpath() == startdir
+    finally:
+        os.chdir(startdir)
+
+
+def test_cd_force_quiet():
+    """Test OSMagics.cd_force_quiet option"""
+    _ip.config.OSMagics.cd_force_quiet = True
+    osmagics = osm.OSMagics(shell=_ip)
+
+    startdir = os.getcwd()
+    ipdir = os.path.realpath(_ip.ipython_dir)
+
+    try:
+        with tt.AssertNotPrints(ipdir):
+            osmagics.cd('"%s"' % ipdir)
+        with tt.AssertNotPrints(startdir):
+            osmagics.cd("-")
+    finally:
+        os.chdir(startdir)
+
+
+def test_xmode():
+    # Calling xmode three times should be a no-op
+    xmode = _ip.InteractiveTB.mode
+    for i in range(5):
+        _ip.run_line_magic("xmode", "")
+    assert _ip.InteractiveTB.mode == xmode
+
+
+def test_reset_hard():
+    monitor = []
+
+    class A(object):
+        def __del__(self):
+            monitor.append(1)
+
+        def __repr__(self):
+            return "<A instance>"
+
+    _ip.user_ns["a"] = A()
+    _ip.run_cell("a")
+
+    assert monitor == []
+    _ip.run_line_magic("reset", "-f")
+    assert monitor == [1]
+
+
+class TestXdel(tt.TempFileMixin):
+    def test_xdel(self):
+        """Test that references from %run are cleared by xdel."""
+        src = (
+            "class A(object):\n"
+            "    monitor = []\n"
+            "    def __del__(self):\n"
+            "        self.monitor.append(1)\n"
+            "a = A()\n"
+        )
+        self.mktmp(src)
+        # %run creates some hidden references...
+        _ip.run_line_magic("run", "%s" % self.fname)
+        # ... as does the displayhook.
+        _ip.run_cell("a")
+
+        monitor = _ip.user_ns["A"].monitor
+        assert monitor == []
+
+        _ip.run_line_magic("xdel", "a")
+
+        # Check that a's __del__ method has been called.
+        gc.collect(0)
+        assert monitor == [1]
+
+
+def doctest_who():
+    """doctest for %who
+
+    In [1]: %reset -sf
+
+    In [2]: alpha = 123
+
+    In [3]: beta = 'beta'
+
+    In [4]: %who int
+    alpha
+
+    In [5]: %who str
+    beta
+
+    In [6]: %whos
+    Variable   Type    Data/Info
+    ----------------------------
+    alpha      int     123
+    beta       str     beta
+
+    In [7]: %who_ls
+    Out[7]: ['alpha', 'beta']
+    """
+
+
+def test_whos():
+    """Check that whos is protected against objects where repr() fails."""
+
+    class A(object):
+        def __repr__(self):
+            raise Exception()
+
+    _ip.user_ns["a"] = A()
+    _ip.run_line_magic("whos", "")
+
+
+@pytest.mark.parametrize(
+    "input,expected",
+    (
+        (
+            "The quick brown fox jumps over the lazy dog",
+            "The quick brown fox jumps over the lazy dog",
+        ),
+        (
+            " ".join(["The quick brown fox jumps over the lazy dog"] * 2),
+            "The quick brown fox jumps<...>x jumps over the lazy dog",
+        ),
+        ("\nThis is \n\na long\n\nstring\n", r"\nThis is \n\na long\n\nstring\n"),
+        (
+            "\rThis is \r\ra long\r\rstring\r",
+            r"\rThis is \r\ra long\r\rstring\r",
+        ),
+    ),
+)
+def test_whos_longstr(input, expected):
+    ip = get_ipython()
+    ip.user_ns["input"] = input
+    ip.user_ns["expected"] = expected
+    with capture_output() as captured:
+        ip.run_line_magic("whos", "")
+    stdout = captured.stdout
+    from_whos = " ".join(
+        re.split(
+            r"\s+str\s+",
+            [l for l in stdout.splitlines() if l.startswith("expected")][0],
+        )[1:]
+    )
+    assert expected == from_whos
+
+
+def test_whos_len_namedtuple():
+    _ip = get_ipython()
+    _ip.run_line_magic("reset", "-f")
+    _ip.user_ns["alpha"] = 123
+    _ip.user_ns["beta"] = "test"
+    _ip.user_ns["nt"] = collections.namedtuple("MyNamedTuple", "col1 col2")
+    _ip.user_ns["x"] = _ip.user_ns["nt"]("a", "b")
+    expected = (
+        "Variable   Type            Data/Info\n"
+        "------------------------------------\n"
+        "alpha      int             123\n"
+        "beta       str             test\n"
+        "nt         type            <class 'tests.test_magic.MyNamedTuple'>\n"
+        "x          MyNamedTuple    MyNamedTuple(col1='a', col2='b')\n"
+    )
+    with capture_output() as captured:
+        ip.run_line_magic("whos", "")
+    stdout = captured.stdout
+    assert stdout == expected.strip() + "\n"
+
+
+@dec.skip_without("pandas")
+def test_whos_len_pandas():
+    import pandas as pd
+
+    _ip = get_ipython()
+    _ip.run_line_magic("reset", "-f")
+    df = pd.DataFrame({"a": range(10), "b": range(10, 20)})
+    _ip.user_ns["df"] = df
+    s = df["a"]
+    _ip.user_ns["s"] = s
+    expected = (
+        "Variable   Type         Data/Info\n"
+        "---------------------------------\n"
+        "df         DataFrame    Shape: (10, 2)\n"
+        "s          Series       Shape: (10,)\n"
+    )
+    with capture_output() as captured:
+        ip.run_line_magic("whos", "")
+    stdout = captured.stdout
+    assert stdout == expected.strip() + "\n"
+
+
+def doctest_precision():
+    """doctest for %precision
+
+    In [1]: f = get_ipython().display_formatter.formatters['text/plain']
+
+    In [2]: %precision 5
+    Out[2]: '%.5f'
+
+    In [3]: f.float_format
+    Out[3]: '%.5f'
+
+    In [4]: %precision %e
+    Out[4]: '%e'
+
+    In [5]: f(3.1415927)
+    Out[5]: '3.141593e+00'
+    """
+
+
+def test_debug_magic():
+    """Test debugging a small code with %debug
+
+    In [1]: with PdbTestInput(['c']):
+       ...:     %debug print("a b") #doctest: +ELLIPSIS
+       ...:
+    ...
+    ipdb> c
+    a b
+    In [2]:
+    """
+
+
+def test_debug_magic_locals():
+    """Test debugging a small code with %debug with locals
+
+    In [1]: with PdbTestInput(['c']):
+       ...:     def fun():
+       ...:         res = 1
+       ...:         %debug print(res)
+       ...:     fun()
+       ...:
+    ...
+    ipdb> c
+    1
+    In [2]:
+    """
+
+
+def test_psearch():
+    with tt.AssertPrints("dict.fromkeys"):
+        _ip.run_cell("dict.fr*?")
+    with tt.AssertPrints("Ï€.is_integer"):
+        _ip.run_cell("π = 3.14;\nπ.is_integ*?")
+
+
+def test_timeit_shlex():
+    """test shlex issues with timeit (#1109)"""
+    _ip.ex("def f(*a,**kw): pass")
+    _ip.run_line_magic("timeit", '-n1 "this is a bug".count(" ")')
+    _ip.run_line_magic("timeit", '-r1 -n1 f(" ", 1)')
+    _ip.run_line_magic("timeit", '-r1 -n1 f(" ", 1, " ", 2, " ")')
+    _ip.run_line_magic("timeit", '-r1 -n1 ("a " + "b")')
+    _ip.run_line_magic("timeit", '-r1 -n1 f("a " + "b")')
+    _ip.run_line_magic("timeit", '-r1 -n1 f("a " + "b ")')
+
+
+def test_timeit_special_syntax():
+    "Test %%timeit with IPython special syntax"
+
+    @register_line_magic
+    def lmagic(line):
+        ip = get_ipython()
+        ip.user_ns["lmagic_out"] = line
+
+    # line mode test
+    _ip.run_line_magic("timeit", "-n1 -r1 %lmagic my line")
+    assert _ip.user_ns["lmagic_out"] == "my line"
+    # cell mode test
+    _ip.run_cell_magic("timeit", "-n1 -r1", "%lmagic my line2")
+    assert _ip.user_ns["lmagic_out"] == "my line2"
+
+
+def test_timeit_return():
+    """
+    test whether timeit -o return object
+    """
+
+    res = _ip.run_line_magic("timeit", "-n10 -r10 -o 1")
+    assert res is not None
+
+
+def test_timeit_save():
+    """
+    test whether timeit -v save object
+    """
+
+    name = "some_variable_name"
+    _ip.run_line_magic("timeit", "-n10 -r10 -v %s 1" % name)
+    assert _ip.user_ns[name] is not None
+
+
+def test_timeit_quiet():
+    """
+    test quiet option of timeit magic
+    """
+    with tt.AssertNotPrints("loops"):
+        _ip.run_cell("%timeit -n1 -r1 -q 1")
+
+
+def test_timeit_return_quiet():
+    with tt.AssertNotPrints("loops"):
+        res = _ip.run_line_magic("timeit", "-n1 -r1 -q -o 1")
+    assert res is not None
+
+
+def test_timeit_invalid_return():
+    with pytest.raises(SyntaxError):
+        _ip.run_line_magic("timeit", "return")
+
+
+def test_timeit_raise_on_interrupt():
+    ip = get_ipython()
+
+    with pytest.raises(KeyboardInterrupt):
+        thread = Thread(target=_interrupt_after_1s)
+        thread.start()
+        ip.run_cell_magic("timeit", "", "from time import sleep; sleep(2)")
+        thread.join()
+
+
+@dec.skipif(execution.profile is None)
+def test_prun_special_syntax():
+    "Test %%prun with IPython special syntax"
+
+    @register_line_magic
+    def lmagic(line):
+        ip = get_ipython()
+        ip.user_ns["lmagic_out"] = line
+
+    # line mode test
+    _ip.run_line_magic("prun", "-q %lmagic my line")
+    assert _ip.user_ns["lmagic_out"] == "my line"
+    # cell mode test
+    _ip.run_cell_magic("prun", "-q", "%lmagic my line2")
+    assert _ip.user_ns["lmagic_out"] == "my line2"
+
+
+@dec.skipif(execution.profile is None)
+def test_prun_quotes():
+    "Test that prun does not clobber string escapes (GH #1302)"
+    _ip.run_line_magic("prun", r"-q x = '\t'")
+    assert _ip.user_ns["x"] == "\t"
+
+
+def test_extension():
+    # Debugging information for failures of this test
+    assert "daft_extension" not in sys.modules
+    daft_path = os.path.join(os.path.dirname(__file__), "fake_ext_dir")
+    if daft_path in sys.path:
+        # it is likely pytest added this path
+        # when scanning for tests
+        sys.path.remove(daft_path)
+    print("sys.path:")
+    for p in sys.path:
+        print(" ", p)
+    print("CWD", os.getcwd())
+
+    with pytest.raises(ModuleNotFoundError):
+        import daft_extension
+
+    with pytest.raises(ModuleNotFoundError):
+        _ip.run_line_magic("load_ext", "daft_extension")
+    sys.path.insert(0, daft_path)
+    import daft_extension
+
+    try:
+        _ip.user_ns.pop("arq", None)
+        invalidate_caches()  # Clear import caches
+        _ip.run_line_magic("load_ext", "daft_extension")
+        assert _ip.user_ns["arq"] == 185
+        _ip.run_line_magic("unload_ext", "daft_extension")
+        assert "arq" not in _ip.user_ns
+    finally:
+        sys.path.remove(daft_path)
+
+
+def test_notebook_export_json():
+    pytest.importorskip("nbformat")
+    from nbformat import read, sign
+
+    _ip = get_ipython()
+    _ip.history_manager.reset()  # Clear any existing history.
+    _ip.run_line_magic("config", "NotebookNotary.algorithm = 'sha384'")
+    cmds = ["a=1", "def b():\n  return a**2", "print('noël, été', b())"]
+    for i, cmd in enumerate(cmds, start=1):
+        _ip.history_manager.store_inputs(i, cmd)
+    with TemporaryDirectory() as td:
+        outfile = os.path.join(td, "nb.ipynb")
+        _ip.run_line_magic("notebook", "%s" % outfile)
+        with open(outfile) as f:
+            exported = json.load(f)
+        nb = read(outfile, as_version=4)
+
+    # check metadata
+    language_info = exported["metadata"]["language_info"]
+    assert language_info["name"] == "python"
+    assert language_info["file_extension"] == ".py"
+    assert language_info["version"] == platform.python_version()
+
+    kernelspec = exported["metadata"]["kernelspec"]
+    assert kernelspec["language"] == "python"
+
+    # Check if notebook is trusted
+    notary = sign.NotebookNotary(algorithm="sha384")
+    is_trusted = notary.check_signature(nb)
+    assert is_trusted, "Exported notebook should be trusted"
+
+
+def test_notebook_export_json_with_output():
+    """Tests if notebook export correctly captures outputs, errors, display outputs, and stream outputs."""
+    pytest.importorskip("nbformat")
+    pytest.importorskip("nbclient")
+    import nbformat
+    from nbclient import NotebookClient
+
+    _ip = get_ipython()
+    _ip.history_manager.reset()
+    _ip.colors = "neutral"
+    _ip.execution_count = 1
+
+    try:
+        commands = [
+            "1/0",
+            "print('test')",
+            "display('test')",
+            "1+1",
+            "display('a'), display('b')",
+            "import sys\nprint('test', file=sys.stderr)",
+        ]
+
+        clean_nb = nbformat.v4.new_notebook(
+            cells=[nbformat.v4.new_code_cell(source=cmd) for cmd in commands]
+        )
+
+        with TemporaryDirectory() as td:
+            outfile = os.path.join(td, "nb.ipynb")
+            client = NotebookClient(
+                clean_nb,
+                timeout=600,
+                kernel_name="python3",
+                resources={"metadata": {"path": td}},
+                allow_errors=True,
+            )
+            client.execute()
+            nbformat.write(clean_nb, outfile)
+            expected_nb = nbformat.read(outfile, as_version=4)
+
+        for cmd in commands:
+            _ip.run_cell(cmd, store_history=True, silent=False)
+            print(f"\n{_ip.history_manager.outputs}\n")
+
+        with TemporaryDirectory() as td:
+            outfile = os.path.join(td, "nb.ipynb")
+            _ip.run_cell(f"%notebook {outfile}", store_history=True)
+            sleep(2)
+            actual_nb = nbformat.read(outfile, as_version=4)
+
+        assert len(actual_nb["cells"]) == len(commands)
+        assert len(expected_nb["cells"]) == len(commands)
+
+        for i, command in enumerate(commands):
+            actual = actual_nb["cells"][i]
+            expected = expected_nb["cells"][i]
+            assert expected["source"] == command
+            assert actual["source"] == expected["source"]
+            assert (
+                actual["outputs"] == expected["outputs"]
+            ), f"Outputs do not match for cell {i+1} with source {command!r}"
+    finally:
+        _ip.colors = "nocolor"
+
+
+def test_notebook_export_single_display():
+    """Test that multiple MIME types create a single display_data output, not multiple."""
+    pytest.importorskip("nbformat")
+
+    _ip = get_ipython()
+    orig_outputs = _ip.history_manager.outputs.copy()
+    orig_execution_count = _ip.execution_count
+    _ip.history_manager.reset()
+
+    try:
+        execution_count = _ip.execution_count = 1
+        _ip.run_cell("'test'", store_history=True, silent=False)
+
+        # Mock display output with multiple MIME types
+        test_display_history = HistoryOutput(
+            output_type="display_data",
+            bundle={"text/plain": "test", "text/html": "<div>test</div>"},
+        )
+        _ip.history_manager.outputs[execution_count] = [test_display_history]
+
+        with TemporaryDirectory() as td:
+            outfile = f"{td}/test.ipynb"
+            _ip.run_cell(f"%notebook {outfile}", store_history=True, silent=False)
+
+            # Verify single display_data output with both MIME types
+            with open(outfile, "r") as f:
+                nb = json.load(f)
+
+        cell = nb["cells"][0]
+        display_outputs = [
+            out for out in cell["outputs"] if out["output_type"] == "display_data"
+        ]
+
+        assert (
+            len(display_outputs) == 1
+        ), f"Expected 1 display_data output, got {len(display_outputs)}"
+
+        output_data = display_outputs[0]["data"]
+        assert set(output_data.keys()) == {"text/plain", "text/html"}
+        assert output_data["text/plain"] == ["test"]
+        assert output_data["text/html"] == ["<div>test</div>"]
+
+    finally:
+        _ip.history_manager.outputs = orig_outputs
+        _ip.execution_count = orig_execution_count
+
+
+class TestEnv(TestCase):
+    def test_env(self):
+        env = _ip.run_line_magic("env", "")
+        self.assertTrue(isinstance(env, dict))
+
+    def test_env_secret(self):
+        env = _ip.run_line_magic("env", "")
+        hidden = "<hidden>"
+        with mock.patch.dict(
+            os.environ,
+            {
+                "API_KEY": "abc123",
+                "SECRET_THING": "ssshhh",
+                "JUPYTER_TOKEN": "",
+                "VAR": "abc",
+            },
+        ):
+            env = _ip.run_line_magic("env", "")
+        assert env["API_KEY"] == hidden
+        assert env["SECRET_THING"] == hidden
+        assert env["JUPYTER_TOKEN"] == hidden
+        assert env["VAR"] == "abc"
+
+    def test_env_get_set_simple(self):
+        env = _ip.run_line_magic("env", "var val1")
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ["var"], "val1")
+        self.assertEqual(_ip.run_line_magic("env", "var"), "val1")
+        env = _ip.run_line_magic("env", "var=val2")
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ["var"], "val2")
+
+    def test_env_get_set_complex(self):
+        env = _ip.run_line_magic("env", "var 'val1 '' 'val2")
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ["var"], "'val1 '' 'val2")
+        self.assertEqual(_ip.run_line_magic("env", "var"), "'val1 '' 'val2")
+        env = _ip.run_line_magic("env", 'var=val2 val3="val4')
+        self.assertEqual(env, None)
+        self.assertEqual(os.environ["var"], 'val2 val3="val4')
+
+    def test_env_set_bad_input(self):
+        self.assertRaises(UsageError, lambda: _ip.run_line_magic("set_env", "var"))
+
+    def test_env_set_whitespace(self):
+        self.assertRaises(UsageError, lambda: _ip.run_line_magic("env", "var A=B"))
+
+
+def check_ident(magic):
+    # Manually called, we get the result
+    out = _ip.run_cell_magic(magic, "a", "b")
+    assert out == ("a", "b")
+    # Via run_cell, it goes into the user's namespace via displayhook
+    _ip.run_cell("%%" + magic + " c\nd\n")
+    assert _ip.user_ns["_"] == ("c", "d\n")
+
+
+def test_cell_magic_func_deco(underscore_not_in_builtins):
+    "Cell magic using simple decorator"
+
+    @register_cell_magic
+    def cellm(line, cell):
+        return line, cell
+
+    check_ident("cellm")
+
+
+def test_cell_magic_reg(underscore_not_in_builtins):
+    "Cell magic manually registered"
+
+    def cellm(line, cell):
+        return line, cell
+
+    _ip.register_magic_function(cellm, "cell", "cellm2")
+    check_ident("cellm2")
+
+
+def test_cell_magic_class(underscore_not_in_builtins):
+    "Cell magics declared via a class"
+
+    @magics_class
+    class MyMagics(Magics):
+        @cell_magic
+        def cellm3(self, line, cell):
+            return line, cell
+
+    _ip.register_magics(MyMagics)
+    check_ident("cellm3")
+
+
+def test_cell_magic_class2(underscore_not_in_builtins):
+    "Cell magics declared via a class, #2"
+
+    @magics_class
+    class MyMagics2(Magics):
+        @cell_magic("cellm4")
+        def cellm33(self, line, cell):
+            return line, cell
+
+    _ip.register_magics(MyMagics2)
+    check_ident("cellm4")
+    # Check that nothing is registered as 'cellm33'
+    c33 = _ip.find_cell_magic("cellm33")
+    assert c33 == None
+
+
+def test_file():
+    """Basic %%writefile"""
+    ip = get_ipython()
+    with TemporaryDirectory() as td:
+        fname = os.path.join(td, "file1")
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
+        assert "line1\n" in s
+        assert "line2" in s
+
+
+@dec.skip_win32
+def test_file_single_quote():
+    """Basic %%writefile with embedded single quotes"""
+    ip = get_ipython()
+    with TemporaryDirectory() as td:
+        fname = os.path.join(td, "'file1'")
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
+        assert "line1\n" in s
+        assert "line2" in s
+
+
+@dec.skip_win32
+def test_file_double_quote():
+    """Basic %%writefile with embedded double quotes"""
+    ip = get_ipython()
+    with TemporaryDirectory() as td:
+        fname = os.path.join(td, '"file1"')
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
+        assert "line1\n" in s
+        assert "line2" in s
+
+
+def test_file_var_expand():
+    """%%writefile $filename"""
+    ip = get_ipython()
+    with TemporaryDirectory() as td:
+        fname = os.path.join(td, "file1")
+        ip.user_ns["filename"] = fname
+        ip.run_cell_magic(
+            "writefile",
+            "$filename",
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
+        assert "line1\n" in s
+        assert "line2" in s
+
+
+def test_file_unicode():
+    """%%writefile with unicode cell"""
+    ip = get_ipython()
+    with TemporaryDirectory() as td:
+        fname = os.path.join(td, "file1")
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "liné1",
+                    "liné2",
+                ]
+            ),
+        )
+        with io.open(fname, encoding="utf-8") as f:
+            s = f.read()
+        assert "liné1\n" in s
+        assert "liné2" in s
+
+
+def test_file_amend():
+    """%%writefile -a amends files"""
+    ip = get_ipython()
+    with TemporaryDirectory() as td:
+        fname = os.path.join(td, "file2")
+        ip.run_cell_magic(
+            "writefile",
+            fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        ip.run_cell_magic(
+            "writefile",
+            "-a %s" % fname,
+            "\n".join(
+                [
+                    "line3",
+                    "line4",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
+        assert "line1\n" in s
+        assert "line3\n" in s
+
+
+def test_file_spaces():
+    """%%file with spaces in filename"""
+    ip = get_ipython()
+    with TemporaryWorkingDirectory() as td:
+        fname = "file name"
+        ip.run_cell_magic(
+            "file",
+            '"%s"' % fname,
+            "\n".join(
+                [
+                    "line1",
+                    "line2",
+                ]
+            ),
+        )
+        s = Path(fname).read_text(encoding="utf-8")
+        assert "line1\n" in s
+        assert "line2" in s
+
+
+def test_script_config():
+    ip = get_ipython()
+    ip.config.ScriptMagics.script_magics = ["whoda"]
+    sm = script.ScriptMagics(shell=ip)
+    assert "whoda" in sm.magics["cell"]
+
+
+def _interrupt_after_1s():
+    sleep(1)
+    signal.raise_signal(signal.SIGINT)
+
+
+def test_script_raise_on_interrupt():
+    ip = get_ipython()
+
+    with pytest.raises(CalledProcessError):
+        thread = Thread(target=_interrupt_after_1s)
+        thread.start()
+        ip.run_cell_magic(
+            "script", f"{sys.executable}", "from time import sleep; sleep(2)"
+        )
+        thread.join()
+
+
+def test_script_do_not_raise_on_interrupt():
+    ip = get_ipython()
+
+    thread = Thread(target=_interrupt_after_1s)
+    thread.start()
+    ip.run_cell_magic(
+        "script",
+        f"--no-raise-error {sys.executable}",
+        "from time import sleep; sleep(2)",
+    )
+    thread.join()
+
+
+def test_script_out():
+    ip = get_ipython()
+    ip.run_cell_magic("script", f"--out output {sys.executable}", "print('hi')")
+    assert ip.user_ns["output"].strip() == "hi"
+
+
+def test_script_out_multiple_lines():
+    ip = get_ipython()
+    code = "print('hi')\nprint('this')\nprint('is')\nprint('ipython')"
+    ip.run_cell_magic("script", f"--out output {sys.executable}", code)
+    assert ip.user_ns["output"].strip().splitlines() == ["hi", "this", "is", "ipython"]
+
+
+def test_script_err():
+    ip = get_ipython()
+    ip.run_cell_magic(
+        "script",
+        f"--err error {sys.executable}",
+        "import sys; print('hello', file=sys.stderr)",
+    )
+    assert ip.user_ns["error"].strip() == "hello"
+
+
+def test_script_out_err():
+    ip = get_ipython()
+    ip.run_cell_magic(
+        "script",
+        f"--out output --err error {sys.executable}",
+        "\n".join(
+            [
+                "import sys",
+                "print('hi')",
+                "print('hello', file=sys.stderr)",
+            ]
+        ),
+    )
+    assert ip.user_ns["output"].strip() == "hi"
+    assert ip.user_ns["error"].strip() == "hello"
+
+
+@pytest.mark.asyncio
+async def test_script_bg_out():
+    ip = get_ipython()
+    ip.run_cell_magic("script", f"--bg --out output {sys.executable}", "print('hi')")
+    assert (await ip.user_ns["output"].read()).strip() == b"hi"
+    assert ip.user_ns["output"].at_eof()
+
+
+@pytest.mark.asyncio
+async def test_script_bg_err():
+    ip = get_ipython()
+    ip.run_cell_magic(
+        "script",
+        f"--bg --err error {sys.executable}",
+        "import sys; print('hello', file=sys.stderr)",
+    )
+    assert (await ip.user_ns["error"].read()).strip() == b"hello"
+    assert ip.user_ns["error"].at_eof()
+
+
+@pytest.mark.asyncio
+async def test_script_bg_out_err():
+    ip = get_ipython()
+    ip.run_cell_magic(
+        "script",
+        f"--bg --out output --err error {sys.executable}",
+        "\n".join(
+            [
+                "import sys",
+                "print('hi')",
+                "print('hello', file=sys.stderr)",
+            ]
+        ),
+    )
+    assert (await ip.user_ns["output"].read()).strip() == b"hi"
+    assert (await ip.user_ns["error"].read()).strip() == b"hello"
+    assert ip.user_ns["output"].at_eof()
+    assert ip.user_ns["error"].at_eof()
+
+
+@pytest.mark.asyncio
+async def test_script_bg_proc():
+    ip = get_ipython()
+    ip.run_cell_magic(
+        "script",
+        f"--bg --out output --proc p {sys.executable}",
+        "\n".join(
+            [
+                "import sys",
+                "print('hi')",
+                "print('hello', file=sys.stderr)",
+            ]
+        ),
+    )
+    p = ip.user_ns["p"]
+    await p.wait()
+    stdout = await p.stdout.read()
+    stderr = await p.stderr.read()
+    assert p.returncode == 0, (stdout, stderr)
+    assert stdout.strip() == b"hi"
+    # not captured, so empty
+    assert (stderr) == b""
+    assert p.stdout.at_eof()
+    assert p.stderr.at_eof()
+
+
+def test_script_defaults():
+    ip = get_ipython()
+    for cmd in ["sh", "bash", "perl", "ruby"]:
+        try:
+            find_cmd(cmd)
+        except Exception:
+            pass
+        else:
+            assert cmd in ip.magics_manager.magics["cell"]
+
+
+@pytest.mark.asyncio
+async def test_script_streams_continuously(capsys):
+    ip = get_ipython()
+    # Windows is slow to start up a thread on CI
+    is_windows = os.name == "nt"
+    step = 3 if is_windows else 1
+    code = dedent(
+        f"""\
+    import time
+    for _ in range(3):
+        time.sleep({step})
+        print(".", flush=True, end="")
+    """
+    )
+
+    def print_numbers():
+        for i in range(3):
+            sleep(step)
+            print(i, flush=True, end="")
+
+    thread = Thread(target=print_numbers)
+    thread.start()
+    sleep(step / 2)
+    ip.run_cell_magic("script", sys.executable, code)
+    thread.join()
+
+    captured = capsys.readouterr()
+    # If the streaming was line-wise or broken
+    # we would get `012...`
+    assert captured.out == "0.1.2."
+
+
+def test_script_streams_multibyte_unicode(capsys):
+    ip = get_ipython()
+    # € in UTF-8 is encoded using 3 bytes
+    code = "print('€' * 1000, end='')"
+    is_windows = os.name == "nt"
+    command = sys.executable
+    if is_windows:
+        # windows does not use UTF for streams/pipes by default
+        command += " -X utf8"
+    ip.run_cell_magic("script", command, code)
+
+    captured = capsys.readouterr()
+    assert captured.out == "€" * 1000
+
+
+@magics_class
+class FooFoo(Magics):
+    """class with both %foo and %%foo magics"""
+
+    @line_magic("foo")
+    def line_foo(self, line):
+        "I am line foo"
+        pass
+
+    @cell_magic("foo")
+    def cell_foo(self, line, cell):
+        "I am cell foo, not line foo"
+        pass
+
+
+def test_line_cell_info():
+    """%%foo and %foo magics are distinguishable to inspect"""
+    ip = get_ipython()
+    ip.magics_manager.register(FooFoo)
+    oinfo = ip.object_inspect("foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+
+    oinfo = ip.object_inspect("%%foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+    assert oinfo["docstring"] == FooFoo.cell_foo.__doc__
+
+    oinfo = ip.object_inspect("%foo")
+    assert oinfo["found"] is True
+    assert oinfo["ismagic"] is True
+    assert oinfo["docstring"] == FooFoo.line_foo.__doc__
+
+
+def test_multiple_magics():
+    ip = get_ipython()
+    foo1 = FooFoo(ip)
+    foo2 = FooFoo(ip)
+    mm = ip.magics_manager
+    mm.register(foo1)
+    assert mm.magics["line"]["foo"].__self__ is foo1
+    mm.register(foo2)
+    assert mm.magics["line"]["foo"].__self__ is foo2
+
+
+def test_alias_magic():
+    """Test %alias_magic."""
+    ip = get_ipython()
+    mm = ip.magics_manager
+
+    # Basic operation: both cell and line magics are created, if possible.
+    ip.run_line_magic("alias_magic", "timeit_alias timeit")
+    assert "timeit_alias" in mm.magics["line"]
+    assert "timeit_alias" in mm.magics["cell"]
+
+    # --cell is specified, line magic not created.
+    ip.run_line_magic("alias_magic", "--cell timeit_cell_alias timeit")
+    assert "timeit_cell_alias" not in mm.magics["line"]
+    assert "timeit_cell_alias" in mm.magics["cell"]
+
+    # Test that line alias is created successfully.
+    ip.run_line_magic("alias_magic", "--line env_alias env")
+    assert ip.run_line_magic("env", "") == ip.run_line_magic("env_alias", "")
+
+    # Test that line alias with parameters passed in is created successfully.
+    ip.run_line_magic(
+        "alias_magic", "--line history_alias history --params " + shlex.quote("3")
+    )
+    assert "history_alias" in mm.magics["line"]
+
+
+def test_save():
+    """Test %save."""
+    ip = get_ipython()
+    ip.history_manager.reset()  # Clear any existing history.
+    cmds = ["a=1", "def b():\n  return a**2", "print(a, b())"]
+    for i, cmd in enumerate(cmds, start=1):
+        ip.history_manager.store_inputs(i, cmd)
+    with TemporaryDirectory() as tmpdir:
+        file = os.path.join(tmpdir, "testsave.py")
+        ip.run_line_magic("save", "%s 1-10" % file)
+        content = Path(file).read_text(encoding="utf-8")
+        assert content.count(cmds[0]) == 1
+        assert "coding: utf-8" in content
+        ip.run_line_magic("save", "-a %s 1-10" % file)
+        content = Path(file).read_text(encoding="utf-8")
+        assert content.count(cmds[0]) == 2
+        assert "coding: utf-8" in content
+
+
+def test_save_with_no_args():
+    ip = get_ipython()
+    ip.history_manager.reset()  # Clear any existing history.
+    cmds = ["a=1", "def b():\n    return a**2", "print(a, b())", "%save"]
+    for i, cmd in enumerate(cmds, start=1):
+        ip.history_manager.store_inputs(i, cmd)
+
+    with TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "testsave.py")
+        ip.run_line_magic("save", path)
+        content = Path(path).read_text(encoding="utf-8")
+        expected_content = dedent(
+            """\
+            # coding: utf-8
+            a=1
+            def b():
+                return a**2
+            print(a, b())
+            """
+        )
+        assert content == expected_content
+
+
+def test_store():
+    """Test %store."""
+    ip = get_ipython()
+    ip.run_line_magic("load_ext", "storemagic")
+
+    # make sure the storage is empty
+    ip.run_line_magic("store", "-z")
+    ip.user_ns["var"] = 42
+    ip.run_line_magic("store", "var")
+    ip.user_ns["var"] = 39
+    ip.run_line_magic("store", "-r")
+    assert ip.user_ns["var"] == 42
+
+    ip.run_line_magic("store", "-d var")
+    ip.user_ns["var"] = 39
+    ip.run_line_magic("store", "-r")
+    assert ip.user_ns["var"] == 39
+
+
+def _run_edit_test(
+    arg_s, exp_filename=None, exp_lineno=-1, exp_contents=None, exp_is_temp=None
+):
+    ip = get_ipython()
+    M = code.CodeMagics(ip)
+    last_call = ["", ""]
+    opts, args = M.parse_options(arg_s, "prxn:")
+    filename, lineno, is_temp = M._find_edit_target(ip, args, opts, last_call)
+
+    if exp_filename is not None:
+        assert exp_filename == filename
+    if exp_contents is not None:
+        with io.open(filename, "r", encoding="utf-8") as f:
+            contents = f.read()
+        assert exp_contents == contents
+    if exp_lineno != -1:
+        assert exp_lineno == lineno
+    if exp_is_temp is not None:
+        assert exp_is_temp == is_temp
+
+
+def test_edit_interactive():
+    """%edit on interactively defined objects"""
+    ip = get_ipython()
+    n = ip.execution_count
+    ip.run_cell("def foo(): return 1", store_history=True)
+
+    with pytest.raises(code.InteractivelyDefined) as e:
+        _run_edit_test("foo")
+    assert e.value.index == n
+
+
+def test_edit_cell():
+    """%edit [cell id]"""
+    ip = get_ipython()
+
+    ip.run_cell("def foo(): return 1", store_history=True)
+
+    # test
+    _run_edit_test("1", exp_contents=ip.user_ns["In"][1], exp_is_temp=True)
+
+
+def test_edit_fname():
+    """%edit file"""
+    # test
+    _run_edit_test("test file.py", exp_filename="test file.py")
+
+
+def test_bookmark():
+    ip = get_ipython()
+    ip.run_line_magic("bookmark", "bmname")
+    with tt.AssertPrints("bmname"):
+        ip.run_line_magic("bookmark", "-l")
+    ip.run_line_magic("bookmark", "-d bmname")
+
+
+def test_ls_magic():
+    ip = get_ipython()
+    json_formatter = ip.display_formatter.formatters["application/json"]
+    json_formatter.enabled = True
+    lsmagic = ip.run_line_magic("lsmagic", "")
+    with warnings.catch_warnings(record=True) as w:
+        j = json_formatter(lsmagic)
+    assert sorted(j) == ["cell", "line"]
+    assert w == []  # no warnings
+
+
+def test_strip_initial_indent():
+    def sii(s):
+        lines = s.splitlines()
+        return "\n".join(code.strip_initial_indent(lines))
+
+    assert sii("  a = 1\nb = 2") == "a = 1\nb = 2"
+    assert sii("  a\n    b\nc") == "a\n  b\nc"
+    assert sii("a\n  b") == "a\n  b"
+
+
+def test_logging_magic_quiet_from_arg():
+    _ip.config.LoggingMagics.quiet = False
+    lm = logging.LoggingMagics(shell=_ip)
+    with TemporaryDirectory() as td:
+        try:
+            with tt.AssertNotPrints(re.compile("Activating.*")):
+                lm.logstart("-q {}".format(os.path.join(td, "quiet_from_arg.log")))
+        finally:
+            _ip.logger.logstop()
+
+
+def test_logging_magic_quiet_from_config():
+    _ip.config.LoggingMagics.quiet = True
+    lm = logging.LoggingMagics(shell=_ip)
+    with TemporaryDirectory() as td:
+        try:
+            with tt.AssertNotPrints(re.compile("Activating.*")):
+                lm.logstart(os.path.join(td, "quiet_from_config.log"))
+        finally:
+            _ip.logger.logstop()
+
+
+def test_logging_magic_not_quiet():
+    _ip.config.LoggingMagics.quiet = False
+    lm = logging.LoggingMagics(shell=_ip)
+    with TemporaryDirectory() as td:
+        try:
+            with tt.AssertPrints(re.compile("Activating.*")):
+                lm.logstart(os.path.join(td, "not_quiet.log"))
+        finally:
+            _ip.logger.logstop()
+
+
+def test_time_no_var_expand():
+    _ip.user_ns["a"] = 5
+    _ip.user_ns["b"] = []
+    _ip.run_line_magic("time", 'b.append("{a}")')
+    assert _ip.user_ns["b"] == ["{a}"]
+
+
+# this is slow, put at the end for local testing.
+def test_timeit_arguments():
+    "Test valid timeit arguments, should not cause SyntaxError (GH #1269)"
+    _ip.run_line_magic("timeit", "-n1 -r1 a=('#')")
+
+
+def test_time_raise_on_interrupt():
+    ip = get_ipython()
+
+    with pytest.raises(KeyboardInterrupt):
+        thread = Thread(target=_interrupt_after_1s)
+        thread.start()
+        ip.run_cell_magic("time", "", "from time import sleep; sleep(2)")
+        thread.join()
+
+
+MINIMAL_LAZY_MAGIC = """
+from IPython.core.magic import (
+    Magics,
+    magics_class,
+    line_magic,
+    cell_magic,
+)
+
+
+@magics_class
+class LazyMagics(Magics):
+    @line_magic
+    def lazy_line(self, line):
+        print("Lazy Line")
+
+    @cell_magic
+    def lazy_cell(self, line, cell):
+        print("Lazy Cell")
+
+
+def load_ipython_extension(ipython):
+    ipython.register_magics(LazyMagics)
+"""
+
+
+def test_lazy_magics():
+    with pytest.raises(UsageError):
+        ip.run_line_magic("lazy_line", "")
+
+    startdir = os.getcwd()
+
+    with TemporaryDirectory() as tmpdir:
+        with prepended_to_syspath(tmpdir):
+            ptempdir = Path(tmpdir)
+            tf = ptempdir / "lazy_magic_module.py"
+            tf.write_text(MINIMAL_LAZY_MAGIC)
+            ip.magics_manager.register_lazy("lazy_line", Path(tf.name).name[:-3])
+            with tt.AssertPrints("Lazy Line"):
+                ip.run_line_magic("lazy_line", "")
+
+
+TEST_MODULE = """
+print('Loaded my_tmp')
+if __name__ == "__main__":
+    print('I just ran a script')
+"""
+
+
+def test_run_module_from_import_hook():
+    "Test that a module can be loaded via an import hook"
+    with TemporaryDirectory() as tmpdir:
+        fullpath = os.path.join(tmpdir, "my_tmp.py")
+        Path(fullpath).write_text(TEST_MODULE, encoding="utf-8")
+
+        import importlib.abc
+        import importlib.util
+
+        class MyTempImporter(importlib.abc.MetaPathFinder, importlib.abc.SourceLoader):
+            def find_spec(self, fullname, path, target=None):
+                if fullname == "my_tmp":
+                    return importlib.util.spec_from_loader(fullname, self)
+
+            def get_filename(self, fullname):
+                assert fullname == "my_tmp"
+                return fullpath
+
+            def get_data(self, path):
+                assert Path(path).samefile(fullpath)
+                return Path(fullpath).read_text(encoding="utf-8")
+
+        sys.meta_path.insert(0, MyTempImporter())
+
+        with capture_output() as captured:
+            _ip.run_line_magic("run", "-m my_tmp")
+            _ip.run_cell("import my_tmp")
+
+        output = "Loaded my_tmp\nI just ran a script\nLoaded my_tmp\n"
+        assert output == captured.stdout
+
+        sys.meta_path.pop(0)
diff --git a/tests/test_magic_arguments.py b/tests/test_magic_arguments.py
new file mode 100644
index 00000000000..a74bd87d89b
--- /dev/null
+++ b/tests/test_magic_arguments.py
@@ -0,0 +1,145 @@
+# -----------------------------------------------------------------------------
+# Copyright (C) 2010-2011, IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+import argparse
+import sys
+
+from IPython.core.magic_arguments import (
+    argument,
+    argument_group,
+    kwds,
+    magic_arguments,
+    parse_argstring,
+    real_name,
+)
+
+LEADING_SPACE = "" if sys.version_info > (3, 13) else " "
+
+# We do test docstring behavior here.
+# fmt: off
+
+@magic_arguments()
+@argument('-f', '--foo', help="an argument")
+def magic_foo1(self, args):
+    """ A docstring.
+    """
+    return parse_argstring(magic_foo1, args)
+
+
+@magic_arguments()
+def magic_foo2(self, args):
+    """ A docstring.
+    """
+    return parse_argstring(magic_foo2, args)
+
+
+@magic_arguments()
+@argument('-f', '--foo', help="an argument")
+@argument_group('Group')
+@argument('-b', '--bar', help="a grouped argument")
+@argument_group('Second Group')
+@argument('-z', '--baz', help="another grouped argument")
+def magic_foo3(self, args):
+    """ A docstring.
+    """
+    return parse_argstring(magic_foo3, args)
+
+
+@magic_arguments()
+@kwds(argument_default=argparse.SUPPRESS)
+@argument('-f', '--foo', help="an argument")
+def magic_foo4(self, args):
+    """ A docstring.
+    """
+    return parse_argstring(magic_foo4, args)
+
+
+@magic_arguments('frobnicate')
+@argument('-f', '--foo', help="an argument")
+def magic_foo5(self, args):
+    """ A docstring.
+    """
+    return parse_argstring(magic_foo5, args)
+
+
+@magic_arguments()
+@argument('-f', '--foo', help="an argument")
+def magic_magic_foo(self, args):
+    """ A docstring.
+    """
+    return parse_argstring(magic_magic_foo, args)
+
+
+@magic_arguments()
+@argument('-f', '--foo', help="an argument")
+def foo(self, args):
+    """ A docstring.
+    """
+    return parse_argstring(foo, args)
+
+
+def test_magic_arguments():
+    assert (
+        magic_foo1.__doc__
+        == f"::\n\n  %foo1 [-f FOO]\n\n{LEADING_SPACE}A docstring.\n\noptions:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_foo1, "argcmd_name", None) == None
+    assert real_name(magic_foo1) == "foo1"
+    assert magic_foo1(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(magic_foo1, "has_arguments")
+
+    assert magic_foo2.__doc__ == f"::\n\n  %foo2\n\n{LEADING_SPACE}A docstring.\n"
+    assert getattr(magic_foo2, "argcmd_name", None) == None
+    assert real_name(magic_foo2) == "foo2"
+    assert magic_foo2(None, "") == argparse.Namespace()
+    assert hasattr(magic_foo2, "has_arguments")
+
+    assert (
+        magic_foo3.__doc__
+        == f"::\n\n  %foo3 [-f FOO] [-b BAR] [-z BAZ]\n\n{LEADING_SPACE}A docstring.\n\noptions:\n  -f FOO, --foo FOO  an argument\n\nGroup:\n  -b BAR, --bar BAR  a grouped argument\n\nSecond Group:\n  -z BAZ, --baz BAZ  another grouped argument\n"
+    )
+    assert getattr(magic_foo3, "argcmd_name", None) == None
+    assert real_name(magic_foo3) == "foo3"
+    assert magic_foo3(None, "") == argparse.Namespace(bar=None, baz=None, foo=None)
+    assert hasattr(magic_foo3, "has_arguments")
+
+    assert (
+        magic_foo4.__doc__
+        == f"::\n\n  %foo4 [-f FOO]\n\n{LEADING_SPACE}A docstring.\n\noptions:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_foo4, "argcmd_name", None) == None
+    assert real_name(magic_foo4) == "foo4"
+    assert magic_foo4(None, "") == argparse.Namespace()
+    assert hasattr(magic_foo4, "has_arguments")
+
+    assert (
+        magic_foo5.__doc__
+        == f"::\n\n  %frobnicate [-f FOO]\n\n{LEADING_SPACE}A docstring.\n\noptions:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_foo5, "argcmd_name", None) == "frobnicate"
+    assert real_name(magic_foo5) == "frobnicate"
+    assert magic_foo5(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(magic_foo5, "has_arguments")
+
+    assert (
+        magic_magic_foo.__doc__
+        == f"::\n\n  %magic_foo [-f FOO]\n\n{LEADING_SPACE}A docstring.\n\noptions:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(magic_magic_foo, "argcmd_name", None) == None
+    assert real_name(magic_magic_foo) == "magic_foo"
+    assert magic_magic_foo(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(magic_magic_foo, "has_arguments")
+
+    assert (
+        foo.__doc__
+        == f"::\n\n  %foo [-f FOO]\n\n{LEADING_SPACE}A docstring.\n\noptions:\n  -f FOO, --foo FOO  an argument\n"
+    )
+    assert getattr(foo, "argcmd_name", None) == None
+    assert real_name(foo) == "foo"
+    assert foo(None, "") == argparse.Namespace(foo=None)
+    assert hasattr(foo, "has_arguments")
diff --git a/tests/test_magic_terminal.py b/tests/test_magic_terminal.py
new file mode 100644
index 00000000000..893c3b940d8
--- /dev/null
+++ b/tests/test_magic_terminal.py
@@ -0,0 +1,220 @@
+"""Tests for various magic functions specific to the terminal frontend."""
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import sys
+from io import StringIO
+from unittest import TestCase
+
+from IPython.testing import tools as tt
+
+# -----------------------------------------------------------------------------
+# Test functions begin
+# -----------------------------------------------------------------------------
+
+
+MINIMAL_LAZY_MAGIC = """
+from IPython.core.magic import (
+    Magics,
+    magics_class,
+    line_magic,
+    cell_magic,
+)
+
+
+@magics_class
+class LazyMagics(Magics):
+    @line_magic
+    def lazy_line(self, line):
+        print("Lazy Line")
+
+    @cell_magic
+    def lazy_cell(self, line, cell):
+        print("Lazy Cell")
+
+
+def load_ipython_extension(ipython):
+    ipython.register_magics(LazyMagics)
+"""
+
+
+def check_cpaste(code, should_fail=False):
+    """Execute code via 'cpaste' and ensure it was executed, unless
+    should_fail is set.
+    """
+    ip.user_ns["code_ran"] = False
+
+    src = StringIO()
+    src.write(code)
+    src.write("\n--\n")
+    src.seek(0)
+
+    stdin_save = sys.stdin
+    sys.stdin = src
+
+    try:
+        context = tt.AssertPrints if should_fail else tt.AssertNotPrints
+        with context("Traceback (most recent call last)"):
+            ip.run_line_magic("cpaste", "")
+
+        if not should_fail:
+            assert ip.user_ns["code_ran"], "%r failed" % code
+    finally:
+        sys.stdin = stdin_save
+
+
+def test_cpaste():
+    """Test cpaste magic"""
+
+    def runf():
+        """Marker function: sets a flag when executed."""
+        ip.user_ns["code_ran"] = True
+        return "runf"  # return string so '+ runf()' doesn't result in success
+
+    tests = {
+        "pass": [
+            "runf()",
+            "In [1]: runf()",
+            "In [1]: if 1:\n   ...:     runf()",
+            "> > > runf()",
+            ">>> runf()",
+            "   >>> runf()",
+        ],
+        "fail": [
+            "1 + runf()",
+            "++ runf()",
+        ],
+    }
+
+    ip.user_ns["runf"] = runf
+
+    for code in tests["pass"]:
+        check_cpaste(code)
+
+    for code in tests["fail"]:
+        check_cpaste(code, should_fail=True)
+
+
+class PasteTestCase(TestCase):
+    """Multiple tests for clipboard pasting"""
+
+    def paste(self, txt, flags="-q"):
+        """Paste input text, by default in quiet mode"""
+        ip.hooks.clipboard_get = lambda: txt
+        ip.run_line_magic("paste", flags)
+
+    def setUp(self):
+        # Inject fake clipboard hook but save original so we can restore it later
+        self.original_clip = ip.hooks.clipboard_get
+
+    def tearDown(self):
+        # Restore original hook
+        ip.hooks.clipboard_get = self.original_clip
+
+    def test_paste(self):
+        ip.user_ns.pop("x", None)
+        self.paste("x = 1")
+        self.assertEqual(ip.user_ns["x"], 1)
+        ip.user_ns.pop("x")
+
+    def test_paste_pyprompt(self):
+        ip.user_ns.pop("x", None)
+        self.paste(">>> x=2")
+        self.assertEqual(ip.user_ns["x"], 2)
+        ip.user_ns.pop("x")
+
+    def test_paste_py_multi(self):
+        self.paste(
+            """
+        >>> x = [1,2,3]
+        >>> y = []
+        >>> for i in x:
+        ...     y.append(i**2)
+        ... 
+        """
+        )
+        self.assertEqual(ip.user_ns["x"], [1, 2, 3])
+        self.assertEqual(ip.user_ns["y"], [1, 4, 9])
+
+    def test_paste_py_multi_r(self):
+        "Now, test that self.paste -r works"
+        self.test_paste_py_multi()
+        self.assertEqual(ip.user_ns.pop("x"), [1, 2, 3])
+        self.assertEqual(ip.user_ns.pop("y"), [1, 4, 9])
+        self.assertFalse("x" in ip.user_ns)
+        ip.run_line_magic("paste", "-r")
+        self.assertEqual(ip.user_ns["x"], [1, 2, 3])
+        self.assertEqual(ip.user_ns["y"], [1, 4, 9])
+
+    def test_paste_email(self):
+        "Test pasting of email-quoted contents"
+        self.paste(
+            """\
+        >> def foo(x):
+        >>     return x + 1
+        >> xx = foo(1.1)"""
+        )
+        self.assertEqual(ip.user_ns["xx"], 2.1)
+
+    def test_paste_email2(self):
+        "Email again; some programs add a space also at each quoting level"
+        self.paste(
+            """\
+        > > def foo(x):
+        > >     return x + 1
+        > > yy = foo(2.1)     """
+        )
+        self.assertEqual(ip.user_ns["yy"], 3.1)
+
+    def test_paste_email_py(self):
+        "Email quoting of interactive input"
+        self.paste(
+            """\
+        >> >>> def f(x):
+        >> ...   return x+1
+        >> ... 
+        >> >>> zz = f(2.5)      """
+        )
+        self.assertEqual(ip.user_ns["zz"], 3.5)
+
+    def test_paste_echo(self):
+        "Also test self.paste echoing, by temporarily faking the writer"
+        w = StringIO()
+        old_write = sys.stdout.write
+        sys.stdout.write = w.write
+        code = """
+        a = 100
+        b = 200"""
+        try:
+            self.paste(code, "")
+            out = w.getvalue()
+        finally:
+            sys.stdout.write = old_write
+        self.assertEqual(ip.user_ns["a"], 100)
+        self.assertEqual(ip.user_ns["b"], 200)
+        assert out == code + "\n## -- End pasted text --\n"
+
+    def test_paste_leading_commas(self):
+        "Test multiline strings with leading commas"
+        tm = ip.magics_manager.registry["TerminalMagics"]
+        s = '''\
+a = """
+,1,2,3
+"""'''
+        ip.user_ns.pop("foo", None)
+        tm.store_or_execute(s, "foo")
+        self.assertIn("foo", ip.user_ns)
+
+    def test_paste_trailing_question(self):
+        "Test pasting sources with trailing question marks"
+        tm = ip.magics_manager.registry["TerminalMagics"]
+        s = """\
+def funcfoo():
+   if True: #am i true?
+       return 'fooresult'
+"""
+        ip.user_ns.pop("funcfoo", None)
+        self.paste(s)
+        self.assertEqual(ip.user_ns["funcfoo"](), "fooresult")
diff --git a/tests/test_module_paths.py b/tests/test_module_paths.py
new file mode 100644
index 00000000000..babe43e75c0
--- /dev/null
+++ b/tests/test_module_paths.py
@@ -0,0 +1,112 @@
+# encoding: utf-8
+"""Tests for IPython.utils.module_paths.py"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2008-2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import shutil
+import sys
+import tempfile
+
+from pathlib import Path
+
+import IPython.utils.module_paths as mp
+
+TEST_FILE_PATH = Path(__file__).resolve().parent
+
+TMP_TEST_DIR = Path(tempfile.mkdtemp(suffix="with.dot"))
+#
+# Setup/teardown functions/decorators
+#
+
+old_syspath = sys.path
+
+
+def make_empty_file(fname):
+    open(fname, "w", encoding="utf-8").close()
+
+
+def setup_module():
+    """Setup testenvironment for the module:"""
+    # Do not mask exceptions here.  In particular, catching WindowsError is a
+    # problem because that exception is only defined on Windows...
+    Path(TMP_TEST_DIR / "xmod").mkdir(parents=True)
+    Path(TMP_TEST_DIR / "nomod").mkdir(parents=True)
+    make_empty_file(TMP_TEST_DIR / "xmod/__init__.py")
+    make_empty_file(TMP_TEST_DIR / "xmod/sub.py")
+    make_empty_file(TMP_TEST_DIR / "pack.py")
+    make_empty_file(TMP_TEST_DIR / "packpyc.pyc")
+    sys.path = [str(TMP_TEST_DIR)]
+
+
+def teardown_module():
+    """Teardown testenvironment for the module:
+
+    - Remove tempdir
+    - restore sys.path
+    """
+    # Note: we remove the parent test dir, which is the root of all test
+    # subdirs we may have created.  Use shutil instead of os.removedirs, so
+    # that non-empty directories are all recursively removed.
+    shutil.rmtree(TMP_TEST_DIR)
+    sys.path = old_syspath
+
+
+def test_tempdir():
+    """
+    Ensure the test are done with a temporary file that have a dot somewhere.
+    """
+    assert "." in str(TMP_TEST_DIR)
+
+
+def test_find_mod_1():
+    """
+    Search for a directory's file path.
+    Expected output: a path to that directory's __init__.py file.
+    """
+    modpath = TMP_TEST_DIR / "xmod" / "__init__.py"
+    assert Path(mp.find_mod("xmod")) == modpath
+
+
+def test_find_mod_2():
+    """
+    Search for a directory's file path.
+    Expected output: a path to that directory's __init__.py file.
+    TODO: Confirm why this is a duplicate test.
+    """
+    modpath = TMP_TEST_DIR / "xmod" / "__init__.py"
+    assert Path(mp.find_mod("xmod")) == modpath
+
+
+def test_find_mod_3():
+    """
+    Search for a directory + a filename without its .py extension
+    Expected output: full path with .py extension.
+    """
+    modpath = TMP_TEST_DIR / "xmod" / "sub.py"
+    assert Path(mp.find_mod("xmod.sub")) == modpath
+
+
+def test_find_mod_4():
+    """
+    Search for a filename without its .py extension
+    Expected output: full path with .py extension
+    """
+    modpath = TMP_TEST_DIR / "pack.py"
+    assert Path(mp.find_mod("pack")) == modpath
+
+
+def test_find_mod_5():
+    """
+    Search for a filename with a .pyc extension
+    Expected output: TODO: do we exclude or include .pyc files?
+    """
+    assert mp.find_mod("packpyc") == None
diff --git a/tests/test_oinspect.py b/tests/test_oinspect.py
new file mode 100644
index 00000000000..31ce73ba946
--- /dev/null
+++ b/tests/test_oinspect.py
@@ -0,0 +1,606 @@
+from contextlib import contextmanager
+from inspect import signature, Signature, Parameter
+import inspect
+import os
+import pytest
+import re
+import sys
+
+from IPython.core import oinspect
+
+from decorator import decorator
+
+from IPython.testing.tools import AssertPrints, AssertNotPrints
+from IPython.utils.path import compress_user
+
+
+# -----------------------------------------------------------------------------
+# Globals and constants
+# -----------------------------------------------------------------------------
+
+inspector = None
+
+
+def setup_module():
+    global inspector
+    inspector = oinspect.Inspector(theme_name="nocolor")
+
+
+class SourceModuleMainTest:
+    __module__ = "__main__"
+
+
+# -----------------------------------------------------------------------------
+# Local utilities
+# -----------------------------------------------------------------------------
+
+# WARNING: since this test checks the line number where a function is
+# defined, if any code is inserted above, the following line will need to be
+# updated.  Do NOT insert any whitespace between the next line and the function
+# definition below.
+THIS_LINE_NUMBER = 41  # Put here the actual number of this line
+
+
+def test_find_source_lines():
+    assert oinspect.find_source_lines(test_find_source_lines) == THIS_LINE_NUMBER + 3
+    assert oinspect.find_source_lines(type) is None
+    assert oinspect.find_source_lines(SourceModuleMainTest) is None
+    assert oinspect.find_source_lines(SourceModuleMainTest()) is None
+
+
+def test_getsource():
+    assert oinspect.getsource(type) is None
+    assert oinspect.getsource(SourceModuleMainTest) is None
+    assert oinspect.getsource(SourceModuleMainTest()) is None
+
+
+def test_inspect_getfile_raises_exception():
+    """Check oinspect.find_file/getsource/find_source_lines expectations"""
+    with pytest.raises(TypeError):
+        inspect.getfile(type)
+    with pytest.raises(OSError):
+        inspect.getfile(SourceModuleMainTest)
+
+
+# A couple of utilities to ensure these tests work the same from a source or a
+# binary install
+def pyfile(fname):
+    return os.path.normcase(re.sub(".py[co]$", ".py", fname))
+
+
+def match_pyfiles(f1, f2):
+    assert pyfile(f1) == pyfile(f2)
+
+
+def test_find_file():
+    match_pyfiles(oinspect.find_file(test_find_file), os.path.abspath(__file__))
+    assert oinspect.find_file(type) is None
+    assert oinspect.find_file(SourceModuleMainTest) is None
+    assert oinspect.find_file(SourceModuleMainTest()) is None
+
+
+def test_find_file_decorated1():
+    @decorator
+    def noop1(f):
+        def wrapper(*a, **kw):
+            return f(*a, **kw)
+
+        return wrapper
+
+    @noop1
+    def f(x):
+        "My docstring"
+
+    match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__))
+    assert f.__doc__ == "My docstring"
+
+
+def test_find_file_decorated2():
+    @decorator
+    def noop2(f, *a, **kw):
+        return f(*a, **kw)
+
+    @noop2
+    @noop2
+    @noop2
+    def f(x):
+        "My docstring 2"
+
+    match_pyfiles(oinspect.find_file(f), os.path.abspath(__file__))
+    assert f.__doc__ == "My docstring 2"
+
+
+def test_find_file_magic():
+    run = ip.find_line_magic("run")
+    assert oinspect.find_file(run) is not None
+
+
+# A few generic objects we can then inspect in the tests below
+
+
+class Call(object):
+    """This is the class docstring."""
+
+    def __init__(self, x, y=1):
+        """This is the constructor docstring."""
+
+    def __call__(self, *a, **kw):
+        """This is the call docstring."""
+
+    def method(self, x, z=2):
+        """Some method's docstring"""
+
+
+class HasSignature(object):
+    """This is the class docstring."""
+
+    __signature__ = Signature([Parameter("test", Parameter.POSITIONAL_OR_KEYWORD)])
+
+    def __init__(self, *args):
+        """This is the init docstring"""
+
+
+class SimpleClass(object):
+    def method(self, x, z=2):
+        """Some method's docstring"""
+
+
+class Awkward(object):
+    def __getattr__(self, name):
+        raise Exception(name)
+
+
+class NoBoolCall:
+    """
+    callable with `__bool__` raising should still be inspect-able.
+    """
+
+    def __call__(self):
+        """does nothing"""
+        pass
+
+    def __bool__(self):
+        """just raise NotImplemented"""
+        raise NotImplementedError("Must be implemented")
+
+
+class SerialLiar(object):
+    """Attribute accesses always get another copy of the same class.
+
+    unittest.mock.call does something similar, but it's not ideal for testing
+    as the failure mode is to eat all your RAM. This gives up after 10k levels.
+    """
+
+    def __init__(self, max_fibbing_twig, lies_told=0):
+        if lies_told > 10000:
+            raise RuntimeError("Nose too long, honesty is the best policy")
+        self.max_fibbing_twig = max_fibbing_twig
+        self.lies_told = lies_told
+        max_fibbing_twig[0] = max(max_fibbing_twig[0], lies_told)
+
+    def __getattr__(self, item):
+        return SerialLiar(self.max_fibbing_twig, self.lies_told + 1)
+
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+def test_info():
+    "Check that Inspector.info fills out various fields as expected."
+    i = inspector.info(Call, oname="Call")
+    assert i["type_name"] == "type"
+    expected_class = str(type(type))  # <class 'type'> (Python 3) or <type 'type'>
+    assert i["base_class"] == expected_class
+    assert re.search(
+        "<class 'tests.test_oinspect.Call'( at 0x[0-9a-f]{1,9})?>",
+        i["string_form"],
+    )
+    fname = __file__
+    if fname.endswith(".pyc"):
+        fname = fname[:-1]
+    # case-insensitive comparison needed on some filesystems
+    # e.g. Windows:
+    assert i["file"].lower() == compress_user(fname).lower()
+    assert i["definition"] == None
+    assert i["docstring"] == Call.__doc__
+    assert i["source"] == None
+    assert i["isclass"] is True
+    assert i["init_definition"] == "Call(x, y=1)"
+    assert i["init_docstring"] == Call.__init__.__doc__
+
+    i = inspector.info(Call, detail_level=1)
+    assert i["source"] is not None
+    assert i["docstring"] == None
+
+    c = Call(1)
+    c.__doc__ = "Modified instance docstring"
+    i = inspector.info(c)
+    assert i["type_name"] == "Call"
+    assert i["docstring"] == "Modified instance docstring"
+    assert i["class_docstring"] == Call.__doc__
+    assert i["init_docstring"] == Call.__init__.__doc__
+    assert i["call_docstring"] == Call.__call__.__doc__
+
+
+def test_class_signature():
+    info = inspector.info(HasSignature, "HasSignature")
+    assert info["init_definition"] == "HasSignature(test)"
+    assert info["init_docstring"] == HasSignature.__init__.__doc__
+
+
+def test_info_awkward():
+    # Just test that this doesn't throw an error.
+    inspector.info(Awkward())
+
+
+def test_bool_raise():
+    inspector.info(NoBoolCall())
+
+
+def test_info_serialliar():
+    fib_tracker = [0]
+    inspector.info(SerialLiar(fib_tracker))
+
+    # Nested attribute access should be cut off at 100 levels deep to avoid
+    # infinite loops: https://github.com/ipython/ipython/issues/9122
+    assert fib_tracker[0] < 9000
+
+
+def support_function_one(x, y=2, *a, **kw):
+    """A simple function."""
+
+
+def test_calldef_none():
+    # We should ignore __call__ for all of these.
+    for obj in [support_function_one, SimpleClass().method, any, str.upper]:
+        i = inspector.info(obj)
+        assert i["call_def"] is None
+
+
+def f_kwarg(pos, *, kwonly):
+    pass
+
+
+def test_definition_kwonlyargs():
+    i = inspector.info(f_kwarg, oname="f_kwarg")  # analysis:ignore
+    assert i["definition"] == "f_kwarg(pos, *, kwonly)"
+
+
+def test_getdoc():
+    class A(object):
+        """standard docstring"""
+
+        pass
+
+    class B(object):
+        """standard docstring"""
+
+        def getdoc(self):
+            return "custom docstring"
+
+    class C(object):
+        """standard docstring"""
+
+        def getdoc(self):
+            return None
+
+    a = A()
+    b = B()
+    c = C()
+
+    assert oinspect.getdoc(a) == "standard docstring"
+    assert oinspect.getdoc(b) == "custom docstring"
+    assert oinspect.getdoc(c) == "standard docstring"
+
+
+def test_empty_property_has_no_source():
+    i = inspector.info(property(), detail_level=1)
+    assert i["source"] is None
+
+
+def test_property_sources():
+    # A simple adder whose source and signature stays
+    # the same across Python distributions
+    def simple_add(a, b):
+        "Adds two numbers"
+        return a + b
+
+    class A(object):
+        @property
+        def foo(self):
+            return "bar"
+
+        foo = foo.setter(lambda self, v: setattr(self, "bar", v))
+
+        dname = property(oinspect.getdoc)
+        adder = property(simple_add)
+
+    i = inspector.info(A.foo, detail_level=1)
+    assert "def foo(self):" in i["source"]
+    assert "lambda self, v:" in i["source"]
+
+    i = inspector.info(A.dname, detail_level=1)
+    assert "def getdoc(obj)" in i["source"]
+
+    i = inspector.info(A.adder, detail_level=1)
+    assert "def simple_add(a, b)" in i["source"]
+
+
+def test_property_docstring_is_in_info_for_detail_level_0():
+    class A(object):
+        @property
+        def foobar(self):
+            """This is `foobar` property."""
+            pass
+
+    ip.user_ns["a_obj"] = A()
+    assert (
+        "This is `foobar` property."
+        == ip.object_inspect("a_obj.foobar", detail_level=0)["docstring"]
+    )
+
+    ip.user_ns["a_cls"] = A
+    assert (
+        "This is `foobar` property."
+        == ip.object_inspect("a_cls.foobar", detail_level=0)["docstring"]
+    )
+
+
+def test_pdef():
+    # See gh-1914
+    def foo():
+        pass
+
+    inspector.pdef(foo, "foo")
+
+
+@contextmanager
+def cleanup_user_ns(**kwargs):
+    """
+    On exit delete all the keys that were not in user_ns before entering.
+
+    It does not restore old values !
+
+    Parameters
+    ----------
+
+    **kwargs
+        used to update ip.user_ns
+
+    """
+    try:
+        known = set(ip.user_ns.keys())
+        ip.user_ns.update(kwargs)
+        yield
+    finally:
+        added = set(ip.user_ns.keys()) - known
+        for k in added:
+            del ip.user_ns[k]
+
+
+def test_pinfo_bool_raise():
+    """
+    Test that bool method is not called on parent.
+    """
+
+    class RaiseBool:
+        attr = None
+
+        def __bool__(self):
+            raise ValueError("pinfo should not access this method")
+
+    raise_bool = RaiseBool()
+
+    with cleanup_user_ns(raise_bool=raise_bool):
+        ip._inspect("pinfo", "raise_bool.attr", detail_level=0)
+
+
+def test_pinfo_getindex():
+    def dummy():
+        """
+        MARKER
+        """
+
+    container = [dummy]
+    with cleanup_user_ns(container=container):
+        with AssertPrints("MARKER"):
+            ip._inspect("pinfo", "container[0]", detail_level=0)
+    assert "container" not in ip.user_ns.keys()
+
+
+def test_qmark_getindex():
+    def dummy():
+        """
+        MARKER 2
+        """
+
+    container = [dummy]
+    with cleanup_user_ns(container=container):
+        with AssertPrints("MARKER 2"):
+            ip.run_cell("container[0]?")
+    assert "container" not in ip.user_ns.keys()
+
+
+def test_qmark_getindex_negatif():
+    def dummy():
+        """
+        MARKER 3
+        """
+
+    container = [dummy]
+    with cleanup_user_ns(container=container):
+        with AssertPrints("MARKER 3"):
+            ip.run_cell("container[-1]?")
+    assert "container" not in ip.user_ns.keys()
+
+
+def test_pinfo_nonascii():
+    # See gh-1177
+    from . import nonascii2
+
+    ip.user_ns["nonascii2"] = nonascii2
+    ip._inspect("pinfo", "nonascii2", detail_level=1)
+
+
+def test_pinfo_type():
+    """
+    type can fail in various edge case, for example `type.__subclass__()`
+    """
+    ip._inspect("pinfo", "type")
+
+
+def test_pinfo_docstring_no_source():
+    """Docstring should be included with detail_level=1 if there is no source"""
+    with AssertPrints("Docstring:"):
+        ip._inspect("pinfo", "str.format", detail_level=0)
+    with AssertPrints("Docstring:"):
+        ip._inspect("pinfo", "str.format", detail_level=1)
+
+
+def test_pinfo_no_docstring_if_source():
+    """Docstring should not be included with detail_level=1 if source is found"""
+
+    def foo():
+        """foo has a docstring"""
+
+    ip.user_ns["foo"] = foo
+
+    with AssertPrints("Docstring:"):
+        ip._inspect("pinfo", "foo", detail_level=0)
+    with AssertPrints("Source:"):
+        ip._inspect("pinfo", "foo", detail_level=1)
+    with AssertNotPrints("Docstring:"):
+        ip._inspect("pinfo", "foo", detail_level=1)
+
+
+def test_pinfo_docstring_if_detail_and_no_source():
+    """Docstring should be displayed if source info not available"""
+    obj_def = '''class Foo(object):
+                  """ This is a docstring for Foo """
+                  def bar(self):
+                      """ This is a docstring for Foo.bar """
+                      pass
+              '''
+
+    ip.run_cell(obj_def)
+    ip.run_cell("foo = Foo()")
+
+    with AssertNotPrints("Source:"):
+        with AssertPrints("Docstring:"):
+            ip._inspect("pinfo", "foo", detail_level=0)
+        with AssertPrints("Docstring:"):
+            ip._inspect("pinfo", "foo", detail_level=1)
+        with AssertPrints("Docstring:"):
+            ip._inspect("pinfo", "foo.bar", detail_level=0)
+
+    with AssertNotPrints("Docstring:"):
+        with AssertPrints("Source:"):
+            ip._inspect("pinfo", "foo.bar", detail_level=1)
+
+
+@pytest.mark.xfail(
+    sys.version_info.releaselevel not in ("final", "candidate"),
+    reason="fails on 3.13.dev",
+    strict=(sys.version_info < (3, 15)),
+)
+def test_pinfo_docstring_dynamic(capsys):
+    obj_def = """class Bar:
+    __custom_documentations__ = {
+     "prop" : "cdoc for prop",
+     "non_exist" : "cdoc for non_exist",
+    }
+    @property
+    def prop(self):
+        '''
+        Docstring for prop
+        '''
+        return self._prop
+    
+    @prop.setter
+    def prop(self, v):
+        self._prop = v
+    """
+    ip.run_cell(obj_def)
+
+    ip.run_cell("b = Bar()")
+
+    ip.run_line_magic("pinfo", "b.prop")
+    captured = capsys.readouterr()
+    assert re.search(r"Docstring:\s+cdoc for prop", captured.out)
+
+    ip.run_line_magic("pinfo", "b.non_exist")
+    captured = capsys.readouterr()
+    assert re.search(r"Docstring:\s+cdoc for non_exist", captured.out)
+
+    ip.run_cell("b.prop?")
+    captured = capsys.readouterr()
+    assert re.search(r"Docstring:\s+cdoc for prop", captured.out)
+
+    ip.run_cell("b.non_exist?")
+    captured = capsys.readouterr()
+    assert re.search(r"Docstring:\s+cdoc for non_exist", captured.out)
+
+    ip.run_cell("b.undefined?")
+    captured = capsys.readouterr()
+    assert re.search(r"Type:\s+NoneType", captured.out)
+
+
+def test_pinfo_magic():
+    with AssertPrints("Docstring:"):
+        ip._inspect("pinfo", "lsmagic", detail_level=0)
+
+    with AssertPrints("Source:"):
+        ip._inspect("pinfo", "lsmagic", detail_level=1)
+
+
+def test_init_colors():
+    # ensure colors are not present in signature info
+    info = inspector.info(HasSignature)
+    init_def = info["init_definition"]
+    assert "[0m" not in init_def
+
+
+def test_builtin_init():
+    info = inspector.info(list)
+    init_def = info["init_definition"]
+    assert init_def is not None
+
+
+def test_render_signature_short():
+    def short_fun(a=1):
+        pass
+
+    sig = oinspect._render_signature(
+        signature(short_fun),
+        short_fun.__name__,
+    )
+    assert sig == "short_fun(a=1)"
+
+
+def test_render_signature_long():
+    from typing import Optional
+
+    def long_function(
+        a_really_long_parameter: int,
+        and_another_long_one: bool = False,
+        let_us_make_sure_this_is_looong: Optional[str] = None,
+    ) -> bool:
+        pass
+
+    sig = oinspect._render_signature(
+        signature(long_function),
+        long_function.__name__,
+    )
+    expected = """\
+long_function(
+    a_really_long_parameter: int,
+    and_another_long_one: bool = False,
+    let_us_make_sure_this_is_looong: Optional[str] = None,
+) -> bool\
+"""
+    if sys.version_info >= (3, 14):
+        expected = expected.replace("Optional[str]", "str | None")
+
+    assert sig == expected
diff --git a/tests/test_openpy.py b/tests/test_openpy.py
new file mode 100644
index 00000000000..f98f97a1931
--- /dev/null
+++ b/tests/test_openpy.py
@@ -0,0 +1,38 @@
+import io
+import os.path
+
+from IPython.utils import openpy
+
+mydir = os.path.dirname(__file__)
+nonascii_path = os.path.join(mydir, "nonascii.py")
+
+
+def test_detect_encoding():
+    with open(nonascii_path, "rb") as f:
+        enc, lines = openpy.detect_encoding(f.readline)
+    assert enc == "iso-8859-5"
+
+
+def test_read_file():
+    with io.open(nonascii_path, encoding="iso-8859-5") as f:
+        read_specified_enc = f.read()
+    read_detected_enc = openpy.read_py_file(nonascii_path, skip_encoding_cookie=False)
+    assert read_detected_enc == read_specified_enc
+    assert "coding: iso-8859-5" in read_detected_enc
+
+    read_strip_enc_cookie = openpy.read_py_file(
+        nonascii_path, skip_encoding_cookie=True
+    )
+    assert "coding: iso-8859-5" not in read_strip_enc_cookie
+
+
+def test_source_to_unicode():
+    with io.open(nonascii_path, "rb") as f:
+        source_bytes = f.read()
+    assert (
+        openpy.source_to_unicode(source_bytes, skip_encoding_cookie=False).splitlines()
+        == source_bytes.decode("iso-8859-5").splitlines()
+    )
+
+    source_no_cookie = openpy.source_to_unicode(source_bytes, skip_encoding_cookie=True)
+    assert "coding: iso-8859-5" not in source_no_cookie
diff --git a/tests/test_page.py b/tests/test_page.py
new file mode 100644
index 00000000000..1b9b3b88e73
--- /dev/null
+++ b/tests/test_page.py
@@ -0,0 +1,21 @@
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2010-2011 The IPython Development Team.
+#
+#  Distributed under the terms of the BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+import io
+
+# N.B. For the test suite, page.page is overridden (see IPython.testing.globalipapp)
+from IPython.core import page
+
+
+def test_detect_screen_size():
+    """Simple smoketest for page._detect_screen_size."""
+    try:
+        page._detect_screen_size(True, 25)
+    except (TypeError, io.UnsupportedOperation):
+        # This can happen in the test suite, because stdout may not have a
+        # fileno.
+        pass
diff --git a/tests/test_path.py b/tests/test_path.py
new file mode 100644
index 00000000000..900bf2d67f6
--- /dev/null
+++ b/tests/test_path.py
@@ -0,0 +1,525 @@
+# encoding: utf-8
+"""Tests for IPython.utils.path.py"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from contextlib import contextmanager
+from importlib import reload
+from os.path import abspath, join
+from unittest.mock import patch
+
+import pytest
+from tempfile import TemporaryDirectory
+
+import IPython
+from IPython import paths
+from IPython.testing import decorators as dec
+from IPython.testing.decorators import (
+    onlyif_unicode_paths,
+    skip_if_not_win32,
+    skip_win32,
+)
+from IPython.testing.tools import make_tempfile
+from IPython.utils import path
+
+# Platform-dependent imports
+try:
+    import winreg as wreg
+except ImportError:
+    # Fake _winreg module on non-windows platforms
+    import types
+
+    wr_name = "winreg"
+    sys.modules[wr_name] = types.ModuleType(wr_name)
+    try:
+        import winreg as wreg
+    except ImportError:
+        import _winreg as wreg
+
+        # Add entries that needs to be stubbed by the testing code
+        (
+            wreg.OpenKey,
+            wreg.QueryValueEx,
+        ) = (None, None)
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+env = os.environ
+TMP_TEST_DIR = tempfile.mkdtemp()
+HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
+#
+# Setup/teardown functions/decorators
+#
+
+
+def setup_module():
+    """Setup testenvironment for the module:
+
+    - Adds dummy home dir tree
+    """
+    # Do not mask exceptions here.  In particular, catching WindowsError is a
+    # problem because that exception is only defined on Windows...
+    os.makedirs(os.path.join(HOME_TEST_DIR, "ipython"))
+
+
+def teardown_module():
+    """Teardown testenvironment for the module:
+
+    - Remove dummy home dir tree
+    """
+    # Note: we remove the parent test dir, which is the root of all test
+    # subdirs we may have created.  Use shutil instead of os.removedirs, so
+    # that non-empty directories are all recursively removed.
+    shutil.rmtree(TMP_TEST_DIR)
+
+
+# Build decorator that uses the setup_environment/setup_environment
+@pytest.fixture
+def environment():
+    global oldstuff, platformstuff
+    oldstuff = (
+        env.copy(),
+        os.name,
+        sys.platform,
+        path.get_home_dir,
+        IPython.__file__,
+        os.getcwd(),
+    )
+
+    yield
+
+    (
+        oldenv,
+        os.name,
+        sys.platform,
+        path.get_home_dir,
+        IPython.__file__,
+        old_wd,
+    ) = oldstuff
+    os.chdir(old_wd)
+    reload(path)
+
+    for key in list(env):
+        if key not in oldenv:
+            del env[key]
+    env.update(oldenv)
+    assert not hasattr(sys, "frozen")
+
+
+with_environment = pytest.mark.usefixtures("environment")
+
+
+@skip_if_not_win32
+@with_environment
+def test_get_home_dir_1(monkeypatch):
+    """Testcase for py2exe logic, un-compressed lib"""
+    unfrozen = path.get_home_dir()
+    monkeypatch.setattr(sys, "frozen", True, raising=False)
+
+    # fake filename for IPython.__init__
+    IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
+
+    home_dir = path.get_home_dir()
+    assert home_dir == unfrozen
+
+
+@skip_if_not_win32
+@with_environment
+def test_get_home_dir_2(monkeypatch):
+    """Testcase for py2exe logic, compressed lib"""
+    unfrozen = path.get_home_dir()
+    monkeypatch.setattr(sys, "frozen", True, raising=False)
+    # fake filename for IPython.__init__
+    IPython.__file__ = abspath(
+        join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")
+    ).lower()
+
+    home_dir = path.get_home_dir(True)
+    assert home_dir == unfrozen
+
+
+@skip_win32
+@with_environment
+def test_get_home_dir_3():
+    """get_home_dir() uses $HOME if set"""
+    env["HOME"] = HOME_TEST_DIR
+    home_dir = path.get_home_dir(True)
+    # get_home_dir expands symlinks
+    assert home_dir == os.path.realpath(env["HOME"])
+
+
+@with_environment
+def test_get_home_dir_4():
+    """get_home_dir() still works if $HOME is not set"""
+
+    if "HOME" in env:
+        del env["HOME"]
+    # this should still succeed, but we don't care what the answer is
+    home = path.get_home_dir(False)
+
+
+@skip_win32
+@with_environment
+def test_get_home_dir_5(monkeypatch):
+    """raise HomeDirError if $HOME is specified, but not a writable dir"""
+    env["HOME"] = abspath(HOME_TEST_DIR + "garbage")
+    # set os.name = posix, to prevent My Documents fallback on Windows
+    monkeypatch.setattr(os, "name", "posix")
+    pytest.raises(path.HomeDirError, path.get_home_dir, True)
+
+
+# Should we stub wreg fully so we can run the test on all platforms?
+@skip_if_not_win32
+@with_environment
+def test_get_home_dir_8(monkeypatch):
+    """Using registry hack for 'My Documents', os=='nt'
+
+    HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
+    """
+    monkeypatch.setattr(os, "name", "nt")
+    # Remove from stub environment all keys that may be set
+    for key in ["HOME", "HOMESHARE", "HOMEDRIVE", "HOMEPATH", "USERPROFILE"]:
+        env.pop(key, None)
+
+    class key:
+        def __enter__(self):
+            pass
+
+        def Close(self):
+            pass
+
+        def __exit__(*args, **kwargs):
+            pass
+
+    with (
+        patch.object(wreg, "OpenKey", return_value=key()),
+        patch.object(wreg, "QueryValueEx", return_value=[abspath(HOME_TEST_DIR)]),
+    ):
+        home_dir = path.get_home_dir()
+    assert home_dir == abspath(HOME_TEST_DIR)
+
+
+@with_environment
+def test_get_xdg_dir_0(monkeypatch):
+    """test_get_xdg_dir_0, check xdg_dir"""
+    monkeypatch.setattr(path, "_writable_dir", lambda path: True)
+    monkeypatch.setattr(path, "get_home_dir", lambda: "somewhere")
+    monkeypatch.setattr(os, "name", "posix")
+    monkeypatch.setattr(sys, "platform", "linux2")
+    env.pop("IPYTHON_DIR", None)
+    env.pop("IPYTHONDIR", None)
+    env.pop("XDG_CONFIG_HOME", None)
+
+    assert path.get_xdg_dir() == os.path.join("somewhere", ".config")
+
+
+@with_environment
+def test_get_xdg_dir_1(monkeypatch):
+    """test_get_xdg_dir_1, check nonexistent xdg_dir"""
+    monkeypatch.setattr(path, "get_home_dir", lambda: HOME_TEST_DIR)
+    monkeypatch.setattr(os, "name", "posix")
+    monkeypatch.setattr(sys, "platform", "linux2")
+    env.pop("IPYTHON_DIR", None)
+    env.pop("IPYTHONDIR", None)
+    env.pop("XDG_CONFIG_HOME", None)
+    assert path.get_xdg_dir() is None
+
+
+@with_environment
+def test_get_xdg_dir_2(monkeypatch):
+    """test_get_xdg_dir_2, check xdg_dir default to ~/.config"""
+    monkeypatch.setattr(path, "get_home_dir", lambda: HOME_TEST_DIR)
+    monkeypatch.setattr(os, "name", "posix")
+    monkeypatch.setattr(sys, "platform", "linux2")
+    env.pop("IPYTHON_DIR", None)
+    env.pop("IPYTHONDIR", None)
+    env.pop("XDG_CONFIG_HOME", None)
+    cfgdir = os.path.join(path.get_home_dir(), ".config")
+    if not os.path.exists(cfgdir):
+        os.makedirs(cfgdir)
+
+    assert path.get_xdg_dir() == cfgdir
+
+
+@with_environment
+def test_get_xdg_dir_3(monkeypatch):
+    """test_get_xdg_dir_3, check xdg_dir not used on non-posix systems"""
+    monkeypatch.setattr(path, "get_home_dir", lambda: HOME_TEST_DIR)
+    monkeypatch.setattr(os, "name", "nt")
+    monkeypatch.setattr(sys, "platform", "win32")
+    env.pop("IPYTHON_DIR", None)
+    env.pop("IPYTHONDIR", None)
+    env.pop("XDG_CONFIG_HOME", None)
+    cfgdir = os.path.join(path.get_home_dir(), ".config")
+    os.makedirs(cfgdir, exist_ok=True)
+
+    assert path.get_xdg_dir() is None
+
+
+def test_filefind():
+    """Various tests for filefind"""
+    f = tempfile.NamedTemporaryFile()
+    # print('fname:',f.name)
+    alt_dirs = paths.get_ipython_dir()
+    t = path.filefind(f.name, alt_dirs)
+    # print('found:',t)
+
+
+@dec.skip_if_not_win32
+def test_get_long_path_name_win32():
+    with TemporaryDirectory() as tmpdir:
+        # Make a long path. Expands the path of tmpdir prematurely as it may already have a long
+        # path component, so ensure we include the long form of it
+        long_path = os.path.join(
+            path.get_long_path_name(tmpdir), "this is my long path name"
+        )
+        os.makedirs(long_path)
+
+        # Test to see if the short path evaluates correctly.
+        short_path = os.path.join(tmpdir, "THISIS~1")
+        evaluated_path = path.get_long_path_name(short_path)
+        assert evaluated_path.lower() == long_path.lower()
+
+
+@dec.skip_win32
+def test_get_long_path_name():
+    p = path.get_long_path_name("/usr/local")
+    assert p == "/usr/local"
+
+
+@dec.skip_win32  # can't create not-user-writable dir on win
+@with_environment
+def test_not_writable_ipdir():
+    tmpdir = tempfile.mkdtemp()
+    os.name = "posix"
+    env.pop("IPYTHON_DIR", None)
+    env.pop("IPYTHONDIR", None)
+    env.pop("XDG_CONFIG_HOME", None)
+    env["HOME"] = tmpdir
+    ipdir = os.path.join(tmpdir, ".ipython")
+    os.mkdir(ipdir, 0o555)
+    try:
+        open(os.path.join(ipdir, "_foo_"), "w", encoding="utf-8").close()
+    except IOError:
+        pass
+    else:
+        # I can still write to an unwritable dir,
+        # assume I'm root and skip the test
+        pytest.skip("I can't create directories that I can't write to")
+
+    with pytest.warns(UserWarning, match="is not a writable location"):
+        ipdir = paths.get_ipython_dir()
+    env.pop("IPYTHON_DIR", None)
+
+
+@with_environment
+def test_get_py_filename():
+    os.chdir(TMP_TEST_DIR)
+    with make_tempfile("foo.py"):
+        assert path.get_py_filename("foo.py") == "foo.py"
+        assert path.get_py_filename("foo") == "foo.py"
+    with make_tempfile("foo"):
+        assert path.get_py_filename("foo") == "foo"
+        pytest.raises(IOError, path.get_py_filename, "foo.py")
+    pytest.raises(IOError, path.get_py_filename, "foo")
+    pytest.raises(IOError, path.get_py_filename, "foo.py")
+    true_fn = "foo with spaces.py"
+    with make_tempfile(true_fn):
+        assert path.get_py_filename("foo with spaces") == true_fn
+        assert path.get_py_filename("foo with spaces.py") == true_fn
+        pytest.raises(IOError, path.get_py_filename, '"foo with spaces.py"')
+        pytest.raises(IOError, path.get_py_filename, "'foo with spaces.py'")
+
+
+@onlyif_unicode_paths
+def test_unicode_in_filename():
+    """When a file doesn't exist, the exception raised should be safe to call
+    str() on - i.e. in Python 2 it must only have ASCII characters.
+
+    https://github.com/ipython/ipython/issues/875
+    """
+    try:
+        # these calls should not throw unicode encode exceptions
+        path.get_py_filename("fooéè.py")
+    except IOError as ex:
+        str(ex)
+
+
+class TestShellGlob(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.filenames_start_with_a = ["a0", "a1", "a2"]
+        cls.filenames_end_with_b = ["0b", "1b", "2b"]
+        cls.filenames = cls.filenames_start_with_a + cls.filenames_end_with_b
+        cls.tempdir = TemporaryDirectory()
+        td = cls.tempdir.name
+
+        with cls.in_tempdir():
+            # Create empty files
+            for fname in cls.filenames:
+                open(os.path.join(td, fname), "w", encoding="utf-8").close()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.tempdir.cleanup()
+
+    @classmethod
+    @contextmanager
+    def in_tempdir(cls):
+        save = os.getcwd()
+        try:
+            os.chdir(cls.tempdir.name)
+            yield
+        finally:
+            os.chdir(save)
+
+    def check_match(self, patterns, matches):
+        with self.in_tempdir():
+            # glob returns unordered list. that's why sorted is required.
+            assert sorted(path.shellglob(patterns)) == sorted(matches)
+
+    def common_cases(self):
+        return [
+            (["*"], self.filenames),
+            (["a*"], self.filenames_start_with_a),
+            (["*c"], ["*c"]),
+            (
+                ["*", "a*", "*b", "*c"],
+                self.filenames
+                + self.filenames_start_with_a
+                + self.filenames_end_with_b
+                + ["*c"],
+            ),
+            (["a[012]"], self.filenames_start_with_a),
+        ]
+
+    @skip_win32
+    def test_match_posix(self):
+        for patterns, matches in self.common_cases() + [
+            ([r"\*"], ["*"]),
+            ([r"a\*", "a*"], ["a*"] + self.filenames_start_with_a),
+            ([r"a\[012]"], ["a[012]"]),
+        ]:
+            self.check_match(patterns, matches)
+
+    @skip_if_not_win32
+    def test_match_windows(self):
+        for patterns, matches in self.common_cases() + [
+            # In windows, backslash is interpreted as path
+            # separator.  Therefore, you can't escape glob
+            # using it.
+            ([r"a\*", "a*"], [r"a\*"] + self.filenames_start_with_a),
+            ([r"a\[012]"], [r"a\[012]"]),
+        ]:
+            self.check_match(patterns, matches)
+
+
+@pytest.mark.parametrize(
+    "globstr, unescaped_globstr",
+    [
+        (r"\*\[\!\]\?", "*[!]?"),
+        (r"\\*", r"\*"),
+        (r"\\\*", r"\*"),
+        (r"\\a", r"\a"),
+        (r"\a", r"\a"),
+    ],
+)
+def test_unescape_glob(globstr, unescaped_globstr):
+    assert path.unescape_glob(globstr) == unescaped_globstr
+
+
+@onlyif_unicode_paths
+def test_ensure_dir_exists():
+    with TemporaryDirectory() as td:
+        d = os.path.join(td, "∂ir")
+        path.ensure_dir_exists(d)  # create it
+        assert os.path.isdir(d)
+        path.ensure_dir_exists(d)  # no-op
+        f = os.path.join(td, "Æ’ile")
+        open(f, "w", encoding="utf-8").close()  # touch
+        with pytest.raises(IOError):
+            path.ensure_dir_exists(f)
+
+
+class TestLinkOrCopy(unittest.TestCase):
+    def setUp(self):
+        self.tempdir = TemporaryDirectory()
+        self.src = self.dst("src")
+        with open(self.src, "w", encoding="utf-8") as f:
+            f.write("Hello, world!")
+
+    def tearDown(self):
+        self.tempdir.cleanup()
+
+    def dst(self, *args):
+        return os.path.join(self.tempdir.name, *args)
+
+    def assert_inode_not_equal(self, a, b):
+        assert (
+            os.stat(a).st_ino != os.stat(b).st_ino
+        ), "%r and %r do reference the same indoes" % (a, b)
+
+    def assert_inode_equal(self, a, b):
+        assert (
+            os.stat(a).st_ino == os.stat(b).st_ino
+        ), "%r and %r do not reference the same indoes" % (a, b)
+
+    def assert_content_equal(self, a, b):
+        with open(a, "rb") as a_f:
+            with open(b, "rb") as b_f:
+                assert a_f.read() == b_f.read()
+
+    @skip_win32
+    def test_link_successful(self):
+        dst = self.dst("target")
+        path.link_or_copy(self.src, dst)
+        self.assert_inode_equal(self.src, dst)
+
+    @skip_win32
+    def test_link_into_dir(self):
+        dst = self.dst("some_dir")
+        os.mkdir(dst)
+        path.link_or_copy(self.src, dst)
+        expected_dst = self.dst("some_dir", os.path.basename(self.src))
+        self.assert_inode_equal(self.src, expected_dst)
+
+    @skip_win32
+    def test_target_exists(self):
+        dst = self.dst("target")
+        open(dst, "w", encoding="utf-8").close()
+        path.link_or_copy(self.src, dst)
+        self.assert_inode_equal(self.src, dst)
+
+    @skip_win32
+    def test_no_link(self):
+        real_link = os.link
+        try:
+            del os.link
+            dst = self.dst("target")
+            path.link_or_copy(self.src, dst)
+            self.assert_content_equal(self.src, dst)
+            self.assert_inode_not_equal(self.src, dst)
+        finally:
+            os.link = real_link
+
+    @skip_if_not_win32
+    def test_windows(self):
+        dst = self.dst("target")
+        path.link_or_copy(self.src, dst)
+        self.assert_content_equal(self.src, dst)
+
+    def test_link_twice(self):
+        # Linking the same file twice shouldn't leave duplicates around.
+        # See https://github.com/ipython/ipython/issues/6450
+        dst = self.dst("target")
+        path.link_or_copy(self.src, dst)
+        path.link_or_copy(self.src, dst)
+        self.assert_inode_equal(self.src, dst)
+        assert sorted(os.listdir(self.tempdir.name)) == ["src", "target"]
diff --git a/tests/test_paths.py b/tests/test_paths.py
new file mode 100644
index 00000000000..7034f10cc82
--- /dev/null
+++ b/tests/test_paths.py
@@ -0,0 +1,229 @@
+import errno
+import os
+import shutil
+import tempfile
+import warnings
+from unittest.mock import patch
+
+from tempfile import TemporaryDirectory
+from testpath import assert_isdir, assert_isfile, modified_env
+
+from IPython import paths
+from IPython.testing.decorators import skip_win32
+
+TMP_TEST_DIR = os.path.realpath(tempfile.mkdtemp())
+HOME_TEST_DIR = os.path.join(TMP_TEST_DIR, "home_test_dir")
+XDG_TEST_DIR = os.path.join(HOME_TEST_DIR, "xdg_test_dir")
+XDG_CACHE_DIR = os.path.join(HOME_TEST_DIR, "xdg_cache_dir")
+IP_TEST_DIR = os.path.join(HOME_TEST_DIR, ".ipython")
+
+
+def setup_module():
+    """Setup testenvironment for the module:
+
+    - Adds dummy home dir tree
+    """
+    # Do not mask exceptions here.  In particular, catching WindowsError is a
+    # problem because that exception is only defined on Windows...
+    os.makedirs(IP_TEST_DIR)
+    os.makedirs(os.path.join(XDG_TEST_DIR, "ipython"))
+    os.makedirs(os.path.join(XDG_CACHE_DIR, "ipython"))
+
+
+def teardown_module():
+    """Teardown testenvironment for the module:
+
+    - Remove dummy home dir tree
+    """
+    # Note: we remove the parent test dir, which is the root of all test
+    # subdirs we may have created.  Use shutil instead of os.removedirs, so
+    # that non-empty directories are all recursively removed.
+    shutil.rmtree(TMP_TEST_DIR)
+
+
+def patch_get_home_dir(dirpath):
+    return patch.object(paths, "get_home_dir", return_value=dirpath)
+
+
+def test_get_ipython_dir_1():
+    """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
+    env_ipdir = os.path.join("someplace", ".ipython")
+    with (
+        patch.object(paths, "_writable_dir", return_value=True),
+        modified_env({"IPYTHONDIR": env_ipdir}),
+    ):
+        ipdir = paths.get_ipython_dir()
+
+    assert ipdir == env_ipdir
+
+
+def test_get_ipython_dir_2():
+    """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
+    with (
+        patch_get_home_dir("someplace"),
+        patch.object(paths, "get_xdg_dir", return_value=None),
+        patch.object(paths, "_writable_dir", return_value=True),
+        patch("os.name", "posix"),
+        modified_env(
+            {"IPYTHON_DIR": None, "IPYTHONDIR": None, "XDG_CONFIG_HOME": None}
+        ),
+    ):
+        ipdir = paths.get_ipython_dir()
+
+    assert ipdir == os.path.join("someplace", ".ipython")
+
+
+def test_get_ipython_dir_3():
+    """test_get_ipython_dir_3, use XDG if defined and exists, and .ipython doesn't exist."""
+    tmphome = TemporaryDirectory()
+    try:
+        with (
+            patch_get_home_dir(tmphome.name),
+            patch("os.name", "posix"),
+            modified_env(
+                {
+                    "IPYTHON_DIR": None,
+                    "IPYTHONDIR": None,
+                    "XDG_CONFIG_HOME": XDG_TEST_DIR,
+                }
+            ),
+            warnings.catch_warnings(record=True) as w,
+        ):
+            ipdir = paths.get_ipython_dir()
+
+        assert ipdir == os.path.join(tmphome.name, XDG_TEST_DIR, "ipython")
+        assert len(w) == 0
+    finally:
+        tmphome.cleanup()
+
+
+def test_get_ipython_dir_4():
+    """test_get_ipython_dir_4, warn if XDG and home both exist."""
+    with patch_get_home_dir(HOME_TEST_DIR), patch("os.name", "posix"):
+        try:
+            os.mkdir(os.path.join(XDG_TEST_DIR, "ipython"))
+        except OSError as e:
+            if e.errno != errno.EEXIST:
+                raise
+
+        with (
+            modified_env(
+                {
+                    "IPYTHON_DIR": None,
+                    "IPYTHONDIR": None,
+                    "XDG_CONFIG_HOME": XDG_TEST_DIR,
+                }
+            ),
+            warnings.catch_warnings(record=True) as w,
+        ):
+            ipdir = paths.get_ipython_dir()
+
+        assert len(w) == 1
+        assert "Ignoring" in str(w[0])
+
+
+def test_get_ipython_dir_5():
+    """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
+    with patch_get_home_dir(HOME_TEST_DIR), patch("os.name", "posix"):
+        try:
+            os.rmdir(os.path.join(XDG_TEST_DIR, "ipython"))
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+
+        with modified_env(
+            {
+                "IPYTHON_DIR": None,
+                "IPYTHONDIR": None,
+                "XDG_CONFIG_HOME": XDG_TEST_DIR,
+            }
+        ):
+            ipdir = paths.get_ipython_dir()
+
+        assert ipdir == IP_TEST_DIR
+
+
+def test_get_ipython_dir_6():
+    """test_get_ipython_dir_6, use home over XDG if defined and neither exist."""
+    xdg = os.path.join(HOME_TEST_DIR, "somexdg")
+    os.mkdir(xdg)
+    shutil.rmtree(os.path.join(HOME_TEST_DIR, ".ipython"))
+    print(paths._writable_dir)
+    with (
+        patch_get_home_dir(HOME_TEST_DIR),
+        patch.object(paths, "get_xdg_dir", return_value=xdg),
+        patch("os.name", "posix"),
+        modified_env(
+            {
+                "IPYTHON_DIR": None,
+                "IPYTHONDIR": None,
+                "XDG_CONFIG_HOME": None,
+            }
+        ),
+        warnings.catch_warnings(record=True) as w,
+    ):
+        ipdir = paths.get_ipython_dir()
+
+    assert ipdir == os.path.join(HOME_TEST_DIR, ".ipython")
+    assert len(w) == 0
+
+
+def test_get_ipython_dir_7():
+    """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR"""
+    home_dir = os.path.normpath(os.path.expanduser("~"))
+    with (
+        modified_env({"IPYTHONDIR": os.path.join("~", "somewhere")}),
+        patch.object(paths, "_writable_dir", return_value=True),
+    ):
+        ipdir = paths.get_ipython_dir()
+    assert ipdir == os.path.join(home_dir, "somewhere")
+
+
+@skip_win32
+def test_get_ipython_dir_8():
+    """test_get_ipython_dir_8, test / home directory"""
+    if not os.access("/", os.W_OK):
+        # test only when HOME directory actually writable
+        return
+
+    with (
+        patch.object(paths, "_writable_dir", lambda path: bool(path)),
+        patch.object(paths, "get_xdg_dir", return_value=None),
+        modified_env(
+            {
+                "IPYTHON_DIR": None,
+                "IPYTHONDIR": None,
+                "HOME": "/",
+            }
+        ),
+    ):
+        assert paths.get_ipython_dir() == "/.ipython"
+
+
+def test_get_ipython_cache_dir():
+    with modified_env({"HOME": HOME_TEST_DIR}):
+        if os.name == "posix":
+            # test default
+            os.makedirs(os.path.join(HOME_TEST_DIR, ".cache"))
+            with modified_env({"XDG_CACHE_HOME": None}):
+                ipdir = paths.get_ipython_cache_dir()
+            assert os.path.join(HOME_TEST_DIR, ".cache", "ipython") == ipdir
+            assert_isdir(ipdir)
+
+            # test env override
+            with modified_env({"XDG_CACHE_HOME": XDG_CACHE_DIR}):
+                ipdir = paths.get_ipython_cache_dir()
+            assert_isdir(ipdir)
+            assert ipdir == os.path.join(XDG_CACHE_DIR, "ipython")
+        else:
+            assert paths.get_ipython_cache_dir() == paths.get_ipython_dir()
+
+
+def test_get_ipython_package_dir():
+    ipdir = paths.get_ipython_package_dir()
+    assert_isdir(ipdir)
+
+
+def test_get_ipython_module_path():
+    ipapp_path = paths.get_ipython_module_path("IPython.terminal.ipapp")
+    assert_isfile(ipapp_path)
diff --git a/tests/test_prefilter.py b/tests/test_prefilter.py
new file mode 100644
index 00000000000..347e8ad366e
--- /dev/null
+++ b/tests/test_prefilter.py
@@ -0,0 +1,154 @@
+"""Tests for input manipulation machinery."""
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import pytest
+
+from IPython.core.prefilter import AutocallChecker
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+def test_prefilter():
+    """Test user input conversions"""
+
+    # pairs of (raw, expected correct) input
+    pairs = [
+        ("2+2", "2+2"),
+    ]
+
+    for raw, correct in pairs:
+        assert ip.prefilter(raw) == correct
+
+
+def test_prefilter_shadowed():
+    def dummy_magic(line):
+        pass
+
+    prev_automagic_state = ip.automagic
+    ip.automagic = True
+    ip.autocall = 0
+
+    try:
+        # These should not be transformed - they are shadowed by other names
+        for name in ["if", "zip", "get_ipython"]:  # keyword, builtin, global
+            ip.register_magic_function(dummy_magic, magic_name=name)
+            res = ip.prefilter(name + " foo")
+            assert res == name + " foo"
+            del ip.magics_manager.magics["line"][name]
+
+        # These should be transformed
+        for name in ["fi", "piz", "nohtypi_teg"]:
+            ip.register_magic_function(dummy_magic, magic_name=name)
+            res = ip.prefilter(name + " foo")
+            assert res != name + " foo"
+            del ip.magics_manager.magics["line"][name]
+
+    finally:
+        ip.automagic = prev_automagic_state
+
+
+def test_autocall_binops():
+    """See https://github.com/ipython/ipython/issues/81"""
+    ip.run_line_magic("autocall", "2")
+    f = lambda x: x
+    ip.user_ns["f"] = f
+    try:
+        assert ip.prefilter("f 1") == "f(1)"
+        for t in ["f +1", "f -1"]:
+            assert ip.prefilter(t) == t
+
+        # Run tests again with a more permissive exclude_regexp, which will
+        # allow transformation of binary operations ('f -1' -> 'f(-1)').
+        pm = ip.prefilter_manager
+        ac = AutocallChecker(shell=pm.shell, prefilter_manager=pm, config=pm.config)
+        try:
+            ac.priority = 1
+            ac.exclude_regexp = r"^[,&^\|\*/]|^is |^not |^in |^and |^or "
+            pm.sort_checkers()
+
+            assert ip.prefilter("f -1") == "f(-1)"
+            assert ip.prefilter("f +1") == "f(+1)"
+        finally:
+            pm.unregister_checker(ac)
+    finally:
+        ip.run_line_magic("autocall", "0")
+        del ip.user_ns["f"]
+
+
+def test_issue_114():
+    """Check that multiline string literals don't expand as magic
+    see http://github.com/ipython/ipython/issues/114"""
+
+    template = '"""\n%s\n"""'
+    # Store the current value of multi_line_specials and turn it off before
+    # running test, since it could be true (case in which the test doesn't make
+    # sense, as multiline string literals *will* expand as magic in that case).
+    msp = ip.prefilter_manager.multi_line_specials
+    ip.prefilter_manager.multi_line_specials = False
+    try:
+        for mgk in ip.magics_manager.lsmagic()["line"]:
+            raw = template % mgk
+            assert ip.prefilter(raw) == raw
+    finally:
+        ip.prefilter_manager.multi_line_specials = msp
+
+
+def test_prefilter_attribute_errors():
+    """Capture exceptions thrown by user objects on attribute access.
+
+    See http://github.com/ipython/ipython/issues/988."""
+
+    class X(object):
+        def __getattr__(self, k):
+            raise ValueError("broken object")
+
+        def __call__(self, x):
+            return x
+
+    # Create a callable broken object
+    ip.user_ns["x"] = X()
+    ip.run_line_magic("autocall", "2")
+    try:
+        # Even if x throws an attribute error when looking at its rewrite
+        # attribute, we should not crash.  So the test here is simply making
+        # the prefilter call and not having an exception.
+        ip.prefilter("x 1")
+    finally:
+        del ip.user_ns["x"]
+        ip.run_line_magic("autocall", "0")
+
+
+def test_autocall_type_ann():
+    ip.run_cell("import collections.abc")
+    ip.run_line_magic("autocall", "1")
+    try:
+        assert (
+            ip.prefilter("collections.abc.Callable[[int], None]")
+            == "collections.abc.Callable[[int], None]"
+        )
+    finally:
+        ip.run_line_magic("autocall", "0")
+
+
+def test_autocall_should_support_unicode():
+    ip.run_line_magic("autocall", "2")
+    ip.user_ns["Ï€"] = lambda x: x
+    try:
+        assert ip.prefilter("Ï€ 3") == "Ï€(3)"
+    finally:
+        ip.run_line_magic("autocall", "0")
+        del ip.user_ns["Ï€"]
+
+
+def test_autocall_regression_gh_14513():
+    ip.run_line_magic("autocall", "2")
+    ip.user_ns["foo"] = dict()
+    try:
+        assert ip.prefilter("foo") == "foo"
+    finally:
+        ip.run_line_magic("autocall", "0")
+        del ip.user_ns["foo"]
diff --git a/tests/test_pretty.py b/tests/test_pretty.py
new file mode 100644
index 00000000000..f98c3c8dfb4
--- /dev/null
+++ b/tests/test_pretty.py
@@ -0,0 +1,596 @@
+# coding: utf-8
+"""Tests for IPython.lib.pretty."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+from collections import Counter, defaultdict, deque, OrderedDict, UserList
+import os
+import pytest
+import types
+import string
+import sys
+import unittest
+
+import pytest
+
+from IPython.lib import pretty
+
+from io import StringIO
+
+
+class MyList(object):
+    def __init__(self, content):
+        self.content = content
+
+    def _repr_pretty_(self, p, cycle):
+        if cycle:
+            p.text("MyList(...)")
+        else:
+            with p.group(3, "MyList(", ")"):
+                for i, child in enumerate(self.content):
+                    if i:
+                        p.text(",")
+                        p.breakable()
+                    else:
+                        p.breakable("")
+                    p.pretty(child)
+
+
+class MyDict(dict):
+    def _repr_pretty_(self, p, cycle):
+        p.text("MyDict(...)")
+
+
+class MyObj(object):
+    def somemethod(self):
+        pass
+
+
+class Dummy1(object):
+    def _repr_pretty_(self, p, cycle):
+        p.text("Dummy1(...)")
+
+
+class Dummy2(Dummy1):
+    _repr_pretty_ = None
+
+
+class NoModule(object):
+    pass
+
+
+NoModule.__module__ = None
+
+
+class Breaking(object):
+    def _repr_pretty_(self, p, cycle):
+        with p.group(4, "TG: ", ":"):
+            p.text("Breaking(")
+            p.break_()
+            p.text(")")
+
+
+class BreakingRepr(object):
+    def __repr__(self):
+        return "Breaking(\n)"
+
+
+class BadRepr(object):
+    def __repr__(self):
+        return 1 / 0
+
+
+def test_indentation():
+    """Test correct indentation in groups"""
+    count = 40
+    gotoutput = pretty.pretty(MyList(range(count)))
+    expectedoutput = "MyList(\n" + ",\n".join("   %d" % i for i in range(count)) + ")"
+
+    assert gotoutput == expectedoutput
+
+
+def test_dispatch():
+    """
+    Test correct dispatching: The _repr_pretty_ method for MyDict
+    must be found before the registered printer for dict.
+    """
+    gotoutput = pretty.pretty(MyDict())
+    expectedoutput = "MyDict(...)"
+
+    assert gotoutput == expectedoutput
+
+
+def test_callability_checking():
+    """
+    Test that the _repr_pretty_ method is tested for callability and skipped if
+    not.
+    """
+    gotoutput = pretty.pretty(Dummy2())
+    expectedoutput = "Dummy1(...)"
+
+    assert gotoutput == expectedoutput
+
+
+@pytest.mark.parametrize(
+    "obj,expected_output",
+    zip(
+        [
+            set(),
+            frozenset(),
+            set([1]),
+            frozenset([1]),
+            set([1, 2]),
+            frozenset([1, 2]),
+            set([-1, -2, -3]),
+        ],
+        [
+            "set()",
+            "frozenset()",
+            "{1}",
+            "frozenset({1})",
+            "{1, 2}",
+            "frozenset({1, 2})",
+            "{-3, -2, -1}",
+        ],
+    ),
+)
+def test_sets(obj, expected_output):
+    """
+    Test that set and frozenset use Python 3 formatting.
+    """
+    got_output = pretty.pretty(obj)
+    assert got_output == expected_output
+
+
+def test_pprint_heap_allocated_type():
+    """
+    Test that pprint works for heap allocated types.
+    """
+    module_name = "xxlimited_35"
+    expected_output = "xxlimited_35.Null"
+    xxlimited = pytest.importorskip(module_name)
+    output = pretty.pretty(xxlimited.Null)
+    assert output == expected_output
+
+
+def test_pprint_nomod():
+    """
+    Test that pprint works for classes with no __module__.
+    """
+    output = pretty.pretty(NoModule)
+    assert output == "NoModule"
+
+
+def test_pprint_break():
+    """
+    Test that p.break_ produces expected output
+    """
+    output = pretty.pretty(Breaking())
+    expected = "TG: Breaking(\n    ):"
+    assert output == expected
+
+
+def test_pprint_break_repr():
+    """
+    Test that p.break_ is used in repr
+    """
+    output = pretty.pretty([[BreakingRepr()]])
+    expected = "[[Breaking(\n  )]]"
+    assert output == expected
+
+    output = pretty.pretty([[BreakingRepr()] * 2])
+    expected = "[[Breaking(\n  ),\n  Breaking(\n  )]]"
+    assert output == expected
+
+
+def test_bad_repr():
+    """Don't catch bad repr errors"""
+    with pytest.raises(ZeroDivisionError):
+        pretty.pretty(BadRepr())
+
+
+class BadException(Exception):
+    def __str__(self):
+        return -1
+
+
+class ReallyBadRepr(object):
+    __module__ = 1
+
+    @property
+    def __class__(self):
+        raise ValueError("I am horrible")
+
+    def __repr__(self):
+        raise BadException()
+
+
+def test_really_bad_repr():
+    with pytest.raises(BadException):
+        pretty.pretty(ReallyBadRepr())
+
+
+class SA(object):
+    pass
+
+
+class SB(SA):
+    pass
+
+
+class TestsPretty(unittest.TestCase):
+    def test_super_repr(self):
+        # "<super: module_name.SA, None>"
+        output = pretty.pretty(super(SA))
+        self.assertRegex(output, r"<super: \S+.SA, None>")
+
+        # "<super: module_name.SA, <module_name.SB at 0x...>>"
+        sb = SB()
+        output = pretty.pretty(super(SA, sb))
+        self.assertRegex(output, r"<super: \S+.SA,\s+<\S+.SB at 0x\S+>>")
+
+    def test_long_list(self):
+        lis = list(range(10000))
+        p = pretty.pretty(lis)
+        last2 = p.rsplit("\n", 2)[-2:]
+        self.assertEqual(last2, [" 999,", " ...]"])
+
+    def test_long_set(self):
+        s = set(range(10000))
+        p = pretty.pretty(s)
+        last2 = p.rsplit("\n", 2)[-2:]
+        self.assertEqual(last2, [" 999,", " ...}"])
+
+    def test_long_tuple(self):
+        tup = tuple(range(10000))
+        p = pretty.pretty(tup)
+        last2 = p.rsplit("\n", 2)[-2:]
+        self.assertEqual(last2, [" 999,", " ...)"])
+
+    def test_long_dict(self):
+        d = {n: n for n in range(10000)}
+        p = pretty.pretty(d)
+        last2 = p.rsplit("\n", 2)[-2:]
+        self.assertEqual(last2, [" 999: 999,", " ...}"])
+
+    def test_unbound_method(self):
+        output = pretty.pretty(MyObj.somemethod)
+        self.assertIn("MyObj.somemethod", output)
+
+
+class MetaClass(type):
+    def __new__(cls, name):
+        return type.__new__(cls, name, (object,), {"name": name})
+
+    def __repr__(self):
+        return "[CUSTOM REPR FOR CLASS %s]" % self.name
+
+
+ClassWithMeta = MetaClass("ClassWithMeta")
+
+
+def test_metaclass_repr():
+    output = pretty.pretty(ClassWithMeta)
+    assert output == "[CUSTOM REPR FOR CLASS ClassWithMeta]"
+
+
+def test_unicode_repr():
+    u = "üniçodé"
+    ustr = u
+
+    class C(object):
+        def __repr__(self):
+            return ustr
+
+    c = C()
+    p = pretty.pretty(c)
+    assert p == u
+    p = pretty.pretty([c])
+    assert p == "[%s]" % u
+
+
+def test_basic_class():
+    def type_pprint_wrapper(obj, p, cycle):
+        if obj is MyObj:
+            type_pprint_wrapper.called = True
+        return pretty._type_pprint(obj, p, cycle)
+
+    type_pprint_wrapper.called = False
+
+    stream = StringIO()
+    printer = pretty.RepresentationPrinter(stream)
+    printer.type_pprinters[type] = type_pprint_wrapper
+    printer.pretty(MyObj)
+    printer.flush()
+    output = stream.getvalue()
+
+    assert output == "%s.MyObj" % __name__
+    assert type_pprint_wrapper.called is True
+
+
+def test_collections_userlist():
+    # Create userlist with cycle
+    a = UserList()
+    a.append(a)
+
+    cases = [
+        (UserList(), "UserList([])"),
+        (
+            UserList(i for i in range(1000, 1020)),
+            "UserList([1000,\n"
+            "          1001,\n"
+            "          1002,\n"
+            "          1003,\n"
+            "          1004,\n"
+            "          1005,\n"
+            "          1006,\n"
+            "          1007,\n"
+            "          1008,\n"
+            "          1009,\n"
+            "          1010,\n"
+            "          1011,\n"
+            "          1012,\n"
+            "          1013,\n"
+            "          1014,\n"
+            "          1015,\n"
+            "          1016,\n"
+            "          1017,\n"
+            "          1018,\n"
+            "          1019])",
+        ),
+        (a, "UserList([UserList(...)])"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_defaultdict():
+    # Create defaultdicts with cycles
+    a = defaultdict()
+    a.default_factory = a
+    b = defaultdict(list)
+    b["key"] = b
+
+    # Dictionary order cannot be relied on, test against single keys.
+    cases = [
+        (defaultdict(list), "defaultdict(list, {})"),
+        (
+            defaultdict(list, {"key": "-" * 50}),
+            "defaultdict(list,\n"
+            "            {'key': '--------------------------------------------------'})",
+        ),
+        (a, "defaultdict(defaultdict(...), {})"),
+        (b, "defaultdict(list, {'key': defaultdict(...)})"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_ordereddict():
+    # Create OrderedDict with cycle
+    a = OrderedDict()
+    a["key"] = a
+
+    cases = [
+        (OrderedDict(), "OrderedDict()"),
+        (
+            OrderedDict((i, i) for i in range(1000, 1010)),
+            "OrderedDict([(1000, 1000),\n"
+            "             (1001, 1001),\n"
+            "             (1002, 1002),\n"
+            "             (1003, 1003),\n"
+            "             (1004, 1004),\n"
+            "             (1005, 1005),\n"
+            "             (1006, 1006),\n"
+            "             (1007, 1007),\n"
+            "             (1008, 1008),\n"
+            "             (1009, 1009)])",
+        ),
+        (a, "OrderedDict([('key', OrderedDict(...))])"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_deque():
+    # Create deque with cycle
+    a = deque()
+    a.append(a)
+
+    cases = [
+        (deque(), "deque([])"),
+        (
+            deque(i for i in range(1000, 1020)),
+            "deque([1000,\n"
+            "       1001,\n"
+            "       1002,\n"
+            "       1003,\n"
+            "       1004,\n"
+            "       1005,\n"
+            "       1006,\n"
+            "       1007,\n"
+            "       1008,\n"
+            "       1009,\n"
+            "       1010,\n"
+            "       1011,\n"
+            "       1012,\n"
+            "       1013,\n"
+            "       1014,\n"
+            "       1015,\n"
+            "       1016,\n"
+            "       1017,\n"
+            "       1018,\n"
+            "       1019])",
+        ),
+        (a, "deque([deque(...)])"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_collections_counter():
+    class MyCounter(Counter):
+        pass
+
+    cases = [
+        (Counter(), "Counter()"),
+        (Counter(a=1), "Counter({'a': 1})"),
+        (MyCounter(a=1), "MyCounter({'a': 1})"),
+        (Counter(a=1, c=22), "Counter({'c': 22, 'a': 1})"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_mappingproxy():
+    MP = types.MappingProxyType
+    underlying_dict = {}
+    mp_recursive = MP(underlying_dict)
+    underlying_dict[2] = mp_recursive
+    underlying_dict[3] = underlying_dict
+
+    cases = [
+        (MP({}), "mappingproxy({})"),
+        (MP({None: MP({})}), "mappingproxy({None: mappingproxy({})})"),
+        (
+            MP({k: k.upper() for k in string.ascii_lowercase}),
+            "mappingproxy({'a': 'A',\n"
+            "              'b': 'B',\n"
+            "              'c': 'C',\n"
+            "              'd': 'D',\n"
+            "              'e': 'E',\n"
+            "              'f': 'F',\n"
+            "              'g': 'G',\n"
+            "              'h': 'H',\n"
+            "              'i': 'I',\n"
+            "              'j': 'J',\n"
+            "              'k': 'K',\n"
+            "              'l': 'L',\n"
+            "              'm': 'M',\n"
+            "              'n': 'N',\n"
+            "              'o': 'O',\n"
+            "              'p': 'P',\n"
+            "              'q': 'Q',\n"
+            "              'r': 'R',\n"
+            "              's': 'S',\n"
+            "              't': 'T',\n"
+            "              'u': 'U',\n"
+            "              'v': 'V',\n"
+            "              'w': 'W',\n"
+            "              'x': 'X',\n"
+            "              'y': 'Y',\n"
+            "              'z': 'Z'})",
+        ),
+        (mp_recursive, "mappingproxy({2: {...}, 3: {2: {...}, 3: {...}}})"),
+        (underlying_dict, "{2: mappingproxy({2: {...}, 3: {...}}), 3: {...}}"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+# TODO : pytest.mark.parametrise once nose is gone.
+def test_simplenamespace():
+    SN = types.SimpleNamespace
+
+    sn_recursive = SN()
+    sn_recursive.first = sn_recursive
+    sn_recursive.second = sn_recursive
+    cases = [
+        (SN(), "namespace()"),
+        (SN(x=SN()), "namespace(x=namespace())"),
+        (
+            SN(a_long_name=[SN(s=string.ascii_lowercase)] * 3, a_short_name=None),
+            "namespace(a_long_name=[namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
+            "                       namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
+            "                       namespace(s='abcdefghijklmnopqrstuvwxyz')],\n"
+            "          a_short_name=None)",
+        ),
+        (sn_recursive, "namespace(first=namespace(...), second=namespace(...))"),
+    ]
+    for obj, expected in cases:
+        assert pretty.pretty(obj) == expected
+
+
+@pytest.mark.skipif(sys.version_info[1] == 12, reason="issue on old-deps + python 3.12")
+def test_pretty_environ():
+    dict_repr = pretty.pretty(dict(os.environ))
+    # reindent to align with 'environ' prefix
+    dict_indented = dict_repr.replace("\n", "\n" + (" " * len("environ")))
+    env_repr = pretty.pretty(os.environ)
+    assert env_repr == "environ" + dict_indented
+
+
+def test_function_pretty():
+    "Test pretty print of function"
+    # posixpath is a pure python module, its interface is consistent
+    # across Python distributions
+
+    import posixpath
+
+    if sys.version_info > (3, 15):
+        assert pretty.pretty(posixpath.join) == "<function posixpath.join(a, /, *p)>"
+    else:
+        assert pretty.pretty(posixpath.join) == "<function posixpath.join(a, *p)>"
+
+    # custom function
+    def meaning_of_life(question=None):
+        if question:
+            return 42
+        return "Don't panic"
+
+    assert "meaning_of_life(question=None)" in pretty.pretty(meaning_of_life)
+
+
+def test_annotated_function_pretty():
+    "Test pretty print of a function with PEP-649 annotations"
+    # Confirm that the name is not in scope
+    try:
+        b
+    except NameError:
+        pass
+    else:
+        assert False, "Unexpected 'b' found in scope"
+    try:
+        def f(a: b): pass
+    except NameError as e:
+        if e.name == 'b':
+            # PEP-649 not available
+            return
+        raise
+    # Check whether __future__.annotations is in effect
+    # It probably shouldn't be, but to be sure:
+    import __future__
+    if f.__code__.co_flags & __future__.annotations.compiler_flag:
+        assert "f(a: 'b')" in pretty.pretty(f)
+    else:
+        assert "f(a: b)" in pretty.pretty(f)
+
+
+class OrderedCounter(Counter, OrderedDict):
+    "Counter that remembers the order elements are first encountered"
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, OrderedDict(self))
+
+    def __reduce__(self):
+        return self.__class__, (OrderedDict(self),)
+
+
+class MySet(set):  # Override repr of a basic type
+    def __repr__(self):
+        return "mine"
+
+
+def test_custom_repr():
+    """A custom repr should override a pretty printer for a parent type"""
+    oc = OrderedCounter("abracadabra")
+    assert "OrderedCounter(OrderedDict" in pretty.pretty(oc)
+
+    assert pretty.pretty(MySet()) == "mine"
diff --git a/tests/test_process.py b/tests/test_process.py
new file mode 100644
index 00000000000..5dfeb737527
--- /dev/null
+++ b/tests/test_process.py
@@ -0,0 +1,195 @@
+"""
+Tests for platutils.py
+"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2008-2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import sys
+import signal
+import os
+import time
+from _thread import interrupt_main  # Py 3
+import threading
+
+import pytest
+
+from IPython.utils.process import (
+    find_cmd,
+    FindCmdError,
+    arg_split,
+    system,
+    getoutput,
+    getoutputerror,
+    get_output_error_code,
+)
+from IPython.utils.capture import capture_output
+from IPython.testing import decorators as dec
+from IPython.testing import tools as tt
+
+python = os.path.basename(sys.executable)
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+@dec.skip_win32
+def test_find_cmd_ls():
+    """Make sure we can find the full path to ls."""
+    path = find_cmd("ls")
+    assert path.endswith("ls")
+
+
+@dec.skip_if_not_win32
+def test_find_cmd_pythonw():
+    """Try to find pythonw on Windows."""
+    path = find_cmd("pythonw")
+    assert path.lower().endswith("pythonw.exe"), path
+
+
+def test_find_cmd_fail():
+    """Make sure that FindCmdError is raised if we can't find the cmd."""
+    pytest.raises(FindCmdError, find_cmd, "asdfasdf")
+
+
+@dec.skip_win32
+@pytest.mark.parametrize(
+    "argstr, argv",
+    [
+        ("hi", ["hi"]),
+        ("hello there", ["hello", "there"]),
+        # \u01ce == \N{LATIN SMALL LETTER A WITH CARON}
+        # Do not use \N because the tests crash with syntax error in
+        # some cases, for example windows python2.6.
+        ("h\u01cello", ["h\u01cello"]),
+        ('something "with quotes"', ["something", '"with quotes"']),
+    ],
+)
+def test_arg_split(argstr, argv):
+    """Ensure that argument lines are correctly split like in a shell."""
+    assert arg_split(argstr) == argv
+
+
+@dec.skip_if_not_win32
+@pytest.mark.parametrize(
+    "argstr,argv",
+    [
+        ("hi", ["hi"]),
+        ("hello there", ["hello", "there"]),
+        ("h\u01cello", ["h\u01cello"]),
+        ('something "with quotes"', ["something", "with quotes"]),
+    ],
+)
+def test_arg_split_win32(argstr, argv):
+    """Ensure that argument lines are correctly split like in a shell."""
+    assert arg_split(argstr) == argv
+
+
+class SubProcessTestCase(tt.TempFileMixin):
+    def setUp(self):
+        """Make a valid python temp file."""
+        lines = [
+            "import sys",
+            "print('on stdout', end='', file=sys.stdout)",
+            "print('on stderr', end='', file=sys.stderr)",
+            "sys.stdout.flush()",
+            "sys.stderr.flush()",
+        ]
+        self.mktmp("\n".join(lines))
+
+    def test_system(self):
+        status = system(f'{python} "{self.fname}"')
+        self.assertEqual(status, 0)
+
+    def test_system_quotes(self):
+        status = system('%s -c "import sys"' % python)
+        self.assertEqual(status, 0)
+
+    def assert_interrupts(self, command):
+        """
+        Interrupt a subprocess after a second.
+        """
+        if threading.main_thread() != threading.current_thread():
+            raise pytest.skip("Can't run this test if not in main thread.")
+
+        # Some tests can overwrite SIGINT handler (by using pdb for example),
+        # which then breaks this test, so just make sure it's operating
+        # normally.
+        signal.signal(signal.SIGINT, signal.default_int_handler)
+
+        def interrupt():
+            # Wait for subprocess to start:
+            time.sleep(0.5)
+            interrupt_main()
+
+        threading.Thread(target=interrupt).start()
+        start = time.time()
+        try:
+            result = command()
+        except KeyboardInterrupt:
+            # Success!
+            pass
+        end = time.time()
+        self.assertTrue(
+            end - start < 2, "Process didn't die quickly: %s" % (end - start)
+        )
+        return result
+
+    def test_system_interrupt(self):
+        """
+        When interrupted in the way ipykernel interrupts IPython, the
+        subprocess is interrupted.
+        """
+
+        def command():
+            return system('%s -c "import time; time.sleep(5)"' % python)
+
+        status = self.assert_interrupts(command)
+        self.assertNotEqual(
+            status, 0, f"The process wasn't interrupted. Status: {status}"
+        )
+
+    def test_getoutput(self):
+        out = getoutput(f'{python} "{self.fname}"')
+        # we can't rely on the order the line buffered streams are flushed
+        try:
+            self.assertEqual(out, "on stderron stdout")
+        except AssertionError:
+            self.assertEqual(out, "on stdouton stderr")
+
+    def test_getoutput_quoted(self):
+        out = getoutput('%s -c "print (1)"' % python)
+        self.assertEqual(out.strip(), "1")
+
+    # Invalid quoting on windows
+    @dec.skip_win32
+    def test_getoutput_quoted2(self):
+        out = getoutput("%s -c 'print (1)'" % python)
+        self.assertEqual(out.strip(), "1")
+        out = getoutput("%s -c 'print (\"1\")'" % python)
+        self.assertEqual(out.strip(), "1")
+
+    def test_getoutput_error(self):
+        out, err = getoutputerror(f'{python} "{self.fname}"')
+        self.assertEqual(out, "on stdout")
+        self.assertEqual(err, "on stderr")
+
+    def test_get_output_error_code(self):
+        quiet_exit = '%s -c "import sys; sys.exit(1)"' % python
+        out, err, code = get_output_error_code(quiet_exit)
+        self.assertEqual(out, "")
+        self.assertEqual(err, "")
+        self.assertEqual(code, 1)
+        out, err, code = get_output_error_code(f'{python} "{self.fname}"')
+        self.assertEqual(out, "on stdout")
+        self.assertEqual(err, "on stderr")
+        self.assertEqual(code, 0)
diff --git a/tests/test_profile.py b/tests/test_profile.py
new file mode 100644
index 00000000000..be438817d1b
--- /dev/null
+++ b/tests/test_profile.py
@@ -0,0 +1,162 @@
+# coding: utf-8
+"""Tests for profile-related functions.
+
+Currently only the startup-dir functionality is tested, but more tests should
+be added for:
+
+    * ipython profile create
+    * ipython profile list
+    * ipython profile create --parallel
+    * security dir permissions
+
+Authors
+-------
+
+* MinRK
+
+"""
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from unittest import TestCase
+
+import pytest
+
+from IPython.core.profileapp import list_bundled_profiles, list_profiles_in
+from IPython.core.profiledir import ProfileDir
+from IPython.testing import decorators as dec
+from IPython.testing import tools as tt
+from IPython.utils.process import getoutput
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+TMP_TEST_DIR = Path(tempfile.mkdtemp())
+HOME_TEST_DIR = TMP_TEST_DIR / "home_test_dir"
+IP_TEST_DIR = HOME_TEST_DIR / ".ipython"
+
+#
+# Setup/teardown functions/decorators
+#
+
+
+def setup_module():
+    """Setup test environment for the module:
+
+    - Adds dummy home dir tree
+    """
+    # Do not mask exceptions here.  In particular, catching WindowsError is a
+    # problem because that exception is only defined on Windows...
+    (Path.cwd() / IP_TEST_DIR).mkdir(parents=True)
+
+
+def teardown_module():
+    """Teardown test environment for the module:
+
+    - Remove dummy home dir tree
+    """
+    # Note: we remove the parent test dir, which is the root of all test
+    # subdirs we may have created.  Use shutil instead of os.removedirs, so
+    # that non-empty directories are all recursively removed.
+    shutil.rmtree(TMP_TEST_DIR)
+
+
+# -----------------------------------------------------------------------------
+# Test functions
+# -----------------------------------------------------------------------------
+class ProfileStartupTest(TestCase):
+    def setUp(self):
+        # create profile dir
+        self.pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, "test")
+        self.options = ["--ipython-dir", IP_TEST_DIR, "--profile", "test"]
+        self.fname = TMP_TEST_DIR / "test.py"
+
+    def tearDown(self):
+        # We must remove this profile right away so its presence doesn't
+        # confuse other tests.
+        shutil.rmtree(self.pd.location)
+
+    def init(self, startup_file, startup, test):
+        # write startup python file
+        with open(Path(self.pd.startup_dir) / startup_file, "w", encoding="utf-8") as f:
+            f.write(startup)
+        # write simple test file, to check that the startup file was run
+        with open(self.fname, "w", encoding="utf-8") as f:
+            f.write(test)
+
+    def validate(self, output):
+        tt.ipexec_validate(self.fname, output, "", options=self.options)
+
+    def test_startup_py(self):
+        self.init("00-start.py", "zzz=123\n", "print(zzz)\n")
+        self.validate("123")
+
+    def test_startup_ipy(self):
+        self.init("00-start.ipy", "%xmode plain\n", "")
+        self.validate("Exception reporting mode: Plain")
+
+
+@pytest.mark.skipif(
+    sys.implementation.name == "pypy"
+    and ((7, 3, 13) < sys.implementation.version < (7, 3, 16)),
+    reason="Unicode issues with scandir on PyPy, see https://github.com/pypy/pypy/issues/4860",
+)
+def test_list_profiles_in():
+    # No need to remove these directories and files, as they will get nuked in
+    # the module-level teardown.
+    td = Path(tempfile.mkdtemp(dir=TMP_TEST_DIR))
+    for name in ("profile_foo", "profile_hello", "not_a_profile"):
+        Path(td / name).mkdir(parents=True)
+    if dec.unicode_paths:
+        Path(td / "profile_ünicode").mkdir(parents=True)
+
+    with open(td / "profile_file", "w", encoding="utf-8") as f:
+        f.write("I am not a profile directory")
+    profiles = list_profiles_in(td)
+
+    # unicode normalization can turn u'ünicode' into u'u\0308nicode',
+    # so only check for *nicode, and that creating a ProfileDir from the
+    # name remains valid
+    found_unicode = False
+    for p in list(profiles):
+        if p.endswith("nicode"):
+            pd = ProfileDir.find_profile_dir_by_name(td, p)
+            profiles.remove(p)
+            found_unicode = True
+            break
+    if dec.unicode_paths:
+        assert found_unicode is True
+    assert set(profiles) == {"foo", "hello"}
+
+
+def test_list_bundled_profiles():
+    # This variable will need to be updated when a new profile gets bundled
+    bundled = sorted(list_bundled_profiles())
+    assert bundled == []
+
+
+def test_profile_create_ipython_dir():
+    """ipython profile create respects --ipython-dir"""
+    with TemporaryDirectory() as td:
+        getoutput(
+            [
+                sys.executable,
+                "-m",
+                "IPython",
+                "profile",
+                "create",
+                "foo",
+                "--ipython-dir=%s" % td,
+            ]
+        )
+        profile_dir = Path(td) / "profile_foo"
+        assert Path(profile_dir).exists()
+        ipython_config = profile_dir / "ipython_config.py"
+        assert Path(ipython_config).exists()
diff --git a/tests/test_pt_inputhooks.py b/tests/test_pt_inputhooks.py
new file mode 100644
index 00000000000..3f788c738cf
--- /dev/null
+++ b/tests/test_pt_inputhooks.py
@@ -0,0 +1,50 @@
+import os
+import importlib
+
+import pytest
+
+from IPython.terminal.pt_inputhooks import set_qt_api, get_inputhook_name_and_func
+
+
+guis_avail = []
+
+
+def _get_qt_vers():
+    """If any version of Qt is available, this will populate `guis_avail` with 'qt' and 'qtx'. Due
+    to the import mechanism, we can't import multiple versions of Qt in one session."""
+    for gui in ["qt", "qt6", "qt5"]:
+        print(f"Trying {gui}")
+        try:
+            set_qt_api(gui)
+            importlib.import_module("IPython.terminal.pt_inputhooks.qt")
+            guis_avail.append(gui)
+            if "QT_API" in os.environ.keys():
+                del os.environ["QT_API"]
+        except ImportError:
+            pass  # that version of Qt isn't available.
+        except RuntimeError:
+            pass  # the version of IPython doesn't know what to do with this Qt version.
+
+
+_get_qt_vers()
+
+
+@pytest.mark.skipif(
+    len(guis_avail) == 0, reason="No viable version of PyQt or PySide installed."
+)
+def test_inputhook_qt():
+    # Choose the "best" Qt version.
+    gui_ret, _ = get_inputhook_name_and_func("qt")
+
+    assert gui_ret != "qt"  # you get back the specific version that was loaded.
+    assert gui_ret in guis_avail
+
+    if len(guis_avail) > 2:
+        # ...and now we're stuck with this version of Qt for good; can't switch.
+        for not_gui in ["qt6", "qt5"]:
+            if not_gui != gui_ret:
+                break
+        # Try to import the other gui; it won't work.
+        gui_ret2, _ = get_inputhook_name_and_func(not_gui)
+        assert gui_ret2 == gui_ret
+        assert gui_ret2 != not_gui
diff --git a/tests/test_pycolorize.py b/tests/test_pycolorize.py
new file mode 100644
index 00000000000..dc36ae92fe0
--- /dev/null
+++ b/tests/test_pycolorize.py
@@ -0,0 +1,71 @@
+# coding: utf-8
+"""Test suite for our color utilities.
+
+Authors
+-------
+
+* Min RK
+"""
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING.txt, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+# our own
+import sys
+from IPython.utils.PyColorize import Parser
+import io
+import pytest
+
+
+@pytest.fixture(scope="module", params=("linux", "nocolor", "lightbg", "neutral"))
+def theme_name(request):
+    yield request.param
+
+
+# -----------------------------------------------------------------------------
+# Test functions
+# -----------------------------------------------------------------------------
+
+sample = """
+def function(arg, *args, kwarg=True, **kwargs):
+    '''
+    this is docs
+    '''
+    pass is True
+    False == None
+
+    with io.open(rf'unicode {1}', encoding='utf-8'):
+        raise ValueError("escape \r sequence")
+
+    print("wěird ünicoðe")
+
+class Bar(Super):
+
+    def __init__(self):
+        super(Bar, self).__init__(1**2, 3^4, 5 or 6)
+"""
+
+
+def test_parse_sample(theme_name):
+    """and test writing to a buffer"""
+    buf = io.StringIO()
+    p = Parser(theme_name=theme_name)
+    p.format(sample, buf)
+    buf.seek(0)
+    f1 = buf.read()
+
+    assert "ERROR" not in f1
+
+
+def test_parse_error(theme_name):
+    p = Parser(theme_name=theme_name)
+    f1 = p.format(r"\ " if sys.version_info >= (3, 12) else ")", "str")
+    if theme_name != "nocolor":
+        assert "ERROR" in f1
diff --git a/tests/test_pylabtools.py b/tests/test_pylabtools.py
new file mode 100644
index 00000000000..073fdbba473
--- /dev/null
+++ b/tests/test_pylabtools.py
@@ -0,0 +1,394 @@
+"""Tests for pylab tools module."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+from binascii import a2b_base64
+from io import BytesIO
+
+import pytest
+
+matplotlib = pytest.importorskip("matplotlib")
+matplotlib.use("Agg")
+from matplotlib.figure import Figure
+
+from matplotlib import pyplot as plt
+from matplotlib_inline import backend_inline
+import numpy as np
+
+from IPython.core.getipython import get_ipython
+from IPython.core.interactiveshell import InteractiveShell
+from IPython.core.display import _PNG, _JPEG
+from IPython.core import pylabtools as pt
+
+from IPython.testing import decorators as dec
+from .test_history import hmmax3
+
+
+def test_figure_to_svg():
+    # simple empty-figure test
+    fig = plt.figure()
+    assert pt.print_figure(fig, "svg") is None
+
+    plt.close("all")
+
+    # simple check for at least svg-looking output
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1)
+    ax.plot([1, 2, 3])
+    plt.draw()
+    svg = pt.print_figure(fig, "svg")[:100].lower()
+    assert "doctype svg" in svg
+
+
+def _check_pil_jpeg_bytes():
+    """Skip if PIL can't write JPEGs to BytesIO objects"""
+    # PIL's JPEG plugin can't write to BytesIO objects
+    # Pillow fixes this
+    from PIL import Image
+
+    buf = BytesIO()
+    img = Image.new("RGB", (4, 4))
+    try:
+        img.save(buf, "jpeg")
+    except Exception as e:
+        ename = e.__class__.__name__
+        raise pytest.skip("PIL can't write JPEG to BytesIO: %s: %s" % (ename, e)) from e
+
+
+@dec.skip_without("PIL.Image")
+def test_figure_to_jpeg():
+    _check_pil_jpeg_bytes()
+    # simple check for at least jpeg-looking output
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1)
+    ax.plot([1, 2, 3])
+    plt.draw()
+    jpeg = pt.print_figure(fig, "jpeg", pil_kwargs={"optimize": 50})[:100].lower()
+    assert jpeg.startswith(_JPEG)
+
+
+def test_retina_figure():
+    # simple empty-figure test
+    fig = plt.figure()
+    assert pt.retina_figure(fig) == None
+    plt.close("all")
+
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1)
+    ax.plot([1, 2, 3])
+    plt.draw()
+    png, md = pt.retina_figure(fig)
+    assert png.startswith(_PNG)
+    assert "width" in md
+    assert "height" in md
+
+
+_fmt_mime_map = {
+    "png": "image/png",
+    "jpeg": "image/jpeg",
+    "pdf": "application/pdf",
+    "retina": "image/png",
+    "svg": "image/svg+xml",
+}
+
+
+def test_select_figure_formats_str():
+    ip = get_ipython()
+    for fmt, active_mime in _fmt_mime_map.items():
+        pt.select_figure_formats(ip, fmt)
+        for mime, f in ip.display_formatter.formatters.items():
+            if mime == active_mime:
+                assert Figure in f
+            else:
+                assert Figure not in f
+
+
+def test_select_figure_formats_kwargs():
+    ip = get_ipython()
+    kwargs = dict(bbox_inches="tight")
+    pt.select_figure_formats(ip, "png", **kwargs)
+    formatter = ip.display_formatter.formatters["image/png"]
+    f = formatter.lookup_by_type(Figure)
+    cell = f.keywords
+    expected = kwargs
+    expected["base64"] = True
+    expected["fmt"] = "png"
+    assert cell == expected
+
+    # check that the formatter doesn't raise
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1)
+    ax.plot([1, 2, 3])
+    plt.draw()
+    formatter.enabled = True
+    png = formatter(fig)
+    assert isinstance(png, str)
+    png_bytes = a2b_base64(png)
+    assert png_bytes.startswith(_PNG)
+
+
+def test_select_figure_formats_set():
+    ip = get_ipython()
+    for fmts in [
+        {"png", "svg"},
+        ["png"],
+        ("jpeg", "pdf", "retina"),
+        {"svg"},
+    ]:
+        active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
+        pt.select_figure_formats(ip, fmts)
+        for mime, f in ip.display_formatter.formatters.items():
+            if mime in active_mimes:
+                assert Figure in f
+            else:
+                assert Figure not in f
+
+
+def test_select_figure_formats_bad():
+    ip = get_ipython()
+    with pytest.raises(ValueError):
+        pt.select_figure_formats(ip, "foo")
+    with pytest.raises(ValueError):
+        pt.select_figure_formats(ip, {"png", "foo"})
+    with pytest.raises(ValueError):
+        pt.select_figure_formats(ip, ["retina", "pdf", "bar", "bad"])
+
+
+def test_import_pylab():
+    ns = {}
+    pt.import_pylab(ns, import_all=False)
+    assert "plt" in ns
+    assert ns["np"] == np
+
+
+@pytest.fixture
+def shell_pylab_fixture(hmmax3):
+    import matplotlib
+
+    def act_mpl(backend):
+        matplotlib.rcParams["backend"] = backend
+
+    # Save rcParams since they get modified
+    _saved_rcParams = matplotlib.rcParams
+    _saved_rcParamsOrig = matplotlib.rcParamsOrig
+    matplotlib.rcParams = dict(backend="QtAgg")
+    matplotlib.rcParamsOrig = dict(backend="QtAgg")
+
+    # Mock out functions
+    _save_am = pt.activate_matplotlib
+    pt.activate_matplotlib = act_mpl
+    _save_ip = pt.import_pylab
+    pt.import_pylab = lambda *a, **kw: None
+    s = Shell()
+    yield s
+    s.configurables = []
+    s.history_manager = None
+    pt.activate_matplotlib = _save_am
+    pt.import_pylab = _save_ip
+    matplotlib.rcParams = _saved_rcParams
+    matplotlib.rcParamsOrig = _saved_rcParamsOrig
+
+
+class Shell(InteractiveShell):
+    def init_history(self):
+        """Sets up the command history, and starts regular autosaves."""
+        self.config.HistoryManager.hist_file = ":memory:"
+        super().init_history()
+
+    def enable_gui(self, gui):
+        pass
+
+
+def test_just_shell_no_leak(shell_pylab_fixture):
+    s = shell_pylab_fixture
+
+
+def test_qt(shell_pylab_fixture):
+    s = shell_pylab_fixture
+    gui, backend = s.enable_matplotlib(None)
+    assert gui == "qt"
+    assert s.pylab_gui_select == "qt"
+
+    gui, backend = s.enable_matplotlib("inline")
+    assert gui is None
+    assert s.pylab_gui_select == "qt"
+
+    gui, backend = s.enable_matplotlib("qt")
+    assert gui == "qt"
+    assert s.pylab_gui_select == "qt"
+
+    gui, backend = s.enable_matplotlib("inline")
+    assert gui is None
+    assert s.pylab_gui_select == "qt"
+
+    gui, backend = s.enable_matplotlib()
+    assert gui == "qt"
+    assert s.pylab_gui_select == "qt"
+    s.configurables = []
+    s.history_manager = None
+
+
+def test_inline(shell_pylab_fixture):
+    s = shell_pylab_fixture
+    gui, backend = s.enable_matplotlib("inline")
+    assert gui is None
+    assert s.pylab_gui_select == None
+
+    gui, backend = s.enable_matplotlib("inline")
+    assert gui is None
+    assert s.pylab_gui_select == None
+
+    gui, backend = s.enable_matplotlib("qt")
+    assert gui == "qt"
+    assert s.pylab_gui_select == "qt"
+
+
+def test_inline_twice(shell_pylab_fixture):
+    "Using '%matplotlib inline' twice should not reset formatters"
+
+    ip = shell_pylab_fixture
+    gui, backend = ip.enable_matplotlib("inline")
+    assert gui is None
+
+    fmts = {"png"}
+    active_mimes = {_fmt_mime_map[fmt] for fmt in fmts}
+    pt.select_figure_formats(ip, fmts)
+
+    gui, backend = ip.enable_matplotlib("inline")
+    assert gui is None
+
+    for mime, f in ip.display_formatter.formatters.items():
+        if mime in active_mimes:
+            assert Figure in f
+        else:
+            assert Figure not in f
+
+
+def test_qt_gtk(shell_pylab_fixture):
+    s = shell_pylab_fixture
+    gui, backend = s.enable_matplotlib("qt")
+    assert gui == "qt"
+    assert s.pylab_gui_select == "qt"
+
+    gui, backend = s.enable_matplotlib("gtk3")
+    assert gui == "qt"
+    assert s.pylab_gui_select == "qt"
+
+
+@dec.skipif(not pt._matplotlib_manages_backends())
+def test_backend_module_name_case_sensitive(shell_pylab_fixture):
+    # Matplotlib backend names are case insensitive unless explicitly specified using
+    # "module://some_module.some_name" syntax which are case sensitive for mpl >= 3.9.1
+    all_lowercase = "module://matplotlib_inline.backend_inline"
+    some_uppercase = "module://matplotlib_inline.Backend_inline"
+    mpl3_9_1 = matplotlib.__version_info__ >= (3, 9, 1)
+
+    s = shell_pylab_fixture
+    s.enable_matplotlib(all_lowercase)
+    if mpl3_9_1:
+        with pytest.raises(RuntimeError):
+            s.enable_matplotlib(some_uppercase)
+    else:
+        s.enable_matplotlib(some_uppercase)
+
+    s.run_line_magic("matplotlib", all_lowercase)
+    if mpl3_9_1:
+        with pytest.raises(RuntimeError):
+            s.run_line_magic("matplotlib", some_uppercase)
+    else:
+        s.run_line_magic("matplotlib", some_uppercase)
+
+
+def test_no_gui_backends():
+    for k in ["agg", "svg", "pdf", "ps"]:
+        assert k not in pt.backend2gui
+
+
+def test_figure_no_canvas():
+    fig = Figure()
+    fig.canvas = None
+    pt.print_figure(fig)
+
+
+@pytest.mark.parametrize(
+    "name, expected_gui, expected_backend",
+    [
+        # name is gui
+        ("gtk3", "gtk3", "gtk3agg"),
+        ("gtk4", "gtk4", "gtk4agg"),
+        ("headless", None, "agg"),
+        ("osx", "osx", "macosx"),
+        ("qt", "qt", "qtagg"),
+        ("qt5", "qt5", "qt5agg"),
+        ("qt6", "qt6", "qtagg"),
+        ("tk", "tk", "tkagg"),
+        ("wx", "wx", "wxagg"),
+        # name is backend
+        ("agg", None, "agg"),
+        ("cairo", None, "cairo"),
+        ("pdf", None, "pdf"),
+        ("ps", None, "ps"),
+        ("svg", None, "svg"),
+        ("template", None, "template"),
+        ("gtk3agg", "gtk3", "gtk3agg"),
+        ("gtk3cairo", "gtk3", "gtk3cairo"),
+        ("gtk4agg", "gtk4", "gtk4agg"),
+        ("gtk4cairo", "gtk4", "gtk4cairo"),
+        ("macosx", "osx", "macosx"),
+        ("nbagg", "nbagg", "nbagg"),
+        ("notebook", "nbagg", "notebook"),
+        ("qtagg", "qt", "qtagg"),
+        ("qtcairo", "qt", "qtcairo"),
+        ("qt5agg", "qt5", "qt5agg"),
+        ("qt5cairo", "qt5", "qt5cairo"),
+        ("tkagg", "tk", "tkagg"),
+        ("tkcairo", "tk", "tkcairo"),
+        ("webagg", "webagg", "webagg"),
+        ("wxagg", "wx", "wxagg"),
+        ("wxcairo", "wx", "wxcairo"),
+    ],
+)
+def test_backend_builtin(name, expected_gui, expected_backend):
+    # Test correct identification of Matplotlib built-in backends without importing and using them,
+    # otherwise we would need to ensure all the complex dependencies such as windowing toolkits are
+    # installed.
+
+    mpl_manages_backends = pt._matplotlib_manages_backends()
+    if not mpl_manages_backends:
+        # Backends not supported before _matplotlib_manages_backends or supported
+        # but with different expected_gui or expected_backend.
+        if (
+            name.endswith("agg")
+            or name.endswith("cairo")
+            or name in ("headless", "macosx", "pdf", "ps", "svg", "template")
+        ):
+            pytest.skip()
+        elif name == "qt6":
+            expected_backend = "qtagg"
+        elif name == "notebook":
+            expected_backend, expected_gui = expected_gui, expected_backend
+
+    gui, backend = pt.find_gui_and_backend(name)
+    if not mpl_manages_backends:
+        gui = gui.lower() if gui else None
+        backend = backend.lower() if backend else None
+    assert gui == expected_gui
+    assert backend == expected_backend
+
+
+def test_backend_entry_point():
+    gui, backend = pt.find_gui_and_backend("inline")
+    assert gui is None
+    expected_backend = (
+        "inline"
+        if pt._matplotlib_manages_backends()
+        else "module://matplotlib_inline.backend_inline"
+    )
+    assert backend == expected_backend
+
+
+def test_backend_unknown():
+    with pytest.raises(RuntimeError if pt._matplotlib_manages_backends() else KeyError):
+        pt.find_gui_and_backend("name-does-not-exist")
diff --git a/tests/test_qt_loaders.py b/tests/test_qt_loaders.py
new file mode 100644
index 00000000000..7bc9ccfa86d
--- /dev/null
+++ b/tests/test_qt_loaders.py
@@ -0,0 +1,11 @@
+import importlib
+import pytest
+from IPython.external.qt_loaders import ID
+
+
+def test_import_denier():
+    ID.forbid("ipython_denied_module")
+    with pytest.raises(ImportError, match="disabled by IPython"):
+        import ipython_denied_module
+    with pytest.raises(ImportError, match="disabled by IPython"):
+        importlib.import_module("ipython_denied_module")
diff --git a/tests/test_run.py b/tests/test_run.py
new file mode 100644
index 00000000000..0c846925ab3
--- /dev/null
+++ b/tests/test_run.py
@@ -0,0 +1,647 @@
+# encoding: utf-8
+"""Tests for code execution (%run and related), which is particularly tricky.
+
+Because of how %run manages namespaces, and the fact that we are trying here to
+verify subtle object deletion and reference counting issues, the %run tests
+will be kept in this separate file.  This makes it easier to aggregate in one
+place the tricks needed to handle it; most other magics are much easier to test
+and we do so in a common test_magic file.
+
+Note that any test using `run -i` should make sure to do a `reset` afterwards,
+as otherwise it may influence later tests.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import functools
+import os
+import platform
+import random
+import string
+import sys
+import textwrap
+import unittest
+from os.path import join as pjoin
+from unittest.mock import patch
+
+import pytest
+from tempfile import TemporaryDirectory
+
+from IPython.core import debugger
+from IPython.testing import decorators as dec
+from IPython.testing import tools as tt
+from IPython.utils.io import capture_output
+
+
+def doctest_refbug():
+    """Very nasty problem with references held by multiple runs of a script.
+    See: https://github.com/ipython/ipython/issues/141
+
+    In [1]: _ip.clear_main_mod_cache()
+    # random
+
+    In [2]: %run refbug
+
+    In [3]: call_f()
+    lowercased: hello
+
+    In [4]: %run refbug
+
+    In [5]: call_f()
+    lowercased: hello
+    lowercased: hello
+    """
+
+
+def doctest_run_builtins():
+    r"""Check that %run doesn't damage __builtins__.
+
+    In [1]: import tempfile
+
+    In [2]: bid1 = id(__builtins__)
+
+    In [3]: fname = tempfile.mkstemp('.py')[1]
+
+    In [3]: f = open(fname, 'w', encoding='utf-8')
+
+    In [4]: dummy= f.write('pass\n')
+
+    In [5]: f.flush()
+
+    In [6]: t1 = type(__builtins__)
+
+    In [7]: %run $fname
+
+    In [7]: f.close()
+
+    In [8]: bid2 = id(__builtins__)
+
+    In [9]: t2 = type(__builtins__)
+
+    In [10]: t1 == t2
+    Out[10]: True
+
+    In [10]: bid1 == bid2
+    Out[10]: True
+
+    In [12]: try:
+       ....:     os.unlink(fname)
+       ....: except:
+       ....:     pass
+       ....:
+    """
+
+
+def doctest_run_option_parser():
+    r"""Test option parser in %run.
+
+    In [1]: %run print_argv.py
+    []
+
+    In [2]: %run print_argv.py print*.py
+    ['print_argv.py']
+
+    In [3]: %run -G print_argv.py print*.py
+    ['print*.py']
+
+    """
+
+
+@dec.skip_win32
+def doctest_run_option_parser_for_posix():
+    r"""Test option parser in %run (Linux/OSX specific).
+
+    You need double quote to escape glob in POSIX systems:
+
+    In [1]: %run print_argv.py print\\*.py
+    ['print*.py']
+
+    You can't use quote to escape glob in POSIX systems:
+
+    In [2]: %run print_argv.py 'print*.py'
+    ['print_argv.py']
+
+    """
+
+
+doctest_run_option_parser_for_posix.__skip_doctest__ = sys.platform == "win32"
+
+
+@dec.skip_if_not_win32
+def doctest_run_option_parser_for_windows():
+    r"""Test option parser in %run (Windows specific).
+
+    In Windows, you can't escape ``*` `by backslash:
+
+    In [1]: %run print_argv.py print\\*.py
+    ['print\\\\*.py']
+
+    You can use quote to escape glob:
+
+    In [2]: %run print_argv.py 'print*.py'
+    ["'print*.py'"]
+
+    """
+
+
+doctest_run_option_parser_for_windows.__skip_doctest__ = sys.platform != "win32"
+
+
+def doctest_reset_del():
+    """Test that resetting doesn't cause errors in __del__ methods.
+
+    In [2]: class A(object):
+       ...:     def __del__(self):
+       ...:         print(str("Hi"))
+       ...:
+
+    In [3]: a = A()
+
+    In [4]: get_ipython().reset(); import gc; x = gc.collect(0)
+    Hi
+
+    In [5]: 1+1
+    Out[5]: 2
+    """
+
+
+# For some tests, it will be handy to organize them in a class with a common
+# setup that makes a temp file
+
+import sysconfig
+
+is_freethreaded = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+
+
+class TestMagicRunPass(tt.TempFileMixin):
+    def setUp(self):
+        content = "a = [1,2,3]\nb = 1"
+        self.mktmp(content)
+
+    def run_tmpfile(self):
+        _ip = get_ipython()
+        # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
+        # See below and ticket https://bugs.launchpad.net/bugs/366353
+        _ip.run_line_magic("run", self.fname)
+
+    def run_tmpfile_p(self):
+        _ip = get_ipython()
+        # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
+        # See below and ticket https://bugs.launchpad.net/bugs/366353
+        _ip.run_line_magic("run", "-p %s" % self.fname)
+
+    def test_builtins_id(self):
+        """Check that %run doesn't damage __builtins__"""
+        _ip = get_ipython()
+        # Test that the id of __builtins__ is not modified by %run
+        bid1 = id(_ip.user_ns["__builtins__"])
+        self.run_tmpfile()
+        bid2 = id(_ip.user_ns["__builtins__"])
+        assert bid1 == bid2
+
+    def test_builtins_type(self):
+        """Check that the type of __builtins__ doesn't change with %run.
+
+        However, the above could pass if __builtins__ was already modified to
+        be a dict (it should be a module) by a previous use of %run.  So we
+        also check explicitly that it really is a module:
+        """
+        _ip = get_ipython()
+        self.run_tmpfile()
+        assert type(_ip.user_ns["__builtins__"]) == type(sys)
+
+    def test_run_profile(self):
+        """Test that the option -p, which invokes the profiler, do not
+        crash by invoking execfile"""
+        self.run_tmpfile_p()
+
+    def test_run_debug_twice(self):
+        # https://github.com/ipython/ipython/issues/10028
+        _ip = get_ipython()
+        with tt.fake_input(["c"]):
+            _ip.run_line_magic("run", "-d %s" % self.fname)
+        with tt.fake_input(["c"]):
+            _ip.run_line_magic("run", "-d %s" % self.fname)
+
+    def test_run_debug_twice_with_breakpoint(self):
+        """Make a valid python temp file."""
+        _ip = get_ipython()
+        with tt.fake_input(["b 2", "c", "c"]):
+            _ip.run_line_magic("run", "-d %s" % self.fname)
+
+        with tt.fake_input(["c"]):
+            with tt.AssertNotPrints("KeyError"):
+                _ip.run_line_magic("run", "-d %s" % self.fname)
+
+
+class TestMagicRunSimple(tt.TempFileMixin):
+    def test_simpledef(self):
+        """Test that simple class definitions work."""
+        src = "class foo: pass\n" "def f(): return foo()"
+        self.mktmp(src)
+        _ip.run_line_magic("run", str(self.fname))
+        _ip.run_cell("t = isinstance(f(), foo)")
+        assert _ip.user_ns["t"] is True
+
+    @pytest.mark.xfail(
+        platform.python_implementation() == "PyPy",
+        reason="expecting __del__ call on exit is unreliable and doesn't happen on PyPy",
+    )
+    def test_obj_del(self):
+        """Test that object's __del__ methods are called on exit."""
+        src = (
+            "class A(object):\n"
+            "    def __del__(self):\n"
+            "        print('object A deleted')\n"
+            "a = A()\n"
+        )
+        self.mktmp(src)
+        err = None
+        tt.ipexec_validate(self.fname, "object A deleted", err)
+
+    def test_aggressive_namespace_cleanup(self):
+        """Test that namespace cleanup is not too aggressive GH-238
+
+        Returning from another run magic deletes the namespace"""
+        # see ticket https://github.com/ipython/ipython/issues/238
+
+        with tt.TempFileMixin() as empty:
+            empty.mktmp("")
+            # On Windows, the filename will have \users in it, so we need to use the
+            # repr so that the \u becomes \\u.
+            src = (
+                "ip = get_ipython()\n"
+                "for i in range(5):\n"
+                "   try:\n"
+                "       ip.run_line_magic(%r, %r)\n"
+                "   except NameError as e:\n"
+                "       print(i)\n"
+                "       break\n" % ("run", empty.fname)
+            )
+            self.mktmp(src)
+            _ip.run_line_magic("run", str(self.fname))
+            _ip.run_cell("ip == get_ipython()")
+            assert _ip.user_ns["i"] == 4
+
+    def test_run_second(self):
+        """Test that running a second file doesn't clobber the first, gh-3547"""
+        self.mktmp("avar = 1\n" "def afunc():\n" "  return avar\n")
+
+        with tt.TempFileMixin() as empty:
+            empty.mktmp("")
+
+            _ip.run_line_magic("run", self.fname)
+            _ip.run_line_magic("run", empty.fname)
+            assert _ip.user_ns["afunc"]() == 1
+
+    @pytest.mark.xfail(is_freethreaded, reason="C-third leaks on free-threaded python")
+    def test_tclass(self):
+        mydir = os.path.dirname(__file__)
+        tc = os.path.join(mydir, "tclass")
+        src = f"""\
+import gc
+%run "{tc}" C-first
+gc.collect(0)
+%run "{tc}" C-second
+gc.collect(0)
+%run "{tc}" C-third
+gc.collect(0)
+%reset -f
+"""
+        self.mktmp(src, ".ipy")
+        out = """\
+ARGV 1-: ['C-first']
+ARGV 1-: ['C-second']
+tclass.py: deleting object: C-first
+ARGV 1-: ['C-third']
+tclass.py: deleting object: C-second
+tclass.py: deleting object: C-third
+"""
+        err = None
+        tt.ipexec_validate(self.fname, out, err)
+
+    def test_run_i_after_reset(self):
+        """Check that %run -i still works after %reset (gh-693)"""
+        src = "yy = zz\n"
+        self.mktmp(src)
+        _ip.run_cell("zz = 23")
+        try:
+            _ip.run_line_magic("run", "-i %s" % self.fname)
+            assert _ip.user_ns["yy"] == 23
+        finally:
+            _ip.run_line_magic("reset", "-f")
+
+        _ip.run_cell("zz = 23")
+        try:
+            _ip.run_line_magic("run", "-i %s" % self.fname)
+            assert _ip.user_ns["yy"] == 23
+        finally:
+            _ip.run_line_magic("reset", "-f")
+
+    def test_unicode(self):
+        """Check that files in odd encodings are accepted."""
+        mydir = os.path.dirname(__file__)
+        na = os.path.join(mydir, "nonascii.py")
+        _ip.run_line_magic("run", na)
+        assert _ip.user_ns["u"] == "Ўт№Ф"
+
+    def test_run_py_file_attribute(self):
+        """Test handling of `__file__` attribute in `%run <file>.py`."""
+        src = "t = __file__\n"
+        self.mktmp(src)
+        _missing = object()
+        file1 = _ip.user_ns.get("__file__", _missing)
+        _ip.run_line_magic("run", self.fname)
+        file2 = _ip.user_ns.get("__file__", _missing)
+
+        # Check that __file__ was equal to the filename in the script's
+        # namespace.
+        assert _ip.user_ns["t"] == self.fname
+
+        # Check that __file__ was not leaked back into user_ns.
+        assert file1 == file2
+
+    def test_run_ipy_file_attribute(self):
+        """Test handling of `__file__` attribute in `%run <file.ipy>`."""
+        src = "t = __file__\n"
+        self.mktmp(src, ext=".ipy")
+        _missing = object()
+        file1 = _ip.user_ns.get("__file__", _missing)
+        _ip.run_line_magic("run", self.fname)
+        file2 = _ip.user_ns.get("__file__", _missing)
+
+        # Check that __file__ was equal to the filename in the script's
+        # namespace.
+        assert _ip.user_ns["t"] == self.fname
+
+        # Check that __file__ was not leaked back into user_ns.
+        assert file1 == file2
+
+    def test_run_formatting(self):
+        """Test that %run -t -N<N> does not raise a TypeError for N > 1."""
+        src = "pass"
+        self.mktmp(src)
+        _ip.run_line_magic("run", "-t -N 1 %s" % self.fname)
+        _ip.run_line_magic("run", "-t -N 10 %s" % self.fname)
+
+    def test_ignore_sys_exit(self):
+        """Test the -e option to ignore sys.exit()"""
+        src = "import sys; sys.exit(1)"
+        self.mktmp(src)
+        with tt.AssertPrints("SystemExit"):
+            _ip.run_line_magic("run", self.fname)
+
+        with tt.AssertNotPrints("SystemExit"):
+            _ip.run_line_magic("run", "-e %s" % self.fname)
+
+    def test_run_nb(self):
+        """Test %run notebook.ipynb"""
+        pytest.importorskip("nbformat")
+        from nbformat import v4, writes
+
+        nb = v4.new_notebook(
+            cells=[
+                v4.new_markdown_cell("The Ultimate Question of Everything"),
+                v4.new_code_cell("answer=42"),
+            ]
+        )
+        src = writes(nb, version=4)
+        self.mktmp(src, ext=".ipynb")
+
+        _ip.run_line_magic("run", self.fname)
+
+        assert _ip.user_ns["answer"] == 42
+
+    def test_run_nb_error(self):
+        """Test %run notebook.ipynb error"""
+        pytest.importorskip("nbformat")
+        from nbformat import v4, writes
+
+        # %run when a file name isn't provided
+        pytest.raises(Exception, _ip.run_line_magic, "run")
+
+        # %run when a file doesn't exist
+        pytest.raises(Exception, _ip.run_line_magic, "run", "foobar.ipynb")
+
+        # %run on a notebook with an error
+        nb = v4.new_notebook(cells=[v4.new_code_cell("0/0")])
+        src = writes(nb, version=4)
+        self.mktmp(src, ext=".ipynb")
+        pytest.raises(Exception, _ip.run_line_magic, "run", self.fname)
+
+    def test_file_options(self):
+        src = "import sys\n" 'a = " ".join(sys.argv[1:])\n'
+        self.mktmp(src)
+        test_opts = "-x 3 --verbose"
+        _ip.run_line_magic("run", "{0} {1}".format(self.fname, test_opts))
+        assert _ip.user_ns["a"] == test_opts
+
+
+class TestMagicRunWithPackage(unittest.TestCase):
+    def writefile(self, name, content):
+        path = os.path.join(self.tempdir.name, name)
+        d = os.path.dirname(path)
+        if not os.path.isdir(d):
+            os.makedirs(d)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(textwrap.dedent(content))
+
+    def setUp(self):
+        self.package = package = "tmp{0}".format(
+            "".join([random.choice(string.ascii_letters) for i in range(10)])
+        )
+        """Temporary  (probably) valid python package name."""
+
+        self.value = int(random.random() * 10000)
+
+        self.tempdir = TemporaryDirectory()
+        self.__orig_cwd = os.getcwd()
+        sys.path.insert(0, self.tempdir.name)
+
+        self.writefile(os.path.join(package, "__init__.py"), "")
+        self.writefile(
+            os.path.join(package, "sub.py"),
+            """
+        x = {0!r}
+        """.format(
+                self.value
+            ),
+        )
+        self.writefile(
+            os.path.join(package, "relative.py"),
+            """
+        from .sub import x
+        """,
+        )
+        self.writefile(
+            os.path.join(package, "absolute.py"),
+            """
+        from {0}.sub import x
+        """.format(
+                package
+            ),
+        )
+        self.writefile(
+            os.path.join(package, "args.py"),
+            """
+        import sys
+        a = " ".join(sys.argv[1:])
+        """.format(
+                package
+            ),
+        )
+
+    def tearDown(self):
+        os.chdir(self.__orig_cwd)
+        sys.path[:] = [p for p in sys.path if p != self.tempdir.name]
+        self.tempdir.cleanup()
+
+    def check_run_submodule(self, submodule, opts=""):
+        _ip.user_ns.pop("x", None)
+        _ip.run_line_magic(
+            "run", "{2} -m {0}.{1}".format(self.package, submodule, opts)
+        )
+        self.assertEqual(
+            _ip.user_ns["x"],
+            self.value,
+            "Variable `x` is not loaded from module `{0}`.".format(submodule),
+        )
+
+    def test_run_submodule_with_absolute_import(self):
+        self.check_run_submodule("absolute")
+
+    def test_run_submodule_with_relative_import(self):
+        """Run submodule that has a relative import statement (#2727)."""
+        self.check_run_submodule("relative")
+
+    def test_prun_submodule_with_absolute_import(self):
+        self.check_run_submodule("absolute", "-p")
+
+    def test_prun_submodule_with_relative_import(self):
+        self.check_run_submodule("relative", "-p")
+
+    def with_fake_debugger(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwds):
+            with patch.object(debugger.Pdb, "run", staticmethod(eval)):
+                return func(*args, **kwds)
+
+        return wrapper
+
+    @with_fake_debugger
+    def test_debug_run_submodule_with_absolute_import(self):
+        self.check_run_submodule("absolute", "-d")
+
+    @with_fake_debugger
+    def test_debug_run_submodule_with_relative_import(self):
+        self.check_run_submodule("relative", "-d")
+
+    def test_module_options(self):
+        _ip.user_ns.pop("a", None)
+        test_opts = "-x abc -m test"
+        _ip.run_line_magic("run", "-m {0}.args {1}".format(self.package, test_opts))
+        assert _ip.user_ns["a"] == test_opts
+
+    def test_module_options_with_separator(self):
+        _ip.user_ns.pop("a", None)
+        test_opts = "-x abc -m test"
+        _ip.run_line_magic("run", "-m {0}.args -- {1}".format(self.package, test_opts))
+        assert _ip.user_ns["a"] == test_opts
+
+
+def test_run__name__():
+    with TemporaryDirectory() as td:
+        path = pjoin(td, "foo.py")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write("q = __name__")
+
+        _ip.user_ns.pop("q", None)
+        _ip.run_line_magic("run", "{}".format(path))
+        assert _ip.user_ns.pop("q") == "__main__"
+
+        _ip.run_line_magic("run", "-n {}".format(path))
+        assert _ip.user_ns.pop("q") == "foo"
+
+        try:
+            _ip.run_line_magic("run", "-i -n {}".format(path))
+            assert _ip.user_ns.pop("q") == "foo"
+        finally:
+            _ip.run_line_magic("reset", "-f")
+
+
+def test_run_tb():
+    """Test traceback offset in %run"""
+    with TemporaryDirectory() as td:
+        path = pjoin(td, "foo.py")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(
+                "\n".join(
+                    [
+                        "def foo():",
+                        "    return bar()",
+                        "def bar():",
+                        "    raise RuntimeError('hello!')",
+                        "foo()",
+                    ]
+                )
+            )
+        with capture_output() as io:
+            _ip.run_line_magic("run", "{}".format(path))
+        out = io.stdout
+        assert "execfile" not in out
+        assert "RuntimeError" in out
+        assert out.count("---->") == 3
+        del ip.user_ns["bar"]
+        del ip.user_ns["foo"]
+
+
+def test_multiprocessing_run():
+    """Set we can run mutiprocesgin without messing up up main namespace
+
+    Note that import `nose.tools as nt` modify the values
+    sys.module['__mp_main__'] so we need to temporarily set it to None to test
+    the issue.
+    """
+    with TemporaryDirectory() as td:
+        mpm = sys.modules.get("__mp_main__")
+        sys.modules["__mp_main__"] = None
+        try:
+            path = pjoin(td, "test.py")
+            with open(path, "w", encoding="utf-8") as f:
+                f.write("import multiprocessing\nprint('hoy')")
+            with capture_output() as io:
+                _ip.run_line_magic("run", path)
+                _ip.run_cell("i_m_undefined")
+            out = io.stdout
+            assert "hoy" in out
+            assert "AttributeError" not in out
+            assert "NameError" in out
+            assert out.count("---->") == 1
+        except:
+            raise
+        finally:
+            sys.modules["__mp_main__"] = mpm
+
+
+def test_script_tb():
+    """Test traceback offset in `ipython script.py`"""
+    with TemporaryDirectory() as td:
+        path = pjoin(td, "foo.py")
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(
+                "\n".join(
+                    [
+                        "def foo():",
+                        "    return bar()",
+                        "def bar():",
+                        "    raise RuntimeError('hello!')",
+                        "foo()",
+                    ]
+                )
+            )
+        out, err = tt.ipexec(path)
+        assert "execfile" not in out
+        assert "RuntimeError" in out
+        assert out.count("---->") == 3
diff --git a/tests/test_shellapp.py b/tests/test_shellapp.py
new file mode 100644
index 00000000000..3e7964d0e15
--- /dev/null
+++ b/tests/test_shellapp.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""Tests for shellapp module.
+
+Authors
+-------
+* Bradley Froehle
+"""
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2012  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import unittest
+
+from IPython.testing import decorators as dec
+from IPython.testing import tools as tt
+
+
+class TestFileToRun(tt.TempFileMixin, unittest.TestCase):
+    """Test the behavior of the file_to_run parameter."""
+
+    def test_py_script_file_attribute(self):
+        """Test that `__file__` is set when running `ipython file.py`"""
+        src = "print(__file__)\n"
+        self.mktmp(src)
+
+        err = None
+        tt.ipexec_validate(self.fname, self.fname, err)
+
+    def test_ipy_script_file_attribute(self):
+        """Test that `__file__` is set when running `ipython file.ipy`"""
+        src = "print(__file__)\n"
+        self.mktmp(src, ext=".ipy")
+
+        err = None
+        tt.ipexec_validate(self.fname, self.fname, err)
+
+    # The commands option to ipexec_validate doesn't work on Windows, and it
+    # doesn't seem worth fixing
+    @dec.skip_win32
+    def test_py_script_file_attribute_interactively(self):
+        """Test that `__file__` is not set after `ipython -i file.py`"""
+        src = "True\n"
+        self.mktmp(src)
+
+        out, err = tt.ipexec(
+            self.fname,
+            options=["-i"],
+            commands=['"__file__" in globals()', "print(123)", "exit()"],
+        )
+        assert "False" in out, f"Subprocess stderr:\n{err}\n-----"
diff --git a/tests/test_shortcuts.py b/tests/test_shortcuts.py
new file mode 100644
index 00000000000..102bf50bf2b
--- /dev/null
+++ b/tests/test_shortcuts.py
@@ -0,0 +1,520 @@
+import pytest
+import time
+from IPython.terminal.interactiveshell import PtkHistoryAdapter
+from IPython.terminal.shortcuts.auto_suggest import (
+    accept,
+    accept_or_jump_to_end,
+    accept_token,
+    accept_character,
+    accept_word,
+    accept_and_keep_cursor,
+    discard,
+    llm_autosuggestion,
+    NavigableAutoSuggestFromHistory,
+    swap_autosuggestion_up,
+    swap_autosuggestion_down,
+)
+from IPython.terminal.shortcuts.auto_match import skip_over
+from IPython.terminal.shortcuts import create_ipython_shortcuts, reset_search_buffer
+from IPython.testing import decorators as dec
+
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.document import Document
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.enums import DEFAULT_BUFFER
+
+from unittest.mock import patch, Mock
+
+
+def make_event(text, cursor, suggestion):
+    event = Mock()
+    event.current_buffer = Mock()
+    event.current_buffer.suggestion = Mock()
+    event.current_buffer.text = text
+    event.current_buffer.cursor_position = cursor
+    event.current_buffer.suggestion.text = suggestion
+    event.current_buffer.document = Document(text=text, cursor_position=cursor)
+    return event
+
+
+try:
+    from .fake_llm import FIBONACCI
+except ImportError:
+    FIBONACCI = ""
+
+
+@pytest.mark.skip(reason="pydandic messed up")
+@dec.skip_without("jupyter_ai")
+@pytest.mark.asyncio
+async def test_llm_autosuggestion():
+    provider = NavigableAutoSuggestFromHistory()
+    ip = get_ipython()
+    ip.auto_suggest = provider
+    ip.llm_provider_class = "tests.fake_llm.FibonacciCompletionProvider"
+    ip.history_manager.get_range = Mock(return_value=[])
+    text = "def fib"
+    event = Mock()
+    event.current_buffer = Buffer(
+        history=PtkHistoryAdapter(ip),
+    )
+    event.current_buffer.insert_text(text, move_cursor=True)
+    await llm_autosuggestion(event)
+    assert event.current_buffer.suggestion.text == FIBONACCI[len(text) :]
+
+
+def test_slow_llm_provider_should_not_block_init():
+    ip = get_ipython()
+    provider = NavigableAutoSuggestFromHistory()
+    ip.auto_suggest = provider
+    start = time.perf_counter()
+    ip.llm_provider_class = "tests.fake_llm.SlowStartingCompletionProvider"
+    end = time.perf_counter()
+    elapsed = end - start
+    assert elapsed < 0.1
+
+
+@pytest.mark.parametrize(
+    "text, suggestion, expected",
+    [
+        ("", "def out(tag: str, n=50):", "def out(tag: str, n=50):"),
+        ("def ", "out(tag: str, n=50):", "out(tag: str, n=50):"),
+    ],
+)
+def test_accept(text, suggestion, expected):
+    event = make_event(text, len(text), suggestion)
+    buffer = event.current_buffer
+    buffer.insert_text = Mock()
+    accept(event)
+    assert buffer.insert_text.called
+    assert buffer.insert_text.call_args[0] == (expected,)
+
+
+@pytest.mark.parametrize(
+    "text, suggestion",
+    [
+        ("", "def out(tag: str, n=50):"),
+        ("def ", "out(tag: str, n=50):"),
+    ],
+)
+def test_discard(text, suggestion):
+    event = make_event(text, len(text), suggestion)
+    buffer = event.current_buffer
+    buffer.insert_text = Mock()
+    discard(event)
+    assert not buffer.insert_text.called
+    assert buffer.suggestion is None
+
+
+@pytest.mark.parametrize(
+    "text, cursor, suggestion, called",
+    [
+        ("123456", 6, "123456789", True),
+        ("123456", 3, "123456789", False),
+        ("123456   \n789", 6, "123456789", True),
+    ],
+)
+def test_autosuggest_at_EOL(text, cursor, suggestion, called):
+    """
+    test that autosuggest is only applied at end of line.
+    """
+
+    event = make_event(text, cursor, suggestion)
+    event.current_buffer.insert_text = Mock()
+    accept_or_jump_to_end(event)
+    if called:
+        event.current_buffer.insert_text.assert_called()
+    else:
+        event.current_buffer.insert_text.assert_not_called()
+        # event.current_buffer.document.get_end_of_line_position.assert_called()
+
+
+@pytest.mark.parametrize(
+    "text, suggestion, expected",
+    [
+        ("", "def out(tag: str, n=50):", "def "),
+        ("d", "ef out(tag: str, n=50):", "ef "),
+        ("de ", "f out(tag: str, n=50):", "f "),
+        ("def", " out(tag: str, n=50):", " "),
+        ("def ", "out(tag: str, n=50):", "out("),
+        ("def o", "ut(tag: str, n=50):", "ut("),
+        ("def ou", "t(tag: str, n=50):", "t("),
+        ("def out", "(tag: str, n=50):", "("),
+        ("def out(", "tag: str, n=50):", "tag: "),
+        ("def out(t", "ag: str, n=50):", "ag: "),
+        ("def out(ta", "g: str, n=50):", "g: "),
+        ("def out(tag", ": str, n=50):", ": "),
+        ("def out(tag:", " str, n=50):", " "),
+        ("def out(tag: ", "str, n=50):", "str, "),
+        ("def out(tag: s", "tr, n=50):", "tr, "),
+        ("def out(tag: st", "r, n=50):", "r, "),
+        ("def out(tag: str", ", n=50):", ", n"),
+        ("def out(tag: str,", " n=50):", " n"),
+        ("def out(tag: str, ", "n=50):", "n="),
+        ("def out(tag: str, n", "=50):", "="),
+        ("def out(tag: str, n=", "50):", "50)"),
+        ("def out(tag: str, n=5", "0):", "0)"),
+        ("def out(tag: str, n=50", "):", "):"),
+        ("def out(tag: str, n=50)", ":", ":"),
+    ],
+)
+def test_autosuggest_token(text, suggestion, expected):
+    event = make_event(text, len(text), suggestion)
+    event.current_buffer.insert_text = Mock()
+    accept_token(event)
+    assert event.current_buffer.insert_text.called
+    assert event.current_buffer.insert_text.call_args[0] == (expected,)
+
+
+@pytest.mark.parametrize(
+    "text, suggestion, expected",
+    [
+        ("", "def out(tag: str, n=50):", "d"),
+        ("d", "ef out(tag: str, n=50):", "e"),
+        ("de ", "f out(tag: str, n=50):", "f"),
+        ("def", " out(tag: str, n=50):", " "),
+    ],
+)
+def test_accept_character(text, suggestion, expected):
+    event = make_event(text, len(text), suggestion)
+    event.current_buffer.insert_text = Mock()
+    accept_character(event)
+    assert event.current_buffer.insert_text.called
+    assert event.current_buffer.insert_text.call_args[0] == (expected,)
+
+
+@pytest.mark.parametrize(
+    "text, suggestion, expected",
+    [
+        ("", "def out(tag: str, n=50):", "def "),
+        ("d", "ef out(tag: str, n=50):", "ef "),
+        ("de", "f out(tag: str, n=50):", "f "),
+        ("def", " out(tag: str, n=50):", " "),
+        # (this is why we also have accept_token)
+        ("def ", "out(tag: str, n=50):", "out(tag: "),
+    ],
+)
+def test_accept_word(text, suggestion, expected):
+    event = make_event(text, len(text), suggestion)
+    event.current_buffer.insert_text = Mock()
+    accept_word(event)
+    assert event.current_buffer.insert_text.called
+    assert event.current_buffer.insert_text.call_args[0] == (expected,)
+
+
+@pytest.mark.parametrize(
+    "text, suggestion, expected, cursor",
+    [
+        ("", "def out(tag: str, n=50):", "def out(tag: str, n=50):", 0),
+        ("def ", "out(tag: str, n=50):", "out(tag: str, n=50):", 4),
+    ],
+)
+def test_accept_and_keep_cursor(text, suggestion, expected, cursor):
+    event = make_event(text, cursor, suggestion)
+    buffer = event.current_buffer
+    buffer.insert_text = Mock()
+    accept_and_keep_cursor(event)
+    assert buffer.insert_text.called
+    assert buffer.insert_text.call_args[0] == (expected,)
+    assert buffer.cursor_position == cursor
+
+
+def test_autosuggest_token_empty():
+    full = "def out(tag: str, n=50):"
+    event = make_event(full, len(full), "")
+    event.current_buffer.insert_text = Mock()
+
+    with patch(
+        "prompt_toolkit.key_binding.bindings.named_commands.forward_word"
+    ) as forward_word:
+        accept_token(event)
+        assert not event.current_buffer.insert_text.called
+        assert forward_word.called
+
+
+def test_reset_search_buffer():
+    event_with_text = Mock()
+    event_with_text.current_buffer.document.text = "some text"
+    event_with_text.current_buffer.reset = Mock()
+
+    event_empty = Mock()
+    event_empty.current_buffer.document.text = ""
+    event_empty.app.layout.focus = Mock()
+
+    reset_search_buffer(event_with_text)
+    event_with_text.current_buffer.reset.assert_called_once()
+
+    reset_search_buffer(event_empty)
+    event_empty.app.layout.focus.assert_called_once_with(DEFAULT_BUFFER)
+
+
+def test_other_providers():
+    """Ensure that swapping autosuggestions does not break with other providers"""
+    provider = AutoSuggestFromHistory()
+    ip = get_ipython()
+    ip.auto_suggest = provider
+    event = Mock()
+    event.current_buffer = Buffer()
+    assert swap_autosuggestion_up(event) is None
+    assert swap_autosuggestion_down(event) is None
+
+
+@pytest.mark.asyncio
+async def test_navigable_provider():
+    provider = NavigableAutoSuggestFromHistory()
+    history = InMemoryHistory(history_strings=["very_a", "very", "very_b", "very_c"])
+    buffer = Buffer(history=history)
+    ip = get_ipython()
+    ip.auto_suggest = provider
+
+    async for _ in history.load():
+        pass
+
+    buffer.cursor_position = 5
+    buffer.text = "very"
+
+    up = swap_autosuggestion_up
+    down = swap_autosuggestion_down
+
+    event = Mock()
+    event.current_buffer = buffer
+
+    def get_suggestion():
+        suggestion = provider.get_suggestion(buffer, buffer.document)
+        buffer.suggestion = suggestion
+        return suggestion
+
+    assert get_suggestion().text == "_c"
+
+    # should go up
+    up(event)
+    assert get_suggestion().text == "_b"
+
+    # should skip over 'very' which is identical to buffer content
+    up(event)
+    assert get_suggestion().text == "_a"
+
+    # should cycle back to beginning
+    up(event)
+    assert get_suggestion().text == "_c"
+
+    # should cycle back through end boundary
+    down(event)
+    assert get_suggestion().text == "_a"
+
+    down(event)
+    assert get_suggestion().text == "_b"
+
+    down(event)
+    assert get_suggestion().text == "_c"
+
+    down(event)
+    assert get_suggestion().text == "_a"
+
+
+@pytest.mark.asyncio
+async def test_navigable_provider_multiline_entries():
+    provider = NavigableAutoSuggestFromHistory()
+    history = InMemoryHistory(history_strings=["very_a\nvery_b", "very_c"])
+    buffer = Buffer(history=history)
+    ip = get_ipython()
+    ip.auto_suggest = provider
+
+    async for _ in history.load():
+        pass
+
+    buffer.cursor_position = 5
+    buffer.text = "very"
+    up = swap_autosuggestion_up
+    down = swap_autosuggestion_down
+
+    event = Mock()
+    event.current_buffer = buffer
+
+    def get_suggestion():
+        suggestion = provider.get_suggestion(buffer, buffer.document)
+        buffer.suggestion = suggestion
+        return suggestion
+
+    assert get_suggestion().text == "_c"
+
+    up(event)
+    assert get_suggestion().text == "_b"
+
+    up(event)
+    assert get_suggestion().text == "_a"
+
+    down(event)
+    assert get_suggestion().text == "_b"
+
+    down(event)
+    assert get_suggestion().text == "_c"
+
+
+def create_session_mock():
+    session = Mock()
+    session.default_buffer = Buffer()
+    return session
+
+
+def test_navigable_provider_connection():
+    provider = NavigableAutoSuggestFromHistory()
+    provider.skip_lines = 1
+
+    session_1 = create_session_mock()
+    provider.connect(session_1)
+
+    assert provider.skip_lines == 1
+    session_1.default_buffer.on_text_insert.fire()
+    assert provider.skip_lines == 0
+
+    session_2 = create_session_mock()
+    provider.connect(session_2)
+    provider.skip_lines = 2
+
+    assert provider.skip_lines == 2
+    session_2.default_buffer.on_text_insert.fire()
+    assert provider.skip_lines == 0
+
+    provider.skip_lines = 3
+    provider.disconnect()
+    session_1.default_buffer.on_text_insert.fire()
+    session_2.default_buffer.on_text_insert.fire()
+    assert provider.skip_lines == 3
+
+
+@pytest.fixture
+def ipython_with_prompt():
+    ip = get_ipython()
+    ip.pt_app = Mock()
+    ip.pt_app.key_bindings = create_ipython_shortcuts(ip)
+    try:
+        yield ip
+    finally:
+        ip.pt_app = None
+
+
+def find_bindings_by_command(command):
+    ip = get_ipython()
+    return [
+        binding
+        for binding in ip.pt_app.key_bindings.bindings
+        if binding.handler == command
+    ]
+
+
+def test_modify_unique_shortcut(ipython_with_prompt):
+    original = find_bindings_by_command(accept_token)
+    assert len(original) == 1
+
+    ipython_with_prompt.shortcuts = [
+        {"command": "IPython:auto_suggest.accept_token", "new_keys": ["a", "b", "c"]}
+    ]
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 1
+    assert list(matched[0].keys) == ["a", "b", "c"]
+    assert list(matched[0].keys) != list(original[0].keys)
+    assert matched[0].filter == original[0].filter
+
+    ipython_with_prompt.shortcuts = [
+        {"command": "IPython:auto_suggest.accept_token", "new_filter": "always"}
+    ]
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 1
+    assert list(matched[0].keys) != ["a", "b", "c"]
+    assert list(matched[0].keys) == list(original[0].keys)
+    assert matched[0].filter != original[0].filter
+
+
+def test_disable_shortcut(ipython_with_prompt):
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 1
+
+    ipython_with_prompt.shortcuts = [
+        {"command": "IPython:auto_suggest.accept_token", "new_keys": []}
+    ]
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 0
+
+    ipython_with_prompt.shortcuts = []
+    matched = find_bindings_by_command(accept_token)
+    assert len(matched) == 1
+
+
+def test_modify_shortcut_with_filters(ipython_with_prompt):
+    matched = find_bindings_by_command(skip_over)
+    matched_keys = {m.keys[0] for m in matched}
+    assert matched_keys == {")", "]", "}", "'", '"'}
+
+    with pytest.raises(ValueError, match="Multiple shortcuts matching"):
+        ipython_with_prompt.shortcuts = [
+            {"command": "IPython:auto_match.skip_over", "new_keys": ["x"]}
+        ]
+
+    ipython_with_prompt.shortcuts = [
+        {
+            "command": "IPython:auto_match.skip_over",
+            "new_keys": ["x"],
+            "match_filter": "focused_insert & auto_match & followed_by_single_quote",
+        }
+    ]
+    matched = find_bindings_by_command(skip_over)
+    matched_keys = {m.keys[0] for m in matched}
+    assert matched_keys == {")", "]", "}", "x", '"'}
+
+
+def example_command():
+    pass
+
+
+def test_add_shortcut_for_new_command(ipython_with_prompt):
+    matched = find_bindings_by_command(example_command)
+    assert len(matched) == 0
+
+    with pytest.raises(ValueError, match="example_command is not a known"):
+        ipython_with_prompt.shortcuts = [
+            {"command": "example_command", "new_keys": ["x"]}
+        ]
+    matched = find_bindings_by_command(example_command)
+    assert len(matched) == 0
+
+
+def test_modify_shortcut_failure(ipython_with_prompt):
+    with pytest.raises(ValueError, match="No shortcuts matching"):
+        ipython_with_prompt.shortcuts = [
+            {
+                "command": "IPython:auto_match.skip_over",
+                "match_keys": ["x"],
+                "new_keys": ["y"],
+            }
+        ]
+
+
+def test_add_shortcut_for_existing_command(ipython_with_prompt):
+    matched = find_bindings_by_command(skip_over)
+    assert len(matched) == 5
+
+    with pytest.raises(ValueError, match="Cannot add a shortcut without keys"):
+        ipython_with_prompt.shortcuts = [
+            {"command": "IPython:auto_match.skip_over", "new_keys": [], "create": True}
+        ]
+
+    ipython_with_prompt.shortcuts = [
+        {"command": "IPython:auto_match.skip_over", "new_keys": ["x"], "create": True}
+    ]
+    matched = find_bindings_by_command(skip_over)
+    assert len(matched) == 6
+
+    ipython_with_prompt.shortcuts = []
+    matched = find_bindings_by_command(skip_over)
+    assert len(matched) == 5
+
+
+def test_setting_shortcuts_before_pt_app_init():
+    ipython = get_ipython()
+    assert ipython.pt_app is None
+    shortcuts = [
+        {"command": "IPython:auto_match.skip_over", "new_keys": ["x"], "create": True}
+    ]
+    ipython.shortcuts = shortcuts
+    assert ipython.shortcuts == shortcuts
diff --git a/tests/test_splitinput.py b/tests/test_splitinput.py
new file mode 100644
index 00000000000..f5fc53fafe3
--- /dev/null
+++ b/tests/test_splitinput.py
@@ -0,0 +1,41 @@
+# coding: utf-8
+
+from IPython.core.splitinput import split_user_input, LineInfo
+
+import pytest
+
+tests = [
+    ("x=1", ("", "", "x", "=1")),
+    ("?", ("", "?", "", "")),
+    ("??", ("", "??", "", "")),
+    (" ?", (" ", "?", "", "")),
+    (" ??", (" ", "??", "", "")),
+    ("??x", ("", "??", "x", "")),
+    ("?x=1", ("", "?", "x", "=1")),
+    ("!ls", ("", "!", "ls", "")),
+    ("  !ls", ("  ", "!", "ls", "")),
+    ("!!ls", ("", "!!", "ls", "")),
+    ("  !!ls", ("  ", "!!", "ls", "")),
+    (",ls", ("", ",", "ls", "")),
+    (";ls", ("", ";", "ls", "")),
+    ("  ;ls", ("  ", ";", "ls", "")),
+    ("f.g(x)", ("", "", "f.g", "(x)")),
+    ("f.g (x)", ("", "", "f.g", " (x)")),
+    ("?%hist1", ("", "?", "%hist1", "")),
+    ("?%%hist2", ("", "?", "%%hist2", "")),
+    ("??%hist3", ("", "??", "%hist3", "")),
+    ("??%%hist4", ("", "??", "%%hist4", "")),
+    ("?x*", ("", "?", "x*", "")),
+    ("Pérez Fernando", ("", "", "Pérez", " Fernando")),
+]
+
+
+@pytest.mark.parametrize("input, output", tests)
+def test_split_user_input(input, output):
+    assert split_user_input(input) == output
+
+
+def test_LineInfo():
+    """Simple test for LineInfo construction and str()"""
+    linfo = LineInfo("  %cd /home")
+    assert str(linfo) == "LineInfo [  |%|cd|/home]"
diff --git a/tests/test_storemagic.py b/tests/test_storemagic.py
new file mode 100644
index 00000000000..dcff8605236
--- /dev/null
+++ b/tests/test_storemagic.py
@@ -0,0 +1,72 @@
+import tempfile, os
+from pathlib import Path
+
+from traitlets.config.loader import Config
+
+
+def setup_module():
+    ip.run_line_magic("load_ext", "storemagic")
+
+
+def test_store_restore():
+    assert "bar" not in ip.user_ns, "Error: some other test leaked `bar` in user_ns"
+    assert "foo" not in ip.user_ns, "Error: some other test leaked `foo` in user_ns"
+    assert (
+        "foobar" not in ip.user_ns
+    ), "Error: some other test leaked `foobar` in user_ns"
+    assert (
+        "foobaz" not in ip.user_ns
+    ), "Error: some other test leaked `foobaz` in user_ns"
+    ip.user_ns["foo"] = 78
+    ip.run_line_magic("alias", 'bar echo "hello"')
+    ip.user_ns["foobar"] = 79
+    ip.user_ns["foobaz"] = "80"
+    tmpd = tempfile.mkdtemp()
+    ip.run_line_magic("cd", tmpd)
+    ip.run_line_magic("store", "foo")
+    ip.run_line_magic("store", "bar")
+    ip.run_line_magic("store", "foobar foobaz")
+
+    # Check storing
+    assert ip.db["autorestore/foo"] == 78
+    assert "bar" in ip.db["stored_aliases"]
+    assert ip.db["autorestore/foobar"] == 79
+    assert ip.db["autorestore/foobaz"] == "80"
+
+    # Remove those items
+    ip.user_ns.pop("foo", None)
+    ip.user_ns.pop("foobar", None)
+    ip.user_ns.pop("foobaz", None)
+    ip.alias_manager.undefine_alias("bar")
+    ip.run_line_magic("cd", "-")
+    ip.user_ns["_dh"][:] = []
+
+    # Check restoring
+    ip.run_line_magic("store", "-r foo bar foobar foobaz")
+    assert ip.user_ns["foo"] == 78
+    assert ip.alias_manager.is_alias("bar")
+    assert ip.user_ns["foobar"] == 79
+    assert ip.user_ns["foobaz"] == "80"
+
+    ip.run_line_magic("store", "-r")  # restores _dh too
+    assert any(Path(tmpd).samefile(p) for p in ip.user_ns["_dh"])
+
+    os.rmdir(tmpd)
+
+
+def test_autorestore():
+    ip.user_ns["foo"] = 95
+    ip.run_line_magic("store", "foo")
+    del ip.user_ns["foo"]
+    c = Config()
+    c.StoreMagics.autorestore = False
+    orig_config = ip.config
+    try:
+        ip.config = c
+        ip.extension_manager.reload_extension("storemagic")
+        assert "foo" not in ip.user_ns
+        c.StoreMagics.autorestore = True
+        ip.extension_manager.reload_extension("storemagic")
+        assert ip.user_ns["foo"] == 95
+    finally:
+        ip.config = orig_config
diff --git a/tests/test_sysinfo.py b/tests/test_sysinfo.py
new file mode 100644
index 00000000000..0e0ad719670
--- /dev/null
+++ b/tests/test_sysinfo.py
@@ -0,0 +1,17 @@
+# coding: utf-8
+"""Test suite for our sysinfo utilities."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import json
+import pytest
+
+from IPython.utils import sysinfo
+
+
+def test_json_getsysinfo():
+    """
+    test that it is easily jsonable and don't return bytes somewhere.
+    """
+    json.dumps(sysinfo.get_sys_info())
diff --git a/tests/test_tempdir.py b/tests/test_tempdir.py
new file mode 100644
index 00000000000..0cf262a5b59
--- /dev/null
+++ b/tests/test_tempdir.py
@@ -0,0 +1,30 @@
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2012-  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+from pathlib import Path
+
+from IPython.utils.tempdir import NamedFileInTemporaryDirectory
+from IPython.utils.tempdir import TemporaryWorkingDirectory
+
+
+def test_named_file_in_temporary_directory():
+    with NamedFileInTemporaryDirectory("filename", "wb") as file:
+        name = file.name
+        assert not file.closed
+        assert Path(name).exists()
+        file.write(b"test")
+    assert file.closed
+    assert not Path(name).exists()
+
+
+def test_temporary_working_directory():
+    with TemporaryWorkingDirectory() as directory:
+        directory_path = Path(directory).resolve()
+        assert directory_path.exists()
+        assert Path.cwd().resolve() == directory_path
+    assert not directory_path.exists()
+    assert Path.cwd().resolve() != directory_path
diff --git a/tests/test_text.py b/tests/test_text.py
new file mode 100644
index 00000000000..4cd04c4d676
--- /dev/null
+++ b/tests/test_text.py
@@ -0,0 +1,151 @@
+# encoding: utf-8
+"""Tests for IPython.utils.text"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import os
+import sys
+import math
+import random
+
+from pathlib import Path
+
+import pytest
+
+from IPython.utils import text
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+
+
+def eval_formatter_list_comprehension_check(f):
+    ns = dict(n=12)
+    s = f.format("{[n//i for i in range(1,8)]}", **ns)
+    assert s == "[12, 6, 4, 3, 2, 2, 1]"
+
+
+def eval_formatter_check(f):
+    ns = dict(n=12, pi=math.pi, stuff="hello there", os=os, u="café", b="café")
+    s = f.format("{n} {n//4} {stuff.split()[0]}", **ns)
+    assert s == "12 3 hello"
+    s = f.format(" ".join(["{n//%i}" % i for i in range(1, 8)]), **ns)
+    assert s == "12 6 4 3 2 2 1"
+    s = f.format("{list(n//i for i in range(1,8))}", **ns)
+    assert s == "[12, 6, 4, 3, 2, 2, 1]"
+    s = f.format("{stuff!s}", **ns)
+    assert s == ns["stuff"]
+    s = f.format("{stuff!r}", **ns)
+    assert s == repr(ns["stuff"])
+
+    # Check with unicode:
+    s = f.format("{u}", **ns)
+    assert s == ns["u"]
+    # This decodes in a platform dependent manner, but it shouldn't error out
+    s = f.format("{b}", **ns)
+
+    pytest.raises(NameError, f.format, "{dne}", **ns)
+
+
+def eval_formatter_slicing_check(f):
+    ns = dict(n=12, pi=math.pi, stuff="hello there", os=os)
+    s = f.format(" {stuff.split()[:]} ", **ns)
+    assert s == " ['hello', 'there'] "
+    s = f.format(" {stuff.split()[::-1]} ", **ns)
+    assert s == " ['there', 'hello'] "
+    s = f.format("{stuff[::2]}", **ns)
+    assert s == ns["stuff"][::2]
+
+    pytest.raises(SyntaxError, f.format, "{n:x}", **ns)
+
+
+def eval_formatter_no_slicing_check(f):
+    ns = dict(n=12, pi=math.pi, stuff="hello there", os=os)
+
+    s = f.format("{n:x} {pi**2:+f}", **ns)
+    assert s == "c +9.869604"
+
+    s = f.format("{stuff[slice(1,4)]}", **ns)
+    assert s == "ell"
+
+    s = f.format("{a[:]}", a=[1, 2])
+    assert s == "[1, 2]"
+
+
+def test_eval_formatter():
+    f = text.EvalFormatter()
+    eval_formatter_check(f)
+    eval_formatter_no_slicing_check(f)
+    if sys.version_info < (3, 14):
+        eval_formatter_list_comprehension_check(f)
+
+
+def test_full_eval_formatter():
+    f = text.FullEvalFormatter()
+    eval_formatter_check(f)
+    eval_formatter_slicing_check(f)
+    eval_formatter_list_comprehension_check(f)
+
+
+def test_dollar_formatter():
+    f = text.DollarFormatter()
+    eval_formatter_check(f)
+    eval_formatter_slicing_check(f)
+
+    ns = dict(n=12, pi=math.pi, stuff="hello there", os=os)
+    s = f.format("$n", **ns)
+    assert s == "12"
+    s = f.format("$n.real", **ns)
+    assert s == "12"
+    s = f.format("$n/{stuff[:5]}", **ns)
+    assert s == "12/hello"
+    s = f.format("$n $$HOME", **ns)
+    assert s == "12 $HOME"
+    s = f.format("${foo}", foo="HOME")
+    assert s == "$HOME"
+
+
+def test_strip_email():
+    src = """\
+        >> >>> def f(x):
+        >> ...   return x+1
+        >> ... 
+        >> >>> zz = f(2.5)"""
+    cln = """\
+>>> def f(x):
+...   return x+1
+... 
+>>> zz = f(2.5)"""
+    assert text.strip_email_quotes(src) == cln
+
+
+def test_strip_email2():
+    src = "> > > list()"
+    cln = "list()"
+    assert text.strip_email_quotes(src) == cln
+
+
+def test_LSString():
+    lss = text.LSString("abc\ndef")
+    assert lss.l == ["abc", "def"]
+    assert lss.s == "abc def"
+    lss = text.LSString(os.getcwd())
+    assert isinstance(lss.p[0], Path)
+
+
+def test_SList():
+    sl = text.SList(["a 11", "b 1", "a 2"])
+    assert sl.n == "a 11\nb 1\na 2"
+    assert sl.s == "a 11 b 1 a 2"
+    assert sl.grep(lambda x: x.startswith("a")) == text.SList(["a 11", "a 2"])
+    assert sl.fields(0) == text.SList(["a", "b", "a"])
+    assert sl.sort(field=1, nums=True) == text.SList(["b 1", "a 2", "a 11"])
diff --git a/tests/test_tips.py b/tests/test_tips.py
new file mode 100644
index 00000000000..198b9d3629b
--- /dev/null
+++ b/tests/test_tips.py
@@ -0,0 +1,12 @@
+from IPython.core.tips import _tips
+
+import os
+import pytest
+
+all_tips = _tips["random"] + list(_tips["every_year"].values())
+
+
+@pytest.mark.skipif(os.name != "nt", reason="Windows console may crash with Unicode")
+@pytest.mark.parametrize("tip", all_tips)
+def test_tips(tip):
+    assert tip.isascii()
diff --git a/tests/test_tokenutil.py b/tests/test_tokenutil.py
new file mode 100644
index 00000000000..496806c1b3e
--- /dev/null
+++ b/tests/test_tokenutil.py
@@ -0,0 +1,183 @@
+"""Tests for tokenutil"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import pytest
+import textwrap
+
+from IPython.utils.tokenutil import token_at_cursor, line_at_cursor
+
+
+def expect_token(expected: str, cell: str, cursor_pos: int | None = None) -> None:
+    """
+    If cursor_pos is `None`, look for `|` as the cursor position.
+    Assert that the token at the cursor position is `expected`.
+    """
+    if cursor_pos is None:
+        assert (
+            cursor_count := cell.count("|")
+        ) == 1, (
+            f"Cursor position not specified and found {cursor_count} instance(s) of '|'"
+        )
+        cursor_pos = cell.index("|")
+        cell = cell.replace("|", "")
+    token = token_at_cursor(cell, cursor_pos)
+    offset = 0
+    for line in cell.splitlines():
+        if offset + len(line) >= cursor_pos:
+            break
+        else:
+            offset += len(line) + 1
+    column = cursor_pos - offset
+    line_with_cursor = "%s|%s" % (line[:column], line[column:])
+    assert token == expected, "Expected %r, got %r in: %r (pos %i)" % (
+        expected,
+        token,
+        line_with_cursor,
+        cursor_pos,
+    )
+
+
+def test_simple():
+    cell = "foo"
+    for i in range(len(cell)):
+        expect_token("foo", cell, i)
+
+
+def test_function():
+    cell = "foo(a=5, b='10')"
+    for i in range(len(cell)):
+        expect_token("foo", cell, i)
+    expect_token("a", "foo(|a, b)")
+    expect_token("foo", "foo(a|, b)")
+    expect_token("foo", "foo(a,| b)")
+    expect_token("b", "foo(a, |b)")
+    expect_token("foo", "foo(a, b|)")
+
+
+@pytest.mark.parametrize(
+    "cell",
+    [
+        "\n".join(["a = 5", "b = hello('string', there)"]),
+        textwrap.dedent(
+            '''
+            """\n\nxxxxxxxxxx\n\n"""
+            5, """
+            """\n\nxxxxxxxxxx\n\n"""
+            docstring
+            multiline token
+            """, [
+            2, 3, "complicated"]
+            b = hello("string", there)
+        '''
+        ),
+    ],
+)
+def test_multiline(cell):
+    expected = "hello"
+    start = cell.index(expected) + 1
+    for i in range(start, start + len(expected)):
+        expect_token(expected, cell, i)
+    start = cell.index(expected) + 1
+    for i in range(start, start + len(expected)):
+        expect_token(expected, cell, i)
+
+
+def test_nested_call_kwargs():
+    cell = "foo(bar(a=5), b=10)"
+    start = cell.index("bar")
+    last = start + len("bar")
+    for i in range(start, last + 1):
+        expect_token("bar", cell, i)
+    start = cell.index("a=")
+    for i in range(start, start + 3):
+        expect_token("bar", cell, i)
+    expect_token("bar", "foo(bar(a=|5), b=10)")
+    expect_token("bar", "foo(bar(a=5|), b=10)")
+    for i in range(cell.index(")") + 1, cell.index("b=") + 2):
+        expect_token("foo", cell, i)
+    expect_token("foo", cell, len(cell) - 1)
+
+
+def test_nested_call_args():
+    expect_token("bar", "foo(bar(x,| ))")
+    expect_token("bar", "foo(bar(x, |))")
+    expect_token("bar", "foo(ba|r(x, y))")
+    expect_token("x", "foo(bar(|x, y))")
+    expect_token("bar", "foo(bar(x|, y))")
+    expect_token("bar", "foo(bar(x,| y))")
+    expect_token("y", "foo(bar(x, |y))")
+    expect_token("bar", "foo(bar(x, y|))")
+    expect_token("foo", "foo(bar(x, y)|)")
+    expect_token("foo", "foo(bar(, y)|)")
+
+
+def test_outer_name():
+    expect_token("x", "|x + foo(a, b) + y + z")
+    expect_token("x", "x| + foo(a, b) + y + z")
+    expect_token("x", "x |+ foo(a, b) + y + z")
+    expect_token("x", "x +| foo(a, b) + y + z")
+    expect_token("foo", "x + |foo(a, b) + y + z")
+    expect_token("a", "x + foo(|a, b) + y + z")
+    expect_token("foo", "x + foo(a|, b) + y + z")
+    expect_token("foo", "x + foo(a, b)| + y + z")
+    expect_token("foo", "x + foo(a, b) |+ y + z")
+    expect_token("foo", "x + foo(a, b) +| y + z")
+    expect_token("y", "x + foo(a, b) + |y + z")
+    expect_token("y", "x + foo(a, b) + y| + z")
+    expect_token("y", "x + foo(a, b) + y |+ z")
+    expect_token("y", "x + foo(a, b) + y +| z")
+    expect_token("z", "x + foo(a, b) + y + |z")
+
+
+def test_attrs():
+    cell = "a = obj.attr.subattr"
+    expected = "obj"
+    idx = cell.find("obj") + 1
+    for i in range(idx, idx + 3):
+        expect_token(expected, cell, i)
+    idx = cell.find(".attr") + 2
+    expected = "obj.attr"
+    for i in range(idx, idx + 4):
+        expect_token(expected, cell, i)
+    idx = cell.find(".subattr") + 2
+    expected = "obj.attr.subattr"
+    for i in range(idx, len(cell)):
+        expect_token(expected, cell, i)
+
+
+def test_line_at_cursor():
+    cell = ""
+    (line, offset) = line_at_cursor(cell, cursor_pos=11)
+    assert line == ""
+    assert offset == 0
+
+    # The position after a newline should be the start of the following line.
+    cell = "One\nTwo\n"
+    (line, offset) = line_at_cursor(cell, cursor_pos=4)
+    assert line == "Two\n"
+    assert offset == 4
+
+    # The end of a cell should be on the last line
+    cell = "pri\npri"
+    (line, offset) = line_at_cursor(cell, cursor_pos=7)
+    assert line == "pri"
+    assert offset == 4
+
+
+@pytest.mark.parametrize(
+    "c, token",
+    zip(
+        list(range(16, 22)) + list(range(22, 28)),
+        ["int"] * (22 - 16) + ["map"] * (28 - 22),
+    ),
+)
+def test_multiline_statement(c, token):
+    cell = """a = (1,
+    3)
+
+int()
+map()
+"""
+    expect_token(token, cell, c)
diff --git a/tests/test_tools.py b/tests/test_tools.py
new file mode 100644
index 00000000000..783c8ed7bc6
--- /dev/null
+++ b/tests/test_tools.py
@@ -0,0 +1,128 @@
+# encoding: utf-8
+"""
+Tests for testing.tools
+"""
+
+# -----------------------------------------------------------------------------
+#  Copyright (C) 2008-2011  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import os
+import unittest
+
+from IPython.testing import decorators as dec
+from IPython.testing import tools as tt
+
+# -----------------------------------------------------------------------------
+# Tests
+# -----------------------------------------------------------------------------
+
+
+@dec.skip_win32
+def test_full_path_posix():
+    spath = "/foo/bar.py"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["/foo/a.txt" == "/foo/b.txt"]
+    spath = "/foo"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["/a.txt" == "/b.txt"]
+    result = tt.full_path(spath, ["a.txt"])
+    assert result == ["/a.txt"]
+
+
+@dec.skip_if_not_win32
+def test_full_path_win32():
+    spath = "c:\\foo\\bar.py"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["c:\\foo\\a.txt" == "c:\\foo\\b.txt"]
+    spath = "c:\\foo"
+    result = tt.full_path(spath, ["a.txt", "b.txt"])
+    assert result, ["c:\\a.txt" == "c:\\b.txt"]
+    result = tt.full_path(spath, ["a.txt"])
+    assert result == ["c:\\a.txt"]
+
+
+def test_parser():
+    err = ("FAILED (errors=1)", 1, 0)
+    fail = ("FAILED (failures=1)", 0, 1)
+    both = ("FAILED (errors=1, failures=1)", 1, 1)
+    for txt, nerr, nfail in [err, fail, both]:
+        nerr1, nfail1 = tt.parse_test_output(txt)
+        assert nerr == nerr1
+        assert nfail == nfail1
+
+
+def test_temp_pyfile():
+    src = "pass\n"
+    fname = tt.temp_pyfile(src)
+    assert os.path.isfile(fname)
+    with open(fname, encoding="utf-8") as fh2:
+        src2 = fh2.read()
+    assert src2 == src
+
+
+class TestAssertPrints(unittest.TestCase):
+    def test_passing(self):
+        with tt.AssertPrints("abc"):
+            print("abcd")
+            print("def")
+            print(b"ghi")
+
+    def test_failing(self):
+        def func():
+            with tt.AssertPrints("abc"):
+                print("acd")
+                print("def")
+                print(b"ghi")
+
+        self.assertRaises(AssertionError, func)
+
+
+class Test_ipexec_validate(tt.TempFileMixin):
+    def test_main_path(self):
+        """Test with only stdout results."""
+        self.mktmp("print('A')\n" "print('B')\n")
+        out = "A\nB"
+        tt.ipexec_validate(self.fname, out)
+
+    def test_main_path2(self):
+        """Test with only stdout results, expecting windows line endings."""
+        self.mktmp("print('A')\n" "print('B')\n")
+        out = "A\r\nB"
+        tt.ipexec_validate(self.fname, out)
+
+    def test_exception_path(self):
+        """Test exception path in exception_validate."""
+        self.mktmp(
+            "import sys\n"
+            "print('A')\n"
+            "print('B')\n"
+            "print('C', file=sys.stderr)\n"
+            "print('D', file=sys.stderr)\n"
+        )
+        out = "A\nB"
+        tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\nD")
+
+    def test_exception_path2(self):
+        """Test exception path in exception_validate, expecting windows line endings."""
+        self.mktmp(
+            "import sys\n"
+            "print('A')\n"
+            "print('B')\n"
+            "print('C', file=sys.stderr)\n"
+            "print('D', file=sys.stderr)\n"
+        )
+        out = "A\r\nB"
+        tt.ipexec_validate(self.fname, expected_out=out, expected_err="C\r\nD")
+
+    def tearDown(self):
+        # tear down correctly the mixin,
+        # unittest.TestCase.tearDown does nothing
+        tt.TempFileMixin.tearDown(self)
diff --git a/tests/test_ultratb.py b/tests/test_ultratb.py
new file mode 100644
index 00000000000..e32c171426b
--- /dev/null
+++ b/tests/test_ultratb.py
@@ -0,0 +1,506 @@
+# encoding: utf-8
+"""Tests for IPython.core.ultratb"""
+import io
+import os.path
+import platform
+import re
+import sys
+import traceback
+import unittest
+from textwrap import dedent
+
+from tempfile import TemporaryDirectory
+
+from IPython.core.ultratb import VerboseTB, FormattedTB
+from IPython.testing import tools as tt
+from IPython.testing.decorators import onlyif_unicode_paths, skip_without
+from IPython.utils.syspathcontext import prepended_to_syspath
+
+file_1 = """1
+2
+3
+def f():
+  1/0
+"""
+
+file_2 = """def f():
+  1/0
+"""
+
+
+def recursionlimit(frames):
+    """
+    decorator to set the recursion limit temporarily
+    """
+
+    def inner(test_function):
+        def wrapper(*args, **kwargs):
+            rl = sys.getrecursionlimit()
+            sys.setrecursionlimit(frames)
+            try:
+                return test_function(*args, **kwargs)
+            finally:
+                sys.setrecursionlimit(rl)
+
+        return wrapper
+
+    return inner
+
+
+class ChangedPyFileTest(unittest.TestCase):
+    def test_changing_py_file(self):
+        """Traceback produced if the line where the error occurred is missing?
+
+        https://github.com/ipython/ipython/issues/1456
+        """
+        with TemporaryDirectory() as td:
+            fname = os.path.join(td, "foo_1456.py")
+            with open(fname, "w", encoding="utf-8") as f:
+                f.write(file_1)
+
+            with prepended_to_syspath(td):
+                ip.run_cell("import foo_1456")
+
+            with tt.AssertPrints("ZeroDivisionError"):
+                ip.run_cell("foo_1456.f()")
+
+            # Make the file shorter, so the line of the error is missing.
+            with open(fname, "w", encoding="utf-8") as f:
+                f.write(file_2)
+
+            # For some reason, this was failing on the *second* call after
+            # changing the file, so we call f() twice.
+            with tt.AssertNotPrints("Internal Python error", channel="stderr"):
+                with tt.AssertPrints("ZeroDivisionError"):
+                    ip.run_cell("foo_1456.f()")
+                with tt.AssertPrints("ZeroDivisionError"):
+                    ip.run_cell("foo_1456.f()")
+
+
+iso_8859_5_file = '''# coding: iso-8859-5
+
+def fail():
+    """дбИЖ"""
+    1/0     # дбИЖ
+'''
+
+
+class NonAsciiTest(unittest.TestCase):
+    @onlyif_unicode_paths
+    def test_nonascii_path(self):
+        # Non-ascii directory name as well.
+        with TemporaryDirectory(suffix="é") as td:
+            fname = os.path.join(td, "fooé.py")
+            with open(fname, "w", encoding="utf-8") as f:
+                f.write(file_1)
+
+            with prepended_to_syspath(td):
+                ip.run_cell("import fooé")
+
+            with tt.AssertPrints("ZeroDivisionError"):
+                ip.run_cell("fooé.f()")
+
+    def test_iso8859_5(self):
+        with TemporaryDirectory() as td:
+            fname = os.path.join(td, "dfghjkl.py")
+
+            with io.open(fname, "w", encoding="iso-8859-5") as f:
+                f.write(iso_8859_5_file)
+
+            with prepended_to_syspath(td):
+                ip.run_cell("from dfghjkl import fail")
+
+            with tt.AssertPrints("ZeroDivisionError"):
+                with tt.AssertPrints("дбИЖ", suppress=False):
+                    ip.run_cell("fail()")
+
+    def test_nonascii_msg(self):
+        cell = "raise Exception('é')"
+        expected = "Exception('é')"
+        ip.run_cell("%xmode plain")
+        with tt.AssertPrints(expected):
+            ip.run_cell(cell)
+
+        ip.run_cell("%xmode verbose")
+        with tt.AssertPrints(expected):
+            ip.run_cell(cell)
+
+        ip.run_cell("%xmode context")
+        with tt.AssertPrints(expected):
+            ip.run_cell(cell)
+
+        ip.run_cell("%xmode minimal")
+        with tt.AssertPrints("Exception: é"):
+            ip.run_cell(cell)
+
+        # Put this back into Context mode for later tests.
+        ip.run_cell("%xmode context")
+
+
+class NestedGenExprTestCase(unittest.TestCase):
+    """
+    Regression test for the following issues:
+    https://github.com/ipython/ipython/issues/8293
+    https://github.com/ipython/ipython/issues/8205
+    """
+
+    def test_nested_genexpr(self):
+        code = dedent(
+            """\
+            class SpecificException(Exception):
+                pass
+
+            def foo_8293(x):
+                raise SpecificException("Success!")
+
+            sum(sum(foo_8293(x) for _ in [0]) for x in [0])
+            """
+        )
+        with tt.AssertPrints("SpecificException: Success!", suppress=False):
+            ip.run_cell(code)
+
+
+indentationerror_file = """if True:
+zoom()
+"""
+
+
+class IndentationErrorTest(unittest.TestCase):
+    def test_indentationerror_shows_line(self):
+        # See issue gh-2398
+        with tt.AssertPrints("IndentationError"):
+            with tt.AssertPrints("zoom()", suppress=False):
+                ip.run_cell(indentationerror_file)
+
+        with TemporaryDirectory() as td:
+            fname = os.path.join(td, "foo_2398.py")
+            with open(fname, "w", encoding="utf-8") as f:
+                f.write(indentationerror_file)
+
+            with tt.AssertPrints("IndentationError"):
+                with tt.AssertPrints("zoom()", suppress=False):
+                    ip.run_line_magic("run", fname)
+
+
+@skip_without("pandas")
+def test_dynamic_code():
+    code = """
+    import pandas
+    df = pandas.DataFrame([])
+
+    # Important: only fails inside of an "exec" call:
+    exec("df.foobarbaz()")
+    """
+
+    with tt.AssertPrints("Could not get source"):
+        ip.run_cell(code)
+
+
+se_file_1 = """1
+2
+7/
+"""
+
+se_file_2 = """7/
+"""
+
+
+class SyntaxErrorTest(unittest.TestCase):
+    def test_syntaxerror_no_stacktrace_at_compile_time(self):
+        syntax_error_at_compile_time = """
+def foo_syntax_error_test():
+    ..
+"""
+        with tt.AssertPrints("SyntaxError"):
+            ip.run_cell(syntax_error_at_compile_time)
+
+        with tt.AssertNotPrints("foo_syntax_error_test()"):
+            ip.run_cell(syntax_error_at_compile_time)
+
+    def test_syntaxerror_stacktrace_when_running_compiled_code(self):
+        syntax_error_at_runtime = """
+def foo_syntax_error_test_2():
+    eval("..")
+
+def bar_syntax_error_test_2():
+    foo_syntax_error_test_2()
+
+bar_syntax_error_test_2()
+"""
+        with tt.AssertPrints("SyntaxError"):
+            ip.run_cell(syntax_error_at_runtime)
+        # Assert syntax error during runtime generate stacktrace
+        with tt.AssertPrints(
+            ["foo_syntax_error_test_2()", "bar_syntax_error_test_2()"]
+        ):
+            ip.run_cell(syntax_error_at_runtime)
+        del ip.user_ns["bar_syntax_error_test_2"]
+        del ip.user_ns["foo_syntax_error_test_2"]
+
+    def test_changing_py_file(self):
+        with TemporaryDirectory() as td:
+            fname = os.path.join(td, "foo_test_changing_py_file.py")
+            with open(fname, "w", encoding="utf-8") as f:
+                f.write(se_file_1)
+
+            with tt.AssertPrints(["7/", "SyntaxError"]):
+                ip.run_line_magic("run", fname)
+
+            # Modify the file
+            with open(fname, "w", encoding="utf-8") as f:
+                f.write(se_file_2)
+
+            # The SyntaxError should point to the correct line
+            with tt.AssertPrints(["7/", "SyntaxError"]):
+                ip.run_line_magic("run", fname)
+
+    def test_non_syntaxerror(self):
+        # SyntaxTB may be called with an error other than a SyntaxError
+        # See e.g. gh-4361
+        try:
+            raise ValueError("QWERTY")
+        except ValueError:
+            with tt.AssertPrints("QWERTY"):
+                ip.showsyntaxerror()
+
+
+import sys
+
+if platform.python_implementation() != "PyPy":
+    """
+    New 3.9 Pgen Parser does not raise Memory error, except on failed malloc.
+    """
+
+    class MemoryErrorTest(unittest.TestCase):
+        def test_memoryerror(self):
+            memoryerror_code = "(" * 200 + ")" * 200
+            ip.run_cell(memoryerror_code)
+
+
+class Python3ChainedExceptionsTest(unittest.TestCase):
+    DIRECT_CAUSE_ERROR_CODE = """
+try:
+    x = 1 + 2
+    print(not_defined_here)
+except Exception as e:
+    x += 55
+    x - 1
+    y = {}
+    raise KeyError('uh') from e
+    """
+
+    EXCEPTION_DURING_HANDLING_CODE = """
+try:
+    x = 1 + 2
+    print(not_defined_here)
+except Exception as e:
+    x += 55
+    x - 1
+    y = {}
+    raise KeyError('uh')
+    """
+
+    SUPPRESS_CHAINING_CODE = """
+try:
+    1/0
+except Exception:
+    raise ValueError("Yikes") from None
+    """
+
+    SYS_EXIT_WITH_CONTEXT_CODE = """
+try:
+    1/0
+except Exception as e:
+    raise SystemExit(1)
+    """
+
+    def test_direct_cause_error(self):
+        with tt.AssertPrints(["KeyError", "NameError", "direct cause"]):
+            ip.run_cell(self.DIRECT_CAUSE_ERROR_CODE)
+
+    def test_exception_during_handling_error(self):
+        with tt.AssertPrints(["KeyError", "NameError", "During handling"]):
+            ip.run_cell(self.EXCEPTION_DURING_HANDLING_CODE)
+
+    def test_sysexit_while_handling_error(self):
+        with tt.AssertPrints(["SystemExit", "to see the full traceback"]):
+            with tt.AssertNotPrints(["another exception"], suppress=False):
+                ip.run_cell(self.SYS_EXIT_WITH_CONTEXT_CODE)
+
+    def test_suppress_exception_chaining(self):
+        with (
+            tt.AssertNotPrints("ZeroDivisionError"),
+            tt.AssertPrints("ValueError", suppress=False),
+        ):
+            ip.run_cell(self.SUPPRESS_CHAINING_CODE)
+
+    def test_plain_direct_cause_error(self):
+        with tt.AssertPrints(["KeyError", "NameError", "direct cause"]):
+            ip.run_cell("%xmode Plain")
+            ip.run_cell(self.DIRECT_CAUSE_ERROR_CODE)
+            ip.run_cell("%xmode Verbose")
+
+    def test_plain_exception_during_handling_error(self):
+        with tt.AssertPrints(["KeyError", "NameError", "During handling"]):
+            ip.run_cell("%xmode Plain")
+            ip.run_cell(self.EXCEPTION_DURING_HANDLING_CODE)
+            ip.run_cell("%xmode Verbose")
+
+    def test_plain_suppress_exception_chaining(self):
+        with (
+            tt.AssertNotPrints("ZeroDivisionError"),
+            tt.AssertPrints("ValueError", suppress=False),
+        ):
+            ip.run_cell("%xmode Plain")
+            ip.run_cell(self.SUPPRESS_CHAINING_CODE)
+            ip.run_cell("%xmode Verbose")
+
+
+class RecursionTest(unittest.TestCase):
+    DEFINITIONS = """
+def non_recurs():
+    1/0
+
+def r1():
+    r1()
+
+def r3a():
+    r3b()
+
+def r3b():
+    r3c()
+
+def r3c():
+    r3a()
+
+def r3o1():
+    r3a()
+
+def r3o2():
+    r3o1()
+"""
+
+    def setUp(self):
+        ip.run_cell(self.DEFINITIONS)
+
+    def test_no_recursion(self):
+        with tt.AssertNotPrints("skipping similar frames"):
+            ip.run_cell("non_recurs()")
+
+    @recursionlimit(200)
+    def test_recursion_one_frame(self):
+        with tt.AssertPrints(
+            re.compile(
+                r"\[\.\.\. skipping similar frames: r1 at line 5 \(\d{2,3} times\)\]"
+            )
+        ):
+            ip.run_cell("r1()")
+
+    @recursionlimit(160)
+    def test_recursion_three_frames(self):
+        with (
+            tt.AssertPrints("[... skipping similar frames: "),
+            tt.AssertPrints(
+                re.compile(r"r3a at line 8 \(\d{2} times\)"), suppress=False
+            ),
+            tt.AssertPrints(
+                re.compile(r"r3b at line 11 \(\d{2} times\)"), suppress=False
+            ),
+            tt.AssertPrints(
+                re.compile(r"r3c at line 14 \(\d{2} times\)"), suppress=False
+            ),
+        ):
+            ip.run_cell("r3o2()")
+
+
+class PEP678NotesReportingTest(unittest.TestCase):
+    ERROR_WITH_NOTE = """
+try:
+    raise AssertionError("Message")
+except Exception as e:
+    try:
+        e.add_note("This is a PEP-678 note.")
+    except AttributeError:  # Python <= 3.10
+        e.__notes__ = ("This is a PEP-678 note.",)
+    raise
+    """
+
+    def test_verbose_reports_notes(self):
+        with tt.AssertPrints(["AssertionError", "Message", "This is a PEP-678 note."]):
+            ip.run_cell(self.ERROR_WITH_NOTE)
+
+    def test_plain_reports_notes(self):
+        with tt.AssertPrints(["AssertionError", "Message", "This is a PEP-678 note."]):
+            ip.run_cell("%xmode Plain")
+            ip.run_cell(self.ERROR_WITH_NOTE)
+            ip.run_cell("%xmode Verbose")
+
+
+class ExceptionMessagePreferenceTest(unittest.TestCase):
+    """
+    Test that exception string representation is preferred over .msg attribute
+    for non-SyntaxError exceptions in %xmode plain.
+    """
+
+    def test_jsondecodeerror_message(self):
+        cell = "import json;json.loads('{\"a\": }')"
+        if platform.python_implementation() == "PyPy":
+            expected = "JSONDecodeError: Unexpected '}': line 1 column 7 (char 6)"
+        else:
+            expected = "JSONDecodeError: Expecting value: line 1 column 7 (char 6)"
+        ip.run_cell("%xmode plain")
+        with tt.AssertPrints(expected):
+            ip.run_cell(cell)
+        ip.run_cell("%xmode context")
+
+
+# ----------------------------------------------------------------------------
+
+
+# module testing (minimal)
+def test_handlers():
+    def spam(c, d_e):
+        (d, e) = d_e
+        x = c + d
+        y = c * d
+        foo(x, y)
+
+    def foo(a, b, bar=1):
+        eggs(a, b + bar)
+
+    def eggs(f, g, z=globals()):
+        h = f + g
+        i = f - g
+        return h / i
+
+    buff = io.StringIO()
+
+    buff.write("")
+    buff.write("*** Before ***")
+    try:
+        buff.write(spam(1, (2, 3)))
+    except:
+        traceback.print_exc(file=buff)
+
+    handler = FormattedTB(ostream=buff)
+    buff.write("*** FormattedTB ***")
+    try:
+        buff.write(spam(1, (2, 3)))
+    except:
+        handler(*sys.exc_info())
+    buff.write("")
+
+    handler = VerboseTB(ostream=buff)
+    buff.write("*** VerboseTB ***")
+    try:
+        buff.write(spam(1, (2, 3)))
+    except:
+        handler(*sys.exc_info())
+    buff.write("")
+
+
+def testSyntaxError():
+    cell = "raise SyntaxError()"
+    expected = "SyntaxError\n"
+    with tt.AssertPrints(expected):
+        ip.run_cell(cell)
diff --git a/tests/test_wildcard.py b/tests/test_wildcard.py
new file mode 100644
index 00000000000..1e5ed6e1c66
--- /dev/null
+++ b/tests/test_wildcard.py
@@ -0,0 +1,264 @@
+"""Some tests for the wildcard utilities."""
+
+# -----------------------------------------------------------------------------
+# Library imports
+# -----------------------------------------------------------------------------
+# Stdlib
+import unittest
+
+# Our own
+from IPython.utils import wildcard
+
+# -----------------------------------------------------------------------------
+# Globals for test
+# -----------------------------------------------------------------------------
+
+
+class obj_t(object):
+    pass
+
+
+root = obj_t()
+l = ["arna", "abel", "ABEL", "active", "bob", "bark", "abbot"]
+q = ["kate", "loop", "arne", "vito", "lucifer", "koppel"]
+for x in l:
+    o = obj_t()
+    setattr(root, x, o)
+    for y in q:
+        p = obj_t()
+        setattr(o, y, p)
+root._apan = obj_t()
+root._apan.a = 10
+root._apan._a = 20
+root._apan.__a = 20
+root.__anka = obj_t()
+root.__anka.a = 10
+root.__anka._a = 20
+root.__anka.__a = 20
+
+root._APAN = obj_t()
+root._APAN.a = 10
+root._APAN._a = 20
+root._APAN.__a = 20
+root.__ANKA = obj_t()
+root.__ANKA.a = 10
+root.__ANKA._a = 20
+root.__ANKA.__a = 20
+
+# -----------------------------------------------------------------------------
+# Test cases
+# -----------------------------------------------------------------------------
+
+
+class Tests(unittest.TestCase):
+    def test_case(self):
+        ns = root.__dict__
+        tests = [
+            (
+                "a*",
+                [
+                    "abbot",
+                    "abel",
+                    "active",
+                    "arna",
+                ],
+            ),
+            (
+                "?b*.?o*",
+                [
+                    "abbot.koppel",
+                    "abbot.loop",
+                    "abel.koppel",
+                    "abel.loop",
+                ],
+            ),
+            ("_a*", []),
+            (
+                "_*anka",
+                [
+                    "__anka",
+                ],
+            ),
+            (
+                "_*a*",
+                [
+                    "__anka",
+                ],
+            ),
+        ]
+        for pat, res in tests:
+            res.sort()
+            a = sorted(
+                wildcard.list_namespace(
+                    ns, "all", pat, ignore_case=False, show_all=False
+                ).keys()
+            )
+            self.assertEqual(a, res)
+
+    def test_case_showall(self):
+        ns = root.__dict__
+        tests = [
+            (
+                "a*",
+                [
+                    "abbot",
+                    "abel",
+                    "active",
+                    "arna",
+                ],
+            ),
+            (
+                "?b*.?o*",
+                [
+                    "abbot.koppel",
+                    "abbot.loop",
+                    "abel.koppel",
+                    "abel.loop",
+                ],
+            ),
+            ("_a*", ["_apan"]),
+            (
+                "_*anka",
+                [
+                    "__anka",
+                ],
+            ),
+            (
+                "_*a*",
+                [
+                    "__anka",
+                    "_apan",
+                ],
+            ),
+        ]
+        for pat, res in tests:
+            res.sort()
+            a = sorted(
+                wildcard.list_namespace(
+                    ns, "all", pat, ignore_case=False, show_all=True
+                ).keys()
+            )
+            self.assertEqual(a, res)
+
+    def test_nocase(self):
+        ns = root.__dict__
+        tests = [
+            (
+                "a*",
+                [
+                    "abbot",
+                    "abel",
+                    "ABEL",
+                    "active",
+                    "arna",
+                ],
+            ),
+            (
+                "?b*.?o*",
+                [
+                    "abbot.koppel",
+                    "abbot.loop",
+                    "abel.koppel",
+                    "abel.loop",
+                    "ABEL.koppel",
+                    "ABEL.loop",
+                ],
+            ),
+            ("_a*", []),
+            (
+                "_*anka",
+                [
+                    "__anka",
+                    "__ANKA",
+                ],
+            ),
+            (
+                "_*a*",
+                [
+                    "__anka",
+                    "__ANKA",
+                ],
+            ),
+        ]
+        for pat, res in tests:
+            res.sort()
+            a = sorted(
+                wildcard.list_namespace(
+                    ns, "all", pat, ignore_case=True, show_all=False
+                ).keys()
+            )
+            self.assertEqual(a, res)
+
+    def test_nocase_showall(self):
+        ns = root.__dict__
+        tests = [
+            (
+                "a*",
+                [
+                    "abbot",
+                    "abel",
+                    "ABEL",
+                    "active",
+                    "arna",
+                ],
+            ),
+            (
+                "?b*.?o*",
+                [
+                    "abbot.koppel",
+                    "abbot.loop",
+                    "abel.koppel",
+                    "abel.loop",
+                    "ABEL.koppel",
+                    "ABEL.loop",
+                ],
+            ),
+            ("_a*", ["_apan", "_APAN"]),
+            (
+                "_*anka",
+                [
+                    "__anka",
+                    "__ANKA",
+                ],
+            ),
+            ("_*a*", ["__anka", "__ANKA", "_apan", "_APAN"]),
+        ]
+        for pat, res in tests:
+            res.sort()
+            a = sorted(
+                wildcard.list_namespace(
+                    ns, "all", pat, ignore_case=True, show_all=True
+                ).keys()
+            )
+            a.sort()
+            self.assertEqual(a, res)
+
+    def test_dict_attributes(self):
+        """Dictionaries should be indexed by attributes, not by keys. This was
+        causing Github issue 129."""
+        ns = {"az": {"king": 55}, "pq": {1: 0}}
+        tests = [("a*", ["az"]), ("az.k*", ["az.keys"]), ("pq.k*", ["pq.keys"])]
+        for pat, res in tests:
+            res.sort()
+            a = sorted(
+                wildcard.list_namespace(
+                    ns, "all", pat, ignore_case=False, show_all=True
+                ).keys()
+            )
+            self.assertEqual(a, res)
+
+    def test_dict_dir(self):
+        class A(object):
+            def __init__(self):
+                self.a = 1
+                self.b = 2
+
+            def __getattribute__(self, name):
+                if name == "a":
+                    raise AttributeError
+                return object.__getattribute__(self, name)
+
+        a = A()
+        adict = wildcard.dict_dir(a)
+        assert "a" not in adict  # change to assertNotIn method in >= 2.7
+        self.assertEqual(adict["b"], 2)
diff --git a/tests/test_zzz_autoreload.py b/tests/test_zzz_autoreload.py
new file mode 100644
index 00000000000..4728dffba49
--- /dev/null
+++ b/tests/test_zzz_autoreload.py
@@ -0,0 +1,1153 @@
+"""Tests for autoreload extension."""
+
+# -----------------------------------------------------------------------------
+#  Copyright (c) 2012 IPython Development Team.
+#
+#  Distributed under the terms of the Modified BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+
+import os
+import platform
+import pytest
+import sys
+import tempfile
+import textwrap
+import shutil
+import random
+import time
+import traceback
+from io import StringIO
+from dataclasses import dataclass
+
+import IPython.testing.tools as tt
+
+from unittest import TestCase
+
+from IPython.extensions.autoreload import AutoreloadMagics
+from IPython.core.events import EventManager, pre_run_cell
+from IPython.testing.decorators import skipif_not_numpy
+from IPython.core.interactiveshell import ExecutionInfo
+from IPython.core import inputtransformer2 as ipt2
+
+if platform.python_implementation() == "PyPy":
+    pytest.skip(
+        "Current autoreload implementation is extremely slow on PyPy",
+        allow_module_level=True,
+    )
+
+# -----------------------------------------------------------------------------
+# Test fixture
+# -----------------------------------------------------------------------------
+
+noop = lambda *a, **kw: None
+
+
+class FakeShell:
+    def __init__(self):
+        self.ns = {}
+        self.user_ns = self.ns
+        self.user_ns["In"] = []
+        self.user_ns_hidden = {}
+        self.events = EventManager(self, {"pre_run_cell", pre_run_cell})
+        self.auto_magics = AutoreloadMagics(shell=self)
+        self.events.register("pre_run_cell", self.auto_magics.pre_run_cell)
+        self.input_transformer_manager = ipt2.TransformerManager()
+
+    register_magics = set_hook = noop
+
+    def showtraceback(
+        self,
+        exc_tuple=None,
+        filename=None,
+        tb_offset=None,
+        exception_only=False,
+        running_compiled_code=False,
+    ):
+        traceback.print_exc()
+
+    def run_code(self, code):
+        transformed_cell = self.input_transformer_manager.transform_cell(code)
+        self.events.trigger(
+            "pre_run_cell",
+            ExecutionInfo(
+                raw_cell=code,
+                transformed_cell=code,
+                store_history=False,
+                silent=False,
+                shell_futures=False,
+                cell_id=None,
+            ),
+        )
+        exec(code, self.user_ns)
+        self.auto_magics.post_execute_hook()
+
+    def push(self, items):
+        self.ns.update(items)
+
+    def magic_autoreload(self, parameter):
+        self.auto_magics.autoreload(parameter)
+
+    def magic_aimport(self, parameter, stream=None):
+        self.auto_magics.aimport(parameter, stream=stream)
+        self.auto_magics.post_execute_hook()
+
+
+class Fixture(TestCase):
+    """Fixture for creating test module files"""
+
+    test_dir = None
+    old_sys_path = None
+    filename_chars = "abcdefghijklmopqrstuvwxyz0123456789"
+
+    def setUp(self):
+        self.test_dir = tempfile.mkdtemp()
+        self.old_sys_path = list(sys.path)
+        sys.path.insert(0, self.test_dir)
+        self.shell = FakeShell()
+
+    def tearDown(self):
+        shutil.rmtree(self.test_dir)
+        sys.path = self.old_sys_path
+
+        self.test_dir = None
+        self.old_sys_path = None
+        self.shell = None
+
+    def get_module(self):
+        module_name = "tmpmod_" + "".join(random.sample(self.filename_chars, 20))
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+        file_name = os.path.join(self.test_dir, module_name + ".py")
+        return module_name, file_name
+
+    def write_file(self, filename, content):
+        """
+        Write a file, and force a timestamp difference of at least one second
+
+        Notes
+        -----
+        Python's .pyc files record the timestamp of their compilation
+        with a time resolution of one second.
+
+        Therefore, we need to force a timestamp difference between .py
+        and .pyc, without having the .py file be timestamped in the
+        future, and without changing the timestamp of the .pyc file
+        (because that is stored in the file).  The only reliable way
+        to achieve this seems to be to sleep.
+        """
+        content = textwrap.dedent(content)
+        # Sleep one second + eps
+        time.sleep(1.05)
+
+        # Write
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    def new_module(self, code):
+        code = textwrap.dedent(code)
+        mod_name, mod_fn = self.get_module()
+        with open(mod_fn, "w", encoding="utf-8") as f:
+            f.write(code)
+        return mod_name, mod_fn
+
+
+# -----------------------------------------------------------------------------
+# Test automatic reloading
+# -----------------------------------------------------------------------------
+
+
+def pickle_get_current_class(obj):
+    """
+    Original issue comes from pickle; hence the name.
+    """
+    name = obj.__class__.__name__
+    module_name = getattr(obj, "__module__", None)
+    obj2 = sys.modules[module_name]
+    for subpath in name.split("."):
+        obj2 = getattr(obj2, subpath)
+    return obj2
+
+
+class TestAutoreload(Fixture):
+    def test_reload_enums(self):
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                                from enum import Enum
+                                class MyEnum(Enum):
+                                    A = 'A'
+                                    B = 'B'
+                            """
+            )
+        )
+        self.shell.magic_autoreload("2")
+        self.shell.magic_aimport(mod_name)
+        self.write_file(
+            mod_fn,
+            textwrap.dedent(
+                """
+                                from enum import Enum
+                                class MyEnum(Enum):
+                                    A = 'A'
+                                    B = 'B'
+                                    C = 'C'
+                            """
+            ),
+        )
+        with tt.AssertNotPrints(
+            ("[autoreload of %s failed:" % mod_name), channel="stderr"
+        ):
+            self.shell.run_code("pass")  # trigger another reload
+
+    def test_reload_class_type(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            """
+            class Test():
+                def meth(self):
+                    return "old"
+        """
+        )
+        assert "test" not in self.shell.ns
+        assert "result" not in self.shell.ns
+
+        self.shell.run_code("from %s import Test" % mod_name)
+        self.shell.run_code("test = Test()")
+
+        self.write_file(
+            mod_fn,
+            """
+            class Test():
+                def meth(self):
+                    return "new"
+        """,
+        )
+
+        test_object = self.shell.ns["test"]
+
+        # important to trigger autoreload logic !
+        self.shell.run_code("pass")
+
+        test_class = pickle_get_current_class(test_object)
+        assert isinstance(test_object, test_class)
+
+        # extra check.
+        self.shell.run_code("import pickle")
+        self.shell.run_code("p = pickle.dumps(test)")
+
+    def test_reload_class_attributes(self):
+        self.shell.magic_autoreload("2")
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                                class MyClass:
+
+                                    def __init__(self, a=10):
+                                        self.a = a
+                                        self.b = 22 
+                                        # self.toto = 33
+
+                                    def square(self):
+                                        print('compute square')
+                                        return self.a*self.a
+                            """
+            )
+        )
+        self.shell.run_code("from %s import MyClass" % mod_name)
+        self.shell.run_code("first = MyClass(5)")
+        self.shell.run_code("first.square()")
+        with self.assertRaises(AttributeError):
+            self.shell.run_code("first.cube()")
+        with self.assertRaises(AttributeError):
+            self.shell.run_code("first.power(5)")
+        self.shell.run_code("first.b")
+        with self.assertRaises(AttributeError):
+            self.shell.run_code("first.toto")
+
+        # remove square, add power
+
+        self.write_file(
+            mod_fn,
+            textwrap.dedent(
+                """
+                            class MyClass:
+
+                                def __init__(self, a=10):
+                                    self.a = a
+                                    self.b = 11
+
+                                def power(self, p):
+                                    print('compute power '+str(p))
+                                    return self.a**p
+                            """
+            ),
+        )
+
+        self.shell.run_code("second = MyClass(5)")
+
+        for object_name in {"first", "second"}:
+            self.shell.run_code(f"{object_name}.power(5)")
+            with self.assertRaises(AttributeError):
+                self.shell.run_code(f"{object_name}.cube()")
+            with self.assertRaises(AttributeError):
+                self.shell.run_code(f"{object_name}.square()")
+            self.shell.run_code(f"{object_name}.b")
+            self.shell.run_code(f"{object_name}.a")
+            with self.assertRaises(AttributeError):
+                self.shell.run_code(f"{object_name}.toto")
+
+    @skipif_not_numpy
+    def test_comparing_numpy_structures(self):
+        self.shell.magic_autoreload("2")
+        self.shell.run_code("1+1")
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                                import numpy as np
+                                class MyClass:
+                                    a = (np.array((.1, .2)),
+                                         np.array((.2, .3)))
+                            """
+            )
+        )
+        self.shell.run_code("from %s import MyClass" % mod_name)
+        self.shell.run_code("first = MyClass()")
+
+        # change property `a`
+        self.write_file(
+            mod_fn,
+            textwrap.dedent(
+                """
+                                import numpy as np
+                                class MyClass:
+                                    a = (np.array((.3, .4)),
+                                         np.array((.5, .6)))
+                            """
+            ),
+        )
+
+        with tt.AssertNotPrints(
+            ("[autoreload of %s failed:" % mod_name), channel="stderr"
+        ):
+            self.shell.run_code("pass")  # trigger another reload
+
+    def test_autoload_newly_added_objects(self):
+        # All of these fail with %autoreload 2
+        self.shell.magic_autoreload("3")
+        mod_code = """
+        def func1(): pass
+        """
+        mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
+        self.shell.run_code(f"from {mod_name} import *")
+        self.shell.run_code("func1()")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func2()")
+        with self.assertRaises(NameError):
+            self.shell.run_code("t = Test()")
+        with self.assertRaises(NameError):
+            self.shell.run_code("number")
+
+        # ----------- TEST NEW OBJ LOADED --------------------------
+
+        new_code = """
+        def func1(): pass
+        def func2(): pass
+        class Test: pass
+        number = 0
+        from enum import Enum
+        class TestEnum(Enum):
+            A = 'a'
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+
+        # test function now exists in shell's namespace namespace
+        self.shell.run_code("func2()")
+        # test function now exists in module's dict
+        self.shell.run_code(f"import sys; sys.modules['{mod_name}'].func2()")
+        # test class now exists
+        self.shell.run_code("t = Test()")
+        # test global built-in var now exists
+        self.shell.run_code("number")
+        # test the enumerations gets loaded successfully
+        self.shell.run_code("TestEnum.A")
+
+        # ----------- TEST NEW OBJ CAN BE CHANGED --------------------
+
+        new_code = """
+        def func1(): return 'changed'
+        def func2(): return 'changed'
+        class Test:
+            def new_func(self):
+                return 'changed'
+        number = 1
+        from enum import Enum
+        class TestEnum(Enum):
+            A = 'a'
+            B = 'added'
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+        self.shell.run_code("assert func1() == 'changed'")
+        self.shell.run_code("assert func2() == 'changed'")
+        self.shell.run_code("t = Test(); assert t.new_func() == 'changed'")
+        self.shell.run_code("assert number == 1")
+
+        # ----------- TEST IMPORT FROM MODULE --------------------------
+
+        new_mod_code = """
+        from enum import Enum
+        class Ext(Enum):
+            A = 'ext'
+        def ext_func():
+            return 'ext'
+        class ExtTest:
+            def meth(self):
+                return 'ext'
+        ext_int = 2
+        """
+        new_mod_name, new_mod_fn = self.new_module(textwrap.dedent(new_mod_code))
+        current_mod_code = f"""
+        from {new_mod_name} import *
+        """
+        self.write_file(mod_fn, textwrap.dedent(current_mod_code))
+        self.shell.run_code("assert Ext.A.value == 'ext'")
+        self.shell.run_code("assert ext_func() == 'ext'")
+        self.shell.run_code("t = ExtTest(); assert t.meth() == 'ext'")
+        self.shell.run_code("assert ext_int == 2")
+
+    def test_autoload3_import_Y_as_Z(self):
+        self.shell.magic_autoreload("3")
+        mod_code = """
+        def func1(): pass
+        n = 1
+        """
+        mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
+        self.shell.run_code(f"from {mod_name} import n as foo")
+        self.shell.run_code("foo")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func1()")
+
+        new_code = """
+        n = 100
+        def func2(): pass
+        def func1(): pass
+        m = 5
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+
+        self.shell.run_code("foo")
+        with self.assertRaises(NameError):
+            self.shell.run_code("n")
+
+    def test_autoload3_import_Y_as_Z_overloading(self):
+        self.shell.magic_autoreload("3")
+        mod_code = """
+        def func1(): pass
+        n = 1
+        """
+        mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
+        self.shell.run_code(f"from {mod_name} import n as foo")
+        self.shell.run_code("foo")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func1()")
+
+        new_code = """
+        n = 100
+        def func2(): pass
+        def func1(): pass
+        foo = 45
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+        self.shell.run_code(f"assert foo == 100")
+        self.shell.run_code(f"from {mod_name} import foo")
+        self.shell.run_code(f"assert foo == 45")
+
+    def test_autoload3_normalimport(self):
+        self.shell.magic_autoreload("3")
+        mod_code = """
+        def func1(): pass
+        n = 1
+        """
+        mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
+        self.shell.run_code(f"import {mod_name}")
+        self.shell.run_code(f"{mod_name}.func1()")
+        self.shell.run_code(f"{mod_name}.n")
+
+        new_code = """
+        n = 100
+        def func2(): pass
+        def func1(): pass
+        m = 5
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+
+        self.shell.run_code(f"{mod_name}.func1()")
+        self.shell.run_code(f"{mod_name}.n")
+        self.shell.run_code(f"{mod_name}.func2()")
+        self.shell.run_code(f"{mod_name}.m")
+
+        self.shell.run_code(f"from {mod_name} import n")
+        self.shell.run_code(f"{mod_name}.func1()")
+        self.shell.run_code(f"n")
+
+    def test_autoload3_normalimport_2(self):
+        self.shell.magic_autoreload("3")
+        mod_code = """
+        def func1(): pass
+        n = 1
+        """
+        mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
+        self.shell.run_code(f"from {mod_name} import n")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func1()")
+        self.shell.run_code("n")
+
+        new_code = """
+        n = 100
+        def func2(): pass
+        def func1(): pass
+        m = 5
+        """
+        self.shell.run_code(f"import {mod_name}")
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+        self.shell.run_code(f"{mod_name}.func1()")
+        self.shell.run_code(f"{mod_name}.n")
+        self.shell.run_code(f"{mod_name}.func2()")
+        self.shell.run_code(f"{mod_name}.m")
+        self.shell.run_code(f"n")
+
+    def test_autoload_3_does_not_add_all(self):
+        # Tests that %autoreload 3 does not effectively run from X import *
+        self.shell.magic_autoreload("3")
+        mod_code = """
+        def func1(): pass
+        n = 1
+        """
+        mod_name, mod_fn = self.new_module(textwrap.dedent(mod_code))
+        self.shell.run_code(f"from {mod_name} import n")
+        self.shell.run_code("n")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func()")
+
+        new_code = """
+        n = 1
+        def func2(): pass
+        def func1(): pass
+        m = 5
+        """
+        self.write_file(mod_fn, textwrap.dedent(new_code))
+        self.shell.run_code("n")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func1()")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func2()")
+        with self.assertRaises(NameError):
+            self.shell.run_code("m")
+
+        self.shell.run_code(f"from {mod_name} import m")
+        self.shell.run_code("n")
+        self.shell.run_code("m")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func1()")
+        with self.assertRaises(NameError):
+            self.shell.run_code("func2()")
+
+        self.shell.run_code(f"from {mod_name} import func1,func2")
+        self.shell.run_code("n")
+        self.shell.run_code("m")
+        self.shell.run_code("func1()")
+        self.shell.run_code("func2()")
+
+    def test_verbose_names(self):
+        # Asserts correspondense between original mode names and their verbose equivalents.
+        @dataclass
+        class AutoreloadSettings:
+            check_all: bool
+            enabled: bool
+            autoload_obj: bool
+
+        def gather_settings(mode):
+            self.shell.magic_autoreload(mode)
+            module_reloader = self.shell.auto_magics._reloader
+            return AutoreloadSettings(
+                module_reloader.check_all,
+                module_reloader.enabled,
+                module_reloader.autoload_obj,
+            )
+
+        assert gather_settings("0") == gather_settings("off")
+        assert gather_settings("0") == gather_settings("OFF")  # Case insensitive
+        assert gather_settings("1") == gather_settings("explicit")
+        assert gather_settings("2") == gather_settings("all")
+        assert gather_settings("3") == gather_settings("complete")
+
+        # And an invalid mode name raises an exception.
+        with self.assertRaises(ValueError):
+            self.shell.magic_autoreload("4")
+
+    def test_aimport_parsing(self):
+        # Modules can be included or excluded all in one line.
+        module_reloader = self.shell.auto_magics._reloader
+        self.shell.magic_aimport("os")  # import and mark `os` for auto-reload.
+        assert module_reloader.modules["os"] is True
+        assert "os" not in module_reloader.skip_modules.keys()
+
+        self.shell.magic_aimport("-math")  # forbid autoreloading of `math`
+        assert module_reloader.skip_modules["math"] is True
+        assert "math" not in module_reloader.modules.keys()
+
+        self.shell.magic_aimport(
+            "-os, math"
+        )  # Can do this all in one line; wasn't possible before.
+        assert module_reloader.modules["math"] is True
+        assert "math" not in module_reloader.skip_modules.keys()
+        assert module_reloader.skip_modules["os"] is True
+        assert "os" not in module_reloader.modules.keys()
+
+    def test_autoreload_output(self):
+        self.shell.magic_autoreload("complete")
+        mod_code = """
+        def func1(): pass
+        """
+        mod_name, mod_fn = self.new_module(mod_code)
+        self.shell.run_code(f"import {mod_name}")
+        with tt.AssertPrints("", channel="stdout"):  # no output; this is default
+            self.shell.run_code("pass")
+
+        self.shell.magic_autoreload("complete --print")
+        self.write_file(mod_fn, mod_code)  # "modify" the module
+        with tt.AssertPrints(
+            f"Reloading '{mod_name}'.", channel="stdout"
+        ):  # see something printed out
+            self.shell.run_code("pass")
+
+        self.shell.magic_autoreload("complete -p")
+        self.write_file(mod_fn, mod_code)  # "modify" the module
+        with tt.AssertPrints(
+            f"Reloading '{mod_name}'.", channel="stdout"
+        ):  # see something printed out
+            self.shell.run_code("pass")
+
+        self.shell.magic_autoreload("complete --print --log")
+        self.write_file(mod_fn, mod_code)  # "modify" the module
+        with tt.AssertPrints(
+            f"Reloading '{mod_name}'.", channel="stdout"
+        ):  # see something printed out
+            self.shell.run_code("pass")
+
+        self.shell.magic_autoreload("complete --print --log")
+        self.write_file(mod_fn, mod_code)  # "modify" the module
+        with self.assertLogs(logger="autoreload") as lo:  # see something printed out
+            self.shell.run_code("pass")
+        assert lo.output == [f"INFO:autoreload:Reloading '{mod_name}'."]
+
+        self.shell.magic_autoreload("complete -l")
+        self.write_file(mod_fn, mod_code)  # "modify" the module
+        with self.assertLogs(logger="autoreload") as lo:  # see something printed out
+            self.shell.run_code("pass")
+        assert lo.output == [f"INFO:autoreload:Reloading '{mod_name}'."]
+
+    def _check_smoketest(self, use_aimport=True):
+        """
+        Functional test for the automatic reloader using either
+        '%autoreload 1' or '%autoreload 2'
+        """
+
+        mod_name, mod_fn = self.new_module(
+            """
+x = 9
+
+z = 123  # this item will be deleted
+
+def foo(y):
+    return y + 3
+
+class Baz(object):
+    def __init__(self, x):
+        self.x = x
+    def bar(self, y):
+        return self.x + y
+    @property
+    def quux(self):
+        return 42
+    def zzz(self):
+        '''This method will be deleted below'''
+        return 99
+
+class Bar:    # old-style class: weakref doesn't work for it on Python < 2.7
+    def foo(self):
+        return 1
+"""
+        )
+
+        #
+        # Import module, and mark for reloading
+        #
+        if use_aimport:
+            self.shell.magic_autoreload("1")
+            self.shell.magic_aimport(mod_name)
+            stream = StringIO()
+            self.shell.magic_aimport("", stream=stream)
+            self.assertIn(("Modules to reload:\n%s" % mod_name), stream.getvalue())
+
+            with self.assertRaises(ImportError):
+                self.shell.magic_aimport("tmpmod_as318989e89ds")
+        else:
+            self.shell.magic_autoreload("2")
+            self.shell.run_code("import %s" % mod_name)
+            stream = StringIO()
+            self.shell.magic_aimport("", stream=stream)
+            self.assertTrue(
+                "Modules to reload:\nall-except-skipped" in stream.getvalue()
+            )
+        self.assertIn(mod_name, self.shell.ns)
+
+        mod = sys.modules[mod_name]
+
+        #
+        # Test module contents
+        #
+        old_foo = mod.foo
+        old_obj = mod.Baz(9)
+        old_obj2 = mod.Bar()
+
+        def check_module_contents():
+            self.assertEqual(mod.x, 9)
+            self.assertEqual(mod.z, 123)
+
+            self.assertEqual(old_foo(0), 3)
+            self.assertEqual(mod.foo(0), 3)
+
+            obj = mod.Baz(9)
+            self.assertEqual(old_obj.bar(1), 10)
+            self.assertEqual(obj.bar(1), 10)
+            self.assertEqual(obj.quux, 42)
+            self.assertEqual(obj.zzz(), 99)
+
+            obj2 = mod.Bar()
+            self.assertEqual(old_obj2.foo(), 1)
+            self.assertEqual(obj2.foo(), 1)
+
+        check_module_contents()
+
+        #
+        # Simulate a failed reload: no reload should occur and exactly
+        # one error message should be printed
+        #
+        self.write_file(
+            mod_fn,
+            """
+a syntax error
+""",
+        )
+
+        with tt.AssertPrints(
+            ("[autoreload of %s failed:" % mod_name), channel="stderr"
+        ):
+            self.shell.run_code("pass")  # trigger reload
+        with tt.AssertNotPrints(
+            ("[autoreload of %s failed:" % mod_name), channel="stderr"
+        ):
+            self.shell.run_code("pass")  # trigger another reload
+        check_module_contents()
+
+        #
+        # Rewrite module (this time reload should succeed)
+        #
+        self.write_file(
+            mod_fn,
+            """
+x = 10
+
+def foo(y):
+    return y + 4
+
+class Baz(object):
+    def __init__(self, x):
+        self.x = x
+    def bar(self, y):
+        return self.x + y + 1
+    @property
+    def quux(self):
+        return 43
+
+class Bar:    # old-style class
+    def foo(self):
+        return 2
+""",
+        )
+
+        def check_module_contents():
+            self.assertEqual(mod.x, 10)
+            self.assertFalse(hasattr(mod, "z"))
+
+            self.assertEqual(old_foo(0), 4)  # superreload magic!
+            self.assertEqual(mod.foo(0), 4)
+
+            obj = mod.Baz(9)
+            self.assertEqual(old_obj.bar(1), 11)  # superreload magic!
+            self.assertEqual(obj.bar(1), 11)
+
+            self.assertEqual(old_obj.quux, 43)
+            self.assertEqual(obj.quux, 43)
+
+            self.assertFalse(hasattr(old_obj, "zzz"))
+            self.assertFalse(hasattr(obj, "zzz"))
+
+            obj2 = mod.Bar()
+            self.assertEqual(old_obj2.foo(), 2)
+            self.assertEqual(obj2.foo(), 2)
+
+        self.shell.run_code("pass")  # trigger reload
+        check_module_contents()
+
+        #
+        # Another failure case: deleted file (shouldn't reload)
+        #
+        os.unlink(mod_fn)
+
+        self.shell.run_code("pass")  # trigger reload
+        check_module_contents()
+
+        #
+        # Disable autoreload and rewrite module: no reload should occur
+        #
+        if use_aimport:
+            self.shell.magic_aimport("-" + mod_name)
+            stream = StringIO()
+            self.shell.magic_aimport("", stream=stream)
+            self.assertTrue(("Modules to skip:\n%s" % mod_name) in stream.getvalue())
+
+            # This should succeed, although no such module exists
+            self.shell.magic_aimport("-tmpmod_as318989e89ds")
+        else:
+            self.shell.magic_autoreload("0")
+
+        self.write_file(
+            mod_fn,
+            """
+x = -99
+""",
+        )
+
+        self.shell.run_code("pass")  # trigger reload
+        self.shell.run_code("pass")
+        check_module_contents()
+
+        #
+        # Re-enable autoreload: reload should now occur
+        #
+        if use_aimport:
+            self.shell.magic_aimport(mod_name)
+        else:
+            self.shell.magic_autoreload("")
+
+        self.shell.run_code("pass")  # trigger reload
+        self.assertEqual(mod.x, -99)
+
+    def test_smoketest_aimport(self):
+        self._check_smoketest(use_aimport=True)
+
+    def test_smoketest_autoreload(self):
+        self._check_smoketest(use_aimport=False)
+
+    def test_autoreload_with_user_defined_In_variable(self):
+        """
+        Check that autoreload works when the user has defined an In variable.
+        """
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                                def hello():
+                                    return "Hello"
+                            """
+            )
+        )
+        self.shell.magic_autoreload("2")
+        self.shell.run_code(f"import {mod_name}")
+        self.shell.run_code(f"res = {mod_name}.hello()")
+        assert self.shell.user_ns["res"] == "Hello"
+
+        self.shell.user_ns["In"] = "some_value"
+
+        self.write_file(
+            mod_fn,
+            textwrap.dedent(
+                """
+                                def hello():
+                                    return "Changed"
+                            """
+            ),
+        )
+
+        self.shell.run_code(f"res = {mod_name}.hello()")
+        assert self.shell.user_ns["res"] == "Changed"
+
+    def test_import_from_tracker_conflict_resolution(self):
+        """Test that ImportFromTracker properly handles import conflicts"""
+        from IPython.extensions.autoreload import ImportFromTracker
+        from unittest.mock import Mock
+
+        # Create a test module with both 'foo' and 'bar' attributes
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                foo = "original_foo"
+                bar = "original_bar"
+                """
+            )
+        )
+
+        # Mock the module in sys.modules instead of actually importing it
+        mock_module = Mock()
+        mock_module.foo = "original_foo"
+        mock_module.bar = "original_bar"
+        sys.modules[mod_name] = mock_module
+
+        try:
+            # Create a tracker
+            tracker = ImportFromTracker({}, {})
+
+            # Test case 1: "from x import y as z" then "from x import z"
+            # First import: from mod_name import foo as bar
+            tracker.add_import(mod_name, "foo", "bar")
+
+            # Verify initial state
+            assert mod_name in tracker.imports_froms
+            assert "foo" in tracker.imports_froms[mod_name]
+            assert tracker.symbol_map[mod_name]["foo"] == ["bar"]
+
+            # Second import: from mod_name import bar (conflicts with previous "bar")
+            tracker.add_import(mod_name, "bar", "bar")
+
+            # The second import should take precedence since "bar" is a valid import
+            assert "bar" in tracker.imports_froms[mod_name]
+            assert "foo" not in tracker.imports_froms[mod_name]  # Should be removed
+            assert tracker.symbol_map[mod_name]["bar"] == ["bar"]
+            assert "foo" not in tracker.symbol_map[mod_name]  # Should be removed
+        finally:
+            # Clean up sys.modules
+            if mod_name in sys.modules:
+                del sys.modules[mod_name]
+
+    def test_import_from_tracker_reverse_conflict(self):
+        """Test the reverse case: 'from x import z' then 'from x import y as z'"""
+        from IPython.extensions.autoreload import ImportFromTracker
+        from unittest.mock import Mock
+
+        # Create a test module
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                foo = "original_foo"
+                bar = "original_bar"
+                """
+            )
+        )
+
+        # Mock the module in sys.modules instead of actually importing it
+        mock_module = Mock()
+        mock_module.foo = "original_foo"
+        mock_module.bar = "original_bar"
+        sys.modules[mod_name] = mock_module
+
+        try:
+            # Create a tracker
+            tracker = ImportFromTracker({}, {})
+
+            # First import: from mod_name import bar
+            tracker.add_import(mod_name, "bar", "bar")
+
+            # Verify initial state
+            assert "bar" in tracker.imports_froms[mod_name]
+            assert tracker.symbol_map[mod_name]["bar"] == ["bar"]
+
+            # Second import: from mod_name import foo as bar (conflicts with previous "bar")
+            tracker.add_import(mod_name, "foo", "bar")
+
+            # The second import should take precedence since "foo" is a valid import
+            assert "foo" in tracker.imports_froms[mod_name]
+            assert "bar" not in tracker.imports_froms[mod_name]  # Should be removed
+            assert tracker.symbol_map[mod_name]["foo"] == ["bar"]
+            assert "bar" not in tracker.symbol_map[mod_name]  # Should be removed
+        finally:
+            # Clean up sys.modules
+            if mod_name in sys.modules:
+                del sys.modules[mod_name]
+
+    def test_import_from_tracker_invalid_import(self):
+        """Test that ImportFromTracker works correctly with the post-execution approach"""
+        from IPython.extensions.autoreload import ImportFromTracker
+
+        # Create a test module with only 'foo' attribute
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                foo = "original_foo"
+                """
+            )
+        )
+
+        # Create a tracker
+        tracker = ImportFromTracker({}, {})
+
+        # First import: from mod_name import foo as bar
+        # Since we're simulating post-execution, this is a valid import
+        tracker.add_import(mod_name, "foo", "bar")
+
+        # Verify initial state
+        assert "foo" in tracker.imports_froms[mod_name]
+        assert tracker.symbol_map[mod_name]["foo"] == ["bar"]
+
+        # Second import: from mod_name import foo2 as bar (conflicting import)
+        # In the new approach, this would only be called if the import actually succeeded
+        # So this represents a case where the module was updated to have foo2
+        tracker.add_import(mod_name, "foo2", "bar")
+
+        # The new mapping should replace the old one since it's more recent
+        assert "foo2" in tracker.imports_froms[mod_name]
+        assert "foo" not in tracker.imports_froms[mod_name]  # Should be replaced
+        assert tracker.symbol_map[mod_name]["foo2"] == ["bar"]
+        assert "foo" not in tracker.symbol_map[mod_name]  # Should be replaced
+
+    def test_import_from_tracker_integration(self):
+        """Test the integration of ImportFromTracker with autoreload"""
+        # Create a test module
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                foo = "original_foo"
+                bar = "original_bar"
+                """
+            )
+        )
+
+        # Enable autoreload mode 3 (complete)
+        self.shell.magic_autoreload("3")
+
+        # First import: from mod_name import foo as bar
+        # This will naturally load the module into sys.modules
+        self.shell.run_code(f"from {mod_name} import foo as bar")
+        assert self.shell.user_ns["bar"] == "original_foo"
+
+        # Second import: from mod_name import bar (should override the alias)
+        # The module is already in sys.modules, so this should work with our validation
+        self.shell.run_code(f"from {mod_name} import bar")
+        assert self.shell.user_ns["bar"] == "original_bar"  # Should now be the real bar
+
+        # Modify the module
+        self.write_file(
+            mod_fn,
+            textwrap.dedent(
+                """
+                foo = "modified_foo"
+                bar = "modified_bar"
+                """
+            ),
+        )
+
+        # Trigger autoreload by running any code
+        self.shell.run_code("x = 1")
+
+        # The 'bar' variable should now contain the modified 'bar', not 'foo'
+        assert self.shell.user_ns["bar"] == "modified_bar"
+
+    def test_autoreload3_double_import(self):
+        """Test the integration of ImportFromTracker with autoreload"""
+        # Create a test module
+        mod_name, mod_fn = self.new_module(
+            textwrap.dedent(
+                """
+                foo = "original_foo"
+                bar = "original_bar"
+                """
+            )
+        )
+        # Enable autoreload mode 3 (complete)
+        self.shell.magic_autoreload("3")
+
+        # First import: from mod_name import foo as bar
+        # This will naturally load the module into sys.modules
+        self.shell.run_code(f"from {mod_name} import foo as bar")
+        self.shell.run_code(f"from {mod_name} import foo")
+        assert self.shell.user_ns["bar"] == "original_foo"
+        assert self.shell.user_ns["foo"] == "original_foo"
+        # Modify the module
+        self.write_file(
+            mod_fn,
+            textwrap.dedent(
+                """
+                foo = "modified_foo"
+                bar = "modified_bar"
+                """
+            ),
+        )
+        self.shell.run_code("pass")
+        assert self.shell.user_ns["bar"] == "modified_foo"
+        assert self.shell.user_ns["foo"] == "modified_foo"
+
+    def test_import_from_tracker_unloaded_module(self):
+        """Test that ImportFromTracker works with the post-execution approach"""
+        from IPython.extensions.autoreload import ImportFromTracker
+
+        # With the new approach, we only track imports after successful execution
+        # So even if a module isn't initially in sys.modules, if an import executed
+        # successfully, we should track it
+
+        fake_mod_name = "test_module_12345"
+
+        # Create a tracker
+        tracker = ImportFromTracker({}, {})
+
+        # Simulate an import that executed successfully
+        # (In reality, this would only be called if the import actually succeeded)
+        tracker.add_import(fake_mod_name, "some_attr", "some_name")
+
+        # Since the import "succeeded", it should be tracked
+        assert fake_mod_name in tracker.imports_froms
+        assert fake_mod_name in tracker.symbol_map
+        assert "some_attr" in tracker.imports_froms[fake_mod_name]
+        assert tracker.symbol_map[fake_mod_name]["some_attr"] == ["some_name"]
+
+        # Simulate a conflict scenario - another import succeeded
+        tracker.add_import(fake_mod_name, "another_attr", "some_name")
+
+        # The newer import should replace the older one
+        assert fake_mod_name in tracker.imports_froms
+        assert fake_mod_name in tracker.symbol_map
+        assert "another_attr" in tracker.imports_froms[fake_mod_name]
+        assert (
+            "some_attr" not in tracker.imports_froms[fake_mod_name]
+        )  # Should be replaced
+        assert tracker.symbol_map[fake_mod_name]["another_attr"] == ["some_name"]
+        assert (
+            "some_attr" not in tracker.symbol_map[fake_mod_name]
+        )  # Should be replaced
+
+    def test_import_from_tracker_multiple_resolved_names(self):
+        """Test that the same original name can map to multiple resolved names"""
+        from IPython.extensions.autoreload import ImportFromTracker
+
+        # Create a tracker
+        tracker = ImportFromTracker({}, {})
+
+        fake_mod_name = "test_module_abc"
+
+        # Simulate: from test_module_abc import foo as bar
+        tracker.add_import(fake_mod_name, "foo", "bar")
+
+        # Verify initial state
+        assert "foo" in tracker.imports_froms[fake_mod_name]
+        assert tracker.symbol_map[fake_mod_name]["foo"] == ["bar"]
+
+        # Simulate: from test_module_abc import foo (same original name, different resolved name)
+        tracker.add_import(fake_mod_name, "foo", "foo")
+
+        # Both resolved names should be tracked for the same original name
+        assert "foo" in tracker.imports_froms[fake_mod_name]
+        assert set(tracker.symbol_map[fake_mod_name]["foo"]) == {"bar", "foo"}
diff --git a/tools/alldeps/Makefile b/tools/alldeps/Makefile
deleted file mode 100644
index 8076acd83bf..00000000000
--- a/tools/alldeps/Makefile
+++ /dev/null
@@ -1,130 +0,0 @@
-# Simple makefile to rapidly deploy IPython with all its dependencies.
-
-# Configuration section.  The version numbers and paths declared here may
-# change with each release.
-
-# IPython version
-IPYTHON_VER=0.9.1
-
-# Declare here version numbers of all the dependencies
-PYOPENSSL_VER=0.6
-ZOPE_INTERFACE_VER=3.4.1
-TWISTED_VER=8.1.0
-FOOLSCAP_VER=0.3.1
-NOSE_VER=0.10.3
-
-# Repository URLs for all packages.  Make sure these are correct for each
-# release, since projects may change paths!
-IPYTHON_REPO=http://ipython.scipy.org/dist
-PYOPENSSL_REPO=http://downloads.sourceforge.net/pyopenssl
-ZOPE_INTERFACE_REPO=http://pypi.python.org/packages/source/z/zope.interface
-TWISTED_REPO=http://tmrc.mit.edu/mirror/twisted/Twisted/8.1
-FOOLSCAP_REPO=http://foolscap.lothar.com/releases
-NOSE_REPO=http://somethingaboutorange.com/mrl/projects/nose
-
-#-----------------------------------------------------------------------------
-# Main code begins.  There shouldn't be much to change here with each release.
-#
-
-# Hand-written files to ship in self-contained tarball
-SOURCES=pkginstall pkginstall.cfg Makefile README.txt README.html
-
-# Versions of tarballs we ship
-IPYTHON=ipython-$(IPYTHON_VER).tar.gz
-IP_ALLDEPS=ipython-alldeps-$(IPYTHON_VER)
-
-PYOPENSSL=pyOpenSSL-$(PYOPENSSL_VER).tar.gz
-ZOPE_INTERFACE=zope.interface-$(ZOPE_INTERFACE_VER).tar.gz
-NOSE=nose-$(NOSE_VER).tar.gz
-TWISTED=Twisted-$(TWISTED_VER).tar.bz2
-FOOLSCAP=foolscap-$(FOOLSCAP_VER).tar.gz
-
-TARBALLS=$(PYOPENSSL) $(ZOPE_INTERFACE) $(TWISTED) $(FOOLSCAP) \
-$(NOSE) $(IPYTHON)
-
-# URLs for downloads
-
-#-----------------------------------------------------------------------------
-# Target declaration
-#
-
-# Targets to install, in correct dependency order
-install: pyopenssl zope.interface twisted foolscap nose ipython
-	echo
-	echo "IPython Installation finished."
-	echo "You can now run the ipython test suite by running:"
-	echo "iptest"
-	echo "If all tests pass, you can delete this entire directory."
-	echo
-
-# Download targets
-download: $(TARBALLS)
-
-$(IPYTHON):
-	wget $(IPYTHON_REPO)/$(IPYTHON)
-
-$(PYOPENSSL):
-	wget $(PYOPENSSL_REPO)/$(PYOPENSSL)
-
-$(ZOPE_INTERFACE):
-	wget $(ZOPE_INTERFACE_REPO)/$(ZOPE_INTERFACE)
-
-$(TWISTED):
-	wget $(TWISTED_REPO)/$(TWISTED)
-
-$(FOOLSCAP):
-	wget $(FOOLSCAP_REPO)/$(FOOLSCAP)
-
-$(NOSE):
-	wget $(NOSE_REPO)/$(NOSE)
-
-
-# The calls to pkginstall must use the actual Python package name
-nose: $(NOSE)
-	./pkginstall nose
-
-zope.interface: $(ZOPE_INTERFACE)
-	./pkginstall zope.interface zope
-
-pyopenssl: $(PYOPENSSL)
-	./pkginstall pyOpenSSL OpenSSL
-
-twisted: $(TWISTED)
-	./pkginstall Twisted
-
-foolscap: $(FOOLSCAP)
-	./pkginstall foolscap
-
-ipython: $(IPYTHON)
-	./pkginstall ipython IPython
-
-# Distribution targets
-dist: $(IP_ALLDEPS).tar
-
-$(IP_ALLDEPS).tar: download readme
-	-mkdir $(IP_ALLDEPS)
-	-ln $(SOURCES) $(TARBALLS) $(IP_ALLDEPS)/
-	tar cf $(IP_ALLDEPS).tar $(IP_ALLDEPS)
-	rm -rf $(IP_ALLDEPS)
-
-readme: README.html
-
-README.html: README.txt
-	rst2html README.txt > README.html
-
-# Auxiliary targets
-upload: dist
-	rsync -e ssh -av README.html $(IP_ALLDEPS).tar \
-	ipython@ipython.scipy.org:www/dist/alldeps
-
-clean:
-	ls -p | grep /$ | xargs rm -rf
-	rm -f $(IP_ALLDEPS)* *~
-
-distclean: clean
-	rm -f $(TARBALLS)
-	rm README.html
-
-info:
-	echo "TARBALLS"
-	echo $(TARBALLS)
diff --git a/tools/alldeps/README.txt b/tools/alldeps/README.txt
deleted file mode 100644
index f40ec7a6e86..00000000000
--- a/tools/alldeps/README.txt
+++ /dev/null
@@ -1,109 +0,0 @@
-===========================================================
- Self-contained IPython installation with all dependencies
-===========================================================
-
-This is a self-contained source distribution of IPython with all its
-*non-graphical* dependencies, that installs in a single ``make`` call to your
-home directory (by default) or any location of your choice.
-
-This distribution is meant for developer-type usage in Unix environments, it is
-*not* an easy way to get IPython working on Windows, since it assumes the
-presence of a working compiler and development tools.
-
-Currently, the distribution contains::
-
-  ipython-0.9.1.tar.gz
-  pyOpenSSL-0.6.tar.gz
-  zope.interface-3.4.1.tar.gz
-  Twisted-8.1.0.tar.bz2
-  foolscap-0.3.1.tar.gz
-  nose-0.10.3.tar.gz
-
-
-Usage
-=====
-
-Download the single tarball where this README file lives and unpack it.  If
-your system is already configured as described below, these lines will do the
-whole job::
-
-    wget http://ipython.scipy.org/dist/alldeps/ipython-alldeps-0.9.1.tar
-    tar xf ipython-alldeps-0.9.1.tar
-    cd ipython-alldeps-0.9.1
-    make
-
-If all goes well, then just type::
-
-    iptest
-
-to run IPython's test suite.
-
-    
-It is meant to be used in an environment where you have your ``$PATH``,
-``$PYTHONPATH``, etc variables properly configured, so that the installation of
-packages can be made with (using ``~/usr/local`` as an example)::
-
-    python setup.py install --prefix=~/usr/local
-
-For an explanation of how to do this, see below.
-
-You can configure the default prefix used by editing the file
-``pkginstall.cfg``, where you can also override the python version used for the
-process.  If your system is configured in this manner, you can simply type::
-
-    make
-
-and this will build and install all of IPython's non-graphical dependencies on
-your system, assuming you have Python, a compiler, the Python headers and the
-SSL headers available.
-
-
-.. _environment_configuration:
-
-Environment configuration
-=========================
-
-Below is an example of what to put in your ``~/.bashrc`` file to configure your
-environment as described in this document, in a reasonably portable manner that
-takes 64-bit operating systems into account::
-
-  # For processor dependent config
-  MACHINE=$(uname -m)
-
-  # Python version information
-  PYVER=$(python -ESV 2>&1)
-  PYVER_MINOR=${PYVER#Python }
-  PYVER_MAJOR=${PYVER_MINOR:0:3}
-
-  function export_paths {
-      # Export useful paths based on a common prefix
-
-      # Input: a path prefix
-
-      local prefix=$1
-      local pp
-      local lp
-      local pypath=python${PYVER_MAJOR}/site-packages
-
-      # Compute paths with 64-bit specifics
-      if [[ $MACHINE == "x86_64" ]]; then
-	  lp=$prefix/lib64:$prefix/lib
-	  pp=$prefix/lib64/$pypath:$prefix/lib/$pypath
-      else	
-	  lp=$prefix/lib
-	  pp=$prefix/lib/$pypath
-      fi
-
-      # Set paths based on given prefix
-      export PATH=$prefix/bin:$PATH
-      export CPATH=$prefix/include:$CPATH
-      export LD_LIBRARY_PATH=$lp:$LD_LIBRARY_PATH
-      export LIBRARY_PATH=$lp:$LIBRARY_PATH
-      export PYTHONPATH=$pp:$PYTHONPATH
-  }
-
-  # Actually call the export function to set the paths.  If you want more than
-  # one such prefix, note that the call *prepends* the new prefix to the
-  # existing paths, so later calls take priority.
-
-  export_paths $HOME/usr/local
diff --git a/tools/alldeps/pkginstall b/tools/alldeps/pkginstall
deleted file mode 100755
index 14a731a2d0c..00000000000
--- a/tools/alldeps/pkginstall
+++ /dev/null
@@ -1,119 +0,0 @@
-#!/bin/bash
-#
-# Simple installation shell script for Python packages.
-#
-# Usage:
-#   pkginstall PAKPREFIX [PYPACKAGE]
-#
-# PAKPREFIX: prefix of the package as distributed in the tarball.
-#
-# PYPACKAGE: name of the Python package as it will end up installed.  If not
-# given, it defaults to PAKPREFIX.
-#
-
-#-----------------------------------------------------------------------------
-# Process command-line args
-#
-PAKPREFIX=$1
-PYPACKAGE=${2:-$PAKPREFIX}
-
-#-----------------------------------------------------------------------------
-# Configure main variables
-#
-# Defaults for variables that the .cfg file may override.
-PYTHON_DEFAULT=python
-PREFIX_DEFAULT=$HOME/usr/local
-
-# Read config file which may declare user values for these variables.
-source ./pkginstall.cfg
-
-# Set the variables we'll actually use, either from the config file or from our
-# defaults.
-PYTHON=${PYTHON-${PYTHON_DEFAULT}}
-PREFIX=${PREFIX-${PREFIX_DEFAULT}}
-
-#-----------------------------------------------------------------------------
-# 'Main' code begins
-#
-
-# Find the actual python executable path
-PYTHONX=$(which $PYTHON)
-if [[ ! -x $PYTHONX ]]; then
-    echo "ERROR: no python executable found at given path: $PYTHON"
-    echo "Aborting."
-    exit 1
-fi    
-
-# Python version information.  PYTHONV holds a versioned string used to build
-# the site-packages path for the actual Python version we'll use.
-PYVER=$($PYTHONX -ESV 2>&1)
-PYVER_MINOR=${PYVER#Python }
-PYVER_MAJOR=${PYVER_MINOR:0:3}
-PYTHONV=python${PYVER_MAJOR}
-
-# Set prefixes and other variables for the installation path.
-SITEPKG=${PREFIX}/lib/${PYTHONV}/site-packages
-SITEPKG64=${PREFIX}/lib64/${PYTHONV}/site-packages
-
-# User diagnostics of current config
-echo "Configuration:"
-echo "  PYTHON   : $PYTHON"
-echo "  PYTHONX  : $PYTHONX"
-echo "  PREFIX   : $PREFIX"
-echo "  SITEPKG  : $SITEPKG"
-echo "  SITEPKG64: $SITEPKG64"
-
-# Find tarball
-tarball=$(ls *$PAKPREFIX*.tar.*)
-
-if [[ -z $tarball ]]; then
-    echo "ERROR: tarball not found for $PYPACKAGE"
-    exit 1
-fi
-
-# Figure out the name of the directory and compression format to use to unpack
-pakdir=$(echo $tarball | awk -F '.tar.' '{print $1}')
-tarfmt=$(echo $tarball | awk -F '.tar.' '{print $2}')
-
-if [[ $tarfmt == "gz" ]]; then
-    tarflag="z"
-else
-    tarflag="j"
-fi
-
-# Unpack the tarball if needed
-if [[ ! -d $pakdir ]]; then
-    echo "Unpacking tarball: $tarball"
-    tar -x -${tarflag} -f $tarball
-
-        if [[ ! -d $pakdir ]]; then
-	echo "Tarball $tarball unpacked to unexpected path, aborting"
-	exit 1
-    fi
-fi
-
-# Remove existing ${PYPACKAGE} to make sure the build doesn't pick up spurious
-# things.  We don't touch the bin/ dir or anything else because it's hard to
-# know what goes there in advance.  But this should prevent most serious
-# problems.
-rm -rf $SITEPKG/${PYPACKAGE}
-rm -rf $SITEPKG/${PYPACKAGE}*.egg
-rm -rf $SITEPKG/${PYPACKAGE}*.egg-info
-
-rm -rf $SITEPKG64/${PYPACKAGE}
-rm -rf $SITEPKG64/${PYPACKAGE}*.egg
-rm -rf $SITEPKG64/${PYPACKAGE}*.egg-info
-
-# Make/install phase
-
-# Set python search path correctly
-export PYTHONPATH=$SITEPKG:$SITEPKG64:$PYTHONPATH
-
-# Ensure install dirs exist
-mkdir -p $SITEPKG
-mkdir -p $SITEPKG64
-
-cd ${pakdir}
-rm -rf build dist
-$PYTHONX setup.py clean
-time $PYTHONX setup.py install --prefix=$PREFIX
diff --git a/tools/alldeps/pkginstall.cfg b/tools/alldeps/pkginstall.cfg
deleted file mode 100644
index 34e2f2dae86..00000000000
--- a/tools/alldeps/pkginstall.cfg
+++ /dev/null
@@ -1,27 +0,0 @@
-# -*- sh -*-
-#
-# Configuration for the pkginstall script.
-# This script uses bash syntax, as it will be sourced by a bash script.
-
-# Uncomment and set the variables you want, otherwise pkginstall has sensible
-# defaults predefined.  These can also be declared either as environment
-# variables (which can be done by the makefile calling this script).
-
-#-----------------------------------------------------------------------------
-#
-# Executable for Python.
-#
-# You can set this to an explicit full path if you don't want the default
-# (simply 'python') to be the version used to install this package.
-
-#PYTHON=python
-
-#-----------------------------------------------------------------------------
-#
-# Default prefix.
-#
-# This should be a valid input the setup.py script as the --prefix argument.
-# That is, your $PYTHONPATH should contain $PREFIX/lib/pythonX.Y/site-packages,
-# your $PATH should contain $PREFIX/bin, etc.
-
-#PREFIX=$HOME/usr/local
diff --git a/tools/autoformat_file b/tools/autoformat_file
new file mode 100755
index 00000000000..3b6b71d3007
--- /dev/null
+++ b/tools/autoformat_file
@@ -0,0 +1,46 @@
+#!/bin/bash
+
+set -ueo pipefail
+FILE=$1
+
+echo "will update $FILE"
+
+echo $LINENO $?
+pyupgrade --py36-plus --exit-zero-even-if-changed $FILE
+
+echo $LINENO $?
+git commit -am"Apply pyupgrade to $FILE
+
+    pyupgrade --py36-plus $FILE
+
+To ignore those changes when using git blame see the content of
+.git-blame-ignore-revs"
+
+HASH=$(git rev-parse HEAD)
+
+echo "$HASH # apply pyupgrade to $FILE" >> .git-blame-ignore-revs
+
+git commit -am'Update .git-blame-ignore-revs with previous commit'
+
+#####
+
+black --target-version py36 $FILE
+
+
+git commit -am"Apply black to $FILE
+
+    black --target-version py36 $FILE
+
+To ignore those changes when using git blame see the content of
+.git-blame-ignore-revs"
+
+HASH=$(git rev-parse HEAD)
+
+echo "$HASH # apply black to $FILE" >> .git-blame-ignore-revs
+
+git commit -am'Update .git-blame-ignore-revs with previous commit'
+
+echo 
+echo "Updating, reformatting and adding to .git-blame-ignore-revs successful"
+
+
diff --git a/tools/build_release b/tools/build_release
index 1a9c830d42a..f5d99eec1cf 100755
--- a/tools/build_release
+++ b/tools/build_release
@@ -1,35 +1,21 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """IPython release build script.
 """
-from toollib import *
+import os
+import sys
 
-# Get main ipython dir, this will raise if it doesn't pass some checks
-ipdir = get_ipdir()
-cd(ipdir)
+from toollib import sh, get_ipdir, cd, build_command
 
-# Load release info
-execfile(pjoin('IPython','core','release.py'))
+def build_release():
 
-# Check that everything compiles
-compile_tree()
+    # Get main ipython dir, this will raise if it doesn't pass some checks
+    ipdir = get_ipdir()
+    cd(ipdir)
 
-# Cleanup
-for d in ['build','dist',pjoin('docs','build'),pjoin('docs','dist'),
-          pjoin('docs','source','api','generated')]:
-    if os.path.isdir(d):
-        remove_tree(d)
+    # Build source and binary distros
+    sh(build_command)
+    # don't try to change, xz, bz2 deprecated.
+    sh(' '.join([sys.executable, 'tools/retar.py', 'dist/*.gz']))
 
-# Build source and binary distros
-sh('./setup.py sdist --formats=gztar,zip')
-
-# Build eggs
-sh('python2.6 ./setupegg.py bdist_egg')
-
-# Call the windows build separately, so that the extra Windows scripts don't
-# get pulled into Unix builds (setup.py has code which checks for
-# bdist_wininst)
-sh("python setup.py bdist_wininst --install-script=ipython_win_post_install.py")
-
-# Change name so retarded Vista runs the installer correctly
-sh("rename 's/linux-i686/win32-setup/' dist/*.exe")
-sh("rename 's/linux-x86_64/win32-setup/' dist/*.exe")
+if __name__ == '__main__':
+    build_release()
diff --git a/tools/check_sources.py b/tools/check_sources.py
old mode 100755
new mode 100644
index 5b64c6e326f..333d2a746eb
--- a/tools/check_sources.py
+++ b/tools/check_sources.py
@@ -33,22 +33,22 @@
         rets.append(f)
         
     if errs:
-        print "%3s" % errs, f
+        print("%3s" % errs, f)
 
     if 't' in errs and full_report_tabs:
         for ln,line in enumerate(f.lines()):
             if '\t' in line:
-                print 'TAB:',ln,':',line,
+                print('TAB:',ln,':',line, end=' ')
 
     if 'r' in errs and full_report_rets:
         for ln,line in enumerate(open(f.abspath(),'rb')):
             if '\r' in line:
-                print 'RET:',ln,':',line,
+                print('RET:',ln,':',line, end=' ')
 
 # Summary at the end, to call cleanup tools if necessary
 if tabs:
-    print 'Hard tabs found. These can be cleaned with untabify:'
-    for f in tabs: print f,
+    print('Hard tabs found. These can be cleaned with untabify:')
+    for f in tabs: print(f, end=' ')
 if rets:
-    print 'Carriage returns (\\r) found in:'
-    for f in rets: print f,
+    print('Carriage returns (\\r) found in:')
+    for f in rets: print(f, end=' ')
diff --git a/tools/configure-git-blame-ignore-revs.bat b/tools/configure-git-blame-ignore-revs.bat
new file mode 100644
index 00000000000..3fc3c01dcf8
--- /dev/null
+++ b/tools/configure-git-blame-ignore-revs.bat
@@ -0,0 +1,10 @@
+rem Other config options for blame are markUnblamables and markIgnoredLines.
+rem See docs for more details:
+rem https://git-scm.com/docs/git-config#Documentation/git-config.txt-blameignoreRevsFile
+
+rem Uncomment below and rerun script to enable an option.
+rem git config blame.markIgnoredLines
+rem git config blame.markUnblamables
+
+git config blame.ignoreRevsFile .git-blame-ignore-revs
+git config --get blame.ignoreRevsFile
diff --git a/tools/configure-git-blame-ignore-revs.sh b/tools/configure-git-blame-ignore-revs.sh
new file mode 100755
index 00000000000..390d1877855
--- /dev/null
+++ b/tools/configure-git-blame-ignore-revs.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+# Other config options for blame are markUnblamables and markIgnoredLines.
+# See docs for more details:
+# https://git-scm.com/docs/git-config#Documentation/git-config.txt-blameignoreRevsFile
+
+# Uncomment below and rerun script to enable an option.
+# git config blame.markIgnoredLines
+# git config blame.markUnblamables
+
+git config blame.ignoreRevsFile .git-blame-ignore-revs
+git config --get blame.ignoreRevsFile
diff --git a/tools/fixup_whats_new_pr.py b/tools/fixup_whats_new_pr.py
new file mode 100644
index 00000000000..59b1934eaea
--- /dev/null
+++ b/tools/fixup_whats_new_pr.py
@@ -0,0 +1,40 @@
+"""
+This tool is used during CI testing to make sure sphinx raise no error.
+
+During development, we like to have whatsnew/pr/*.rst documents to track
+individual new features. Unfortunately they other either:
+  - have no title (sphinx complains)
+  - are not included in any toctree (sphinx complain)
+
+This fix-them up by "inventing" a title, before building the docs. At release
+time, these title and files will anyway be rewritten into the actual release
+notes.
+"""
+
+from pathlib import Path
+
+
+def main():
+    folder = Path("docs/source/whatsnew/pr/")
+    files = list(folder.glob("*.rst"))
+    print(files)
+
+    for filepath in files:
+        print("Adding pseudo-title to:", filepath.name)
+        title = filepath.name[:-4].split("/")[-1].replace("-", " ").capitalize()
+
+        data = filepath.read_text(encoding="utf-8")
+        try:
+            if data and data.splitlines()[1].startswith("="):
+                continue
+        except IndexError:
+            pass
+
+        with filepath.open("w", encoding="utf-8") as f:
+            f.write(title + "\n")
+            f.write("=" * len(title) + "\n\n")
+            f.write(data)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/gen_latex_symbols.py b/tools/gen_latex_symbols.py
new file mode 100644
index 00000000000..8484a480fdd
--- /dev/null
+++ b/tools/gen_latex_symbols.py
@@ -0,0 +1,101 @@
+# coding: utf-8
+
+# This script autogenerates `IPython.core.latex_symbols.py`, which contains a
+# single dict , named `latex_symbols`. The keys in this dict are latex symbols,
+# such as `\\alpha` and the values in the dict are the unicode equivalents for
+# those. Most importantly, only unicode symbols that are valid identifiers in
+# Python 3 are included.
+
+#
+# The original mapping of latex symbols to unicode comes from the `latex_symbols.jl` files from Julia.
+
+from pathlib import Path
+
+# Import the Julia LaTeX symbols
+print("Importing latex_symbols.jl from Julia...")
+import requests
+
+url = "https://raw.githubusercontent.com/JuliaLang/julia/master/stdlib/REPL/src/latex_symbols.jl"
+r = requests.get(url)
+
+
+# Build a list of key, value pairs
+print("Building a list of (latex, unicode) key-value pairs...")
+lines = r.text.splitlines()
+
+prefixes_line = lines.index('# "font" prefixes')
+symbols_line = lines.index("# manual additions:")
+
+prefix_dict = {}
+for l in lines[prefixes_line + 1 : symbols_line]:
+    p = l.split()
+    if not p or p[1] == "latex_symbols":
+        continue
+    prefix_dict[p[1]] = p[3]
+
+idents = []
+for l in lines[symbols_line:]:
+    if "=>" not in l:
+        continue  # if it's not a def, skip
+    if "#" in l:
+        l = l[: l.index("#")]  # get rid of eol comments
+    x, y = l.strip().split("=>")
+    if "*" in x:  # if a prefix is present substitute it with its value
+        p, x = x.split("*")
+        x = prefix_dict[p][:-1] + x[1:]
+    try:
+        x = x.split('"')[1]
+        y = y.split('"')[1]  # get the values in quotes
+    except IndexError as e:
+        continue
+        raise ValueError((x, y)) from e
+    if not x.startswith("\\\\"):
+        # reverse mapping
+        continue
+    idents.append((x, y))
+
+# Filter out non-valid identifiers
+print("Filtering out characters that are not valid Python 3 identifiers")
+
+
+def test_ident(i):
+    """Is the unicode string valid in a Python 3 identifier."""
+    # Some characters are not valid at the start of a name, but we still want to
+    # include them. So prefix with 'a', which is valid at the start.
+    return ("a" + i).isidentifier()
+
+
+assert test_ident("α")
+assert not test_ident("‴")
+
+valid_idents = [line for line in idents if test_ident(line[1])]
+
+# Write the `latex_symbols.py` module in the cwd
+
+s = f"""# encoding: utf-8
+
+# DO NOT EDIT THIS FILE BY HAND.
+
+# To update this file, run the script /tools/gen_latex_symbols.py using Python 3
+
+# This file is autogenerated from the file:
+# {url}
+# This original list is filtered to remove any unicode characters that are not valid
+# Python identifiers.
+
+latex_symbols = {{
+"""
+for line in valid_idents:
+    s += '    "%s": "%s",\n' % (line[0], line[1])
+s += "}\n"
+
+s += """
+
+reverse_latex_symbol = {v: k for k, v in latex_symbols.items()}
+"""
+
+HERE = Path(__file__).parent
+
+fn = HERE / ".." / "IPython" / "core" / "latex_symbols.py"
+print("Writing the file: %s" % str(fn))
+fn.write_text(s, encoding="utf-8")
diff --git a/tools/gitwash_dumper.py b/tools/gitwash_dumper.py
deleted file mode 100755
index 000245a920b..00000000000
--- a/tools/gitwash_dumper.py
+++ /dev/null
@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-''' Checkout gitwash repo into directory and do search replace on name '''
-
-import os
-from os.path import join as pjoin
-import shutil
-import sys
-import re
-import glob
-import fnmatch
-import tempfile
-from subprocess import call
-
-
-verbose = False
-
-
-def clone_repo(url, branch):
-    cwd = os.getcwd()
-    tmpdir = tempfile.mkdtemp()
-    try:
-        cmd = 'git clone %s %s' % (url, tmpdir)
-        call(cmd, shell=True)
-        os.chdir(tmpdir)
-        cmd = 'git checkout %s' % branch
-        call(cmd, shell=True)
-    except:
-        shutil.rmtree(tmpdir)
-        raise
-    finally:
-        os.chdir(cwd)
-    return tmpdir
-
-
-def cp_files(in_path, globs, out_path):
-    try:
-        os.makedirs(out_path)
-    except OSError:
-        pass
-    out_fnames = []
-    for in_glob in globs:
-        in_glob_path = pjoin(in_path, in_glob)
-        for in_fname in glob.glob(in_glob_path):
-            out_fname = in_fname.replace(in_path, out_path)
-            pth, _ = os.path.split(out_fname)
-            if not os.path.isdir(pth):
-                os.makedirs(pth)
-            shutil.copyfile(in_fname, out_fname)
-            out_fnames.append(out_fname)
-    return out_fnames
-
-
-def filename_search_replace(sr_pairs, filename, backup=False):
-    ''' Search and replace for expressions in files
-
-    '''
-    in_txt = open(filename, 'rt').read(-1)
-    out_txt = in_txt[:]
-    for in_exp, out_exp in sr_pairs:
-        in_exp = re.compile(in_exp)
-        out_txt = in_exp.sub(out_exp, out_txt)
-    if in_txt == out_txt:
-        return False
-    open(filename, 'wt').write(out_txt)
-    if backup:
-        open(filename + '.bak', 'wt').write(in_txt)
-    return True
-
-        
-def copy_replace(replace_pairs,
-                 out_path,
-                 repo_url,
-                 repo_branch = 'master',
-                 cp_globs=('*',),
-                 rep_globs=('*',),
-                 renames = ()):
-    repo_path = clone_repo(repo_url, repo_branch)
-    try:
-        out_fnames = cp_files(repo_path, cp_globs, out_path)
-    finally:
-        shutil.rmtree(repo_path)
-    renames = [(re.compile(in_exp), out_exp) for in_exp, out_exp in renames]
-    fnames = []
-    for rep_glob in rep_globs:
-        fnames += fnmatch.filter(out_fnames, rep_glob)
-    if verbose:
-        print '\n'.join(fnames)
-    for fname in fnames:
-        filename_search_replace(replace_pairs, fname, False)
-        for in_exp, out_exp in renames:
-            new_fname, n = in_exp.subn(out_exp, fname)
-            if n:
-                os.rename(fname, new_fname)
-                break
-
-            
-USAGE = ''' <output_directory> <project_name>
-
-If not set with options, the repository name is the same as the <project
-name>
-
-If not set with options, the main github user is the same as the
-repository name.'''
-
-
-GITWASH_CENTRAL = 'git://github.com/matthew-brett/gitwash.git'
-GITWASH_BRANCH = 'master'
-
-
-if __name__ == '__main__':
-    from optparse import OptionParser
-    parser = OptionParser()
-    parser.set_usage(parser.get_usage().strip() + USAGE)
-    parser.add_option("--repo-name", dest="repo_name",
-                      help="repository name - e.g. nitime",
-                      metavar="REPO_NAME")
-    parser.add_option("--github-user", dest="main_gh_user",
-                      help="github username for main repo - e.g fperez",
-                      metavar="MAIN_GH_USER")
-    parser.add_option("--gitwash-url", dest="gitwash_url",
-                      help="URL to gitwash repository - default %s"
-                      % GITWASH_CENTRAL, 
-                      default=GITWASH_CENTRAL,
-                      metavar="GITWASH_URL")
-    parser.add_option("--gitwash-branch", dest="gitwash_branch",
-                      help="branch in gitwash repository - default %s"
-                      % GITWASH_BRANCH,
-                      default=GITWASH_BRANCH,
-                      metavar="GITWASH_BRANCH")
-    parser.add_option("--source-suffix", dest="source_suffix",
-                      help="suffix of ReST source files - default '.rst'",
-                      default='.rst',
-                      metavar="SOURCE_SUFFIX")
-    (options, args) = parser.parse_args()
-    if len(args) < 2:
-        parser.print_help()
-        sys.exit()
-    out_path, project_name = args
-    if options.repo_name is None:
-        options.repo_name = project_name
-    if options.main_gh_user is None:
-        options.main_gh_user = options.repo_name
-    copy_replace((('PROJECTNAME', project_name),
-                  ('REPONAME', options.repo_name),
-                  ('MAIN_GH_USER', options.main_gh_user)),
-                 out_path,
-                 options.gitwash_url,
-                 options.gitwash_branch,
-                 cp_globs=(pjoin('gitwash', '*'),),
-                 rep_globs=('*.rst',),
-                 renames=(('\.rst$', options.source_suffix),))
diff --git a/tools/make_tarball.py b/tools/make_tarball.py
old mode 100755
new mode 100644
index 11738be87d5..fb639f61f61
--- a/tools/make_tarball.py
+++ b/tools/make_tarball.py
@@ -2,14 +2,11 @@
 """Simple script to create a tarball with proper git info.
 """
 
-import commands
-import os
-import sys
-import shutil
+import subprocess
 
-from  toollib import *
+from toollib import cd, sh
 
-tag = commands.getoutput('git describe --tags')
+tag = subprocess.check_output('git describe --tags', shell=True).decode('utf8', 'replace').strip()
 base_name = 'ipython-%s' % tag
 tar_name = '%s.tgz' % base_name
 
@@ -18,7 +15,6 @@
 # to the top of the tree.  There are long threads (since 2007) on the git list
 # about this and it still doesn't work in a sensible way...
 
-start_dir = os.getcwd()
 cd('..')
 git_tpl = 'git archive --format=tar --prefix={0}/ HEAD | gzip > {1}'
 sh(git_tpl.format(base_name, tar_name))
diff --git a/tools/release b/tools/release
deleted file mode 100755
index 1bf83d9e762..00000000000
--- a/tools/release
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/usr/bin/env python
-"""IPython release script.
-
-This should only be run at real release time.
-"""
-
-from toollib import *
-
-# Get main ipython dir, this will raise if it doesn't pass some checks
-ipdir = get_ipdir()
-tooldir = pjoin(ipdir,'tools')
-distdir = pjoin(ipdir,'dist')
-# Where I keep static backups of each release
-ipbackupdir = os.path.expanduser('~/ipython/backup')
-
-# Start in main IPython dir
-cd(ipdir)
-
-# Load release info
-execfile(pjoin('IPython','core','release.py'))
-
-print
-print "Releasing IPython"
-print "================="
-print
-print 'Source IPython directory:', ipdir
-print
-
-# Perform local backup, go to tools dir to run it.
-cd(tooldir)
-c('./make_tarball.py')
-c('mv ipython-*.tgz %s' % ipbackupdir)
-
-# Build release files
-c('./build_release %s' % ipdir)
-
-# Register with the Python Package Index (PyPI)
-print "Registering with PyPI..."
-cd(ipdir)
-c('./setup.py register')
-
-# Upload all files
-c('./setup.py sdist --formats=gztar,zip upload')
-cd(distdir)
-print "Uploading distribution files..."
-c('scp * ipython@ipython.scipy.org:www/dist/')
-
-print "Uploading backup files..."
-cd(ipbackupdir)
-c('scp `ls -1tr *tgz | tail -1` ipython@ipython.scipy.org:www/backup/')
-
-print "Done!"
diff --git a/tools/release_helper.sh b/tools/release_helper.sh
new file mode 100644
index 00000000000..47171397be7
--- /dev/null
+++ b/tools/release_helper.sh
@@ -0,0 +1,237 @@
+# Simple tool to help for release
+# when releasing with bash, simple source it to get asked questions.
+
+# misc check before starting
+BLACK=$(tput setaf 1)
+RED=$(tput setaf 1)
+GREEN=$(tput setaf 2)
+YELLOW=$(tput setaf 3)
+BLUE=$(tput setaf 4)
+MAGENTA=$(tput setaf 5)
+CYAN=$(tput setaf 6)
+WHITE=$(tput setaf 7)
+NOR=$(tput sgr0)
+
+
+echo "Checking all tools are installed..."
+
+python -c 'import keyring'
+python -c 'import twine'
+python -c 'import sphinx'
+python -c 'import sphinx_rtd_theme'
+python -c 'import pytest'
+python -c 'import build'
+# those are necessary fo building the docs
+echo "Checking imports for docs"
+python -c 'import numpy'
+python -c 'import matplotlib'
+
+
+
+
+echo "Will use $BLUE'$EDITOR'$NOR to edit files when necessary"
+# echo -n "PREV_RELEASE (X.y.z) [$PREV_RELEASE]: "
+# read input
+# PREV_RELEASE=${input:-$PREV_RELEASE}
+# echo -n "MILESTONE (X.y) [$MILESTONE]: "
+# read input
+# MILESTONE=${input:-$MILESTONE}
+echo -n "VERSION (X.y.z) [$VERSION]:"
+read input
+VERSION=${input:-$VERSION}
+echo -n "BRANCH (main|X.y) [$BRANCH]:"
+read input
+BRANCH=${input:-$BRANCH}
+
+ask_section(){
+    echo
+    echo $BLUE"$1"$NOR
+    echo -n $GREEN"Press Enter to continue, S to skip: "$NOR
+    if [ "$ZSH_NAME" = "zsh" ] ; then
+        read -k1 value
+        value=${value%$'\n'}
+    else
+       read -n1 value
+    fi
+    if [ -z "$value" ] || [ $value = 'y' ]; then
+        return 0
+    fi
+    return 1
+}
+
+
+maybe_edit(){
+    echo
+    echo $BLUE"$1"$NOR
+    echo -n $GREEN"Press ${BLUE}e$GREEN to Edit ${BLUE}$1$GREEN, any other keys to skip: "$NOR
+    if [ "$ZSH_NAME" = "zsh" ] ; then
+        read -k1 value
+        value=${value%$'\n'}
+    else
+       read -n1 value
+    fi
+
+    echo
+    if [ "$value" = 'e' ]  ; then
+        $EDITOR $1
+    fi
+}
+
+
+
+echo
+if ask_section "Updating what's new with information from docs/source/whatsnew/pr"
+then
+    python tools/update_whatsnew.py
+
+    echo
+    echo $BLUE"please move the contents of "docs/source/whatsnew/development.rst" to version-X.rst"$NOR
+    echo $GREEN"Press enter to continue"$NOR
+    read
+fi
+
+# if ask_section "Generate API difference (using frapuccino)"
+# then
+#     echo $BLUE"Checking out $PREV_RELEASE"$NOR
+#     git checkout tags/$PREV_RELEASE
+#     sleep 1
+#     echo $BLUE"Saving API to file $PREV_RELEASE"$NOR
+#     frappuccino IPython IPython.kernel IPython.lib IPython.qt IPython.lib.kernel IPython.html IPython.frontend IPython.external --save IPython-$PREV_RELEASE.json
+#     echo $BLUE"coming back to $BRANCH"$NOR
+#     git switch $BRANCH
+#     sleep 1
+#     echo $BLUE"comparing ..."$NOR
+#     frappuccino IPython IPython.kernel IPython.lib --compare IPython-$PREV_RELEASE.json
+#     echo $GREEN"Use the above guideline to write an API changelog ..."$NOR
+#     echo $GREEN"Press any keys to continue"$NOR
+#     read
+# fi
+
+echo "Cleaning repository"
+git clean -xfdi
+
+echo $GREEN"please update version number in ${RED}IPython/core/release.py${NOR} , Do not commit yet – we'll do it later."$NOR
+echo $GREEN"I tried ${RED}sed -i bkp -e '/Uncomment/s/^# //g' IPython/core/release.py${NOR}"
+sed -i bkp -e '/Uncomment/s/^# //g' IPython/core/release.py
+rm IPython/core/release.pybkp
+git diff | cat
+maybe_edit IPython/core/release.py
+
+echo $GREEN"Press enter to continue"$NOR
+read
+
+if ask_section "Build the documentation ?"
+then
+    make html -C docs
+    echo
+    echo $GREEN"Check the docs, press enter to continue"$NOR
+    read
+
+fi
+
+if ask_section "Should we commit, tag, push... etc ? "
+then
+   echo
+   echo $BLUE"Let's commit : git commit -am \"release $VERSION\" -S"
+   echo $GREEN"Press enter to commit"$NOR
+   read
+   git commit -am "release $VERSION" -S
+
+   echo
+   echo $BLUE"git push origin \$BRANCH ($BRANCH)?"$NOR
+   echo $GREEN"Make sure you can push"$NOR
+   echo $GREEN"Press enter to continue"$NOR
+   read
+   git push origin $BRANCH
+
+   echo
+   echo "Let's tag : git tag -am \"release $VERSION\" \"$VERSION\" -s"
+   echo $GREEN"Press enter to tag commit"$NOR
+   read
+   git tag -am "release $VERSION" "$VERSION" -s
+
+   echo
+   echo $BLUE"And push the tag: git push origin \$VERSION ?"$NOR
+   echo $GREEN"Press enter to continue"$NOR
+   read
+   git push origin $VERSION
+
+
+   echo $GREEN"please update version number and back to .dev in ${RED}IPython/core/release.py"
+   echo $GREEN"I tried ${RED}sed -i bkp -e '/Uncomment/s/^/# /g' IPython/core/release.py${NOR}"
+   sed -i bkp -e '/Uncomment/s/^/# /g' IPython/core/release.py
+   rm IPython/core/release.pybkp
+   git diff | cat
+   echo $GREEN"Please bump ${RED}the minor version number${NOR}"
+   maybe_edit IPython/core/release.py
+   echo ${BLUE}"Do not commit yet – we'll do it later."$NOR
+
+
+   echo $GREEN"Press enter to continue"$NOR
+   read
+
+   echo
+   echo "Let's commit : "$BLUE"git commit -am \"back to dev\""$NOR
+   echo $GREEN"Press enter to commit"$NOR
+   read
+   git commit -am "back to dev"
+
+   echo
+   echo $BLUE"git push origin \$BRANCH ($BRANCH)?"$NOR
+   echo $GREEN"Press enter to continue"$NOR
+   read
+   git push origin $BRANCH
+
+
+   echo
+   echo $BLUE"let's : git checkout tags/$VERSION"$NOR
+   echo $GREEN"Press enter to continue"$NOR
+   read
+   git checkout tags/$VERSION
+fi
+
+if ask_section "Should we build and release ?"
+then
+
+    echo $BLUE"going to set SOURCE_DATE_EPOCH"$NOR
+    echo $BLUE'export SOURCE_DATE_EPOCH=$(git show -s --format=%ct HEAD)'$NOR
+    echo $GREEN"Press enter to continue"$NOR
+    read
+
+    export SOURCE_DATE_EPOCH=$(git show -s --format=%ct HEAD)
+
+    echo $BLUE"SOURCE_DATE_EPOCH set to $SOURCE_DATE_EPOCH"$NOR
+    echo $GREEN"Press enter to continue"$NOR
+    read
+
+
+
+    echo
+    echo $BLUE"Attempting to build package..."$NOR
+
+    tools/build_release
+
+
+    echo $RED'$ shasum -a 256 dist/*'
+    shasum -a 256 dist/*
+    echo $NOR
+
+    echo $BLUE"We are going to rebuild, node the hash above, and compare them to the rebuild"$NOR
+    echo $GREEN"Press enter to continue"$NOR
+    read
+
+    echo
+    echo $BLUE"Attempting to build package..."$NOR
+
+    tools/build_release
+
+    echo $RED"Check the shasum for SOURCE_DATE_EPOCH=$SOURCE_DATE_EPOCH"
+    echo $RED'$ shasum -a 256 dist/*'
+    shasum -a 256 dist/*
+    echo $NOR
+
+    if ask_section "upload packages ?"
+    then
+       twine upload --verbose dist/*.tar.gz dist/*.whl
+    fi
+fi
diff --git a/tools/retar.py b/tools/retar.py
new file mode 100644
index 00000000000..fd828d0a7a9
--- /dev/null
+++ b/tools/retar.py
@@ -0,0 +1,87 @@
+"""
+Un-targz and retargz a targz file to ensure reproducible build.
+
+usage:
+
+    $ export SOURCE_DATE_EPOCH=$(date +%s)
+    # or
+    $ export SOURCE_DATE_EPOCH=$(git show -s --format=%ct HEAD)
+    ...
+    $ python retar.py <tarfile.gz>
+
+The process of creating an sdist can be non-reproducible:
+  - directory created during the process get a mtime of the creation date;
+  - gziping files embed the timestamp of zip creation.
+
+This will untar-retar; ensuring that all mtime > SOURCE_DATE_EPOCH will be set
+equal to SOURCE_DATE_EPOCH.
+
+"""
+
+import tarfile
+import sys
+import os
+import gzip
+import io
+
+from pathlib import Path
+
+if len(sys.argv) > 2:
+    raise ValueError("Too many arguments")
+
+
+timestamp = int(os.environ["SOURCE_DATE_EPOCH"])
+
+path = Path(sys.argv[1])
+old_buf = io.BytesIO()
+with open(path, "rb") as f:
+    old_buf.write(f.read())
+old_buf.seek(0)
+if path.name.endswith("gz"):
+    r_mode = "r:gz"
+if path.name.endswith("bz2"):
+    r_mode = "r:bz2"
+if path.name.endswith("xz"):
+    raise ValueError("XZ is deprecated but it's written nowhere")
+old = tarfile.open(fileobj=old_buf, mode=r_mode)
+
+buf = io.BytesIO()
+new = tarfile.open(fileobj=buf, mode="w", format=tarfile.GNU_FORMAT)
+for i, m in enumerate(old):
+    data = None
+    # mutation does not work, copy
+    if m.name.endswith('.DS_Store'):
+        continue
+    m2 = tarfile.TarInfo(m.name)
+    m2.mtime = min(timestamp, m.mtime)
+    m2.pax_headers["mtime"] = m2.mtime
+    m2.size = m.size
+    m2.type = m.type
+    m2.linkname = m.linkname
+    m2.mode = m.mode
+    if m.isdir():
+        new.addfile(m2)
+    else:
+        data = old.extractfile(m)
+        new.addfile(m2, data)
+new.close()
+old.close()
+
+buf.seek(0)
+
+if r_mode == "r:gz":
+    with open(path, "wb") as f:
+        with gzip.GzipFile("", "wb", fileobj=f, mtime=timestamp) as gzf:
+            gzf.write(buf.read())
+elif r_mode == "r:bz2":
+    import bz2
+
+    with bz2.open(path, "wb") as f:
+        f.write(buf.read())
+
+else:
+    assert False
+
+# checks the archive is valid.
+archive = tarfile.open(path)
+names = archive.getnames()
diff --git a/tools/run_ipy_in_profiler.py b/tools/run_ipy_in_profiler.py
deleted file mode 100755
index a58e0c55d14..00000000000
--- a/tools/run_ipy_in_profiler.py
+++ /dev/null
@@ -1,22 +0,0 @@
-"""XXX - What exactly is the use of this script?
-
-I (fperez) tried it quickly and it doesn't work in its current form.  Either it
-needs to be fixed and documented or removed.
-"""
-
-import cProfile as profile
-import sys
-#import profile
-
-def main():
-    import IPython.ipapi
-    print "Entering ipython for profiling. Type 'Exit' for profiler report"
-    IPython.ipapi.launch_new_instance()
-
-if len(sys.argv) == 1:   
-    profile.run('main()', 'ipython_profiler_results')
-
-import pstats
-p = pstats.Stats(len(sys.argv) >1 and sys.argv[1] or 'ipython_profiler_results')
-p.sort_stats('time').print_stats(30)
-
diff --git a/tools/tests/embed/embed1.py b/tools/tests/embed/embed1.py
new file mode 100644
index 00000000000..cdf55e4ee73
--- /dev/null
+++ b/tools/tests/embed/embed1.py
@@ -0,0 +1,10 @@
+"""This tests standard embedding, automatically detecting the module and
+local namespaces."""
+
+f = set([1,2,3,4,5])
+
+def bar(foo):
+    import IPython
+    IPython.embed(banner1='check f in globals, foo in locals')
+
+bar(f)
diff --git a/tools/tests/embed/embed2.py b/tools/tests/embed/embed2.py
new file mode 100644
index 00000000000..a60e3e9cbd6
--- /dev/null
+++ b/tools/tests/embed/embed2.py
@@ -0,0 +1,5 @@
+"""This tests passing a dict for the user_ns at shell instantiation."""
+from IPython import embed
+
+user_ns = dict(cookie='monster')
+embed(user_ns=user_ns, banner1="check 'cookie' present, locals and globals equivalent")
diff --git a/tools/tests/embed/embed3.py b/tools/tests/embed/embed3.py
new file mode 100644
index 00000000000..595ea5d589c
--- /dev/null
+++ b/tools/tests/embed/embed3.py
@@ -0,0 +1,7 @@
+"""This tests passing local_ns and global_ns (for backwards compatibility only)
+at activation of an embedded shell."""
+from IPython.terminal.embed import InteractiveShellEmbed
+
+user_ns = dict(cookie='monster')
+ISE = InteractiveShellEmbed(banner1='check cookie in locals, and globals empty')
+ISE(local_ns=user_ns, global_ns={})
diff --git a/tools/tests/embed/embed_flufl.py b/tools/tests/embed/embed_flufl.py
new file mode 100644
index 00000000000..76682fae936
--- /dev/null
+++ b/tools/tests/embed/embed_flufl.py
@@ -0,0 +1,5 @@
+"""This tests that future compiler flags are passed to the embedded IPython."""
+from __future__ import barry_as_FLUFL
+from IPython import embed
+embed(banner1='', header='check 1 <> 2 == True')
+embed(banner1='', header='check 1 <> 2 cause SyntaxError', compile_flags=0)
diff --git a/tools/tests/embed/embed_no_flufl.py b/tools/tests/embed/embed_no_flufl.py
new file mode 100644
index 00000000000..a65061c4357
--- /dev/null
+++ b/tools/tests/embed/embed_no_flufl.py
@@ -0,0 +1,6 @@
+"""This tests that future compiler flags are passed to the embedded IPython."""
+from IPython import embed
+import __future__
+embed(banner1='', header='check 1 <> 2 cause SyntaxError')
+embed(banner1='', header='check 1 <> 2 == True',
+      compile_flags=__future__.barry_as_FLUFL.compiler_flag)
diff --git a/tools/tests/heartbeat/hb_gil.py b/tools/tests/heartbeat/hb_gil.py
new file mode 100644
index 00000000000..3f9aef18f90
--- /dev/null
+++ b/tools/tests/heartbeat/hb_gil.py
@@ -0,0 +1,31 @@
+"""
+Run this script in the qtconsole with one of:
+
+    %load hb_gil.py
+
+or
+    %run hb_gil.py
+
+Holding the GIL for too long could disrupt the heartbeat.
+
+See Issue #1260: https://github.com/ipython/ipython/issues/1260
+
+"""
+
+import sys
+import time
+
+from cython import inline
+
+def gilsleep(t):
+    """gil-holding sleep with cython.inline"""
+    code = '\n'.join([
+        'from posix cimport unistd',
+        'unistd.sleep(t)',
+    ])
+    while True:
+        inline(code, quiet=True, t=t)
+        print(time.time())
+        sys.stdout.flush() # this is important
+
+gilsleep(5)
diff --git a/tools/tests/inline_figshow.py b/tools/tests/inline_figshow.py
new file mode 100644
index 00000000000..ba80d21039c
--- /dev/null
+++ b/tools/tests/inline_figshow.py
@@ -0,0 +1,23 @@
+"""Manual test for figure.show() in the inline matplotlib backend.
+
+This script should be loaded for interactive use (via %load) into a qtconsole
+or notebook initialized with the inline backend.
+
+Expected behavior: only *one* copy of the figure is shown.
+
+
+For further details:
+https://github.com/ipython/ipython/issues/1612
+https://github.com/matplotlib/matplotlib/issues/835
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+plt.ioff()
+x = np.random.uniform(-5, 5, size=(100))
+y = np.random.uniform(-5, 5, size=(100))
+f = plt.figure()
+plt.scatter(x, y)
+plt.plot(y)
+f.show()
diff --git a/tools/testupload b/tools/testupload
index a3a04dbe045..77adbe79055 100755
--- a/tools/testupload
+++ b/tools/testupload
@@ -1,6 +1,22 @@
-#!/bin/sh
-# Simple upload script to push up into the testing directory a local build
-ipdir=$PWD/..
+#!/usr/bin/env python
+"""Simple upload script to push up into the testing directory a local build
+"""
+from __future__ import print_function
 
-cd $ipdir/dist
-scp * ipython@ipython.scipy.org:www/dist/testing/
+from toollib import *
+
+# Get main ipython dir, this will raise if it doesn't pass some checks
+ipdir = get_ipdir()
+distdir = pjoin(ipdir, 'dist')
+
+# Load release info
+execfile(pjoin(ipdir, 'IPython','core','release.py'))
+
+# Build site addresses for file uploads
+testing_site = '%s/testing/%s' % (archive, version)
+
+cd(distdir)
+
+# Create remote path if it doesn't exist.
+sh('ssh %s "mkdir -p %s/testing/%s" ' % (archive_user, archive_dir, version))
+sh('scp * %s' % testing_site)
diff --git a/tools/toollib.py b/tools/toollib.py
index b0fa830e266..2d82bf1d06f 100644
--- a/tools/toollib.py
+++ b/tools/toollib.py
@@ -1,48 +1,48 @@
 """Various utilities common to IPython release and maintenance tools.
 """
+
 # Library imports
 import os
 import sys
 
-from distutils.dir_util import remove_tree
+from pathlib import Path
 
 # Useful shorthands
-pjoin = os.path.join
 cd = os.chdir
 
+# Constants
+
+# SSH root address of the archive site
+archive_user = 'ipython@archive.ipython.org'
+archive_dir = 'archive.ipython.org'
+archive = '%s:%s' % (archive_user, archive_dir)
+
+# Build commands
+# Source dists
+build_command = "{python} -m build".format(python=sys.executable)
+
+
 # Utility functions
 def sh(cmd):
     """Run system command in shell, raise SystemExit if it returns an error."""
-    print "$",cmd
+    print("$", cmd)
     stat = os.system(cmd)
     #stat = 0  # Uncomment this and comment previous to run in debug mode
     if stat:
         raise SystemExit("Command %s failed with code: %s" % (cmd, stat))
 
-# Backwards compatibility
-c = sh
-
 def get_ipdir():
     """Get IPython directory from command line, or assume it's the one above."""
 
     # Initialize arguments and check location
-    try:
-        ipdir = sys.argv[1]
-    except IndexError:
-        ipdir = '..'
-
-    ipdir = os.path.abspath(ipdir)
+    ipdir = Path(__file__).parent / os.pardir
+    ipdir = ipdir.resolve()
 
     cd(ipdir)
-    if not os.path.isdir('IPython') and os.path.isfile('setup.py'):
-        raise SystemExit('Invalid ipython directory: %s' % ipdir)
+    if not Path("IPython").is_dir() and Path("setup.py").is_file():
+        raise SystemExit("Invalid ipython directory: %s" % ipdir)
     return ipdir
 
-
-def compile_tree():
-    """Compile all Python files below current directory."""
-    stat = os.system('python -m compileall .')
-    if stat:
-        msg = '*** ERROR: Some Python files in tree do NOT compile! ***\n'
-        msg += 'See messages above for the actual file that produced it.\n'
-        raise SystemExit(msg)
+def execfile(fname, globs, locs=None):
+    locs = locs or globs
+    exec(compile(open(fname, encoding="utf-8").read(), fname, "exec"), globs, locs)
diff --git a/tools/update_whatsnew.py b/tools/update_whatsnew.py
new file mode 100644
index 00000000000..f5870758bc3
--- /dev/null
+++ b/tools/update_whatsnew.py
@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+"""Update the What's New doc (development version)
+
+This collects the snippets from whatsnew/pr/, moves their content into
+whatsnew/development.rst (chronologically ordered), and deletes the snippets.
+"""
+
+import io
+import sys
+from pathlib import Path
+from subprocess import check_call, check_output
+
+repo_root = Path(__file__).resolve().parent.parent
+whatsnew_dir = repo_root / "docs" / "source" / "whatsnew"
+pr_dir = whatsnew_dir / "pr"
+target = whatsnew_dir / "development.rst"
+
+FEATURE_MARK = ".. DO NOT EDIT THIS LINE BEFORE RELEASE. FEATURE INSERTION POINT."
+INCOMPAT_MARK = ".. DO NOT EDIT THIS LINE BEFORE RELEASE. INCOMPAT INSERTION POINT."
+
+# 1. Collect the whatsnew snippet files ---------------------------------------
+
+files = set(pr_dir.glob("*.rst"))
+# Ignore explanatory and example files
+files.difference_update(
+    {pr_dir / f for f in {"incompat-switching-to-perl.rst", "antigravity-feature.rst"}}
+)
+
+if not files:
+    print("No automatic update available for what's new")
+    sys.exit(0)
+
+
+def getmtime(f):
+    return check_output(["git", "log", "-1", '--format="%ai"', "--", f])
+
+
+files = sorted(files, key=getmtime)
+
+features, incompats = [], []
+for path in files:
+    with io.open(path, encoding="utf-8") as f:
+        try:
+            content = f.read().rstrip()
+        except Exception as e:
+            raise Exception('Error reading "{}"'.format(f)) from e
+
+    if path.name.startswith("incompat-"):
+        incompats.append(content)
+    else:
+        features.append(content)
+
+# Put the insertion markers back on the end, so they're ready for next time.
+feature_block = "\n\n".join(features + [FEATURE_MARK])
+incompat_block = "\n\n".join(incompats + [INCOMPAT_MARK])
+
+# 2. Update the target file ---------------------------------------------------
+
+with io.open(target, encoding="utf-8") as f:
+    content = f.read()
+
+assert content.count(FEATURE_MARK) == 1
+assert content.count(INCOMPAT_MARK) == 1
+
+content = content.replace(FEATURE_MARK, feature_block)
+content = content.replace(INCOMPAT_MARK, incompat_block)
+
+# Clean trailing whitespace
+content = "\n".join(l.rstrip() for l in content.splitlines())
+
+with io.open(target, "w", encoding="utf-8") as f:
+    f.write(content)
+
+# 3. Stage the changes in git -------------------------------------------------
+
+for file in files:
+    check_call(["git", "rm", file])
+
+check_call(["git", "add", target])
+
+print("Merged what's new changes. Check the diff and commit the change.")