00_datareader.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# read the data file\n",
    "\n",
    "just processing the json file into a list of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import re\n",
    "\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## read card data from json\n",
    "\n",
    "json file available at https://mtgjson.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_json(\"data//AllSets.json\", 'r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'artist': 'Thomas Denmark',\n",
       " 'cmc': 2,\n",
       " 'colorIdentity': ['W'],\n",
       " 'colors': ['White'],\n",
       " 'flavor': '\"If a boggart even dares breathe near one of my kin, I\\'ll know. And I\\'ll not be happy.\"',\n",
       " 'id': 'b373a0db34c644c48fe0245610a3c32ff144179b',\n",
       " 'imageName': 'kinsbaile skirmisher',\n",
       " 'layout': 'normal',\n",
       " 'manaCost': '{1}{W}',\n",
       " 'mciNumber': '16',\n",
       " 'multiverseid': 383292,\n",
       " 'name': 'Kinsbaile Skirmisher',\n",
       " 'number': '16',\n",
       " 'power': '2',\n",
       " 'rarity': 'Common',\n",
       " 'subtypes': ['Kithkin', 'Soldier'],\n",
       " 'text': 'When Kinsbaile Skirmisher enters the battlefield, target creature gets +1/+1 until end of turn.',\n",
       " 'toughness': '2',\n",
       " 'type': 'Creature &mdash; Kithkin Soldier',\n",
       " 'types': ['Creature']}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# example card\n",
    "card = data['M15']['cards'][15]\n",
    "card"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## parse data into lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total included cards: 30303\n",
      "excluded b/c funny mcost or P/T: 771\n"
     ]
    }
   ],
   "source": [
    "setnm = [] # {set}\n",
    "idnum = [] # 'id'\n",
    "names = [] # 'name'\n",
    "mcost = [] # 'manaCost'\n",
    "power = [] # 'power'\n",
    "tough = [] # 'toughness'\n",
    "rarty = [] # 'rarity'\n",
    "types = [] # 'types'\n",
    "subtp = [] # 'subtypes'\n",
    "ctext = [] # 'text'\n",
    "layot = [] # 'layout' >>> use to confirm not flippy or split\n",
    "\n",
    "split_excludes = 0\n",
    "\n",
    "def addcard(this_set, card):\n",
    "    \n",
    "    # add values\n",
    "    setnm.append(this_set)\n",
    "    idnum.append(card['id'])\n",
    "    names.append(card['name'])\n",
    "    rarty.append(card['rarity'])\n",
    "    layot.append(card['layout'])\n",
    "\n",
    "    if 'types' in card.keys():\n",
    "        types.append(' ' .join(card['types']))\n",
    "    else:\n",
    "        types.append('token')\n",
    "\n",
    "    if 'manaCost' in card.keys():\n",
    "        mcost.append(card['manaCost'])\n",
    "    else:\n",
    "        mcost.append(0)\n",
    "\n",
    "    if 'text' in card.keys():\n",
    "        ctext.append(card['text'])\n",
    "    else:\n",
    "        ctext.append('')    \n",
    "\n",
    "    if 'subtypes' in card.keys():\n",
    "        subtp.append(card['subtypes'])\n",
    "    else:\n",
    "        subtp.append(['PAD'])\n",
    "\n",
    "    if 'power' in card.keys():\n",
    "        power.append(card['power'])\n",
    "    else:\n",
    "        power.append('&#8999;')\n",
    "\n",
    "    if 'toughness' in card.keys():\n",
    "        tough.append(card['toughness'])\n",
    "    else:\n",
    "        tough.append('&#8999;')\n",
    "    \n",
    "    return\n",
    "\n",
    "for this_set in list(data.columns):\n",
    "    set_cards = data[this_set]['cards']\n",
    "    for card in set_cards:\n",
    "        \n",
    "        # only get normal(not flippy ,split, etc) cards, \n",
    "        # and exclude pwalkers, conspiracies, unsets, and tokens (no type)\n",
    "        # and exclude lands and hybrid mana costs for now...\n",
    "        # and exclude cards with funky mana too\n",
    "        if card['layout'] == 'normal' and 'types' in card.keys():\n",
    "            \n",
    "            if card['types'] not in ('Conspiracy', 'Planeswalker') and this_set not in ('UGL', 'UNH'):\n",
    "\n",
    "                if 'manaCost' in card.keys():\n",
    "                    \n",
    "                    if re.search(r'\\{[0-9A-Z]\\/[0-9A-Z]\\}', card['manaCost']) == None:\n",
    "                        \n",
    "                        # check creature for strange manacost\n",
    "                        if 'toughness' in card.keys() and 'power' in card.keys():\n",
    "                        \n",
    "                            if re.search(r'[^0-9]', card['power']) == None and re.search(r'[^0-9]', card['toughness']) == None:\n",
    "                            \n",
    "                                addcard(this_set, card)\n",
    "                                \n",
    "                            else:\n",
    "                                \n",
    "                                split_excludes += 1\n",
    "                        \n",
    "                        else:\n",
    "                            \n",
    "                            addcard(this_set, card)\n",
    "                            \n",
    "                    else:\n",
    "                        \n",
    "                        split_excludes += 1\n",
    "                \n",
    "print(\"total included cards:\", len(idnum))\n",
    "print(\"excluded b/c funny mcost or P/T:\", split_excludes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Common', 10891),\n",
       " ('Uncommon', 8984),\n",
       " ('Rare', 7993),\n",
       " ('Special', 1441),\n",
       " ('Mythic Rare', 994)]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(rarty).most_common()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Creature', 14616),\n",
       " ('Instant', 4191),\n",
       " ('Sorcery', 3831),\n",
       " ('Enchantment', 3805),\n",
       " ('Artifact', 2468),\n",
       " ('Artifact Creature', 988),\n",
       " ('Planeswalker', 190),\n",
       " ('Enchantment Creature', 101),\n",
       " ('Tribal Instant', 33),\n",
       " ('Tribal Sorcery', 26),\n",
       " ('Tribal Enchantment', 21),\n",
       " ('Host Creature', 15),\n",
       " ('Enchantment Artifact', 9),\n",
       " ('Tribal Artifact', 5),\n",
       " ('Artifact Host Creature', 4)]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(types).most_common()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of subtypes: 280\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('PAD', 12034),\n",
       " ('Human', 3207),\n",
       " ('Aura', 1698),\n",
       " ('Warrior', 996),\n",
       " ('Wizard', 984),\n",
       " ('Soldier', 951),\n",
       " ('Elemental', 699),\n",
       " ('Elf', 697),\n",
       " ('Zombie', 662),\n",
       " ('Goblin', 645)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allsubtypes = [st for lst in subtp for st in lst]\n",
    "print(\"total number of subtypes:\", len(set(allsubtypes)))\n",
    "Counter(allsubtypes).most_common()[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, ['Centaur', 'Druid', 'Scout', 'Archer'])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([len(l) for l in subtp]), subtp[np.argmax([len(l) for l in subtp])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max length threshhold: 657 chars\n",
      "95% length threshhold: 280 chars\n"
     ]
    }
   ],
   "source": [
    "# char-level text length analysis - uncomment to see\n",
    "lens = Counter([len(n) for n in ctext]).most_common()\n",
    "x = sorted(lens, key=lambda x: x[0], reverse=True)\n",
    "y = [t[0] for t in x]\n",
    "z = [t[1] for t in x]\n",
    "print('max length threshhold:', max(y), \"chars\")\n",
    "s = 0\n",
    "for i in range(len(y)):\n",
    "    s += z[i] \n",
    "    if s > int(sum(z)*0.05):\n",
    "        print('95% length threshhold:', y[i], \"chars\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max length threshhold: 113 words\n",
      "95% length threshhold: 48 words\n"
     ]
    }
   ],
   "source": [
    "# word-level text length analysis - uncomment to see\n",
    "lens = Counter([len(n.split()) for n in ctext]).most_common()\n",
    "x = sorted(lens, key=lambda x: x[0], reverse=True)\n",
    "y = [t[0] for t in x]\n",
    "z = [t[1] for t in x]\n",
    "print('max length threshhold:', max(y), \"words\")\n",
    "s = 0\n",
    "for i in range(len(y)):\n",
    "    s += z[i] \n",
    "    if s > int(sum(z)*0.05):\n",
    "        print('95% length threshhold:', y[i], \"words\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max length threshhold: 31 chars\n",
      "95% length threshhold: 21 chars\n"
     ]
    }
   ],
   "source": [
    "# char-level name length analysis - uncomment to see\n",
    "lens = Counter([len(n) for n in names]).most_common()\n",
    "x = sorted(lens, key=lambda x: x[0], reverse=True)\n",
    "y = [t[0] for t in x]\n",
    "z = [t[1] for t in x]\n",
    "print('max length threshhold:', max(y), \"chars\")\n",
    "s = 0\n",
    "for i in range(len(y)):\n",
    "    s += z[i] \n",
    "    if s > int(sum(z)*0.05):\n",
    "        print('95% length threshhold:', y[i], \"chars\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "longest name: Circle of Protection: Artifacts 31\n",
      "\n",
      "longest text: \n",
      " Master of the Hunt \n",
      " {2}{G}{G}: Create a 1/1 green Wolf creature token named Wolves of the Hunt. It has \"bands with other creatures named Wolves of the Hunt.\" (Any creatures named Wolves of the Hunt can attack in a band as long as at least one has \"bands with other creatures named Wolves of the Hunt.\" Bands are blocked as a group. If at least two creatures named Wolves of the Hunt you control, one of which has \"bands with other creatures named Wolves of the Hunt,\" are blocking or being blocked by the same creature, you divide that creature's combat damage, not its controller, among any of the creatures it's being blocked by or is blocking.) 113\n"
     ]
    }
   ],
   "source": [
    "# longest name, longest ability text\n",
    "maxname = max([len(n) for n in names])\n",
    "maxidx = np.argmax([len(n) for n in names])\n",
    "print(\"longest name:\", names[maxidx], maxname)\n",
    "print('')\n",
    "maxtext = max([len(n.split()) for n in ctext])\n",
    "maxtidx = np.argmax([len(n.split()) for n in ctext])\n",
    "print(\"longest text:\", '\\n', names[maxtidx], '\\n', ctext[maxtidx], maxtext)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## preprocessing\n",
    "\n",
    "replace certain things with unique tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "pad_sub = max([len(l) for l in subtp])\n",
    "\n",
    "for i in range(len(idnum)):\n",
    "    # lowercase'&#8999;')\n",
    "    ctext[i] = ctext[i].lower()\n",
    "    names[i] = names[i].lower()\n",
    "    \n",
    "    # replace newlines with pipes\n",
    "    ctext[i] = ctext[i].replace('\\n', '|')\n",
    "    \n",
    "    # replace cardname in text with '&#9411;'\n",
    "    ctext[i] = ctext[i].replace(names[i], '&#9411;')\n",
    "\n",
    "    # replace tap {T} with '&#8631;' in text :\n",
    "    ctext[i] = ctext[i].replace('{t}', '&#8631;')\n",
    "    \n",
    "    # replace '+1/+1', '-1/-1' (?=counter) with '&oplus;', '&#8854;' in text:\n",
    "    # ctext[i] = re.sub(r'\\+1\\/\\+1(?=\\scounter)', '&oplus;', ctext[i])\n",
    "    # ctext[i] = re.sub(r'\\-1\\/\\-1(?=\\scounter)', '&oplus;', ctext[i])\n",
    "    \n",
    "    # MANA COSTS: \n",
    "    # replace {C} with '&#9420;', '&#9418;', '&#9399;', '&#9415;', '&#9404;' in ctext, mcost\n",
    "    colors = ['{W}', '{U}', '{B}', '{R}', '{G}', '{C}', '{w}', '{u}', '{b}', '{r}', '{g}', '{c}']\n",
    "    symbols = ['&#9420;', '&#9418;', '&#9399;', '&#9415;', '&#9404;', '&#9400;', '&#9420;', '&#9418;', '&#9399;', '&#9415;', '&#9404;', '&#9400;']\n",
    "    for j, color in enumerate(colors):\n",
    "        ctext[i] = ctext[i].replace(color, symbols[j])\n",
    "        mcost[i] = mcost[i].replace(color, symbols[j])\n",
    "        \n",
    "    # replace {#} with number icon and {X} with '&#9421;':\n",
    "    numbers = ['{x}', '{X}', '{1}', '{2}', '{3}', '{4}', '{5}', '{6}', '{7}', '{8}', '{9}', '{10}', '{11}', '{12', '{13}', '{14}', '{15}', '{16}', '{17}', '{18}', '{19}', '{20}']\n",
    "    nsymbols= ['&#9421;', '&#9421;', '&#9312;', '&#9313;', '&#9314;', '&#9315;', '&#9316;', '&#9317;', '&#9318;', '&#9319;', '&#9320;', '&#9321;', '&#9322;', '&#9323;', '&#9324;', '&#9325;', '&#9326;', '&#9327;', '&#9328;', '&#9329;', '&#9330;', '&#9331;']\n",
    "    for j, number in enumerate(numbers):\n",
    "        ctext[i] = ctext[i].replace(number, nsymbols[j])\n",
    "        mcost[i] = mcost[i].replace(number, nsymbols[j])\n",
    "        \n",
    "    # pad subtype with '&#8999;'\n",
    "    while len(subtp[i]) < pad_sub:\n",
    "        if type(subtp[i]) == str:\n",
    "            print(subtp[i])\n",
    "        else:\n",
    "            subtp[i].append('PAD')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## create a `pandas` dataframe and save data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "carddf = pd.DataFrame({\n",
    "    'set' : setnm,\n",
    "    'card_id' : idnum,\n",
    "    'card_name' : names,\n",
    "    'mana_cost' : mcost,\n",
    "    'rarity' : rarty,\n",
    "    'type' : types,\n",
    "    'subtypes' : subtp,\n",
    "    'card_text' : ctext,\n",
    "    'power' : power,\n",
    "    'toughness' : tough    \n",
    "})\n",
    "\n",
    "carddf = carddf[['set', 'card_id', 'rarity', 'card_name', 'mana_cost', 'type', 'subtypes', 'power', 'toughness', 'card_text']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "carddf.to_csv('data//card_database.csv', index=False)\n",
    "np.save('data//card_database.npy', carddf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('data//numpy//setnm.npy', setnm)\n",
    "np.save('data//numpy//idnum.npy', idnum)\n",
    "np.save('data//numpy//names.npy', names)\n",
    "np.save('data//numpy//mcost.npy', mcost)\n",
    "np.save('data//numpy//rarty.npy', rarty)\n",
    "np.save('data//numpy//types.npy', types)\n",
    "np.save('data//numpy//subtp.npy', subtp)\n",
    "np.save('data//numpy//ctext_orig.npy', ctext)\n",
    "np.save('data//numpy//power.npy', power)\n",
    "np.save('data//numpy//tough.npy', tough) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## view some cards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "iters = iter([i for i in range(len(idnum))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ancestor's chosen \t &#9316;&#9420;&#9420;\n",
      "\n",
      "Creature - Human Cleric PAD PAD ( 10E Uncommon )\n",
      "\n",
      "first strike (this creature deals combat damage before creatures without first strike.)\n",
      "\n",
      "when &#9411; enters the battlefield, you gain 1 life for each card in your graveyard.\n",
      "\n",
      "4 / 4\n"
     ]
    }
   ],
   "source": [
    "i = next(iters)\n",
    "print(names[i], '\\t', mcost[i])\n",
    "print('')\n",
    "if subtp[i][0] != '&#8999;':\n",
    "    sub = '- ' + ' '.join(subtp[i])\n",
    "else:\n",
    "    sub = '\\t'\n",
    "print(types[i], sub, '(', setnm[i], rarty[i], ')')\n",
    "print('')\n",
    "print(ctext[i].replace('|', '\\n\\n'))\n",
    "print('')\n",
    "if power[i] != '&#8999;' and tough[i] != '&#8999;':\n",
    "    print(power[i], '/', tough[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## testing ability vocab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# preprocessing: properly space all symbols\n",
    "# also, remove all hint text (text in parentheses)\n",
    "dels = []\n",
    "dtext = []\n",
    "for idx, txt in enumerate(ctext):\n",
    "    \n",
    "    if re.search(r'\\([0-9A-Za-z\\s\\.\\,\\'\\\"]+\\)', txt):\n",
    "        dels.append(re.search(r'\\([0-9A-Za-z\\s\\.\\,\\'\\\"]+\\)', txt))\n",
    "    \n",
    "    txt = re.sub(r'\\([0-9A-Za-z\\s\\.\\,\\'\\\"]+\\)', '', txt)\n",
    "    \n",
    "    rep = re.findall(r'[^0-9A-Za-z\\s\\'\\-\\+\\/]', txt)\n",
    "    for r in rep:\n",
    "        txt = txt.replace(r, ' '+r+' ')\n",
    "    txt = re.sub(r'[\\s]+', ' ', txt)\n",
    "    dtext.append(txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "angel of mercy \t &#9315;&#9420;\n",
      "\n",
      "Creature - Angel PAD PAD PAD ( 10E Uncommon )\n",
      "\n",
      "flying \n",
      "\n",
      " when &#9411; enters the battlefield , you gain 3 life . \n",
      "\n",
      "3 / 3\n"
     ]
    }
   ],
   "source": [
    "i = next(iters)\n",
    "print(names[i], '\\t', mcost[i])\n",
    "print('')\n",
    "if subtp[i][0] != '&#8999;':\n",
    "    sub = '- ' + ' '.join(subtp[i])\n",
    "else:\n",
    "    sub = '\\t'\n",
    "print(types[i], sub, '(', setnm[i], rarty[i], ')')\n",
    "print('')\n",
    "print(dtext[i].replace('|', '\\n\\n'))\n",
    "print('')\n",
    "if power[i] != '&#8999;' and tough[i] != '&#8999;':\n",
    "    print(power[i], '/', tough[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1969"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split on space and get vocab\n",
    "dlists = [x.split(' ') for x in dtext]\n",
    "dvocab = [st for lst in dlists for st in lst]\n",
    "dcount = Counter(dvocab)\n",
    "len(set(dvocab))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('.', 47675),\n",
       " ('', 35467),\n",
       " (',', 26589),\n",
       " ('creature', 18515),\n",
       " ('|', 18002),\n",
       " ('&#9411;', 17830),\n",
       " ('the', 16852),\n",
       " ('a', 16389),\n",
       " ('you', 15842),\n",
       " ('of', 13858)]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dcount.most_common(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('data//numpy//ctext.npy', dtext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}