Budowanie pierwszego bota telegramu: przewodnik krok po kroku

Chatboty są często reklamowane jako rewolucja w sposobie interakcji użytkowników z technologią i biznesem. Mają dość prosty interfejs w porównaniu z tradycyjnymi aplikacjami, ponieważ wymagają od użytkowników tylko czatowania, a chatboty mają rozumieć i robić wszystko, czego użytkownik od nich żąda, przynajmniej teoretycznie.

Wiele branż przenosi obsługę klienta na systemy chatbotów. Wynika to z ogromnego spadku kosztów w porównaniu z rzeczywistymi ludźmi, a także ze względu na solidność i stałą dostępność. Chatboty zapewniają wsparcie użytkownika bez znacznych dodatkowych kosztów.

Obecnie chatboty są wykorzystywane w wielu scenariuszach, począwszy od służebnych zadań, takich jak wyświetlanie danych o czasie i pogodzie, po bardziej złożone operacje, takie jak podstawowa diagnostyka medyczna i komunikacja/wsparcie klienta. Możesz stworzyć chatbota, który pomoże Twoim klientom, gdy zadają pewne pytania dotyczące Twojego produktu, lub możesz stworzyć osobistego asystenta chatbota, który poradzi sobie z podstawowymi zadaniami i przypomni Ci, kiedy nadszedł czas, aby udać się na spotkanie lub na siłownię.

Istnieje wiele opcji, jeśli chodzi o wdrożenie chatbota, a jednym z najczęstszych zastosowań są platformy mediów społecznościowych, ponieważ większość ludzi korzysta z nich regularnie. To samo można powiedzieć o aplikacjach do obsługi wiadomości błyskawicznych, choć z pewnymi zastrzeżeniami.

Telegram jest obecnie jedną z bardziej popularnych platform IM, ponieważ umożliwia przechowywanie wiadomości w chmurze zamiast tylko na urządzeniu i oferuje dobrą obsługę wielu platform, ponieważ możesz mieć Telegram na Androida, iOS, Windows i prawie dowolna inna platforma obsługująca wersję internetową. Zbudowanie chatbota na Telegramie jest dość proste i wymaga kilku kroków, których wykonanie zajmuje bardzo mało czasu. Chatbot można zintegrować z grupami i kanałami Telegrama, a także działa samodzielnie.

W tym samouczku będziemy tworzyć bota Telegram, który daje obraz awatara z Adorable Avatars. Nasz przykład będzie polegał na zbudowaniu bota za pomocą Flask i rozmieszczeniu go na darmowym serwerze Heroku.

Aby ukończyć ten samouczek, będziesz potrzebować Pythona 3 zainstalowanego w swoim systemie, a także umiejętności kodowania w Pythonie. Ponadto dobre zrozumienie działania aplikacji byłoby dobrym dodatkiem, ale nie koniecznością, ponieważ będziemy szczegółowo omawiać większość rzeczy, które przedstawimy. Musisz także zainstalować Git w swoim systemie.

Oczywiście samouczek wymaga również konta Telegram, które jest bezpłatne. Możesz zarejestrować się tutaj. Wymagane jest również konto Heroku, które możesz pobrać tutaj za darmo.

Ożywianie bota Telegrama

Aby utworzyć chatbota w Telegramie, musisz skontaktować się z BotFather, który jest zasadniczo botem używanym do tworzenia innych botów.

Potrzebne polecenie to /newbot , które prowadzi do następujących kroków, aby utworzyć bota:

Twój bot powinien mieć dwa atrybuty: nazwę i nazwę użytkownika. Nazwa pojawi się dla twojego bota, a nazwa użytkownika będzie używana do wzmianek i udostępniania.

Po wybraniu nazwy bota i nazwy użytkownika — które muszą kończyć się słowem „bot” — otrzymasz wiadomość zawierającą token dostępu i oczywiście będziesz musiał zapisać swój token dostępu i nazwę użytkownika na później, ponieważ będą Ci potrzebne.

Zakoduj logikę Chatbota

W tym samouczku będziemy używać Ubuntu. W przypadku użytkowników systemu Windows większość poleceń będzie działać bez żadnych problemów, ale jeśli napotkasz jakiekolwiek problemy z konfiguracją środowiska wirtualnego, skorzystaj z tego łącza. Jeśli chodzi o użytkowników komputerów Mac, ten samouczek powinien działać dobrze.

Najpierw stwórzmy wirtualne środowisko. Pomaga odizolować wymagania projektu od globalnego środowiska Pythona.

 $ python -m venv botenv/

