Hey zusammen, Marcus hier von ai7bot.com. Heute möchte ich über etwas reden, das in meinen persönlichen Entwicklungsprojekten in letzter Zeit viel Aufmerksamkeit erregt hat: Telegram-Bots. Genauer gesagt möchte ich erkunden, wie man seinen Telegram-Bot nicht nur als Antwortgeber, sondern als Zeitplaner macht. Vergesst die einfachen „Hello World“-Sachen; wir werden einen Bot bauen, der sich Dinge für euch merkt und Nachrichten zu bestimmten Zeiten sendet. Denkt daran als euren persönlichen, stillen digitalen Assistenten, der direkt in euren Telegram-Chats lebt.
Ich erinnere mich, dass ich vor ein paar Monaten versucht habe, eine wöchentliche D&D-Sitzung mit meiner Gruppe zu koordinieren. Wir haben ständig vergessen, wer hostet, um welche Uhrzeit wir uns verabredet hatten und welche Snacks jeder mitbringt. Wir haben es mit gemeinsamen Notizen, Kalendern, allem Möglichen versucht. Aber der gemeinsame Nenner war immer Telegram. Da hatte ich die Idee: Warum machen wir nicht einen Bot, der uns einfach erinnert? Nicht nur eine einmalige Erinnerung, sondern etwas, das regelmäßig ist, etwas, das sich anpasst. Diese kleine Frustration führte mich in ein neues Thema, und was ich fand, war überraschend einfach umzusetzen, sobald man die anfängliche Einrichtung hinter sich hat.
Über einfache Antworten hinaus: Die Kraft geplanter Nachrichten
Die meisten grundlegenden Telegram-Bots sind reaktiv. Du sendest ihnen einen Befehl, sie senden eine Antwort zurück. Das ist großartig für einfache Anfragen, aber es schöpft nicht wirklich das volle Potenzial eines Bots aus. Die wirkliche Magie passiert, wenn dein Bot proaktiv sein kann – wenn er Gespräche initiieren, Updates senden oder dich an etwas erinnern kann, ohne dass du ihn zuerst anstoßen musst. Hier kommen die geplanten Nachrichten ins Spiel.
Stell dir einen Bot vor, der:
- Dein Team fünf Minuten vor täglichen Stand-ups erinnert.
- Dir jeden Morgen um 7 Uhr eine personalisierte Wettervorhersage sendet.
- Dich über wichtige Fristen für ein Projekt informiert.
- Deine D&D-Gruppe jeden Sonntag um 15 Uhr mit einer Nachricht „Sitzung beginnt bald!“ anpingt.
Die Möglichkeiten sind endlos. Und das Beste daran? Es ist nicht so kompliziert, wie du denkst. Wir werden Python verwenden, eine beliebte Sprache für die Bot-Entwicklung, und ein paar zuverlässige Bibliotheken.
Was wir brauchen: Die Grundlagen
Bevor wir mit dem Code beginnen, lass uns unsere Werkzeuge auflisten:
- Python 3: Wenn du es noch nicht hast, besorg es dir. Es ist das Fundament unseres Bots.
python-telegram-botBibliothek: Dies ist unsere Hauptschnittstelle zur Telegram Bot API. Sie kümmert sich um die gesamte Kommunikation.APSchedulerBibliothek: Dies ist der Star der Show für die Planung. Sie ermöglicht es uns, Funktionen zu bestimmten Zeiten oder Intervallen auszuführen.
Du kannst die Python-Bibliotheken mit pip installieren:
pip install python-telegram-bot APScheduler
Und natürlich benötigst du ein Telegram-Bot-Token. Wenn du noch keinen Bot erstellt hast, gehe zu BotFather auf Telegram, sende ihm /newbot und folge den Anweisungen. Er gibt dir ein Token – bewahre es sicher auf!
Einrichten der grundlegenden Bot-Struktur
Zuerst richten wir unseren grundlegenden Telegram-Bot ein. Dieser Teil sollte dir bekannt vorkommen, wenn du schon einmal Bot-Entwicklung gemacht hast.
from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes
# Ersetze durch dein tatsächliches Bot-Token von BotFather
BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Sendet eine Willkommensnachricht, wenn der Befehl /start ausgeführt wird."""
await update.message.reply_text("Hallo! Ich bin dein Planungsbot. Verwende /help, um zu sehen, was ich kann.")
async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Sendet eine Hilfenachricht."""
await update.message.reply_text("Ich kann Nachrichten für dich planen. Probiere /schedule, um eine Erinnerung einzustellen!")
def main() -> None:
"""Startet den Bot."""
application = Application.builder().token(BOT_TOKEN).build()
application.add_handler(CommandHandler("start", start))
application.add_handler(CommandHandler("help", help_command))
print("Bot gestartet und hört zu...")
application.run_polling(allowed_updates=Update.ALL_TYPES)
if __name__ == "__main__":
main()
Führe dieses Skript aus, und wenn du /start oder /help an deinen Bot sendest, solltest du eine Antwort erhalten. Das ist unser Fundament. Jetzt bringen wir den Zeitplaner hinein.
Einführung in APScheduler: Dein Zeitwächter
APScheduler steht für „Advanced Python Scheduler.“ Es ist eine solide Bibliothek, die es dir ermöglicht, Python-Funktionen zu bestimmten Zeiten, Daten oder Intervallen auszuführen. Wir werden den BlockingScheduler verwenden, der im Haupt-Thread unserer Anwendung läuft.
Die Grundidee ist folgende: Wenn ein Benutzer unserem Bot sagt, etwas zu planen, speichern wir diese Anfrage und verwenden dann APScheduler, um einen Job hinzuzufügen. Wenn die Zeit gekommen ist, wird APScheduler eine Funktion ausführen, die die Nachricht an den Benutzer sendet.
Unsere erste Nachricht planen
Lass uns unseren Bot modifizieren, um Planungsfunktionen hinzuzufügen. Wir beginnen mit einem einfachen Befehl, /schedule, der eine Nachricht und eine Zeit (z. B. „in 5 Minuten“) entgegennimmt.
from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes
from apscheduler.schedulers.blocking import BlockingScheduler
from datetime import datetime, timedelta
import asyncio
# Ersetze durch dein tatsächliches Bot-Token
BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"
# Initialisiere den Zeitplaner
scheduler = BlockingScheduler()
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Sendet eine Willkommensnachricht."""
await update.message.reply_text("Hallo! Ich bin dein Planungsbot. Verwende /help, um zu sehen, was ich kann.")
async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Sendet eine Hilfenachricht."""
await update.message.reply_text(
"Ich kann Nachrichten für dich planen. Probiere /schedule <Minuten> <deine Nachricht>.\n"
"Beispiel: /schedule 5 Denk daran, Lebensmittel zu kaufen!"
)
async def send_scheduled_message(chat_id: int, message_text: str, application: Application) -> None:
"""Sendet die tatsächlich geplante Nachricht."""
# Wir müssen die Bot-Instanz bekommen, um Nachrichten außerhalb eines Update-Kontexts zu senden
await application.bot.send_message(chat_id=chat_id, text=message_text)
print(f"Gesendete geplante Nachricht an {chat_id}: {message_text}")
async def schedule_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Plant eine Nachricht."""
if not context.args or len(context.args) < 2:
await update.message.reply_text(
"Verwendung: /schedule <Minuten> <deine Nachricht>.\n"
"Beispiel: /schedule 5 Denk daran, Lebensmittel zu kaufen!"
)
return
try:
minutes = int(context.args[0])
if minutes <= 0:
await update.message.reply_text("Minuten müssen eine positive Zahl sein.")
return
message_to_schedule = " ".join(context.args[1:])
# Berechne die zukünftige Zeit
run_time = datetime.now() + timedelta(minutes=minutes)
# Füge den Job zum Zeitplaner hinzu
# Wir müssen die Anwendungsinstanz übergeben, damit send_scheduled_message darauf zugreifen kann
scheduler.add_job(
send_scheduled_message,
'date',
run_date=run_time,
args=[update.effective_chat.id, message_to_schedule, context.application]
)
await update.message.reply_text(
f"Okay, ich werde dich in {minutes} Minute(n) um {run_time.strftime('%H:%M:%S')} erinnern!"
)
print(f"Geplantes Job für {update.effective_chat.id} um {run_time} mit der Nachricht: {message_to_schedule}")
except ValueError:
await update.message.reply_text("Bitte gib eine gültige Zahl für Minuten an.")
except Exception as e:
await update.message.reply_text(f"Etwas ist schiefgelaufen: {e}")
def main() -> None:
"""Startet den Bot und den Zeitplaner."""
application = Application.builder().token(BOT_TOKEN).build()
application.add_handler(CommandHandler("start", start))
application.add_handler(CommandHandler("help", help_command))
application.add_handler(CommandHandler("schedule", schedule_command))
# Starte den Zeitplaner in einem separaten Thread oder Prozess, wenn du nicht blockierendes Verhalten benötigst
# Zur Vereinfachung werden wir ihn im Hauptthread mit run_polling ausführen.
# Der BlockingScheduler von APScheduler blockiert, also müssen wir ihn gleichzeitig ausführen.
# Ein gängiges Muster ist, den Zeitplaner in einem separaten Thread auszuführen.
# Lass uns den Zeitplaner auf nicht-blockierende Weise für die Produktion starten
# indem wir BackgroundScheduler verwenden oder BlockingScheduler in einem separaten Thread platzieren.
# Für dieses Beispiel werden wir die Ausführung von main leicht anpassen.
# Der BlockingScheduler von APScheduler blockiert den Hauptthread.
# Um es mit application.run_polling() von python-telegram-bot arbeiten zu lassen,
# müssen wir sicherstellen, dass der Zeitplaner läuft, ohne die Updates des Bots zu blockieren.
# Eine einfache Möglichkeit, dies zu tun, ist die Verwendung eines BackgroundSchedulers.
from apscheduler.schedulers.background import BackgroundScheduler
global scheduler # Initialisiere den Zeitplaner erneut für BackgroundScheduler
scheduler = BackgroundScheduler()
scheduler.start()
print("Bot gestartet und hört zu...")
application.run_polling(allowed_updates=Update.ALL_TYPES)
# Beende den Zeitplaner, wenn der Bot stoppt
scheduler.shutdown()
if __name__ == "__main__":
main()
Eine kurze Anmerkung zu BlockingScheduler vs. BackgroundScheduler: In meinen ersten Tests für diesen Artikel wurde mir schnell klar, dass BlockingScheduler (wie der Name schon sagt) den Hauptthread blockiert. Das bedeutet, dass dein Bot während der Ausführung des Zeitplaners keine neuen Updates von Telegram empfangen könnte. Nicht ideal! Die Lösung ist, BackgroundScheduler zu verwenden, der in einem eigenen Thread läuft und es deinem Bot ermöglicht, reaktionsfähig zu bleiben. Ich habe die main()-Funktion im obigen Snippet aktualisiert, um dies zu berücksichtigen.
Wenn du dieses aktualisierte Skript ausführst, kannst du deinem Bot etwas wie /schedule 1 Test reminder! senden und nach einer Minute sollte dir dein Bot „Test reminder!“ senden. Wie cool ist das?
Es flexibler gestalten: Wiederkehrende Jobs
Einmalige Erinnerungen sind gut, aber was ist mit wiederkehrenden Ereignissen? APScheduler macht dies mit seinen interval und cron Triggern unglaublich einfach. Lassen Sie uns einen Befehl hinzufügen, um eine Nachricht alle X Minuten zu planen.
# ... (frühere Importe und Initialisierungen) ...
async def schedule_recurring_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
"""Plant eine wiederkehrende Nachricht."""
if not context.args or len(context.args) < 2:
await update.message.reply_text(
"Benutzung: /schedule_every <minutes> <deine Nachricht>.\n"
"Beispiel: /schedule_every 60 Stündliche Überprüfung!"
)
return
try:
minutes_interval = int(context.args[0])
if minutes_interval <= 0:
await update.message.reply_text("Die Minuten müssen eine positive Zahl sein.")
return
message_to_schedule = " ".join(context.args[1:])
chat_id = update.effective_chat.id
# Füge den wiederkehrenden Job zum Scheduler hinzu
job_id = f"recurring_job_{chat_id}_{datetime.now().timestamp()}" # Eindeutige ID für eine mögliche Entfernung
scheduler.add_job(
send_scheduled_message,
'interval',
minutes=minutes_interval,
args=[chat_id, message_to_schedule, context.application],
id=job_id,
replace_existing=True # Optional: ersetzen, wenn die ID bereits existiert
)
await update.message.reply_text(
f"Okay, ich werde dich alle {minutes_interval} Minute(n) an '{message_to_schedule}' erinnern."
)
print(f"Wiederkehrenden Job '{job_id}' für {chat_id} alle {minutes_interval} Minuten geplant.")
except ValueError:
await update.message.reply_text("Bitte gib eine gültige Zahl für Minuten an.")
except Exception as e:
await update.message.reply_text(f"Es ist ein Fehler aufgetreten: {e}")
# ... (füge diesen Handler in die main() Funktion ein) ...
# application.add_handler(CommandHandler("schedule_every", schedule_recurring_command))
Denke daran, den neuen Befehls-Handler in deiner main() Funktion hinzuzufügen:
def main() -> None:
# ... bestehende Handler ...
application.add_handler(CommandHandler("schedule_every", schedule_recurring_command))
# ... Rest der main() ...
Nun kannst du deinem Bot /schedule_every 15 Vergiss nicht zu dehnen! sagen und er wird dich alle 15 Minuten daran erinnern. Hier kam die D&D-Sitzungserinnerung für mich wirklich zur Geltung. Ich konnte es einmal einstellen und es würde einfach jede Woche funktionieren.
Umgang mit Status und Persistenz (ein notwendiger nächster Schritt)
Im Moment gehen bei einem Neustart deines Bots alle geplanten Jobs verloren. Das ist nicht ideal für einen zuverlässigen Scheduler. Für einen Bot im realen Einsatz möchtest du diese geplanten Jobs in einer Datenbank (wie SQLite, PostgreSQL oder sogar einer einfachen JSON-Datei) speichern und sie beim Start des Bots wieder laden. APScheduler unterstützt integrierte Job-Speicher, die dies relativ unkompliziert machen.
Für einen Produktionsbot würde ich dringend empfehlen, einen Job-Speicher hinzuzufügen. Hier ist ein konzeptioneller Überblick, wie du ihn mit SQLite integrieren würdest:
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
# ... (rest deiner Importe und deines Codes) ...
# In deiner main() Funktion:
def main() -> None:
# ... bestehende Anwendungsanpassung ...
jobstores = {
'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite')
}
# Scheduler mit Job-Speichern neu initialisieren
global scheduler
scheduler = BackgroundScheduler(jobstores=jobstores)
scheduler.start()
# ... Rest der main() ...
Bei Verwendung eines Job-Speichers kümmert sich APScheduler um die Serialisierung und Deserialisierung von Jobs. Das bedeutet, dass selbst wenn dein Bot abstürzt oder neu startet, er alle alten Jobs genau dort wieder aufnehmen kann, wo er aufgehört hat. Dies ist entscheidend für jede ernsthafte Anwendung.
Handlungsfähige Erkenntnisse für deinen eigenen Bot
Den Bau eines Bots, der Nachrichten planen kann, eröffnet eine ganz neue Welt der Möglichkeiten. Hier ist, was ich gelernt habe und was du bedenken solltest:
- Einfach beginnen: Versuche nicht, sofort den komplexesten Scheduler zu bauen. Lass zuerst eine einfache, einmalige Erinnerung funktionieren, und füge dann wiederkehrende Jobs hinzu.
- Fehlerbehandlung ist entscheidend: Benutzer werden zwangsläufig falsche Befehle oder ungültige Zeiten eingeben. Dein Bot muss stabil genug sein, um diese Fehler elegant zu handhaben. Füge
try-exceptBlöcke hinzu! - Persistenz ist unverzichtbar: Für jeden Bot, den du erwartest, dass er länger als ein paar Minuten läuft, musst du unbedingt geplante Jobs speichern. Die Job-Speicher von
APSchedulermachen dies einfach. SQLite ist ein großartiger Ausgangspunkt für die lokale Speicherung. - Benutzerrückmeldungen: Bestätige immer dem Benutzer, dass sein Zeitplan festgelegt wurde. „Okay, ich werde dich in 5 Minuten erinnern!“ kommt gut an.
- Klare Anleitungen: Stelle gute
/helpNachrichten mit Beispielen bereit. Das hilft den Benutzern zu verstehen, wie sie mit deinem Bot interagieren können. - Zeitzonen berücksichtigen: Für einen globalen Bot können Zeitzonen ein Albtraum sein.
APSchedulerkann sie handhaben, aber es fügt Komplexität hinzu. Für einen persönlichen Bot kannst du vielleicht einfach UTC oder die lokale Zeit des Servers verwenden.
Diese Reise von einer einfachen D&D-Erinnerung zu einem fähigeren Scheduler-Bot war unglaublich belohnend. Es zeigt, dass du mit ein paar guten Bibliotheken und etwas Python deine Telegram-Bots von einfachen Antworten zu wirklich proaktiven Assistenten erheben kannst. Versuch es, experimentiere und lass mich wissen, welche coolen Planungsideen du hast!
Viel Spaß beim Bot-Bauen!
🕒 Published: