{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using LX-DepParser to parse sentences and displaying dependency tree graphs\n",
    "This is an example notebook that illustrates how you can use the LX-DepParser web service to parse \n",
    "sentences and how to visualize dependency tree graphs in a notebook.\n",
    "\n",
    "**Before you run this example**, replace `access_key_goes_here` by your webservice access key, below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "LXDEPPARSER_WS_API_KEY = 'access_key_goes_here'\n",
    "LXDEPPARSER_WS_API_URL = 'https://portulanclarin.net/workbench/lx-depparser/api/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing required Python modules\n",
    "The next cell will take care of installing the `requests` and `pydependencygrapher` packages,\n",
    "if not already installed, and make them available to use in this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    import requests\n",
    "except:\n",
    "    !pip3 install requests\n",
    "    import requests\n",
    "try:\n",
    "    import pydependencygrapher\n",
    "except:\n",
    "    # see https://github.com/pygobject/pycairo/issues/39#issuecomment-391830334\n",
    "    !apt-get install libcairo2-dev libjpeg-dev libgif-dev\n",
    "    !pip3 install pydependencygrapher\n",
    "    import pydependencygrapher\n",
    "\n",
    "import base64\n",
    "import IPython"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrapping the complexities of the JSON-RPC API in a simple, easy to use function\n",
    "\n",
    "The `WSException` class defined below, will be used later to identify errors\n",
    "from the webservice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WSException(Exception):\n",
    "    'Webservice Exception'\n",
    "    def __init__(self, errordata):\n",
    "        \"errordata is a dict returned by the webservice with details about the error\"\n",
    "        super().__init__(self)\n",
    "        assert isinstance(errordata, dict)\n",
    "        self.message = errordata[\"message\"]\n",
    "        # see https://json-rpc.readthedocs.io/en/latest/exceptions.html for more info\n",
    "        # about JSON-RPC error codes\n",
    "        if -32099 <= errordata[\"code\"] <= -32000:  # Server Error\n",
    "            if errordata[\"data\"][\"type\"] == \"WebServiceException\":\n",
    "                self.message += f\": {errordata['data']['message']}\"\n",
    "            else:\n",
    "                self.message += f\": {errordata['data']!r}\"\n",
    "    def __str__(self):\n",
    "        return self.message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next function invoques the LX-DepParser webservice through it's public JSON-RPC API."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse(text, tagset, format):\n",
    "    '''\n",
    "    Arguments\n",
    "        text: a string with a maximum of 2000 characters, Portuguese text, with\n",
    "             the input to be processed\n",
    "        tagset: either 'CINTIL' or 'UD' (universal dependencies)\n",
    "        format: either 'CONLL' or 'JSON'\n",
    "\n",
    "    Returns a string with the output according to specification in\n",
    "       https://portulanclarin.net/workbench/lx-depparser/\n",
    "    \n",
    "    Raises a WSException if an error occurs.\n",
    "    '''\n",
    "\n",
    "    request_data = {\n",
    "        'method': 'parse',\n",
    "        'jsonrpc': '2.0',\n",
    "        'id': 0,\n",
    "        'params': {\n",
    "            'text': text,\n",
    "            'tagset': tagset,\n",
    "            'format': format,\n",
    "            'key': LXDEPPARSER_WS_API_KEY,\n",
    "        },\n",
    "    }\n",
    "    request = requests.post(LXDEPPARSER_WS_API_URL, json=request_data)\n",
    "    response_data = request.json()\n",
    "    if \"error\" in response_data:\n",
    "        raise WSException(response_data[\"error\"])\n",
    "    else:\n",
    "        return response_data[\"result\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us test the function we just defined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#id\tform\tlemma\tcpos\tpos\tfeat\thead\tdeprel\tphead\tpdeprel\n",
      "1\tEsta\t-\tDEM\tDEM\tfs\t2\tSP\t2\tSP\n",
      "2\tfrase\tFRASE\tCN\tCN\tfs\t3\tSJ\t3\tSJ\n",
      "3\tserve\tSERVIR\tV\tV\tpi-3s\t0\tROOT\t0\tROOT\n",
      "4\tpara\t-\tPREP\tPREP\t-\t3\tC\t3\tC\n",
      "5\ttestar\tTESTAR\tV\tV\tINF-nInf\t3\tCOORD\t3\tCOORD\n",
      "6\to\t-\tDA\tDA\tms\t7\tSP\t7\tSP\n",
      "7\tfuncionamento\tFUNCIONAMENTO\tCN\tCN\tms\t5\tDO\t5\tDO\n",
      "8\tde_\t-\tPREP\tPREP\t-\t7\tOBL\t7\tOBL\n",
      "9\to\t-\tDA\tDA\tms\t10\tSP\t10\tSP\n",
      "10\tparser\tPARSER\tCN\tCN\tms\t8\tC\t8\tC\n",
      "11\tde\t-\tPREP\tPREP\t-\t10\tM\t10\tM\n",
      "12\tdependências\tDEPENDÊNCIA\tCN\tCN\tfp\t11\tC\t11\tC\n",
      "13\t.\t-\tPNT\tPNT\t-\t3\tPUNCT\t3\tPUNCT\n",
      "\n",
      "\n",
      "#id\tform\tlemma\tcpos\tpos\tfeat\thead\tdeprel\tphead\tpdeprel\n",
      "1\tEsta\t-\tDEM\tDEM\tfs\t3\tSP\t3\tSP\n",
      "2\toutra\tOUTRO\tADJ\tADJ\tfs\t3\tSP\t3\tSP\n",
      "3\tfrase\tFRASE\tCN\tCN\tfs\t4\tSJ\t4\tSJ\n",
      "4\tfaz\tFAZER\tV\tV\tpi-3s\t0\tROOT\t0\tROOT\n",
      "5\to\t-\tLDEM1\tLDEM1\t-\t4\tDO\t4\tDO\n",
      "6\tmesmo\t-\tLDEM2\tLDEM2\t-\t4\tDO\t4\tDO\n",
      "7\t.\t-\tPNT\tPNT\t-\t4\tPUNCT\t4\tPUNCT\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "text = '''Esta frase serve para testar o funcionamento do parser de dependências. Esta outra\n",
    "frase faz o mesmo.'''\n",
    "# the CONLL annotation format is a popular format for annotating part of speech\n",
    "# and dependency tree graphs\n",
    "result = parse(text, tagset=\"CINTIL\", format=\"CONLL\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displaying dependency tree graphs from parsed text in CONLL format\n",
    "\n",
    "To view dependency tree graphs for the parsed sentences, first we will split the CONLL output on empty lines to get one set of lines per sentence (each line carrying information pertaining to each token)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def group_sentence_conll_lines(conll_lines):\n",
    "    \"\"\"Groups CONLL-encoded lines (one line encodes one token), according to sentences.\n",
    "\n",
    "    This generator function takes as argument a sequence of CONLL lines, and generates\n",
    "    a sequence of lists, each one containing the CONLL lines of a sentence\n",
    "    \"\"\"\n",
    "    parsed_sentences = []\n",
    "    current_sentence = []\n",
    "    for line in conll_lines:\n",
    "        # lines starting with # are comments; ignore\n",
    "        if line.startswith(\"#\"):\n",
    "            continue\n",
    "        # one or more consecutive empty lines mark the end of a sentence\n",
    "        if not line:\n",
    "            if current_sentence:\n",
    "                parsed_sentences.append(current_sentence)\n",
    "                current_sentence = []\n",
    "        else:\n",
    "            current_sentence.append(line)\n",
    "    if current_sentence:\n",
    "        parsed_sentences.append(current_sentence)\n",
    "    return parsed_sentences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us define a function `render_tree` that displays a sentence dependency graph, making use of the `pydependencygrapher` package for rendering the graph into an image and the `IPython` package for displaying the resulting image.\n",
    "\n",
    "We also define a function `render_tree_from_conll` that will take a CONLL sentence (a list of CONLL-formatted lines, one for each token) and create one `pydependencygrapher.Token` object for each token, before calling `render_tree` to display the dependency graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def render_tree(sentence):\n",
    "    graph = pydependencygrapher.DependencyGraph(sentence)\n",
    "    graph.draw()\n",
    "    b64png = graph.save_buffer()\n",
    "    IPython.display.display(IPython.display.Image(data=base64.b64decode(b64png)))\n",
    "\n",
    "def render_tree_from_conll(conll_sentence):\n",
    "    sentence = [pydependencygrapher.Token(*conll_token.split(\"\\t\")) for conll_token in conll_sentence] \n",
    "    return render_tree(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABC8AAACgCAIAAACjetF0AAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3de3hTZZ4H8PekTdq0TS+0TXqjTa+kFIFCoS0XqUNB6YyPOsryOAuoKzizOyM+Pj6zz+rsKgw7Wnx0lZnHhVUWq7guo6AORWQFGQoi104LUii90EKvaaH3e9Ke/ePMnMnkJOnJ9Vzy/fzBE07O5f29v995T97kJKVomiYAAAAAAAA+pxC6AQAAAAAA4KcwGwEAAAAAAGFgNgIAAAAAAMLAbAQAAAAAAISB2QgAAAAAAAgDsxEAAAAAABAGZiMAAAAAACAMzEYAAAAAAEAYgUI3AEACampqqqqqjEZjW1vb8PCw0M0BAAAAcIVSqYyMjExNTc3Pz58zZ47QzSGEEAp/ix3Anhs3buzevfvQoUPNzc2ZmZlxcXGJiYlhYWFCtwsAAADAFRMTE729vQ0NDdevX09NTX344Yc3bdpkMBgEbBJmIwA2tLW1bdu2raysbOXKlY899tiDDz6o1WqFbhQAAACAZ3R1dZWXlx88ePD48eNPPfXU1q1b4+PjBWkJvjcCYO3w4cOzZ8+uq6urqKj46quvnn76aUxFAMAdY2NjCoUiIyMjNTX1iSeeMJlMR48e/dGPfsQ8+/DDDx8+fPjAgQMBAQEtLS2EkE2bNu3fv58Q0tzcfN9996Wmps6ZM6e+vv7HP/5xUlJSREREeHh4UlLSD3/4QyGjAgAp02q1Tz/99JEjR06fPl1bW2swGMrLywVpCWYjAH9jx44djz766K9//euTJ08WFhYK3RwAkImQkJCGhoa6urrW1taysjKb62g0mg8++MByyZNPPvkP//APTU1Nx44d02g0n332WWtr6y9/+cstW7a0trZ++eWXvmg6AMhafn5+RUXF9u3bH3vssdLSUt/fNoXZCMBflZaWvvbaa+Xl5c8995zQbQEAGVIqlUVFRfX19TaffeCBB/7whz+w/21sbGxqatqwYQMhJD4+Pi4uzketBAD/s2XLlsOHD5eWlpaWlvr40JiNAPzZ0aNHX3nllY8//nj16tVCtwUA5Gl4ePjo0aM5OTk2nw0ODl6wYMG3337L/PfmzZtpaWk+bB0A+LVVq1YdOHBg69athw4d8uVxMRsBIISQtra2devWvf766yUlJUK3BQBkaGRkRK/Xz5s3Ly8vb/369RRFWT7L/vfJJ59k7+OiadpqNQAAryouLn7jjTc2bNjQ0dHhs4NiNgJACCHbtm2bP38+btACAC8JCQlpbm5uaGjYuXNnQECAUqlkb86maVqlUjGPCwsLr1y5MjIyQghJT09vaGgQrMUA4JeeffbZhQsXbt261WdHxGwEgNTV1ZWVle3YsUPohgCAv8jIyKirqxsaGhoeHr5x40ZGRgb71COPPPLVV18RQtLT0/V6PfNRSUdHhy/fqgQAf/bqq6/u3bu3trbWN4fDbASA7Nq1q7i4uKCgQOiGAIC/SE5O/sUvfjF37tx77rnnmWeeSU1NZZ/auHHjwMAA87isrOz999+fOXPmqlWrhoeHBWosAPiXgoKC4uLi9957zzeHw18/BCCZmZkvvfTSU089JXRDAAAAAIS3Z8+e0tJS39wsitkI+Luampq5c+e2t7frdDqh2wIAAAAgPKPRmJCQ8P3338+ePdvbx8KdWuDvqqqqMjMzMRUBAAAAYOh0OoPBcOHCBR8cC7MR8HednZ0JCQlCtwIAAABARDIyMhobG31wIMxGwN91dHTEx8cL3QoAAAAAEYmKiurv7/fBgTAbAX83ODgYGhoqdCsAAAAARESlUo2NjfngQJiNAAAAAACAMDAbAQAAAAAAYWA2AgAAAAAAwggUugGEEFJTU1NVVWU0Gtva2vC3ZsE1SqUyMjIyNTU1Pz9/zpw5Xj0WKtZLfJlES0iojwmVaGCh5rlQlgBCEXI2cuPGjd27dx86dKi5uTkzMzMuLi4xMTEsLEzAJoF0DQ8Pt7a2fvHFF9evX09NTX344Yc3bdpkMBg8eAhUrLf5IImWkFCh+DjRwELNO4CyBBAMLYTW1tbNmzcrlcoHHnhgz549RqNRkGaALBmNxj179qxZs0apVD7zzDPt7e2O19+8efPmzZsdr4OK9TFnk+gsJFQkvJ1oYKHm+UNZAjD4vEDyCAFmI+Xl5eHh4StWrPjuu+98f3QxKy8vDw0NTU9Pz8jIKCsrYxbu37/fYDAYDIaPPvrI5pJHHnkkMTExPDxco9EkJiaWlJQIFoDInDt37t577w0PDz906JCD1aY92cRcsU1NTUVFRXq9Picnp66ujuZRMNwy+/TTT8PCwtLT01evXl1fXy9gOFw8k+gUMSeUP5tZ42ZfKryRaGBJoua5o5ngUJbg52Q7GyktLVWpVG+//baPjysJ5eXlDz30EE3TN27cCA0N7enp6e7ujomJaW9v7+rq0ul0nZ2d3CXMttu3b//Vr34laPNFaufOnSqV6rXXXpuamrK5guOTTeQVu2LFig8//JCm6fb29o6ODj4Fwy2zTz/9dN26dTRNHz58WK/XT0xMCBwVx7RJ5E/kCeWPmzV7g4OEeDDRwJJKzVuNZkI3569QluC3fDYb8en3RkpLS0tLS8vLy1evXu3L40pOVlZWXFxcZ2dnXV3dwoULmb8Unp+ff+rUKZVKZbVk7dq1QrdX1LZs2ZKdnb127Vqapl988UWnthV5xTY2NjY1NW3YsIEQwpTEH/7wh2kLRq1WM5uzZcbu8Ic//OH27dvPnDlTVFTk+3AccCeJlkSeUNewWevv75f64OCpRANLKjXPHc3EA2UJ4G2++4Xfo0ePvvLKKx9//LHIx0QxqK2tjY2NzcrK6uzsjI2NZRZqtdqOjg7uEuGaKRmrVq06cODA1q1bDx06xH8r8VfszZs309LSLJc4VTBsmVnuISUlpampycsNd4VrSbQk/oS6jMmaPAYH9xMNLAnVPHc0ExWUJYBX+Wg20tbWtm7dutdff72kpMQ3R5Sob775Jj09PS8vr7S0NCAggBBCURTzFE3TzAPuEphWcXHxG2+8sWHDBp4v0SRRsTRNs8XA4lMw3DKzuQexcTaJliSRUHcwWZPH4OBOooElrZq3OZqJCsoSwHt8NBvZtm3b/Pnzn3vuOd8cTrpWrlzZ2Nj47rvvbtq0aXJyMi4uzmg0Mk91d3fHx8dzlwjXWIl59tlnFy5cuHXrVj4rS6Ji09PTGxoaLJfwLBirMrPcQ3Nzs16v90XrXeJUEi1JIqEuY7Imp8HB5UQDS1o1zx3NRAhlCeAlvpiN1NXVlZWV7dixwwfHkoef/OQniYmJBw8eXLp06Z/+9Cfma6nnz5+/9957uUuEbqyUvPrqq3v37q2trXW8mlQqNj09Xa/Xl5WVEUI6Ojo6OjqcKhi2zNglhw8fNhqNS5cu9X0s/PFMoiWpJNQ1bNZkNji4kGhgSa7muaOZ0C2yDWUJ4A2+mI3s2rWruLi4oKDAB8eSjV/96ldvvvlmTEzM7373u6KiomXLlr355ps6nY67ROiWSklBQUFxcfF7773neDUJVWxZWdn7778/c+bMVatWDQ8PO1swTJkRQsrLy/V6/c6dO//v//5PqVQKFA0vPJNoSUIJdYpV1mQ2OLiQaGBJseatRjOhm2MbyhLAGygf3F6cmZn50ksvPfXUU94+EMC09uzZU1paanlLwDPPPEMIeffdd9klqFiR4ybRMSRUopxNNLBQ896DsgT/wX2B5CVe/2ykpqbm5s2bkvgWHfiDBx98sKmp6dq1a/ZWQMWK37RJtISESpdTiQYWat6rUJYAHuf12UhVVVVmZqbU7xkA2dDpdAaD4cKFC/ZWQMWK37RJtISESpdTiQYWat6rUJYAHuf12UhnZ2dCQoK3jwLAX0ZGRmNjo71nUbGS4DiJlpBQSeOfaGCh5r0NZQngWV6fjXR0dEj6hyZBfqKiovr7++09i4qVBMdJtISEShr/RAMLNe9tKEsAz/L6bGRwcDA0NNTbRwHgT6VSjY2N2XsWFSsJjpNoCQmVNP6JBhZq3ttQlgCe5aO/fggAAAAAAGAFsxEAAAAAABAGZiMAAAAAACCMQKEb4EdqamqqqqqMRmNbW5uP/9CsUqmMjIxMTU3Nz8+fM2eOtw/nm0h9HJQDQmVWPD0APibgYELkWHjC9ieX/HrYKd5Lh3g61tsl571IxXayOEs8NQCWMBvxuhs3buzevfvQoUPNzc2ZmZlxcXGJiYlhYWG+bMPw8HBra+sXX3xx/fr11NTUhx9+eNOmTQaDwbNH8XGkvgnKAcEzK3gPgI8JXnIM2RSeSPqTSzY97BQfpEPwjvVZyXk8UtGeLM4SvAbAJsxGvKitrW3btm1lZWUrV6586aWXHnzwQa1WK2yTurq6ysvLDx48OHfu3Keeemrr1q0e+SFIYSP1UlAOiC2zvu8B8DGxlRxDuoUnzv7kkm4PO8X36fCfq4b7kUrlZHGWn5xckkF72ebNmzdv3uzto4hQeXl5eHj4ihUrvvvuO/f39tZbb2VlZWVkZDz00EM0TY+OjlIUlZ6ertfrN27cODEx4ewOz507d++994aHhx86dMjNtrkfqVV0NE3X1tYmJiZGR0c/+uij/PfDMyirmnT8Xy7PZpbV1NRUVFSk1+tzcnLq6upc24kH0ypy/AcWGQxBIh9MaG8WnjfS59n+3L9/v8FgMBgMH330EU3TVVVVQUFB6enpaWlpzz//PLNOaGjo4OCgO0dxqoelVfPupMP9YnatdJ3tYU+V3M9//vOZM2cyj5OSkn7605/y39a1SL10vePDI9dEPvznuukCnw0mmI14RWlpqUqlevvttz2yt5qamrlz546MjNA0fenSJZqmR0dHQ0NDaZqemJj4wQ9+8O6777q25507d6pUqtdee21qasq1PbgfKTc61ueff+7UbIQxbVDuzEY8m1lLK1as+PDDD2mabm9v7+jocGdX7qdV/PxnNiKVwYT2TuF5PH2e7c/u7u6YmJj29vauri6dTtfZ2VlVVbVw4UKaps1m89y5c8+dO0d7YjbC4NnDEqp5d9LhwWJ2tnSd6mEPltzPf/7znJycysrKS5cuzZkzx6nZCMOpSL13vePDg9dEPvzhuukCnw0muFPL80pLS0tLS8vLy1evXu2RHd6+fVun06nVakLIwoULLZ9SKpVFRUX19fWu7XnLli3Z2dlr166lafrFF190dnOPROogOte4GZQDHs8sq7GxsampacOGDYQQ9z8s9l4PgI9JaDAhUig8j/fnmTNnFi5cyJyz+fn5p06dyszMZJ4aHR0dGRnx7F8hFH8PO8XNdHiwmCV01XjooYe++OILmqYfeuihO3fuOLs5/0i9d73jw7PXRD5kdnJJDn7h18OOHj36yiuvfPzxxx48ge+9916j0VhYWPib3/ymo6PD8qnh4eGjR4/m5OS4vPNVq1YdOHBg69athw4dcmpDT0XqIDqXuRyUA97ILOvmzZtpaWke3KE3egB8THKDCRF34XmjPzs7O2NjY5nHWq2W6dKamhqDwaDT6e6//36P/2iPmHvYKe6nw7PFLJWrRm5ublVVVXV19fz5813bA59IvXq948Pj10Q+ZHNySRFmI57U1ta2bt26119/vaSkxIO7DQkJqays/PWvf93e3p6Xl3f37l1CyMjIiF6vnzdvXl5e3vr1693Zf3Fx8RtvvLFhwwb+kwEPRmozOve5EJQDXsosi6ZpiqI8u0/P9gD4mEQHEyLWwvPeKcyeuTRNMw9ycnJqa2u7u7uvXr36zTffePZwRKw97BSPpMPjxSyVq4Zer09NTXVnD44j9fb1jg9vXBP5kMHJJVGYjXjStm3b5s+f/9xzz3l8z4GBgatWrXrnnXeKiopOnz5NCAkJCWlubm5oaNi5c2dAQICb+3/22WcXLly4detWnut7NlJudAyTyRQUFOTybp0NygHvZZaRnp7e0NDg8d16sAfAx6Q7mBBRFp6X+jMuLs5oNDKPu7u7LW8pCQkJeeCBByoqKjx7RIYIe9gpnkqHx4tZEleN7du3b9++3c2dOIjU29c7Prx0TeRD6ieXRGE24jF1dXVlZWU7duzw+J5v3bp18eJFQsjo6CjzY1MePwQh5NVXX927d29tbe20a3o2Um50J06caG1tJYRUVlamp6e7s3P+QTngvcyymB+BKSsrI4R0dHR48F0Zj/QA+JjUBxMissLzXn8uXbr0T3/6E/Mt9vPnz997773sU5OTk2fPnk1OTvb4QRmi6mGneCodXipm8V81IiMjIyIi3N+PzUh9cL3jw3vXRD6ke3JJF2YjHrNr167i4uKCggKP73lycnLLli3Jyclz5sz50Y9+tGjRIo8fghBSUFBQXFz83nvvTbumZyPlRjc2NvaDH/wgLS3t22+//dnPfubOzvkH5YD3MmuprKzs/fffnzlz5qpVqzz4B2490gPgY1IfTIjICs97/RkTE/O73/2uqKho2bJlb775pk6nI4R8//33qampGRkZUVFRTzzxBLPmrFmzkpKSkpKSPPWeq6h62CmeSoeXillCVw032YxUPC330jWRD+meXBLm7R/tktBPDbopIyNj7969QrfCLe+99156evq0q0krUm5Qzv7Cr7Ti5eKZVmmR9y/8Sr3kGB4pPI+kTx79yWWvh0Ve8+JPx7SlO20Piz9GBjdSqbTc22R53XSBzwYTfDbiGTU1NTdv3hTwK18e8eCDDzY1NV27ds3BOpKLlE9QDkguXi43ewB8TAYlxxBJ4cmmP7lE0sNOkUQ6/OeqYRWphFrubVI8uSQNsxHPqKqqyszMZD6mly6dTmcwGC5cuOBgHclFyicoByQXL5ebPQA+JoOSY4ik8GTTn1wi6WGnSCId/nPVsIpUQi33NimeXJKG2YhndHZ2JiQkCN0KD8jIyGhsbHSwghQjnTYoB6QYL5c7PQA+Jo+SY4ih8OTUn1xi6GGnSCUd/nPVsIxUWi33NsmdXJKG2YhndHR0+ObPhXpbVFRUf3+/gxWkGOm0QTkgxXi53OkB8DF5lBxDDIUnp/7kEkMPO0Uq6fCfq4ZlpNJqubdJ7uSSNMxGPGNwcDA0NFToVniASqUaGxtzsIIUI502KAekGC+XOz0APiaPkmOIofDk1J9cYuhhp0glHf5z1bCMVFot9zbJnVyShtkIAAAAAAAIA7MRAAAAAAAQBmYjAAAAAAAgDMxGAAAAAABAGJiNAAAAAACAMDAbcdeVK1cc/FdOZBCpDEJwlvxCll9ELBmH5gL0hmOS6x/JNdgmeUTBkFMsnoWeIT7vBMxG3HL58uW8vLyPPvqI+e9HH32Ul5d3+fJlYVvlDTKIVAYhOEt+IcsvIpaMQ3MBesMxyfWP5BpskzyiYNiM5e7du8K2SgzklGWX+b4TAr23a38wb968ffv2bdy4ccmSJQEBAR988MGePXvmzZsndLs8TwaRyiAEZ8kvZPlFxJJxaC5Abzgmuf6RXINtkkcUDJuxfPvtt0K3S3hyyrLLfN8JmI24a926dSaT6YknniCEfPDBB+vXrxe6Rd4ig0hlEIKz5Bey/CJiyTg0F6A3HJNc/0iuwTbJIwoGNxbMRhhyyrLLfNwJFE3TXj2An2A+z/KHkpVBpDIIwVnyC1l+EbFkHJoL0BuOSa5/JNdgm+QRBUNOsXgWeob4sBMwGwEAAAAAAGHgW+wAAAAAACAMzEYAAAAAAEAYmI0AAAAAAIAwMBvxR7t379ZqtZGRkefOnRO6LQAgat4YLubPn3/8+HFP7c0PBQcHt7a2Ct0KkAOp1JLP2ml5oIaGhpSUlN/85jcu7w1jHU+uzEZqa2spiqIoKiQkZNGiRSdOnHBhJ//+7//+s5/9zIUNfclgMFAW9u/f72BlSURECJmcnHzhhRfOnz/f19dXUFAgdHMA/oab55FUTkOp8NJw8eKLLxoMBk/tzX0oGwCwYjKZtmzZUlFRUVtb6/J7MWIb60TL9b83MjQ0RNP0rl27HnnkkZaWlvDwcA82Szw+/PDDtWvXMo9VKpWwjfGI7u7uycnJ1NRUoRsCAGLnpeFi3bp1nt0hAIBnKZXKI0eOEEL27dvn8k4w1vFFO+/69euEkNHRUZqmh4aGCCEXL16kabqxsfG+++6LiIi45557Tp48yazMXXjx4sWUlJTIyMiwsLCUlJSUlJTh4WEXmuEDs2bN+t///V+rhQ0NDcuXL4+KitLpdNu2baPtR7Rjx47U1FSNRpObm/vHP/7R9+3nWrFiRVJSEiGEaSeTOJqmU1JS3nnnnXvuuScuLu7xxx+n7TSeGztN052dnY899lh0dHRGRsZnn30mRFjWnGqnVewVFRXp6enss48//vhrr73mYHMBJSYm/uM//mNBQUFOTs7+/fuZhfaqjmeKBWTvPLLZ8+6fhtwOEZbN8VNYNoeL9PT0s2fPMitER0dfv36dWbht27aCgoKkpKRdu3axe9i9e/esWbM0Gk1hYWFLSwtN02+99VZKSopSqTx27Bi7ms3Ybe6Tm819+/YtWLAgKSnp8ccff+yxx3Q6XWVlJW2nbLj7tFc2IkxHZWXlvHnzNBrNK6+8EhQUxPSnCMclm0TYn26On+5cZXwXpB1SqSX+7bSZTZ6DgFMHcnOs4//Kyt+4NRsZGxv7z//8z+Dg4O7ubpqmCwsL//mf/3liYuKzzz6bMWNGf3+/vYU0TW/fvv2nP/2pByPxBpuzkfXr17/wwgtTU1MDAwOnT59ml3Mjevfdd2traycnJw8ePKjRaJhPkwTX0tISFBRktTAlJaWwsLCrq4um6draWtpO423GXlRU9E//9E9jY2OXL1+OiYm5deuWbwOywal2WsU+OTkZHx9fVVVF0/TY2Fh4eHh9fb2DzQWUmJjIXNiam5sjIiLa29tp+1XHM8WC455HNnve/dOQ2yHCsjdUCos7XNibjWzcuJGm6atXr2o0mvHxcZqmP/nkk+Tk5OrqarPZXFFRcfPmTXYn8+bNs7xC24zd5j652dy3b9+SJUsGBwdDQkKOHDlSWlr6wgsv0HbKxuY+aVtlI7Z0TE5OZmZmvv322+Pj4y+88AIhhHnFI8JxySax9Sft9vjpzlXG57H+DanUklPttJlNnoOAUwdyc6zj/8rK37g+G2GkpqZ+/fXXNE0bjUZCyN27d5l1srOzy8vLbS5kHktlNqLRaKL/grnubty4cd26dUyxWnIcUUxMzOXLl73bXH7szUY+/vhje5uwjefG3tjYqFQq2SH7Jz/5yX/91395odXOcaqd3Nh/8Ytf/Ou//itN0+Xl5bm5uY43F1BiYuKXX37JPC4uLt67d6/VCpZVxzPFgrM6j+z1vPunoeMO8TEHQ6Ww+M9Gjh49yiwMDw9vbm6maXrNmjVvvfWWzd1aXqHtxW5zn5aYbO7bt2/9+vU0Tev1+oaGhv37969fv95e2djbp1XZiDAdNTU1ISEhJpOJpumOjg7mBZM4xyUuEfYn7fb46eZVRkBSqSWn2snNJv9BwKkDuTPWWXHwysoP8foWe1xcHPM17oaGBnbh6Ojo3bt3U1NT6+rqCCFdXV1KpXLGjBnsJp2dnTYXOnsgYZWWllb/RUZGBrOE+fp+amrqJ5984mDbzz//vKCgQK/X6/X63t5ek8nkq1a7Ii0tzfK/NhvPjb2lpYUQsnDhQoPBYDAYTp061dvbK0j7LTnbTqvY165de/DgQULIwYMHmW8NiTNMQkhUVBTzYMaMGcwl30HV8Umx2NjreY+chlYdIiBnh0oRioiIYB4olcrR0VFCSEtLi16vn3ZDB7Fz92kzmwEBAcy/DLPZ7OCE5e7TqSYJpaurKyYmJjAwkGmPQqEgIh6XrIiwPxnujJ9uXmUEJJVacradVtnkPwg4eyCXxzrC+5WVH+L1LXZ7A8eMGTN++9vfLl++/O///u+1Wq3JZOrp6WFGnM7OTp1OZ3Mhs61CoaBpmueBBDRjxgzmzmlWfHz83r17CSGffvrp008/vXbtWoqiCCcio9G4fv36kydPLlq0iNkPN15RYa7oDHuN58Y+c+ZMjUZz/fp1phNEwtl2WsZOCFm2bFlfX9+VK1cOHTp0/vx5Qog4wySEMG/kMA/uv/9+x1XHJ8WCszqP7PW8R05Dq7wLyMFQKTbBwcFms5kQQtP04OCggzVnzpzZ3Nw87Q75x86zaGmadvaEtSobEaZDp9P19/czj/v7+6empoiIxyUrIuxPhsvjJ3H7KiMgqdSSs+20yib/iNzvEJ5jHf9XVuLJgs+4+/dGcnJyCgsLf/vb32q12vz8/B07dphMps8//7y9vX358uU2FzIbxsfHX7t2bXJy0u0QvMtkMo39BdPaQ4cOMUWvVCrDwsLYorGKaGhoSKlUZmdnE0I++eQTwd9mcIq9xnNjT0tLmzNnzssvvzw6OjoxMXH8+PHGxkYhm+6JdioUih//+MdbtmxJTk5mPhATZ5iEkHfeeWdoaOjs2bOVlZX3338//6oTbX1anUf2el5mp6GDoVJsMjMzz549Swj57LPPJiYmHKz55JNP/sd//MeVK1empqbOnDnT1NRkczX+sfPPprMnrFXZiDAds2bN0ul0Vr/wI9pxyYoI+5Ph8vhJpHM15JJKLTnbTqts8o/I/Q7hOdbxf2XlfG953u3btzMyMr788kvfHM4Df/3w+eef37lzJ/NtwgsXLsTExLz88ssHDhyIjIwkhNhcSAh59NFHVSpVYmJiUlLSyMiI+83wko0bN6r/4q233iKEXLx4ceHChRERES+//LLl775ZRZSenv78888vXrx49erV1dXVM2fOFC4Ip9lrvM3Yf//739fV1aWkpOh0uh07dgjX6r9yv51r166tqKhgf9zZ2c19pqCgIC0tbd26dXv27ElMTORfdaKtT+7IYLPn5Xca2hsqxebf/u3f/vu//3v58uXXrl2Ljo52sObf/d3f/cu//MvatWsjIiJ++ctfMjdC5OTk6PX6a9eurV+/Xgdx9CcAABaHSURBVK/X/8///A/hHbtT2XTqhOVWndjSoVAofv/732/durWwsLCuro79uXlxjktcYutPhsvjJ5HO1ZBLKrXkbDutsulgTTcPxMVzrHPqlZXgJiYmGhsbHX8A7kGUSG7PAABnJSUlffHFF3l5eUI3BABAYjB+ygmyKXUe+GwEAAAAAADABa7/LXYAAAAQla1bt3IXbtq0yernWAAAxAN3agEAAAAAgDBwpxYAAAAAAAgDsxEAAAAAABAGZiMAAAAAACAMzEYAAAAAAEAYmI0AAAAAAIAwMBsBAAAAAABhYDYCAAAAAADCwF8/tKu/v//06dOEkKCgIK1Wm52drVKpCCEnT54cGhpiV1uwYMHQ0FBdXV1hYWF0dLTJZPr6669jY2MXL14sWNMdamxsbG5uHh8f12g0ubm5U1NTp06dyszMnDVrFiHk3Llz8fHxKSkpQjfTddevXx8eHs7Ly2P+29jY2NXVVVhYKGyrvIEtxaCgoPj4+JycnOHh4ZMnTxJCAgICwsLCsrOzY2JiiK2iTUhI4G5OUZQwkRBC/ClxXPZGG0LInTt3zp07ZzAYMjIyfN8w2Q8XEiLd8x3lLTYSqiW/zZGwuCkeHBzk9nxnZ2d3d7flhgEBAWvWrHHhiJiNTKOkpGRkZOT69esXLlxYtmwZs3D+/PkJCQnMY4qi6uvrQ0NDOzo6oqOjOzs7Q0JChGvvNG7fvt3c3LxgwQKNRtPT08P87UuKolpbW7OysoR9MeopWq320qVLNE0z4dy9e1er1QrdKG/Jzc1NSEgYGBi4ePGiWq3W6XSEkDVr1tA0fevWrUuXLhUXFwcGBhJO0drcPD09XahAiJ8lziabo43RaFSr1Uaj0fcv1/xhuJAWSZ/vKG9RkUQt+XmOhGWV4tjYWG7PL168mEnK0aNHCwoKIiMjXT4c7tSahkKhCAsLy83NHRgY6O3tZReymKxER0czp0pHR0d8fLygTXakoaEhKysrKioqMDBQq9VqNBpCiEKhiIiIMBqNQrfOM2bMmEHT9MDAACGEpumenh4Zv6ilKIqiqIiICJ1Ox4TMLAwMDNTr9WazeXh4mFnILVp7mwvFrxJnk83RpqurKzMzs6+vb2Jiwsft8YfhQlokfb6jvEVFErXk5zkSFjfF3J6nKIopDKvHLsBshJfAwMDQ0FAHpxxFUZGRkV1dXRMTE6L9bMRkMo2MjMyYMYP7VHJy8u3bt33fJG+gKComJubu3buEkL6+vsDAQGYIk7Hx8fE7d+6EhoayS6amplpbWxUKhVqtdmFzQfhh4myyHG2Gh4dHRkYSEhI0Gk1XV5cvm+Enw4UUSfp8R3mLiphrCTkSA6sUe6/ncacWX4GBgSaTiXl85cqVq1evMo+XLFnCPIiPj798+bJerxekeXyMj48TQtgbdi3FxsZevXp1dHTU543yCq1WazQa09LSZH+3z5UrV2pqakwmk1arTU9PZzJ45MgRQkhISMiiRYvYdFsVbVhYGHdzgYL4K/9JnGPsaGM0Gpn3BWNiYoxGY1JSks/a4D/DhYTI43xHeYuB+GsJORKWVYqZz8q81/OYjfBlNpuVSiXz2GAwxMXFMY+DgoKYBzExMaGhofHx8cybuyLENHViYoINhEVRVFJSUktLixDt8jytVnvt2jWapu/cuSPm+aH7srOz4+LiVCqV5R20JSUlk5OTlZWVw8PDsbGxzEKbRWtzcwH5T+IcY0cbo9HIfJc0Nja2srKS/VKND/jPcCEh8jjfUd5iIP5aQo6EZTPF3ut53KnFC3MPZXh4OPNflUoV/BeWt1EWFhYKfruLA0qlUq1W9/T02Hw2OTm5paWF+UKS1AUHB6vV6t7e3r6+PuZqJ1dKpTIoKIh7PVAqlTk5OTdu3GA/0LNZtPY2F4r/JM4BdrQxm809PT0NDQ1Hjhy5ePGi2Wz25Tsd/jNcSIgMzneUt0iIv5aQI2HZS7GXeh6zkWlMTU0NDQ1VVVWFh4dHRUWxC1nSOhnS09Pr6up6e3vNZnN3d/fg4CD7VHBwcHh4OPvlQqnTarUNDQ0RERHMr4L4IY1GExUV1dTUxPxXKkXrz4mzGm26urpUKtWaNWtKSkpKSkp0Op2Pv7jpP8OFDIj/fEd5S4V4agk5EiEv9bzfXe+ddeTIEeYn0ufNm8curK6urq6uZh5nZ2cL1DRXML+VUVlZOTExwfx6t+XgkpKSIpvfqdBqtY2NjQaDQeiGCCktLa2ysjItLY1wilYM3xKxyZ8TZzXadHV1xcXFsW9NxcXF1dfX5+Tk+Kw9/jNcyIPIz3eUt4SIpJaQI3HyRs9TInnXBAAAAAAA/A3u1AIAAAAAAGFgNgIAAAAAAMLAbAQAAAAAAISB2QgAAAAAAAgDsxEAAAAAABAGZiMAAAAAACAMzEYAAAAAAEAYmI0AAAAAAPyNycnJ+vr6np4eoRsif5iNAAAAAAD8jatXr4aHhzc2Ng4NDQndFpnD32IHAAAAAABhBArdAPCpqqqqtrY29r+ZmZmJiYknT54khAQEBISFhWVnZ8fExDDP3rlz59y5cwaDISMjg1nS399fU1PT39+vVCpjY2PnzZtHCDl58qTl2wYLFixISEjwWUQ28WxneHg4N/br168PDw/n5eUxqzU2NnZ1dRUWFlZUVAwODrKbl5SUjIyM2Os6cMH58+e7u7stlwQEBKxZs8ZmgXFTbG9zwqnkoaEhJI4P7nCRlJT0xz/+8YEHHggMDCSEVFRUZGRkaDSaU6dOZWZmzpo1ixBy7ty5+Pj4lJQUQkhjY2Nzc/P4+LhGo8nNzQ0LC+OeRwqFYmRkpLq6uq+vLyQkZM6cOTExMQMDA/b2aZXNurq6urq6wsLC6Ohok8n09ddfx8bGLl68mFs2YWFh3H12dnbaLBtuk7zZ0yAAtkKCgoLi4+NzcnIoiiK8hwt3rjK+D1aK+vv7T58+TQgJCgrSarXZ2dkqlYrYeclhM5s8B4HIyEieB7K5uVNjHbH1ygoIZiN+SK/Xz549m3lMUdTw8DAhZM2aNTRN37p169KlS8XFxcxLDaPRqFarjUYjc87QNH3hwoWMjIz8/PyJiYnOzk52n/Pnz2dnIMyALiD+7bQZu1arvXTpEk3TTCB3797VarWEkOXLlxNCvvrqqyVLlkRERDDDCndzpuvABYsXL2Y+qj169GhBQUFkZCT7lFXibKbYweZWlcxA4viwGi5GRkZsrkZRVGtra1ZWluXpf/v27ebm5gULFmg0mp6eHiY7Ns+jqqoqjUazaNGi9vb2ysrKlStX2tsnsZXN0NDQjo6O6Ojozs7OkJAQdk2rshkcHOTu017ZcJuECpGf3NzchISEgYGBixcvqtXq9PR0wm+4CAgIcOcqg1rij3nj7/r16xcuXFi2bBmz0OZLDpvZ5DMI8D+Qvc35j3XEToEBvjfidyiKUvwFezpRFBUYGKjX681mMzN6EkK6uroyMzP7+vomJiYIISMjIxMTE3q9PiAgQK1Wp6amsvtUWBB8NuJsO61inzFjBk3TAwMDhBCapnt6epjZCLOV5QObm/s0VHlhK9PqMeEkzmaKHWxuVcns4ZC4adkcLrgUCkVERITRaLRc2NDQkJWVFRUVFRgYqNVqNRoNsXUejY2N9fb2ZmVlKZXKlJSUwMDArq4ue/sktrIZHR3NvALo6OiIj4+3bJVV47n7tFk29poEMkNRFEVREREROp2OGfMJv+HCzauML2OUOoVCERYWlpubOzAw0Nvbyy602cncbPIZBJw6kDtjHcNmgQFmI/BnU1NTra2tCoVCrVYTQpgBNyEhQaPRMFditVqtUqmuXr3a398v5q8budBOy9gpioqJibl79y4hpK+vLzAwkBlZeG7ugQBgOk6lmFvJLCTOg5KTk2/fvs3+12QyjYyMzJgxY9oNh4aGAgICgoODmf+GhISwL9es9knsZJOiqMjIyK6uromJCcvPRvi009kmgfyMj4/fuXMnNDSU8B4u3LzKeCUMWQsMDAwNDWXnGA5YZtMeB4MAnwO5PNYRhwXm5/Bxod+5desWey84+3HkkSNHCCEhISGLFi1i7pg0Go3MRD8mJsZoNCYlJSkUiiVLltTX158/f56iqIyMDPYNoStXrly9epV5vGTJkrCwMF9HZYF/O5kH3Ni1Wq3RaExLS2Nv03KAuzl4HLfA7KWYi1vJzHIkjg+bw4VNsbGxV69eHR0dZf47Pj5OCOHTsZOTk5ZvHAYEBJjNZpv7JPazGR8ff/nyZb1eb7lnm+c7d59ONQnk5MqVKzU1NSaTSavVsrdp8Rwu3LzKgLMCAwNNJhPz2OZLDm42uWsyDxwPAg4OZHNz/mMdsV9ggNnINI4dO8aU2n333ed4ti0VSUlJWVlZzOOgoCDmPb+SkpLJycnKysrh4eHY2FhCiNFoZL5sFxsbW1lZyXyPIjQ0dP78+YSQO3fuXLp0KTIyMioqihBiMBji4uLYfQoSlyWe7bQXu1arvXbtGk3Td+7csXp9w8Xd3JfkV582cQvMXoq5uJXMLBc2cTaJMJtWw4WDF/EURSUlJbW0tLArE0ImJiaUSqXjQwQEBExNTbH/nZycZO+qt9onsZ/NmJiY0NDQ+Ph45lNNhlXZMN8o5e7TqSYJS4QVwp8IG5+dnR0XF6dSqdi7ffgPF25eZQQnwnQ4Zjab2cHE5ksObja5a/IZBBwcyObm/Mc6YueVFe8+8CkfV4goRlgxW7VqldBN8DDLOxAsKZXKnJyc7777LjExkaKonp6e3t7ehoYGQsjU1NTdu3ctfwkkJiYmIiJicHCQGX9VKpXNfQqOZzstY1cqlcHBwWq1ure3t6+vj8/vn1ht7vkw7JNffdrkoMCsUmzFbDZzK5ndlYCJs0mE2bQaLgICAiyfpWna8mV6cnLymTNnmHullEqlWq3u6emZ9jIWGho6OTk5Pj7OXNRHRkYsN7Hcp81sMqtRFFVYWEgIsZyN2Csby3260CQBibBC+BNh45VKpeXbZ64NF65dZbwbGA8iTIcDzPdtwsPDmf/a7GSrbDpYk9gfBPgciLg61tksMNH+xpqPKwTfG4G/0mg0UVFRTU1NXV1dKpVqzZo1JSUlJSUlOp3OaDSazeba2trh4eGpqak7d+709/dHREQwG05ZEPwrJa61k42d+a9Wq21oaIiIiGBfbDFbWT5wsDl4llXiHKTYis1KtlwBiXNKUFBQaGjorVu3zGZzd3f3yMgIe9kmhAQHB4eHh7NfAE1PT6+rq+vt7WVWZt5W5J5HarU6MjKyrq7OZDLdunWLudHC5j6nzaYVe+e7VTu5HDcJ5Ir/cOGRqwzwMTU1NTQ0VFVVFR4ezr7lxP8lB/9BwKkDuTbWOTuC+RV8NgJ/Iy0trbKyMjo6Oi4ujv0AMS4urr6+3mAwjI6OfvfddyaTSa1Wz549mx1/q6urq6urmcfZ2dnsLZuCoCiKZzt1Op3lhkzsaWlpzM9iNDY2GgwG9tnTp08zQ8yZM2cIISUlJVbHtdzce9H5J6vE6fV6eym20tXVxa1k5ufhWUicUxYsWPD999/fuHEjODh4/vz5arWavceaEJKSksJeX5lfEKqsrJyYmGB+g5/YOo8UCkVubm51dfWxY8fUanVeXp5VIth92symgxuvrcrG8g4Zy3ba5LhJIEv8hwsHQxD/q4z3A5KDI0eOMH8GhPmLLgz+Lzn4DwJ8DmRvc55jnc0Cy8nJcb5XZAh/ix0AAAAAAISBO7UAAAAAAEAYmI0AAAAAAIAwMBsBAAAAAABhYDYCAAAAAADCwGwEAAAAAACEgdkIAAAAAAAIA7MRAAAAAAAQBmYjAAAAAAAgDMxGAAAAAABAGIFCN0ACbt26dePGjampqfz8/KioKKGb4wHyi4i/U6dOzZ49OyYmRuiGgJT48ykDACAgDL/+ALORadA0fe3atRUrVoSEhAjdFs+QX0ROycjICAsLc7xOZWVlT0+P2WwODw/PycmJjIz0TdugoqJicHCQ/W9JScnQ0NCpU6cyMzNnzZpFCDl37lx8fHxKSkpVVVVbWxu7JruCywdSKOx+UOznpwwAgFAw/PoJzEamMTExQdO0nE4D+UXklISEhGnXSU5Onj17dmBgYHt7+8WLF4uLiymK8kHbYPny5YSQr776asmSJREREcwMgaKo1tbWrKwsqyzo9frZs2czj51NkM0D2ePnpwwAgFAw/PoJzEYcOXv27PDw8NTU1DfffEMIycvLi4iIGBkZqa6uHhwcVCgUKSkpWVlZQjfTCfKLyKbjx4/rdLqBgQGz2ZyZmcnMQJqamm7evDk2Npafn+/4Tq3Y2FjmgVqtHh8fN5lMKpVKfr0kQuysQKFQWD6OiIgwGo1xcXGWK1MU5XgWwThx4kRSUlJ3d/fo6GhmZmZKSoq9A9lc0+Yp45loLbS1td28eXN8fDw6Onpqaqqnp2fx4sXCnpsibBJIlAhrSYRNAi6bw6/N6ztIHWYjjhQWFo6NjZ04cWLlypXswhs3bkRGRi5ZssRsNg8MDAjYPBfILyJ7zGbz0qVLR0dHKyoqoqOjg4KCUlNTU1NTT506xWfzy5cvd3Z2mkymxMRElUpFZNpLUpGcnNzc3Gw1G+FvZGRk6dKlg4ODZ86cmTlzpoM5DHdNm6eMNygUiqKiomPHji1cuDAyMrKtrS0iIkLYqhNhk0CiRFhLImwSWLE3/HKv70K1EDwFsxGnURQ1NjY2NjYWHBw8Y8YMoZvjAfKLiBCSmJhICFGr1ZGRkV1dXTNnznRq89mzZ2dkZDDXJ2aJLHtJKmJjY69evTo6Omq58NatW+xXR5YtW+bgo3ymGDQaDSFkfHxcrVa7v6bHhYSEBAYGBgUFhYWFsa+EhK06ETYJJEqEtSTCJgFPbl7fQYQwG3FadnZ2bW3t6dOnAwICDAaDDD4llF9EhBClUsk8UKlU4+PjDtY8duwYs8J9990XGhrKbq5UKjMzM48fP75s2TK1Wi3OXrLZePmhKCopKamlpcVyYVJSEnsfBfvemM0OCQz880CnUCgmJycdHIj/mh5n+dUXiqJomiZCn5sibJKfk+75LsJaEmGTfEm6tUScub6Dy3xcIZiNOC0oKGjevHmEkI6OjsuXL8tgtJJfRIQQdoQaGxtjvwdi06pVq+w9xVyihoaG1Gq1OHvJQeNlJjk5+cyZM5YfgAQEBAQHB1utJrMOEWHVibBJ/gPl7YdN8hJJ1xL/6zu4zMcVgr9+6DSj0cicCRRFBQQECN0cD5BfRISQ5uZms9nc29vb39/v1Gg1MjLS3Nw8MjIyPj5eW1s7OTkZHh5OZNpLYjM1NTU1NWX5gBUcHBweHt7b2+vtA4mKCKtOhE0CiRJhLYmwScDl8vUdRAufjTitr6/vypUrk5OTarU6NzdX6OZ4gPwiIoRERkaeOHEiICBg7ty5zDvoFRUVZrN5bGysqqpKoVAYDAbm3lMrFEV1dHQwf2spLCwsLy+PuQtIlr0kNqdPn2b+DMiZM2cIISUlJZbPpqSkGI1GLx2Iz89z+Z4Iq06ETQKJEmEtibBJwMW9voPU/fleSQA5OX78+KJFi7zxS6wAAAAgFFzfZUmMbwcCAAAAAIA/wGwEAAAAAACEgTu1AAAAAABAGPhsBAAAAAAAhIHZCAAAAAAACAOzEQAAAAAAEAZmIwAAAAAAIAzMRgAAAAAAQBiYjQAAAAAAgDD+H7Uhq/kVcRpDAAAAAElFTkSuQmCC",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "conll_lines = result.splitlines(keepends=False)\n",
    "for conll_sentence in group_sentence_conll_lines(conll_lines):\n",
    "    data = render_tree_from_conll(conll_sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The JSON output format\n",
    "\n",
    "The JSON format (which we obtain by passing `format=\"JSON\"` into the `parse` function) is more\n",
    "convenient when we need to further process the annotations, because each abstraction is mapped\n",
    "directly into a Python native object (lists, dicts, strings, etc) as follows:\n",
    "- The returned object is a `list`, where each element corresponds to a paragraph of the given text;\n",
    "- In turn, each paragraph is a `list` where each element represents a sentence;\n",
    "- Each sentence is a `list` where each element represents a token;\n",
    "- Each token is a `dict` where each key-value pair is an attribute of the token."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paragraph 1:\n",
      "  sentence 1:\n",
      "    token 1: {'form': 'Esta', 'space': 'LR', 'pos': 'DEM', 'infl': 'fs', 'deprel': 'SP', 'parent': 2}\n",
      "    token 2: {'form': 'frase', 'space': 'LR', 'pos': 'CN', 'lemma': 'FRASE', 'infl': 'fs', 'deprel': 'SJ', 'parent': 3}\n",
      "    token 3: {'form': 'serve', 'space': 'LR', 'pos': 'V', 'lemma': 'SERVIR', 'infl': 'pi-3s', 'deprel': 'ROOT', 'parent': 0}\n",
      "    token 4: {'form': 'para', 'space': 'LR', 'pos': 'PREP', 'deprel': 'C', 'parent': 3}\n",
      "    token 5: {'form': 'testar', 'space': 'LR', 'pos': 'V', 'lemma': 'TESTAR', 'infl': 'INF-nInf', 'deprel': 'COORD', 'parent': 3}\n",
      "    token 6: {'form': 'o', 'space': 'LR', 'pos': 'DA', 'infl': 'ms', 'deprel': 'SP', 'parent': 7}\n",
      "    token 7: {'form': 'funcionamento', 'space': 'LR', 'pos': 'CN', 'lemma': 'FUNCIONAMENTO', 'infl': 'ms', 'deprel': 'DO', 'parent': 5}\n",
      "    token 8: {'form': 'de_', 'space': 'L', 'raw': 'do', 'pos': 'PREP', 'deprel': 'OBL', 'parent': 7}\n",
      "    token 9: {'form': 'o', 'space': 'R', 'pos': 'DA', 'infl': 'ms', 'deprel': 'SP', 'parent': 10}\n",
      "    token 10: {'form': 'parser', 'space': 'LR', 'pos': 'CN', 'lemma': 'PARSER', 'infl': 'ms', 'deprel': 'C', 'parent': 8}\n",
      "    token 11: {'form': 'de', 'space': 'LR', 'pos': 'PREP', 'deprel': 'M', 'parent': 10}\n",
      "    token 12: {'form': 'dependências', 'space': 'L', 'pos': 'CN', 'lemma': 'DEPENDÊNCIA', 'infl': 'fp', 'deprel': 'C', 'parent': 11}\n",
      "    token 13: {'form': '.', 'space': 'R', 'pos': 'PNT', 'deprel': 'PUNCT', 'parent': 3}\n",
      "  sentence 2:\n",
      "    token 1: {'form': 'Esta', 'space': 'LR', 'pos': 'DEM', 'infl': 'fs', 'deprel': 'SP', 'parent': 3}\n",
      "    token 2: {'form': 'outra', 'space': 'LR', 'pos': 'ADJ', 'lemma': 'OUTRO', 'infl': 'fs', 'deprel': 'SP', 'parent': 3}\n",
      "    token 3: {'form': 'frase', 'space': 'LR', 'pos': 'CN', 'lemma': 'FRASE', 'infl': 'fs', 'deprel': 'SJ', 'parent': 4}\n",
      "    token 4: {'form': 'faz', 'space': 'LR', 'pos': 'V', 'lemma': 'FAZER', 'infl': 'pi-3s', 'deprel': 'ROOT', 'parent': 0}\n",
      "    token 5: {'form': 'o', 'space': 'LR', 'pos': 'LDEM1', 'deprel': 'DO', 'parent': 4}\n",
      "    token 6: {'form': 'mesmo', 'space': 'L', 'pos': 'LDEM2', 'deprel': 'DO', 'parent': 4}\n",
      "    token 7: {'form': '.', 'space': 'R', 'pos': 'PNT', 'deprel': 'PUNCT', 'parent': 4}\n"
     ]
    }
   ],
   "source": [
    "parsed_text = parse(text, tagset=\"CINTIL\", format=\"JSON\")\n",
    "for pnum, paragraph in enumerate(parsed_text, start=1): # enumerate paragraphs in text, starting at 1\n",
    "    print(f\"paragraph {pnum}:\")\n",
    "    for snum, sentence in enumerate(paragraph, start=1): # enumerate sentences in paragraph, starting at 1\n",
    "        print(f\"  sentence {snum}:\")\n",
    "        for tnum, token in enumerate(sentence, start=1): # enumerate tokens in sentence, starting at 1\n",
    "            print(f\"    token {tnum}: {token!r}\")  # print a token representation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displaying dependency graphs from parsed text in JSON format\n",
    "Let us define a function, similar to `render_tree_from_conll` to display dependency graphs for JSON-encoded sentences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def render_tree_from_json(json_sentence):\n",
    "    token_attributes = [\"form\", \"lemma\", \"pos\", \"pos\", \"infl\", \"parent\", \"deprel\", \"parent\", \"deprel\"]\n",
    "    sentence = []\n",
    "    for num, token in enumerate(json_sentence, start=1):\n",
    "        sentence.append(\n",
    "            pydependencygrapher.Token(\n",
    "                num,\n",
    "                *[token.get(attribute, \"_\") for attribute in token_attributes]\n",
    "            )\n",
    "        )\n",
    "    return render_tree(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us test the function we just defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for paragraph in parsed_text:\n",
    "    for sentence in paragraph:\n",
    "        render_tree_from_json(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting the status of a webservice access key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_key_status():\n",
    "    '''Returns a string with the detailed status of the webservice access key'''\n",
    "    \n",
    "    request_data = {\n",
    "        'method': 'key_status',\n",
    "        'jsonrpc': '2.0',\n",
    "        'id': 0,\n",
    "        'params': {\n",
    "            'key': LXDEPPARSER_WS_API_KEY,\n",
    "        },\n",
    "    }\n",
    "    request = requests.post(LXDEPPARSER_WS_API_URL, json=request_data)\n",
    "    response_data = request.json()\n",
    "    if \"error\" in response_data:\n",
    "        raise WSException(response_data[\"error\"])\n",
    "    else:\n",
    "        return response_data[\"result\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'requests_remaining': 99999970,\n",
       " 'chars_remaining': 999998849,\n",
       " 'expiry': '2030-01-10T00:00+00:00'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_key_status()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "006d5deb8e6cdcd4312641bdf15f3bc20f0769a7305d81173599a7b40f33b4a2"
  },
  "kernelspec": {
   "display_name": "Python 3.7.7 64-bit",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}