lora tg bot
1.0.0
Pytelegambotapi
Eine einfache, aber erweiterbare Python -Implementierung für die Telegramm -Bot -API.
Sowohl synchron als auch asynchron.
Unterstützte Bot -API -Version: 7.1!
Diese API wird mit Python 3.8-3.12 und Pypy getestet. Es gibt zwei Möglichkeiten, die Bibliothek zu installieren:
$ pip install pyTelegramBotAPI
$ pip install git+https://github.com/eternnoir/pyTelegramBotAPI.git
Es wird im Allgemeinen empfohlen, die erste Option zu verwenden.
Während die API produktionsbereit ist, ist sie noch in der Entwicklung und hat regelmäßig Updates. Vergessen Sie nicht, sie regelmäßig zu aktualisieren, indem Sie anrufen
pip install pytelegrambotapi --upgrade
Es wird angenommen, dass Sie mit @BotFather ein API -Token erhalten haben. Wir werden diesen Token TOKEN nennen. Darüber hinaus verfügen Sie über grundlegende Kenntnisse der Python -Programmiersprache und vor allem über die Telegramm -Bot -API.
Die Telebot -Klasse (definiert in __init__.py) fasst alle API -Aufrufe in einer einzigen Klasse zusammen. Es enthält Funktionen wie send_xyz ( send_message , send_document usw.) und verschiedene Möglichkeiten, nach eingehenden Nachrichten zu hören.
Erstellen Sie eine Datei namens echo_bot.py . Öffnen Sie dann die Datei und erstellen Sie eine Instanz der Telebot -Klasse.
import telebot
bot = telebot . TeleBot ( "TOKEN" , parse_mode = None ) # You can set parse_mode by default. HTML or MARKDOWNHinweis: Stellen Sie sicher, dass Token durch Ihr eigenes API -Token ersetzt werden.
Nach dieser Erklärung müssen wir einige sogenannte Nachrichtenhandler registrieren. Nachrichtenhandler definieren Filter, die eine Nachricht verabschieden muss. Wenn eine Nachricht den Filter übergibt, wird die dekorierte Funktion aufgerufen und die eingehende Nachricht als Argument übergeben.
Definieren wir einen Nachrichtenhandler, der die Befehle für eingehende /start und /help verarbeitet.
@ bot . message_handler ( commands = [ 'start' , 'help' ])
def send_welcome ( message ):
bot . reply_to ( message , "Howdy, how are you doing?" )Eine Funktion, die von einem Nachrichtenhandler dekoriert wird , kann einen willkürlichen Namen haben. Sie muss jedoch nur einen Parameter (die Nachricht) haben .
Fügen wir einen weiteren Handler hinzu:
@ bot . message_handler ( func = lambda m : True )
def echo_all ( message ):
bot . reply_to ( message , message . text )Dieser regt alle eingehenden Textnachrichten an den Absender zurück. Es verwendet eine Lambda -Funktion, um eine Nachricht zu testen. Wenn die Lambda wahr zurückgibt, wird die Nachricht von der dekorierten Funktion übernommen. Da wir möchten, dass alle Nachrichten von dieser Funktion behandelt werden, geben wir einfach immer True zurück.
Hinweis: Alle Handler werden in der Reihenfolge getestet, in der sie deklariert wurden
Wir haben jetzt einen grundlegenden Bot, der eine statische Nachricht an "/start "- und"/hilf "-Fandte antwortet und die den Rest der gesendeten Nachrichten widerspiegelt. Um den Bot zu starten, fügen Sie unsere Quelldatei Folgendes hinzu:
bot . infinity_polling ()Okay, das war's! Unsere Quelldatei sieht jetzt so aus:
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 () Um den Bot zu starten, öffnen Sie einfach ein Terminal und geben Sie python echo_bot.py ein, um den Bot auszuführen! Testen Sie es, indem Sie Befehle ('/start' und '/hilf') und willkürliche Textnachrichten senden.
Alle Typen sind in Typen definiert.py. Sie sind alle vollständig mit der Definition der Telegramm -API -Definition der Typen überein, mit Ausnahme der Botschaft from dem Feld, die in from_user umbenannt wird (weil from einem Python reservierten Token ist). Somit können Attribute wie message_id direkt mit message.message_id zugegriffen werden. Beachten Sie, dass message.chat entweder eine Instanz von User oder GroupChat sein kann (siehe, wie kann ich einen Benutzer und einen GroupChat in Message.chat?) Unterscheiden.
Das Nachrichtenobjekt hat auch ein content_type -Attribut, das den Typ der Nachricht definiert. 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 , 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 .
Sie können einige Typen in einer Funktion verwenden. Beispiel:
content_types=["text", "sticker", "pinned_message", "photo", "audio"]
Alle API -Methoden befinden sich in der Telebot -Klasse. Sie werden umbenannt, um gemeinsame Python -Namenskonventionen zu folgen. ZB getMe wird in get_me und sendMessage in send_message umbenannt.
Im Folgenden sind einige allgemeine Anwendungsfälle der API aufgeführt.
Ein Nachrichtenhandler ist eine Funktion, die mit dem message_handler Decorator einer Telebot -Instanz verziert ist. Nachrichtenhandler bestehen aus einem oder mehreren Filtern. Jeder Filter muss TRUE für eine bestimmte Nachricht zurückgeben, damit ein Nachrichtenhandler in Frage kommt, dass diese Nachricht verarbeitet wird. Ein Nachrichtenhandler wird auf folgende Weise deklariert (vorausgesetzt, bot ist eine Instanz von Telebot):
@ bot . message_handler ( filters )
def function_name ( message ):
bot . reply_to ( message , "This is a message handler" ) function_name ist nicht an Beschränkungen gebunden. Jeder Funktionsname ist mit Nachrichtenhandlern erlaubt. Die Funktion muss höchstens ein Argument akzeptieren, was die Nachricht sein wird, die die Funktion verarbeiten muss. filters ist eine Liste der Keyword -Argumente. Ein Filter wird auf folgende Weise deklariert: name=argument . Ein Handler kann mehrere Filter haben. Telebot unterstützt die folgenden Filter:
| Name | Argumentation (en) | Zustand |
|---|---|---|
| content_types | Liste der Zeichenfolgen (Standard ['text'] ) | True if message.content_type in der Liste der Zeichenfolgen. |
| Regexp | Ein regulärer Ausdruck als String | True if re.search(regexp_arg) gibt True und message.content_type == 'text' zurück. |
| Befehle | Liste der Saiten | True message.text message.content_type == 'text' |
| CHAT_TYPES | Liste der Chat -Typen | True if message.chat.type in Ihrem Filter |
| Func | eine Funktion (Lambda oder Funktionsreferenz) | True , wenn die Lambda oder Funktionsreferenz True zurückgibt |
Hier sind einige Beispiele für die Verwendung der Filter und Nachrichtenhandler:
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 ):
passWichtig: Alle Handler werden in der Reihenfolge getestet, in der sie deklariert wurden
Behandeln bearbeiteten Nachrichten @bot.edited_message_handler(filters) # <- passes a Message type object to your function
Handle Channel-Post-Nachrichten @bot.channel_post_handler(filters) # <- passes a Message type object to your function
Behandeln Sie bearbeitete Kanal-Post-Nachrichten @bot.edited_channel_post_handler(filters) # <- passes a Message type object to your function
Rückrufanfragen behandeln
@ bot . callback_query_handler ( func = lambda call : True )
def test_callback ( call ): # <- passes a CallbackQuery type object to your function
logger . info ( call ) Versandabfragen @bot.shipping_query_handler() # <- passes a ShippingQuery type object to your function
Behandeln Sie die Abfragen vor dem Checkoupt @bot.pre_checkout_query_handler() # <- passes a PreCheckoutQuery type object to your function
Behandeln Sie Umfrage-Updates @bot.poll_handler() # <- passes a Poll type object to your function
Verwandte Umfrage-Antworten @bot.poll_answer_handler() # <- passes a PollAnswer type object to your function
Behandeln Sie die Updates eines Status des Bots in einem Chat @bot.my_chat_member_handler() # <- passes a ChatMemberUpdated type object to your function
Behandeln Sie Updates des Status eines Chat-Mitglieds in einem Chat @bot.chat_member_handler() # <- passes a ChatMemberUpdated type object to your function Hinweis: "chat_member" -Kugane werden standardmäßig nicht angefordert. bot.infinity_polling() util.update_types alle allowed_updates zulassen möchten bot.polling() setzen
Verwandte Chat @bot.chat_join_request_handler() # <- passes ChatInviteLink type object to your function Join
Weitere Informationen zum Inline -Modus.
Jetzt können Sie Inline_handler verwenden, um Inline -Abfragen in Telebot zu erhalten.
@ bot . inline_handler ( lambda query : query . query == 'text' )
def query_text ( inline_query ):
# Query message is text Verwenden Sie Waage_Inline_handler, um in Telebot zu erhalten. Vergessen Sie nicht, den Befehl /setInlinefeedback für @BotFather hinzuzufügen.
Weitere Informationen: Sammeln von 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 ) Ein Middleware -Handler ist eine Funktion, mit der Sie Anforderungen oder den Bot -Kontext ändern können, wenn sie das Telegramm an den Bot übergeben. Sie können sich Middleware als eine Kette von Logikverbindungen vorstellen, bevor andere Handler ausgeführt werden. Die Middleware -Verarbeitung ist standardmäßig deaktiviert. Aktivieren Sie diese durch Einstellen 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'Es gibt andere Beispiele, die Middleware -Handler in den Beispielen/Middleware -Verzeichnissen verwenden.
Es gibt klassenbasierte Middlewares. Grundlegende klassenbasierte Middleware sieht so aus:
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 )Klassenbasierte Middleware sollten zwei Funktionen haben: Post und Vorprozess. Wie Sie sehen können, funktionieren die klassenbasierten Middlewares vor und nach der Ausführung von Handler. Weitere Informationen finden Sie in Beispielen
Außerdem können Sie integrierte benutzerdefinierte Filter verwenden. Oder Sie können Ihren eigenen Filter erstellen.
Beispiel für einen benutzerdefinierten Filter, wir haben Beispiele dazu. Überprüfen Sie diese Links: Sie können einige integrierte Filter im Quellcode-Beispiel für die Filterung durch ID-Beispiel für Filterung per Text überprüfen, wenn Sie einen integrierten Filter hinzufügen möchten. Hier ist Beispiel für das Erstellen der Filterklasse:
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 ))
Alle send_xyz -Funktionen von Telebot nehmen ein optionales reply_markup -Argument. Dieses Argument muss eine Instanz von ReplyKeyboardMarkup , ReplyKeyboardRemove oder ForceReply sein, die in Typen definiert sind.
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 )Das letzte Beispiel ergibt dieses Ergebnis:
# 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:
Dieses Objekt repräsentiert eine spezielle Entität in einer Textnachricht. Zum Beispiel Hashtags, Benutzernamen, URLs usw. Attribute:
typeurloffsetlengthuser Hier ist ein Beispiel: message.entities[num].<attribute>
Hier ist num die Entitätsnummer oder Reihenfolge der Entität in einer Antwort, denn wenn es für falls mehrere Entitäten in der Antwort/Nachricht enthalten.
message.entities gibt eine Liste von Entitäten Objekt zurück.
message.entities[0].type würde den Typ der ersten Entität geben
Weitere Informationen finden Sie unter Bot -API
Seit Version 5.0 der Bot -API haben Sie die Möglichkeit, Ihren eigenen lokalen Bot -API -Server auszuführen. Pytelegambotapi unterstützt auch diese Funktion.
from telebot import apihelper
apihelper . API_URL = "http://localhost:4200/bot{0}/{1}" WICHTIG: Wie hier beschrieben, müssen Sie Ihren Bot vom Telegrammserver anmelden, bevor Sie auf Ihren lokalen API -Server wechseln. In Pytelegambotapi verwenden Sie bot.log_out()
Hinweis: 4200 ist ein Beispielport
NEU: Es gibt eine asynchrone Umsetzung von Telebot. Um dieses Verhalten zu ermöglichen, erstellen Sie eine Instanz von Asynctelebot anstelle von Telebot.
tb = telebot . AsyncTeleBot ( "TOKEN" )Jetzt wird jede Funktion, die die Telegramm -API aufruft, in einer separaten asynchronen Aufgabe ausgeführt. Mit Asynctelebot können Sie Folgendes tun:
import telebot
tb = telebot . AsyncTeleBot ( "TOKEN" )
@ tb . message_handler ( commands = [ 'start' ])
async def start_message ( message ):
await bot . send_message ( message . chat . id , 'Hello!' )Weitere Beispiele finden Sie in Beispielen
Manchmal müssen Sie Nachrichten über 5000 Zeichen senden. Die Telegramm -API kann nicht so viele Zeichen in einer Anfrage verarbeiten, daher müssen wir die Nachricht in Vielfachen teilen. Hier erfahren Sie, wie Sie das mit der API tun:
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 ) Oder Sie können die neue smart_split -Funktion verwenden, um aussagekräftigere Substrings zu erhalten:
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 )Der Telebot -Konstruktor nimmt die folgenden optionalen Argumente an:
Als Alternative zu den Nachrichtenhandlern kann man auch eine Funktion als Hörer für Telebot registrieren.
Beachten Sie: Handler werden nicht verschwinden! Ihre Nachricht wird sowohl von Handlern als auch von Zuhörern verarbeitet. Außerdem ist es unmöglich vorherzusagen, welche aufgrund von Faden zuerst funktionieren wird. Wenn Sie Threaded = False verwenden, arbeiten benutzerdefinierte Hörer früher, nachdem sie Handler aufgerufen werden. Beispiel:
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 ()Wenn Sie das Webhooks -Telegramm verwenden, sendet ein Update pro Anruf, um es zu verarbeiten, wenn Sie es erhalten, wenn Sie es erhalten.
Es gibt einige Beispiele, die Webhooks im Verzeichnis von Beispielen/Webhook_Examples verwenden.
Sie können den Telebot -Modul -Logger verwenden, um Debug -Informationen zu Telebot zu protokollieren. Verwenden Sie telebot.logger , um den Logger des Telebot -Moduls zu erhalten. Es ist möglich, dem Logger benutzerdefinierte Protokollierungshandler hinzuzufügen. Weitere Informationen finden Sie auf der Seite Python Logging Modul.
import logging
logger = telebot . logger
telebot . logger . setLevel ( logging . DEBUG ) # Outputs debug messages to console.Für Synchronisation:
Sie können Proxy für Anfrage verwenden. apihelper.proxy -Objekt wird durch requests Proxies -Argument verwendet.
from telebot import apihelper
apihelper . proxy = { 'http' : 'http://127.0.0.1:3128' } Wenn Sie Socket5 -Proxy verwenden möchten, müssen Sie Abhängigkeits pip install requests[socks] installieren und sicherstellen, dass Sie die neueste Version von gunicorn , PySocks , pyTelegramBotAPI , requests und urllib3 haben.
apihelper . proxy = { 'https' : 'socks5://userproxy:password@proxy_address:port' }Für asynchronisch:
from telebot import asyncio_helper
asyncio_helper . proxy = 'http://127.0.0.1:3128' #urlSie können die Interaktion mit dem realen Telegrammserver durch Verwendung deaktivieren oder ändern
apihelper . CUSTOM_REQUEST_SENDER = your_handlerParameter. Sie können dort Ihre eigene Funktion übergeben, die anstelle von Anfragen aufgerufen wird.
Zum Beispiel:
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 resultAnschließend können Sie API verwenden und Anfragen in Ihrem Handler -Code durchführen.
apihelper . CUSTOM_REQUEST_SENDER = custom_sender
tb = TeleBot ( "test" )
res = tb . send_message ( 123 , "Test" )Ergebnis wird sein:
custom_sender. method: post, url: https://api.telegram.org/botololo/sendMessage, params: {'chat_id': '123', 'text': 'Test'}
Wir haben eine vollständig asynchrone Version von Telebot. Diese Klasse wird nicht durch Threads gesteuert. Asyncio -Aufgaben werden erstellt, um alle Dinge auszuführen.
Echo Bot Beispiel auf 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 ())Wie Sie hier sehen können, werden Schlüsselwörter warten und asynchronisiert.
Asynchrone Aufgaben hängen von der Prozessorleistung ab. Viele asynchrone Aufgaben können parallelly ausführen, während sich Fadenaufgaben gegenseitig blockieren.
Asynctelebot ist asynchron. Es verwendet AIOHTTP anstelle von Anfragenmodul.
Weitere Beispiele finden Sie in unserem Beispiel -Ordner
Telegram Bot API Unterstützung neuer Typ Chat für message.chat.
type im Chat -Objekt: 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 BOT -Instanzen, die lange Zeit im Leerlauf waren, können vom Server beim Senden einer Nachricht aufgrund einer Auszeit der letzten gebrauchten Sitzung abgelehnt werden. Fügen Sie apihelper.SESSION_TIME_TO_LIVE = 5 * 60 zu Ihrer Initialisierung hinzu, um die Erholung nach 5 Minuten ohne Aktivität zu erzwingen.
Holen Sie sich Hilfe. Diskutieren. Chat.
Treten Sie dem Nachrichtensender bei. Hier veröffentlichen wir Veröffentlichungen und Updates.
Vorlage ist ein bereiten Ordner, der Architektur des Grundprojekts enthält. Hier sind einige Beispiele für die Vorlage:
Möchten Sie Ihren Bot hier auflisten lassen? Machen Sie einfach eine Pull -Anfrage. Es werden nur Bots mit öffentlichem Quellcode akzeptiert.
