nosebook_textual_smell_trend_analyser.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ysu6s5Mk-t8B"
      },
      "source": [
        "#**Odeuropa Nosebook – Textual Smell Trend Analyser (WP3)**\n",
        "![Screenshot 2023-11-21 at 12.42.01.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPAAAABtCAYAAACfrewPAAAK3GlDQ1BJQ0MgUHJvZmlsZQAASImVlwdUk9kSgO//pzdaQqQTehOkE0BKCC0UQTqISkgCCSXGhNBsqCyu4FpQEQF1QRdFFFxdAVkLYsG2KDbsC7IIKOtiwYbK/sAj7O47773zJmcy35nMnZn7n3v/MwGAEsKVSDJgFQAyxVnSiAAfRlx8AgM3AEhAHRCBOaBxeTIJKzw8BCAybf8u7+4CaMLesp7I9e+//1dR4wtkPACgRIST+TJeJsJtiI7wJNIsAFBHEL9RTpZkgm8jTJMiDSI8OMGpU/x5gpMnGa0yGRMVwUbYGAA8mcuVpgJAtkX8jGxeKpKHHI6wrZgvEiNcgLAnT8jlI4zUBbMzM5dM8DDC5ki8BAAKDWFm8l9ypv4tf7IiP5ebquCpfU0K3lckk2Rw8/7PR/O/JTNDPl3DFFGyUBoYgVgN5PndS18SrGBx8rywaRbxJ+MnWSgPjJ5mnoydMM18rm+wYm3GvJBpThH5cxR5sjhR0yyQ+UVOs3RJhKJWipTNmmaudKauPD1a4RcKOIr8+cKo2GnOFsXMm2ZZemTwTAxb4ZfKIxT9C8QBPjN1/RV7z5T9Zb8ijmJtljAqULF37kz/AjFrJqcsTtEbX+DrNxMTrYiXZPkoakkywhXxgowAhV+WHalYm4Uczpm14YpnmMYNCp9m4Av8QAjyYYBIYA9cELVHfOwsQW7WxGbYSyR5UlGqMIvBQm6cgMER82xmM+xt7R0AmLi/U0fizb3JewnR8TO+bGcA3CbuWsOMbwFiWzwBoOrP+EwKkHOfAsCZJJ5cmj3lQ098YZC3gjKgAU2gB4yQ94M10pkzcAfeSMdBIAxEgXiwCPCAEGQCKcgBy8FqUARKwGawHVSAPWAvOAAOg6OgGZwEZ8FFcBXcAHfAQ9AD+sELMALegTEIgnAQBaJCmpA+ZAJZQfYQE/KE/KAQKAKKh5KgVEgMyaHl0FqoBCqFKqBqqA76EToBnYUuQ13QfagXGoJeQ59gFEyGabAubArPgZkwCw6Go+CFcCq8FM6HC+GNcDlcAx+Cm+Cz8FX4DtwDv4BHUQBFQtFRBihrFBPFRoWhElApKClqJaoYVYaqQTWgWlEdqFuoHtQw6iMai6aiGWhrtDs6EB2N5qGXoleiN6Ar0AfQTejz6FvoXvQI+iuGgtHBWGHcMBxMHCYVk4MpwpRhajHHMRcwdzD9mHdYLJaONcO6YAOx8dg07DLsBuwubCO2DduF7cOO4nA4TZwVzgMXhuPisnBFuJ24Q7gzuJu4ftwHPAmvj7fH++MT8GL8GnwZ/iD+NP4mfgA/RlAhmBDcCGEEPiGPsImwj9BKuE7oJ4wRVYlmRA9iFDGNuJpYTmwgXiA+Ir4hkUiGJFfSfJKIVEAqJx0hXSL1kj6S1ciWZDY5kSwnbyTvJ7eR75PfUCgUU4o3JYGSRdlIqaOcozyhfFCiKtkocZT4SquUKpWalG4qvVQmKJsos5QXKecrlykfU76uPKxCUDFVYatwVVaqVKqcUOlWGVWlqtqphqlmqm5QPah6WXVQDadmquanxlcrVNurdk6tj4qiGlHZVB51LXUf9QK1n4almdE4tDRaCe0wrZM2oq6m7qgeo56rXql+Sr2HjqKb0jn0DPom+lH6XfqnWbqzWLMEs9bPaph1c9Z7DW0Nbw2BRrFGo8YdjU+aDE0/zXTNLZrNmo+10FqWWvO1crR2a13QGtamabtr87SLtY9qP9CBdSx1InSW6ezVuaYzqqunG6Ar0d2pe053WI+u562XprdN77TekD5V31NfpL9N/4z+c4Y6g8XIYJQzzjNGDHQMAg3kBtUGnQZjhmaG0YZrDBsNHxsRjZhGKUbbjNqNRoz1jUONlxvXGz8wIZgwTYQmO0w6TN6bmpnGmq4zbTYdNNMw45jlm9WbPTKnmHuZLzWvMb9tgbVgWqRb7LK4YQlbOlkKLSstr1vBVs5WIqtdVl2zMbNdZ4tn18zutiZbs6yzreute23oNiE2a2yabV7OMZ6TMGfLnI45X22dbDNs99k+tFOzC7JbY9dq99re0p5nX2l/24Hi4O+wyqHF4ZWjlaPAcbfjPSeqU6jTOqd2py/OLs5S5wbnIRdjlySXKpduJo0ZztzAvOSKcfVxXeV60vWjm7NblttRtz/crd3T3Q+6D841myuYu29un4ehB9ej2qPHk+GZ5Pm9Z4+XgRfXq8brqbeRN9+71nuAZcFKYx1ivfSx9ZH6HPd5z3Zjr2C3+aJ8A3yLfTv91Pyi/Sr8nvgb+qf61/uPBDgFLAtoC8QEBgduCezm6HJ4nDrOSJBL0Iqg88Hk4MjgiuCnIZYh0pDWUDg0KHRr6KN5JvPE85rDQBgnbGvY43Cz8KXhP8/Hzg+fXzn/WYRdxPKIjkhq5OLIg5HvonyiNkU9jDaPlke3xyjHJMbUxbyP9Y0tje2JmxO3Iu5qvFa8KL4lAZcQk1CbMLrAb8H2Bf2JTolFiXcXmi3MXXh5kdaijEWnFisv5i4+loRJik06mPSZG8at4Y4mc5Krkkd4bN4O3gu+N38bf0jgISgVDKR4pJSmDKZ6pG5NHRJ6CcuEwyK2qEL0Ki0wbU/a+/Sw9P3p4xmxGY2Z+MykzBNiNXG6+PwSvSW5S7okVpIiSc9St6Xbl45Ig6W1Mki2UNaSRUMGpWtyc/k38t5sz+zK7A85MTnHclVzxbnX8izz1ucN5Pvn/7AMvYy3rH25wfLVy3tXsFZUr4RWJq9sX2W0qnBVf0FAwYHVxNXpq39ZY7umdM3btbFrWwt1CwsK+74J+Ka+SKlIWtS9zn3dnm/R34q+7VzvsH7n+q/F/OIrJbYlZSWfN/A2XPnO7rvy78Y3pmzs3OS8afdm7Gbx5rtbvLYcKFUtzS/t2xq6tWkbY1vxtrfbF2+/XOZYtmcHcYd8R095SHnLTuOdm3d+rhBW3Kn0qWys0qlaX/V+F3/Xzd3euxv26O4p2fPpe9H396oDqptqTGvK9mL3Zu99ti9mX8cPzB/qarVqS2q/7Bfv7zkQceB8nUtd3UGdg5vq4Xp5/dChxEM3DvsebmmwbqhupDeWHAFH5Eee/5j0492jwUfbjzGPNfxk8lPVcerx4iaoKa9ppFnY3NMS39J1IuhEe6t76/GfbX7ef9LgZOUp9VObThNPF54eP5N/ZrRN0jZ8NvVsX/vi9ofn4s7dPj//fOeF4AuXLvpfPNfB6jhzyePSyctul09cYV5pvup8tema07Xjvzj9crzTubPpusv1lhuuN1q75nadvul18+wt31sXb3NuX70z707X3ei797oTu3vu8e8N3s+4/+pB9oOxhwWPMI+KH6s8Lnui86TmV4tfG3uce071+vZeexr59GEfr+/Fb7LfPvcXPqM8KxvQH6gbtB88OeQ/dOP5guf9LyQvxoaLflf9veql+cuf/vD+49pI3Ej/K+mr8dcb3mi+2f/W8W37aPjok3eZ78beF3/Q/HDgI/Njx6fYTwNjOZ9xn8u/WHxp/Rr89dF45vi4hCvlTo4CKEThFGQ+eL0fmRPikdnhBgDEBVPz9aRAU/8JJgn8J56awScFmUvq2gCIQuaOIG8AqhE2RSwF0XBEo7wB7OCg0H+JLMXBfioXqRkZTcrGx98g8yPOAoAv3ePjY83j419qkWYfAND2bmqunxCVQ0j+Ww5Brj5PmukF4B8yNfP/ZY//tGCiA0fwT/snCTUahHvl42UAAABWZVhJZk1NACoAAAAIAAGHaQAEAAAAAQAAABoAAAAAAAOShgAHAAAAEgAAAESgAgAEAAAAAQAAAPCgAwAEAAAAAQAAAG0AAAAAQVNDSUkAAABTY3JlZW5zaG90w+98BAAAAdZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+MTA5PC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjI0MDwvZXhpZjpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlVzZXJDb21tZW50PlNjcmVlbnNob3Q8L2V4aWY6VXNlckNvbW1lbnQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgroZ7XrAABAAElEQVR4Ae29B2BdR5n+/Uq60tVVr+6x5RbHTnF64hQS0hsJCYFACEv5Uza0j7LA7v53qbsfuwss7H5LJ8BCAgmhhRAgpEAapHfHce9Vsnq5ReX7Pe/cI1/Lkp3Ekls00r33lDlz5syZZ9467+QNkGw8jbfAeAsclC2Qf1DWerzS4y0w3gLeAuMAHu8I4y1wELfAOIAP4pc3XvXxFhgH8HgfGG+Bg7gFxgF8EL+88aqPt8A4gMf7wHgLHMQtEDuI6z5s1QcMqxiWsWAb69dmNum4WV5+Hvv5lp+nX33G03gLHLwtcAgBeMD6+wEsf+nebkv3pay3L229/WmO91nfQK/1g+a+gbT19WV4Y3lWVlxlJUVVVsqnIF/MyDigD96u/Oqs+SEB4L7+Xsv0JS3Tm7RUX48DNwOAk5lOS/Z2Wk+mw1K9XX58YEAg7wfMfPiDJFtxYcKqiidbZWICn3orj9dbLP+QaJpXZ69+FT113sHuidUnSguABUTxyAMDUNv+DGDts3Q/YO7NQI27rTvTZk2da6wr1Q54OQ9F7oNC93B9GpBbfoFNKGuwgrwCwFtkM2sX2vTqo9gufBV1h/FHPdha4KAGcKCmecizanZ9CcASgfthlQXitGVgodO9PVnq3G3tPY3W2LHWkn0dzl472AF9Guqd7k9ZfdkMKyoo9vcY53dmzQk2o/ZI34++XMJ2kTrI1Zan+7I9JOVJztZhfvWn5Md8a/xrvAX2vgUOaj5RYIiAEZqCPXCSBxXNtwLk2pjF+gutEIqaLohbrLfItxOF5ba5fZV1phoDqwx4+/yafGvp2mhVJROdCvdSyoa252xCxXQrjpVqeHA8mrPhGiiyRwbyOA47nh1EVBcHan8YVFCZefW8vuT1Ou9Sd88y/jXeAi+rBQ5qAAfAjPy8+XkxOGM+eYWWD4tcADtcwK/Y7ek182Gpy21LxwoUWRWWiJW5oksUuzYxyRo711lzeh3DQMxKYhV2xKQzLMYg4KDNUlxReqXhqK+4goEs1R1gcNDIwmUB2NKCA+R8Kc4EaI0642m8BV5BCxzULPTLeV5pqHthkfsAaAotdU+6C7a5y7Z3b7FN7UtdLi4E6Gm01KWFVXZY1QLrSrfCcm+zdii1TE8lhaVQ5ylWXzrDqkonAcDCANEs9xwx0YHGAkrwmQdAHbzKKRAzeATOocB/Zc4StzAO4pfzNsfzRi3wqgGwHliUUiCWbJxCLu5Jd7j2uj213dY0P4sGu9Pi+XGAGbOGmmPJ18unG3kZJViqmfMpl6lVTkVxrU0AyHXIzHGALeoKCgN7rG+nqvrlMBCV/dlZe1e2SW4XuoM9Wue178cE9PE03gIvsQVeVQBWmwQQYx/GFizTUne6DRCnnMqub1kC1W22OPLuzOqFsNRQ7b4u8gn0SZdzu3sD6LVfWFDirHdNyVSbUnUEAIw5YB2yAjOgzMtSV4GXI25v9m3J3A5ygFvA9kCgzJLb93dq6khZR3eG+ku290YL21lFnR/Xtp7RTyMsKO9O5znhg1doc52XHV4tMrEqbon4/n9OPdpop2Sq1za2JCEClOxNNLRdvEU5qbbrt4aJ5XtVhUOzFYdpEnUudTZ9CgBaf14/2uaEWZEB4g4rK6q1aZVH2IZ2QAy17cy0Qo1LoLhyAsnwSXsHjecXO1vcj+mqsWs99uM68mSsDTZ7SsU8K4tX05kFRoCpl4TM7VsO2ALKAMj5/YC3D/FX+ZCP+6hUPp2b7X404vubEn/uJ8/ajfesz7YWP9mktlOKumDYC2063PHo/I5fOdLE7OaPLrRLTpux4/AhspXqSdk1//GI3f/sNn/vkp6UcttN2330xXRnj33+PQvtE1fJwhHlUO6Xlw5KALvuN6tAUncSCwoSBJednl6g5R+lMR2nD9NSL04cfep+GhUNdlpUIW55nEO9ZWWxfJtS1m8b+1+0be1rraZ0qpcnai2QSmkVKaKKpPTq38DxXkv1bLHygVpb3vgotuMjrby4nhEYpZkgTId19lgwdkrLPtR2QIMIw3Q+A4nAO9Af40moFMeVBOb9lWpKEjapisFtDFIXg1Vh0UHZ7XbbGqK8bwS8L25os8k1FRCI3l36owoYoFckk932jY+fZpecOnO3Zb6UkwdUSwbAQfFgLQbcLTLS8gYXSQFI8qvAUYiN1oHLU4o9E8UryFI0L4emyiT7cOQQcCkRkArzvb3Itb0YfTgub6zI/COTUe9AiRUOTLFJyLRt/RutAPB197Xgiok9mfuq+VW2kgaLYsxR3el2i8Xi1pFstopEna1ufsYmlc+22tLDME0BUKi3WGs5iEhZJcob9sVOQpGd6hoabsrtB7TBqO3l65kOpdTPQKqWO9RSMpmxD33jEXtsWYtVl2KpoP8OJSZ6Zj19byZl//bOY2zRgkmj0gz7HcBiGeUKGX5hK4UyGsBdHWFfdVyKJ7GiiVg5/ss1NI5Yz+E7goCa7En7J5ORtxWgz/RBJfHIoqHVifILgE4szwoLoYZQQZ/gAAWUR5coYV5/iRX11VuqPWnxooRlrJURFVl5oBuQi5UWzrges1IaWVgKsRh1a8NJpBST1OaO5W6DroAS50FtBdo+UWQGBAG5ABZ6QGw09yqAAuezrXoOQIn9LesX7BYMw1WMylsfL2TUWkBs8+X/8rA9u6bVaspkZlTR/rXTPfroxy1tKfvBR4+3047CbZe8o5H2G4AFzAzKIZ9kAGAhkQG0oooCNR/JmfJt1oSD2pLJIrU5zyyGc+dxTkBtaW63dApqCXC0n+xKW1c3FDTTb8WJGKCVHCqWWp+gqFGhBbC3kkdVr7z+IsCVsL5MkmrlU5dS5wriRQA7lrKuvmYfVARgUckB6i4vLtxGuF6sU8zWty62GWiyNegIsCpXMpGAq/uLtnI39gGxKuDPhkuoTtAczlVwgSvGdP4QSPniLiTvHyIpTf96+9cetpVb2qwmgaMP3NZIqYtT//W3x9pli2aOlOUVHd/nABaFlWujU13Bgs4sAAi0mlwQzRwSq9ydabdJlXOYXFDNwwm8MgPJRRKK7JSsKHhScaYLpUB7a6fGAf8kGRk70aaKvVHHKS4BlIBDcrBovMqS+CngCCySc/M4IOepAYCTN4Dzx0ARpqZOQFtk/RkGhD5kZyh3IjYR9CWtu7/FNdbytVad8qHoHbDUVVDeJHbmps7VNrF8DnDGNIWNeSAP6i22GQobc8UVzR8qE4CLgkv7jmU9rqonDmFfs9JegXD/0f7elTaN9h32TXmpZNre/V+P2r3PtVltWTHvdXjw0rOtpT1l/3LtXLv2nNmjXrl9CmBN7ZPPsaiUHCsEXtM2DyngwkhCFaFmmG66mUE0pXKug1fZMkxMSAImUTJ5RBUVoHYS9eNkd2fSWls6gozLqNgN1XXwpnsBOOBNQCkpA4JO/ui+2tb9+WRBLJou7bT+XJnkgAJwjuo49+8GeCibAHJerMRKAXZerABOosdBpokVGlh6Ml2YSSqstXsb3EOtVcRrHLQgnEFDfAMDEfWKCbxilylfmHFbsosHnKA9JCr0SRkC+Mkx6i9/pAIz6AxSiB+om6gpgw0ihxI19RTVpBe2X6kge17HlWd3533KZ1SQLj4Ik0S0S7/wV9u4pQVdRylPoLbaNekxm9t77Oa/O9HOO3HGrhlG4cg+A7CoVBqWOQAosMkCj1hlaYmltZMMmsQ224ljxdTq+VYJJdMLl0dUR7KJjlEAICpdvhRlUldJItu2tXYBKimo+qyD0a4T2TWZEtDNysuLuQdDgzBJi3Z1dmLj7LKeJOy75E79cVwsdHEi4XJxrAjo0DLQZK6T1piujMlJ5WeQgWMom3xA4Lcwv85qiwpse2Yj5fVaUWGR25eLUYQp0/au1fhRSzkW3lYehVEdqDKcBI8QQMw5acdF+Qt0TyAAwPN4qPz+fIYT5Ghk6H0F4ln1cTt5VhltHyrtTc1mpHfwgY8q8mo8FVBXHXsp57ugXNUlLjSEiw+yb2mb3/+NR23JhlarKip3rmq4R5CQpNlu/3rdgjEDr+475o4cAkg6w2wglD0uB/KipaXzbQEXqqtvd6wA5J1ocxOAdGYdnlAAXm6Mbd2NVoimt6yoGoAABrylYgVia/OsrYX5vrDLfek+6+xE3u1AqZQU1Sqw2tpyWFCzjs4Oa+/AISOVdBD2ZgbYluJIIJEpiZagXv1sa0DJwBVkoMRAzPKLeq28rMCqKqD6cQYYZjHlgzrwjjKMAaAA1ikvhT05ac2pta4dF5tfjUZaz5iC45hUNgcNteYYi41HUpbc637ZUmIVsp/jq73TvhReRdmPlGEHb8cfrpMfbMeksHrLVx61h15ostryErpMdgQb8iDqTh0d3fbFdx1jf3P+3CFnR3d3zCmw2MsIvIFlzoJXgHEZGE0x7GLk2qh5urMAr/yVW7o2W3P3ZgBbaCX5orx0dCFSrDMUt6cLGRd2pk/Kqh5Ybz69gFqKn+raUtjAlDVt3w41ljIKthXgZtBv9UH6lEfstVIEC6oEqDH1yNmCenSne6yLezS3FNj6/JRVlGIrroxZorTHElCRAnlPSaaVVjtdZvWJWdaW3uJASzFgxaHaAnEXTiHFRWWh7hoknGXmWlFcRmoNHGEgkYlJAwrPyDFNeJC4kY/2WnK5hr6Iyo1uNxgvbU8tkExl7A1ffMSWbZa2uYz3ISXGroleZplUgX37IyfZZadM3zXDKB8ZUwBLURVkXmmUGa0kXzJqid2SnKnO2cdxRdKQYqsHN8XassN8W+Dd1rEGs03GEonJgFduigKMuny+m4WkWdbeAGxmBtYmid03A5gn4J62vXm7tcMuy94rVlna5H6mE8o0g+jqSfcW+64RU8nlUH1xQAOJwCeMx1FcCXQt7b2GqO3Kqrq6XptQX2BFAhv16oc1LsiUWnlhjXX2NuM7jfIL2Vua6hTPlSI6SCFeXGQmO0ozytNgpHv0c0+Zm/Rx/kT3ZVtAhkUSf+LPrWfXgDGe9m0LpADvh2Cbn1zdatXxEt6XhKtdE+4Flpcpsq9/+Bg7pqFq1wxjcGTMACz2IokiSh00yEwASYChOzp8OS7KKzkh3a9QOMwOQlE1kagYbcwAau5c75RLtlSxnpoGGAAs2YIuLW0yYEXnBSXOOKWUuaiyMm6bt24BzLDVyKy9UN7iolIxw4B3ZwqmeqmeblKibpL5ROekTuvMdHt98yTsCjYANFGYh4JNIkGBbdiUse6eXps6OWaVmIqgs1wP4DJliABQ777NHEMRBTh7KEvPlxio9MFH99S9JZvLrVKudflsa3BTm8jmHdrJ4cwgQ34GP8lVOjJOhccACSMU6XbeLz5sT69ohW2WnXd48Kqft7Vn7LsfWmhnHDkBy8VwEB/hJntxGPIxNkkTBNxUpM6nzhmBl21BxEEMhZaLorycpGWeWjnPQb+dubgdqSZoTb77KwfZL1AjdfwUpiHZeqWokp23J2vrjaNMau2A+vUg6wJubmkT6uoAMoAQSNwks6NhZV7SsRi24SL/QOVRImV4Ge5IApALmU8sAEN3nUKLGhdzXUFekW1vzbO16zOW7I5ZUR5O6VDM3jT25jxGXxRaem5R2SQ6ANmJ5fQROBC1ieoXBjdtB1CHtvJzaif/aADRQIPSiF9I8ti8sPFSd2mBNHqV65B5V25qd22z+tBISZzR168/yq44YxbORvQn3HL3RRqjuyBr0lnDAwcqAoS9Q6obShaWuUhaZ5mWMnTuJGx0SWGlNXdtstbUNjp7t9tYBd7gSxyaQyadJDNlUrDLsvH2QHVFecXmdKdaOc7AAXhFoetq6615O5pvKKtkS1Hknu4kn5R18+ni04MM3YvJpCBWiJIKR484U/jjvA5egOopjjok2FfqondYCOgTmLF4FGvrMlu7gYgemWIm/ldxL1j0Acm78uwKzyotruzEmousj3Ml3g6ivqFdRIUl2KvNfPDguG7mg5/y6GZ8dteJopqO/+59C6ToF+/52gN2/5IWBmfsvNjwR0rdWEI+eOl0e+PZY6uwGu7+Y8JCq4OK+obOlu102cErokCKRSUvLP3K4yqDx5XCwbYmt8CidgIAQuEgP2rmUEhibqGOgE3UNR0BGI1zNwBWYLoCOrqUVVL4TJ44EVswGmLdl+OSjxXoTngsKi608sqElZagWYZqS7KUCybYYzBJW0VvnlVRbmuX3B2x/yb7GRhgnaGuGlD0XDEoYTH166DO7dxn+/aMFcA6F0g7jjBUju3XA+dRqP6SKMQyRWkGpQDQfNpItmanvlBpAVROHqqwtlVPp8Ac83Z0MIezAxIFPAeZxtOot4AG+NfBNq/Y0MWEFvk2y847OJL7/bLdmXffbTd8fJFdfOKUUa/HSykwQsdLyfuS86Tkgij+VV1RFMVZZgFLrKmob+T7jKEmC94YgG3v2e7zc3UjKa1kYnH7p8igWowiXZMMgHsAmDTQosDtHe1WUqZz0gzmW21NLRR4gDxpVwL1MEKqPnI4qJtYiZKrwkrwzIoXo4mGdXYXP65UvrZ2XDE7OtB6Y+NNYBvGrtsHoNPpfGzMGWtp5Z5ou3kMK4KVLkI+70G1vb05aaWV3Sjc9MLzLJ5XRnSP7QFoADR4nokCA3IHroApCq12UlJbqfZ86V+ARe71bdmO9cdxMoynMWwBt/N+/XFbuq7VSuOakRW9n51vqr4cYybbZ687cr+BVzUaEwBr8kFIoirqdUp0Vu+E/DprmZUzocKiVAW4LXalt9PBxXoHGTO4EAYKphIEDLmwZZB/nYVGidSBC6XlQ80x/wgLlZXVligutq1bOxw8shFLOVUUL7TDZtRyPoEZqBDwQuEL8ebCoOs2XcBYwmhbVoWOu63dmpBvW1vRbkPxi4uZgJ7It7KSEqsoL7TGpiTmKVwnuUMRpq0uBqQONN7bmntszowKuIEuiKsUHozdPJtqLju3K/F0DCpfCKXe0TYRYBmA5P0FhdWw526X+kW2dvTquFDM71CKoPYZT3vXAkko79u++ld7YHEHkVbwhedvuKTW7+rstS+8Y46988Ijhsuyz46NOoB3UJUsYL0DBkrsLCEoEwvoIBZlFhVCmVPGLJ7OTFPoqDz+IOVlW6Yi2UpR2AJcUV7sxsi/8sJqbsUXtbYQKtkPAMutvLQEZw7kTcnYuFIKvMWJIpvWUGeVeGUlSpB1AW8Rc1ILcdUqQGklxZVrdsFJXqzYqpi8kLYm5GEcRTpaGBAmUwdkY+zAxQlghX23B5a8C+23mAM5ZmQYlNLY/+RtJrNPnGgd4rxkKuOhAHAICKDtJGYleWd5e1C/fmYr5UXuigBUXEpEidUThFldp4//sblDNte58bS3LSAdylX//pAt24gTTllsRPDqPsp7w0ePtQtPbtjb2+719WMC4GyPy/Y5yQ5Oe/1wUNCI+koLG+RksZWapidFj7punjo0bGegMt57HUCSLTPSPNOAKXledfVYnBlGssPKna8MPlq529q7/XppEZWmTq+xCqZvFQPeQhRV0jjHBF40yvkoqzS9UABWTQXoMquytuRWgAUL3tNjxaVQT6YTwibgkVXLNQXcu8jlakYKBiQNOGKTqVN3C2Dss9LSiQ5QPaOLDfwqsgfwDNpofiXVh0ZSLXOpa9jWQKdGy3eKqzxKudeEI2P1vaEJDR1pWp38fXdNezq/ketV25Gu37XEcKTb9Q9S9un5ub5+5/uvb+yiTcjLR/7wk2peefABmRn7mCP+wa8/ak+t7LTKkhATfPi6IUohLn31fcfZaUfvH5l3aL1GHcAOVRpefxENDnvZb51zuU+/vB06ZxI7qShSL5roAhRDvBZgHIS9wECzTUO78iqNCQlgCsRtHZ1WPwHDOgqoyooqgMlsIKiv3mw6nXYwTp7CZIKKYthgTSXMd6rr84EBbT5glba5AECGunA30FicV2JVZRNsgPARFRWltqblcautmohcW+XUWp2qD8eQAUAvSHK5U/QCAC6lnLTOyRRApiZqA1FfdUYftBi4JGIoKmYZg4nbd9UOJH1nN7N7Oqrj+gu/YV/fY5fuemKTPbOq2dZtw2uFh5hRH+I2RbqCyEd6XSMTSKjYjAkv7by4hgE4pctOnWbzGmqGfQC9hxdWN9pN961z7klPrvI1QKsR1I5rEI9kVVB9ahmYX3v0JDuqodQqKkM9hi14hINdiGFv+eK99ujKlNVh58VWMWxOPWdbR4994wPH2GuPmWgl8dA/h828Dw+OOoC9ldXheGKBQTB2cLDv7HJ2X8e0rzwCsWyk8kN2PSyNJQrMD0kvTp5LACENBcb7SnJpeyfUwdtwAGAWA0bAQG6Zh3SJzEhVVWVWU1sGsCXvorAS1QW4ml2jl18gQAOikKir3xAzEIqpsuJqD/w+AMhl5urobkV+nogrZh6znfqRj7Vomlwd+9BG98EJFGC2KqJunVZXOYmyCV0LJ5DPPRQUj7s7hZaftFNirovu6wOd31wPnj0cbejxdShULtsmfiTKOOq/f36+yW65f11Oudt9WwBUylYl7Pj3SzxP3nb0BcfMqQPAOZcP2bzl4U32q4e38Z6ixsiWn80XPb2Uft0MpN+4ZxPefAM2s6LIPnPNTLvkNXOGlDjybmVZoT29AZMjug1NJx0pdUA0/r8PHGdXntkwUpb9cjzqvaN382zrauQUeNX9AoC1KTUU+3Kp9HMc4x2Jfc1gjgkaWV2jFxdY2sBFAhRekMw4fQBYE6k1m0gdSoqhRDz4RsouLNlX90tgIhLljTNSahK/WOWCGJptscuAV/MCZPPNTVEHJScOJHEWOpvk7p1Ta+dYU/MGZFwcNbr7UWLhRMJgkgKEMSY04EPJrKci7ilNNtP0AWmmIG1TambZuqZlsGiEAXK7spxWejgvKqy5wWobrncWOdtwvq1ahX21IUNOtppRh9avzkf72dOj9BODhYhh5xZAlET8hkuv5DyGQYrKFjxcoRzTVMY8NPUSS5SG3n/wvpRTgWJE7rFM37ZWuK63fHOZzbhlqX36mvl2xaJpvPus36yXNPyXdCAh7VovHZHJ8u+vbLCrDzDwqs5jxAdkgUsDRx00dNbAUur9aT/6loNEMDVxxIf3cC6AmCgXgFfss5RSvbw9UWEpEuIAUFRQL1qfduZeKqWRk8vRIkp5VYidNwYVFKssqhvlLYKlHhkAgAYzksLLViWmMP1tqk2rOtY2b2qxVWvRNjdilvJngLLGk7DvMbTTcghJwUozfRG3yi63ZRfYYbWH66H9XjKZKYaWTBBaMdGfFcCGZ45qo2cniTMhaRjztsu2lx/07ajThSOj/c2QCTDCR9vDfV7J+ZdST7HHimIyUvnRcbnGOmtNU6id5PAzpRzXVQbav//hC3bhZ+9jIgpiwJ4Sika18q4pzxWV3/7w0fahK4/a9fQBcGTUARw6HE+W7YAOxcE+yQbHA3jZVAMIsBpB9aPT3ttVLT/LsQKoKuwzAE4DXIiXg1fHEgC0FMWV7hmC1TEMwDpPmIQ8XCQqAjsMcEVxtf5v0DSTm9FacvDuEldCrQt9lYaKgmnW14Niq63a1mzoQH4FwHh1FRRmuH8h8jHUvKgLLXgZ5qkiJjNktel0LHWqavy5FQ9Lg5TYcXlfpfu7eeaseDFYETXAEGCyryNByZY9F5pm8KpDbUMA3pvEK+fdF9jqTWm74vP3WFtnZNYcvtR8JmsPbVKZ8Pp4V++65DA7f4wm4w9fm5d3dPe9+OWVFXLT9qHLhd3QMFkqA0pDU0k+Vr5wVq9LKwKKrXYPLoHYOy5yMJuabNALeAVischJfgPzoBE4yMppmYzIp45ejjLCTURQXsnGbirKgpjsbgMOtRvpmycQFRDrmi621u0DtnZNrzVtpcY4d3V1tlhfLOnzhCfU4lZZ1s6AUWTFGP7jJdiPCW6nAUh/0kyrDhMqpjKaa0VEmbZ4Fthq506c49AAptxqvNyuFG2H1xTtOaJHqvoBfDxSfu2pihccPQE7eaQD2VPu4c9rDIgjOvXnVdiln/6TtbYF7iw3t9qzHSWWiEGKPhWx5sojZZYcdW66d5Pd9ucXcy87oLZHHcC54A1POtjtfFdgVdJRP8MBdWgtW+KdXh1ZZJbjkv1cewtVVTQMUVmFe1EoF8my8l8O2l0omkxGXFNSWuxsszTLnnhCRe/QqC7iJlnUKXE4u9O3g0iA0j9vs6ezzzZubLNlL7ZY8zYcN7ivVjqMJaDPiQ48uvKtvKrLwVtSUorCqtc6+5u9TipEUwE120o3LmIR8anVs3mm4GOdTIeVHgRbv6GjUjemkmxHEUdUQeXwh/PfQ/9LA3b01HvztCIQzVDfTa199uavPe66h9zy1NLqF87d6Df3JNt9hBSKIUr9n++vsRt+9cSQswfGbqQdGb3auPY4UJRdWoS7CB9RCppmlE4AVtEaBVmnwjSdMop9lolIJhtwyy/yL2AX4DXxQElT7XgD7qGlTi65V3ZejfbSRDOI+ktSHtlTI1OIX5z9imRQL4/69SFzb29ss3Xrm2z1qhZcKJMEfw82x6pKlFXVRKmMNSH/phhI4s7G58NOd/RtpYh+2Dd5Wak2aKDxgdZOEZ5ZiiPd3t3EICKWX6alUAEBXZm8C2UpsMOYOoNkb8aoc/lxgTw6EIoY1W9NmexGYdjFR6kMcUT3i27p1earc5jz2UfyZx56Xu9Ek/H8ne2mxinuvx1PJ28f2qAMRWTuvTuJphKlPLib6rhMeepz0dGdf4sY7Fev77S7Ht+M88W0nU7qEvUvgV3b0X2iTJpOWk/5//jrbVgZltsVr9n3Exaiugz3O+oAjka03JsJIKKU3kRqoZyGxs2XUY5VATEjSeaU3JGnebUwsGKfBVa4ZgevFFiScVWEx3JmS+f6Ab8odDlhTsQuy76bwMFDXluaalhYjdCra+gMui4XsDqe++K7cQ5ZvWKdNW7r4iNfa8WKpo5Q9Lr6hFXV47BRuJFJF0x8QBFVW13LJAZicSH3yqQkmbeoUOFmxQFgj8aE5NwCHY2nIJrDBJxEkJEZ2QV2NYZs50rhm6cTcNkLNIGjDuQog84r99ili06eYtMnl9nvntziN7nk+BCEXGytUoZBVel3TzJg0XiXnLDjvEAny4DS7zmv935p9ryb79ifP73Mzw/3pXdUz6oQZyycgLhBC5H/shMmo00O9xa7+5vHNmeVV7xruLD8tmb74/NtNrU24e94aLlqPtX5X29e4gBOIW7Fs6tDFMKRnTUjbnctTbK4+9Ars/sUUEEXuv77yxCDknb2onmshbVn7fYIpY3q4TGJidWebISlhUVEiym7p2Q9ByLavjADCY0tx7VAmGTeDtYiauxkYe1ErS8uFiPm1aSyw60kj8DofYWssJAPkDRxvx9FUpKJA9hXeZ812Hk9YiSa6E5srvV1lf6iJzFZQb7OikzpHWJSuftCC0jF+EHL/qsUgBxGbrHn27Zssw1rtxEkDzvvdvytedEKAZvAVjhhEi6WROCwwh7b0Pw8oONZrNuDvReVEp2SkTrIeLBtHdsI3F3DNDRcLru1ckORVVdMoNOJ5WdCROc2ru61w6qPcgcWuV2KakexvmTC0b4HMmDesWToQo9IgjzPbzTFclR7wkFcGBi3R55bb2/67yVMQuGdD5rddn6oTW3ddv/nF9nCebt6UV33L/faAys1pXWk0VHkh/WwUsX2tTdOtLddtnDnwvfTXujJo3xzBWLbfVIjqUGCnKpAbx24ICqYXL5fyzlGTAc9o7mUUwKH7Kca3WUvDp04HHf5F7YyRuM7hc3evJTJCRp9FbFDZEuU1D+8cBEJjzPFdiezj555erFtWNNsbc0F1tzIaoQoNcq4/jDcMI89frI1zK7ErlxkHayDVMxkidIyAnknemxz5wpnh0UtZaIS5ZUJqriwAqePJJP/8c9OVFFf5HkGKx6apy7gWK23garqFFgVDf8cEQciaTm8HrVWblLW8bSjBdQepx5zmN32saOtm3hnQzmsKGctbpL/9Yvl0e5Ov9/7xJl23MxixALe0bBJb5iBPN5nn7x1nf3mgRXD5trXB8cEwNIoD5/U86LeF+QO79B0bv22dm1laZJKv1QMZNDYCmwCqgANsBluxUZLW+tMJm8vk5FDIwUAoDiycZv4W5IcNWRq0pTDTtzgMlBZydQasfWVTqVs8eIXbeXS9dbbRSieDT3El+6y8oqEzZpbb8eeOM3mHzXBygCuph0OyEebiOzFJTFjPhIcBA4cZdXE/oXV5Bkk04vKF7JdzCTwIlY3zIeS+sSMLBj1+Kp3GfLwIEC5TtUXt6ARR38hscW+2HJ5nmg7nInOZ7ON/3gLHLdgsn39XUewvKcG7F2TomTc/nw7J5C7hqRiZqv9FBCfMbuEoBL0HYjJSKkUQvHeG5bbD297cqQs++z4mABYU+VEjbxX5jyKul3UAb2bqkOqg0KxykqrCIWjtXjR2pJLWmDJO5o77NPwALCA5wAOCAwAkNKHQjVZX/eL4bghsDo7y6kwdZBFytBG+iwlZOU+PH0atzXZC89DPQmH04zVZ9uWTmTohB1+xEQ78uiJ/E6y6jqWUkGBIvlX6xc1da6yvDgrRhC0ThTSFVOKt4U4kErhYM8I7fZj2F4tDh4bwBMslvDnUx09Uad+gB/LT/CJ1scB0rSDHiSANJs5Opa91B9UbTa4P74xtAUuWTTLTpyuaKBDz6h3IEKhG9m0RSDeNSUSgPifz7Xz5xPEoW8kIgS46a9ViGEf/0Wj3Xr3kl0L2odHxgTA6mhii73D5TxMbsfzjkpnVKOKwpTFK9HmVlhj2zqrZ+V7gVcss7TOUWgad3xQqVynWSRuM0X+5YC/MJmYxHprP42zhcve5CvFLhzn5bQR/6apsdOWLVtjnfgyJzuLbP3aDmTpEjv+pBl2+II65gxX28TJNdhzkTcZscN8Ycob6LB0TGsidSOHwgTzfAUAMM5gVVpWaV1Joojwh7TqYWDzCG9r/cw7Jvi3NMkafdSnfOyhfkUFpdiqg6ghXkTJBzXK0K5TXW2Q16lv9niAb8jvF41/7dQCUmJec+ZklngN4tlOJ1GOFsJFPY2Dx+7Sp97M+sXHllkLrrlq/mET+p264l77f368ym67b+mwWfbFwTECMHIeChulQFnCrzpwgGxERcQeipbJ9zjB9Lwu5EkBT9RUrLGM7HJbDCyPD6p8yX1O84HVuqLIKkMeVwK8/KTLKouZK6xrA2DENit0jqTNjesbrZvJ+qmeAZsypdJOOnW6TWkoYyJ/3OonVhNqpxTgagBCDy4Ag7Huvkb8bDdwvWRcATcEYy+E0sYQF0RlfW0kaZoZPzwGNNQ3j4gNcSi0WGtf44gSNDNJoYJKWXrFFxhXmRzX80ZtJfCqVbSvgD9Bs+85snn9gvGvYVpA/aGaAVvmw10SgR+SmIyyOsxdTkcHZk+rtMtPn25nszrFduKvDZdUvAbscrTZ7/reKvvuLx8fLtuYHxOZHJMkTSpGP0/0w0B5wp66KltRh9Wv2NEEeaScQuMMNSthAe1O/ImLkP0GWMJEE/qzl7miSuRMbHMYFEJZkj9lTlK+bdt6rIwJ/Iq2oTVMlLcScBbHebmyGfJXXMoLUIQOFrRW0suPPsqBbw6a6A4UG034LrdTrKhjGDBESd1fl4XLCpm4UMzKhUk8rWCwcJuMU189E84d/IlaB9snM5mSHXgIsbpENui7g3VQvs22CQ0Wjoe2UVfx9vL7j9mYqyY4JFIbK3To/QxNA7izlvGu9pRK8JM/54SpfKbYVV940J5ag7NOPgpW3tPQlMeSQPWJfvu/tzVZPXbi1581d2iWMd0fs94QyXd0QR5An9AFtakIMWEvUsxAQaFqZSXVHoK1uW1zoKYK9g6ANMe2V84evBSVJ6CqRAVxl6wtMPoLo2AHJxRX7PT27V3kkRyNvhskS3stl8sSFFt19RU4yxPGh2DtGby4GDe4FhaY4blA2mzeVe9A0pZufNgXWhOIRHkVbM814LDR0ixrvV+ZeypKCOje08bKhZUs84J9OqNz2CWpUyxPcbIgzXzLgaOkuMIHLbHiKkuUVk+kX21xJ7ZFe3WMiuk4D6xn1rHxNHILqA2/c89a3pnae+ektm2Xb8CImuad86u1b/z4KXbMtEJrYm643sHQcSG8uRjrJA3Y+7ET//TOxUMLGdP9MQNwIRR41xHLu6SLrqHTqm9613UqVVWK07+DAqUTYFBrackVLTOq6XeyvYo1UqQKfbTsSVgjFM41q/RyyojSSdMItze1e9hYgVZmoQHYp06UWZr0n8S0JG8uhdbZzsT1zlZMRwB50DUTG/WaLU/bhJqZVEMOGgFsHmA+CzBtFwLo4nzCyCL9FudX4yeNCpMVDFHL8WwRCAU6ICwbFpslcQID6BA7orQaHBTMPXQGtsPJ0DbZbc8zuK1rx9NwLfCD3zxpq5olTg2Fmvoa8dTQPVx+8tThLh32mIIf3va5c+3iBeWs24VVg3Wwdi0Zboz3WUmf++BPNtr/3v70sGWNxcExA7A6p1jFnRIPKROKeq930ix4BWLg4bJkeUkVcmWceMsEdoeyydkjyVzhrnQL8oscJ9wZz0PAJpGRVaIzu4DDZWZ/cQNWWVPi1LcFm4AWmtKSox1op9tbe6yZYy2Yi9qg0N0shqa6tLCdIk9wbO+yJWv/RCysckAn+TuwzbIx+5/XO1DgQpwwCqCwMSvBNFRPyB+Yb5xP+nsJMqB8gNg5BNUSzXQhMrPMbHpm/TnIKTds8w1HsYN9VjuFQYCc/rdTe47v7NQCf3xitX34h8tsMrHLhkuaBHPV0SNrl4e7Jjp2wydeY2cdHkcXQnif4fjzbMaJLID3qVs32u0ProwuHdPfMQQwyhyWHHEWUKAl6VsROAKlCR3SlTve0aVcYBI+bLR8o3W2vZOJAXR8rVKYYuWGrnQbv1A4HaXmKSZwpxUsThSZYz3MAxZbncZOLOcPTehvBphp2OnOzm7btHE70SQ7bBshWbZsbrMtW9sxJ3VYC6FhZCtuBtSt7Y32wro/W331TBRjca5l7V/9CXC6aXbwkaksprWO8NdmPpIV9JVYRxfLsbAQeB5B8RS5g8s8+Y+4CcLolCbKWSK1GjlZA0CgwFrEzIcwgVVt4RQ+gFuFaICJ6hBKHP8e2gJf+skT9t5vLiH+VqVzakPPa3874tIn3nT0cKf2eEz+Bd/+2Gl22uyYbR1BxlYhos7l+I6/93tL7ce3j/0EiDFTYulhZN8VSyzWNyR1RrakkMp2TFEeX9yLzqs40Aplk2KB7D600XKUyAOIqJtcDs5IhpVduI/g6eRNMxK2wkaXFaEwA8SdAChBaBuZoDUyFdCQIsjd+DPLN1p+zWkCAfisJpw/Ej2KooELoyZGoKEc6MxYPXLu1PoFTnnFvmt1Rcm6qoUSt/HqBy8xbL2AN49lSls7GtFs63wx4GVCBURAc1I1Ed6nSFLXHhY8qy6fGrTPNIS4ET2/s89U2vcEYiiygrX5OZpK4A0N51U4pL9E3P7wl9X21IrNvEf1kwCK3IcORxnGYY6eWdlld65sow+UOHBC7ijHjqs0QeI1R1Xb4dOZvP0KUwmmyJv+6bV21WfusSfXs0JlNONtp/KkzzFk4gL7yK1NiGkv2DUXLNgpx2jujC2A6YRiGTNQUFERaXiDLEfXdUqsrhkojTq6WEflL6kirCtRIfOcLWbyAhpA4AhwmEqIh0xSk+KNgOt8mtsJa0NUwgzIShHuJoFjhnxWM8ihclQXhW5q7LW6SSw3KruSNNXYltuIJ51kgOhg3aIC1vstZxpiAtfJviTulyzqPTBAZEvqmy9nC4E2+wccg5snRTHcMBjg+7x9M4MELHxKcaYLASqTKaqCaUvTmDyEjiY1MBDUsfpi4ErCa/SpjlllVuTnLLaZh/Z8EeUVtX51JIIc0je+dldL4FR5bKx6GsVC4l3Q5J50qITJ+FPKCNHrR7InwunB7yC29ds/EGZnNNKHr5hvt/1lvf300UargWB4tx5SsPrghOJ8++hNq9HHFI6ZdnpMAaxnKkVhozjIMqMIxKIzQb/AlmRKqJeAOyDZDzW/Xpa0vaWJSmy9UkJJ+6cZPVA6/aEtEFvdPwAAkU/zcJboQLkQp4w+jOsdrH0UoxDl6YPlLa8uYiJ+l23ZAuWmpdPyRyZJydFL2YWYqIqhwN3EtZLdF7donD4AMaaBtFwvKUNAVicIy7ZoKMHTDJD1YCNsatkO5dc6TSi0iKzZ000ngjQU48Yp0Im1l4yeIvJmeWmdx4tWG6gtJF87aw4dD9pozlBusPvKNZPG4BP6bvj2yh/iX+JeqgmMIF91PXWWEA8+deg/7Kp5+BketlF2zVjLszMOL/dVA6Oje/O7CE+9CiawbCZs7r0rmJEGF6c65L4h9XQlsdPvuWEFolubvfuqE/3YaH6Fu4xmiUPKElWJ07F3PJ4eM3RgyY/qpC73AUABWRE21IHLmM0TL0o4FZUZKJlkOhJg8CVCqbVKKcCmlxxgEe+uLgPOTCvE55lpS934OKc8/CxB5ACTIkNqASqx1oroIUWVIOnlwlZ3AUSx2Z0osbrZbm5GI52E9WdVw3wUUvKoyoNtB+pQXZYShUXu6GD2UlMb0Sm7WZVBMjeOKD1ouTvgJMgpLbjblLETaoiWAquWqBwyr0XPq7cuM5Szy6LCTonVHgKxYO5MtOfncV9VSR1TwB0KXjVCdFx5ckGjc7lJg66mGGZiafvRp17Dqd3lzr1y99uK9DGVWNU3f/YcBgZxYbxvlgIYLqmudcwn/gfsxL/88zLPEjjR4XK//GNqgzFPxYUyqahjhltJMhz8U2flL0QhFKAlt7IUCiskVJbXQE3lBMGFUKtMKkwjlMgrQTTGVD/FYk4hL7exTlJfAf7OULrG9jZsfUwHRHmV5LeoRA4eGdZQkpAKHilLbK2v1cRvkqVa2pi0396Z5Ddl7W0MClsZErrInIbyZxiAMnHLdEOh21B2MZ1x65Y2V5C1AeT+vnJ8oWMMBFr6FP9rZKV+lnrJJ2IltBfKj8mK56kra3CQ6hlVEZmVnG12t0y1gsAs8IqF5t5kCzwL26+i5IHq9KJeYdLgrJlfU2rjdvK8KlvytfNfYUkjXzYxG0z+Rx8/006ZVWhbuzWldIT8nKhmzvgHf7jUbvnjC7a1XY4mu+cbRihpl8P7BMBFmu8KW6weGVFcvR/fZkMdOrCNoRNLaSQ7cklxWQioDiXuQy4VCNPpbpwtKAlWWnJ0kVZPgHXulq2XhipAJtJ6SK1d7US/6LAuNEuaVF9UUoBSTIAKM3l7AY8+2pdCSoqtFuaLbmvqJGwsPtOAtGkrqw42snAZayE1buMcKwLos2Vzq+dpw5bc2xt35VUX4XeSyMGiouXMOS6RCzSydaqvk4DgTVZX0YB4oNjDoQ3E+Inyut2bttEz+3TErDzsbSL2XWzDqyzd9XyjT8AfCQ97ag4ttN7CWlWTiFD5hesWMKC+MtPRnu6j82Ww0jei2Dp3XpG1wOWNlPSuK/E5eP9NG+zOPz/nfX+kvC/n+JjLwKqMgFpBZMbm7k3Ovga6Iu2zzirCBsClsw7wkANQI0iurnJn/5IEoV0r5ONMTljpVJq1hwBsfj4+xvAn0vgVouRKAXABqgzFgbQcWjNYxSuAQEa+zWiE+7RyAh468riS22aUoo7Sj/mpAyCLBY93wTBTFrHqqBcsN1RbbLBYdK16mMI7jLu7c4imN4qiF8ItlALeijJMTCwjSkkMGoSeBbj1FTMHwSvuw2UmDTgOXnEhknkD9XWQkyca4KJ6vlp+pWRkrGVQC1QqUOQdT983KATrGAMhg5zyy85byMBeVxOzf3/rSXbla+fsuGiMt37wqbPt6i/eZ8+vS+LcE94v3WyXJDvx3926xSqqV9iVLyMA/S4FZQ/sEwDrXmIh9Um6HRd4Qj2V5Gqol6DO6y4PgFFTCWkD2GOtdM4qCQnkjIoC27o9hLbpxlda0R4Z/7iUri9gItuihsJWLMUZsZeQZYmOg5GHVRlkc81n9YSyPOtohoozU4ixwu+jLhLkTUDIjvZZ/gYWnK02rfoAyKQUA4g9aKwV2hZaT6dhVGcE0lNIUSWTh55pQg0TIyqgrHACSWYuZVguZs7kk9EDyHmD59UXV4nqO3jhNOQ3rjoogJpMSkra1+fVmPqQKRtbidUcPb6aLDfpJSl5W9L+BMtfOC1hZ58+0c47YYadNKcKt9w9BZUIRYzWtybL3PzJM+w9X3nIfv14q8c9k5jnKaq/6s2gBC2w676y2D69ts0+9bYT9qoKYxJSZ6QaKe5VM6Fzgl1UgOEjJlYjrk+g1sgLpWNbM33y+mBPiYrfDWXtwHje3iFHiw4mBHQx2uKhheNGf7+AAXtNo2RYx7dPrChDXxzAGuacQpwxSphaptlKYlGF+27kVrWlJg/5XOOsPJIrl1AlTxlMTXIkkfZaeeWHrWiYgm6w1QJGXpDiPZVAsU86fopVYELKj3dbW3or7HW3LTjsLO4t6ioug2IZKeTfLYWW6hfC52iWk+ZRS8PNPairOJNXY9rS2GIt7SzRSlupuYaKizoeHSti5YVZ0yccUM20ePk67yeqlERDxXJTijHIS78TpR6cfeYzfbVYS3q8wrTPKLDqJxdCmZU6ktt5AXRPHk6zjFzeg3rqOcU2wRSxDTskFhkNslZXiMPLlsRhZYlPpdAmrDzmcztb8D3WigiomgMbLnCw1nAPgIkXSkHFOc3LxVQktlaUMlGGtrhNyidKAnSKXhl8Z0PjhjWPRKkFXDmUBLZb83fDMhxifRU1OijcxPIXwS3MnMtslzKASoTKVB/eXT3tUN9TuafMRAIkiVto2Mqnvr7Ui58TuHku3xZsNTx4bl3xqku1VeXMDdfstPA+KlhlIze1a01okrgZ9aEDLR02ud6rNLTeUT2j+o90Psr3Un73KYBVIQFYkxMUYFRiKHhyKixWOiwuBTjownp1QJGRTA4Z+FUz26OPVQ9k0xtAuaUZQAr2btiOO7q7kU3DwuCSo/uhzsZg0SMWHE6qh/10D97KLHKm0DgaMOK4tErpJOtUrAi4oNHWpIcw/1ia7RSKFFY4hNpqIXCHFVRWwCqE3dev6qhBR+x/w5wSm1xTjlcXDh0srSKb84SKWYQIUjwsckcdjeO6TguDB6UWTyvqDHh3yL6ivAdex6RS+yRpITp9Rkqj0fFHKns0ju+pfns6/3LqMHIrvZxSXkZemUhqS6bY9q6N6JqwzUKBoYt0XpRZkocH+60bA5w1hYBaP7ajPrHImFXlUOWOFc5hIjvjl1woExJATio+lpw1kD8NxVY3dlyBp4CJEN3EE5ZMXYQLnFhURgqf8NBFFMo8QuYoNnWGWU9hNQXAz0oLMus43+vZA+UVmJW0ZlMMQ/2cuaVEnYSFZoGzvjw4AqYhJpn3O33KUQBToNfzhUaSskvSfjQ1UWYkuZAGLkT59BlshHDR+Pd4C4zQAvscwKqHZhuVFddYW3ejs0m+upzTXbACheoHNB6VQ1pIZ6NhqdFAx3GPlKyLohiQAmaoZikyr9wyxJLGWVisCxNSVxKKi/13AMVTHjKswmpkyAdqGAA0x1iaSzynoNDgBQ4b90yoseTjGG5vcaJOKgVFm6gzrLxkX5Rh4uqUT/UsrYzZjAatgljAihCiosw17e/kXL8dMe1MroGq+oi0A5DCptwtna0WGy62mXwyoDnUVaHxNN4CL7EF9guAVTdFnxQ1au9pYo/OCyDwmXIKDMwgemxzTNSskGgdYqkUDK4PBwnJq6La6RTaYAAywOyfAWRireQgu2pxURxTDxMXmG7ocanJ7fN8udOAImEAfMnY4sDFwuejCCmpZINBoZ/ZRH1JhgS2JS8H2yxUH+pP8Q7mgnieTZrIJP5KqC76h1gsRXTKWuvpQ/sIxa0sYVlLQKqHiai1auwRR5ziSlmFTO6sc5Y9V05xBeNpvAVeRgvsNwCrc5fFa5xd7WI1+8hkIuWvNMAQPAedqKDMNJJd+2GJBXopmQbQVIuu+UwmtpSnB6eOtFhWscwMAGlY5XS6EIqtAYEcouj+Lxlb11ACg8QgbDifh7wNR+tAJSs5yKcbAeYiFGoVKMCqsTMyRlhR8QCUt5DlRcuZGdXl8nopQexqK6ZRtpdOASqFxH1UL02Z9AXXRHnhGgLrDHid8upG42m8BV56C+xHANO36dCVJcEE0MnqDKJWosQCiyYR5CMXC3FaMLsINlPRM5TcyZ2+LnAR7srLyScGs5JmLsmMVIBRX7ZfLcAtLbKCv8vhQsDiBpQRgCWYabKC0gAUUSKvSnYAUj8poIpQctVWx6CyUE22Eai5Rx9OGwpqh5aawaNIbDHXTahqUIkqxOulsgJ45XkF5YVtj8nU5QDOss6AV0A+2JK81+TqerAl+QzIx+BQSPu99dXVKxN1ToHcvKRWFZ4ATghkx4wd+nZmIA1YmEygOZjFQMQ7PeFeYYcVp1ca5AJcNgtxRtb6vb0MAsqrYHaiwFrwTJP9NYHBlWCA1m1yqgDbAcJAm+s0EUFeWJpbrEXEi2CZ9b6lqc5jUCgguHuCwGeFRQAXmTmB7J1gwkZ91bQsaDUG7QCkBguPpeXgDVMOHcCCvD/Hjrx6/P2dnnzySbvvz/cOPovq0zBzll1xxZUcY3lVJo/c+rObCRy4zau68Njj7IILLvT8CrL/i5/fahs3rLdTTl1kZ5z5Gs+z9MUX7ZZbbrZ3v+e9nu+Wm3/ix+UDUFdXb0cfs9COPvronQYEAe1nXLN58yY7k3JOOvkUv0ZfS5e+aL/65S98lQwXc6hYCpPh/PkLPO+PfvRDziX8fsrfjYLzD7+/w1avXg1B6Ld5Ryywyy+/XKc83XrrLbZ86VK78g1Xexk62NLcbF/+0n/Y333yUwSD2GS/+91vGMyJb8b7VN0mTJhgb/ubd/j1++trvwNYD65OXAGI5ffb0YONGCURKiqnfv1M9/O4V2KB0VrLrKOzSKWATdpc2GhMRbE09lxWy5O9Nw6IU9hw5XLX6zJzoLwyW8kGK08vp8BZ8LpfdRbw+diK1Un9I1yx7V5W0pIDXk1Q0FRBBy9yeQlhYxPI6HWVU6mLWPMwFHjRKkTghXsIkxbkcRUUWOI2xIEciHbMYMYptKqqahpgwGpqa23ixMneJgLCjT/+XxcX5hx+uLflC4ufZzWMVrv6jW+irfAoo12KiP5ZiG5BIFdH17HS0hIHj6h2IfY9cSoVFRWIISV21x//YM8++4y96U3XOCjVNhpIdJ3yrFmz2k486WRvMyrl72/y5CnUI5/yJ1pTUxNTRjdzD/Qh/Gm95tNOP11ZGbgzPngkcao5iTI0ILQ0N9n3vvttu/Sy15nKUV8qTiTsnrvvssMPn+fXqT8W40ctaq1XqTSXZ27evp3BPUGbhEXdwpn9831AADh69HJk4mIoWWP7GpCGzMsJrYgwADsNDpBFgR8scgy7rLO+WupEE+YJVieHjwwzPjS1qxh7sSYwKKKG7LH0MvLrpVMs2xqBI6DpmExYoXy4YyFWuNNkCdVAcjFTApWnDxm7hBdnTGOMx4sZdGpxFokh86oDgHbldYFZLLjv6q6Al6mIdBBRXf8dBG92hCDXgZZEYY497jirra2jg08erN5jjz1KtM/tdv37P+jgUcdftmyZA3DTpk3E2p5Cc/cD+jqWrXnOdRwCsFIktoQdFJlMxD/3vPNs0qTJrE31lINHVPXNb7mW9ibKSUszbq0ZW3TaGfbAA/dZe3s7oYHD0jsNDTMDgHhx1TU19s1v/I+D9vQzzmQ2GQERs/fTulePP/44gN1ur3vdFQ7AVgablSuW24MPPoC5MKKH7AAAH0pJREFUD0cfTywjSj2bGhvtkUcesYULj/GjWdx6/1Des88+B2qOExF9sLLylUf3yN50r3/Ugw6opIgck6rmWjlhWqVRRprlZQZqJTBAh1FGZWhAPLRgi+WDKqKs3+Ji1uDFbbIQ22wCU1AZ8aeKGYlFUeRKqYn+Yqvj5JVCSmWEX8nX8twKZUmBLDbZPwWAl08hsm+ZLx4ORSqr85UUK4nfJcrr4PVWzMqydD51QNVbbpJu66VQd5X05xHlPXDBq0dR/cUqC7y5wHsOKjl79lwHUkVFJZ5nZXYcQBfgVwAKJQ1eapP5C45k6iUO7NkUtPChy1G8UzFRP91rztzDndIrfyoLqkbAVFtXC0U83AHYlgWmitMCc9XV1Q7eO+74LV5vPbDOZ/FO4XAkZpEef/wxYoOX25Ilix1sEyZO9ONVVVV2woknAd6kPffcM35M9a+HlZ837wjbvGkDlFxrjepJNPCIlGggD3DWoFZeXrFTu3jG/fB1QFHg6Pnl7FGVmGgJFgBr7d4KNWWyvlRFNKT3ezTRInTuk0yjStnVC6WWa6KURAWah4usW4DdOEZwdXlUKbSO5ogGl8lgc5UpyV8OZWlo0PvRTCcOepmUQkekoyH3xJgaWAzVLWUJGAWHryyp41hgrcKLDS/XXzS0W8d8uiAAlq+2HEJE0wXqwDZH+aOnPoB+nSvJQ15cReCCEE1l+vQZyI1HuCyZYJW/qDOr1toWKMTGCrh6zu7OTmTaY+zb3/qGXXjhxeHhAh58W4OCuJ4oaSAQ2ysWvaOzw1lwsc3iAgTKuvoJLvdOnz49usR/N27YYMuXLbUqwHz4vMD6DmbI3kAsdCnlx3lvuUl19TDA2YOisBdeeJF961tfd2rPk3m/0K+Srr/3nrt9WwOG5PYjaJP9mQ44CpzbGIrkMaF8utUSCE7LkWjOrAOEhhfgmEQI9cXJAuopaixfZ8nAhWiri1z5BIVFASWWuhyH8fKSMqfIiKSM0hoAABNUeQCNMqE3GBQ0txjvKrluxpkFVQJQWTS8sqwcSjsJ0DLiY++tZpHuQjzDpO32DksHFvgFTO1LFtYMI3mI5TvlDQ4doroHOuX19tez8AxJOmlrS4ttRY4VsALoAuokhkRJ2mhhJSPnmSxoJD8KlBOheg899KCD0Bspe5FAnzsIhMMBKJI5H330YahcuU2dMtVPHX3UMfbsMzvHW1YdHn/iMa/rwoXHOUVXZi+F8qOJA34vjg69n+4jyhueJYA1Dhd3GIOE5HpReQexP1O4XkrRMqhvKX0iUGav3n77OiApcG5ryM+4hLV2iyvLmLTfyoc4WYRndcUSZDhNgDuxqALxAH7S6leSy0SBJRv3Mbnb1xR223FgmwdY+kQzouQyKduwKLEGBvRYDmhpm4vgy32hbVF1jieIepjAxit23GN5cUwdZUAdURWmA0edMpiIADjssuiRkgOdvYMlqVMvWHCUnXzKDs2v6h6HG9GyrLlJoO3oaIe1njMI4Oj8XBRCDz5wvzU0NOwCoCiPfkUltaKjkpRni59/joE0ZpK5VX4b8q/Atm7tOps+I1DhxsZtyLIrXMl1wgm7TssLy9kwUDtQceohIEQuFdb8bimj9G70AnUfvcNjGQx++9vf2DELj/X6hC8Fiuixiy66OAvsnFP7cfOAB3DUNqJcZfFqPLiq8a5KEUKn0Vnr/Ow0Pzl45AO6AgArRVKMbb0gAVl2Y9mVRbVDYDoBVtps0A6+pNLivYEyHEYYDMTmhnMEtCU4fRkLdPukcjL5Kf2SQy9dW75NJ1AdXUkFp6CBR8fD6B/YSr/kIPkSgNVeQ9PMWbNc1o0orc6vW7cWcPTa7Dk7ABydPxnTz4P332dPoVHOpYA6H+VRGRs3bghKKuTqtrZWVy7V1NZ4Hq3rLO2yKPKDDz1g1854qy6x395+u5f5pje/xfejL4rm1SBCAVyl6dMbbNWqFcQG78zKtmYbYL31nqW4UvJr+FUdp07Dkw62/eGH/+q/ufX2zAfQ10ED4NBmgAVUaB5tbdnULBXVWjedfNp9+h9Sst6CK8C0fq86ooAc2CReFGw2r3YHuMguTbXkY75d6ZRgEkMhE/Z9up8Qy3+guqFLC5ghAVpKUp3y3DzEXlbWFTvtf474KP/B8xsGnl3re9bZr7Xly5fZTTf+GBvo2wkt1AiQfuOmmKlTpw6CMur0+j1l0en2GCxx9A5Uqo5r0G1tabUlLy6xvwBMpbdc+1Y3J6UwBZ5xxmsA33QvU9f+5KYbCW/EYs6kZ555BtNVi2uVO9pYGqddPujyjGNRdVFUtT8fpQsuvNC++p/PYce9w6699jr3k//dHbc79V2w4EjPk/slqnwE9mRxARoEooFG3NfmzZtRkIbpjSp/4qSgGMu9fl9uH2QADk2jhtMgG2byIPMSBracyRH9ADVF0IAMC4hpGU84Ll4A7DWf8BIEwPBSNeJqS2VpJPZpi+7aGBRTDlqZhcgUlE66IIAy0N2oLjIPifqqKYNdV7m0HXWgkPPg+VZ7idWcPmOGa2qDLBjqL2XVhbCRjz36qD2EGUYRROSI8ZqzzsYvvMQpsTq97LwyyUh5tGjRIpdf84kaKht8vlsE8GyD2i5d9qJrgmfNmm3nnX+BU7xy5MsZDTMHwaN2VJkTJk5wVr0ZB4sK3FdnwbJXwm7f+vNbmFrKMrSA/Mgjj7Jzzj3PJmIbXphlgaUcu/bat9kfsTV/7atfwT58Bsqx412LrTorFaHTKJQ5gyR2Xg4hS15YDLtMUEPuL+WozEZ3/PZ2zFqn06cK7E9/usc+8tGP+zX762ufRuQYi4eMtMgqWyAd/MhZQ8fECrIRjnsu39YWR519DmBjF8AKewHY/IqT9j0pbHQ0JF4nuwJroLiiwjrPIb51TPl25A9XHTzfmsnVg9ODzCwyp0gZNTR1sQrGE5hppKw6+WRCBuVoeKW5Fpg0sIn11a+OSYZVWQJEBzLtuvXrvFiBN/ce8paS0mwi7K3Y5mh2mOol05ZkY3ldye6sd9jQMNPvoXtGrp2LUUJNm3YYNuZJfj/dSNfLRvwiFH8K3ILuG9VT5UqvkkDZqb6i466BZ1vmKokIYsFV95UrV/jvzJmzXPvuD5Hzpbop5bZJzmmvh9okqmvuuZe7fcADWCAMUNixNfQh1eB6kQ5AfnyPY9FxNx358XDSwez5Q95BqGkjuyNttNuqfF8019HsL04UO9DiHVRWLzbKM7R+B9u+Oq+okJ4pSpIJta+20zn9RudzO6M00dL+5nZedWjlVRmiwBmUSdoXZYySwBXliY7pPpH2u6ys1PUa0bncX+VTnVWeyojqqDw6pvMaPHROSb+5dda9BU4lDThR3fsArdbfErjlDRaVr/xKufXXvkCeex/VQyDVvTQYiouI2s1DM8Hp7G3a+xKGqYEq2dHOsqDEsVLlyyuLcUkLHWCY7CMe2raZUXpNkz392Fp7y7sWwY6FebpDLwgvRi9OlFIvKOTY8cIERj4kda5Am0MePyywZpOu1Z4X4SQ4nAvmH5Ud6K2yC7L+Hd1QBw+B9Czy5d13/9E7nB5H4DgcBwdpYAWGH3z/Bihg0t+twClqJieKhoYGu+N3v7NlULiPfOzjgx1cLouyDLz9He+0rVu32o34KZcAlI9//JPZhjb78Y/+F7Z5hp133gXegk/jmfXgAw9wP8QhgCFKLHuylGhD022//pXJZvw3b3+Hu1UuWbLEbvv1L91ufdVVV9udd/7B5ICiPqD3r0FmEWy0bL6LFy+2P917FwAO3lXtxFz73Oe/YNth0+/8/R1ovdfCASSgmil7w9VvtDlz5tqNN/7IOYDrr//AYFXURqrHqlUrBwc44eDUUxc5y/6l//g3fwZ1rjTPJEXZBRdcjJktKNEGC3qZG6MO4FXLt9o3vnSPbduCA4A7XgTt7ImnzrB3fuBMolbgBBDgsduqaiT75PU/JQ8gATRveOvJAHi3lzi4lMNHOW0ATNrQR9wI1ZrtFCCpDAGsYSvsDVc3h2kEUjTa2hSQD9UkSiEqpMkIJ5xwons0yYHhiHnz3YQjmbgG90W5PK5evcqVWI888ldXOIkqyX9Y7yBKUgq5kw2DeTgvudJwWXyYe5zqeYuwu8s9VWkZjhkyPU2dOs1ed/kVznLK2+rnP/+ZfeCDH3ZZOypbv6pPMAcFrbMmLUguF3iVdE4DgPye63EI0cAubkBmIU3aKC4usff97QcG2WRdc89dd7LqRiuTG97oz6WByzkInkuB9MRJDE16NuV5+zve5SKBQC1/Ak20kZeg2lL+3HJ4uf03twH4X9h733f90GJe1v6oAVhs6ne+eo8tf3GrveG6E23qYTWu/Nmyqc3u/M1z9vjDa23pki32+jefYOdevKvmb2it1Yk+/I8X2v/8292MmkPP7n4/osiCpzpK6EyhEAFPki8QHFKIzgNK/eScCpt8U5Bvq8BDPWUfUTNv9B6OQ+HzR6iYKEeUJPuqnWfNmu2UOM3qFhp0Q9p9G2lwOPLIo+3pp5+kQ5/k1+u6qGmXL1vubOsll1zmLKjY0DPOOAMXx40oju61Sy+9LHufHT/i9CTD3gR1VHrrddftOMmW+oAUVrmytthmfeYvaHDgCXwCu1I34FaZckTRseh47sDkGXO/eGydl4upABultIKa06/kwy8WXYNVRWWFTwCJ8rzS31EhI1qy86tfuMOee2qDfeyfLrLTzppnM2bV22Ez6+yk02fbxz59sR0+v55lSVL20+8/YoufXk99A6B2V/Fqlq+I2ODd5Rv5nDqSKKY6m7TLGqF1TI+t4wJl9ld5om3OS54NC47punAuXMulr4Ik6iFFlvyRfwf1q6uvtxlopXMHQzWD2NUeFE51dXUOgui9esyxbDvtADYtSJvLEeQ1Z53ldt/169f7sZBVpqV+FgJrdKoqr6goSZmmz4as4is6PvhLuQ/cfz+zn7ZiNroIsJYOnopAt2nTZlsLS7x6zRqnvhpIJk2ebCuWL3WRQfJ2lET9BW5pnZcvDz7eOud9hoFCZsXc5P0026XFleg++nR1BcWXTunZJA4sgW3fjAJOvuJ7m0aFAj/+8CrAuwk29ySbOqNmlzqVsGznRwD2pz/6K2va1mlf+dzv7cvfudZq6vfAE+9S0t4fiEA7WFLue8jdHszw6twQ5X0UFlemInX0Sy59nVMvsZ0yqTThBfWfX/mSN86ZZ70WWe/UnRoqcmPUQe/c2bMCk+sh+BX7rMkEDQ0NPngqi873EgpJYM1Noq76iJUdLmlQkEOJuIajjjp6pyy6v8Dz5z/d4+VLg34Nzh+aJKE5zjf/9CZsvs8zI+ppB798uM8//wKnwE89+YTPI37s0Tp74xuvcRdanojyd+4s0SAhKi4bs+6nNrzsdZe7NlzU/MknHsf89oi35+Xcd/78+TvV85XsjAqA77r9BX+g2YcrHu7ODxZVqoSZPGddMM9+ceMTvMA8e/jBFXbJlbmuamZSWq1Z1YjGLmMzZjIQ7IFIb17fjNKAwHhwxJMmV9rMufWDihfdd8vGVtY2Yo2cqZVWW89iRdmUIpbW1g0tvqDZ0ccdFh3232efWGtHnzDdmli8bMVSFmhm4v4xxx8GdQnylTK1sW7S0hc3EwivFztkAu4CNotBamjq6kzZyqVb7KhjD7PN1GX1yibql2+z5tTZxCm7TkVTwIFVS7dBRdpd/Jgxq9amzagdWuw+2RfVvBgWVp1w48aNsKb/i5PF2wIVRqaR/XXO7NlOgR/+60PYXBdm2UzxMfQCQCNtrUAVdW5VXB1ZSceOO+4E++lPbnTAquP7guhcp+mHMhGJ8s2dOzebP3QHXbdhw3oHhZ/IliU5+Ij5RwKSx+znt/7M5V0d0+ymAKaYXXLJRbCule5Cq4kpSpqe+L6/fT/s/NP2yMN/sd/j7KF5zA0NDXYu9mTZku+55y4PUPAXnvMs7N0yb+VSay8o+6UB5vLXX8WEF6KfIhPLLTQadObOnWcNM2fZCy88j7PK0wcGgFubu2z1iiavvijt7tLFVxxrv731aTR4ffb8k+sHAazgdHf86in7423P27wFk2zazFq74+fPYOhHWcALG5pSBKz78XcegBXfbKez/s2Lz/Oy6fiHL5hoH/rU+VxXYl/6zO22+NnNXJpn7/vo2bD1AcBbN7fY31//M6RgdbMB+99fv8/vsWLJZvvBNx+wjevb7V+/eqX9+2fuYKaKzBMD9kaWv7j0DcfjHNJP/Z+wO6nnCYsakM8K7KlH1+EFlLS3vmeRnX3BfKiTAsX3IfOvsp9+7xEfABaesN42b2i1htkT7IlHVtvWTR127qXznWNJJIIpZd3qbfY//36vtWzvstPPnuud7offeMBOPr3B3n79a5CbgpPB0LYYy32BV44bswHq8889S8dbnGWjZW9liU3srIVQvIcevN8pmORZgUU+5hHVU/20rcF46LtUXsmlf0KRJNCIMge5c5J7e3GBX6Pr3S4N9dckejlXDE0acDSISDu+Yf0GPuuzbpJ6z6oDYOVZNDhEJp3cMo499ljeW8b++peHnE2fOnWKs/ESDd70pjfb1//nv93dM/ea4bZVjxpA65NhUJwpaSDTs1dVVeJfPp8BeotJdJDmvKFh5nDFvORjey0Dr1zeOHizXFln8GDOhibdzzkiRDFYsazRX7ZO3/LDv9hvbnna3va3p9uH/+9FdvV1J9tnv/x6n7vrNtycMnSPz3/yV/bQn1baP37xdXb12062T37uEps2vdKWv7DNbrv5cX9Z7/7w2VAxwVefHYPAxMnV9u6PnMMx/nRSid/Fz2yyTYBXDfLTH/7VPvUvr7PzLjnCT/8ewKoeXwHUqueH/+ECe/eHX2vveP9r7DNfvsIqq4vtxu/+1b6FEk8vqhdKevP3H0VJ0WPbERmKWafno/98sb3xb062z3zp9XbUwil2929fsO997U+UH+r2sx8+Zo1bO+z9nzjX3oG2/p0fPIv7z7e/3LfK/vuLd6ov77vEvQQa+STXEo1DkwbktihbaEihVeXmGDp+7yClFdi7kB2laRXrLT9kTcSP7KsCrZLaSdRP83I182fLlk1+TOfkFaXBY926dV4PXbPkhSXUp83OOec8l7eVL0qqq9pH8qVY3wzRWH6NGUmDj+rviku9F86r/4jaa6BQHQRmHdc9NPNKSfOGgy99UMrJoUOiQ2X2+RVlREENlHSdKKzKUj9SXUqwWctMpnvpuExo+lUWJVH1ZLLHzWThyCv/3msWur2tZ/DuWhx792nA2c3Fz2xEkUHj8ECbYWXvu3sFJqK4LYR1lZyjlGAq3+uvPdGW/vPvdtJC/+W+5bZxXavJLFU/MYxwRUwXvPb/nAnVvcOeemyjve19ZjV15bhaEvQuvIOdqjWjQaFidiSB+cLLj7Ff3/KUw0mj57TpNXbR64+ztpYeO37RTHv68bW25PktlFti84+ZOnix7nPNOxfZN798jz3x13XOMmuQ+vR/XG4fe/ct/kLPu2SBUyxdpOc699Ij7dmnN0CN19mTj6yx40+ZaZMPq5K1zI44agq5wuByxrnz7Pe3vWDPwWmsWbENEWHvbIaDld7DhmYFiWo88vDDsJZPEQ9qox122HQ75eRTvFOq00sLrSQNsSblr2SygAB2+OGH++T873/vOza9YaZtw+4r85DiWQk0ssF24xgRJbks3n3XH91kEzlIyM2xsbEJ89WjTGXc4lE5FC5HrpZ19XXRpYO/uk52WoFJAHrtOee6mea73/m2x8TSOTlj/OoXP/c69MIhiJJfeeVV9p1vf8tNTLpu69YtaNVn2THHLLQbqL+W5amursEXYbUHDjju+BP9nrJ9txAt5Jvf+Dr7rISJTP0WTGqKHiLT6Q9u+J6wzBn6O/bzRYtOc7ux2k1A1sBSBsA1QLXSZlUMZK807TWA610RpaElz2XOo5H3vPYj1GjK9AAezddVvttvfdJloHxWNSjOspN+KeeURw07OHRx4rknpME2mwOrrSbincHC9thdtz/j4D/iyJfgXK4yhyStvxTSACx8UMTV1JXa9Z843w//8ieP+e/0GZLzw/OG/AabO9t+9K0HoTxpe/SBlXAZkzH+izUmH/caerc5R0yk3gq1Q9wnzGsC8FvffTrgYJ3jrqS1bsdTiSmNNXVl2E8JoMYKEJtgwfcVgOfMmWs1dFw9pdpeEwTkByyKKqpyObbZXDfASzDriCKJHRblvIrAcHL630zsqRNPPNHl1ch8I6eP6/7mHU4Fo/a79q1vc/CLIkfpvPPOt+OPP97dLUXhFG9L5Q+XzjjzTKfkAobSXKJ7XPNmAMV1Um4pDpYGCn/t2VcnZZco8dVXv8k2btrg11140UVuP9bOW5j0sGb1GoILtPv0wpmzGpDxw/01OSKDoi3qB/20icL6SLN+PLbewUTblUO1xX0o+J1s596fyXDOuec7FdaStHuT9u5q7jxn3kQ6GfNvCdn6PGak8y87euT6ZJ0glGE2CieNyNtZMFtIxudi8OFGLsBs/dpmP52C2j//1HoGgKds62aiP5wwxT71+Uts+qxdR+jdlTf0nN5v5HWVe27T+sBeaUK3jzw5J9Uxjjp2mj3yINp4uIs9pQQsdYEif8CwdwFYJbHa3/7aPbZ+TYvNmluHPD/Vlr6w0U1ZxNK0ZhYe31dJTg/6DJcEUE14z00CTgQeHRcwxF4PjZ6hc1LszGHaYW4Sm6tPbpKZphb5U589JQW1y00CyTQ8naJUjzKrHjPYcGkKsq4+Q5MGiwVHLhh62PenTt1Rdm4GXSMHkuGSKHtukn15NNJeA7i4pNAWHj/NnkSZ8+yTG23d6iabjv132ERHX7c6yA5HodlVGtTughzJjkVE1NhdKnN3yna745fPMnjU2YmnzbJTzpzDSLdzmJfdlSGQ7jYNJZlkLq8MihO5dkYjb24ZVdXhvOJsKflon5shZ9sjdxA0T9xDFOv6Jzf8xZa9sNUWIB/Lbi5tdXvLPPunj/7SMq09yMftOSWMb463QGiB0Nv2qjXyoLpHOu8v/v7H337IWcGRinzgnuXOhknTqjRrXhix5G7WgTZ3pwTFHpoWHDPZD2UI1P726890il8BuCLWZNWyLS4LKZOW61TShP6dkpDzMtNkTFFK7a3dTi2HXp7CmUXplDPDc+XyzTTLTsljVbPIuNKkaWL7BmwVJiZR9tPOnu1sqLYrqkvs2BODvB04FV0xnsZbYEcLjAKAzeYdOcXe/E6tg8tUK7TSt6DFDTLCjhtJwfDjbz+A107K/uFfL7WqmiBPXHb1ca4YSvZk7Nkn1nHBjt6exh7sDgGOgHBcrKpcIaUg+M9/udM2rCGOtP5QHixGMfS9/3lAYpunI4+RnAzb7VTTNz3vbbDdIQ0BNgf9yDD4lkdZkPvy0Tg/NDhIqBzJQM88uQFuIgbgsuxltg6Sa++/eyl12vFcm9bBjtNWotoXoNDSmRI4GSVp0ndK2cEnV1m40/nxnVd1CxR8lrS3LSB5ZS6aVykm163abkue22Krlm0l+BerBXb0uBPDr256zF54brNd++5FdvzJM7llAI/k4LoJZfYcAHjykbU2c069s8Py2PrZj4hBjCOG+n7DbDk11FjthHI3+K+k/PbWpN37hyX2KLLn3Xcstj/e/rxd8abjXS7XM2kW1F//vNxWvLjNr1c9H7l/pT3ywCqUG6KYeXbCKdOtDPZb2vA//eFFP1aM88aJp890GV3lKMlee/LpM9Byr0Mj3MQ1cVcyyfni9798Blv0FrvqrSfYcafMoFR5DPXB5oeQpatXNNqUaZXIiQlrxQnkFzc9zm+XXf/xc/Bcw8zBXwsy7rIlW23D2hY09RNQfBTZmpW4Mf7qWQa9DAHmel1UEVWOuI1Qs/HvV3MLjOp8YAGto63bO92D9y61zg7mgYrS4NN8/sVH2WsvXoAZZccc0NyGb4M1veG/77Pnn9ng6/fOmF2HOeh0+8HX72OlQbR82Fo/9PcXDmqqNevpx995iIFCMnW/T56Qw4aUWIMdnPo0N7Xblz9/JzbeFo9gedpZszE5nWHf+sq99vzTG61uYqn94/97mf0B8D+NHK8kGfXvPn2hVdVGdk8/7F/JnrT99udPMmAsdYcFaZIbZtXYte85Ddl/hwKjuytl73/rj1Dw5WP7fR124UdMtm9R4gVHTbb3fvQc7IXxwbqKUj+B88dPvvswE8lZkRGt+LEnHmaXX3M8fuZ3uoPHLBR/f/fZS/eoJ9hR2/GtQ70FRhXAOzUW4OmhswtMmgv8UpNkWymz5PywsyKIAqFUQ5O8spTiUM3dpZ7uNKAIAd6VT2z3zgae4cvfXZkCqTyS3CQ2pG65AP7P716Ds0eZpRATZD8N+YcrmTrAMqvdVO4O01aU9+XXMbpy/PfQbIHd9/q9eWawNhK13V2x6rS7dlxdsSt4dXRPwFUepaF12Rm8yjF8+TozUtqT6+jQ6+J7HMiow27b7eXXcWgdxvcPrRYYFSXWodUko/M0gy6gIqqvYHAYnVqMl3Kot8A4gMfgDUuB9d2v/tlLlufS9772Z5RmgdUfg9uNF/kqboGxk4FfxY0qk9nq5ZiDJLIqIcw3oF2Xc8Z4Gm+B0WyBcQCPZmuOlzXeAvu4BcZJwj5u8PHbjbfAaLbAOIBHszXHyxpvgX3cAuMA3scNPn678RYYzRb4/wEVmS4NArEG4QAAAABJRU5ErkJggg==)\n",
        "\n",
        "Through this Notebook you will be able to:\n",
        "\n",
        "1.   Select a dataset your preferred language (English, Italian, German, Dutch, French, Slovene) - Section 1.\n",
        "2.   See the time distribution of a specific *Smell Source* within the selected dataset - Section 2.\n",
        "3. Extract occurrences of a specific *Smell Source* within your dataset - Section 3.\n",
        "4. See the co-occourrences of a specific *Smell Source* within your selected dataset - Section 4.\n",
        "5. Calculate the [PMI](https://en.wikipedia.org/wiki/Pointwise_mutual_information) of a specific *Smell Source* within your selected dataset  - Section 5.\n",
        "6. Extract the smell sources appearing more frequently together in specific time spans and save them in an excel file  - Section 6.\n",
        "7. Find the emotions related to smell sources in specific time spans.\n",
        "\n",
        "\n",
        "For more details visit https://odeuropa.eu/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B94sKgRg_DQp"
      },
      "source": [
        "\n",
        "\n",
        "# Load Functions\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "> Before playing with the data, click on the arrow close to \"*10 cells hidden*\". You don't need to do anything else here and go to section \"Play with the data\"\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UujoTp1g-3Q6"
      },
      "outputs": [],
      "source": [
        "!pip install xlsxwriter\n",
        "!pip install transformers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fJXrCrb8jhtB"
      },
      "outputs": [],
      "source": [
        "from google.colab import files\n",
        "from google.colab import data_table\n",
        "from itertools import islice\n",
        "from IPython.display import clear_output\n",
        "from tqdm import tqdm\n",
        "import glob\n",
        "import re\n",
        "import ipywidgets as widgets\n",
        "import math\n",
        "import os\n",
        "import pandas as pd\n",
        "import xlsxwriter\n",
        "from ipywidgets import interact, interactive, fixed, interact_manual\n",
        "import functools\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from transformers import pipeline\n",
        "os.environ[\"PYTORCH_CUDA_ALLOC_CONF\"] = \"max_split_size_mb:512\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "C2ZEZq321uJp"
      },
      "outputs": [],
      "source": [
        "def download_data(lang):\n",
        "  global df\n",
        "  filenamedownload = \"https://zenodo.org/records/10683359/files/Dataset_\"+lang+\".tsv\"\n",
        "  filenamesaved = '/content/Dataset_'+lang+'.tsv'\n",
        "  try:\n",
        "    !rm {filenamesaved}\n",
        "  except:\n",
        "    filenotfound = True\n",
        "  #!wget -q {filenamedownload}\n",
        "  !wget {filenamedownload}\n",
        "  df = pd.read_csv(filenamesaved, sep = '\\t')\n",
        "  df = df.astype({'year':'int'})\n",
        "  df[\"sentencewords\"] = df[\"Sentence\"].apply(lambda n: len(n.split()))\n",
        "\n",
        "def intersection(lst1, lst2):\n",
        "    lst3 = [value for value in lst1 if value in lst2]\n",
        "    return lst3\n",
        "\n",
        "def extract_smell_sources_instances(targets,spans,download):\n",
        "\n",
        "  if download == True:\n",
        "    filename = \"_\".join(targets)+\"-examples.xlsx\"\n",
        "    writer = pd.ExcelWriter(filename, engine = 'xlsxwriter')\n",
        "  for span in spans:\n",
        "    lower_limit,upper_limit = span.split(\"-\")\n",
        "    targets = [x.lower() for x in targets]\n",
        "    df_source = df.dropna(subset=['Smell_Source_lemma'])\n",
        "    pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "    df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "    df_source = df_source.drop(columns=['sentencewords','Quality_lemma','Smell_Source_lemma','Sentence_lemma'])\n",
        "    df_source = df_source.loc[(df[\"year\"] >= int(lower_limit)) & (df[\"year\"] <= int(upper_limit))]\n",
        "    if download == True:\n",
        "      df_source.to_excel(writer, sheet_name=span, index = False)\n",
        "    else:\n",
        "      print()\n",
        "      print('+++++++++++++++++++++++++++++++++')\n",
        "      print()\n",
        "      print('Results for '+ str(span) +' span, and targets  '+ str(targets))\n",
        "      display(data_table.DataTable(df_source[['year','Sentence', 'Smell_Source', 'Quality','Corpus']], include_index=False, num_rows_per_page=10))\n",
        "\n",
        "  if download == True:\n",
        "    files.download(filename)\n",
        "    writer.close()\n",
        "\n",
        "\n",
        "def extract_smell_sources_cooc(targets, spans, top_n,download):\n",
        "  if download == True:\n",
        "    filename = \"_\".join(targets)+\"-cooc.xlsx\"\n",
        "    writer = pd.ExcelWriter(filename, engine = 'xlsxwriter')\n",
        "  for span in spans:\n",
        "    lower_limit,upper_limit = span.split(\"-\")\n",
        "    targets = [x.lower() for x in targets]\n",
        "    df_source = df.dropna(subset=['Smell_Source_lemma'])\n",
        "    pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "    df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "    df_source = df_source.loc[(df[\"year\"] >= int(lower_limit)) & (df[\"year\"] <= int(upper_limit))]\n",
        "    total_words = df_source['sentencewords'].sum()\n",
        "    df_source = df_source.drop(columns=['sentencewords'])\n",
        "    freq_cooc = count_form_list(df_source[\"Sentence_lemma\"].dropna().values.tolist())\n",
        "    freq_cooc_norm = dict()\n",
        "    for word in freq_cooc:\n",
        "      if len(word) < 2:\n",
        "        continue\n",
        "      freq_cooc_norm[word] = freq_cooc[word] * 1000 / total_words\n",
        "    df_cooc = pd.DataFrame(take_top(top_n, freq_cooc_norm), columns =['Word', 'Frequency over 1000 words'])\n",
        "    if download == True:\n",
        "      df_cooc.to_excel(writer, sheet_name=span, index = False)\n",
        "    else:\n",
        "      print()\n",
        "      print('+++++++++++++++++++++++++++++++++')\n",
        "      print()\n",
        "      print('Results for '+ str(span) +' span, and targets  '+ str(targets))\n",
        "      display(data_table.DataTable(df_cooc, include_index=False))\n",
        "  if download == True:\n",
        "    writer.close()\n",
        "    files.download(filename)\n",
        "\n",
        "\n",
        "def extract_smell_sources_cooc_window(targets, spans, window_size, top_n,download):\n",
        "  if download == True:\n",
        "    filename = \"_\".join(targets)+\"-cooc-window\"+str(window_size)+\".xlsx\"\n",
        "    writer = pd.ExcelWriter(filename, engine = 'xlsxwriter')\n",
        "  for span in spans:\n",
        "    lower_limit,upper_limit = span.split(\"-\")\n",
        "    targets = [x.lower() for x in targets]\n",
        "    df_source = df.dropna(subset=['Smell_Source_lemma'])\n",
        "    pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "    df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "    df_source = df_source.loc[(df[\"year\"] >= int(lower_limit)) & (df[\"year\"] <= int(upper_limit))]\n",
        "    total_words = df_source['sentencewords'].sum()\n",
        "    df_source = df_source.drop(columns=['sentencewords','Quality','Smell_Source'])\n",
        "    freq_cooc = count_form_list_window(df_source[\"Sentence_lemma\"].dropna().values.tolist(),targets,window_size)\n",
        "    freq_cooc_norm = dict()\n",
        "    for word in freq_cooc:\n",
        "      if len(word) < 2:\n",
        "        continue\n",
        "      freq_cooc_norm[word] = freq_cooc[word] * 1000 / total_words\n",
        "    df_cooc = pd.DataFrame(take_top(top_n, freq_cooc_norm), columns =['Word', 'Frequency over 1000 words'])\n",
        "    if download == True:\n",
        "      df_cooc.to_excel(writer, sheet_name=span, index = False)\n",
        "    else:\n",
        "      print()\n",
        "      print('+++++++++++++++++++++++++++++++++')\n",
        "      print()\n",
        "      print('Results for '+ str(span) +' span, and targets  '+ str(targets))\n",
        "      display(data_table.DataTable(df_cooc, include_index=False))\n",
        "  if download == True:\n",
        "    writer.close()\n",
        "    files.download(filename)\n",
        "\n",
        "\n",
        "def count_form_list_window(mylist,targets,window_size):\n",
        "  freq_dict = dict()\n",
        "  for sentence in mylist:\n",
        "    sentence = sentence.split(\" \")\n",
        "    for i,w in enumerate(sentence):\n",
        "      if str(w) in targets:\n",
        "        my_window_tokens_list = []\n",
        "        for span_i in range(i - window_size, i + window_size + 1):\n",
        "          if span_i >= 0 and  span_i < len(sentence):\n",
        "            my_window_tokens_list.append(sentence[span_i])\n",
        "        for word in my_window_tokens_list:\n",
        "          if word not in freq_dict:\n",
        "            freq_dict[word] = 0\n",
        "          freq_dict[word]+=1\n",
        "  return(freq_dict)\n",
        "\n",
        "\n",
        "def count_form_list(mylist):\n",
        "  freq_dict = dict()\n",
        "  for item in mylist:\n",
        "    for frame in item.lower().split(\"|\"):\n",
        "      for word in frame.split(\" \"):\n",
        "        if word not in freq_dict:\n",
        "          freq_dict[word] = 0\n",
        "        freq_dict[word]+=1\n",
        "  return(freq_dict)\n",
        "\n",
        "def pmi_span (targets, spans, top_n, download):\n",
        "  targets = [x.lower() for x in targets]\n",
        "  if download ==True:\n",
        "    filename = \"_\".join(targets)+\"-pmi.xlsx\"\n",
        "    writer = pd.ExcelWriter(filename, engine = 'xlsxwriter')\n",
        "  for span in spans:\n",
        "\n",
        "    lower_limit,upper_limit = span.split(\"-\")\n",
        "\n",
        "    df_selection = df.loc[(df[\"year\"] >= int(lower_limit)) & (df[\"year\"] <= int(upper_limit))]\n",
        "\n",
        "    total_words = df_selection['sentencewords'].sum()\n",
        "    freq_quality = count_form_list(df_selection[\"Quality_lemma\"].dropna().values.tolist())\n",
        "\n",
        "    df_source = df_selection.dropna(subset=['Smell_Source_lemma'])\n",
        "    pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "    df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "\n",
        "    freq_target = len(df_source)\n",
        "    freq_cooc = count_form_list(df_source[\"Quality_lemma\"].dropna().values.tolist())\n",
        "\n",
        "    pmiDict = dict()\n",
        "    for quality in freq_cooc:\n",
        "        if freq_cooc[quality] > 5 and len(quality)>0:\n",
        "          pxy= freq_cooc[quality]/total_words\n",
        "          px = freq_target/total_words\n",
        "          py = freq_quality[quality]/total_words\n",
        "          pmi_value = math.log2(pxy/(px*py))\n",
        "          pmiDict[quality] = pmi_value\n",
        "    df_pmi = pd.DataFrame(take_top(top_n, pmiDict), columns =['Quality', 'PMI_score'])\n",
        "\n",
        "    if download ==True:\n",
        "      df_pmi.to_excel(writer, sheet_name=span, index = False)\n",
        "    else:\n",
        "      print()\n",
        "      print('+++++++++++++++++++++++++++++++++')\n",
        "      print()\n",
        "      print('Results for '+ str(span) +' span, and targets  '+ str(targets))\n",
        "      display(data_table.DataTable(df_pmi, include_index=False))\n",
        "  if download ==True:\n",
        "    writer.close()\n",
        "    files.download(filename)\n",
        "\n",
        "# def pmi_span_smell_sources (targets, spans, top_n, download):\n",
        "#   targets = [x.lower() for x in targets]\n",
        "#   if download ==True:\n",
        "#     filename = \"_\".join(targets)+\"-pmi.xlsx\"\n",
        "#     writer = pd.ExcelWriter(filename, engine = 'xlsxwriter')\n",
        "#   for span in spans:\n",
        "\n",
        "#     lower_limit,upper_limit = span.split(\"-\")\n",
        "\n",
        "#     df_selection = df.loc[(df[\"year\"] >= int(lower_limit)) & (df[\"year\"] <= int(upper_limit))]\n",
        "\n",
        "#     total_words = df_selection['sentencewords'].sum()\n",
        "#     freq_quality = count_form_list(df_selection[\"Smell_Source_lemma\"].dropna().values.tolist())\n",
        "\n",
        "#     df_source = df_selection.dropna(subset=['Smell_Source_lemma'])\n",
        "#     pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "#     df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "\n",
        "#     freq_target = len(df_source)\n",
        "#     freq_cooc = count_form_list(df_source[\"Smell_Source_lemma\"].dropna().values.tolist())\n",
        "\n",
        "#     pmiDict = dict()\n",
        "#     for quality in freq_cooc:\n",
        "#         if freq_cooc[quality] > 9 and len(quality)>0:\n",
        "#           pxy= freq_cooc[quality]/total_words\n",
        "#           px = freq_target/total_words\n",
        "#           py = freq_quality[quality]/total_words\n",
        "#           pmi_value = math.log2(pxy/(px*py))\n",
        "#           pmiDict[quality] = pmi_value\n",
        "#     df_pmi = pd.DataFrame(take_top(top_n, pmiDict), columns =['Smell Source', 'PMI_score'])\n",
        "\n",
        "#     if download ==True:\n",
        "#       df_pmi.to_excel(writer, sheet_name=span, index = False)\n",
        "#     else:\n",
        "\n",
        "#       display(data_table.DataTable(df_pmi, include_index=False))\n",
        "#   if download ==True:\n",
        "#     writer.close()\n",
        "#     files.download(filename)\n",
        "\n",
        "def pmi_span_smell_sources (targets, spans, top_n, download):\n",
        "  targets = [x.lower() for x in targets]\n",
        "  if download ==True:\n",
        "    filename = \"_\".join(targets)+\"-pmi.xlsx\"\n",
        "    writer = pd.ExcelWriter(filename, engine = 'xlsxwriter')\n",
        "  for span in spans:\n",
        "\n",
        "    lower_limit,upper_limit = span.split(\"-\")\n",
        "\n",
        "    df_selection = df.loc[(df[\"year\"] >= int(lower_limit)) & (df[\"year\"] <= int(upper_limit))]\n",
        "\n",
        "    total_words = df_selection['sentencewords'].sum()\n",
        "    freq_quality = count_form_list(df_selection[\"Smell_Source_lemma\"].dropna().values.tolist())\n",
        "\n",
        "    df_source = df_selection.dropna(subset=['Smell_Source_lemma'])\n",
        "    pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "    df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "\n",
        "    freq_target = len(df_source)\n",
        "    freq_cooc = count_form_list(df_source[\"Smell_Source_lemma\"].dropna().values.tolist())\n",
        "\n",
        "    pmiDict = dict()\n",
        "    for quality in freq_cooc:\n",
        "        if  len(quality)>1:\n",
        "          pmiDict[quality] = freq_cooc[quality]\n",
        "    df_pmi = pd.DataFrame(take_top(top_n, pmiDict), columns =['Smell Source', 'Frequency'])\n",
        "\n",
        "    if download ==True:\n",
        "      df_pmi.to_excel(writer, sheet_name=span, index = False)\n",
        "    else:\n",
        "      print()\n",
        "      print('+++++++++++++++++++++++++++++++++')\n",
        "      print()\n",
        "      print('Results for '+ str(span) +' span, and targets  '+ str(targets))\n",
        "      display(data_table.DataTable(df_pmi, include_index=False))\n",
        "  if download ==True:\n",
        "    writer.close()\n",
        "    files.download(filename)\n",
        "\n",
        "\n",
        "def take_top(top_n, myDict):\n",
        "  sorted_pmiDict = sorted(myDict.items(), key=lambda x:x[1], reverse=True)\n",
        "  converted_dict = dict(sorted_pmiDict)\n",
        "  return list(islice(converted_dict.items(), top_n))\n",
        "\n",
        "def mobile_average(targets):\n",
        "    window_size = 10\n",
        "    targets = [x.lower() for x in targets]\n",
        "    df_source = df.dropna(subset=['Smell_Source_lemma'])\n",
        "    pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "    df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "    freq_dict = dict()\n",
        "    for y in df_source[\"year\"].dropna().values.tolist():\n",
        "      if y not in freq_dict:\n",
        "        freq_dict[y]=0\n",
        "      freq_dict[y]+=1\n",
        "    average_dict = dict()\n",
        "\n",
        "    for year in freq_dict:\n",
        "      sum = 0\n",
        "      for y in range(year - window_size, year + window_size + 1):\n",
        "        if y in freq_dict:\n",
        "          sum = sum + freq_dict[y]\n",
        "      average_dict[year] = sum/(window_size)+1\n",
        "    return(average_dict)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZqfkcM4JdX_Q"
      },
      "outputs": [],
      "source": [
        "def reset_run_extract_cooc(name):\n",
        "  clear_output()\n",
        "  run_extract_cooc()\n",
        "def run_extract_cooc():\n",
        "\n",
        "  def call_extract_smell_sources_cooc(name):\n",
        "    source = sources.value\n",
        "    source = source.replace(\" \", \"\")\n",
        "    targets = source.split(\",\")\n",
        "    spans = []\n",
        "    for w in sliderlist:\n",
        "      if w.layout.visibility == \"visible\":\n",
        "\n",
        "        mySpan = str(w.value[0])+\"-\"+str(w.value[1])\n",
        "        spans.append(mySpan)\n",
        "    top_n = slidercooc.value\n",
        "\n",
        "    if name.description =='Export Excel':\n",
        "      extract_smell_sources_cooc(targets, spans, top_n,True)\n",
        "    else:\n",
        "      extract_smell_sources_cooc(targets, spans, top_n, False)\n",
        "\n",
        "  def read_values(name):\n",
        "    print(slider1.value)\n",
        "    print(slider2.value)\n",
        "    print(slider3.value)\n",
        "    print(sources.value)\n",
        "\n",
        "\n",
        "  def add_span(name):\n",
        "    if slider2.layout.visibility == \"hidden\":\n",
        "      slider2.layout.visibility = \"visible\"\n",
        "    else:\n",
        "      slider3.layout.visibility = \"visible\"\n",
        "\n",
        "\n",
        "  # print(\"# extract co-occurrences from the sentences and save them in an excel file\")\n",
        "  slider1 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider2 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider3 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "\n",
        "  style = {'description_width': 'initial'}\n",
        "  slidercooc = widgets.IntSlider(value=10,min=10,max=300,step=1,description='Number of co-occurrences:', style=style)\n",
        "\n",
        "  sources = widgets.Text(value='', description='Smell Source')\n",
        "\n",
        "  slider1.layout.visibility = \"visible\"\n",
        "  slider2.layout.visibility = \"hidden\"\n",
        "  slider3.layout.visibility = \"hidden\"\n",
        "\n",
        "  sliderlist = [slider1, slider2, slider3]\n",
        "  addButton = widgets.Button(description='Add time span')\n",
        "  showButton = widgets.Button(description='Show Selection')\n",
        "  sendButton = widgets.Button(description='Export Excel')\n",
        "  resetButton = widgets.Button(description='Reset')\n",
        "\n",
        "  addButton.on_click(add_span)\n",
        "  sendButton.on_click(call_extract_smell_sources_cooc)\n",
        "  showButton.on_click(call_extract_smell_sources_cooc)\n",
        "  resetButton.on_click(reset_run_extract_cooc)\n",
        "\n",
        "  display(sources)\n",
        "  for w in sliderlist:\n",
        "    display(w)\n",
        "  display(slidercooc)\n",
        "  display(addButton,showButton,sendButton,resetButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L1PoFT9Rheg2"
      },
      "outputs": [],
      "source": [
        "def reset_run_extract_smell_sources_cooc_window(name):\n",
        "  clear_output()\n",
        "  run_extract_smell_sources_cooc_window()\n",
        "\n",
        "def run_extract_smell_sources_cooc_window():\n",
        "\n",
        "  def call_extract_smell_sources_cooc_window(name):\n",
        "    source = sources.value\n",
        "    source = source.replace(\" \", \"\")\n",
        "    targets = source.split(\",\")\n",
        "    spans = []\n",
        "    for w in sliderlist:\n",
        "      if w.layout.visibility == \"visible\":\n",
        "\n",
        "        mySpan = str(w.value[0])+\"-\"+str(w.value[1])\n",
        "        spans.append(mySpan)\n",
        "    top_n = slidercooc.value\n",
        "    window_size =  sliderwindow.value\n",
        "\n",
        "\n",
        "    if name.description =='Export Excel':\n",
        "      extract_smell_sources_cooc_window(targets, spans, window_size, top_n, True)\n",
        "    else:\n",
        "      extract_smell_sources_cooc_window(targets, spans, window_size, top_n, False)\n",
        "\n",
        "  def read_values(name):\n",
        "    print(slider1.value)\n",
        "    print(slider2.value)\n",
        "    print(slider3.value)\n",
        "    print(sources.value)\n",
        "\n",
        "\n",
        "  def add_span(name):\n",
        "    if slider2.layout.visibility == \"hidden\":\n",
        "      slider2.layout.visibility = \"visible\"\n",
        "    else:\n",
        "      slider3.layout.visibility = \"visible\"\n",
        "\n",
        "\n",
        "  # print(\"# extract co-occurrences from the sentences and save them in an excel file\")\n",
        "  slider1 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider2 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider3 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "\n",
        "  style = {'description_width': 'initial'}\n",
        "  slidercooc = widgets.IntSlider(value=10,min=10,max=300,step=1,description='Number of co-occurrences:', style=style)\n",
        "  sliderwindow = widgets.IntSlider(value=3,min=1,max=10,step=1,description='Window size', style=style)\n",
        "\n",
        "  sources = widgets.Text(value='', description='Smell Source')\n",
        "\n",
        "  slider1.layout.visibility = \"visible\"\n",
        "  slider2.layout.visibility = \"hidden\"\n",
        "  slider3.layout.visibility = \"hidden\"\n",
        "\n",
        "  sliderlist = [slider1, slider2, slider3]\n",
        "  addButton = widgets.Button(description='Add time span')\n",
        "  showButton = widgets.Button(description='Show Selection')\n",
        "  sendButton = widgets.Button(description='Export Excel')\n",
        "  resetButton = widgets.Button(description='Reset')\n",
        "\n",
        "  addButton.on_click(add_span)\n",
        "  sendButton.on_click(call_extract_smell_sources_cooc_window)\n",
        "  showButton.on_click(call_extract_smell_sources_cooc_window)\n",
        "  resetButton.on_click(reset_run_extract_smell_sources_cooc_window)\n",
        "  display(sources)\n",
        "  for w in sliderlist:\n",
        "    display(w)\n",
        "  display(slidercooc)\n",
        "  display(sliderwindow)\n",
        "  display(addButton,showButton,sendButton,resetButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q48HoXe7kgqA"
      },
      "outputs": [],
      "source": [
        "def reset_call_pmi_span(name):\n",
        "  clear_output()\n",
        "  run_pmi_span()\n",
        "\n",
        "def run_pmi_span():\n",
        "\n",
        "  def call_pmi_span(name):\n",
        "    source = sources.value\n",
        "    source = source.replace(\" \", \"\")\n",
        "    targets = source.split(\",\")\n",
        "    spans = []\n",
        "    for w in sliderlist:\n",
        "      if w.layout.visibility == \"visible\":\n",
        "\n",
        "        mySpan = str(w.value[0])+\"-\"+str(w.value[1])\n",
        "        spans.append(mySpan)\n",
        "    top_n = slidercooc.value\n",
        "    if name.description =='Export Excel':\n",
        "      pmi_span(targets, spans, top_n,True)\n",
        "    else:\n",
        "      pmi_span(targets, spans, top_n,False)\n",
        "\n",
        "\n",
        "  def read_values(name):\n",
        "    print(slider1.value)\n",
        "    print(slider2.value)\n",
        "    print(slider3.value)\n",
        "    print(sources.value)\n",
        "\n",
        "\n",
        "  def add_span(name):\n",
        "    if slider2.layout.visibility == \"hidden\":\n",
        "      slider2.layout.visibility = \"visible\"\n",
        "    else:\n",
        "      slider3.layout.visibility = \"visible\"\n",
        "\n",
        "\n",
        "  # print(\"# top pmi qualities for the smell source in the timespan\")\n",
        "  slider1 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider2 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider3 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "\n",
        "  style = {'description_width': 'initial'}\n",
        "  slidercooc = widgets.IntSlider(value=10,min=10,max=300,step=1,description='Number of qualities:', style=style)\n",
        "\n",
        "  sources = widgets.Text(value='', description='Smell Source')\n",
        "\n",
        "  slider1.layout.visibility = \"visible\"\n",
        "  slider2.layout.visibility = \"hidden\"\n",
        "  slider3.layout.visibility = \"hidden\"\n",
        "\n",
        "  sliderlist = [slider1, slider2, slider3]\n",
        "  addButton = widgets.Button(description='Add time span')\n",
        "  showButton = widgets.Button(description='Show Selection')\n",
        "  sendButton = widgets.Button(description='Export Excel')\n",
        "  resetButton = widgets.Button(description='Reset')\n",
        "\n",
        "  addButton.on_click(add_span)\n",
        "  sendButton.on_click(call_pmi_span)\n",
        "  showButton.on_click(call_pmi_span)\n",
        "  resetButton.on_click(reset_call_pmi_span)\n",
        "\n",
        "  display(sources)\n",
        "  for w in sliderlist:\n",
        "    display(w)\n",
        "  display(slidercooc)\n",
        "  display(addButton,showButton,sendButton,resetButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "91HUwusNQ126"
      },
      "outputs": [],
      "source": [
        "def reset_call_pmi_span_smell_sources(name):\n",
        "  clear_output()\n",
        "  run_cooc_smell_sources()\n",
        "\n",
        "def run_cooc_smell_sources():\n",
        "\n",
        "  def call_pmi_span_smell_sources(name):\n",
        "    source = sources.value\n",
        "    source = source.replace(\" \", \"\")\n",
        "    targets = source.split(\",\")\n",
        "    spans = []\n",
        "    for w in sliderlist:\n",
        "      if w.layout.visibility == \"visible\":\n",
        "\n",
        "        mySpan = str(w.value[0])+\"-\"+str(w.value[1])\n",
        "        spans.append(mySpan)\n",
        "    top_n = slidercooc.value\n",
        "    if name.description =='Export Excel':\n",
        "      pmi_span_smell_sources(targets, spans, top_n,True)\n",
        "    else:\n",
        "      pmi_span_smell_sources(targets, spans, top_n,False)\n",
        "\n",
        "\n",
        "  def read_values(name):\n",
        "    print(slider1.value)\n",
        "    print(slider2.value)\n",
        "    print(slider3.value)\n",
        "    print(sources.value)\n",
        "\n",
        "\n",
        "  def add_span(name):\n",
        "    if slider2.layout.visibility == \"hidden\":\n",
        "      slider2.layout.visibility = \"visible\"\n",
        "    else:\n",
        "      slider3.layout.visibility = \"visible\"\n",
        "\n",
        "\n",
        "  # print(\"# top pmi qualities for the smell source in the timespan\")\n",
        "  slider1 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider2 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider3 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "\n",
        "  style = {'description_width': 'initial'}\n",
        "  slidercooc = widgets.IntSlider(value=10,min=10,max=300,step=1,description='Number of smell sources:', style=style)\n",
        "\n",
        "  sources = widgets.Text(value='', description='Smell Source')\n",
        "\n",
        "  slider1.layout.visibility = \"visible\"\n",
        "  slider2.layout.visibility = \"hidden\"\n",
        "  slider3.layout.visibility = \"hidden\"\n",
        "\n",
        "  sliderlist = [slider1, slider2, slider3]\n",
        "  addButton = widgets.Button(description='Add time span')\n",
        "  showButton = widgets.Button(description='Show Selection')\n",
        "  sendButton = widgets.Button(description='Export Excel')\n",
        "  resetButton = widgets.Button(description='Reset')\n",
        "\n",
        "  addButton.on_click(add_span)\n",
        "  sendButton.on_click(call_pmi_span_smell_sources)\n",
        "  showButton.on_click(call_pmi_span_smell_sources)\n",
        "  resetButton.on_click(reset_call_pmi_span_smell_sources)\n",
        "\n",
        "  display(sources)\n",
        "  for w in sliderlist:\n",
        "    display(w)\n",
        "  display(slidercooc)\n",
        "  display(addButton,showButton,sendButton,resetButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "erxXzYJYlz6x"
      },
      "outputs": [],
      "source": [
        "def reset_run_extract_examples(name):\n",
        "  clear_output()\n",
        "  run_extract_examples()\n",
        "\n",
        "def run_extract_examples():\n",
        "\n",
        "  def call_extract_smell_sources_instances(name):\n",
        "    source = sources.value\n",
        "    source = source.replace(\" \", \"\")\n",
        "    targets = source.split(\",\")\n",
        "    spans = []\n",
        "    for w in sliderlist:\n",
        "      if w.layout.visibility == \"visible\":\n",
        "\n",
        "        mySpan = str(w.value[0])+\"-\"+str(w.value[1])\n",
        "        spans.append(mySpan)\n",
        "    if name.description =='Export Excel':\n",
        "      extract_smell_sources_instances(targets, spans, True)\n",
        "    else:\n",
        "      extract_smell_sources_instances(targets, spans, False)\n",
        "\n",
        "\n",
        "  def read_values(name):\n",
        "    print(slider1.value)\n",
        "    print(slider2.value)\n",
        "    print(slider3.value)\n",
        "    print(sources.value)\n",
        "\n",
        "\n",
        "  def add_span(name):\n",
        "    if slider2.layout.visibility == \"hidden\":\n",
        "      slider2.layout.visibility = \"visible\"\n",
        "    else:\n",
        "      slider3.layout.visibility = \"visible\"\n",
        "\n",
        "  style = {'description_width': 'initial'}\n",
        "  # print(\"# this code looks for target/s as smell source/s and saves all the related sentences in an excel file\")\n",
        "  slider1 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider2 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider3 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  sources = widgets.Text(value='', description='Smell Source')\n",
        "\n",
        "  slider1.layout.visibility = \"visible\"\n",
        "  slider2.layout.visibility = \"hidden\"\n",
        "  slider3.layout.visibility = \"hidden\"\n",
        "\n",
        "  sliderlist = [slider1, slider2, slider3]\n",
        "  addButton = widgets.Button(description='Add time span')\n",
        "  showButton = widgets.Button(description='Show Selection')\n",
        "  sendButton = widgets.Button(description='Export Excel')\n",
        "  resetButton = widgets.Button(description='Reset')\n",
        "  addButton.on_click(add_span)\n",
        "  sendButton.on_click(call_extract_smell_sources_instances)\n",
        "  showButton.on_click(call_extract_smell_sources_instances)\n",
        "  resetButton.on_click(reset_run_extract_examples)\n",
        "  #data_table.DataTable(df[['year','Sentence', 'Smell_Source_lemma', 'Quality_lemma','Corpus']], include_index=False, num_rows_per_page=10)\n",
        "  display(sources)\n",
        "  for w in sliderlist:\n",
        "    display(w)\n",
        "  display(addButton,showButton,sendButton,resetButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2l9VzIRmvTkS"
      },
      "outputs": [],
      "source": [
        "def reset_run_mobile_average(name):\n",
        "  clear_output()\n",
        "  run_mobile_average()\n",
        "\n",
        "def run_mobile_average():\n",
        "\n",
        "  def call_mobile_average(name):\n",
        "\n",
        "    source = sources.value\n",
        "    source = source.replace(\" \", \"\")\n",
        "    targets = source.split(\",\")\n",
        "    av_dict = mobile_average(targets)\n",
        "    # pairs in the dictionary\n",
        "    result = av_dict.items()\n",
        "    # Convert object to a list\n",
        "    data = list(result)\n",
        "    # Convert list to an array\n",
        "\n",
        "    numpyArray = np.array(data)\n",
        "    if (len(numpyArray)) !=0:\n",
        "\n",
        "      numpyArray = numpyArray[numpyArray[:, 0].argsort()]\n",
        "      plt.xlim(1550,2000)\n",
        "      plt.plot(numpyArray[:,0], numpyArray[:,1], 'g', linestyle='--')#marker='o',\n",
        "      plt.xlabel('year')\n",
        "      plt.ylabel('Occurrences')\n",
        "      #plt.xticks(xi, x)\n",
        "      if sources.value =='':\n",
        "        plt.title('All data')\n",
        "      else:\n",
        "        plt.title(sources.value)\n",
        "      #plt.legend()\n",
        "      plt.show()\n",
        "    else:\n",
        "      display()\n",
        "      display(' no data found ')\n",
        "\n",
        "\n",
        "  sources = widgets.Text(value='', description='Smell Source')\n",
        "\n",
        "\n",
        "\n",
        "  sendButton = widgets.Button(description='Plot')\n",
        "  resetButton = widgets.Button(description='Reset')\n",
        "\n",
        "  sendButton.on_click(call_mobile_average)\n",
        "  resetButton.on_click(reset_run_mobile_average)\n",
        "  display(sources)\n",
        "\n",
        "  display(sendButton,resetButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "83wzAD-afUTd"
      },
      "outputs": [],
      "source": [
        "def call_downlaod(name,langmenu):\n",
        "  langdict = {\n",
        "      'English':'en',\n",
        "      'Dutch':'nl',\n",
        "      'French':'fr',\n",
        "      'Italian':'it',\n",
        "      'Slovenian':'sl',\n",
        "      'German':'de'\n",
        "  }\n",
        "\n",
        "  lang = langdict[langmenu.value]\n",
        "  download_data(lang)\n",
        "  global classifier\n",
        "  if lang == \"en\":\n",
        "    classifier = pipeline(\"text-classification\", model=\"lrei/roberta-large-emolit\", top_k=None)\n",
        "  if lang == \"it\" or lang == \"sl\" or lang == \"nl\":\n",
        "    classifier = pipeline(\"text-classification\", model=\"lrei/xlm-roberta-base-emolit-multilingual\", top_k=None)\n",
        "def language_selection():\n",
        "  langmenu = widgets.Dropdown(\n",
        "      options=['English', 'Dutch', 'French', 'Italian','Slovenian','German'],\n",
        "      value='English',\n",
        "      description='Language:',\n",
        "      disabled=False,\n",
        "  )\n",
        "  display(langmenu)\n",
        "\n",
        "  downloadButton = widgets.Button(description='Download data')\n",
        "  downloadButton.on_click(functools.partial(call_downlaod, langmenu=langmenu))\n",
        "  display(downloadButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UXRzzk4TgtMe"
      },
      "outputs": [],
      "source": [
        "import json\n",
        "from tqdm import tqdm\n",
        "\n",
        "def average_list(lst):\n",
        "    return sum(lst) / len(lst)\n",
        "\n",
        "def extract_smell_sources_emotions(targets,spans,download):\n",
        "\n",
        "  if download == True:\n",
        "    filename = \"_\".join(targets)+\"-examples.xlsx\"\n",
        "    writer = pd.ExcelWriter(filename, engine = 'xlsxwriter')\n",
        "\n",
        "\n",
        "\n",
        "  for span in spans:\n",
        "    print()\n",
        "    print(\"Processing \"+str(span))\n",
        "    emotionsDict = dict()\n",
        "    lower_limit,upper_limit = span.split(\"-\")\n",
        "    targets = [x.lower() for x in targets]\n",
        "    df_source = df.dropna(subset=['Smell_Source_lemma'])\n",
        "    pat = '|'.join(r\"\\b{}\\b\".format(x) for x in targets)\n",
        "    df_source = df_source[df_source['Smell_Source_lemma'].str.contains(pat)]\n",
        "    df_source = df_source.drop(columns=['sentencewords','Smell_Source_lemma','Sentence_lemma'])\n",
        "    df_source = df_source.loc[(df[\"year\"] >= int(lower_limit)) & (df[\"year\"] <= int(upper_limit))]\n",
        "    if download == True:\n",
        "      df_source.to_excel(writer, sheet_name=span, index = False)\n",
        "    else:\n",
        "      myString = \"\"\n",
        "      for q in df_source[\"Quality_lemma\"].dropna().values.tolist():\n",
        "        myString = myString + \" \" + str(q)\n",
        "        myString = myString.replace(\"|\", \" \")\n",
        "        myString = re.sub(' +', ' ', myString)\n",
        "      myList = myString.split(\" \")\n",
        "\n",
        "      parts_number = len(myList)/200\n",
        "      parts_number = math.ceil(parts_number)\n",
        "      new_list = np.array_split(myList, parts_number)\n",
        "\n",
        "      for short_list in tqdm(new_list):\n",
        "        to_predict = \" \".join(short_list)\n",
        "        predictions = classifier(to_predict)\n",
        "        predictions_1=predictions[0]\n",
        "\n",
        "        for e in predictions_1:\n",
        "\n",
        "          if e['label'] not in emotionsDict:\n",
        "            emotionsDict[e['label']] = []\n",
        "          emotionsDict[e['label']].append(e['score'])\n",
        "\n",
        "      average_dict = dict()\n",
        "      for em in emotionsDict:\n",
        "        average_dict[em] = average_list(emotionsDict[em])\n",
        "      print()\n",
        "      sorted_averageDict = {k: v for k, v in sorted(average_dict.items(), key=lambda item: item[1], reverse=True)}\n",
        "\n",
        "      for i in sorted_averageDict:\n",
        "        # if sorted_averageDict[i] >= 0.5:\n",
        "          print(str(i) +\" \"+str(sorted_averageDict[i]))\n",
        "\n",
        "  if download == True:\n",
        "    files.download(filename)\n",
        "    writer.close()\n",
        "\n",
        "\n",
        "\n",
        "def reset_extract_emotion(name):\n",
        "  clear_output()\n",
        "  run_extract_emotion()\n",
        "\n",
        "def run_extract_emotion():\n",
        "\n",
        "\n",
        "  def call_extract_smell_sources_emotions(name):\n",
        "\n",
        "    source = sources.value\n",
        "    source = source.replace(\" \", \"\")\n",
        "    targets = source.split(\",\")\n",
        "    spans = []\n",
        "    for w in sliderlist:\n",
        "      if w.layout.visibility == \"visible\":\n",
        "\n",
        "        mySpan = str(w.value[0])+\"-\"+str(w.value[1])\n",
        "        spans.append(mySpan)\n",
        "    if name.description =='Export Excel':\n",
        "      extract_smell_sources_emotions(targets, spans, True)\n",
        "    else:\n",
        "      extract_smell_sources_emotions(targets, spans, False)\n",
        "\n",
        "\n",
        "  def read_values(name):\n",
        "    print(slider1.value)\n",
        "    print(slider2.value)\n",
        "    print(slider3.value)\n",
        "    print(sources.value)\n",
        "\n",
        "\n",
        "  def add_span(name):\n",
        "    if slider2.layout.visibility == \"hidden\":\n",
        "      slider2.layout.visibility = \"visible\"\n",
        "    else:\n",
        "      slider3.layout.visibility = \"visible\"\n",
        "\n",
        "  style = {'description_width': 'initial'}\n",
        "  # print(\"# this code looks for target/s as smell source/s and saves all the related sentences in an excel file\")\n",
        "  slider1 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider2 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  slider3 = widgets.IntRangeSlider(value=[1700, 1800],min=1500,max=1950,step=10,description='Time Span:')\n",
        "  sources = widgets.Text(value='', description='Smell Source')\n",
        "\n",
        "  slider1.layout.visibility = \"visible\"\n",
        "  slider2.layout.visibility = \"hidden\"\n",
        "  slider3.layout.visibility = \"hidden\"\n",
        "\n",
        "  sliderlist = [slider1, slider2, slider3]\n",
        "  addButton = widgets.Button(description='Add time span')\n",
        "  showButton = widgets.Button(description='Show Emotions')\n",
        "  # sendButton = widgets.Button(description='Export Excel')\n",
        "  resetButton = widgets.Button(description='Reset')\n",
        "  addButton.on_click(add_span)\n",
        "  # sendButton.on_click(call_extract_smell_sources_emotions)\n",
        "  showButton.on_click(call_extract_smell_sources_emotions)\n",
        "  resetButton.on_click(reset_extract_emotion)\n",
        "  #data_table.DataTable(df[['year','Sentence', 'Smell_Source_lemma', 'Quality_lemma','Corpus']], include_index=False, num_rows_per_page=10)\n",
        "  display(sources)\n",
        "  for w in sliderlist:\n",
        "    display(w)\n",
        "  display(addButton,showButton,resetButton)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rCE9a4UKtTmC"
      },
      "outputs": [],
      "source": [
        "# this code looks for target/s as smell source/s and saves all the related sentences in an excel file\n",
        "\n",
        "# targets = [\"kaars\"] # list of lemmas\n",
        "# spans = ['1500-1600', '1700-1900']\n",
        "# extract_smell_sources_instances(targets, spans)\n",
        "\n",
        "# extract co-occurrences from the sentences and save them in an excel file\n",
        "\n",
        "# targets = [\"kaars\"] # list of lemmas\n",
        "# spans = ['1500-1600', '1700-1900']\n",
        "# extract_smell_sources_cooc(targets, spans, 50)\n",
        "\n",
        "# # extract co-occurrences from a window in the sentences and save them in an excel file\n",
        "\n",
        "# targets = [\"candle\"] # list of lemmas\n",
        "# spans = ['1500-1600', '1700-1750']\n",
        "# extract_smell_sources_cooc_window(targets, spans, 3, 50)\n",
        "\n",
        "# # top pmi qualities for the smell source in the timespan\n",
        "\n",
        "# targets = ['fish']\n",
        "# spans = ['1500-1700', '1700-1800','1800-1900']\n",
        "# pmi_span(targets, spans,20)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mIXdN7VNnlrZ"
      },
      "source": [
        "# Play with the data\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eDR_gdaxDx1w"
      },
      "source": [
        "**1. Select your language:**\n",
        "  1. Run the code by clicking on the arrow below (close to \"*language selection ()*\")\n",
        "  2. Select your preferred language\n",
        "  3. Click on \"Download data\"\n",
        "  4. **For English, French, Dutch and Italian after the download please wait for the emotions detection models to download**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "88A6huHbfgOn"
      },
      "outputs": [],
      "source": [
        "language_selection()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bD3LDdftDvlP"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "**2. See distribution in time of your preferred smell source:**\n",
        "\n",
        "  1.  Run the code by clicking on the arrow below close to \"*run_mobile_average()*\"\n",
        "  2.  Enter your smell source (one or more, divided by comma if more than one)\n",
        "  3. Click on \"*Plot*\"\n",
        "  4. Repeat from 2. if you want add new plots one close to the other, or click on reset if you want to start again\n",
        "\n",
        "Tip: if you want to see the distribution in time of the entire selected dataset, leave the field empty and click on run\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YZJR6Mbxvt2r"
      },
      "outputs": [],
      "source": [
        "run_mobile_average()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ik_6vhgYEnWm"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "**3. Search for a smell source or a list of smell sources in specific timespan and saves all the related sentences in an excel file**\n",
        "\n",
        "  1.  Run the code by clicking on the arrow below close to \"*run_extract_examples()*\"\n",
        "  2.  Enter your smell source (one or more, divided by comma if more than one).\n",
        "  3. Select one or more time ranges of interest by clickin on \"*Add time span*\"\n",
        "  4. Click on \"*Show Selection*\" to see a table with the results, or on \"*Export Excel*\" to download them\n",
        "  5. Repeat from 2. if you want add new results one close to the other, or click on reset if you want to start again"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T-VVGRL3dMwg"
      },
      "outputs": [],
      "source": [
        "run_extract_examples()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XARSM74gDkYS"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "**4. Extract co-occurrences of a smell source in specific time spans looking at the context (context = closest words) and save them in an excel file**\n",
        "\n",
        "\n",
        "\n",
        "  1.  Run the code by clicking on the arrow below close to \"*run_extract_smell_sources_cooc_window()*\"\n",
        "  2.  Enter your smell source (one or more, divided by comma if more than one)\n",
        "  3. Select one or more time ranges of interest by clicking on \"*Add time span*\"\n",
        "  4. Select the numer of co-occurences to visualize (default = 10) and the Window size (the number of Words to consider context. Default is 3 before and 3 after)\n",
        "  4. Click on \"*Show Selection*\" to see a table with the results, or on \"*Export Excel*\" to download them\n",
        "  5. Repeat from 2. if you want add new results one close to the other, or click on reset if you want to start again\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZoYS2XtCkPNJ"
      },
      "outputs": [],
      "source": [
        "run_extract_smell_sources_cooc_window()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wd98HNO0FH8s"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "**5. Extract PMI (i.e. the most relevant qualities) for a smell source in specific time spans and save them in an excel file**\n",
        "\n",
        "\n",
        "  1.  Run the code by clicking on the arrow below close to \"*run_pmi_span()*\"\n",
        "  2.  Enter your smell source (one or more, divided by comma if more than one)\n",
        "  3. Select one or more time ranges of interest by clicking on \"*Add time span*\"\n",
        "  4. Click on \"*Show Selection*\" to see a table with the results, or on \"*Export Excel*\" to download them\n",
        "  5. Repeat from 2. if you want add new results one close to the other, or click on reset if you want to start again\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ue3YC3VBkVUH"
      },
      "outputs": [],
      "source": [
        "run_pmi_span()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MMdjSiyLRdeA"
      },
      "source": [
        "**6. Extract the smell sources appearing more frequently together in specific time spans and save them in an excel file**\n",
        "\n",
        "\n",
        "\n",
        "1.   Run the code by clicking on the arrow below close to \"run_pmi_span()\"\n",
        "2.   Enter your smell source (one or more, divided by comma if more than one)\n",
        "3.   Select one or more time ranges of interest by clicking on \"Add time span\"\n",
        "4.   Click on \"Show Selection\" to see a table with the results, or on \"Export Excel\" to download them\n",
        "5.   Repeat from 2. if you want add new results one close to the other, or click on reset if you want to start again"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vH0MKxfeRZrx"
      },
      "outputs": [],
      "source": [
        "run_cooc_smell_sources()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jdmfaQiljS4p"
      },
      "source": [
        "**7. Extract the emotions related to smell sources in specific time spans and save them in an excel file**\n",
        "\n",
        "** Emotions supports English, Slovene, Dutch and Ialian **\n",
        "\n",
        "\n",
        "1.   Run the code by clicking on the arrow below close to \"run_extract_emotion()\"\n",
        "2.   Enter your smell source (one or more, divided by comma if more than one)\n",
        "3.   Select one or more time ranges of interest by clicking on \"Add time span\"\n",
        "4.   Click on \"Show Selection\" to see a table with the results\n",
        "5.   Repeat from 2. if you want add new results one close to the other, or click on reset if you want to start again"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "jy3ShdPyjGvz"
      },
      "outputs": [],
      "source": [
        "run_extract_emotion()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lthrBp0wso1O"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "axoNECPEqycN"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "![Screenshot 2023-11-24 at 15.11.52.png](data:image/png;base64,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)    This work has been realised in the context of Odeuropa, a research project that has received funding from the European Union's Horizon 2020 research and innovation programme under grant agreement No. 101004469."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VjvEdLllsmPR"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}