Introduction : L'Automatisation au Service de la Productivité
Dans notre monde numérique hyperconnecté, nous passons énormément de temps sur des tâches répétitives : envoyer des messages, vérifier la météo, gérer des rappels, surveiller des informations en ligne... Et si tout cela pouvait être automatisé ?
C'est exactement ce que nous allons créer dans ce tutoriel : un bot d'automatisation Python polyvalent capable de gérer toutes ces tâches pour vous, 24h/24 et 7j/7.
Ce que vous allez apprendre :
- 🤖 Créer un bot pour Telegram et Discord
- ⏰ Implémenter un système de rappels intelligent
- 🌐 Récupérer des données en temps réel (météo, news, crypto)
- 📊 Générer des rapports automatiques
- 🔄 Automatiser des workflows complexes
- 🧠 Intégrer de l'intelligence artificielle (bonus)
Niveau requis : Intermédiaire en Python (connaissances de base en programmation orientée objet)
Temps estimé : 2-3 heures pour la version complète
🎯 Présentation du Projet
Ce projet consiste à créer un bot multi-plateforme capable d'automatiser une grande variété de tâches quotidiennes. Le bot agit comme votre assistant personnel numérique, toujours disponible et prêt à exécuter vos commandes.
Architecture du système
┌─────────────────────────────────────────────┐
│ BOT D'AUTOMATISATION PYTHON │
├─────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ Telegram │ │ Discord │ │
│ │ Interface │ │ Interface │ │
│ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │
│ └────────┬─────────┘ │
│ │ │
│ ┌────────▼─────────┐ │
│ │ Core Bot Engine │ │
│ │ (Gestionnaire) │ │
│ └────────┬─────────┘ │
│ │ │
│ ┌─────────────┼─────────────┐ │
│ │ │ │ │
│ ┌──▼───┐ ┌─────▼────┐ ┌────▼────┐ │
│ │Tasks │ │ Reminders│ │ Data │ │
│ │ Mgr │ │ Mgr │ │ Fetcher │ │
│ └──────┘ └──────────┘ └─────────┘ │
│ │
└───────────────────────────────────────────┘
✨ Fonctionnalités Principales
1. 🤖 Intégration Multi-Plateformes
Le bot peut être déployé simultanément sur Telegram et Discord, vous permettant de l'utiliser depuis vos plateformes de messagerie préférées.
Commandes disponibles :
/start- Initialise le bot et affiche le menu/help- Liste toutes les commandes disponibles/status- Affiche l'état du bot et les tâches en cours/settings- Configure les préférences utilisateur
Fonctionnalités de messagerie :
- Réponses automatiques basées sur des mots-clés
- Envoi de messages programmés
- Gestion de groupes (modération, statistiques)
- Notifications push personnalisées
2. ⏰ Système de Rappels et Notifications
Un gestionnaire de rappels intelligent qui vous permet de ne jamais oublier une tâche importante.
Types de rappels :
- Rappels ponctuels - À une date/heure précise
- Rappels récurrents - Quotidiens, hebdomadaires, mensuels
- Rappels conditionnels - Basés sur des événements externes
- Rappels géolocalisés - Déclenchés par position (si activé)
Exemples d'utilisation :
/remind 15m Sortir le poulet du four
/remind 2024-03-15 18:00 Rendez-vous dentiste
/remind every monday 9:00 Réunion d'équipe
/remind when bitcoin > 50000 Vendre mes BTC
3. 🌐 Récupération de Données en Temps Réel
Le bot peut interroger diverses APIs pour vous fournir des informations actualisées.
Sources de données disponibles :
- Météo - Prévisions actuelles et sur 7 jours (OpenWeatherMap)
- Actualités - Dernières news par catégorie (NewsAPI)
- Cryptomonnaies - Prix en temps réel (CoinGecko, Binance)
- Actions boursières - Cours et tendances (Alpha Vantage)
- Taux de change - Conversion de devises
- Réseaux sociaux - Tendances Twitter/Reddit
- APIs personnalisées - Intégration facile de nouvelles sources
Commandes exemples :
/weather Paris
/news technology
/crypto bitcoin
/stock AAPL
/convert 100 USD EUR
4. 📊 Analyse de Données et Rapports
Génération automatique de rapports basés sur vos données.
Types de rapports :
- Rapport quotidien de productivité
- Résumé hebdomadaire des tâches accomplies
- Analyse des dépenses (si intégré à vos comptes)
- Statistiques d'utilisation du bot
- Graphiques de performance personnalisés
5. 🔄 Automatisation de Tâches Répétitives
Le bot peut exécuter des workflows complexes de manière autonome.
Exemples de workflows :
- Backup automatique de fichiers à intervalles réguliers
- Surveillance de sites web avec alertes de changement
- Envoi de rapports hebdomadaires par email
- Synchronisation de données entre services
- Scraping de données et compilation en base
🛠️ Technologies Utilisées
Le bot est développé entièrement en Python 3.10+ avec un écosystème de bibliothèques puissantes.
Bibliothèques principales
| Bibliothèque | Version | Usage |
|---|---|---|
| python-telegram-bot | 20.7+ | Interface Telegram |
| discord.py | 2.3+ | Interface Discord |
| requests | 2.31+ | Requêtes HTTP |
| schedule | 1.2+ | Tâches planifiées |
| python-dotenv | 1.0+ | Gestion configuration |
| SQLAlchemy | 2.0+ | Base de données |
| APScheduler | 3.10+ | Planification avancée |
Bibliothèques optionnelles (fonctionnalités avancées)
- pandas - Analyse de données
- matplotlib - Génération de graphiques
- beautifulsoup4 - Web scraping
- openai - Intégration ChatGPT
- transformers - Modèles IA locaux
📦 Installation et Configuration
Prérequis
- Python 3.10 ou supérieur
- pip (gestionnaire de packages Python)
- Un compte Telegram et/ou Discord
- Tokens d'API (Telegram Bot, Discord Bot, OpenWeatherMap, etc.)
Étape 1 : Créer les bots
Bot Telegram :
- Ouvrir Telegram et chercher
@BotFather - Envoyer
/newbot - Suivre les instructions et noter le token
Bot Discord :
- Aller sur Discord Developer Portal
- Créer une nouvelle application
- Onglet "Bot" → Créer un bot
- Copier le token
- Activer les "Privileged Gateway Intents"
Étape 2 : Installation des dépendances
# Cloner le projet (ou créer un nouveau dossier)
mkdir automation-bot && cd automation-bot
# Créer un environnement virtuel
python -m venv venv
# Activer l'environnement
# Windows:
venv\Scripts\activate
# Linux/Mac:
source venv/bin/activate
# Installer les dépendances
pip install python-telegram-bot discord.py requests schedule python-dotenv sqlalchemy apscheduler
Étape 3 : Configuration
Créer un fichier .env à la racine du projet :
# .env
TELEGRAM_BOT_TOKEN=votre_token_telegram
DISCORD_BOT_TOKEN=votre_token_discord
# APIs externes
OPENWEATHER_API_KEY=votre_clé_openweather
NEWS_API_KEY=votre_clé_newsapi
COINGECKO_API_KEY=optionnel
# Configuration
BOT_LANGUAGE=fr
TIMEZONE=Europe/Paris
DATABASE_URL=sqlite:///bot_data.db
# Fonctionnalités optionnelles
ENABLE_AI=false
OPENAI_API_KEY=votre_clé_openai
💻 Code Source du Bot
Structure du projet
automation-bot/
├── main.py # Point d'entrée principal
├── config.py # Configuration et variables d'environnement
├── requirements.txt # Dépendances
├── .env # Variables d'environnement (secrets)
├── .gitignore
│
├── bots/
│ ├── __init__.py
│ ├── telegram_bot.py # Bot Telegram
│ ├── discord_bot.py # Bot Discord
│ └── base_bot.py # Classe de base
│
├── handlers/
│ ├── __init__.py
│ ├── commands.py # Gestionnaire de commandes
│ ├── messages.py # Gestionnaire de messages
│ └── callbacks.py # Gestionnaire de callbacks
│
├── services/
│ ├── __init__.py
│ ├── reminder.py # Service de rappels
│ ├── weather.py # Service météo
│ ├── news.py # Service actualités
│ ├── crypto.py # Service crypto
│ └── scheduler.py # Planificateur de tâches
│
├── database/
│ ├── __init__.py
│ ├── models.py # Modèles de données
│ └── database.py # Gestionnaire BDD
│
└── utils/
├── __init__.py
├── logger.py # Système de logs
└── helpers.py # Fonctions utilitaires
1. Configuration (config.py)
import os
from dotenv import load_dotenv
load_dotenv()
class Config:
"""Configuration du bot"""
# Tokens
TELEGRAM_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
DISCORD_TOKEN = os.getenv('DISCORD_BOT_TOKEN')
# APIs externes
OPENWEATHER_KEY = os.getenv('OPENWEATHER_API_KEY')
NEWS_API_KEY = os.getenv('NEWS_API_KEY')
# Base de données
DATABASE_URL = os.getenv('DATABASE_URL', 'sqlite:///bot_data.db')
# Paramètres généraux
LANGUAGE = os.getenv('BOT_LANGUAGE', 'fr')
TIMEZONE = os.getenv('TIMEZONE', 'Europe/Paris')
# Fonctionnalités
ENABLE_AI = os.getenv('ENABLE_AI', 'false').lower() == 'true'
OPENAI_KEY = os.getenv('OPENAI_API_KEY')
@classmethod
def validate(cls):
"""Valide que toutes les configs nécessaires sont présentes"""
required = ['TELEGRAM_TOKEN', 'DISCORD_TOKEN']
missing = [key for key in required if not getattr(cls, key)]
if missing:
raise ValueError(f"Variables manquantes: {', '.join(missing)}")
2. Bot Telegram (bots/telegram_bot.py)
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
from config import Config
import logging
logger = logging.getLogger(__name__)
class TelegramBot:
"""Bot Telegram principal"""
def __init__(self, token: str):
self.token = token
self.app = Application.builder().token(token).build()
self._register_handlers()
def _register_handlers(self):
"""Enregistre tous les handlers de commandes"""
# Commandes de base
self.app.add_handler(CommandHandler("start", self.start_command))
self.app.add_handler(CommandHandler("help", self.help_command))
self.app.add_handler(CommandHandler("status", self.status_command))
# Commandes fonctionnelles
self.app.add_handler(CommandHandler("weather", self.weather_command))
self.app.add_handler(CommandHandler("news", self.news_command))
self.app.add_handler(CommandHandler("remind", self.remind_command))
self.app.add_handler(CommandHandler("crypto", self.crypto_command))
# Messages texte
self.app.add_handler(MessageHandler(
filters.TEXT & ~filters.COMMAND,
self.handle_message
))
async def start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Commande /start"""
user = update.effective_user
welcome_msg = f"""
🤖 Bonjour {user.first_name}!
Je suis votre assistant d'automatisation personnel.
📋 Commandes disponibles:
/help - Liste complète des commandes
/weather [ville] - Météo actuelle
/news [catégorie] - Dernières actualités
/remind [délai] [message] - Créer un rappel
/crypto [coin] - Prix des cryptos
/status - État du bot
Que puis-je faire pour vous?
"""
await update.message.reply_text(welcome_msg)
async def help_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Commande /help"""
help_text = """
📚 GUIDE DES COMMANDES
🌤️ MÉTÉO:
/weather Paris - Météo à Paris
/weather forecast Paris - Prévisions 7 jours
📰 ACTUALITÉS:
/news - Top actualités
/news tech - News technologie
/news sports - News sports
⏰ RAPPELS:
/remind 30m Sortir le gâteau
/remind 2024-03-15 10:00 RDV dentiste
/remind every monday 9:00 Réunion
💰 CRYPTO:
/crypto bitcoin - Prix BTC
/crypto btc eth ada - Plusieurs cryptos
⚙️ AUTRES:
/status - État du bot
/settings - Paramètres
"""
await update.message.reply_text(help_text)
async def status_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Commande /status"""
# Récupérer stats du bot
status_msg = """
✅ Bot Status: Opérationnel
📊 Statistiques:
- Utilisateurs actifs: 42
- Rappels actifs: 15
- Tâches en cours: 3
- Uptime: 2j 14h
💾 Système:
- CPU: 12%
- RAM: 245 MB
- Dernière mise à jour: 2024-02-01
"""
await update.message.reply_text(status_msg)
async def weather_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Commande /weather"""
from services.weather import WeatherService
if not context.args:
await update.message.reply_text("Usage: /weather [ville]")
return
city = ' '.join(context.args)
weather_service = WeatherService()
try:
weather_data = await weather_service.get_weather(city)
msg = f"""
🌤️ Météo à {weather_data['city']}
🌡️ Température: {weather_data['temp']}°C
💨 Vent: {weather_data['wind']} km/h
💧 Humidité: {weather_data['humidity']}%
☁️ Conditions: {weather_data['description']}
Mise à jour: {weather_data['timestamp']}
"""
await update.message.reply_text(msg)
except Exception as e:
await update.message.reply_text(f"❌ Erreur: {str(e)}")
async def remind_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Commande /remind"""
from services.reminder import ReminderService
if not context.args:
await update.message.reply_text(
"Usage: /remind [délai] [message]\n"
"Exemples:\n"
"/remind 30m Sortir le gâteau\n"
"/remind 2h Appeler maman\n"
"/remind tomorrow 10:00 Réunion"
)
return
reminder_service = ReminderService()
user_id = update.effective_user.id
try:
# Parser la commande
time_arg = context.args[0]
message = ' '.join(context.args[1:])
reminder = await reminder_service.create_reminder(
user_id=user_id,
time=time_arg,
message=message
)
await update.message.reply_text(
f"✅ Rappel créé!\n"
f"⏰ {reminder['formatted_time']}\n"
f"📝 {message}"
)
except Exception as e:
await update.message.reply_text(f"❌ Erreur: {str(e)}")
async def crypto_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Commande /crypto"""
from services.crypto import CryptoService
if not context.args:
await update.message.reply_text("Usage: /crypto [coin]")
return
coins = context.args
crypto_service = CryptoService()
try:
prices = await crypto_service.get_prices(coins)
msg = "💰 Prix des Cryptomonnaies\n\n"
for coin, data in prices.items():
msg += f"{data['symbol'].upper()}: ${data['price']}\n"
msg += f" 📊 24h: {data['change_24h']}%\n\n"
await update.message.reply_text(msg)
except Exception as e:
await update.message.reply_text(f"❌ Erreur: {str(e)}")
async def news_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Commande /news"""
from services.news import NewsService
category = context.args[0] if context.args else 'general'
news_service = NewsService()
try:
articles = await news_service.get_news(category, limit=5)
msg = f"📰 Actualités - {category.capitalize()}\n\n"
for i, article in enumerate(articles, 1):
msg += f"{i}. {article['title']}\n"
msg += f" 🔗 {article['url']}\n\n"
await update.message.reply_text(msg)
except Exception as e:
await update.message.reply_text(f"❌ Erreur: {str(e)}")
async def handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
"""Gère les messages texte normaux"""
text = update.message.text.lower()
# Réponses automatiques basiques
if 'bonjour' in text or 'salut' in text:
await update.message.reply_text("Bonjour! Comment puis-je vous aider?")
elif 'merci' in text:
await update.message.reply_text("De rien! 😊")
elif '?' in text:
await update.message.reply_text(
"Je peux vous aider! Utilisez /help pour voir mes commandes."
)
def run(self):
"""Démarre le bot"""
logger.info("Démarrage du bot Telegram...")
self.app.run_polling(allowed_updates=Update.ALL_TYPES)
3. Service de Rappels (services/reminder.py)
from datetime import datetime, timedelta
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from database.models import Reminder
import re
class ReminderService:
"""Service de gestion des rappels"""
def __init__(self):
self.scheduler = AsyncIOScheduler()
self.scheduler.start()
async def create_reminder(self, user_id: int, time: str, message: str):
"""Crée un nouveau rappel"""
# Parser le temps
target_time = self._parse_time(time)
# Enregistrer en base de données
reminder = Reminder(
user_id=user_id,
message=message,
trigger_time=target_time,
created_at=datetime.now()
)
reminder.save()
# Planifier l'exécution
self.scheduler.add_job(
self._send_reminder,
'date',
run_date=target_time,
args=[user_id, message, reminder.id]
)
return {
'id': reminder.id,
'formatted_time': target_time.strftime('%Y-%m-%d %H:%M'),
'message': message
}
def _parse_time(self, time_str: str) -> datetime:
"""Parse différents formats de temps"""
now = datetime.now()
# Format: 30m, 2h, 1d
if re.match(r'^\d+[mhd]$', time_str):
value = int(time_str[:-1])
unit = time_str[-1]
if unit == 'm':
return now + timedelta(minutes=value)
elif unit == 'h':
return now + timedelta(hours=value)
elif unit == 'd':
return now + timedelta(days=value)
# Format: tomorrow, today
if time_str.lower() == 'tomorrow':
return now + timedelta(days=1)
elif time_str.lower() == 'today':
return now
# Format: YYYY-MM-DD HH:MM
try:
return datetime.strptime(time_str, '%Y-%m-%d %H:%M')
except ValueError:
pass
raise ValueError(f"Format de temps non reconnu: {time_str}")
async def _send_reminder(self, user_id: int, message: str, reminder_id: int):
"""Envoie le rappel à l'utilisateur"""
# Ici, envoyer via Telegram/Discord
from bots.telegram_bot import send_message
await send_message(
user_id,
f"⏰ RAPPEL!\n\n{message}"
)
# Marquer comme envoyé en base
reminder = Reminder.get_by_id(reminder_id)
reminder.status = 'sent'
reminder.save()
4. Service Météo (services/weather.py)
import requests
from config import Config
from datetime import datetime
class WeatherService:
"""Service de récupération de données météo"""
def __init__(self):
self.api_key = Config.OPENWEATHER_KEY
self.base_url = "https://api.openweathermap.org/data/2.5"
async def get_weather(self, city: str) -> dict:
"""Récupère la météo actuelle pour une ville"""
url = f"{self.base_url}/weather"
params = {
'q': city,
'appid': self.api_key,
'units': 'metric',
'lang': 'fr'
}
try:
response = requests.get(url, params=params, timeout=10)
response.raise_for_status()
data = response.json()
return {
'city': data['name'],
'temp': round(data['main']['temp']),
'feels_like': round(data['main']['feels_like']),
'humidity': data['main']['humidity'],
'wind': round(data['wind']['speed'] * 3.6), # m/s vers km/h
'description': data['weather'][0]['description'].capitalize(),
'icon': data['weather'][0]['icon'],
'timestamp': datetime.now().strftime('%H:%M')
}
except requests.exceptions.RequestException as e:
raise Exception(f"Impossible de récupérer la météo: {str(e)}")
async def get_forecast(self, city: str, days: int = 7) -> list:
"""Récupère les prévisions sur plusieurs jours"""
url = f"{self.base_url}/forecast"
params = {
'q': city,
'appid': self.api_key,
'units': 'metric',
'lang': 'fr',
'cnt': days * 8 # 8 mesures par jour
}
try:
response = requests.get(url, params=params, timeout=10)
response.raise_for_status()
data = response.json()
forecasts = []
for item in data['list'][::8]: # Un par jour
forecasts.append({
'date': item['dt_txt'].split()[0],
'temp_min': round(item['main']['temp_min']),
'temp_max': round(item['main']['temp_max']),
'description': item['weather'][0]['description']
})
return forecasts
except requests.exceptions.RequestException as e:
raise Exception(f"Impossible de récupérer les prévisions: {str(e)}")
5. Point d'entrée principal (main.py)
import asyncio
import logging
from config import Config
from bots.telegram_bot import TelegramBot
from bots.discord_bot import DiscordBot
# Configuration du logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('bot.log'),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
async def main():
"""Point d'entrée principal"""
try:
# Valider la configuration
Config.validate()
logger.info("Configuration validée ✓")
# Initialiser les bots
telegram_bot = TelegramBot(Config.TELEGRAM_TOKEN)
discord_bot = DiscordBot(Config.DISCORD_TOKEN)
logger.info("Bots initialisés ✓")
# Démarrer les bots en parallèle
await asyncio.gather(
telegram_bot.run(),
discord_bot.run()
)
except KeyboardInterrupt:
logger.info("Arrêt du bot par l'utilisateur")
except Exception as e:
logger.error(f"Erreur fatale: {str(e)}", exc_info=True)
finally:
logger.info("Bot arrêté")
if __name__ == "__main__":
asyncio.run(main())
🚀 Démarrage du Bot
Lancer le bot :
# Activer l'environnement virtuel
source venv/bin/activate # Linux/Mac
# ou
venv\Scripts\activate # Windows
# Lancer le bot
python main.py
Sortie attendue :
2024-02-01 10:30:15 - INFO - Configuration validée ✓
2024-02-01 10:30:15 - INFO - Bots initialisés ✓
2024-02-01 10:30:16 - INFO - Démarrage du bot Telegram...
2024-02-01 10:30:16 - INFO - Démarrage du bot Discord...
2024-02-01 10:30:17 - INFO - Bot Telegram connecté! @YourBotName
2024-02-01 10:30:17 - INFO - Bot Discord connecté! Bot#1234
💡 Cas d'Usage Pratiques
1. Assistant personnel quotidien
Scénario : Automatiser votre routine matinale
# Configurer des rappels récurrents
/remind every day 07:00 Réveil! ☀️
/remind every day 07:30 Prendre petit-déjeuner
/remind every weekday 08:30 Partir au travail
# Recevoir les infos du jour
/weather [votre_ville]
/news today
/crypto btc eth
2. Suivi de portefeuille crypto
Scénario : Être alerté des variations importantes
# Configurer des alertes de prix
/alert bitcoin > 50000 BTC a dépassé 50k!
/alert ethereum < 3000 ETH sous 3000!
# Rapport quotidien
/remind every day 18:00 /crypto btc eth ada sol
3. Gestion de projet
Scénario : Suivre les deadlines et milestones
# Rappels de deadlines
/remind 2024-03-15 10:00 Deadline Projet Alpha
/remind 3d before Préparer présentation client
# Rapports hebdomadaires
/remind every friday 17:00 Générer rapport hebdo
4. Veille technologique
Scénario : Rester à jour sur les actualités tech
# Flux d'actualités automatique
/remind every day 09:00 /news technology
/remind every day 12:00 /news ai
# Suivre des sites spécifiques
/watch hackernews
/watch producthunet
🔮 Fonctionnalités Avancées (Bonus)
Intégration IA (ChatGPT)
Ajouter de l'intelligence artificielle pour des réponses plus naturelles :
from openai import OpenAI
class AIService:
def __init__(self, api_key: str):
self.client = OpenAI(api_key=api_key)
async def chat(self, user_message: str, context: list = None) -> str:
"""Génère une réponse intelligente"""
messages = context or []
messages.append({"role": "user", "content": user_message})
response = self.client.chat.completions.create(
model="gpt-4",
messages=messages,
max_tokens=500,
temperature=0.7
)
return response.choices[0].message.content
Web Scraping automatique
Surveiller des sites et être alerté des changements :
from bs4 import BeautifulSoup
import requests
class WebMonitor:
def __init__(self):
self.tracked_sites = {}
async def monitor(self, url: str, selector: str):
"""Surveille un élément spécifique d'un site"""
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
current_content = soup.select_one(selector).text.strip()
# Comparer avec version précédente
if url in self.tracked_sites:
if current_content != self.tracked_sites[url]:
# Changement détecté!
await self.send_alert(url, current_content)
self.tracked_sites[url] = current_content
Génération de rapports PDF
Créer des rapports visuels automatiques :
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
class ReportGenerator:
def generate_weekly_report(self, data: dict) -> str:
"""Génère un rapport hebdomadaire en PDF"""
filename = f"rapport_{datetime.now().strftime('%Y%m%d')}.pdf"
c = canvas.Canvas(filename, pagesize=letter)
# Titre
c.setFont("Helvetica-Bold", 24)
c.drawString(100, 750, "Rapport Hebdomadaire")
# Contenu
y = 700
for key, value in data.items():
c.setFont("Helvetica", 12)
c.drawString(100, y, f"{key}: {value}")
y -= 20
c.save()
return filename
📈 Déploiement en Production
Option 1: Hébergement local (Raspberry Pi)
Avantages :
- ✅ Contrôle total
- ✅ Pas de coûts récurrents
- ✅ Données privées
Installation sur Raspberry Pi :
# Installation Python
sudo apt update
sudo apt install python3 python3-pip python3-venv
# Cloner le projet
git clone https://github.com/your/bot.git
cd bot
# Installation et lancement
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
# Lancer en service systemd (démarrage auto)
sudo nano /etc/systemd/system/automation-bot.service
Option 2: Cloud (Heroku, Railway, Fly.io)
Fichiers nécessaires :
Procfile :
worker: python main.py
runtime.txt :
python-3.11.7
Déploiement sur Heroku :
# Installer Heroku CLI
# https://devcenter.heroku.com/articles/heroku-cli
# Login et création
heroku login
heroku create mon-automation-bot
# Configurer variables d'environnement
heroku config:set TELEGRAM_BOT_TOKEN=xxx
heroku config:set DISCORD_BOT_TOKEN=xxx
# Déployer
git push heroku main
# Activer le worker
heroku ps:scale worker=1
Option 3: VPS (DigitalOcean, Linode, Hetzner)
Script de déploiement automatique :
#!/bin/bash
# deploy.sh
echo "🚀 Déploiement du bot..."
# Mise à jour du code
git pull origin main
# Activation environnement
source venv/bin/activate
# Installation dépendances
pip install -r requirements.txt --upgrade
# Redémarrage du service
sudo systemctl restart automation-bot
echo "✅ Déploiement terminé!"
🔒 Sécurité et Bonnes Pratiques
Protection des tokens et clés API
- ✅ Jamais commit les fichiers
.env - ✅ Utiliser des variables d'environnement
- ✅ Régénérer les tokens si exposés
- ✅ Limiter les permissions des tokens
.gitignore recommandé :
# .gitignore
.env
*.db
*.log
__pycache__/
venv/
.vscode/
.idea/
*.pyc
bot_data.db
Gestion des erreurs robuste
import functools
import logging
def error_handler(func):
"""Décorateur pour gérer les erreurs"""
@functools.wraps(func)
async def wrapper(*args, **kwargs):
try:
return await func(*args, **kwargs)
except Exception as e:
logging.error(f"Erreur dans {func.__name__}: {str(e)}", exc_info=True)
# Notifier l'administrateur
await notify_admin(f"Erreur bot: {str(e)}")
return wrapper
@error_handler
async def risky_operation():
# Opération qui peut échouer
pass
Rate limiting
from functools import wraps
from time import time
class RateLimiter:
def __init__(self, max_calls: int, period: int):
self.max_calls = max_calls
self.period = period
self.calls = {}
def __call__(self, func):
@wraps(func)
async def wrapper(*args, **kwargs):
user_id = args[0] if args else kwargs.get('user_id')
now = time()
if user_id not in self.calls:
self.calls[user_id] = []
# Nettoyer les appels expirés
self.calls[user_id] = [
t for t in self.calls[user_id]
if now - t < self.period
]
if len(self.calls[user_id]) >= self.max_calls:
raise Exception("Rate limit dépassé!")
self.calls[user_id].append(now)
return await func(*args, **kwargs)
return wrapper
# Usage
@RateLimiter(max_calls=5, period=60) # 5 appels par minute
async def expensive_operation(user_id):
pass
📊 Monitoring et Logs
Système de logs structuré
import logging
import json
from datetime import datetime
class JSONFormatter(logging.Formatter):
"""Formatter JSON pour les logs"""
def format(self, record):
log_data = {
'timestamp': datetime.now().isoformat(),
'level': record.levelname,
'module': record.module,
'function': record.funcName,
'message': record.getMessage(),
}
if record.exc_info:
log_data['exception'] = self.formatException(record.exc_info)
return json.dumps(log_data)
# Configuration
handler = logging.FileHandler('bot_structured.log')
handler.setFormatter(JSONFormatter())
logger = logging.getLogger()
logger.addHandler(handler)
Dashboard de monitoring (optionnel)
from flask import Flask, render_template
import psutil
app = Flask(__name__)
@app.route('/status')
def status():
"""Endpoint de statut du bot"""
return {
'status': 'running',
'cpu_percent': psutil.cpu_percent(),
'memory_mb': psutil.virtual_memory().used / 1024 / 1024,
'active_users': get_active_users_count(),
'uptime': get_uptime()
}
# Lancer sur un port séparé
# flask run --port 5000
🎓 Ressources et Apprentissage
Documentation officielle
- python-telegram-bot - docs.python-telegram-bot.org
- discord.py - discordpy.readthedocs.io
- APScheduler - apscheduler.readthedocs.io
APIs gratuites utiles
- OpenWeatherMap - Météo (gratuit jusqu'à 1000 appels/jour)
- NewsAPI - Actualités (gratuit 100 requêtes/jour)
- CoinGecko - Crypto (gratuit illimité)
- ExchangeRate-API - Taux de change
- IP Geolocation - Géolocalisation
Communautés et support
- Reddit: r/TelegramBots, r/Discord_Bots
- Discord: Python Discord Server
- Stack Overflow: Tags python-telegram-bot, discord.py
- GitHub Discussions des projets
🚧 Évolutions Futures
Le projet est en constante évolution avec de nouvelles fonctionnalités prévues :
Court terme (1-2 mois)
- 🎤 Commandes vocales - Reconnaissance vocale Telegram
- 📸 Traitement d'images - OCR, reconnaissance visuelle
- 🌍 Traduction automatique - Support multilingue
- 📱 Application mobile - Interface dédiée
Moyen terme (3-6 mois)
- 🧠 IA conversationnelle - Intégration GPT-4 native
- 📊 Analytics avancés - Dashboard complet
- 🔗 Intégrations tierces - Notion, Trello, Google Calendar
- 🎮 Mini-jeux - Fonctionnalités ludiques
Long terme (6-12 mois)
- 🤖 Marketplace de plugins - Système de modules communautaires
- ☁️ Version SaaS - Bot-as-a-Service hébergé
- 🔐 Chiffrement E2E - Sécurité renforcée
- 🌐 Support multi-plateformes - WhatsApp, Signal, Matrix
📝 Conclusion
Vous venez de créer un bot d'automatisation Python complet et polyvalent capable de gérer de nombreuses tâches quotidiennes. Ce projet est non seulement fonctionnel mais également extensible et évolutif.
Ce que vous avez appris :
- ✅ Création de bots Telegram et Discord
- ✅ Gestion de tâches asynchrones et planifiées
- ✅ Intégration d'APIs externes
- ✅ Architecture modulaire et maintenable
- ✅ Bonnes pratiques de développement
- ✅ Déploiement en production
Prochaines étapes suggérées :
- Personnaliser le bot selon vos besoins spécifiques
- Ajouter de nouvelles intégrations API
- Implémenter des fonctionnalités IA avancées
- Partager votre bot avec la communauté
- Contribuer aux projets open-source utilisés
L'automatisation est un domaine en constante évolution. N'hésitez pas à expérimenter, à ajouter vos propres fonctionnalités et à partager vos créations avec la communauté!
Code source complet disponible : Le projet entier avec tous les fichiers, la documentation détaillée et des exemples supplémentaires est disponible sur GitHub (lien dans les commentaires).
Article rédigé par Matteo - Développeur Python passionné d'automatisation et de bots. Retrouvez plus de tutoriels pratiques sur mat-univer.tech.
Dernière mise à jour : Février 2026
💬 Questions? N'hésitez pas à commenter ci-dessous! Je réponds à toutes les questions techniques.