Lecture_Redis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте потестируем производительность БД Redis, которая относится к базам \"ключ-значение\".\n",
    "\n",
    "Документация на обертку для Питона находится [здесь](https://redis-py.readthedocs.io/en/stable/genindex.html).\n",
    "\n",
    "Установим саму базу данных и redis-py (`pip install redis`). Помимо этого установим библиотеку hiredis (`pip install hiredis`), которая обрабатывает ответ от БД несколько быстрее.\n",
    "\n",
    "Воспользуемся тем, что Mongo и bson у нас уже установлены<sup>\\*</sup>. Будем генерировать уникальные идентификаторы при помощи ObjectId.\n",
    "<hr>\n",
    "<sup>*</sup> По-крайней мере, у меня. Если кто-либо хочет синхронизироваться, пусть поставит библиотеку для работы с Mongo - <a href=\"http://api.mongodb.com/python/current/api/index.html\">pymongo</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Импортируем драйвер к Redis.\n",
    "import redis\n",
    "from bson import ObjectId\n",
    "import datetime\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Присоединяемся к базе данных. По умолчанию она работает только с локальной машиной, аутентификация не предусмотрена.\n",
    "\n",
    "На самом деле, параметры можно не указывать, ниже передаются те же самые значения, что принимаются по умолчанию."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = redis.Redis(host='localhost', port=6379, db=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем положить какой-нибудь ключ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.set('foo', 'bar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... и получить его обратно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'bar'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.get('foo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ttt = r.get('foo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bar'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ttt.decode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.set('foo', 100)\n",
    "int(r.get('foo'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ObjectId по умолчанию генерирует некоторый уникальный ключ. В дальнейшем мы будем преобразовывать его к строке и использовать как уникальный ключ для наших данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ObjectId('5fb6a8eca99faadc798c62e4')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ObjectId()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При помощи функции `keys` можно посмотреть все ключи в базе. Функция `flushdb` очищает текущую базу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.flushdb()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Померим скорость работы с базой при помощи такого простого метода, как `set`. Положим в базу 100 000 уникальных ключей, к которым привязано одно целое число."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6.2 s, sys: 1.63 s, total: 7.84 s\n",
      "Wall time: 9.84 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for i in range(100000):\n",
    "    r.set(str(ObjectId()), i)\n",
    "#    r.set(i, i)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Примерно 20 000 операций вставки в секунду на локальной машине. Не так уж и много.\n",
    "\n",
    "Посмотрим с какой скоростью они будут читаться."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Всего ключей: 100000\n",
      "CPU times: user 4.24 s, sys: 1.83 s, total: 6.07 s\n",
      "Wall time: 7.97 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "summ=0\n",
    "for k in r.keys():\n",
    "    summ+=int(r.get(k))\n",
    "\n",
    "print(\"Всего ключей:\", len(r.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Около 20 000 операций чтения.\n",
    "\n",
    "Хм... Этот Redis, кажется, не такой уж и молодец.\n",
    "\n",
    "Или мы что-то делаем не так? Давайте сравним с `dict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 446 ms, sys: 33.9 ms, total: 480 ms\n",
      "Wall time: 481 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "tst_dct={}\n",
    "for i in range(100000):\n",
    "    tst_dct[str(ObjectId())]=i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Примерно 300 000 операций записи в секунду..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 73.4 ms, sys: 8.08 ms, total: 81.5 ms\n",
      "Wall time: 80.7 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "summ=0\n",
    "for k in tst_dct.keys():\n",
    "    summ+=int(tst_dct[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... и примерно 2,5 млн операций чтения в секунду. Пока Redis очень далеко до `dict`.\n",
    "\n",
    "Хотя dict не умеет отдавать данные нескольким программам одновременно.\n",
    "\n",
    "Давайте пока посмотрим что Redis  умеет еще. Например, при помощи функции `expire` каждой паре можно сказать, что она утрачивает актуальность через какое-то время. \n",
    "\n",
    "Положим в базу 100 000 ключей, каждому из них установим время жизни 10 секунд, уснём на 15 секунд и посмотрим что осталось в базе."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n"
     ]
    }
   ],
   "source": [
    "r.flushdb()\n",
    "\n",
    "for i in range(100000):\n",
    "    oid=str(ObjectId())\n",
    "    r.set(oid, i)\n",
    "    r.expire(oid, 10)\n",
    "\n",
    "time.sleep(15)\n",
    "\n",
    "summ=0\n",
    "for k in r.keys():\n",
    "    summ+=int(r.get(k))\n",
    "    \n",
    "print(r.dbsize(), summ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(r.get(oid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно, не осталось ничего. Метод работает.\n",
    "\n",
    "Помимо работы с простыми числами, Redis позволяет организовывать список, привязанный к определенному ключу. При помощи функций `rpush` и `lpush` можно класть значения в очередь с заданным ключем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[b'secondkey', b'firstkey']\n",
      "CPU times: user 8.35 s, sys: 3.04 s, total: 11.4 s\n",
      "Wall time: 14.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for i in range(100000):\n",
    "    r.lpush('firstkey', i)\n",
    "    r.lpush('secondkey', i)\n",
    "    \n",
    "print(r.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.flushdb()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[b'secondkey', b'firstkey']\n",
      "CPU times: user 8.66 s, sys: 3.06 s, total: 11.7 s\n",
      "Wall time: 15 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for i in range(100000):\n",
    "    r.rpush('firstkey', i)\n",
    "    r.rpush('secondkey', i)\n",
    "    \n",
    "print(r.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получается еще медленнее, чем при помощи `set`.\n",
    "\n",
    "Извлекаем данные при помощи `lpop` и `rpop`. Как видно, получается тоже не быстро."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 7.79 s, sys: 3.13 s, total: 10.9 s\n",
      "Wall time: 14.3 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for i in range(100000):\n",
    "    r.lpop('firstkey')\n",
    "    r.lpop('secondkey')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь попробуем пакетную запись значений. \n",
    "\n",
    "Может быть генерация ключей занимает больше времени, чем работа с БД? Отдельно сгенерируем идентификаторы для ключей, а потом положим их в базу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 416 ms, sys: 16.4 ms, total: 432 ms\n",
      "Wall time: 433 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "objs=[str(ObjectId()) for i in range(100000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.69 s, sys: 1.72 s, total: 6.41 s\n",
      "Wall time: 8.18 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for i,x in enumerate(objs):\n",
    "    r.set(x, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Быстрее не вышло. Может быть дело в for, и с помощью map мы сделаем всё быстрее?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.76 s, sys: 1.52 s, total: 6.27 s\n",
      "Wall time: 7.95 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "_=list(map(lambda x: r.set(x[1], x[0]), enumerate(objs)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Убедимся, что мы не забыли сгенерировать новые ключи перед запуском предыдущей ячейки - проверим количество ключей в базу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100000"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.dbsize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также убедимся, что работа со словарем всё еще быстрее. Кстати, значительно быстрее генерации ключей."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 36.1 ms, sys: 0 ns, total: 36.1 ms\n",
      "Wall time: 36 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "tst_dct={}\n",
    "for i in enumerate(objs):\n",
    "    tst_dct[x]=i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ключи в самом деле лежат в базе?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[b'5fb6ac07a99faadc79926517',\n",
       " b'5fb6ac07a99faadc799140b3',\n",
       " b'5fb6ac07a99faadc799108d7',\n",
       " b'5fb6ac07a99faadc799149d0',\n",
       " b'5fb6ac07a99faadc7991e1ff',\n",
       " b'5fb6ac07a99faadc79924985',\n",
       " b'5fb6ac07a99faadc79923a1b',\n",
       " b'5fb6ac07a99faadc799149a7',\n",
       " b'5fb6ac07a99faadc79913d29',\n",
       " b'5fb6ac07a99faadc799195ec']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(r.keys())[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем функцию mset, которая кладет всё содержимое словаря одновременно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 910 ms, sys: 48 ms, total: 958 ms\n",
      "Wall time: 1.09 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "objs={str(ObjectId()):i for i in range(100000)}\n",
    "r.mset(objs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "mkeys = list(r.keys())[:1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2.58 ms, sys: 866 µs, total: 3.44 ms\n",
      "Wall time: 4.65 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "_ = r.mget(mkeys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получается в несколько раз быстрее - около 130 000 ключей в секунду. Но это всё еще не похоже на миллион запросов в секунду.\n",
    "\n",
    "Хорошо, может быть это Питон не справляется, а база может работать быстрее? Попробуем запустить несколько потоков, которые пишут в базу. Оформим генерацию ключей и загрузку ключей в базу как отдельную функцию, чтобы можно было ее запускать в параллельных потоках."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putKey2Redis():\n",
    "    objs={str(ObjectId()):i for i in range(100000)}\n",
    "    #_=list(map(lambda x: r.set(x[1], x[0]), enumerate(objs)))\n",
    "    r.mset(objs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 23.9 ms, sys: 18.9 ms, total: 42.8 ms\n",
      "Wall time: 3.21 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pr=[]\n",
    "\n",
    "for i in range(10):\n",
    "    p=multiprocessing.Process(target=putKey2Redis)\n",
    "    p.start()\n",
    "    pr.append(p)\n",
    "\n",
    "for p in pr:\n",
    "    p.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "330 000 запросов в секунду. Явно улучшение не в 10 раз. Значит дело не только в Питоне. Но скорость уже впечатляющая. От обычной БД с настройками из коробки такую скорость не получишь.\n",
    "\n",
    "Redis умеет привязывать к ключу хешированный массив - аналог питоновского словаря. Попробуем класть его при помощи функции `hmset` (h - хешированный. m - много ключей сразу)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.flushdb()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def putKey2Redis2(my_key):\n",
    "    objs={str(ObjectId()):i for i in range(100000)}\n",
    "    print(my_key, list(objs.keys())[:2])\n",
    "    r.hmset(my_key, objs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hash_key2 ['5fb6b0f2d9ac4f1c17940405', '5fb6b0f2d9ac4f1c17940406']\n",
      "hash_key3 ['5fb6b0f26e575211c6940405', '5fb6b0f26e575211c6940406']\n",
      "hash_key7 ['5fb6b0f2681690e998940405', '5fb6b0f2681690e998940406']\n",
      "hash_key8 ['5fb6b0f2c7e3443646940405', '5fb6b0f2c7e3443646940406']\n",
      "hash_key6 ['5fb6b0f251e4b07de2940405', '5fb6b0f251e4b07de2940406']\n",
      "hash_key4 ['5fb6b0f24bc3ae3186940405', '5fb6b0f24bc3ae3186940406']\n",
      "hash_key0 ['5fb6b0f2728beefd58940405', '5fb6b0f2728beefd58940406']\n",
      "hash_key9 ['5fb6b0f281cc163114940405', '5fb6b0f281cc163114940406']\n",
      "hash_key1 ['5fb6b0f29a1f97489b940405', '5fb6b0f29a1f97489b940406']\n",
      "hash_key5 ['5fb6b0f2b37c5483b6940405', '5fb6b0f2b37c5483b6940406']\n",
      "CPU times: user 16.6 ms, sys: 39.7 ms, total: 56.3 ms\n",
      "Wall time: 3.35 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pr=[]\n",
    "\n",
    "for i in range(10):\n",
    "    p=multiprocessing.Process(target=putKey2Redis2, args=['hash_key'+str(i)])\n",
    "    p.start()\n",
    "    pr.append(p)\n",
    "\n",
    "for p in pr:\n",
    "    p.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[b'hash_key4',\n",
       " b'hash_key6',\n",
       " b'hash_key9',\n",
       " b'hash_key7',\n",
       " b'hash_key1',\n",
       " b'hash_key0',\n",
       " b'hash_key8',\n",
       " b'hash_key3',\n",
       " b'hash_key5',\n",
       " b'hash_key2']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'1'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hget('hash_key3', '5fb6b0f26e575211c6940406')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hmset(\"test_key\", {\"c\":3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hmset(\"test_key\", {\"a\":1, \"b\":2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'3'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hget(\"test_key\", \"c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hmset(\"test_key\", {\"c\":\"{'s':'d'}\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b\"{'s':'d'}\""
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hget(\"test_key\", \"c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[b'1', b\"{'s':'d'}\"]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hmget(\"test_key\",['a','c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Увеличения скорости не наблюдается.\n",
    "\n",
    "При помощи функции `hkeys` можно получить ключи для конкретного хеш-массива. `hmget` позволяет получить значения по нескольким ключам."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.flushdb()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 351 ms, sys: 34.8 ms, total: 386 ms\n",
      "Wall time: 385 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "objs={str(ObjectId()):i for i in range(100000)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 474 ms, sys: 8.64 ms, total: 483 ms\n",
      "Wall time: 602 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "r.hmset(\"longkey\", objs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "ho=r.hkeys(\"longkey\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[b'5f96a09a746fb4df4704f017',\n",
       " b'5f96a09a746fb4df4704996e',\n",
       " b'5f96a09a746fb4df4704f6f2',\n",
       " b'5f96a09a746fb4df4704ef8a',\n",
       " b'5f96a09a746fb4df470512ff',\n",
       " b'5f96a09a746fb4df47053293',\n",
       " b'5f96a09a746fb4df4703c936',\n",
       " b'5f96a09a746fb4df4703de5b',\n",
       " b'5f96a09a746fb4df4704b83d',\n",
       " b'5f96a09a746fb4df4704fb72']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ho[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.84 ms, sys: 0 ns, total: 1.84 ms\n",
      "Wall time: 1.17 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "oo=r.hmget(\"longkey\", ho[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[b'81071',\n",
       " b'58886',\n",
       " b'82826',\n",
       " b'80930',\n",
       " b'90007',\n",
       " b'98091',\n",
       " b'5582',\n",
       " b'10995',\n",
       " b'66773',\n",
       " b'83978']"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.87 s, sys: 1.45 s, total: 5.32 s\n",
      "Wall time: 6.82 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "for k in ho:\n",
    "    _=r.hget(\"longkey\", k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Redis поддерживает блокирующие операции. При помощи `brpop` и `blpop` мы можем приостановить свои действия либо пока не будет получено значение, либо пока не пройдет заданный промежуток времени.\n",
    "\n",
    "Если функция успешно получила значение, она вернет его после ожидания."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(b'blockedTest', b'asdf')\n"
     ]
    }
   ],
   "source": [
    "r.rpush(\"blockedTest\", \"asdf\")\n",
    "print(r.brpop(\"blockedTest\", 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если значение не было получено за время ожидания, возвращается None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "waiting\n",
      "waiting\n",
      "waiting\n",
      "waiting\n",
      "(b'blockedTest', b'Yahooo!')\n"
     ]
    }
   ],
   "source": [
    "def blockingWrite():\n",
    "    time.sleep(5)\n",
    "    r.lpush(\"blockedTest\", \"Yahooo!\")\n",
    "    \n",
    "def blockingRead():\n",
    "    bres=r.brpop(\"blockedTest\", 1)\n",
    "    while bres==None:\n",
    "        print(\"waiting\")\n",
    "        bres=r.brpop(\"blockedTest\", 1)\n",
    "    print(bres)\n",
    "    \n",
    "bpr1=multiprocessing.Process(target=blockingWrite)\n",
    "bpr2=multiprocessing.Process(target=blockingRead)\n",
    "bpr1.start()\n",
    "bpr2.start()\n",
    "bpr1.join()\n",
    "bpr2.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Помимо этого, к ключу можно привязать множество. Добавление в множество ведется при помощи операции `sadd`. Также можно находить пересечение (`sinter`), объединение (`sunion`)  разницу (`sdiff`) множеств."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{b'A'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.sadd(\"testSets1\", \"A\")\n",
    "r.sadd(\"testSets1\", \"B\")\n",
    "r.sadd(\"testSets1\", \"C\")\n",
    "\n",
    "r.sadd(\"testSets2\", \"A\")\n",
    "r.sadd(\"testSets2\", \"D\")\n",
    "r.sadd(\"testSets2\", \"F\")\n",
    "\n",
    "r.sinter([\"testSets1\",\"testSets2\"])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результаты пересечения и объединения можно сохранить в другое множество."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{b'A', b'B', b'C', b'D', b'F'}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.sunionstore(\"testSets3\", [\"testSets1\", \"testSets2\"])\n",
    "r.smembers(\"testSets3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Элемент можно атомарно перебросить из одного множества в другое при помощи `smove`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({b'A', b'D'}, {b'A', b'B', b'C', b'F'})"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.smove(\"testSets2\", \"testSets1\", 'F')\n",
    "r.smembers(\"testSets2\"), r.smembers(\"testSets1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Удалить значение можно при помощи `srem`, узнать длину множества - `scard`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.srem(\"testSets1\", 'F')\n",
    "r.scard(\"testSets1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Каждая команда возвращает объект типа `pipeline`. Данный объект позволяет выполнять транзакции. Для этого необходимо при помощи pipeline выполнить несколько команд (они будут поставлены во внутреннюю очередь), а затем вызвать `execute`. Таким образом поддерживаются транзакции для нескольких команд, не требующих промежуточного чтения результатов.\n",
    "\n",
    "В итоге вернется список результатов выполнения команд."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, {b'B', b'C', b'G'}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe=r.pipeline()\n",
    "pipe.srem(\"testSets1\", 'A')\n",
    "pipe.sadd(\"testSets1\", 'G')\n",
    "pipe.smembers(\"testSets1\")\n",
    "pipe.execute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, {b'B', b'C', b'G', b'R'}]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.pipeline().srem(\"testSets2\", 'A').sadd(\"testSets1\", 'R').smembers(\"testSets1\").execute()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если в промежутках необходимо модифицировать какие-то значения, следует использовать следующую конструкцию. В ней `watch` говорит, что мы будем следить за заданным ключем. Команда `multi` говорит о том, что сейчас будет выполняться несколько операций как транзакция. Если значение, связанное с ключем в `watch` изменилось до начала `execute` (выполнение нескольких операций), то будет вызвано исключение."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True, True]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ppp=r.pipeline()\n",
    "ppp.multi()\n",
    "ppp.set(\"dummy1\", \"1\")\n",
    "#ppp.multi()\n",
    "ppp.set(\"dummy2\", \"1\")\n",
    "ppp.execute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'1'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.get(\"dummy1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'2'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.set('OUR-SEQUENCE-KEY', 1)\n",
    "with r.pipeline() as pipe:\n",
    "    while 1:\n",
    "        try:\n",
    "            pipe.watch('OUR-SEQUENCE-KEY')\n",
    "            current_value = pipe.get('OUR-SEQUENCE-KEY')\n",
    "            next_value = int(current_value) + 1\n",
    "            pipe.multi()\n",
    "            pipe.set('OUR-SEQUENCE-KEY', next_value)\n",
    "            pipe.execute()\n",
    "            break\n",
    "        except redis.WatchError:\n",
    "            continue\n",
    "            \n",
    "r.get('OUR-SEQUENCE-KEY')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А еще у Redis замечательные [битовые операции](https://blog.getspool.com/2011/11/29/fast-easy-realtime-metrics-using-redis-bitmaps/) и отсортированные списки."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наличие хеш-массивов фактически позволяет хранить в базе данных объекты/словари/JSON и обращаться к ним при помощи уникальных ключей. Правда, плохо получается хранить в полях таких объектов массивы других объектов. Традиционно для таких задач склеивают последовательность ключей в один, используя в качестве разделителя двоеточие. Таким образом, вместо того, чтобы хранить список объектов, мы храним много уникальных ключей, которые известным образом можно соотнести с объектами.\n",
    "\n",
    "Попробуем решить следующую задачу.\n",
    "\n",
    "Есть квадратная карта заданного размера. На карте находятся растения, деревья, травоядные и хищники. Необходимо промоделировать поведение системы, обеспечивая обмен данными между частями модели через Redis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = redis.Redis(host='localhost', port=6379, db=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.flushdb()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "world={\"sizeX\":50, \"sizeY\":50, \"iniPred\":5, \"iniCarn\":20, \n",
    "       \"lifeExpPred\":10, \"lifeExpPredStd\":3, \"breedPeriodPred\":4, \"lifePredMin\":50, \"lifePredMax\":100,  \n",
    "       \"lifeExpCarn\":10, \"lifeExpCarnStd\":3, \"breedPeriodCarn\":3, \"lifeCarnMin\":50, \"lifeCarnMax\":100, \n",
    "       \"herbCount\":10000, \"treesCount\":500, \n",
    "       \"lifeExpTree\":30, \"lifeExpTreeStd\":5, \"breedPeriodTree\":6}\n",
    "\n",
    "r.hmset(\"worldDescription\", world)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У тайлов заводим свойство \"количество растений в тайле\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "tile={\"herbs\": 0}\n",
    "for i in range(world[\"sizeY\"]):\n",
    "    for j in range(world[\"sizeX\"]):\n",
    "        r.hmset(\"tile:\"+str(i+1)+\":\"+str(j+1), tile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Раскидываем растения по тайлам, увеличивая число растений в выбранном тайле."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(world[\"herbCount\"]):\n",
    "    x=random.randint(1, world[\"sizeX\"])\n",
    "    y=random.randint(1, world[\"sizeY\"])\n",
    "    r.hincrby(\"tile:\"+str(y)+\":\"+str(x), \"herbs\", 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(world[\"iniCarn\"]):\n",
    "    g=random.randint(0, 1)\n",
    "    x = random.randint(1, world[\"sizeX\"])\n",
    "    y = random.randint(1, world[\"sizeY\"])\n",
    "    carn={\"x\":str(x), \"y\":str(y), \n",
    "          \"carn_id\":str(ObjectId()), \"carn_age\":0, \"carn_gender\": g,\n",
    "          \"carn_life_exp\": random.randint(world[\"lifeExpCarn\"]-world[\"lifeExpCarnStd\"], world[\"lifeExpCarn\"]+world[\"lifeExpCarnStd\"]), \n",
    "          \"carn_hunger\":0,\n",
    "          \"carn_life\":random.randint(world[\"lifeCarnMin\"], world[\"lifeCarnMax\"])\n",
    "         }\n",
    "    r.lpush(\"tile:\"+str(x)+\":\"+str(y)+\":carns\", carn[\"carn_id\"])\n",
    "    r.hmset(\"carn:\"+carn[\"carn_id\"], carn)\n",
    "    r.lpush(\"carns_id\", carn[\"carn_id\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(world[\"iniPred\"]):\n",
    "    x = random.randint(1, world[\"sizeX\"])\n",
    "    y = random.randint(1, world[\"sizeY\"])\n",
    "    g=random.randint(0, 1)\n",
    "    pred={\"x\":str(x), \"y\":str(y), \n",
    "          \"pred_id\":str(ObjectId()), \"pred_age\":0, \"pred_gender\": g,\n",
    "          \"pred_life_exp\": random.randint(world[\"lifeExpPred\"]-world[\"lifeExpPredStd\"], world[\"lifeExpPred\"]+world[\"lifeExpPredStd\"]), \n",
    "          \"pred_hunger\":0,\n",
    "          \"pred_life\":random.randint(world[\"lifePredMin\"], world[\"lifePredMax\"])\n",
    "         }\n",
    "    r.lpush(\"tile:\"+str(x)+\":\"+str(y)+\":preds\", pred[\"pred_id\"])\n",
    "    r.hmset(\"pred:\"+pred[\"pred_id\"], pred)\n",
    "    r.lpush(\"preds_id\", pred[\"pred_id\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use('ggplot')\n",
    "#plt.style.use('classic')\n",
    "plt.rcParams['figure.figsize'] = (12, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def showIt(field, who, c_len, s):\n",
    "    for i in range(c_len):\n",
    "        c_id=r.rpoplpush(who+\"s_id\", who+\"s_id\").decode()\n",
    "        cx=int(r.hget(who+\":\"+c_id, \"x\"))\n",
    "        cy=int(r.hget(who+\":\"+c_id, \"y\"))\n",
    "        #print(\"pred:\"+p_id, cx, cy)\n",
    "        field[cy-1][cx-1]=s\n",
    "\n",
    "def showField():\n",
    "    sx=int(r.hget(\"worldDescription\", \"sizeX\"))\n",
    "    sy=int(r.hget(\"worldDescription\", \"sizeY\"))\n",
    "    \n",
    "    carn_len=r.llen(\"carns_id\")\n",
    "    pred_len=r.llen(\"preds_id\")\n",
    "    field=[[0 for j in range(sx)] for i in range(sy)]\n",
    "    for i in range(sy):\n",
    "        for j in range(sx):\n",
    "            try:\n",
    "                field[i][j]=int(r.hget(\"tile:\"+str(i+1)+\":\"+str(j+1),\"herbs\"))\n",
    "            except Exception:\n",
    "                print(\"Except:\", i, j, r.hget(\"tile:\"+str(i+1)+\":\"+str(j+1),\"herbs\"))\n",
    "    \n",
    "    \"\"\"for i in range(sx):\n",
    "        for j in range(sy):\n",
    "            herb_cnt=r.hget(\"tile:\"+str(i+1)+\":\"+str(j+1), \"herbs\")\n",
    "            field[i][j]=herb_cnt.decode()\"\"\";\n",
    "    \n",
    "    showIt(field, \"pred\", pred_len, 10)\n",
    "    showIt(field, \"carn\", carn_len, 12)\n",
    "\n",
    "    ax = plt.subplot()\n",
    "    ax.imshow(field);\n",
    "\n",
    "        \n",
    "def moveIt(who, c_id, sx, sy):\n",
    "    #print(who+\":\"+c_id, r.hget(who+\":\"+c_id, \"x\"), r.hget(who+\":\"+c_id, \"y\"))\n",
    "    cx=int(r.hget(who+\":\"+c_id, \"x\"))\n",
    "    cy=int(r.hget(who+\":\"+c_id, \"y\"))\n",
    "    \n",
    "    while True:\n",
    "        _cx=cx+random.randint(-1, 1)\n",
    "        _cy=cy+random.randint(-1, 1)\n",
    "        if _cx>=1 and _cx<=sx and _cy>=1 and _cy<=sy:\n",
    "            break\n",
    "    r.hset(who+\":\"+c_id, \"x\", _cx)\n",
    "    r.hset(who+\":\"+c_id, \"y\", _cy)\n",
    "    r.lrem(\"tile:\"+str(cx)+\":\"+str(cy)+\":\"+who+\"s\", 0, c_id)\n",
    "    r.lpush(\"tile:\"+str(_cx)+\":\"+str(_cy)+\":\"+who+\"s\", c_id)\n",
    "\n",
    "    return cx, cy, _cx, _cy\n",
    "    \n",
    "\n",
    "def moveCarns():\n",
    "    carn_len=r.llen(\"carns_id\")\n",
    "    sx=int(r.hget(\"worldDescription\", \"sizeX\"))\n",
    "    sy=int(r.hget(\"worldDescription\", \"sizeY\"))\n",
    "    \n",
    "    for i in range(carn_len):\n",
    "        c_id=r.rpoplpush(\"carns_id\", \"carns_id\").decode()\n",
    "        cx, cy, _cx, _cy = moveIt(\"carn\", c_id, sx, sy)\n",
    "\n",
    "        h_cnt=int(r.hget(\"tile:\"+str(cy)+\":\"+str(cx), \"herbs\"))\n",
    "        if h_cnt>0:\n",
    "            r.hincrby(\"tile:\"+str(cy)+\":\"+str(cx), \"herbs\", -1)\n",
    "        #print(\"move \", cx, cy, _cx, _cy)\n",
    "\n",
    "def movePreds():\n",
    "    pred_len=r.llen(\"preds_id\")\n",
    "    sx=int(r.hget(\"worldDescription\", \"sizeX\"))\n",
    "    sy=int(r.hget(\"worldDescription\", \"sizeY\"))\n",
    "    for i in range(pred_len):\n",
    "        p_id=r.rpoplpush(\"preds_id\", \"preds_id\").decode()\n",
    "        cx, cy, _cx, _cy = moveIt(\"pred\", p_id, sx, sy)\n",
    "        # Кого-нибудь съесть.\n",
    "\n",
    "        #print(\"move \", cx, cy, _cx, _cy)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(r.hget(\"tile:49:4\",\"herbs\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdQAAAHSCAYAAABVfjpxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3df3Rcdb3v/1eSSRimNAlpQtukID/iPRlKuxSLLUhbKF0glOspXUqPYM9SOSo/Lgrcexalx2/xy1J+6OkPxWiFhXIO4rV6b+1RjtXz7e2CVqHaCqxgSdG48ECalmQ6TWmZjslk8v2De2r3nunn/WnyaWo5z8dfnb0/+ew9n9l7vzuz9/v9qRgeHh4WAAAYlcoTvQMAALwTEFABAAiAgAoAQAAEVAAAAiCgAgAQAAEVAIAACKgAAASQGM0fv/jii/rOd76jYrGoK664QgsXLjT/Jv35VYf//cNbbtBHvvm9yPqGziHn39du32Vu480ZLWab1O5DzvXNq181++jMTjTbDK5vMtv0p92pwM2b7VThXFP0/0ZP3nODbnwgOrb5xgpnH/mmorkdn33Jpquc66dsOmj2kdiVNdvsvGuK2eaOKzc41695coHZx/s/9FLk9RemLtcXdtwXWfbrH09z9pHMhEn3nrThdef6nffbx1vzuhqzzeCn9pptqh+d4Fzfs2jA7CPZeWrkdblrwpT7n3V3Mmu6uZ2uxSl7X/rc3y+sa5NUeh6Wk+qzzzOffizx873s2Hqci5bM9HFmm8aOt0a9na7b3NcVSWpd8oLZJnfdTPd6j7F/Yc1dZZeP+FMrFot67LHHtGzZMq1atUq//OUv1d3dPdLuAAA4qY04oHZ1dWnSpEmaOHGiEomELrnkEm3bti3kvgEAcNKoGGnpwa1bt+rFF1/UzTffLEnavHmzfv/73+umm26KtNu4caM2btwoSXrwwQf1211vHF53XlOD/tAX/Wkvcci9O5W5QXPfiqlqs03loPtnl+qz7J+r8gX7F/PhfrtNIeleX3PA7ELF2Fs+Z9IEvbon+rNdMeH+ybeYsA8Fn30pnOreTs2b9k9nGrTb5Cfan/PE2v3O9X3ZerOPcfXR2wPNycnqye+OLHurP/rTZVxlIcxPvon97uM/32IfbzX73J+PJA03Fcw2FX3ubQ2cbr/nynz0//Tlrgk1u42fJce5x16S8g32d4fKgntcrGuTVHoelt2OfQnz6sfsI3a+lx1bn3PRUEjZY5vI2T9zW/Jn2Mdt8tWc2aZY7/6J2mfsz3/XpLLLR3UP1cf8+fM1f/78w6+P/A2fe6hv4x5qKe6hlsc91DK4h1oW91DL+4u8h9rQ0KC9e/980u3du1cNDQ0j7Q4AgJPaiAPqeeedp927d6u3t1eFQkHPPvusZsyYEXLfAAA4aYz4J9+qqip98pOf1Je+9CUVi0VdfvnlOvPMM0PuGwAAJ41R3UO98MILdeGFFx7T3xx5L6myMFxyb6lnjvs+XzZ91jFt42hyTe7f/buem2r2Ud9p3yT3uXfQ2OFe73M/MbskOi7FREXJPZTxl/Y6+2gw7olJfvcXzn7iNed6n3vcuen2f87qO80mevKvLnKuz6fd99IlqePbF0ReH7onWbJMjfa+WHyOFfMeaeYUs49s2v4Mkx73/qvlvhdYv8V42k5S3mPcrt2xz7l+9fP2vbX6Lfa52j/bfSxk5fHwk8dzCPlGe3997tdaGjui76fmxqGSe6bW/U/r+Q5JSvbZY2tdw3yeh2he53FdN+6PHm9USgIAIAACKgAAARBQAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAI57Ld+4I/OaCsnSPCerVmzKKpQtv9qSIern9swxm6g/bdcQbV3rLujsk7fpo+4+9750LbbzyXxyP/dc7c4h9all6qPxkefsRh3uOq/Vk+26ttl0dFzK5fhauc9WHWXJr1aplWfqc9z6nEPd804z20za4K6rnWqxS5HGz9VyuelWveV6j7xznxzffKP9ni1WPWApTF1nqxa5VCb3c3CodJlxrbSuTZLfsWJdE1rX2p9PbrKdB2zVMZD86geMFN9QAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAGMeWEHS8+iAXeDjF0oQY15s0nzOndCv0/idPNmO9HYZ0JuqxCFT1J67fZownbN9QMlE33/cYl7cvb6ztEnnEv2/vokgvskv2c+fbHZpn+2+1hoXmd24WXShted670mVc/YE3JbY9u12KeQiNnEa6Js6z35nEPx95PIFUuWWe+pweO49Tnm4pNvx4UqLOCzvxaf4jXxog2FuuqSAgs+1xZLiMnQQ10T7rjyp2abNX3uQiGjwTdUAAACIKACABAAARUAgAAIqAAABEBABQAgAAIqAAABEFABAAiAgAoAQABjXtihefOfk3NrFkRfS1Lt9j7n3/skyGfTdgJ2Nu1en9ptdjFm/JKe7SRuK1k/mQkzk72VAP/+D71k9tH10Pn2djyKZrS2u5POc5PNLpRPRwsUFJPFkmVW0Ywp9z9rb+i6mWaTrtuqnOtb23P2drZ22G1ue6/dRu7iKD7FB+KFN/JnVJS8x2Sn+3PONYUpSGKdZz6FBVrX2oUSghSZaPIo7OAhRFEZn/Mw3+i+tvgUEsmn/2S2WfOkXbQhRAGPo+EbKgAAARBQAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEMOZ5qEdOwDswvnRC3lzTmfE/ibAmcpakbNqdEyjZuUg+EzX7SPbZuZ3jL+11rm+8psvso+uJaN5g4bThkhw/Kycz1CS/2bQ7V7IzO9Hso85jcurBT9k5l13pRuf6eB50OfFxS144XLKse567D5/J0EPYv9wekwmfmWK2qd9iT3a+pf2bzvWfeG222Uc837hmZoWa10XzW3vmuHMUp2yy37NPbqE1IbpPXm1iV9Zs09Bp74t1/fG5rsQn/q4clFJ90bG0JkTPN9rXBJ8c0ubN7japTfb57vMZ+uQkW2P7Pxc+bPYh/Y+yS/mGCgBAAARUAAACIKACABAAARUAgAAIqAAABEBABQAgAAIqAAABEFABAAhgzAs7WKyJaOOTZpfjU3zAShL2Sfi3EsF95TonONd3rXIXJ5CkpgmZyOvqxJCaJhyILOued4azj3gieDk+kwlbRTOuvXGb2cfj068x22i9nWifNI4nyeM9x46VYnXlMU9C7FOQxJqkXJKSRlGAwYxdkOHNGXYivs/+njf7E8718QIN5dRu3xV5XZkbLFmW2t1g9mOxChhIkhrdBUnkcV1p7Bj9vkr29adnkce1p9Mef4vPtdSnsIZVNKZnjl1Ix+eabMWPt/txH/8f1e1mH69+rvxyvqECABAAARUAgAAIqAAABEBABQAgAAIqAAABEFABAAiAgAoAQAAEVAAAAhjzwg5tK7sP/zt5+WDktSS9OaNl1Ntovftls83m56a6+1hrJytnptuFBfpn5802bct2OdfXbje7KBm3itaEqh+NFYxIu/vIpo3EdtlFGyR7XFb/29VmH60db416O5KUbzKKGHSaXZQcT6dMzpcs63rofGcfhRY74X/8pb1mm8H1Tc71jR7jZiXZS37FFHwKN1jix20xVV2yzCqg4nMctK4d/fHkcy778DnPrIIKbcv6zD4Kr0evrZX3XKfUj34VWdb0qVZnH4Od7uNNkroW20UZJPd5WN9pF2So3d5ttmm9e7/ZpiNzgbsPj2NFFHYAAOD4IaACABAAARUAgAAIqAAABEBABQAgAAIqAAABEFABAAiAgAoAQABjXtjhyKTtkSRx++j4tjtxV5Ka+9yJxl5FAzxmh092nmq2sey5+kyzTTyhv3KwWDKW2bSd0B9CyhjbfKOd2B5q/OuNwg09i/5k9pGLHU+H7kmWHGP5tHtfeubYye+t95lNlJluNNjaYfbRMHmm2SaxK2u2GVyedK7ve6XR7CPZF/0/feHUipLCB6nd7j58joPcZPs8rF7oLpbQHC+UUq7NaruoTPePp5ltrHPIR+bTF0deF5rGlSzr3+suVpH0ucb12W2soiXVm+2x9bkO7vm23Wb6J3/rXP9rj8/naPiGCgBAAARUAAACIKACABAAARUAgAAIqAAABEBABQAgAAIqAAABjHkeaq7pzzG8WB19/TZ3vlhp+1I+eWkpe35ekzUJsO++WJOqjyTPrlhd6ZV7F9mONRm3J2sC5YbOIbMPr8/ZY38bOt2fUcpjkuza7a9HXiduHdSkDdFlf1xylrOPeL5lOT4Tf5vH3CwrUbV0wvRyeu44x2xT/aj7+GqWfX6kdkcnrK+5cahkEvuu29zHU/0Wezu123eZbQrGpOqZ6fZn6JMDP36hPZF8T3q8c3027T7epNLzo5CU+tPRsbImic+mzc2UfF7l5DrtPFOLT26uz3XD+ozy6ZFfB/mGCgBAAARUAAACIKACABAAARUAgAAIqAAABEBABQAgAAIqAAABEFABAAhgzAs7HJlYXC7RuLHDPcG4Ndmw5JcgbyV6D37LPXmyJA2ubzLb5NMeE6Z3upOrfQohxCcTLzfBuDXJdX1nmImarYILg5futfv4xRlmG2vycEnqmWO3scST6Acm1JQUcrAKLsQngC/H57jtn+2eELp/tj15u88E12fves1sU2vUSvCZEDrXFJ1IvpCqLJlcPmkcl3l7HnOz8IZkn2fxYh7l7LzfvibUe1w32oxt+YxtMhMdt0S+9BzPpt3fqXyK18Q/r3Ks4jQ+xSF8thNiYvZ8o30OHY0ZUL/xjW/o+eefV11dnVasWCFJOnjwoFatWqW+vj41NTXpzjvv1Gmn2RcDAADeqcyffC+77DItW7Yssmz9+vWaNm2avva1r2natGlav379cdtBAABOBmZAPf/880u+fW7btk1z586VJM2dO1fbtm07PnsHAMBJYkT3UPfv36/TTz9dklRfX6/9+/cfte3GjRu1ceNGSdKDDz6of/mbGw+va22YEHktSckrR/8b+ECt/Rt4zfUDzvVD77LvJw6n7eErnGbfg6iZaW/LUjkYHbezzm5U+2M3RZblG9z/f0q4b8/93+3YbQbcdb1VnSyYfQxNq7b3pWCPbcG+Fe6xnejnc15Tg354yw3HtC+JnH1c+xy3xeToz4/Ky+xnEa3zw0ehzv4M486ZNEFP3hMd22Ji9OeHj8Qh92dYmbMP/nyLfU1IXGq/n8St7m2N1dj6nGM+rO3U3Gg/J1JI2cetz/XJ3M6pIz/eRv1QUkVFhSoqjr4D8+fP1/z58w+//uvvP3n43//yNzdGXktS69rcaHfJ6+GOs59wP3SxN9BDSdZDJJI944OP+ANI7Y/dpNtueiyyrGvx6B9K8rnp3zPH3U/TX2XMPg54PJTk88BE/KG3kYjPFPPDW27QR775vWPal1APJXk95GZIdtoPllnnhw+fB2finrznBt34QHRsfWZbCsF6KMlnxhqvh5K22NcW6wGosRpbn3PMx8n0UJI1W5YkdX7xzrLLR5Q2U1dXp3379kmS9u3bp9ra2pF0AwDAO8aIAuqMGTP0zDPPSJKeeeYZXXTRRUF3CgCAk435k+/q1av18ssv68CBA7r55pt1/fXXa+HChVq1apU2bdp0OG0GAID/zMyAescdd5Rdvnz58hFtsG1l9+F/Jy8fjLyWpDdntDj/3uf3bZ/f4wstDc71Ez6TNfv44xL73o7P/ZIt7d90rl8w81qzj/g9lXIJ8pL7fojf/Ub7Rw2r4ELdWve9XEmqk/0Z+txzbF3rvneZ2GV/zjvvmhJ5XUwMlxSvyBu3ziZtsLcj2e/Hut++YuXXzT4+0fk5s41PIQRLqPti1r3NXJN9TIa4t+YzJndc+K9mm6fa5456X3zO1fi9/2KiouRepnWP1OcZEJ978ieT0dw3pvQgAAABEFABAAiAgAoAQAAEVAAAAiCgAgAQAAEVAIAACKgAAAQw5hOMH5lnWkxVm3mncdbk1ZJds1aSmje7c41y0+1ameMv7TXb1N1n78vUr9/qbrDE7KJkXMpN3u5Tq9fik88Xrysc17z6VbOProfON9v4HAvXPvaMc/1TN9k5gfH60skri8dcc9rnOPfJ29y/3L3d/3fOdWYfDTPsQuQ+rNq2Vq63VFrjtVyuZH/aqDfb53Nc298drPq5PYvsOr1rnlxg78o8u0mDkdtpXb8kKbU7ejzV3DhUcoxZudxty/rM7YSYvN0nH7xxa4fZJvPpi+1+jLraqR/Z29Ga8ov5hgoAQAAEVAAAAiCgAgAQAAEVAIAACKgAAARAQAUAIAACKgAAARBQAQAIYMwLO/QsGjj874HThyOvJXsCZR8+BQxyTe428eTyciZ9xp58d+ddjWYbyV2g4FiLCEjliw9YydPxScpHykoW7/7xNLOPs7e/ZrbJpu2E8h98/oPO9YPL95p9VD86IfK6WF2p3ORjm1R58FP2duRRBCTd8IZz/a+X2GPrU0DCZ/L2njlTnOt9ig/EE/4Th4ZLlmVV5ewjn3YXEpGkBo/rilV8o7Xd3k5muv2eGx95zmyTu26mc3027R6Tt0WP0XLHrVVwYedd7s9YktpW2ueqXfzBLnySDTDpvST73DXG3oVvqAAABEBABQAgAAIqAAABEFABAAiAgAoAQAAEVAAAAiCgAgAQAAEVAIAAxrywQ/KImegrL6uMvJakbNrqwV0EQZJSfXYbS77RTpz2maneZ3+Tfe7/1/gk2Scz0YTyQqpSmenjIssmGYUdqhf2mdvJ/uIMs42VLF67fZfZh5VkL/kVKLCSuA94vB/FjsnCqRUlifXWe+7bO97cTPVku/hAx7cvcK4/e4OdZO8zttb7kaRcxn3c9swxuygxMF7qmRMtqlLfaRRL6PQpsmG/H6tYQs8i+5rQtux1s82bHoUDUrvdRSSyafua4CPX5P4M6zvtPgotDWYbn3PV4vOevY5b4z33p+3iHEfDN1QAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACGDM81CPzEequXGoJD/JnPzVIy8qnsdWjjX5sU8+U+vdL5ttej9SZ7axJvbun21PZB5vUThtuOTvUn3u/MO+vQPO9ZKUNFvYfPIgfXJVffKArcmn/3DFd8w+Zt/2mcjrcpNgW9qW2Tm+PnLGseIzSXxjx1tmm3gO80j6aewwuyiZ9D55+aDaVnZHln3wZy85+3j8q9eY2/G7Jrg/01zGPvp9jm2fycFTu80mpni+ZbHazsEcCZ88eYtPnur4S3vtjjonmE2s66nPNUH672WX8g0VAIAACKgAAARAQAUAIAACKgAAARBQAQAIgIAKAEAABFQAAAIgoAIAEMCYF3aw9CxyFxdobbcT6us77aT0nkV/cq6f8+4uu487zjHb5GbYkx9bE3u3fcYu7BCf5Dd54XDJWHUtdie312+xE9fzjWYTM3ncZwJ4nwIFPqz3tGDZtWYftYoWmajMDZYUnrAS+n0mYQ5h0gaPCa49ig/4sIo/+BQkaV4X3Zdiqrpk/9Y86S7gkU/bx1Pr2pzZJl5kIi7rUUikPz36AhKS1LU45VxvTrqu0vOscrB0mVXwovXOreZ2EmdOMdtYRVh8Con07/WY4N2jIEzPHPf+xgu5lPPL/11+Od9QAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAGMeWGHIxN4C6nKkoTe1va3nH9vJV9LkkftAU3a4O5n811TzT6aJ9vJ1a13v2y26fj2Bc71e642uyhRbmzbVrqT/n2KKYy/tNdsU/3oBOd6q3iHJCU77YIYUzYdNNvkJrv78XnPjY88F10wMKDC693R7Rj91G63j9t4n2X3RdOd632KNmTTdoL82U+8ZraxtjXdozhKR1P02C9WlxYGyacPOftoXldjbscqlCBJanSPS2u7fbz5bMcqpiBJzZvd15bUbrtQhXXsS1J9p3tfulbNMvuw9lWSGjrdxSy8xsTjc955f5NHP/b+jhTfUAEACICACgBAAARUAAACIKACABAAARUAgAAIqAAABEBABQAgAAIqAAABjHlhh+qFfYf/XVFfiLyWpK7Z451/X7/FTsTvn50327Qtc69vXWsnTvuwijZIUmOHu5iFz2z28T4SuWLJMisRv6SAQTkd7sICkpTYtcu5vna7vZk/LjnLbOOTuJ7a7S4K0Hr3q2YfXX0zI6+L9eOUuy66LN/oTkz3Kbgw+K2k2abvFY8CBYbmze4ke8lvf81k/IfOt3fGzsNX27I+u5EhtbvBbLN/ufucT+yyryvNm0d/TProus0uztHaHt1O5WCxZNs9c9zHk0/RBh+pH/3KuT6ZvsTsI9dk70uIY8Xn2nM0fEMFACAAAioAAAEQUAEACICACgBAAARUAAACIKACABAAARUAgADGPg/1iMmnK1oTJZNR1ze5Y3x/2s5Fqt9i5/NZuUb5pqLZR9tKe0Lo/LzTzDaWeK5uOYkNsRy5waGSydiz89zvObXbzjH9+bp/Ntuct/Zm5/pQuW3xiajLSe12r9/8nD2RvOZEXw6ML83BrO+0JoS2cw9zxsTsktRqTCztk5vrM8G7zzmU7HPnoQ5+yp6MXuvtRFQrJ9ZncmprIm1JSj3qHrvC6+5cSklKtdj5rj6TkFv727zOvj6V5IOXuSZYebM+x63P+/HJM7Wk+uz3XAgx/o0jzxPmGyoAAAEQUAEACICACgBAAARUAAACIKACABAAARUAgAAIqAAABEBABQAggDEv7JBN/3li3MKpFZHXkpTMjD7p35rsWZLOfuI153qfSWZ9JmGesumg2abbKP7QYCScS9Ifl0THcWBCTcl7yKfdCcuJJ7LO9ZI068UPm22Sfe7/p2XTZhde4+ZTxMBq45PwHz+eKgsVJe8x1eeetPvax54xt/ODz3/QbGMdKz7j1tpuNlFusp1En290T3I96FG0YdKG1yOvE7cOliyz2edhNm1/d+hPu4+Ftu1TzD52ekz8Lf3JbDFpg7uYy56rzzT7yMXaFOqqS/7OKhrjVWxkrbvYiCRlpo9zrvcp2KNOu4l1fkhS61r3OeLTx9GYATWTyai9vV39/f2qqKjQ/Pnzdc011+jgwYNatWqV+vr61NTUpDvvvFOnnTb6qkAAAJyMzIBaVVWlJUuW6Nxzz9WhQ4e0dOlSTZ8+XU8//bSmTZumhQsXav369Vq/fr0+9rGPjcU+AwDwF8f8HeT000/XueeeK0k69dRT1dLSomw2q23btmnu3LmSpLlz52rbtm3Hd08BAPgLVjE8POx907K3t1f33nuvVqxYoVtvvVWPP/64JGl4eFif+MQnDr8+0saNG7Vx40ZJ0oMPPqjf7nrj8Lrzmhr0h77ofbvKgnt3CnbNblUW7PtiNXvdBcIHJtSYfSQO2UNXOWjfixqodd938dlO4dToey43tsWke1+SuwrmdobeZY/t0MFqs42l5k33PUlJKlaP/pm6oseuFhP22Fqf0ekt+83t7NtVZ7aJf85xPuPmw2dsrX2xzmVJSuwfjLw+q3WiXut64yityyum7A/R2ldJKibc+5t8Y9C5XpLyLWEeS7HOxULdsZ9j50yaoFf37I0sq6h3b6eiz34/Pte4Qsp9PPlc12sO2G18PmfrHLGux5J0QcvEssu9P/18Pq8VK1bo4x//uFKpaLX+iooKVVSUfyPz58/X/PnzD7/+yDe/d/jfP7zlhshryX4oyefmtfVQjBTmoaSGTvvi5TNbg/lQksd24g93lRtb66GktmX2rDZ7v2Uf+Qd+cYbZxhLqoSSzD48Za+IPJZUbW+szuv6LPzO34/NQUvxzjvMZNx8+Y2vti88DhvEHkL76k7v0uf+60vy7I/k8HGjtq2TPMOUzu9TO++0HsXxY56LPQ0lxT95zg258IHrcWg8lxWcDK8fnGhfioSSfWap8PmfrHPF5KKnzi3eWXe71X/xCoaAVK1Zo9uzZmjlzpiSprq5O+/btkyTt27dPtbW1Pl0BAPCOZAbU4eFhrVmzRi0tLbr22msPL58xY4aeeebtVIBnnnlGF1100fHbSwAA/sKZP/m+8sor2rx5s8466yz9/d//vSTpox/9qBYuXKhVq1Zp06ZNh9NmAAD4z8oMqG1tbfrBD35Qdt3y5cuPeYNH3lepLAyX3Gexfkv3+R0912S32XmXO0m7ebN937J2+y6zjc+9WOteU88i9wNUkpTstO95tba735PPvajB9R73HGe776lY+yFJ+5fbyeJ195lNzHuB0z/5W7OP3o9EHxaquX6g5B68dU/rqZvmmtvJzvMpCuBm3auSSu9blpObbt+js+5FdXkUOWjsaIguqK5SoSW6rGtx9JmNOJ/CApLH/XajcIB1zZCk1nZ7X6z3I9nPKjTe95bZR/zYrxyUUn3R+8Q9rzQ6+0h6FMTomWO/n3qPogwWn+vtlvanzDZTdatz/WiKC1F6EACAAAioAAAEQEAFACAAAioAAAEQUAEACICACgBAAARUAAACGPMJxj/+uZ8e/veEMxZEXkt2PVOf2qteGt2T/PbMOcXsIpsOU++3Z467oHPzOrtQf8+caH5ZMTFcUpvUqlHpk3/lU3Ozfos7h67rtrzZR9KjHnDfYrsot5W3HM8xLSeeF1kuV9LK7fTJYWxb6a4vLdn5rvE8w5GK1y8ux8oz9cmN7op9hvmGypI8zTuu3ODs4web7RrIPszz0CMHPrEra7Zp3uyRE7vZXUO36zY7N71+S/RaWawuvX42b3YfL4Of6jW3k9873mzT2OG+Dqb67DHxqV/8vi/cYraZ0uHOnx5NjXC+oQIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACICACgBAAARUAAACGPPCDs8f+HMxhA8VT4m89uFVWKDTTkq3ig9UL+wz++hrtBOacxn3diR78t2sxyS/ydjuVhYqlOyL/p1VZMJnAt9Unz0Jee32buf6kkmly+ieZzYxi3NIdoEOn+Ic8cnENThUksBvFW7wOSZ33t9ktpFRfCPfaE/qPaL3XMYfl7j7GUkf5Y7bEMVefApVtK4d/YTpks/5YZ9nJcVEYuq32BPJx6+VhTX3UNwAACAASURBVGS566d77PqNCcglqW2l+3yXpHs3/8i5/pYHPmv2EapoSYgCN0fDN1QAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACICACgBAAGNe2GHzc1MP//vAu5KR15LULHdSrU+CfGPHW2Yba1b2Ho+E5ubNdgJw692/Ndts/n2rc71VhEIqTdguJoaVb4omQucy7v8/pYxkcknqWTTg0cYoUJBxF1uQ7CR7SdImu0lmuvt4qV7Ya/axMx19P/mWREkRhtb2nLMP63iTJHl8zlZye+vdL5l99H6kzmyz5+ozzTZWArxV+MGXWQhhhl1Mwee7Q2a6u1jCH674ptnHeZmbzTa5JntsrWuYV6GKO5+LvE5+YKFa79waWZb59MXOPnyucW96jP9/v+u/Odf3L8qbfaTW1ZhtfEzZ5HFtGSG+oQIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACICACgBAAGOeh2qxJgv2yb+yJpCVVJKjGeeTf9Uzx96X3LcvMNvUG+t98mobO6Kvk1cW1bo2mhsZnxQ7zidvsH7LyCffPRbWvkr2JMySnbeZui9l9jFhV3T29uS0gtqWRZf57IuldPLnUtYE4l0PnW/2kV3iM1G2zZqw3meycx9WnqNPbnRru3tfJTsP9X1fuMXso23D62Ybn2PFK2/Z0L3sksjrgcmnlSyzPsNs2v4Mx19q53KnG95wb+fH08w+smmzifl+JKl59avO9Z3ZifaGjoJvqAAABEBABQAgAAIqAAABEFABAAiAgAoAQAAEVAAAAiCgAgAQAAEVAIAAxryww5HFBo5X8YF8+pC9H0ait09xCDXa28k3jj5B2yfJO56APVBbVfIekhl34vpYsYotSH6fs08StzU5tU+SfXxfBibUlCyzCoXEJ3Yua84ss4nPew7BZxJm67j06aNrcbSwRjExXDKWWbmLCzR7TDzdtdguwtK20l2UwWcibZ+J2ftn25NpK+Pe37aVr5ld7LxrSuT1SMbW5zPMZJrMNh1yt8mn7WuCGv9kNsllkmabzb9vda5Pdnpcsz9YfjHfUAEACICACgBAAARUAAACIKACABAAARUAgAAIqAAABEBABQAgAAIqAAABjHlhh8z0PxcXKKQqI68lqf82Y4b4jJ0A7JWYK3fCspWoL0n1W+wkYmnYbJFvdCdx55rs//ec/UQ00bvm+oGSZTvvdydX+4xbY8dbZhsr4b9n0YDZhzKnmE16muxk/drt7vXxwgLl1HdGP8PKwrCSmeiyvJHb3rXKLtpQ32m/H+t4sgpZSFLr3fvNNj2bzjHbxIuJlPQxxx7b5s3R91OzoHTZ9V/8V2cfq//tanM78QIy5ViFG3zOQ5+iJf0ex7Z1LPgUPmldG73GlSukE7/+xlnrJanxkefMNj/vedG5furXbzX7aNhsF/Co3e4uziFJkza41xde7zb70BfvLLuYb6gAAARAQAUAIAACKgAAARBQAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAMa8sMOkDX9OvE3cOhh5LUmNHQ3Ov89Mt5PfU31DZhsrod8nEdwqYCD5JdrvufpM53qfYgrxRO+BCTUly1qXPOvsI/Ppi83t+CR6W1rb7c8nN9kuiOGTaL/3W+7iG/Xr7eMpXnijmKgoWVbf6e7D5zPU1g6zifkZGcUJJGnPt93HmyRVL+8z2+gXpzlXxws0jNQPPv9B5/pk2j4OEruyZpta41TtuWuK2UfKY9h8Cnj85gvfdK6ffdtnzD7i16didWXJMqsQRWr3IXM7PteN2bfNdK5vkH1N8LmWWsU5JPu6kW+0i2YcDd9QAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACCAMc9D3XlELld+YnXktWTnrvlM4OuTn9i20j0Rrc8EvvFJpsvui5FjKtk5ij65n/F9KTcJtpUvZk107iuftnLXPCYt9snblJ0HnFvvnvnbZzv7l0dzkqtOG9T4S3sjywaN7fjkLGeXXWK2aeh05+tZk35LfsftgV+cMep+fM7D+OTUlfdcp9SPfhXt5zp3DmO+yb4mWLnekn1t8clN98l3TbW4c+0l6by1N7v3Zbe9L/Fc+4HxUs+cYzvHW9fabUJdky0+ecA+uc8hrrdHwzdUAAACIKACABAAARUAgAAIqAAABEBABQAgAAIqAAABEFABAAiAgAoAQABmYYeBgQHde++9KhQKGhoa0qxZs3T99dert7dXq1ev1oEDB3Tuuefq9ttvVyJh14loW9l9+N/JywcjryW7oIJdNMBvAmtrIlorgV7ym3zXmshcklJ97qR/a7JhSZr69Vsjr8tNgm29p+qFe83tVD86wWxT+4R7luWCR2K7T4K8JtuTCVtJ3D6fT+t90ddVj1Wq7r7o33XPcyfM96fthPr6Tjsp3adwg2XSBndRE8mvEILVj8/nrFnTo6/HnVqyzJpYOpu2i7D0p+3iA9b3i55FHmOfsYsP+Eww3rrWp7CJW7Iv+n4qCxUly6yiGN3z3JPIS36FQqziDz6FH0IV1rCObb+iMkfZvtWgurpa9957r5LJpAqFgpYvX673vOc9euqpp7RgwQJ94AMf0COPPKJNmzbpyiuvHPGOAABwMjP/W1BRUaFkMilJGhoa0tDQkCoqKrRjxw7NmjVLknTZZZdp27Ztx3dPAQD4C+ZVy7dYLOruu+/Wnj17dNVVV2nixIlKpVKqqnr7J5CGhgZlsx4/0QEA8A5VMTw8bP8A/n+99dZb+sd//EctXrxY7e3tevjhhyVJmUxGDzzwgFasWFHyNxs3btTGjRslSQ8++KB+1/Hn+y5ntU7Ua11vRNoPTKhx7kMxad8LSfbab6lYPfrnsSoH7X3JN9jbqTngXv9X73Lfk5SkHb3RYubnNTXoD33R/+QkDrnHZbipYG6nos/+P1hlbtDdoNrjXtSgfQ+7mKq298X4jHw+n2Q22sdZZzfqtT9mIssGat3vqZiwj8lE3myiYmL0ExjU7B0w2xTq7LFN7A/wOceUG1vrWLCuGVKY8S+c5nGpLNifj8/nnMj53PN1ix+T5a4J1rhUeryfyoI9LpXGoVK0Dze/MfG4bljHts92/ku6ufzfmn95hHHjxmnq1Kn63e9+p1wup6GhIVVVVSmbzaqhofwDCPPnz9f8+fMPv/7cf115+N9f/cldkdfS2D2U5DP7hyXUQ0nWDAlb2r9l9vGRb0YfSvrhLTfoI9/8XmSZ9VDS4KcCPZRkPEQS6qEk68Eyyf6MvB5Kij0M0f7YTbrtpsciy6yHN3xmRPF5WCXEjEBnP/Ga2WbMHkqKKTe21rHgMzNUiPHvn+0RCTOnjHo70ugejPkP8WOy3DXBGpf4Q0xl24zRQ0k+YzJWDyX9f8/+P2WXm+/izTff1Ftvvb2BgYEBdXR0qKWlRVOnTtXWrVslSU8//bRmzJhh7gQAAO9U5jfUffv2qb29XcViUcPDw7r44ov1vve9T1OmTNHq1av1/e9/X+ecc47mzZs3FvsLAMBfJDOgvutd79KXv/zlkuUTJ07UAw88cFx2CgCAk80x3UMN4cj7HQMTakruf5gFFTrtBxByk0e0axE+9xN1n33/zed+Sc8c9/qrmt9j9jFl1sHI65obhzRlU3SZdb+w2eP+qM+9Dnnc27SkZN9/8/mMfv6e/+Vc/74v3GL2Eb/fXqyuPOZ78PECJiNl3f/xuc/nc3/U5z7SzrvcRQx87r/FDdRWlbkfbdyf9niuwufepnWfL7XOvvb0LPqT2aY/7bMv7uOrZ459XUnazzKax6XPcwo++2LdXfQ53nzOuZ7bmuxdMe759qft6/rRUHoQAIAACKgAAARAQAUAIAACKgAAARBQAQAIgIAKAEAABFQAAAIY8zxUi5VbGJ/YuRyfSXHjOZpxmfV2PlNmutnEzG17u417fe66mWYf8Ymny+XzNW+2axyH0LPIXXy9bZmdIOeTK6n148wms/Rh5/r+tF2HND45+MD4Mrl3je5cSJ98PqsGsuSTr2ePSeMjz5ltMp++2GwjucfOp35uvI514tBwSS66Nal6snP0dbnf5j4/vHKwPfJdffJzc03usW3ebI9t690vRV6Pqz+k938ouqz3iTpnHz4T2reudV9LpTC1073yXT3G3+JTO+Bo+IYKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACGDMCzskj5jctbIwHHkt+RVusFhFGyQpM91OgLfkG0c/sa5/P0YfsST6YmK4ZFkuM/r/P/lMBGxNjmxNTC1J9Z32vvgUzeh5pdG53ifJPn48Ja8sqnVtLrLMKiaS2m0fk39ccpbZJl70IM7nWOp64r1mm/otZpOSogxxPon48cIBhVMrSpZZBSJ8EvF9Jl5PbXKPbWq32YV57EtSNm33U73QXfwk5XGd7LnjnMjrwcdqSpZ13e8u3NC8zi4G41NIZ/ylve4+fnGG2YdPYRqfQhQ33/ivzvWrdbXZx9HwDRUAgAAIqAAABEBABQAgAAIqAAABEFABAAiAgAoAQAAEVAAAAiCgAgAQwJgXdjgyGb9y0C85/0g/X/fPZpurFv3tMe1HObkm+/8a8aIU5fSn7TaSu42VQC9JtU/sirxOXj6otpXdkWU7729y9tG2zJ1MLvkVZbDMuXiH2aZr8/lmm9TuQ2abtpVZ5/o3Z7SYffjwORZC9JH60a+c67PpS8w+WtvtBPnMdLOJvZ1Y8YtycpOjhRASh4ZLi1cYRT5qt3e7G0hK9fl8zu7jKUQxGMmv8Ey33IUO+hbb102f8beOhcx0+zpoFRuRpKzxfnz68LkmW0VAJOnxr17jXJ8cRaEdvqECABAAARUAgAAIqAAABEBABQAgAAIqAAABEFABAAiAgAoAQABjnodqieelxZ33fz5hd7L4FLOJlaPlM5mwT16aTw6plV+V2m3nk8VzTPMtiZJlzetqnH34THBd32m/n49/7qfO9VYemCQ17rYnMu+6zZ5MONnpfk9T7n/W7CPz6YsjrwupypLP3so3zjfakzDn03ZebapvpnN9iHxYyW+i8sYOe38t8WO/WF26zJrUfs/VZ5rb8cl3tybKDjW2IfJZfXJMfVjX21BCjJ3PJPHJTvv9pPrcOa+TNuxyrpckfbH8Yr6hAgAQAAEVAIAACKgAAARAQAUAIAACKgAAARBQAQAIgIAKAEAABFQAAAIY88IO2fSfk/ELp1ZEXkv2RLM+ibs+E/gmdrknnvYpcuAzma1P8nvtdve+WBODS6UTBScvHC5Z1j3PXQjBJ/m68ZHnzDY/6Pugc31K9rj5JJwnO+3CDmaxhFn2TNrxogCVg6XL+tMjn5T4P1iFNySpZ461HZ/PsMPemXn2ROXWZ+QzAbwPqxCCT9EGH+//0EvO9T13nGP2MWaTkG+1P8PmreMjr6vPGlDz6lcjy3o/UufsI9XSYG7Hp8CKpd+jzZx3d5ltOrZcYLaJx5xSPpPRl8c3VAAAAiCgAgAQAAEVAIAACKgAAARAQAUAIAACKgAAARBQAQAIgIAKAEAAY17Y4chiCMXEcElxhFzGHeOtwg+S1D3vNI89cbfxKQ7hU3zAJ9G7f3HKub55nc9s93YSvc/YWbqeeK/Zpm2Ze8b7nXdNGfV+vM1O6K/fkjRavBVkT1rX5pzrf77un80+Zt/2GbNNss99fpiFLCR1L7OLNtx847+abdY8ucC5PrXb7KKkUEji7/66tHiIUXzD5xzzKf7w6x9Pc67P32aPbbLTLvBhFZCQpK6HzneuT3kUJOl6KHp9+tNDyZJ+c1e7j6f+tMe1J2M3sTRvtrfT0WQXbWjsGP353GVcj134hgoAQAAEVAAAAiCgAgAQAAEVAIAACKgAAARAQAUAIAACKgAAARBQAQAIYMwLOxyZwFuzoFxCrzvBt3a7u2iAJGXTZ5ltkhn3dkIli/uwigL4FJCIF7MYqK0qWWa9Z58k7mSnvS9vzhj5jPf/wRoTSdq/3G5zoO8M53q/IiBRhVMrlE1XRZb1LKo6Suu3+RRtSO22CwdsaXcXiLhq0d+afXR5FCh4/KvXmG2mdLiLn1z72DNmH6v/7erI6/yZ49S1alZkmZX075PM73MOWXyOfZ/CGj6sY8Hn/cT7qBwslizLpt3Hf32nuRnlG+1iFvECPnE9c+w+kn12Gx/2OT/y6zrfUAEACICACgBAAARUAAACIKACABAAARUAgAAIqAAABEBABQAggDHPQz0yD6pcXlTz6ledf9/7kbog+2HlriV2Zc0+Ci0NZpueOfZktf1pd5t6j0mL4xOi19w4VLLMyl3rT3vkghm5rJJKcjRLNIbJ1at+dILZJtk0+hzGeE5yZWG4ZBySxkTmPXM8cnz77JzYBTOvda7vuss+3lrb7fzd7nn2sWDlavvkstbHXifypcd7rsm9L1YupS/r2PbJt7QntJc6ttgTZcuYP3wkubfF6spjzsf1mmC8MX9MfZbTvK7GbNOzyL5uZDJ2/QCLTw68Pld+Md9QAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAF4F3YoFotaunSpGhoatHTpUvX29mr16tU6cOCAzj33XN1+++1KJOzujkwsLpdo3PFtI+n5avdqyZ7MNr4fZddPP9PsY9KG1+2dkZ1ob02gXLu92+xj511TIq/zDZXqWhzdtp2wbO+rj7OfeM25fs/V9thq63N2m+tmmk2sBHifCcZ9illYCfChJkzfe6lROOAVswsvDZ1DZpva7buc6z/4s5fMPn7w+Q9GXlcOSqm+6Pl7/Rd/5uxj9fPzzO34FFywjpUQk5RLfhPJW4Vl3pzRYvbRevfLkdenTM6XLLOutw2dHoUdZBdlyDW5v7v5FD5pbbePSZ/rRtcT73Wuz3lMJH803t9Qf/rTn6ql5c8f4ne/+10tWLBADz/8sMaNG6dNmzaNeCcAADjZeQXUvXv36vnnn9cVV1whSRoeHtaOHTs0a9YsSdJll12mbdu2Hb+9BADgL5xXQH388cf1sY99TBUVb9eyPHDggFKplKqq3q7Z2tDQoGzWrn0LAMA7VcXw8LDzx+vf/OY3euGFF/R3f/d32rFjh37yk5/o1ltv1T/8wz/o4YcfliRlMhk98MADWrFiRcnfb9y4URs3bpQkPfjgg9rZtefwundNmaB/794baV+sHvV7UsG+XaKaA+71PvuR2D9otslPtDuy9qUyd+zbaW2YoK5sdGyTWfe95XyD/f+rhEcdbGtcCnX2mCT67OLfxXq7EHbloPs9D9Qahfz1djH8I50zaYJe3RMdW+uYs8Zekoaa7TaWwbz9HIPPvhSr7WPBOi7r3m3fE963KzrZRblrwukt+519vJGrNbeTOGgXtk/k3OPiMyY+rGNSkjTovl9YTNnn0CmToydrc3KyevK7I8sOZdwHbqV96fFiXU99rtk+x63esu9P589xPytSs88+VtpaJ5Vdbp59r7zyirZv364XXnhBAwMDOnTokB5//HHlcjkNDQ2pqqpK2WxWDQ3lZ16ZP3++5s+ff/j1TXd/9/C/H3voY5HXkn3z2ofPDAnWg0A+++HzUFL8YaGR7Iv18Ee57fzL39yov/7+k5Fl1oMx8YeYyvGZ+cYaF5+HkhofsR8uyHk8lGQ9ADKSh5KevOcG3fjA9yLLxuqhJEvfK41mG5998XkA53g8lFTumsBDSaVG8lDSF6Yu1xd23BdZZj2UFH9AbKSs66nPNdtrFpitHWYT66Ekn5lvfvm//0fZ5WZAveGGG3TDDTdI0uFvqJ/97Ge1cuVKbd26VR/4wAf09NNPa8aMGeZOAADwTjXir4M33nijnnrqKd1+++06ePCg5s2z/5cIAMA71TFNMD516lRNnTpVkjRx4kQ98MADx2WnAAA42RxTQB0L1n0M696CJOUbzzLb5Jrcv9nnG+17hYWW8veNj9S20i7KYN0P8bnn2LYyet8yeflgybat+7k+9yh87rNO/6T7IZI//tj+fLpWzTLb+NzPldz3vaZsOujRR1QiVyw5ThvtWzemuvvssc1Mdz+I1WqcP5LfvcBs2n5YK9fkPi7XPGl/zvk50Xt0A+OlnjnRzzV+nzWu2dyKNPipPrNNRk3O9T73E/2eAbHHPyX3tSX1o1+ZfXQp+ozBnx5Kquuh8yPL+o2CCpM22M9v+FwHc032A4SWrtvsY7J5sv1cRdOEvc71uSb3ceBC6UEAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACGDM81CPzG8rnFpRku+W+pE7oW/Ppy82t+EzwXg+/Sfnep96jj58avla6jvtNiW5YNVVJctC1PL1yVXtWXuOc31yul23M++RChYiLzC127n67T5ieZvF6sqSZVZd253322+obZmdKykjD9VHPM+z7L6sdE8SL9n50/lGO29QjbHzMDFcsmxL+3ecXbzvC7eYm+nfO95sU2+s96nB2zPHPof6Zw+YbZrXGbmqHnWs48dkZW6wzHHq/gx9rl9Nf5Ux22i9+7j1ySlP9dnXZJ/86YZHJzjXV2vk9Yv5hgoAQAAEVAAAAiCgAgAQAAEVAIAACKgAAARAQAUAIAACKgAAARBQAQAIYMwLOxxZdKGYGC4pwtC97BLn3/tMCJ1vPM1ss2OxkSy+xU4Wr91uT3beutZsYk6a7jPBePe86HseqK0qWWaNnc9k6D6TCYfgsy8+42IVf7Am7JZKJ5svV5DEmmxbGbuYhQ9r4nvrWJKktpV2G5+E/tY7txot7OIDqU1DkdfJC4fV2h5dZp2LPgU++s0W9tj6FD7xKVDQ2DFktula7O5nzsU77D5ik4kXU9UlxTh6FrmLTPgUuOlptItmWBPf+0x67zN5ezLAeeZT+ORo+IYKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACGDMCztYfAo3WHySexfMvNa5Pr/ETu6NJ0mX45OMPH31q+7tPGRvp392NEG7mCwqnz4U3ZdOd/J0dt5Z5nZ8xrZ6YZ+7wXq7mEKoAhLxAgxxPsdbPOk8cWhYDZ3R5PwQCfI+x5M1/j7j5lP8wadAQeJMd/EHn2M/m7YLkljv2Wc7PuMvuQsuZOU+lt5mnx8+xURa73zOuX7zE++1+/jRryKvK++5TqnYsmTaXUgntds+P1rbzSZmUYzWtTm7E9nFH6zzXZJSxuUp2Tfy75l8QwUAIAACKgAAARBQAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAMY8D/XIfKPklcWS/KOu29x5RPVbkuY2Go3JbCU75y+eZ3g8/frH05zr83PsCZSVOSX6ulBRsqxnjruLpJGfJdmTMEtS/hdnuLfjkavnM5lz82aPiaXT7v2N5zyW8/4PvRR5fcrkvFrvfjmyLPftC5x9pHbbx6TPvlh8xs1n0vvpn/yt2aan4xznep9jZfylvZHXVacNlizr2+uewNonx9QnV7V/dt65/g9XfMfsY+rXbzXb+Fxbcte5J2dPdtr5lt3LojmmA5NPK1kWQoi8Wp/98hm3Hf/tG2ab8/7PJ5zr/XKWy+MbKgAAARBQAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACCAMS/scORkzcXqypLJm62E5cZHnjW3kfn0xWYbq/jDz9f9s9nH7Ns+Y7axksUl6Y4LNznXP/7Va8w+Jm14PfI6efmg2lZ2R5ZZk0/7FBbwmZDbSvRO9XkUqvD4v55VqEKyJ8pu7LDfT0cmWrTh0D1JdcQKOfgUE7HEJ4QvJ2lMEu8zMbhPIn63UWxEkqbIPXY+7ycfK9owWKgqLeQQL1oSU7u927leknJXn2m2aV3ygnP97Ovs832Kx4TcPuLXxbizn3jtmPusuX6g5O+sa4LPseLDuib7FG1I7baPJ5/CGlZpIJ9J1Y+Gb6gAAARAQAUAIAACKgAAARBQAQAIgIAKAEAABFQAAAIgoAIAEAABFQCAAMa8sMORybmVg8WSZN2eRfZM9Jb+9LC9H33uxOmrFv2t2Ud23uj3VZKeummuc33/Yvv9fPxzL0Ve152d0wd/Fl22+t+udvbRujZMUrqlZ45dfKB1rV0oYdKGrNlm511TnOv7Z9ufYTJWLKGYqFC+MbrMSsT3SUr3YRVLSG6x0tb9+CTaW0n/TRP6zD6qH50QeV0zs0LN62oiy6wCHns8ijZ4Fd6YNd25unb7LrMLq1CCZB8rkpRrcn/XSXlsp0R1ldf+HcnnWupTTMQq5tKzaMDso22Zfb4nM3Yhivi5G+dT4OZo+IYKAEAABFQAAAIgoAIAEAABFQCAAAioAAAEQEAFACAAAioAAAEQUAEACGDMCzt0LU4d/ne+oTLyWpKa17kTibueeK+5jfotHonGu3NmG4tP8rs6a8wmucnu9ck++/898eIQVz82vmRZ/fTRJzQnMz5FM9xJ3Ck7398r+T21tdts07y5xbm+Z84pZh/x91xZGC5ZNvipvc4+Muub7O14JMhb8o0ebZrcn48k9aftfUn2udv0v2LvTLPs46l1rftctQpM+LaxEv6nbDK78DqHpmyyC6j0zEkZLez341XMwtC82f58smmf72XuNvUeBUl8CnhY1x5JmrTBXaDjzRnua4YL31ABAAiAgAoAQAAEVAAAAiCgAgAQAAEVAIAACKgAAARAQAUAIIAxz0M9Mq+pZkFpnpM1sa5PvpJP/pWV5+gzCbbPxLo++xLPxS3djp0L5sPKsxt/aa/Zx4TP5M02f1xylnP9+z/0knO9JP36x9PMNtn0JWYbS9vK18w28UnKC8nSiZeTvzjD2UdDn0fOssf/b63jyTqWJKltpZ2/a32Gkj3ZeXyi8HLi+bvDTYWSZVYOb6hJsK33k+u0c6N98rR9cqyt/e2f1uoVbAAABPZJREFUbZ+H8VzVQqrSKx/3SD55nV75+AFsaf+W2eaqRX9rtomfzyUa/+S7SyX4hgoAQAAEVAAAAiCgAgAQAAEVAIAACKgAAARAQAUAIAACKgAAARBQAQAIoGJ4eDhM1QAAAP4TO6HfUJcuXXoiN/+OxtgeP4zt8cPYHj+M7fHHT74AAARAQAUAIIATGlDnz59/Ijf/jsbYHj+M7fHD2B4/jO3xx0NJAAAEwE++AAAEMObzof6HF198Ud/5zndULBZ1xRVXaOHChSdqV0563/jGN/T888+rrq5OK1askCQdPHhQq1atUl9fn5qamnTnnXfqtNNOO8F7evLJZDJqb29Xf3+/KioqNH/+fF1zzTWMbwADAwO69957VSgUNDQ0pFmzZun6669Xb2+vVq9erQMHDujcc8/V7bffrkTihF2qTlrFYlFLly5VQ0ODli5dyriOgRPyDbVYLOqxxx7TsmXLtGrVKv3yl79Ud7c96THKu+yyy7Rs2bLIsvXr12vatGn62te+pmnTpmn9+vUnaO9OblVVVVqyZIlWrVqlL33pS/r5z3+u7u5uxjeA6upq3XvvvfrKV76iL3/5y3rxxRf1u9/9Tt/97ne1YMECPfzwwxo3bpw2bdp0onf1pPTTn/5ULS0th18zrsffCQmoXV1dmjRpkiZOnKhEIqFLLrlE27ZtOxG78o5w/vnnl3w72rZtm+bOnStJmjt3LuM7QqeffrrOPfdcSdKpp56qlpYWZbNZxjeAiooKJZNJSdLQ0JCGhoZUUVGhHTt2aNasWZLe/s8iY3vs9u7dq+eff15XXHGFJGl4eJhxHQMn5Pt+NpvVhAkTDr+eMGGCfv/735+IXXnH2r9/v04//XRJUn19vfbv33+C9+jk19vbq1dffVWtra2MbyDFYlF333239uzZo6uuukoTJ05UKpVSVVWVJKmhoUHZbPYE7+XJ5/HHH9fHPvYxHTp0SJJ04MABxnUM8FDSfwIVFRWqqKg40btxUsvn81qxYoU+/vGPK5VKRdYxviNXWVmpr3zlK1qzZo3+8Ic/qKen50Tv0knvN7/5jerq6g7/soKxc0K+oTY0NGjv3r2HX+/du1cNDQ0nYlfeserq6rRv3z6dfvrp2rdvn2pra0/0Lp20CoWCVqxYodmzZ2vmzJmSGN/Qxo0bp6lTp+p3v/udcrmchoaGVFVVpWw2y7XhGL3yyivavn27XnjhBQ0MDOjQoUN6/PHHGdcxcEK+oZ533nnavXu3ent7VSgU9Oyzz2rGjBknYlfesWbMmKFnnnlGkvTMM8/ooosuOsF7dHIaHh7WmjVr1NLSomuvvfbwcsZ39N5880299dZbkt5+4rejo0MtLS2aOnWqtm7dKkl6+umnuTYcoxtuuEFr1qxRe3u77rjjDl1wwQX67Gc/y7iOgRNW2OH555/XP/3TP6lYLOryyy/XokWLTsRuvCOsXr1aL7/8sg4cOKC6ujpdf/31uuiii7Rq1SplMhnSOkZh586dWr58uc4666zDP+t+9KMf1bvf/W7Gd5T+/d//Xe3t7SoWixoeHtbFF1+sD3/4w3rjjTe0evVqHTx4UOecc45uv/12VVdXn+jdPSnt2LFDP/nJT7R06VLGdQxQKQkAgAB4KAkAgAAIqAAABEBABQAgAAIqAAABEFABAAiAgAoAQAAEVAAAAiCgAgAQwP8PMBzkxZZDeXoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "showField()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "movePreds()\n",
    "moveCarns()\n",
    "showField()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.hexists(\"tile:49:4\",\"herbs2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import requests\n",
    "import pymorphy2\n",
    "import re\n",
    "from bs4 import BeautifulSoup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Функция для загрузки одной новости из Ленты.ру\n",
    "def getLentaArticle(url):\n",
    "    \"\"\" getLentaArticle gets the body of the article from Lenta.ru\"\"\"\n",
    "    print(\"downloading lenta:\", url)\n",
    "    r = requests.get(url)\n",
    "    p = BeautifulSoup(r.text, \"html5\")(\"p\")\n",
    "    if len(p) == 0:\n",
    "        return \"  \"\n",
    "    p = \" \".join([a.get_text() for a in p])\n",
    "    return p\n",
    "\n",
    "# Функция загрузки одной новости из N+1.\n",
    "def getArticleTextNPlus1(adr):\n",
    "    print(\"downloading nplus1:\", adr)\n",
    "    r = requests.get(adr)\n",
    "    n_text = re.split(\"</div>\", re.split(\"</figure>\", re.split('</article>',re.split('<article', r.text)[1])[0])[1])[1]    \n",
    "    #return BeautifulSoup(n_text, \"lxml\").get_text()\n",
    "    return BeautifulSoup(n_text, \"html5\").get_text()\n",
    "\n",
    "# Загрузка новостей из Ленты.ру за некоторый период.\n",
    "def getLenta():\n",
    "    curdate = datetime.date(2017, 1, 16)\n",
    "    findate = datetime.date(2017, 1, 16)\n",
    "    res = \"\"\n",
    "    \n",
    "    redi = redis.Redis()\n",
    "    redi.incrby(\"downloaders\", 1)\n",
    "\n",
    "# Загружаем новости до конечной даты.\n",
    "    cnt = 0 # Очень скучно ждать, ограничим число новостей.\n",
    "    while curdate <= findate:\n",
    "        print('lenta ' + curdate.strftime('%Y/%m/%d'))\n",
    "        day = requests.get('https://lenta.ru/news/' + curdate.strftime('%Y/%m/%d'))\n",
    "        body = re.findall('<h3>(.+?)</h3>', day.text)\n",
    "        links = ['https://lenta.ru' + re.findall('\"(.+?)\"', x)[0] for x in body]\n",
    "        for l in links: # идем по всем ссылкам на новости за день.\n",
    "            news = getLentaArticle(l)\n",
    "            if news != \"  \":\n",
    "                redi.rpush(\"downloaded news\", news)\n",
    "            time.sleep(0.2)\n",
    "            cnt += 1\n",
    "            if cnt > 10:\n",
    "                break\n",
    "        curdate += datetime.timedelta(days=1)\n",
    "    redi.incrby(\"downloaders\", -1)\n",
    "    print(\"lenta finished\")\n",
    "\n",
    "# Получаем новости с NPlus1 за заданный промежуток времени, кладем тексты новостей в очередь qu.\n",
    "# По завершении взводим семафор sem.\n",
    "def getNplus1():\n",
    "    curdate = datetime.date(2015, 12, 15)\n",
    "    findate = datetime.date(2015, 12, 19)\n",
    "    \n",
    "    redi = redis.Redis()\n",
    "    redi.incrby(\"downloaders\", 1)\n",
    "    cnt = 0\n",
    "    while curdate <= findate: # Перебираем все дни.\n",
    "        r = requests.get('https://nplus1.ru/news/'+curdate.strftime('%Y/%m/%d'))\n",
    "        print('nplus ' + curdate.strftime('%Y/%m/%d'))\n",
    "        # Берем заголовки и ссылки на новости за этот день.\n",
    "        refs = [re.split('\"', t)[6] for t in re.split('<article class=\"item item-news item-news', r.text)[1:]]\n",
    "        for t in refs:\n",
    "            news = getArticleTextNPlus1(\"https://nplus1.ru\" + t)\n",
    "            if news != \"  \":\n",
    "                redi.rpush(\"downloaded news\", news)\n",
    "            time.sleep(0.2) # Мы этичные хакеры и не стремимся к DDoS.\n",
    "            cnt += 1\n",
    "            if cnt > 10:\n",
    "                break\n",
    "        curdate += datetime.timedelta(days=1)\n",
    "    redi.incrby(\"downloaders\", -1)\n",
    "    print(\"nplus1 finished\")\n",
    "    \n",
    "# Функция токенизирует вход из очереди qu1 и кладет результаты токенизации в очередь qu2.\n",
    "# Токенизация ведется до тех пор, пока семафор semw не будет взведен максимальное количество раз.\n",
    "# По завершении токенизации устанавливаем событие evs.\n",
    "def tokenize():  \n",
    "    redi = redis.Redis()\n",
    "    redi.incrby(\"tokenizers\", 1)\n",
    "    \n",
    "    c = 0\n",
    "    while True: \n",
    "        news = redi.blpop(\"downloaded news\", 1)\n",
    "        if news == None:\n",
    "            nd = redi.get(\"downloaders\")\n",
    "            if int(nd) == 0:\n",
    "                break\n",
    "            else:\n",
    "                continue\n",
    "                \n",
    "        c += 1\n",
    "        print('tokenizer ' + str(c))\n",
    "        res = [n[0] for n in re.findall(\"([А-Яа-я]+(-[А-Яа-я]+)*)\", news[1].decode())]\n",
    "        news = redi.rpush(\"tagged news\", json.dumps(res))\n",
    "        \n",
    "    redi.incrby(\"tokenizers\", -1)\n",
    "    print(\"tokenization finished\")\n",
    "\n",
    "def lemmatize():\n",
    "    redi = redis.Redis()\n",
    "    redi.incrby(\"lemmatizers\", 1)\n",
    "\n",
    "    morpho = pymorphy2.MorphAnalyzer() # Создаем морфоанализатор.\n",
    "    l = []\n",
    "    c = 0\n",
    "    while True: # Если событие установлено - пора завершать работу.\n",
    "        news = redi.blpop(\"tagged news\", 1)\n",
    "        if news == None:\n",
    "            nd = redi.get(\"tokenizers\")\n",
    "            if int(nd) == 0:\n",
    "                break\n",
    "            else:\n",
    "                continue\n",
    "\n",
    "        # blpop возвращает пару: имя списка, значение.\n",
    "        txt = json.loads(news[1].decode())\n",
    "        s = []\n",
    "        for w in txt:\n",
    "            s += morpho.parse(w)[0]\n",
    "            \n",
    "        res = json.dumps(str(s))\n",
    "        redi.rpush(\"lemmatized news\", res)\n",
    "        c += 1\n",
    "        print('lemma', c)\n",
    "    redi.incrby(\"lemmatizers\", -1)\n",
    "    print(\"lemmatization finished\")\n",
    "\n",
    "# Функция имитирует, что она обрабатывает данные из очереди qu. Заершает работу по событию ev.    \n",
    "def utilize():\n",
    "    redi = redis.Redis()\n",
    "\n",
    "    c = 0\n",
    "    while True: # Если событие установлено - пора завершать работу.\n",
    "        news = redi.blpop(\"lemmatized news\", 1)\n",
    "        if news == None:\n",
    "            nd = redi.get(\"lemmatizers\")\n",
    "            if int(nd) == 0:\n",
    "                break\n",
    "            else:\n",
    "                continue\n",
    "                \n",
    "        #processing\n",
    "        c += 1\n",
    "        print('process', c)\n",
    "    print('processing finished')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = redis.Redis()\n",
    "r.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.flushdb()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lenta 2017/01/16\n",
      "nplus 2015/12/15\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/tastelikehumanist\n",
      "tokenizer 1\n",
      "process 1\n",
      "lemma 1\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/soyuz-19m-success\n",
      "tokenizer 2\n",
      "process 2\n",
      "lemma 2\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/new-particle\n",
      "tokenizer 3\n",
      "lemma 3\n",
      "process 3\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/ocean-xprize\n",
      "tokenizer 4\n",
      "process 4\n",
      "lemma 4\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/amegilla\n",
      "tokenizer 5\n",
      "process 5\n",
      "lemma 5\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/veggie\n",
      "tokenizer 6\n",
      "lemma 6\n",
      "process 6\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/saar\n",
      "tokenizer 7\n",
      "process 7\n",
      "lemma 7\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/apollo/\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/lemurvocalisation\n",
      "tokenizer 8\n",
      "process 8\n",
      "lemma 8\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/engine\n",
      "tokenizer 9\n",
      "process 9\n",
      "lemma 9\n",
      "tokenizer 10\n",
      "lemma 10\n",
      "process 10\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/kadyrov/\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/Putin-gait\n",
      "tokenizer 11\n",
      "process 11\n",
      "lemma 11\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/15/rescue\n",
      "tokenizer 12\n",
      "process 12\n",
      "lemma 12\n",
      "tokenizer 13\n",
      "process 13\n",
      "lemma 13\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/trump2/\n",
      "nplus 2015/12/16\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/16/sexylips\n",
      "tokenizer 14\n",
      "process 14\n",
      "lemma 14\n",
      "tokenizer 15\n",
      "process 15\n",
      "lemma 15\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/accordion/\n",
      "nplus 2015/12/17\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/17/notthesame\n",
      "tokenizer 16\n",
      "process 16\n",
      "lemma 16\n",
      "nplus 2015/12/18\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/18/ding-ding-don\n",
      "tokenizer 17\n",
      "lemma 17\n",
      "process 17\n",
      "tokenizer 18\n",
      "lemma 18\n",
      "process 18\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/trump3/\n",
      "nplus 2015/12/19\n",
      "downloading nplus1: https://nplus1.ru/news/2015/12/19/cart-walkies\n",
      "tokenizer 19\n",
      "lemma 19\n",
      "process 19\n",
      "nplus1 finished\n",
      "tokenizer 20\n",
      "lemma 20\n",
      "process 20\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/bishkek4/\n",
      "tokenizer 21\n",
      "process 21\n",
      "lemma 21\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/bishkek5/\n",
      "tokenizer 22\n",
      "process 22\n",
      "lemma 22\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/realsevilla/\n",
      "tokenizer 23\n",
      "lemma 23\n",
      "process 23\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/safetymoscow/\n",
      "tokenizer 24\n",
      "lemma 24\n",
      "process 24\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/vertols/\n",
      "tokenizer 25\n",
      "process 25\n",
      "lemma 25\n",
      "downloading lenta: https://lenta.ru/news/2017/01/16/boss/\n",
      "tokenizer 26\n",
      "lemma 26\n",
      "process 26\n",
      "lenta finished\n",
      "tokenization finished\n",
      "lemmatization finished\n",
      "processing finished\n"
     ]
    }
   ],
   "source": [
    "lentap = multiprocessing.Process(target=getLenta)\n",
    "nplusp = multiprocessing.Process(target=getNplus1)  \n",
    "tokenp = multiprocessing.Process(target=tokenize)   \n",
    "lemmap = multiprocessing.Process(target=lemmatize)   \n",
    "processp = multiprocessing.Process(target=utilize)    \n",
    "\n",
    "\n",
    "# Стартуем процессы    \n",
    "lentap.start()\n",
    "nplusp.start()\n",
    "time.sleep(0.1)\n",
    "tokenp.start()\n",
    "time.sleep(0.1)\n",
    "lemmap.start()\n",
    "time.sleep(0.1)\n",
    "processp.start()\n",
    "\n",
    "# Если надо - ждем пока процессы не завершатся.\n",
    "#lentap.join()\n",
    "#nplusp.join()\n",
    "#tokenp.join()\n",
    "#lemmap.join()\n",
    "#processp.join()\n",
    "#print(\"Everything is allright\")                               \n",
    "                               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'0' b'0' b'0'\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(r.get('downloaders'), r.get('tokenizers'), r.get('lemmatizers'))\n",
    "print(r.blpop(\"downloaded news\", 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}