01-lxsuite.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Using LX-Suite to annotate a text from the BDCamões corpus\n",
    "This is an example notebook that illustrates how you can use the LX-Suite web service to annotate\n",
    "a sample text from the BDCamões corpus (the full corpus is [available from the PORTULAN CLARIN repository](https://portulanclarin.net/repository/browse/bdcamoes-corpus-collection-of-portuguese-literary-documents-from-the-digital-library-of-camoes-ip-part-i/52f2b16412c411ea8a1302420a000005407eb504ccc045a4a0582ab53dfd43fd/)).\n",
    "\n",
    "**Before you run this example**, replace `access_key_goes_here` by your webservice access key, below:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "LXSUITE_WS_API_KEY = 'access_key_goes_here'\n",
    "LXSUITE_WS_API_URL = 'https://portulanclarin.net/workbench/lx-suite/api/'"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Importing required Python modules\n",
    "The next cell will take care of installing the `requests` and `matplotlib` packages,\n",
    "if not already installed, and make them available to use in this notebook."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "try:\n",
    "    import requests\n",
    "except:\n",
    "    !pip3 install requests\n",
    "    import requests\n",
    "try:\n",
    "    import matplotlib.pyplot as plt\n",
    "except:\n",
    "    !pip3 install matplotlib\n",
    "    import matplotlib.pyplot as plt\n",
    "import collections"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "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."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The next function invokes the LX-Suite webservice through its public JSON-RPC API."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "def annotate(text, format):\n",
    "    '''\n",
    "    Arguments\n",
    "        text: a string with a maximum of 4000 characters, Portuguese text, with\n",
    "             the input to be processed\n",
    "        format: either 'CINTIL', 'CONLL' or 'JSON'\n",
    "\n",
    "    Returns a string with the output according to specification in\n",
    "       https://portulanclarin.net/workbench/lx-suite/\n",
    "    \n",
    "    Raises a WSException if an error occurs.\n",
    "    '''\n",
    "\n",
    "    request_data = {\n",
    "        'method': 'annotate',\n",
    "        'jsonrpc': '2.0',\n",
    "        'id': 0,\n",
    "        'params': {\n",
    "            'text': text,\n",
    "            'format': format,\n",
    "            'key': LXSUITE_WS_API_KEY,\n",
    "        },\n",
    "    }\n",
    "    request = requests.post(LXSUITE_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\"]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Let us test the function we just defined:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "text = '''Esta frase serve para testar o funcionamento da suite. Esta outra\n",
    "frase faz o mesmo.'''\n",
    "# the CONLL annotation format is a popular format for annotating part of speech\n",
    "result = annotate(text, format=\"CONLL\")\n",
    "print(result)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "#id\tform\tlemma\tcpos\tpos\tfeat\thead\tdeprel\tphead\tpdeprel\n",
      "1\tEsta\t-\tDEM\tDEM\tfs\t-\t-\t-\t-\n",
      "2\tfrase\tFRASE\tCN\tCN\tfs\t-\t-\t-\t-\n",
      "3\tserve\tSERVIR\tV\tV\tpi-3s\t-\t-\t-\t-\n",
      "4\tpara\t-\tPREP\tPREP\t-\t-\t-\t-\t-\n",
      "5\ttestar\tTESTAR\tV\tV\tINF-nInf\t-\t-\t-\t-\n",
      "6\to\t-\tDA\tDA\tms\t-\t-\t-\t-\n",
      "7\tfuncionamento\tFUNCIONAMENTO\tCN\tCN\tms\t-\t-\t-\t-\n",
      "8\tde_\t-\tPREP\tPREP\t-\t-\t-\t-\t-\n",
      "9\ta\t-\tDA\tDA\tfs\t-\t-\t-\t-\n",
      "10\tsuite\tSUITE\tCN\tCN\tfs\t-\t-\t-\t-\n",
      "11\t.\t-\tPNT\tPNT\t-\t-\t-\t-\t-\n",
      "\n",
      "\n",
      "#id\tform\tlemma\tcpos\tpos\tfeat\thead\tdeprel\tphead\tpdeprel\n",
      "1\tEsta\t-\tDEM\tDEM\tfs\t-\t-\t-\t-\n",
      "2\toutra\tOUTRO\tADJ\tADJ\tfs\t-\t-\t-\t-\n",
      "3\tfrase\tFRASE\tCN\tCN\tfs\t-\t-\t-\t-\n",
      "4\tfaz\tFAZER\tV\tV\tpi-3s\t-\t-\t-\t-\n",
      "5\to\t-\tLDEM1\tLDEM1\t-\t-\t-\t-\t-\n",
      "6\tmesmo\t-\tLDEM2\tLDEM2\t-\t-\t-\t-\t-\n",
      "7\t.\t-\tPNT\tPNT\t-\t-\t-\t-\t-\n",
      "\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## The JSON output format\n",
    "\n",
    "The JSON format (which we obtain by passing `format=\"JSON\"` into the `annotate` 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."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "annotated_text = annotate(text, format=\"JSON\")\n",
    "for pnum, paragraph in enumerate(annotated_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"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "paragraph 1:\n",
      "  sentence 1:\n",
      "    token 1: {'form': 'Esta', 'space': 'LR', 'pos': 'DEM', 'infl': 'fs'}\n",
      "    token 2: {'form': 'frase', 'space': 'LR', 'pos': 'CN', 'lemma': 'FRASE', 'infl': 'fs'}\n",
      "    token 3: {'form': 'serve', 'space': 'LR', 'pos': 'V', 'lemma': 'SERVIR', 'infl': 'pi-3s'}\n",
      "    token 4: {'form': 'para', 'space': 'LR', 'pos': 'PREP'}\n",
      "    token 5: {'form': 'testar', 'space': 'LR', 'pos': 'V', 'lemma': 'TESTAR', 'infl': 'INF-nInf'}\n",
      "    token 6: {'form': 'o', 'space': 'LR', 'pos': 'DA', 'infl': 'ms'}\n",
      "    token 7: {'form': 'funcionamento', 'space': 'LR', 'pos': 'CN', 'lemma': 'FUNCIONAMENTO', 'infl': 'ms'}\n",
      "    token 8: {'form': 'de_', 'space': 'L', 'raw': 'da', 'pos': 'PREP'}\n",
      "    token 9: {'form': 'a', 'space': 'R', 'pos': 'DA', 'infl': 'fs'}\n",
      "    token 10: {'form': 'suite', 'space': 'L', 'pos': 'CN', 'lemma': 'SUITE', 'infl': 'fs'}\n",
      "    token 11: {'form': '.', 'space': 'R', 'pos': 'PNT'}\n",
      "  sentence 2:\n",
      "    token 1: {'form': 'Esta', 'space': 'LR', 'pos': 'DEM', 'infl': 'fs'}\n",
      "    token 2: {'form': 'outra', 'space': 'LR', 'pos': 'ADJ', 'lemma': 'OUTRO', 'infl': 'fs'}\n",
      "    token 3: {'form': 'frase', 'space': 'LR', 'pos': 'CN', 'lemma': 'FRASE', 'infl': 'fs'}\n",
      "    token 4: {'form': 'faz', 'space': 'LR', 'pos': 'V', 'lemma': 'FAZER', 'infl': 'pi-3s'}\n",
      "    token 5: {'form': 'o', 'space': 'LR', 'pos': 'LDEM1'}\n",
      "    token 6: {'form': 'mesmo', 'space': 'L', 'pos': 'LDEM2'}\n",
      "    token 7: {'form': '.', 'space': 'R', 'pos': 'PNT'}\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Downloading and preparing our working text\n",
    "\n",
    "In the next code cell, we will download a copy of the book \"Viagens na minha terra\" and prepare it to be used as our working text."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "# A plain text version of this book is available from our Gitbub repository:\n",
    "sample_text_url = \"https://github.com/portulanclarin/jupyter-notebooks/raw/main/sample-data/viagensnaminhaterra.txt\"\n",
    "\n",
    "req = requests.get(sample_text_url)\n",
    "sample_text_lines = req.text.splitlines()\n",
    "\n",
    "num_lines = len(sample_text_lines)\n",
    "print(f\"The downloaded text contains {num_lines} lines\")\n",
    "\n",
    "# discard whitespace at beginning and end of each line:\n",
    "sample_text_lines = [line.strip() for line in sample_text_lines]\n",
    "\n",
    "# discard empty lines\n",
    "sample_text_lines = [line for line in sample_text_lines if line]\n",
    "\n",
    "# how many lines do we have left?\n",
    "num_lines = len(sample_text_lines)\n",
    "print(f\"After discarding empty lines we are left with {num_lines} non-empty lines\")\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "The downloaded text contains 2509 lines\n",
      "After discarding empty lines we are left with 2205 non-empty lines\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Annotating with the LX-Suite web service\n",
    "\n",
    "There is a limit on the number of web service requests per hour that can be made in association with any given key.\n",
    "Thus, we should send as much text as possible in each request while also conforming with the 4000 characters\n",
    "per request limit.\n",
    "\n",
    "To this end, the following function slices our text into chunks smaller than 4K:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "def slice_into_chunks(lines, max_chunk_size=4000):\n",
    "    chunk, chunk_size = [], 0\n",
    "    for lnum, line in enumerate(lines, start=1):\n",
    "        if (chunk_size + len(line)) <= max_chunk_size:\n",
    "            chunk.append(line)\n",
    "            chunk_size += len(line) + 1\n",
    "            # the + 1 above is for the newline character terminating each line\n",
    "        else:\n",
    "            yield \"\\n\".join(chunk)\n",
    "            if len(line) > max_chunk_size:\n",
    "                print(f\"line {lnum} is longer than 4000 characters; truncating\")\n",
    "                line = line[:4000]\n",
    "            chunk, chunk_size = [line], len(line) + 1\n",
    "    if chunk:\n",
    "        yield \"\\n\".join(chunk)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Next, we will apply `slice_into_chunks` to the sample text to get the chunks to be annotated."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "chunks = list(slice_into_chunks(sample_text_lines))\n",
    "annotated_text = [] # annotated paragraphs will be stored here\n",
    "chunks_processed = 0  # this variable keeps track of which chunks have been processed already\n",
    "print(f\"There are {len(chunks)} chunks to be annotated\")"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "There are 105 chunks to be annotated\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Next, we will invoke `annotate` on each chunk.\n",
    "If we get an exception while annotating a chunk:\n",
    "- check the exception message to determine what was the cause;\n",
    "- if the maximum number of requests per hour has been exceeded, then wait some time before retrying;\n",
    "- if a temporary error occurred in the webservice, try again later.\n",
    "\n",
    "In any case, as long as the notebook is not shutdown or restarted, the text that has been annotated thus far is not lost,\n",
    "and re-running the following cell will pick up from the point where the exception occurred."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "for cnum, chunk in enumerate(chunks[chunks_processed:], start=chunks_processed+1):\n",
    "    try:\n",
    "        annotated_text.extend(annotate(chunk, format=\"JSON\"))\n",
    "        chunks_processed = cnum\n",
    "        # print one dot for each annotated chunk to get some progress feedback\n",
    "        print(\".\", end=\"\", flush=True)\n",
    "    except Exception as exc:\n",
    "        chunk_preview = chunk[:100] + \"[...]\" if len(chunk) > 100 else chunk\n",
    "        print(\n",
    "            f\"\\nError: annotation of chunk {cnum} failed ({exc}); chunk contents:\\n\\n{chunk_preview}\\n\\n\"\n",
    "        )\n",
    "        break"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "........................................................................................................."
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Let's create a pie chart with the most common part-of-speech tags"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "%matplotlib inline\n",
    "\n",
    "tag_frequencies = collections.Counter(\n",
    "        token[\"pos\"]\n",
    "        for paragraph in annotated_text\n",
    "        for sentence in paragraph\n",
    "        for token in sentence\n",
    ").most_common()\n",
    "\n",
    "tags = [tag for tag, _ in tag_frequencies[:9]]\n",
    "freqs = [freq for _, freq in tag_frequencies[:9]]\n",
    "\n",
    "tags.append(\"other\")\n",
    "freqs.append(sum(freq for _, freq in tag_frequencies[10:]))\n",
    "\n",
    "plt.rcParams['figure.figsize'] = [10, 10]\n",
    "fig1, ax1 = plt.subplots()\n",
    "ax1.pie(freqs, labels=tags, autopct='%1.1f%%', startangle=90)\n",
    "ax1.axis('equal')  # equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "plt.show()\n",
    "# To learn more about matplotlib visit https://matplotlib.org/"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {}
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Getting the status of a webservice access key"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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': LXSUITE_WS_API_KEY,\n",
    "        },\n",
    "    }\n",
    "    request = requests.post(LXSUITE_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\"]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "get_key_status()"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "{'requests_remaining': 99999140,\n",
       " 'chars_remaining': 998236690,\n",
       " 'expiry': '2030-01-10T00:00+00:00'}"
      ]
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "006d5deb8e6cdcd4312641bdf15f3bc20f0769a7305d81173599a7b40f33b4a2"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.7.7 64-bit"
  },
  "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
}