190911_regular_expressions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Regular Expressions and Patterns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Regular expressions (regex) are short statements which describe patterns of text for searching within text\n",
    "* A regular expression is interpreted by a regex processor, which can be used to search in or split up text into \"chunks\"\n",
    "* A regex follows a sort of \"mini-language\" of programming to define patterns of interest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* In my not so humble view, regexs are:\n",
    "  * Pretty awesome\n",
    "  * Pretty efficient\n",
    "  * Compact\n",
    "  * Painful to read if complex\n",
    "  * Hard as hell to debug\n",
    "  * Are super fragile and should be rarely used in production programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* However, in data science, regexs should be used, and fairly often. This is especially true because:\n",
    "  * A lot of data cleaning code is \"one off\" or \"few off\" -- it just needs to work on a limited set of data, not be robust across all kinds of input data\n",
    "  * The data science process involves a lot of \"understanding of your data\", where the data is poorly described, and thus\n",
    "    * You will write a lot of throw away code\n",
    "    * You will want to rapidly investigate your code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Good uses of regex:\n",
    "  * Validating input data (\"Hey, make sure all phone numbers are in the format (###) ###-####\")\n",
    "  * Quick and dirty cleaning of data when you can verify the results easily\n",
    "* Questionable uses of regex:\n",
    "  * If someone needs to be able to understand what you wrote\n",
    "  * If there are a lot of edge cases (in which case you might want regex + more error handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* One more reason to learn regex: they're nearly ubiquitously supported in tools and languages (Java, python, C#, as well as grep, text editors etc)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Regex's in python are done through the `re` module (and the docs are your friend!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import IFrame    \n",
    "display(IFrame(\"https://docs.python.org/3/library/re.html\", width=\"100%\", height=700))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* The most important operations are:\n",
    "  * `re.search()` which returns a `Match` object for the first item which can be found\n",
    "  * `re.finditer()` which returns an iterator over `Match` objects for items found\n",
    "  * `re.findall()` which returns a bunch of `string` objects, `re.finditer()` is generally prefered\n",
    "  * `re.split()` which uses a pattern to break up a string\n",
    "  * `re.sub()` which replaces substrings through substitution\n",
    "* But! Lots of other modules will take in a regex as well, and we'll touch on them in pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideOutput": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* The Match object is key to understand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "print(re.Match.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* If nothing is found the `Match` object doesn't exist - it's `None`.\n",
    "* There is some important subtlety here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Quick example\n",
    "strng = \"I absolutely love Christopher Brooks and everything \\\n",
    " he does in class, he is amazing.\"\n",
    "pattern = \"Chris\"\n",
    "result = re.search(pattern, strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if result:\n",
    "    print(\"I knew it was about Chris!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if result == True:\n",
    "    print(\"I knew it was about Chris!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Wait, wtf? How does work? Why does `result == True` not evaluate to `True`, but `result is True` does, when we have a `Match` object?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* This is important python object understanding:\n",
    "  * `==` checks for equality between objects, that the left hand side and right hand side point to the **same** object. In this case, `True` is not the same as a given `Match` object\n",
    "  * `is` is a function which is called on the `Match` object and returns a value of `True` or `False`. The authors of the `re` module have implemented this function to make life easy for us\n",
    "* Don't use `==` with `Match` objects. In truth, never use `==` when checking a `bool`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Ok, that was a bit of a digression, let's get back on track\n",
    "* Match objects also have some helpful information inside of them, such as what was matched (`match`) and where it was matched in the string (`span`)\n",
    "* This can be helpful when your patterns can match many different substrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Patterns\n",
    "* We've already seen the most basic pattern, just a list of ordinary alphanumeric characters\n",
    "* But there are a lot of special characters. Let's start with `.`\n",
    "* `.` will match any single character except for newline characters (which we represent with the escaped`\\n`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "pattern='G..d'\n",
    "re.search(pattern, 'Good')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(pattern, 'Gawd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "pattern='G..d'\n",
    "re.search(pattern, 'Goodness!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(pattern, 'God')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* The next patterns to be aware of are\n",
    "  * `\\s` which matches whitespace, this will match odd unicode whitespaces, tabs, spaces, etc.\n",
    "  * `\\S` which matches non-whitespace\n",
    "  * `\\d` which matches digits\n",
    "  * `\\D` which matches non-digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "pattern=\"\\D\\d\\d\\d\\D\\s\\d\\d\\d-\\d\\d\\d\\d\"\n",
    "re.search(pattern,\"(306) 262-2905\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search(pattern,\"306-262-2905\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "pattern=\"\\D\\d\\d\\d\\D\\s\\d\\d\\d-\\d\\d\\d\\d\"\n",
    "# But we see it's not an ideal pattern...\n",
    "re.search(pattern,\":306p 262-2905\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* In addition to characters to match, we can match next to positions (boundaries)\n",
    "  * `^` match to the beginning of a line\n",
    "  * `$` match to the end of a line\n",
    "  * `\\b` which matches to the beginning or end of a **word**\n",
    "  * `\\B` which matches not to the beginning or end of a work\n",
    "  * `\\w` matches to a word character (defined as letter, number or... underscore?)\n",
    "  * `\\W` matches to a non-word character'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "strng=\"My goodness, have you heard that Chris \\\n",
    "Brooks teach? He's amazing!\"\n",
    "re.search('^Brooks', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search('^My', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# words that start with good (but not good itself)\n",
    "re.search('\\bgood\\B', strng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Wait, WTF? Isn't that supposed to work? What is happening here?\n",
    "  * Gah. Strings are a mess in Python. There are 3 ways of representing strings:\n",
    "    * Just as per normal: `strng=\"No thank you\"`, in Python 3 this is unicode data\n",
    "    * As an array of bytes: `strng=b\"No thank you\"`, this is not done in Python 3 and reminds Chris of the simplier days. Who needs more than 255 characters?\n",
    "    * As a raw string. In this case, the backslash characters are left in and not escaped by the string processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print('No thank you chris brooks')\n",
    "print('No thank you chris \\brooks')\n",
    "print(r'No thank you chris \\brooks')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Goodness! The `\\b` that we were putting in the string was being mistaken for a backspace character!\n",
    "* Wait, why didn't this happen with the \\d before?\n",
    "* Because \\d isn't a special character..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Morale of the story: Always prepend your regex strings with r\n",
    "* Seriously. Always. Make your life easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# words that start with good (but not good itself)\n",
    "re.search(r'\\bgood\\B', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# what's going to happen!?\n",
    "print(len('a'))\n",
    "print(len('a\\b'))\n",
    "print('a\\b')\n",
    "print(len(r'a\\b'))\n",
    "print(r'a\\b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "strng=\"Dang I love this class! It was worth every $\"\n",
    "re.search(r'worth every $', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.search('worth every \\$', strng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Quantifiers\n",
    "* A few different kinds of special sequence characters we can use\n",
    "  * `*` zero or more of the previous character\n",
    "  * `+` one or more of the previous character\n",
    "  * `?` zerp or one of the previous character\n",
    "  * `{m,n}` between `m` and `n` of the previous character, where `n` is optional and if left out it means either exactly `m` (`{m}`) or `m` or more (`{m,`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "strng='`My phone number is (306) 373-2905'\n",
    "re.search(r'\\d*', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ok, seems like that wasn't the aim\n",
    "strng='`My phone number is (306) 373-2905'\n",
    "re.search(r'\\d+', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# can we find all number fragments in the string?\n",
    "re.findall(r'\\d+', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# what do you think this will do?\n",
    "re.findall(r'\\d{1,3}', strng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# imagine these are your grades over time\n",
    "grades='\"ACCAAAABCBCBAA'\n",
    "# how do you find your longest A streak?\n",
    "re.findall(r'A+', grades)\n",
    "# it's in there somewhere...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# What do you figure this does?\n",
    "grades='\"ACCAAAABCBCBAA'\n",
    "re.findall(r'CA+', grades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sets of Characters\n",
    "* We can wrap a set of characters we want to match inside of `[]`\n",
    "* `[aeiou]` means match any vowel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.findall(r'[aeiou]+','The quick brown fox jumped over the...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# we can negate THE WHOLE SET with a caret `^`\n",
    "re.findall(r'[^aeiou]{1}','The quick brown fox jumped over the...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "re.findall(r'dog[s]{1}','The dogs ran after the big dog')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* We can also define a range inside of a character set. This is still used, but meta characters are often more appropriate.\n",
    "  * `[A-Z]` all upper case roman characters\n",
    "  * `[a-zA-Z]` all upper case or lower roman characters\n",
    "  * `[a-zA-Z0-9_]` the same as `\\w`\n",
    "  *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# unicode ranges work too\n",
    "re.findall(r'[α-ω]+','Someone once said, \"I am the α\". Does this mean there is a γ?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* And logic is implicit, but if you want to specify an or you use a pipe `|`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "line=\"POST /incentivize HTTP/1.1\"\n",
    "re.findall(r'HTTP/1.[1|2]',line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Play time\n",
    "* Let's play! Someone throw out a Canadian hockey player name?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Insert fun 🇨🇦🏒 activity here.\n",
    "# save data as datasets/wiki.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Capture Groups\n",
    "* Up until this point it probably seems really laborious. It is.\n",
    "* Capture groups let us match and/or extract subpatterns so we can build many regexes up together\n",
    "* To indicate a capture group we use parentheses `()`\n",
    "* The cannonical example? An email address"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "strng=\"Wow, the course taught by brooksch@umich.edu is fire!\"\n",
    "re.search(r'[\\w.-]+@[\\w.-]+',strng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* But, there are actually a few different parts of an email address, including the username and the hostname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "strng=\"Wow, the course taught by brooksch@umich.edu is fire!\"\n",
    "match=re.search(r'([\\w.-]+)@([\\w.-]+)',strng)\n",
    "if match:\n",
    "    print(match.group()) # the whole match\n",
    "    print(match.group(1))# the first group\n",
    "    print(match.group(2))# the second group"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Capture groups get even cooler though: you can label them like a variable\n",
    "* Uses the syntax `(?P<name>)`, where \n",
    "  * the `()` denotes a capture group \n",
    "  * the `?P` indicates this is an extension to standard regex\n",
    "  * the `<name>` means that matches for that group are labeled with the dictionary key `name`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# read in the wiki text\n",
    "with open(\"datasets/wiki.txt\",\"r\") as file:\n",
    "    wiki=file.read()\n",
    "\n",
    "# can you write a better regex to pull out titles from that datafile?\n",
    "for item in re.finditer(\"???\",wiki):\n",
    "    print(item.groupdict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Last topic I'll touch on in capture groups: thus far the focus has been on returning and labeling the capture groups\n",
    "* What if we want to match on the group, but don't want to see it come back?\n",
    "* (like \\[edit\\])\n",
    "* We can use non capturing groups\n",
    "  * `(?:...)` Match but don't return the group"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Here's an example from the New York Times which covers health tweets on news items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# get a list of all of the hashtags that are included in this data\n",
    "with open(\"datasets/nytimeshealth.txt\",\"r\") as file:\n",
    "    health=file.read()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Lets see an example using data from wikipedia on US universities which are buddhist-based"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Get a list of dicts where each university 'name', 'city', and 'state' are labeled as such\n",
    "with open(\"datasets/buddhist.txt\",\"r\") as file:\n",
    "    wiki=file.read()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](https://imgs.xkcd.com/comics/regular_expressions.png)"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}