Bot for pinning suggestions in telegram group chat - EN version

#this bot is intended to be integrated with Amazon AWS Lambda and Gateway API
#for further information on how to integrate with AWS and Telegram Bot API, I suggest to read related documentation

#it is intended to be used in group chats
#it checks if a message contains a link or a suggestion for whatching a movie/clip/video or listening a song or reading a book
#if the message matches those conditions, the bot asks to the users wheter to pin it or not
#furthermore, the bot can unpin any pinned message whenever a user wants
#it must be added into the group chat and needs for proper administrator permissions (pin, unpin and remove message)

#Be aware this is the English version! Enjoy it!

import json
from time import sleep

#import os to integrate with AWS Lambda environment variables
import os
#import botocore.vendored to integrat with Telegram Bot API
from botocore.vendored import requests

#TELE_TOKEN is Telegram Bot Token
#URL_BOT is the base URL to communicate with Telegram Bots: "https://api.telegram.org/bot{}/"
TELE_TOKEN = os.environ['TELE_TOKEN']
URL = os.environ['URL_BOT'].format(TELE_TOKEN)
#MY_ID is your telegram ID
#Set it for logging
myId = os.environ['MY_ID']

#Telegram Bot API communicating methods
def send_message(text, chat_id, message_id):
    url = URL + "sendMessage?text={}&chat_id={}&reply_to_message_id={}".format(text, chat_id, message_id)
    requests.get(url)

def send_message_with_keyboard(text, chat_id, message_id, keyboard):
    url = URL + "sendMessage?text={}&chat_id={}&reply_to_message_id={}&reply_markup={}".format(text, chat_id, message_id, keyboard)
    requests.get(url)

def send_message_debug(text):
    url = URL + "sendMessage?text={}&chat_id={}".format(text, myId)
    requests.get(url)

def pin_message(chat_id, message_id):
    url = URL + "pinChatMessage?chat_id={}&message_id={}".format(chat_id, message_id)
    requests.get(url)

def delete_message(chat_id, message_id):
    url = URL + "deleteMessage?chat_id={}&message_id={}".format(chat_id, message_id)
    requests.get(url)

def edit_message_text(chat_id, message_id, text):
    url = URL + "editMessageText?chat_id={}&message_id={}&text={}".format(chat_id, message_id, text)
    requests.get(url)

def remove_reply_markup(chat_id, message_id):
    url = URL + "editMessageReplyMarkup?chat_id={}&message_id={}".format(chat_id, message_id)
    requests.get(url)

def update_reply_markup(chat_id, message_id, pinned_message_id, text):
    callbackData = "remove_pin_message|" + str(chat_id) + "|" + str(pinned_message_id)
    inline_keyboard = [
        [
            {'text': 'Remove', 'callback_data': callbackData}
        ]
    ]
    url = URL + "editMessageText?chat_id={}&message_id={}&reply_markup={}&text={}".format(chat_id, message_id, json.dumps({'inline_keyboard': inline_keyboard}), text)
    requests.get(url)

def remove_pin_message(chat_id, message_id):
    url = URL + "unpinChatMessage?chat_id={}&message_id={}".format(chat_id, message_id)
    requests.get(url)

#message managing methods
def manageMessage(body):
    message = body['message']
    if 'text' in message:
        manageMessageWithText(message)
    else:
        send_message_debug("Found a new type of message: {}".format(message))

def manageMessageWithText(message):

    chat_id = message['chat']['id']
    from_id = message['from']['id']
    message_id = message['message_id']
    message_text = message['text']
    message_text = message_text.lower()

    if ( any(word in message_text for word in ["listen", "watch", "look", "read", "youtu.be", "youtube.", "https://", "http://"]) ):
        callbackData = "pin_message|" + str(chat_id) + "|" + str(message_id)
        callbackDataNo = "not_want_to_pin|Ok, I won't pin it."
        inline_keyboard = [
            [
                {'text': 'OK', 'callback_data': callbackData},
                {'text': 'NO', 'callback_data': callbackDataNo}
            ]
        ]
        send_message_with_keyboard("Shall I pin it?", chat_id, message_id, json.dumps({'inline_keyboard': inline_keyboard}))


def manageCallbackQuery(body):
    callbackQuery = body['callback_query']
    data = callbackQuery['data'].split('|')
    queryType = data[0]
    if queryType == "delete_request":
        message_id = callbackQuery['message']['message_id']
        chat_id = callbackQuery['message']['chat']['id']
        delete_message(chat_id, message_id)
    elif queryType == 'pin_message':
        inline_id = callbackQuery['message']['message_id']
        inline_chat_id = callbackQuery['message']['chat']['id']
        chat_id = data[1]
        message_id = data[2]
        update_reply_markup(inline_chat_id, inline_id, message_id, "Pinned it!")
        pin_message(chat_id, message_id)
    elif queryType == "not_want_to_pin":
        message_id = callbackQuery['message']['message_id']
        chat_id = callbackQuery['message']['chat']['id']
        new_text = data[1]
        delete_message(chat_id, message_id)
    elif queryType == "remove_pin_message":
        chat_id = data[1]
        message_id = data[2]
        inline_id = callbackQuery['message']['message_id']
        inline_chat_id = callbackQuery['message']['chat']['id']
        remove_pin_message(chat_id, message_id)
        edit_message_text(inline_chat_id, inline_id, "Unpinned it!")
    else:
        send_message_debug("Found unexpected callback_query: {}".format(callback_query))

#this is the main method
#it must be named "lambda_handler", for AWS Lambda integration
#it must return 'statusCode': 200, for Telegram Bot API integration
def lambda_handler(event, context):
    myIdNum = int(myId)
    try:
        if 'body' in event:
            body = json.loads(event['body'])
            if 'callback_query' in body:
                manageCallbackQuery(body)
            elif 'message' in body:
                manageMessage(body)
            else:
                send_message_debug("Found a new type of body: " + body)
        else:
            send_message_debug("Found a body-less event: {}".format(event))
    except Exception as err:
        send_message_debug("An error occured: {}. For event {}".format(err, event))
    finally:
        return {
            'statusCode': 200
        }