Movie_review_imdb_scrapping.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "#importing beautiful soap for scrapping the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dependencies\n",
    "\n",
    "`BBeautifulSoup` :    pip install BeautifulSoup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import itertools #to create efficent looping to fetch more data in a go\n",
    "import re \n",
    "import random \n",
    "from textblob import TextBlob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating BS4 Functions for scrapping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  Movies are cateogirsed into seven and each category is processed by indivitual team members.\n",
    "- category 1: [1940 to 1980 200 movie listing with rating=10000](https://www.imdb.com/search/title/?title_type=feature&release_date=1940-01-01,1980-12-31&num_votes=10000,&count=200) \n",
    "- category 2: [2020 to 2021 200 movie listing with rating=20000](https://www.imdb.com/search/title/?title_type=feature&release_date=2020-01-01,2021-12-31&num_votes=20000,&count=200) \n",
    "- category 3: [2000 to 2021 200 movie listing with rating=60000](https://www.imdb.com/search/title/?title_type=feature&release_date=2000-01-01,2021-12-31&num_votes=60000,&count=200) \n",
    "- category 4: [1940 to 1980 200 movie listing with rating=10000](https://www.imdb.com/search/title/?title_type=feature&release_date=2005-01-01,2015-12-31&num_votes=30000,&count=200) \n",
    "- category 5: [1980 to 2019 200 movie listing with rating=500000](https://www.imdb.com/search/title/?title_type=feature&release_date=1980-01-01,2019-12-31&num_votes=500000,&count=200) \n",
    "- category 6: [1980 to 2019 200 movie listing with rating=80000](https://www.imdb.com/search/title/?title_type=tv_series&release_date=1980-01-01,2019-12-31&num_votes=80000,&count=200) \n",
    "- category 7: [2005 to 2010 200 movie listing with rating=5000](https://www.imdb.com/search/title/?title_type=feature&release_date=2005-01-01,2010-12-31&num_votes=5000,&count=200) \n",
    "\n",
    "#Sample files are put into Data_scrapped folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = \"https://www.imdb.com/search/title/?title_type=feature&release_date=2009-01-01,2011-12-31&num_votes=2000,&count=200\" #2000 - 2021 6000votes filter 200 titles (imdb not letting to filter >200 titles in a go)\n",
    "\n",
    "def getSoup(url):\n",
    "    \"\"\"\n",
    "    Utility function this get soup function will fetch the above url which stored in url var.\n",
    "    \"\"\"\n",
    "    headers = {\n",
    "        'User-Agent': 'Your User-Agent String',\n",
    "        'Authorization': 'Bearer Your_Authentication_Token'  # Include this if authentication is required\n",
    "    }\n",
    "    try:\n",
    "        response = requests.get(url, headers=headers)  # Removed custom headers\n",
    "        response.raise_for_status()  # Check if request was successful\n",
    "        return BeautifulSoup(response.text, 'html.parser')\n",
    "    except requests.exceptions.RequestException as e:\n",
    "        print(f\"Failed to fetch URL: {url} - {e}\")\n",
    "        return None\n",
    "\n",
    "def getReviews(soup):\n",
    "    '''Function returns all reviews including postive and negative..'''\n",
    "    \n",
    "    # get a list of user ratings\n",
    "    user_review_ratings = [tag.previous_element for tag in \n",
    "                           soup.find_all('span', attrs={'class': 'point-scale'})]      \n",
    "                             #can search div by inspect elementor\n",
    "    \n",
    "    \n",
    "    # get the review tags\n",
    "    user_review_list = soup.find_all('a', attrs={'class':'title'})\n",
    "    ans = []\n",
    "    for i in range(5):\n",
    "        ans.append(user_review_list[random.randint(0, len(user_review_list) -1)])\n",
    "    links = [\"https://www.imdb.com\" + tag['href'] for tag in ans]\n",
    "    return links\n",
    "\n",
    "\n",
    "def getReviewText(review_url):\n",
    "    '''Returns the user review text given the review url.'''\n",
    "    if review_url is None:\n",
    "        return None\n",
    "    try:\n",
    "        # Assuming we're looking for a specific tag for reviews\n",
    "        tag = review_url.find('div', attrs={'class': 'text show-more__control'})\n",
    "        return tag.get_text() if tag else \"No review text found\"\n",
    "    except AttributeError as e:\n",
    "        print(f\"Error extracting review text: {e}\")\n",
    "        return None\n",
    "\n",
    "\n",
    "def getMovieTitle(review_url):\n",
    "    '''Returns the movie title from the review url.'''\n",
    "    # get the review_url's soup\n",
    "    soup = getSoup(review_url)\n",
    "    # find h1 tag\n",
    "    tag = soup.find('h1')\n",
    "    return list(tag.children)[1].getText()\n",
    "\n",
    "def getNounChunks(user_review):\n",
    "    # create the doc object\n",
    "    doc = nlp(user_review)\n",
    "    # get a list of noun_chunks\n",
    "    noun_chunks = list(doc.noun_chunks)\n",
    "    # convert noun_chunks from span objects to strings, otherwise it won't pick\n",
    "    noun_chunks_strlist = [chunk.text for chunk in noun_chunks]\n",
    "    return noun_chunks_strlist\n",
    "movies_soup = getSoup(url)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering the movie tags"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are a total of 25 movie titles\n",
      "Displaying 10 titles\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['/title/tt0327597/',\n",
       " '/title/tt1273235/',\n",
       " '/title/tt1375666/',\n",
       " '/title/tt1131734/',\n",
       " '/title/tt1259521/',\n",
       " '/title/tt1262416/',\n",
       " '/title/tt1591095/',\n",
       " '/title/tt1130884/',\n",
       " '/title/tt0361748/',\n",
       " '/title/tt0758746/']"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_tags = movies_soup.find_all('a', attrs={'class': \"ipc-title-link-wrapper\"})\n",
    "\n",
    "# filter the a-tags to get just the titles\n",
    "movie_links = [tag.attrs['href'][:tag.attrs['href'].index('?')] for tag in movie_tags]\n",
    "\n",
    "# remove duplicate links\n",
    "unique_movie_links = list(dict.fromkeys(movie_links))\n",
    "\n",
    "print(\"There are a total of \" + str(len(unique_movie_links)) + \" movie titles\")\n",
    "print(\"Displaying 10 titles\")\n",
    "unique_movie_links[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering the movie URL's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are a total of 25 movie user reviews\n",
      "Displaying 20 user reviews links\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['https://www.imdb.com/title/tt0327597/reviews',\n",
       " 'https://www.imdb.com/title/tt1273235/reviews',\n",
       " 'https://www.imdb.com/title/tt1375666/reviews',\n",
       " 'https://www.imdb.com/title/tt1131734/reviews',\n",
       " 'https://www.imdb.com/title/tt1259521/reviews',\n",
       " 'https://www.imdb.com/title/tt1262416/reviews',\n",
       " 'https://www.imdb.com/title/tt1591095/reviews',\n",
       " 'https://www.imdb.com/title/tt1130884/reviews',\n",
       " 'https://www.imdb.com/title/tt0361748/reviews',\n",
       " 'https://www.imdb.com/title/tt0758746/reviews',\n",
       " 'https://www.imdb.com/title/tt1201607/reviews',\n",
       " 'https://www.imdb.com/title/tt1467304/reviews',\n",
       " 'https://www.imdb.com/title/tt1311067/reviews',\n",
       " 'https://www.imdb.com/title/tt1189340/reviews',\n",
       " 'https://www.imdb.com/title/tt0947798/reviews',\n",
       " 'https://www.imdb.com/title/tt1119646/reviews',\n",
       " 'https://www.imdb.com/title/tt0926084/reviews',\n",
       " 'https://www.imdb.com/title/tt1853739/reviews',\n",
       " 'https://www.imdb.com/title/tt1014759/reviews',\n",
       " 'https://www.imdb.com/title/tt1438176/reviews']"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "base_url = \"https://www.imdb.com\"\n",
    "movie_links = []\n",
    "\n",
    "for tag in movie_tags:\n",
    "    href = tag.attrs.get('href', '')\n",
    "    if '?' in href:\n",
    "        movie_url = base_url + href[:href.index('?')] + 'reviews'\n",
    "    else:\n",
    "        movie_url = base_url + href + 'reviews'\n",
    "    \n",
    "    movie_links.append(movie_url)\n",
    "print(\"There are a total of \" + str(len(movie_links)) + \" movie user reviews\")\n",
    "print(\"Displaying 20 user reviews links\")\n",
    "movie_links[:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie_soups = [getSoup(link) for link in movie_links]\n",
    "# get all movie review links from the 200 listing\n",
    "movie_review_list = [getReviewText(movie_soup) for movie_soup in movie_soups]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n",
      "There are a total of 500 individual movie reviews\n",
      "Displaying 10 reviews\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['N', 'o', ' ', 'r', 'e', 'v', 'i', 'e', 'w', ' ']"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Checking how many movie review were able to filter.\n",
    "movie_review_list = list(itertools.chain(*movie_review_list))\n",
    "print(len(movie_review_list))\n",
    "\n",
    "print(\"There are a total of \" + str(len(movie_review_list)) + \" individual movie reviews\")\n",
    "print(\"Displaying 10 reviews\")\n",
    "movie_review_list[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting into the Pandas Data Frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "str.find() takes no keyword arguments",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[252], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m review_texts \u001b[38;5;241m=\u001b[39m [\u001b[43mgetReviewText\u001b[49m\u001b[43m(\u001b[49m\u001b[43murl\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m url \u001b[38;5;129;01min\u001b[39;00m movie_review_list]\n\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m# get movie name from the review link\u001b[39;00m\n\u001b[0;32m      4\u001b[0m movie_titles \u001b[38;5;241m=\u001b[39m [getMovieTitle(url) \u001b[38;5;28;01mfor\u001b[39;00m url \u001b[38;5;129;01min\u001b[39;00m movie_review_list]\n",
      "Cell \u001b[1;32mIn[239], line 43\u001b[0m, in \u001b[0;36mgetReviewText\u001b[1;34m(review_url)\u001b[0m\n\u001b[0;32m     40\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m     41\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m     42\u001b[0m     \u001b[38;5;66;03m# Assuming we're looking for a specific tag for reviews\u001b[39;00m\n\u001b[1;32m---> 43\u001b[0m     tag \u001b[38;5;241m=\u001b[39m \u001b[43mreview_url\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfind\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdiv\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mclass\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtext show-more__control\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     44\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m tag\u001b[38;5;241m.\u001b[39mget_text() \u001b[38;5;28;01mif\u001b[39;00m tag \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo review text found\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m     45\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n",
      "\u001b[1;31mTypeError\u001b[0m: str.find() takes no keyword arguments"
     ]
    }
   ],
   "source": [
    "review_texts = [getReviewText(url) for url in movie_review_list]\n",
    "\n",
    "# get movie name from the review link\n",
    "movie_titles = [getMovieTitle(url) for url in movie_review_list]\n",
    "\n",
    "# Filtering the dataframe with only User_reviews by avoiding links and title\n",
    "\n",
    "# construct a dataframe\n",
    "df = pd.DataFrame({\n",
    "             'user_review': review_texts })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_review</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [user_review]\n",
       "Index: []"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(5) #displaying the resultant data frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The data frame need to remove index and filter the limit review length by 250 words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "text_list = [m for m in df['user_review']]\n",
    "#text_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_review</th>\n",
       "      <th>length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [user_review, length]\n",
       "Index: []"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#calculating the length of the text\n",
    "text_list_length = [len(m.split()) for m in text_list]     \n",
    "df['length'] = text_list_length\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_review</th>\n",
       "      <th>length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [user_review, length]\n",
       "Index: []"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = df[df['length'] < 250]  #limiting the df by 250 in length\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>user_review</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [user_review]\n",
       "Index: []"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.drop('length', axis=1, inplace=True)\n",
    "df\n",
    "#dropping the len row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "#converting only reviews to CSV & removing the index\n",
    "df.to_csv('data_scrapped/data.csv', index=False) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Splitting the csv file to the indivitual text files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "with open(\"data_scrapped/data.csv\", \"r\") as f:\n",
    "        reader = csv.reader(f)\n",
    "        rownumber = 2639\n",
    "        for row in reader:\n",
    "             g=open(str(rownumber)+\".txt\",\"w\")\n",
    "             g.write(str(row))\n",
    "             rownumber = rownumber + 1\n",
    "             g.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analyze_sentiment(text):\n",
    "    \"\"\"\n",
    "    Analyzes the sentiment of the input text.\n",
    "    \n",
    "    Returns:\n",
    "    - 'positive' if sentiment polarity > 0\n",
    "    - 'negative' if sentiment polarity < 0\n",
    "    - 'neutral' if sentiment polarity == 0\n",
    "    \"\"\"\n",
    "    blob = TextBlob(text)\n",
    "    polarity = blob.sentiment.polarity\n",
    "    \n",
    "    if polarity > 0:\n",
    "        return 'positive'\n",
    "    elif polarity < 0:\n",
    "        return 'negative'\n",
    "    else:\n",
    "        return 'neutral'\n",
    "\n",
    "# Assuming df is your DataFrame containing the reviews\n",
    "df['sentiment'] = df['user_review'].apply(analyze_sentiment)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <------------------------------------------------------EOL----------------------------------------------------------------->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Dataset\n",
    "\n",
    "Here is the Link to Final Dataset: [Drive Link](https://drive.google.com/file/d/1sTNAeuy-99Hao0V5AOVznLXyDJC2zuFn/view?usp=sharing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "23784c1f7cb08f751fc8275aaeeb793366452f178ab646d6f5c554e80b94c083"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}