backport nbformat v4 to 2.x

IPython/nbformat/notebooknode.py

@@ -0,0 +1,21 b''
+"""NotebookNode - adding attribute access to dicts"""
+
+from IPython.utils.ipstruct import Struct
+
+class NotebookNode(Struct):
+    """A dict-like node with attribute-access"""
+    pass
+
+def from_dict(d):
+    """Convert dict to dict-like NotebookNode
+    
+    Recursively converts any dict in the container to a NotebookNode
+    """
+    if isinstance(d, dict):
+        return NotebookNode({k:from_dict(v) for k,v in d.items()})
+    elif isinstance(d, (tuple, list)):
+        return [from_dict(i) for i in d]
+    else:
+        return d
+
+

IPython/nbformat/tests/test4.ipynb

@@ -0,0 +1,308 b''
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# nbconvert latex test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Lorem ipsum** dolor sit amet, consectetur adipiscing elit. Nunc luctus bibendum felis dictum sodales. Ut suscipit, orci ut interdum imperdiet, purus ligula mollis *justo*, non malesuada nisl augue eget lorem. Donec bibendum, erat sit amet porttitor aliquam, urna lorem ornare libero, in vehicula diam diam ut ante. Nam non urna rhoncus, accumsan elit sit amet, mollis tellus. Vestibulum nec tellus metus. Vestibulum tempor, ligula et vehicula rhoncus, sapien turpis faucibus lorem, id dapibus turpis mauris ac orci. Sed volutpat vestibulum venenatis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Printed Using Python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hello\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"hello\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pyout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<script>\n",
+       "console.log(\"hello\");\n",
+       "</script>\n",
+       "<b>HTML</b>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML at 0x1112757d0>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import HTML\n",
+    "HTML(\"\"\"\n",
+    "<script>\n",
+    "console.log(\"hello\");\n",
+    "</script>\n",
+    "<b>HTML</b>\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "console.log(\"hi\");"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript at 0x1112b4b50>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%%javascript\n",
+    "console.log(\"hi\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": [
+       "iVBORw0KGgoAAAANSUhEUgAAAggAAABDCAYAAAD5/P3lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
+       "AAAH3AAAB9wBYvxo6AAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACAASURB\n",
+       "VHic7Z15uBxF1bjfugkJhCWBsCSAJGACNg4QCI3RT1lEAVE+UEBNOmwCDcjHT1wQgU+WD3dFxA1o\n",
+       "CAikAZFFVlnCjizpsCUjHQjBIAkQlpCFJGS79fvjdGf69vTsc2fuza33eeaZmeqq6jM9vZw6dc4p\n",
+       "BUwC+tE+fqW1fqmRDpRSHjCggS40sBxYDCxKvL8KzNBaL21EPoPB0DPIWVY/4NlE0ffzYfhgu+Qx\n",
+       "GHoy/YFjaK+CcB3QkIIAHAWs3wRZsuhUSs0CXgQeBm7UWi/spn0Z+jA5yxpEfYruqnwYllRic5a1\n",
+       "MaWv8U5gaT4M19Sx396IAnZLfB/SLkEMhp5O/3YL0AvoAHaKXl8HLlZK3QZcpbWe0lbJDOsaHuDU\n",
+       "0e4u4JAy2wPk/C1JzrKWArOQ0fUtwH35MOysQxaDwbCO0NFuAXoh6wPjgQeUUvcqpUa0WyCDoQls\n",
+       "CIwBjgfuAV7KWdY+7RWpmJxlXZezrEdylvXxdstiMKzrGAtCYxwI/EspdZbW+g/tFsbQ67kQuBHY\n",
+       "FNgseh9FV6vCbUAeWBC9PgBeq2EfS6J2MQOBrRDTe5KdgAdzlvW1fBjeUUP/3UbOsoYBE6OvG7VT\n",
+       "FoOhL9Af+BUwFLkZpV+DaY6V4UPkRpb1+ncT+m8nGwK/V0oN01qf025hDL2XfBi+DLycLMtZVo6u\n",
+       "CsKfGnSq8/NheEpqHwOBEcDBwJnAsGhTP2ByzrJG5cPwnQb22Sy+0G4BDIa+RH+t9dmlNiqlFKIk\n",
+       "JJWGi+jq5JPmq8BbJJQArfXqpkncczlbKbVQa/3rdgtiMNRCPgxXAK8Ar+Qs63LgXmDvaPPGwPeA\n",
+       "H7VJvCRfbLcABkNfouwUg9ZaAwuj178BlFLvVejzgR4WFviM1npcuQpKqf6IyXIjxLS7GzAWuUnu\n",
+       "XsO+fqWUellr3ZBJdq/jr9+BDn1uve07O9Rz0y6f8PtGZGgWe53oT6SBkZ/q1/nHZy47aloTRTKU\n",
+       "IR+Gy3OWNR6Zxtg0Kv4KRkEwGPocxgcBiCwcsSI0F5iOhF+ilPok8C3gVGS+thK/VErdrbWuO2ys\n",
+       "s/+aLZTuOKbe9krrIUCPUBB0B+PQ1P1bdKe6EzAKQgvJh+GbOct6gkJkxM45y+qXDIWMHBhjBWJe\n",
+       "PgyDWvaRs6zPIVObAG/nw/DpEvUGAp8E9gGGJzbtl7Os7cvs4skqp0V0Yl8jgcOBjyMDhbmIZeWl\n",
+       "fBg+UUVfReQsayhwELAnsAXi6/E28BxwTz4MP6iyn92RaSCA+/NhuCwqXx9R4MYhU0MfRTK/AjyW\n",
+       "D8MFGd0ZDFVhFIQKaK3/BXxfKXUlklTq0xWafAI4Driyu2UzGLqRlygoCArYHJif2H4gcFb0+Z2c\n",
+       "ZW2bD8NV1XScs6yNgH8g/jsAPwCeTmzfFPgjYsnbiez71MUVdnMQcF8V4nyUs6whwB8QX4+0s2Ys\n",
+       "0yPAt/NhGFbRZ/wbzgO+DaxXotqqnGX9GbigCkXhf5CBCsDngYdzljURGQhsWqLN+znL+iFwdT4M\n",
+       "dYk6BkNJTJhjlWitQ2Bf4P4qqv848t8wGHor6Yd9+ruHJFkC2BI4rIa+D6egHKwmstYlGAxMQCwH\n",
+       "rRjEPI5ER5S7ZvcFXsxZ1phKneUsawSi8HyH0soB0bbvAM9Ebaplt5xlnYkct1LKAYiFZhJwSQ19\n",
+       "GwxrMRaEGtBar1RKfRX4JxIzXortou3PN1mE+YgJsSwaeoLHOQCqUy3QSr9eqZ6G/gq2aYVMhqrY\n",
+       "OfF5FeJwvJZ8GM7JWdY/gC9HRS7wtyr7Pjrx+e6MqYC3KLbU7Qhck/h+FJIKvRRVjfSREXicU8EH\n",
+       "pgAvIIqLBZwGfC7avl5Uf29KkLOsTZCMq8npj9sQx89no37HIlaAODplNPBIzrJ2z4dhNVlaT0HC\n",
+       "XwFmIkrAC4if2PaIz8/3KCgn385Z1pX5MJxeRd8Gw1qMglAjWutlSqnTgUcqVP0SzVYQtP5mcMXE\n",
+       "SvvtUUy9YsK5QEWHy7EnTB6lOtSsFohkqEDOsgYAdqJoagkT9Z8pKAj75yzr4/kwnF2h748ho/GY\n",
+       "q9J1oqiKLj4JOctKK8Yz8mH4Yrl9VcnHkXVYTsyHoZ8WJWdZNyPThbF5/3M5yzowH4alpi9+T0E5\n",
+       "WA18Nx+Gf0zVeRG4KmdZ90R9bwCMRKwyX69C5h2j91uA4/JhuCSxbTYwJWdZtwNPIFbifsAFSISZ\n",
+       "wVA1ZoqhDrTWjyIjjXIc3ApZDIZu4ELgY4nvt5Wody8wJ/qsgBOr6HsihfvOfCRrY7v5dYZyAECk\n",
+       "GP0ISEZmZYZ55yxrB8SyEXNxhnKQ7Pt64H8TRUfmLGuXKmWeC4xPKQfJvp9CLCJlZTYYymEUhPq5\n",
+       "tcL2XVsihcHQJHKWtU3Osi5GnAZj5iKWgiKitRouTxQdl7OscnPu0HV64dp8GLY7R8pyxEGxJPkw\n",
+       "fBcZ9ceUSvN8IoV76upK/UZcgawcG3NKqYopfleFU+gDic/b5SzLWIwNNWFOmPqp5CG9sVJqPa11\n",
+       "VZ7dBkOL2D1nWcmcBkOR8MFtgM/QdTXJZcCR+TBcXqa/SYj5egAFZ8VMX4ScZe2FRPnEXF2z9M3n\n",
+       "3nwYVsrtAmK6/0z0uVR4ZXLtivvzYfhGpU7zYbgkZ1k3ACdHRQdWIQsUO3ZmkUzB3Q/xjaolLbeh\n",
+       "j2MUhDrRWr+mlFpJ+eV5hyIxz4YWs98Fj/Rf8uZbozo0/ZYt7D8rf9ORK9stUw/hU9GrEnMAp1R+\n",
+       "gph8GL4bzdNPiIpOorSzYtJ68FS1IYPdTLWp3hcnPm+Q3pizrA7E+TCmFn+aZN0dcpY1LB+G5e4b\n",
+       "y6rM8bA49X39GmQyGMwUQ4NUGnkMrbDd0A3sdeLk4z6cN+89pTtDTWd+gyErF+7pTv5eu+XqJbyK\n",
+       "TDHsmg/DJ6tsc2ni8+dzljUqXSGaevhmoqjIObFNVBzlV8kQug4W5tbQNl13WGatAv+poW+DoW6M\n",
+       "BaExPgC2LrO9nHWhpSilDqI4NPMhrfXUJvS9M/DfqeJXtdY3N9p3rex50uQ9lFKT6BrTvoFCXbTX\n",
+       "yZNfmnrZxHtbLVMP4xng74nvK5DzeD7wfIWRayb5MHwiZ1kzgF0oOCuemar2ZQoK8zLgr7Xup5t4\n",
+       "s0n9DEl9b0RBSPeV5q0a+jYY6sYoCI1RacnZ91siRXUMAH6eKnsYicdulDOAY1NlpzWh35pRqG9R\n",
+       "IuGN7uw4AfG878s8nw/DX3RDv5dScGY8NmdZP86HYXJaJzm9cHMp7/s2UHdK9BTpKaxBNbRN163k\n",
+       "t9Rux05DH8FMMTTGZhW2v9sSKarjbopNk/sqpUY30qlSahCSGS/JCuD6RvqtF6UpMm/HaHTJbYaG\n",
+       "mQzED/0umRVzlrUZhXwJ0HOmF5pJOlXyxzJrZbNt6rtZP8HQIzAKQp0opTZAlsItxTKtdTnv75YS\n",
+       "LR7lpYqrjV0vx2EUH4fbtdZtucnpMqOrDjPy6jYii8DkRFHSYnAEhem22cBjrZKrVeTDcCldTf/p\n",
+       "h345ksrEGprnF2EwNIRREOrnMxW2z2uJFLVxJcXmy2OVUo34ShydUda+EaIq7T2u0SZTY/eSdFY8\n",
+       "MGdZm0efk86J6/LCQUnFp5pIkZjkcvQz8mH4YZPkMRgawigI9VNp7v7BlkhRA1rr+RQneNqC2hba\n",
+       "WYtSajiS9z3JXLomaGktq/VllLIUdKqSWe0MjZMPwxlIel8Q/6Zv5CxrGIX8AJ10XU+hFtIRQ+UW\n",
+       "KWoXyYyTu+Qsa79KDXKWNRpJyx5zZ9OlMhjqxCgIdaCU6g98o0K1npBCNotLM8rcOvuagCRgSXKN\n",
+       "1rozq3IrCCZNfFkrfRjotWsCaJinUBODK51/tkuuPkTy/DoYOIDCfeb+fBjW4t2/lqhdcmRdbUri\n",
+       "VnILXS2HZ1WRvfAcCk61K4A/dYdgBkM9GAWhPr5F6XSrIBf6Qy2SpSaidSReShV/XilV7veUIj29\n",
+       "oOkB2fGmXT7x7sCbOGpFf7VZx4A1m0/znG2nehMyc+0bms7NFJxzxwH7J7Y1OvWUPG9/mLOsLRvs\n",
+       "r6lEaaOT0TtfBB5ITLWsJWdZg3KWdRNwTKL4wnwYzu9mMQ2GqjFhjjWilBqBpJYtx51a66UV6rST\n",
+       "S+maJz52VvxRdvVilFK7UbzexGNa67Kr+bWS6X+ekPYs79HkLGt34JOI+Xyz6D2d1vfMnGUdini6\n",
+       "L0C851/Oh2HD+SyaQT4MV+YsaxJyLm1Gwf9gAXBHg93/JNHHtsArOcuajCztPBDYCkkytBXg5sOw\n",
+       "5QmF8mF4W86yLgK+HxXtC8zKWVaALMm8CslHsicS7RFzL8VhyAZDWzEKQg0opbYE7qd8prPVdF2h\n",
+       "rSdyLfALYMNE2XFKqR/XsHbEURll62L4Wiv5PuBUqPPF6JXkLuCQbpGoPi4HfohYKGMHWD9axrlu\n",
+       "8mF4Z7RuwfioaDBwaonqRemQW0U+DH+Qs6xFwHnIFNwQsv+3mMnA8dHiVwZDj8FMMVSJUuow4DkK\n",
+       "a7GX4gqt9cstEKlutNaL6boULMho5tBq2iul+lH8IFuCmJcNfZx8GM6hOCFVU5THfBhOQHxfylkH\n",
+       "3gY+asb+6iUfhhcCewC3l5BlFbJk/P75MDwqlVTKYOgRKK1rizhSSk2h67ximo1abV5XSi2n9EIk\n",
+       "z2itx5XYVqnfQcjI7DiqW2XtfeCTUbRA3ex50nWfUrqjeJEcrfcLrpj4SCN9xyilxgDPp4of0Fof\n",
+       "UEXbg4B/pIqv1FrXnVNh7AmTR3V0qIwwRH1E4E28pd5+De0hZ1m/Bb4bfX0+H4Z7dMM+hgGjkDwC\n",
+       "S5FpjFk9bR4/Z1mDkGmF4VHR20g4Y3oxJYOhR9EXphg6lFLlVjFbH0mZvDGwCTAayCFe0ntTOZ1y\n",
+       "zDLgkEaVg1ahtX5BKfUU8OlE8ReUUjtorSstCduzch8YehSR5/6ERFG3nBvRuhE9frXUfBguA6pd\n",
+       "+Mpg6DH0BQXBBro7o+Ea4Bta66e6eT/N5lK6KggKOAE4u1QDpdTGFOdNmNkLf7uh+zgYcRQEMa+3\n",
+       "Je22wWBoDOOD0DhLgYla67vaLUgd3ETxglLHRXkeSnEExQ5gbQ9tNPQokis5TsqHoVlbwGDohRgF\n",
+       "oTECYHet9Y3tFqQetNYrKDb/DqN46eYk6emF1UhUhMFAzrImUEhDvgr4VRvFMRgMDWAUhPpYAvwf\n",
+       "8Bmte31+/8uQBEdJMjMrKqW2o5A2N+YfWusePw9s6F5yltWRs6zxwKRE8RXtyEVgMBiaQ1/wQWgm\n",
+       "eWTe/jqtdU9Zz74htNavKaXuAw5KFB+glBqptZ6Tqj6RQlrYGDO90AfJWdY5wNeQFQwHIAmetk5U\n",
+       "eZFCsiCDwdALMQpCed5AphEC4NF12BHvUroqCAoJ7TwvVS+d++BdJEmPoe+xKRLnn0UeODwfhm3N\n",
+       "RWAwGBqjLygIbwN/LbNdI1MGH6ReL/eWkMUmcDeSeGa7RNlRSqnzdZQoQym1C7Bzqt11NWReNKxb\n",
+       "zEMU6GHAesBiYCaSLOviaF0Cg8HQi+kLCsLrWuvT2y1ET0ZrvUYp5SG57mO2Bz4LPB59/2ZRQ5P7\n",
+       "oM+SD8OLgYvbLYfBYOg+jJOiIeZKxOs8STJiIb28daC1/lf3imQwGAyGdmEUBAMA0XTKraniI5VS\n",
+       "A6O0zOnloI31wGAwGNZhjIJgSHJp6vtgJBNlehW65cANLZHIYDAYDG3BKAiGtWitHwVeShV/muLF\n",
+       "uW7VWi9qjVQGg8FgaAd9wUnRUBuXAn9IfN8f+FyqTo/OfbDnSX8brDpXnqEUe2ropzQvdtDx66ev\n",
+       "GN9XolIMPQDb9T8LrBd4zsPtlsXQe7Bd/0BgQeA5QbtlMQqCIc21wC+ADaPv6WWu5wAPtVKgWtjt\n",
+       "6Os2XG/9jhdQjIzTQ2rFF9bQecy4E2/I9UQlwXb9LYDDK1R7K/Cc21shj6FxbNcfDjwGKNv1Rwae\n",
+       "83q7ZWo2tusPBb6ELGW9BbAICX99Gngs8Jx0hlZDBWzXHwvcC6ywXX9o4DlL2ymPURAMXdBaL1ZK\n",
+       "+ZRItwz8Jc6N0BMZMFB9GxiZsWnzTjrPAH7QWomqYgTF/h9pngC6RUGwXf+XwC2B50ztjv57M7br\n",
+       "XwJMCjxneo1NP0SWgAfJq7LOYLv+esAFwOkUL9wWM912/d0Dz+lsnWQ9A9v1BwEXAT8PPKfWVOML\n",
+       "kPVt3kNWQm0rxgfBkEWph5UG/tJCOWqnQ40ttUkrvWcrRamWwHOmAZsguSfGAi9Hmy5AUhgPAz7f\n",
+       "Hfu2XX8k8ENgx+7ovzdju/4uwP9D/peaCDxnCbANsF3gOYubLVu7sF1/AHAHcBaiHDwI/C+ywNsE\n",
+       "4KfA68BdfVE5iNgbOBmxqtRE4Dn/BoYDnwg8Z02zBasVY0EwFKG1fkEp9RTioJjkIa11zzaVarYq\n",
+       "vVFt2TpBaiN6oCwB5tiu/2FUPCvwnLTTaLM5oJv77800dGwCz1kXHXkvRNKydwI/Cjzn1+kKtuuf\n",
+       "i2TX7Ks0et681yxBGsUoCIZSBBQrCL0h98EbdW7rddiuPwoYFJu/bdffFNgL2BZ4DZgWKR5ZbRWS\n",
+       "2+KIqGiE7fpjUtXmlrtZRdaHscBAYDowM/CckimWbdffFfgw8JzXou/9kfUccojV5MXAcz4s0XYw\n",
+       "sCsymu8PzAVmBJ7zVqn9pdoPRVKF7wSsAN4EgqzRve36HcAoZDEqgO0zjs3rged8kGo3gOJ05ADT\n",
+       "s0bTkan+k9HXGaVGjNFxykVf81nH2Hb9Ich/MRJJeT291H9fL7brj6CwANfPspQDgOi3rijRx/rI\n",
+       "b8kB7wPPBZ4zL6Ne/JvfCDzn/WhufhvgvsBzVkR1dgN2AR4JPGduom38P7wXeM7c6FzfCfgU4iMR\n",
+       "lFLebNfPIefXzMBzikz8tusPQyx676bljmTeCfhyVLST7frp//TV9Dluu/6GwOhUvTWB58zIkjFq\n",
+       "sykyNfmfwHMW2K7fLzoWeyDTFPnAc14t1T7qYwNgT+Rc/wi5ZyT/N20UBEMRSqn+wNdTxQspTqTU\n",
+       "41BaP6yVOipzGzzSYnG6m6uBz0YPv7OQm3dytc35tuuflHZutF3/BuArwEaJ4p/QNdU2wGnAH9M7\n",
+       "jRSTG5CbS5LQdv2joymTLKYBzwHjbNc/DomW2TCxfbXt+sMCz3k/sa8RwM+Qh/X6qf5W2q4/CTit\n",
+       "zMN1OPB7CopQktW2658YeM5fEvXvRKZzBiXqZaWUPha4JlW2NfB8Rt0hiANfmjWIuf5jiLPfvVm/\n",
+       "AfmvbgNmB54zKrkheuD+Bjg11Wap7fpnBJ5TybelFk4E+iE+Fb+ptbHt+scg//nGqfJbgeMDz1mY\n",
+       "KN4UOZYX2q7fSWHhuNdt198ZOBc4MypbbLv+5wPPeTb6PiJqe5ft+ichx3WXRN8rbdc/OfCcrGis\n",
+       "R4ChiHKSlSn2f4BzkOvitMRvCKJ9DEzU9TPafwGZlkkyBvExSrKUrtdnmoOBycA5tus/iCyat3li\n",
+       "u7Zd/0rk2ihS1mzXPwT4E3LulaLTKAiGLL6EaMlJbtBat91pphIjFw289t9DVh4N7Jva9EKnWnpJ\n",
+       "G0RqBXcjCa08YCqy/PJE4L8A33b9HQPPeTNR/0bgvujzGchoywPSq5U+nd6R7fp7IDfRjYDrEE99\n",
+       "DeyHrPb5lO364xI36zTb2q4/AUnt/SSyLHQHMvJZklQOIhYChyCLid2FWBoGIQrDfwGnAP8Gskzd\n",
+       "VvSbBgPvIMdpJjLHuxdikXgg1ewa4Jbo84+BHRAFI/3gT9/QQZa+/iIy9zwccVQrSeA5nbbrX4s8\n",
+       "cI6htIIQK7xdFJLIAvEEYjmYBlyP/E4LeXj92Xb94YHnnFtOjhrYJ3q/vtbpE9v1fwqcjYxUL0GO\n",
+       "51bI//g1YIzt+mNTSgJIivfNEIXgBOThfx0ySv8Nct7vgzgfj0+1HQf8E5iPKM/vI+vLHA9cZbs+\n",
+       "JZSEevgDBZ++3yIKzgVI1FeSrCnD6ci0zebAJxCfjmoZjxzXPPBL5By0gW8jCt3sqHwtkYL1N0RB\n",
+       "/R2ymOG2yHE5CLFAHAu8ahQEQxbfyijrDdML3HTTkWvUBRfsb88bPb6TzjEK+oHKL184YHL+Jmdl\n",
+       "u+XrJsYBhwaec0dcYLu+hzw0dkcu/AvjbUmLgu36DqIgPB54zuQq9nURMgI8LjnyBibZrj8z2s/l\n",
+       "tuvvVcJJbWvkXDoi8JzbKu0s8JxFtut/IqXgAPzOdv0/IiPnb5KhICAjpMGIEjAhPV1iu35HWsbA\n",
+       "c25ObD8ZURAeqibENBqpTYnark8FBSHiakRBOMx2/cHpB29kSv4KooSlLRYnIcrBHcBXk7/Fdv0b\n",
+       "gReAM23Xvz7wnJlVyFIJK3qfXUsj2/U/jiiiq4B9ktEytuv/Fhlpfx2xEnw31XxHYLfAc6bbrv8k\n",
+       "cny/Bnwz8Jy/2q6/DTLd9F8Zu94ceXAeEHhOvM7MNbbrT0UU4vNs15+c2FY3gedcm/hNP0EUhDvL\n",
+       "KMrJtkuIFPboWNWiIOSAO4HDE7/Dj67FSxEn21+m2pyOWDpuCDxn7fG2Xf8e4F1EIVsceE5oohgM\n",
+       "XVBKjURuSEke11qXMhv3OPR553VO9Sb407yJZwTexO8FnnNV/qYj11XlAOCfSeUA1s4D/y36mp7f\n",
+       "rAvb9fdGLDMzU8pBzMXIg2wsMhLKQiFhgxWVg5gM5SDm+uh9VHqD7fr7IlaNFcAJWb4UPcHLPvCc\n",
+       "2YgVZn3gyIwq30AsQg8lQ+aiefUfR1/PzlB08sD9Udusfmsi2t+Q6GutjspnIE6L16dDaSN/irMR\n",
+       "p8dTbddPOxK/nwgxTZr8747e30SsEkNL7PvXGQrAVYgvwggK/gK9mXMyfuON0fvWkY9Dkp2i97uT\n",
+       "hYHnLKNgURsDxknRUMz5FJ8XP22DHIbqSc9pxsSOW8ObtJ89ovdXbNcvpQC8j4zcdiTbnAoy4q2b\n",
+       "6Ia3CYV5/Y0zqsXOf4/WEYveaq5GQuOOQaZekhydqJNkW2BLZF2UzhL/R+xE2XAIa+A52nb9lUho\n",
+       "Y63hd7GD5d1ZGwPPmW27/iuIUrkLXc/n9xP13rZd/yNgVezoF8n1NjAyyyKETGGl97fGdv1/IlaL\n",
+       "3h7e+06WM2PgOQtt11+GTMcNo6vVJ1aWsyK+4nvFQjAKgiGBUmoshfnOmGe11vdl1Tf0GOaUKI9v\n",
+       "lqrE9lqJb6b/Hb3KsU2Zba/VslPb9bdDfA0ORLz0N62iWWxVqMkc3iZuRuawP2u7/g6JKI9RSCTR\n",
+       "YoodhOP/YgNKK2Ix2zZJzjnINMN2NbaL/4uiaIUE/0EUhB3pqiCkMwl2IscjXZZFJ/B2iW1xRtWR\n",
+       "ZWTqDcwps63U9f8Q0TSN7fp/iK0PtuvviPjmrCHyR1qrICilNkTmHjZDLsDke/JzOtwnzY1KqXcR\n",
+       "R4cFiBab9XlRT87I19dQSo1GNPz0tJOxHvR8mhrOVobB0XuAOBiWo1zmwaqdXW3X3x+4BzGVv4SM\n",
+       "pN9AnPEg21McxMIArTs2dRN4zoe26/8NOA6xGJwfbYqV9b8GnrM81Sz+Lz5A0qOXo2y4Ww3MoT4F\n",
+       "IY4+KTfNF58TaXN4VthstVNDitLKcdxvOjKmEj0tv0M953fs87E3Eul0B2JliBflOzfwnFcA+iul\n",
+       "5iEmwQFNEBaK569L0amUWggcqrXO8gg2FKHG2CdW4Uem9XvBlUflu7RUaiByU3lPa92ZKN8cSav8\n",
+       "fUQBTHKr1rrqueIsxp18/eg1azrLjSYB6NfRsY3G6Is9nDjDYxh4zundvbMotvtm5N50duA5P09t\n",
+       "T0faJIkfirU+zNrF1YiC4FBQECZE73/JqB//F+u14r+ImIVEOB1iu/6ZNfhwzEamp7YuU2e7RN1m\n",
+       "oZBnW5YVIfZ1qNWfotw51yuIph++hET0bAkcikwpTAEuCjxnSly3PzIP0a8NcnYgD6SBlSoaIhQX\n",
+       "V2UtVup24LBU6S7IyG+NUuodZP52awojrTSvIjeshlij9XdQKh2jXYRRDtpGfOCruQfEpmzbdn0V\n",
+       "dP9iPLsgjnEryI67Lzd/PCt6/5Tt+v3LJXAqQ/z7ut2ZO/Ccx23XfxUYZbt+7D8xCngl8Jwsa80s\n",
+       "ZBS8ke36O7cg4ybA5UgegJ0QE/XN5auvZRaiIMQRF12wXX8TCv9ls6eERpOtIMR+EXNS5YsRh8dS\n",
+       "To/V+CzUck21i6uR5++4wHNeKFXJRDH0PfoR5fqmtHKwDDhCa73O5JA3lCSeF04v6Z3FPRTMzBO7\n",
+       "S6AE8Q12PbomgYn5Xpm29yMPhu2RUK96iKMn9q6zfa38JXo/NHoly7oQeM5K4Iro60+jKINuJVJC\n",
+       "Yu/439uuX805A4VkWyfbrp+V/MdFnOmeCmpfFKsSRYMc2/U/DeyG3OfSjpOx5WmfVHmcuXFcFfus\n",
+       "5ZpqObbrb45EtswqpxyAcVI0FDMbOFxrXeT9a+heopvnEArzolvashT0wmbEapdgGpIU5XDb9R9F\n",
+       "YqrXQyyL8wPPeTeuGHjOMtv1T0VuqldH6W//jigNmyHOcAcBgwPPcZog20xkRLcJ8DPb9S9CRqM7\n",
+       "I7kDvoDE1hfdxwLPWWy7/plI7oCLbNffHXm4zUQeRtsjGRP/EXhOKSfcABkpj49i5+9G/putgHmB\n",
+       "5yxIN4iSF21C14V6Rtiu/yYSW15uHv4a4P8oKAedlPcvOAv4KmItfCTKKfAS8v8NR1ILHwnsl5GA\n",
+       "qF7ORdYaGA48HGWyfBqYgViDRwCfQR72PkDgOU9E2TvHI4m0TgeeRczb30DyH2iKcyA0ymrgWNv1\n",
+       "FyDK1NvIQ3tStN3LCH+9HUl29UPb9echFo8BUbtLEKfJtJ9EmgA59ifbrj8bCR3cGDlvZqdTLcPa\n",
+       "9NCbUMhs2GFLKvPFSAKxZl7/CxEL8pgoA+QMxD+kE3HenAHcHnjOGmNB6Dt8iGjHWSFKK4HHkcQr\n",
+       "OxvloLXYrr+77fqrEIejNyiE6P0WccZbabv+lFLtG+Ry5AY/BHkYfRDtR9M79QAAA3FJREFUcwYS\n",
+       "NdCFwHPuQR6a7wHfAR5GMhk+i9xcT6G6KIOKBJ6zFBn9r0GUmBlIWN9ziHf/5yjO/phsfy2yqt4i\n",
+       "xOJxF3INTI9k/Q7ZoV4xv0PC5LZCci4sQm6g08kYHdquvxy5lt4DwsSmF5EENCts1//Idv3M9LbR\n",
+       "egJTkEx4NvBA1joFifqLIjkeR6wcfwdeQfIFTEEcjHNU79RXkShvw95Ixs5+yOj/KuSh+ATiAHcq\n",
+       "xb4fxwOXRfJMQc6zlxGF6B3g4MBznmmWnBFzEUfP0xDFcCGiAG+JHKushESXIdanjRBF4l3EInAj\n",
+       "8vuOqWK/5yNRGaOQFNkfIhkOX6CQgwAA2/W3jkI3V0T7ejjatAFyXb2PXP/LbVnroWGi6bbzo697\n",
+       "IlaWk5Br93wkk+jztusP7o94Lna7eaoMZU0cVXIAped7eqGZfP2ZqmPFl+ptrVf3n19UpvVMYLRS\n",
+       "agBywxuEjLwWAe9qrTMXV2mUzs7OP/Xrp+6qt33Hmn5Zue3XNeZTOVoky5nqKiQkrNT883Qk3WvJ\n",
+       "sMLAc1bbrv9Z5AH6KWRkOB+5wRWlWo7a3Ga7/mOIomAho/GFyI30YeDREru7ELlOq07TG3jONbbr\n",
+       "T0Nu9KOQm+i/gFsDz3nTdv2fI2FbpdpfHnlpH4LcnHdAlIz5yLErqXgFnvOR7fo28lDYE7lu3kKO\n",
+       "TdZ9K52xrhTl7knnUVB6SqVeTsr4apQU6lDEbG4hCsFbROsRBE1ebjrwnNB2/XGIGf5gRBkYhPyv\n",
+       "7yDpjR9MtVkOnGK7/vWIgrFrVPcF4O8ZKbaXIuduWkH6KfL/JbkEsWClfWK2CDzHt10/jzhXjkGO\n",
+       "yzNIZEiRD00ga3ocaLv+kUh2xo8hSuVURKmIUyiXVGYCWVzKQlJD7xrJNg85b9LX8RLgF6X6SpFU\n",
+       "9Cpe28gaJgORqEEAbNffDLlvHIQoAndR8NEYilwjExD/nwuUiTQ0GAwGw7qC7fqjEUvKqsBzmhWd\n",
+       "t05gu/5pyNoifw48J9N5PForxQeeNFMMBoPBYDD0DWL/llvK1In9jt4zCoLBYDAYDH2DePo5MwrJ\n",
+       "dv0hFPwTnjBRDAaDwWAw9A3+hPgOHRPl25iK+FhsiuR4OARx0Lwf+J1REAwGg8Fg6AMEnvNklL78\n",
+       "HMRRca/E5hVINNIVwI2B56z6/3ExLRI31pXNAAAAAElFTkSuQmCC\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Image at 0x111275490>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "Image(\"http://ipython.org/_static/IPy_header.png\")"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
  No newline at end of file

IPython/nbformat/v4/__init__.py

@@ -0,0 +1,19 b''
+"""The main API for the v4 notebook format."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from .nbbase import (
+    nbformat, nbformat_minor, nbformat_schema,
+    new_code_cell, new_markdown_cell, new_notebook,
+    new_output, output_from_msg,
+)
+
+from .nbjson import reads, writes, to_notebook
+reads_json = reads
+writes_json = writes
+to_notebook_json = to_notebook
+
+from .convert import downgrade, upgrade
+
+

IPython/nbformat/v4/convert.py

@@ -0,0 +1,249 b''
+"""Code for converting notebooks to and from v3."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import json
+import re
+
+from .nbbase import (
+    nbformat, nbformat_minor,
+    NotebookNode,
+)
+
+from IPython.nbformat import v3
+from IPython.utils.log import get_logger
+
+def _warn_if_invalid(nb, version):
+    """Log validation errors, if there are any."""
+    from IPython.nbformat import validate, ValidationError
+    try:
+        validate(nb, version=version)
+    except ValidationError as e:
+        get_logger().error("Notebook JSON is not valid v%i: %s", version, e)
+
+def upgrade(nb, from_version=3, from_minor=0):
+    """Convert a notebook to v4.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The Python representation of the notebook to convert.
+    from_version : int
+        The original version of the notebook to convert.
+    from_minor : int
+        The original minor version of the notebook to convert (only relevant for v >= 3).
+    """
+    if from_version == 3:
+        # Validate the notebook before conversion
+        _warn_if_invalid(nb, from_version)
+
+        # Mark the original nbformat so consumers know it has been converted
+        orig_nbformat = nb.pop('orig_nbformat', None)
+        nb.metadata.orig_nbformat = orig_nbformat or 3
+
+        # Mark the new format
+        nb.nbformat = nbformat
+        nb.nbformat_minor = nbformat_minor
+
+        # remove worksheet(s)
+        nb['cells'] = cells = []
+        # In the unlikely event of multiple worksheets,
+        # they will be flattened
+        for ws in nb.pop('worksheets', []):
+            # upgrade each cell
+            for cell in ws['cells']:
+                cells.append(upgrade_cell(cell))
+        # upgrade metadata
+        nb.metadata.pop('name', '')
+        # Validate the converted notebook before returning it
+        _warn_if_invalid(nb, nbformat)
+        return nb
+    elif from_version == 4:
+        # nothing to do
+        if from_minor != nbformat_minor:
+            nb.metadata.orig_nbformat_minor = from_minor
+        nb.nbformat_minor = nbformat_minor
+
+        return nb
+    else:
+        raise ValueError('Cannot convert a notebook directly from v%s to v4.  ' \
+                'Try using the IPython.nbformat.convert module.' % from_version)
+
+def upgrade_cell(cell):
+    """upgrade a cell from v3 to v4
+
+    heading cell -> markdown heading
+    code cell:
+        - remove language metadata
+        - cell.input -> cell.source
+        - cell.prompt_number -> cell.execution_count
+        - update outputs
+    """
+    cell.setdefault('metadata', NotebookNode())
+    if cell.cell_type == 'code':
+        cell.pop('language', '')
+        if 'collapsed' in cell:
+            cell.metadata['collapsed'] = cell.pop('collapsed')
+        cell.source = cell.pop('input', '')
+        cell.execution_count = cell.pop('prompt_number', None)
+        cell.outputs = upgrade_outputs(cell.outputs)
+    elif cell.cell_type == 'heading':
+        cell.cell_type = 'markdown'
+        level = cell.pop('level', 1)
+        cell.source = u'{hashes} {single_line}'.format(
+            hashes='#' * level,
+            single_line = ' '.join(cell.get('source', '').splitlines()),
+        )
+    elif cell.cell_type == 'html':
+        # Technically, this exists. It will never happen in practice.
+        cell.cell_type = 'markdown'
+    return cell
+
+def downgrade_cell(cell):
+    """downgrade a cell from v4 to v3
+
+    code cell:
+        - set cell.language
+        - cell.input <- cell.source
+        - cell.prompt_number <- cell.execution_count
+        - update outputs
+    markdown cell:
+        - single-line heading -> heading cell
+    """
+    if cell.cell_type == 'code':
+        cell.language = 'python'
+        cell.input = cell.pop('source', '')
+        cell.prompt_number = cell.pop('execution_count', None)
+        cell.collapsed = cell.metadata.pop('collapsed', False)
+        cell.outputs = downgrade_outputs(cell.outputs)
+    elif cell.cell_type == 'markdown':
+        source = cell.get('source', '')
+        if '\n' not in source and source.startswith('#'):
+            prefix, text = re.match(r'(#+)\s*(.*)', source).groups()
+            cell.cell_type = 'heading'
+            cell.source = text
+            cell.level = len(prefix)
+    return cell
+
+_mime_map = {
+    "text" : "text/plain",
+    "html" : "text/html",
+    "svg" : "image/svg+xml",
+    "png" : "image/png",
+    "jpeg" : "image/jpeg",
+    "latex" : "text/latex",
+    "json" : "application/json",
+    "javascript" : "application/javascript",
+};
+
+def to_mime_key(d):
+    """convert dict with v3 aliases to plain mime-type keys"""
+    for alias, mime in _mime_map.items():
+        if alias in d:
+            d[mime] = d.pop(alias)
+    return d
+
+def from_mime_key(d):
+    """convert dict with mime-type keys to v3 aliases"""
+    for alias, mime in _mime_map.items():
+        if mime in d:
+            d[alias] = d.pop(mime)
+    return d
+
+def upgrade_output(output):
+    """upgrade a single code cell output from v3 to v4
+
+    - pyout -> execute_result
+    - pyerr -> error
+    - output.type -> output.data.mime/type
+    - mime-type keys
+    - stream.stream -> stream.name
+    """
+    if output['output_type'] in {'pyout', 'display_data'}:
+        output.setdefault('metadata', NotebookNode())
+        if output['output_type'] == 'pyout':
+            output['output_type'] = 'execute_result'
+            output['execution_count'] = output.pop('prompt_number', None)
+
+        # move output data into data sub-dict
+        data = {}
+        for key in list(output):
+            if key in {'output_type', 'execution_count', 'metadata'}:
+                continue
+            data[key] = output.pop(key)
+        to_mime_key(data)
+        output['data'] = data
+        to_mime_key(output.metadata)
+        if 'application/json' in data:
+            data['application/json'] = json.loads(data['application/json'])
+        # promote ascii bytes (from v2) to unicode
+        for key in ('image/png', 'image/jpeg'):
+            if key in data and isinstance(data[key], bytes):
+                data[key] = data[key].decode('ascii')
+    elif output['output_type'] == 'pyerr':
+        output['output_type'] = 'error'
+    elif output['output_type'] == 'stream':
+        output['name'] = output.pop('stream')
+    return output
+
+def downgrade_output(output):
+    """downgrade a single code cell output to v3 from v4
+
+    - pyout <- execute_result
+    - pyerr <- error
+    - output.data.mime/type -> output.type
+    - un-mime-type keys
+    - stream.stream <- stream.name
+    """
+    if output['output_type'] in {'execute_result', 'display_data'}:
+        if output['output_type'] == 'execute_result':
+            output['output_type'] = 'pyout'
+            output['prompt_number'] = output.pop('execution_count', None)
+
+        # promote data dict to top-level output namespace
+        data = output.pop('data', {})
+        if 'application/json' in data:
+            data['application/json'] = json.dumps(data['application/json'])
+        from_mime_key(data)
+        output.update(data)
+        from_mime_key(output.get('metadata', {}))
+    elif output['output_type'] == 'error':
+        output['output_type'] = 'pyerr'
+    elif output['output_type'] == 'stream':
+        output['stream'] = output.pop('name')
+    return output
+
+def upgrade_outputs(outputs):
+    """upgrade outputs of a code cell from v3 to v4"""
+    return [upgrade_output(op) for op in outputs]
+
+def downgrade_outputs(outputs):
+    """downgrade outputs of a code cell to v3 from v4"""
+    return [downgrade_output(op) for op in outputs]
+
+def downgrade(nb):
+    """Convert a v4 notebook to v3.
+
+    Parameters
+    ----------
+    nb : NotebookNode
+        The Python representation of the notebook to convert.
+    """
+    if nb.nbformat != nbformat:
+        return nb
+
+    # Validate the notebook before conversion
+    _warn_if_invalid(nb, nbformat)
+
+    nb.nbformat = v3.nbformat
+    nb.nbformat_minor = v3.nbformat_minor
+    cells = [ downgrade_cell(cell) for cell in nb.pop('cells') ]
+    nb.worksheets = [v3.new_worksheet(cells=cells)]
+    nb.metadata.setdefault('name', '')
+    nb.metadata.pop('orig_nbformat', None)
+    nb.metadata.pop('orig_nbformat_minor', None)
+
+    # Validate the converted notebook before returning it
+    _warn_if_invalid(nb, v3.nbformat)
+    return nb

IPython/nbformat/v4/nbbase.py

@@ -0,0 +1,137 b''
+"""Python API for composing notebook elements
+
+The Python representation of a notebook is a nested structure of
+dictionary subclasses that support attribute access
+(IPython.utils.ipstruct.Struct). The functions in this module are merely
+helpers to build the structs in the right form.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from ..notebooknode import from_dict, NotebookNode
+
+# Change this when incrementing the nbformat version
+nbformat = 4
+nbformat_minor = 0
+nbformat_schema = 'nbformat.v4.schema.json'
+
+
+def validate(node, ref=None):
+    """validate a v4 node"""
+    from .. import validate
+    return validate(node, ref=ref, version=nbformat)
+
+
+def new_output(output_type, data=None, **kwargs):
+    """Create a new output, to go in the ``cell.outputs`` list of a code cell."""
+    output = NotebookNode(output_type=output_type)
+
+    # populate defaults:
+    if output_type == 'stream':
+        output.name = u'stdout'
+        output.text = u''
+    elif output_type in {'execute_result', 'display_data'}:
+        output.metadata = NotebookNode()
+        output.data = NotebookNode()
+    # load from args:
+    output.update(from_dict(kwargs))
+    if data is not None:
+        output.data = from_dict(data)
+    # validate
+    validate(output, output_type)
+    return output
+
+
+def output_from_msg(msg):
+    """Create a NotebookNode for an output from a kernel's IOPub message.
+
+    Returns
+    -------
+
+    NotebookNode: the output as a notebook node.
+
+    Raises
+    ------
+
+    ValueError: if the message is not an output message.
+
+    """
+    msg_type = msg['header']['msg_type']
+    content = msg['content']
+
+    if msg_type == 'execute_result':
+        return new_output(output_type=msg_type,
+            metadata=content['metadata'],
+            data=content['data'],
+            execution_count=content['execution_count'],
+        )
+    elif msg_type == 'stream':
+        return new_output(output_type=msg_type,
+            name=content['name'],
+            text=content['text'],
+        )
+    elif msg_type == 'display_data':
+        return new_output(output_type=msg_type,
+            metadata=content['metadata'],
+            data=content['data'],
+        )
+    elif msg_type == 'error':
+        return new_output(output_type=msg_type,
+            ename=content['ename'],
+            evalue=content['evalue'],
+            traceback=content['traceback'],
+        )
+    else:
+        raise ValueError("Unrecognized output msg type: %r" % msg_type)
+
+
+def new_code_cell(source='', **kwargs):
+    """Create a new code cell"""
+    cell = NotebookNode(
+        cell_type='code',
+        metadata=NotebookNode(),
+        execution_count=None,
+        source=source,
+        outputs=[],
+    )
+    cell.update(from_dict(kwargs))
+
+    validate(cell, 'code_cell')
+    return cell
+
+def new_markdown_cell(source='', **kwargs):
+    """Create a new markdown cell"""
+    cell = NotebookNode(
+        cell_type='markdown',
+        source=source,
+        metadata=NotebookNode(),
+    )
+    cell.update(from_dict(kwargs))
+
+    validate(cell, 'markdown_cell')
+    return cell
+
+def new_raw_cell(source='', **kwargs):
+    """Create a new raw cell"""
+    cell = NotebookNode(
+        cell_type='raw',
+        source=source,
+        metadata=NotebookNode(),
+    )
+    cell.update(from_dict(kwargs))
+
+    validate(cell, 'raw_cell')
+    return cell
+
+def new_notebook(**kwargs):
+    """Create a new notebook"""
+    nb = NotebookNode(
+        nbformat=nbformat,
+        nbformat_minor=nbformat_minor,
+        metadata=NotebookNode(),
+        cells=[],
+    )
+    nb.update(from_dict(kwargs))
+    validate(nb)
+    return nb

IPython/nbformat/v4/nbformat.v4.schema.json

@@ -0,0 +1,308 b''
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "IPython Notebook v4.0 JSON schema.",
+    "type": "object",
+    "additionalProperties": false,
+    "required": ["metadata", "nbformat_minor", "nbformat", "cells"],
+    "properties": {
+        "metadata": {
+            "description": "Notebook root-level metadata.",
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+                "kernel_info": {
+                    "description": "Kernel information.",
+                    "type": "object",
+                    "required": ["name", "language"],
+                    "properties": {
+                        "name": {
+                            "description": "Name of the kernel specification.",
+                            "type": "string"
+                        },
+                        "language": {
+                            "description": "The programming language which this kernel runs.",
+                            "type": "string"
+                        },
+                        "codemirror_mode": {
+                            "description": "The codemirror mode to use for code in this language.",
+                            "type": "string"
+                        }
+                    }
+                },
+                "signature": {
+                    "description": "Hash of the notebook.",
+                    "type": "string"
+                },
+                "orig_nbformat": {
+                    "description": "Original notebook format (major number) before converting the notebook between versions. This should never be written to a file.",
+                    "type": "integer",
+                    "minimum": 1
+                }
+            }
+        },
+        "nbformat_minor": {
+            "description": "Notebook format (minor number). Incremented for backward compatible changes to the notebook format.",
+            "type": "integer",
+            "minimum": 0
+        },
+        "nbformat": {
+            "description": "Notebook format (major number). Incremented between backwards incompatible changes to the notebook format.",
+            "type": "integer",
+            "minimum": 4,
+            "maximum": 4
+        },
+        "cells": {
+            "description": "Array of cells of the current notebook.",
+            "type": "array",
+            "items": {
+                "type": "object",
+                "oneOf": [
+                    {"$ref": "#/definitions/raw_cell"},
+                    {"$ref": "#/definitions/markdown_cell"},
+                    {"$ref": "#/definitions/code_cell"}
+                ]
+            }
+        }
+    },
+
+    "definitions": {
+
+        "raw_cell": {
+            "description": "Notebook raw nbconvert cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["cell_type", "metadata", "source"],
+            "properties": {
+                "cell_type": {
+                    "description": "String identifying the type of cell.",
+                    "enum": ["raw"]
+                },
+                "metadata": {
+                    "description": "Cell-level metadata.",
+                    "type": "object",
+                    "additionalProperties": true,
+                    "properties": {
+                        "format": {
+                            "description": "Raw cell metadata format for nbconvert.",
+                            "type": "string"
+                        },
+                        "name": {"$ref": "#/definitions/misc/metadata_name"},
+                        "tags": {"$ref": "#/definitions/misc/metadata_tags"}
+                    }
+                },
+                "source": {"$ref": "#/definitions/misc/source"}
+            }
+        },
+
+        "markdown_cell": {
+            "description": "Notebook markdown cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["cell_type", "metadata", "source"],
+            "properties": {
+                "cell_type": {
+                    "description": "String identifying the type of cell.",
+                    "enum": ["markdown"]
+                },
+                "metadata": {
+                    "description": "Cell-level metadata.",
+                    "type": "object",
+                    "properties": {
+                        "name": {"$ref": "#/definitions/misc/metadata_name"},
+                        "tags": {"$ref": "#/definitions/misc/metadata_tags"}
+                    },
+                    "additionalProperties": true
+                },
+                "source": {"$ref": "#/definitions/misc/source"}
+            }
+        },
+
+        "code_cell": {
+            "description": "Notebook code cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["cell_type", "metadata", "source", "outputs", "execution_count"],
+            "properties": {
+                "cell_type": {
+                    "description": "String identifying the type of cell.",
+                    "enum": ["code"]
+                },
+                "metadata": {
+                    "description": "Cell-level metadata.",
+                    "type": "object",
+                    "additionalProperties": true,
+                    "properties": {
+                        "collapsed": {
+                            "description": "Whether the cell is collapsed/expanded.",
+                            "type": "boolean"
+                        },
+                        "autoscroll": {
+                            "description": "Whether the cell's output is scrolled, unscrolled, or autoscrolled.",
+                            "enum": [true, false, "auto"]
+                        },
+                        "name": {"$ref": "#/definitions/misc/metadata_name"},
+                        "tags": {"$ref": "#/definitions/misc/metadata_tags"}
+                    }
+                },
+                "source": {"$ref": "#/definitions/misc/source"},
+                "outputs": {
+                    "description": "Execution, display, or stream outputs.",
+                    "type": "array",
+                    "items": {"$ref": "#/definitions/output"}
+                },
+                "execution_count": {
+                    "description": "The code cell's prompt number. Will be null if the cell has not been run.",
+                    "type": ["integer", "null"],
+                    "minimum": 0
+                }
+            }
+        },
+        "output": {
+            "type": "object",
+            "oneOf": [
+                {"$ref": "#/definitions/execute_result"},
+                {"$ref": "#/definitions/display_data"},
+                {"$ref": "#/definitions/stream"},
+                {"$ref": "#/definitions/error"}
+            ]
+        },
+
+        "execute_result": {
+            "description": "Result of executing a code cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type", "data", "metadata", "execution_count"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["execute_result"]
+                },
+                "execution_count": {
+                    "description": "A result's prompt number.",
+                    "type": ["integer", "null"],
+                    "minimum": 0
+                },
+                "data": {"$ref": "#/definitions/misc/mimebundle"},
+                "metadata": {"$ref": "#/definitions/misc/output_metadata"}
+            }
+        },
+
+        "display_data": {
+            "description": "Data displayed as a result of code cell execution.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type", "data", "metadata"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["display_data"]
+                },
+                "data": {"$ref": "#/definitions/misc/mimebundle"},
+                "metadata": {"$ref": "#/definitions/misc/output_metadata"}
+            }
+        },
+
+        "stream": {
+            "description": "Stream output from a code cell.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type", "name", "text"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["stream"]
+                },
+                "name": {
+                    "description": "The name of the stream (stdout, stderr).",
+                    "type": "string"
+                },
+                "text": {
+                    "description": "The stream's text output, represented as an array of strings.",
+                    "$ref": "#/definitions/misc/multiline_string"
+                }
+            }
+        },
+
+        "error": {
+            "description": "Output of an error that occurred during code cell execution.",
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["output_type", "ename", "evalue", "traceback"],
+            "properties": {
+                "output_type": {
+                    "description": "Type of cell output.",
+                    "enum": ["error"]
+                },
+                "ename": {
+                    "description": "The name of the error.",
+                    "type": "string"
+                },
+                "evalue": {
+                    "description": "The value, or message, of the error.",
+                    "type": "string"
+                },
+                "traceback": {
+                    "description": "The error's traceback, represented as an array of strings.",
+                    "type": "array",
+                    "items": {"type": "string"}
+                }
+            }
+        },
+
+        "misc": {
+            "metadata_name": {
+                "description": "The cell's name. If present, must be a non-empty string.",
+                "type": "string",
+                "pattern": "^.+$"
+            },
+            "metadata_tags": {
+                "description": "The cell's tags. Tags must be unique, and must not contain commas.",
+                "type": "array",
+                "uniqueItems": true,
+                "items": {
+                    "type": "string",
+                    "pattern": "^[^,]+$"
+                }
+            },
+            "source": {
+                "description": "Contents of the cell, represented as an array of lines.",
+                "$ref": "#/definitions/misc/multiline_string"
+            },
+            "execution_count": {
+                "description": "The code cell's prompt number. Will be null if the cell has not been run.",
+                "type": ["integer", "null"],
+                "minimum": 0
+            },
+            "mimebundle": {
+                "description": "A mime-type keyed dictionary of data",
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                    "application/json": {
+                        "type": "object"
+                    }
+                },
+                "patternProperties": {
+                    "^(?!application/json$)[a-zA-Z0-9]+/[a-zA-Z0-9\\-\\+\\.]+$": {
+                        "description": "mimetype output (e.g. text/plain), represented as either an array of strings or a string.",
+                        "$ref": "#/definitions/misc/multiline_string"
+                    }
+                }
+            },
+            "output_metadata": {
+                "description": "Cell output metadata.",
+                "type": "object",
+                "additionalProperties": true
+            },
+            "multiline_string": {
+                "oneOf" : [
+                    {"type": "string"},
+                    {
+                        "type": "array",
+                        "items": {"type": "string"}
+                    }
+                ]
+            }
+        }
+    }
+}

IPython/nbformat/v4/nbjson.py

@@ -0,0 +1,67 b''
+"""Read and write notebooks in JSON format."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import copy
+import json
+
+from IPython.utils import py3compat
+
+from .nbbase import from_dict
+from .rwbase import (
+    NotebookReader, NotebookWriter, rejoin_lines, split_lines, strip_transient
+)
+
+
+class BytesEncoder(json.JSONEncoder):
+    """A JSON encoder that accepts b64 (and other *ascii*) bytestrings."""
+    def default(self, obj):
+        if isinstance(obj, bytes):
+            return obj.decode('ascii')
+        return json.JSONEncoder.default(self, obj)
+
+
+class JSONReader(NotebookReader):
+
+    def reads(self, s, **kwargs):
+        """Read a JSON string into a Notebook object"""
+        nb = json.loads(s, **kwargs)
+        nb = self.to_notebook(nb, **kwargs)
+        return nb
+
+    def to_notebook(self, d, **kwargs):
+        """Convert a disk-format notebook dict to in-memory NotebookNode
+        
+        handles multi-line values as strings, scrubbing of transient values, etc.
+        """
+        nb = from_dict(d)
+        nb = rejoin_lines(nb)
+        nb = strip_transient(nb)
+        return nb
+
+
+class JSONWriter(NotebookWriter):
+
+    def writes(self, nb, **kwargs):
+        """Serialize a NotebookNode object as a JSON string"""
+        kwargs['cls'] = BytesEncoder
+        kwargs['indent'] = 1
+        kwargs['sort_keys'] = True
+        kwargs['separators'] = (',',': ')
+        # don't modify in-memory dict
+        nb = copy.deepcopy(nb)
+        if kwargs.pop('split_lines', True):
+            nb = split_lines(nb)
+        nb = strip_transient(nb)
+        return py3compat.str_to_unicode(json.dumps(nb, **kwargs), 'utf-8')
+
+
+_reader = JSONReader()
+_writer = JSONWriter()
+
+reads = _reader.reads
+read = _reader.read
+to_notebook = _reader.to_notebook
+write = _writer.write
+writes = _writer.writes

IPython/nbformat/v4/rwbase.py

@@ -0,0 +1,95 b''
+"""Base classes and utilities for readers and writers."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+from IPython.utils.py3compat import string_types, cast_unicode_py2
+
+
+def rejoin_lines(nb):
+    """rejoin multiline text into strings
+
+    For reversing effects of ``split_lines(nb)``.
+
+    This only rejoins lines that have been split, so if text objects were not split
+    they will pass through unchanged.
+
+    Used when reading JSON files that may have been passed through split_lines.
+    """
+    for cell in nb.cells:
+        if 'source' in cell and isinstance(cell.source, list):
+            cell.source = ''.join(cell.source)
+        if cell.get('cell_type', None) == 'code':
+            for output in cell.get('outputs', []):
+                output_type = output.get('output_type', '')
+                if output_type in {'execute_result', 'display_data'}:
+                    for key, value in output.get('data', {}).items():
+                        if key != 'application/json' and isinstance(value, list):
+                            output.data[key] = ''.join(value)
+                elif output_type:
+                    if isinstance(output.get('text', ''), list):
+                        output.text = ''.join(output.text)
+    return nb
+
+
+def split_lines(nb):
+    """split likely multiline text into lists of strings
+
+    For file output more friendly to line-based VCS. ``rejoin_lines(nb)`` will
+    reverse the effects of ``split_lines(nb)``.
+
+    Used when writing JSON files.
+    """
+    for cell in nb.cells:
+        source = cell.get('source', None)
+        if isinstance(source, string_types):
+            cell['source'] = source.splitlines(True)
+
+        if cell.cell_type == 'code':
+            for output in cell.outputs:
+                if output.output_type in {'execute_result', 'display_data'}:
+                    for key, value in output.data.items():
+                        if key != 'application/json' and isinstance(value, string_types):
+                            output.data[key] = value.splitlines(True)
+                elif output.output_type == 'stream':
+                    if isinstance(output.text, string_types):
+                        output.text = output.text.splitlines(True)
+    return nb
+
+
+def strip_transient(nb):
+    """Strip transient values that shouldn't be stored in files.
+
+    This should be called in *both* read and write.
+    """
+    nb.metadata.pop('orig_nbformat', None)
+    nb.metadata.pop('orig_nbformat_minor', None)
+    for cell in nb.cells:
+        cell.metadata.pop('trusted', None)
+    return nb
+
+
+class NotebookReader(object):
+    """A class for reading notebooks."""
+
+    def reads(self, s, **kwargs):
+        """Read a notebook from a string."""
+        raise NotImplementedError("loads must be implemented in a subclass")
+
+    def read(self, fp, **kwargs):
+        """Read a notebook from a file like object"""
+        nbs = cast_unicode_py2(fp.read())
+        return self.reads(nbs, **kwargs)
+
+
+class NotebookWriter(object):
+    """A class for writing notebooks."""
+
+    def writes(self, nb, **kwargs):
+        """Write a notebook to a string."""
+        raise NotImplementedError("loads must be implemented in a subclass")
+
+    def write(self, nb, fp, **kwargs):
+        """Write a notebook to a file like object"""
+        nbs = cast_unicode_py2(self.writes(nb, **kwargs))
+        return fp.write(nbs)

IPython/nbformat/v4/tests/formattest.py

@@ -0,0 +1,54 b''
+# -*- coding: utf8 -*-
+import io
+import os
+import shutil
+import tempfile
+
+pjoin = os.path.join
+
+from .nbexamples import nb0
+
+
+def open_utf8(fname, mode):
+    return io.open(fname, mode=mode, encoding='utf-8')
+
+class NBFormatTest:
+    """Mixin for writing notebook format tests"""
+
+    # override with appropriate values in subclasses
+    nb0_ref = None
+    ext = None
+    mod = None
+
+    def setUp(self):
+        self.wd = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.wd)
+
+    def assertNBEquals(self, nba, nbb):
+        self.assertEqual(nba, nbb)
+
+    def test_writes(self):
+        s = self.mod.writes(nb0)
+        if self.nb0_ref:
+            self.assertEqual(s, self.nb0_ref)
+
+    def test_reads(self):
+        s = self.mod.writes(nb0)
+        nb = self.mod.reads(s)
+
+    def test_roundtrip(self):
+        s = self.mod.writes(nb0)
+        self.assertNBEquals(self.mod.reads(s),nb0)
+
+    def test_write_file(self):
+        with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'w') as f:
+            self.mod.write(nb0, f)
+
+    def test_read_file(self):
+        with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'w') as f:
+            self.mod.write(nb0, f)
+
+        with open_utf8(pjoin(self.wd, "nb0.%s" % self.ext), 'r') as f:
+            nb = self.mod.read(f)

IPython/nbformat/v4/tests/nbexamples.py

@@ -0,0 +1,104 b''
+# -*- coding: utf-8 -*-
+
+import os
+from base64 import encodestring
+
+from ..nbbase import (
+    new_code_cell, new_markdown_cell, new_notebook,
+    new_output, new_raw_cell
+)
+
+# some random base64-encoded *text*
+png = encodestring(os.urandom(5)).decode('ascii')
+jpeg = encodestring(os.urandom(6)).decode('ascii')
+
+cells = []
+cells.append(new_markdown_cell(
+    source='Some NumPy Examples',
+))
+
+
+cells.append(new_code_cell(
+    source='import numpy',
+    execution_count=1,
+))
+
+cells.append(new_markdown_cell(
+    source='A random array',
+))
+
+cells.append(new_raw_cell(
+    source='A random array',
+))
+
+cells.append(new_markdown_cell(
+    source=u'## My Heading',
+))
+
+cells.append(new_code_cell(
+    source='a = numpy.random.rand(100)',
+    execution_count=2,
+))
+cells.append(new_code_cell(
+    source='a = 10\nb = 5\n',
+    execution_count=3,
+))
+cells.append(new_code_cell(
+    source='a = 10\nb = 5',
+    execution_count=4,
+))
+
+cells.append(new_code_cell(
+    source=u'print "ünîcødé"',
+    execution_count=3,
+    outputs=[new_output(
+        output_type=u'execute_result',
+        data={
+            'text/plain': u'<array a>',
+            'text/html': u'The HTML rep',
+            'text/latex': u'$a$',
+            'image/png': png,
+            'image/jpeg': jpeg,
+            'image/svg+xml': u'<svg>',
+            'application/json': {
+                'key': 'value'
+            },
+            'application/javascript': u'var i=0;'
+        },
+        execution_count=3
+    ),new_output(
+        output_type=u'display_data',
+        data={
+            'text/plain': u'<array a>',
+            'text/html': u'The HTML rep',
+            'text/latex': u'$a$',
+            'image/png': png,
+            'image/jpeg': jpeg,
+            'image/svg+xml': u'<svg>',
+            'application/json': {
+                'key': 'value'
+            },
+            'application/javascript': u'var i=0;'
+        },
+    ),new_output(
+        output_type=u'error',
+        ename=u'NameError',
+        evalue=u'NameError was here',
+        traceback=[u'frame 0', u'frame 1', u'frame 2']
+    ),new_output(
+        output_type=u'stream',
+        text='foo\rbar\r\n'
+    ),new_output(
+        output_type=u'stream',
+        name='stderr',
+        text='\rfoo\rbar\n'
+    )]
+))
+
+nb0 = new_notebook(cells=cells,
+    metadata={
+        'language': 'python',
+    }
+)
+
+

IPython/nbformat/v4/tests/test_convert.py

@@ -0,0 +1,72 b''
+# -*- coding: utf-8 -*-
+import copy
+
+import nose.tools as nt
+
+from IPython.nbformat import validate
+from .. import convert
+
+from . import nbexamples
+from IPython.nbformat.v3.tests import nbexamples as v3examples
+from IPython.nbformat import v3, v4
+
+def test_upgrade_notebook():
+    nb03 = copy.deepcopy(v3examples.nb0)
+    validate(nb03)
+    nb04 = convert.upgrade(nb03)
+    validate(nb04)
+
+def test_downgrade_notebook():
+    nb04 = copy.deepcopy(nbexamples.nb0)
+    validate(nb04)
+    nb03 = convert.downgrade(nb04)
+    validate(nb03)
+
+def test_upgrade_heading():
+    v3h = v3.new_heading_cell
+    v4m = v4.new_markdown_cell
+    for v3cell, expected in [
+        (
+            v3h(source='foo', level=1),
+            v4m(source='# foo'),
+        ),
+        (
+            v3h(source='foo\nbar\nmulti-line\n', level=4),
+            v4m(source='#### foo bar multi-line'),
+        ),
+        (
+            v3h(source=u'ünìcö∂e–cønvërsioñ', level=4),
+            v4m(source=u'#### ünìcö∂e–cønvërsioñ'),
+        ),
+    ]:
+        upgraded = convert.upgrade_cell(v3cell)
+        nt.assert_equal(upgraded, expected)
+
+def test_downgrade_heading():
+    v3h = v3.new_heading_cell
+    v4m = v4.new_markdown_cell
+    v3m = lambda source: v3.new_text_cell('markdown', source)
+    for v4cell, expected in [
+        (
+            v4m(source='# foo'),
+            v3h(source='foo', level=1),
+        ),
+        (
+            v4m(source='#foo'),
+            v3h(source='foo', level=1),
+        ),
+        (
+            v4m(source='#\tfoo'),
+            v3h(source='foo', level=1),
+        ),
+        (
+            v4m(source='# \t  foo'),
+            v3h(source='foo', level=1),
+        ),
+        (
+            v4m(source='# foo\nbar'),
+            v3m(source='# foo\nbar'),
+        ),
+    ]:
+        downgraded = convert.downgrade_cell(v4cell)
+        nt.assert_equal(downgraded, expected)

IPython/nbformat/v4/tests/test_json.py

@@ -0,0 +1,69 b''
+from base64 import decodestring
+from unittest import TestCase
+
+from IPython.utils.py3compat import unicode_type
+from ..nbjson import reads, writes
+from .. import nbjson
+from .nbexamples import nb0
+
+from . import formattest
+
+
+class TestJSON(formattest.NBFormatTest, TestCase):
+
+    nb0_ref = None
+    ext = 'ipynb'
+    mod = nbjson
+
+    def test_roundtrip_nosplit(self):
+        """Ensure that multiline blobs are still readable"""
+        # ensures that notebooks written prior to splitlines change
+        # are still readable.
+        s = writes(nb0, split_lines=False)
+        self.assertEqual(nbjson.reads(s),nb0)
+
+    def test_roundtrip_split(self):
+        """Ensure that splitting multiline blocks is safe"""
+        # This won't differ from test_roundtrip unless the default changes
+        s = writes(nb0, split_lines=True)
+        self.assertEqual(nbjson.reads(s),nb0)
+
+    def test_read_png(self):
+        """PNG output data is b64 unicode"""
+        s = writes(nb0)
+        nb1 = nbjson.reads(s)
+        found_png = False
+        for cell in nb1.cells:
+            if not 'outputs' in cell:
+                continue
+            for output in cell.outputs:
+                if not 'data' in output:
+                    continue
+                if 'image/png' in output.data:
+                    found_png = True
+                    pngdata = output.data['image/png']
+                    self.assertEqual(type(pngdata), unicode_type)
+                    # test that it is valid b64 data
+                    b64bytes = pngdata.encode('ascii')
+                    raw_bytes = decodestring(b64bytes)
+        assert found_png, "never found png output"
+
+    def test_read_jpeg(self):
+        """JPEG output data is b64 unicode"""
+        s = writes(nb0)
+        nb1 = nbjson.reads(s)
+        found_jpeg = False
+        for cell in nb1.cells:
+            if not 'outputs' in cell:
+                continue
+            for output in cell.outputs:
+                if not 'data' in output:
+                    continue
+                if 'image/jpeg' in output.data:
+                    found_jpeg = True
+                    jpegdata = output.data['image/jpeg']
+                    self.assertEqual(type(jpegdata), unicode_type)
+                    # test that it is valid b64 data
+                    b64bytes = jpegdata.encode('ascii')
+                    raw_bytes = decodestring(b64bytes)
+        assert found_jpeg, "never found jpeg output"

IPython/nbformat/v4/tests/test_nbbase.py

@@ -0,0 +1,101 b''
+# coding: utf-8
+"""Tests for the Python API for composing notebook elements"""
+
+import nose.tools as nt
+
+from IPython.nbformat.validator import isvalid, validate, ValidationError
+from ..nbbase import (
+    NotebookNode, nbformat,
+    new_code_cell, new_markdown_cell, new_notebook,
+    new_output, new_raw_cell,
+)
+
+def test_empty_notebook():
+    nb = new_notebook()
+    nt.assert_equal(nb.cells, [])
+    nt.assert_equal(nb.metadata, NotebookNode())
+    nt.assert_equal(nb.nbformat, nbformat)
+
+def test_empty_markdown_cell():
+    cell = new_markdown_cell()
+    nt.assert_equal(cell.cell_type, 'markdown')
+    nt.assert_equal(cell.source, '')
+
+def test_markdown_cell():
+    cell = new_markdown_cell(u'* Søme markdown')
+    nt.assert_equal(cell.source, u'* Søme markdown')
+
+def test_empty_raw_cell():
+    cell = new_raw_cell()
+    nt.assert_equal(cell.cell_type, u'raw')
+    nt.assert_equal(cell.source, '')
+
+def test_raw_cell():
+    cell = new_raw_cell('hi')
+    nt.assert_equal(cell.source, u'hi')
+
+def test_empty_code_cell():
+    cell = new_code_cell('hi')
+    nt.assert_equal(cell.cell_type, 'code')
+    nt.assert_equal(cell.source, u'hi')
+
+def test_empty_display_data():
+    output = new_output('display_data')
+    nt.assert_equal(output.output_type, 'display_data')
+
+def test_empty_stream():
+    output = new_output('stream')
+    nt.assert_equal(output.output_type, 'stream')
+    nt.assert_equal(output.name, 'stdout')
+    nt.assert_equal(output.text, '')
+
+def test_empty_execute_result():
+    output = new_output('execute_result', execution_count=1)
+    nt.assert_equal(output.output_type, 'execute_result')
+
+mimebundle = {
+    'text/plain': "some text",
+    "application/json": {
+        "key": "value"
+    },
+    "image/svg+xml": 'ABCDEF',
+    "application/octet-stream": 'ABC-123',
+    "application/vnd.foo+bar": "Some other stuff",
+}
+
+def test_display_data():
+    output = new_output('display_data', mimebundle)
+    for key, expected in mimebundle.items():
+        nt.assert_equal(output.data[key], expected)
+
+def test_execute_result():
+    output = new_output('execute_result', mimebundle, execution_count=10)
+    nt.assert_equal(output.execution_count, 10)
+    for key, expected in mimebundle.items():
+        nt.assert_equal(output.data[key], expected)
+
+def test_error():
+    o = new_output(output_type=u'error', ename=u'NameError',
+        evalue=u'Name not found', traceback=[u'frame 0', u'frame 1', u'frame 2']
+    )
+    nt.assert_equal(o.output_type, u'error')
+    nt.assert_equal(o.ename, u'NameError')
+    nt.assert_equal(o.evalue, u'Name not found')
+    nt.assert_equal(o.traceback, [u'frame 0', u'frame 1', u'frame 2'])
+
+def test_code_cell_with_outputs():
+    cell = new_code_cell(execution_count=10, outputs=[
+        new_output('display_data', mimebundle),
+        new_output('stream', text='hello'),
+        new_output('execute_result', mimebundle, execution_count=10),
+    ])
+    nt.assert_equal(cell.execution_count, 10)
+    nt.assert_equal(len(cell.outputs), 3)
+    er = cell.outputs[-1]
+    nt.assert_equal(er.execution_count, 10)
+    nt.assert_equal(er['output_type'], 'execute_result')
+
+def test_stream():
+    output = new_output('stream', name='stderr', text='hello there')
+    nt.assert_equal(output.name, 'stderr')
+    nt.assert_equal(output.text, 'hello there')

IPython/nbformat/v4/tests/test_validate.py

@@ -0,0 +1,105 b''
+"""Tests for nbformat validation"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import io
+import os
+
+import nose.tools as nt
+
+from IPython.nbformat.validator import validate, ValidationError
+from ..nbjson import reads
+from ..nbbase import (
+    nbformat,
+    new_code_cell, new_markdown_cell, new_notebook,
+    new_output, new_raw_cell,
+)
+
+def validate4(obj, ref=None):
+    return validate(obj, ref, version=nbformat)
+
+def test_valid_code_cell():
+    cell = new_code_cell()
+    validate4(cell, 'code_cell')
+
+def test_invalid_code_cell():
+    cell = new_code_cell()
+
+    cell['source'] = 5
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'code_cell')
+
+    cell = new_code_cell()
+    del cell['metadata']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'code_cell')
+
+    cell = new_code_cell()
+    del cell['source']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'code_cell')
+
+    cell = new_code_cell()
+    del cell['cell_type']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'code_cell')
+
+def test_invalid_markdown_cell():
+    cell = new_markdown_cell()
+
+    cell['source'] = 5
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'markdown_cell')
+
+    cell = new_markdown_cell()
+    del cell['metadata']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'markdown_cell')
+
+    cell = new_markdown_cell()
+    del cell['source']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'markdown_cell')
+
+    cell = new_markdown_cell()
+    del cell['cell_type']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'markdown_cell')
+
+def test_invalid_raw_cell():
+    cell = new_raw_cell()
+
+    cell['source'] = 5
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'raw_cell')
+
+    cell = new_raw_cell()
+    del cell['metadata']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'raw_cell')
+
+    cell = new_raw_cell()
+    del cell['source']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'raw_cell')
+
+    cell = new_raw_cell()
+    del cell['cell_type']
+
+    with nt.assert_raises(ValidationError):
+        validate4(cell, 'raw_cell')
+
+def test_sample_notebook():
+    here = os.path.dirname(__file__)
+    with io.open(os.path.join(here, os.pardir, os.pardir, 'tests', "test4.ipynb"), encoding='utf-8') as f:
+        nb = reads(f.read())
+    validate4(nb)