Teraz będziemy mieli katalog botenv/ , który będzie zawierał wszystkie biblioteki Pythona, których będziemy używać. Śmiało i aktywuj virtualenv za pomocą następującego polecenia:

 $ source botenv/bin/activate

Biblioteki, których potrzebujemy dla naszego bota to:

• Flask: Micro web framework zbudowany w Pythonie.
• Python-telegram-bot: opakowanie Telegrama w Pythonie.
• Requests: popularna biblioteka http Pythona.

Możesz je zainstalować w środowisku wirtualnym za pomocą polecenia pip w następujący sposób:

 (telebot) $ pip install flask (telebot) $ pip install python-telegram-bot (telebot) $ pip install requests

Teraz przejrzyjmy nasz katalog projektów.

 . ├── app.py ├── telebot │ ├── credentials.py │ | . │ | you can build your engine here │ | . │ └── __init__.py └── botenv

W pliku credentials.py będziemy potrzebować trzech zmiennych:

 bot_token = "here goes your access token from BotFather" bot_user_name = "the username you entered" URL = "the heroku app link that we will create later"

Wróćmy teraz do naszego app.py i przejdźmy krok po kroku przez kod:

 # import everything from flask import Flask, request import telegram from telebot.credentials import bot_token, bot_user_name,URL

 global bot global TOKEN TOKEN = bot_token bot = telegram.Bot(token=TOKEN)

Teraz mamy obiekt bota, który będzie używany do dowolnej akcji, której wymagamy od bota.

 # start the flask app app = Flask(__name__)

Musimy również powiązać funkcje z określonymi trasami. Innymi słowy, musimy powiedzieć Flask, co ma zrobić, gdy zostanie wywołany określony adres. Więcej szczegółowych informacji o Flasku i trasach można znaleźć tutaj.

W naszym przykładzie funkcja trasy odpowiada na adres URL, którym jest w zasadzie /{token} , i jest to adres URL, który Telegram wywoła, aby uzyskać odpowiedzi na wiadomości wysłane do bota.

 @app.route('/{}'.format(TOKEN), methods=['POST']) def respond(): # retrieve the message in JSON and then transform it to Telegram object update = telegram.Update.de_json(request.get_json(force=True), bot) chat_id = update.message.chat.id msg_id = update.message.message_id # Telegram understands UTF-8, so encode text for unicode compatibility text = update.message.text.encode('utf-8').decode() # for debugging purposes only print("got text message :", text) # the first time you chat with the bot AKA the welcoming message if text == "/start": # print the welcoming message bot_welcome = """ Welcome to coolAvatar bot, the bot is using the service from http://avatars.adorable.io/ to generate cool looking avatars based on the name you enter so please enter a name and the bot will reply with an avatar for your name. """ # send the welcoming message bot.sendMessage(chat_id=chat_id, text=bot_welcome, reply_to_message_id=msg_id) else: try: # clear the message we got from any non alphabets text = re.sub(r"\W", "_", text) # create the api link for the avatar based on http://avatars.adorable.io/ url = "https://api.adorable.io/avatars/285/{}.png".format(text.strip()) # reply with a photo to the name the user sent, # note that you can send photos by url and telegram will fetch it for you bot.sendPhoto(chat_id=chat_id, photo=url, reply_to_message_id=msg_id) except Exception: # if things went wrong bot.sendMessage(chat_id=chat_id, text="There was a problem in the name you used, please enter different name", reply_to_message_id=msg_id) return 'ok'

Intuicyjny sposób, aby ta funkcja działała, polega na tym, że będziemy ją wywoływać co sekundę, aby sprawdziła, czy nadeszła nowa wiadomość, ale nie będziemy tego robić. Zamiast tego będziemy używać Webhooka, który umożliwia botowi dzwonienie do naszego serwera za każdym razem, gdy wywoływana jest wiadomość, dzięki czemu nie musimy narażać naszego serwera na pętlę w oczekiwaniu na nadchodzącą wiadomość.

Stworzymy więc funkcję, którą sami musimy wywołać, aby aktywować Webhook Telegrama, zasadniczo mówiąc Telegramowi, aby wywołał określony link, gdy nadejdzie nowa wiadomość. Funkcję tę wywołamy tylko raz, kiedy po raz pierwszy stworzymy bota. Jeśli zmienisz łącze do aplikacji, będziesz musiał ponownie uruchomić tę funkcję z nowym łączem, które masz.

Trasa tutaj może być dowolna; to ty to nazwiesz:

 @app.route('/setwebhook', methods=['GET', 'POST']) def set_webhook(): # we use the bot object to link the bot to our app which live # in the link provided by URL s = bot.setWebhook('{URL}{HOOK}'.format(URL=URL, HOOK=TOKEN)) # something to let us know things work if s: return "webhook setup ok" else: return "webhook setup failed"

