lora tg bot
1.0.0
Pytelegrambotapi
Uma implementação Python simples, mas extensível, para a API do Telegram Bot.
Tanto síncrono quanto assíncrono.
API de bot suportado Versão: 7.1!
Esta API é testada com Python 3.8-3.12 e Pypy 3. Existem duas maneiras de instalar a biblioteca:
$ pip install pyTelegramBotAPI
$ pip install git+https://github.com/eternnoir/pyTelegramBotAPI.git
Geralmente é recomendável usar a primeira opção.
Embora a API esteja pronta para a produção, ela ainda está em desenvolvimento e possui atualizações regulares, não se esqueça de atualizá-la regularmente ligando
pip install pytelegrambotapi --upgrade
Presume -se que você tenha obtido um token da API com @botfather. Vamos chamar isso de TOKEN . Além disso, você tem conhecimento básico da linguagem de programação Python e, mais importante, a API do Telegram Bot.
A classe Telebot (definida em __init__.py) encapsula todas as chamadas de API em uma única classe. Ele fornece funções como send_xyz ( send_message , send_document etc.) e várias maneiras de ouvir mensagens recebidas.
Crie um arquivo chamado echo_bot.py . Em seguida, abra o arquivo e crie uma instância da classe Telebot.
import telebot
bot = telebot . TeleBot ( "TOKEN" , parse_mode = None ) # You can set parse_mode by default. HTML or MARKDOWNNota: Certifique -se de substituir o token pelo seu próprio token de API.
Após essa declaração, precisamos registrar alguns chamados manipuladores de mensagens. Os manipuladores de mensagens definem filtros que uma mensagem deve passar. Se uma mensagem passar o filtro, a função decorada será chamada e a mensagem de entrada será passada como um argumento.
Vamos definir um manipulador de mensagens que lida com os comandos de entrada /start e /help .
@ bot . message_handler ( commands = [ 'start' , 'help' ])
def send_welcome ( message ):
bot . reply_to ( message , "Howdy, how are you doing?" )Uma função decorada por um manipulador de mensagens pode ter um nome arbitrário, no entanto, deve ter apenas um parâmetro (a mensagem) .
Vamos adicionar outro manipulador:
@ bot . message_handler ( func = lambda m : True )
def echo_all ( message ):
bot . reply_to ( message , message . text )Este ecoa todas as mensagens de texto recebidas de volta ao remetente. Ele usa uma função lambda para testar uma mensagem. Se o Lambda retornar verdadeiro, a mensagem será tratada pela função decorada. Como queremos que todas as mensagens sejam tratadas por essa função, sempre retornamos verdadeiro.
Nota: Todos os manipuladores são testados na ordem em que foram declarados
Agora temos um bot básico que responde uma mensagem estática aos comandos "Start/Start" e "Help" e que ecoa o restante das mensagens enviadas. Para iniciar o bot, adicione o seguinte ao nosso arquivo de origem:
bot . infinity_polling ()Tudo bem, é isso! Nosso arquivo de origem agora se parece com o seguinte:
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 o bot, basta abrir um terminal e entrar em python echo_bot.py para executar o bot! Teste -o enviando comandos ('/start' e '/ajuda') e mensagens de texto arbitrárias.
Todos os tipos são definidos em tipos.py. Eles estão todos completamente alinhados com a definição dos tipos da API do Telegram, exceto a mensagem from campo, que é renomeada para from_user ( from é um token reservado Python). Assim, atributos como message_id podem ser acessados diretamente com message.message_id . Observe que o message.chat pode ser uma instância do User ou GroupChat (consulte como posso distinguir um usuário e um grupo de grupo no message.chat?).
O objeto de mensagem também possui um atributo content_type , que define o tipo da mensagem. content_type can be one of the following strings: 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_chat_photo , group_chat_created , supergroup_chat_created , channel_chat_created , migrate_to_chat_id , migrate_from_chat_id , pinned_message , invoice , com successful_payment video_chat_participants_invited connected_website , poll video_chat_started passport_data video_chat_scheduled proximity_alert_triggered , video_chat_ended web_app_data , message_auto_delete_timer_changed , forum_topic_created , forum_topic_closed , forum_topic_reopened , forum_topic_edited , general_forum_topic_unhidden , general_forum_topic_hidden , write_access_allowed , story , user_shared , chat_shared
Você pode usar alguns tipos em uma função. Exemplo:
content_types=["text", "sticker", "pinned_message", "photo", "audio"]
Todos os métodos da API estão localizados na classe Telebot. Eles são renomeados para seguir convenções comuns de nomeação de Python. Por exemplo, getMe é renomeado para get_me e sendMessage para send_message .
Espelados abaixo estão alguns casos de uso geral da API.
Um manipulador de mensagens é uma função que é decorada com o decorador message_handler de uma instância do Telebot. Os manipuladores de mensagens consistem em um ou vários filtros. Cada filtro deve retornar true para uma determinada mensagem para que um manipulador de mensagens se torne elegível para lidar com essa mensagem. Um manipulador de mensagens é declarado da seguinte maneira (desde que bot seja uma instância do Telebot):
@ bot . message_handler ( filters )
def function_name ( message ):
bot . reply_to ( message , "This is a message handler" ) function_name não está vinculado a nenhuma restrição. Qualquer nome de função é permitido com manipuladores de mensagens. A função deve aceitar no máximo um argumento, que será a mensagem que a função deve lidar. filters é uma lista de argumentos de palavras -chave. Um filtro é declarado da seguinte maneira: name=argument . Um manipulador pode ter vários filtros. Telebot suporta os seguintes filtros:
| nome | argumento (s) | Doença |
|---|---|---|
| content_types | Lista de strings (padrão ['text'] ) | True if message.content_type está na lista de strings. |
| regexp | uma expressão regular como uma corda | True se re.search(regexp_arg) retorna True e message.content_type == 'text' (consulte expressões regulares do Python) |
| comandos | Lista de strings | True if message.content_type == 'text' e message.text inicia com um comando que está na lista de strings. |
| chat_types | Lista de tipos de bate -papo | True se message.chat.type em seu filtro |
| functão | uma função (lambda ou referência de função) | True se a referência lambda ou função True |
Aqui estão alguns exemplos de uso dos filtros e manipuladores de mensagens:
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 os manipuladores são testados na ordem em que foram declarados
Handle mensagens editadas @bot.edited_message_handler(filters) # <- passes a Message type object to your function
Lidar com mensagens de postagem de canal @bot.channel_post_handler(filters) # <- passes a Message type object to your function
Handle Channel editado Mensagens de postagem @bot.edited_channel_post_handler(filters) # <- passes a Message type object to your function
Lidar com consultas de retorno de chamada
@ bot . callback_query_handler ( func = lambda call : True )
def test_callback ( call ): # <- passes a CallbackQuery type object to your function
logger . info ( call ) Lidar com consultas de remessa @bot.shipping_query_handler() # <- passes a ShippingQuery type object to your function
Lidar com as consultas pré-checkOUpt @bot.pre_checkout_query_handler() # <- passes a PreCheckoutQuery type object to your function
Lidar com atualizações de pesquisa @bot.poll_handler() # <- passes a Poll type object to your function
Lidar com respostas da enquete @bot.poll_answer_handler() # <- passes a PollAnswer type object to your function
Lidar com as atualizações de um status de membro do bot em um bate-papo @bot.my_chat_member_handler() # <- passes a ChatMemberUpdated type object to your function
Lidar com as atualizações do status de um membro do bate-papo em um bate-papo @bot.chat_member_handler() # <- passes a ChatMemberUpdated type object to your function Nota: "Chat_member" as atualizações não são solicitadas por padrão. Se você deseja permitir todos os tipos de atualização, defina allowed_updates em bot.polling() / bot.infinity_polling() como util.update_types
Lidar com as solicitações de junção de bate-papo usando: @bot.chat_join_request_handler() # <- passes ChatInviteLink type object to your function
Mais informações sobre o modo embutido.
Agora, você pode usar o Inline_Handler para obter consultas em linha no Telebot.
@ bot . inline_handler ( lambda query : query . query == 'text' )
def query_text ( inline_query ):
# Query message is text Use CHOSEN_INLINE_HANDLER para ser escolhido para CHOSEN_INLINE_RESULT no Telebot. Não se esqueça, adicione o comando /setinLineFeedback para @botfather.
Mais informações: coleta de feedback
@ 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 ) Um manipulador de middleware é uma função que permite modificar solicitações ou o contexto de bot à medida que passam pelo telegrama para o bot. Você pode imaginar o middleware como uma cadeia de conexão lógica tratada antes que outros manipuladores sejam executados. O processamento do middleware é desativado por padrão, habilite a configuração de 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'Existem outros exemplos usando o manipulador de middleware no diretório Exemplos/Middleware.
Existem Middlewares baseados em classe. O middleware básico baseado em classe se parece com o seguinte:
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 )O middleware baseado em classe deve ter duas funções: postar e pré-processo. Assim, como você pode ver, o Middlewares baseado em classe trabalha antes e depois da execução do manipulador. Para mais, confira em exemplos
Além disso, você pode usar filtros personalizados embutidos. Ou você pode criar seu próprio filtro.
Exemplo de filtro personalizado também, temos exemplos neles. Verifique estes links: você pode verificar alguns filtros internos no exemplo do código-fonte de filtragem por exemplo de identificação de filtragem por texto Se desejar adicionar algum filtro interno, você poderá adicioná-lo no arquivo custom_filters.py. Aqui está o exemplo de criação de classe 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 as funções send_xyz do Telebot recebem um argumento opcional reply_markup . Esse argumento deve ser uma instância do ReplyKeyboardMarkup , ReplyKeyboardRemove ou ForceReply , que são definidos em 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 )O último exemplo produz 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 )Forcereply:
Este objeto representa uma entidade especial em uma mensagem de texto. Por exemplo, hashtags, nomes de usuário, URLs, etc. Atributos:
typeurloffsetlengthuser Aqui está um exemplo: message.entities[num].<attribute>
Aqui, num é o número da entidade ou a ordem da entidade em uma resposta, pois, se houver várias entidades na resposta/mensagem.
message.entities Retorna uma lista de entidades objeto.
message.entities[0].type daria o tipo de primeira entidade
Consulte a API de bot para obter detalhes extras
Desde a versão 5.0 da API do bot, você tem a possibilidade de executar seu próprio servidor de API de bot local. O Pytelegrambotapi também suporta esse recurso.
from telebot import apihelper
apihelper . API_URL = "http://localhost:4200/bot{0}/{1}" IMPORTANTE: Como descrito aqui, você deve registrar seu bot no servidor Telegram antes de mudar para o servidor de API local. Em Pytelegrambotapi, use bot.log_out()
Nota: 4200 é uma porta de exemplo
NOVO: Há uma implementação assíncrona do Telebot. Para ativar esse comportamento, crie uma instância de AsyncteleBot em vez de Telebot.
tb = telebot . AsyncTeleBot ( "TOKEN" )Agora, toda função que chama a API do Telegram é executada em uma tarefa assíncrona separada. O uso do AsyncteleBot permite que você faça o seguinte:
import telebot
tb = telebot . AsyncTeleBot ( "TOKEN" )
@ tb . message_handler ( commands = [ 'start' ])
async def start_message ( message ):
await bot . send_message ( message . chat . id , 'Hello!' )Veja mais em exemplos
Às vezes, você deve enviar mensagens que excedam 5000 caracteres. A API do Telegram não pode lidar com muitos caracteres em uma solicitação, portanto, precisamos dividir a mensagem em múltiplos. Aqui está como fazer isso usando a 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 ) Ou você pode usar a nova função smart_split para obter substâncias mais 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 )O construtor Telebot recebe os seguintes argumentos opcionais:
Como alternativa aos manipuladores de mensagens, também é possível registrar uma função como ouvinte do Telebot.
Aviso: os manipuladores não desaparecem! Sua mensagem será processada por manipuladores e ouvintes. Além disso, é impossível prever o que funcionará primeiro por causa do encadeamento. Se você usar threaded = false, os ouvintes personalizados funcionarão mais cedo, depois que os manipuladores serão chamados. Exemplo:
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 ()Ao usar o webhooks O Telegram envia uma atualização por chamada, para processá -lo, você deve chamar Process_New_Messages ([Update.Message]) ao receber.
Existem alguns exemplos usando webhooks no diretório Exemplos/Webhook_examples.
Você pode usar o Logger do Módulo Telebot para registrar informações de depuração sobre o Telebot. Use telebot.logger para obter o módulo Telebot. É possível adicionar manipuladores de registro personalizados ao logger. Consulte a página do módulo de log Python para obter mais informações.
import logging
logger = telebot . logger
telebot . logger . setLevel ( logging . DEBUG ) # Outputs debug messages to console.Para sincronização:
Você pode usar proxy para solicitação. objeto apihelper.proxy usará pelo argumento de proxies de chamadas requests .
from telebot import apihelper
apihelper . proxy = { 'http' : 'http://127.0.0.1:3128' } Se você deseja usar o proxy do Socket5, é necessário instalar pip install requests[socks] e certifique -se de ter a versão mais recente de gunicorn , PySocks , pyTelegramBotAPI , requests e urllib3 .
apihelper . proxy = { 'https' : 'socks5://userproxy:password@proxy_address:port' }Para assíncrono:
from telebot import asyncio_helper
asyncio_helper . proxy = 'http://127.0.0.1:3128' #urlVocê pode desativar ou alterar a interação com o servidor real do telegrama usando
apihelper . CUSTOM_REQUEST_SENDER = your_handlerparâmetro. Você pode passar lá sua própria função que será chamada em vez de solicitações.Request .
Por exemplo:
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 resultEm seguida, você pode usar as solicitações da API e prosseguir em seu código de manipulador.
apihelper . CUSTOM_REQUEST_SENDER = custom_sender
tb = TeleBot ( "test" )
res = tb . send_message ( 123 , "Test" )Resultado será:
custom_sender. method: post, url: https://api.telegram.org/botololo/sendMessage, params: {'chat_id': '123', 'text': 'Test'}
Temos uma versão totalmente assíncrona do Telebot. Esta classe não é controlada por threads. As tarefas do Asyncio são criadas para executar todas as coisas.
ECHO BOT Exemplo no 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 você pode ver aqui, as palavras -chave são aguardando e assíncronas.
Tarefas assíncronas dependem do desempenho do processador. Muitas tarefas assíncronas podem ser executadas em Paralelly, enquanto as tarefas de threads se bloqueam.
Asctelebot é assíncrono. Ele usa AIOHTTP em vez do módulo de solicitações.
Veja mais exemplos em nossa pasta Exemplos
API do Telegram Bot Suporte novo tipo de bate -papo para message.chat.
type no 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 Instâncias de bot que ficaram ociosas por um longo tempo podem ser rejeitadas pelo servidor ao enviar uma mensagem devido ao tempo limite da última sessão usada. Adicione apihelper.SESSION_TIME_TO_LIVE = 5 * 60 à sua inicialização para forçar a recreação após 5 minutos sem nenhuma atividade.
Obtenha ajuda. Discutir. Bater papo.
Junte -se ao canal de notícias. Aqui, publicaremos lançamentos e atualizações.
O modelo é uma pasta pronta que contém arquitetura do projeto básico. Aqui estão alguns exemplos de modelo:
Quer ter seu bot listado aqui? Basta fazer um pedido de tração. Apenas bots com código -fonte público são aceitos.
