2015-12-11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Improving django-celery tasks with metaprogramming\n",
    "\n",
    "StuPIG, 2015-12-11\n",
    "\n",
    "Michael Käufl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# TOC\n",
    "- Quest & Conditions\n",
    "- The Problem\n",
    "- First Attempts\n",
    "- The Method Caller\n",
    "- Function/Method Attributes\n",
    "- The Metaclass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Quest & Conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Quest\n",
    "\n",
    "- Import data from wikidata based on id (e.g. Stuttgart: Q1022)\n",
    "- Use Django and Celery tasks\n",
    "- Run import async and use one Celery task per wikidata id\n",
    "- Python 3.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Conditions\n",
    "\n",
    "- There is a registry with a mapping: `class name` -> `class`\n",
    "- We have to use an importer class in `app/importer.py`\n",
    "- Only basic python data types are allowed as parameters when calling a task async (`str`, `int`, `list`, `set`, `dict`, …)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Problem"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Structure of app `wikidata` in Django:\n",
    "\n",
    "wikidata\n",
    "├── importer.py  <- our importer class\n",
    "├── models.py\n",
    "└── tasks.py     <- celery tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## First attempts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# importer.py\n",
    "from wikidata.tasks import import_wikidata_single\n",
    "\n",
    "class WikidataImporter:\n",
    "    \n",
    "    def import_bulk(self, wikidata_ids):\n",
    "        for wikidata_id in wikidata_ids:\n",
    "            task_import_wikidata_single.delay(wikidata_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# tasks.py\n",
    "from celery import app\n",
    "from somewhere import Registry\n",
    "\n",
    "@app.task\n",
    "def task_import_wikidata():  # Interface from outside\n",
    "    wikidata_ids = [\n",
    "        'Q1022', 'Q28865', 'Q1032372',\n",
    "    ]\n",
    "    importer = Registry.get_importer_instance('WikidataImporter')\n",
    "    importer.import_bulk(wikidata_ids)\n",
    "\n",
    "@app.task\n",
    "def task_import_wikidata_single(wikidata_id):  # Used by importer\n",
    "    # download and save\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# importer.py\n",
    "from wikidata.tasks import task_import_wikidata_single\n",
    "\n",
    "class WikidataImporter:\n",
    "    \n",
    "    def import_bulk(self, wikidata_ids):\n",
    "        for wikidata_id in wikidata_ids:\n",
    "            task_import_wikidata_single.delay(wikidata_id)\n",
    "    \n",
    "    def import_single(self, wikidata_id):\n",
    "        # download and save\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# tasks.py\n",
    "from celery import app\n",
    "from somewhere import Registry\n",
    "\n",
    "@app.task\n",
    "def task_import_wikidata():  # Interface from outside\n",
    "    wikidata_ids = [\n",
    "        'Q1022', 'Q28865', 'Q1032372',\n",
    "    ]\n",
    "    importer = Registry.get_importer_instance('WikidataImporter')\n",
    "    importer.import_bulk(wikidata_ids)\n",
    "\n",
    "@app.task\n",
    "def task_import_wikidata_single(wikidata_id):  # Used by importer\n",
    "    importer = Registry.get_importer_instance('WikidataImporter')\n",
    "    importer.import_single(wikidata_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Method Caller"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Idea\n",
    "\n",
    "- Use a generalized task that calls a method of an importer.\n",
    "- Signature of method caller:\n",
    "  - name of importer class\n",
    "  - name of method\n",
    "  - \\*args and \\*\\*kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def task_import_call_method(importer_name, method_name, *args, **kwargs):\n",
    "    importer = Registry.get_importer_instance(class_name=importer_name)\n",
    "\n",
    "    # Check preconditions, e.g.:\n",
    "    if not hasattr(importer, method_name):\n",
    "        raise ValueError('not an attribute')\n",
    "\n",
    "    method = getattr(importer, method_name)\n",
    "    \n",
    "    if not inspect.ismethod(method) and not inspect.isfunction(method):\n",
    "        raise ValueError('not a method/function')\n",
    "\n",
    "    return method(*args, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The Importer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# importer.py\n",
    "from general.tasks import task_import_call_method\n",
    "\n",
    "class WikidataImporter:\n",
    "    \n",
    "    def import_bulk(self, wikidata_ids):\n",
    "        for wikidata_id in wikidata_ids:\n",
    "            task_import_call_method.delay(\n",
    "                importer_name=self.__class__.__name__,\n",
    "                method_name='import_single',\n",
    "                # Actual arguments:\n",
    "                wikidata_id=wikidata_id,\n",
    "            )\n",
    "    \n",
    "    def import_single(self, wikidata_id):\n",
    "        # download and save\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Why not perfect?\n",
    "\n",
    "1. Readability\n",
    "  - better: no need to switch files\n",
    "  - worse: too many LOC (`importer_name`, `method_name`, …)\n",
    "1. No chance to verify `method_name` prior to runtime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Function/Method Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Idea\n",
    "\n",
    "- Functions/Methods are objects and can have attributes\n",
    "  - Django admin: `.short_description = '…'`\n",
    "  - Celery: `.delay()`\n",
    "  \n",
    "- Use a decorator to add an attribute `as_task()`\n",
    "\n",
    "- Call decorated methods async in importer:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# importer.py\n",
    "from somewhere import as_task\n",
    "\n",
    "class WikidataImporter:\n",
    "    \n",
    "    def import_bulk(self, wikidata_ids):\n",
    "        for wikidata_id in wikidata_ids:\n",
    "            self.import_single.as_task(\n",
    "                wikidata_id=wikidata_id,\n",
    "            )\n",
    "    \n",
    "    @as_task\n",
    "    def import_single(self, wikidata_id):\n",
    "        # download and save\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### No unbound Methods any more"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class MyLittlePony:\n",
    "    def ride(self):\n",
    "        print('riding')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "riding\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<bound method MyLittlePony.ride of <__main__.MyLittlePony object at 0x7f4ad489dcc0>>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pony = MyLittlePony()\n",
    "pony.ride()\n",
    "pony.ride"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.MyLittlePony.ride>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyLittlePony.ride"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Decorator Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from general.tasks import task_import_call_method\n",
    "from functools import partial\n",
    "\n",
    "def as_task(method):\n",
    "    if '<locals>' in method.__qualname__:\n",
    "        raise ValueError\n",
    "\n",
    "    qualname = method.__qualname__.split('.')\n",
    "    if len(qualname) != 2:\n",
    "        raise ValueError\n",
    "\n",
    "    class_name = qualname[0]\n",
    "\n",
    "    method.as_task = partial(\n",
    "        task_import_call_method.delay,\n",
    "        class_name,\n",
    "        method.__name__,\n",
    "    )\n",
    "\n",
    "    return method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Why not perfect?\n",
    "\n",
    "Class name is based on “implementation time”, not run time.\n",
    "\n",
    "=> Does not work with inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The Metaclass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Idea\n",
    "\n",
    "- Use decorator `as_task` as a simple annotation of async methods\n",
    "- Check if parent class has a method decorated with `as_task`.\n",
    "- Use metaprogramming to\n",
    "  - Add function attribute to decorated methods\n",
    "  - Do the same if parent class has an according method\n",
    "  - If not, add a method (see below) with same name and attribute\n",
    "- Implementation of method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def foo(*args, **kwgars):\n",
    "    super().foo(*args, **kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from abc import ABCMeta\n",
    "import inspect\n",
    "from functools import partial\n",
    "\n",
    "registry = dict()\n",
    "\n",
    "def as_task(method):\n",
    "    def raiser(*args, **kwargs):\n",
    "        raise TypeError()\n",
    "\n",
    "    method.as_task = raiser\n",
    "\n",
    "    return method\n",
    "\n",
    "\n",
    "def method_caller(class_name, func_name, *args, **kwargs):\n",
    "    cls = registry[class_name]\n",
    "    obj = cls()\n",
    "    func = getattr(obj, func_name)\n",
    "\n",
    "    print('CALLING {}\\n'.format(func))\n",
    "    func(*args, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def print_info(mcls, name, bases, namespace):  # Signature of __new__()\n",
    "    print('\\nMETA INFO')\n",
    "\n",
    "    print('  mcls: {}'.format(mcls))    # Metaclass\n",
    "    print('  name: {}'.format(name))    # Name of class\n",
    "    print('  bases: {}'.format(bases))  # Parent classes\n",
    "\n",
    "    print('  namespace:')               # Attributes\n",
    "    for attr_name, attr_value in namespace.items():\n",
    "        if not attr_name.startswith('__'):\n",
    "            print('    {name}: {value}'.format(\n",
    "                name=attr_name,\n",
    "                value=attr_value,\n",
    "            ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class MetaImporter(ABCMeta):\n",
    "\n",
    "    def __new__(mcls, name, bases, namespace):\n",
    "        new = super().__new__(mcls, name, bases, namespace)\n",
    "        print_info(mcls, name, bases, namespace)\n",
    "\n",
    "        registry[name] = new\n",
    "\n",
    "        prepared = set()\n",
    "        \n",
    "        task_methods = ((attr_name, attr)  # All decorated methods\n",
    "            for attr_name, attr in namespace.items()\n",
    "            if inspect.isfunction(attr) and hasattr(attr, 'as_task'))\n",
    "\n",
    "        for attr_name, attr in task_methods:\n",
    "            mcls.prep_as_task(name, attr)\n",
    "            prepared.add(attr_name)\n",
    "\n",
    "        for base in bases:\n",
    "            mcls.process_base(new, name, base, prepared)\n",
    "\n",
    "        return new\n",
    "\n",
    "    def prep_as_task(class_name, func):\n",
    "        print('\\nprep func\\n  {}\\n  [{}]'.format(func, func.__name__))\n",
    "        func.as_task = partial(method_caller, class_name, func.__name__)\n",
    "\n",
    "    def process_base(cls, class_name, base, prepared):\n",
    "        process_base(cls, class_name, base, prepared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def task_methods_of_base(base, prepared):\n",
    "    attrs = (\n",
    "        (attr_name, getattr(base, attr_name))\n",
    "        for attr_name in dir(base)\n",
    "        if not attr_name.startswith('__')\n",
    "    )\n",
    "    return (\n",
    "        (attr_name, attr)\n",
    "        for attr_name, attr in attrs\n",
    "        if inspect.isfunction(attr) and hasattr(attr, 'as_task')\n",
    "        if attr_name not in prepared\n",
    "    )\n",
    "\n",
    "def process_base(cls, class_name, base, prepared):\n",
    "    print('\\nprocess base {}'.format(base))\n",
    "\n",
    "    for func_name, attr in task_methods_of_base(base, prepared):\n",
    "        if hasattr(cls, func_name):\n",
    "            attr = getattr(cls, func_name)\n",
    "            if not inspect.ismethod(attr) and not inspect.isfunction(attr):\n",
    "                raise ValueError('not a method/function')\n",
    "            attr.as_task = partial(method_caller, class_name, func_name)\n",
    "            prepared.add(func_name)\n",
    "            continue\n",
    "\n",
    "        def super_caller(self, *args, **kwargs):\n",
    "            parent = super(cls, self)\n",
    "            parent_func = getattr(parent, func_name)\n",
    "            return parent_func(*args, **kwargs)\n",
    "        super_caller.as_task = partial(method_caller, class_name, func_name)\n",
    "\n",
    "        setattr(cls, func_name, super_caller)\n",
    "        # print('task method:', func_name)\n",
    "        prepared.add(func_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "META INFO\n",
      "  mcls: <class '__main__.MetaImporter'>\n",
      "  name: BaseImporter\n",
      "  bases: ()\n",
      "  namespace:\n",
      "    do_something: <function BaseImporter.do_something at 0x7f5230e5ae18>\n",
      "\n",
      "prep func\n",
      "  <function BaseImporter.do_something at 0x7f5230e5ae18>\n",
      "  [do_something]\n"
     ]
    }
   ],
   "source": [
    "class BaseImporter(metaclass=MetaImporter):\n",
    "\n",
    "    @as_task\n",
    "    def do_something(self):\n",
    "        print('Done something in {}, defined in BaseImporter'.format(\n",
    "            self.__class__.__name__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CALLING <bound method BaseImporter.do_something of <__main__.BaseImporter object at 0x7f5230e850b8>>\n",
      "\n",
      "Done something in BaseImporter, defined in BaseImporter\n"
     ]
    }
   ],
   "source": [
    "importer = BaseImporter()\n",
    "importer.do_something.as_task()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "META INFO\n",
      "  mcls: <class '__main__.MetaImporter'>\n",
      "  name: ManInTheMiddle\n",
      "  bases: (<class '__main__.BaseImporter'>,)\n",
      "  namespace:\n",
      "    do_something: <function ManInTheMiddle.do_something at 0x7f5230e63840>\n",
      "\n",
      "prep func\n",
      "  <function ManInTheMiddle.do_something at 0x7f5230e63840>\n",
      "  [do_something]\n",
      "\n",
      "process base <class '__main__.BaseImporter'>\n"
     ]
    }
   ],
   "source": [
    "class ManInTheMiddle(BaseImporter):\n",
    "\n",
    "    @as_task\n",
    "    def do_something(self):\n",
    "        print('  Done something in {}, defined in ManInTheMiddle'.format(\n",
    "            self.__class__.__name__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CALLING <bound method ManInTheMiddle.do_something of <__main__.ManInTheMiddle object at 0x7f5230e85898>>\n",
      "\n",
      "  Done something in ManInTheMiddle, defined in ManInTheMiddle\n"
     ]
    }
   ],
   "source": [
    "importer = ManInTheMiddle()\n",
    "importer.do_something.as_task()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "META INFO\n",
      "  mcls: <class '__main__.MetaImporter'>\n",
      "  name: ConcreteImporter\n",
      "  bases: (<class '__main__.ManInTheMiddle'>,)\n",
      "  namespace:\n",
      "    do_something: <function ConcreteImporter.do_something at 0x7f5230e63b70>\n",
      "\n",
      "prep func\n",
      "  <function ConcreteImporter.do_something at 0x7f5230e63b70>\n",
      "  [do_something]\n",
      "\n",
      "process base <class '__main__.ManInTheMiddle'>\n"
     ]
    }
   ],
   "source": [
    "class ConcreteImporter(ManInTheMiddle):\n",
    "\n",
    "    @as_task\n",
    "    def do_something(self):\n",
    "        print('Done something in {}, defined in ConcreteImporter'.format(\n",
    "        self.__class__.__name__))\n",
    "\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CALLING <bound method ConcreteImporter.do_something of <__main__.ConcreteImporter object at 0x7f5234c0eef0>>\n",
      "\n",
      "Done something in ConcreteImporter, defined in ConcreteImporter\n"
     ]
    }
   ],
   "source": [
    "importer = ConcreteImporter()\n",
    "importer.do_something.as_task()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BaseImporter      ->   <class '__main__.BaseImporter'>\n",
      "ManInTheMiddle    ->   <class '__main__.ManInTheMiddle'>\n",
      "ConcreteImporter  ->   <class '__main__.ConcreteImporter'>\n"
     ]
    }
   ],
   "source": [
    "for name, cls in registry.items():\n",
    "    print('{name:17} ->   {cls}'.format(name=name, cls=cls))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Thank you!\n",
    "\n",
    "Further questions?"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}