Teraz, gdy wszystko jest już ustawione, zróbmy po prostu wymyślną stronę główną, abyśmy wiedzieli, że silnik jest włączony.

 @app.route('/') def index(): return '.' if __name__ == '__main__': # note the threaded arg which allow # your app to have more than one thread app.run(threaded=True)

Przyjrzyjmy się pełnej wersji app.py:

 import re from flask import Flask, request import telegram from telebot.credentials import bot_token, bot_user_name,URL global bot global TOKEN TOKEN = bot_token bot = telegram.Bot(token=TOKEN) app = Flask(__name__) @app.route('/{}'.format(TOKEN), methods=['POST']) def respond(): # retrieve the message in JSON and then transform it to Telegram object update = telegram.Update.de_json(request.get_json(force=True), bot) chat_id = update.message.chat.id msg_id = update.message.message_id # Telegram understands UTF-8, so encode text for unicode compatibility text = update.message.text.encode('utf-8').decode() # for debugging purposes only print("got text message :", text) # the first time you chat with the bot AKA the welcoming message if text == "/start": # print the welcoming message bot_welcome = """ Welcome to coolAvatar bot, the bot is using the service from http://avatars.adorable.io/ to generate cool looking avatars based on the name you enter so please enter a name and the bot will reply with an avatar for your name. """ # send the welcoming message bot.sendMessage(chat_id=chat_id, text=bot_welcome, reply_to_message_id=msg_id) else: try: # clear the message we got from any non alphabets text = re.sub(r"\W", "_", text) # create the api link for the avatar based on http://avatars.adorable.io/ url = "https://api.adorable.io/avatars/285/{}.png".format(text.strip()) # reply with a photo to the name the user sent, # note that you can send photos by url and telegram will fetch it for you bot.sendPhoto(chat_id=chat_id, photo=url, reply_to_message_id=msg_id) except Exception: # if things went wrong bot.sendMessage(chat_id=chat_id, text="There was a problem in the name you used, please enter different name", reply_to_message_id=msg_id) return 'ok' @app.route('/set_webhook', methods=['GET', 'POST']) def set_webhook(): s = bot.setWebhook('{URL}{HOOK}'.format(URL=URL, HOOK=TOKEN)) if s: return "webhook setup ok" else: return "webhook setup failed" @app.route('/') def index(): return '.' if __name__ == '__main__': app.run(threaded=True)

To ostatni fragment kodu, który napiszesz w naszym samouczku. Teraz możemy przejść do ostatniego kroku, uruchamiając naszą aplikację na Heroku.

Uruchom naszą aplikację na Heroku

Zanim stworzymy naszą aplikację, potrzebujemy kilku rzeczy.

Heroku nie może wiedzieć, jakich bibliotek używa twój projekt, więc musimy to powiedzieć za pomocą pliku Requirements.txt — częstym problemem jest błędna pisownia requirements.txt , więc bądź ostrożny — aby wygenerować plik wymagań za pomocą pip:

 pip freeze > requirements.txt

Teraz masz gotowy plik wymagań.

Teraz potrzebujesz Procfile , który mówi Heroku, gdzie zaczyna się nasza aplikacja, więc utwórz plik Procfile i dodaj następujące elementy:

 web: gunicorn app:app

Krok odbicia: możesz dodać plik .gitignore do swojego projektu, aby nieużywane pliki nie zostały przesłane do repozytorium.

Na pulpicie Heroku utwórz nową aplikację. Gdy to zrobisz, przekieruje Cię do strony Wdrażania . Następnie otwórz zakładkę Ustawienia w nowym oknie i skopiuj domenę aplikacji, która będzie wyglądała jak https://appname.herokuapp.com/ i wklej ją w zmiennej URL wewnątrz credentials.py .

Teraz wróć do zakładki Wdróż i wykonaj następujące czynności:

Uwaga: użytkownicy systemów Windows i macOS mogą wykonać opisane tutaj czynności.

Zaloguj się do Heroku:

 $ heroku login

Pamiętaj, że ta metoda czasami utknęła w waiting for login , jeśli tak się stanie, spróbuj zalogować się za pomocą:

 $ heroku login -i

Zainicjuj repozytorium Git w naszym katalogu:

 $ git init $ heroku git:remote -a {heroku-project-name}

Wdróż aplikację:

 $ git add . $ git commit -m "first commit" $ git push heroku master

