lectures/ConcurrencySockets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FUTURES\n",
    "\n",
    "A future, or promise, is something that represents a pending opearion and returns straight away. \n",
    "\n",
    "You have seen one idea of futures in the Lazy eval\" paer of this course where we created a class instance instead of executing a function. Thean calling `eval` evaluated the function. But we stopped there, not constructing a structure in which we figure where and when we should execute the `eval`, and how we should return the result to the user.\n",
    "\n",
    "These issues become important when we are running many threads or are in a callback based system. We'll see how python handles this with threads for us, and later, how we would do this for co-routines and callbacks.\n",
    "\n",
    "We use the `concurrent.futures` module here to do this. One creates a \"thread pool\" with multiple threads (or processes). One can then query their state of completion, or register callbacks to be called on successful completion or error.\n",
    "Examples Adapted from Fluent Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time, uuid, functools\n",
    "def get_thing_maker(secs, item):\n",
    "    time.sleep(secs)\n",
    "    return str(uuid.uuid4())+str(item)\n",
    "get_thing = functools.partial(get_thing_maker, 1)\n",
    "def get_many(lot):\n",
    "    counter=0\n",
    "    for t in lot:\n",
    "        thing = get_thing(t)\n",
    "        counter += 1\n",
    "    return counter\n",
    "def serial_main(it):\n",
    "    t0 = time.time()\n",
    "    count = get_many(it)\n",
    "    elapsed = time.time() - t0\n",
    "    msg = '\\n{} things got in {:.2f}s' \n",
    "    print(msg.format(count, elapsed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "20 things got in 20.01s\n"
     ]
    }
   ],
   "source": [
    "serial_main(range(20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from concurrent import futures\n",
    "def get_many_threaded1(it):\n",
    "    workers = 10\n",
    "    with futures.ThreadPoolExecutor(max_workers=workers) as executor:\n",
    "        res = executor.map(get_thing, it)\n",
    "    return len(list(res))\n",
    "def threaded_main1(it):\n",
    "    t0 = time.time()\n",
    "    count = get_many_threaded1(it)\n",
    "    elapsed = time.time() - t0\n",
    "    msg = '\\n{} things got in {:.2f}s' \n",
    "    print(msg.format(count, elapsed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "20 things got in 2.01s\n"
     ]
    }
   ],
   "source": [
    "threaded_main1(range(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One might think that the concurrent IO (or sleeping) case is limited by the GIL, but in both cases, the GIL is yielded. Thus there is no waiting around.\n",
    "\n",
    "The GIL is harmless if code is being run in the context of python library IO or code running in properly coded C extensions like numpy. The time.sleep() function also releases the GIL. Python threads are totally usable in I/O-bound applications.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Threads\n",
    "\n",
    "### threads vs processes\n",
    "\n",
    "On linux\n",
    "- processes created by fork() have a primary thread\n",
    "- thread is the unit of execution\n",
    "- process is a container, can have more threads\n",
    "- can be scheduled across different cores/cpus\n",
    "\n",
    "```c\n",
    "int pid;\n",
    "int status = 0;\n",
    "/* fork returns pid of child to parent and 0 to child*/\n",
    "if (pid = fork()) {\n",
    "    /* parent code */\n",
    "    pid = wait(&status);\n",
    "    /*wait returns child pid and status*/\n",
    "} else {\n",
    "    /* child  code*/\n",
    "    exit(status);\n",
    "}\n",
    "```\n",
    "\n",
    "- threads in a process share same address space (share it entirely)\n",
    "- thread abstraction decouples resource allocation from control\n",
    "- defines a single sequential execution stream with PC, stack, register values\n",
    "- process handles: address space, global variables, open files, child processes, pending alarms, signals and signal handlers, accounting info\n",
    "- thread handles program counter, registers, stack, and state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Processes with concurrent futures.\n",
    "\n",
    "CPU based processing wont release the gil, and is thus best done in a separate process. For illustration, we show what this looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time\n",
    "def get_many_process(it, workers=None):\n",
    "    if workers:\n",
    "        with futures.ProcessPoolExecutor(max_workers=workers) as executor:\n",
    "            res = executor.map(get_thing, it)\n",
    "    else:\n",
    "        with futures.ProcessPoolExecutor() as executor:\n",
    "            res = executor.map(get_thing, it)\n",
    "    return len(list(res))\n",
    "\n",
    "def process_main(it, workers=None):\n",
    "    t0 = time.time()\n",
    "    count = get_many_process(it, workers)\n",
    "    elapsed = time.time() - t0\n",
    "    msg = '\\n{} things got in {:.2f}s' \n",
    "    print(msg.format(count, elapsed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "20 things got in 5.04s\n"
     ]
    }
   ],
   "source": [
    "process_main(range(20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "20 things got in 2.05s\n"
     ]
    }
   ],
   "source": [
    "process_main(range(20), workers=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    return fib(n - 1) + fib(n - 2) if n > 1 else n\n",
    "def cpuy():\n",
    "    for i in range(35):\n",
    "        val = fib(i)\n",
    "        print(\"fib({}) is {}\".format(i, val))\n",
    "\n",
    "def cpuy2():\n",
    "    for i in range(35):\n",
    "        val = fib(i)\n",
    "        print(\"cpuy2 fib({}) is {}\".format(i, val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from threading import Thread\n",
    "def thr():\n",
    "    # Second thread will print the hello message. Starting as a daemon means\n",
    "    # the thread will not prevent the process from exiting.\n",
    "    start = time.time()\n",
    "    cpuy()\n",
    "    cpuy2()\n",
    "    print(\"serial elapsed:\", time.time() - start)\n",
    "    start=time.time()\n",
    "    #t = Thread(target=sleepy)\n",
    "    #t.start()\n",
    "    t2 = Thread(target=cpuy2)\n",
    "    t2.start()\n",
    "    # Main thread will read and process input\n",
    "    cpuy()\n",
    "    print(\"thread elapsed:\", time.time() - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fib(0) is 0\n",
      "fib(1) is 1\n",
      "fib(2) is 1\n",
      "fib(3) is 2\n",
      "fib(4) is 3\n",
      "fib(5) is 5\n",
      "fib(6) is 8\n",
      "fib(7) is 13\n",
      "fib(8) is 21\n",
      "fib(9) is 34\n",
      "fib(10) is 55\n",
      "fib(11) is 89\n",
      "fib(12) is 144\n",
      "fib(13) is 233\n",
      "fib(14) is 377\n",
      "fib(15) is 610\n",
      "fib(16) is 987\n",
      "fib(17) is 1597\n",
      "fib(18) is 2584\n",
      "fib(19) is 4181\n",
      "fib(20) is 6765\n",
      "fib(21) is 10946\n",
      "fib(22) is 17711\n",
      "fib(23) is 28657\n",
      "fib(24) is 46368\n",
      "fib(25) is 75025\n",
      "fib(26) is 121393\n",
      "fib(27) is 196418\n",
      "fib(28) is 317811\n",
      "fib(29) is 514229\n",
      "fib(30) is 832040\n",
      "fib(31) is 1346269\n",
      "fib(32) is 2178309\n",
      "fib(33) is 3524578\n",
      "fib(34) is 5702887\n",
      "cpuy2 fib(0) is 0\n",
      "cpuy2 fib(1) is 1\n",
      "cpuy2 fib(2) is 1\n",
      "cpuy2 fib(3) is 2\n",
      "cpuy2 fib(4) is 3\n",
      "cpuy2 fib(5) is 5\n",
      "cpuy2 fib(6) is 8\n",
      "cpuy2 fib(7) is 13\n",
      "cpuy2 fib(8) is 21\n",
      "cpuy2 fib(9) is 34\n",
      "cpuy2 fib(10) is 55\n",
      "cpuy2 fib(11) is 89\n",
      "cpuy2 fib(12) is 144\n",
      "cpuy2 fib(13) is 233\n",
      "cpuy2 fib(14) is 377\n",
      "cpuy2 fib(15) is 610\n",
      "cpuy2 fib(16) is 987\n",
      "cpuy2 fib(17) is 1597\n",
      "cpuy2 fib(18) is 2584\n",
      "cpuy2 fib(19) is 4181\n",
      "cpuy2 fib(20) is 6765\n",
      "cpuy2 fib(21) is 10946\n",
      "cpuy2 fib(22) is 17711\n",
      "cpuy2 fib(23) is 28657\n",
      "cpuy2 fib(24) is 46368\n",
      "cpuy2 fib(25) is 75025\n",
      "cpuy2 fib(26) is 121393\n",
      "cpuy2 fib(27) is 196418\n",
      "cpuy2 fib(28) is 317811\n",
      "cpuy2 fib(29) is 514229\n",
      "cpuy2 fib(30) is 832040\n",
      "cpuy2 fib(31) is 1346269\n",
      "cpuy2 fib(32) is 2178309\n",
      "cpuy2 fib(33) is 3524578\n",
      "cpuy2 fib(34) is 5702887\n",
      "serial elapsed: 16.363996028900146\n",
      "cpuy2 fib(0) is 0\n",
      "cpuy2 fib(1) is 1\n",
      "cpuy2 fib(2) is 1\n",
      "cpuy2 fib(3) is 2\n",
      "cpuy2 fib(4) is 3\n",
      "cpuy2 fib(5) is 5\n",
      "cpuy2 fib(6) is 8\n",
      "cpuy2 fib(7) is 13\n",
      "cpuy2 fib(8) is 21\n",
      "cpuy2 fib(9) is 34\n",
      "cpuy2 fib(10) is 55\n",
      "cpuy2 fib(11) is 89\n",
      "cpuy2 fib(12) is 144\n",
      "cpuy2 fib(13) is 233\n",
      "cpuy2 fib(14) is 377\n",
      "cpuy2 fib(15) is 610\n",
      "cpuy2 fib(16) is 987\n",
      "cpuy2 fib(17) is 1597\n",
      "fib(0) is 0\n",
      "fib(1) is 1\n",
      "fib(2) is 1\n",
      "fib(3) is 2\n",
      "fib(4) is 3\n",
      "fib(5) is 5\n",
      "fib(6) is 8\n",
      "fib(7) is 13\n",
      "fib(8) is 21\n",
      "fib(9) is 34\n",
      "fib(10) is 55\n",
      "fib(11) is 89\n",
      "fib(12) is 144\n",
      "fib(13) is 233\n",
      "fib(14) is 377\n",
      "fib(15) is 610\n",
      "fib(16) is 987\n",
      "fib(17) is 1597\n",
      "fib(18) is 2584\n",
      "cpuy2 fib(18) is 2584\n",
      "cpuy2 fib(19) is 4181\n",
      "fib(19) is 4181\n",
      "cpuy2 fib(20) is 6765\n",
      "cpuy2 fib(21) is 10946\n",
      "fib(20) is 6765\n",
      "fib(21) is 10946\n",
      "cpuy2 fib(22) is 17711\n",
      "fib(22) is 17711\n",
      "cpuy2 fib(23) is 28657\n",
      "fib(23) is 28657\n",
      "cpuy2 fib(24) is 46368\n",
      "fib(24) is 46368\n",
      "cpuy2 fib(25) is 75025\n",
      "fib(25) is 75025\n",
      "cpuy2 fib(26) is 121393\n",
      "fib(26) is 121393\n",
      "fib(27) is 196418\n",
      "cpuy2 fib(27) is 196418\n",
      "fib(28) is 317811\n",
      "cpuy2 fib(28) is 317811\n",
      "fib(29) is 514229\n",
      "cpuy2 fib(29) is 514229\n",
      "fib(30) is 832040\n",
      "cpuy2 fib(30) is 832040\n",
      "fib(31) is 1346269\n",
      "cpuy2 fib(31) is 1346269\n",
      "fib(32) is 2178309\n",
      "cpuy2 fib(32) is 2178309\n",
      "fib(33) is 3524578\n",
      "cpuy2 fib(33) is 3524578\n",
      "fib(34) is 5702887\n",
      "thread elapsed: 19.81546401977539\n",
      "cpuy2 fib(34) is 5702887\n"
     ]
    }
   ],
   "source": [
    "thr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpuy2 fib(0) is 0\n",
      "cpuy2 fib(8) is 21\n",
      "cpuy2 fib(1) is 1\n",
      "cpuy2 fib(2) is 1\n",
      "cpuy2 fib(3) is 2\n",
      "cpuy2 fib(4) is 3\n",
      "cpuy2 fib(5) is 5\n",
      "cpuy2 fib(6) is 8\n",
      "cpuy2 fib(7) is 13\n",
      "cpuy2 fib(9) is 34\n",
      "cpuy2 fib(12) is 144\n",
      "cpuy2 fib(10) is 55\n",
      "cpuy2 fib(11) is 89\n",
      "cpuy2 fib(13) is 233\n",
      "cpuy2 fib(15) is 610\n",
      "cpuy2 fib(14) is 377\n",
      "cpuy2 fib(16) is 987\n",
      "cpuy2 fib(18) is 2584\n",
      "cpuy2 fib(17) is 1597\n",
      "cpuy2 fib(19) is 4181\n",
      "cpuy2 fib(20) is 6765\n",
      "cpuy2 fib(21) is 10946\n",
      "cpuy2 fib(22) is 17711\n",
      "cpuy2 fib(23) is 28657\n",
      "cpuy2 fib(24) is 46368\n",
      "fib(0) is 0\n",
      "fib(1) is 1\n",
      "fib(2) is 1\n",
      "fib(3) is 2\n",
      "fib(4) is 3\n",
      "fib(5) is 5\n",
      "fib(6) is 8\n",
      "fib(7) is 13\n",
      "fib(8) is 21\n",
      "fib(9) is 34\n",
      "fib(10) is 55\n",
      "fib(11) is 89\n",
      "fib(12) is 144\n",
      "fib(13) is 233\n",
      "fib(14) is 377\n",
      "fib(15) is 610\n",
      "fib(16) is 987\n",
      "fib(17) is 1597\n",
      "fib(18) is 2584\n",
      "fib(19) is 4181\n",
      "fib(20) is 6765\n",
      "fib(21) is 10946\n",
      "fib(22) is 17711\n",
      "fib(23) is 28657\n",
      "fib(24) is 46368\n",
      "fib(25) is 75025\n",
      "cpuy2 fib(25) is 75025\n",
      "cpuy2 fib(26) is 121393\n",
      "cpuy2 fib(27) is 196418\n",
      "fib(26) is 121393\n",
      "fib(27) is 196418\n",
      "cpuy2 fib(28) is 317811\n",
      "fib(28) is 317811\n",
      "cpuy2 fib(29) is 514229\n",
      "fib(29) is 514229\n",
      "cpuy2 fib(30) is 832040\n",
      "fib(30) is 832040\n",
      "cpuy2 fib(31) is 1346269\n",
      "fib(31) is 1346269\n",
      "cpuy2 fib(32) is 2178309\n",
      "fib(32) is 2178309\n",
      "cpuy2 fib(33) is 3524578\n",
      "fib(33) is 3524578\n",
      "cpuy2 fib(34) is 5702887\n",
      "fib(34) is 5702887\n",
      "mp elapsed: 9.802114963531494\n"
     ]
    }
   ],
   "source": [
    "import multiprocessing, time\n",
    "start = time.time()\n",
    "p=multiprocessing.Process(target=cpuy2)\n",
    "p.start()\n",
    "cpuy()\n",
    "p.join()\n",
    "print(\"mp elapsed:\", time.time() - start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use threads for IOy stuff and processes for computey stuff\n",
    "\n",
    "#### A URL fetcher\n",
    "\n",
    "Example from concurrent.futures documentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'http://some-made-up-domain.com/' generated an exception: <urlopen error [Errno 8] nodename nor servname provided, or not known>\n",
      "'http://www.foxnews.com/' page is 70624 bytes\n",
      "'http://www.cnn.com/' page is 124685 bytes\n",
      "'http://www.bbc.co.uk/' page is 182063 bytes\n",
      "'http://europe.wsj.com/' page is 915474 bytes\n"
     ]
    }
   ],
   "source": [
    "import concurrent.futures\n",
    "import urllib.request\n",
    "\n",
    "URLS = ['http://www.foxnews.com/',\n",
    "        'http://www.cnn.com/',\n",
    "        'http://europe.wsj.com/',\n",
    "        'http://www.bbc.co.uk/',\n",
    "        'http://some-made-up-domain.com/']\n",
    "\n",
    "# Retrieve a single page and report the URL and contents\n",
    "def load_url(url, timeout):\n",
    "    with urllib.request.urlopen(url, timeout=timeout) as conn:\n",
    "        return conn.read()\n",
    "\n",
    "# We can use a with statement to ensure threads are cleaned up promptly\n",
    "with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:\n",
    "    # Start the load operations and mark each future with its URL\n",
    "    #executor.submit returns a future.\n",
    "    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}\n",
    "    for future in concurrent.futures.as_completed(future_to_url):\n",
    "        url = future_to_url[future]\n",
    "        try:\n",
    "            data = future.result()\n",
    "        except Exception as exc:\n",
    "            print('%r generated an exception: %s' % (url, exc))\n",
    "        else:\n",
    "            print('%r page is %d bytes' % (url, len(data)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are sockets?\n",
    "\n",
    "\n",
    "From wikipedia:\n",
    ">A network socket is an endpoint of a connection in a computer network. In Internet Protocol (IP) networks, these are often called Internet sockets. It is a handle (abstract reference) that a program can pass to the networking application programming interface (API) to use the connection for receiving and sending data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- we will stick to TCP (or STREAM) sockets and to INET (or IPV4) sockets\n",
    "- a client program only has a client socket\n",
    "- a server program has both client and server sockets: the server socket is the thing that sits and listens for connections, spawning a client socket to deal with them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why do we care?\n",
    "\n",
    "- we'll need it for the client communications for our database\n",
    "- you will want to know how to use them to make custom data servers and clients. \n",
    "\n",
    "Here for example, is a no-copy numpy array sharing over tcp sockets. Might be useful one day..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A simple server and its client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting server0.py\n"
     ]
    }
   ],
   "source": [
    "%%file server0.py\n",
    "from socket import *\n",
    "s = socket(AF_INET, SOCK_STREAM)\n",
    "s.bind(('', 25000))\n",
    "s.listen(1)\n",
    "c,a = s.accept()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `s` here is a server socket. It binds to '', or any address on this machine, and port 25000. \n",
    "- Low number ports are reserved by system services, only the root user can create them.\n",
    "- listen tells the socker to queue in only `1` request here before refusing outside connections. 5-10 is plenty, if your code is well written\n",
    "- `accept` creates a client socket `c` with address `a`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting client0.py\n"
     ]
    }
   ],
   "source": [
    "%%file client0.py\n",
    "from socket import *\n",
    "c = socket(AF_INET, SOCK_STREAM)\n",
    "c.connect(('localhost', 25000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the client:\n",
    "\n",
    "- when you are `connect`ed the socket `c` can be used to send in a request or to recieve some data. \n",
    "- This socket will read the response and then be destroyed. Client sockets are one-shot\n",
    "- the client's client socket and server's client socket are the same type of thing, so you need to decide \"who calls whom\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Communication happens using some variant of `send` and `recv`, or `read` and `write`. It is your responsibility to call and call again until the buffers are full. We do that below, and note that we are reading into already allocated buffers (many a time we will allocate on the fly, as we shall see).\n",
    "\n",
    "This is a great example of memoryviews in Python as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sharing data with sockets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting client0.py\n"
     ]
    }
   ],
   "source": [
    "%%file client0.py\n",
    "import numpy as np\n",
    "from socket import *\n",
    "\n",
    "\n",
    "def recv_into(arr, source):\n",
    "    view = memoryview(arr).cast('B') \n",
    "    while len(view):\n",
    "        nrecv = source.recv_into(view)\n",
    "        print(\"recieved\", nrecv)\n",
    "        view = view[nrecv:]\n",
    "            \n",
    "c = socket(AF_INET, SOCK_STREAM)\n",
    "c.connect(('localhost', 25000))\n",
    "a = np.zeros(shape=50000000, dtype=float)\n",
    "print(a[0:10])\n",
    "recv_into(a, c)\n",
    "print(a[0:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting server0.py\n"
     ]
    }
   ],
   "source": [
    "%%file server0.py\n",
    "from socket import *\n",
    "import numpy as np\n",
    "\n",
    "def send_from(arr, dest):\n",
    "    view = memoryview(arr).cast('B') \n",
    "    while len(view):\n",
    "        nsent = dest.send(view)\n",
    "        view = view[nsent:]\n",
    "            \n",
    "\n",
    "s = socket(AF_INET, SOCK_STREAM)\n",
    "s.bind(('', 25000))\n",
    "s.listen(1)\n",
    "c,addr = s.accept()\n",
    "a = np.arange(0.0, 50000000.0)\n",
    "send_from(a, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case we have chosen to have the server \"write-to\" the client. We could have had the client request the server. We'll do that next"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that so far we have not tried to keep the server socket persistent. We'll do this next as well. But first let us write the cacnonical echo server. We can test this with `telnet`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The canonical echo server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing echo_server.py\n"
     ]
    }
   ],
   "source": [
    "%%file echo_server.py\n",
    "from socket import socket, AF_INET, SOCK_STREAM\n",
    "\n",
    "def echo_handler(address, client_sock):\n",
    "    print('Got connection from {}'.format(address)) \n",
    "    while True:\n",
    "        msg = client_sock.recv(2)\n",
    "        print(len(msg))\n",
    "        if not msg:\n",
    "            print(\"broke\")\n",
    "            break\n",
    "        client_sock.sendall(msg)\n",
    "    client_sock.close()\n",
    "\n",
    "def echo_server(address, backlog=5): \n",
    "    sock = socket(AF_INET, SOCK_STREAM) \n",
    "    sock.bind(address) \n",
    "    sock.listen(backlog)\n",
    "    while True:\n",
    "        client_sock, client_addr = sock.accept() \n",
    "        echo_handler(client_addr, client_sock)\n",
    "        \n",
    "if __name__ == '__main__': \n",
    "    echo_server(('', 20002))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making the server persistent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing server1.py\n"
     ]
    }
   ],
   "source": [
    "%%file server1.py\n",
    "from socket import *\n",
    "import numpy as np\n",
    "\n",
    "a = np.arange(0.0, 50000000.0)\n",
    "\n",
    "def send_from(arr, dest):\n",
    "    view = memoryview(arr).cast('B') \n",
    "    while len(view):\n",
    "        nsent = dest.send(view)\n",
    "        view = view[nsent:]\n",
    "            \n",
    "def handle(csock):\n",
    "    msg = b\"\"\n",
    "    while True:\n",
    "        recvd = csock.recv(2)#chosen to be large enough\n",
    "        print(\"recieved\", recvd)\n",
    "        if not recvd: # handle close\n",
    "            break\n",
    "        msg += recvd\n",
    "        if len(msg)==10:\n",
    "            break\n",
    "    offset, numele=msg.decode().split(':')\n",
    "    offset=int(offset)\n",
    "    numele=int(numele)\n",
    "    send_from(a[offset:offset+numele], csock)\n",
    "    csock.close()\n",
    "        \n",
    "def array_server(address_tuple, backlog=1):\n",
    "    s = socket(AF_INET, SOCK_STREAM)\n",
    "    s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)\n",
    "    s.bind(address_tuple)\n",
    "    s.listen(backlog)\n",
    "    \n",
    "    while True:\n",
    "        csock,caddr = s.accept()\n",
    "        print(\"got connection from {}\".format(caddr))\n",
    "        handle(csock)\n",
    "    s.close()\n",
    "\n",
    "array_server(('', 25000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing client1.py\n"
     ]
    }
   ],
   "source": [
    "%%file client1.py\n",
    "import numpy as np\n",
    "from socket import *\n",
    "offset=5000\n",
    "num_wanted=10000\n",
    "\n",
    "def recv_into(arr, source):\n",
    "    view = memoryview(arr).cast('B') \n",
    "    while len(view):\n",
    "        nrecv = source.recv_into(view)\n",
    "        print(\"recieved\", nrecv)\n",
    "        view = view[nrecv:]\n",
    "            \n",
    "\n",
    "c = socket(AF_INET, SOCK_STREAM)\n",
    "c.connect(('localhost', 25000))\n",
    "mybytes=str.encode(\"{}:{}\".format(offset, num_wanted))\n",
    "print(len(mybytes))\n",
    "c.send(mybytes)\n",
    "a = np.zeros(shape=num_wanted, dtype=float)\n",
    "print(a[0:10])\n",
    "recv_into(a, c)\n",
    "print(a[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using the socket server module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing echo_server2.py\n"
     ]
    }
   ],
   "source": [
    "%%file echo_server2.py\n",
    "from socketserver import BaseRequestHandler, TCPServer\n",
    "\n",
    "class EchoHandler(BaseRequestHandler): \n",
    "    def handle(self):\n",
    "        print('Got connection from', self.client_address) \n",
    "        while True:\n",
    "            msg = self.request.recv(8192)\n",
    "            if not msg:\n",
    "                break\n",
    "            self.request.send(msg)\n",
    "            \n",
    "if __name__ == '__main__':\n",
    "    serv = TCPServer(('', 20000), EchoHandler) \n",
    "    serv.serve_forever()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing echo_client.py\n"
     ]
    }
   ],
   "source": [
    "%%file echo_client.py\n",
    "import sys\n",
    "from socket import socket, AF_INET, SOCK_STREAM\n",
    "s = socket(AF_INET, SOCK_STREAM)\n",
    "s.connect(('localhost', 20000))\n",
    "s.send(sys.argv[1].encode())\n",
    "print(s.recv(8192))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Threaded implementations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing echo_server3.py\n"
     ]
    }
   ],
   "source": [
    "%%file echo_server3.py\n",
    "from socketserver import BaseRequestHandler, ThreadingTCPServer\n",
    "\n",
    "class EchoHandler(BaseRequestHandler): \n",
    "    def handle(self):\n",
    "        print('Got connection from', self.client_address) \n",
    "        while True:\n",
    "            msg = self.request.recv(8192)\n",
    "            if not msg:\n",
    "                break\n",
    "            self.request.send(msg)\n",
    "            \n",
    "if __name__ == '__main__':\n",
    "    serv = ThreadingTCPServer(('', 20000), EchoHandler) \n",
    "    serv.serve_forever()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting echo_server4.py\n"
     ]
    }
   ],
   "source": [
    "%%file echo_server4.py\n",
    "from socketserver import BaseRequestHandler, TCPServer\n",
    "\n",
    "class EchoHandler(BaseRequestHandler): \n",
    "    def handle(self):\n",
    "        print('Got connection from', self.client_address) \n",
    "        while True:\n",
    "            msg = self.request.recv(8192)\n",
    "            if not msg:\n",
    "                break\n",
    "            self.request.send(msg)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    from threading import Thread\n",
    "    NWORKERS = 16\n",
    "    TCPServer.allow_reuse_address = True\n",
    "    serv = TCPServer(('', 20000), EchoHandler) \n",
    "    \n",
    "    for n in range(NWORKERS):\n",
    "            t = Thread(target=serv.serve_forever)\n",
    "            t.daemon = True\n",
    "            t.start()\n",
    "    serv.serve_forever()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the usual echo server written with a thread pool from the `concurrent.futures` package. We saw some other ways of writing this server above using the `socketserver` module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing threads0.py\n"
     ]
    }
   ],
   "source": [
    "%%file threads0.py\n",
    "from socket import AF_INET, SOCK_STREAM, socket \n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "\n",
    "def echo_client(sock, client_addr):\n",
    "    print('Got connection from', client_addr) \n",
    "    while True:\n",
    "        msg = sock.recv(65536) \n",
    "        if not msg:\n",
    "            break\n",
    "        sock.sendall(msg) \n",
    "    print('Client closed connection') \n",
    "    sock.close()\n",
    "    \n",
    "def echo_server(addr):\n",
    "    pool = ThreadPoolExecutor(12) \n",
    "    sock = socket(AF_INET, SOCK_STREAM) \n",
    "    sock.bind(addr)\n",
    "    sock.listen(5)\n",
    "    while True:\n",
    "        client_sock, client_addr = sock.accept()\n",
    "        pool.submit(echo_client, client_sock, client_addr)\n",
    "        \n",
    "echo_server(('',15000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here is something more along the lines of what we did last time in setting up a thread pool, but you can see how the pool is set up and fed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing threads1.py\n"
     ]
    }
   ],
   "source": [
    "%%file threads1.py\n",
    "from socket import socket, AF_INET, SOCK_STREAM \n",
    "from threading import Thread\n",
    "from queue import Queue\n",
    "\n",
    "def echo_client(q):\n",
    "    sock, client_addr = q.get()\n",
    "    print('Got connection from', client_addr) \n",
    "    while True:\n",
    "        msg = sock.recv(65536) \n",
    "        if not msg:\n",
    "            break\n",
    "        sock.sendall(msg) \n",
    "    print('Client closed connection')\n",
    "    sock.close()\n",
    "\n",
    "def echo_server(addr, nworkers): \n",
    "    # Launch the client workers \n",
    "    q = Queue()\n",
    "    for n in range(nworkers):\n",
    "        t = Thread(target=echo_client, args=(q,))\n",
    "        t.daemon = True\n",
    "        t.start()\n",
    "    # Run the server\n",
    "    sock = socket(AF_INET, SOCK_STREAM) sock.bind(addr)\n",
    "    sock.listen(5)\n",
    "    while True:\n",
    "        client_sock, client_addr = sock.accept()\n",
    "        q.put((client_sock, client_addr))\n",
    "    \n",
    "echo_server(('',15000), 128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So lets use this model to write a simple, in-memory database server."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting dbserver.py\n"
     ]
    }
   ],
   "source": [
    "%%file dbserver.py\n",
    "from socket import AF_INET, SOCK_STREAM, socket, SOL_SOCKET, SO_REUSEADDR\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "import threading\n",
    "class LockableDict: \n",
    "    def __init__(self):\n",
    "        self._d={}\n",
    "        self._dlock={}\n",
    "        \n",
    "    def __getitem__(self, attr):\n",
    "        return self._d[attr]\n",
    "    \n",
    "    def __setitem__(self, attr, val):\n",
    "        if attr not in self._d:\n",
    "            self._dlock[attr]=threading.Lock()\n",
    "        print(\"LOCKING FOR\", attr, val)\n",
    "        with self._dlock[attr]:\n",
    "            self._d[attr] = val\n",
    "        print(\"UNLOCKED FOR\", attr, val)\n",
    "            \n",
    "def db_client(sock, client_addr, ldict):\n",
    "    print('Got connection from', client_addr) \n",
    "    while True:\n",
    "        msg = sock.recv(65536)\n",
    "        print(\"msg\", msg)\n",
    "        if not msg:\n",
    "            break\n",
    "        key, value = msg.decode().split('=')\n",
    "        print(\"k,v\", key, value)\n",
    "        ldict[key] = value\n",
    "        sock.sendall(value.encode())\n",
    "    print('Client closed connection') \n",
    "    sock.close()\n",
    "    \n",
    "def db_server(addr):\n",
    "    print(\"creating lockable dict and pool\")\n",
    "    ldict=LockableDict()\n",
    "    pool = ThreadPoolExecutor(50) \n",
    "    sock = socket(AF_INET, SOCK_STREAM)\n",
    "    sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)\n",
    "    sock.bind(addr)\n",
    "    sock.listen(15)\n",
    "    while True:\n",
    "        print('connection')\n",
    "        client_sock, client_addr = sock.accept()\n",
    "        pool.submit(db_client, client_sock, client_addr, ldict)\n",
    "        \n",
    "db_server(('',15000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a client that uses a threadpool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing dbclient.py\n"
     ]
    }
   ],
   "source": [
    "%%file dbclient.py\n",
    "import sys\n",
    "from socket import socket, AF_INET, SOCK_STREAM\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "def fetch(i):\n",
    "    s = socket(AF_INET, SOCK_STREAM)\n",
    "    s.connect(('localhost', 15000))\n",
    "    print(\"sending, i\",i)\n",
    "    s.send(\"a={}\".format(i).encode())\n",
    "    print(\"sent\")\n",
    "    return s.recv(65536)\n",
    "pool = ThreadPoolExecutor(20)\n",
    "thrs=[]\n",
    "for i in range(40):\n",
    "    t = pool.submit(fetch, i)\n",
    "    thrs.append(t)\n",
    "for i in range(40):\n",
    "    print('i', i, thrs[i].result())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And another that uses a process pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing dbclient2.py\n"
     ]
    }
   ],
   "source": [
    "%%file dbclient2.py\n",
    "import sys\n",
    "from socket import socket, AF_INET, SOCK_STREAM\n",
    "from concurrent.futures import ProcessPoolExecutor\n",
    "def fetch(i):\n",
    "    s = socket(AF_INET, SOCK_STREAM)\n",
    "    s.connect(('localhost', 15000))\n",
    "    print(\"sending, i\",i)\n",
    "    s.send(\"a={}\".format(i).encode())\n",
    "    print(\"sent\")\n",
    "    return s.recv(65536)\n",
    "pool = ProcessPoolExecutor(20)\n",
    "thrs=[]\n",
    "for i in range(40):\n",
    "    t = pool.submit(fetch, i)\n",
    "    thrs.append(t)\n",
    "for i in range(40):\n",
    "    print('i', i, thrs[i].result())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And a third that uses the process pool using the built in map method, just for illustration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing dbclient3.py\n"
     ]
    }
   ],
   "source": [
    "%%file dbclient3.py\n",
    "import sys\n",
    "from socket import socket, AF_INET, SOCK_STREAM\n",
    "from concurrent.futures import ProcessPoolExecutor\n",
    "def fetch(i):\n",
    "    s = socket(AF_INET, SOCK_STREAM)\n",
    "    s.connect(('localhost', 15000))\n",
    "    print(\"sending, i\",i)\n",
    "    s.send(\"a={}\".format(i).encode())\n",
    "    print(\"sent\")\n",
    "    return s.recv(65536)\n",
    "\n",
    "with ProcessPoolExecutor(20) as pool: \n",
    "    for result in pool.map(fetch, range(40)):\n",
    "        print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of blocking, one can use callbacks. For example (from the cookbook):\n",
    "\n",
    "```python\n",
    "def when_done(r): \n",
    "    print('Got:', r.result())\n",
    "with ProcessPoolExecutor() as pool: \n",
    "        future_result = pool.submit(work, arg)\n",
    "        future_result.add_done_callback(when_done)\n",
    "        \n",
    "```\n",
    "\n",
    "We do not show how we can create a multiprocessing based db server. But its doable. Three things to keep in mind\n",
    "\n",
    "(a) you can create the database by doing a multiprocessing.lock (b) you must however do this in shared memory (c) you cannot easily pass the socket in the client function like we did above. This is as function arguments are passed from one process to the other by pickling, and sockets are not pickle-able. This leaves you with the choice of sending the data only to a child process, or using multiprocessing.reduction to somehow pickle the socket, or preforking (what apache does) in which the accept is run in the client (see http://foobarnbaz.com/2011/08/30/developing-scalable-services-with-python/) for an example.\n",
    "\n",
    "\n",
    "#### Daemonization\n",
    "You want your process to run afteryou kill your shell. See http://chimera.labs.oreilly.com/books/1230000000393/ch12.html#_problem_210 ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing a web page fetcher\n",
    "\n",
    " \n",
    "Adapted from http://aosabook.org/en/500L/a-web-crawler-with-asyncio-coroutines.html\n",
    "\n",
    "It talks about callback and co-routines, how non-blocking socket based programming works, and some of the new functionality in python 3.4+. Very much worth reading."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Blocking fetch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import socket\n",
    "def fetch(host, url):\n",
    "    sock = socket.socket()\n",
    "    sock.connect((host, 80))\n",
    "    request = 'GET {} HTTP/1.0\\r\\nHost: {}\\r\\n\\r\\n'.format(url, host)\n",
    "    sock.send(request.encode('ascii'))\n",
    "    response = b''\n",
    "    chunk = sock.recv(4096)\n",
    "    while chunk:\n",
    "        response += chunk\n",
    "        chunk = sock.recv(4096)\n",
    "    return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b\\'HTTP/1.0 200 OK\\\\r\\\\nCache-Control: max-age=604800\\\\r\\\\nContent-Type: text/html\\\\r\\\\nDate: Wed, 09 Nov 2016 07:51:27 GMT\\\\r\\\\nEtag: \"359670651+gzip+ident\"\\\\r\\\\nExpires: Wed, 16 Nov 2016 07:51:27 GMT\\\\r\\\\nLast-Modified: Fri, 09 Aug 2013 23:54:35 GMT\\\\r\\\\nServer: ECS (bos/F56E)\\\\r\\\\nVary: Accept-Encoding\\\\r\\\\nX-Cache: HIT\\\\r\\\\nx-ec-custom-error: 1\\\\r\\\\nContent-Length: 1270\\\\r\\\\nConnection: close\\\\r\\\\n\\\\r\\\\n<!doctype html>\\\\n<html>\\\\n<head>\\\\n    <title>Example Domain</title>\\\\n\\\\n    <meta charset=\"utf-8\" />\\\\n    <meta http-equiv=\"Content-type\" content=\"text/html; charset=utf-8\" />\\\\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\\\\n    <style type=\"text/css\">\\\\n    body {\\\\n        background-color: #f0f0f2;\\\\n        margin: 0;\\\\n        padding: 0;\\\\n        font-family: \"Open Sans\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\\\\n        \\\\n    }\\\\n    div {\\\\n        width: 600px;\\\\n        margin: 5em auto;\\\\n        padding: 50px;\\\\n        background-color: #fff;\\\\n        border-radius: 1em;\\\\n    }\\\\n    a:link, a:visited {\\\\n        color: #38488f;\\\\n        text-decoration: none;\\\\n    }\\\\n    @media (max-width: 700px) {\\\\n        body {\\\\n            background-color: #fff;\\\\n        }\\\\n        div {\\\\n            width: auto;\\\\n            margin: 0 auto;\\\\n            border-radius: 0;\\\\n            padding: 1em;\\\\n        }\\\\n    }\\\\n    </style>    \\\\n</head>\\\\n\\\\n<body>\\\\n<div>\\\\n    <h1>Example Domain</h1>\\\\n    <p>This domain is established to be used for illustrative examples in documents. You may use this\\\\n    domain in examples without prior coordination or asking for permission.</p>\\\\n    <p><a href=\"http://www.iana.org/domains/example\">More information...</a></p>\\\\n</div>\\\\n</body>\\\\n</html>\\\\n\\''"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(fetch(\"www.example.com\",\"/\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "You can run the fetches in threads or processes. For the threaded implementation, a queue can be used to collect the results. For multi-process, Redis is a good choice, or you'll need something shared-memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}