Dependency Parsing Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b2d13260",
   "metadata": {},
   "source": [
    "## Follow Steps found in \n",
    " - https://towardsdatascience.com/natural-language-processing-dependency-parsing-cf094bbbe3f7\n",
    " ### A list of NLP libraries that can be used \n",
    " - https://medium.com/@soffosdotai/top-7-python-nlp-libraries-and-their-applications-in-2023-bd0c4395851b\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61e073b4",
   "metadata": {},
   "source": [
    "## Genius access token \n",
    "client ID: YNiczFFSCq1ZrNpdWaasGqGPG03cxe8drkbwv5b41MA-TXZiZqQehT_NjpyUGRMu\n",
    "client secret: 1UzBNab_mGL4ICeMdMj32EiwfmPtGsZDYMBckFKT-irCdFIJUVf01kKhsgLptuT_jpcAdbi4A1OlzI_sLvaLxQ\n",
    "client access token: AcU_KX10e5nyufSsdSw9vwAf12Vox91khaxz0BH-5oIP9G6pu_RoyS4ojUUocy8V"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3639f8c",
   "metadata": {},
   "source": [
    "### Things to do\n",
    "- a function to Isolate the lyrics into sentence fragmetns \n",
    "- a function to create your own tokens (maybe help with the lap lyric contextualization)\n",
    "- a function that runs the nlp pipeline, either your own token or a built in one\n",
    "- Figure out the data structure for the output and how that can help in sending the output for humdrum, maybe just a json can be helpful in the same way we make the table? read up on that \n",
    "- Convert to a humdrum stem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfec3a1d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d8357a1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Searching for songs by Eminem...\n",
      "\n",
      "Done. Found 0 songs.\n",
      "Searching for \"Not Afraid\" by Eminem...\n",
      "Done.\n",
      "358 ContributorsTranslationsPortuguêsItalianoΕλληνικάFrançaisNot Afraid Lyrics[Chorus]\n",
      "I'm not afraid (I'm not afraid)\n",
      "Yeah\n",
      "To take a stand (To take a stand)\n",
      "It's been a ride\n",
      "Everybody (Everybody)\n",
      "I guess I had to\n",
      "Come take my hand (Come take my hand)\n",
      "Go to that place to get to this one\n",
      "We'll walk this road together, through the storm\n",
      "Now some of you\n",
      "Whatever weather, cold or warm\n",
      "Might still be in that place\n",
      "Just lettin' you know that you're not alone\n",
      "If you're tryna get out\n",
      "Holla if you feel like you've been down the same road\n",
      "Just follow me, I'll get you there\n",
      "\n",
      "[Verse 1]\n",
      "You can try and read my lyrics off of this paper before I lay 'em\n",
      "But you won't take the sting out these words before I say 'em\n",
      "'Cause ain't no way I'ma let you stop me from causin' mayhem\n",
      "When I say I'ma do somethin', I do it, I don't give a damn what you think\n",
      "I'm doin' this for me, so fuck the world\n",
      "Feed it beans, it's gassed up if it thinks it's stoppin' me\n",
      "I'ma be what I set out to be, without a doubt, undoubtedly\n",
      "And all those who look down on me, I'm tearin' down your balcony\n",
      "No ifs, ands or buts, don't try to ask him why or how can he\n",
      "From Infinite down to the last Relapse album he's\n",
      "Still shittin' whether he's on salary, paid hourly\n",
      "Until he bows out or he shits his bowels out of him\n",
      "Whichever comes first, for better or worse\n",
      "He's married to the game\n",
      "Like a \"fuck you\" for Christmas, his gift is a curse\n",
      "Forget the Earth, he's got the urge to pull his dick from the dirt\n",
      "And fuck the whole universe\n",
      "You might also like[Chorus]\n",
      "I'm not afraid (I'm not afraid)\n",
      "To take a stand (To take a stand)\n",
      "Everybody (Everybody)\n",
      "Come take my hand (Come take my hand)\n",
      "We'll walk this road together, through the storm\n",
      "Whatever weather, cold or warm\n",
      "Just lettin' you know that you're not alone\n",
      "Holla if you feel like you've been down the same road\n",
      "\n",
      "[Verse 2]\n",
      "Okay, quit playin' with the scissors and shit, and cut the crap\n",
      "I shouldn't have to rhyme these words in a rhythm for you to know it's a wrap\n",
      "You said you was king, you lied through your teeth\n",
      "For that, fuck your feelings\n",
      "Instead of gettin' crowned, you're gettin' capped\n",
      "And to the fans, I'll never let you down again, I'm back\n",
      "I promise to never go back on that promise\n",
      "In fact, let's be honest, that last Relapse CD was \"ehh\"\n",
      "Perhaps I ran them accents into the ground\n",
      "Relax, I ain't goin' back to that now\n",
      "All I'm tryna say is get back, click-clack-blaow!\n",
      "'Cause I ain't playin' around\n",
      "There's a game called circle and I don't know how\n",
      "I'm way too up to back down\n",
      "But I think I'm still tryna figure this crap out\n",
      "Thought I had it mapped out\n",
      "But I guess I didn't, this fuckin' black cloud still follows me around\n",
      "But it's time to exorcise these demons\n",
      "These ma'fuckers are doin' jumpin' jacks now\n",
      "[Chorus]\n",
      "I'm not afraid (I'm not afraid)\n",
      "To take a stand (To take a stand)\n",
      "Everybody (Everybody)\n",
      "Come take my hand (Come take my hand)\n",
      "We'll walk this road together, through the storm\n",
      "Whatever weather, cold or warm\n",
      "Just lettin' you know that you're not alone\n",
      "Holla if you feel like you've been down the same road\n",
      "\n",
      "[Bridge]\n",
      "And I just can't keep livin' this way\n",
      "So startin' today\n",
      "I'm breakin' out of this cage\n",
      "I'm standin' up, I'ma face my demons\n",
      "I'm mannin' up, I'ma hold my ground\n",
      "I've had enough, now I'm so fed up\n",
      "Time to put my life back together right now\n",
      "\n",
      "[Verse 3]\n",
      "It was my decision to get clean, I did it for me\n",
      "Admittedly I probably did it subliminally for you\n",
      "So I could come back a brand-new me\n",
      "You helped see me through\n",
      "And don't even realize what you did, 'cause believe me you\n",
      "I've been through the wringer\n",
      "But they can do little to the middle finger\n",
      "I think I got a tear in my eye, I feel like the king of\n",
      "My world, haters can make like bees with no stingers\n",
      "And drop dead: no more beef lingers\n",
      "No more drama from now on, I promise\n",
      "To focus solely on handlin' my responsibilities as a father\n",
      "So I solemnly swear to always treat this roof like my daughters and raise it\n",
      "You couldn't lift a single shingle on it\n",
      "'Cause the way I feel, I'm strong enough to go to the club\n",
      "Or the corner pub and lift the whole liquor counter up\n",
      "'Cause I'm raisin' the bar\n",
      "I'd shoot for the moon, but I'm too busy gazin' at stars\n",
      "I feel amazin', and I'm—\n",
      "[Chorus]\n",
      "I'm not afraid (I'm not afraid)\n",
      "To take a stand (To take a stand)\n",
      "Everybody (Everybody)\n",
      "Come take my hand (Come take my hand)\n",
      "We'll walk this road together, through the storm\n",
      "Whatever weather, cold or warm\n",
      "Just lettin' you know that you're not alone\n",
      "Holla if you feel like you've been down the same road431Embed\n"
     ]
    }
   ],
   "source": [
    "import lyricsgenius\n",
    "from lyricsgenius import Genius\n",
    "token = 'AcU_KX10e5nyufSsdSw9vwAf12Vox91khaxz0BH-5oIP9G6pu_RoyS4ojUUocy8V'\n",
    "genius = Genius(token)\n",
    "genius.response_format = 'plain,html'\n",
    "artist = genius.search_artist(\"Eminem\", max_songs=0, sort=\"title\")\n",
    "song = genius.search_song(\"Not Afraid\", artist.name)\n",
    "\n",
    "\n",
    "print(song.lyrics)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "25b911ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting lyricsgenius\n",
      "  Downloading lyricsgenius-3.0.1-py3-none-any.whl (59 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m59.4/59.4 kB\u001b[0m \u001b[31m530.8 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: beautifulsoup4>=4.6.0 in /opt/anaconda3/lib/python3.9/site-packages (from lyricsgenius) (4.10.0)\n",
      "Requirement already satisfied: requests>=2.20.0 in /opt/anaconda3/lib/python3.9/site-packages (from lyricsgenius) (2.26.0)\n",
      "Requirement already satisfied: soupsieve>1.2 in /opt/anaconda3/lib/python3.9/site-packages (from beautifulsoup4>=4.6.0->lyricsgenius) (2.2.1)\n",
      "Requirement already satisfied: charset-normalizer~=2.0.0 in /opt/anaconda3/lib/python3.9/site-packages (from requests>=2.20.0->lyricsgenius) (2.0.4)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /opt/anaconda3/lib/python3.9/site-packages (from requests>=2.20.0->lyricsgenius) (3.2)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /opt/anaconda3/lib/python3.9/site-packages (from requests>=2.20.0->lyricsgenius) (2022.12.7)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/anaconda3/lib/python3.9/site-packages (from requests>=2.20.0->lyricsgenius) (1.26.7)\n",
      "Installing collected packages: lyricsgenius\n",
      "Successfully installed lyricsgenius-3.0.1\n",
      "\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.3.2\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install lyricsgenius"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fccb0a8",
   "metadata": {},
   "source": [
    "## Using custom tokenization can help!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bbbd38db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Token           | Relation   | Head            \n"
     ]
    }
   ],
   "source": [
    "print (\"{:<15} | {:<10} | {:<15} \".format('Token', 'Relation', 'Head'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "509b28d2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "93b4dca6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bd0c80ddf20a4c88895b3bf6c84338cc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading https://raw.githubusercontent.com/stanfordnlp/stanza-resources/main/resources_1.7.0.json:   0%|   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-01-23 22:50:18 INFO: Downloading default packages for language: en (English) ...\n",
      "2024-01-23 22:50:19 INFO: File exists: /Users/noelalben/stanza_resources/en/default.zip\n",
      "2024-01-23 22:50:22 INFO: Finished downloading models and saved to /Users/noelalben/stanza_resources.\n",
      "2024-01-23 22:50:22 INFO: Checking for updates to resources.json in case models have been updated.  Note: this behavior can be turned off with download_method=None or download_method=DownloadMethod.REUSE_RESOURCES\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6450b3256a514b1aad71f4e7ee024be8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading https://raw.githubusercontent.com/stanfordnlp/stanza-resources/main/resources_1.7.0.json:   0%|   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-01-23 22:50:23 INFO: Loading these models for language: en (English):\n",
      "=================================\n",
      "| Processor | Package           |\n",
      "---------------------------------\n",
      "| tokenize  | combined          |\n",
      "| mwt       | combined          |\n",
      "| pos       | combined_charlm   |\n",
      "| lemma     | combined_nocharlm |\n",
      "| depparse  | combined_charlm   |\n",
      "=================================\n",
      "\n",
      "2024-01-23 22:50:23 INFO: Using device: cpu\n",
      "2024-01-23 22:50:23 INFO: Loading: tokenize\n",
      "2024-01-23 22:50:23 INFO: Loading: mwt\n",
      "2024-01-23 22:50:23 INFO: Loading: pos\n",
      "2024-01-23 22:50:24 INFO: Loading: lemma\n",
      "2024-01-23 22:50:24 INFO: Loading: depparse\n",
      "2024-01-23 22:50:24 INFO: Done loading processors!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Deemed', 2, 'amod')\n",
      "('universities', 3, 'nsubj')\n",
      "('charge', 0, 'root')\n",
      "('huge', 5, 'amod')\n",
      "('fees', 3, 'obj')\n",
      "Token           | Relation   | Head            \n",
      "--------------------------------------------------\n",
      "Deemed          | amod       | universities    \n",
      "universities    | nsubj      | charge          \n",
      "charge          | root       | ROOT            \n",
      "huge            | amod       | fees            \n",
      "fees            | obj        | charge          \n"
     ]
    }
   ],
   "source": [
    "import stanza\n",
    "\n",
    "# Download the language model\n",
    "stanza.download('en')\n",
    "\n",
    "sentence = 'Deemed universities charge huge fees'\n",
    "\n",
    "# Build a Neural Pipeline\n",
    "nlp = stanza.Pipeline('en', processors = \"tokenize,mwt,pos,lemma,depparse\") \n",
    "\n",
    "# Pass the sentence through the pipeline\n",
    "doc = nlp(sentence)\n",
    "\n",
    "# Print the dependencies of the first sentence in the doc object\n",
    "# Format - (Token, Index of head, Nature of dependency)\n",
    "# Index starts from 1, 0 is reserved for ROOT\n",
    "doc.sentences[0].print_dependencies()\n",
    "\n",
    "\n",
    "print (\"{:<15} | {:<10} | {:<15} \".format('Token', 'Relation', 'Head'))\n",
    "print (\"-\" * 50)\n",
    "  \n",
    "# Convert sentence object to dictionary  \n",
    "sent_dict = doc.sentences[0].to_dict()\n",
    "\n",
    "# iterate to print the token, relation and head\n",
    "for word in sent_dict:\n",
    "  print (\"{:<15} | {:<10} | {:<15} \"\n",
    "         .format(str(word['text']),str(word['deprel']), str(sent_dict[word['head']-1]['text'] if word['head'] > 0 else 'ROOT')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6343602",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c6d08a42",
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.parse.stanford import StanfordDependencyParser\n",
    "import nltk\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "eabfe6d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "models_jar_path = '/Users/noelalben/github/RapDependency/stanford-corenlp-4.2.2-models-english.jar'\n",
    "jar_path = '/Users/noelalben/github/RapDependency/stanford-corenlp-4.2.2/stanford-corenlp-4.2.2-models.jar'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1e0431c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"You can't deny that when a girl walks in you get excited\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "48c1c72b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Parsing(sentence, jar_path,path_to_models_jar):\n",
    "    parser = StanfordDependencyParser(path_to_jar = jar_path, path_to_models_jar = models_jar_path)\n",
    "    result = parser.raw_parse(sentence)\n",
    "    dependency = result.__next__()\n",
    "    print (\"{:<15} | {:<10} | {:<10} | {:<15} | {:<10}\".format('Head', 'Head POS','Relation','Dependent', 'Dependent POS'))\n",
    "    print (\"-\" * 75)\n",
    "    for dep in list(dependency.triples()):\n",
    "          print (\"{:<15} | {:<10} | {:<10} | {:<15} | {:<10}\"\n",
    "         .format(str(dep[0][0]),str(dep[0][1]), str(dep[1]), str(dep[2][0]),str(dep[2][1])))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ff172fc2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/td/wr0v_l5j16bgp1cvydp7pmqc0000gn/T/ipykernel_42777/2588957925.py:2: DeprecationWarning: The StanfordDependencyParser will be deprecated\n",
      "Please use \u001b[91mnltk.parse.corenlp.CoreNLPDependencyParser\u001b[0m instead.\n",
      "  parser = StanfordDependencyParser(path_to_jar = jar_path, path_to_models_jar = models_jar_path)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Head            | Head POS   | Relation   | Dependent       | Dependent POS\n",
      "---------------------------------------------------------------------------\n",
      "deny            | VB         | nsubj      | You             | PRP       \n",
      "deny            | VB         | aux        | ca              | MD        \n",
      "deny            | VB         | advmod     | n't             | RB        \n",
      "deny            | VB         | obj        | that            | DT        \n",
      "deny            | VB         | advcl      | walks           | VBZ       \n",
      "walks           | VBZ        | advmod     | when            | WRB       \n",
      "walks           | VBZ        | nsubj      | girl            | NN        \n",
      "girl            | NN         | det        | a               | DT        \n",
      "walks           | VBZ        | obl        | you             | PRP       \n",
      "you             | PRP        | case       | in              | IN        \n",
      "deny            | VB         | dep        | excited         | JJ        \n",
      "excited         | JJ         | dep        | get             | VB        \n"
     ]
    }
   ],
   "source": [
    "Parsing(sentence, jar_path,models_jar_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a4213c6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def networkX(sentence, jar_path,path_to_models_jar):\n",
    "    parser = StanfordDependencyParser(path_to_jar = jar_path, path_to_models_jar = models_jar_path)\n",
    "    result = parser.raw_parse(sentence)\n",
    "    dependency = result.__next__()\n",
    "    G = dependency.nx_graph().reverse()\n",
    "    words = sentence.split(\" \")\n",
    "    labels = {index + 1: words[index] for index in range(len(words))}\n",
    "    nx.draw(G, with_labels=True, labels=labels, node_size=2500, node_color='#B5EAD7', font_size=10)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "83076a86",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/td/wr0v_l5j16bgp1cvydp7pmqc0000gn/T/ipykernel_42777/3941199874.py:2: DeprecationWarning: The StanfordDependencyParser will be deprecated\n",
      "Please use \u001b[91mnltk.parse.corenlp.CoreNLPDependencyParser\u001b[0m instead.\n",
      "  parser = StanfordDependencyParser(path_to_jar = jar_path, path_to_models_jar = models_jar_path)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "networkX(sentence, jar_path,models_jar_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "626e639e",
   "metadata": {},
   "outputs": [],
   "source": [
    "G = dependency.nx_graph().reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d4f6caf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "words = sentence.split(\" \")\n",
    "labels = {index + 1: words[index] for index in range(len(words))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0651573e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nx.draw(G, with_labels=True, labels=labels, node_size=2500, node_color='#B5EAD7', font_size=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a94735ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting graphviz\n",
      "  Downloading graphviz-0.19.1-py3-none-any.whl (46 kB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.3/46.3 KB\u001b[0m \u001b[31m1.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hInstalling collected packages: graphviz\n",
      "Successfully installed graphviz-0.19.1\n"
     ]
    }
   ],
   "source": [
    "!pip install graphviz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b1c7a4f9",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'NoneType' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/td/wr0v_l5j16bgp1cvydp7pmqc0000gn/T/ipykernel_84455/314958759.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mgraphviz\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mSource\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdot_def\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdependency\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_dot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m '''\n\u001b[1;32m      4\u001b[0m \u001b[0mThe\u001b[0m \u001b[0mbelow\u001b[0m \u001b[0mlines\u001b[0m \u001b[0mrequire\u001b[0m \u001b[0mgraphviz\u001b[0m \u001b[0mexecutables\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0minstalled\u001b[0m \u001b[0mto\u001b[0m \u001b[0myour\u001b[0m \u001b[0msystem\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mIf\u001b[0m \u001b[0mthat\u001b[0m \u001b[0mdoes\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mwork\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprint\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mdot_def\u001b[0m \u001b[0mobject\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mpaste\u001b[0m \u001b[0mthe\u001b[0m \u001b[0moutput\u001b[0m \u001b[0mon\u001b[0m \u001b[0mhttp\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m//\u001b[0m\u001b[0mgraphs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrevian\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0morg\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m '''\n",
      "\u001b[0;32m/opt/anaconda3/envs/GRA2022/lib/python3.9/site-packages/nltk/parse/dependencygraph.py\u001b[0m in \u001b[0;36mto_dot\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    168\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    169\u001b[0m         \u001b[0;31m# Draw the remaining nodes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 170\u001b[0;31m         \u001b[0;32mfor\u001b[0m \u001b[0mnode\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"address\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    171\u001b[0m             s += '\\n{} [label=\"{} ({})\"]'.format(\n\u001b[1;32m    172\u001b[0m                 \u001b[0mnode\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"address\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'NoneType' and 'int'"
     ]
    }
   ],
   "source": [
    "from graphviz import Source\n",
    "dot_def = dependency.to_dot()\n",
    "'''\n",
    "The below lines require graphviz executables to be installed to your system. If that does not work, print the dot_def object and paste the output on http://graphs.grevian.org/graph/\n",
    "'''\n",
    "print(dot_def)\n",
    "# source = Source(dot_def, filename=\"dependency_graph\", format=\"png\")\n",
    "# source.view()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed7a7e0e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}