lora tg bot
1.0.0
pytelegrambotapi
Una implementación simple pero extensible de Python para la API BOT Telegram.
Tanto sincrónicos como asincrónicos.
Versión de API BOT compatible: 7.1!
Esta API se prueba con Python 3.8-3.12 y Pypy 3. Hay dos formas de instalar la biblioteca:
$ pip install pyTelegramBotAPI
$ pip install git+https://github.com/eternnoir/pyTelegramBotAPI.git
Generalmente se recomienda usar la primera opción.
Si bien la API está lista para la producción, todavía está en desarrollo y tiene actualizaciones regulares, no olvide actualizarla regularmente llamando
pip install pytelegrambotapi --upgrade
Se presume que ha obtenido un token API con @Botfather. Llamaremos a esto token TOKEN . Además, tiene un conocimiento básico del lenguaje de programación de Python y, lo que es más importante, de la API BOT Telegram.
La clase Telebot (definida en __init__.py) encapsula todas las llamadas de API en una sola clase. Proporciona funciones como send_xyz ( send_message , send_document , etc.) y varias formas de escuchar mensajes entrantes.
Cree un archivo llamado echo_bot.py . Luego, abra el archivo y cree una instancia de la clase Telebot.
import telebot
bot = telebot . TeleBot ( "TOKEN" , parse_mode = None ) # You can set parse_mode by default. HTML or MARKDOWNNota: Asegúrese de reemplazar realmente el token con su propio token API.
Después de esa declaración, necesitamos registrar algunos llamados manejadores de mensajes. Los manejadores de mensajes definen filtros que debe pasar un mensaje. Si un mensaje pasa el filtro, se llama la función decorada y el mensaje entrante se pasa como argumento.
Definamos un controlador de mensajes que maneja los comandos entrantes /start y /help .
@ bot . message_handler ( commands = [ 'start' , 'help' ])
def send_welcome ( message ):
bot . reply_to ( message , "Howdy, how are you doing?" )Una función decorada por un controlador de mensajes puede tener un nombre arbitrario, sin embargo, debe tener solo un parámetro (el mensaje) .
Agreguemos otro controlador:
@ bot . message_handler ( func = lambda m : True )
def echo_all ( message ):
bot . reply_to ( message , message . text )Este se hace eco de todos los mensajes de texto entrantes al remitente. Utiliza una función Lambda para probar un mensaje. Si el Lambda devuelve verdadero, el mensaje es manejado por la función decorada. Dado que queremos que todos los mensajes sean manejados por esta función, simplemente siempre devolvemos verdadero.
Nota: Todos los manejadores se prueban en el orden en que fueron declarados
Ahora tenemos un bot básico que responde un mensaje estático a los comandos "/inicio" y "/ayuda" y que se hace eco del resto de los mensajes enviados. Para iniciar el bot, agregue lo siguiente a nuestro archivo fuente:
bot . infinity_polling ()Muy bien, ¡eso es todo! Nuestro archivo fuente ahora se ve así:
import telebot
bot = telebot . TeleBot ( "YOUR_BOT_TOKEN" )
@ bot . message_handler ( commands = [ 'start' , 'help' ])
def send_welcome ( message ):
bot . reply_to ( message , "Howdy, how are you doing?" )
@ bot . message_handler ( func = lambda message : True )
def echo_all ( message ):
bot . reply_to ( message , message . text )
bot . infinity_polling () Para iniciar el bot, ¡simplemente abra un terminal e ingrese python echo_bot.py para ejecutar el bot! Pruébelo enviando comandos ('/inicio' y '/ayuda') y mensajes de texto arbitrarios.
Todos los tipos se definen en tipos.py. Todos están completamente en línea con la definición de la API de Telegram de los tipos, excepto los mensajes from el campo, que se renombra a from_user (porque from es un token reservado de Python). Por lo tanto, se puede acceder a atributos como message_id directamente con message.message_id . Tenga en cuenta que message.chat puede ser una instancia de User o GroupChat (vea ¿Cómo puedo distinguir un usuario y un grupo en Message.Chat?).
El objeto de mensaje también tiene un atributo content_type , que define el tipo de mensaje. content_type puede ser una de las siguientes cadenas: text , audio , document , animation , game , photo , sticker , video , video_note , voice , location , contact , venue , dice , new_chat_members , left_chat_member , new_chat_title , new_chat_photo , delete_chot_photo, group_chat_created, supergroup, súper group, súper group, delete_chat_photo group, group_chat_created , supergroup_chat_created channel_chat_created , migrate_to_chat_id , migrate_from_chat_id , pinned_message , invoice , successful_payment , connected_website , poll , passport_data , proximity_alert_triggered , video_chat_scheduled , video_chat_started , video_chat_ended , video_chat_participants_invited web_app_data , message_auto_delete_timer_changed , forum_topic_created , forum_topic_closed , forum_topic_reopened , forum_topic_edited , general_forum_topic_hidden , general_forum_topic_unhidden , write_access_allowed , user_shared , chat_shared , story .
Puede usar algunos tipos en una función. Ejemplo:
content_types=["text", "sticker", "pinned_message", "photo", "audio"]
Todos los métodos API se encuentran en la clase Telebot. Se renombra para seguir las convenciones comunes de nombres de Python. Por ejemplo, getMe se renombra para get_me y sendMessage a send_message .
A continuación se describen algunos casos de uso general de la API.
Un controlador de mensajes es una función que está decorada con el decorador de message_handler de una instancia de Telebot. Los manejadores de mensajes consisten en uno o múltiples filtros. Cada filtro debe devolver verdadero para un determinado mensaje para que un controlador de mensajes sea elegible para manejar ese mensaje. Un controlador de mensajes se declara de la siguiente manera (siempre que bot es una instancia de Telebot):
@ bot . message_handler ( filters )
def function_name ( message ):
bot . reply_to ( message , "This is a message handler" ) function_name no está vinculado a ninguna restricción. Cualquier nombre de función está permitido con manejadores de mensajes. La función debe aceptar como máximo un argumento, que será el mensaje que debe manejar la función. filters es una lista de argumentos de palabras clave. Un filtro se declara de la siguiente manera: name=argument . Un controlador puede tener múltiples filtros. Telebot admite los siguientes filtros:
| nombre | argumento (s) | Condición |
|---|---|---|
| content_types | Lista de cadenas (predeterminada ['text'] ) | True If Message.Content_Type está en la lista de cadenas. |
| regexp | una expresión regular como cadena | True si re.search(regexp_arg) Devuelve True and message.content_type == 'text' (ver expresiones regulares de Python) |
| comandos | Lista de cuerdas | True If message.content_type == 'text' y message.text comienza con un comando que está en la lista de cadenas. |
| chat_types | Lista de tipos de chat | True If message.chat.type en su filtro |
| concurrido | una función (referencia de lambda o función) | True si la referencia de lambda o función devuelve True |
Aquí hay algunos ejemplos de uso de los filtros y los controladores de mensajes:
import telebot
bot = telebot . TeleBot ( "TOKEN" )
# Handles all text messages that contains the commands '/start' or '/help'.
@ bot . message_handler ( commands = [ 'start' , 'help' ])
def handle_start_help ( message ):
pass
# Handles all sent documents and audio files
@ bot . message_handler ( content_types = [ 'document' , 'audio' ])
def handle_docs_audio ( message ):
pass
# Handles all text messages that match the regular expression
@ bot . message_handler ( regexp = "SOME_REGEXP" )
def handle_message ( message ):
pass
# Handles all messages for which the lambda returns True
@ bot . message_handler ( func = lambda message : message . document . mime_type == 'text/plain' , content_types = [ 'document' ])
def handle_text_doc ( message ):
pass
# Which could also be defined as:
def test_message ( message ):
return message . document . mime_type == 'text/plain'
@ bot . message_handler ( func = test_message , content_types = [ 'document' ])
def handle_text_doc ( message ):
pass
# Handlers can be stacked to create a function which will be called if either message_handler is eligible
# This handler will be called if the message starts with '/hello' OR is some emoji
@ bot . message_handler ( commands = [ 'hello' ])
@ bot . message_handler ( func = lambda msg : msg . text . encode ( "utf-8" ) == SOME_FANCY_EMOJI )
def send_something ( message ):
passIMPORTANTE: Todos los manejadores se prueban en el orden en que fueron declarados
Manejar mensajes editados @bot.edited_message_handler(filters) # <- passes a Message type object to your function
Manejar los mensajes de publicación de canal @bot.channel_post_handler(filters) # <- passes a Message type object to your function
Manejar mensajes de publicación de canal editado @bot.edited_channel_post_handler(filters) # <- passes a Message type object to your function
Manejar consultas de devolución de llamada
@ bot . callback_query_handler ( func = lambda call : True )
def test_callback ( call ): # <- passes a CallbackQuery type object to your function
logger . info ( call ) Manejo de consultas de envío @bot.shipping_query_handler() # <- passes a ShippingQuery type object to your function
Manejar consultas previas en checkupt @bot.pre_checkout_query_handler() # <- passes a PreCheckoutQuery type object to your function
Las actualizaciones de la encuesta manejan @bot.poll_handler() # <- passes a Poll type object to your function
Respuestas de la encuesta de manejo @bot.poll_answer_handler() # <- passes a PollAnswer type object to your function
Manejar actualizaciones de un estado de miembro del bot en un chat @bot.my_chat_member_handler() # <- passes a ChatMemberUpdated type object to your function
Maneje las actualizaciones del estado de un miembro de chat en un chat @bot.chat_member_handler() # <- passes a ChatMemberUpdated type object to your function Nota: "CHAT_MEME" Las actualizaciones no se solicitan de forma predeterminada. Si desea permitir todos los tipos de actualización, establezca allowed_updates en bot.polling() / bot.infinity_polling() para util.update_types
Handle las solicitudes de unir chat usando: @bot.chat_join_request_handler() # <- passes ChatInviteLink type object to your function
Más información sobre el modo en línea.
Ahora, puede usar Inline_handler para obtener consultas en línea en Telebot.
@ bot . inline_handler ( lambda query : query . query == 'text' )
def query_text ( inline_query ):
# Query message is text Use Eleged_inline_handler para ser elegido_inline_result en Telebot. No olvides Agregar el comando /setinlineFeedback para @botfather.
Más información: recopilación de retroalimentación
@ bot . chosen_inline_handler ( func = lambda chosen_inline_result : True )
def test_chosen ( chosen_inline_result ):
# Process all chosen_inline_result. @ bot . inline_handler ( lambda query : query . query == 'text' )
def query_text ( inline_query ):
try :
r = types . InlineQueryResultArticle ( '1' , 'Result' , types . InputTextMessageContent ( 'Result message.' ))
r2 = types . InlineQueryResultArticle ( '2' , 'Result2' , types . InputTextMessageContent ( 'Result message2.' ))
bot . answer_inline_query ( inline_query . id , [ r , r2 ])
except Exception as e :
print ( e ) Un controlador de middleware es una función que le permite modificar las solicitudes o el contexto de BOT a medida que pasan por el telegrama al bot. Puede imaginar el middleware como una cadena de conexión lógica manejada antes de que se ejecute otros manejadores. El procesamiento de middleware está deshabilitado de forma predeterminada, habilitándolo configurando apihelper.ENABLE_MIDDLEWARE = True .
apihelper . ENABLE_MIDDLEWARE = True
@ bot . middleware_handler ( update_types = [ 'message' ])
def modify_message ( bot_instance , message ):
# modifying the message before it reaches any other handler
message . another_text = message . text + ':changed'
@ bot . message_handler ( commands = [ 'start' ])
def start ( message ):
# the message is already modified when it reaches message handler
assert message . another_text == message . text + ':changed'Hay otros ejemplos que usan el controlador de middleware en el directorio de ejemplos/middleware.
Hay middlewares basados en clase. El middleware básico basado en la clase se ve así:
class Middleware ( BaseMiddleware ):
def __init__ ( self ):
self . update_types = [ 'message' ]
def pre_process ( self , message , data ):
data [ 'foo' ] = 'Hello' # just for example
# we edited the data. now, this data is passed to handler.
# return SkipHandler() -> this will skip handler
# return CancelUpdate() -> this will cancel update
def post_process ( self , message , data , exception = None ):
print ( data [ 'foo' ])
if exception : # check for exception
print ( exception )El middleware basado en clases debe tener dos funciones: Post y PreCoact. Por lo tanto, como puede ver, la ejecución de MiddleWares basados en clase antes y después del controlador. Para obtener más información, consulte en ejemplos
Además, puede usar filtros personalizados incorporados. O puede crear su propio filtro.
Ejemplo de filtro personalizado también, tenemos ejemplos sobre ellos. Verifique estos enlaces: puede verificar algunos filtros incorporados en el código fuente Ejemplo de filtrado por ID Ejemplo de filtrado por texto Si desea agregar algún filtro incorporado, puede agregarlo en el archivo custom_filters.py. Aquí hay un ejemplo de creación de Clase de filtro:
class IsAdmin ( telebot . custom_filters . SimpleCustomFilter ):
# Class will check whether the user is admin or creator in group or not
key = 'is_chat_admin'
@ staticmethod
def check ( message : telebot . types . Message ):
return bot . get_chat_member ( message . chat . id , message . from_user . id ). status in [ 'administrator' , 'creator' ]
# To register filter, you need to use method add_custom_filter.
bot . add_custom_filter ( IsAdmin ())
# Now, you can use it in handler.
@ bot . message_handler ( is_chat_admin = True )
def admin_of_group ( message ):
bot . send_message ( message . chat . id , 'You are admin of this group!' ) import telebot
TOKEN = '<token_string>'
tb = telebot . TeleBot ( TOKEN ) #create a new Telegram Bot object
# Upon calling this function, TeleBot starts polling the Telegram servers for new messages.
# - interval: int (default 0) - The interval between polling requests
# - timeout: integer (default 20) - Timeout in seconds for long polling.
# - allowed_updates: List of Strings (default None) - List of update types to request
tb . infinity_polling ( interval = 0 , timeout = 20 )
# getMe
user = tb . get_me ()
# setWebhook
tb . set_webhook ( url = "http://example.com" , certificate = open ( 'mycert.pem' ))
# unset webhook
tb . remove_webhook ()
# getUpdates
updates = tb . get_updates ()
# or
updates = tb . get_updates ( 1234 , 100 , 20 ) #get_Updates(offset, limit, timeout):
# sendMessage
tb . send_message ( chat_id , text )
# editMessageText
tb . edit_message_text ( new_text , chat_id , message_id )
# forwardMessage
tb . forward_message ( to_chat_id , from_chat_id , message_id )
# All send_xyz functions which can take a file as an argument, can also take a file_id instead of a file.
# sendPhoto
photo = open ( '/tmp/photo.png' , 'rb' )
tb . send_photo ( chat_id , photo )
tb . send_photo ( chat_id , "FILEID" )
# sendAudio
audio = open ( '/tmp/audio.mp3' , 'rb' )
tb . send_audio ( chat_id , audio )
tb . send_audio ( chat_id , "FILEID" )
## sendAudio with duration, performer and title.
tb . send_audio ( CHAT_ID , file_data , 1 , 'eternnoir' , 'pyTelegram' )
# sendVoice
voice = open ( '/tmp/voice.ogg' , 'rb' )
tb . send_voice ( chat_id , voice )
tb . send_voice ( chat_id , "FILEID" )
# sendDocument
doc = open ( '/tmp/file.txt' , 'rb' )
tb . send_document ( chat_id , doc )
tb . send_document ( chat_id , "FILEID" )
# sendSticker
sti = open ( '/tmp/sti.webp' , 'rb' )
tb . send_sticker ( chat_id , sti )
tb . send_sticker ( chat_id , "FILEID" )
# sendVideo
video = open ( '/tmp/video.mp4' , 'rb' )
tb . send_video ( chat_id , video )
tb . send_video ( chat_id , "FILEID" )
# sendVideoNote
videonote = open ( '/tmp/videonote.mp4' , 'rb' )
tb . send_video_note ( chat_id , videonote )
tb . send_video_note ( chat_id , "FILEID" )
# sendLocation
tb . send_location ( chat_id , lat , lon )
# sendChatAction
# action_string can be one of the following strings: 'typing', 'upload_photo', 'record_video', 'upload_video',
# 'record_audio', 'upload_audio', 'upload_document' or 'find_location'.
tb . send_chat_action ( chat_id , action_string )
# getFile
# Downloading a file is straightforward
# Returns a File object
import requests
file_info = tb . get_file ( file_id )
file = requests . get ( 'https://api.telegram.org/file/bot{0}/{1}' . format ( API_TOKEN , file_info . file_path ))
Todas las funciones send_xyz de TeleBot toman un argumento opcional reply_markup . Este argumento debe ser una instancia de ReplyKeyboardMarkup , ReplyKeyboardRemove o ForceReply , que se definen en tipos.py.
from telebot import types
# Using the ReplyKeyboardMarkup class
# It's constructor can take the following optional arguments:
# - resize_keyboard: True/False (default False)
# - one_time_keyboard: True/False (default False)
# - selective: True/False (default False)
# - row_width: integer (default 3)
# row_width is used in combination with the add() function.
# It defines how many buttons are fit on each row before continuing on the next row.
markup = types . ReplyKeyboardMarkup ( row_width = 2 )
itembtn1 = types . KeyboardButton ( 'a' )
itembtn2 = types . KeyboardButton ( 'v' )
itembtn3 = types . KeyboardButton ( 'd' )
markup . add ( itembtn1 , itembtn2 , itembtn3 )
tb . send_message ( chat_id , "Choose one letter:" , reply_markup = markup )
# or add KeyboardButton one row at a time:
markup = types . ReplyKeyboardMarkup ()
itembtna = types . KeyboardButton ( 'a' )
itembtnv = types . KeyboardButton ( 'v' )
itembtnc = types . KeyboardButton ( 'c' )
itembtnd = types . KeyboardButton ( 'd' )
itembtne = types . KeyboardButton ( 'e' )
markup . row ( itembtna , itembtnv )
markup . row ( itembtnc , itembtnd , itembtne )
tb . send_message ( chat_id , "Choose one letter:" , reply_markup = markup )El último ejemplo produce este resultado:
# ReplyKeyboardRemove: hides a previously sent ReplyKeyboardMarkup
# Takes an optional selective argument (True/False, default False)
markup = types . ReplyKeyboardRemove ( selective = False )
tb . send_message ( chat_id , message , reply_markup = markup ) # ForceReply: forces a user to reply to a message
# Takes an optional selective argument (True/False, default False)
markup = types . ForceReply ( selective = False )
tb . send_message ( chat_id , "Send me another word:" , reply_markup = markup )Forceply:
Este objeto representa una entidad especial en un mensaje de texto. Por ejemplo, hashtags, nombres de usuario, URL, etc. Atributos:
typeurloffsetlengthuser Aquí hay un ejemplo: message.entities[num].<attribute>
Aquí num es el número de entidad o el orden de la entidad en una respuesta, ya que si hay en caso de múltiples entidades en la respuesta/mensaje.
message.entities Devuelve una lista de objeto de entidades.
message.entities[0].type daría el tipo de la primera entidad
Consulte la API BOT para obtener detalles adicionales
Desde la versión 5.0 de la API BOT, tiene la posibilidad de ejecutar su propio servidor de API BOT local. Pytelegrambotapi también admite esta función.
from telebot import apihelper
apihelper . API_URL = "http://localhost:4200/bot{0}/{1}" IMPORTANTE: Como se describe aquí, debe iniciar sesión su bot desde el servidor Telegram antes de cambiar a su servidor API local. En Pytelegrambotapi use bot.log_out()
Nota: 4200 es un puerto de ejemplo
NUEVO: Hay una implementación asincrónica de Telebot. Para habilitar este comportamiento, cree una instancia de Asynctelebot en lugar de Telebot.
tb = telebot . AsyncTeleBot ( "TOKEN" )Ahora, cada función que llama a la API de Telegram se ejecuta en una tarea asincrónica separada. Usar Asynctelebot le permite hacer lo siguiente:
import telebot
tb = telebot . AsyncTeleBot ( "TOKEN" )
@ tb . message_handler ( commands = [ 'start' ])
async def start_message ( message ):
await bot . send_message ( message . chat . id , 'Hello!' )Ver más en ejemplos
A veces debes enviar mensajes que superen los 5000 caracteres. La API de Telegram no puede manejar tantos caracteres en una sola solicitud, por lo que necesitamos dividir el mensaje en múltiplos. Aquí está cómo hacerlo usando la API:
from telebot import util
large_text = open ( "large_text.txt" , "rb" ). read ()
# Split the text each 3000 characters.
# split_string returns a list with the splitted text.
splitted_text = util . split_string ( large_text , 3000 )
for text in splitted_text :
tb . send_message ( chat_id , text ) O puede usar la nueva función smart_split para obtener sustraciones más significativas:
from telebot import util
large_text = open ( "large_text.txt" , "rb" ). read ()
# Splits one string into multiple strings, with a maximum amount of `chars_per_string` (max. 4096)
# Splits by last 'n', '. ' or ' ' in exactly this priority.
# smart_split returns a list with the splitted text.
splitted_text = util . smart_split ( large_text , chars_per_string = 3000 )
for text in splitted_text :
tb . send_message ( chat_id , text )El constructor TeleBot toma los siguientes argumentos opcionales:
Como alternativa a los manejadores de mensajes, también se puede registrar una función como oyente a Telebot.
Aviso: ¡los manejadores no desaparecerán! Su mensaje será procesado tanto por manejadores como de oyentes. Además, es imposible predecir qué funcionará al principio debido a los enhebramientos. Si usa Threaded = False, los oyentes personalizados funcionarán antes, después de que se llamen a los manejadores. Ejemplo:
def handle_messages ( messages ):
for message in messages :
# Do something with the message
bot . reply_to ( message , 'Hi' )
bot . set_update_listener ( handle_messages )
bot . infinity_polling ()Al usar Webhooks Telegram envía una actualización por llamada, para procesarla debe llamar a Process_new_Messages ([update.message]) cuando la recibe.
Hay algunos ejemplos utilizando Webhooks en el directorio de ejemplos/webhook_examples.
Puede usar el registrador del módulo Telebot para registrar la información de depuración sobre TeleBot. Use telebot.logger para obtener el registrador del módulo TeleBot. Es posible agregar controladores de registro personalizados al registrador. Consulte la página del módulo de registro de Python para obtener más información.
import logging
logger = telebot . logger
telebot . logger . setLevel ( logging . DEBUG ) # Outputs debug messages to console.Para la sincronización:
Puede usar proxy para la solicitud. El objeto apihelper.proxy se utilizará mediante el argumento de solicitud requests de llamadas.
from telebot import apihelper
apihelper . proxy = { 'http' : 'http://127.0.0.1:3128' } Si desea usar Socket5 Proxy, necesita instalar Dependency pip install requests[socks] y asegúrese de que tenga la última versión de gunicorn , PySocks , pyTelegramBotAPI , requests y urllib3 .
apihelper . proxy = { 'https' : 'socks5://userproxy:password@proxy_address:port' }Para Async:
from telebot import asyncio_helper
asyncio_helper . proxy = 'http://127.0.0.1:3128' #urlPuede deshabilitar o cambiar la interacción con el servidor real de telegrama utilizando
apihelper . CUSTOM_REQUEST_SENDER = your_handlerparámetro. Puede pasar allí su propia función que se llamará en lugar de solicitudes .
Por ejemplo:
def custom_sender ( method , url , ** kwargs ):
print ( "custom_sender. method: {}, url: {}, params: {}" . format ( method , url , kwargs . get ( "params" )))
result = util . CustomRequestResponse ( '{"ok":true,"result":{"message_id": 1, "date": 1, "chat": {"id": 1, "type": "private"}}}' )
return resultLuego puede usar API y continuar las solicitudes en el código de su controlador.
apihelper . CUSTOM_REQUEST_SENDER = custom_sender
tb = TeleBot ( "test" )
res = tb . send_message ( 123 , "Test" )El resultado será:
custom_sender. method: post, url: https://api.telegram.org/botololo/sendMessage, params: {'chat_id': '123', 'text': 'Test'}
Tenemos una versión totalmente asincrónica de Telebot. Esta clase no está controlada por hilos. Las tareas de Asyncio se crean para ejecutar todas las cosas.
Echo Bot Ejemplo en Asynctelebot:
# This is a simple echo bot using the decorator mechanism.
# It echoes any incoming text messages.
from telebot . async_telebot import AsyncTeleBot
import asyncio
bot = AsyncTeleBot ( 'TOKEN' )
# Handle '/start' and '/help'
@ bot . message_handler ( commands = [ 'help' , 'start' ])
async def send_welcome ( message ):
await bot . reply_to ( message , """
Hi there, I am EchoBot.
I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!
""" )
# Handle all other messages with content_type 'text' (content_types defaults to ['text'])
@ bot . message_handler ( func = lambda message : True )
async def echo_message ( message ):
await bot . reply_to ( message , message . text )
asyncio . run ( bot . polling ())Como puede ver aquí, las palabras clave se esperan y se async.
Las tareas asincrónicas dependen del rendimiento del procesador. Muchas tareas asíncronas pueden ejecutarse paralelas, mientras que las tareas de los hilos se bloquearán entre sí.
Asynctelebot es asíncrono. Utiliza AIOHTTP en lugar del módulo de solicitudes.
Ver más ejemplos en nuestra carpeta de ejemplos
Telegram Bot API admite nuevo chat de tipo para mensajes. CHAT.
type en el objeto Chat : if message . chat . type == "private" :
# private chat message
if message . chat . type == "group" :
# group chat message
if message . chat . type == "supergroup" :
# supergroup chat message
if message . chat . type == "channel" :
# channel message Las instancias de BOT que estuvieron inactivas durante mucho tiempo podrían ser rechazadas por el servidor al enviar un mensaje debido a un tiempo de espera de la última sesión usada. Agregue apihelper.SESSION_TIME_TO_LIVE = 5 * 60 a su inicialización para forzar la recreación después de 5 minutos sin ninguna actividad.
Obtenga ayuda. Conversar. Charlar.
Únete al canal de noticias. Aquí publicaremos lanzamientos y actualizaciones.
La plantilla es una carpeta lista que contiene arquitectura del proyecto básico. Aquí hay algunos ejemplos de plantilla:
¿Quieres que tu bot en la lista aquí? Solo haga una solicitud de extracción. Solo se aceptan bots con código fuente público.