W tym momencie zobaczysz postęp budowy w swoim terminalu. Jeśli wszystko poszło dobrze, zobaczysz coś takiego:

 remote: -----> Launching... remote: Released v6 remote: https://project-name.herokuapp.com/ deployed to Heroku remote: remote: Verifying deploy... done.

Teraz przejdź do strony aplikacji (link do domeny, którą skopiowałeś wcześniej) i dodaj na końcu linku /setwebhook , aby adres był podobny do https://appname.herokuapp.com/setwebhook . Jeśli widzisz, że webhook setup ok , oznacza to, że jesteś gotowy do pracy!

Teraz idź porozmawiaj ze swoim botem

Ostatnie szlify, porady i sztuczki

Teraz masz bota Telegrama działającego 24 godziny na dobę, 7 dni w tygodniu, bez potrzeby Twojej interwencji. Możesz dodać do bota dowolną logikę, dzięki czemu możesz na przykład uczynić swojego bota bardziej realistycznym, dodając status „pisania” i wysyłając status zdjęcia w następujący sposób:

Następny fragment kodu z funkcji respond() :

 if text == "/start": # print the welcoming message bot_welcome = """ Welcome to coolAvatar bot, the bot is using the service from http://avatars.adorable.io/ to generate cool looking avatars based on the name you enter so please enter a name and the bot will reply with an avatar for your name. """ # send the welcoming message bot.sendChatAction(chat_id=chat_id, action="typing") sleep(1.5) bot.sendMessage(chat_id=chat_id, text=bot_welcome, reply_to_message_id=msg_id) else: try: # clear the message we got from any non alphabets text = re.sub(r"\W", "_", text) # create the api link for the avatar based on http://avatars.adorable.io/ url = "https://api.adorable.io/avatars/285/{}.png".format(text.strip()) # reply with a photo to the name the user sent, # note that you can send photos by url and telegram will fetch it for you bot.sendChatAction(chat_id=chat_id, action="upload_photo") sleep(2) bot.sendPhoto(chat_id=chat_id, photo=url, reply_to_message_id=msg_id) except Exception: # if things went wrong bot.sendMessage(chat_id=chat_id, text="There was a problem in the name you used, please enter different name", reply_to_message_id=msg_id)

Jak widać we fragmencie, dodaliśmy akcję wpisywania, gdy mamy zamiar wysłać informacje o bocie, która jest w formacie tekstowym, oraz dodaliśmy akcję przesyłania zdjęć, gdy mamy zamiar wysłać zdjęcie, aby bot był bardziej realistyczny . Więcej akcji znajdziesz tutaj.

Możesz także zmienić obraz i opis bota z kanału BotFather, aby był bardziej przyjazny.

Wiele prostszych przykładów botów telegramowych można znaleźć na stronie python-telegram-bot na GitHub.

Możesz oprzeć się na naszym bocie i uczynić go kolejnym super botem AI — wszystko, co musisz zrobić, to zintegrować swoją logikę z funkcją respond() . Na przykład twoja logika może znajdować się w osobnym module i może być wywołana wewnątrz funkcji respond() w następujący sposób:

 . ├── app.py ├── telebot │ ├── credentials.py │ ├──ai.py │ | . │ | you can build your engine here │ | . │ └── __init__.py └── botenv

A wewnątrz ai .py :

 def generate_smart_reply(text): # here we can do all our work return "this is a smart reply from the ai!"

Zaimportuj go teraz w aplikacji .py :

 import re from time import sleep from flask import Flask, request import telegram From telebot.ai import generate_smart_reply from telebot.credentials import bot_token, bot_user_name,URL

Następnie po prostu wywołaj go wewnątrz kodu respond() .

 def respond(): # retrieve the message in JSON and then transform it to Telegram object update = telegram.Update.de_json(request.get_json(force=True), bot) chat_id = update.message.chat.id msg_id = update.message.message_id # Telegram understands UTF-8, so encode text for unicode compatibility text = update.message.text.encode('utf-8').decode() # for debugging purposes only print("got text message :", text) # here call your smart reply message reply = generate_smart_reply(text) bot.sendMessage(chat_id=chat_id, text=reply, reply_to_message_id=msg_id)

Teraz możesz sprawić, by Twój bot działał tak, jak chcesz — śmiało stwórz kolejną wielką rzecz!

Mam nadzieję, że dobrze się bawiłeś podczas budowania swojego pierwszego bota Telegrama.

Dodatkowe zasoby

• Budowanie Chatbota za pomocą Telegrama i Pythona
• Łatwe ustawianie Telegram Bot WebHook
• Repozytorium Python-telegram-bot
• Wdrażanie za pomocą Git na Heroku
• Dokumentacja Pythona Telegram Bot