sem14_bot/bot_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <center> Последний семинар :)</center>\n",
    "\n",
    "\n",
    "<img src=\"https://evilcoder.ru/wp-content/uploads/2017/09/TelegramMessenger.png\" width=100>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Всем привет! Цель сегодняшнего нашего занятия – написать своего первого телеграм-бота. Это сильно проще, чем кажется :)\n",
    "\n",
    "Нам потребуется чуть более удобная IDE, например, PyCharm – скачать можно [здесь](https://www.jetbrains.com/ru-ru/pycharm/), Вам нужна community edition.\n",
    "\n",
    "Будет писать бота, который хранит списки дел. То есть, для каждого пользователя, который начинает с ним диалог, бот сможет:\n",
    "* добавлять дело в список;\n",
    "* удалять дело из списка;\n",
    "* удалять все дела из списка;\n",
    "* присылать список дел.\n",
    "\n",
    "Результат наших сегодняшних стараний доступен по нику `@planner_hse_bot`. По любым вопросам можно писать мне `@anastasiyamaxx`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Получаем токен"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Первое, что надо сделать – найти в поисковой строке телеграма `@BotFather`, набрать команду `/start` и создать своего бота. Вас сначала попросят выбрать имя, потом имя пользователя (должно заканчиваться на \"bot\") и в конце выдадут токен, по которому мы будем подключаться к API телеграма. \n",
    "\n",
    "Также в `@BotFather` можно поставить аватарку и описание нашему боту, а также обновить токен, если Вы его случайно кому-то отдали (команда `/revoke`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Подключаем бота и пишем первую функцию"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Открываем новый проект в PyCharm\n",
    "* Работать будем в файле `main.py` – если не пользовались раньше PyCharm, то можете глянуть первую неделю курсеры, которую мы рекомендовали в начале курса :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для работы с API телеграма есть специальная библиотека – `telebot`. Вам нужно ее установить. Откройте вкладку терминал в PyCharm и напишите такую строчку:\n",
    "\n",
    "`pip install pyTelegramBotAPI==3.7.9`\n",
    "\n",
    "На скрине ниже выделила как открыть терминал:\n",
    "\n",
    "<img src=imgs/pyc_terminal.png width=700>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Будьте аккуратны! Не используйте для текущего семинара `pip install telebot`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Отлично! Теперь мы готовы начинать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import telebot\n",
    "from telebot import types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# подключим токен нашего бота\n",
    "bot = telebot.TeleBot(\"вставьте сюда свой токен\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вообще токены обычно хранят в отдельном файле с конфигурациями – можете его создать и импортировать токен оттуда."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Следующий наш шаг – написать первую команду!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# напишем, что делать нашему боту при команде старт\n",
    "@bot.message_handler(commands=['start'])\n",
    "def send_keyboard(message, text=\"Привет, чем я могу тебе помочь?\"):\n",
    "    keyboard = types.ReplyKeyboardMarkup(row_width=2)  # наша клавиатура\n",
    "    itembtn1 = types.KeyboardButton('Добавить дело в список') # создадим кнопку\n",
    "    itembtn2 = types.KeyboardButton('Показать список дел')\n",
    "    itembtn3 = types.KeyboardButton('Удалить дело из списка')\n",
    "    itembtn4 = types.KeyboardButton(\"Удалить все дела из списка\")\n",
    "    itembtn5 = types.KeyboardButton('Другое')\n",
    "    itembtn6 = types.KeyboardButton('Пока все!')\n",
    "    keyboard.add(itembtn1, itembtn2) # добавим кнопки 1 и 2 на первый ряд\n",
    "    keyboard.add(itembtn3, itembtn4, itembtn5, itembtn6) # добавим кнопки 3, 4, 5 на второй ряд\n",
    "    # но если кнопок слишком много, они пойдут на след ряд автоматически\n",
    "\n",
    "    # пришлем это все сообщением и запишем выбранный вариант\n",
    "    msg = bot.send_message(message.from_user.id,\n",
    "                     text=text, reply_markup=keyboard)\n",
    "\n",
    "    # отправим этот вариант в функцию, которая его обработает\n",
    "    bot.register_next_step_handler(msg, callback_worker)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте разберемся, что здесь происходит.\n",
    "\n",
    "`@bot.message_handler(commands=['start'])` обозначает, когда выполнять функцию, которая написана под ней (`send_keyboard`) в нашем случае. Такая конструкция называется декоратор и использует механизм хендлеров. `commands=['start']` значит, что `send_keyboard` будет высылаться при команде `\\start`.\n",
    "\n",
    "Аналогично можно написать `@bot.message_handler(commands=['start', 'help'])`, чтобы функция вызывалась при командах `\\start` и `\\help`. А `@bot.message_handler(content_types=[\"text\"])` будет вызывать функцию под ней при получении любого текстового сообщения. Можно сделать его более кастомным: `@bot.message_handler(func=lambda message: message.text == \"hi\")\n",
    "` будет работать, если сообщение было словом \"hi\". Можно настроить его для ответов на присланные пользователем файлы, фотографии и аудио – [см. документацию](https://core.telegram.org/bots/api#available-types).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`types.ReplyKeyboardMarkup` – создает нам клавиатуру, а `types.KeyboardButton('Добавить дело в список')` – кнопку. `keyboard.add(itembtn1, itembtn2)` добавляет кнопки на клавиатуру. \n",
    "\n",
    "`msg = bot.send_message(message.from_user.id, text=text, reply_markup=keyboard)` присылает пользователю клавиатуру с сообщением \"Привет, чем я могу тебе помочь?\". `bot.send_message(message.from_user.id,` отвечает за то, чтобы прислать сообщение в нужный чат, `text=text,` задает текст сообщения (я его задала аргументом в функции, тк буду использовать эту функцию дальше в других случаях с другим текстом). `reply_markup=keyboard` прикрепляет клавиатуру к сообщению. Выбор пользователя сохраняем в переменную `msg`.\n",
    "\n",
    "Если Вы следуете этой инструкции код параллельно с семинаром, то можете запустить код – бот будет присылать клавиатуру (но больше ничего делать не будет, т.к. функцию-обработчик мы еще не написали). Добавьте только в конце строчку `bot.polling(none_stop=True)`, мы чуть позже разберем, что она делает.\n",
    "\n",
    "`bot.register_next_step_handler(msg, callback_worker)` – отправит выбор пользователя с клавиатуры в функцию `callback_worker`, которую мы позже напишем.\n",
    "\n",
    "Кстати, вы наверняка видели и другой тип клавиатуры – inline. \n",
    "\n",
    "<img src=\"https://core.telegram.org/file/811140659/1/RRJyulbtLBY/ea6163411c7eb4f4dc\" width=300>\n",
    "\n",
    "Почитать о ней подробнее можно [здесь](https://core.telegram.org/bots/api/#inlinekeyboardmarkup), запускается она практически аналогично."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Добавляем SQLite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нам нужно, чтобы для каждого обратившегося к ней пользователя наша система хранила список дел. Я предлагаю воспользоваться базой данных SQLite – она быстрая (т.к. обращается напрямую к файлам, без портов и сокетов), легко встраивается в приложения и проста в использовании. Вы можете попробовать подключить более продвинутые MySQL и PostgreSQL, но это потребует чуть больше времени. \n",
    "\n",
    "Можно и просто сохранять все в обычный файлик, но помните, что такой вариант масштабировать не получится – вспомните историю, [как в Великобритании потеряли 16 тысяч положительных тестов на коронавирус.](https://www.kommersant.ru/doc/4520501)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Устанавливать ее не нужно – она встроена в питон. Можем сразу начинать работать. Подключим ее:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# подключаем базу данных\n",
    "conn = sqlite3.connect('planner_hse.db')\n",
    "\n",
    "# курсор для работы с таблицами\n",
    "cursor = conn.cursor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если базы данных с таким названием раньше не было, то она создастся, а если есть, то откроется. Теперь давайте проверим, есть ли в ней нужная нам таблица:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # sql запрос для создания таблицы\n",
    "    query = \"CREATE TABLE \\\"planner\\\" (\\\"ID\\\" INTEGER UNIQUE, \\\"user_id\\\" INTEGER, \\\"plan\\\" TEXT, PRIMARY KEY (\\\"ID\\\"))\"\n",
    "    # исполняем его –> ура, теперь у нас есть таблица, куда будем все сохранять!\n",
    "    cursor.execute(query)\n",
    "except:\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Этот код попытается создать таблицу под названием planner, в которой есть столбец ID, который должен содержать уникальные целые числа (это будет идентификатор записи – за это отвечает конец строки `, PRIMARY KEY (\\\"ID\\\")`). Также есть столбец \"user_id\", который может содержать только целые числа и столбец \"plan\", который может содержать текст.\n",
    "\n",
    "То, что мы записали в переменную query, называется SQL запросом. Для того, чтобы понимать все, что происходит в этом семинаре с SQL, Вам хватит прочтения [20-минутного введения](https://proglib.io/p/sql-for-20-minutes).\n",
    "\n",
    "После того, как мы написали код, мы нажимаем кнопку запуска. Аналогично здесь, запрос надо исполнить – за это отвечает `cursor.execute(query)`. \n",
    "\n",
    "Если таблицы раньше не было, то эти несколько строчек ее создадут в нашей базе данных 'planner_hse.db'. Если была, то вылетит ошибка (`table already exists`), мы перейдем в код под `except`. `pass` означает, что ничего делать не надо. То есть если таблица уже есть, то ничего не произойдет – ни создание таблицы заново, ни вылет ошибки.\n",
    "\n",
    "Последнее, что хочется отметить – названия таблицы и колонок в SQL запросе должны быть в кавычках. Чтобы запихнуть кавычки внутрь строки в питоне я использую экранирование – ставлю обратный слэш перед каждой кавычкой."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Пишем функции нашему боту"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В начале занятия мы сделали 6 кнопок для нашего бота:\n",
    "1. Добавить дело в список\n",
    "2. Показать список дел\n",
    "3. Удалить дело из списка\n",
    "4. Удалить все дела из списка\n",
    "5. Другое\n",
    "6. Пока все!\n",
    "\n",
    "Давайте по очереди напишем функции для каждой из них."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Добавить дело в список**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# напишем функции для каждого случая\n",
    "# эта добавляет строчку с планом в хранилище\n",
    "def add_plan(msg):\n",
    "    with sqlite3.connect('planner_hse.db') as con:\n",
    "        cursor = con.cursor()\n",
    "        cursor.execute('INSERT INTO planner (user_id, plan) VALUES (?, ?)',\n",
    "                       (msg.from_user.id, msg.text))\n",
    "        con.commit()\n",
    "    bot.send_message(msg.chat.id, 'Запомню :-)')\n",
    "    send_keyboard(msg, \"Чем еще могу помочь?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```with sqlite3.connect('planner_hse.db') as con:\n",
    "        cursor = con.cursor()```\n",
    "        \n",
    "Присоединимся к базе данных – внутри функций это лучше делать так, иначе будет ругаться, что мы используем коннекшны, созданные в разных запусках."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`cursor.execute('INSERT INTO planner (user_id, plan) VALUES (?, ?)', (msg.from_user.id, msg.text)`\n",
    "\n",
    "С этим концептом мы уже знакомы – здесь исполняется SQL запрос. Мы вставляем в таблицу planner в столбцы user_id, plan значения, которые встанут на место вопросов – msg.from_user.id, msg.text (id пользователя и текст, соответственно).\n",
    "\n",
    "`con.commit()` сохраняет изменения в базе данных.\n",
    "\n",
    "`bot.send_message(msg.chat.id, 'Запомню :-)')` присылает сообщение. Если после этого ничего не прислать, то мы, получается, будем игнорировать пользователя. Давайте ему пришлем клавиатуру и спросим, что еще он бы хотел поделать: `send_keyboard(msg, \"Чем еще могу помочь?\")` (мы воспользовались функцией, которую написали в начале)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Показать список дел**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# просто функция, которая делает нам красивые строки для отправки пользователю\n",
    "def get_plans_string(tasks):\n",
    "    tasks_str = []\n",
    "    for val in list(enumerate(tasks)):\n",
    "        tasks_str.append(str(val[0] + 1) + ') ' + val[1][0] + '\\n')\n",
    "    return ''.join(tasks_str)\n",
    "\n",
    "# отправляем пользователю его планы\n",
    "def show_plans(msg):\n",
    "    with sqlite3.connect('planner_hse.db') as con:\n",
    "        cursor = con.cursor()\n",
    "        cursor.execute('SELECT plan FROM planner WHERE user_id=={}'.format(msg.from_user.id))\n",
    "        tasks = get_plans_string(cursor.fetchall())\n",
    "        bot.send_message(msg.chat.id, tasks)\n",
    "        send_keyboard(msg, \"Чем еще могу помочь?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Разберем сначала вторую функцию. Мы снова присоеднились к базе данных, выполнили SQL запрос, который выбрал значения только из столбца plan из таблицы planner (`SELECT plan FROM planner`), где id пользователя равен id того, кто прислал нам сообщение (`WHERE user_id=={}'.format(msg.from_user.id)`).\n",
    "\n",
    "Чтобы получить результаты запроса используем `cursor.fetchall()`. Он вернет нам данные в формате `[(дело1,), (дело2,), (дело3,)]`. Напишем функцию помощник, которая превратит это в красивую запись в формате (ее мы разбирать не будем, т.к. тут все знакомое):\n",
    "```1) дело1\n",
    "2) дело2\n",
    "3) дело3```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Осталось отправить красивое сообщение, где будет эта строка и клавиатуру с нашим меню заново."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Удалить дело из списка**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# выыделяет одно дело, которое пользователь хочет удалить\n",
    "def delete_one_plan(msg):\n",
    "    markup = types.ReplyKeyboardMarkup(row_width=2)\n",
    "    with sqlite3.connect('planner_hse.db') as con:\n",
    "        cursor = con.cursor()\n",
    "        # достаем все задачи пользователя\n",
    "        cursor.execute('SELECT plan FROM planner WHERE user_id=={}'.format(msg.from_user.id))\n",
    "        # достанем результат запроса\n",
    "        tasks = cursor.fetchall()\n",
    "        for value in tasks:\n",
    "            markup.add(types.KeyboardButton(value[0]))\n",
    "        msg = bot.send_message(msg.from_user.id,\n",
    "                               text = \"Выбери одно дело из списка\",\n",
    "                               reply_markup=markup)\n",
    "        bot.register_next_step_handler(msg, delete_one_plan_)\n",
    "\n",
    "# удаляет это дело\n",
    "def delete_one_plan_(msg):\n",
    "    with sqlite3.connect('planner_hse.db') as con:\n",
    "        cursor = con.cursor()\n",
    "        cursor.execute('DELETE FROM planner WHERE user_id==? AND plan==?', (msg.from_user.id, msg.text))\n",
    "        bot.send_message(msg.chat.id, 'Ура, минус одна задача!')\n",
    "        send_keyboard(msg, \"Чем еще могу помочь?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для того, чтобы удалить дело из списка, нам нужно реализовать такую последовательность действий:\n",
    "* Обратимся к базе данных и достанем все дела для данного пользователя (по аналогии с предыдущим пунктом)\n",
    "* Выведем все его дела на клавиатуру, спросим какое нужно удалить, сохраним выбор\n",
    "* Удалим его\n",
    "\n",
    "Все команды в первой функции нам уже знакомы, разве что кнопки добавляем теперь циклом по всем делам пользователя:\n",
    "\n",
    "\n",
    "```\n",
    "tasks = cursor.fetchall()\n",
    "for value in tasks:\n",
    "    markup.add(types.KeyboardButton(value[0]))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Напомню, что tasks внутри выглядит примерно так: `[(дело1,), (дело2,), (дело3,)]`. \n",
    "\n",
    "То есть на каждой итерации value будет принимать значения типа кортеж с одной строкой внутри: `(дело1,),`. Поэтому мы берем `value[0]` (только текст) и добавляем его на кнопку `types.KeyboardButton(value[0]))`, а кнопку новым рядом на клавиатуру `markup.add(types.KeyboardButton(value[0]))`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во второй функции мы также подключаемся к базе данных, добавляем условие, что plan должен быть равен msg.text (т.к. выбранная на клавиатуре кнопка присылается как текстовое сообщение от пользователя). Не забываем отправить сообщение, что дело удалено, и мы готовы помогать пользователю дальше."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Удалить все дела из списка**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# удаляет все планы для конкретного пользователя\n",
    "def delete_all_plans(msg):\n",
    "    with sqlite3.connect('planner_hse.db') as con:\n",
    "        cursor = con.cursor()\n",
    "        cursor.execute('DELETE FROM planner WHERE user_id=={}'.format(msg.from_user.id))\n",
    "        con.commit()\n",
    "    bot.send_message(msg.chat.id, 'Удалены все дела. Хорошего отдыха!')\n",
    "    send_keyboard(msg, \"Чем еще могу помочь?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тут также все нам уже знакомо. `DELETE FROM planner` удаляет все строки таблицы, где выполняются условия, которые идут после `WHERE`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Самое сложное позади. Давайте теперь соберем это все воедино. Помните, как в начале занятия мы собирались написать функцию, которая все обработает? \n",
    "\n",
    "```\n",
    "# отправим этот вариант в функцию, которая его обработает\n",
    "    bot.register_next_step_handler(msg, callback_worker)\n",
    "```\n",
    "\n",
    "Пришло ее время!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# привязываем функции к кнопкам на клавиатуре\n",
    "def callback_worker(call):\n",
    "    if call.text == \"Добавить дело в список\":\n",
    "        msg = bot.send_message(call.chat.id, 'Давайте добавим дело! Напишите его в чат')\n",
    "        bot.register_next_step_handler(msg, add_plan)\n",
    "\n",
    "    elif call.text == \"Показать список дел\":\n",
    "        try:\n",
    "            show_plans(call)\n",
    "        except:\n",
    "            bot.send_message(call.chat.id, 'Здесь пусто. Можно отдыхать :-)')\n",
    "            send_keyboard(call, \"Чем еще могу помочь?\")\n",
    "\n",
    "    elif call.text == \"Удалить дело из списка\":\n",
    "        try:\n",
    "            delete_one_plan(call)\n",
    "        except:\n",
    "            bot.send_message(call.chat.id, 'Здесь пусто. Можно отдыхать :-)')\n",
    "            send_keyboard(call, \"Чем еще могу помочь?\")\n",
    "\n",
    "    elif call.text == \"Удалить все дела из списка\":\n",
    "        try:\n",
    "            delete_all_plans(call)\n",
    "        except:\n",
    "            bot.send_message(call.chat.id, 'Здесь пусто. Можно отдыхать :-)')\n",
    "            send_keyboard(call, \"Чем еще могу помочь?\")\n",
    "\n",
    "    elif call.text == \"Другое\":\n",
    "        bot.send_message(call.chat.id, 'Больше я пока ничего не умею :-(')\n",
    "        send_keyboard(call, \"Чем еще могу помочь?\")\n",
    "\n",
    "    elif call.text == \"Пока все!\":\n",
    "        bot.send_message(call.chat.id, 'Хорошего дня! Когда захотите продолжнить нажмите на команду /start')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Простая if-else конструкция, ничего нового. В некоторые пункты я добавила конструкцию try-except на случай, если планов пользователя в нашей таблице нет (наши функции, написанные ранее, могут кидать ошибки на такое).\n",
    "\n",
    "Осталась лишь пара штрихов. Когда я кинула этот бот первым пользователям потестить, они начали писать туда текстовые сообщения или как-то еще ломать алгоритм. Например, если на вопрос \"Чем я еще могу помочь?\" с прикрепленной клавиатурой ответить не вариантом с клавиатуры, а другим сообщением, то бот замолкал. Давайте допишем функцию, которая на любое текстовое сообщение будет заново кидать клавиатуру:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@bot.message_handler(content_types=['text'])\n",
    "def handle_docs_audio(message):\n",
    "    send_keyboard(message, text=\"Я не понимаю :-( Выберите один из пунктов меню:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И последняя строчка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot.polling(none_stop=True) # или bot.infinity_polling()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это значит, что наш бот постоянно спрашивает у телеграма нет ли для него новых сообщений. Если Вы добавите эту строчку в Ваш код в PyCharm и запустите код (зеленый треугольник в правом верхнем углу), то Ваш бот заработает! НО работать он будет только если Ваш код запущен – то есть при выключении компьютера или закрытии программы бот отвечать перестанет."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Деплой"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы Ваш бот работал без постоянно запущенной программы, мы должны его где-то развернуть. Очень простой и приятный сервис для этого – [heroku](https://www.heroku.com). Для небольших по количеству пользователей ботов он будет работать бесплатно. Документация [здесь](https://devcenter.heroku.com/articles/getting-started-with-python).\n",
    "\n",
    "Для начала работы с ним нужно зарегистрироваться на сайте (не забудьте подтвердить почту). Вам также потребуется установить git, если не делали этого ранее, [вот ссылка](https://git-scm.com/downloads).\n",
    "\n",
    "А также установить heroku. На маке легко это сделать с помощью brew: `brew install heroku`. Для винды лучше скачать установщик [отсюда](https://devcenter.heroku.com/articles/heroku-cli)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После того, как вы зарегистрировались на сайте heroku и скачали git, возвращайтесь в PyCharm. Откройте терминал в нем, напишите команду `heroku login`. После этого он предложит нажать любую кнопку для подтверждения Ваших намерений, Вы нажимаете, открывается окно в браузере, где надо залогиниться на сайте. Делайте это и возвращайтесь в PyCharm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь нам нужно создать 2 файлика: Procfile и requirements.txt.\n",
    "\n",
    "Чтобы создать первый нажимаем в правом верхнем углу File, потом New. Должно появиться что-то как на картинке ниже:\n",
    "\n",
    "<img src=imgs/pyc_file.png width=300> \n",
    "\n",
    "Нужно выбрать первый вариант. Важно: нам нужно сделать файл без расширения. \n",
    "\n",
    "В этот файл вставляем такую строку: `worker: python main.py`\n",
    "\n",
    "Теперь создадим второй файл. Это сделать просто – откройте терминал в PyCharm опять и напишите `pip freeze > requirements.txt`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Возвращаемся в терминал. Надо ввести несколько команд:\n",
    "\n",
    "1. `git init` – инициализирует гитхаб репозиторий\n",
    "2. `heroku git:remote -a название_проекта` – создаст удаленный репозиторий и назовет приложение (если не работает, то создайте приложение вручную [тут](https://dashboard.heroku.com/apps) и вернитесь к этому шагу)\n",
    "3. `git add .` – добавляет файлы\n",
    "4. `git commit -am \"make it better\"` – делает коммит (можете менять подпись)\n",
    "5. `git push heroku master` – отправляет коммит в репозиторий (после этого лучше подождать минутку-другую)\n",
    "6. `heroku ps:scale worker=1` – запускает worker dyno (так heroku называет контейнеры, мы используем бесплатную версию, подробней [тут](https://www.heroku.com/dynos))\n",
    "\n",
    "Все, победа! Бот должен заработать (иногда нужно подождать пару минут). \n",
    "\n",
    "В дальнейшем, если Вы будете менять код и дополнять функционал бота, Вам нужно будет делать только пункты 3-6 из списка выше, чтобы обновить бот.\n",
    "\n",
    "Дашборды со всякой информацией по Вашему приложению можно смотреть тут: https://dashboard.heroku.com/apps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задание\n",
    "\n",
    "Если у Вас осталось время в конце занятия, допишите пару функций боту в раздел \"Другое\". Например, можно уточнить другую информацию о пользователе, прислать ему ссылки на последние новости и т.д."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Дополнительное чтение\n",
    "\n",
    "Туториалов и уроков на тему ботов – тьма. В принципе можете брать любой на хабре (если любите читать) или ютубе (если любите смотреть). Но вот несколько, что показались мне полезными:\n",
    "\n",
    "1. [Очень классный и большой набор уроков, телеграм боты от А до Я](https://mastergroosha.github.io/telegram-tutorial/)\n",
    "2. [Как сделать бота с базой данных MySQL](https://www.youtube.com/playlist?list=PLvpsu6rFEzwUtzK6qf9wyDsAzM-sdtHTT)\n",
    "3. [Милое вдохновение для грядущей домашки – бот, который присылает дешевые билеты в театр](https://habr.com/ru/post/445632/)\n",
    "4. [Как деплоить с хероку – похоже на наш семинар, но есть пара неточностей](https://www.youtube.com/watch?v=B72-sZyiW10&lc=UgxmpAY651efoK6fGgd4AaABAg.9B7tj_dFDQq9B7vksC6WGf&ab_channel=%D0%92%D0%BB%D0%B0%D0%B4%D0%9D%D0%B5%D0%B2%D0%B5%D1%80%D0%BE%D0%B2)"
   ]
  }
 ],
 "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.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}